小编Art*_*oul的帖子

如果我有任何类型的本地/全局变量，var如何获取其名称，即字符串"var"？即对于某些虚函数或运算符，nameof()下一个代码应该可以工作：

var = 123
assert nameof(var) == "var"

有用于.__name__获取变量保存值的函数或类型对象的名称的属性，但是是否有类似的用于获取变量本身的名称的属性？

这是否可以在不将变量包装到某个神奇对象中的情况下实现，就像某些库为了获取变量名称所做的那样？如果没有魔术包装器就无法实现，那么用于这种情况的最常见/流行的包装库是什么？

如果我有知道分解的整数，那么计算浮点数N最快（最有效）的方法是什么？1/N为此应使用大浮点（或整数）算术。

我想在 C++ 中执行此操作（或在 Python 中进行实验运行）。

我的N非常巨大，大小为千兆/太比特。生成的浮点N还应该具有很高的精度，大约与初始的位大小相同N。

需要精确的浮点值，这意味着如果我请求浮点精度Log2(N)位，那么至少95%结果的所有前导位应该是精确的（所有位与理想值中的位相同）。

当然，4^Ceil(Log2(N)) / N如果它有助于和/或简化任务，则可以计算整数除法，而不是浮点计算。对我来说，这两个任务（整数和浮点数）本质上是相同的，因为整数表示可以转换为浮点数，反之亦然。

一个重要的注意事项是 的因式分解N只有很小的质因数，它们的大小都是 32 位（当然最多可能是 64 位）。

我想知道如果因式分解N以及因数很小这一事实是否可以帮助以某种方式解决任务？

当然，我没有首先实现我自己的部门，而是尝试使用高度优化的GMP库来完成此任务，但它（据我所知）并没有使用N已经因式分解的事实。

任何人都可以建议我是否要为此实现自己的函数，只是为了通过实验弄清楚它是否比 GMP 更快，那么我应该使用哪种算法？

我发现这里可以使用 3 种算法 1）长除法，这是一种学校级算法。2）巴雷特还原。3）蒙哥马利还原。

其实我不知道其他算法。你能建议其他吗？仅当相同素因子重复多次时，Barrett 和 Montgomery 约简才有帮助，否则单次除法不值得 Barrett 和 Montgomery 所需的预计算。

此外，Barrett/Montgomery 归约仍然需要一次性计算4^Ceil(Log2(N)) / PrimeDivisor。所以它们不会让你免于进行长除算法。

对于长除法算法，我肯定会使用它2^64作为基础而不是基础10（如在学校）。

我已经使用长除法和所有其他整数算术算法以及椭圆曲线算术实现了自己的实验库。目前它是通用的，因此不会比 GMP 更快。现在我需要特殊的除法算法，它至少比 GMP 快几倍。 …

NumPy中有np.stack，但是否有与tf.unstack相同的相反项？np.unstack

我需要尽可能快地生成整数, , , 的所有排列，并将结果作为shape的NumPy数组，或者遍历此类数组的大部分以节省内存。012...n - 1(factorial(n), n)

NumPy 中是否有一些内置函数可以执行此操作？或者一些功能的组合。

使用itertools.permutations(...)太慢，我需要一个更快的方法。

我试图重现最小的问题。当我在 Ubuntu 上运行 CMake+Make 时出现错误

funccpp.cpp:(.text+0x5): undefined reference to `FuncC'

即在 C++ 库中导入时找不到 C 库中的导出函数。当我尝试使用g++ main.cpp funcc.c funccpp.cpp它手动编译时，成功编译了最终程序。如何解决 CMake 问题？

作为参考，当我运行时，nm libfuncc_lib.a我得到线T FuncC（所以符号是外部的并在文本部分中定义），当我运行时nm libfunccpp_lib.a我得到U FuncC（所以符号是未定义的，应该从外部链接）。

CMakeLists.txt

cmake_minimum_required(VERSION 2.8)

project(Test C CXX)

set (SRC_CPP funccpp.cpp)
set (SRC_C funcc.c)
set (SRC_MAIN main.cpp)

add_library(funcc_lib STATIC ${SRC_C})
add_library(funccpp_lib STATIC ${SRC_CPP})
add_executable(prog ${SRC_MAIN})
target_link_libraries(prog funcc_lib funccpp_lib)

主程序

#include "funccpp.h"

int main() {
    FuncCPP();
    return 0;
}

功能文件

#ifndef FUNCCPP_H
#define FUNCCPP_H

void FuncCPP();

#endif

功能文件 …

标准 C++ 中是否有 size_t 的有符号变体？意味着与 size_t 完全相同的位大小，但有符号。

我当然可以这样做：

#include <type_traits>
using signed_size_t = std::make_signed_t<std::size_t>;

但也许标准库中已经有类似的定义，而不是发明额外的类型名称？

我知道有 ssize_t 和 ptrdiff_t，都有签名。但根据他们的描述，它们似乎都可以具有与 size_t 不同的位大小。但我需要与 size_t 完全相同的位大小，但已签名。

有PEP-554和PEP-684。两者都旨在支持线程级别的多个解释器。

有谁知道这些 PEP 是否至少在 Python 的实验版本或预发布版本（如 3.11）中实现？

我发现 Python 3.10（甚至可能是 3.9）在实验版本中具有这些功能。如果您通过配置以下标志来构建 CPython：

./configure --with-experimental-isolated-subinterpreters

或者在编译所有文件时在编译命令中添加define .c：

#define EXPERIMENTAL_ISOLATED_SUBINTERPRETERS 1

我在一个著名的项目中发布了启用此功能的请求，请参阅此处的问题。

启用此功能后，我想我将能够在多个线程（而不是进程）内创建单独的解释器，这意味着我不再需要多重处理。

更重要的是，根据此功能描述，当使用多个解释器时，不需要有单个 GIL，单独线程中的每个解释器都有自己的 GIL。这意味着即使解释器是在线程内创建的，仍然会使用所有 CPU 核心，就像multiprocessing. 当前的 Python 遭受 GIL 的困扰只是因为它强制只使用单个 CPU 核心，因此multiprocessing人们使用所有 CPU 核心来克服这个问题。

在描述这些功能时，据说作者必须手动修改 1500 个静态和全局变量，将它们全部移动到线程状态结构内的每线程本地表中。

想必所有这些新功能现在只能通过Python C API来使用。

如果这里有人知道如何使用这些独立的子解释器功能，您能否提供一些 Python 代码或 C API 代码以及如何使用它们的详细示例？

具体来说，我感兴趣的是如何以使用所有CPU核心的方式使用解释器，即我想知道如何避免单个GIL，而是使用多个GIL（实际上是本地锁，LIL）。当然，我想要内部线程，而不使用multiprocessing.

我正在为NumPy寻找最好的64-bit（或至少是32-bit）具有下一个属性的哈希函数：

1. 它针对 numpy 进行了矢量化，这意味着它应该具有散列任何 ND numpy 数组的所有元素的函数。
2. 它可以应用于任何可散列的 numpy 的dtype. 为此，这种散列能够仅处理原始字节块就足够了。
3. 它非常非常快，就像xxhash一样。特别是对于许多小输入，例如 32、64 位数字或短 np.str_ 的巨大数组，它应该很快，但也应该处理其他 dtype。
4. 它应该是抗碰撞的。我可能只使用部分位，所以散列中的任意数量的位也应该是抗碰撞的。
5. 它可能是（也可能不是）非加密的，这意味着如果它有时可以反转就可以了，比如xxhash.
6. 它应该产生64-bit整数或更大的输出，但如果是，32-bit那么仍然可以，尽管不是那么可取。如果可能的话，最好选择生成 32、64、128 位大小的散列。
7. 它本身应该在内部将 numpy 数组转换为字节以使散列速度更快，或者至少可能在 numpy 中已经有这样的转换函数，可以将任何流行的 dtype 的整个 ND 数组转换为可变的字节序列，如果有人会告诉我这个很好.

xxhash如果它有numpy数组矢量化，我会使用上面链接提到的。但是现在它只是单个对象，它的绑定函数每次调用只接受一个字节块，产生一个整数输出。并且 xxhash 每次调用小（4、8 个字节）输入时只使用几个 CPU 周期，因此可能在大数组上执行纯 Python 循环来为每个数字调用 xxhash 效率非常低。

我需要它用于不同的事情，一个是概率存在过滤器（或集合），即我需要设计这样的结构（集合），N如果请求的元素可能在集合中或不是。为此，我想使用较低的散列位将输入分布到K存储桶中，并且每个存储桶还存储一些（可调整的）较高位的数量，以增加正确答案的概率。另一个应用是布隆过滤器。我需要这个集合在添加和请求时非常快，并且在内存中尽可能紧凑，并处理非常多的元素。

如果没有现有的好的解决方案，那么也许我还可以改进xxhash库并向作者的存储库创建拉取请求。

我有使用Numba进行JIT编辑的人工示例代码：

import numba
@numba.njit
def f(x, c):
    for i in range(3):
        if c == 0:
            x += 1
        elif c == 1:
            x *= 2
        else:
            assert False
    return x
print(f(3, 0), f(3, 1))

c如果是来自小的最终整数值集的某个常数，例如，如何优化它0 <= c <= 3？

不允许将if有关条件c移出循环，因为这将是一个明显的优化。因为它是一个人为的示例，所以在实际示例中，循环可能会很大，并且仅更改主体内部的 1-2 行即可重复循环两次是负担不起的。

基本上我想让c编译时保持不变。与C++一样，可以将编译时常量作为模板参数，并执行与此相关的所有代码优化。

所以我想告诉 Numba 参数c0、c1等是编译时常量，应该以这样的方式处理：每当使用不同的cNumba 值调用函数时，都应该创建和编译一个单独的函数实例并进行必要的优化，就像C++生成一样当传递新的模板参数集时，模板化函数的每次实例化。

换句话说，这些常量的可能值c应该包含在函数的签名中，据我了解，Numba 会为每个不同的签名生成单独的函数代码，就像 C++ 模板一样。

另一种需要优化的情况是，whenc不是函数的参数，而是循环开始之前某些复杂表达式计算的结果。在这种情况下，结果c …

我想在代码的某个点检查是否x声明了某个标识符，我该怎么做？

我需要对不同类型的标识符进行这种检查 - 变量、枚举常量、函数、类型、宏等。但首先我想至少检查变量和函数。

我需要这样的检查（例如虚数declared(x)），以便下一个代码适用于 int 变量的情况x：

if constexpr(declared(x)) {
    int y = x + 1;
} else {
    std::cout << "Variable 'x' not declared!" << std::endl;
}

对于原因宏的情况，我可以使用#ifdef x，但是如何对变量/函数进行相同的检查？

对于全局非 lambda 函数的情况，我根据重载函数解析计算出了下一个代码，但它需要使用基于辅助宏的全局定义（可以进一步简化吗？）：

在线尝试一下！

#include <iostream>
#include <type_traits>

#define declared_func_helper(x, ...) \
    struct NotDeclared; \
    template <typename ... Args> \
    NotDeclared x(Args ...); \
    template <typename ... Args> \
    inline constexpr bool declared_func_##x(Args && ... args) { \
        return !std::is_same_v<decltype(x(args...)), NotDeclared>; \ …