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が指摘したように、型がunsigned long longである場合、減算演算中に注意が必要になる場合があります。

たとえば、あなたが問題に持っている場合、それはたった1回の反復を必要とします、

 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/など）を使用するか、構造体または配列を使用して表現し、一種の長い乗算を実装することにより、オーバーフローできない表現を使用することです（つまり、各数値を2つの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)、正しい結果がに収まる限り正確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彼らは共通因子を持っていないだろう、互いに素ことが起こります）。

同様に、対数スケールでの作業を検討することもできますが、これは数値の精度に応じて少し恐ろしいことになります。

結果がlong long intに収まる場合、式A * BC * Dは算術mod 2 ^ 64を実行し、正しい結果を与えるので問題ありません。問題は、結果がlong long intに収まるかどうかを知ることです。これを検出するには、doubleを使用して次のトリックを使用できます。

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に対して実行し、それらを多項式として乗算します。結果の多項式を取得したら、それから数を再構築するだけです。

一方でsigned long long int保持していないだろうA*B、彼ら二人はなります。したがってA*B、異なる指数のツリー項に分解でき、それらのいずれも1に適合し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_10toの上半分を転送して続行しますE_20（32だけシフトして追加し、次にの上半分を消去しE_10ます）。

これで、キャリービットE_11を正しい記号（キャリー以外の部分から取得）でに追加することで、キャリービットを取り除くことができますE_20。これによりオーバーフローがトリガーされると、結果も適合しません。

E_10E_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

コンポーネントがまだオーバーフローしている場合は、それらを小さなコンポーネントに再帰的に分割してから再結合できます。

私はすべてのエッジケースをカバーしていなかったし、これを厳密にテストしていなかったかもしれませんが、これは、16ビットCPUで32ビット整数演算を実行しようとしたときに80年代に使用したことを覚えているテクニックを実装します。基本的に、32ビットを2つの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小さい数。