Como evitar o estouro em expr. A * B - C * D

Preciso calcular uma expressão que se pareça com:, A*B - C*Donde estão seus tipos: signed long long int A, B, C, D; Cada número pode ser muito grande (sem exceder o seu tipo). Embora A*Bpossa causar estouro, ao mesmo tempo, a expressão A*B - C*Dpode ser muito pequena. Como posso calcular corretamente?

Por exemplo:, MAX * MAX - (MAX - 1) * (MAX + 1) == 1onde MAX = LLONG_MAX - ne n - algum número natural.

Isso parece muito trivial, eu acho. Mas A*Bé o único que pode transbordar.

Você pode fazer o seguinte, sem perder a precisão

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)

Essa decomposição pode ser feita ainda mais .
Como o @Gian apontou, talvez seja necessário tomar cuidado durante a operação de subtração se o tipo não tiver assinatura por muito tempo.

Por exemplo, com o caso em questão, são necessárias apenas uma iteração,

 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

A solução mais simples e mais geral é usar uma representação que não pode transbordar, usando uma biblioteca inteira longa (por exemplo, http://gmplib.org/ ) ou representando usando uma estrutura ou matriz e implementando um tipo de multiplicação longa ( isto é, separar cada número em duas metades de 32 bits e realizar a multiplicação conforme abaixo:

(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

Supondo que o resultado final se encaixe em 64 bits, você realmente não precisa da maioria dos bits de R3 e nenhum de R4

Observe que isso não é padrão, uma vez que se baseia no estouro de sinalização wrap-around. (O GCC possui sinalizadores de compilador que permitem isso.)

Mas se você fizer todos os cálculos long long, o resultado da aplicação direta da fórmula:
(A * B - C * D)será preciso enquanto o resultado correto se encaixar em a long long.

Aqui está uma solução alternativa que depende apenas do comportamento definido pela implementação de converter um número inteiro não assinado em número inteiro assinado. Mas isso pode funcionar em quase todos os sistemas atualmente.

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

Isso lança as entradas para as unsigned long longquais o comportamento de estouro é garantido como padrão pelo padrão. A conversão de volta para um número inteiro assinado no final é a parte definida pela implementação, mas funcionará em quase todos os ambientes hoje.

Se você precisar de uma solução mais pedante, acho que você deve usar "aritmética longa"

Isso deve funcionar (eu acho):

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);

Aqui está minha derivação:

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)

Você pode considerar o cálculo do maior fator comum para todos os seus valores e depois dividi-los por esse fator antes de executar suas operações aritméticas e depois multiplicar novamente. Isso pressupõe que tal fator um existe, no entanto (por exemplo, se A, B, Ce Dacontecer de ser relativamente primos, eles não têm um fator comum).

Da mesma forma, você pode considerar trabalhar em escalas de log, mas isso será um pouco assustador, sujeito à precisão numérica.

Se o resultado se encaixa em um longo e longo int, então a expressão A * BC * D está correta, pois executa o mod aritmético 2 ^ 64 e fornecerá o resultado correto. O problema é saber se o resultado se encaixa em um int muito longo. Para detectar isso, você pode usar o seguinte truque usando duplas:

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

O problema dessa abordagem é que você é limitado pela precisão da mantissa das dobras (54 bits?), Portanto, você precisa limitar os produtos A * B e C * D a 63 + 54 bits (ou provavelmente um pouco menos).

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

então

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

Você pode escrever cada número em uma matriz, cada elemento sendo um dígito e fazer os cálculos como polinômios . Pegue o polinômio resultante, que é uma matriz, e calcule o resultado multiplicando cada elemento da matriz por 10 à potência da posição na matriz (a primeira posição sendo a maior e a última sendo zero).

O número 123pode ser expresso como:

123 = 100 * 1 + 10 * 2 + 3

para o qual você acabou de criar uma matriz [1 2 3].

Você faz isso para todos os números A, B, C e D e os multiplica como polinômios. Depois de obter o polinômio resultante, você apenas reconstrói o número a partir dele.

Enquanto um signed long long intnão aguentar A*B, dois deles o farão. Assim, A*Bpoderia ser decomposto em termos de árvore de diferentes expoentes, qualquer um deles adequado 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;

O mesmo para C*D.

Seguindo da maneira correta, a sub-ação poderia ser feita para todos os pares de, AB_ie da CD_imesma forma, usando um bit de transporte adicional (com precisão um número inteiro de 1 bit) para cada um. Então, se dissermos E = A * BC * D, você terá algo como:

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 
...

Continuamos transferindo a metade superior de E_10para E_20(mude 32 e adicione e depois apague a metade superior E_10).

Agora você pode se livrar do bit de transporte E_11, adicionando-o com o sinal correto (obtido da parte de não transporte) a E_20. Se isso disparar um estouro, o resultado também não seria adequado.

E_10agora tem 'espaço' suficiente para retirar a metade superior E_00 (mudar, adicionar, apagar) e o bit de transporte E_01.

E_10agora pode ser maior novamente, então repetimos a transferência para E_20.

Neste ponto, E_20deve se tornar zero, caso contrário, o resultado não será adequado. A metade superior também E_10está vazia como resultado da transferência.

O passo final é transferir a metade inferior E_20para E_10novamente.

Se a expectativa que E=A*B+C*Dcaberia nos signed long long intporões, agora temos

E_20=0
E_10=0
E_00=E

Se você sabe que o resultado final é representável no seu tipo inteiro, você pode executar esse cálculo rapidamente usando o código abaixo. Como o padrão C especifica que a aritmética não assinada é aritmética modular e não transborda, é possível usar um tipo não assinado para executar o cálculo.

O código a seguir assume que existe um tipo não assinado da mesma largura e que o tipo assinado usa todos os padrões de bits para representar valores (sem representações de trap, o mínimo do tipo assinado é o negativo da metade do módulo do tipo não assinado). Se isso não ocorrer em uma implementação C, ajustes simples poderão ser feitos na rotina ConvertToSigned para isso.

O seguinte usa signed chare unsigned charpara demonstrar o código. Para sua implementação, altere a definição de Signedpara typedef signed long long int Signed;e a definição de Unsignedpara 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;
}

Você pode tentar dividir a equação em componentes menores que não transbordam.

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

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

    where K = B - N
          J = D - M

Se os componentes ainda estiverem transbordando, você poderá dividi-los em componentes menores recursivamente e recombinar.

Talvez eu não tenha abordado todos os casos extremos, nem testei rigorosamente isso, mas isso implementa uma técnica que me lembro de usar nos anos 80 ao tentar fazer cálculos inteiros de 32 bits em uma CPU de 16 bits. Basicamente, você divide os 32 bits em duas unidades de 16 bits e trabalha com eles separadamente.

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());

  }

}

Impressões:

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

o que me parece que está funcionando.

Aposto que perdi algumas das sutilezas, como observar o excesso de sinal, etc., mas acho que a essência está lá.

Por uma questão de completude, como ninguém o mencionou, alguns compiladores (por exemplo, GCC) realmente fornecem um número inteiro de 128 bits hoje em dia.

Assim, uma solução fácil pode ser:

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

AB-CD = (AB-CD) * AC / AC = (B/C-D/A)*A*C. Nem B/Cnem D/Apode transbordar, por isso, calcular (B/C-D/A)em primeiro lugar. Como o resultado final não transbordará de acordo com sua definição, você pode realizar com segurança as multiplicações restantes e calcular (B/C-D/A)*A*Cqual é o resultado necessário.

Observe que, se sua entrada também pode ser extremamente pequena , a B/Cou D/Apode estourar. Se possível, manipulações mais complexas podem ser necessárias de acordo com a inspeção de entrada.

Escolha K = a big number(por exemplo K = A - sqrt(A))

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

Por quê?

(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)

Note que, como A, B, C e D são grandes números, portanto, A-Ce B-Dsão pequenos números.