Умножение между большими целыми числами и удвоениями

это то, что вы хотели:

// BYTE lint[_N]   ... lint[0]=MSB, lint[_N-1]=LSB
void mul(BYTE *c,BYTE *a,double b)  // c[_N]=a[_N]*b
    {
    int i; DWORD cc;
    double q[_N+1],aa,bb;
    for (q[0]=0.0,i=0;i<_N;)        // mul,carry down
        {
        bb=double(a[i])*b; aa=floor(bb); bb-=aa;
        q[i]+=aa; i++;
        q[i]=bb*256.0;
        }
    cc=0; if (q[_N]>127.0) cc=1.0;  // round
    for (i=_N-1;i>=0;i--)           // carry up
        {
        double aa,bb;
        cc+=q[i];
        c[i]=cc&255;
        cc>>=8;
        }
    }

_N — это число битов/8 на большое целое, большое целое — это массив из _N BYTE, где первый байт — MSB (самый значащий BYTE), а последний BYTE — младший значащий BYTE (младший значащий BYTE) функция не обрабатывает сигнум, но это только один, если и немного xor/inc для добавления.

проблема в том, что double имеет низкую точность даже для вашего числа 1.23456789 !!! из-за потери точности результат не совсем такой, каким он должен быть (1234387129122386944 вместо 1234567890000000000). Я думаю, что мой код намного быстрее и даже точнее, чем ваш, потому что мне не нужно число mul/mod/div на 10, вместо этого я использую битовый сдвиг там, где это возможно, и не на 10 разрядов, а на 256 разрядов (8 бит). если вам нужна большая точность, чем использовать длинную арифметику. вы можете ускорить этот код, используя большие цифры (16,32, ... бит)

Моя длинная арифметика для точных астрономических вычислений обычно представляет собой 256,256-битные числа с фиксированной точкой, состоящие из 2 * 8 DWORD + signum, но, конечно, это намного медленнее, и некоторые гониометрические функции действительно сложно реализовать, но если вам нужны только базовые функции, чем кодируйте свой собственный лон арифметика не так уж сложна.

также, если вы хотите, чтобы числа часто были в читаемой форме, хорошо найти компромисс между скоростью/размером и рассмотреть возможность использования не двоично-кодированных чисел, а двоично-десятичных кодированных чисел.

Я не настолько знаком ни с C++, ни с GMP, чтобы предложить исходный код без синтаксических ошибок, но то, что вы делаете, сложнее, чем должно, и может ввести ненужное приближение.

Вместо этого я предлагаю вам написать функцию mpz_mult_d() следующим образом:

mpz_mult_d(mpz_class & r, const mpz_class & i, double d) {
  d = ldexp(d, 52); /* exact, no overflow because 1 <= d <= 10 */
  unsigned long long l = d; /* exact because d is an integer */
  p = l * i; /* exact, in GMP */
  (quotient, remainder) = p / 2^52; /* in GMP */

И теперь следующий шаг зависит от того, какое округление вы хотите. Если вы хотите, чтобы умножение d на i дало результат, округленный в сторону -inf, просто верните quotient в качестве результата функции. Если вы хотите, чтобы результат был округлен до ближайшего целого числа, вы должны посмотреть на remainder:

 assert(0 <= remainder);  /* proper Euclidean division */
 assert(remainder < 2^52);
 if (remainder < 2^51) return quotient;
 if (remainder > 2^51) return quotient + 1; /* in GMP */
 if (remainder == 2^51) return quotient + (quotient & 1); /* in GMP, round to “even” */

PS: я нашел ваш вопрос случайным образом, но если бы вы пометили его как «с плавающей запятой», люди, более компетентные, чем я, могли бы быстро ответить на него.

Попробуйте эту стратегию:

1. Преобразование целочисленного значения в большое число с плавающей запятой
2. Преобразовать двойное значение в большое число с плавающей запятой
3. Сделать продукт

4. Преобразовать результат в целое число

   mpf_set_z(...)
   mpf_set_d(...)
   mpf_mul(...)
   mpz_set_f(...)