标签: integer-division

我对python中的以下整数数学感到困惑:

-7/3 = -3自从(-3)*3 = -9 < -7.我明白.

7/-3 = -3我不明白这是如何定义的.(-3)*(-3) = 9 > 7.在我看来,它应该是-2,因为(-3)*(-2) = 6 < 7.

这是如何运作的？

我知道如果数字都是正数,则整数除法将始终返回与浮点结果截断相同的答案.如果其中一个或两个都是否定的,这是真的吗？

我只是想知道是否有一个整数除法表达式会在Python 2和Python 3中返回相同的结果(是的,我知道from __future__ import division).

PS让我们暂时忽略浮点溢出.

在 C 中可以进行楼层划分，例如：

int floor_div(int a, int b) {
    int d = a / b;
    if (a < 0 != b < 0) {  /* negative output (check inputs since 'd' isn't floored) */
        if (d * a != b) {  /* avoid modulo, use multiply instead */
            d -= 1;        /* floor */
        }
    }
    return d;
}

但这似乎可以简化。

在 C 中有没有更有效的方法来做到这一点？

请注意，这几乎与这个问题相反：C/C++ 中整数除法的快速上限

是否有一个 checkstyle 规则可以捕获这样的内容：

double result = someInt / someOtherInt;

result 是 double （所以显然需要分数）但右侧会进行整数除法（向下取整）。

这样的东西存在吗？

我想计算 x/y，其中 x 和 y 都是有符号整数，并将结果四舍五入到最接近的整数。具体来说，我想要一个rquotient(x, y)仅使用整数算术的函数，以便：

ASSERT(rquotient(59, 4) == 15);
ASSERT(rquotient(59, -4) == -15);
ASSERT(rquotient(-59, 4) == -15);
ASSERT(rquotient(-59, -4) == 15);

ASSERT(rquotient(57, 4) == 14);
ASSERT(rquotient(57, -4) == -14);
ASSERT(rquotient(-57, 4) == -14);
ASSERT(rquotient(-57, -4) == 14);

我已经向 SO 寻求解决方案，并发现以下内容（每个都有自己的缺点）：

• 舍入整数除法（而不是截断）（仅向上舍入）
• 带舍入的整数除法（仅正 x 和 y）
• 整数除法舍入（仅正 x 和 y）
• 整数除法，四舍五入（仅正 y，但评论中的一个好建议）
• C ++中带有负数的整数除法舍入（关于标准的问题，而不是解决方案）

我听说当处理器执行 / 或 % 时，它将执行相同的操作，但以一种方式返回商，另一种方式返回余数。

是否可以在一次操作中同时获得两者？也许如果我加入一段汇编代码（我从未做过）？

我有一个128位数字存储为2个64位数字("Hi"和"Lo").我只需要将它除以32位数.我怎么能这样做,使用CPU的本机64位操作？

(请注意,我不需要任意精度库.只需要知道如何使用本机操作进行这种简单的划分.谢谢).

请考虑以下内容作为参考实现:

/* calculates (a * b) / c */
uint32_t muldiv(uint32_t a, uint32_t b, uint32_t c)
{
    uint64_t x = a;
    x = x * b;
    x = x / c;
    return x;
}

我感兴趣的是一个不需要64位整数类型的实现(在C或伪代码中).

我开始草拟一个如下概述的实现:

/* calculates (a * b) / c */
uint32_t muldiv(uint32_t a, uint32_t b, uint32_t c)
{
    uint32_t d1, d2, d1d2;
    d1 = (1 << 10);
    d2 = (1 << 10);
    d1d2 = (1 << 20); /* d1 * d2 */
    return ((a / d1) …

在c ++和python编程语言中,非正数除法是完全不同的:

//c++:
11 / 3 = 3
11 % 3 = 2
(-11) / 3 = -3
(-11) % 3 = -2
11 / (-3) = -3
11 % (-3) = 2
(-11) / (-3) = 3
(-11) % (-3) = -2

所以,正如你所看到的,c ++正在最小化商.但是,python的行为如下:

#python
11 / 3 = 3
11 % 3 = 2
(-11) / 3 = -4
(-11) % 3 = 1
11 / (-3) = -4
11 % (-3) = -1
(-11) / (-3) = …

你可以这样写:

int i = 3;
int k = 2;
int division = i / k;
int remainder = i % k;

似乎认为这将在低级别上要求ALU执行两个视觉操作:一个返回商,一个返回余数.但是,我相信ALU最有可能在一次操作中计算两者.如果是这种情况,这不是最佳效率.

是否有更有效的方法,而不要求CPU计算两次？换句话说,它可以在C++的单个操作中完成吗？