All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.google.gwt.emul.java.math.Multiplication Maven / Gradle / Ivy

There is a newer version: 2.10.0
Show newest version
/*
 * Copyright 2009 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with this
 * work for additional information regarding copyright ownership. The ASF
 * licenses this file to You under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 * 
 * INCLUDES MODIFICATIONS BY RICHARD ZSCHECH AS WELL AS GOOGLE.
 */
package java.math;

/**
 * Static library that provides all multiplication of {@link BigInteger}
 * methods.
 */
class Multiplication {

  /**
   * An array with the first powers of five in {@code BigInteger} version. (
   * {@code 5^0,5^1,...,5^31})
   */
  static final BigInteger bigFivePows[] = new BigInteger[32];

  /**
   * An array with the first powers of ten in {@code BigInteger} version. (
   * {@code 10^0,10^1,...,10^31})
   */
  static final BigInteger[] bigTenPows = new BigInteger[32];

  /**
   * An array with powers of five that fit in the type {@code int}. ({@code
   * 5^0,5^1,...,5^13})
   */
  static final int fivePows[] = {
      1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625,
      48828125, 244140625, 1220703125};

  /**
   * An array with powers of ten that fit in the type {@code int}. ({@code
   * 10^0,10^1,...,10^9})
   */
  static final int tenPows[] = {
      1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};

  /**
   * Break point in digits (number of {@code int} elements) between Karatsuba
   * and Pencil and Paper multiply.
   */
  static final int whenUseKaratsuba = 63; // an heuristic value

  static {
    int i;
    long fivePow = 1L;

    for (i = 0; i <= 18; i++) {
      bigFivePows[i] = BigInteger.valueOf(fivePow);
      bigTenPows[i] = BigInteger.valueOf(fivePow << i);
      fivePow *= 5;
    }
    for (; i < bigTenPows.length; i++) {
      bigFivePows[i] = bigFivePows[i - 1].multiply(bigFivePows[1]);
      bigTenPows[i] = bigTenPows[i - 1].multiply(BigInteger.TEN);
    }
  }

  /**
   * Performs the multiplication with the Karatsuba's algorithm. Karatsuba's
   * algorithm: 
   *             u = u1 * B + u0
* v = v1 * B + v0
* * * u*v = (u1 * v1) * B2 + ((u1 - u0) * (v0 - v1) + u1 * v1 + * u0 * v0 ) * B + u0 * v0
*
* * @param op1 first factor of the product * @param op2 second factor of the product * @return {@code op1 * op2} * @see #multiply(BigInteger, BigInteger) */ static BigInteger karatsuba(BigInteger op1, BigInteger op2) { BigInteger temp; if (op2.numberLength > op1.numberLength) { temp = op1; op1 = op2; op2 = temp; } if (op2.numberLength < whenUseKaratsuba) { return multiplyPAP(op1, op2); } /* * Karatsuba: u = u1*B + u0 v = v1*B + v0 u*v = (u1*v1)*B^2 + * ((u1-u0)*(v0-v1) + u1*v1 + u0*v0)*B + u0*v0 */ // ndiv2 = (op1.numberLength / 2) * 32 int ndiv2 = (op1.numberLength & 0xFFFFFFFE) << 4; BigInteger upperOp1 = op1.shiftRight(ndiv2); BigInteger upperOp2 = op2.shiftRight(ndiv2); BigInteger lowerOp1 = op1.subtract(upperOp1.shiftLeft(ndiv2)); BigInteger lowerOp2 = op2.subtract(upperOp2.shiftLeft(ndiv2)); BigInteger upper = karatsuba(upperOp1, upperOp2); BigInteger lower = karatsuba(lowerOp1, lowerOp2); BigInteger middle = karatsuba(upperOp1.subtract(lowerOp1), lowerOp2.subtract(upperOp2)); middle = middle.add(upper).add(lower); middle = middle.shiftLeft(ndiv2); upper = upper.shiftLeft(ndiv2 << 1); return upper.add(middle).add(lower); } static void multArraysPAP(int[] aDigits, int aLen, int[] bDigits, int bLen, int[] resDigits) { if (aLen == 0 || bLen == 0) { return; } if (aLen == 1) { resDigits[bLen] = multiplyByInt(resDigits, bDigits, bLen, aDigits[0]); } else if (bLen == 1) { resDigits[aLen] = multiplyByInt(resDigits, aDigits, aLen, bDigits[0]); } else { multPAP(aDigits, bDigits, resDigits, aLen, bLen); } } /** * Performs a multiplication of two BigInteger and hides the algorithm used. * * @see BigInteger#multiply(BigInteger) */ static BigInteger multiply(BigInteger x, BigInteger y) { return karatsuba(x, y); } /** * Multiplies a number by a power of five. This method is used in {@code * BigDecimal} class. * * @param val the number to be multiplied * @param exp a positive {@code int} exponent * @return {@code val * 5exp} */ static BigInteger multiplyByFivePow(BigInteger val, int exp) { // PRE: exp >= 0 if (exp < fivePows.length) { return multiplyByPositiveInt(val, fivePows[exp]); } else if (exp < bigFivePows.length) { return val.multiply(bigFivePows[exp]); } else { // Large powers of five return val.multiply(bigFivePows[1].pow(exp)); } } /** * Multiplies an array of integers by an integer value. * * @param a the array of integers * @param aSize the number of elements of intArray to be multiplied * @param factor the multiplier * @return the top digit of production */ static int multiplyByInt(int a[], final int aSize, final int factor) { return multiplyByInt(a, a, aSize, factor); } /** * Multiplies a number by a positive integer. * * @param val an arbitrary {@code BigInteger} * @param factor a positive {@code int} number * @return {@code val * factor} */ static BigInteger multiplyByPositiveInt(BigInteger val, int factor) { int resSign = val.sign; if (resSign == 0) { return BigInteger.ZERO; } int aNumberLength = val.numberLength; int[] aDigits = val.digits; if (aNumberLength == 1) { long res = unsignedMultAddAdd(aDigits[0], factor, 0, 0); int resLo = (int) res; int resHi = (int) (res >>> 32); return ((resHi == 0) ? new BigInteger(resSign, resLo) : new BigInteger( resSign, 2, new int[] {resLo, resHi})); } // Common case int resLength = aNumberLength + 1; int resDigits[] = new int[resLength]; resDigits[aNumberLength] = multiplyByInt(resDigits, aDigits, aNumberLength, factor); BigInteger result = new BigInteger(resSign, resLength, resDigits); result.cutOffLeadingZeroes(); return result; } /** * Multiplies a number by a power of ten. This method is used in {@code * BigDecimal} class. * * @param val the number to be multiplied * @param exp a positive {@code long} exponent * @return {@code val * 10exp} */ static BigInteger multiplyByTenPow(BigInteger val, int exp) { // PRE: exp >= 0 return ((exp < tenPows.length) ? multiplyByPositiveInt(val, tenPows[(int) exp]) : val.multiply(powerOf10(exp))); } /** * Multiplies two BigIntegers. Implements traditional scholar algorithm * described by Knuth. * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
A=a3a2a1a0
B=b2b1b1
b0*a3b0*a2b0*a1b0*a0
b1*a3b1*a2b1*a1b1*a0
+b2*a3b2*a2b2*a1b2*a0
____________________________________
A*B=R=r5r4r3r2r1r0
* *
* * @param op1 first factor of the multiplication {@code op1 >= 0} * @param op2 second factor of the multiplication {@code op2 >= 0} * @return a {@code BigInteger} of value {@code op1 * op2} */ static BigInteger multiplyPAP(BigInteger a, BigInteger b) { // PRE: a >= b int aLen = a.numberLength; int bLen = b.numberLength; int resLength = aLen + bLen; int resSign = (a.sign != b.sign) ? -1 : 1; // A special case when both numbers don't exceed int if (resLength == 2) { long val = unsignedMultAddAdd(a.digits[0], b.digits[0], 0, 0); int valueLo = (int) val; int valueHi = (int) (val >>> 32); return ((valueHi == 0) ? new BigInteger(resSign, valueLo) : new BigInteger(resSign, 2, new int[] {valueLo, valueHi})); } int[] aDigits = a.digits; int[] bDigits = b.digits; int resDigits[] = new int[resLength]; // Common case multArraysPAP(aDigits, aLen, bDigits, bLen, resDigits); BigInteger result = new BigInteger(resSign, resLength, resDigits); result.cutOffLeadingZeroes(); return result; } static void multPAP(int a[], int b[], int t[], int aLen, int bLen) { if (a == b && aLen == bLen) { square(a, aLen, t); return; } for (int i = 0; i < aLen; i++) { long carry = 0; int aI = a[i]; for (int j = 0; j < bLen; j++) { carry = unsignedMultAddAdd(aI, b[j], t[i + j], (int) carry); t[i + j] = (int) carry; carry >>>= 32; } t[i + bLen] = (int) carry; } } static BigInteger pow(BigInteger base, int exponent) { // PRE: exp > 0 BigInteger res = BigInteger.ONE; BigInteger acc = base; for (; exponent > 1; exponent >>= 1) { if ((exponent & 1) != 0) { // if odd, multiply one more time by acc res = res.multiply(acc); } // acc = base^(2^i) // a limit where karatsuba performs a faster square than the square // algorithm if (acc.numberLength == 1) { acc = acc.multiply(acc); // square } else { acc = new BigInteger(1, square(acc.digits, acc.numberLength, new int[acc.numberLength << 1])); } } // exponent == 1, multiply one more time res = res.multiply(acc); return res; } /** * It calculates a power of ten, which exponent could be out of 32-bit range. * Note that internally this method will be used in the worst case with an * exponent equals to: {@code Integer.MAX_VALUE - Integer.MIN_VALUE}. * * @param exp the exponent of power of ten, it must be positive. * @return a {@code BigInteger} with value {@code 10exp}. */ static BigInteger powerOf10(double exp) { // PRE: exp >= 0 int intExp = (int) exp; // "SMALL POWERS" if (exp < bigTenPows.length) { // The largest power that fit in 'long' type return bigTenPows[intExp]; } else if (exp <= 50) { // To calculate: 10^exp return BigInteger.TEN.pow(intExp); } else if (exp <= 1000) { // To calculate: 5^exp * 2^exp return bigFivePows[1].pow(intExp).shiftLeft(intExp); } // "LARGE POWERS" /* * To check if there is free memory to allocate a BigInteger of the * estimated size, measured in bytes: 1 + [exp / log10(2)] */ if (exp > 1000000) { throw new ArithmeticException("power of ten too big"); //$NON-NLS-1$ } if (exp <= Integer.MAX_VALUE) { // To calculate: 5^exp * 2^exp return bigFivePows[1].pow(intExp).shiftLeft(intExp); } /* * "HUGE POWERS" * * This branch probably won't be executed since the power of ten is too big. */ // To calculate: 5^exp BigInteger powerOfFive = bigFivePows[1].pow(Integer.MAX_VALUE); BigInteger res = powerOfFive; long longExp = (long) (exp - Integer.MAX_VALUE); intExp = (int) (exp % Integer.MAX_VALUE); while (longExp > Integer.MAX_VALUE) { res = res.multiply(powerOfFive); longExp -= Integer.MAX_VALUE; } res = res.multiply(bigFivePows[1].pow(intExp)); // To calculate: 5^exp << exp res = res.shiftLeft(Integer.MAX_VALUE); longExp = (long) (exp - Integer.MAX_VALUE); while (longExp > Integer.MAX_VALUE) { res = res.shiftLeft(Integer.MAX_VALUE); longExp -= Integer.MAX_VALUE; } res = res.shiftLeft(intExp); return res; } /** * Performs a2. * * @param a The number to square. * @param aLen The length of the number to square. */ static int[] square(int[] a, int aLen, int[] res) { long carry; for (int i = 0; i < aLen; i++) { carry = 0; for (int j = i + 1; j < aLen; j++) { carry = unsignedMultAddAdd(a[i], a[j], res[i + j], (int) carry); res[i + j] = (int) carry; carry >>>= 32; } res[i + aLen] = (int) carry; } BitLevel.shiftLeftOneBit(res, res, aLen << 1); carry = 0; for (int i = 0, index = 0; i < aLen; i++, index++) { carry = unsignedMultAddAdd(a[i], a[i], res[index], (int) carry); res[index] = (int) carry; carry >>>= 32; index++; carry += res[index] & 0xFFFFFFFFL; res[index] = (int) carry; carry >>>= 32; } return res; } /** * Computes the value unsigned ((uint)a*(uint)b + (uint)c + (uint)d). This * method could improve the readability and performance of the code. * * @param a parameter 1 * @param b parameter 2 * @param c parameter 3 * @param d parameter 4 * @return value of expression */ static long unsignedMultAddAdd(int a, int b, int c, int d) { return (a & 0xFFFFFFFFL) * (b & 0xFFFFFFFFL) + (c & 0xFFFFFFFFL) + (d & 0xFFFFFFFFL); } /** * Multiplies an array of integers by an integer value and saves the result in * {@code res}. * * @param a the array of integers * @param aSize the number of elements of intArray to be multiplied * @param factor the multiplier * @return the top digit of production */ private static int multiplyByInt(int res[], int a[], final int aSize, final int factor) { long carry = 0; for (int i = 0; i < aSize; i++) { carry = unsignedMultAddAdd(a[i], factor, (int) carry, 0); res[i] = (int) carry; carry >>>= 32; } return (int) carry; } /** * Just to denote that this class can't be instantiated. */ private Multiplication() { } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy