钳制真实(固定/浮点)值的最快方法? [英] Fastest way to clamp a real (fixed/floating point) value?
问题描述
有没有比使用 if 语句或三元运算符更有效的方法来限制实数?我想为双打和 32 位定点实现 (16.16) 执行此操作.我不是要求可以处理这两种情况的代码;它们将在单独的函数中处理.
Is there a more efficient way to clamp real numbers than using if statements or ternary operators? I want to do this both for doubles and for a 32-bit fixpoint implementation (16.16). I'm not asking for code that can handle both cases; they will be handled in separate functions.
显然,我可以这样做:
double clampedA;
double a = calculate();
clampedA = a > MY_MAX ? MY_MAX : a;
clampedA = a < MY_MIN ? MY_MIN : a;
或
double a = calculate();
double clampedA = a;
if(clampedA > MY_MAX)
clampedA = MY_MAX;
else if(clampedA < MY_MIN)
clampedA = MY_MIN;
固定点版本将使用函数/宏进行比较.
The fixpoint version would use functions/macros for comparisons.
这是在代码的性能关键部分完成的,所以我正在寻找一种尽可能有效的方法来做到这一点(我怀疑这会涉及位操作)
This is done in a performance-critical part of the code, so I'm looking for an as efficient way to do it as possible (which I suspect would involve bit-manipulation)
它必须是标准/可移植的 C,平台特定的功能在这里没有任何意义.此外,MY_MIN
和 MY_MAX
与我想要限制的值的类型相同(在上面的示例中为双精度值).
It has to be standard/portable C, platform-specific functionality is not of any interest here. Also, MY_MIN
and MY_MAX
are the same type as the value I want clamped (doubles in the examples above).
推荐答案
对于 16.16 表示,简单的三进制不太可能在速度方面得到改善.
For the 16.16 representation, the simple ternary is unlikely to be bettered speed-wise.
对于双打,因为您需要标准/便携式 C,所以任何类型的位摆弄都会以糟糕的方式结束.
And for doubles, because you need it standard/portable C, bit-fiddling of any kind will end badly.
即使可能有一些小技巧(我对此表示怀疑),你也会依赖双精度的二进制表示.这(及其大小)取决于实施.
Even if a bit-fiddle was possible (which I doubt), you'd be relying on the binary representation of doubles. THIS (and their size) IS IMPLEMENTATION-DEPENDENT.
您可能可以使用 sizeof(double) 来猜测"这一点,然后将各种 double 值的布局与其常见的二进制表示形式进行比较,但我认为您对此一无所知.
Possibly you could "guess" this using sizeof(double) and then comparing the layout of various double values against their common binary representations, but I think you're on a hiding to nothing.
最好的规则是告诉编译器你想要什么(即三元),然后让它为你优化.
The best rule is TELL THE COMPILER WHAT YOU WANT (ie ternary), and let it optimise for you.
谦虚的馅饼时间.我刚刚测试了 quinmars 的想法(如下),它可以工作 - 如果你有 IEEE-754 浮点数.这给下面的代码带来了大约 20% 的加速.IObviously 不可移植,但我认为可能有一种标准化的方式来询问您的编译器是否使用带有#IF 的 IEEE754 浮点格式...?
Humble pie time. I just tested quinmars idea (below), and it works - if you have IEEE-754 floats. This gave a speedup of about 20% on the code below. IObviously non-portable, but I think there may be a standardised way of asking your compiler if it uses IEEE754 float formats with a #IF...?
double FMIN = 3.13;
double FMAX = 300.44;
double FVAL[10] = {-100, 0.23, 1.24, 3.00, 3.5, 30.5, 50 ,100.22 ,200.22, 30000};
uint64 Lfmin = *(uint64 *)&FMIN;
uint64 Lfmax = *(uint64 *)&FMAX;
DWORD start = GetTickCount();
for (int j=0; j<10000000; ++j)
{
uint64 * pfvalue = (uint64 *)&FVAL[0];
for (int i=0; i<10; ++i)
*pfvalue++ = (*pfvalue < Lfmin) ? Lfmin : (*pfvalue > Lfmax) ? Lfmax : *pfvalue;
}
volatile DWORD hacktime = GetTickCount() - start;
for (int j=0; j<10000000; ++j)
{
double * pfvalue = &FVAL[0];
for (int i=0; i<10; ++i)
*pfvalue++ = (*pfvalue < FMIN) ? FMIN : (*pfvalue > FMAX) ? FMAX : *pfvalue;
}
volatile DWORD normaltime = GetTickCount() - (start + hacktime);
这篇关于钳制真实(固定/浮点)值的最快方法?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!