小编pla*_*cel的帖子

我想将两个__m128值组合成一个__m256.

像这样的东西:

__m128 a = _mm_set_ps(1, 2, 3, 4);
__m128 b = _mm_set_ps(5, 6, 7, 8);

类似于:

__m256 c = { 1, 2, 3, 4, 5, 6, 7, 8 };

我可以使用任何内在函数来做到这一点吗？

我正在使用带有Ninja生成器的Windows上的CMake

cmake -G Ninja ..

这使用默认的Windows x86工具链.如何使用Ninja生成器指定x64？

PS:我知道如何使用Visual Studio生成x64

cmake -G "Visual Studio 12 2013 Win64 ..

IEEE 754浮点除法的可逆性是什么？我的意思是它是否由标准保证,如果double y = 1.0 / x那时x == 1.0 / y,即x可以一点一滴地精确恢复？

当案件y是infinity或NaN有明显的例外.

是否有任何聪明的位技巧来检测是否有少数整数(比如3或4)具有特定值？

直截了当

bool test(int a, int b, int c, int d)
{
    // The compiler will pretty likely optimize it to (a == d | b == d | c == d)
    return (a == d || b == d || c == d);
}

在GCC汇编到

test(int, int, int, int):
        cmp     ecx, esi
        sete    al
        cmp     ecx, edx
        sete    dl
        or      eax, edx
        cmp     edi, ecx
        sete    dl
        or      eax, edx
        ret

这些sete指令有较高的延迟比我要忍受,所以我宁愿用一些按位(&,|,^ …

我当时正在处理四个像素的图像,这armv7适用于Android应用程序.

我想float32x4_t用另一个向量来划分一个向量,但是它中的数字从大约0.7到有不同,在3.85我看来,除法的唯一方法是使用右移,但这是一个数字2^n.

此外,我是新手,所以欢迎任何建设性的帮助或评论.

例:

如何使用NEON内在函数执行这些操作？

float32x4_t a = {25.3,34.1,11.0,25.1};
float32x4_t b = {1.2,3.5,2.5,2.0};
//    somthing like this
float32x4 resultado = a/b; // {21.08,9.74,4.4,12.55}

如果我复制从一个FBO像素到另一个和他们每个人都有颜色附件的多个(不必是相同的号码),如果我的面具是GL_COLOR_BUFFER_BIT,哪种颜色的附件(GL_COLOR_ATTACHMENT0,GL_COLOR_ATTACHMENT1,..., GL_COLOR_ATTACHMENTi)它复制？他们都是？如果是,如果这些FBO附加了不同数量的颜色缓冲区怎么办？

假设有2个FBO以这种方式绑定:

glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo1); 
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo2); 

请注意,它fbo1有2个颜色附件,并fbo2有4个颜色附件.

那么glBlitFrameBuffer在这种情况下如何将blit颜色附件？

我无法在OpenGL文档中的任何地方找到它.

我已经设法实现了二次和三次Bezier曲线.因为我们有一个公式,所以非常简单.现在我想用泛化表示一个n阶贝塞尔曲线:

哪里

和

我正在使用位图库来渲染输出,所以这是我的代码:

// binomialCoef(n, k) = (factorial(n) / (factorial(k) * factorial(n- k)))
unsigned int binomialCoef(unsigned int n, const unsigned int k)
{
    unsigned int r = 1;

    if(k > n)
        return 0;

    for(unsigned int d = 1; d <= k; d++)
    {
        r *= n--;
        r /= d;
    }

    return r;
}

void nBezierCurve(Bitmap* obj, const Point* p, const unsigned int nbPoint, float steps, const unsigned char red, const unsigned char green, const unsigned char blue)
{
    int …

我正在寻找其他人的代码,目前正试图弄清楚为什么_mm_load_si128存在.

基本上,我尝试更换

_ra = _mm_load_si128(reinterpret_cast<__m128i*>(&cd->data[idx]));

同

_ra = *reinterpret_cast<__m128i*>(&cd->data[idx]);

它的工作原理和表现完全相同.

我认为为了方便起见,较小类型存在加载函数,因此人们不必手动将它们打包到连续内存中,但对于已经按正确顺序排列的数据,为什么要这么麻烦？

还有别的_mm_load_si128吗？或者它本质上只是一种分配价值的迂回方式？

我在一次采访中被问到了这个问题,它让我付出了一份工作:P面试官问道,你将获得一棵树的根,你必须将根返回复制的树,但副本应该是以迭代的方式.我在这里粘贴我的代码,我在那里写了相同的,它工作正常.我最初使用两个堆栈来做这个,面试官说他不喜欢,然后我用以下方式做到了.面试官对我使用另一个包含指向原始和最终树的指针的结构有点不满(参考代码).

我想知道是否还有其他更好的方法吗？

struct node
{
   int data;
   struct node * left;
   struct node * right;
};

struct copynode
{
   node * original;
   node * final;
};

node * copy(node *root)
{
    stack <copynode*> s;
    copynode * temp=(copynode*)malloc(sizeof(copynode));
    temp->original=root;
    temp->final=(node *)malloc(sizeof(node));
    s.push(temp);
    while(s.empty()==false)
    {
       copynode * i;
       i=s.top();
       s.pop();
       i->final=i->original;
       if(i->original->left)
       {
          copynode *left=(copynode*)malloc(sizeof(copynode));
          left->original=i->original->left;
          left->final=(node *)malloc(sizeof(node));
          s.push(left);
       }
       if(i->original->right)
       {
          copynode *right=(copynode*)malloc(sizeof(copynode));
          right->original=i->original->right;
          right->final=(node *)malloc(sizeof(node));
          s.push(right);
       }
   }  
   return temp->final;
}

给定struct B,它从以下位置继承匿名union数据成员struct A:

#include <cstddef>

struct A
{
    union
    {
        struct { int a, b, c; };
        int vals[3];
    };
};

struct B: A
{
    constexpr B(int x)
    :
        A{{{ x, x, x }}}
    {}

    constexpr int& operator[](size_t i)
    {
        return this->vals[i];
    }

    constexpr const int& operator[](size_t i) const
    {
        return this->vals[i];
    }
};

我声明一个constexpr类型的变量B,然后调用它将operator[]返回值赋给constexpr int:

int main()
{
    constexpr B b(7);
    constexpr int i = …