似乎每当我用一个负整数除以一个正整数时，我都需要它向下舍入 （向 -inf），而不是向 0。但 C# 和 C++ 都向 0 舍入。
所以我想我需要一个 DivideDownward() 方法。我可以用几行来写它，测试是否定的等等，但我的想法似乎很糟糕。所以我想知道我是否遗漏了什么，以及你是否有一种“优雅”的方式来向下舍入负除法。
【问题讨论】：
每当我将一个负整数除以一个正整数时，我都需要将它向下舍入。
这是地狱，不是吗？ Knuth 写了为什么这是做事的正确方法，但我们被传统的整数硬件所困。
如果您能承受精度损失，最简单和最干净的方法是将 32 位整数转换为 64 位 double 并使用 FP 舍入模式向负无穷大舍入当您将商转换回整数时。今天的浮点单元非常快，实际上可能比整数单元除法快；可以肯定的是，你必须测量。
如果您需要完整的 64 位整数精度，作为编译器编写者，我已经通过执行两个条件分支来处理这个问题，这样您就可以对幅度进行划分，然后得到正确的符号。但这是不久前条件分支与除法相比便宜的时候了。在今天的硬件上，我必须先进行试验，然后才能推荐一些东西。
原则上，您可以使用传统的英特尔 80 位浮点数在 64 位整数上提取浮点技巧，但它非常不可移植，我不相信英特尔会继续制作那个单位快。这些天浮点速度在 SSE 单元中。
寻找其他技巧的地方包括 Hank Warren 的书 Hacker's Delight（我的副本正在工作）和标准 ML 的 MLton 编译器，它需要整数除法以向负无穷舍入。
无论你做什么，当你确定它时，如果你使用的是 C++ 或 C99，请将你的除法例程粘贴到一个 .h 文件中并使其成为static inline。这样一来，当您的解决方案对于 5 年内交付的新 whizbang 硬件来说并不理想时，您可以在一个地方进行更改。
【讨论】：
假设 b 始终为正，这是一个便宜的解决方案：
inline int roundDownDivide(int a, int b) {
if (a >= 0) return a/b;
else return (a-b+1)/b;
}
【讨论】：
roundDownDivide(-2147483648, 2) == 1073741823 -- 如果a < INT_MIN + b - 1 会溢出，同时不是最快的。详细评估见我的回答。
您可以通过这样做摆脱任何分支：
inline int DivideRoundDown(int a_numerator, int a_denominator)
{
return (a_numerator / a_denominator) + ((a_numerator % a_denominator) >> 31);
}
【讨论】：
如果您想以相对简洁的方式仅使用整数来编写此代码，则可以这样编写：
var res = a / b - (a % b < 0 ? 1 : 0);
这可能编译成相当多的指令，但它可能仍然比使用浮点更快。
【讨论】：
a % b != 0 来概括它。
a % b 返回一个大于零的数字，则它需要返回 0（这就是为什么我在 C# 中需要 <）。
a 是否定的。所以我猜一个通用版本是：a /b - (a < 0 && a % b != 0 ? 1 : 0)
(a/b)*b + a%b == a 除非 b == 0，即使 / 和 % 返回的实际值是为负操作数定义的实现。如果内置 / 向 -inf 而不是 0 舍入，您的版本将失败。
警告：对于 a=-1 的输入，这篇文章会产生不正确的结果。请查看其他答案。 -摄像头
[c++]
这可能是您所说的“kludgey”的意思，但这是我想出的；）
int divideDown(int a, int b){
int r=a/b;
if (r<0 && r*b!=a)
return r-1;
return r;
}
在 if 语句中，我输入了 r
if (a<0 && b>0)
这与您的描述一致“似乎每当我将 负整数除以正整数时”。
【讨论】：
if (r<=0 && r*b!=a)吗？
许多编程语言，包括 C 和 C++ 的旧标准，都保证了除法规则，即
a = b * (a / b) + a % b
即使 a/b 和 a%b 的确切值未定义。[0] 这可以被利用来计算在许多语言和平台中使用（等价于）的所需结果以下代码：
int divF(int a, int b) { return a / b - (a % b < 0); }
这是来自@TomasPetricek 答案的版本。但是，它仅适用于b > 0！
以下代码适用于任何b != 0：[1]
int sign(int x) { return (x > 0) - (x < 0); }
int divF2(int a, int b) { return a / b - (sign(a % b) == -sign(b)); }
但是，四舍五入的除法（又名地板除法，又名Knuth 的除法）并不总是可取的。有人认为[2] 欧几里得除法是最常用的除法。 b > 0 向下取整，b < 0 向上取整。它具有很好的属性，即对于所有a 和b，兼容定义的余数的值始终为非负，与它们的符号无关。此外，它与二进制补码机器上的位移和掩码相一致，用于二次除数的幂。是的，计算起来也更快：
int divE(int a, int b) {
int c = a % b < 0;
return a / b + (b < 0 ? c : -c);
}
所有三个版本都在 amd64 上使用 clang -O3 生成无分支代码。但是，在二进制补码架构上，以下可能会稍微快一些：
int divE2(int a, int b) { return a / b + (-(a % b < 0) & (b < 0 ? 1 : -1)); }
divF:
cdq
idiv esi
sar edx, 31
add eax, edx
divF2:
cdq
idiv esi
xor ecx, ecx
test edx, edx
setg cl
sar edx, 31
add edx, ecx
xor ecx, ecx
test esi, esi
setg cl
shr esi, 31
sub esi, ecx
xor ecx, ecx
cmp edx, esi
sete cl
sub eax, ecx
Chazz:
cdq
idiv esi
test edx, edx
cmove edi, esi
xor edi, esi
sar edi, 31
add eax, edi
divE:
cdq
idiv esi
mov ecx, edx
shr ecx, 31
sar edx, 31
test esi, esi
cmovs edx, ecx
add eax, edx
divE2:
cdq
idiv esi
sar edx, 31
shr esi, 31
lea ecx, [rsi + rsi]
add ecx, -1
and ecx, edx
add eax, ecx
simple truncating division:
2464805950: 1.90 ns -- base
euclidean division:
2464831322: 2.13 ns -- divE
2464831322: 2.13 ns -- divE2
round to -inf for all b:
1965111352: 2.58 ns -- Chazz
1965111352: 2.64 ns -- divF2
1965111352: 5.02 ns -- Warty
round to -inf for b > 0, broken for b < 0:
1965143330: 2.13 ns -- ben135
1965143330: 2.13 ns -- divF
1965143330: 2.13 ns -- Tomas
4112595000: 5.79 ns -- runevision
round to -inf, broken for b < 0 or some edge-cases:
4112315315: 2.24 ns -- DrAltan
1965115133: 2.45 ns -- Cam
1965111351: 7.76 ns -- LegsDrivenCat
在 FreeBSD 12.2 上使用 clang -O3 编译，i7-8700K CPU @ 3.70GHz。第一列是产生相同结果的校验和分组算法。 base 是用于衡量测试开销的最简单的截断除法。
试验台：
static const int N = 1000000000;
int rng[N][2], nrng;
void push(int a, int b) { rng[nrng][0] = a, rng[nrng][1] = b, ++nrng; }
SN_NOINLINE void test_case(int (*func)(), const char *name) {
struct timespec t0, t1;
clock_gettime(CLOCK_PROF, &t0);
int sum = func();
clock_gettime(CLOCK_PROF, &t1);
double elapsed = (t1.tv_sec - t0.tv_sec)*1.e9 + (t1.tv_nsec - t0.tv_nsec);
printf("%10u: %5.2f ns -- %s\n", sum, elapsed/N, name);
}
#define ALL_TESTS(X) X(base) X(divF) X(divF2) X(divE) X(divE2) X(ben135) X(DrAltan) X(Cam) X(Tomas) X(Warty) X(Chazz) X(runevision) X(LegsDrivenCat)
#define LOOP_TEST(X) \
SN_NOINLINE int loop_##X() { \
int sum = 0; \
for(int i = 0; i < N; ++i) sum += X(rng[i][0], rng[i][1]); \
return sum; \
} \
/**/
ALL_TESTS(LOOP_TEST)
int main() {
srandom(6283185);
push(INT_MAX, 1); push(INT_MAX, -1); push(INT_MIN, 1);
push(INT_MAX, 2); push(INT_MAX, -2); push(INT_MIN, 2); push(INT_MIN, -2);
while(nrng < N) {
int a = random() - 0x40000000, b;
do b = (random() >> 16) - 0x4000; while(b == 0);
push(a,b);
}
#define CALL_TEST(X) test_case(loop_##X, #X);
ALL_TESTS(CALL_TEST)
}
【讨论】：
Math.Floor((double)a/(double)b)
如果你需要它作为一个 int，之后再转换它(int)Math.Floor((double)a/(double)b)
【讨论】：
decimal 是slowest 数字类型，它不会在此处添加任何内容。 float 或 double 会更合适。
对于 2 的幂，取决于您的编译器实现 (Visual Studio)，您可以使用右移。
-5 >> 2 == -2
【讨论】：
这是一个在除数为负数时有效的版本：
int floor_div2(int a, int b)
{
int rem = a % b;
int div = a/b;
if (!rem)
a = b;
int sub = a ^ b;
sub >>= 31;
return div+sub;
}
【讨论】：
上面的 Atlans 博士解决方案是最普遍的答案，但如果您知道 a 不会小于某个固定数字，您可以添加 b 的最小倍数，使其成为正数，然后调整结果。例如，如果 a 始终 >= -10 * b，您可以说：
return (a + 10 * b) / b - 10
或者如果您只想要 a 为正数或 0 时的正确结果，而当 a 为负数时 some 为负数（例如，用于测试结果是否 >= 0 而不包括范围 a = [ -1 ; -b +1]) 你可以这样做
return (a + b) / b - 1;
这将为 [-1 , -b + 1] 以及 [-b ] 返回 -1 ； -2 * b + 1]，但如果你只是想确定除法的结果是否为正，这并不重要。实际上，我们只是更改了舍入，使其向 -1 而不是 0 舍入。
【讨论】：
我不是低级优化方面的专家，但这里有一个没有分支（条件）的版本，它也不需要转换为浮点数。在 C# 中测试，它似乎比使用分支的版本快得多。
return (a - (((a % b) + b) % b)) / b;
这个解决方案部分来源于关于如何为负数做最佳模函数的讨论：Modulo of negative numbers
【讨论】：
编辑：我的解决方案并非在所有情况下都有效。这是Dr.Atlan's解决方案的C#实现：
/// <summary>
/// Divides a/b, rounding negative numbers towards -Inf.
/// </summary>
/// <param name="a">Dividend</param>
/// <param name="b">Divisor; must be positive for correct results</param>
/// <returns>a ÷ b</returns>
public static int Div(int a, int b)
{
return a < 0 ? (a - b + 1) / b : a / b;
}
【讨论】：
Div(-1, 1) 返回 -2。
通过偏移 2^31 以 unsigned long 进行计算，例如：
int floor_div(int a, int b)
{
unsigned long aa = a + (1UL << 31);
unsigned long cc = (aa / b) - (1UL << 31);
return (int)cc
}
我还没有测试过。
【讨论】：
floor_div(6, 2) == -1431655764? O.o 这家伙应该获得“此页面上最糟糕的解决方案”的徽章。
我是这样做的（只有一个除法，没有乘法，没有模，看起来是最快的解决方案）：
(a < 0 && b > 0) ? (a - b + 1) / b : (a > 0 && b < 0) ? (a - b - 1) / b : a / b
我很好奇什么更快：更少的分支或更少的乘法/除法/模数，所以我将我的解决方案与 runevision 的解决方案进行了比较，在这种特殊情况下，更少的除法比更少的分支更好。 ben135 的解决方案在某些情况下会给出不正确的结果（例如 10/-3 给出 -3 但应该是 -4）。
【讨论】：