如何在不使用 long long 的情况下将 64 位 unsigned int 与 C 上的 32 位 unsigned int 相乘？

Question

如何在不使用long long 的情况下将 64 位无符号整数与 32 位无符号整数相乘。 64 位数字存储为两个 32 位数字的数组。

换句话说，我怎样才能从a、b 和b 和c 获得e 和f 给定以下条件：

( a * 2^32 + b ) * c = e * 2^32 + f

a、b、c、e 和 f 都是 32 位无符号整数，只能进行 32 位数学运算。

Answer 1

首先要实现的是，我们将获得一个 96 位的数字，如下所示：

(2⁶⁴ - 1) × (2³² - 1)
= 2⁶⁴ × 2³² - 2⁶⁴ - 2³² + 1
= 2⁹⁶ - 2⁶⁴ - 2³² + 1
96

接下来要意识到的是，我们不能使用 32 位乘法。即使没有进位，结果也太大了。

(2³² - 1) × (2³² - 1)
= 2³² × 2³² - 2³² - 2³² + 1
= 2⁶⁴ - 2³³ + 1
≥2³²

我们需要改为执行 16 位乘法。 16 位乘法可以使用 32 位数字完成，而不会溢出，即使使用 16 位进位也是如此。

FFFF₁₆ × FFFF₁₆ + FFFF₁₆
= FFFF_0000₁₆
32

如果我们将数字视为 16 位值，则乘法如下：

                  +-----+-----+-----+-----+
                  | ahi | alo | bhi | blo |
                  +-----+-----+-----+-----+

                              +-----+-----+
                           ×  | chi | clo |
                              +-----+-----+

===========================================

      +-----+-----+-----+-----+-----+-----+
      | dhi | dlo | ehi | elo | fhi | flo |
      +-----+-----+-----+-----+-----+-----+

上面的乘法从小学就知道了，对吧？

      +-----+-----+-----+-----+     +-----+
      | ahi | alo | bhi | blo |  ×  | clo |
      +-----+-----+-----+-----+     +-----+

      +-----+-----+-----+-----+-----+     +-----+
   +  | ahi | alo | bhi | blo |  0  |  ×  | chi |
      +-----+-----+-----+-----+-----+     +-----+

表示以下是我们需要的所有工具：

void mul16c(
   uint16_t i, uint16_t j, uint16_t cin,
   uint16_t *prod_ptr, uint16_t *cout_ptr
) {
   uint32_t prod = i * j + cin;
   *prod_ptr = prod & 0xFFFF:
   *cout_ptr = prod >> 16;
}

void add16c(
   uint16_t i, uint16_t j, uint16_t cin,
   uint16_t *sum_ptr, uint16_t* cout_ptr
) {
   uint32_t sum = i + j + cin;
   *sum_ptr = sum & 0xFFFF:
   *cout_ptr = sum >> 16;
}

我们可以按如下方式使用它们：

void mul64x32(
   uint32_t i[2], uint32_t j,
   uint32_t (*prod_ptr)[2], uint32_t *cout_ptr
) {
   uint16_t i16[4];
   i16[3] = i[1] >> 16;
   i16[2] = i[1] & 0xFFFF;
   i16[1] = i[0] >> 16;
   i16[0] = i[0] & 0xFFFF;

   uint16_t j16[2];
   j16[1] = j[0] >> 16;
   j16[0] = j[0] & 0xFFFF;

   uint16_t p[6];
   {
      uint16_t carry = 0;
      mul16c(i16[0], j16[0], carry, &(p[0]), &carry);
      mul16c(i16[1], j16[0], carry, &(p[1]), &carry);
      mul16c(i16[2], j16[0], carry, &(p[2]), &carry);
      mul16c(i16[3], j16[0], carry, &(p[3]), &carry);
      p[4] = carry;
      p[5] = 0;
   }

   uint16_t q[6];
   {
      uint16_t carry = 0;
      q[0] = 0;
      mul16c(i16[0], j16[1], carry, &(q[1]), &carry);
      mul16c(i16[1], j16[1], carry, &(q[2]), &carry);
      mul16c(i16[2], j16[1], carry, &(q[3]), &carry);
      mul16c(i16[3], j16[1], carry, &(q[4]), &carry);
      q[5] = carry;
   }

   uint16_t product[6];
   {
      uint16_t carry = 0;
      add16c(p[0], q[0], carry, &(product[0]), &carry);
      add16c(p[1], q[1], carry, &(product[1]), &carry);
      add16c(p[2], q[2], carry, &(product[2]), &carry);
      add16c(p[3], q[3], carry, &(product[3]), &carry);
      add16c(p[4], q[4], carry, &(product[4]), &carry);
      add16c(p[5], q[5], carry, &(product[5]), &carry);
   }

   (*prod_ptr)[0] = ( product[1] << 16 ) | product[0];
   (*prod_ptr)[1] = ( product[3] << 16 ) | product[2];
   *cout_ptr      = ( product[5] << 16 ) | product[4];
}

每个数组的元素零应该是数字的最低有效部分。