全部问题(coding)

假设我有下面的表格。我想创建索引来帮助加快查询速度。

所有查询都类似于以下内容：

Select *
from users
where Type = 'SomeType'
  and First = 'SomeName1'
Order by CreatedAt DESC;

Select *
from users
where Type = 'SomeType'
  and Middle = 'SomeName2'
Order by CreatedAt DESC;

Select *
from users
where Type = 'SomeType'
  and Last = 'SomeName3'
Order by CreatedAt DESC;

我该如何索引这些列以使查询更高效？CreatedAt索引列中的第一个会是什么？

我在想

CREATE INDEX idx_users on users(CreatedAt, Type, First, Middle, Last)

CreatedAt和type总是会被使用，而第一、中间和最后一个则会有所不同。

在 GCC 15 中，std::noop_coroutine的定义是

{ return std::noop_coroutine_handle(); }

std::noop_coroutine_handle定义为：

using noop_coroutine_handle = std::coroutine_handle<std::noop_coroutine_promise>;

为了获得无操作协程，我们编写

std::noop_coroutine()

我猜这相当于

std::noop_coroutine_handle{}

和

std::coroutine_handle<std::noop_coroutine_promise>{}

因此我相信标准库只需要提供std::noop_coroutine_promise（以及使用它作为模板参数的某些专业化）。

为什么标准引入了三个新符号？（感觉有点武断 - 只是我的个人观点。）

我有一个嵌套列的字典，每个列都以索引作为键。当我尝试将其转换为 polars 数据框时，它会正确获取列名和值，但每列只有一个元素，即列元素的字典，而不会将其“扩展”为一系列。

举个例子，假设我有：

d = {'col1': {'0':'A','1':'B','2':'C'}, 'col2': {'0':1,'1':2,'2':3}}

然后，当我执行pl.DataFrame(d)或 时pl.from_dict(d)，我得到：

col1           col2
---            ---
struct[3]      struct[3]
{"A","B","C"}  {1,2,3}

而不是常规的数据框。

知道如何修复这个问题吗？

提前致谢！

我正在构建一个简单的 React 应用，其中有一只宠物，它有饥饿、无聊和精力等属性。我想以不同的间隔更新这些属性（每 5 秒更新一次饥饿，每 8 秒更新一次无聊，每 10 秒更新一次精力）。

但是，虽然饥饿值可以正确更新，但无聊值和精力值却不能。我曾经setInterval更新过这些值，但似乎只有饥饿值在更新。

相关代码如下：

import { useEffect, useState } from "react";
import { Pet } from "./types/pet";

function App() {
  const [pet, setPet] = useState<Pet | null>(null);

  useEffect(() => {
    // Load pet from localStorage or create a new pet
    const savedPet = localStorage.getItem("pet");
    if (savedPet) {
      try {
        const parsedPet = JSON.parse(savedPet) as Pet;
        setPet(parsedPet);
      } catch (error) {
        console.error("Error parsing saved pet:", error);
        createNewPet();
      }
    } else {
      createNewPet();
    }
  }, []);

  const updatePet = (updateFn: (currentPet: Pet) => Partial<Pet>) => {
    setPet((prevPet) => {
      if (!prevPet) return null;
      const updatedPet = { ...prevPet, ...updateFn(prevPet) };
      localStorage.setItem("pet", JSON.stringify(updatedPet));
      return updatedPet;
    });
  };

  useEffect(() => {
    if (!pet) return;

    const hungerInterval = setInterval(() => {
      updatePet((pet) => ({ hunger: Math.min(pet.hunger + 1, 100) }));
    }, 5000);

    const boredomInterval = setInterval(() => {
      updatePet((pet) => ({ boredom: Math.min(pet.boredom + 1, 100) }));
    }, 8000);

    const energyInterval = setInterval(() => {
      updatePet((pet) => ({ energy: Math.max(pet.energy - 1, 0) }));
    }, 10000);

    return () => {
      clearInterval(hungerInterval);
      clearInterval(boredomInterval);
      clearInterval(energyInterval);
    };
  }, [pet]);

  return (
    <div>
      <p>Hunger: {pet.hunger}%</p>
      <p>Boredom: {pet.boredom}%</p>
      <p>Energy: {pet.energy}%</p>
    </div>
  );
}

export default App;

我的经历：

• 饥饿值每 5 秒正确更新一次。
• 尽管无聊和能量统计数据的间隔设置方式相同，但它们并没有按预期更新。

我尝试过的：

• 我已检查过间隔并且它们似乎是正确的。
• 我尝试使用功能更新来更新状态以确保使用最新状态，但仍然只有饥饿更新。

有人知道为什么只有饥饿状态在更新，以及我该怎么做才能解决这个问题？

我有一个文件夹，里面全是 .wav 文件，我想将它们复制到名为“唯一大小”和“非唯一大小”的子文件夹中。大约一半的文件大小相同，精确到字节：

Get-ChildItem "*.wav" | Group-Object -Property Length -NoElement | Sort-Object Count -Descending

Count Name     Group (Example)
----- ----     ----
    6 26244078 {file206.wav, file137.wav, file 101.wav, etc.}
    5 28716602
    5 28807758
    5 30750266
    ...
    1 17773794 {file31.wav}
    1 18144078
    1 18432082
    1 70589446

如果组数 = 1，我希望将它们复制到“唯一大小”，否则复制到“非唯一大小”，但我对 powershell 和 CLI 总体上不太熟悉，目前我还不太确定如何处理命令的输出。我在网上搜索过几次，但我的关键字似乎对这个相当独特的问题没有任何帮助。任何帮助我都会感激不尽，谢谢！

我正在使用 Swaggo 来记录我的 Go API 端点。我有一个处理程序函数，其中我在 JSON 结构字段中定义了一个带有示例标签的结构，但这些示例并未出现在生成的 Swagger UI 中。

// @Summary Register a new user
// @Description Creates a new user account. In development environment, the user is activated immediately. Otherwise, an activation email is sent.
// @Tags users
// @Accept json
// @Produce json
// @Param request body main.application.registerUserHandler.input true "User registration details"
// @Success 202 {object} object{user=data.User}
// @Router /users [post]
func (app *application) registerUserHandler(w http.ResponseWriter, r *http.Request) {
    var input struct {
        Name     string `json:"name" example:"John Doe"`
        Email    string `json:"email" example:"[email protected]"`
        Password string `json:"password" example:"SecurePass123!"`
    }
    // ... rest of the handler ...
}

Swagger 文档生成正确，但结构中示例标签的示例值未显示在请求主体模式中。

有没有办法让 Swaggo 识别嵌套/内联结构中的示例标签？

因此，我偶然发现了 Jeff Preshing 的精彩博客文章，其中介绍了什么是AcquireCPU障碍Release以及如何通过一些 CPU障碍实现这些障碍。

我还读过关于某种总顺序的文章，它保证与非一致性后关系SeqCst一致- 尽管有时由于历史原因它可能与由简单/操作建立的前发生关系相矛盾。AcquireRelease

我的问题是，旧的 GCC 内置函数如何映射到 C++11 (及更高版本) 提出的内存模型？具体来说，如何映射__sync_synchronize()到 C++11 或更高版本的现代 C/C++？

在 GCC手册中，此调用被简单地描述为完整内存屏障，我认为这是所有四种主要屏障（即LoadLoad/ LoadStore/ StoreLoad/StoreStore 屏障）的组合。但sync_synchronize 相当于std::atomic_thread_fence(memory_order_seq_cst)？或者，从形式上讲，其中一个比另一个更强（我想这里就是这种情况：通常，SeqCst隔离应该更强，因为它需要工具链/平台以某种方式即兴执行全局排序，不是吗？），而碰巧大多数 CPU只提供同时满足两者（完整内存屏障__sync_synchronize，完全顺序排序std::atomic_thread_fence(memory_order_seq_cst)）的指令，例如 x86和 PowerPC ？mfencehwsync

__sync_synchronize和要么std::atomic_thread_fence(memory_order_seq_cst)在形式上相等，要么在实际上相等（即，从形式上讲它们是不同的，但没有商业化的 CPU 会费心区分两者），从技术上讲，memory_order_relaxed对同一原子的负载仍然不能依赖于与它同步/创建先发生关系，不是吗？

也就是说，从技术上讲，所有这些断言都可以失败，对吗？

// Experiment 1, using C11 `atomic_thread_fence`: assertion is allowed to fail, right?

// global
static atomic_bool lock = false;
static atomic_bool critical_section = false;

// thread 1
atomic_store_explicit(&critical_section, true, memory_order_relaxed);
atomic_thread_fence(memory_order_seq_cst);
atomic_store_explicit(&lock, true, memory_order_relaxed);

// thread 2
if (atomic_load_explicit(&lock, memory_order_relaxed)) {
    // We should really `memory_order_acquire` the `lock`
    // or `atomic_thread_fence(memory_order_acquire)` here,
    // or this assertion may fail, no?
    assert(atomic_load_explicit(&critical_section, memory_order_relaxed));
}

// Experiment 2, using `SeqCst` directly on the atomic store

// global
static atomic_bool lock = false;
static atomic_bool critical_section = false;

// thread 1
atomic_store_explicit(&critical_section, true, memory_order_relaxed);
atomic_store_explicit(&lock, true, memory_order_seq_cst);

// thread 2
if (atomic_load_explicit(&lock, memory_order_relaxed)) {
    // Again we should really `memory_order_acquire` the `lock`
    // or `atomic_thread_fence(memory_order_acquire)` here,
    // or this assertion may fail, no?
    assert(atomic_load_explicit(&critical_section, memory_order_relaxed));
}

// Experiment 3, using GCC built-in: assertion is allowed to fail, right?

// global
static atomic_bool lock = false;
static atomic_bool critical_section = false;

// thread 1
atomic_store_explicit(&critical_section, true, memory_order_relaxed);
__sync_synchronize();
atomic_store_explicit(&lock, true, memory_order_relaxed);

// thread 2
if (atomic_load_explicit(&lock, memory_order_relaxed)) {
    // we should somehow put a `LoadLoad` memory barrier here,
    // or the assert might fail, no?
    assert(atomic_load_explicit(&critical_section, memory_order_relaxed));
}

我已经在 RPi 5 上尝试了这些代码片段，但我没有看到断言失败。是的，这并没有正式证明任何事情，但它也没有阐明__sync_synchronize和之间的区别std::atomic_thread_fence(memory_order_seq_cst)。

我正在开发自定义子集和算法，但遇到了一个令人费解的问题：如果不使用非常大的整数（例如，大于 2^22），似乎很难生成真正“硬”的子集和实例（即强制指数级的计算工作量）。

我特别想知道：

• 是否存在已知的子集和构造或实例生成器，可以可靠地强制指数复杂性 - 特别是针对常见的子集和算法或自定义启发式方法 - 仅使用中等大小的整数（≤2^22）？
• 子集和实例的难度是否本质上与所涉及的整数的大小相关，或者是否有可能纯粹通过数值结构和关系来创建计算困难的实例，即使数字较小？

就上下文而言，以下是我在生成潜在困难实例方面所做的一些尝试（欢迎反馈或改进）：

import random

def generate_exponential_instance(n):
    max_element = 2 ** 22
    A = [random.randint(1, max_element) for _ in range(n)]
    while True:
        mask = [random.choice([0, 1]) for _ in range(n)]
        if sum(mask) != 0:
            break
    target = sum(A[i] * mask[i] for i in range(n))
    return A, target

def generate_dense_high_values_instance(n):
    base = 2 ** 22 - random.randint(0, 100)
    A = [base + random.randint(0, 20) for _ in range(n)]
    target = sum(random.sample(A, k=n // 2))
    return A, target

def generate_merkle_hellman_instance(n, max_step=20):
    total = 0
    private_key = []
    for _ in range(n):
        next_val = total + random.randint(1, max_step)
        private_key.append(next_val)
        total += next_val
    q = random.randint(total + 1, 2 * total)
    r = random.randint(2, q - 1)
    public_key = [(r * w) % q for w in private_key]
    message = [random.randint(0, 1) for _ in range(n)]
    ciphertext = sum(b * k for b, k in zip(message, public_key))
    return public_key, ciphertext

我有一个用 C# 实现的 ASP.NET Core 7 Web API 服务和一个定义如下的方法：

[ApiController]
[Route("api/[controller]")]
public class SensorsController : ControllerBase
{
    // ...
    [HttpGet("{sensorname}/zf")]
    public async Task<ActionResult> GetZForecast(string sensorname, [FromQuery]DateTime? when, [FromQuery]string? wind)
    {
        // ...
    }
}

我想用这个 curl 命令来测试它：

curl -X get https://localhost:7091/api/Sensors/VK_THC_GreenRoom/zf?when="2025-03-15T08:00:00Z"&wind="Calm"

为什么wind在这种情况下控制器无法捕获该参数？

如果我只使用一个可选查询参数（如下所示），那么一切都可以正常工作，并且wind分别when捕获和：

curl -X get https://localhost:7091/api/Sensors/VK_THC_GreenRoom/zf?when="2025-03-15T08:00:00Z"

curl -X get https://localhost:7091/api/Sensors/VK_THC_GreenRoom/zf?wind="Calm"

那么我错过了什么？

抱歉标题太长了。我不知道这更像是数学问题还是编程问题，但我认为我的数学非常生疏，而我更擅长编程。

所以我有这个反正切的连分式展开式：

我从维基百科上找到的

我尝试找到一个简单的算法来计算它：

我做到了，我编写了一个连分数展开的无限精度实现，没有使用任何库，只使用基本的整数运算：

import json
import math
import random
from decimal import Decimal, getcontext
from typing import Callable, List, Tuple


Fraction = Tuple[int, int]


def arctan_cf(y: int, x: int, lim: int) -> Fraction:
    y_sq = y**2
    a1, a2 = y, 3 * x * y
    b1, b2 = x, 3 * x**2 + y_sq
    odd = 5
    for i in range(2, 2 + lim):
        t1, t2 = odd * x, i**2 * y_sq
        a1, a2 = a2, t1 * a2 + t2 * a1
        b1, b2 = b2, t1 * b2 + t2 * b1
        odd += 2

    return a2, b2

并且它比我以前使用的牛顿反正切级数收敛得更快。

现在我认为如果我将它与反正切的半角公式结合起来，它应该收敛得更快。

def half_arctan_cf(y: int, x: int, lim: int) -> Fraction:
    c = (x**2 + y**2) ** 0.5
    a, b = c.as_integer_ratio()
    a, b = arctan_cf(a - b * x, b * y, lim)
    return 2 * a, b

事实上，它确实收敛得更快：

def test_accuracy(lim: int) -> dict:
    result = {}
    for _ in range(lim):
        x, y = random.sample(range(1024), 2)
        while not x or not y:
            x, y = random.sample(range(1024), 2)

        atan2 = math.atan2(y, x)
        entry = {"atan": atan2}
        for fname, func in zip(
            ("arctan_cf", "half_arctan_cf"), (arctan_cf, half_arctan_cf)
        ):
            i = 1
            while True:
                a, b = func(y, x, i)
                if math.isclose(deci := a / b, atan2):
                    break

                i += 1

            entry[fname] = (i, deci)

        result[f"{y} / {x}"] = entry

    return result


print(json.dumps(test_accuracy(8), indent=4))

for v in test_accuracy(128).values():
    assert v["half_arctan_cf"][0] <= v["arctan_cf"][0]

{
    "206 / 136": {
        "atan": 0.9872880750087898,
        "arctan_cf": [
            16,
            0.9872880746658675
        ],
        "half_arctan_cf": [
            6,
            0.9872880746018052
        ]
    },
    "537 / 308": {
        "atan": 1.0500473287277563,
        "arctan_cf": [
            18,
            1.0500473281360896
        ],
        "half_arctan_cf": [
            7,
            1.0500473288158192
        ]
    },
    "331 / 356": {
        "atan": 0.7490241118247137,
        "arctan_cf": [
            10,
            0.7490241115996227
        ],
        "half_arctan_cf": [
            5,
            0.749024111913438
        ]
    },
    "744 / 613": {
        "atan": 0.8816364228048325,
        "arctan_cf": [
            13,
            0.8816364230439662
        ],
        "half_arctan_cf": [
            6,
            0.8816364227495634
        ]
    },
    "960 / 419": {
        "atan": 1.1592605364805093,
        "arctan_cf": [
            24,
            1.1592605359263286
        ],
        "half_arctan_cf": [
            7,
            1.1592605371181872
        ]
    },
    "597 / 884": {
        "atan": 0.5939827714677137,
        "arctan_cf": [
            7,
            0.5939827719895824
        ],
        "half_arctan_cf": [
            4,
            0.59398277135389
        ]
    },
    "212 / 498": {
        "atan": 0.40246578425167584,
        "arctan_cf": [
            5,
            0.4024657843859885
        ],
        "half_arctan_cf": [
            3,
            0.40246578431841773
        ]
    },
    "837 / 212": {
        "atan": 1.322727785860997,
        "arctan_cf": [
            41,
            1.322727786922624
        ],
        "half_arctan_cf": [
            8,
            1.3227277847674388
        ]
    }
}

对于大量样本来说，该断言块运行的时间相当长，但它从未引发异常。

所以我认为我可以使用反正切的连分式展开和类似 Machin 的级数来计算 π。（我使用了链接部分中的最后一个级数，因为它收敛速度最快）

def sum_fractions(fractions: List[Fraction]) -> Fraction:
    while (length := len(fractions)) > 1:
        stack = []
        for i in range(0, length - (odd := length & 1), 2):
            num1, den1 = fractions[i]
            num2, den2 = fractions[i + 1]
            stack.append((num1 * den2 + num2 * den1, den1 * den2))

        if odd:
            stack.append(fractions[-1])

        fractions = stack

    return fractions[0]


MACHIN_SERIES = ((44, 57), (7, 239), (-12, 682), (24, 12943))


def approximate_loop(lim: int, func: Callable) -> List[Fraction]:
    fractions = []
    for coef, denom in MACHIN_SERIES:
        dividend, divisor = func(1, denom, lim)
        fractions.append((coef * dividend, divisor))

    return fractions


def approximate_1(lim: int) -> List[Fraction]:
    return approximate_loop(lim, arctan_cf)


def approximate_2(lim: int) -> List[Fraction]:
    return approximate_loop(lim, half_arctan_cf)


approx_funcs = (approximate_1, approximate_2)


def calculate_pi(lim: int, approx: bool = 0) -> Fraction:
    dividend, divisor = sum_fractions(approx_funcs[approx](lim))
    dividend *= 4
    return dividend // (common := math.gcd(dividend, divisor)), divisor // common

getcontext().rounding = 'ROUND_DOWN'
def to_decimal(dividend: int, divisor: int, places: int) -> str:
    getcontext().prec = places + len(str(dividend // divisor))
    return str(Decimal(dividend) / Decimal(divisor))


def get_accuracy(lim: int, approx: bool = 0) -> Tuple[int, str]:
    length = 12
    fraction = calculate_pi(lim, approx)
    while True:
        decimal = to_decimal(*fraction, length)
        for i, e in enumerate(decimal):
            if Pillion[i] != e:
                return (max(0, i - 2), decimal[:i])

        length += 10


with open("D:/Pillion.txt", "r") as f:
    Pillion = f.read()

Pillion.txt包含 π 的前 1000001 位数字，Pi + Million = Pillion。

它确实有效，但只是部分有效。基本连分数展开与类似 Machin 的公式配合得很好，但与半角公式结合，无论如何我都只能得到 9 位正确的小数，事实上，我在第一次迭代中就得到了 9 位正确的数字，然后整个事情就再也没有改善了：

In [2]: get_accuracy(16)
Out[2]:
(73,
 '3.1415926535897932384626433832795028841971693993751058209749445923078164062')

In [3]: get_accuracy(32)
Out[3]:
(138,
 '3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231')

In [4]: get_accuracy(16, 1)
Out[4]: (9, '3.141592653')

In [5]: get_accuracy(32, 1)
Out[5]: (9, '3.141592653')

In [6]: get_accuracy(1, 1)
Out[6]: (9, '3.141592653')

但数字确实发生了变化：

In [7]: to_decimal(*calculate_pi(1, 1), 32)
Out[7]: '3.14159265360948500093515231500093'

In [8]: to_decimal(*calculate_pi(2, 1), 32)
Out[8]: '3.14159265360945286794831052938917'

In [9]: to_decimal(*calculate_pi(3, 1), 32)
Out[9]: '3.14159265360945286857612896472974'

In [10]: to_decimal(*calculate_pi(4, 1), 32)
Out[10]: '3.14159265360945286857611676794770'

In [11]: to_decimal(*calculate_pi(5, 1), 32)
Out[11]: '3.14159265360945286857611676818392'

为什么半角连分数公式不适用于类似 Machin 的公式？是否有可能让它起作用？如果可以，那么如何起作用？我想要一个证明它是不可能的证据，或者一个证明它是可能的实例。

只需进行健全性检查，使用 π/4 = arctan(1) 我能够得出half_arctan_cfπ 的数字，但它的收敛速度要慢得多：

def approximate_3(lim: int) -> List[Fraction]:
    return [half_arctan_cf(1, 1, lim)]


approx_funcs = (approximate_1, approximate_2, approximate_3)

In [28]: get_accuracy(16, 2)
Out[28]: (15, '3.141592653589793')

In [29]: get_accuracy(16, 0)
Out[29]:
(73,
 '3.1415926535897932384626433832795028841971693993751058209749445923078164062')

同样的问题再次出现，在第 10 次迭代时达到 15 位数字的最大精度：

In [37]: get_accuracy(9, 2)
Out[37]: (14, '3.14159265358979')

In [38]: get_accuracy(10, 2)
Out[38]: (15, '3.141592653589793')

In [39]: get_accuracy(11, 2)
Out[39]: (15, '3.141592653589793')

In [40]: get_accuracy(32, 2)
Out[40]: (15, '3.141592653589793')

我刚刚重写了反正切连分数的实现并使其避免进行冗余计算。

在我的代码中，每次迭代 t1 都会增加 2 * y_sq，因此无需重复将 y_sq 乘以奇数，而是只需使用累积变量和 2 * y_sq 的步长。

并且每对连续平方数之间的差恰好是奇数，因此我可以使用累积变量的累积变量。

def arctan_cf_0(y: int, x: int, lim: int) -> Fraction:
    y_sq = y**2
    a1, a2 = y, 3 * x * y
    b1, b2 = x, 3 * x**2 + y_sq
    odd = 5
    for i in range(2, 2 + lim):
        t1, t2 = odd * x, i**2 * y_sq
        a1, a2 = a2, t1 * a2 + t2 * a1
        b1, b2 = b2, t1 * b2 + t2 * b1
        odd += 2

    return a2, b2


def arctan_cf(y: int, x: int, lim: int) -> Fraction:
    y_sq = y**2
    a1, a2 = y, 3 * x * y
    b1, b2 = x, 3 * x**2 + y_sq
    t1_step, t3_step = 2 * x, 2 * y_sq
    t1, t2 = 5 * x, 4 * y_sq
    t3 = t2 + y_sq
    for _ in range(lim):
        a1, a2 = a2, t1 * a2 + t2 * a1
        b1, b2 = b2, t1 * b2 + t2 * b1
        t1 += t1_step
        t2 += t3
        t3 += t3_step

    return a2, b2

In [301]: arctan_cf_0(4, 3, 100) == arctan_cf(4, 3, 100)
Out[301]: True

In [302]: %timeit arctan_cf_0(4, 3, 100)
58.6 μs ± 503 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [303]: %timeit arctan_cf(4, 3, 100)
54.3 μs ± 816 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

虽然这并没有显著提高速度，但这无疑是一种进步。