All perguntas(coding)

Eu esperaria que isso só acontecesse quando o último bit da mantissa fosse 0. Caso contrário, para subtraí-los (já que seus expoentes diferem em 1), xperderia um pouco de precisão primeiro e o resultado acabaria sendo arredondado para cima ou para baixo.

Mas um experimento rápido mostra que isso parece sempre valer (assumindo que xe 2xsão finitos) para qualquer número aleatório (incluindo aqueles com um 1bit à direita).

import random
import struct
from collections import Counter


def float_to_bits(f: float) -> int:
    """
    Convert a double-precision floating-point number to a 64-bit integer.
    """
    # Pack the float into 8 bytes, then unpack as an unsigned 64-bit integer
    return struct.unpack(">Q", struct.pack(">d", f))[0]


def check_floating_point_precision(num_trials: int) -> float:
    true_count = 0
    false_count = 0
    bit_counts = Counter()

    for _ in range(num_trials):
        x = random.uniform(0, 1)
        if 2 * x - x == x:
            true_count += 1
        else:
            false_count += 1

        bits = float_to_bits(x)

        # Extract the last three bits of the mantissa
        last_three_bits = bits & 0b111
        bit_counts[last_three_bits] += 1

    return (bit_counts, true_count / num_trials)


num_trials = 1_000_000
(bit_counts, proportion_true) = check_floating_point_precision(num_trials)

print(f"The proportion of times 2x - x == x holds true: {proportion_true:.6f}")
print("Distribution of last three bits (mod 8):")
for bits_value in range(8):
    print(f"{bits_value:03b}: {bit_counts[bits_value]} occurrences")

The proportion of times 2x - x == x holds true: 1.000000
Distribution of last three bits (mod 8):
000: 312738 occurrences
001: 62542 occurrences
010: 125035 occurrences
011: 62219 occurrences
100: 187848 occurrences
101: 62054 occurrences
110: 125129 occurrences
111: 62435 occurrences

Tenho um conjunto de dados do qual estou tentando remover entradas duplicadas. O lazyframe com o qual estou trabalhando é estruturado assim:

df = pl.from_repr("""
┌──────┬────────────┬──────────────────┬───────┐
│ id   ┆ title      ┆ type             ┆ type2 │
│ ---  ┆ ---        ┆ ---              ┆ ---   │
│ i64  ┆ str        ┆ str              ┆ i64   │
╞══════╪════════════╪══════════════════╪═══════╡
│ 1001 ┆ Research A ┆ journal article  ┆ 35    │
│ 1002 ┆ Research B ┆ book chapter     ┆ 41    │
│ 1003 ┆ Research C ┆ journal article  ┆ 35    │
│ 1004 ┆ Research D ┆ conference paper ┆ 42    │
│ 1001 ┆ Research E ┆ journal article  ┆ 35    │
│ 1002 ┆ Research F ┆ journal article  ┆ 41    │
│ 1003 ┆ Research G ┆                  ┆ 41    │
│ 1002 ┆ Research I ┆ book chapter     ┆ 41    │
│ 1003 ┆ Research J ┆ journal article  ┆ 35    │
└──────┴────────────┴──────────────────┴───────┘
""")

Quero remover entradas que tenham o mesmo id, mas na verdade existem casos diferentes:

1. As duplicatas têm o mesmo type(por exemplo, 1001): mantenha a primeira.
2. As duplicatas têm uma diferença type: descarta aquelas com uma string vazia ("") como tipo e, em seguida, mantém apenas as entradas que respeitam os seguintes pares de typee type2:

dict_df = pl.DataFrame({
    "type": ['journal article', 'book chapter', 'book chapter'],
    "type2": [35, 41, 42]
})

Saída esperada

• 1001: mesmo tipo, mantenha o primeiro
• 1002: tipo diferente, mantenha a primeira ocorrência das entradas com o par {'book chapter': 41}
• 1003: tipo diferente, descarte as entradas com um tipo vazio e mantenha a primeira ocorrência
• 1004: não é uma duplicata

Tentei muitas coisas, principalmente usando a expressão pl.when(), mas não consigo descobrir uma maneira de filtrar os grupos.

(
    df
    .sort('type', descending=True)
    .group_by("id")
    .agg([
        pl.when(pl.col("type").n_unique() > 1)
        .then( ... )
        .otherwise(pl.all().first())
    ])
)

Tenho uma tabela confusa que leio em um quadro de dados semelhante ao seguinte simplificado, que desejo analisar.

mydf <- data.frame(group=LETTERS[1:5], code=101:105, ids=c('g1:id1,id2,id3\ng2:id4,id5',
                                                           'id6,id7,id8,id9',
                                                           'g1:id10,id11\ng3:id12',
                                                           'g2:id13,id14',
                                                           'id15'))

Parece que:

> mydf
  group code                        ids
1     A  101 g1:id1,id2,id3\ng2:id4,id5
2     B  102            id6,id7,id8,id9
3     C  103      g1:id10,id11\ng3:id12
4     D  104               g2:id13,id14
5     E  105                       id15

Preciso separar a idscoluna recolhida em várias linhas para obter um quadro de dados final em formato longo.

Para isso, eu normalmente aplicaria separate_rowsfrom tidyr, mas esse caso tem um problema adicional: alguns dos recolhidos idsestão agrupados em subgrupos.

Acho que devo primeiro separar esses subgrupos em colunas de ids diferentes e depois aplicar separate_rowsou separate_longer_delimnessas colunas... Não sei como fazer isso.

O quadro de dados final que espero seria assim, em formato longo, com as subgroupinformações em uma coluna adicional:

> mydf_new
   group code   id subgroup
1      A  101  id1       g1
2      A  101  id2       g1
3      A  101  id3       g1
4      A  101  id4       g2
5      A  101  id5       g2
6      B  102  id6     <NA>
7      B  102  id7     <NA>
8      B  102  id8     <NA>
9      B  102  id9     <NA>
10     C  103 id10       g1
11     C  103 id11       g1
12     C  103 id12       g3
13     D  104 id13       g2
14     D  104 id14       g2
15     E  105 id15     <NA>

Como posso incluir uma função decorada dentro de um doctest Python?

def decorator(func):
    def wrapper() -> None:
        func()

    return wrapper

def foo() -> None:
    """
    Stub.

    Examples:
        >>> @decorator
        >>> def stub(): ...
    """

if __name__ == "__main__":
    import doctest
    doctest.testmod()

Executar o comando acima com Python 3.12 gera SyntaxError:

UNEXPECTED EXCEPTION: SyntaxError('invalid syntax', ('<doctest path.to.a[0]>', 1, 0, '@decorator\n', 1, 0))

Operadores de comparação para uma classe em C++23 podem ter parâmetros de objeto explícitos de um tipo distinto do tipo de classe?

Considere por exemplo

struct A {
    int i;
    constexpr bool operator==(this int x, int y) { return x == y; }
    constexpr operator int() const { return i; }
};

Agora a comparação para desigualdade

static_assert( A{0} != A{1} );

é aceito pelo GCC e Clang, mas o MSVC reclama:

error C2803: 'operator ==' must have at least one formal parameter of class type
error C2333: 'A::operator ==': error in function declaration; skipping function body

E a comparação para igualdade

static_assert( A{2} == A{2} );

é aceito apenas pelo GCC, enquanto o Clang já não gosta dele:

error: use of overloaded operator '==' is ambiguous (with operand types 'A' and 'A')
   11 | static_assert( A{2} == A{2} );
note: candidate function
    3 |     constexpr bool operator==(this int x, int y) { return x == y; }
note: built-in candidate operator==(int, int)

Demonstração online: https://gcc.godbolt.org/z/dnKc1fhcT

Qual compilador está correto aqui?

Tenho dados de um pré e pós-teste em dois grupos: controle e tratamento. Calculei a pontuação e agora quero ilustrar as diferenças entre grupos e testes. Como base tenho um data frame em R contendo para cada aluno uma linha com os resultados do pré e do pós-teste:

student_id  group       test_id  Score
145         Treatment   pre      0.12
145         Treatment   post     0.78
109         Control     pre      0.45
109         Control     post     0.99

Eu escrevi o seguinte código

s2$test_id <- as.factor(s2$test_id)
s2$group <- as.factor(s2$group)

p <- ggplot(s2, aes(x = test_id, y=score, fill = group)) + geom_violinhalf(trim=FALSE, fill="gray")+
  labs(title="Half Violin",x="Test", y = "Score")+
  geom_boxplot(width=0.1)+
  theme_classic() + scale_x_discrete(limits = rev)
p

produzindo

É possível que o violino cinza possa ser transformado na distribuição do grupo de tratamento (azul) e que eu possa adicionar uma segunda forma de violino à esquerda do pré e pós-teste representando a distribuição de controle (vermelho)?

Imagine que tenho um conjunto de dados como:

data = {
    "a": [1, 4, 2, 4, 7, 4],
    "b": [4, 2, 3, 3, 0, 2],
    "c": ["a", "b", "c", "d", "e", "f"],
}

e quero manter apenas as linhas a + bdescritas exclusivamente por uma única combinação de ae b. Eu consegui hackear isso:

df = (
    pl.DataFrame(data)
    .with_columns(sum_ab=pl.col("a") + pl.col("b"))
    .group_by("sum_ab")
    .agg(pl.col("a"), pl.col("b"), pl.col("c"))
    .filter(
        (pl.col("a").list.unique().list.len() == 1)
        & (pl.col("b").list.unique().list.len() == 1)
    )
    .explode(["a", "b", "c"])
    .select("a", "b", "c")
)

"""
shape: (2, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 4   ┆ 2   ┆ b   │
│ 4   ┆ 2   ┆ f   │
└─────┴─────┴─────┘
"""

Alguém pode sugerir uma maneira melhor de conseguir o mesmo? Lutei um pouco para descobrir essa lógica, então imagino que exista uma maneira mais direta/elegante de obter o mesmo resultado.

Estou olhando cppreference mas não vejo nenhuma informação sobre a ordem do loop executado.

Minha pergunta : ao ligar, std::ranges::any_oftenho data.begin(), data.end() certeza de que vai de begin()para end()em ordem e para uma vez true?

Na estrutura C, por que packed,alignedparece fazer preenchimento?

Eu tenho que ler vários bytes MSB/LSB de um dispositivo remoto usando i2c. Como todos os dados do dispositivo são bytes, eu uso uint8_to que representa exatamente 8 bits, ou seja, 1 byte.

Agora preciso ter certeza de que a estrutura está packed(ou seja, não há "buraco" entre os elementos na estrutura), a menos que eu não leia os dados à medida que são gerados no dispositivo remoto.

Em seguida, adicionei aligneddesempenho (ou seja, permitir que a CPU leia a estrutura com acesso mínimo à memória).

Conforme explicado aqui Preenchimento e empacotamento da estrutura , o preenchimento alinha os membros da estrutura aos limites de endereço "naturais" e o empacotamento evita o preenchimento.

Este teste simples me surpreendeu:

$ gcc --version
gcc (Debian 10.2.1-6) 10.2.1 20210110

$ cat dumb.c 
#include <stdio.h>
#include <stdint.h> // uint8_t

struct struct1 {
  uint8_t msb;
} __attribute__((packed));

struct struct2 {
  uint8_t msb;
} __attribute__((packed,aligned(4)));

struct struct3 {
  uint8_t msb;
  uint8_t lsb;
} __attribute__((packed));

struct struct4 {
  uint8_t msb;
  uint8_t lsb;
} __attribute__((packed,aligned(4)));

int main(void) {
  struct struct1 s1;
  printf("sizeof(s1) %zu\n", sizeof(s1));
  struct struct2 s2;
  printf("sizeof(s2) %zu\n", sizeof(s2));
  struct struct3 s3;
  printf("sizeof(s3) %zu\n", sizeof(s3));
  struct struct4 s4;
  printf("sizeof(s4) %zu\n", sizeof(s4));
  return 0;
}

$ gcc -o dumb dumb.c

$ ./dumb 
sizeof(s1) 1
sizeof(s2) 4
sizeof(s3) 2
sizeof(s4) 4

alignedparece "preencher o final da estrutura": isso é esperado?

• Eu esperava s2começar com um endereço de memória múltiplo de 4 bytes, mas ter tamanho 1.
• Eu esperava s4começar com um endereço de memória múltiplo de 4 bytes, mas ter tamanho 2.

Eu li esses bytes de um dispositivo remoto para que cada byte seja transferido usando i2c do dispositivo para o PC: agora para desempenho, é melhor ir packedapenas para evitar "preenchimento extra no final", ou é melhor ir packed,alignedtransferindo e lendo bytes extras "preenchidos no final" não utilizados cada vez que há uma transferência?

Se você tiver um std::variantcom tipos duplicados, como atribuir a ele? std::variantaparentemente permite tipos duplicados.

std::variant<int,int> foo;

compila com sucesso, mas não tenho certeza de como atribuir a foo, ainda mais se eu desejar atribuir a uma entrada específica na variante.

Eu tentei:

std::variant<int,int> foo;
foo = 1;

falha ao compilar, com o erro que =é indefinido para std::variant<int,int>.

std::variant<int,int> foo;
get<foo, 0> = 1;

falha ao compilar com o erro de que não há informações de tipo contextual suficientes para determinar o tipo.

Eu quero algo como

std::variant<int,int> foo;
something<foo, 1> = 10
assert(foo.index == 1);
assert(get<1>(foo) == 10);