是否可以简化这种基于分支的向量数学运算？

Question

我试图在 C++ 中实现类似以下内容：

class MyVector; // 3 component vector  class

MyVector const kA = /* ... */;
MyVector const kB = /* ... */;

MyVector const kC = /* ... */;
MyVector const kD = /* ... */;


// I'd like to shorten the remaining lines, ideally making it readable but less code/operations.
MyVector result = kA;

MyVector const kCMinusD = kC - kD;

if(kCMinusD.X <= 0)
{
    result.X = kB.X;
}

if(kCMinusD.Y <= 0)
{
    result.Y = kB.Y;
}

if(kCMinusD.Z <= 0)
{
    result.Z = kB.Z;
}

将代码解释为英语，我有四个“已知”向量。其中两个向量具有我在结果中可能想要也可能不想要的值，并且我是否想要它们取决于基于其他两个向量的分量的分支。

我觉得我应该能够通过一些矩阵数学和掩码来简化这段代码，但我无法理解它。

现在我将使用分支，但我很好奇是否有更好的方法仍然可以理解，并且代码更简洁。

编辑：

参考马克的评论，我将解释我在这里想做的事情。

这段代码是我正在研究的一些弹簧物理学的摘录。组成部分如下：

kC 为当前弹簧长度，kD 为最小弹簧长度。

kA 和kB 是两组弹簧张力，其每个分量对于每个分量可以是唯一的（即，沿X、Y或Z的不同弹簧张力）。 kA 是弹簧未完全压缩时的张力，kB 是弹簧完全压缩时的张力。

我想建立一个结果“向量”，它只是 kC 和 kD 的合并，取决于弹簧是否被压缩。

Answer 1

根据您所在的平台，编译器可能能够优化语句，例如

result.x = (kC.x > kD.x) ? kA.x : kB.x;
result.y = (kC.y > kD.y) ? kA.y : kB.y;
result.z = (kC.z > kD.z) ? kA.z : kB.z;

使用 fsel (浮点选择）指令或条件移动。就我个人而言，我认为这种方式代码看起来也更好、更简洁，但这是主观的。

如果代码确实对性能至关重要，并且您不介意将矢量类更改为 4 个浮点数而不是 3 个浮点数，则可以使用 SIMD（例如 Intel 平台上的 SSE、PowerPC 上的 VMX）进行比较并选择答案。如果您继续这样做，它会像这样：（伪代码）

// Set each component of mask to be either 0x0 or 0xFFFFFFFF depending on the comparison
MyVector4 mask = vec_compareLessThan(kC, kD);

// Sets each component of result to either kA or kB's component, depending on whether the bits are set in mask
result = vec_select(kA, kb, mask);

这需要一段时间来习惯，并且最初可能不太可读，但您最终会习惯以 SIMD 模式思考。

当然，通常的警告是适用的 - 在分析之前不要进行优化等。

Answer 2

如果你的向量元素是整数，你可以这样做：（

MyVector result;
MyVector const kCMinusD = kC - kD;
int mask = kCMinusD.X >> 31;  // either 0 or -1
result.X = (kB.X & mask) | (kCMinusD.X & ~mask)
mask = kCMinusD.Y >> 31;
result.X = (kB.Y & mask) | (kCMinusD.Y & ~mask)
mask = kCMinusD.Z >> 31;
result.X = (kB.Z & mask) | (kCMinusD.Z & ~mask)

注意这以不同的方式处理 == 0 的情况，不确定你是否关心）

如果你的向量元素是双精度而不是整数，你可以做类似的事情，因为符号位在同样的地方，您只需转换为整数，执行掩码，然后再转换回来。

Answer 3

如果您在源代码中寻求干净的表达式而不是运行时优化，您可能会考虑从“工具箱”的角度解决这个问题。假设您在 MyVector 上定义了 sign、gt（大于）和 le（小于或等于）。然后分为两行：

MyVector const kSignCMinusD = (kC - kD).sign();
result = kSignCMinusD.gt(0) * kA + kSignCMinusD.le(0) * kB;

使用运算符重载：

MyVector const kSignCMinusD = (kC - kD).sign();
result = (kSignCMinusD > 0) * kA + (kSignCMinusD <= 0) * kB;

为了获得灵感，这里是 MatLab函数参考。显然，有许多具有此类功能的 C++ 矢量库可供选择。

如果分析显示有必要，您随时可以进一步优化。但通常最大的性能问题是您能否很好地了解全局并重用中间计算。

Answer 4

由于您只进行减法，因此重写如下：

MyVector result;
result.x = kD.x > kC.x ? kB.x : kA.x;
result.y = kD.y > kC.y ? kB.y : kA.y;
result.z = kD.z > kC.z ? kB.z : kA.z;