全部问题(coding)

我希望这仅在尾数的最后一位为时才成立0。否则，为了减去它们（因为它们的指数相差 1），x首先会损失一些精度，结果最终要么向上舍入，要么向下舍入。

但一个快速实验表明，对于任何随机数（包括带有 aa 尾随位的数） ，它似乎总是成立（假设x和是有限的） 。2x1

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

我有一个数据集，想从中删除重复的条目。我使用的 lazyframe 结构如下：

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    │
└──────┴────────────┴──────────────────┴───────┘
""")

我想删除具有相同的条目id，但实际上存在不同的情况：

1. 重复项具有相同的内容type（例如 1001）：保留第一个。
2. 重复项具有不同的type：丢弃以空字符串（“”）作为类型的重复项，然后仅保留符合以下type和对的条目type2：

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

预期输出

• 1001：相同类型，保留第一个
• 1002：不同类型，保留第一次出现的带有 {'book chapter': 41} 的条目
• 1003：不同类型，丢弃类型为空的条目并保留第一个匹配项
• 1004：不是重复的

我尝试了很多方法，主要是使用 pl.when() 表达式，但我无法找到过滤组的方法。

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

我有一个混乱的表格，我将其读入类似于以下简化的数据框中，我想对其进行解析。

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'))

它看起来像：

> 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

我需要将折叠的ids列分成多行，以获得长格式的最终​​数据框。

对于这一点，我通常会separate_rows从申请开始tidyr，但这种情况还有一个额外的问题：一些折叠ids被分组到子组中。

我想我应该先将这些子组分成不同的 ID 列，然后在这些列上应用separate_rows或separate_longer_delim...我不知道该怎么做。

我期望的最终数据框将是这样的，采用长格式，并subgroup在附加列中包含信息：

> 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>

如何在 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()

使用 Python 3.12 运行上述代码会抛出一个错误SyntaxError：

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

C++23 中类的比较运算符是否可以具有与类类型不同的类型的显式对象参数？

例如

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

现在比较不平等

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

被 GCC 和 Clang 接受，但 MSVC 抱怨：

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

平等的比较

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

仅被 GCC 接受，而 Clang 已经不喜欢它了：

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)

在线演示：https://gcc.godbolt.org/z/dnKc1fhcT

这里哪个编译器是正确的？

我有两组（对照组和实验组）的预测试和后测试数据。我计算了分数，现在想说明组和测试之间的差异。作为基础，我在 R 中有一个数据框，其中包含每个学生的预测试和后测试结果的一行：

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

我写了下面的代码

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

生产

是否可以将灰色小提琴改为治疗组的分布（蓝色），并且我可以在前测和后测的左侧添加第二半小提琴形状来描绘控制分布（红色）？

假设我有一个如下数据集：

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

并且我只想保留由和a + b的单个组合唯一描述的行。我设法破解了这一点：ab

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   │
└─────┴─────┴─────┘
"""

有人能建议一种更好的方法来实现同样的效果吗？我花了一些功夫才弄清楚这个逻辑，所以我想有一种更直接/更优雅的方法可以获得相同的结果。

我正在查看cppreference，但没有看到有关执行循环顺序的任何信息。

我的问题是：当调用时，std::ranges::any_of我data.begin(), data.end() 是否确定它会按顺序从到进行begin()并且end()停止一次true？

在 C 结构中，为什么packed,aligned似乎要做填充？

我必须使用 i2c 从远程设备读取一堆 MSB/LSB 字节。由于所有设备数据都是字节，因此我使用uint8_t它来精确表示 8 位，即 1 个字节。

现在我需要确保结构是packed（即结构中的元素之间没有“洞”），除非我不会读取远程设备中生成的数据。

然后，我添加了aligned性能（即允许 CPU 以最少的内存访问读取结构）。

正如结构填充和打包所解释的，填充将结构成员与“自然”地址边界对齐，而打包可防止填充。

这个简单的测试让我很惊讶：

$ 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

aligned似乎“填充了结构的末尾”：这是预期的结果吗？

• 我希望s2从 4 字节的倍数内存地址开始，但大小为 1。
• 我希望s4从 4 字节的倍数内存地址开始，但大小为 2。

我从远程设备读取这些字节，因此每个字节都使用 i2c 从设备传输到 PC：现在为了提高性能，最好packed只避免“末尾的额外填充”，还是最好packed,aligned每次传输时都传输和读取额外未使用的“末尾填充”字节？

如果您有一个std::variant具有重复类型的，您如何分配给它？std::variant看似允许重复类型。

std::variant<int,int> foo;

编译成功，但我不确定如何分配给foo，如果我想分配给变体中的特定条目，就更是如此。

我尝试过：

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

编译失败，错误=为未定义的std::variant<int,int>。

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

编译失败，错误为缺乏足够的上下文类型信息来确定类型。

我想要类似的东西

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