Як уникнути переповнення в expr. А Б В Г

Мені потрібно обчислити вираз, який виглядає так:, A*B - C*Dде їх типи: signed long long int A, B, C, D; кожне число може бути дійсно великим (не переповнюючи його тип). Хоча це A*Bможе спричинити переповнення, в той же час вираження A*B - C*Dможе бути дуже малим. Як я можу правильно її обчислити?

Наприклад: MAX * MAX - (MAX - 1) * (MAX + 1) == 1де MAX = LLONG_MAX - nі n - деяке натуральне число.

Здається, це здається занадто банальним. Але A*Bце той, який міг би переповнитись.

Ви можете зробити наступне, не втрачаючи точності

A*B - C*D = A(D+E) - (A+F)D
          = AD + AE - AD - DF
          = AE - DF
             ^smaller quantities E & F

E = B - D (hence, far smaller than B)
F = C - A (hence, far smaller than C)

Це розкладання можна зробити і далі .
Як зазначав @Gian, під час операції віднімання, можливо, потрібно буде бути обережним, якщо тип довго не підписується.

Наприклад, у випадку, який ви маєте в запитанні, потрібно лише одну ітерацію,

 MAX * MAX - (MAX - 1) * (MAX + 1)
  A     B       C           D

E = B - D = -1
F = C - A = -1

AE - DF = {MAX * -1} - {(MAX + 1) * -1} = -MAX + MAX + 1 = 1

Найпростішим і найзагальнішим рішенням є використання представлення, яке не може переповнювати, або за допомогою довгої цілочисельної бібліотеки (наприклад, http://gmplib.org/ ), або представляючи за допомогою структури або масиву та впроваджуючи вид довгого множення ( тобто розділення кожного числа на дві 32-бітні половинки і виконання множення, як показано нижче:

(R1 + R2 * 2^32 + R3 * 2^64 + R4 * 2^96) = R = A*B = (A1 + A2 * 2^32) * (B1 + B2 * 2^32) 
R1 = (A1*B1) % 2^32
R2 = ((A1*B1) / 2^32 + (A1*B2) % 2^32 + (A2*B1) % 2^32) % 2^32
R3 = (((A1*B1) / 2^32 + (A1*B2) % 2^32 + (A2*B1) % 2^32) / 2^32 + (A1*B2) / 2^32 + (A2*B1) / 2^32 + (A2*B2) % 2^32) %2^32
R4 = ((((A1*B1) / 2^32 + (A1*B2) % 2^32 + (A2*B1) % 2^32) / 2^32 + (A1*B2) / 2^32 + (A2*B1) / 2^32 + (A2*B2) % 2^32) / 2^32) + (A2*B2) / 2^32

Якщо припустити, що кінцевий результат відповідає 64 бітам, вам насправді не потрібні більшість біт R3 і жоден з R4

Зауважте, що це не є стандартним, оскільки воно покладається на обтікання підписом-підписом. (GCC має прапори компілятора, які це дозволяють.)

Але якщо ви просто зробите всі обчислення long long, результат прямого застосування формули:
(A * B - C * D)буде точним, доки правильний результат впишеться в a long long.

Ось обхід, який покладається лише на визначену реалізацією поведінку викидання непідписаного цілого числа до підписаного цілого числа. Але це, як можна очікувати, буде працювати майже в кожній системі сьогодні.

(long long)((unsigned long long)A * B - (unsigned long long)C * D)

Це відкидає вхідні дані, unsigned long longде стандартна нормально гарантовано перекриває поведінку переливу. Повернення до підписаного цілого числа в кінці - це частина, визначена реалізацією, але сьогодні буде працювати майже в усіх середовищах.

Якщо вам потрібно більш педантичне рішення, я думаю, вам доведеться використовувати "довгу арифметику"

Це має працювати (я думаю):

signed long long int a = 0x7ffffffffffffffd;
signed long long int b = 0x7ffffffffffffffd;
signed long long int c = 0x7ffffffffffffffc;
signed long long int d = 0x7ffffffffffffffe;
signed long long int bd = b / d;
signed long long int bdmod = b % d;
signed long long int ca = c / a;
signed long long int camod = c % a;
signed long long int x = (bd - ca) * a * d - (camod * d - bdmod * a);

Ось моє виведення:

x = a * b - c * d
x / (a * d) = (a * b - c * d) / (a * d)
x / (a * d) = b / d - c / a

now, the integer/mod stuff:
x / (a * d) = (b / d + ( b % d ) / d) - (c / a + ( c % a ) / a )
x / (a * d) = (b / d - c / a) - ( ( c % a ) / a - ( b % d ) / d)
x = (b / d - c / a) * a * d - ( ( c % a ) * d - ( b % d ) * a)

Ви можете вважати обчислення найбільшим загальним фактором для всіх своїх значень, а потім ділити їх на цей коефіцієнт, перш ніж робити арифметичні операції, а потім помножувати знову. Це передбачає , що такий фактор існує, однак (наприклад, якщо A, B, CіD трапляється бути відносно простими, вони не будуть мати загальний фактор).

Так само ви можете розглянути можливість роботи з масштабними журналами, але це буде трохи страшно, за умови чисельної точності.

Якщо результат укладається в довгий довгий int, то вираз A * BC * D добре, оскільки він виконує арифметичний mod 2 ^ 64, і дасть правильний результат. Проблема полягає в тому, щоб знати, чи підходить результат у довгий довгий int. Щоб виявити це, ви можете використовувати наступний трюк, використовуючи парні:

if( abs( (double)A*B - (double)C*D ) > MAX_LLONG ) 
    Overflow
else 
    return A*B-C*D;

Проблема такого підходу полягає в тому, що ви обмежені точністю мантіси з подвійних пар (54 біт?), Тому вам потрібно обмежити продукти A * B і C * D до 63 + 54 біт (або, можливо, трохи менше).

E = max(A,B,C,D)
A1 = A -E;
B1 = B -E;
C1 = C -E;
D1 = D -E;

тоді

A*B - C*D = (A1+E)*(B1+E)-(C1+E)(D1+E) = (A1+B1-C1-D1)*E + A1*B1 -C1*D1

Ви можете записати кожне число у масив, кожен елемент має цифру, а обчислення робити як многочлени . Візьміть отриманий многочлен, який є масивом, і обчисліть результат, помноживши кожен елемент масиву на 10 на потужність позиції в масиві (перша позиція є найбільшою, а остання - нульовою).

Цифра 123може бути виражена як:

123 = 100 * 1 + 10 * 2 + 3

для якого ви просто створюєте масив [1 2 3] .

Ви робите це для всіх чисел A, B, C і D, а потім перемножуєте їх на многочлени. Коли ви отримаєте поліном, ви просто реконструюєте число з нього.

Поки a signed long long int заповіту не буде A*B, два з них будуть. Таким чином, A*Bможна розкласти на дерева дерева різні показники, будь-який з них підходить один signed long long int.

A1=A>>32;
A0=A & 0xffffffff;
B1=B>>32;
B0=B & 0xffffffff;

AB_0=A0*B0;
AB_1=A0*B1+A1*B0;
AB_2=A1*B1;

Те саме для C*D.

Простежуючи прямий шлях, віднімання можна зробити кожній парі AB_i і CD_iтак само, використовуючи додатковий біт перенесення (точно 1-бітове ціле число) для кожної. Отже, якщо ми скажемо E = A * BC * D, ви отримаєте щось на кшталт:

E_00=AB_0-CD_0 
E_01=(AB_0 > CD_0) == (AB_0 - CD_0 < 0) ? 0 : 1  // carry bit if overflow
E_10=AB_1-CD_1 
...

Продовжуємо, переносячи верхню половину E_10 на E_20(змініть на 32 та додайте, а потім стерти верхню половину E_10).

Тепер ви можете позбутися біт-переносника E_11, додавши його правильним знаком (отриманим від частини, що не переносить) до E_20. Якщо це викликає переповнення, результат також не підходить.

E_10 тепер має достатньо «місця», щоб забрати верхню половину E_00 (зміщення, додавання, видалення) та біт для перенесення E_01.

E_10може бути знову більшим, тому повторюємо передачу на E_20.

У цей момент E_20 має стати нульовим, інакше результат не підійде. Верхня половинаE_10 порожнього в результаті передачі також порожня.

Останній крок - перевести нижню половину E_20вE_10 знову.

Якщо очікування, яке E=A*B+C*Dби відповідало signed long long intтрюму, зараз у нас є

E_20=0
E_10=0
E_00=E

Якщо ви знаєте, що кінцевий результат представлений у вашому цілому типі, ви можете швидко виконати цей обчислення, використовуючи наведений нижче код. Оскільки стандарт C визначає, що непідписана арифметика є арифметичною за модулем і не переливається, для обчислення можна використовувати неподписаний тип.

Наступний код передбачає, що існує непідписаний тип однакової ширини і що підписаний тип використовує всі бітові шаблони для представлення значень (відсутність представлень пастки, мінімум підписаного типу - мінус половини модуля неподписаного типу). Якщо це не стосується реалізації C, для цього можна вносити прості коригування у звичайну програму ConvertToSigned.

Далі використовується signed charі unsigned charдля демонстрації коду. Для своєї реалізації змініть визначення Signedдо typedef signed long long int Signed;та визначення Unsignedдо typedef unsigned long long int Unsigned;.

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>


//  Define the signed and unsigned types we wish to use.
typedef signed char   Signed;
typedef unsigned char Unsigned;

//  uHalfModulus is half the modulus of the unsigned type.
static const Unsigned uHalfModulus = UCHAR_MAX/2+1;

//  sHalfModulus is the negation of half the modulus of the unsigned type.
static const Signed   sHalfModulus = -1 - (Signed) (UCHAR_MAX/2);


/*  Map the unsigned value to the signed value that is the same modulo the
    modulus of the unsigned type.  If the input x maps to a positive value, we
    simply return x.  If it maps to a negative value, we return x minus the
    modulus of the unsigned type.

    In most C implementations, this routine could simply be "return x;".
    However, this version uses several steps to convert x to a negative value
    so that overflow is avoided.
*/
static Signed ConvertToSigned(Unsigned x)
{
    /*  If x is representable in the signed type, return it.  (In some
        implementations, 
    */
    if (x < uHalfModulus)
        return x;

    /*  Otherwise, return x minus the modulus of the unsigned type, taking
        care not to overflow the signed type.
    */
    return (Signed) (x - uHalfModulus) - sHalfModulus;
}


/*  Calculate A*B - C*D given that the result is representable as a Signed
    value.
*/
static signed char Calculate(Signed A, Signed B, Signed C, Signed D)
{
    /*  Map signed values to unsigned values.  Positive values are unaltered.
        Negative values have the modulus of the unsigned type added.  Because
        we do modulo arithmetic below, adding the modulus does not change the
        final result.
    */
    Unsigned a = A;
    Unsigned b = B;
    Unsigned c = C;
    Unsigned d = D;

    //  Calculate with modulo arithmetic.
    Unsigned t = a*b - c*d;

    //  Map the unsigned value to the corresponding signed value.
    return ConvertToSigned(t);
}


int main()
{
    //  Test every combination of inputs for signed char.
    for (int A = SCHAR_MIN; A <= SCHAR_MAX; ++A)
    for (int B = SCHAR_MIN; B <= SCHAR_MAX; ++B)
    for (int C = SCHAR_MIN; C <= SCHAR_MAX; ++C)
    for (int D = SCHAR_MIN; D <= SCHAR_MAX; ++D)
    {
        //  Use int to calculate the expected result.
        int t0 = A*B - C*D;

        //  If the result is not representable in signed char, skip this case.
        if (t0 < SCHAR_MIN || SCHAR_MAX < t0)
            continue;

        //  Calculate the result with the sample code.
        int t1 = Calculate(A, B, C, D);

        //  Test the result for errors.
        if (t0 != t1)
        {
            printf("%d*%d - %d*%d = %d, but %d was returned.\n",
                A, B, C, D, t0, t1);
            exit(EXIT_FAILURE);
        }
    }
    return 0;
}

Ви можете спробувати розбити рівняння на більш дрібні компоненти, які не переповнюються.

AB - CD
= [ A(B - N) - C( D - M )] + [AN - CM]

= ( AK - CJ ) + ( AN - CM)

    where K = B - N
          J = D - M

Якщо компоненти все ще переповнюються, ви можете розбити їх на більш дрібні компоненти рекурсивно, а потім рекомбінувати.

Я, можливо, не охоплював усіх крайових випадків, а також не проводив жорсткого тестування цього, але це реалізує методику, яку я пам’ятаю, використовуючи у 80-х, коли намагався робити 32-бітну цілочисельну математику на 16-бітному процесорі. По суті, ви розділите 32 біти на два 16-бітні одиниці і працюєте з ними окремо.

public class DoubleMaths {
  private static class SplitLong {
    // High half (or integral part).
    private final long h;
    // Low half.
    private final long l;
    // Split.
    private static final int SPLIT = (Long.SIZE / 2);

    // Make from an existing pair.
    private SplitLong(long h, long l) {
      // Let l overflow into h.
      this.h = h + (l >> SPLIT);
      this.l = l % (1l << SPLIT);
    }

    public SplitLong(long v) {
      h = v >> SPLIT;
      l = v % (1l << SPLIT);
    }

    public long longValue() {
      return (h << SPLIT) + l;
    }

    public SplitLong add ( SplitLong b ) {
      // TODO: Check for overflow.
      return new SplitLong ( longValue() + b.longValue() );
    }

    public SplitLong sub ( SplitLong b ) {
      // TODO: Check for overflow.
      return new SplitLong ( longValue() - b.longValue() );
    }

    public SplitLong mul ( SplitLong b ) {
      /*
       * e.g. 10 * 15 = 150
       * 
       * Divide 10 and 15 by 5
       * 
       * 2 * 3 = 5
       * 
       * Must therefore multiply up by 5 * 5 = 25
       * 
       * 5 * 25 = 150
       */
      long lbl = l * b.l;
      long hbh = h * b.h;
      long lbh = l * b.h;
      long hbl = h * b.l;
      return new SplitLong ( lbh + hbl, lbl + hbh );
    }

    @Override
    public String toString () {
      return Long.toHexString(h)+"|"+Long.toHexString(l);
    }
  }

  // I'll use long and int but this can apply just as easily to long-long and long.
  // The aim is to calculate A*B - C*D without overflow.
  static final long A = Long.MAX_VALUE;
  static final long B = Long.MAX_VALUE - 1;
  static final long C = Long.MAX_VALUE;
  static final long D = Long.MAX_VALUE - 2;

  public static void main(String[] args) throws InterruptedException {
    // First do it with BigIntegers to get what the result should be.
    BigInteger a = BigInteger.valueOf(A);
    BigInteger b = BigInteger.valueOf(B);
    BigInteger c = BigInteger.valueOf(C);
    BigInteger d = BigInteger.valueOf(D);
    BigInteger answer = a.multiply(b).subtract(c.multiply(d));
    System.out.println("A*B - C*D = "+answer+" = "+answer.toString(16));

    // Make one and test its integrity.
    SplitLong sla = new SplitLong(A);
    System.out.println("A="+Long.toHexString(A)+" ("+sla.toString()+") = "+Long.toHexString(sla.longValue()));

    // Start small.
    SplitLong sl10 = new SplitLong(10);
    SplitLong sl15 = new SplitLong(15);
    SplitLong sl150 = sl10.mul(sl15);
    System.out.println("10="+sl10.longValue()+"("+sl10.toString()+") * 15="+sl15.longValue()+"("+sl15.toString()+") = "+sl150.longValue() + " ("+sl150.toString()+")");

    // The real thing.
    SplitLong slb = new SplitLong(B);
    SplitLong slc = new SplitLong(C);
    SplitLong sld = new SplitLong(D);
    System.out.println("B="+Long.toHexString(B)+" ("+slb.toString()+") = "+Long.toHexString(slb.longValue()));
    System.out.println("C="+Long.toHexString(C)+" ("+slc.toString()+") = "+Long.toHexString(slc.longValue()));
    System.out.println("D="+Long.toHexString(D)+" ("+sld.toString()+") = "+Long.toHexString(sld.longValue()));
    SplitLong sanswer = sla.mul(slb).sub(slc.mul(sld));
    System.out.println("A*B - C*D = "+sanswer+" = "+sanswer.longValue());

  }

}

Друкує:

A*B - C*D = 9223372036854775807 = 7fffffffffffffff
A=7fffffffffffffff (7fffffff|ffffffff) = 7fffffffffffffff
10=10(0|a) * 15=15(0|f) = 150 (0|96)
B=7ffffffffffffffe (7fffffff|fffffffe) = 7ffffffffffffffe
C=7fffffffffffffff (7fffffff|ffffffff) = 7fffffffffffffff
D=7ffffffffffffffd (7fffffff|fffffffd) = 7ffffffffffffffd
A*B - C*D = 7fffffff|ffffffff = 9223372036854775807

що мені здається, що це працює.

Б'юсь об заклад, я пропустив деякі тонкощі, такі як спостереження за переповненням знаків тощо.

Для повноти, оскільки ніхто про це не згадував, деякі компілятори (наприклад, GCC) насправді надають вам 128-бітове ціле число.

Таким чином, легким рішенням може бути:

(long long)((__int128)A * B - (__int128)C * D)

AB-CD = (AB-CD) * AC / AC = (B/C-D/A)*A*C. Ні, B/Cні D/Aпереповнювати не можна, тому (B/C-D/A)спочатку обчисліть . Оскільки кінцевий результат не переповниться згідно з вашим визначенням, ви можете сміливо виконати решта множення та обчислити, (B/C-D/A)*A*Cякий необхідний результат.

Зверніть увагу, якщо ваш вхід може бути надзвичайно малий , а також, B/Cчи D/Aможе переповниться. Якщо це можливо, можуть знадобитися більш складні маніпуляції відповідно до вхідної перевірки.

Виберіть K = a big number(напр. K = A - sqrt(A))

A*B - C*D = (A-K)*(B-K) - (C-K)*(D-K) + K*(A-C+B-D); // Avoid overflow.

Чому?

(A-K)*(B-K) = A*B - K*(A+B) + K^2
(C-K)*(D-K) = C*D - K*(C+D) + K^2

=>
(A-K)*(B-K) - (C-K)*(D-K) = A*B - K*(A+B) + K^2 - {C*D - K*(C+D) + K^2}
(A-K)*(B-K) - (C-K)*(D-K) = A*B - C*D - K*(A+B) + K*(C+D) + K^2 - K^2
(A-K)*(B-K) - (C-K)*(D-K) = A*B - C*D - K*(A+B-C-D)

=>
A*B - C*D = (A-K)*(B-K) - (C-K)*(D-K) + K*(A+B-C-D)

=>
A*B - C*D = (A-K)*(B-K) - (C-K)*(D-K) + K*(A-C+B-D)

Зауважте, що оскільки A, B, C і D - це великі числа, отже, A-Cі B-Dце малі числа.