我正在努力思考如何在 C 语言中仅使用带有移位运算和缩放的整数将 0..4096 乘以 0.3，不进行除法。我我是新手，任何输入或分步建议都会非常有帮助。
【问题讨论】：
[0, 4096]范围内的任何给定数字乘以0.3
简单地尝试了很多(A*x + B) >> n形式的组合与下面的测试代码并想出了：
// Scale by 4915, then shift 14.
int Mult3Tenths(int x) {
return (x*4915 + 0) >> 14; // Use 4915L if `int` is 16 bit.
}
测试代码
#define N3 (4096)
int main(void) {
int target[N3 + 1];
unsigned i;
for (i = 0; i <= N3; i++) {
target[i] = 0.3 * i;
}
// form (A*x + B) >> n
int A, B, n;
int besti = 0;
for (n = 0; n < 31; n++) {
int Amin = ((N3 * 0.3 - 1) * (1 << n) - (1 << n)) / N3 - 1;
int Amax = ((N3 * 0.3 + 1) * (1 << n) + (1 << n)) / N3 + 1;
for (A = Amin; A <= Amax; A++) {
int Bmax = 1 << n;
for (B = -Bmax; B <= Bmax; B++) {
for (i = 0; i <= N3; i++) {
int y = (A * i + B) >> n;
if (y != target[i])
break;
if (i > besti) {
besti = i;
if (i == N3) {
printf("i:%i A:%d B:%d n:%d\n", i, A, B, n);
printf("!!!\n");
exit(0);
}
}
}
}
}
}
printf("???\n");
return 0;
}
【讨论】：
乘以 0.3 与乘以 (0.3*2^n)，然后除以 2^n 相同。第二阶段相当于n右移。
但是n 的最佳值是多少？
要找到它，请取最大整数并找到n 的最大值，这样您就可以乘以(0.3*2^n) 而不会溢出。 64位无符号整数，最大值4096，需要
0.3*2^n <= 2^(64-12)
或
0.3 <= 2^(64-12-n)
当 RHS 等于 0.5 时，这个不等式最大 n，所以
2^-1 = 2^(64-12-n)
所以-1 = 64-12-n，n = 64-12+1 = 53。
所以答案是乘以2^53*0.3，然后右移53，即
/* designed to work with input values 0 .. 4096 only */
uint64_t
multiplyby0_3 (uint64_t x)
{
return (x * 2702159776422297ULL) >> 53;
}
检查没有溢出，我们有最好的n，来自bc：
2702159776422297*4096 = 11068046444225728512
2^64 = 18446744073709551616
IE它不会溢出，但如果我们再次将它乘以2，它就会溢出。
对于 32 位整数，答案是乘以 2^21*0.3 然后右移 21，即
/* designed to work with input values 0 .. 4096 only */
uint32_t
multiplyby0_3 (uint32_t x)
{
return (x * 629146U) >> 21;
}
最后，您可以通过查看乘法器中的二进制1 将任何乘法分解为多个加法。所以你允许 'scaling' 我认为这意味着乘法。如果没有，这里是 32 位版本（留给读者练习的 64 位版本）利用了 629146 是 10011001100110011010 的事实（由于重复出现二进制分数，这是一个简洁的模式）。我们将反过来使用10011001100110011001。
/* designed to work with input values 0 .. 4096 only */
uint32_t
multiplyby0_3 (uint32_t x)
{
uint32_t y;
x += x<<3; /* * 1001 */
y = x<<4 + x; /* * 10011001 */
y += y<<8; /* * 1001100110011001 */
y += x<<16; /* * 10011001100110011001 */
return y >> 21;
}
【讨论】：
629146ULL 更改为 629146U 以便您只使用 32 位算术，那么就可以了。
我知道这不是一个编码示例，对此感到抱歉，但如果集合如此之小（范围 [0;4096]），为什么不创建一个结果块并使用指针来提取值呢？它将大大减少 GPU 周期，因为没有内存限制。
【讨论】：
对下面的divu10() 使用经典破解。我更喜欢 *n 和 shift 方法，但我认为我提供了另一个 POV。
unsigned mult3tenths(unsigned x) {
return divu10(x*3);
}
unsigned divu10(unsigned n) {
unsigned q, rem;
q = (n >> 1) + (n >> 2);
q = q + (q >> 4);
q = q + (q >> 8);
q = q + (q >> 16);
q = q >> 3;
rem = n - q*10;
return q + ((rem + 6) >> 4);
}
【讨论】：
div10(x+(x<<1)) 和后来的 rem=n-(q<<3)-(q<<1) 只是为了消除所有乘法:-)
x*3 或x+(x<<1) 并生成相同的代码。
如果你有快速整数乘法，但你没有整数除法，你可以通过乘以 1229，然后右移 12 位得到一个合理的近似值。例如：
>> 100 * 1229
122900
>> 122900 >> 12
30
这是有效的，因为 1229 大约是 0.3 * 1 << 12。 “真实”值是 1228.8，因此在某些情况下估计值会高 1（4097 个值中有 68 个）。不过，它的偏差永远不会超过 1。
【讨论】：
1229 * 4096 = 5033984。这完全在 32 位整数的范围内；如果你需要保持在 16 位以内，那就有点困难了。