All perguntas(coding)

Por que esse código leva a um java.lang.IllegalThreadStateException?

newSingleThreadScheduledExecutor(Thread::startVirtualThread).scheduleWithFixedDelay(
   () -> System.out.println("Hello, World!"),
   0,
   1,
   TimeUnit.SECONDS
);

O JavaDoc java.util.concurrent.ThreadFactoryafirma explicitamente:

Um objeto que cria novos threads sob demanda.

... e Thread::startVirtualThreadé um Function<Runnable, Thread>(objeto) que deveria fazer isso. Certo?

Imagino que a maneira pretendida seja provavelmente Thread.ofVirtual().factory(), mas ainda não tenho a mínima ideia do porquê a outra função não funciona.

Este post fala sobre um método que conta o número de membros de uma classe:

struct UniversalType { template<typename T> operator T();  };

template<typename T, typename... A0>
consteval auto MemberCounter(auto ...c0) 
{
    if constexpr (requires { T{ {A0{}}..., {UniversalType{}}, c0... }; } == false
               && requires { T{ {A0{}}..., c0..., UniversalType{}   }; } == false )
   {
        return sizeof...(A0) + sizeof...(c0);
    }
    else if constexpr (requires { T{ {A0{}}..., {UniversalType{}}, c0... }; })
    {
        return MemberCounter<T,A0...,UniversalType>(c0...);
    }
    else
    {
        return MemberCounter<T,A0...>(c0...,UniversalType{});
    }
}

using TestType = struct { int x[3]; float y; char z; };
static_assert (MemberCounter<TestType>() == 3);

int main() {}

Em particular, as duas requirescláusulas a seguir me intrigam um pouco, pois misturam chaves simples e duplas:

1. requires { T{ {A0{}}..., {UniversalType{}}, c0... }; }
2. requires { T{ {A0{}}..., c0..., UniversalType{} }; }

Pergunta: que tipo de itens eles permitem combinar exatamente?

Suponha que você tenha um vetor numérico xe um data frame dfcom colunas starte stop. Existe uma maneira inteligente de retornar um vetor lógico com comprimento igual a xindicando se x está em pelo menos um intervalo definido por startou stop?

O caso real com o qual estou trabalhando tem length(x)>> nrow(df). A maneira ingênua de fazer isso seria usar um loop for, mas eu esperava algo mais elegante e que rodasse rápido.

 x <- 1:10
df <- data.frame(start = c(0, 4.5, 6), stop = c(1, 5.5, 8.5))
z <- rep(FALSE, length(x))

for(i in 1:nrow(df)){
  z <- z | (df$start[i] <= x & x <= df$stop[i])
}

x[z] # 1 5 6 7 8

A seguinte função não-template (ou seria?) retornando um lambda não genérico e com estado,

auto foo(double a) {
    return [a](double b) -> double {
        return a + b;
    };
}

compilado para isso com GCC ou Clang . Por quê?

foo(double):
        ret

Eu esperaria que não gerasse nenhuma saída .

A origem da questão

Nem me lembro por que comecei a escrever o trecho acima, mas enfim...

Inicialmente pensei que deveria ter sido compilado para algo um pouco maior, pois esperava ver addpelo menos uma instrução.

Mas então percebi que o fooacima não pode ser compilado sozinho, em um cpp, e então vinculado a outra TU onde é usado, porque não consigo nem escrever uma declaração - somente para ele!

Então chego ao ponto em que a única razão para escrever essa função em um arquivo sem cabeçalho é que ela é usada nesse arquivo sem cabeçalho, e nesse ponto o compilador pode presumivelmente incorporá-la onde quer que ela seja usada.

Mas se esse é o caso... então por que copilar foopara baixo para qualquer coisa , se é a única coisa na TU? Não há nada para vincular, então por que qualquer saída é gerada para isso?

Usar um struct+ operator()não muda nada, pois isso

struct Bar {
    double a;
    double operator()(double b) const {
        return a + b;
    }
};

Bar bar(double a) {
    return Bar{a};
}

gera o mesmo retcódigo -only, o que também é óbvio em retrospecto, pois não há como vincular essa barfunção a outras TUs, se Barestiver oculta no arquivo cpp.

Eu tenho um dataframe:

mydf <- data.frame(
  col1 = c("54", "abc", "123", "54 abc", "zzz", "a", "99"),
  col2 = c("100", "200", "300", "400", "500", "600", "700"),
  stringsAsFactors = FALSE
)

Neste dataframe, quero substituir todos os elementos por NA, a menos que atendam a uma destas condições:

• estritamente um número (por exemplo, "54" manter, "54 abc" descartar)
• pertencem a target_string

Eu não tinha certeza de como fazer isso em R usando apply, então tentei escrever um loop:

target_string <- c("a", "zzz")

replace_with_na_old <- function(df, target_string) {
  for (i in 1:nrow(df)) {
    for (j in 1:ncol(df)) {
      value <- df[i, j]
      if (!grepl("^[0-9]+$", value) && !(value %in% target_string)) {
        df[i, j] <- NA
      }
    }
  }
  return(df)
}

mydf_cleaned_old <- replace_with_na_old(mydf, target_string)

Existe outra maneira de fazer isso?

Nota: Veja como substituir %in% por %like%:

   replace_with_na_new <- function(df, target_string) {
  for (i in 1:nrow(df)) {
    for (j in 1:ncol(df)) {
      value <- df[i, j]
      if (!grepl("^[0-9]+$", value) && !any(sapply(target_string, function(pattern) grepl(pattern, value)))) {
        df[i, j] <- NA
      }
    }
  }
  return(df)
}

Estou tentando entender por que há uma diferença quando mudo de y.addAll(x) para x.addAll(y) no trecho de código abaixo:

List<Integer> result = List.of(1, 2)
    .parallelStream() 
    .collect(
        ArrayList::new,
        (x, y) -> x.add(y),
        (x, y) -> y.addAll(x)
    );
System.out.println(result);

Eu sei que quando uso paraleloStream(), há mais de um thread sendo executado por vez.

collect() possui três parâmetros; os dois primeiros parâmetros eu entendo. Com o terceiro parâmetro, sei que x, y são substreams e são ArrayLists, mas não entendo por que os resultados são diferentes em cada caso. Eu esperava que eles fossem iguais.

• (x, y) -> y.addAll(x) // saída: [1]

• (x, y) -> x.addAll(y) // saída: [1, 2]

Suponha que eu tenha esse dataframe

import polars as pl

df = pl.DataFrame({
    'item':         ['CASH', 'CHECK', 'DEBT', 'CHECK', 'CREDIT', 'CASH'],
    'quantity':     [100, -20, 0, 10, 0, 0],
    'value':        [99, 47, None, 90, None, 120],
    'value_other':  [97, 57, None, 91, None, 110],
    'value_other2': [94, 37, None, 93, None, 115],
})

┌────────┬──────────┬───────┬─────────────┬──────────────┐
│ item   ┆ quantity ┆ value ┆ value_other ┆ value_other2 │
│ ---    ┆ ---      ┆ ---   ┆ ---         ┆ ---          │
│ str    ┆ i64      ┆ i64   ┆ i64         ┆ i64          │
╞════════╪══════════╪═══════╪═════════════╪══════════════╡
│ CASH   ┆ 100      ┆ 99    ┆ 97          ┆ 94           │
│ CHECK  ┆ -20      ┆ 47    ┆ 57          ┆ 37           │
│ DEBT   ┆ 0        ┆ null  ┆ null        ┆ null         │
│ CHECK  ┆ 10       ┆ 90    ┆ 91          ┆ 93           │
│ CREDIT ┆ 0        ┆ null  ┆ null        ┆ null         │
│ CASH   ┆ 0        ┆ 120   ┆ 110         ┆ 115          │
└────────┴──────────┴───────┴─────────────┴──────────────┘

Agora quero definir todas as colunas de valor 0para todas as linhas onde value is nulle quantity == 0.

No momento eu tenho essa solução

cols = ['value', 'value_other', 'value_other2']
df   = df.with_columns([
    pl.when(pl.col('value').is_null() & (pl.col('quantity') == 0))
    .then(0)
    .otherwise(pl.col(col))
    .alias(col)
    for col in cols
])

que dá corretamente

┌────────┬──────────┬───────┬─────────────┬──────────────┐
│ item   ┆ quantity ┆ value ┆ value_other ┆ value_other2 │
│ ---    ┆ ---      ┆ ---   ┆ ---         ┆ ---          │
│ str    ┆ i64      ┆ i64   ┆ i64         ┆ i64          │
╞════════╪══════════╪═══════╪═════════════╪══════════════╡
│ CASH   ┆ 100      ┆ 99    ┆ 97          ┆ 94           │
│ CHECK  ┆ -20      ┆ 47    ┆ 57          ┆ 37           │
│ DEBT   ┆ 0        ┆ 0     ┆ 0           ┆ 0            │
│ CHECK  ┆ 10       ┆ 90    ┆ 91          ┆ 93           │
│ CREDIT ┆ 0        ┆ 0     ┆ 0           ┆ 0            │
│ CASH   ┆ 0        ┆ 120   ┆ 110         ┆ 115          │
└────────┴──────────┴───────┴─────────────┴──────────────┘

No entanto, sinto que isso é muito ineficiente, pois minha whencondição é executada para cada coluna de valor. Existe uma maneira de conseguir isso usando apenas funções internas polares e sem o loop for nativo?

O programa C a seguir tem garantia de saída 0ou o compilador tem permissão para identificar os objetos se tuns com os outros, conforme permitido em C++, como a chamada forma de elisão de cópia de otimização de valor de retorno nomeado (NRVO)?

typedef struct {
    int i, j;
    double a, b;
} S;

int result;

S test(S* q) {
    S s = {0, 0, 0, 0};
    result = &s == q;
    return s;
}

int main(void)
{
  S t = test(&t);
  return result;
}

Clang sai 1contra minhas expectativas, consulte https://godbolt.org/z/ME8sPGn3n .

(Em C++, ambos 0e 1são resultados válidos devido à permissão explícita para executar NRVO.)

Quero saber se existem algumas opções para configurar o arquivo MSI sem poder de administrador. Quando abro o arquivo msi em um usuário não administrador, ele sempre precisa de poder de administrador. Como posso configurá-lo para abrir o arquivo msi sem o poder do administrador?

Com base na minha pesquisa, descobri que a área de trabalho remota tem esse comportamento, mas não consegui encontrar as configurações nos projetos do instalador do Microsoft Visual Studio.

Quero usar o instalador MSI para usuários não administradores.

Considere o seguinte tipo:

template<typename T> struct View
{
    T*     data;
    size_t size;
};

É válido transmitir de: View<T>&To View<const T>&?

Invoca comportamento indefinido?

Suspeito que o elenco funcionará conforme planejado em todos os compiladores, mas terá um comportamento tecnicamente indefinido de acordo com o padrão devido à regra estrita de alias .