小编Vin*_*ent的帖子

当我为小数学向量实现模板化类时,我遇到了一个问题.对于算术运算,返回类型T1 lhs + T2 rhs是std::common_type<T1, T2>::type. 但是以下的返回类型是什么(例如T1签名和T2无符号或相反,或T1 char和T2 unsigned long long int等...):

T1 lhs & T2 rhs ?
T1 lhs | T2 rhs ?
T1 lhs ^ T2 rhs ?
T1 lhs << T2 rhs ?
T1 lhs >> T2 rhs ?

非常感谢你.

我想为MyClass一个参数编写一个构造函数,我希望只有在参数为a pointer或iterator(具有某些东西iterator_traits)的情况下才能编译.怎么做到这一点？

如果我们看一下C语言的委员会草案:n1570 ,特别是Annex G关于复杂数学函数的行为,我们可以看到复指数在无穷大处有以下行为:

cexp(+infinity+I*infinity)=+/-infinity+I*NaN
(where the sign of the real part of the result is unspecified).

我的问题是:为什么？

从数学的角度来看,如果我们以相同的方式接近实部和虚部的无穷大,则限制是复数无穷大(例如参见Wolfram Alpha),它对应于无限模数和未定义的参数.

此外,如果我们查看cexp函数的行为,它的实部和虚部非常可比(参见Wolfram Alpha上的3D图).

所以,我原以为:

cexp(+infinity+I*infinity)=+/-infinity+/-I*infinity

代替:

cexp(+infinity+I*infinity)=+/-infinity+I*NaN

我知道有一个很好的理由,但我不明白.有人能解释一下这背后的逻辑吗？

编辑:这里是链接的摘要:

目前我有两个numpy的数组:x与y相同尺寸的.

我想写一个函数(可能调用numpy/scipy ...函数,如果它们存在):

def derivative(x, y, n = 1):
    # something
    return result

其中result是的相同大小的numpy的阵列x和包含的值n的第衍生物y关于到x(我想要评价的衍生物使用若干值y,以避免非平滑结果).

考虑以下两点:

template <class Function>
void apply(Function&& function)
{
    std::forward<Function>(function)();
}

和

template <class Function>
void apply(Function&& function)
{
    function();
}

在什么情况下有差异,它有什么具体的区别？

考虑使用numpy数组的以下代码非常慢:

# Intersection of an octree and a trajectory
def intersection(octree, trajectory):
    # Initialize numpy arrays
    ox = octree.get("x")
    oy = octree.get("y")
    oz = octree.get("z")
    oe = octree.get("extent")/2
    tx = trajectory.get("x")
    ty = trajectory.get("y")
    tz = trajectory.get("z")
    result = np.zeros(np.size(ox))
    # Loop over elements
    for i in range(0, np.size(tx)):
        for j in range(0, np.size(ox)):
            if (tx[i] > ox[j]-oe[j] and 
                tx[i] < ox[j]+oe[j] and 
                ty[i] > oy[j]-oe[j] and 
                ty[i] < oy[j]+oe[j] and 
                tz[i] > oz[j]-oe[j] and 
                tz[i] < oz[j]+oe[j]):
                result[j] += …

我是一名数字物理学家,我在社区中看到了一些模拟代码,这些代码使用的是一个三维模拟框,其中心位于中心,[0.5, 0.5, 0.5]标准化长度为1(因此框坐标从中0.到1.).在此框中,执行了许多物理计算,通常需要尽可能高的精度.

我认为做这样的事情可以被视为一种缺陷,但我想得到确认.我倾向于认为这是一个缺陷,因为由于我们附近有更多的数值精度0.,所以在整个方框中数值精度没有很好地平衡.

为了获得良好的平衡,我认为这样一个盒子:

• 如果想要围绕盒子中心的对称精度,应该以0.(从-0.5到0.5)为中心
• 如果想要在整个盒子中获得准同质精度,那么应该以1.5(从1.到2.)为中心

我是正确还是完全错误？

在C ++中，标准和平台无关性（无论如何签名）都可以很好地定义将有符号整数值转换为可以有两种不同大小（例如：short intto unsigned long long int或long long intto unsigned char）的无符号整数值的结果。例如代表整数）？

SHLD/SHRD指令是用于实现多精度移位的汇编指令.

请考虑以下问题:

uint64_t array[4] = {/*something*/};
left_shift(array, 172);
right_shift(array, 172);

什么是实行最有效的方法left_shift和right_shift,经营4个64位无符号整数数组上的转变,就好像它是一个巨大的256位无符号整数两种功能？

最有效的方法是使用SHLD/SHRD指令,还是有更好的(如SIMD版本)现代架构指令？

请考虑以下代码:

#include <limits>
#include <cstdint>

using T = uint32_t; // or uint64_t

T shift(T x, T y, T n)
{
    return (x >> n) | (y << (std::numeric_limits<T>::digits - n));
}

根据godbolt,clang 3.8.1 为-O1,-O2,-O3生成以下汇编代码:

shift(unsigned int, unsigned int, unsigned int):
        movb    %dl, %cl
        shrdl   %cl, %esi, %edi
        movl    %edi, %eax
        retq

而gcc 6.2(即使有-mtune=haswell)生成:

shift(unsigned int, unsigned int, unsigned int):
    movl    $32, %ecx
    subl    %edx, %ecx
    sall    %cl, %esi
    movl    %edx, %ecx
    shrl    %cl, %edi …