Revert r7351 due to test failures.
git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@7359 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/user/src/com/google/gwt/i18n/client/NumberFormat.java b/user/src/com/google/gwt/i18n/client/NumberFormat.java
index 7f543a4..7b2ba5c 100644
--- a/user/src/com/google/gwt/i18n/client/NumberFormat.java
+++ b/user/src/com/google/gwt/i18n/client/NumberFormat.java
@@ -15,11 +15,9 @@
*/
package com.google.gwt.i18n.client;
+import com.google.gwt.core.client.GWT;
import com.google.gwt.i18n.client.constants.NumberConstants;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
/**
* Formats and parses numbers using locale-sensitive patterns.
*
@@ -351,7 +349,7 @@
public static boolean forcedLatinDigits() {
return defaultNumberConstants != localizedNumberConstants;
}
-
+
/**
* Provides the standard currency format for the default locale.
*
@@ -365,7 +363,7 @@
}
return cachedCurrencyFormat;
}
-
+
/**
* Provides the standard currency format for the default locale using a
* specified currency.
@@ -378,7 +376,7 @@
return new NumberFormat(defaultNumberConstants.currencyPattern(),
currencyData, false);
}
-
+
/**
* Provides the standard currency format for the default locale using a
* specified currency.
@@ -611,47 +609,6 @@
}
/**
- * Appends a scaled string representation to a buffer, returning the scale
- * (which is the number of places to the right of the end of the string the
- * decimal point should be moved -- i.e., 3.5 would be added to the buffer
- * as "35" and a returned scale of -1).
- *
- * @param buf
- * @param val
- * @return scale to apply to the result
- */
- // @VisibleForTesting
- static int toScaledString(StringBuilder buf, double val) {
- int startLen = buf.length();
- buf.append(toPrecision(val, 20));
- int scale = 0;
-
- // remove exponent if present, adjusting scale
- int expIdx = buf.indexOf("e", startLen);
- if (expIdx < 0) {
- expIdx = buf.indexOf("E", startLen);
- }
- if (expIdx >= 0) {
- int expDigits = expIdx + 1;
- if (expDigits < buf.length() && buf.charAt(expDigits) == '+') {
- ++expDigits;
- }
- if (expDigits < buf.length()) {
- scale = Integer.parseInt(buf.substring(expDigits));
- }
- buf.delete(expIdx, buf.length());
- }
-
- // remove decimal point if present, adjusting scale
- int dot = buf.indexOf(".", startLen);
- if (dot >= 0) {
- buf.deleteCharAt(dot);
- scale -= buf.length() - dot;
- }
- return scale;
- }
-
- /**
* Lookup a currency code.
*
* @param currencyCode ISO4217 currency code
@@ -668,43 +625,26 @@
return currencyData;
}
- /**
- * Convert a double to a string with {@code digits} precision. The resulting
- * string may still be in exponential notation.
- *
- * @param d double value
- * @param digits number of digits of precision to include
- * @return non-localized string representation of {@code d}
- */
- private static native String toPrecision(double d, int digits) /*-{
- return d.toPrecision(digits);
+ private static native String toFixed(double d, int digits) /*-{
+ return d.toFixed(digits);
}-*/;
- /**
- * The currency code.
- */
+ // The currency code.
private final String currencyCode;
- /**
- * Currency symbol to use.
- */
+ // Currency setting.
private final String currencySymbol;
- /**
- * Forces the decimal separator to always appear in a formatted number.
- */
+ // Forces the decimal separator to always appear in a formatted number.
private boolean decimalSeparatorAlwaysShown = false;
- /**
- * The number of digits between grouping separators in the integer portion of
- * a number.
- */
+ // The number of digits between grouping separators in the integer
+ // portion of a number.
private int groupingSize = 3;
-
+
private boolean isCurrencyFormat = false;
-
+
private int maximumFractionDigits = 3; // invariant, >= minFractionDigits.
-
private int maximumIntegerDigits = 40;
private int minExponentDigits;
private int minimumFractionDigits = 0;
@@ -731,24 +671,6 @@
private boolean useExponentialNotation = false;
/**
- * Holds the current exponent during one call to
- * {@link #format(boolean, StringBuilder, int)}.
- */
- private transient int exponent;
-
- /**
- * Holds the current decimal position during one call to
- * {@link #format(boolean, StringBuilder, int)}.
- */
- private transient int decimalPosition;
-
- /**
- * Holds the current digits length during one call to
- * {@link #format(boolean, StringBuilder, int)}.
- */
- private transient int digitsLength;
-
- /**
* Constructs a format object based on the specified settings.
*
* @param numberConstants the locale-specific number constants to use for this
@@ -797,75 +719,33 @@
* @return the formatted number string
*/
public String format(double number) {
+ StringBuffer result = new StringBuffer();
+
if (Double.isNaN(number)) {
- return numberConstants.notANumber();
+ result.append(numberConstants.notANumber());
+ return result.toString();
}
- boolean isNegative = ((number < 0.0)
- || (number == 0.0 && 1 / number < 0.0));
- if (isNegative) {
- number = -number;
- }
- StringBuilder buf = new StringBuilder();
+
+ boolean isNegative = ((number < 0.0) || (number == 0.0 && 1 / number < 0.0));
+
+ result.append(isNegative ? negativePrefix : positivePrefix);
if (Double.isInfinite(number)) {
- buf.append(isNegative ? negativePrefix : positivePrefix);
- buf.append(numberConstants.infinity());
- buf.append(isNegative ? negativeSuffix : positiveSuffix);
- return buf.toString();
- }
- number *= multiplier;
- int scale = toScaledString(buf, number);
-
- // pre-round value to deal with .15 being represented as .149999... etc
- // check at 3 more digits than will be required in the output
- int preRound = buf.length() + scale + maximumFractionDigits + 3;
- if (preRound > 0 && preRound < buf.length()
- && buf.charAt(preRound) == '9') {
- propagateCarry(buf, preRound - 1);
- scale += buf.length() - preRound;
- buf.delete(preRound, buf.length());
- }
-
- format(isNegative, buf, scale);
- return buf.toString();
- }
-
- /**
- * This method formats a Number to produce a string.
- * <p>
- * Any {@link Number} which is not a {@link BigDecimal}, {@link BigInteger},
- * or {@link Long} instance is formatted as a {@code double} value.
- *
- * @param number The Number instance to format
- * @return the formatted number string
- */
- public String format(Number number) {
- if (number instanceof BigDecimal) {
- BigDecimal bigDec = (BigDecimal) number;
- boolean isNegative = bigDec.signum() < 0;
- if (isNegative) {
- bigDec = bigDec.negate();
- }
- bigDec = bigDec.multiply(BigDecimal.valueOf(multiplier));
- StringBuilder buf = new StringBuilder();
- buf.append(bigDec.unscaledValue().toString());
- format(isNegative, buf, -bigDec.scale());
- return buf.toString();
- } else if (number instanceof BigInteger) {
- BigInteger bigInt = (BigInteger) number;
- boolean isNegative = bigInt.signum() < 0;
- if (isNegative) {
- bigInt = bigInt.negate();
- }
- bigInt = bigInt.multiply(BigInteger.valueOf(multiplier));
- StringBuilder buf = new StringBuilder();
- buf.append(bigInt.toString());
- format(isNegative, buf, 0);
- return buf.toString();
- } else if (number instanceof Long) {
- return format(number.longValue(), 0);
+ result.append(numberConstants.infinity());
} else {
- return format(number.doubleValue());
+ if (isNegative) {
+ number = -number;
+ }
+ number *= multiplier;
+ if (useExponentialNotation) {
+ subformatExponential(number, result);
+ } else {
+ subformatFixed(number, result, minimumIntegerDigits);
+ }
}
+
+ result.append(isNegative ? negativeSuffix : positiveSuffix);
+
+ return result.toString();
}
/**
@@ -983,294 +863,56 @@
return ret;
}
- /**
- * Format a number with its significant digits already represented in string
- * form. This is done so both double and BigInteger/Decimal formatting can
- * share code without requiring all users to pay the code size penalty for
- * BigDecimal/etc.
- * <p>
- * Example values passed in:
- * <ul>
- * <li>-13e2
- * <br>{@code isNegative=true, digits="13", scale=2}
- * <li>3.14158
- * <br>{@code isNegative=false, digits="314158", scale=-5}
- * <li>.0001
- * <br>{@code isNegative=false, digits="1" ("0001" would be ok), scale=-4}
- * </ul>
- *
- * @param isNegative true if the value to be formatted is negative
- * @param digits a StringBuilder containing just the significant digits in
- * the value to be formatted, the formatted result will be left here
- * @param scale the number of places to the right the decimal point should
- * be moved in the digit string -- negative means the value contains
- * fractional digits
- */
- protected void format(boolean isNegative, StringBuilder digits, int scale) {
- char decimalSeparator;
- char groupingSeparator;
- if (isCurrencyFormat) {
- decimalSeparator = numberConstants.monetarySeparator().charAt(0);
- groupingSeparator = numberConstants.monetaryGroupingSeparator().charAt(0);
- } else {
- decimalSeparator = numberConstants.decimalSeparator().charAt(0);
- groupingSeparator = numberConstants.groupingSeparator().charAt(0);
- }
-
- // Set these transient fields, which will be adjusted/used by the routines
- // called in this method.
- exponent = 0;
- digitsLength = digits.length();
- decimalPosition = digitsLength + scale;
-
- boolean useExponent = this.useExponentialNotation;
- int currentGroupingSize = this.groupingSize;
- if (decimalPosition > 1024) {
- // force really large numbers to be in exponential form
- useExponent = true;
- }
-
- if (useExponent) {
- computeExponent(digits);
- }
- processLeadingZeros(digits);
- roundValue(digits);
- insertGroupingSeparators(digits, groupingSeparator, currentGroupingSize);
- adjustFractionDigits(digits);
- addZeroAndDecimal(digits, decimalSeparator);
- if (useExponent) {
- addExponent(digits);
- // the above call has invalidated digitsLength == digits.length()
- }
- char zeroChar = numberConstants.zeroDigit().charAt(0);
- if (zeroChar != '0') {
- localizeDigits(digits, zeroChar);
- }
-
- // add prefix/suffix
- digits.insert(0, isNegative ? negativePrefix : positivePrefix);
- digits.append(isNegative ? negativeSuffix : positiveSuffix);
- }
-
- /**
- * Parses text to produce a numeric value. A {@link NumberFormatException} is
- * thrown if either the text is empty or if the parse does not consume all
- * characters of the text.
- *
- * param text the string to be parsed
- * return a parsed number value, which may be a Double, BigInteger, or
- * BigDecimal, or {@code Double(0.0)} if the parse fails.
- * throws NumberFormatException if the text segment could not be converted
- * into a number
- */
-// public Number parseBig(String text) throws NumberFormatException {
-// // TODO(jat): implement
-// return Double.valueOf(parse(text));
-// }
-
- /**
- * Parses text to produce a numeric value.
- *
- * <p>
- * The method attempts to parse text starting at the index given by pos. If
- * parsing succeeds, then the index of <code>pos</code> is updated to the
- * index after the last character used (parsing does not necessarily use all
- * characters up to the end of the string), and the parsed number is returned.
- * The updated <code>pos</code> can be used to indicate the starting point
- * for the next call to this method. If an error occurs, then the index of
- * <code>pos</code> is not changed.
- * </p>
- *
- * param text the string to be parsed
- * pparam inOutPos position to pass in and get back
- * return a parsed number value, which may be a Double, BigInteger, or
- * BigDecimal, or {@code Double(0.0)} if the parse fails.
- * throws NumberFormatException if the text segment could not be converted
- * into a number
- */
-// public Number parseBig(String text, int[] inOutPos)
-// throws NumberFormatException {
-// // TODO(jat): implement
-// return Double.valueOf(parse(text, inOutPos));
-// }
-
- /**
- * Format a possibly scaled long value.
- *
- * @param value value to format
- * @param scale the number of places to the right the decimal point should
- * be moved in the digit string -- negative means the value contains
- * fractional digits
- * @return formatted value
- */
- protected String format(long value, int scale) {
- boolean isNegative = value < 0;
- if (isNegative) {
- value = -value;
- }
- value *= multiplier;
- StringBuilder buf = new StringBuilder();
- buf.append(String.valueOf(value));
- format(isNegative, buf, scale);
- return buf.toString();
- }
-
- /**
- * @return the number of digits between grouping separators in the integer
- * portion of a number.
- */
protected int getGroupingSize() {
return groupingSize;
}
- /**
- * @return the prefix to use for negative values.
- */
protected String getNegativePrefix() {
return negativePrefix;
}
- /**
- * @return the suffix to use for negative values.
- */
protected String getNegativeSuffix() {
return negativeSuffix;
}
- /**
- * @return the NumberConstants instance for this formatter.
- */
protected NumberConstants getNumberConstants() {
return numberConstants;
}
- /**
- * @return the prefix to use for positive values.
- */
protected String getPositivePrefix() {
return positivePrefix;
}
- /**
- * @return the suffix to use for positive values.
- */
protected String getPositiveSuffix() {
return positiveSuffix;
}
- /**
- * @return true if the decimal separator should always be shown.
- */
protected boolean isDecimalSeparatorAlwaysShown() {
return decimalSeparatorAlwaysShown;
}
/**
- * Add exponent suffix.
+ * This method formats the exponent part of a double.
*
- * @param digits
+ * @param exponent exponential value
+ * @param result formatted exponential part will be append to it
*/
- private void addExponent(StringBuilder digits) {
- digits.append(numberConstants.exponentialSymbol());
+ private void addExponentPart(int exponent, StringBuffer result) {
+ result.append(numberConstants.exponentialSymbol());
+
if (exponent < 0) {
exponent = -exponent;
- digits.append(numberConstants.minusSign());
+ result.append(numberConstants.minusSign());
}
+
String exponentDigits = String.valueOf(exponent);
- for (int i = exponentDigits.length(); i < minExponentDigits; ++i) {
- digits.append('0');
+ int len = exponentDigits.length();
+ for (int i = len; i < minExponentDigits; ++i) {
+ result.append(numberConstants.zeroDigit());
}
- digits.append(exponentDigits);
- }
-
- /**
- * @param digits
- * @param decimalSeparator
- */
- private void addZeroAndDecimal(StringBuilder digits, char decimalSeparator) {
- // add zero and decimal point if required
- if (digitsLength == 0) {
- digits.insert(0, '0');
- ++decimalPosition;
- ++digitsLength;
- }
- if (decimalPosition < digitsLength || decimalSeparatorAlwaysShown) {
- digits.insert(decimalPosition, decimalSeparator);
- ++digitsLength;
- }
- }
-
- /**
- * Adjust the fraction digits, adding trailing zeroes if necessary or removing
- * excess trailing zeroes.
- *
- * @param digits
- */
- private void adjustFractionDigits(StringBuilder digits) {
- // adjust fraction digits as required
- int requiredDigits = decimalPosition + minimumFractionDigits;
- if (digitsLength < requiredDigits) {
- // add trailing zeros
- while (digitsLength < requiredDigits) {
- digits.append('0');
- ++digitsLength;
- }
- } else {
- // remove excess trailing zeros
- int toRemove = decimalPosition + maximumFractionDigits;
- if (toRemove > digitsLength) {
- toRemove = digitsLength;
- }
- while (toRemove > requiredDigits
- && digits.charAt(toRemove - 1) == '0') {
- --toRemove;
- }
- if (toRemove < digitsLength) {
- digits.delete(toRemove, digitsLength);
- digitsLength = toRemove;
- }
- }
- }
-
- /**
- * Compute the exponent to use and adjust decimal position if we are using
- * exponential notation.
- *
- * @param digits
- */
- private void computeExponent(StringBuilder digits) {
- // always trim leading zeros
- int strip = 0;
- while (strip < digitsLength - 1 && digits.charAt(strip) == '0') {
- ++strip;
- }
- if (strip > 0) {
- digits.delete(0, strip);
- digitsLength -= strip;
- exponent -= strip;
- }
-
- // decimal should wind up between minimum & maximumIntegerDigits
- if (maximumIntegerDigits > minimumIntegerDigits
- && maximumIntegerDigits > 0) {
- // in this case, the exponent should be a multiple of
- // maximumIntegerDigits and 1 <= decimal <= maximumIntegerDigits
- exponent += decimalPosition - 1;
- int remainder = exponent % maximumIntegerDigits;
- if (remainder < 0) {
- remainder += maximumIntegerDigits;
- }
- decimalPosition = remainder + 1;
- exponent -= remainder;
- } else {
- exponent += decimalPosition - minimumIntegerDigits;
- decimalPosition = minimumIntegerDigits;
- }
-
- // special-case 0 to have an exponent of 0
- if (digitsLength == 1 && digits.charAt(0) == '0') {
- exponent = 0;
- decimalPosition = minimumIntegerDigits;
+ int zeroDelta = numberConstants.zeroDigit().charAt(0) - '0';
+ for (int i = 0; i < len; ++i) {
+ result.append((char) (exponentDigits.charAt(i) + zeroDelta));
}
}
@@ -1291,41 +933,47 @@
}
/**
- * Insert grouping separators if needed.
- *
- * @param digits
- * @param groupingSeparator
- * @param g
- */
- private void insertGroupingSeparators(StringBuilder digits,
- char groupingSeparator, int g) {
- if (g > 0) {
- for (int i = g; i < decimalPosition; i += g + 1) {
- digits.insert(decimalPosition - i, groupingSeparator);
- ++decimalPosition;
- ++digitsLength;
- }
- }
- }
-
- /**
- * Replace locale-independent digits with locale-specific ones.
+ * This does the work of String.valueOf(long), but given a double as input
+ * and avoiding our emulated longs. Contrasted with String.valueOf(double),
+ * it ensures (a) there will be no trailing .0, and (b) unwinds E-notation.
*
- * @param digits StringBuilder containing formatted number
- * @param zero locale-specific zero character -- the rest of the digits must
- * be consecutive
+ * @param number the integral value to convert
+ * @return the string representing that integer
*/
- private void localizeDigits(StringBuilder digits, char zero) {
- // don't use digitsLength since we may have added an exponent
- int n = digits.length();
- for (int i = 0; i < n; ++i) {
- char ch = digits.charAt(i);
- if (ch >= '0' && ch <= '9') {
- digits.setCharAt(i, (char) (ch - '0' + zero));
- }
+ private String makeIntString(double number) {
+ String intPart = String.valueOf(number);
+ if (GWT.isScript()) {
+ return intPart; // JavaScript does the right thing for integral doubles
}
- }
+ // ...but bytecode (hosted mode) does not... String.valueOf(double) will
+ // either end in .0 (non internationalized) which we don't want but is
+ // easy, or, for large numbers, it will be E-notation, which is annoying.
+ int digitLen = intPart.length();
+
+ if (intPart.charAt(digitLen - 2) == '.') {
+ return intPart.substring(0, digitLen - 2);
+ }
+ // if we have E notation, (1) the exponent will be positive (else
+ // intValue is 0, which doesn't need E notation), and (2) there will
+ // be a radix dot (String.valueOf() isn't interationalized)
+ int radix = intPart.indexOf('.');
+ int exp = intPart.indexOf('E');
+ int digits = 0;
+ for (int i = exp + 1; i < intPart.length(); i++) {
+ digits = digits * 10 + (intPart.charAt(i) - '0');
+ }
+ digits++; // exp of zero is one int digit...
+ StringBuffer newIntPart = new StringBuffer();
+ newIntPart.append(intPart.substring(0, radix));
+ newIntPart.append(intPart.substring(radix + 1, exp));
+ while (newIntPart.length() < digits) {
+ newIntPart.append('0');
+ }
+ newIntPart.setLength(digits);
+ return newIntPart.toString();
+ }
+
/**
* This method parses affix part of pattern.
*
@@ -1653,87 +1301,141 @@
return pos - start;
}
-
+
/**
- * Remove excess leading zeros or add some if we don't have enough.
+ * This method formats a <code>double</code> in exponential format.
*
- * @param digits
+ * @param number value need to be formated
+ * @param result where the formatted string goes
*/
- private void processLeadingZeros(StringBuilder digits) {
- // make sure we have enough trailing zeros
- if (decimalPosition > digitsLength) {
- while (digitsLength < decimalPosition) {
- digits.append('0');
- ++digitsLength;
- }
+ private void subformatExponential(double number, StringBuffer result) {
+ if (number == 0.0) {
+ subformatFixed(number, result, minimumIntegerDigits);
+ addExponentPart(0, result);
+ return;
}
- if (!useExponentialNotation) {
- // make sure we have the right number of leading zeros
- if (decimalPosition < minimumIntegerDigits) {
- // add leading zeros
- StringBuilder prefix = new StringBuilder();
- while (decimalPosition < minimumIntegerDigits) {
- prefix.append('0');
- ++decimalPosition;
- ++digitsLength;
- }
- digits.insert(0, prefix);
- } else if (decimalPosition > minimumIntegerDigits) {
- // trim excess leading zeros
- int strip = decimalPosition - minimumIntegerDigits;
- for (int i = 0; i < strip; ++i) {
- if (digits.charAt(i) != '0') {
- strip = i;
- break;
- }
- }
- if (strip > 0) {
- digits.delete(0, strip);
- digitsLength -= strip;
- decimalPosition -= strip;
- }
- }
- }
- }
+ int exponent = (int) Math.floor(Math.log(number) / Math.log(10));
+ number /= Math.pow(10, exponent);
- /**
- * Propagate a carry from incrementing the {@code i+1}'th digit.
- *
- * @param digits
- * @param i digit to start incrementing
- */
- private void propagateCarry(StringBuilder digits, int i) {
- boolean carry = true;
- while (carry && i >= 0) {
- char digit = digits.charAt(i);
- if (digit == '9') {
- // set this to zero and keep going
- digits.setCharAt(i--, '0');
+ int minIntDigits = minimumIntegerDigits;
+ if (maximumIntegerDigits > 1 && maximumIntegerDigits > minimumIntegerDigits) {
+ // A repeating range is defined; adjust to it as follows.
+ // If repeat == 3, we have 6,5,4=>3; 3,2,1=>0; 0,-1,-2=>-3;
+ // -3,-4,-5=>-6, etc. This takes into account that the
+ // exponent we have here is off by one from what we expect;
+ // it is for the format 0.MMMMMx10^n.
+ while ((exponent % maximumIntegerDigits) != 0) {
+ number *= 10;
+ exponent--;
+ }
+ minIntDigits = 1;
+ } else {
+ // No repeating range is defined; use minimum integer digits.
+ if (minimumIntegerDigits < 1) {
+ exponent++;
+ number /= 10;
} else {
- digits.setCharAt(i, (char) (digit + 1));
- carry = false;
+ for (int i = 1; i < minimumIntegerDigits; i++) {
+ exponent--;
+ number *= 10;
+ }
}
}
- if (carry) {
- // ran off the front, prepend a 1
- digits.insert(0, '1');
- ++decimalPosition;
- ++digitsLength;
- }
+
+ subformatFixed(number, result, minIntDigits);
+ addExponentPart(exponent, result);
}
/**
- * Round the value at the requested place, propagating any carry backward.
+ * This method formats a <code>double</code> into a fractional
+ * representation.
*
- * @param digits
+ * @param number value need to be formated
+ * @param result result will be written here
+ * @param minIntDigits minimum integer digits
*/
- private void roundValue(StringBuilder digits) {
- // TODO(jat): other rounding modes?
- if (digitsLength > decimalPosition + maximumFractionDigits
- && digits.charAt(decimalPosition + maximumFractionDigits) >= '5') {
- int i = decimalPosition + maximumFractionDigits - 1;
- propagateCarry(digits, i);
+ private void subformatFixed(double number, StringBuffer result,
+ int minIntDigits) {
+ double power = Math.pow(10, maximumFractionDigits);
+ // Use 3 extra digits to allow us to do our own rounding since
+ // Java rounds up on .5 whereas some browsers might use 'round to even'
+ // or other rules.
+
+ // There are cases where more digits would be required to get
+ // guaranteed results, but this at least makes such cases rarer.
+ String fixedString = toFixed(number, maximumFractionDigits + 3);
+
+ double intValue = 0, fracValue = 0;
+ int exponentIndex = fixedString.indexOf('e');
+ if (exponentIndex != -1) {
+ // Large numbers may be returned in exponential notation: such numbers
+ // are integers anyway
+ intValue = Math.floor(number);
+ } else {
+ int decimalIndex = fixedString.indexOf('.');
+ int len = fixedString.length();
+ if (decimalIndex == -1) {
+ decimalIndex = len;
+ }
+ if (decimalIndex > 0) {
+ intValue = Double.parseDouble(fixedString.substring(0, decimalIndex));
+ }
+ if (decimalIndex < len - 1) {
+ fracValue = Double.parseDouble(fixedString.substring(decimalIndex + 1));
+ fracValue = (((int) fracValue) + 500) / 1000;
+ if (fracValue >= power) {
+ fracValue -= power;
+ intValue++;
+ }
+ }
+ }
+
+ boolean fractionPresent = (minimumFractionDigits > 0) || (fracValue > 0);
+
+ String intPart = makeIntString(intValue);
+ String grouping = isCurrencyFormat
+ ? numberConstants.monetaryGroupingSeparator()
+ : numberConstants.groupingSeparator();
+ String decimal = isCurrencyFormat ? numberConstants.monetarySeparator()
+ : numberConstants.decimalSeparator();
+
+ int zeroDelta = numberConstants.zeroDigit().charAt(0) - '0';
+ int digitLen = intPart.length();
+
+ if (intValue > 0 || minIntDigits > 0) {
+ for (int i = digitLen; i < minIntDigits; i++) {
+ result.append(numberConstants.zeroDigit());
+ }
+
+ for (int i = 0; i < digitLen; i++) {
+ result.append((char) (intPart.charAt(i) + zeroDelta));
+
+ if (digitLen - i > 1 && groupingSize > 0
+ && ((digitLen - i) % groupingSize == 1)) {
+ result.append(grouping);
+ }
+ }
+ } else if (!fractionPresent) {
+ // If there is no fraction present, and we haven't printed any
+ // integer digits, then print a zero.
+ result.append(numberConstants.zeroDigit());
+ }
+
+ // Output the decimal separator if we always do so.
+ if (decimalSeparatorAlwaysShown || fractionPresent) {
+ result.append(decimal);
+ }
+
+ // To make sure it lead zero will be kept.
+ String fracPart = makeIntString(Math.floor(fracValue + power + 0.5d));
+ int fracLen = fracPart.length();
+ while (fracPart.charAt(fracLen - 1) == '0' && fracLen > minimumFractionDigits + 1) {
+ fracLen--;
+ }
+
+ for (int i = 1; i < fracLen; i++) {
+ result.append((char) (fracPart.charAt(i) + zeroDelta));
}
}
}
diff --git a/user/src/com/google/gwt/i18n/rebind/MessagesMethodCreator.java b/user/src/com/google/gwt/i18n/rebind/MessagesMethodCreator.java
index 80975fc..a360356 100644
--- a/user/src/com/google/gwt/i18n/rebind/MessagesMethodCreator.java
+++ b/user/src/com/google/gwt/i18n/rebind/MessagesMethodCreator.java
@@ -83,23 +83,7 @@
public String format(StringGenerator out, String subformat, String argName,
JType argType) {
JPrimitiveType argPrimType = argType.isPrimitive();
- if (argPrimType != null) {
- if (argPrimType == JPrimitiveType.BOOLEAN
- || argPrimType == JPrimitiveType.VOID) {
- return "Illegal argument type for number format";
- }
- } else {
- JClassType classType = argType.isClass();
- if (classType == null) {
- return "Unexpected argument type for number format";
- }
- TypeOracle oracle = classType.getOracle();
- JClassType numberType = oracle.findType("java.lang.Number");
- if (!classType.isAssignableTo(numberType)) {
- return "Only Number subclasses may be formatted as a number";
- }
- }
- if (argPrimType == JPrimitiveType.BOOLEAN
+ if (argPrimType == null || argPrimType == JPrimitiveType.BOOLEAN
|| argPrimType == JPrimitiveType.VOID) {
return "Illegal argument type for number format";
}
diff --git a/user/src/com/google/gwt/user/client/rpc/core/java/math/BigDecimal_CustomFieldSerializer.java b/user/src/com/google/gwt/user/client/rpc/core/java/math/BigDecimal_CustomFieldSerializer.java
deleted file mode 100644
index 8bd01ee..0000000
--- a/user/src/com/google/gwt/user/client/rpc/core/java/math/BigDecimal_CustomFieldSerializer.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * 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.
- */
-/*
- * author Richard Zschech
- */
-package com.google.gwt.user.client.rpc.core.java.math;
-
-import com.google.gwt.user.client.rpc.SerializationException;
-import com.google.gwt.user.client.rpc.SerializationStreamReader;
-import com.google.gwt.user.client.rpc.SerializationStreamWriter;
-
-import java.math.BigDecimal;
-
-/**
- * Custom field serializer for BigDecimal.
- */
-public class BigDecimal_CustomFieldSerializer {
-
- public static void deserialize(SerializationStreamReader streamReader,
- BigDecimal instance) {
- }
-
- public static BigDecimal instantiate(SerializationStreamReader streamReader)
- throws SerializationException {
- return new BigDecimal(streamReader.readString());
- }
-
- public static void serialize(SerializationStreamWriter streamWriter,
- BigDecimal instance) throws SerializationException {
- streamWriter.writeString(instance.toString());
- }
-}
diff --git a/user/src/com/google/gwt/user/client/rpc/core/java/math/BigInteger_CustomFieldSerializer.java b/user/src/com/google/gwt/user/client/rpc/core/java/math/BigInteger_CustomFieldSerializer.java
deleted file mode 100644
index 57ed4ba..0000000
--- a/user/src/com/google/gwt/user/client/rpc/core/java/math/BigInteger_CustomFieldSerializer.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * 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.
- */
-/*
- * author Richard Zschech
- */
-package com.google.gwt.user.client.rpc.core.java.math;
-
-import com.google.gwt.user.client.rpc.SerializationException;
-import com.google.gwt.user.client.rpc.SerializationStreamReader;
-import com.google.gwt.user.client.rpc.SerializationStreamWriter;
-
-import java.math.BigInteger;
-
-/**
- * Custom field serializer for BigInteger.
- */
-public class BigInteger_CustomFieldSerializer {
-
- public static void deserialize(SerializationStreamReader streamReader,
- BigInteger instance) {
- }
-
- public static BigInteger instantiate(SerializationStreamReader streamReader)
- throws SerializationException {
- return new BigInteger(streamReader.readString());
- }
-
- public static void serialize(SerializationStreamWriter streamWriter,
- BigInteger instance) throws SerializationException {
- streamWriter.writeString(instance.toString());
- }
-}
diff --git a/user/src/com/google/gwt/user/client/rpc/core/java/math/MathContext_CustomFieldSerializer.java b/user/src/com/google/gwt/user/client/rpc/core/java/math/MathContext_CustomFieldSerializer.java
deleted file mode 100644
index a9b3277..0000000
--- a/user/src/com/google/gwt/user/client/rpc/core/java/math/MathContext_CustomFieldSerializer.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * 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.
- */
-/*
- * author Richard Zschech
- */
-package com.google.gwt.user.client.rpc.core.java.math;
-
-import com.google.gwt.user.client.rpc.SerializationException;
-import com.google.gwt.user.client.rpc.SerializationStreamReader;
-import com.google.gwt.user.client.rpc.SerializationStreamWriter;
-
-import java.math.MathContext;
-import java.math.RoundingMode;
-
-/**
- * Custom field serializer for MathContext.
- */
-public class MathContext_CustomFieldSerializer {
-
- public static void deserialize(SerializationStreamReader streamReader,
- MathContext instance) {
- }
-
- public static MathContext instantiate(SerializationStreamReader streamReader)
- throws SerializationException {
- return new MathContext(streamReader.readInt(),
- RoundingMode.values()[streamReader.readInt()]);
- }
-
- public static void serialize(SerializationStreamWriter streamWriter,
- MathContext instance) throws SerializationException {
- streamWriter.writeInt(instance.getPrecision());
- streamWriter.writeInt(instance.getRoundingMode().ordinal());
- }
-}
diff --git a/user/super/com/google/gwt/emul/java/lang/ArithmeticException.java b/user/super/com/google/gwt/emul/java/lang/ArithmeticException.java
index 235bc2c..faf821e 100644
--- a/user/super/com/google/gwt/emul/java/lang/ArithmeticException.java
+++ b/user/super/com/google/gwt/emul/java/lang/ArithmeticException.java
@@ -16,11 +16,10 @@
package java.lang;
/**
- * NOTE: in GWT this is only thrown for division by zero on longs and
- * BigInteger/BigDecimal.
- * <p>
+ * NOTE: in GWT this is only thrown for division by zero on longs.
+ *
* See <a
- * href="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/ArithmeticException.html">the
+ * href="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/ArrayIndexOutOfBoundsException.html">the
* official Java API doc</a> for details.
*/
public class ArithmeticException extends RuntimeException {
diff --git a/user/super/com/google/gwt/emul/java/lang/Float.java b/user/super/com/google/gwt/emul/java/lang/Float.java
index b3c9576..8d9e849 100644
--- a/user/super/com/google/gwt/emul/java/lang/Float.java
+++ b/user/super/com/google/gwt/emul/java/lang/Float.java
@@ -16,7 +16,7 @@
package java.lang;
/**
- * Wraps a primitive <code>float</code> as an object.
+ * Wraps a primitve <code>float</code> as an object.
*/
public final class Float extends Number implements Comparable<Float> {
public static final float MAX_VALUE = 3.4028235e+38f;
@@ -40,9 +40,7 @@
}
/**
- * @skip Here for shared implementation with Arrays.hashCode.
- * @param f
- * @return hash value of float (currently just truncated to int)
+ * @skip Here for shared implementation with Arrays.hashCode
*/
public static int hashCode(float f) {
return (int) f;
@@ -57,13 +55,7 @@
}-*/;
public static float parseFloat(String s) throws NumberFormatException {
- double doubleValue = __parseAndValidateDouble(s);
- if (doubleValue > Float.MAX_VALUE) {
- return Float.POSITIVE_INFINITY;
- } else if (doubleValue < -Float.MAX_VALUE) {
- return Float.NEGATIVE_INFINITY;
- }
- return (float) doubleValue;
+ return (float) __parseAndValidateDouble(s);
}
public static String toString(float b) {
diff --git a/user/super/com/google/gwt/emul/java/math/BigDecimal.java b/user/super/com/google/gwt/emul/java/math/BigDecimal.java
deleted file mode 100644
index 569918e..0000000
--- a/user/super/com/google/gwt/emul/java/math/BigDecimal.java
+++ /dev/null
@@ -1,2979 +0,0 @@
-/*
- * 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;
-
-import com.google.gwt.core.client.JavaScriptObject;
-
-import java.io.Serializable;
-
-/**
- * This class represents immutable arbitrary precision decimal numbers. Each
- * {@code BigDecimal} instance is represented with a unscaled arbitrary
- * precision mantissa (the unscaled value) and a scale. The value of the {@code
- * BigDecimal} is {@code unscaledValue} 10^(-{@code scale}).
- */
-public class BigDecimal extends Number implements Comparable<BigDecimal>,
- Serializable {
-
- /**
- * The constant one as a {@code BigDecimal}.
- */
- public static final BigDecimal ONE = new BigDecimal(1, 0);
-
- /**
- * Rounding mode to round towards positive infinity. For positive values this
- * rounding mode behaves as {@link #ROUND_UP}, for negative values as
- * {@link #ROUND_DOWN}.
- *
- * @see RoundingMode#CEILING
- */
- public static final int ROUND_CEILING = 2;
-
- /**
- * Rounding mode where the values are rounded towards zero.
- *
- * @see RoundingMode#DOWN
- */
- public static final int ROUND_DOWN = 1;
-
- /**
- * Rounding mode to round towards negative infinity. For positive values this
- * rounding mode behaves as {@link #ROUND_DOWN}, for negative values as
- * {@link #ROUND_UP}.
- *
- * @see RoundingMode#FLOOR
- */
- public static final int ROUND_FLOOR = 3;
-
- /**
- * Rounding mode where values are rounded towards the nearest neighbor. Ties
- * are broken by rounding down.
- *
- * @see RoundingMode#HALF_DOWN
- */
- public static final int ROUND_HALF_DOWN = 5;
-
- /**
- * Rounding mode where values are rounded towards the nearest neighbor. Ties
- * are broken by rounding to the even neighbor.
- *
- * @see RoundingMode#HALF_EVEN
- */
- public static final int ROUND_HALF_EVEN = 6;
-
- /**
- * Rounding mode where values are rounded towards the nearest neighbor. Ties
- * are broken by rounding up.
- *
- * @see RoundingMode#HALF_UP
- */
- public static final int ROUND_HALF_UP = 4;
-
- /**
- * Rounding mode where the rounding operations throws an {@code
- * ArithmeticException} for the case that rounding is necessary, i.e. for the
- * case that the value cannot be represented exactly.
- *
- * @see RoundingMode#UNNECESSARY
- */
- public static final int ROUND_UNNECESSARY = 7;
-
- /**
- * Rounding mode where positive values are rounded towards positive infinity
- * and negative values towards negative infinity.
- *
- * @see RoundingMode#UP
- */
- public static final int ROUND_UP = 0;
-
- /**
- * The constant ten as a {@code BigDecimal}.
- */
- public static final BigDecimal TEN = new BigDecimal(10, 0);
-
- /**
- * The constant zero as a {@code BigDecimal}.
- */
- public static final BigDecimal ZERO = new BigDecimal(0, 0);
-
- protected static JavaScriptObject unscaledRegex;
-
- private static final int BI_SCALED_BY_ZERO_LENGTH = 11;
-
- /**
- * An array with the first <code>BigInteger</code> scaled by zero. (
- * <code>[0,0],[1,0],...,[10,0]</code>).
- */
- private static final BigDecimal BI_SCALED_BY_ZERO[] = new BigDecimal[BI_SCALED_BY_ZERO_LENGTH];
-
- /**
- * An array filled with characters <code>'0'</code>.
- */
- private static final char[] CH_ZEROS = new char[100];
-
- private static final double[] DOUBLE_FIVE_POW = new double[] {
- 1D, 5D, 25D, 125D, 625D, 3125D, 15625D, 78125D, 390625D, 1953125D,
- 9765625D, 48828125D, 244140625D, 1220703125D, 6103515625D, 30517578125D,
- 152587890625D, 762939453125D, 3814697265625D, 19073486328125D,
- 95367431640625D, 476837158203125D, 2384185791015625D,};
-
- private static final int[] DOUBLE_FIVE_POW_BIT_LENGTH = new int[DOUBLE_FIVE_POW.length];
-
- /**
- * An array with powers of ten that fit in the type <code>double</code> (
- * <code>10^0,10^1,...,10^18</code>).
- */
- private static final double[] DOUBLE_TEN_POW = new double[] {
- 1D, 10D, 100D, 1000D, 10000D, 100000D, 1000000D, 10000000D, 100000000D,
- 1000000000D, 10000000000D, 100000000000D, 1000000000000D,
- 10000000000000D, 100000000000000D,};
-
- private static final int[] DOUBLE_TEN_POW_BIT_LENGTH = new int[DOUBLE_TEN_POW.length];
-
- /**
- * An array with powers of five that fit in the type <code>double</code> (
- * <code>5^0,5^1,...,5^27</code>).
- */
- private static final BigInteger FIVE_POW[];
- /**
- * The double closer to <code>Log10(2)</code>.
- */
- private static final double LOG10_2 = 0.3010299956639812;
-
- /**
- * This is the serialVersionUID used by the sun implementation.
- */
- private static final long serialVersionUID = 6108874887143696463L;
-
- /**
- * An array with powers of ten that fit in the type <code>double</code> (
- * <code>10^0,10^1,...,10^18</code>).
- */
- private static final BigInteger TEN_POW[];
-
- /**
- * An array with the zero number scaled by the first positive scales. (
- * <code>0*10^0, 0*10^1, ..., 0*10^10</code>).
- */
- private static final BigDecimal ZERO_SCALED_BY[] = new BigDecimal[11];
-
- static {
- // To fill all static arrays.
- int i = 0;
-
- for (; i < ZERO_SCALED_BY.length; i++) {
- BI_SCALED_BY_ZERO[i] = new BigDecimal(i, 0);
- ZERO_SCALED_BY[i] = new BigDecimal(0, i);
- CH_ZEROS[i] = '0';
- }
-
- for (; i < CH_ZEROS.length; i++) {
- CH_ZEROS[i] = '0';
- }
- for (int j = 0; j < DOUBLE_FIVE_POW_BIT_LENGTH.length; j++) {
- DOUBLE_FIVE_POW_BIT_LENGTH[j] = bitLength(DOUBLE_FIVE_POW[j]);
- }
- for (int j = 0; j < DOUBLE_TEN_POW_BIT_LENGTH.length; j++) {
- DOUBLE_TEN_POW_BIT_LENGTH[j] = bitLength(DOUBLE_TEN_POW[j]);
- }
-
- // Taking the references of useful powers.
- TEN_POW = Multiplication.bigTenPows;
- FIVE_POW = Multiplication.bigFivePows;
- }
-
- /**
- * Returns a new {@code BigDecimal} instance whose value is equal to {@code
- * val}. The new decimal is constructed as if the {@code BigDecimal(String)}
- * constructor is called with an argument which is equal to {@code
- * Double.toString(val)}. For example, {@code valueOf("0.1")} is converted to
- * (unscaled=1, scale=1), although the double {@code 0.1} cannot be
- * represented exactly as a double value. In contrast to that, a new {@code
- * BigDecimal(0.1)} instance has the value {@code
- * 0.1000000000000000055511151231257827021181583404541015625} with an unscaled
- * value {@code 1000000000000000055511151231257827021181583404541015625} and
- * the scale {@code 55}.
- *
- * @param val double value to be converted to a {@code BigDecimal}.
- * @return {@code BigDecimal} instance with the value {@code val}.
- * @throws NumberFormatException if {@code val} is infinite or {@code val} is
- * not a number
- */
- public static BigDecimal valueOf(double val) {
- if (Double.isInfinite(val) || Double.isNaN(val)) {
- // math.03=Infinity or NaN
- throw new NumberFormatException("Infinite or NaN"); //$NON-NLS-1$
- }
- return new BigDecimal(Double.toString(val));
- }
-
- /**
- * Returns a new {@code BigDecimal} instance whose value is equal to {@code
- * unscaledVal}. The scale of the result is {@code 0}, and its unscaled value
- * is {@code unscaledVal}.
- *
- * @param unscaledVal value to be converted to a {@code BigDecimal}.
- * @return {@code BigDecimal} instance with the value {@code unscaledVal}.
- */
- public static BigDecimal valueOf(long unscaledVal) {
- if ((unscaledVal >= 0) && (unscaledVal < BI_SCALED_BY_ZERO_LENGTH)) {
- return BI_SCALED_BY_ZERO[(int) unscaledVal];
- }
- return new BigDecimal(unscaledVal, 0);
- }
-
- /**
- * Returns a new {@code BigDecimal} instance whose value is equal to {@code
- * unscaledVal} 10^(-{@code scale}). The scale of the result is {@code scale},
- * and its unscaled value is {@code unscaledVal}.
- *
- * @param unscaledVal unscaled value to be used to construct the new {@code
- * BigDecimal}.
- * @param scale scale to be used to construct the new {@code BigDecimal}.
- * @return {@code BigDecimal} instance with the value {@code unscaledVal}*
- * 10^(-{@code unscaledVal}).
- */
- public static BigDecimal valueOf(long unscaledVal, int scale) {
- if (scale == 0) {
- return valueOf(unscaledVal);
- }
- if ((unscaledVal == 0) && (scale >= 0) && (scale < ZERO_SCALED_BY.length)) {
- return ZERO_SCALED_BY[scale];
- }
- return new BigDecimal(unscaledVal, scale);
- }
-
- private static BigDecimal addAndMult10(BigDecimal thisValue,
- BigDecimal augend, double diffScale) {
- if (diffScale < DOUBLE_TEN_POW.length
- && Math.max(thisValue.bitLength, augend.bitLength
- + DOUBLE_TEN_POW_BIT_LENGTH[(int) diffScale]) + 1 < 54) {
- return valueOf(thisValue.smallValue + augend.smallValue
- * DOUBLE_TEN_POW[(int) diffScale], thisValue.scale);
- }
- return new BigDecimal(thisValue.getUnscaledValue().add(
- Multiplication.multiplyByTenPow(augend.getUnscaledValue(),
- (int) diffScale)), thisValue.scale);
- }
-
- private static int bitLength(double sv) {
- long smallValue = (long) sv;
- if (smallValue < 0) {
- smallValue = ~smallValue;
- }
- return 64 - Long.numberOfLeadingZeros(smallValue);
- }
-
- private static int bitLength(long smallValue) {
- if (smallValue < 0) {
- smallValue = ~smallValue;
- }
- return 64 - Long.numberOfLeadingZeros(smallValue);
- }
-
- private static BigDecimal divideBigIntegers(BigInteger scaledDividend,
- BigInteger scaledDivisor, int scale, RoundingMode roundingMode) {
-
- BigInteger[] quotAndRem = scaledDividend.divideAndRemainder(scaledDivisor); // quotient
- // and
- // remainder
- // If after division there is a remainder...
- BigInteger quotient = quotAndRem[0];
- BigInteger remainder = quotAndRem[1];
- if (remainder.signum() == 0) {
- return new BigDecimal(quotient, scale);
- }
- int sign = scaledDividend.signum() * scaledDivisor.signum();
- int compRem; // 'compare to remainder'
- if (scaledDivisor.bitLength() < 54) {
- long rem = remainder.longValue();
- long divisor = scaledDivisor.longValue();
- compRem = longCompareTo(Math.abs(rem) << 1, Math.abs(divisor));
- // To look if there is a carry
- compRem = roundingBehavior(quotient.testBit(0) ? 1 : 0, sign
- * (5 + compRem), roundingMode);
-
- } else {
- // Checking if: remainder * 2 >= scaledDivisor
- compRem = remainder.abs().shiftLeftOneBit().compareTo(scaledDivisor.abs());
- compRem = roundingBehavior(quotient.testBit(0) ? 1 : 0, sign
- * (5 + compRem), roundingMode);
- }
- if (compRem != 0) {
- if (quotient.bitLength() < 54) {
- return valueOf(quotient.longValue() + compRem, scale);
- }
- quotient = quotient.add(BigInteger.valueOf(compRem));
- return new BigDecimal(quotient, scale);
- }
- // Constructing the result with the appropriate unscaled value
- return new BigDecimal(quotient, scale);
- }
-
- // TODO convert to double math dont use longs
- private static BigDecimal dividePrimitiveLongs(long scaledDividend,
- long scaledDivisor, int scale, RoundingMode roundingMode) {
- long quotient = scaledDividend / scaledDivisor;
- long remainder = scaledDividend % scaledDivisor;
- int sign = Long.signum(scaledDividend) * Long.signum(scaledDivisor);
- if (remainder != 0) {
- // Checking if: remainder * 2 >= scaledDivisor
- int compRem; // 'compare to remainder'
- compRem = longCompareTo(Math.abs(remainder) << 1, Math.abs(scaledDivisor));
- // To look if there is a carry
- quotient += roundingBehavior(((int) quotient) & 1, sign * (5 + compRem),
- roundingMode);
- }
- // Constructing the result with the appropriate unscaled value
- return valueOf(quotient, scale);
- }
-
- private static int longCompareTo(long value1, long value2) {
- return value1 > value2 ? 1 : (value1 < value2 ? -1 : 0);
- }
-
- private static native double parseUnscaled(String str) /*-{
- var unscaledRegex = @java.math.BigDecimal::unscaledRegex;
- if (!unscaledRegex) {
- unscaledRegex = @java.math.BigDecimal::unscaledRegex = /^[+-]?\d*$/i;
- }
- if (unscaledRegex.test(str)) {
- return parseInt(str, 10);
- } else {
- return Number.NaN;
- }
- }-*/;
-
- /**
- * Return an increment that can be -1,0 or 1, depending of {@code
- * roundingMode}.
- *
- * @param parityBit can be 0 or 1, it's only used in the case {@code
- * HALF_EVEN}
- * @param fraction the mantisa to be analyzed
- * @param roundingMode the type of rounding
- * @return the carry propagated after rounding
- */
- private static int roundingBehavior(int parityBit, int fraction,
- RoundingMode roundingMode) {
- int increment = 0; // the carry after rounding
-
- switch (roundingMode) {
- case UNNECESSARY:
- if (fraction != 0) {
- // math.08=Rounding necessary
- throw new ArithmeticException("Rounding necessary"); //$NON-NLS-1$
- }
- break;
- case UP:
- increment = Integer.signum(fraction);
- break;
- case DOWN:
- break;
- case CEILING:
- increment = Math.max(Integer.signum(fraction), 0);
- break;
- case FLOOR:
- increment = Math.min(Integer.signum(fraction), 0);
- break;
- case HALF_UP:
- if (Math.abs(fraction) >= 5) {
- increment = Integer.signum(fraction);
- }
- break;
- case HALF_DOWN:
- if (Math.abs(fraction) > 5) {
- increment = Integer.signum(fraction);
- }
- break;
- case HALF_EVEN:
- if (Math.abs(fraction) + parityBit > 5) {
- increment = Integer.signum(fraction);
- }
- break;
- }
- return increment;
- }
-
- /**
- * It tests if a scale of type {@code long} fits in 32 bits. It returns the
- * same scale being casted to {@code int} type when is possible, otherwise
- * throws an exception.
- *
- * @param doubleScale a double bit scale
- * @return a 32 bit scale when is possible
- * @throws ArithmeticException when {@code scale} doesn't fit in {@code int}
- * type
- * @see #scale
- */
- private static int toIntScale(double doubleScale) {
- if (doubleScale < Integer.MIN_VALUE) {
- // math.09=Overflow
- throw new ArithmeticException("Overflow"); //$NON-NLS-1$
- } else if (doubleScale > Integer.MAX_VALUE) {
- // math.0A=Underflow
- throw new ArithmeticException("Underflow"); //$NON-NLS-1$
- } else {
- return (int) doubleScale;
- }
- }
-
- /**
- * Convert a double to a string with {@code digits} precision. The resulting
- * string may still be in exponential notation.
- *
- * @param d double value
- * @param digits number of digits of precision to include
- * @return non-localized string representation of {@code d}
- */
- private static native String toPrecision(double d, int digits) /*-{
- return d.toPrecision(digits);
- }-*/;
-
- private static BigDecimal valueOf(double smallValue, double scale) {
- return new BigDecimal(smallValue, scale);
- }
-
- /**
- * It returns the value 0 with the most approximated scale of type {@code int}
- * . if {@code longScale > Integer.MAX_VALUE} the scale will be {@code
- * Integer.MAX_VALUE}; if {@code longScale < Integer.MIN_VALUE} the scale will
- * be {@code Integer.MIN_VALUE}; otherwise {@code longScale} is casted to the
- * type {@code int}.
- *
- * @param doubleScale the scale to which the value 0 will be scaled.
- * @return the value 0 scaled by the closer scale of type {@code int}.
- * @see #scale
- */
- private static BigDecimal zeroScaledBy(double doubleScale) {
- if (doubleScale == (int) doubleScale) {
- return valueOf(0, (int) doubleScale);
- }
- if (doubleScale >= 0) {
- return new BigDecimal(0, Integer.MAX_VALUE);
- }
- return new BigDecimal(0, Integer.MIN_VALUE);
- }
-
- private transient int bitLength;
-
- /**
- * Cache for the hash code.
- */
- private transient int hashCode;
-
- /**
- * The arbitrary precision integer (unscaled value) in the internal
- * representation of {@code BigDecimal}.
- */
- private BigInteger intVal;
-
- /**
- * Constructs a new {@code BigDecimal} instance from the 64bit double {@code
- * val}. The constructed big decimal is equivalent to the given double. For
- * example, {@code new BigDecimal(0.1)} is equal to {@code
- * 0.1000000000000000055511151231257827021181583404541015625}. This happens as
- * {@code 0.1} cannot be represented exactly in binary.
- * <p>
- * To generate a big decimal instance which is equivalent to {@code 0.1} use
- * the {@code BigDecimal(String)} constructor.
- *
- * @param val double value to be converted to a {@code BigDecimal} instance.
- * @throws NumberFormatException if {@code val} is infinity or not a number.
- */
- // public BigDecimal(double val) {
- // if (Double.isInfinite(val) || Double.isNaN(val)) {
- // // math.03=Infinity or NaN
- // throw new NumberFormatException("Infinite or NaN"); //$NON-NLS-1$
- // }
- // long bits = Double.doubleToLongBits(val); // IEEE-754
- // long mantisa;
- // int trailingZeros;
- // // Extracting the exponent, note that the bias is 1023
- // scale = 1075 - (int)((bits >> 52) & 0x7FFL);
- // // Extracting the 52 bits of the mantisa.
- // mantisa = (scale == 1075) ? (bits & 0xFFFFFFFFFFFFFL) << 1
- // : (bits & 0xFFFFFFFFFFFFFL) | 0x10000000000000L;
- // if (mantisa == 0) {
- // scale = 0;
- // precision = 1;
- // }
- // // To simplify all factors '2' in the mantisa
- // if (scale > 0) {
- // trailingZeros = Math.min(scale, Long.numberOfTrailingZeros(mantisa));
- // mantisa >>>= trailingZeros;
- // scale -= trailingZeros;
- // }
- // // Calculating the new unscaled value and the new scale
- // if((bits >> 63) != 0) {
- // mantisa = -mantisa;
- // }
- // int mantisaBits = bitLength(mantisa);
- // if (scale < 0) {
- // bitLength = mantisaBits == 0 ? 0 : mantisaBits - scale;
- // if(bitLength < 64) {
- // smallValue = mantisa << (-scale);
- // } else {
- // intVal = BigInteger.valueOf(mantisa).shiftLeft(-scale);
- // }
- // scale = 0;
- // } else if (scale > 0) {
- // // m * 2^e = (m * 5^(-e)) * 10^e
- // if(scale < LONG_FIVE_POW.length
- // && mantisaBits+LONG_FIVE_POW_BIT_LENGTH[scale] < 64) {
- // smallValue = mantisa * LONG_FIVE_POW[scale];
- // bitLength = bitLength(smallValue);
- // } else {
- // setUnscaledValue(Multiplication.multiplyByFivePow(BigInteger.valueOf(mantisa),
- // scale));
- // }
- // } else { // scale == 0
- // smallValue = mantisa;
- // bitLength = mantisaBits;
- // }
- // }
- /**
- * Constructs a new {@code BigDecimal} instance from the 64bit double {@code
- * val}. The constructed big decimal is equivalent to the given double. For
- * example, {@code new BigDecimal(0.1)} is equal to {@code
- * 0.1000000000000000055511151231257827021181583404541015625}. This happens as
- * {@code 0.1} cannot be represented exactly in binary.
- * <p>
- * To generate a big decimal instance which is equivalent to {@code 0.1} use
- * the {@code BigDecimal(String)} constructor.
- *
- * @param val double value to be converted to a {@code BigDecimal} instance.
- * @param mc rounding mode and precision for the result of this operation.
- * @throws NumberFormatException if {@code val} is infinity or not a number.
- * @throws ArithmeticException if {@code mc.precision > 0} and {@code
- * mc.roundingMode == UNNECESSARY} and the new big decimal cannot be
- * represented within the given precision without rounding.
- */
- // public BigDecimal(double val, MathContext mc) {
- // this(val);
- // inplaceRound(mc);
- // }
- /**
- * Represent the number of decimal digits in the unscaled value. This
- * precision is calculated the first time, and used in the following calls of
- * method <code>precision()</code>. Note that some call to the private method
- * <code>inplaceRound()</code> could update this field.
- *
- * @see #precision()
- * @see #inplaceRound(MathContext)
- */
- private transient int precision;
-
- private double scale;
-
- private transient double smallValue;
-
- /**
- * The <code>String</code> representation is cached.
- */
- private transient String toStringImage;
-
- /**
- * Constructs a new {@code BigDecimal} instance from the given big integer
- * {@code val}. The scale of the result is {@code 0}.
- *
- * @param val {@code BigInteger} value to be converted to a {@code BigDecimal}
- * instance.
- */
- public BigDecimal(BigInteger val) {
- this(val, 0);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from a given unscaled value
- * {@code unscaledVal} and a given scale. The value of this instance is
- * {@code unscaledVal} 10^(-{@code scale}).
- *
- * @param unscaledVal {@code BigInteger} representing the unscaled value of
- * this {@code BigDecimal} instance.
- * @param scale scale of this {@code BigDecimal} instance.
- * @throws NullPointerException if {@code unscaledVal == null}.
- */
- public BigDecimal(BigInteger unscaledVal, int scale) {
- if (unscaledVal == null) {
- throw new NullPointerException();
- }
- this.scale = scale;
- setUnscaledValue(unscaledVal);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from a given unscaled value
- * {@code unscaledVal} and a given scale. The value of this instance is
- * {@code unscaledVal} 10^(-{@code scale}). The result is rounded according to
- * the specified math context.
- *
- * @param unscaledVal {@code BigInteger} representing the unscaled value of
- * this {@code BigDecimal} instance.
- * @param scale scale of this {@code BigDecimal} instance.
- * @param mc rounding mode and precision for the result of this operation.
- * @throws ArithmeticException if {@code mc.precision > 0} and {@code
- * mc.roundingMode == UNNECESSARY} and the new big decimal cannot be
- * represented within the given precision without rounding.
- * @throws NullPointerException if {@code unscaledVal == null}.
- */
- public BigDecimal(BigInteger unscaledVal, int scale, MathContext mc) {
- this(unscaledVal, scale);
- inplaceRound(mc);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from the given big integer
- * {@code val}. The scale of the result is {@code 0}.
- *
- * @param val {@code BigInteger} value to be converted to a {@code BigDecimal}
- * instance.
- * @param mc rounding mode and precision for the result of this operation.
- * @throws ArithmeticException if {@code mc.precision > 0} and {@code
- * mc.roundingMode == UNNECESSARY} and the new big decimal cannot be
- * represented within the given precision without rounding.
- */
- public BigDecimal(BigInteger val, MathContext mc) {
- this(val);
- inplaceRound(mc);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from a string representation
- * given as a character array.
- *
- * @param in array of characters containing the string representation of this
- * {@code BigDecimal}.
- * @throws NullPointerException if {@code in == null}.
- * @throws NumberFormatException if {@code in} does not contain a valid string
- * representation of a big decimal.
- */
- public BigDecimal(char[] in) {
- this(in, 0, in.length);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from a string representation
- * given as a character array.
- *
- * @param in array of characters containing the string representation of this
- * {@code BigDecimal}.
- * @param offset first index to be copied.
- * @param len number of characters to be used.
- * @throws NullPointerException if {@code in == null}.
- * @throws NumberFormatException if {@code offset < 0} or {@code len <= 0} or
- * {@code offset+len-1 < 0} or {@code offset+len-1 >= in.length}.
- * @throws NumberFormatException if in does not contain a valid string
- * representation of a big decimal.
- */
- public BigDecimal(char[] in, int offset, int len) {
- try {
- initFrom(new String(in, offset, len));
- } catch (StringIndexOutOfBoundsException e) {
- throw new NumberFormatException(e.getMessage());
- }
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from a string representation
- * given as a character array.
- *
- * @param in array of characters containing the string representation of this
- * {@code BigDecimal}.
- * @param offset first index to be copied.
- * @param len number of characters to be used.
- * @param mc rounding mode and precision for the result of this operation.
- * @throws NullPointerException if {@code in == null}.
- * @throws NumberFormatException if {@code offset < 0} or {@code len <= 0} or
- * {@code offset+len-1 < 0} or {@code offset+len-1 >= in.length}.
- * @throws NumberFormatException if {@code in} does not contain a valid string
- * representation of a big decimal.
- * @throws ArithmeticException if {@code mc.precision > 0} and {@code
- * mc.roundingMode == UNNECESSARY} and the new big decimal cannot be
- * represented within the given precision without rounding.
- */
- public BigDecimal(char[] in, int offset, int len, MathContext mc) {
- this(in, offset, len);
- inplaceRound(mc);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from a string representation
- * given as a character array. The result is rounded according to the
- * specified math context.
- *
- * @param in array of characters containing the string representation of this
- * {@code BigDecimal}.
- * @param mc rounding mode and precision for the result of this operation.
- * @throws NullPointerException if {@code in == null}.
- * @throws NumberFormatException if {@code in} does not contain a valid string
- * representation of a big decimal.
- * @throws ArithmeticException if {@code mc.precision > 0} and {@code
- * mc.roundingMode == UNNECESSARY} and the new big decimal cannot be
- * represented within the given precision without rounding.
- */
- public BigDecimal(char[] in, MathContext mc) {
- this(in, 0, in.length);
- inplaceRound(mc);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from the given double {@code
- * val}. The scale of the result is 0.
- *
- * @param val double value to be converted to a {@code BigDecimal} instance.
- * @throws NumberFormatException if {@code val} is infinite or a NaN
- */
- public BigDecimal(double val) {
- if (Double.isInfinite(val) || Double.isNaN(val)) {
- // math.03=Infinity or NaN
- throw new NumberFormatException("Infinite or NaN"); //$NON-NLS-1$
- }
- initFrom(toPrecision(val, 20));
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from the given double {@code
- * val}. The scale of the result is 0. The result is rounded according to the
- * specified math context.
- *
- * @param val double value to be converted to a {@code BigDecimal} instance.
- * @param mc rounding mode and precision for the result of this operation.
- * @throws NumberFormatException if {@code val} is infinite or a NaN
- * @throws ArithmeticException if {@code mc.precision > 0} and {@code
- * mc.roundingMode == UNNECESSARY} and the new big decimal cannot be
- * represented within the given precision without rounding.
- */
- public BigDecimal(double val, MathContext mc) {
- if (Double.isInfinite(val) || Double.isNaN(val)) {
- // math.03=Infinity or NaN
- throw new NumberFormatException("Infinite or NaN"); //$NON-NLS-1$
- }
- initFrom(toPrecision(val, 20));
- inplaceRound(mc);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from the given int {@code val}
- * . The scale of the result is 0.
- *
- * @param val int value to be converted to a {@code BigDecimal} instance.
- */
- public BigDecimal(int val) {
- this(val, 0);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from the given int {@code val}
- * . The scale of the result is {@code 0}. The result is rounded according to
- * the specified math context.
- *
- * @param val int value to be converted to a {@code BigDecimal} instance.
- * @param mc rounding mode and precision for the result of this operation.
- * @throws ArithmeticException if {@code mc.precision > 0} and {@code
- * c.roundingMode == UNNECESSARY} and the new big decimal cannot be
- * represented within the given precision without rounding.
- */
- public BigDecimal(int val, MathContext mc) {
- this(val, 0);
- inplaceRound(mc);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from the given long {@code
- * val}. The scale of the result is {@code 0}.
- *
- * @param val long value to be converted to a {@code BigDecimal} instance.
- */
- public BigDecimal(long val) {
- this(val, 0);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from the given long {@code
- * val}. The scale of the result is {@code 0}. The result is rounded according
- * to the specified math context.
- *
- * @param val long value to be converted to a {@code BigDecimal} instance.
- * @param mc rounding mode and precision for the result of this operation.
- * @throws ArithmeticException if {@code mc.precision > 0} and {@code
- * mc.roundingMode == UNNECESSARY} and the new big decimal cannot be
- * represented within the given precision without rounding.
- */
- public BigDecimal(long val, MathContext mc) {
- this(val);
- inplaceRound(mc);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from a string representation.
- *
- * @param val string containing the string representation of this {@code
- * BigDecimal}.
- * @throws NumberFormatException if {@code val} does not contain a valid
- * string representation of a big decimal.
- */
- public BigDecimal(String val) {
- initFrom(val);
- }
-
- /**
- * Constructs a new {@code BigDecimal} instance from a string representation.
- * The result is rounded according to the specified math context.
- *
- * @param val string containing the string representation of this {@code
- * BigDecimal}.
- * @param mc rounding mode and precision for the result of this operation.
- * @throws NumberFormatException if {@code val} does not contain a valid
- * string representation of a big decimal.
- * @throws ArithmeticException if {@code mc.precision > 0} and {@code
- * mc.roundingMode == UNNECESSARY} and the new big decimal cannot be
- * represented within the given precision without rounding.
- */
- public BigDecimal(String val, MathContext mc) {
- this(val.toCharArray(), 0, val.length());
- inplaceRound(mc);
- }
-
- private BigDecimal(BigInteger unscaledVal, double scale) {
- if (unscaledVal == null) {
- throw new NullPointerException();
- }
- this.scale = scale;
- setUnscaledValue(unscaledVal);
- }
-
- private BigDecimal(double smallValue, double scale) {
- this.smallValue = smallValue;
- this.scale = scale;
- this.bitLength = bitLength(smallValue);
- }
-
- private BigDecimal(long smallValue, int scale) {
- this.scale = scale;
- this.bitLength = bitLength(smallValue);
- if (bitLength < 54) {
- this.smallValue = smallValue;
- } else {
- this.intVal = BigInteger.valueOf(smallValue);
- }
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is the absolute value of
- * {@code this}. The scale of the result is the same as the scale of this.
- *
- * @return {@code abs(this)}
- */
- public BigDecimal abs() {
- return ((signum() < 0) ? negate() : this);
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is the absolute value of
- * {@code this}. The result is rounded according to the passed context {@code
- * mc}.
- *
- * @param mc rounding mode and precision for the result of this operation.
- * @return {@code abs(this)}
- */
- public BigDecimal abs(MathContext mc) {
- return round(mc).abs();
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this + augend}. The
- * scale of the result is the maximum of the scales of the two arguments.
- *
- * @param augend value to be added to {@code this}.
- * @return {@code this + augend}.
- * @throws NullPointerException if {@code augend == null}.
- */
- public BigDecimal add(BigDecimal augend) {
- double diffScale = this.scale - augend.scale;
- // Fast return when some operand is zero
- if (this.isZero()) {
- if (diffScale <= 0) {
- return augend;
- }
- if (augend.isZero()) {
- return this;
- }
- } else if (augend.isZero()) {
- if (diffScale >= 0) {
- return this;
- }
- }
- // Let be: this = [u1,s1] and augend = [u2,s2]
- if (diffScale == 0) {
- // case s1 == s2: [u1 + u2 , s1]
- if (Math.max(this.bitLength, augend.bitLength) + 1 < 54) {
- return valueOf(this.smallValue + augend.smallValue, this.scale);
- }
- return new BigDecimal(this.getUnscaledValue().add(
- augend.getUnscaledValue()), this.scale);
- } else if (diffScale > 0) {
- // case s1 > s2 : [(u1 + u2) * 10 ^ (s1 - s2) , s1]
- return addAndMult10(this, augend, diffScale);
- } else {
- // case s2 > s1 : [(u2 + u1) * 10 ^ (s2 - s1) , s2]
- return addAndMult10(augend, this, -diffScale);
- }
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this + augend}. The
- * result is rounded according to the passed context {@code mc}.
- *
- * @param augend value to be added to {@code this}.
- * @param mc rounding mode and precision for the result of this operation.
- * @return {@code this + augend}.
- * @throws NullPointerException if {@code augend == null} or {@code mc ==
- * null}.
- */
- public BigDecimal add(BigDecimal augend, MathContext mc) {
- BigDecimal larger; // operand with the largest unscaled value
- BigDecimal smaller; // operand with the smallest unscaled value
- BigInteger tempBI;
- double diffScale = this.scale - augend.scale;
- int largerSignum;
- // Some operand is zero or the precision is infinity
- if ((augend.isZero()) || (this.isZero()) || (mc.getPrecision() == 0)) {
- return add(augend).round(mc);
- }
- // Cases where there is room for optimizations
- if (this.approxPrecision() < diffScale - 1) {
- larger = augend;
- smaller = this;
- } else if (augend.approxPrecision() < -diffScale - 1) {
- larger = this;
- smaller = augend;
- } else {
- // No optimization is done
- return add(augend).round(mc);
- }
- if (mc.getPrecision() >= larger.approxPrecision()) {
- // No optimization is done
- return add(augend).round(mc);
- }
- // Cases where it's unnecessary to add two numbers with very different
- // scales
- largerSignum = larger.signum();
- if (largerSignum == smaller.signum()) {
- tempBI = Multiplication.multiplyByPositiveInt(larger.getUnscaledValue(),
- 10).add(BigInteger.valueOf(largerSignum));
- } else {
- tempBI = larger.getUnscaledValue().subtract(
- BigInteger.valueOf(largerSignum));
- tempBI = Multiplication.multiplyByPositiveInt(tempBI, 10).add(
- BigInteger.valueOf(largerSignum * 9));
- }
- // Rounding the improved adding
- larger = new BigDecimal(tempBI, larger.scale + 1);
- return larger.round(mc);
- }
-
- /**
- * Returns this {@code BigDecimal} as a byte value if it has no fractional
- * part and if its value fits to the byte range ([-128..127]). If these
- * conditions are not met, an {@code ArithmeticException} is thrown.
- *
- * @return this {@code BigDecimal} as a byte value.
- * @throws ArithmeticException if rounding is necessary or the number doesn't
- * fit in a byte.
- */
- public byte byteValueExact() {
- return (byte) valueExact(8);
- }
-
- /**
- * Compares this {@code BigDecimal} with {@code val}. Returns one of the three
- * values {@code 1}, {@code 0}, or {@code -1}. The method behaves as if
- * {@code this.subtract(val)} is computed. If this difference is > 0 then 1 is
- * returned, if the difference is < 0 then -1 is returned, and if the
- * difference is 0 then 0 is returned. This means, that if two decimal
- * instances are compared which are equal in value but differ in scale, then
- * these two instances are considered as equal.
- *
- * @param val value to be compared with {@code this}.
- * @return {@code 1} if {@code this > val}, {@code -1} if {@code this < val},
- * {@code 0} if {@code this == val}.
- * @throws NullPointerException if {@code val == null}.
- */
- public int compareTo(BigDecimal val) {
- int thisSign = signum();
- int valueSign = val.signum();
-
- if (thisSign == valueSign) {
- if (this.scale == val.scale && this.bitLength < 54 && val.bitLength < 54) {
- return (smallValue < val.smallValue) ? -1
- : (smallValue > val.smallValue) ? 1 : 0;
- }
- double diffScale = this.scale - val.scale;
- double diffPrecision = this.approxPrecision() - val.approxPrecision();
- if (diffPrecision > diffScale + 1) {
- return thisSign;
- } else if (diffPrecision < diffScale - 1) {
- return -thisSign;
- } else {
- // thisSign == val.signum() and diffPrecision is aprox. diffScale
- BigInteger thisUnscaled = this.getUnscaledValue();
- BigInteger valUnscaled = val.getUnscaledValue();
- // If any of both precision is bigger, append zeros to the shorter one
- if (diffScale < 0) {
- thisUnscaled = thisUnscaled.multiply(Multiplication.powerOf10(-diffScale));
- } else if (diffScale > 0) {
- valUnscaled = valUnscaled.multiply(Multiplication.powerOf10(diffScale));
- }
- return thisUnscaled.compareTo(valUnscaled);
- }
- } else if (thisSign < valueSign) {
- return -1;
- } else {
- return 1;
- }
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this / divisor}. The
- * scale of the result is the difference of the scales of {@code this} and
- * {@code divisor}. If the exact result requires more digits, then the scale
- * is adjusted accordingly. For example, {@code 1/128 = 0.0078125} which has a
- * scale of {@code 7} and precision {@code 5}.
- *
- * @param divisor value by which {@code this} is divided.
- * @return {@code this / divisor}.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @throws ArithmeticException if the result cannot be represented exactly.
- */
- public BigDecimal divide(BigDecimal divisor) {
- BigInteger p = this.getUnscaledValue();
- BigInteger q = divisor.getUnscaledValue();
- BigInteger gcd; // greatest common divisor between 'p' and 'q'
- BigInteger quotAndRem[];
- double diffScale = scale - divisor.scale;
- int newScale; // the new scale for final quotient
- int k; // number of factors "2" in 'q'
- int l = 0; // number of factors "5" in 'q'
- int i = 1;
- int lastPow = FIVE_POW.length - 1;
-
- if (divisor.isZero()) {
- // math.04=Division by zero
- throw new ArithmeticException("Division by zero"); //$NON-NLS-1$
- }
- if (p.signum() == 0) {
- return zeroScaledBy(diffScale);
- }
- // To divide both by the GCD
- gcd = p.gcd(q);
- p = p.divide(gcd);
- q = q.divide(gcd);
- // To simplify all "2" factors of q, dividing by 2^k
- k = q.getLowestSetBit();
- q = q.shiftRight(k);
- // To simplify all "5" factors of q, dividing by 5^l
- do {
- quotAndRem = q.divideAndRemainder(FIVE_POW[i]);
- if (quotAndRem[1].signum() == 0) {
- l += i;
- if (i < lastPow) {
- i++;
- }
- q = quotAndRem[0];
- } else {
- if (i == 1) {
- break;
- }
- i = 1;
- }
- } while (true);
- // If abs(q) != 1 then the quotient is periodic
- if (!q.abs().equals(BigInteger.ONE)) {
- // math.05=Non-terminating decimal expansion; no exact representable
- // decimal result.
- throw new ArithmeticException(
- "Non-terminating decimal expansion; no exact representable decimal result"); //$NON-NLS-1$
- }
- // The sign of the is fixed and the quotient will be saved in 'p'
- if (q.signum() < 0) {
- p = p.negate();
- }
- // Checking if the new scale is out of range
- newScale = toIntScale(diffScale + Math.max(k, l));
- // k >= 0 and l >= 0 implies that k - l is in the 32-bit range
- i = k - l;
-
- p = (i > 0) ? Multiplication.multiplyByFivePow(p, i) : p.shiftLeft(-i);
- return new BigDecimal(p, newScale);
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this / divisor}. The
- * scale of the result is the scale of {@code this}. If rounding is required
- * to meet the specified scale, then the specified rounding mode {@code
- * roundingMode} is applied.
- *
- * @param divisor value by which {@code this} is divided.
- * @param roundingMode rounding mode to be used to round the result.
- * @return {@code this / divisor} rounded according to the given rounding
- * mode.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws IllegalArgumentException if {@code roundingMode} is not a valid
- * rounding mode.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @throws ArithmeticException if {@code roundingMode == ROUND_UNNECESSARY}
- * and rounding is necessary according to the scale of this.
- */
- public BigDecimal divide(BigDecimal divisor, int roundingMode) {
- return divide(divisor, (int) scale, RoundingMode.valueOf(roundingMode));
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this / divisor}. As
- * scale of the result the parameter {@code scale} is used. If rounding is
- * required to meet the specified scale, then the specified rounding mode
- * {@code roundingMode} is applied.
- *
- * @param divisor value by which {@code this} is divided.
- * @param scale the scale of the result returned.
- * @param roundingMode rounding mode to be used to round the result.
- * @return {@code this / divisor} rounded according to the given rounding
- * mode.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws IllegalArgumentException if {@code roundingMode} is not a valid
- * rounding mode.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @throws ArithmeticException if {@code roundingMode == ROUND_UNNECESSARY}
- * and rounding is necessary according to the given scale.
- */
- public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) {
- return divide(divisor, scale, RoundingMode.valueOf(roundingMode));
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this / divisor}. As
- * scale of the result the parameter {@code scale} is used. If rounding is
- * required to meet the specified scale, then the specified rounding mode
- * {@code roundingMode} is applied.
- *
- * @param divisor value by which {@code this} is divided.
- * @param scale the scale of the result returned.
- * @param roundingMode rounding mode to be used to round the result.
- * @return {@code this / divisor} rounded according to the given rounding
- * mode.
- * @throws NullPointerException if {@code divisor == null} or {@code
- * roundingMode == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @throws ArithmeticException if {@code roundingMode ==
- * RoundingMode.UNNECESSAR}Y and rounding is necessary according to
- * the given scale and given precision.
- */
- public BigDecimal divide(BigDecimal divisor, int scale,
- RoundingMode roundingMode) {
- // Let be: this = [u1,s1] and divisor = [u2,s2]
- if (roundingMode == null) {
- throw new NullPointerException();
- }
- if (divisor.isZero()) {
- // math.04=Division by zero
- throw new ArithmeticException("Division by zero"); //$NON-NLS-1$
- }
-
- double diffScale = this.scale - divisor.scale - scale;
- if (this.bitLength < 54 && divisor.bitLength < 54) {
- if (diffScale == 0) {
- return dividePrimitiveLongs((long) this.smallValue,
- (long) divisor.smallValue, scale, roundingMode);
- } else if (diffScale > 0) {
- if (diffScale < DOUBLE_TEN_POW.length
- && divisor.bitLength + DOUBLE_TEN_POW_BIT_LENGTH[(int) diffScale] < 54) {
- return dividePrimitiveLongs((long) this.smallValue,
- (long) (divisor.smallValue * DOUBLE_TEN_POW[(int) diffScale]),
- scale, roundingMode);
- }
- } else { // diffScale < 0
- if (-diffScale < DOUBLE_TEN_POW.length
- && this.bitLength + DOUBLE_TEN_POW_BIT_LENGTH[(int) -diffScale] < 54) {
- return dividePrimitiveLongs(
- (long) (this.smallValue * DOUBLE_TEN_POW[(int) -diffScale]),
- (long) divisor.smallValue, scale, roundingMode);
- }
- }
- }
- BigInteger scaledDividend = this.getUnscaledValue();
- BigInteger scaledDivisor = divisor.getUnscaledValue(); // for scaling of
- // 'u2'
-
- if (diffScale > 0) {
- // Multiply 'u2' by: 10^((s1 - s2) - scale)
- scaledDivisor = Multiplication.multiplyByTenPow(scaledDivisor,
- (int) diffScale);
- } else if (diffScale < 0) {
- // Multiply 'u1' by: 10^(scale - (s1 - s2))
- scaledDividend = Multiplication.multiplyByTenPow(scaledDividend,
- (int) -diffScale);
- }
- return divideBigIntegers(scaledDividend, scaledDivisor, scale, roundingMode);
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this / divisor}. The
- * result is rounded according to the passed context {@code mc}. If the passed
- * math context specifies precision {@code 0}, then this call is equivalent to
- * {@code this.divide(divisor)}.
- *
- * @param divisor value by which {@code this} is divided.
- * @param mc rounding mode and precision for the result of this operation.
- * @return {@code this / divisor}.
- * @throws NullPointerException if {@code divisor == null} or {@code mc ==
- * null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @throws ArithmeticException if {@code mc.getRoundingMode() == UNNECESSARY}
- * and rounding is necessary according {@code mc.getPrecision()}.
- */
- public BigDecimal divide(BigDecimal divisor, MathContext mc) {
- /*
- * Calculating how many zeros must be append to 'dividend' to obtain a
- * quotient with at least 'mc.precision()' digits
- */
- double traillingZeros = mc.getPrecision() + 2L + divisor.approxPrecision()
- - approxPrecision();
- double diffScale = scale - divisor.scale;
- double newScale = diffScale; // scale of the final quotient
- int compRem; // to compare the remainder
- int i = 1; // index
- int lastPow = TEN_POW.length - 1; // last power of ten
- BigInteger integerQuot; // for temporal results
- BigInteger quotAndRem[] = {getUnscaledValue()};
- // In special cases it reduces the problem to call the dual method
- if ((mc.getPrecision() == 0) || (this.isZero()) || (divisor.isZero())) {
- return this.divide(divisor);
- }
- if (traillingZeros > 0) {
- // To append trailing zeros at end of dividend
- quotAndRem[0] = getUnscaledValue().multiply(
- Multiplication.powerOf10(traillingZeros));
- newScale += traillingZeros;
- }
- quotAndRem = quotAndRem[0].divideAndRemainder(divisor.getUnscaledValue());
- integerQuot = quotAndRem[0];
- // Calculating the exact quotient with at least 'mc.precision()' digits
- if (quotAndRem[1].signum() != 0) {
- // Checking if: 2 * remainder >= divisor ?
- compRem = quotAndRem[1].shiftLeftOneBit().compareTo(
- divisor.getUnscaledValue());
- // quot := quot * 10 + r; with 'r' in {-6,-5,-4, 0,+4,+5,+6}
- integerQuot = integerQuot.multiply(BigInteger.TEN).add(
- BigInteger.valueOf(quotAndRem[0].signum() * (5 + compRem)));
- newScale++;
- } else {
- // To strip trailing zeros until the preferred scale is reached
- while (!integerQuot.testBit(0)) {
- quotAndRem = integerQuot.divideAndRemainder(TEN_POW[i]);
- if ((quotAndRem[1].signum() == 0) && (newScale - i >= diffScale)) {
- newScale -= i;
- if (i < lastPow) {
- i++;
- }
- integerQuot = quotAndRem[0];
- } else {
- if (i == 1) {
- break;
- }
- i = 1;
- }
- }
- }
- // To perform rounding
- return new BigDecimal(integerQuot, toIntScale(newScale), mc);
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this / divisor}. The
- * scale of the result is the scale of {@code this}. If rounding is required
- * to meet the specified scale, then the specified rounding mode {@code
- * roundingMode} is applied.
- *
- * @param divisor value by which {@code this} is divided.
- * @param roundingMode rounding mode to be used to round the result.
- * @return {@code this / divisor} rounded according to the given rounding
- * mode.
- * @throws NullPointerException if {@code divisor == null} or {@code
- * roundingMode == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @throws ArithmeticException if {@code roundingMode ==
- * RoundingMode.UNNECESSARY} and rounding is necessary according to
- * the scale of this.
- */
- public BigDecimal divide(BigDecimal divisor, RoundingMode roundingMode) {
- return divide(divisor, (int) scale, roundingMode);
- }
-
- /**
- * Returns a {@code BigDecimal} array which contains the integral part of
- * {@code this / divisor} at index 0 and the remainder {@code this % divisor}
- * at index 1. The quotient is rounded down towards zero to the next integer.
- *
- * @param divisor value by which {@code this} is divided.
- * @return {@code [this.divideToIntegralValue(divisor),
- * this.remainder(divisor)]}.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @see #divideToIntegralValue
- * @see #remainder
- */
- public BigDecimal[] divideAndRemainder(BigDecimal divisor) {
- BigDecimal quotAndRem[] = new BigDecimal[2];
-
- quotAndRem[0] = this.divideToIntegralValue(divisor);
- quotAndRem[1] = this.subtract(quotAndRem[0].multiply(divisor));
- return quotAndRem;
- }
-
- /**
- * Returns a {@code BigDecimal} array which contains the integral part of
- * {@code this / divisor} at index 0 and the remainder {@code this % divisor}
- * at index 1. The quotient is rounded down towards zero to the next integer.
- * The rounding mode passed with the parameter {@code mc} is not considered.
- * But if the precision of {@code mc > 0} and the integral part requires more
- * digits, then an {@code ArithmeticException} is thrown.
- *
- * @param divisor value by which {@code this} is divided.
- * @param mc math context which determines the maximal precision of the
- * result.
- * @return {@code [this.divideToIntegralValue(divisor),
- * this.remainder(divisor)]}.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @see #divideToIntegralValue
- * @see #remainder
- */
- public BigDecimal[] divideAndRemainder(BigDecimal divisor, MathContext mc) {
- BigDecimal quotAndRem[] = new BigDecimal[2];
-
- quotAndRem[0] = this.divideToIntegralValue(divisor, mc);
- quotAndRem[1] = this.subtract(quotAndRem[0].multiply(divisor));
- return quotAndRem;
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is the integral part of
- * {@code this / divisor}. The quotient is rounded down towards zero to the
- * next integer. For example, {@code 0.5/0.2 = 2}.
- *
- * @param divisor value by which {@code this} is divided.
- * @return integral part of {@code this / divisor}.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- */
- public BigDecimal divideToIntegralValue(BigDecimal divisor) {
- BigInteger integralValue; // the integer of result
- BigInteger powerOfTen; // some power of ten
- BigInteger quotAndRem[] = {getUnscaledValue()};
- double newScale = this.scale - divisor.scale;
- double tempScale = 0;
- int i = 1;
- int lastPow = TEN_POW.length - 1;
-
- if (divisor.isZero()) {
- // math.04=Division by zero
- throw new ArithmeticException("Division by zero"); //$NON-NLS-1$
- }
- if ((divisor.approxPrecision() + newScale > this.approxPrecision() + 1L)
- || (this.isZero())) {
- /*
- * If the divisor's integer part is greater than this's integer part, the
- * result must be zero with the appropriate scale
- */
- integralValue = BigInteger.ZERO;
- } else if (newScale == 0) {
- integralValue = getUnscaledValue().divide(divisor.getUnscaledValue());
- } else if (newScale > 0) {
- powerOfTen = Multiplication.powerOf10(newScale);
- integralValue = getUnscaledValue().divide(
- divisor.getUnscaledValue().multiply(powerOfTen));
- integralValue = integralValue.multiply(powerOfTen);
- } else {
- // (newScale < 0)
- powerOfTen = Multiplication.powerOf10(-newScale);
- integralValue = getUnscaledValue().multiply(powerOfTen).divide(
- divisor.getUnscaledValue());
- // To strip trailing zeros approximating to the preferred scale
- while (!integralValue.testBit(0)) {
- quotAndRem = integralValue.divideAndRemainder(TEN_POW[i]);
- if ((quotAndRem[1].signum() == 0) && (tempScale - i >= newScale)) {
- tempScale -= i;
- if (i < lastPow) {
- i++;
- }
- integralValue = quotAndRem[0];
- } else {
- if (i == 1) {
- break;
- }
- i = 1;
- }
- }
- newScale = tempScale;
- }
- return ((integralValue.signum() == 0) ? zeroScaledBy(newScale)
- : new BigDecimal(integralValue, toIntScale(newScale)));
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is the integral part of
- * {@code this / divisor}. The quotient is rounded down towards zero to the
- * next integer. The rounding mode passed with the parameter {@code mc} is not
- * considered. But if the precision of {@code mc > 0} and the integral part
- * requires more digits, then an {@code ArithmeticException} is thrown.
- *
- * @param divisor value by which {@code this} is divided.
- * @param mc math context which determines the maximal precision of the
- * result.
- * @return integral part of {@code this / divisor}.
- * @throws NullPointerException if {@code divisor == null} or {@code mc ==
- * null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @throws ArithmeticException if {@code mc.getPrecision() > 0} and the result
- * requires more digits to be represented.
- */
- public BigDecimal divideToIntegralValue(BigDecimal divisor, MathContext mc) {
- int mcPrecision = mc.getPrecision();
- int diffPrecision = this.precision() - divisor.precision();
- int lastPow = TEN_POW.length - 1;
- double diffScale = this.scale - divisor.scale;
- double newScale = diffScale;
- double quotPrecision = diffPrecision - diffScale + 1;
- BigInteger quotAndRem[] = new BigInteger[2];
- // In special cases it call the dual method
- if ((mcPrecision == 0) || (this.isZero()) || (divisor.isZero())) {
- return this.divideToIntegralValue(divisor);
- }
- // Let be: this = [u1,s1] and divisor = [u2,s2]
- if (quotPrecision <= 0) {
- quotAndRem[0] = BigInteger.ZERO;
- } else if (diffScale == 0) {
- // CASE s1 == s2: to calculate u1 / u2
- quotAndRem[0] = this.getUnscaledValue().divide(divisor.getUnscaledValue());
- } else if (diffScale > 0) {
- // CASE s1 >= s2: to calculate u1 / (u2 * 10^(s1-s2)
- quotAndRem[0] = this.getUnscaledValue().divide(
- divisor.getUnscaledValue().multiply(
- Multiplication.powerOf10(diffScale)));
- // To chose 10^newScale to get a quotient with at least 'mc.precision()'
- // digits
- newScale = Math.min(diffScale, Math.max(mcPrecision - quotPrecision + 1,
- 0));
- // To calculate: (u1 / (u2 * 10^(s1-s2)) * 10^newScale
- quotAndRem[0] = quotAndRem[0].multiply(Multiplication.powerOf10(newScale));
- } else {
- // CASE s2 > s1:
- /*
- * To calculate the minimum power of ten, such that the quotient (u1 *
- * 10^exp) / u2 has at least 'mc.precision()' digits.
- */
- double exp = Math.min(-diffScale, Math.max((double) mcPrecision
- - diffPrecision, 0));
- double compRemDiv;
- // Let be: (u1 * 10^exp) / u2 = [q,r]
- quotAndRem = this.getUnscaledValue().multiply(
- Multiplication.powerOf10(exp)).divideAndRemainder(
- divisor.getUnscaledValue());
- newScale += exp; // To fix the scale
- exp = -newScale; // The remaining power of ten
- // If after division there is a remainder...
- if ((quotAndRem[1].signum() != 0) && (exp > 0)) {
- // Log10(r) + ((s2 - s1) - exp) > mc.precision ?
- compRemDiv = (new BigDecimal(quotAndRem[1])).precision() + exp
- - divisor.precision();
- if (compRemDiv == 0) {
- // To calculate: (r * 10^exp2) / u2
- quotAndRem[1] = quotAndRem[1].multiply(Multiplication.powerOf10(exp)).divide(
- divisor.getUnscaledValue());
- compRemDiv = Math.abs(quotAndRem[1].signum());
- }
- if (compRemDiv > 0) {
- // The quotient won't fit in 'mc.precision()' digits
- // math.06=Division impossible
- throw new ArithmeticException("Division impossible"); //$NON-NLS-1$
- }
- }
- }
- // Fast return if the quotient is zero
- if (quotAndRem[0].signum() == 0) {
- return zeroScaledBy(diffScale);
- }
- BigInteger strippedBI = quotAndRem[0];
- BigDecimal integralValue = new BigDecimal(quotAndRem[0]);
- int resultPrecision = integralValue.precision();
- int i = 1;
- // To strip trailing zeros until the specified precision is reached
- while (!strippedBI.testBit(0)) {
- quotAndRem = strippedBI.divideAndRemainder(TEN_POW[i]);
- if ((quotAndRem[1].signum() == 0)
- && ((resultPrecision - i >= mcPrecision) || (newScale - i >= diffScale))) {
- resultPrecision -= i;
- newScale -= i;
- if (i < lastPow) {
- i++;
- }
- strippedBI = quotAndRem[0];
- } else {
- if (i == 1) {
- break;
- }
- i = 1;
- }
- }
- // To check if the result fit in 'mc.precision()' digits
- if (resultPrecision > mcPrecision) {
- // math.06=Division impossible
- throw new ArithmeticException("Division impossible"); //$NON-NLS-1$
- }
- integralValue.scale = toIntScale(newScale);
- integralValue.setUnscaledValue(strippedBI);
- return integralValue;
- }
-
- /**
- * Returns this {@code BigDecimal} as a double value. If {@code this} is too
- * big to be represented as an float, then {@code Double.POSITIVE_INFINITY} or
- * {@code Double.NEGATIVE_INFINITY} is returned.
- * <p>
- * Note, that if the unscaled value has more than 53 significant digits, then
- * this decimal cannot be represented exactly in a double variable. In this
- * case the result is rounded.
- * <p>
- * For example, if the instance {@code x1 = new BigDecimal("0.1")} cannot be
- * represented exactly as a double, and thus {@code x1.equals(new
- * BigDecimal(x1.doubleValue())} returns {@code false} for this case.
- * <p>
- * Similarly, if the instance {@code new BigDecimal(9007199254740993L)} is
- * converted to a double, the result is {@code 9.007199254740992E15}.
- * <p>
- *
- * @return this {@code BigDecimal} as a double value.
- */
- @Override
- public double doubleValue() {
- return Double.parseDouble(this.toString());
- }
-
- /**
- * Returns {@code true} if {@code x} is a {@code BigDecimal} instance and if
- * this instance is equal to this big decimal. Two big decimals are equal if
- * their unscaled value and their scale is equal. For example, 1.0
- * (10*10^(-1)) is not equal to 1.00 (100*10^(-2)). Similarly, zero instances
- * are not equal if their scale differs.
- *
- * @param x object to be compared with {@code this}.
- * @return true if {@code x} is a {@code BigDecimal} and {@code this == x}.
- */
- @Override
- public boolean equals(Object x) {
- if (this == x) {
- return true;
- }
- if (x instanceof BigDecimal) {
- BigDecimal x1 = (BigDecimal) x;
- return x1.scale == scale
- && (bitLength < 54 ? (x1.smallValue == smallValue)
- : intVal.equals(x1.intVal));
- }
- return false;
- }
-
- // @Override
- // public double doubleValue() {
- // int sign = signum();
- // int exponent = 1076; // bias + 53
- // int lowestSetBit;
- // int discardedSize;
- // long powerOfTwo = this.bitLength - (long)(scale / LOG10_2);
- // long bits; // IEEE-754 Standard
- // long tempBits; // for temporal calculations
- // BigInteger mantisa;
- //
- // if ((powerOfTwo < -1074) || (sign == 0)) {
- // // Cases which 'this' is very small
- // return (sign * 0.0d);
- // } else if (powerOfTwo > 1025) {
- // // Cases which 'this' is very large
- // return (sign * Double.POSITIVE_INFINITY);
- // }
- // mantisa = getUnscaledValue().abs();
- // // Let be: this = [u,s], with s > 0
- // if (scale <= 0) {
- // // mantisa = abs(u) * 10^s
- // mantisa = mantisa.multiply(Multiplication.powerOf10(-scale));
- // } else {// (scale > 0)
- // BigInteger quotAndRem[];
- // BigInteger powerOfTen = Multiplication.powerOf10(scale);
- // int k = 100 - (int)powerOfTwo;
- // int compRem;
- //
- // if (k > 0) {
- // /* Computing (mantisa * 2^k) , where 'k' is a enough big
- // * power of '2' to can divide by 10^s */
- // mantisa = mantisa.shiftLeft(k);
- // exponent -= k;
- // }
- // // Computing (mantisa * 2^k) / 10^s
- // quotAndRem = mantisa.divideAndRemainder(powerOfTen);
- // // To check if the fractional part >= 0.5
- // compRem = quotAndRem[1].shiftLeftOneBit().compareTo(powerOfTen);
- // // To add two rounded bits at end of mantisa
- // mantisa = quotAndRem[0].shiftLeft(2).add(
- // BigInteger.valueOf((compRem * (compRem + 3)) / 2 + 1));
- // exponent -= 2;
- // }
- // lowestSetBit = mantisa.getLowestSetBit();
- // discardedSize = mantisa.bitLength() - 54;
- // if (discardedSize > 0) {// (n > 54)
- // // mantisa = (abs(u) * 10^s) >> (n - 54)
- // bits = mantisa.shiftRight(discardedSize).longValue();
- // tempBits = bits;
- // // #bits = 54, to check if the discarded fraction produces a carry
- // if ((((bits & 1) == 1) && (lowestSetBit < discardedSize))
- // || ((bits & 3) == 3)) {
- // bits += 2;
- // }
- // } else {// (n <= 54)
- // // mantisa = (abs(u) * 10^s) << (54 - n)
- // bits = mantisa.longValue() << -discardedSize;
- // tempBits = bits;
- // // #bits = 54, to check if the discarded fraction produces a carry:
- // if ((bits & 3) == 3) {
- // bits += 2;
- // }
- // }
- // // Testing bit 54 to check if the carry creates a new binary digit
- // if ((bits & 0x40000000000000L) == 0) {
- // // To drop the last bit of mantisa (first discarded)
- // bits >>= 1;
- // // exponent = 2^(s-n+53+bias)
- // exponent += discardedSize;
- // } else {// #bits = 54
- // bits >>= 2;
- // exponent += discardedSize + 1;
- // }
- // // To test if the 53-bits number fits in 'double'
- // if (exponent > 2046) {// (exponent - bias > 1023)
- // return (sign * Double.POSITIVE_INFINITY);
- // } else if (exponent <= 0) {// (exponent - bias <= -1023)
- // // Denormalized numbers (having exponent == 0)
- // if (exponent < -53) {// exponent - bias < -1076
- // return (sign * 0.0d);
- // }
- // // -1076 <= exponent - bias <= -1023
- // // To discard '- exponent + 1' bits
- // bits = tempBits >> 1;
- // tempBits = bits & (-1L >>> (63 + exponent));
- // bits >>= (-exponent );
- // // To test if after discard bits, a new carry is generated
- // if (((bits & 3) == 3) || (((bits & 1) == 1) && (tempBits != 0)
- // && (lowestSetBit < discardedSize))) {
- // bits += 1;
- // }
- // exponent = 0;
- // bits >>= 1;
- // }
- // // Construct the 64 double bits: [sign(1), exponent(11), mantisa(52)]
- // bits = (sign & 0x8000000000000000L) | ((long)exponent << 52)
- // | (bits & 0xFFFFFFFFFFFFFL);
- // return Double.longBitsToDouble(bits);
- // }
-
- /**
- * Returns this {@code BigDecimal} as a float value. If {@code this} is too
- * big to be represented as an float, then {@code Float.POSITIVE_INFINITY} or
- * {@code Float.NEGATIVE_INFINITY} is returned.
- * <p>
- * Note, that if the unscaled value has more than 24 significant digits, then
- * this decimal cannot be represented exactly in a float variable. In this
- * case the result is rounded.
- * <p>
- * For example, if the instance {@code x1 = new BigDecimal("0.1")} cannot be
- * represented exactly as a float, and thus {@code x1.equals(new
- * BigDecimal(x1.folatValue())} returns {@code false} for this case.
- * <p>
- * Similarly, if the instance {@code new BigDecimal(16777217)} is converted to
- * a float, the result is {@code 1.6777216E}7.
- *
- * @return this {@code BigDecimal} as a float value.
- */
- @Override
- public float floatValue() {
- /*
- * A similar code like in doubleValue() could be repeated here, but this
- * simple implementation is quite efficient.
- */
- float floatResult = signum();
- double powerOfTwo = this.bitLength - (scale / LOG10_2);
- if ((powerOfTwo < -149) || (floatResult == 0.0f)) {
- // Cases which 'this' is very small
- floatResult *= 0.0f;
- } else if (powerOfTwo > 129) {
- // Cases which 'this' is very large
- floatResult *= Float.POSITIVE_INFINITY;
- } else {
- floatResult = (float) doubleValue();
- }
- return floatResult;
- }
-
- /**
- * Returns a hash code for this {@code BigDecimal}.
- *
- * @return hash code for {@code this}.
- */
- @Override
- public int hashCode() {
- if (hashCode != 0) {
- return hashCode;
- }
- if (bitLength < 54) {
- long longValue = (long) smallValue;
- hashCode = (int) (longValue & 0xffffffff);
- hashCode = 33 * hashCode + (int) ((longValue >> 32) & 0xffffffff);
- hashCode = 17 * hashCode + (int) scale;
- return hashCode;
- }
- hashCode = 17 * intVal.hashCode() + (int) scale;
- return hashCode;
- }
-
- /**
- * Returns this {@code BigDecimal} as an int value. Any fractional part is
- * discarded. If the integral part of {@code this} is too big to be
- * represented as an int, then {@code this} % 2^32 is returned.
- *
- * @return this {@code BigDecimal} as a int value.
- */
- @Override
- public int intValue() {
- /*
- * If scale <= -32 there are at least 32 trailing bits zero in 10^(-scale).
- * If the scale is positive and very large the long value could be zero.
- */
- return ((scale <= -32) || (scale > approxPrecision()) ? 0
- : toBigInteger().intValue());
- }
-
- /**
- * Returns this {@code BigDecimal} as a int value if it has no fractional part
- * and if its value fits to the int range ([-2^{31}..2^{31}-1]). If these
- * conditions are not met, an {@code ArithmeticException} is thrown.
- *
- * @return this {@code BigDecimal} as a int value.
- * @throws ArithmeticException if rounding is necessary or the number doesn't
- * fit in a int.
- */
- public int intValueExact() {
- return (int) valueExact(32);
- }
-
- /**
- * Returns this {@code BigDecimal} as an long value. Any fractional part is
- * discarded. If the integral part of {@code this} is too big to be
- * represented as an long, then {@code this} % 2^64 is returned.
- *
- * @return this {@code BigDecimal} as a long value.
- */
- @Override
- public long longValue() {
- /*
- * If scale <= -64 there are at least 64 trailing bits zero in 10^(-scale).
- * If the scale is positive and very large the long value could be zero.
- */
- return ((scale <= -64) || (scale > approxPrecision()) ? 0L
- : toBigInteger().longValue());
- }
-
- /**
- * Returns this {@code BigDecimal} as a long value if it has no fractional
- * part and if its value fits to the int range ([-2^{63}..2^{63}-1]). If these
- * conditions are not met, an {@code ArithmeticException} is thrown.
- *
- * @return this {@code BigDecimal} as a long value.
- * @throws ArithmeticException if rounding is necessary or the number doesn't
- * fit in a long.
- */
- public long longValueExact() {
- return valueExact(64);
- }
-
- /**
- * Returns the maximum of this {@code BigDecimal} and {@code val}.
- *
- * @param val value to be used to compute the maximum with this.
- * @return {@code max(this, val}.
- * @throws NullPointerException if {@code val == null}.
- */
- public BigDecimal max(BigDecimal val) {
- return ((compareTo(val) >= 0) ? this : val);
- }
-
- /**
- * Returns the minimum of this {@code BigDecimal} and {@code val}.
- *
- * @param val value to be used to compute the minimum with this.
- * @return {@code min(this, val}.
- * @throws NullPointerException if {@code val == null}.
- */
- public BigDecimal min(BigDecimal val) {
- return ((compareTo(val) <= 0) ? this : val);
- }
-
- /**
- * Returns a new {@code BigDecimal} instance where the decimal point has been
- * moved {@code n} places to the left. If {@code n < 0} then the decimal point
- * is moved {@code -n} places to the right.
- * <p>
- * The result is obtained by changing its scale. If the scale of the result
- * becomes negative, then its precision is increased such that the scale is
- * zero.
- * <p>
- * Note, that {@code movePointLeft(0)} returns a result which is
- * mathematically equivalent, but which has {@code scale >= 0}.
- *
- * @param n number of placed the decimal point has to be moved.
- * @return {@code this * 10^(-n}).
- */
- public BigDecimal movePointLeft(int n) {
- return movePoint(scale + n);
- }
-
- /**
- * Returns a new {@code BigDecimal} instance where the decimal point has been
- * moved {@code n} places to the right. If {@code n < 0} then the decimal
- * point is moved {@code -n} places to the left.
- * <p>
- * The result is obtained by changing its scale. If the scale of the result
- * becomes negative, then its precision is increased such that the scale is
- * zero.
- * <p>
- * Note, that {@code movePointRight(0)} returns a result which is
- * mathematically equivalent, but which has scale >= 0.
- *
- * @param n number of placed the decimal point has to be moved.
- * @return {@code this * 10^n}.
- */
- public BigDecimal movePointRight(int n) {
- return movePoint(scale - n);
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this * multiplicand}
- * . The scale of the result is the sum of the scales of the two arguments.
- *
- * @param multiplicand value to be multiplied with {@code this}.
- * @return {@code this * multiplicand}.
- * @throws NullPointerException if {@code multiplicand == null}.
- */
- public BigDecimal multiply(BigDecimal multiplicand) {
- double newScale = this.scale + multiplicand.scale;
-
- if ((this.isZero()) || (multiplicand.isZero())) {
- return zeroScaledBy(newScale);
- }
- /*
- * Let be: this = [u1,s1] and multiplicand = [u2,s2] so: this x multiplicand
- * = [ s1 * s2 , s1 + s2 ]
- */
- if (this.bitLength + multiplicand.bitLength < 54) {
- return valueOf(this.smallValue * multiplicand.smallValue,
- toIntScale(newScale));
- }
- return new BigDecimal(this.getUnscaledValue().multiply(
- multiplicand.getUnscaledValue()), toIntScale(newScale));
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this * multiplicand}
- * . The result is rounded according to the passed context {@code mc}.
- *
- * @param multiplicand value to be multiplied with {@code this}.
- * @param mc rounding mode and precision for the result of this operation.
- * @return {@code this * multiplicand}.
- * @throws NullPointerException if {@code multiplicand == null} or {@code mc
- * == null}.
- */
- public BigDecimal multiply(BigDecimal multiplicand, MathContext mc) {
- BigDecimal result = multiply(multiplicand);
-
- result.inplaceRound(mc);
- return result;
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is the {@code -this}. The
- * scale of the result is the same as the scale of this.
- *
- * @return {@code -this}
- */
- public BigDecimal negate() {
- if (bitLength < 54) {
- return valueOf(-smallValue, scale);
- }
- return new BigDecimal(getUnscaledValue().negate(), scale);
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is the {@code -this}. The
- * result is rounded according to the passed context {@code mc}.
- *
- * @param mc rounding mode and precision for the result of this operation.
- * @return {@code -this}
- */
- public BigDecimal negate(MathContext mc) {
- return round(mc).negate();
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code +this}. The scale of
- * the result is the same as the scale of this.
- *
- * @return {@code this}
- */
- public BigDecimal plus() {
- return this;
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code +this}. The result
- * is rounded according to the passed context {@code mc}.
- *
- * @param mc rounding mode and precision for the result of this operation.
- * @return {@code this}, rounded
- */
- public BigDecimal plus(MathContext mc) {
- return round(mc);
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this ^ n}. The scale
- * of the result is {@code n} times the scales of {@code this}.
- * <p>
- * {@code x.pow(0)} returns {@code 1}, even if {@code x == 0}.
- * <p>
- * Implementation Note: The implementation is based on the ANSI standard
- * X3.274-1996 algorithm.
- *
- * @param n exponent to which {@code this} is raised.
- * @return {@code this ^ n}.
- * @throws ArithmeticException if {@code n < 0} or {@code n > 999999999}.
- */
- public BigDecimal pow(int n) {
- if (n == 0) {
- return ONE;
- }
- if ((n < 0) || (n > 999999999)) {
- // math.07=Invalid Operation
- throw new ArithmeticException("Invalid Operation"); //$NON-NLS-1$
- }
- double newScale = scale * n;
- // Let be: this = [u,s] so: this^n = [u^n, s*n]
- return ((isZero()) ? zeroScaledBy(newScale) : new BigDecimal(
- getUnscaledValue().pow(n), toIntScale(newScale)));
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this ^ n}. The
- * result is rounded according to the passed context {@code mc}.
- * <p>
- * Implementation Note: The implementation is based on the ANSI standard
- * X3.274-1996 algorithm.
- *
- * @param n exponent to which {@code this} is raised.
- * @param mc rounding mode and precision for the result of this operation.
- * @return {@code this ^ n}.
- * @throws ArithmeticException if {@code n < 0} or {@code n > 999999999}.
- */
- public BigDecimal pow(int n, MathContext mc) {
- // The ANSI standard X3.274-1996 algorithm
- int m = Math.abs(n);
- int mcPrecision = mc.getPrecision();
- int elength = (int) Math.log10(m) + 1; // decimal digits in 'n'
- int oneBitMask; // mask of bits
- BigDecimal accum; // the single accumulator
- MathContext newPrecision = mc; // MathContext by default
-
- // In particular cases, it reduces the problem to call the other 'pow()'
- if ((n == 0) || ((isZero()) && (n > 0))) {
- return pow(n);
- }
- if ((m > 999999999) || ((mcPrecision == 0) && (n < 0))
- || ((mcPrecision > 0) && (elength > mcPrecision))) {
- // math.07=Invalid Operation
- throw new ArithmeticException("Invalid Operation"); //$NON-NLS-1$
- }
- if (mcPrecision > 0) {
- newPrecision = new MathContext(mcPrecision + elength + 1,
- mc.getRoundingMode());
- }
- // The result is calculated as if 'n' were positive
- accum = round(newPrecision);
- oneBitMask = Integer.highestOneBit(m) >> 1;
-
- while (oneBitMask > 0) {
- accum = accum.multiply(accum, newPrecision);
- if ((m & oneBitMask) == oneBitMask) {
- accum = accum.multiply(this, newPrecision);
- }
- oneBitMask >>= 1;
- }
- // If 'n' is negative, the value is divided into 'ONE'
- if (n < 0) {
- accum = ONE.divide(accum, newPrecision);
- }
- // The final value is rounded to the destination precision
- accum.inplaceRound(mc);
- return accum;
- }
-
- /**
- * Returns the precision of this {@code BigDecimal}. The precision is the
- * number of decimal digits used to represent this decimal. It is equivalent
- * to the number of digits of the unscaled value. The precision of {@code 0}
- * is {@code 1} (independent of the scale).
- *
- * @return the precision of this {@code BigDecimal}.
- */
- public int precision() {
- // Checking if the precision already was calculated
- if (precision > 0) {
- return precision;
- }
- int decimalDigits = 1; // the precision to be calculated
- double doubleUnsc = 1; // intVal in 'double'
-
- if (bitLength < 1024) {
- // To calculate the precision for small numbers
- if (bitLength >= 54) {
- doubleUnsc = getUnscaledValue().doubleValue();
- } else if (bitLength >= 1) {
- doubleUnsc = smallValue;
- }
- decimalDigits += (int) Math.log10(Math.abs(doubleUnsc));
- } else {
- // (bitLength >= 1024)
- /*
- * To calculate the precision for large numbers Note that: 2 ^(bitlength()
- * - 1) <= intVal < 10 ^(precision())
- */
- decimalDigits += (bitLength - 1) * LOG10_2;
- // If after division the number isn't zero, exists an aditional digit
- if (getUnscaledValue().divide(Multiplication.powerOf10(decimalDigits)).signum() != 0) {
- decimalDigits++;
- }
- }
- precision = decimalDigits;
- return precision;
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this % divisor}.
- * <p>
- * The remainder is defined as {@code this -
- * this.divideToIntegralValue(divisor) * divisor}.
- *
- * @param divisor value by which {@code this} is divided.
- * @return {@code this % divisor}.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- */
- public BigDecimal remainder(BigDecimal divisor) {
- return divideAndRemainder(divisor)[1];
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this % divisor}.
- * <p>
- * The remainder is defined as {@code this -
- * this.divideToIntegralValue(divisor) * divisor}.
- * <p>
- * The specified rounding mode {@code mc} is used for the division only.
- *
- * @param divisor value by which {@code this} is divided.
- * @param mc rounding mode and precision to be used.
- * @return {@code this % divisor}.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @throws ArithmeticException if {@code mc.getPrecision() > 0} and the result
- * of {@code this.divideToIntegralValue(divisor, mc)} requires more
- * digits to be represented.
- */
- public BigDecimal remainder(BigDecimal divisor, MathContext mc) {
- return divideAndRemainder(divisor, mc)[1];
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this}, rounded
- * according to the passed context {@code mc}.
- * <p>
- * If {@code mc.precision = 0}, then no rounding is performed.
- * <p>
- * If {@code mc.precision > 0} and {@code mc.roundingMode == UNNECESSARY},
- * then an {@code ArithmeticException} is thrown if the result cannot be
- * represented exactly within the given precision.
- *
- * @param mc rounding mode and precision for the result of this operation.
- * @return {@code this} rounded according to the passed context.
- * @throws ArithmeticException if {@code mc.precision > 0} and {@code
- * mc.roundingMode == UNNECESSARY} and this cannot be represented
- * within the given precision.
- */
- public BigDecimal round(MathContext mc) {
- BigDecimal thisBD = new BigDecimal(getUnscaledValue(), scale);
-
- thisBD.inplaceRound(mc);
- return thisBD;
- }
-
- /**
- * Returns the scale of this {@code BigDecimal}. The scale is the number of
- * digits behind the decimal point. The value of this {@code BigDecimal} is
- * the unsignedValue * 10^(-scale). If the scale is negative, then this
- * {@code BigDecimal} represents a big integer.
- *
- * @return the scale of this {@code BigDecimal}.
- */
- public int scale() {
- return (int) scale;
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this} 10^{@code n}.
- * The scale of the result is {@code this.scale()} - {@code n}. The precision
- * of the result is the precision of {@code this}.
- * <p>
- * This method has the same effect as {@link #movePointRight}, except that the
- * precision is not changed.
- *
- * @param n number of places the decimal point has to be moved.
- * @return {@code this * 10^n}
- */
- public BigDecimal scaleByPowerOfTen(int n) {
- double newScale = scale - n;
- if (bitLength < 54) {
- // Taking care when a 0 is to be scaled
- if (smallValue == 0) {
- return zeroScaledBy(newScale);
- }
- return valueOf(smallValue, toIntScale(newScale));
- }
- return new BigDecimal(getUnscaledValue(), toIntScale(newScale));
- }
-
- /**
- * Returns a new {@code BigDecimal} instance with the specified scale. If the
- * new scale is greater than the old scale, then additional zeros are added to
- * the unscaled value. If the new scale is smaller than the old scale, then
- * trailing zeros are removed. If the trailing digits are not zeros then an
- * ArithmeticException is thrown.
- * <p>
- * If no exception is thrown, then the following equation holds: {@code
- * x.setScale(s).compareTo(x) == 0}.
- *
- * @param newScale scale of the result returned.
- * @return a new {@code BigDecimal} instance with the specified scale.
- * @throws ArithmeticException if rounding would be necessary.
- */
- public BigDecimal setScale(int newScale) {
- return setScale(newScale, RoundingMode.UNNECESSARY);
- }
-
- /**
- * Returns a new {@code BigDecimal} instance with the specified scale.
- * <p>
- * If the new scale is greater than the old scale, then additional zeros are
- * added to the unscaled value. In this case no rounding is necessary.
- * <p>
- * If the new scale is smaller than the old scale, then trailing digits are
- * removed. If these trailing digits are not zero, then the remaining unscaled
- * value has to be rounded. For this rounding operation the specified rounding
- * mode is used.
- *
- * @param newScale scale of the result returned.
- * @param roundingMode rounding mode to be used to round the result.
- * @return a new {@code BigDecimal} instance with the specified scale.
- * @throws IllegalArgumentException if {@code roundingMode} is not a valid
- * rounding mode.
- * @throws ArithmeticException if {@code roundingMode == ROUND_UNNECESSARY}
- * and rounding is necessary according to the given scale.
- */
- public BigDecimal setScale(int newScale, int roundingMode) {
- return setScale(newScale, RoundingMode.valueOf(roundingMode));
- }
-
- /**
- * Returns a new {@code BigDecimal} instance with the specified scale.
- * <p>
- * If the new scale is greater than the old scale, then additional zeros are
- * added to the unscaled value. In this case no rounding is necessary.
- * <p>
- * If the new scale is smaller than the old scale, then trailing digits are
- * removed. If these trailing digits are not zero, then the remaining unscaled
- * value has to be rounded. For this rounding operation the specified rounding
- * mode is used.
- *
- * @param newScale scale of the result returned.
- * @param roundingMode rounding mode to be used to round the result.
- * @return a new {@code BigDecimal} instance with the specified scale.
- * @throws NullPointerException if {@code roundingMode == null}.
- * @throws ArithmeticException if {@code roundingMode == ROUND_UNNECESSARY}
- * and rounding is necessary according to the given scale.
- */
- public BigDecimal setScale(int newScale, RoundingMode roundingMode) {
- if (roundingMode == null) {
- throw new NullPointerException();
- }
- double diffScale = newScale - scale;
- // Let be: 'this' = [u,s]
- if (diffScale == 0) {
- return this;
- }
- if (diffScale > 0) {
- // return [u * 10^(s2 - s), newScale]
- if (diffScale < DOUBLE_TEN_POW.length
- && (this.bitLength + DOUBLE_TEN_POW_BIT_LENGTH[(int) diffScale]) < 54) {
- return valueOf(this.smallValue * DOUBLE_TEN_POW[(int) diffScale],
- newScale);
- }
- return new BigDecimal(Multiplication.multiplyByTenPow(getUnscaledValue(),
- (int) diffScale), newScale);
- }
- // diffScale < 0
- // return [u,s] / [1,newScale] with the appropriate scale and rounding
- if (this.bitLength < 54 && -diffScale < DOUBLE_TEN_POW.length) {
- return dividePrimitiveLongs((long) this.smallValue,
- (long) DOUBLE_TEN_POW[(int) -diffScale], newScale, roundingMode);
- }
- return divideBigIntegers(this.getUnscaledValue(),
- Multiplication.powerOf10(-diffScale), newScale, roundingMode);
- }
-
- /**
- * Returns this {@code BigDecimal} as a short value if it has no fractional
- * part and if its value fits to the short range ([-2^{15}..2^{15}-1]). If
- * these conditions are not met, an {@code ArithmeticException} is thrown.
- *
- * @return this {@code BigDecimal} as a short value.
- * @throws ArithmeticException if rounding is necessary of the number doesn't
- * fit in a short.
- */
- public short shortValueExact() {
- return (short) valueExact(16);
- }
-
- /**
- * Returns the sign of this {@code BigDecimal}.
- *
- * @return {@code -1} if {@code this < 0}, {@code 0} if {@code this == 0},
- * {@code 1} if {@code this > 0}.
- */
- public int signum() {
- if (bitLength < 54) {
- return this.smallValue < 0 ? -1 : this.smallValue > 0 ? 1 : 0;
- }
- return getUnscaledValue().signum();
- }
-
- /**
- * Returns a new {@code BigDecimal} instance with the same value as {@code
- * this} but with a unscaled value where the trailing zeros have been removed.
- * If the unscaled value of {@code this} has n trailing zeros, then the scale
- * and the precision of the result has been reduced by n.
- *
- * @return a new {@code BigDecimal} instance equivalent to this where the
- * trailing zeros of the unscaled value have been removed.
- */
- public BigDecimal stripTrailingZeros() {
- int i = 1; // 1 <= i <= 18
- int lastPow = TEN_POW.length - 1;
- double newScale = scale;
-
- if (isZero()) {
- return new BigDecimal("0");
- }
- BigInteger strippedBI = getUnscaledValue();
- BigInteger[] quotAndRem;
-
- // while the number is even...
- while (!strippedBI.testBit(0)) {
- // To divide by 10^i
- quotAndRem = strippedBI.divideAndRemainder(TEN_POW[i]);
- // To look the remainder
- if (quotAndRem[1].signum() == 0) {
- // To adjust the scale
- newScale -= i;
- if (i < lastPow) {
- // To set to the next power
- i++;
- }
- strippedBI = quotAndRem[0];
- } else {
- if (i == 1) {
- // 'this' has no more trailing zeros
- break;
- }
- // To set to the smallest power of ten
- i = 1;
- }
- }
- return new BigDecimal(strippedBI, toIntScale(newScale));
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this - subtrahend}.
- * The scale of the result is the maximum of the scales of the two arguments.
- *
- * @param subtrahend value to be subtracted from {@code this}.
- * @return {@code this - subtrahend}.
- * @throws NullPointerException if {@code subtrahend == null}.
- */
- public BigDecimal subtract(BigDecimal subtrahend) {
- double diffScale = this.scale - subtrahend.scale;
- // Fast return when some operand is zero
- if (this.isZero()) {
- if (diffScale <= 0) {
- return subtrahend.negate();
- }
- if (subtrahend.isZero()) {
- return this;
- }
- } else if (subtrahend.isZero()) {
- if (diffScale >= 0) {
- return this;
- }
- }
- // Let be: this = [u1,s1] and subtrahend = [u2,s2] so:
- if (diffScale == 0) {
- // case s1 = s2 : [u1 - u2 , s1]
- if (Math.max(this.bitLength, subtrahend.bitLength) + 1 < 54) {
- return valueOf(this.smallValue - subtrahend.smallValue, this.scale);
- }
- return new BigDecimal(this.getUnscaledValue().subtract(
- subtrahend.getUnscaledValue()), this.scale);
- } else if (diffScale > 0) {
- // case s1 > s2 : [ u1 - u2 * 10 ^ (s1 - s2) , s1 ]
- if (diffScale < DOUBLE_TEN_POW.length
- && Math.max(this.bitLength, subtrahend.bitLength
- + DOUBLE_TEN_POW_BIT_LENGTH[(int) diffScale]) + 1 < 54) {
- return valueOf(this.smallValue - subtrahend.smallValue
- * DOUBLE_TEN_POW[(int) diffScale], this.scale);
- }
- return new BigDecimal(this.getUnscaledValue().subtract(
- Multiplication.multiplyByTenPow(subtrahend.getUnscaledValue(),
- (int) diffScale)), this.scale);
- } else {
- // case s2 > s1 : [ u1 * 10 ^ (s2 - s1) - u2 , s2 ]
- diffScale = -diffScale;
- if (diffScale < DOUBLE_TEN_POW.length
- && Math.max(this.bitLength
- + DOUBLE_TEN_POW_BIT_LENGTH[(int) diffScale],
- subtrahend.bitLength) + 1 < 54) {
- return valueOf(this.smallValue * DOUBLE_TEN_POW[(int) diffScale]
- - subtrahend.smallValue, subtrahend.scale);
- }
- return new BigDecimal(Multiplication.multiplyByTenPow(
- this.getUnscaledValue(), (int) diffScale).subtract(
- subtrahend.getUnscaledValue()), subtrahend.scale);
- }
- }
-
- /**
- * Returns a new {@code BigDecimal} whose value is {@code this - subtrahend}.
- * The result is rounded according to the passed context {@code mc}.
- *
- * @param subtrahend value to be subtracted from {@code this}.
- * @param mc rounding mode and precision for the result of this operation.
- * @return {@code this - subtrahend}.
- * @throws NullPointerException if {@code subtrahend == null} or {@code mc ==
- * null}.
- */
- public BigDecimal subtract(BigDecimal subtrahend, MathContext mc) {
- double diffScale = subtrahend.scale - this.scale;
- int thisSignum;
- BigDecimal leftOperand; // it will be only the left operand (this)
- BigInteger tempBI;
- // Some operand is zero or the precision is infinity
- if ((subtrahend.isZero()) || (this.isZero()) || (mc.getPrecision() == 0)) {
- return subtract(subtrahend).round(mc);
- }
- // Now: this != 0 and subtrahend != 0
- if (subtrahend.approxPrecision() < diffScale - 1) {
- // Cases where it is unnecessary to subtract two numbers with very
- // different scales
- if (mc.getPrecision() < this.approxPrecision()) {
- thisSignum = this.signum();
- if (thisSignum != subtrahend.signum()) {
- tempBI = Multiplication.multiplyByPositiveInt(
- this.getUnscaledValue(), 10).add(BigInteger.valueOf(thisSignum));
- } else {
- tempBI = this.getUnscaledValue().subtract(
- BigInteger.valueOf(thisSignum));
- tempBI = Multiplication.multiplyByPositiveInt(tempBI, 10).add(
- BigInteger.valueOf(thisSignum * 9));
- }
- // Rounding the improved subtracting
- leftOperand = new BigDecimal(tempBI, this.scale + 1);
- return leftOperand.round(mc);
- }
- }
- // No optimization is done
- return subtract(subtrahend).round(mc);
- }
-
- /**
- * Returns this {@code BigDecimal} as a big integer instance. A fractional
- * part is discarded.
- *
- * @return this {@code BigDecimal} as a big integer instance.
- */
- public BigInteger toBigInteger() {
- if ((scale == 0) || (isZero())) {
- return getUnscaledValue();
- } else if (scale < 0) {
- return getUnscaledValue().multiply(Multiplication.powerOf10(-scale));
- } else {
- // (scale > 0)
- return getUnscaledValue().divide(Multiplication.powerOf10(scale));
- }
- }
-
- /**
- * Returns this {@code BigDecimal} as a big integer instance if it has no
- * fractional part. If this {@code BigDecimal} has a fractional part, i.e. if
- * rounding would be necessary, an {@code ArithmeticException} is thrown.
- *
- * @return this {@code BigDecimal} as a big integer value.
- * @throws ArithmeticException if rounding is necessary.
- */
- public BigInteger toBigIntegerExact() {
- if ((scale == 0) || (isZero())) {
- return getUnscaledValue();
- } else if (scale < 0) {
- return getUnscaledValue().multiply(Multiplication.powerOf10(-scale));
- } else {
- // (scale > 0)
- BigInteger[] integerAndFraction;
- // An optimization before do a heavy division
- if ((scale > approxPrecision())
- || (scale > getUnscaledValue().getLowestSetBit())) {
- // math.08=Rounding necessary
- throw new ArithmeticException("Rounding necessary"); //$NON-NLS-1$
- }
- integerAndFraction = getUnscaledValue().divideAndRemainder(
- Multiplication.powerOf10(scale));
- if (integerAndFraction[1].signum() != 0) {
- // It exists a non-zero fractional part
- // math.08=Rounding necessary
- throw new ArithmeticException("Rounding necessary"); //$NON-NLS-1$
- }
- return integerAndFraction[0];
- }
- }
-
- /**
- * Returns a string representation of this {@code BigDecimal}. This
- * representation always prints all significant digits of this value.
- * <p>
- * If the scale is negative or if {@code scale - precision >= 6} then
- * engineering notation is used. Engineering notation is similar to the
- * scientific notation except that the exponent is made to be a multiple of 3
- * such that the integer part is >= 1 and < 1000.
- *
- * @return a string representation of {@code this} in engineering notation if
- * necessary.
- */
- public String toEngineeringString() {
- String intString = getUnscaledValue().toString();
- if (scale == 0) {
- return intString;
- }
- int begin = (getUnscaledValue().signum() < 0) ? 2 : 1;
- int end = intString.length();
- double exponent = -scale + end - begin;
- StringBuilder result = new StringBuilder(intString);
-
- if ((scale > 0) && (exponent >= -6)) {
- if (exponent >= 0) {
- result.insert(end - (int) scale, '.');
- } else {
- result.insert(begin - 1, "0."); //$NON-NLS-1$
- result.insert(begin + 1, CH_ZEROS, 0, -(int) exponent - 1);
- }
- } else {
- int delta = end - begin;
- int rem = (int) (exponent % 3);
-
- if (rem != 0) {
- // adjust exponent so it is a multiple of three
- if (getUnscaledValue().signum() == 0) {
- // zero value
- rem = (rem < 0) ? -rem : 3 - rem;
- exponent += rem;
- } else {
- // nonzero value
- rem = (rem < 0) ? rem + 3 : rem;
- exponent -= rem;
- begin += rem;
- }
- if (delta < 3) {
- for (int i = rem - delta; i > 0; i--) {
- result.insert(end++, '0');
- }
- }
- }
- if (end - begin >= 1) {
- result.insert(begin, '.');
- end++;
- }
- if (exponent != 0) {
- result.insert(end, 'E');
- if (exponent > 0) {
- result.insert(++end, '+');
- }
- result.insert(++end, Long.toString((long) exponent));
- }
- }
- return result.toString();
- }
-
- /* Private Methods */
-
- /**
- * Returns a string representation of this {@code BigDecimal}. No scientific
- * notation is used. This methods adds zeros where necessary.
- * <p>
- * If this string representation is used to create a new instance, this
- * instance is generally not identical to {@code this} as the precision
- * changes.
- * <p>
- * {@code x.equals(new BigDecimal(x.toPlainString())} usually returns {@code
- * false}.
- * <p>
- * {@code x.compareTo(new BigDecimal(x.toPlainString())} returns {@code 0}.
- *
- * @return a string representation of {@code this} without exponent part.
- */
- public String toPlainString() {
- String intStr = getUnscaledValue().toString();
- if ((scale == 0) || ((isZero()) && (scale < 0))) {
- return intStr;
- }
- int begin = (signum() < 0) ? 1 : 0;
- double delta = scale;
- // We take space for all digits, plus a possible decimal point, plus 'scale'
- StringBuilder result = new StringBuilder(intStr.length() + 1
- + Math.abs((int) scale));
-
- if (begin == 1) {
- // If the number is negative, we insert a '-' character at front
- result.append('-');
- }
- if (scale > 0) {
- delta -= (intStr.length() - begin);
- if (delta >= 0) {
- result.append("0."); //$NON-NLS-1$
- // To append zeros after the decimal point
- for (; delta > CH_ZEROS.length; delta -= CH_ZEROS.length) {
- result.append(CH_ZEROS);
- }
- result.append(CH_ZEROS, 0, (int) delta);
- result.append(intStr.substring(begin));
- } else {
- delta = begin - delta;
- result.append(intStr.substring(begin, (int) delta));
- result.append('.');
- result.append(intStr.substring((int) delta));
- }
- } else {
- // (scale <= 0)
- result.append(intStr.substring(begin));
- // To append trailing zeros
- for (; delta < -CH_ZEROS.length; delta += CH_ZEROS.length) {
- result.append(CH_ZEROS);
- }
- result.append(CH_ZEROS, 0, (int) -delta);
- }
- return result.toString();
- }
-
- /**
- * Returns a canonical string representation of this {@code BigDecimal}. If
- * necessary, scientific notation is used. This representation always prints
- * all significant digits of this value.
- * <p>
- * If the scale is negative or if {@code scale - precision >= 6} then
- * scientific notation is used.
- *
- * @return a string representation of {@code this} in scientific notation if
- * necessary.
- */
- @Override
- public String toString() {
- if (toStringImage != null) {
- return toStringImage;
- }
- if (bitLength < 32) {
- // TODO convert to double math dont cast to long :-(
- toStringImage = Conversion.toDecimalScaledString((long) smallValue,
- (int) scale);
- return toStringImage;
- }
- String intString = getUnscaledValue().toString();
- if (scale == 0) {
- return intString;
- }
- int begin = (getUnscaledValue().signum() < 0) ? 2 : 1;
- int end = intString.length();
- double exponent = -scale + end - begin;
- StringBuilder result = new StringBuilder();
-
- result.append(intString);
- if ((scale > 0) && (exponent >= -6)) {
- if (exponent >= 0) {
- result.insert(end - (int) scale, '.');
- } else {
- result.insert(begin - 1, "0."); //$NON-NLS-1$
- result.insert(begin + 1, CH_ZEROS, 0, -(int) exponent - 1);
- }
- } else {
- if (end - begin >= 1) {
- result.insert(begin, '.');
- end++;
- }
- result.insert(end, 'E');
- if (exponent > 0) {
- result.insert(++end, '+');
- }
- result.insert(++end, Long.toString((long) exponent));
- }
- toStringImage = result.toString();
- return toStringImage;
- }
-
- /**
- * Returns the unit in the last place (ULP) of this {@code BigDecimal}
- * instance. An ULP is the distance to the nearest big decimal with the same
- * precision.
- * <p>
- * The amount of a rounding error in the evaluation of a floating-point
- * operation is often expressed in ULPs. An error of 1 ULP is often seen as a
- * tolerable error.
- * <p>
- * For class {@code BigDecimal}, the ULP of a number is simply 10^(-scale).
- * <p>
- * For example, {@code new BigDecimal(0.1).ulp()} returns {@code 1E-55}.
- *
- * @return unit in the last place (ULP) of this {@code BigDecimal} instance.
- */
- public BigDecimal ulp() {
- return valueOf(1, scale);
- }
-
- /**
- * Returns the unscaled value (mantissa) of this {@code BigDecimal} instance
- * as a {@code BigInteger}. The unscaled value can be computed as {@code this}
- * 10^(scale).
- *
- * @return unscaled value (this * 10^(scale)).
- */
- public BigInteger unscaledValue() {
- return getUnscaledValue();
- }
-
- /**
- * If the precision already was calculated it returns that value, otherwise it
- * calculates a very good approximation efficiently . Note that this value
- * will be {@code precision()} or {@code precision()-1} in the worst case.
- *
- * @return an approximation of {@code precision()} value
- */
- private double approxPrecision() {
- return (precision > 0) ? precision
- : Math.floor((this.bitLength - 1) * LOG10_2) + 1;
- }
-
- private BigInteger getUnscaledValue() {
- if (intVal == null) {
- intVal = BigInteger.valueOf((long) smallValue);
- }
- return intVal;
- }
-
- private void initFrom(String val) {
- int begin = 0; // first index to be copied
- int offset = 0;
- int last = val.length() - 1; // last index to be copied
- String scaleString = null; // buffer for scale
- StringBuilder unscaledBuffer; // buffer for unscaled value
-
- if (val == null) {
- throw new NullPointerException();
- }
- unscaledBuffer = new StringBuilder(val.length());
- // To skip a possible '+' symbol
- if ((offset <= last) && (val.charAt(offset) == '+')) {
- offset++;
- begin++;
- }
- int counter = 0;
- boolean wasNonZero = false;
- // Accumulating all digits until a possible decimal point
- for (; (offset <= last) && (val.charAt(offset) != '.')
- && (val.charAt(offset) != 'e') && (val.charAt(offset) != 'E'); offset++) {
- if (!wasNonZero) {
- if (val.charAt(offset) == '0') {
- counter++;
- } else {
- wasNonZero = true;
- }
- }
- }
- unscaledBuffer.append(val, begin, offset);
- // A decimal point was found
- if ((offset <= last) && (val.charAt(offset) == '.')) {
- offset++;
- // Accumulating all digits until a possible exponent
- begin = offset;
- for (; (offset <= last) && (val.charAt(offset) != 'e')
- && (val.charAt(offset) != 'E'); offset++) {
- if (!wasNonZero) {
- if (val.charAt(offset) == '0') {
- counter++;
- } else {
- wasNonZero = true;
- }
- }
- }
- scale = offset - begin;
- unscaledBuffer.append(val, begin, offset);
- } else {
- scale = 0;
- }
- // An exponent was found
- if ((offset <= last)
- && ((val.charAt(offset) == 'e') || (val.charAt(offset) == 'E'))) {
- offset++;
- // Checking for a possible sign of scale
- begin = offset;
- if ((offset <= last) && (val.charAt(offset) == '+')) {
- offset++;
- if ((offset <= last) && (val.charAt(offset) != '-')) {
- begin++;
- }
- }
- // Accumulating all remaining digits
- scaleString = val.substring(begin, last + 1);
- // Checking if the scale is defined
- scale = scale - Integer.parseInt(scaleString);
- if (scale != (int) scale) {
- // math.02=Scale out of range.
- throw new NumberFormatException("Scale out of range."); //$NON-NLS-1$
- }
- }
- // Parsing the unscaled value
- String unscaled = unscaledBuffer.toString();
- if (unscaled.length() < 16) {
- smallValue = parseUnscaled(unscaled);
- if (Double.isNaN(smallValue)) {
- throw new NumberFormatException("For input string: \"" + val + "\"");
- }
- bitLength = bitLength(smallValue);
- } else {
- setUnscaledValue(new BigInteger(unscaled));
- }
- precision = unscaledBuffer.length() - counter;
- if (unscaledBuffer.charAt(0) == '-') {
- precision--;
- }
- }
-
- /**
- * It does all rounding work of the public method {@code round(MathContext)},
- * performing an inplace rounding without creating a new object.
- *
- * @param mc the {@code MathContext} for perform the rounding.
- * @see #round(MathContext)
- */
- private void inplaceRound(MathContext mc) {
- int mcPrecision = mc.getPrecision();
- if (approxPrecision() - mcPrecision <= 0 || mcPrecision == 0) {
- return;
- }
- int discardedPrecision = precision() - mcPrecision;
- // If no rounding is necessary it returns immediately
- if ((discardedPrecision <= 0)) {
- return;
- }
- // When the number is small perform an efficient rounding
- if (this.bitLength < 54) {
- smallRound(mc, discardedPrecision);
- return;
- }
- // Getting the integer part and the discarded fraction
- BigInteger sizeOfFraction = Multiplication.powerOf10(discardedPrecision);
- BigInteger[] integerAndFraction = getUnscaledValue().divideAndRemainder(
- sizeOfFraction);
- double newScale = scale - discardedPrecision;
- int compRem;
- BigDecimal tempBD;
- // If the discarded fraction is non-zero, perform rounding
- if (integerAndFraction[1].signum() != 0) {
- // To check if the discarded fraction >= 0.5
- compRem = (integerAndFraction[1].abs().shiftLeftOneBit().compareTo(sizeOfFraction));
- // To look if there is a carry
- compRem = roundingBehavior(integerAndFraction[0].testBit(0) ? 1 : 0,
- integerAndFraction[1].signum() * (5 + compRem), mc.getRoundingMode());
- if (compRem != 0) {
- integerAndFraction[0] = integerAndFraction[0].add(BigInteger.valueOf(compRem));
- }
- tempBD = new BigDecimal(integerAndFraction[0]);
- // If after to add the increment the precision changed, we normalize the
- // size
- if (tempBD.precision() > mcPrecision) {
- integerAndFraction[0] = integerAndFraction[0].divide(BigInteger.TEN);
- newScale--;
- }
- }
- // To update all internal fields
- scale = toIntScale(newScale);
- precision = mcPrecision;
- setUnscaledValue(integerAndFraction[0]);
- }
-
- private boolean isZero() {
- return bitLength == 0 && this.smallValue != -1;
- }
-
- private BigDecimal movePoint(double newScale) {
- if (isZero()) {
- return zeroScaledBy(Math.max(newScale, 0));
- }
- /*
- * When: 'n'== Integer.MIN_VALUE isn't possible to call to
- * movePointRight(-n) since -Integer.MIN_VALUE == Integer.MIN_VALUE
- */
- if (newScale >= 0) {
- if (bitLength < 54) {
- return valueOf(smallValue, toIntScale(newScale));
- }
- return new BigDecimal(getUnscaledValue(), toIntScale(newScale));
- }
- if (-newScale < DOUBLE_TEN_POW.length
- && bitLength + DOUBLE_TEN_POW_BIT_LENGTH[(int) -newScale] < 54) {
- return valueOf(smallValue * DOUBLE_TEN_POW[(int) -newScale], 0);
- }
- return new BigDecimal(Multiplication.multiplyByTenPow(getUnscaledValue(),
- (int) -newScale), 0);
- }
-
- private void setUnscaledValue(BigInteger unscaledValue) {
- this.intVal = unscaledValue;
- this.bitLength = unscaledValue.bitLength();
- if (this.bitLength < 54) {
- this.smallValue = unscaledValue.longValue();
- }
- }
-
- /**
- * This method implements an efficient rounding for numbers which unscaled
- * value fits in the type {@code long}.
- *
- * @param mc the context to use
- * @param discardedPrecision the number of decimal digits that are discarded
- * @see #round(MathContext)
- */
- private void smallRound(MathContext mc, int discardedPrecision) {
- long sizeOfFraction = (long) DOUBLE_TEN_POW[discardedPrecision];
- long newScale = (long) scale - discardedPrecision;
- long unscaledVal = (long) smallValue; // TODO convert to double math dont
- // use longs
- // Getting the integer part and the discarded fraction
- long integer = unscaledVal / sizeOfFraction;
- long fraction = unscaledVal % sizeOfFraction;
- int compRem;
- // If the discarded fraction is non-zero perform rounding
- if (fraction != 0) {
- // To check if the discarded fraction >= 0.5
- compRem = longCompareTo(Math.abs(fraction) << 1, sizeOfFraction);
- // To look if there is a carry
- integer += roundingBehavior(((int) integer) & 1, Long.signum(fraction)
- * (5 + compRem), mc.getRoundingMode());
- // If after to add the increment the precision changed, we normalize the
- // size
- if (Math.log10(Math.abs(integer)) >= mc.getPrecision()) {
- integer /= 10;
- newScale--;
- }
- }
- // To update all internal fields
- scale = toIntScale(newScale);
- precision = mc.getPrecision();
- smallValue = integer;
- bitLength = bitLength(integer);
- intVal = null;
- }
-
- /**
- * If {@code intVal} has a fractional part throws an exception, otherwise it
- * counts the number of bits of value and checks if it's out of the range of
- * the primitive type. If the number fits in the primitive type returns this
- * number as {@code long}, otherwise throws an exception.
- *
- * @param bitLengthOfType number of bits of the type whose value will be
- * calculated exactly
- * @return the exact value of the integer part of {@code BigDecimal} when is
- * possible
- * @throws ArithmeticException when rounding is necessary or the number don't
- * fit in the primitive type
- */
- private long valueExact(int bitLengthOfType) {
- BigInteger bigInteger = toBigIntegerExact();
-
- if (bigInteger.bitLength() < bitLengthOfType) {
- // It fits in the primitive type
- return bigInteger.longValue();
- }
- // math.08=Rounding necessary
- throw new ArithmeticException("Rounding necessary"); //$NON-NLS-1$
- }
-}
diff --git a/user/super/com/google/gwt/emul/java/math/BigInteger.java b/user/super/com/google/gwt/emul/java/math/BigInteger.java
deleted file mode 100644
index e36c778..0000000
--- a/user/super/com/google/gwt/emul/java/math/BigInteger.java
+++ /dev/null
@@ -1,1497 +0,0 @@
-/*
- * 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;
-
-import java.io.Serializable;
-import java.util.Random;
-
-/**
- * This class represents immutable integer numbers of arbitrary length. Large
- * numbers are typically used in security applications and therefore BigIntegers
- * offer dedicated functionality like the generation of large prime numbers or
- * the computation of modular inverse.
- * <p>
- * Since the class was modeled to offer all the functionality as the
- * {@link Integer} class does, it provides even methods that operate bitwise on
- * a two's complement representation of large integers. Note however that the
- * implementations favors an internal representation where magnitude and sign
- * are treated separately. Hence such operations are inefficient and should be
- * discouraged. In simple words: Do NOT implement any bit fields based on
- * BigInteger.
- */
-public class BigInteger extends Number implements Comparable<BigInteger>,
- Serializable {
-
- /**
- * The {@code BigInteger} constant 1.
- */
- public static final BigInteger ONE = new BigInteger(1, 1);
-
- /* Fields used for the internal representation. */
-
- /**
- * The {@code BigInteger} constant 10.
- */
- public static final BigInteger TEN = new BigInteger(1, 10);
-
- /**
- * The {@code BigInteger} constant 0.
- */
- public static final BigInteger ZERO = new BigInteger(0, 0);
-
- /**
- * The {@code BigInteger} constant 0 used for comparison.
- */
- static final int EQUALS = 0;
-
- /**
- * The {@code BigInteger} constant 1 used for comparison.
- */
- static final int GREATER = 1;
-
- /**
- * The {@code BigInteger} constant -1 used for comparison.
- */
- static final int LESS = -1;
-
- /**
- * The {@code BigInteger} constant -1.
- */
- static final BigInteger MINUS_ONE = new BigInteger(-1, 1);
-
- /**
- * All the {@code BigInteger} numbers in the range [0,10] are cached.
- */
- static final BigInteger[] SMALL_VALUES = {
- ZERO, ONE, new BigInteger(1, 2), new BigInteger(1, 3),
- new BigInteger(1, 4), new BigInteger(1, 5), new BigInteger(1, 6),
- new BigInteger(1, 7), new BigInteger(1, 8), new BigInteger(1, 9), TEN};
-
- static final BigInteger[] TWO_POWS;
-
- /**
- * This is the serialVersionUID used by the sun implementation.
- */
- private static final long serialVersionUID = -8287574255936472291L;
-
- static {
- TWO_POWS = new BigInteger[32];
- for (int i = 0; i < TWO_POWS.length; i++) {
- TWO_POWS[i] = BigInteger.valueOf(1L << i);
- }
- }
-
- /**
- * Returns a random positive {@code BigInteger} instance in the range [0,
- * 2^(bitLength)-1] which is probably prime. The probability that the returned
- * {@code BigInteger} is prime is beyond (1-1/2^80).
- * <p>
- * <b>Implementation Note:</b> Currently {@code rnd} is ignored.
- *
- * @param bitLength length of the new {@code BigInteger} in bits.
- * @param rnd random generator used to generate the new {@code BigInteger}.
- * @return probably prime random {@code BigInteger} instance.
- * @throws IllegalArgumentException if {@code bitLength < 2}.
- */
- public static BigInteger probablePrime(int bitLength, Random rnd) {
- return new BigInteger(bitLength, 100, rnd);
- }
-
- public static BigInteger valueOf(long val) {
- if (val < 0) {
- if (val != -1) {
- return new BigInteger(-1, -val);
- }
- return MINUS_ONE;
- } else if (val <= 10) {
- return SMALL_VALUES[(int) val];
- } else {
- // (val > 10)
- return new BigInteger(1, val);
- }
- }
-
- static BigInteger getPowerOfTwo(int exp) {
- if (exp < TWO_POWS.length) {
- return TWO_POWS[exp];
- }
- int intCount = exp >> 5;
- int bitN = exp & 31;
- int resDigits[] = new int[intCount + 1];
- resDigits[intCount] = 1 << bitN;
- return new BigInteger(1, intCount + 1, resDigits);
- }
-
- /**
- * @see BigInteger#BigInteger(String, int)
- */
- private static void setFromString(BigInteger bi, String val, int radix) {
- int sign;
- int[] digits;
- int numberLength;
- int stringLength = val.length();
- int startChar;
- int endChar = stringLength;
-
- if (val.charAt(0) == '-') {
- sign = -1;
- startChar = 1;
- stringLength--;
- } else {
- sign = 1;
- startChar = 0;
- }
- /*
- * We use the following algorithm: split a string into portions of n
- * characters and convert each portion to an integer according to the radix.
- * Then convert an exp(radix, n) based number to binary using the
- * multiplication method. See D. Knuth, The Art of Computer Programming,
- * vol. 2.
- */
-
- int charsPerInt = Conversion.digitFitInInt[radix];
- int bigRadixDigitsLength = stringLength / charsPerInt;
- int topChars = stringLength % charsPerInt;
-
- if (topChars != 0) {
- bigRadixDigitsLength++;
- }
- digits = new int[bigRadixDigitsLength];
- // Get the maximal power of radix that fits in int
- int bigRadix = Conversion.bigRadices[radix - 2];
- // Parse an input string and accumulate the BigInteger's magnitude
- int digitIndex = 0; // index of digits array
- int substrEnd = startChar + ((topChars == 0) ? charsPerInt : topChars);
- int newDigit;
-
- for (int substrStart = startChar; substrStart < endChar; substrStart = substrEnd, substrEnd = substrStart
- + charsPerInt) {
- int bigRadixDigit = Integer.parseInt(
- val.substring(substrStart, substrEnd), radix);
- newDigit = Multiplication.multiplyByInt(digits, digitIndex, bigRadix);
- newDigit += Elementary.inplaceAdd(digits, digitIndex, bigRadixDigit);
- digits[digitIndex++] = newDigit;
- }
- numberLength = digitIndex;
- bi.sign = sign;
- bi.numberLength = numberLength;
- bi.digits = digits;
- bi.cutOffLeadingZeroes();
- }
-
- /**
- * The magnitude of this big integer. This array holds unsigned little endian
- * digits. For example: {@code 13} is represented as [ 13 ] {@code -13} is
- * represented as [ 13 ] {@code 2^32 + 13} is represented as [ 13, 1 ] {@code
- * 2^64 + 13} is represented as [ 13, 0, 1 ] {@code 2^31} is represented as [
- * Integer.MIN_VALUE ] The magnitude array may be longer than strictly
- * necessary, which results in additional trailing zeros.
- */
- transient int digits[];
-
- /**
- * The length of this in measured in ints. Can be less than digits.length().
- */
- transient int numberLength;
-
- /**
- * The sign of this.
- */
- transient int sign;
-
- private transient int firstNonzeroDigit = -2;
-
- /**
- * Cache for the hash code.
- */
- private transient int hashCode = 0;
-
- /**
- * Constructs a new {@code BigInteger} from the given two's complement
- * representation. The most significant byte is the entry at index 0. The most
- * significant bit of this entry determines the sign of the new {@code
- * BigInteger} instance. The given array must not be empty.
- *
- * @param val two's complement representation of the new {@code BigInteger}.
- * @throws NullPointerException if {@code val == null}.
- * @throws NumberFormatException if the length of {@code val} is zero.
- */
- public BigInteger(byte[] val) {
- if (val.length == 0) {
- // math.12=Zero length BigInteger
- throw new NumberFormatException("Zero length BigInteger"); //$NON-NLS-1$
- }
- if (val[0] < 0) {
- sign = -1;
- putBytesNegativeToIntegers(val);
- } else {
- sign = 1;
- putBytesPositiveToIntegers(val);
- }
- cutOffLeadingZeroes();
- }
-
- /**
- * Constructs a new {@code BigInteger} instance with the given sign and the
- * given magnitude. The sign is given as an integer (-1 for negative, 0 for
- * zero, 1 for positive). The magnitude is specified as a byte array. The most
- * significant byte is the entry at index 0.
- *
- * @param signum sign of the new {@code BigInteger} (-1 for negative, 0 for
- * zero, 1 for positive).
- * @param magnitude magnitude of the new {@code BigInteger} with the most
- * significant byte first.
- * @throws NullPointerException if {@code magnitude == null}.
- * @throws NumberFormatException if the sign is not one of -1, 0, 1 or if the
- * sign is zero and the magnitude contains non-zero entries.
- */
- public BigInteger(int signum, byte[] magnitude) {
- if (magnitude == null) {
- throw new NullPointerException();
- }
- if ((signum < -1) || (signum > 1)) {
- // math.13=Invalid signum value
- throw new NumberFormatException("Invalid signum value"); //$NON-NLS-1$
- }
- if (signum == 0) {
- for (byte element : magnitude) {
- if (element != 0) {
- // math.14=signum-magnitude mismatch
- throw new NumberFormatException("signum-magnitude mismatch"); //$NON-NLS-1$
- }
- }
- }
- if (magnitude.length == 0) {
- sign = 0;
- numberLength = 1;
- digits = new int[] {0};
- } else {
- sign = signum;
- putBytesPositiveToIntegers(magnitude);
- cutOffLeadingZeroes();
- }
- }
-
- /**
- * Constructs a random {@code BigInteger} instance in the range [0,
- * 2^(bitLength)-1] which is probably prime. The probability that the returned
- * {@code BigInteger} is prime is beyond (1-1/2^certainty).
- *
- * @param bitLength length of the new {@code BigInteger} in bits.
- * @param certainty tolerated primality uncertainty.
- * @param rnd is an optional random generator to be used.
- * @throws ArithmeticException if {@code bitLength} < 2.
- */
- public BigInteger(int bitLength, int certainty, Random rnd) {
- if (bitLength < 2) {
- // math.1C=bitLength < 2
- throw new ArithmeticException("bitLength < 2"); //$NON-NLS-1$
- }
- BigInteger me = Primality.consBigInteger(bitLength, certainty, rnd);
- sign = me.sign;
- numberLength = me.numberLength;
- digits = me.digits;
- }
-
- /**
- * Constructs a random non-negative {@code BigInteger} instance in the range
- * [0, 2^(numBits)-1].
- *
- * @param numBits maximum length of the new {@code BigInteger} in bits.
- * @param rnd is an optional random generator to be used.
- * @throws IllegalArgumentException if {@code numBits} < 0.
- */
- public BigInteger(int numBits, Random rnd) {
- if (numBits < 0) {
- // math.1B=numBits must be non-negative
- throw new IllegalArgumentException("numBits must be non-negative"); //$NON-NLS-1$
- }
- if (numBits == 0) {
- sign = 0;
- numberLength = 1;
- digits = new int[] {0};
- } else {
- sign = 1;
- numberLength = (numBits + 31) >> 5;
- digits = new int[numberLength];
- for (int i = 0; i < numberLength; i++) {
- digits[i] = rnd.nextInt();
- }
- // Using only the necessary bits
- digits[numberLength - 1] >>>= (-numBits) & 31;
- cutOffLeadingZeroes();
- }
- }
-
- /**
- * Constructs a new {@code BigInteger} instance from the string
- * representation. The string representation consists of an optional minus
- * sign followed by a non-empty sequence of decimal digits.
- *
- * @param val string representation of the new {@code BigInteger}.
- * @throws NullPointerException if {@code val == null}.
- * @throws NumberFormatException if {@code val} is not a valid representation
- * of a {@code BigInteger}.
- */
- public BigInteger(String val) {
- this(val, 10);
- }
-
- /**
- * Constructs a new {@code BigInteger} instance from the string
- * representation. The string representation consists of an optional minus
- * sign followed by a non-empty sequence of digits in the specified radix. For
- * the conversion the method {@code Character.digit(char, radix)} is used.
- *
- * @param val string representation of the new {@code BigInteger}.
- * @param radix the base to be used for the conversion.
- * @throws NullPointerException if {@code val == null}.
- * @throws NumberFormatException if {@code val} is not a valid representation
- * of a {@code BigInteger} or if {@code radix < Character.MIN_RADIX}
- * or {@code radix > Character.MAX_RADIX}.
- */
- public BigInteger(String val, int radix) {
- if (val == null) {
- throw new NullPointerException();
- }
- if ((radix < Character.MIN_RADIX) || (radix > Character.MAX_RADIX)) {
- // math.11=Radix out of range
- throw new NumberFormatException("Radix out of range"); //$NON-NLS-1$
- }
- if (val.length() == 0) {
- // math.12=Zero length BigInteger
- throw new NumberFormatException("Zero length BigInteger"); //$NON-NLS-1$
- }
- setFromString(this, val, radix);
- }
-
- /**
- * Constructs a number which array is of size 1.
- *
- * @param sign the sign of the number
- * @param value the only one digit of array
- */
- BigInteger(int sign, int value) {
- this.sign = sign;
- numberLength = 1;
- digits = new int[] {value};
- }
-
- /**
- * Creates a new {@code BigInteger} with the given sign and magnitude. This
- * constructor does not create a copy, so any changes to the reference will
- * affect the new number.
- *
- * @param signum The sign of the number represented by {@code digits}
- * @param digits The magnitude of the number
- */
- BigInteger(int signum, int digits[]) {
- if (digits.length == 0) {
- sign = 0;
- numberLength = 1;
- this.digits = new int[] {0};
- } else {
- sign = signum;
- numberLength = digits.length;
- this.digits = digits;
- cutOffLeadingZeroes();
- }
- }
-
- /**
- * Constructs a number without to create new space. This construct should be
- * used only if the three fields of representation are known.
- *
- * @param sign the sign of the number
- * @param numberLength the length of the internal array
- * @param digits a reference of some array created before
- */
- BigInteger(int sign, int numberLength, int[] digits) {
- this.sign = sign;
- this.numberLength = numberLength;
- this.digits = digits;
- }
-
- /**
- * Creates a new {@code BigInteger} whose value is equal to the specified
- * {@code long}.
- *
- * @param sign the sign of the number
- * @param val the value of the new {@code BigInteger}.
- */
- BigInteger(int sign, long val) {
- // PRE: (val >= 0) && (sign >= -1) && (sign <= 1)
- this.sign = sign;
- if ((val & 0xFFFFFFFF00000000L) == 0) {
- // It fits in one 'int'
- numberLength = 1;
- digits = new int[] {(int) val};
- } else {
- numberLength = 2;
- digits = new int[] {(int) val, (int) (val >> 32)};
- }
- }
-
- /**
- * Returns a (new) {@code BigInteger} whose value is the absolute value of
- * {@code this}.
- *
- * @return {@code abs(this)}.
- */
- public BigInteger abs() {
- return ((sign < 0) ? new BigInteger(1, numberLength, digits) : this);
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this + val}.
- *
- * @param val value to be added to {@code this}.
- * @return {@code this + val}.
- * @throws NullPointerException if {@code val == null}.
- */
- public BigInteger add(BigInteger val) {
- return Elementary.add(this, val);
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this & val}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @param val value to be and'ed with {@code this}.
- * @return {@code this & val}.
- * @throws NullPointerException if {@code val == null}.
- */
- public BigInteger and(BigInteger val) {
- return Logical.and(this, val);
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this & ~val}.
- * Evaluating {@code x.andNot(val)} returns the same result as {@code
- * x.and(val.not())}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @param val value to be not'ed and then and'ed with {@code this}.
- * @return {@code this & ~val}.
- * @throws NullPointerException if {@code val == null}.
- */
- public BigInteger andNot(BigInteger val) {
- return Logical.andNot(this, val);
- }
-
- /**
- * Use {@code bitLength(0)} if you want to know the length of the binary value
- * in bits.
- * <p>
- * Returns the number of bits in the binary representation of {@code this}
- * which differ from the sign bit. If {@code this} is positive the result is
- * equivalent to the number of bits set in the binary representation of
- * {@code this}. If {@code this} is negative the result is equivalent to the
- * number of bits set in the binary representation of {@code -this-1}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @return number of bits in the binary representation of {@code this} which
- * differ from the sign bit
- */
- public int bitCount() {
- return BitLevel.bitCount(this);
- }
-
- /**
- * Returns the length of the value's two's complement representation without
- * leading zeros for positive numbers / without leading ones for negative
- * values.
- * <p>
- * The two's complement representation of {@code this} will be at least
- * {@code bitLength() + 1} bits long.
- * <p>
- * The value will fit into an {@code int} if {@code bitLength() < 32} or into
- * a {@code long} if {@code bitLength() < 64}.
- *
- * @return the length of the minimal two's complement representation for
- * {@code this} without the sign bit.
- */
- public int bitLength() {
- return BitLevel.bitLength(this);
- }
-
- /**
- * Returns a new {@code BigInteger} which has the same binary representation
- * as {@code this} but with the bit at position n cleared. The result is
- * equivalent to {@code this & ~(2^n)}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @param n position where the bit in {@code this} has to be cleared.
- * @return {@code this & ~(2^n)}.
- * @throws ArithmeticException if {@code n < 0}.
- */
- public BigInteger clearBit(int n) {
- if (testBit(n)) {
- return BitLevel.flipBit(this, n);
- }
- return this;
- }
-
- /**
- * Compares this {@code BigInteger} with {@code val}. Returns one of the three
- * values 1, 0, or -1.
- *
- * @param val value to be compared with {@code this}.
- * @return {@code 1} if {@code this > val}, {@code -1} if {@code this < val} ,
- * {@code 0} if {@code this == val}.
- * @throws NullPointerException if {@code val == null}.
- */
- public int compareTo(BigInteger val) {
- if (sign > val.sign) {
- return GREATER;
- }
- if (sign < val.sign) {
- return LESS;
- }
- if (numberLength > val.numberLength) {
- return sign;
- }
- if (numberLength < val.numberLength) {
- return -val.sign;
- }
- // Equal sign and equal numberLength
- return (sign * Elementary.compareArrays(digits, val.digits, numberLength));
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this / divisor}.
- *
- * @param divisor value by which {@code this} is divided.
- * @return {@code this / divisor}.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- */
- public BigInteger divide(BigInteger divisor) {
- if (divisor.sign == 0) {
- // math.17=BigInteger divide by zero
- throw new ArithmeticException("BigInteger divide by zero"); //$NON-NLS-1$
- }
- int divisorSign = divisor.sign;
- if (divisor.isOne()) {
- return ((divisor.sign > 0) ? this : this.negate());
- }
- int thisSign = sign;
- int thisLen = numberLength;
- int divisorLen = divisor.numberLength;
- if (thisLen + divisorLen == 2) {
- long val = (digits[0] & 0xFFFFFFFFL) / (divisor.digits[0] & 0xFFFFFFFFL);
- if (thisSign != divisorSign) {
- val = -val;
- }
- return valueOf(val);
- }
- int cmp = ((thisLen != divisorLen) ? ((thisLen > divisorLen) ? 1 : -1)
- : Elementary.compareArrays(digits, divisor.digits, thisLen));
- if (cmp == EQUALS) {
- return ((thisSign == divisorSign) ? ONE : MINUS_ONE);
- }
- if (cmp == LESS) {
- return ZERO;
- }
- int resLength = thisLen - divisorLen + 1;
- int resDigits[] = new int[resLength];
- int resSign = ((thisSign == divisorSign) ? 1 : -1);
- if (divisorLen == 1) {
- Division.divideArrayByInt(resDigits, digits, thisLen, divisor.digits[0]);
- } else {
- Division.divide(resDigits, resLength, digits, thisLen, divisor.digits,
- divisorLen);
- }
- BigInteger result = new BigInteger(resSign, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Returns a {@code BigInteger} array which contains {@code this / divisor} at
- * index 0 and {@code this % divisor} at index 1.
- *
- * @param divisor value by which {@code this} is divided.
- * @return {@code [this / divisor, this % divisor]}.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- * @see #divide
- * @see #remainder
- */
- public BigInteger[] divideAndRemainder(BigInteger divisor) {
- int divisorSign = divisor.sign;
- if (divisorSign == 0) {
- // math.17=BigInteger divide by zero
- throw new ArithmeticException("BigInteger divide by zero"); //$NON-NLS-1$
- }
- int divisorLen = divisor.numberLength;
- int[] divisorDigits = divisor.digits;
- if (divisorLen == 1) {
- return Division.divideAndRemainderByInteger(this, divisorDigits[0],
- divisorSign);
- }
- // res[0] is a quotient and res[1] is a remainder:
- int[] thisDigits = digits;
- int thisLen = numberLength;
- int cmp = (thisLen != divisorLen) ? ((thisLen > divisorLen) ? 1 : -1)
- : Elementary.compareArrays(thisDigits, divisorDigits, thisLen);
- if (cmp < 0) {
- return new BigInteger[] {ZERO, this};
- }
- int thisSign = sign;
- int quotientLength = thisLen - divisorLen + 1;
- int remainderLength = divisorLen;
- int quotientSign = ((thisSign == divisorSign) ? 1 : -1);
- int quotientDigits[] = new int[quotientLength];
- int remainderDigits[] = Division.divide(quotientDigits, quotientLength,
- thisDigits, thisLen, divisorDigits, divisorLen);
- BigInteger result0 = new BigInteger(quotientSign, quotientLength,
- quotientDigits);
- BigInteger result1 = new BigInteger(thisSign, remainderLength,
- remainderDigits);
- result0.cutOffLeadingZeroes();
- result1.cutOffLeadingZeroes();
- return new BigInteger[] {result0, result1};
- }
-
- /**
- * Returns this {@code BigInteger} as an double value. If {@code this} is too
- * big to be represented as an double, then {@code Double.POSITIVE_INFINITY}
- * or {@code Double.NEGATIVE_INFINITY} is returned. Note, that not all
- * integers x in the range [-Double.MAX_VALUE, Double.MAX_VALUE] can be
- * represented as a double. The double representation has a mantissa of length
- * 53. For example, 2^53+1 = 9007199254740993 is returned as double
- * 9007199254740992.0.
- *
- * @return this {@code BigInteger} as a double value
- */
- @Override
- public double doubleValue() {
- return Double.parseDouble(this.toString());
- }
-
- /**
- * Returns {@code true} if {@code x} is a BigInteger instance and if this
- * instance is equal to this {@code BigInteger}.
- *
- * @param x object to be compared with {@code this}.
- * @return true if {@code x} is a BigInteger and {@code this == x}, {@code
- * false} otherwise.
- */
- @Override
- public boolean equals(Object x) {
- if (this == x) {
- return true;
- }
- if (x instanceof BigInteger) {
- BigInteger x1 = (BigInteger) x;
- return sign == x1.sign && numberLength == x1.numberLength
- && equalsArrays(x1.digits);
- }
- return false;
- }
-
- /**
- * Returns a new {@code BigInteger} which has the same binary representation
- * as {@code this} but with the bit at position n flipped. The result is
- * equivalent to {@code this ^ 2^n}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @param n position where the bit in {@code this} has to be flipped.
- * @return {@code this ^ 2^n}.
- * @throws ArithmeticException if {@code n < 0}.
- */
- public BigInteger flipBit(int n) {
- if (n < 0) {
- // math.15=Negative bit address
- throw new ArithmeticException("Negative bit address"); //$NON-NLS-1$
- }
- return BitLevel.flipBit(this, n);
- }
-
- /**
- * Returns this {@code BigInteger} as an float value. If {@code this} is too
- * big to be represented as an float, then {@code Float.POSITIVE_INFINITY} or
- * {@code Float.NEGATIVE_INFINITY} is returned. Note, that not all integers x
- * in the range [-Float.MAX_VALUE, Float.MAX_VALUE] can be represented as a
- * float. The float representation has a mantissa of length 24. For example,
- * 2^24+1 = 16777217 is returned as float 16777216.0.
- *
- * @return this {@code BigInteger} as a float value.
- */
- @Override
- public float floatValue() {
- return Float.parseFloat(this.toString());
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is greatest common divisor of
- * {@code this} and {@code val}. If {@code this==0} and {@code val==0} then
- * zero is returned, otherwise the result is positive.
- *
- * @param val value with which the greatest common divisor is computed.
- * @return {@code gcd(this, val)}.
- * @throws NullPointerException if {@code val == null}.
- */
- public BigInteger gcd(BigInteger val) {
- BigInteger val1 = this.abs();
- BigInteger val2 = val.abs();
- // To avoid a possible division by zero
- if (val1.signum() == 0) {
- return val2;
- } else if (val2.signum() == 0) {
- return val1;
- }
-
- // Optimization for small operands
- // (op2.bitLength() < 64) and (op1.bitLength() < 64)
- if (((val1.numberLength == 1) || ((val1.numberLength == 2) && (val1.digits[1] > 0)))
- && (val2.numberLength == 1 || (val2.numberLength == 2 && val2.digits[1] > 0))) {
- return BigInteger.valueOf(Division.gcdBinary(val1.longValue(),
- val2.longValue()));
- }
-
- return Division.gcdBinary(val1.copy(), val2.copy());
- }
-
- /**
- * Returns the position of the lowest set bit in the two's complement
- * representation of this {@code BigInteger}. If all bits are zero (this=0)
- * then -1 is returned as result.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @return position of lowest bit if {@code this != 0}, {@code -1} otherwise
- */
- public int getLowestSetBit() {
- if (sign == 0) {
- return -1;
- }
- // (sign != 0) implies that exists some non zero digit
- int i = getFirstNonzeroDigit();
- return ((i << 5) + Integer.numberOfTrailingZeros(digits[i]));
- }
-
- /**
- * Returns a hash code for this {@code BigInteger}.
- *
- * @return hash code for {@code this}.
- */
- @Override
- public int hashCode() {
- if (hashCode != 0) {
- return hashCode;
- }
- for (int i = 0; i < digits.length; i++) {
- hashCode = (hashCode * 33 + (digits[i] & 0xffffffff));
- }
- hashCode = hashCode * sign;
- return hashCode;
- }
-
- /**
- * Returns this {@code BigInteger} as an int value. If {@code this} is too big
- * to be represented as an int, then {@code this} % 2^32 is returned.
- *
- * @return this {@code BigInteger} as an int value.
- */
- @Override
- public int intValue() {
- return (sign * digits[0]);
- }
-
- /**
- * Tests whether this {@code BigInteger} is probably prime. If {@code true} is
- * returned, then this is prime with a probability beyond (1-1/2^certainty).
- * If {@code false} is returned, then this is definitely composite. If the
- * argument {@code certainty} <= 0, then this method returns true.
- *
- * @param certainty tolerated primality uncertainty.
- * @return {@code true}, if {@code this} is probably prime, {@code false}
- * otherwise.
- */
- public boolean isProbablePrime(int certainty) {
- return Primality.isProbablePrime(abs(), certainty);
- }
-
- /**
- * Returns this {@code BigInteger} as an long value. If {@code this} is too
- * big to be represented as an long, then {@code this} % 2^64 is returned.
- *
- * @return this {@code BigInteger} as a long value.
- */
- @Override
- public long longValue() {
- long value = (numberLength > 1) ? (((long) digits[1]) << 32)
- | (digits[0] & 0xFFFFFFFFL) : (digits[0] & 0xFFFFFFFFL);
- return (sign * value);
- }
-
- /**
- * Returns the maximum of this {@code BigInteger} and {@code val}.
- *
- * @param val value to be used to compute the maximum with {@code this}
- * @return {@code max(this, val)}
- * @throws NullPointerException if {@code val == null}
- */
- public BigInteger max(BigInteger val) {
- return ((this.compareTo(val) == GREATER) ? this : val);
- }
-
- /**
- * Returns the minimum of this {@code BigInteger} and {@code val}.
- *
- * @param val value to be used to compute the minimum with {@code this}.
- * @return {@code min(this, val)}.
- * @throws NullPointerException if {@code val == null}.
- */
- public BigInteger min(BigInteger val) {
- return ((this.compareTo(val) == LESS) ? this : val);
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this mod m}. The
- * modulus {@code m} must be positive. The result is guaranteed to be in the
- * interval {@code [0, m)} (0 inclusive, m exclusive). The behavior of this
- * function is not equivalent to the behavior of the % operator defined for
- * the built-in {@code int}'s.
- *
- * @param m the modulus.
- * @return {@code this mod m}.
- * @throws NullPointerException if {@code m == null}.
- * @throws ArithmeticException if {@code m < 0}.
- */
- public BigInteger mod(BigInteger m) {
- if (m.sign <= 0) {
- // math.18=BigInteger: modulus not positive
- throw new ArithmeticException("BigInteger: modulus not positive"); //$NON-NLS-1$
- }
- BigInteger rem = remainder(m);
- return ((rem.sign < 0) ? rem.add(m) : rem);
- }
-
- // @Override
- // public double doubleValue() {
- // return Conversion.bigInteger2Double(this);
- // }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code 1/this mod m}. The
- * modulus {@code m} must be positive. The result is guaranteed to be in the
- * interval {@code [0, m)} (0 inclusive, m exclusive). If {@code this} is not
- * relatively prime to m, then an exception is thrown.
- *
- * @param m the modulus.
- * @return {@code 1/this mod m}.
- * @throws NullPointerException if {@code m == null}
- * @throws ArithmeticException if {@code m < 0 or} if {@code this} is not
- * relatively prime to {@code m}
- */
- public BigInteger modInverse(BigInteger m) {
- if (m.sign <= 0) {
- // math.18=BigInteger: modulus not positive
- throw new ArithmeticException("BigInteger: modulus not positive"); //$NON-NLS-1$
- }
- // If both are even, no inverse exists
- if (!(testBit(0) || m.testBit(0))) {
- // math.19=BigInteger not invertible.
- throw new ArithmeticException("BigInteger not invertible."); //$NON-NLS-1$
- }
- if (m.isOne()) {
- return ZERO;
- }
-
- // From now on: (m > 1)
- BigInteger res = Division.modInverseMontgomery(abs().mod(m), m);
- if (res.sign == 0) {
- // math.19=BigInteger not invertible.
- throw new ArithmeticException("BigInteger not invertible."); //$NON-NLS-1$
- }
-
- res = ((sign < 0) ? m.subtract(res) : res);
- return res;
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this^exponent mod m}
- * . The modulus {@code m} must be positive. The result is guaranteed to be in
- * the interval {@code [0, m)} (0 inclusive, m exclusive). If the exponent is
- * negative, then {@code this.modInverse(m)^(-exponent) mod m)} is computed.
- * The inverse of this only exists if {@code this} is relatively prime to m,
- * otherwise an exception is thrown.
- *
- * @param exponent the exponent.
- * @param m the modulus.
- * @return {@code this^exponent mod val}.
- * @throws NullPointerException if {@code m == null} or {@code exponent ==
- * null}.
- * @throws ArithmeticException if {@code m < 0} or if {@code exponent<0} and
- * this is not relatively prime to {@code m}.
- */
- public BigInteger modPow(BigInteger exponent, BigInteger m) {
- if (m.sign <= 0) {
- // math.18=BigInteger: modulus not positive
- throw new ArithmeticException("BigInteger: modulus not positive"); //$NON-NLS-1$
- }
- BigInteger base = this;
-
- if (m.isOne() | (exponent.sign > 0 & base.sign == 0)) {
- return BigInteger.ZERO;
- }
- if (base.sign == 0 && exponent.sign == 0) {
- return BigInteger.ONE;
- }
- if (exponent.sign < 0) {
- base = modInverse(m);
- exponent = exponent.negate();
- }
- // From now on: (m > 0) and (exponent >= 0)
- BigInteger res = (m.testBit(0)) ? Division.oddModPow(base.abs(), exponent,
- m) : Division.evenModPow(base.abs(), exponent, m);
- if ((base.sign < 0) && exponent.testBit(0)) {
- // -b^e mod m == ((-1 mod m) * (b^e mod m)) mod m
- res = m.subtract(BigInteger.ONE).multiply(res).mod(m);
- }
- // else exponent is even, so base^exp is positive
- return res;
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this * val}.
- *
- * @param val value to be multiplied with {@code this}.
- * @return {@code this * val}.
- * @throws NullPointerException if {@code val == null}.
- */
- public BigInteger multiply(BigInteger val) {
- // This let us to throw NullPointerException when val == null
- if (val.sign == 0) {
- return ZERO;
- }
- if (sign == 0) {
- return ZERO;
- }
- return Multiplication.multiply(this, val);
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is the {@code -this}.
- *
- * @return {@code -this}.
- */
- public BigInteger negate() {
- return ((sign == 0) ? this : new BigInteger(-sign, numberLength, digits));
- }
-
- /**
- * Returns the smallest integer x > {@code this} which is probably prime as a
- * {@code BigInteger} instance. The probability that the returned {@code
- * BigInteger} is prime is beyond (1-1/2^80).
- *
- * @return smallest integer > {@code this} which is robably prime.
- * @throws ArithmeticException if {@code this < 0}.
- */
- public BigInteger nextProbablePrime() {
- if (sign < 0) {
- // math.1A=start < 0: {0}
- throw new ArithmeticException("start < 0: " + this); //$NON-NLS-1$
- }
- return Primality.nextProbablePrime(this);
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code ~this}. The result
- * of this operation is {@code -this-1}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @return {@code ~this}.
- */
- public BigInteger not() {
- return Logical.not(this);
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this | val}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @param val value to be or'ed with {@code this}.
- * @return {@code this | val}.
- * @throws NullPointerException if {@code val == null}.
- */
- public BigInteger or(BigInteger val) {
- return Logical.or(this, val);
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this ^ exp}.
- *
- * @param exp exponent to which {@code this} is raised.
- * @return {@code this ^ exp}.
- * @throws ArithmeticException if {@code exp < 0}.
- */
- public BigInteger pow(int exp) {
- if (exp < 0) {
- // math.16=Negative exponent
- throw new ArithmeticException("Negative exponent"); //$NON-NLS-1$
- }
- if (exp == 0) {
- return ONE;
- } else if (exp == 1 || equals(ONE) || equals(ZERO)) {
- return this;
- }
-
- // if even take out 2^x factor which we can
- // calculate by shifting.
- if (!testBit(0)) {
- int x = 1;
- while (!testBit(x)) {
- x++;
- }
- return getPowerOfTwo(x * exp).multiply(this.shiftRight(x).pow(exp));
- }
- return Multiplication.pow(this, exp);
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this % divisor}.
- * Regarding signs this methods has the same behavior as the % operator on
- * int's, i.e. the sign of the remainder is the same as the sign of this.
- *
- * @param divisor value by which {@code this} is divided.
- * @return {@code this % divisor}.
- * @throws NullPointerException if {@code divisor == null}.
- * @throws ArithmeticException if {@code divisor == 0}.
- */
- public BigInteger remainder(BigInteger divisor) {
- if (divisor.sign == 0) {
- // math.17=BigInteger divide by zero
- throw new ArithmeticException("BigInteger divide by zero"); //$NON-NLS-1$
- }
- int thisLen = numberLength;
- int divisorLen = divisor.numberLength;
- if (((thisLen != divisorLen) ? ((thisLen > divisorLen) ? 1 : -1)
- : Elementary.compareArrays(digits, divisor.digits, thisLen)) == LESS) {
- return this;
- }
- int resLength = divisorLen;
- int resDigits[] = new int[resLength];
- if (resLength == 1) {
- resDigits[0] = Division.remainderArrayByInt(digits, thisLen,
- divisor.digits[0]);
- } else {
- int qLen = thisLen - divisorLen + 1;
- resDigits = Division.divide(null, qLen, digits, thisLen, divisor.digits,
- divisorLen);
- }
- BigInteger result = new BigInteger(sign, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Returns a new {@code BigInteger} which has the same binary representation
- * as {@code this} but with the bit at position n set. The result is
- * equivalent to {@code this | 2^n}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @param n position where the bit in {@code this} has to be set.
- * @return {@code this | 2^n}.
- * @throws ArithmeticException if {@code n < 0}.
- */
- public BigInteger setBit(int n) {
- if (!testBit(n)) {
- return BitLevel.flipBit(this, n);
- }
- return this;
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this << n}. The
- * result is equivalent to {@code this * 2^n} if n >= 0. The shift distance
- * may be negative which means that {@code this} is shifted right. The result
- * then corresponds to {@code floor(this / 2^(-n))}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method on negative values is not
- * recommended as the current implementation is not efficient.
- *
- * @param n shift distance.
- * @return {@code this << n} if {@code n >= 0}; {@code this >> (-n)}.
- * otherwise
- */
- public BigInteger shiftLeft(int n) {
- if ((n == 0) || (sign == 0)) {
- return this;
- }
- return ((n > 0) ? BitLevel.shiftLeft(this, n) : BitLevel.shiftRight(this,
- -n));
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this >> n}. For
- * negative arguments, the result is also negative. The shift distance may be
- * negative which means that {@code this} is shifted left.
- * <p>
- * <b>Implementation Note:</b> Usage of this method on negative values is not
- * recommended as the current implementation is not efficient.
- *
- * @param n shift distance
- * @return {@code this >> n} if {@code n >= 0}; {@code this << (-n)} otherwise
- */
- public BigInteger shiftRight(int n) {
- if ((n == 0) || (sign == 0)) {
- return this;
- }
- return ((n > 0) ? BitLevel.shiftRight(this, n) : BitLevel.shiftLeft(this,
- -n));
- }
-
- /**
- * Returns the sign of this {@code BigInteger}.
- *
- * @return {@code -1} if {@code this < 0}, {@code 0} if {@code this == 0},
- * {@code 1} if {@code this > 0}.
- */
- public int signum() {
- return sign;
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this - val}.
- *
- * @param val value to be subtracted from {@code this}.
- * @return {@code this - val}.
- * @throws NullPointerException if {@code val == null}.
- */
- public BigInteger subtract(BigInteger val) {
- return Elementary.subtract(this, val);
- }
-
- /**
- * Tests whether the bit at position n in {@code this} is set. The result is
- * equivalent to {@code this & (2^n) != 0}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @param n position where the bit in {@code this} has to be inspected.
- * @return {@code this & (2^n) != 0}.
- * @throws ArithmeticException if {@code n < 0}.
- */
- public boolean testBit(int n) {
- if (n == 0) {
- return ((digits[0] & 1) != 0);
- }
- if (n < 0) {
- // math.15=Negative bit address
- throw new ArithmeticException("Negative bit address"); //$NON-NLS-1$
- }
- int intCount = n >> 5;
- if (intCount >= numberLength) {
- return (sign < 0);
- }
- int digit = digits[intCount];
- n = (1 << (n & 31)); // int with 1 set to the needed position
- if (sign < 0) {
- int firstNonZeroDigit = getFirstNonzeroDigit();
- if (intCount < firstNonZeroDigit) {
- return false;
- } else if (firstNonZeroDigit == intCount) {
- digit = -digit;
- } else {
- digit = ~digit;
- }
- }
- return ((digit & n) != 0);
- }
-
- /**
- * Returns the two's complement representation of this BigInteger in a byte
- * array.
- *
- * @return two's complement representation of {@code this}.
- */
- public byte[] toByteArray() {
- if (this.sign == 0) {
- return new byte[] {0};
- }
- BigInteger temp = this;
- int bitLen = bitLength();
- int iThis = getFirstNonzeroDigit();
- int bytesLen = (bitLen >> 3) + 1;
- /*
- * Puts the little-endian int array representing the magnitude of this
- * BigInteger into the big-endian byte array.
- */
- byte[] bytes = new byte[bytesLen];
- int firstByteNumber = 0;
- int highBytes;
- int digitIndex = 0;
- int bytesInInteger = 4;
- int digit;
- int hB;
-
- if (bytesLen - (numberLength << 2) == 1) {
- bytes[0] = (byte) ((sign < 0) ? -1 : 0);
- highBytes = 4;
- firstByteNumber++;
- } else {
- hB = bytesLen & 3;
- highBytes = (hB == 0) ? 4 : hB;
- }
-
- digitIndex = iThis;
- bytesLen -= iThis << 2;
-
- if (sign < 0) {
- digit = -temp.digits[digitIndex];
- digitIndex++;
- if (digitIndex == numberLength) {
- bytesInInteger = highBytes;
- }
- for (int i = 0; i < bytesInInteger; i++, digit >>= 8) {
- bytes[--bytesLen] = (byte) digit;
- }
- while (bytesLen > firstByteNumber) {
- digit = ~temp.digits[digitIndex];
- digitIndex++;
- if (digitIndex == numberLength) {
- bytesInInteger = highBytes;
- }
- for (int i = 0; i < bytesInInteger; i++, digit >>= 8) {
- bytes[--bytesLen] = (byte) digit;
- }
- }
- } else {
- while (bytesLen > firstByteNumber) {
- digit = temp.digits[digitIndex];
- digitIndex++;
- if (digitIndex == numberLength) {
- bytesInInteger = highBytes;
- }
- for (int i = 0; i < bytesInInteger; i++, digit >>= 8) {
- bytes[--bytesLen] = (byte) digit;
- }
- }
- }
- return bytes;
- }
-
- /**
- * Returns a string representation of this {@code BigInteger} in decimal form.
- *
- * @return a string representation of {@code this} in decimal form.
- */
- @Override
- public String toString() {
- return Conversion.toDecimalScaledString(this, 0);
- }
-
- /**
- * Returns a string containing a string representation of this {@code
- * BigInteger} with base radix. If {@code radix} is less than
- * {@link Character#MIN_RADIX} or greater than {@link Character#MAX_RADIX}
- * then a decimal representation is returned. The characters of the string
- * representation are generated with method {@link Character#forDigit}.
- *
- * @param radix base to be used for the string representation.
- * @return a string representation of this with radix 10.
- */
- public String toString(int radix) {
- return Conversion.bigInteger2String(this, radix);
- }
-
- /**
- * Returns a new {@code BigInteger} whose value is {@code this ^ val}.
- * <p>
- * <b>Implementation Note:</b> Usage of this method is not recommended as the
- * current implementation is not efficient.
- *
- * @param val value to be xor'ed with {@code this}
- * @return {@code this ^ val}
- * @throws NullPointerException if {@code val == null}
- */
- public BigInteger xor(BigInteger val) {
- return Logical.xor(this, val);
- }
-
- /*
- * Returns a copy of the current instance to achieve immutability
- */
- BigInteger copy() {
- int[] copyDigits = new int[numberLength];
- System.arraycopy(digits, 0, copyDigits, 0, numberLength);
- return new BigInteger(sign, numberLength, copyDigits);
- }
-
- /* Private Methods */
-
- /**
- * Decreases {@code numberLength} if there are zero high elements.
- */
- final void cutOffLeadingZeroes() {
- while ((numberLength > 0) && (digits[--numberLength] == 0)) {
- // Empty
- }
- if (digits[numberLength++] == 0) {
- sign = 0;
- }
- }
-
- boolean equalsArrays(final int[] b) {
- int i;
- for (i = numberLength - 1; (i >= 0) && (digits[i] == b[i]); i--) {
- // Empty
- }
- return i < 0;
- }
-
- int getFirstNonzeroDigit() {
- if (firstNonzeroDigit == -2) {
- int i;
- if (this.sign == 0) {
- i = -1;
- } else {
- for (i = 0; digits[i] == 0; i++) {
- // Empty
- }
- }
- firstNonzeroDigit = i;
- }
- return firstNonzeroDigit;
- }
-
- /**
- * Tests if {@code this.abs()} is equals to {@code ONE}
- */
- boolean isOne() {
- return ((numberLength == 1) && (digits[0] == 1));
- }
-
- BigInteger shiftLeftOneBit() {
- return (sign == 0) ? this : BitLevel.shiftLeftOneBit(this);
- }
-
- void unCache() {
- firstNonzeroDigit = -2;
- }
-
- /**
- * Puts a big-endian byte array into a little-endian applying two complement.
- */
- private void putBytesNegativeToIntegers(byte[] byteValues) {
- int bytesLen = byteValues.length;
- int highBytes = bytesLen & 3;
- numberLength = (bytesLen >> 2) + ((highBytes == 0) ? 0 : 1);
- digits = new int[numberLength];
- int i = 0;
- // Setting the sign
- digits[numberLength - 1] = -1;
- // Put bytes to the int array starting from the end of the byte array
- while (bytesLen > highBytes) {
- digits[i] = (byteValues[--bytesLen] & 0xFF)
- | (byteValues[--bytesLen] & 0xFF) << 8
- | (byteValues[--bytesLen] & 0xFF) << 16
- | (byteValues[--bytesLen] & 0xFF) << 24;
- if (digits[i] != 0) {
- digits[i] = -digits[i];
- firstNonzeroDigit = i;
- i++;
- while (bytesLen > highBytes) {
- digits[i] = (byteValues[--bytesLen] & 0xFF)
- | (byteValues[--bytesLen] & 0xFF) << 8
- | (byteValues[--bytesLen] & 0xFF) << 16
- | (byteValues[--bytesLen] & 0xFF) << 24;
- digits[i] = ~digits[i];
- i++;
- }
- break;
- }
- i++;
- }
- if (highBytes != 0) {
- // Put the first bytes in the highest element of the int array
- if (firstNonzeroDigit != -2) {
- for (int j = 0; j < bytesLen; j++) {
- digits[i] = (digits[i] << 8) | (byteValues[j] & 0xFF);
- }
- digits[i] = ~digits[i];
- } else {
- for (int j = 0; j < bytesLen; j++) {
- digits[i] = (digits[i] << 8) | (byteValues[j] & 0xFF);
- }
- digits[i] = -digits[i];
- }
- }
- }
-
- /**
- * Puts a big-endian byte array into a little-endian int array.
- */
- private void putBytesPositiveToIntegers(byte[] byteValues) {
- int bytesLen = byteValues.length;
- int highBytes = bytesLen & 3;
- numberLength = (bytesLen >> 2) + ((highBytes == 0) ? 0 : 1);
- digits = new int[numberLength];
- int i = 0;
- // Put bytes to the int array starting from the end of the byte array
- while (bytesLen > highBytes) {
- digits[i++] = (byteValues[--bytesLen] & 0xFF)
- | (byteValues[--bytesLen] & 0xFF) << 8
- | (byteValues[--bytesLen] & 0xFF) << 16
- | (byteValues[--bytesLen] & 0xFF) << 24;
- }
- // Put the first bytes in the highest element of the int array
- for (int j = 0; j < bytesLen; j++) {
- digits[i] = (digits[i] << 8) | (byteValues[j] & 0xFF);
- }
- }
-}
diff --git a/user/super/com/google/gwt/emul/java/math/BitLevel.java b/user/super/com/google/gwt/emul/java/math/BitLevel.java
deleted file mode 100644
index b539637..0000000
--- a/user/super/com/google/gwt/emul/java/math/BitLevel.java
+++ /dev/null
@@ -1,379 +0,0 @@
-/*
- * 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 the <b>bit level</b> operations for
- * {@link BigInteger}. The operations are: <ul type="circle"> <li>Left Shifting</li>
- * <li>Right Shifting</li> <li>Bit clearing</li> <li>Bit setting</li> <li>Bit
- * counting</li> <li>Bit testing</li> <li>Getting of the lowest bit set</li>
- * </ul> All operations are provided in immutable way, and some in both mutable
- * and immutable.
- */
-class BitLevel {
-
- /**
- * @see BigInteger#bitCount()
- * @param val
- * @return
- */
- static int bitCount(BigInteger val) {
- int bCount = 0;
-
- if (val.sign == 0) {
- return 0;
- }
-
- int i = val.getFirstNonzeroDigit();
- if (val.sign > 0) {
- for (; i < val.numberLength; i++) {
- bCount += Integer.bitCount(val.digits[i]);
- }
- } else {
- // (sign < 0)
- // this digit absorbs the carry
- bCount += Integer.bitCount(-val.digits[i]);
- for (i++; i < val.numberLength; i++) {
- bCount += Integer.bitCount(~val.digits[i]);
- }
- // We take the complement sum:
- bCount = (val.numberLength << 5) - bCount;
- }
- return bCount;
- }
-
- /**
- * @see BigInteger#bitLength()
- * @param val
- * @return
- */
- static int bitLength(BigInteger val) {
- if (val.sign == 0) {
- return 0;
- }
- int bLength = (val.numberLength << 5);
- int highDigit = val.digits[val.numberLength - 1];
-
- if (val.sign < 0) {
- int i = val.getFirstNonzeroDigit();
- // We reduce the problem to the positive case.
- if (i == val.numberLength - 1) {
- // ~~ is to handle int overflow
- highDigit = ~~(highDigit - 1);
- }
- }
- // Subtracting all sign bits
- bLength -= Integer.numberOfLeadingZeros(highDigit);
- return bLength;
- }
-
- /**
- * Performs a flipBit on the BigInteger, returning a BigInteger with the the
- * specified bit flipped.
- *
- * @param val BigInteger to operate on
- * @param n the bit to flip
- */
- static BigInteger flipBit(BigInteger val, int n) {
- int resSign = (val.sign == 0) ? 1 : val.sign;
- int intCount = n >> 5;
- int bitN = n & 31;
- int resLength = Math.max(intCount + 1, val.numberLength) + 1;
- int resDigits[] = new int[resLength];
- int i;
-
- int bitNumber = 1 << bitN;
- System.arraycopy(val.digits, 0, resDigits, 0, val.numberLength);
-
- if (val.sign < 0) {
- if (intCount >= val.numberLength) {
- resDigits[intCount] = bitNumber;
- } else {
- // val.sign<0 y intCount < val.numberLength
- int firstNonZeroDigit = val.getFirstNonzeroDigit();
- if (intCount > firstNonZeroDigit) {
- resDigits[intCount] ^= bitNumber;
- } else if (intCount < firstNonZeroDigit) {
- resDigits[intCount] = -bitNumber;
- for (i = intCount + 1; i < firstNonZeroDigit; i++) {
- resDigits[i] = -1;
- }
- resDigits[i] = resDigits[i]--;
- } else {
- i = intCount;
- resDigits[i] = -((-resDigits[intCount]) ^ bitNumber);
- if (resDigits[i] == 0) {
- for (i++; resDigits[i] == -1; i++) {
- resDigits[i] = 0;
- }
- resDigits[i]++;
- }
- }
- }
- } else {
- // case where val is positive
- resDigits[intCount] ^= bitNumber;
- }
- BigInteger result = new BigInteger(resSign, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Performs {@code val <<= count}.
- */
- // val should have enough place (and one digit more)
- static void inplaceShiftLeft(BigInteger val, int count) {
- int intCount = count >> 5; // count of integers
- val.numberLength += intCount
- + (Integer.numberOfLeadingZeros(val.digits[val.numberLength - 1])
- - (count & 31) >= 0 ? 0 : 1);
- shiftLeft(val.digits, val.digits, intCount, count & 31);
- val.cutOffLeadingZeroes();
- val.unCache();
- }
-
- /**
- * Performs {@code val >>= count} where {@code val} is a positive number.
- */
- static void inplaceShiftRight(BigInteger val, int count) {
- int sign = val.signum();
- if (count == 0 || val.signum() == 0) {
- return;
- }
- int intCount = count >> 5; // count of integers
- val.numberLength -= intCount;
- if (!shiftRight(val.digits, val.numberLength, val.digits, intCount,
- count & 31)
- && sign < 0) {
- // remainder not zero: add one to the result
- int i;
- for (i = 0; (i < val.numberLength) && (val.digits[i] == -1); i++) {
- val.digits[i] = 0;
- }
- if (i == val.numberLength) {
- val.numberLength++;
- }
- val.digits[i]++;
- }
- val.cutOffLeadingZeroes();
- val.unCache();
- }
-
- /**
- * Check if there are 1s in the lowest bits of this BigInteger.
- *
- * @param numberOfBits the number of the lowest bits to check
- * @return false if all bits are 0s, true otherwise
- */
- static boolean nonZeroDroppedBits(int numberOfBits, int digits[]) {
- int intCount = numberOfBits >> 5;
- int bitCount = numberOfBits & 31;
- int i;
-
- for (i = 0; (i < intCount) && (digits[i] == 0); i++) {
- }
- return ((i != intCount) || (digits[i] << (32 - bitCount) != 0));
- }
-
- /**
- * @see BigInteger#shiftLeft(int)
- * @param source
- * @param count
- * @return
- */
- static BigInteger shiftLeft(BigInteger source, int count) {
- int intCount = count >> 5;
- count &= 31; // %= 32
- int resLength = source.numberLength + intCount + ((count == 0) ? 0 : 1);
- int resDigits[] = new int[resLength];
-
- shiftLeft(resDigits, source.digits, intCount, count);
- BigInteger result = new BigInteger(source.sign, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Abstractly shifts left an array of integers in little endian (i.e. shift it
- * right). Total shift distance in bits is intCount * 32 + count
- *
- * @param result the destination array
- * @param source the source array
- * @param intCount the shift distance in integers
- * @param count an additional shift distance in bits
- */
- static void shiftLeft(int result[], int source[], int intCount, int count) {
- if (count == 0) {
- System.arraycopy(source, 0, result, intCount, result.length - intCount);
- } else {
- int rightShiftCount = 32 - count;
-
- result[result.length - 1] = 0;
- for (int i = result.length - 1; i > intCount; i--) {
- result[i] |= source[i - intCount - 1] >>> rightShiftCount;
- result[i - 1] = source[i - intCount - 1] << count;
- }
- }
-
- for (int i = 0; i < intCount; i++) {
- result[i] = 0;
- }
- }
-
- static BigInteger shiftLeftOneBit(BigInteger source) {
- int srcLen = source.numberLength;
- int resLen = srcLen + 1;
- int resDigits[] = new int[resLen];
- shiftLeftOneBit(resDigits, source.digits, srcLen);
- BigInteger result = new BigInteger(source.sign, resLen, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Shifts the source digits left one bit, creating a value whose magnitude is
- * doubled.
- *
- * @param result an array of digits that will hold the computed result when
- * this method returns. The size of this array is {@code srcLen + 1},
- * and the format is the same as {@link BigInteger#digits}.
- * @param source the array of digits to shift left, in the same format as
- * {@link BigInteger#digits}.
- * @param srcLen the length of {@code source}; may be less than {@code
- * source.length}
- */
- static void shiftLeftOneBit(int result[], int source[], int srcLen) {
- int carry = 0;
- for (int i = 0; i < srcLen; i++) {
- int val = source[i];
- result[i] = (val << 1) | carry;
- carry = val >>> 31;
- }
- if (carry != 0) {
- result[srcLen] = carry;
- }
- }
-
- /**
- * @see BigInteger#shiftRight(int)
- * @param source
- * @param count
- * @return
- */
- static BigInteger shiftRight(BigInteger source, int count) {
- int intCount = count >> 5; // count of integers
- count &= 31; // count of remaining bits
- if (intCount >= source.numberLength) {
- return ((source.sign < 0) ? BigInteger.MINUS_ONE : BigInteger.ZERO);
- }
- int i;
- int resLength = source.numberLength - intCount;
- int resDigits[] = new int[resLength + 1];
-
- shiftRight(resDigits, resLength, source.digits, intCount, count);
- if (source.sign < 0) {
- // Checking if the dropped bits are zeros (the remainder equals to
- // 0)
- for (i = 0; (i < intCount) && (source.digits[i] == 0); i++) {
- }
- // If the remainder is not zero, add 1 to the result
- if ((i < intCount)
- || ((count > 0) && ((source.digits[i] << (32 - count)) != 0))) {
- for (i = 0; (i < resLength) && (resDigits[i] == -1); i++) {
- resDigits[i] = 0;
- }
- if (i == resLength) {
- resLength++;
- }
- resDigits[i]++;
- }
- }
- BigInteger result = new BigInteger(source.sign, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Shifts right an array of integers. Total shift distance in bits is intCount
- * * 32 + count.
- *
- * @param result the destination array
- * @param resultLen the destination array's length
- * @param source the source array
- * @param intCount the number of elements to be shifted
- * @param count the number of bits to be shifted
- * @return dropped bit's are all zero (i.e. remaider is zero)
- */
- static boolean shiftRight(int result[], int resultLen, int source[],
- int intCount, int count) {
- int i;
- boolean allZero = true;
- for (i = 0; i < intCount; i++) {
- allZero &= source[i] == 0;
- }
- if (count == 0) {
- System.arraycopy(source, intCount, result, 0, resultLen);
- i = resultLen;
- } else {
- int leftShiftCount = 32 - count;
-
- allZero &= (source[i] << leftShiftCount) == 0;
- for (i = 0; i < resultLen - 1; i++) {
- result[i] = (source[i + intCount] >>> count)
- | (source[i + intCount + 1] << leftShiftCount);
- }
- result[i] = (source[i + intCount] >>> count);
- i++;
- }
-
- return allZero;
- }
-
- /**
- * Performs a fast bit testing for positive numbers. The bit to to be tested
- * must be in the range {@code [0, val.bitLength()-1]}
- */
- static boolean testBit(BigInteger val, int n) {
- // PRE: 0 <= n < val.bitLength()
- return ((val.digits[n >> 5] & (1 << (n & 31))) != 0);
- }
-
- /**
- * Just to denote that this class can't be instantiated.
- */
- private BitLevel() {
- }
-}
diff --git a/user/super/com/google/gwt/emul/java/math/Conversion.java b/user/super/com/google/gwt/emul/java/math/Conversion.java
deleted file mode 100644
index 28b8a95..0000000
--- a/user/super/com/google/gwt/emul/java/math/Conversion.java
+++ /dev/null
@@ -1,488 +0,0 @@
-/*
- * 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 {@link BigInteger} base conversion from/to any
- * integer represented in an {@link java.lang.String} Object.
- */
-class Conversion {
-
- /**
- * bigRadices values are precomputed maximal powers of radices (integer
- * numbers from 2 to 36) that fit into unsigned int (32 bits). bigRadices[0] =
- * 2 ^ 31, bigRadices[8] = 10 ^ 9, etc.
- */
-
- static final int bigRadices[] = {
- -2147483648, 1162261467, 1073741824, 1220703125, 362797056, 1977326743,
- 1073741824, 387420489, 1000000000, 214358881, 429981696, 815730721,
- 1475789056, 170859375, 268435456, 410338673, 612220032, 893871739,
- 1280000000, 1801088541, 113379904, 148035889, 191102976, 244140625,
- 308915776, 387420489, 481890304, 594823321, 729000000, 887503681,
- 1073741824, 1291467969, 1544804416, 1838265625, 60466176};
-
- /**
- * Holds the maximal exponent for each radix, so that
- * radix<sup>digitFitInInt[radix]</sup> fit in an {@code int} (32 bits).
- */
- static final int[] digitFitInInt = {
- -1, -1, 31, 19, 15, 13, 11, 11, 10, 9, 9, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7,
- 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5};
-
- /**
- * @see BigInteger#toString(int)
- * @param val
- * @param radix
- * @return
- */
- static String bigInteger2String(BigInteger val, int radix) {
- int sign = val.sign;
- int numberLength = val.numberLength;
- int digits[] = val.digits;
-
- if (sign == 0) {
- return "0"; //$NON-NLS-1$
- }
- if (numberLength == 1) {
- int highDigit = digits[numberLength - 1];
- long v = highDigit & 0xFFFFFFFFL;
- if (sign < 0) {
- v = -v;
- }
- return Long.toString(v, radix);
- }
- if ((radix == 10) || (radix < Character.MIN_RADIX)
- || (radix > Character.MAX_RADIX)) {
- return val.toString();
- }
- double bitsForRadixDigit;
- bitsForRadixDigit = Math.log(radix) / Math.log(2);
- int resLengthInChars = (int) (val.abs().bitLength() / bitsForRadixDigit + ((sign < 0)
- ? 1 : 0)) + 1;
-
- char result[] = new char[resLengthInChars];
- int currentChar = resLengthInChars;
- int resDigit;
- if (radix != 16) {
- int temp[] = new int[numberLength];
- System.arraycopy(digits, 0, temp, 0, numberLength);
- int tempLen = numberLength;
- int charsPerInt = digitFitInInt[radix];
- int i;
- // get the maximal power of radix that fits in int
- int bigRadix = bigRadices[radix - 2];
- while (true) {
- // divide the array of digits by bigRadix and convert remainders
- // to characters collecting them in the char array
- resDigit = Division.divideArrayByInt(temp, temp, tempLen, bigRadix);
- int previous = currentChar;
- do {
- result[--currentChar] = Character.forDigit(resDigit % radix, radix);
- } while (((resDigit /= radix) != 0) && (currentChar != 0));
- int delta = charsPerInt - previous + currentChar;
- for (i = 0; i < delta && currentChar > 0; i++) {
- result[--currentChar] = '0';
- }
- for (i = tempLen - 1; (i > 0) && (temp[i] == 0); i--) {
- // empty
- }
- tempLen = i + 1;
- if ((tempLen == 1) && (temp[0] == 0)) { // the quotient is 0
- break;
- }
- }
- } else {
- // radix == 16
- for (int i = 0; i < numberLength; i++) {
- for (int j = 0; (j < 8) && (currentChar > 0); j++) {
- resDigit = digits[i] >> (j << 2) & 0xf;
- result[--currentChar] = Character.forDigit(resDigit, 16);
- }
- }
- }
- while (result[currentChar] == '0') {
- currentChar++;
- }
- if (sign == -1) {
- result[--currentChar] = '-';
- }
- return new String(result, currentChar, resLengthInChars - currentChar);
- }
-
- static long divideLongByBillion(long a) {
- long quot;
- long rem;
-
- if (a >= 0) {
- long bLong = 1000000000L;
- quot = (a / bLong);
- rem = (a % bLong);
- } else {
- /*
- * Make the dividend positive shifting it right by 1 bit then get the
- * quotient an remainder and correct them properly
- */
- long aPos = a >>> 1;
- long bPos = 1000000000L >>> 1;
- quot = aPos / bPos;
- rem = aPos % bPos;
- // double the remainder and add 1 if 'a' is odd
- rem = (rem << 1) + (a & 1);
- }
- return ((rem << 32) | (quot & 0xFFFFFFFFL));
- }
-
- /**
- * Builds the correspondent {@code String} representation of {@code val} being
- * scaled by {@code scale}.
- *
- * @see BigInteger#toString()
- * @see BigDecimal#toString()
- */
- static String toDecimalScaledString(BigInteger val, int scale) {
- int sign = val.sign;
- int numberLength = val.numberLength;
- int digits[] = val.digits;
- int resLengthInChars;
- int currentChar;
- char result[];
-
- if (sign == 0) {
- switch (scale) {
- case 0:
- return "0"; //$NON-NLS-1$
- case 1:
- return "0.0"; //$NON-NLS-1$
- case 2:
- return "0.00"; //$NON-NLS-1$
- case 3:
- return "0.000"; //$NON-NLS-1$
- case 4:
- return "0.0000"; //$NON-NLS-1$
- case 5:
- return "0.00000"; //$NON-NLS-1$
- case 6:
- return "0.000000"; //$NON-NLS-1$
- default:
- StringBuilder result1 = new StringBuilder();
- if (scale < 0) {
- result1.append("0E+"); //$NON-NLS-1$
- } else {
- result1.append("0E"); //$NON-NLS-1$
- }
- result1.append(-scale);
- return result1.toString();
- }
- }
- // one 32-bit unsigned value may contains 10 decimal digits
- resLengthInChars = numberLength * 10 + 1 + 7;
- // Explanation why +1+7:
- // +1 - one char for sign if needed.
- // +7 - For "special case 2" (see below) we have 7 free chars for
- // inserting necessary scaled digits.
- result = new char[resLengthInChars + 1];
- // allocated [resLengthInChars+1] characters.
- // a free latest character may be used for "special case 1" (see
- // below)
- currentChar = resLengthInChars;
- if (numberLength == 1) {
- int highDigit = digits[0];
- if (highDigit < 0) {
- long v = highDigit & 0xFFFFFFFFL;
- do {
- long prev = v;
- v /= 10;
- result[--currentChar] = (char) (0x0030 + ((int) (prev - v * 10)));
- } while (v != 0);
- } else {
- int v = highDigit;
- do {
- int prev = v;
- v /= 10;
- result[--currentChar] = (char) (0x0030 + (prev - v * 10));
- } while (v != 0);
- }
- } else {
- int temp[] = new int[numberLength];
- int tempLen = numberLength;
- System.arraycopy(digits, 0, temp, 0, tempLen);
- BIG_LOOP : while (true) {
- // divide the array of digits by bigRadix and convert
- // remainders
- // to characters collecting them in the char array
- long result11 = 0;
- for (int i1 = tempLen - 1; i1 >= 0; i1--) {
- long temp1 = (result11 << 32) + (temp[i1] & 0xFFFFFFFFL);
- long res = divideLongByBillion(temp1);
- temp[i1] = (int) res;
- result11 = (int) (res >> 32);
- }
- int resDigit = (int) result11;
- int previous = currentChar;
- do {
- result[--currentChar] = (char) (0x0030 + (resDigit % 10));
- } while (((resDigit /= 10) != 0) && (currentChar != 0));
- int delta = 9 - previous + currentChar;
- for (int i = 0; (i < delta) && (currentChar > 0); i++) {
- result[--currentChar] = '0';
- }
- int j = tempLen - 1;
- for (; temp[j] == 0; j--) {
- if (j == 0) { // means temp[0] == 0
- break BIG_LOOP;
- }
- }
- tempLen = j + 1;
- }
- while (result[currentChar] == '0') {
- currentChar++;
- }
- }
- boolean negNumber = (sign < 0);
- int exponent = resLengthInChars - currentChar - scale - 1;
- if (scale == 0) {
- if (negNumber) {
- result[--currentChar] = '-';
- }
- return new String(result, currentChar, resLengthInChars - currentChar);
- }
- if ((scale > 0) && (exponent >= -6)) {
- if (exponent >= 0) {
- // special case 1
- int insertPoint = currentChar + exponent;
- for (int j = resLengthInChars - 1; j >= insertPoint; j--) {
- result[j + 1] = result[j];
- }
- result[++insertPoint] = '.';
- if (negNumber) {
- result[--currentChar] = '-';
- }
- return new String(result, currentChar, resLengthInChars - currentChar
- + 1);
- }
- // special case 2
- for (int j = 2; j < -exponent + 1; j++) {
- result[--currentChar] = '0';
- }
- result[--currentChar] = '.';
- result[--currentChar] = '0';
- if (negNumber) {
- result[--currentChar] = '-';
- }
- return new String(result, currentChar, resLengthInChars - currentChar);
- }
- int startPoint = currentChar + 1;
- int endPoint = resLengthInChars;
- StringBuilder result1 = new StringBuilder(16 + endPoint - startPoint);
- if (negNumber) {
- result1.append('-');
- }
- if (endPoint - startPoint >= 1) {
- result1.append(result[currentChar]);
- result1.append('.');
- result1.append(result, currentChar + 1, resLengthInChars - currentChar
- - 1);
- } else {
- result1.append(result, currentChar, resLengthInChars - currentChar);
- }
- result1.append('E');
- if (exponent > 0) {
- result1.append('+');
- }
- result1.append(Integer.toString(exponent));
- return result1.toString();
- }
-
- /* can process only 32-bit numbers */
- static String toDecimalScaledString(long value, int scale) {
- int resLengthInChars;
- int currentChar;
- char result[];
- boolean negNumber = value < 0;
- if (negNumber) {
- value = -value;
- }
- if (value == 0) {
- switch (scale) {
- case 0:
- return "0"; //$NON-NLS-1$
- case 1:
- return "0.0"; //$NON-NLS-1$
- case 2:
- return "0.00"; //$NON-NLS-1$
- case 3:
- return "0.000"; //$NON-NLS-1$
- case 4:
- return "0.0000"; //$NON-NLS-1$
- case 5:
- return "0.00000"; //$NON-NLS-1$
- case 6:
- return "0.000000"; //$NON-NLS-1$
- default:
- StringBuilder result1 = new StringBuilder();
- if (scale < 0) {
- result1.append("0E+"); //$NON-NLS-1$
- } else {
- result1.append("0E"); //$NON-NLS-1$
- }
- result1.append((scale == Integer.MIN_VALUE)
- ? "2147483648" : Integer.toString(-scale)); //$NON-NLS-1$
- return result1.toString();
- }
- }
- // one 32-bit unsigned value may contains 10 decimal digits
- resLengthInChars = 18;
- // Explanation why +1+7:
- // +1 - one char for sign if needed.
- // +7 - For "special case 2" (see below) we have 7 free chars for
- // inserting necessary scaled digits.
- result = new char[resLengthInChars + 1];
- // Allocated [resLengthInChars+1] characters.
- // a free latest character may be used for "special case 1" (see below)
- currentChar = resLengthInChars;
- long v = value;
- do {
- long prev = v;
- v /= 10;
- result[--currentChar] = (char) (0x0030 + (prev - v * 10));
- } while (v != 0);
-
- long exponent = (long) resLengthInChars - (long) currentChar - scale - 1L;
- if (scale == 0) {
- if (negNumber) {
- result[--currentChar] = '-';
- }
- return new String(result, currentChar, resLengthInChars - currentChar);
- }
- if (scale > 0 && exponent >= -6) {
- if (exponent >= 0) {
- // special case 1
- int insertPoint = currentChar + (int) exponent;
- for (int j = resLengthInChars - 1; j >= insertPoint; j--) {
- result[j + 1] = result[j];
- }
- result[++insertPoint] = '.';
- if (negNumber) {
- result[--currentChar] = '-';
- }
- return new String(result, currentChar, resLengthInChars - currentChar
- + 1);
- }
- // special case 2
- for (int j = 2; j < -exponent + 1; j++) {
- result[--currentChar] = '0';
- }
- result[--currentChar] = '.';
- result[--currentChar] = '0';
- if (negNumber) {
- result[--currentChar] = '-';
- }
- return new String(result, currentChar, resLengthInChars - currentChar);
- }
- int startPoint = currentChar + 1;
- int endPoint = resLengthInChars;
- StringBuilder result1 = new StringBuilder(16 + endPoint - startPoint);
- if (negNumber) {
- result1.append('-');
- }
- if (endPoint - startPoint >= 1) {
- result1.append(result[currentChar]);
- result1.append('.');
- result1.append(result, currentChar + 1, resLengthInChars - currentChar
- - 1);
- } else {
- result1.append(result, currentChar, resLengthInChars - currentChar);
- }
- result1.append('E');
- if (exponent > 0) {
- result1.append('+');
- }
- result1.append(Long.toString(exponent));
- return result1.toString();
- }
-
- /**
- * Just to denote that this class can't be instantiated.
- */
- private Conversion() {
- }
-
-// /**
-// * @see BigInteger#doubleValue()
-// */
- // static double bigInteger2Double(BigInteger val) {
- // // val.bitLength() < 64
- // if ((val.numberLength < 2)
- // || ((val.numberLength == 2) && (val.digits[1] > 0))) {
- // return val.longValue();
- // }
- // // val.bitLength() >= 33 * 32 > 1024
- // if (val.numberLength > 32) {
- // return ((val.sign > 0) ? Double.POSITIVE_INFINITY
- // : Double.NEGATIVE_INFINITY);
- // }
- // int bitLen = val.abs().bitLength();
- // long exponent = bitLen - 1;
- // int delta = bitLen - 54;
- // // We need 54 top bits from this, the 53th bit is always 1 in lVal.
- // long lVal = val.abs().shiftRight(delta).longValue();
- // /*
- // * Take 53 bits from lVal to mantissa. The least significant bit is
- // * needed for rounding.
- // */
- // long mantissa = lVal & 0x1FFFFFFFFFFFFFL;
- // if (exponent == 1023) {
- // if (mantissa == 0X1FFFFFFFFFFFFFL) {
- // return ((val.sign > 0) ? Double.POSITIVE_INFINITY
- // : Double.NEGATIVE_INFINITY);
- // }
- // if (mantissa == 0x1FFFFFFFFFFFFEL) {
- // return ((val.sign > 0) ? Double.MAX_VALUE : -Double.MAX_VALUE);
- // }
- // }
- // // Round the mantissa
- // if (((mantissa & 1) == 1)
- // && (((mantissa & 2) == 2) || BitLevel.nonZeroDroppedBits(delta,
- // val.digits))) {
- // mantissa += 2;
- // }
- // mantissa >>= 1; // drop the rounding bit
- // long resSign = (val.sign < 0) ? 0x8000000000000000L : 0;
- // exponent = ((1023 + exponent) << 52) & 0x7FF0000000000000L;
- // long result = resSign | exponent | mantissa;
- // return Double.longBitsToDouble(result);
- // }
-}
diff --git a/user/super/com/google/gwt/emul/java/math/Division.java b/user/super/com/google/gwt/emul/java/math/Division.java
deleted file mode 100644
index 4179a82..0000000
--- a/user/super/com/google/gwt/emul/java/math/Division.java
+++ /dev/null
@@ -1,1013 +0,0 @@
-/*
- * 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 operations related with division and modular
- * arithmetic to {@link BigInteger}. Some methods are provided in both mutable
- * and immutable way. There are several variants provided listed below:
- *
- * <ul type="circle"> <li><b>Division</b> <ul type="circle"> <li>
- * {@link BigInteger} division and remainder by {@link BigInteger}.</li> <li>
- * {@link BigInteger} division and remainder by {@code int}.</li> <li><i>gcd</i>
- * between {@link BigInteger} numbers.</li> </ul> </li> <li><b>Modular
- * arithmetic </b> <ul type="circle"> <li>Modular exponentiation between
- * {@link BigInteger} numbers.</li> <li>Modular inverse of a {@link BigInteger}
- * numbers.</li> </ul> </li> </ul>
- */
-class Division {
-
- /**
- * Divides the array 'a' by the array 'b' and gets the quotient and the
- * remainder. Implements the Knuth's division algorithm. See D. Knuth, The Art
- * of Computer Programming, vol. 2. Steps D1-D8 correspond the steps in the
- * algorithm description.
- *
- * @param quot the quotient
- * @param quotLength the quotient's length
- * @param a the dividend
- * @param aLength the dividend's length
- * @param b the divisor
- * @param bLength the divisor's length
- * @return the remainder
- */
- static int[] divide(int quot[], int quotLength, int a[], int aLength,
- int b[], int bLength) {
-
- int normA[] = new int[aLength + 1]; // the normalized dividend
- // an extra byte is needed for correct shift
- int normB[] = new int[bLength + 1]; // the normalized divisor;
- int normBLength = bLength;
- /*
- * Step D1: normalize a and b and put the results to a1 and b1 the
- * normalized divisor's first digit must be >= 2^31
- */
- int divisorShift = Integer.numberOfLeadingZeros(b[bLength - 1]);
- if (divisorShift != 0) {
- BitLevel.shiftLeft(normB, b, 0, divisorShift);
- BitLevel.shiftLeft(normA, a, 0, divisorShift);
- } else {
- System.arraycopy(a, 0, normA, 0, aLength);
- System.arraycopy(b, 0, normB, 0, bLength);
- }
- int firstDivisorDigit = normB[normBLength - 1];
- // Step D2: set the quotient index
- int i = quotLength - 1;
- int j = aLength;
-
- while (i >= 0) {
- // Step D3: calculate a guess digit guessDigit
- int guessDigit = 0;
- if (normA[j] == firstDivisorDigit) {
- // set guessDigit to the largest unsigned int value
- guessDigit = -1;
- } else {
- long product = (((normA[j] & 0xffffffffL) << 32) + (normA[j - 1] & 0xffffffffL));
- long res = Division.divideLongByInt(product, firstDivisorDigit);
- guessDigit = (int) res; // the quotient of divideLongByInt
- int rem = (int) (res >> 32); // the remainder of
- // divideLongByInt
- // decrease guessDigit by 1 while leftHand > rightHand
- if (guessDigit != 0) {
- long leftHand = 0;
- long rightHand = 0;
- boolean rOverflowed = false;
- guessDigit++; // to have the proper value in the loop
- // below
- do {
- guessDigit--;
- if (rOverflowed) {
- break;
- }
- // leftHand always fits in an unsigned long
- leftHand = (guessDigit & 0xffffffffL)
- * (normB[normBLength - 2] & 0xffffffffL);
- /*
- * rightHand can overflow; in this case the loop condition will be
- * true in the next step of the loop
- */
- rightHand = ((long) rem << 32) + (normA[j - 2] & 0xffffffffL);
- long longR = (rem & 0xffffffffL)
- + (firstDivisorDigit & 0xffffffffL);
- /*
- * checks that longR does not fit in an unsigned int; this ensures
- * that rightHand will overflow unsigned long in the next step
- */
- if (Integer.numberOfLeadingZeros((int) (longR >>> 32)) < 32) {
- rOverflowed = true;
- } else {
- rem = (int) longR;
- }
- } while (((leftHand ^ 0x8000000000000000L) > (rightHand ^ 0x8000000000000000L)));
- }
- }
- // Step D4: multiply normB by guessDigit and subtract the production
- // from normA.
- if (guessDigit != 0) {
- int borrow = Division.multiplyAndSubtract(normA, j - normBLength,
- normB, normBLength, guessDigit);
- // Step D5: check the borrow
- if (borrow != 0) {
- // Step D6: compensating addition
- guessDigit--;
- long carry = 0;
- for (int k = 0; k < normBLength; k++) {
- carry += (normA[j - normBLength + k] & 0xffffffffL)
- + (normB[k] & 0xffffffffL);
- normA[j - normBLength + k] = (int) carry;
- carry >>>= 32;
- }
- }
- }
- if (quot != null) {
- quot[i] = guessDigit;
- }
- // Step D7
- j--;
- i--;
- }
- /*
- * Step D8: we got the remainder in normA. Denormalize it id needed
- */
- if (divisorShift != 0) {
- // reuse normB
- BitLevel.shiftRight(normB, normBLength, normA, 0, divisorShift);
- return normB;
- }
- System.arraycopy(normA, 0, normB, 0, bLength);
- return normA;
- }
-
- /**
- * Computes the quotient and the remainder after a division by an {@code int}
- * number.
- *
- * @return an array of the form {@code [quotient, remainder]}.
- */
- static BigInteger[] divideAndRemainderByInteger(BigInteger val, int divisor,
- int divisorSign) {
- // res[0] is a quotient and res[1] is a remainder:
- int[] valDigits = val.digits;
- int valLen = val.numberLength;
- int valSign = val.sign;
- if (valLen == 1) {
- long a = (valDigits[0] & 0xffffffffL);
- long b = (divisor & 0xffffffffL);
- long quo = a / b;
- long rem = a % b;
- if (valSign != divisorSign) {
- quo = -quo;
- }
- if (valSign < 0) {
- rem = -rem;
- }
- return new BigInteger[] {BigInteger.valueOf(quo), BigInteger.valueOf(rem)};
- }
- int quotientLength = valLen;
- int quotientSign = ((valSign == divisorSign) ? 1 : -1);
- int quotientDigits[] = new int[quotientLength];
- int remainderDigits[];
- remainderDigits = new int[] {Division.divideArrayByInt(quotientDigits,
- valDigits, valLen, divisor)};
- BigInteger result0 = new BigInteger(quotientSign, quotientLength,
- quotientDigits);
- BigInteger result1 = new BigInteger(valSign, 1, remainderDigits);
- result0.cutOffLeadingZeroes();
- result1.cutOffLeadingZeroes();
- return new BigInteger[] {result0, result1};
- }
-
- /**
- * Divides an array by an integer value. Implements the Knuth's division
- * algorithm. See D. Knuth, The Art of Computer Programming, vol. 2.
- *
- * @param dest the quotient
- * @param src the dividend
- * @param srcLength the length of the dividend
- * @param divisor the divisor
- * @return remainder
- */
- static int divideArrayByInt(int dest[], int src[], final int srcLength,
- final int divisor) {
-
- long rem = 0;
- long bLong = divisor & 0xffffffffL;
-
- for (int i = srcLength - 1; i >= 0; i--) {
- long temp = (rem << 32) | (src[i] & 0xffffffffL);
- long quot;
- if (temp >= 0) {
- quot = (temp / bLong);
- rem = (temp % bLong);
- } else {
- /*
- * make the dividend positive shifting it right by 1 bit then get the
- * quotient an remainder and correct them properly
- */
- long aPos = temp >>> 1;
- long bPos = divisor >>> 1;
- quot = aPos / bPos;
- rem = aPos % bPos;
- // double the remainder and add 1 if a is odd
- rem = (rem << 1) + (temp & 1);
- if ((divisor & 1) != 0) {
- // the divisor is odd
- if (quot <= rem) {
- rem -= quot;
- } else {
- if (quot - rem <= bLong) {
- rem += bLong - quot;
- quot -= 1;
- } else {
- rem += (bLong << 1) - quot;
- quot -= 2;
- }
- }
- }
- }
- dest[i] = (int) (quot & 0xffffffffL);
- }
- return (int) rem;
- }
-
- /**
- * Divides an unsigned long a by an unsigned int b. It is supposed that the
- * most significant bit of b is set to 1, i.e. b < 0
- *
- * @param a the dividend
- * @param b the divisor
- * @return the long value containing the unsigned integer remainder in the
- * left half and the unsigned integer quotient in the right half
- */
- static long divideLongByInt(long a, int b) {
- long quot;
- long rem;
- long bLong = b & 0xffffffffL;
-
- if (a >= 0) {
- quot = (a / bLong);
- rem = (a % bLong);
- } else {
- /*
- * Make the dividend positive shifting it right by 1 bit then get the
- * quotient an remainder and correct them properly
- */
- long aPos = a >>> 1;
- long bPos = b >>> 1;
- quot = aPos / bPos;
- rem = aPos % bPos;
- // double the remainder and add 1 if a is odd
- rem = (rem << 1) + (a & 1);
- if ((b & 1) != 0) { // the divisor is odd
- if (quot <= rem) {
- rem -= quot;
- } else {
- if (quot - rem <= bLong) {
- rem += bLong - quot;
- quot -= 1;
- } else {
- rem += (bLong << 1) - quot;
- quot -= 2;
- }
- }
- }
- }
- return (rem << 32) | (quot & 0xffffffffL);
- }
-
- /**
- * Performs modular exponentiation using the Montgomery Reduction. It requires
- * that all parameters be positive and the modulus be even. Based <i>The
- * square and multiply algorithm and the Montgomery Reduction C. K. Koc -
- * Montgomery Reduction with Even Modulus</i>. The square and multiply
- * algorithm and the Montgomery Reduction.
- *
- * @ar.org.fitc.ref "C. K. Koc - Montgomery Reduction with Even Modulus"
- * @see BigInteger#modPow(BigInteger, BigInteger)
- */
- static BigInteger evenModPow(BigInteger base, BigInteger exponent,
- BigInteger modulus) {
- // PRE: (base > 0), (exponent > 0), (modulus > 0) and (modulus even)
- // STEP 1: Obtain the factorization 'modulus'= q * 2^j.
- int j = modulus.getLowestSetBit();
- BigInteger q = modulus.shiftRight(j);
-
- // STEP 2: Compute x1 := base^exponent (mod q).
- BigInteger x1 = oddModPow(base, exponent, q);
-
- // STEP 3: Compute x2 := base^exponent (mod 2^j).
- BigInteger x2 = pow2ModPow(base, exponent, j);
-
- // STEP 4: Compute q^(-1) (mod 2^j) and y := (x2-x1) * q^(-1) (mod 2^j)
- BigInteger qInv = modPow2Inverse(q, j);
- BigInteger y = (x2.subtract(x1)).multiply(qInv);
- inplaceModPow2(y, j);
- if (y.sign < 0) {
- y = y.add(BigInteger.getPowerOfTwo(j));
- }
- // STEP 5: Compute and return: x1 + q * y
- return x1.add(q.multiply(y));
- }
-
- /**
- * Performs the final reduction of the Montgomery algorithm.
- *
- * @see #monPro(BigInteger, BigInteger, BigInteger, long)
- * @see #monSquare(BigInteger, BigInteger, long)
- */
- static BigInteger finalSubtraction(int res[], BigInteger modulus) {
-
- // skipping leading zeros
- int modulusLen = modulus.numberLength;
- boolean doSub = res[modulusLen] != 0;
- if (!doSub) {
- int modulusDigits[] = modulus.digits;
- doSub = true;
- for (int i = modulusLen - 1; i >= 0; i--) {
- if (res[i] != modulusDigits[i]) {
- doSub = (res[i] != 0)
- && ((res[i] & 0xFFFFFFFFL) > (modulusDigits[i] & 0xFFFFFFFFL));
- break;
- }
- }
- }
-
- BigInteger result = new BigInteger(1, modulusLen + 1, res);
-
- // if (res >= modulusDigits) compute (res - modulusDigits)
- if (doSub) {
- Elementary.inplaceSubtract(result, modulus);
- }
-
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * @param m a positive modulus Return the greatest common divisor of op1 and
- * op2,
- *
- * @param op1 must be greater than zero
- * @param op2 must be greater than zero
- * @see BigInteger#gcd(BigInteger)
- * @return {@code GCD(op1, op2)}
- */
- static BigInteger gcdBinary(BigInteger op1, BigInteger op2) {
- // PRE: (op1 > 0) and (op2 > 0)
-
- /*
- * Divide both number the maximal possible times by 2 without rounding
- * gcd(2*a, 2*b) = 2 * gcd(a,b)
- */
- int lsb1 = op1.getLowestSetBit();
- int lsb2 = op2.getLowestSetBit();
- int pow2Count = Math.min(lsb1, lsb2);
-
- BitLevel.inplaceShiftRight(op1, lsb1);
- BitLevel.inplaceShiftRight(op2, lsb2);
-
- BigInteger swap;
- // I want op2 > op1
- if (op1.compareTo(op2) == BigInteger.GREATER) {
- swap = op1;
- op1 = op2;
- op2 = swap;
- }
-
- do { // INV: op2 >= op1 && both are odd unless op1 = 0
-
- // Optimization for small operands
- // (op2.bitLength() < 64) implies by INV (op1.bitLength() < 64)
- if ((op2.numberLength == 1)
- || ((op2.numberLength == 2) && (op2.digits[1] > 0))) {
- op2 = BigInteger.valueOf(Division.gcdBinary(op1.longValue(),
- op2.longValue()));
- break;
- }
-
- // Implements one step of the Euclidean algorithm
- // To reduce one operand if it's much smaller than the other one
- if (op2.numberLength > op1.numberLength * 1.2) {
- op2 = op2.remainder(op1);
- if (op2.signum() != 0) {
- BitLevel.inplaceShiftRight(op2, op2.getLowestSetBit());
- }
- } else {
-
- // Use Knuth's algorithm of successive subtract and shifting
- do {
- Elementary.inplaceSubtract(op2, op1); // both are odd
- BitLevel.inplaceShiftRight(op2, op2.getLowestSetBit()); // op2 is even
- } while (op2.compareTo(op1) >= BigInteger.EQUALS);
- }
- // now op1 >= op2
- swap = op2;
- op2 = op1;
- op1 = swap;
- } while (op1.sign != 0);
- return op2.shiftLeft(pow2Count);
- }
-
- /**
- * Performs the same as {@link #gcdBinary(BigInteger, BigInteger)}, but with
- * numbers of 63 bits, represented in positives values of {@code long} type.
- *
- * @param op1 a positive number
- * @param op2 a positive number
- * @see #gcdBinary(BigInteger, BigInteger)
- * @return <code>GCD(op1, op2)</code>
- */
- static long gcdBinary(long op1, long op2) {
- // PRE: (op1 > 0) and (op2 > 0)
- int lsb1 = Long.numberOfTrailingZeros(op1);
- int lsb2 = Long.numberOfTrailingZeros(op2);
- int pow2Count = Math.min(lsb1, lsb2);
-
- if (lsb1 != 0) {
- op1 >>>= lsb1;
- }
- if (lsb2 != 0) {
- op2 >>>= lsb2;
- }
- do {
- if (op1 >= op2) {
- op1 -= op2;
- op1 >>>= Long.numberOfTrailingZeros(op1);
- } else {
- op2 -= op1;
- op2 >>>= Long.numberOfTrailingZeros(op2);
- }
- } while (op1 != 0);
- return (op2 << pow2Count);
- }
-
- /**
- * Performs {@code x = x mod (2<sup>n</sup>)}.
- *
- * @param x a positive number, it will store the result.
- * @param n a positive exponent of {@code 2}.
- */
- static void inplaceModPow2(BigInteger x, int n) {
- // PRE: (x > 0) and (n >= 0)
- int fd = n >> 5;
- int leadingZeros;
-
- if ((x.numberLength < fd) || (x.bitLength() <= n)) {
- return;
- }
- leadingZeros = 32 - (n & 31);
- x.numberLength = fd + 1;
- x.digits[fd] &= (leadingZeros < 32) ? (-1 >>> leadingZeros) : 0;
- x.cutOffLeadingZeroes();
- }
-
- /**
- *
- * Based on "New Algorithm for Classical Modular Inverse" Róbert Lórencz. LNCS
- * 2523 (2002)
- *
- * @return a^(-1) mod m
- */
- static BigInteger modInverseLorencz(BigInteger a, BigInteger modulo) {
- // PRE: a is coprime with modulo, a < modulo
-
- int max = Math.max(a.numberLength, modulo.numberLength);
- int uDigits[] = new int[max + 1]; // enough place to make all the inplace
- // operation
- int vDigits[] = new int[max + 1];
- System.arraycopy(modulo.digits, 0, uDigits, 0, modulo.numberLength);
- System.arraycopy(a.digits, 0, vDigits, 0, a.numberLength);
- BigInteger u = new BigInteger(modulo.sign, modulo.numberLength, uDigits);
- BigInteger v = new BigInteger(a.sign, a.numberLength, vDigits);
-
- BigInteger r = new BigInteger(0, 1, new int[max + 1]); // BigInteger.ZERO;
- BigInteger s = new BigInteger(1, 1, new int[max + 1]);
- s.digits[0] = 1;
- // r == 0 && s == 1, but with enough place
-
- int coefU = 0, coefV = 0;
- int n = modulo.bitLength();
- int k;
- while (!isPowerOfTwo(u, coefU) && !isPowerOfTwo(v, coefV)) {
-
- // modification of original algorithm: I calculate how many times the
- // algorithm will enter in the same branch of if
- k = howManyIterations(u, n);
-
- if (k != 0) {
- BitLevel.inplaceShiftLeft(u, k);
- if (coefU >= coefV) {
- BitLevel.inplaceShiftLeft(r, k);
- } else {
- BitLevel.inplaceShiftRight(s, Math.min(coefV - coefU, k));
- if (k - (coefV - coefU) > 0) {
- BitLevel.inplaceShiftLeft(r, k - coefV + coefU);
- }
- }
- coefU += k;
- }
-
- k = howManyIterations(v, n);
- if (k != 0) {
- BitLevel.inplaceShiftLeft(v, k);
- if (coefV >= coefU) {
- BitLevel.inplaceShiftLeft(s, k);
- } else {
- BitLevel.inplaceShiftRight(r, Math.min(coefU - coefV, k));
- if (k - (coefU - coefV) > 0) {
- BitLevel.inplaceShiftLeft(s, k - coefU + coefV);
- }
- }
- coefV += k;
- }
-
- if (u.signum() == v.signum()) {
- if (coefU <= coefV) {
- Elementary.completeInPlaceSubtract(u, v);
- Elementary.completeInPlaceSubtract(r, s);
- } else {
- Elementary.completeInPlaceSubtract(v, u);
- Elementary.completeInPlaceSubtract(s, r);
- }
- } else {
- if (coefU <= coefV) {
- Elementary.completeInPlaceAdd(u, v);
- Elementary.completeInPlaceAdd(r, s);
- } else {
- Elementary.completeInPlaceAdd(v, u);
- Elementary.completeInPlaceAdd(s, r);
- }
- }
- if (v.signum() == 0 || u.signum() == 0) {
- // math.19: BigInteger not invertible
- throw new ArithmeticException("BigInteger not invertible.");
- }
- }
-
- if (isPowerOfTwo(v, coefV)) {
- r = s;
- if (v.signum() != u.signum()) {
- u = u.negate();
- }
- }
- if (u.testBit(n)) {
- if (r.signum() < 0) {
- r = r.negate();
- } else {
- r = modulo.subtract(r);
- }
- }
- if (r.signum() < 0) {
- r = r.add(modulo);
- }
-
- return r;
- }
-
- /**
- * Calculates a.modInverse(p) Based on: Savas, E; Koc, C "The Montgomery
- * Modular Inverse - Revised".
- */
- static BigInteger modInverseMontgomery(BigInteger a, BigInteger p) {
- if (a.sign == 0) {
- // ZERO hasn't inverse
- // math.19: BigInteger not invertible
- throw new ArithmeticException("BigInteger not invertible.");
- }
-
- if (!p.testBit(0)) {
- // montgomery inverse require even modulo
- return modInverseLorencz(a, p);
- }
-
- int m = p.numberLength * 32;
- // PRE: a \in [1, p - 1]
- BigInteger u, v, r, s;
- u = p.copy(); // make copy to use inplace method
- v = a.copy();
- int max = Math.max(v.numberLength, u.numberLength);
- r = new BigInteger(1, 1, new int[max + 1]);
- s = new BigInteger(1, 1, new int[max + 1]);
- s.digits[0] = 1;
- // s == 1 && v == 0
-
- int k = 0;
-
- int lsbu = u.getLowestSetBit();
- int lsbv = v.getLowestSetBit();
- int toShift;
-
- if (lsbu > lsbv) {
- BitLevel.inplaceShiftRight(u, lsbu);
- BitLevel.inplaceShiftRight(v, lsbv);
- BitLevel.inplaceShiftLeft(r, lsbv);
- k += lsbu - lsbv;
- } else {
- BitLevel.inplaceShiftRight(u, lsbu);
- BitLevel.inplaceShiftRight(v, lsbv);
- BitLevel.inplaceShiftLeft(s, lsbu);
- k += lsbv - lsbu;
- }
-
- r.sign = 1;
- while (v.signum() > 0) {
- // INV v >= 0, u >= 0, v odd, u odd (except last iteration when v is even
- // (0))
-
- while (u.compareTo(v) > BigInteger.EQUALS) {
- Elementary.inplaceSubtract(u, v);
- toShift = u.getLowestSetBit();
- BitLevel.inplaceShiftRight(u, toShift);
- Elementary.inplaceAdd(r, s);
- BitLevel.inplaceShiftLeft(s, toShift);
- k += toShift;
- }
-
- while (u.compareTo(v) <= BigInteger.EQUALS) {
- Elementary.inplaceSubtract(v, u);
- if (v.signum() == 0) {
- break;
- }
- toShift = v.getLowestSetBit();
- BitLevel.inplaceShiftRight(v, toShift);
- Elementary.inplaceAdd(s, r);
- BitLevel.inplaceShiftLeft(r, toShift);
- k += toShift;
- }
- }
- if (!u.isOne()) {
- // in u is stored the gcd
- // math.19: BigInteger not invertible.
- throw new ArithmeticException("BigInteger not invertible.");
- }
- if (r.compareTo(p) >= BigInteger.EQUALS) {
- Elementary.inplaceSubtract(r, p);
- }
-
- r = p.subtract(r);
-
- // Have pair: ((BigInteger)r, (Integer)k) where r == a^(-1) * 2^k mod
- // (module)
- int n1 = calcN(p);
- if (k > m) {
- r = monPro(r, BigInteger.ONE, p, n1);
- k = k - m;
- }
-
- r = monPro(r, BigInteger.getPowerOfTwo(m - k), p, n1);
- return r;
- }
-
- /**
- * @param x an odd positive number.
- * @param n the exponent by which 2 is raised.
- * @return {@code x<sup>-1</sup> (mod 2<sup>n</sup>)}.
- */
- static BigInteger modPow2Inverse(BigInteger x, int n) {
- // PRE: (x > 0), (x is odd), and (n > 0)
- BigInteger y = new BigInteger(1, new int[1 << n]);
- y.numberLength = 1;
- y.digits[0] = 1;
- y.sign = 1;
-
- for (int i = 1; i < n; i++) {
- if (BitLevel.testBit(x.multiply(y), i)) {
- // Adding 2^i to y (setting the i-th bit)
- y.digits[i >> 5] |= (1 << (i & 31));
- }
- }
- return y;
- }
-
- /**
- * Implements the Montgomery Product of two integers represented by {@code
- * int} arrays. The arrays are supposed in <i>little endian</i> notation.
- *
- * @param a The first factor of the product.
- * @param b The second factor of the product.
- * @param modulus The modulus of the operations. Z<sub>modulus</sub>.
- * @param n2 The digit modulus'[0].
- * @ar.org.fitc.ref "C. K. Koc - Analyzing and Comparing Montgomery
- * Multiplication Algorithms"
- * @see #modPowOdd(BigInteger, BigInteger, BigInteger)
- */
- static BigInteger monPro(BigInteger a, BigInteger b, BigInteger modulus,
- int n2) {
- int modulusLen = modulus.numberLength;
- int res[] = new int[(modulusLen << 1) + 1];
- Multiplication.multArraysPAP(a.digits,
- Math.min(modulusLen, a.numberLength), b.digits, Math.min(modulusLen,
- b.numberLength), res);
- monReduction(res, modulus, n2);
- return finalSubtraction(res, modulus);
- }
-
- /**
- * Multiplies an array by int and subtracts it from a subarray of another
- * array.
- *
- * @param a the array to subtract from
- * @param start the start element of the subarray of a
- * @param b the array to be multiplied and subtracted
- * @param bLen the length of b
- * @param c the multiplier of b
- * @return the carry element of subtraction
- */
- static int multiplyAndSubtract(int a[], int start, int b[], int bLen, int c) {
- long carry0 = 0;
- long carry1 = 0;
-
- for (int i = 0; i < bLen; i++) {
- carry0 = Multiplication.unsignedMultAddAdd(b[i], c, (int) carry0, 0);
- carry1 = (a[start + i] & 0xffffffffL) - (carry0 & 0xffffffffL) + carry1;
- a[start + i] = (int) carry1;
- carry1 >>= 32; // -1 or 0
- carry0 >>>= 32;
- }
-
- carry1 = (a[start + bLen] & 0xffffffffL) - carry0 + carry1;
- a[start + bLen] = (int) carry1;
- return (int) (carry1 >> 32); // -1 or 0
- }
-
- /**
- * Performs modular exponentiation using the Montgomery Reduction. It requires
- * that all parameters be positive and the modulus be odd. >
- *
- * @see BigInteger#modPow(BigInteger, BigInteger)
- * @see #monPro(BigInteger, BigInteger, BigInteger, int)
- * @see #slidingWindow(BigInteger, BigInteger, BigInteger, BigInteger, int)
- * @see #squareAndMultiply(BigInteger, BigInteger, BigInteger, BigInteger,
- * int)
- */
- static BigInteger oddModPow(BigInteger base, BigInteger exponent,
- BigInteger modulus) {
- // PRE: (base > 0), (exponent > 0), (modulus > 0) and (odd modulus)
- int k = (modulus.numberLength << 5); // r = 2^k
- // n-residue of base [base * r (mod modulus)]
- BigInteger a2 = base.shiftLeft(k).mod(modulus);
- // n-residue of base [1 * r (mod modulus)]
- BigInteger x2 = BigInteger.getPowerOfTwo(k).mod(modulus);
- BigInteger res;
- // Compute (modulus[0]^(-1)) (mod 2^32) for odd modulus
-
- int n2 = calcN(modulus);
- if (modulus.numberLength == 1) {
- res = squareAndMultiply(x2, a2, exponent, modulus, n2);
- } else {
- res = slidingWindow(x2, a2, exponent, modulus, n2);
- }
-
- return monPro(res, BigInteger.ONE, modulus, n2);
- }
-
- /**
- * It requires that all parameters be positive.
- *
- * @return {@code base<sup>exponent</sup> mod (2<sup>j</sup>)}.
- * @see BigInteger#modPow(BigInteger, BigInteger)
- */
- static BigInteger pow2ModPow(BigInteger base, BigInteger exponent, int j) {
- // PRE: (base > 0), (exponent > 0) and (j > 0)
- BigInteger res = BigInteger.ONE;
- BigInteger e = exponent.copy();
- BigInteger baseMod2toN = base.copy();
- BigInteger res2;
- /*
- * If 'base' is odd then it's coprime with 2^j and phi(2^j) = 2^(j-1); so we
- * can reduce reduce the exponent (mod 2^(j-1)).
- */
- if (base.testBit(0)) {
- inplaceModPow2(e, j - 1);
- }
- inplaceModPow2(baseMod2toN, j);
-
- for (int i = e.bitLength() - 1; i >= 0; i--) {
- res2 = res.copy();
- inplaceModPow2(res2, j);
- res = res.multiply(res2);
- if (BitLevel.testBit(e, i)) {
- res = res.multiply(baseMod2toN);
- inplaceModPow2(res, j);
- }
- }
- inplaceModPow2(res, j);
- return res;
- }
-
- /**
- * Divides a <code>BigInteger</code> by a signed <code>int</code> and returns
- * the remainder.
- *
- * @param dividend the BigInteger to be divided. Must be non-negative.
- * @param divisor a signed int
- * @return divide % divisor
- */
- static int remainder(BigInteger dividend, int divisor) {
- return remainderArrayByInt(dividend.digits, dividend.numberLength, divisor);
- }
-
- /**
- * Divides an array by an integer value. Implements the Knuth's division
- * algorithm. See D. Knuth, The Art of Computer Programming, vol. 2.
- *
- * @param src the dividend
- * @param srcLength the length of the dividend
- * @param divisor the divisor
- * @return remainder
- */
- static int remainderArrayByInt(int src[], final int srcLength,
- final int divisor) {
-
- long result = 0;
-
- for (int i = srcLength - 1; i >= 0; i--) {
- long temp = (result << 32) + (src[i] & 0xffffffffL);
- long res = divideLongByInt(temp, divisor);
- result = (int) (res >> 32);
- }
- return (int) result;
- }
-
- /*
- * Implements the Montgomery modular exponentiation based in <i>The sliding
- * windows algorithm and the MongomeryReduction</i>.
- *
- * @ar.org.fitc.ref
- * "A. Menezes,P. van Oorschot, S. Vanstone - Handbook of Applied Cryptography"
- * ;
- *
- * @see #oddModPow(BigInteger, BigInteger, BigInteger)
- */
- static BigInteger slidingWindow(BigInteger x2, BigInteger a2,
- BigInteger exponent, BigInteger modulus, int n2) {
- // fill odd low pows of a2
- BigInteger pows[] = new BigInteger[8];
- BigInteger res = x2;
- int lowexp;
- BigInteger x3;
- int acc3;
- pows[0] = a2;
-
- x3 = monPro(a2, a2, modulus, n2);
- for (int i = 1; i <= 7; i++) {
- pows[i] = monPro(pows[i - 1], x3, modulus, n2);
- }
-
- for (int i = exponent.bitLength() - 1; i >= 0; i--) {
- if (BitLevel.testBit(exponent, i)) {
- lowexp = 1;
- acc3 = i;
-
- for (int j = Math.max(i - 3, 0); j <= i - 1; j++) {
- if (BitLevel.testBit(exponent, j)) {
- if (j < acc3) {
- acc3 = j;
- lowexp = (lowexp << (i - j)) ^ 1;
- } else {
- lowexp = lowexp ^ (1 << (j - acc3));
- }
- }
- }
-
- for (int j = acc3; j <= i; j++) {
- res = monPro(res, res, modulus, n2);
- }
- res = monPro(pows[(lowexp - 1) >> 1], res, modulus, n2);
- i = acc3;
- } else {
- res = monPro(res, res, modulus, n2);
- }
- }
- return res;
- }
-
- static BigInteger squareAndMultiply(BigInteger x2, BigInteger a2,
- BigInteger exponent, BigInteger modulus, int n2) {
- BigInteger res = x2;
- for (int i = exponent.bitLength() - 1; i >= 0; i--) {
- res = monPro(res, res, modulus, n2);
- if (BitLevel.testBit(exponent, i)) {
- res = monPro(res, a2, modulus, n2);
- }
- }
- return res;
- }
-
- /**
- * Calculate the first digit of the inverse.
- */
- private static int calcN(BigInteger a) {
- long m0 = a.digits[0] & 0xFFFFFFFFL;
- long n2 = 1L; // this is a'[0]
- long powerOfTwo = 2L;
- do {
- if (((m0 * n2) & powerOfTwo) != 0) {
- n2 |= powerOfTwo;
- }
- powerOfTwo <<= 1;
- } while (powerOfTwo < 0x100000000L);
- n2 = -n2;
- return (int) (n2 & 0xFFFFFFFFL);
- }
-
- /**
- * Calculate how many iteration of Lorencz's algorithm would perform the same
- * operation.
- *
- * @param bi
- * @param n
- * @return
- */
- private static int howManyIterations(BigInteger bi, int n) {
- int i = n - 1;
- if (bi.sign > 0) {
- while (!bi.testBit(i)) {
- i--;
- }
- return n - 1 - i;
- } else {
- while (bi.testBit(i)) {
- i--;
- }
- return n - 1 - Math.max(i, bi.getLowestSetBit());
- }
- }
-
- /**
- * @return bi == abs(2^exp)
- */
- private static boolean isPowerOfTwo(BigInteger bi, int exp) {
- boolean result = false;
- result = (exp >> 5 == bi.numberLength - 1)
- && (bi.digits[bi.numberLength - 1] == 1 << (exp & 31));
- if (result) {
- for (int i = 0; result && i < bi.numberLength - 1; i++) {
- result = bi.digits[i] == 0;
- }
- }
- return result;
- }
-
- private static void monReduction(int[] res, BigInteger modulus, int n2) {
-
- /* res + m*modulus_digits */
- int[] modulusDigits = modulus.digits;
- int modulusLen = modulus.numberLength;
- long outerCarry = 0;
-
- for (int i = 0; i < modulusLen; i++) {
- long innnerCarry = 0;
- int m = (int) Multiplication.unsignedMultAddAdd(res[i], n2, 0, 0);
- for (int j = 0; j < modulusLen; j++) {
- innnerCarry = Multiplication.unsignedMultAddAdd(m, modulusDigits[j],
- res[i + j], (int) innnerCarry);
- res[i + j] = (int) innnerCarry;
- innnerCarry >>>= 32;
- }
-
- outerCarry += (res[i + modulusLen] & 0xFFFFFFFFL) + innnerCarry;
- res[i + modulusLen] = (int) outerCarry;
- outerCarry >>>= 32;
- }
-
- res[modulusLen << 1] = (int) outerCarry;
-
- /* res / r */
- for (int j = 0; j < modulusLen + 1; j++) {
- res[j] = res[j + modulusLen];
- }
- }
-}
diff --git a/user/super/com/google/gwt/emul/java/math/Elementary.java b/user/super/com/google/gwt/emul/java/math/Elementary.java
deleted file mode 100644
index 58bec5b..0000000
--- a/user/super/com/google/gwt/emul/java/math/Elementary.java
+++ /dev/null
@@ -1,457 +0,0 @@
-/*
- * 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 the basic arithmetic mutable operations for
- * {@link BigInteger}. The operations provided are listed below. <ul
- * type="circle"> <li>Addition.</li> <li>Subtraction.</li> <li>Comparison.</li>
- * </ul> In addition to this, some <i><b>Inplace</b></i> (mutable) methods are
- * provided.
- */
-class Elementary {
-
- /**
- * @see BigInteger#add(BigInteger) .
- * @param op1
- * @param op2
- * @return
- */
- static BigInteger add(BigInteger op1, BigInteger op2) {
- int resDigits[];
- int resSign;
- int op1Sign = op1.sign;
- int op2Sign = op2.sign;
-
- if (op1Sign == 0) {
- return op2;
- }
- if (op2Sign == 0) {
- return op1;
- }
- int op1Len = op1.numberLength;
- int op2Len = op2.numberLength;
-
- if (op1Len + op2Len == 2) {
- long a = (op1.digits[0] & 0xFFFFFFFFL);
- long b = (op2.digits[0] & 0xFFFFFFFFL);
- long res;
- int valueLo;
- int valueHi;
-
- if (op1Sign == op2Sign) {
- res = a + b;
- valueLo = (int) res;
- valueHi = (int) (res >>> 32);
- return ((valueHi == 0) ? new BigInteger(op1Sign, valueLo)
- : new BigInteger(op1Sign, 2, new int[] {valueLo, valueHi}));
- }
- return BigInteger.valueOf((op1Sign < 0) ? (b - a) : (a - b));
- } else if (op1Sign == op2Sign) {
- resSign = op1Sign;
- // an augend should not be shorter than addend
- resDigits = (op1Len >= op2Len) ? add(op1.digits, op1Len, op2.digits,
- op2Len) : add(op2.digits, op2Len, op1.digits, op1Len);
- } else { // signs are different
- int cmp = ((op1Len != op2Len) ? ((op1Len > op2Len) ? 1 : -1)
- : compareArrays(op1.digits, op2.digits, op1Len));
-
- if (cmp == BigInteger.EQUALS) {
- return BigInteger.ZERO;
- }
- // a minuend should not be shorter than subtrahend
- if (cmp == BigInteger.GREATER) {
- resSign = op1Sign;
- resDigits = subtract(op1.digits, op1Len, op2.digits, op2Len);
- } else {
- resSign = op2Sign;
- resDigits = subtract(op2.digits, op2Len, op1.digits, op1Len);
- }
- }
- BigInteger res = new BigInteger(resSign, resDigits.length, resDigits);
- res.cutOffLeadingZeroes();
- return res;
- }
-
- /**
- * Compares two arrays. All elements are treated as unsigned integers. The
- * magnitude is the bit chain of elements in big-endian order.
- *
- * @param a the first array
- * @param b the second array
- * @param size the size of arrays
- * @return 1 if a > b, -1 if a < b, 0 if a == b
- */
- static int compareArrays(final int[] a, final int[] b, final int size) {
- int i;
- for (i = size - 1; (i >= 0) && (a[i] == b[i]); i--) {
- // empty
- }
- return ((i < 0) ? BigInteger.EQUALS
- : (a[i] & 0xFFFFFFFFL) < (b[i] & 0xFFFFFFFFL) ? BigInteger.LESS
- : BigInteger.GREATER);
- }
-
- /**
- * Same as @link #inplaceAdd(BigInteger, BigInteger), but without the
- * restriction of non-positive values.
- *
- * @param op1 any number
- * @param op2 any number
- */
- static void completeInPlaceAdd(BigInteger op1, BigInteger op2) {
- if (op1.sign == 0) {
- System.arraycopy(op2.digits, 0, op1.digits, 0, op2.numberLength);
- } else if (op2.sign == 0) {
- return;
- } else if (op1.sign == op2.sign) {
- add(op1.digits, op1.digits, op1.numberLength, op2.digits,
- op2.numberLength);
- } else {
- int sign = unsignedArraysCompare(op1.digits, op2.digits,
- op1.numberLength, op2.numberLength);
- if (sign > 0) {
- subtract(op1.digits, op1.digits, op1.numberLength, op2.digits,
- op2.numberLength);
- } else {
- inverseSubtract(op1.digits, op1.digits, op1.numberLength, op2.digits,
- op2.numberLength);
- op1.sign = -op1.sign;
- }
- }
- op1.numberLength = Math.max(op1.numberLength, op2.numberLength) + 1;
- op1.cutOffLeadingZeroes();
- op1.unCache();
- }
-
- /**
- * Same as @link #inplaceSubtract(BigInteger, BigInteger), but without the
- * restriction of non-positive values.
- *
- * @param op1 should have enough space to save the result
- * @param op2
- */
- static void completeInPlaceSubtract(BigInteger op1, BigInteger op2) {
- int resultSign = op1.compareTo(op2);
- if (op1.sign == 0) {
- System.arraycopy(op2.digits, 0, op1.digits, 0, op2.numberLength);
- op1.sign = -op2.sign;
- } else if (op1.sign != op2.sign) {
- add(op1.digits, op1.digits, op1.numberLength, op2.digits,
- op2.numberLength);
- op1.sign = resultSign;
- } else {
- int sign = unsignedArraysCompare(op1.digits, op2.digits,
- op1.numberLength, op2.numberLength);
- if (sign > 0) {
- subtract(op1.digits, op1.digits, op1.numberLength, op2.digits,
- op2.numberLength); // op1 = op1 - op2
- // op1.sign remains equal
- } else {
- inverseSubtract(op1.digits, op1.digits, op1.numberLength, op2.digits,
- op2.numberLength); // op1 = op2 - op1
- op1.sign = -op1.sign;
- }
- }
- op1.numberLength = Math.max(op1.numberLength, op2.numberLength) + 1;
- op1.cutOffLeadingZeroes();
- op1.unCache();
- }
-
- /**
- * Performs {@code op1 += op2}. {@code op1} must have enough place to store
- * the result (i.e. {@code op1.bitLength() >= op2.bitLength()}). Both should
- * be positive (i.e. {@code op1 >= op2}).
- *
- * @param op1 the input minuend, and the output result.
- * @param op2 the addend
- */
- static void inplaceAdd(BigInteger op1, BigInteger op2) {
- // PRE: op1 >= op2 > 0
- add(op1.digits, op1.digits, op1.numberLength, op2.digits, op2.numberLength);
- op1.numberLength = Math.min(
- Math.max(op1.numberLength, op2.numberLength) + 1, op1.digits.length);
- op1.cutOffLeadingZeroes();
- op1.unCache();
- }
-
- /**
- * Performs: {@code op1 += addend}. The number must to have place to hold a
- * possible carry.
- */
- static void inplaceAdd(BigInteger op1, final int addend) {
- int carry = inplaceAdd(op1.digits, op1.numberLength, addend);
- if (carry == 1) {
- op1.digits[op1.numberLength] = 1;
- op1.numberLength++;
- }
- op1.unCache();
- }
-
- /**
- * Adds an integer value to the array of integers remembering carry.
- *
- * @return a possible generated carry (0 or 1)
- */
- static int inplaceAdd(int a[], final int aSize, final int addend) {
- long carry = addend & 0xFFFFFFFFL;
-
- for (int i = 0; (carry != 0) && (i < aSize); i++) {
- carry += a[i] & 0xFFFFFFFFL;
- a[i] = (int) carry;
- carry >>= 32;
- }
- return (int) carry;
- }
-
- /**
- * Performs {@code op1 -= op2}. {@code op1} must have enough place to store
- * the result (i.e. {@code op1.bitLength() >= op2.bitLength()}). Both should
- * be positive (what implies that {@code op1 >= op2}).
- *
- * @param op1 the input minuend, and the output result.
- * @param op2 the subtrahend
- */
- static void inplaceSubtract(BigInteger op1, BigInteger op2) {
- // PRE: op1 >= op2 > 0
- subtract(op1.digits, op1.digits, op1.numberLength, op2.digits,
- op2.numberLength);
- op1.cutOffLeadingZeroes();
- op1.unCache();
- }
-
- /**
- * @see BigInteger#subtract(BigInteger) .
- * @param op1
- * @param op2
- * @return
- */
- static BigInteger subtract(BigInteger op1, BigInteger op2) {
- int resSign;
- int resDigits[];
- int op1Sign = op1.sign;
- int op2Sign = op2.sign;
-
- if (op2Sign == 0) {
- return op1;
- }
- if (op1Sign == 0) {
- return op2.negate();
- }
- int op1Len = op1.numberLength;
- int op2Len = op2.numberLength;
- if (op1Len + op2Len == 2) {
- long a = (op1.digits[0] & 0xFFFFFFFFL);
- long b = (op2.digits[0] & 0xFFFFFFFFL);
- if (op1Sign < 0) {
- a = -a;
- }
- if (op2Sign < 0) {
- b = -b;
- }
- return BigInteger.valueOf(a - b);
- }
- int cmp = ((op1Len != op2Len) ? ((op1Len > op2Len) ? 1 : -1)
- : Elementary.compareArrays(op1.digits, op2.digits, op1Len));
-
- if (cmp == BigInteger.LESS) {
- resSign = -op2Sign;
- resDigits = (op1Sign == op2Sign) ? subtract(op2.digits, op2Len,
- op1.digits, op1Len) : add(op2.digits, op2Len, op1.digits, op1Len);
- } else {
- resSign = op1Sign;
- if (op1Sign == op2Sign) {
- if (cmp == BigInteger.EQUALS) {
- return BigInteger.ZERO;
- }
- resDigits = subtract(op1.digits, op1Len, op2.digits, op2Len);
- } else {
- resDigits = add(op1.digits, op1Len, op2.digits, op2Len);
- }
- }
- BigInteger res = new BigInteger(resSign, resDigits.length, resDigits);
- res.cutOffLeadingZeroes();
- return res;
- }
-
- /**
- * Addss the value represented by {@code b} to the value represented by
- * {@code a}. It is assumed the magnitude of a is not less than the magnitude
- * of b.
- *
- * @return {@code a + b}
- */
- private static int[] add(int a[], int aSize, int b[], int bSize) {
- // PRE: a[] >= b[]
- int res[] = new int[aSize + 1];
- add(res, a, aSize, b, bSize);
- return res;
- }
-
- /**
- * Performs {@code res = a + b}.
- */
- private static void add(int res[], int a[], int aSize, int b[], int bSize) {
- // PRE: a.length < max(aSize, bSize)
-
- int i;
- long carry = (a[0] & 0xFFFFFFFFL) + (b[0] & 0xFFFFFFFFL);
-
- res[0] = (int) carry;
- carry >>= 32;
-
- if (aSize >= bSize) {
- for (i = 1; i < bSize; i++) {
- carry += (a[i] & 0xFFFFFFFFL) + (b[i] & 0xFFFFFFFFL);
- res[i] = (int) carry;
- carry >>= 32;
- }
- for (; i < aSize; i++) {
- carry += a[i] & 0xFFFFFFFFL;
- res[i] = (int) carry;
- carry >>= 32;
- }
- } else {
- for (i = 1; i < aSize; i++) {
- carry += (a[i] & 0xFFFFFFFFL) + (b[i] & 0xFFFFFFFFL);
- res[i] = (int) carry;
- carry >>= 32;
- }
- for (; i < bSize; i++) {
- carry += b[i] & 0xFFFFFFFFL;
- res[i] = (int) carry;
- carry >>= 32;
- }
- }
- if (carry != 0) {
- res[i] = (int) carry;
- }
- }
-
- /**
- * Performs {@code res = b - a}.
- */
- private static void inverseSubtract(int res[], int a[], int aSize, int b[],
- int bSize) {
- int i;
- long borrow = 0;
- if (aSize < bSize) {
- for (i = 0; i < aSize; i++) {
- borrow += (b[i] & 0xFFFFFFFFL) - (a[i] & 0xFFFFFFFFL);
- res[i] = (int) borrow;
- borrow >>= 32; // -1 or 0
- }
- for (; i < bSize; i++) {
- borrow += b[i] & 0xFFFFFFFFL;
- res[i] = (int) borrow;
- borrow >>= 32; // -1 or 0
- }
- } else {
- for (i = 0; i < bSize; i++) {
- borrow += (b[i] & 0xFFFFFFFFL) - (a[i] & 0xFFFFFFFFL);
- res[i] = (int) borrow;
- borrow >>= 32; // -1 or 0
- }
- for (; i < aSize; i++) {
- borrow -= a[i] & 0xFFFFFFFFL;
- res[i] = (int) borrow;
- borrow >>= 32; // -1 or 0
- }
- }
- }
-
- /**
- * Subtracts the value represented by {@code b} from the value represented by
- * {@code a}. It is assumed the magnitude of a is not less than the magnitude
- * of b.
- *
- * @return {@code a - b}
- */
- private static int[] subtract(int a[], int aSize, int b[], int bSize) {
- // PRE: a[] >= b[]
- int res[] = new int[aSize];
- subtract(res, a, aSize, b, bSize);
- return res;
- }
-
- /**
- * Performs {@code res = a - b}. It is assumed the magnitude of a is not less
- * than the magnitude of b.
- */
- private static void subtract(int res[], int a[], int aSize, int b[], int bSize) {
- // PRE: a[] >= b[]
- int i;
- long borrow = 0;
-
- for (i = 0; i < bSize; i++) {
- borrow += (a[i] & 0xFFFFFFFFL) - (b[i] & 0xFFFFFFFFL);
- res[i] = (int) borrow;
- borrow >>= 32; // -1 or 0
- }
- for (; i < aSize; i++) {
- borrow += a[i] & 0xFFFFFFFFL;
- res[i] = (int) borrow;
- borrow >>= 32; // -1 or 0
- }
- }
-
- /**
- * Compares two arrays, representing unsigned integer in little-endian order.
- * Returns +1,0,-1 if a is - respective - greater, equal or lesser then b
- */
- private static int unsignedArraysCompare(int[] a, int[] b, int aSize,
- int bSize) {
- if (aSize > bSize) {
- return 1;
- } else if (aSize < bSize) {
- return -1;
- } else {
- int i;
- for (i = aSize - 1; i >= 0 && a[i] == b[i]; i--) {
- // empty
- }
- return i < 0 ? BigInteger.EQUALS
- : ((a[i] & 0xFFFFFFFFL) < (b[i] & 0xFFFFFFFFL) ? BigInteger.LESS
- : BigInteger.GREATER);
- }
- }
-
- /**
- * Just to denote that this class can't be instantiated.
- */
- private Elementary() {
- }
-
-}
diff --git a/user/super/com/google/gwt/emul/java/math/Logical.java b/user/super/com/google/gwt/emul/java/math/Logical.java
deleted file mode 100644
index d3ab03e..0000000
--- a/user/super/com/google/gwt/emul/java/math/Logical.java
+++ /dev/null
@@ -1,926 +0,0 @@
-/*
- * 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;
-
-/**
- * The library implements some logical operations over {@code BigInteger}. The
- * operations provided are listed below. <ul type="circle"> <li>not</li> <li>and
- * </li> <li>andNot</li> <li>or</li> <li>xor</li> </ul>
- */
-class Logical {
-
- /**
- * @see BigInteger#and(BigInteger)
- * @param val
- * @param that
- * @return
- */
- static BigInteger and(BigInteger val, BigInteger that) {
- if (that.sign == 0 || val.sign == 0) {
- return BigInteger.ZERO;
- }
- if (that.equals(BigInteger.MINUS_ONE)) {
- return val;
- }
- if (val.equals(BigInteger.MINUS_ONE)) {
- return that;
- }
-
- if (val.sign > 0) {
- if (that.sign > 0) {
- return andPositive(val, that);
- } else {
- return andDiffSigns(val, that);
- }
- } else {
- if (that.sign > 0) {
- return andDiffSigns(that, val);
- } else if (val.numberLength > that.numberLength) {
- return andNegative(val, that);
- } else {
- return andNegative(that, val);
- }
- }
- }
-
- /**
- * Return sign = positive.magnitude & magnitude = -negative.magnitude.
- * @param positive
- * @param negative
- * @return
- */
- static BigInteger andDiffSigns(BigInteger positive, BigInteger negative) {
- // PRE: positive is positive and negative is negative
- int iPos = positive.getFirstNonzeroDigit();
- int iNeg = negative.getFirstNonzeroDigit();
-
- // Look if the trailing zeros of the negative will "blank" all
- // the positive digits
- if (iNeg >= positive.numberLength) {
- return BigInteger.ZERO;
- }
- int resLength = positive.numberLength;
- int resDigits[] = new int[resLength];
-
- // Must start from max(iPos, iNeg)
- int i = Math.max(iPos, iNeg);
- if (i == iNeg) {
- resDigits[i] = -negative.digits[i] & positive.digits[i];
- i++;
- }
- int limit = Math.min(negative.numberLength, positive.numberLength);
- for (; i < limit; i++) {
- resDigits[i] = ~negative.digits[i] & positive.digits[i];
- }
- // if the negative was shorter must copy the remaining digits
- // from positive
- if (i >= negative.numberLength) {
- for (; i < positive.numberLength; i++) {
- resDigits[i] = positive.digits[i];
- }
- } // else positive ended and must "copy" virtual 0's, do nothing then
-
- BigInteger result = new BigInteger(1, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Return sign = -1, magnitude = -(-longer.magnitude & -shorter.magnitude).
- * @param longer
- * @param shorter
- * @return
- */
- static BigInteger andNegative(BigInteger longer, BigInteger shorter) {
- // PRE: longer and shorter are negative
- // PRE: longer has at least as many digits as shorter
- int iLonger = longer.getFirstNonzeroDigit();
- int iShorter = shorter.getFirstNonzeroDigit();
-
- // Does shorter matter?
- if (iLonger >= shorter.numberLength) {
- return longer;
- }
-
- int resLength;
- int resDigits[];
- int i = Math.max(iShorter, iLonger);
- int digit;
- if (iShorter > iLonger) {
- digit = -shorter.digits[i] & ~longer.digits[i];
- } else if (iShorter < iLonger) {
- digit = ~shorter.digits[i] & -longer.digits[i];
- } else {
- digit = -shorter.digits[i] & -longer.digits[i];
- }
- if (digit == 0) {
- for (i++; i < shorter.numberLength
- && (digit = ~(longer.digits[i] | shorter.digits[i])) == 0; i++) {
- // digit
- }
- // = ~longer.digits[i] & ~shorter.digits[i]
- if (digit == 0) {
- // shorter has only the remaining virtual sign bits
- for (; i < longer.numberLength && (digit = ~longer.digits[i]) == 0; i++) {
- // empty
- }
- if (digit == 0) {
- resLength = longer.numberLength + 1;
- resDigits = new int[resLength];
- resDigits[resLength - 1] = 1;
-
- BigInteger result = new BigInteger(-1, resLength, resDigits);
- return result;
- }
- }
- }
- resLength = longer.numberLength;
- resDigits = new int[resLength];
- resDigits[i] = -digit;
- for (i++; i < shorter.numberLength; i++) {
- // resDigits[i] = ~(~longer.digits[i] & ~shorter.digits[i];)
- resDigits[i] = longer.digits[i] | shorter.digits[i];
- }
- // shorter has only the remaining virtual sign bits
- for (; i < longer.numberLength; i++) {
- resDigits[i] = longer.digits[i];
- }
-
- BigInteger result = new BigInteger(-1, resLength, resDigits);
- return result;
- }
-
- /**
- * @see BigInteger#andNot(BigInteger)
- * @param val
- * @param that
- * @return
- */
- static BigInteger andNot(BigInteger val, BigInteger that) {
- if (that.sign == 0) {
- return val;
- }
- if (val.sign == 0) {
- return BigInteger.ZERO;
- }
- if (val.equals(BigInteger.MINUS_ONE)) {
- return that.not();
- }
- if (that.equals(BigInteger.MINUS_ONE)) {
- return BigInteger.ZERO;
- }
-
- // if val == that, return 0
-
- if (val.sign > 0) {
- if (that.sign > 0) {
- return andNotPositive(val, that);
- } else {
- return andNotPositiveNegative(val, that);
- }
- } else {
- if (that.sign > 0) {
- return andNotNegativePositive(val, that);
- } else {
- return andNotNegative(val, that);
- }
- }
- }
-
- /**
- * Return sign = 1, magnitude = -val.magnitude & ~(-that.magnitude).
- * @param val
- * @param that
- * @return
- */
- static BigInteger andNotNegative(BigInteger val, BigInteger that) {
- // PRE: val < 0 && that < 0
- int iVal = val.getFirstNonzeroDigit();
- int iThat = that.getFirstNonzeroDigit();
-
- if (iVal >= that.numberLength) {
- return BigInteger.ZERO;
- }
-
- int resLength = that.numberLength;
- int resDigits[] = new int[resLength];
- int limit;
- int i = iVal;
- if (iVal < iThat) {
- // resDigits[i] = -val.digits[i] & -1;
- resDigits[i] = -val.digits[i];
- limit = Math.min(val.numberLength, iThat);
- for (i++; i < limit; i++) {
- // resDigits[i] = ~val.digits[i] & -1;
- resDigits[i] = ~val.digits[i];
- }
- if (i == val.numberLength) {
- for (; i < iThat; i++) {
- // resDigits[i] = -1 & -1;
- resDigits[i] = -1;
- }
- // resDigits[i] = -1 & ~-that.digits[i];
- resDigits[i] = that.digits[i] - 1;
- } else {
- // resDigits[i] = ~val.digits[i] & ~-that.digits[i];
- resDigits[i] = ~val.digits[i] & (that.digits[i] - 1);
- }
- } else if (iThat < iVal) {
- // resDigits[i] = -val.digits[i] & ~~that.digits[i];
- resDigits[i] = -val.digits[i] & that.digits[i];
- } else {
- // resDigits[i] = -val.digits[i] & ~-that.digits[i];
- resDigits[i] = -val.digits[i] & (that.digits[i] - 1);
- }
-
- limit = Math.min(val.numberLength, that.numberLength);
- for (i++; i < limit; i++) {
- // resDigits[i] = ~val.digits[i] & ~~that.digits[i];
- resDigits[i] = ~val.digits[i] & that.digits[i];
- }
- for (; i < that.numberLength; i++) {
- // resDigits[i] = -1 & ~~that.digits[i];
- resDigits[i] = that.digits[i];
- }
-
- BigInteger result = new BigInteger(1, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Return sign = -1, magnitude = -(-negative.magnitude & ~positive.magnitude).
- * @param negative
- * @param positive
- * @return
- */
- static BigInteger andNotNegativePositive(BigInteger negative,
- BigInteger positive) {
- // PRE: negative < 0 && positive > 0
- int resLength;
- int resDigits[];
- int limit;
- int digit;
-
- int iNeg = negative.getFirstNonzeroDigit();
- int iPos = positive.getFirstNonzeroDigit();
-
- if (iNeg >= positive.numberLength) {
- return negative;
- }
-
- resLength = Math.max(negative.numberLength, positive.numberLength);
- int i = iNeg;
- if (iPos > iNeg) {
- resDigits = new int[resLength];
- limit = Math.min(negative.numberLength, iPos);
- for (; i < limit; i++) {
- // 1st case: resDigits [i] = -(-negative.digits[i] & (~0))
- // otherwise: resDigits[i] = ~(~negative.digits[i] & ~0) ;
- resDigits[i] = negative.digits[i];
- }
- if (i == negative.numberLength) {
- for (i = iPos; i < positive.numberLength; i++) {
- // resDigits[i] = ~(~positive.digits[i] & -1);
- resDigits[i] = positive.digits[i];
- }
- }
- } else {
- digit = -negative.digits[i] & ~positive.digits[i];
- if (digit == 0) {
- limit = Math.min(positive.numberLength, negative.numberLength);
- for (i++; i < limit
- && (digit = ~(negative.digits[i] | positive.digits[i])) == 0; i++) {
- // digit
- }
- // = ~negative.digits[i] & ~positive.digits[i]
- if (digit == 0) {
- // the shorter has only the remaining virtual sign bits
- for (; i < positive.numberLength
- && (digit = ~positive.digits[i]) == 0; i++) {
- // digit = -1 & ~positive.digits[i]
- }
- for (; i < negative.numberLength
- && (digit = ~negative.digits[i]) == 0; i++) {
- // empty
- }
- // digit = ~negative.digits[i] & ~0
- if (digit == 0) {
- resLength++;
- resDigits = new int[resLength];
- resDigits[resLength - 1] = 1;
-
- BigInteger result = new BigInteger(-1, resLength, resDigits);
- return result;
- }
- }
- }
- resDigits = new int[resLength];
- resDigits[i] = -digit;
- i++;
- }
-
- limit = Math.min(positive.numberLength, negative.numberLength);
- for (; i < limit; i++) {
- // resDigits[i] = ~(~negative.digits[i] & ~positive.digits[i]);
- resDigits[i] = negative.digits[i] | positive.digits[i];
- }
- // Actually one of the next two cycles will be executed
- for (; i < negative.numberLength; i++) {
- resDigits[i] = negative.digits[i];
- }
- for (; i < positive.numberLength; i++) {
- resDigits[i] = positive.digits[i];
- }
-
- BigInteger result = new BigInteger(-1, resLength, resDigits);
- return result;
- }
-
- /**
- * Return sign = 1, magnitude = val.magnitude & ~that.magnitude.
- * @param val
- * @param that
- * @return
- */
- static BigInteger andNotPositive(BigInteger val, BigInteger that) {
- // PRE: both arguments are positive
- int resDigits[] = new int[val.numberLength];
-
- int limit = Math.min(val.numberLength, that.numberLength);
- int i;
- for (i = val.getFirstNonzeroDigit(); i < limit; i++) {
- resDigits[i] = val.digits[i] & ~that.digits[i];
- }
- for (; i < val.numberLength; i++) {
- resDigits[i] = val.digits[i];
- }
-
- BigInteger result = new BigInteger(1, val.numberLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Return sign = 1, magnitude = positive.magnitude & ~(-negative.magnitude).
- * @param positive
- * @param negative
- * @return
- */
- static BigInteger andNotPositiveNegative(BigInteger positive,
- BigInteger negative) {
- // PRE: positive > 0 && negative < 0
- int iNeg = negative.getFirstNonzeroDigit();
- int iPos = positive.getFirstNonzeroDigit();
-
- if (iNeg >= positive.numberLength) {
- return positive;
- }
-
- int resLength = Math.min(positive.numberLength, negative.numberLength);
- int resDigits[] = new int[resLength];
-
- // Always start from first non zero of positive
- int i = iPos;
- for (; i < iNeg; i++) {
- // resDigits[i] = positive.digits[i] & -1 (~0)
- resDigits[i] = positive.digits[i];
- }
- if (i == iNeg) {
- resDigits[i] = positive.digits[i] & (negative.digits[i] - 1);
- i++;
- }
- for (; i < resLength; i++) {
- // resDigits[i] = positive.digits[i] & ~(~negative.digits[i]);
- resDigits[i] = positive.digits[i] & negative.digits[i];
- }
-
- BigInteger result = new BigInteger(1, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Return sign = 1, magnitude = val.magnitude & that.magnitude.
- * @param val
- * @param that
- * @return
- */
- static BigInteger andPositive(BigInteger val, BigInteger that) {
- // PRE: both arguments are positive
- int resLength = Math.min(val.numberLength, that.numberLength);
- int i = Math.max(val.getFirstNonzeroDigit(), that.getFirstNonzeroDigit());
-
- if (i >= resLength) {
- return BigInteger.ZERO;
- }
-
- int resDigits[] = new int[resLength];
- for (; i < resLength; i++) {
- resDigits[i] = val.digits[i] & that.digits[i];
- }
-
- BigInteger result = new BigInteger(1, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * @see BigInteger#not()
- * @param val
- * @return
- */
- static BigInteger not(BigInteger val) {
- if (val.sign == 0) {
- return BigInteger.MINUS_ONE;
- }
- if (val.equals(BigInteger.MINUS_ONE)) {
- return BigInteger.ZERO;
- }
- int resDigits[] = new int[val.numberLength + 1];
- int i;
-
- if (val.sign > 0) {
- // ~val = -val + 1
- if (val.digits[val.numberLength - 1] != -1) {
- for (i = 0; val.digits[i] == -1; i++) {
- // empty
- }
- } else {
- for (i = 0; (i < val.numberLength) && (val.digits[i] == -1); i++) {
- // empty
- }
- if (i == val.numberLength) {
- resDigits[i] = 1;
- return new BigInteger(-val.sign, i + 1, resDigits);
- }
- }
- // Here a carry 1 was generated
- } else {
- // (val.sign < 0)
- // ~val = -val - 1
- for (i = 0; val.digits[i] == 0; i++) {
- resDigits[i] = -1;
- }
- // Here a borrow -1 was generated
- }
- // Now, the carry/borrow can be absorbed
- resDigits[i] = val.digits[i] + val.sign;
- // Copying the remaining unchanged digit
- for (i++; i < val.numberLength; i++) {
- resDigits[i] = val.digits[i];
- }
- return new BigInteger(-val.sign, i, resDigits);
- }
-
- /**
- * @see BigInteger#or(BigInteger).
- * @param val
- * @param that
- * @return
- */
- static BigInteger or(BigInteger val, BigInteger that) {
- if (that.equals(BigInteger.MINUS_ONE) || val.equals(BigInteger.MINUS_ONE)) {
- return BigInteger.MINUS_ONE;
- }
- if (that.sign == 0) {
- return val;
- }
- if (val.sign == 0) {
- return that;
- }
-
- if (val.sign > 0) {
- if (that.sign > 0) {
- if (val.numberLength > that.numberLength) {
- return orPositive(val, that);
- } else {
- return orPositive(that, val);
- }
- } else {
- return orDiffSigns(val, that);
- }
- } else {
- if (that.sign > 0) {
- return orDiffSigns(that, val);
- } else if (that.getFirstNonzeroDigit() > val.getFirstNonzeroDigit()) {
- return orNegative(that, val);
- } else {
- return orNegative(val, that);
- }
- }
- }
-
- /**
- * Return sign = -1, magnitude = -(positive.magnitude | -negative.magnitude).
- * @param positive
- * @param negative
- * @return
- */
- static BigInteger orDiffSigns(BigInteger positive, BigInteger negative) {
- // Jumping over the least significant zero bits
- int iNeg = negative.getFirstNonzeroDigit();
- int iPos = positive.getFirstNonzeroDigit();
- int i;
- int limit;
-
- // Look if the trailing zeros of the positive will "copy" all
- // the negative digits
- if (iPos >= negative.numberLength) {
- return negative;
- }
- int resLength = negative.numberLength;
- int resDigits[] = new int[resLength];
-
- if (iNeg < iPos) {
- // We know for sure that this will
- // be the first non zero digit in the result
- for (i = iNeg; i < iPos; i++) {
- resDigits[i] = negative.digits[i];
- }
- } else if (iPos < iNeg) {
- i = iPos;
- resDigits[i] = -positive.digits[i];
- limit = Math.min(positive.numberLength, iNeg);
- for (i++; i < limit; i++) {
- resDigits[i] = ~positive.digits[i];
- }
- if (i != positive.numberLength) {
- resDigits[i] = ~(-negative.digits[i] | positive.digits[i]);
- } else {
- for (; i < iNeg; i++) {
- resDigits[i] = -1;
- }
- // resDigits[i] = ~(-negative.digits[i] | 0);
- resDigits[i] = negative.digits[i] - 1;
- }
- i++;
- } else {
- // iNeg == iPos
- // Applying two complement to negative and to result
- i = iPos;
- resDigits[i] = -(-negative.digits[i] | positive.digits[i]);
- i++;
- }
- limit = Math.min(negative.numberLength, positive.numberLength);
- for (; i < limit; i++) {
- // Applying two complement to negative and to result
- // resDigits[i] = ~(~negative.digits[i] | positive.digits[i] );
- resDigits[i] = negative.digits[i] & ~positive.digits[i];
- }
- for (; i < negative.numberLength; i++) {
- resDigits[i] = negative.digits[i];
- }
-
- BigInteger result = new BigInteger(-1, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Return sign = -1, magnitude = -(-val.magnitude | -that.magnitude).
- * @param val
- * @param that
- * @return
- */
- static BigInteger orNegative(BigInteger val, BigInteger that) {
- // PRE: val and that are negative;
- // PRE: val has at least as many trailing zeros digits as that
- int iThat = that.getFirstNonzeroDigit();
- int iVal = val.getFirstNonzeroDigit();
- int i;
-
- if (iVal >= that.numberLength) {
- return that;
- } else if (iThat >= val.numberLength) {
- return val;
- }
-
- int resLength = Math.min(val.numberLength, that.numberLength);
- int resDigits[] = new int[resLength];
-
- // Looking for the first non-zero digit of the result
- if (iThat == iVal) {
- resDigits[iVal] = -(-val.digits[iVal] | -that.digits[iVal]);
- i = iVal;
- } else {
- for (i = iThat; i < iVal; i++) {
- resDigits[i] = that.digits[i];
- }
- resDigits[i] = that.digits[i] & (val.digits[i] - 1);
- }
-
- for (i++; i < resLength; i++) {
- resDigits[i] = val.digits[i] & that.digits[i];
- }
-
- BigInteger result = new BigInteger(-1, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Return sign = 1, magnitude = longer.magnitude | shorter.magnitude.
- * @param longer
- * @param shorter
- * @return
- */
- static BigInteger orPositive(BigInteger longer, BigInteger shorter) {
- // PRE: longer and shorter are positive;
- // PRE: longer has at least as many digits as shorter
- int resLength = longer.numberLength;
- int resDigits[] = new int[resLength];
-
- int i = Math.min(longer.getFirstNonzeroDigit(),
- shorter.getFirstNonzeroDigit());
- for (i = 0; i < shorter.numberLength; i++) {
- resDigits[i] = longer.digits[i] | shorter.digits[i];
- }
- for (; i < resLength; i++) {
- resDigits[i] = longer.digits[i];
- }
-
- BigInteger result = new BigInteger(1, resLength, resDigits);
- return result;
- }
-
- /**
- * @see BigInteger#xor(BigInteger)
- * @param val
- * @param that
- * @return
- */
- static BigInteger xor(BigInteger val, BigInteger that) {
- if (that.sign == 0) {
- return val;
- }
- if (val.sign == 0) {
- return that;
- }
- if (that.equals(BigInteger.MINUS_ONE)) {
- return val.not();
- }
- if (val.equals(BigInteger.MINUS_ONE)) {
- return that.not();
- }
-
- if (val.sign > 0) {
- if (that.sign > 0) {
- if (val.numberLength > that.numberLength) {
- return xorPositive(val, that);
- } else {
- return xorPositive(that, val);
- }
- } else {
- return xorDiffSigns(val, that);
- }
- } else {
- if (that.sign > 0) {
- return xorDiffSigns(that, val);
- } else if (that.getFirstNonzeroDigit() > val.getFirstNonzeroDigit()) {
- return xorNegative(that, val);
- } else {
- return xorNegative(val, that);
- }
- }
- }
-
- /**
- * Return sign = 1, magnitude = -(positive.magnitude ^ -negative.magnitude).
- * @param positive
- * @param negative
- * @return
- */
- static BigInteger xorDiffSigns(BigInteger positive, BigInteger negative) {
- int resLength = Math.max(negative.numberLength, positive.numberLength);
- int resDigits[];
- int iNeg = negative.getFirstNonzeroDigit();
- int iPos = positive.getFirstNonzeroDigit();
- int i;
- int limit;
-
- // The first
- if (iNeg < iPos) {
- resDigits = new int[resLength];
- i = iNeg;
- // resDigits[i] = -(-negative.digits[i]);
- resDigits[i] = negative.digits[i];
- limit = Math.min(negative.numberLength, iPos);
- // Skip the positive digits while they are zeros
- for (i++; i < limit; i++) {
- // resDigits[i] = ~(~negative.digits[i]);
- resDigits[i] = negative.digits[i];
- }
- // if the negative has no more elements, must fill the
- // result with the remaining digits of the positive
- if (i == negative.numberLength) {
- for (; i < positive.numberLength; i++) {
- // resDigits[i] = ~(positive.digits[i] ^ -1) -> ~(~positive.digits[i])
- resDigits[i] = positive.digits[i];
- }
- }
- } else if (iPos < iNeg) {
- resDigits = new int[resLength];
- i = iPos;
- // Applying two complement to the first non-zero digit of the result
- resDigits[i] = -positive.digits[i];
- limit = Math.min(positive.numberLength, iNeg);
- for (i++; i < limit; i++) {
- // Continue applying two complement the result
- resDigits[i] = ~positive.digits[i];
- }
- // When the first non-zero digit of the negative is reached, must apply
- // two complement (arithmetic negation) to it, and then operate
- if (i == iNeg) {
- resDigits[i] = ~(positive.digits[i] ^ -negative.digits[i]);
- i++;
- } else {
- // if the positive has no more elements must fill the remaining digits
- // with
- // the negative ones
- for (; i < iNeg; i++) {
- // resDigits[i] = ~(0 ^ 0)
- resDigits[i] = -1;
- }
- for (; i < negative.numberLength; i++) {
- // resDigits[i] = ~(~negative.digits[i] ^ 0)
- resDigits[i] = negative.digits[i];
- }
- }
- } else {
- int digit;
- // The first non-zero digit of the positive and negative are the same
- i = iNeg;
- digit = positive.digits[i] ^ -negative.digits[i];
- if (digit == 0) {
- limit = Math.min(positive.numberLength, negative.numberLength);
- for (i++; i < limit
- && (digit = positive.digits[i] ^ ~negative.digits[i]) == 0; i++) {
- // empty
- }
- if (digit == 0) {
- // shorter has only the remaining virtual sign bits
- for (; i < positive.numberLength
- && (digit = ~positive.digits[i]) == 0; i++) {
- // empty
- }
- for (; i < negative.numberLength
- && (digit = ~negative.digits[i]) == 0; i++) {
- // empty
- }
- if (digit == 0) {
- resLength = resLength + 1;
- resDigits = new int[resLength];
- resDigits[resLength - 1] = 1;
-
- BigInteger result = new BigInteger(-1, resLength, resDigits);
- return result;
- }
- }
- }
- resDigits = new int[resLength];
- resDigits[i] = -digit;
- i++;
- }
-
- limit = Math.min(negative.numberLength, positive.numberLength);
- for (; i < limit; i++) {
- resDigits[i] = ~(~negative.digits[i] ^ positive.digits[i]);
- }
- for (; i < positive.numberLength; i++) {
- // resDigits[i] = ~(positive.digits[i] ^ -1)
- resDigits[i] = positive.digits[i];
- }
- for (; i < negative.numberLength; i++) {
- // resDigits[i] = ~(0 ^ ~negative.digits[i])
- resDigits[i] = negative.digits[i];
- }
-
- BigInteger result = new BigInteger(-1, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Return sign = 0, magnitude = -val.magnitude ^ -that.magnitude.
- * @param val
- * @param that
- * @return
- */
- static BigInteger xorNegative(BigInteger val, BigInteger that) {
- // PRE: val and that are negative
- // PRE: val has at least as many trailing zero digits as that
- int resLength = Math.max(val.numberLength, that.numberLength);
- int resDigits[] = new int[resLength];
- int iVal = val.getFirstNonzeroDigit();
- int iThat = that.getFirstNonzeroDigit();
- int i = iThat;
- int limit;
-
- if (iVal == iThat) {
- resDigits[i] = -val.digits[i] ^ -that.digits[i];
- } else {
- resDigits[i] = -that.digits[i];
- limit = Math.min(that.numberLength, iVal);
- for (i++; i < limit; i++) {
- resDigits[i] = ~that.digits[i];
- }
- // Remains digits in that?
- if (i == that.numberLength) {
- // Jumping over the remaining zero to the first non one
- for (; i < iVal; i++) {
- // resDigits[i] = 0 ^ -1;
- resDigits[i] = -1;
- }
- // resDigits[i] = -val.digits[i] ^ -1;
- resDigits[i] = val.digits[i] - 1;
- } else {
- resDigits[i] = -val.digits[i] ^ ~that.digits[i];
- }
- }
-
- limit = Math.min(val.numberLength, that.numberLength);
- // Perform ^ between that al val until that ends
- for (i++; i < limit; i++) {
- // resDigits[i] = ~val.digits[i] ^ ~that.digits[i];
- resDigits[i] = val.digits[i] ^ that.digits[i];
- }
- // Perform ^ between val digits and -1 until val ends
- for (; i < val.numberLength; i++) {
- // resDigits[i] = ~val.digits[i] ^ -1 ;
- resDigits[i] = val.digits[i];
- }
- for (; i < that.numberLength; i++) {
- // resDigits[i] = -1 ^ ~that.digits[i] ;
- resDigits[i] = that.digits[i];
- }
-
- BigInteger result = new BigInteger(1, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Return sign = 0, magnitude = longer.magnitude | shorter.magnitude.
- *
- * @param longer
- * @param shorter
- * @return
- */
- static BigInteger xorPositive(BigInteger longer, BigInteger shorter) {
- // PRE: longer and shorter are positive;
- // PRE: longer has at least as many digits as shorter
- int resLength = longer.numberLength;
- int resDigits[] = new int[resLength];
- int i = Math.min(longer.getFirstNonzeroDigit(),
- shorter.getFirstNonzeroDigit());
- for (; i < shorter.numberLength; i++) {
- resDigits[i] = longer.digits[i] ^ shorter.digits[i];
- }
- for (; i < longer.numberLength; i++) {
- resDigits[i] = longer.digits[i];
- }
-
- BigInteger result = new BigInteger(1, resLength, resDigits);
- result.cutOffLeadingZeroes();
- return result;
- }
-
- /**
- * Just to denote that this class can't be instantiated.
- */
- private Logical() {
- }
-}
diff --git a/user/super/com/google/gwt/emul/java/math/MathContext.java b/user/super/com/google/gwt/emul/java/math/MathContext.java
deleted file mode 100644
index ecde7c2..0000000
--- a/user/super/com/google/gwt/emul/java/math/MathContext.java
+++ /dev/null
@@ -1,304 +0,0 @@
-/*
- * 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;
-
-import java.io.Serializable;
-
-/**
- * Immutable objects describing settings such as rounding mode and digit
- * precision for the numerical operations provided by class {@link BigDecimal}.
- */
-public final class MathContext implements Serializable {
-
- /**
- * A {@code MathContext} which corresponds to the IEEE 754r quadruple decimal
- * precision format: 34 digit precision and {@link RoundingMode#HALF_EVEN}
- * rounding.
- */
- public static final MathContext DECIMAL128 = new MathContext(34,
- RoundingMode.HALF_EVEN);
-
- /**
- * A {@code MathContext} which corresponds to the IEEE 754r single decimal
- * precision format: 7 digit precision and {@link RoundingMode#HALF_EVEN}
- * rounding.
- */
- public static final MathContext DECIMAL32 = new MathContext(7,
- RoundingMode.HALF_EVEN);
-
- /**
- * A {@code MathContext} which corresponds to the IEEE 754r double decimal
- * precision format: 16 digit precision and {@link RoundingMode#HALF_EVEN}
- * rounding.
- */
- public static final MathContext DECIMAL64 = new MathContext(16,
- RoundingMode.HALF_EVEN);
-
- /**
- * A {@code MathContext} for unlimited precision with
- * {@link RoundingMode#HALF_UP} rounding.
- */
- public static final MathContext UNLIMITED = new MathContext(0,
- RoundingMode.HALF_UP);
-
- /**
- * An array of {@code char} containing: {@code
- * 'p','r','e','c','i','s','i','o','n','='}. It's used to improve the methods
- * related to {@code String} conversion.
- *
- * @see #MathContext(String)
- * @see #toString()
- */
- private static final char[] chPrecision = {
- 'p', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', '='};
-
- /**
- * An array of {@code char} containing: {@code
- * 'r','o','u','n','d','i','n','g','M','o','d','e','='}. It's used to improve
- * the methods related to {@code String} conversion.
- *
- * @see #MathContext(String)
- * @see #toString()
- */
- private static final char[] chRoundingMode = {
- 'r', 'o', 'u', 'n', 'd', 'i', 'n', 'g', 'M', 'o', 'd', 'e', '='};
-
- /**
- * This is the serialVersionUID used by the sun implementation.
- */
- private static final long serialVersionUID = 5579720004786848255L;
-
- /**
- * The number of digits to be used for an operation; results are rounded to
- * this precision.
- */
- private int precision;
-
- /**
- * A {@code RoundingMode} object which specifies the algorithm to be used for
- * rounding.
- */
- private RoundingMode roundingMode;
-
- /**
- * Constructs a new {@code MathContext} with the specified precision and with
- * the rounding mode {@link RoundingMode#HALF_UP HALF_UP}. If the precision
- * passed is zero, then this implies that the computations have to be
- * performed exact, the rounding mode in this case is irrelevant.
- *
- * @param precision the precision for the new {@code MathContext}.
- * @throws IllegalArgumentException if {@code precision < 0}.
- */
- public MathContext(int precision) {
- this(precision, RoundingMode.HALF_UP);
- }
-
- /**
- * Constructs a new {@code MathContext} with the specified precision and with
- * the specified rounding mode. If the precision passed is zero, then this
- * implies that the computations have to be performed exact, the rounding mode
- * in this case is irrelevant.
- *
- * @param precision the precision for the new {@code MathContext}.
- * @param roundingMode the rounding mode for the new {@code MathContext}.
- * @throws IllegalArgumentException if {@code precision < 0}.
- * @throws NullPointerException if {@code roundingMode} is {@code null}.
- */
- public MathContext(int precision, RoundingMode roundingMode) {
- if (precision < 0) {
- // math.0C=Digits < 0
- throw new IllegalArgumentException("Digits < 0"); //$NON-NLS-1$
- }
- if (roundingMode == null) {
- // math.0D=null RoundingMode
- throw new NullPointerException("null RoundingMode"); //$NON-NLS-1$
- }
- this.precision = precision;
- this.roundingMode = roundingMode;
- }
-
- /**
- * Constructs a new {@code MathContext} from a string. The string has to
- * specify the precision and the rounding mode to be used and has to follow
- * the following syntax:
- * "precision=<precision> roundingMode=<roundingMode>" This is the
- * same form as the one returned by the {@link #toString} method.
- *
- * @param val a string describing the precision and rounding mode for the new
- * {@code MathContext}.
- * @throws IllegalArgumentException if the string is not in the correct format
- * or if the precision specified is < 0.
- */
- public MathContext(String val) {
- char[] charVal = val.toCharArray();
- int i; // Index of charVal
- int j; // Index of chRoundingMode
- int digit; // It will contain the digit parsed
-
- if ((charVal.length < 27) || (charVal.length > 45)) {
- // math.0E=bad string format
- throw new IllegalArgumentException("bad string format"); //$NON-NLS-1$
- }
- // Parsing "precision=" String
- for (i = 0; (i < chPrecision.length) && (charVal[i] == chPrecision[i]); i++) {
- // empty
- }
-
- if (i < chPrecision.length) {
- // math.0E=bad string format
- throw new IllegalArgumentException("bad string format"); //$NON-NLS-1$
- }
- // Parsing the value for "precision="...
- digit = Character.digit(charVal[i], 10);
- if (digit == -1) {
- // math.0E=bad string format
- throw new IllegalArgumentException("bad string format"); //$NON-NLS-1$
- }
- this.precision = this.precision * 10 + digit;
- i++;
-
- do {
- digit = Character.digit(charVal[i], 10);
- if (digit == -1) {
- if (charVal[i] == ' ') {
- // It parsed all the digits
- i++;
- break;
- }
- // It isn't a valid digit, and isn't a white space
- // math.0E=bad string format
- throw new IllegalArgumentException("bad string format"); //$NON-NLS-1$
- }
- // Accumulating the value parsed
- this.precision = this.precision * 10 + digit;
- if (this.precision < 0) {
- // math.0E=bad string format
- throw new IllegalArgumentException("bad string format"); //$NON-NLS-1$
- }
- i++;
- } while (true);
- // Parsing "roundingMode="
- for (j = 0; (j < chRoundingMode.length)
- && (charVal[i] == chRoundingMode[j]); i++, j++) {
- // empty
- }
-
- if (j < chRoundingMode.length) {
- // math.0E=bad string format
- throw new IllegalArgumentException("bad string format"); //$NON-NLS-1$
- }
- // Parsing the value for "roundingMode"...
- this.roundingMode = RoundingMode.valueOf(String.valueOf(charVal, i,
- charVal.length - i));
- }
-
- /* Public Methods */
-
- /**
- * Returns true if x is a {@code MathContext} with the same precision setting
- * and the same rounding mode as this {@code MathContext} instance.
- *
- * @param x object to be compared.
- * @return {@code true} if this {@code MathContext} instance is equal to the
- * {@code x} argument; {@code false} otherwise.
- */
- @Override
- public boolean equals(Object x) {
- return ((x instanceof MathContext)
- && (((MathContext) x).getPrecision() == precision) && (((MathContext) x).getRoundingMode() == roundingMode));
- }
-
- /**
- * Returns the precision. The precision is the number of digits used for an
- * operation. Results are rounded to this precision. The precision is
- * guaranteed to be non negative. If the precision is zero, then the
- * computations have to be performed exact, results are not rounded in this
- * case.
- *
- * @return the precision.
- */
- public int getPrecision() {
- return precision;
- }
-
- /**
- * Returns the rounding mode. The rounding mode is the strategy to be used to
- * round results.
- * <p>
- * The rounding mode is one of {@link RoundingMode#UP},
- * {@link RoundingMode#DOWN}, {@link RoundingMode#CEILING},
- * {@link RoundingMode#FLOOR}, {@link RoundingMode#HALF_UP},
- * {@link RoundingMode#HALF_DOWN}, {@link RoundingMode#HALF_EVEN}, or
- * {@link RoundingMode#UNNECESSARY}.
- *
- * @return the rounding mode.
- */
- public RoundingMode getRoundingMode() {
- return roundingMode;
- }
-
- /**
- * Returns the hash code for this {@code MathContext} instance.
- *
- * @return the hash code for this {@code MathContext}.
- */
- @Override
- public int hashCode() {
- // Make place for the necessary bits to represent 8 rounding modes
- return ((precision << 3) | roundingMode.ordinal());
- }
-
- /**
- * Returns the string representation for this {@code MathContext} instance.
- * The string has the form {@code
- * "precision=<precision> roundingMode=<roundingMode>" * } where
- * {@code <precision>} is an integer describing the number of digits
- * used for operations and {@code <roundingMode>} is the string
- * representation of the rounding mode.
- *
- * @return a string representation for this {@code MathContext} instance
- */
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder(45);
-
- sb.append(chPrecision);
- sb.append(precision);
- sb.append(' ');
- sb.append(chRoundingMode);
- sb.append(roundingMode);
- return sb.toString();
- }
-}
diff --git a/user/super/com/google/gwt/emul/java/math/Multiplication.java b/user/super/com/google/gwt/emul/java/math/Multiplication.java
deleted file mode 100644
index 22fdf49..0000000
--- a/user/super/com/google/gwt/emul/java/math/Multiplication.java
+++ /dev/null
@@ -1,534 +0,0 @@
-/*
- * 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. <b>Karatsuba's
- * algorithm:</b> <tt>
- * u = u<sub>1</sub> * B + u<sub>0</sub><br>
- * v = v<sub>1</sub> * B + v<sub>0</sub><br>
- *
- *
- * u*v = (u<sub>1</sub> * v<sub>1</sub>) * B<sub>2</sub> + ((u<sub>1</sub> - u<sub>0</sub>) * (v<sub>0</sub> - v<sub>1</sub>) + u<sub>1</sub> * v<sub>1</sub> +
- * u<sub>0</sub> * v<sub>0</sub> ) * B + u<sub>0</sub> * v<sub>0</sub><br>
- *</tt>
- *
- * @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 * 5<sup>exp</sup>}
- */
- 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 * 10<sup>exp</sup>}
- */
- 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.
- *
- * <br>
- * <tt>
- * <table border="0">
- * <tbody>
- *
- *
- * <tr>
- * <td align="center">A=</td>
- * <td>a<sub>3</sub></td>
- * <td>a<sub>2</sub></td>
- * <td>a<sub>1</sub></td>
- * <td>a<sub>0</sub></td>
- * <td></td>
- * <td></td>
- * </tr>
- *
- * <tr>
- * <td align="center">B=</td>
- * <td></td>
- * <td>b<sub>2</sub></td>
- * <td>b<sub>1</sub></td>
- * <td>b<sub>1</sub></td>
- * <td></td>
- * <td></td>
- * </tr>
- *
- * <tr>
- * <td></td>
- * <td></td>
- * <td></td>
- * <td>b<sub>0</sub>*a<sub>3</sub></td>
- * <td>b<sub>0</sub>*a<sub>2</sub></td>
- * <td>b<sub>0</sub>*a<sub>1</sub></td>
- * <td>b<sub>0</sub>*a<sub>0</sub></td>
- * </tr>
- *
- * <tr>
- * <td></td>
- * <td></td>
- * <td>b<sub>1</sub>*a<sub>3</sub></td>
- * <td>b<sub>1</sub>*a<sub>2</sub></td>
- * <td>b<sub>1</sub>*a1</td>
- * <td>b<sub>1</sub>*a0</td>
- * </tr>
- *
- * <tr>
- * <td>+</td>
- * <td>b<sub>2</sub>*a<sub>3</sub></td>
- * <td>b<sub>2</sub>*a<sub>2</sub></td>
- * <td>b<sub>2</sub>*a<sub>1</sub></td>
- * <td>b<sub>2</sub>*a<sub>0</sub></td>
- * </tr>
- *
- * <tr>
- * <td></td>
- * <td>______</td>
- * <td>______</td>
- * <td>______</td>
- * <td>______</td>
- * <td>______</td>
- * <td>______</td>
- * </tr>
- *
- * <tr>
- *
- * <td align="center">A*B=R=</td>
- * <td align="center">r<sub>5</sub></td>
- * <td align="center">r<sub>4</sub></td>
- * <td align="center">r<sub>3</sub></td>
- * <td align="center">r<sub>2</sub></td>
- * <td align="center">r<sub>1</sub></td>
- * <td align="center">r<sub>0</sub></td>
- * <td></td>
- * </tr>
- *
- * </tbody>
- * </table>
- *
- *</tt>
- *
- * @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 10<sup>exp</sup>}.
- */
- 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 a<sup>2</sup>.
- *
- * @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() {
- }
-
-}
diff --git a/user/super/com/google/gwt/emul/java/math/Primality.java b/user/super/com/google/gwt/emul/java/math/Primality.java
deleted file mode 100644
index 016d99c..0000000
--- a/user/super/com/google/gwt/emul/java/math/Primality.java
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * 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;
-
-import java.util.Arrays;
-import java.util.Random;
-
-/**
- * Provides primality probabilistic methods.
- */
-class Primality {
-
- /**
- * It encodes how many iterations of Miller-Rabin test are need to get an
- * error bound not greater than {@code 2<sup>(-100)</sup>}. For example: for a
- * {@code 1000}-bit number we need {@code 4} iterations, since {@code BITS[3]
- * < 1000 <= BITS[4]}.
- */
- private static final int[] BITS = {
- 0, 0, 1854, 1233, 927, 747, 627, 543, 480, 431, 393, 361, 335, 314, 295,
- 279, 265, 253, 242, 232, 223, 216, 181, 169, 158, 150, 145, 140, 136,
- 132, 127, 123, 119, 114, 110, 105, 101, 96, 92, 87, 83, 78, 73, 69, 64,
- 59, 54, 49, 44, 38, 32, 26, 1};
-
- /**
- * It encodes how many i-bit primes there are in the table for {@code
- * i=2,...,10}. For example {@code offsetPrimes[6]} says that from index
- * {@code 11} exists {@code 7} consecutive {@code 6}-bit prime numbers in the
- * array.
- */
- private static final int[][] offsetPrimes = {
- null, null, {0, 2}, {2, 2}, {4, 2}, {6, 5}, {11, 7}, {18, 13}, {31, 23},
- {54, 43}, {97, 75}};
-
- /**
- * All prime numbers with bit length lesser than 10 bits.
- */
- private static final int primes[] = {
- 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
- 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149,
- 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227,
- 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307,
- 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389,
- 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467,
- 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571,
- 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653,
- 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751,
- 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853,
- 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947,
- 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021};
-
- /**
- * All {@code BigInteger} prime numbers with bit length lesser than 8 bits.
- */
- private static final BigInteger BIprimes[] = new BigInteger[primes.length];
-
- static {
- // To initialize the dual table of BigInteger primes
- for (int i = 0; i < primes.length; i++) {
- BIprimes[i] = BigInteger.valueOf(primes[i]);
- }
- }
-
- /**
- * A random number is generated until a probable prime number is found.
- *
- * @see BigInteger#BigInteger(int,int,Random)
- * @see BigInteger#probablePrime(int,Random)
- * @see #isProbablePrime(BigInteger, int)
- */
- static BigInteger consBigInteger(int bitLength, int certainty, Random rnd) {
- // PRE: bitLength >= 2;
- // For small numbers get a random prime from the prime table
- if (bitLength <= 10) {
- int rp[] = offsetPrimes[bitLength];
- return BIprimes[rp[0] + rnd.nextInt(rp[1])];
- }
- int shiftCount = (-bitLength) & 31;
- int last = (bitLength + 31) >> 5;
- BigInteger n = new BigInteger(1, last, new int[last]);
-
- last--;
- do {
- // To fill the array with random integers
- for (int i = 0; i < n.numberLength; i++) {
- n.digits[i] = rnd.nextInt();
- }
- // To fix to the correct bitLength
- n.digits[last] |= 0x80000000;
- n.digits[last] >>>= shiftCount;
- // To create an odd number
- n.digits[0] |= 1;
- } while (!isProbablePrime(n, certainty));
- return n;
- }
-
- /**
- * @see BigInteger#isProbablePrime(int)
- * @see #millerRabin(BigInteger, int)
- * @ar.org.fitc.ref Optimizations: "A. Menezes - Handbook of applied
- * Cryptography, Chapter 4".
- */
- static boolean isProbablePrime(BigInteger n, int certainty) {
- // PRE: n >= 0;
- if ((certainty <= 0) || ((n.numberLength == 1) && (n.digits[0] == 2))) {
- return true;
- }
- // To discard all even numbers
- if (!n.testBit(0)) {
- return false;
- }
- // To check if 'n' exists in the table (it fit in 10 bits)
- if ((n.numberLength == 1) && ((n.digits[0] & 0XFFFFFC00) == 0)) {
- return (Arrays.binarySearch(primes, n.digits[0]) >= 0);
- }
- // To check if 'n' is divisible by some prime of the table
- for (int i = 1; i < primes.length; i++) {
- if (Division.remainderArrayByInt(n.digits, n.numberLength, primes[i]) == 0) {
- return false;
- }
- }
- // To set the number of iterations necessary for Miller-Rabin test
- int i;
- int bitLength = n.bitLength();
-
- for (i = 2; bitLength < BITS[i]; i++) {
- // empty
- }
- certainty = Math.min(i, 1 + ((certainty - 1) >> 1));
-
- return millerRabin(n, certainty);
- }
-
- /**
- * It uses the sieve of Eratosthenes to discard several composite numbers in
- * some appropriate range (at the moment {@code [this, this + 1024]}). After
- * this process it applies the Miller-Rabin test to the numbers that were not
- * discarded in the sieve.
- *
- * @see BigInteger#nextProbablePrime()
- * @see #millerRabin(BigInteger, int)
- */
- static BigInteger nextProbablePrime(BigInteger n) {
- // PRE: n >= 0
- int i, j;
- int certainty;
- int gapSize = 1024; // for searching of the next probable prime number
- int modules[] = new int[primes.length];
- boolean isDivisible[] = new boolean[gapSize];
- BigInteger startPoint;
- BigInteger probPrime;
- // If n < "last prime of table" searches next prime in the table
- if ((n.numberLength == 1) && (n.digits[0] >= 0)
- && (n.digits[0] < primes[primes.length - 1])) {
- for (i = 0; n.digits[0] >= primes[i]; i++) {
- // empty
- }
- return BIprimes[i];
- }
- /*
- * Creates a "N" enough big to hold the next probable prime Note that: N <
- * "next prime" < 2*N
- */
- startPoint = new BigInteger(1, n.numberLength, new int[n.numberLength + 1]);
- System.arraycopy(n.digits, 0, startPoint.digits, 0, n.numberLength);
- // To fix N to the "next odd number"
- if (n.testBit(0)) {
- Elementary.inplaceAdd(startPoint, 2);
- } else {
- startPoint.digits[0] |= 1;
- }
- // To set the improved certainly of Miller-Rabin
- j = startPoint.bitLength();
- for (certainty = 2; j < BITS[certainty]; certainty++) {
- // empty
- }
- // To calculate modules: N mod p1, N mod p2, ... for first primes.
- for (i = 0; i < primes.length; i++) {
- modules[i] = Division.remainder(startPoint, primes[i]) - gapSize;
- }
- while (true) {
- // At this point, all numbers in the gap are initialized as
- // probably primes
- Arrays.fill(isDivisible, false);
- // To discard multiples of first primes
- for (i = 0; i < primes.length; i++) {
- modules[i] = (modules[i] + gapSize) % primes[i];
- j = (modules[i] == 0) ? 0 : (primes[i] - modules[i]);
- for (; j < gapSize; j += primes[i]) {
- isDivisible[j] = true;
- }
- }
- // To execute Miller-Rabin for non-divisible numbers by all first
- // primes
- for (j = 0; j < gapSize; j++) {
- if (!isDivisible[j]) {
- probPrime = startPoint.copy();
- Elementary.inplaceAdd(probPrime, j);
-
- if (millerRabin(probPrime, certainty)) {
- return probPrime;
- }
- }
- }
- Elementary.inplaceAdd(startPoint, gapSize);
- }
- }
-
- /**
- * The Miller-Rabin primality test.
- *
- * @param n the input number to be tested.
- * @param t the number of trials.
- * @return {@code false} if the number is definitely compose, otherwise
- * {@code true} with probability {@code 1 - 4<sup>(-t)</sup>}.
- * @ar.org.fitc.ref "D. Knuth, The Art of Computer Programming Vo.2, Section
- * 4.5.4., Algorithm P"
- */
- private static boolean millerRabin(BigInteger n, int t) {
- // PRE: n >= 0, t >= 0
- BigInteger x; // x := UNIFORM{2...n-1}
- BigInteger y; // y := x^(q * 2^j) mod n
- BigInteger nMinus1 = n.subtract(BigInteger.ONE); // n-1
- int bitLength = nMinus1.bitLength(); // ~ log2(n-1)
- // (q,k) such that: n-1 = q * 2^k and q is odd
- int k = nMinus1.getLowestSetBit();
- BigInteger q = nMinus1.shiftRight(k);
- Random rnd = new Random();
-
- for (int i = 0; i < t; i++) {
- // To generate a witness 'x', first it use the primes of table
- if (i < primes.length) {
- x = BIprimes[i];
- } else {
- /*
- * It generates random witness only if it's necesssary. Note that all
- * methods would call Miller-Rabin with t <= 50 so this part is only to
- * do more robust the algorithm
- */
- do {
- x = new BigInteger(bitLength, rnd);
- } while ((x.compareTo(n) >= BigInteger.EQUALS) || (x.sign == 0)
- || x.isOne());
- }
- y = x.modPow(q, n);
- if (y.isOne() || y.equals(nMinus1)) {
- continue;
- }
- for (int j = 1; j < k; j++) {
- if (y.equals(nMinus1)) {
- continue;
- }
- y = y.multiply(y).mod(n);
- if (y.isOne()) {
- return false;
- }
- }
- if (!y.equals(nMinus1)) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Just to denote that this class can't be instantiated.
- */
- private Primality() {
- }
-
-}
diff --git a/user/super/com/google/gwt/emul/java/math/RoundingMode.java b/user/super/com/google/gwt/emul/java/math/RoundingMode.java
deleted file mode 100644
index f432d05..0000000
--- a/user/super/com/google/gwt/emul/java/math/RoundingMode.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * 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;
-
-/**
- * Specifies the rounding behavior for operations whose results cannot be
- * represented exactly.
- */
-public enum RoundingMode {
-
- /**
- * Rounding mode to round towards positive infinity. For positive values this
- * rounding mode behaves as {@link #UP}, for negative values as {@link #DOWN}. <br>
- * Rule: {@code x.round() >= x}
- */
- CEILING(BigDecimal.ROUND_CEILING),
-
- /**
- * Rounding mode where the values are rounded towards zero. <br>
- * Rule: {@code x.round().abs() <= x.abs()}
- */
- DOWN(BigDecimal.ROUND_DOWN),
-
- /**
- * Rounding mode to round towards negative infinity. For positive values this
- * rounding mode behaves as {@link #DOWN}, for negative values as {@link #UP}. <br>
- * Rule: {@code x.round() <= x}
- */
- FLOOR(BigDecimal.ROUND_FLOOR),
-
- /**
- * Rounding mode where values are rounded towards the nearest neighbor. Ties
- * are broken by rounding down.
- */
- HALF_DOWN(BigDecimal.ROUND_HALF_DOWN),
-
- /**
- * Rounding mode where values are rounded towards the nearest neighbor. Ties
- * are broken by rounding to the even neighbor.
- */
- HALF_EVEN(BigDecimal.ROUND_HALF_EVEN),
-
- /**
- * Rounding mode where values are rounded towards the nearest neighbor. Ties
- * are broken by rounding up.
- */
- HALF_UP(BigDecimal.ROUND_HALF_UP),
-
- /**
- * Rounding mode where the rounding operations throws an ArithmeticException
- * for the case that rounding is necessary, i.e. for the case that the value
- * cannot be represented exactly.
- */
- UNNECESSARY(BigDecimal.ROUND_UNNECESSARY),
-
- /**
- * Rounding mode where positive values are rounded towards positive infinity
- * and negative values towards negative infinity. <br>
- * Rule: {@code x.round().abs() >= x.abs()}
- */
- UP(BigDecimal.ROUND_UP);
-
- /**
- * Converts rounding mode constants from class {@code BigDecimal} into {@code
- * RoundingMode} values.
- *
- * @param mode rounding mode constant as defined in class {@code BigDecimal}
- * @return corresponding rounding mode object
- */
- public static RoundingMode valueOf(int mode) {
- switch (mode) {
- case BigDecimal.ROUND_CEILING:
- return CEILING;
- case BigDecimal.ROUND_DOWN:
- return DOWN;
- case BigDecimal.ROUND_FLOOR:
- return FLOOR;
- case BigDecimal.ROUND_HALF_DOWN:
- return HALF_DOWN;
- case BigDecimal.ROUND_HALF_EVEN:
- return HALF_EVEN;
- case BigDecimal.ROUND_HALF_UP:
- return HALF_UP;
- case BigDecimal.ROUND_UNNECESSARY:
- return UNNECESSARY;
- case BigDecimal.ROUND_UP:
- return UP;
- default:
- // math.00=Invalid rounding mode
- throw new IllegalArgumentException("Invalid rounding mode"); //$NON-NLS-1$
- }
- }
-
- /**
- * Set the old constant.
- * @param rm unused
- */
- RoundingMode(int rm) {
- // Note that we do not need the old-style rounding mode, so we ignore it.
- }
-}
diff --git a/user/super/com/google/gwt/emul/java/util/Random.java b/user/super/com/google/gwt/emul/java/util/Random.java
deleted file mode 100644
index f0330e4..0000000
--- a/user/super/com/google/gwt/emul/java/util/Random.java
+++ /dev/null
@@ -1,266 +0,0 @@
-/*
- * 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.util;
-
-import java.io.Serializable;
-
-/**
- * This class provides methods that generates pseudo-random numbers of different
- * types, such as {@code int}, {@code long}, {@code double}, and {@code float}.
- */
-public class Random implements Serializable {
-
- private static final long serialVersionUID = 3905348978240129619L;
-
- private static final long multiplier = 0x5deece66dL;
-
- /**
- * A value used to avoid two random number generators produced at the same
- * time having the same seed.
- */
- private static int uniqueSeed = 0;
-
- /**
- * The boolean value indicating if the second Gaussian number is available.
- *
- * @serial
- */
- private boolean haveNextNextGaussian;
-
- /**
- * @serial It is associated with the internal state of this generator.
- */
- private long seed;
-
- /**
- * The second Gaussian generated number.
- *
- * @serial
- */
- private double nextNextGaussian;
-
- /**
- * Construct a random generator with the current time of day in milliseconds
- * as the initial state.
- *
- * @see #setSeed
- */
- public Random() {
- setSeed(uniqueSeed++ + System.currentTimeMillis());
- }
-
- /**
- * Construct a random generator with the given {@code seed} as the initial
- * state.
- *
- * @param seed the seed that will determine the initial state of this random
- * number generator.
- * @see #setSeed
- */
- public Random(long seed) {
- setSeed(seed);
- }
-
- /**
- * Returns the next pseudo-random, uniformly distributed {@code boolean} value
- * generated by this generator.
- *
- * @return a pseudo-random, uniformly distributed boolean value.
- */
- public boolean nextBoolean() {
- return next(1) != 0;
- }
-
- /**
- * Modifies the {@code byte} array by a random sequence of {@code byte}s
- * generated by this random number generator.
- *
- * @param buf non-null array to contain the new random {@code byte}s.
- * @see #next
- */
- public void nextBytes(byte[] buf) {
- int rand = 0, count = 0, loop = 0;
- while (count < buf.length) {
- if (loop == 0) {
- rand = nextInt();
- loop = 3;
- } else {
- loop--;
- }
- buf[count++] = (byte) rand;
- rand >>= 8;
- }
- }
-
- /**
- * Generates a normally distributed random {@code double} number between 0.0
- * inclusively and 1.0 exclusively.
- *
- * @return a random {@code double} in the range [0.0 - 1.0)
- * @see #nextFloat
- */
- public double nextDouble() {
- return ((((long) next(26) << 27) + next(27)) / (double) (1L << 53));
- }
-
- /**
- * Generates a normally distributed random {@code float} number between 0.0
- * inclusively and 1.0 exclusively.
- *
- * @return float a random {@code float} number between [0.0 and 1.0)
- * @see #nextDouble
- */
- public float nextFloat() {
- return (next(24) / 16777216f);
- }
-
- /**
- * Pseudo-randomly generates (approximately) a normally distributed {@code
- * double} value with mean 0.0 and a standard deviation value of {@code 1.0}
- * using the <i>polar method<i> of G. E. P. Box, M. E. Muller, and G.
- * Marsaglia, as described by Donald E. Knuth in <i>The Art of Computer
- * Programming, Volume 2: Seminumerical Algorithms</i>, section 3.4.1,
- * subsection C, algorithm P.
- *
- * @return a random {@code double}
- * @see #nextDouble
- */
- public double nextGaussian() {
- if (haveNextNextGaussian) {
- // if X1 has been returned, return the second Gaussian
- haveNextNextGaussian = false;
- return nextNextGaussian;
- }
-
- double v1, v2, s;
- do {
- // Generates two independent random variables U1, U2
- v1 = 2 * nextDouble() - 1;
- v2 = 2 * nextDouble() - 1;
- s = v1 * v1 + v2 * v2;
- } while (s >= 1);
- double norm = Math.sqrt(-2 * Math.log(s) / s);
- nextNextGaussian = v2 * norm;
- haveNextNextGaussian = true;
- return v1 * norm;
- }
-
- /**
- * Generates a uniformly distributed 32-bit {@code int} value from the random
- * number sequence.
- *
- * @return a uniformly distributed {@code int} value.
- * @see java.lang.Integer#MAX_VALUE
- * @see java.lang.Integer#MIN_VALUE
- * @see #next
- * @see #nextLong
- */
- public int nextInt() {
- return next(32);
- }
-
- /**
- * Returns a new pseudo-random {@code int} value which is uniformly
- * distributed between 0 (inclusively) and the value of {@code n}
- * (exclusively).
- *
- * @param n the exclusive upper border of the range [0 - n).
- * @return a random {@code int}.
- */
- public int nextInt(int n) {
- if (n > 0) {
- if ((n & -n) == n) {
- return (int) ((n * (long) next(31)) >> 31);
- }
- int bits, val;
- do {
- bits = next(31);
- val = bits % n;
- } while (bits - val + (n - 1) < 0);
- return val;
- }
- throw new IllegalArgumentException();
- }
-
- /**
- * Generates a uniformly distributed 64-bit integer value from the random
- * number sequence.
- *
- * @return 64-bit random integer.
- * @see java.lang.Integer#MAX_VALUE
- * @see java.lang.Integer#MIN_VALUE
- * @see #next
- * @see #nextInt()
- * @see #nextInt(int)
- */
- public long nextLong() {
- return ((long) next(32) << 32) + next(32);
- }
-
- /**
- * Modifies the seed a using linear congruential formula presented in <i>The
- * Art of Computer Programming, Volume 2</i>, Section 3.2.1.
- *
- * @param seed the seed that alters the state of the random number generator.
- * @see #next
- * @see #Random()
- * @see #Random(long)
- */
- public void setSeed(long seed) {
- this.seed = (seed ^ multiplier) & ((1L << 48) - 1);
- haveNextNextGaussian = false;
- }
-
- /**
- * Returns a pseudo-random uniformly distributed {@code int} value of the
- * number of bits specified by the argument {@code bits} as described by
- * Donald E. Knuth in <i>The Art of Computer Programming, Volume 2:
- * Seminumerical Algorithms</i>, section 3.2.1.
- *
- * @param bits number of bits of the returned value.
- * @return a pseudo-random generated int number.
- * @see #nextBytes
- * @see #nextDouble
- * @see #nextFloat
- * @see #nextInt()
- * @see #nextInt(int)
- * @see #nextGaussian
- * @see #nextLong
- */
- protected int next(int bits) {
- seed = (seed * multiplier + 0xbL) & ((1L << 48) - 1);
- return (int) (seed >>> (48 - bits));
- }
-}
diff --git a/user/test/com/google/gwt/emultest/EmulSuite.java b/user/test/com/google/gwt/emultest/EmulSuite.java
index dae2713..34266e4 100644
--- a/user/test/com/google/gwt/emultest/EmulSuite.java
+++ b/user/test/com/google/gwt/emultest/EmulSuite.java
@@ -29,26 +29,6 @@
import com.google.gwt.emultest.java.lang.StringBufferTest;
import com.google.gwt.emultest.java.lang.StringTest;
import com.google.gwt.emultest.java.lang.SystemTest;
-import com.google.gwt.emultest.java.math.BigDecimalArithmeticTest;
-import com.google.gwt.emultest.java.math.BigDecimalCompareTest;
-import com.google.gwt.emultest.java.math.BigDecimalConstructorsTest;
-import com.google.gwt.emultest.java.math.BigDecimalConvertTest;
-import com.google.gwt.emultest.java.math.BigDecimalScaleOperationsTest;
-import com.google.gwt.emultest.java.math.BigIntegerAddTest;
-import com.google.gwt.emultest.java.math.BigIntegerAndTest;
-import com.google.gwt.emultest.java.math.BigIntegerCompareTest;
-import com.google.gwt.emultest.java.math.BigIntegerConstructorsTest;
-import com.google.gwt.emultest.java.math.BigIntegerConvertTest;
-import com.google.gwt.emultest.java.math.BigIntegerDivideTest;
-import com.google.gwt.emultest.java.math.BigIntegerHashCodeTest;
-import com.google.gwt.emultest.java.math.BigIntegerModPowTest;
-import com.google.gwt.emultest.java.math.BigIntegerMultiplyTest;
-import com.google.gwt.emultest.java.math.BigIntegerNotTest;
-import com.google.gwt.emultest.java.math.BigIntegerOperateBitsTest;
-import com.google.gwt.emultest.java.math.BigIntegerOrTest;
-import com.google.gwt.emultest.java.math.BigIntegerSubtractTest;
-import com.google.gwt.emultest.java.math.BigIntegerToStringTest;
-import com.google.gwt.emultest.java.math.BigIntegerXorTest;
import com.google.gwt.emultest.java.sql.SqlDateTest;
import com.google.gwt.emultest.java.sql.SqlTimeTest;
import com.google.gwt.emultest.java.sql.SqlTimestampTest;
@@ -66,22 +46,21 @@
import com.google.gwt.emultest.java.util.LinkedHashMapTest;
import com.google.gwt.emultest.java.util.LinkedListTest;
import com.google.gwt.emultest.java.util.PriorityQueueTest;
-import com.google.gwt.emultest.java.util.RandomTest;
import com.google.gwt.emultest.java.util.StackTest;
import com.google.gwt.junit.tools.GWTTestSuite;
import junit.framework.Test;
/**
- * Tests for JRE emulation classes.
+ * TODO: document me.
*/
public class EmulSuite {
+ /** Note: due to compiler error, only can use one Test Case at a time. */
public static Test suite() {
GWTTestSuite suite = new GWTTestSuite("Tests for com.google.gwt.emul.java");
// $JUnit-BEGIN$
- // java.lang
suite.addTestSuite(BooleanTest.class);
suite.addTestSuite(ByteTest.class);
suite.addTestSuite(CharacterTest.class);
@@ -97,29 +76,6 @@
suite.addTestSuite(StringTest.class);
suite.addTestSuite(SystemTest.class);
- // java.math
- suite.addTestSuite(BigDecimalArithmeticTest.class);
- suite.addTestSuite(BigDecimalCompareTest.class);
- suite.addTestSuite(BigDecimalConstructorsTest.class);
- suite.addTestSuite(BigDecimalConvertTest.class);
- suite.addTestSuite(BigDecimalScaleOperationsTest.class);
- suite.addTestSuite(BigIntegerAddTest.class);
- suite.addTestSuite(BigIntegerAndTest.class);
- suite.addTestSuite(BigIntegerCompareTest.class);
- suite.addTestSuite(BigIntegerConstructorsTest.class);
- suite.addTestSuite(BigIntegerConvertTest.class);
- suite.addTestSuite(BigIntegerDivideTest.class);
- suite.addTestSuite(BigIntegerHashCodeTest.class);
- suite.addTestSuite(BigIntegerModPowTest.class);
- suite.addTestSuite(BigIntegerMultiplyTest.class);
- suite.addTestSuite(BigIntegerNotTest.class);
- suite.addTestSuite(BigIntegerOperateBitsTest.class);
- suite.addTestSuite(BigIntegerOrTest.class);
- suite.addTestSuite(BigIntegerSubtractTest.class);
- suite.addTestSuite(BigIntegerToStringTest.class);
- suite.addTestSuite(BigIntegerXorTest.class);
-
- // java.util
suite.addTestSuite(ApacheMapTest.class);
suite.addTestSuite(ArrayListTest.class);
suite.addTestSuite(ArraysTest.class);
@@ -134,7 +90,6 @@
suite.addTestSuite(LinkedHashMapTest.class);
suite.addTestSuite(LinkedListTest.class);
suite.addTestSuite(PriorityQueueTest.class);
- suite.addTestSuite(RandomTest.class);
suite.addTestSuite(StackTest.class);
suite.addTestSuite(SqlDateTest.class);
suite.addTestSuite(SqlTimeTest.class);
@@ -145,4 +100,5 @@
return suite;
}
+
}
diff --git a/user/test/com/google/gwt/emultest/java/lang/FloatTest.java b/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
index 3254e20..c8cea58 100644
--- a/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
@@ -24,7 +24,6 @@
*/
public class FloatTest extends GWTTestCase {
- @Override
public String getModuleName() {
return "com.google.gwt.emultest.EmulSuite";
}
@@ -78,13 +77,9 @@
assertEquals(-1.5f, Float.parseFloat("-1.5"), 0.0);
assertEquals(3.0f, Float.parseFloat("3."), 0.0);
assertEquals(0.5f, Float.parseFloat(".5"), 0.0);
- // TODO(jat): it isn't safe to parse MAX/MIN_VALUE because we also want to
- // be able to get POSITIVE/NEGATIVE_INFINITY for out-of-range values, and
- // since all math in JS is done in double we can't rely on getting the
- // exact value back.
-// assertEquals("Can't parse MAX_VALUE", Float.MAX_VALUE,
-// Float.parseFloat(String.valueOf(Float.MAX_VALUE)), 1e31);
-// assertEquals("Can't parse MIN_VALUE", Float.MIN_VALUE,
-// Float.parseFloat(String.valueOf(Float.MIN_VALUE)), Float.MIN_VALUE);
+ assertEquals("Can't parse MAX_VALUE", Float.MAX_VALUE,
+ Float.parseFloat(String.valueOf(Float.MAX_VALUE)), 1e31);
+ assertEquals("Can't parse MIN_VALUE", Float.MIN_VALUE,
+ Float.parseFloat(String.valueOf(Float.MIN_VALUE)), Float.MIN_VALUE);
}
}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigDecimalArithmeticTest.java b/user/test/com/google/gwt/emultest/java/math/BigDecimalArithmeticTest.java
deleted file mode 100644
index 99ae798..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigDecimalArithmeticTest.java
+++ /dev/null
@@ -1,1741 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.math.MathContext;
-import java.math.RoundingMode;
-
-/**
- * Class: java.math.BigDecimal Methods: add, subtract, multiply, divide
- */
-public class BigDecimalArithmeticTest extends EmulTestBase {
- /**
- * Add two numbers of different scales; the first is negative
- */
- public void testAddDiffScaleNegPos() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -15;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- String c = "1231212478987482988429808779810457634781459480137916301878791834798.7234564568";
- int cScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.add(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Add two numbers of different scales; the first is positive
- */
- public void testAddDiffScalePosNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 15;
- String b = "747233429293018787918347987234564568";
- int bScale = -10;
- String c = "7472334294161400358170962860775454459810457634.781384756794987";
- int cScale = 15;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.add(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Add two numbers of different scales; the first is positive
- */
- public void testAddDiffScalePosPos() {
- String a = "100";
- int aScale = 15;
- String b = "200";
- int bScale = 14;
- String c = "2.100E-12";
- int cScale = 15;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.add(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Add two zeroes of different scales; the first is negative
- */
- public void testAddDiffScaleZeroZero() {
- String a = "0";
- int aScale = -15;
- String b = "0";
- int bScale = 10;
- String c = "0E-10";
- int cScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.add(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Add two numbers of equal negative scales
- */
- public void testAddEqualScaleNegNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -10;
- String b = "747233429293018787918347987234564568";
- int bScale = -10;
- String c = "1.231212478987483735663238072829245553129371991359555E+61";
- int cScale = -10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.add(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Add two numbers of equal positive scales
- */
- public void testAddEqualScalePosPos() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 10;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- String c = "123121247898748373566323807282924555312937.1991359555";
- int cScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.add(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Add two numbers of different scales using MathContext; the first is
- * positive
- */
- public void testAddMathContextDiffScalePosNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 15;
- String b = "747233429293018787918347987234564568";
- int bScale = -10;
- String c = "7.47233429416141E+45";
- int cScale = -31;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- MathContext mc = new MathContext(15, RoundingMode.CEILING);
- BigDecimal result = aNumber.add(bNumber, mc);
- assertEquals("incorrect value", c, c.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Add two numbers of equal negative scales using MathContext
- */
- public void testAddMathContextEqualScaleNegNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -10;
- String b = "747233429293018787918347987234564568";
- int bScale = -10;
- String c = "1.2312E+61";
- int cScale = -57;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- MathContext mc = new MathContext(5, RoundingMode.FLOOR);
- BigDecimal result = aNumber.add(bNumber, mc);
- assertEquals("incorrect value ", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Add two numbers of equal positive scales using MathContext
- */
- public void testAddMathContextEqualScalePosPos() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 10;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- String c = "1.2313E+41";
- int cScale = -37;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- MathContext mc = new MathContext(5, RoundingMode.UP);
- BigDecimal result = aNumber.add(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- public void testAddZero() {
- BigDecimal val = new BigDecimal("123456789");
- BigDecimal sum = val.add(BigDecimal.ZERO);
- assertEquals(val, sum);
- sum = BigDecimal.ZERO.add(val);
- assertEquals(val, sum);
- val = BigDecimal.valueOf(0L, 1);
- sum = val.add(BigDecimal.ZERO);
- assertEquals(val, sum);
- }
-
-
- /**
- * Test the the approximate scale is computed correctly.
- * <p>
- * See https://issues.apache.org/jira/browse/HARMONY-6406
- */
- public void testApproxScale() {
- BigDecimal decVal = BigDecimal.TEN.multiply(new BigDecimal("0.1"));
- int compare = decVal.compareTo(new BigDecimal("1.00"));
- assertEquals(0, compare);
- }
-
- /**
- * divideAndRemainder(BigDecimal).
- */
- public void testDivideAndRemainder1() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 70;
- String res = "277923185514690367474770683";
- int resScale = 0;
- String rem = "1.3032693871288309587558885943391070087960319452465789990E-15";
- int remScale = 70;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result[] = aNumber.divideAndRemainder(bNumber);
- assertEquals("incorrect quotient value", res, result[0].toString());
- assertEquals("incorrect quotient scale", resScale, result[0].scale());
- assertEquals("incorrect remainder value", rem, result[1].toString());
- assertEquals("incorrect remainder scale", remScale, result[1].scale());
- }
-
- /**
- * divideAndRemainder(BigDecimal).
- */
- public void testDivideAndRemainder2() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = -45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 70;
- String res = "2779231855146903674747706830969461168692256919247547952"
- + "2608549363170374005512836303475980101168105698072946555" + "6862849";
- int resScale = 0;
- String rem = "3.4935796954060524114470681810486417234751682675102093970E-15";
- int remScale = 70;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result[] = aNumber.divideAndRemainder(bNumber);
- assertEquals("incorrect quotient value", res, result[0].toString());
- assertEquals("incorrect quotient scale", resScale, result[0].scale());
- assertEquals("incorrect remainder value", rem, result[1].toString());
- assertEquals("incorrect remainder scale", remScale, result[1].scale());
- }
-
- /**
- * divideAndRemainder(BigDecimal, MathContext).
- */
- public void testDivideAndRemainderMathContextDOWN() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 20;
- int precision = 15;
- RoundingMode rm = RoundingMode.DOWN;
- MathContext mc = new MathContext(precision, rm);
- String res = "0E-25";
- int resScale = 25;
- String rem = "3736186567876.876578956958765675671119238118911893939591735";
- int remScale = 45;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result[] = aNumber.divideAndRemainder(bNumber, mc);
- assertEquals("incorrect quotient value", res, result[0].toString());
- assertEquals("incorrect quotient scale", resScale, result[0].scale());
- assertEquals("incorrect remainder value", rem, result[1].toString());
- assertEquals("incorrect remainder scale", remScale, result[1].scale());
- }
-
- /**
- * divideAndRemainder(BigDecimal, MathContext).
- */
- public void testDivideAndRemainderMathContextUP() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 70;
- int precision = 75;
- RoundingMode rm = RoundingMode.UP;
- MathContext mc = new MathContext(precision, rm);
- String res = "277923185514690367474770683";
- int resScale = 0;
- String rem = "1.3032693871288309587558885943391070087960319452465789990E-15";
- int remScale = 70;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result[] = aNumber.divideAndRemainder(bNumber, mc);
- assertEquals("incorrect quotient value", res, result[0].toString());
- assertEquals("incorrect quotient scale", resScale, result[0].scale());
- assertEquals("incorrect remainder value", rem, result[1].toString());
- assertEquals("incorrect remainder scale", remScale, result[1].scale());
- }
-
- /**
- * Divide to BigDecimal.
- */
- public void testDivideBigDecimal1() {
- String a = "-37361671119238118911893939591735";
- int aScale = 10;
- String b = "74723342238476237823787879183470";
- int bScale = 15;
- String c = "-5E+4";
- int resScale = -4;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide to BigDecimal.
- */
- public void testDivideBigDecimal2() {
- String a = "-37361671119238118911893939591735";
- int aScale = 10;
- String b = "74723342238476237823787879183470";
- int bScale = -15;
- String c = "-5E-26";
- int resScale = 26;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, MathContext).
- */
- public void testDivideBigDecimalScaleMathContextCEILING() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 15;
- String b = "748766876876723342238476237823787879183470";
- int bScale = 70;
- int precision = 21;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- String c = "4.98978611802562512996E+70";
- int resScale = -50;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, MathContext).
- */
- public void testDivideBigDecimalScaleMathContextDOWN() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 15;
- String b = "748766876876723342238476237823787879183470";
- int bScale = 70;
- int precision = 21;
- RoundingMode rm = RoundingMode.DOWN;
- MathContext mc = new MathContext(precision, rm);
- String c = "4.98978611802562512995E+70";
- int resScale = -50;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, MathContext).
- */
- public void testDivideBigDecimalScaleMathContextFLOOR() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 15;
- String b = "748766876876723342238476237823787879183470";
- int bScale = 70;
- int precision = 21;
- RoundingMode rm = RoundingMode.FLOOR;
- MathContext mc = new MathContext(precision, rm);
- String c = "4.98978611802562512995E+70";
- int resScale = -50;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, MathContext).
- */
- public void testDivideBigDecimalScaleMathContextHALF_DOWN() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 70;
- int precision = 21;
- RoundingMode rm = RoundingMode.HALF_DOWN;
- MathContext mc = new MathContext(precision, rm);
- String c = "2.77923185514690367475E+26";
- int resScale = -6;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, MathContext).
- */
- public void testDivideBigDecimalScaleMathContextHALF_EVEN() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 70;
- int precision = 21;
- RoundingMode rm = RoundingMode.HALF_EVEN;
- MathContext mc = new MathContext(precision, rm);
- String c = "2.77923185514690367475E+26";
- int resScale = -6;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, MathContext).
- */
- public void testDivideBigDecimalScaleMathContextHALF_UP() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 70;
- int precision = 21;
- RoundingMode rm = RoundingMode.HALF_UP;
- MathContext mc = new MathContext(precision, rm);
- String c = "2.77923185514690367475E+26";
- int resScale = -6;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, MathContext).
- */
- public void testDivideBigDecimalScaleMathContextUP() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 15;
- String b = "748766876876723342238476237823787879183470";
- int bScale = 10;
- int precision = 21;
- RoundingMode rm = RoundingMode.UP;
- MathContext mc = new MathContext(precision, rm);
- String c = "49897861180.2562512996";
- int resScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, scale, RoundingMode).
- */
- public void testDivideBigDecimalScaleRoundingModeCEILING() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 100;
- String b = "74723342238476237823787879183470";
- int bScale = 15;
- int newScale = 45;
- RoundingMode rm = RoundingMode.CEILING;
- String c = "1E-45";
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, newScale, rm);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", newScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, scale, RoundingMode).
- */
- public void testDivideBigDecimalScaleRoundingModeDOWN() {
- String a = "-37361671119238118911893939591735";
- int aScale = 10;
- String b = "74723342238476237823787879183470";
- int bScale = 15;
- int newScale = 31;
- RoundingMode rm = RoundingMode.DOWN;
- String c = "-50000.0000000000000000000000000000000";
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, newScale, rm);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", newScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, scale, RoundingMode).
- */
- public void testDivideBigDecimalScaleRoundingModeFLOOR() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 100;
- String b = "74723342238476237823787879183470";
- int bScale = 15;
- int newScale = 45;
- RoundingMode rm = RoundingMode.FLOOR;
- String c = "0E-45";
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, newScale, rm);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", newScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, scale, RoundingMode).
- */
- public void testDivideBigDecimalScaleRoundingModeHALF_DOWN() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 5;
- String b = "74723342238476237823787879183470";
- int bScale = 15;
- int newScale = 7;
- RoundingMode rm = RoundingMode.HALF_DOWN;
- String c = "500002603731642864013619132621009722.1803810";
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, newScale, rm);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", newScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, scale, RoundingMode).
- */
- public void testDivideBigDecimalScaleRoundingModeHALF_EVEN() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 5;
- String b = "74723342238476237823787879183470";
- int bScale = 15;
- int newScale = 7;
- RoundingMode rm = RoundingMode.HALF_EVEN;
- String c = "500002603731642864013619132621009722.1803810";
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, newScale, rm);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", newScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, scale, RoundingMode).
- */
- public void testDivideBigDecimalScaleRoundingModeHALF_UP() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = -51;
- String b = "74723342238476237823787879183470";
- int bScale = 45;
- int newScale = 3;
- RoundingMode rm = RoundingMode.HALF_UP;
- String c = "50000260373164286401361913262100972218038099522752460421"
- + "05959924024355721031761947728703598332749334086415670525"
- + "3761096961.670";
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, newScale, rm);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", newScale, result.scale());
- }
-
- /**
- * divide(BigDecimal, scale, RoundingMode).
- */
- public void testDivideBigDecimalScaleRoundingModeUP() {
- String a = "-37361671119238118911893939591735";
- int aScale = 10;
- String b = "74723342238476237823787879183470";
- int bScale = -15;
- int newScale = 31;
- RoundingMode rm = RoundingMode.UP;
- String c = "-5.00000E-26";
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, newScale, rm);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", newScale, result.scale());
- }
-
- /**
- * Divide by zero.
- */
- public void testDivideByZero() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 15;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = BigDecimal.valueOf(0L);
- try {
- aNumber.divide(bNumber);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "Division by zero",
- e.getMessage());
- }
- }
-
- /**
- * Divide with invalid rounding mode.
- */
- public void testDivideExceptionInvalidRM() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 15;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- try {
- aNumber.divide(bNumber, 100);
- fail("IllegalArgumentException has not been caught");
- } catch (IllegalArgumentException e) {
- assertEquals("Improper exception message", "Invalid rounding mode",
- e.getMessage());
- }
- }
-
- /**
- * Divide with ROUND_UNNECESSARY.
- */
- public void testDivideExceptionRM() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 15;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- try {
- aNumber.divide(bNumber, BigDecimal.ROUND_UNNECESSARY);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "Rounding necessary",
- e.getMessage());
- }
- }
-
- /**
- * Divide: local variable exponent is equal to zero.
- */
- public void testDivideExpEqualsZero() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -15;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- String c = "1.64769459009933764189139568605273529E+40";
- int resScale = -5;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_CEILING);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: local variable exponent is greater than zero.
- */
- public void testDivideExpGreaterZero() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -15;
- String b = "747233429293018787918347987234564568";
- int bScale = 20;
- String c = "1.647694590099337641891395686052735285121058381E+50";
- int resScale = -5;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_CEILING);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: local variable exponent is less than zero.
- */
- public void testDivideExpLessZero() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 15;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- String c = "1.64770E+10";
- int resScale = -5;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_CEILING);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * BigDecimal.divide with a scale that's too large.
- *
- * Regression test for HARMONY-6271
- */
- public void testDivideLargeScale() {
- BigDecimal arg1 = new BigDecimal("320.0E+2147483647");
- BigDecimal arg2 = new BigDecimal("6E-2147483647");
- try {
- arg1.divide(arg2, Integer.MAX_VALUE, RoundingMode.CEILING);
- fail("Expected ArithmeticException when dividing with a scale that's too large");
- } catch (ArithmeticException e) {
- // expected behaviour
- }
- }
-
- /**
- * Divide: remainder is zero.
- */
- public void testDivideRemainderIsZero() {
- String a = "8311389578904553209874735431110";
- int aScale = -15;
- String b = "237468273682987234567849583746";
- int bScale = 20;
- String c = "3.5000000000000000000000000000000E+36";
- int resScale = -5;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_CEILING);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_CEILING, result is negative.
- */
- public void testDivideRoundCeilingNeg() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "-1.24390557635720517122423359799283E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_CEILING);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_CEILING, result is positive.
- */
- public void testDivideRoundCeilingPos() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "1.24390557635720517122423359799284E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_CEILING);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_DOWN, result is negative.
- */
- public void testDivideRoundDownNeg() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "-1.24390557635720517122423359799283E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_DOWN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_DOWN, result is positive.
- */
- public void testDivideRoundDownPos() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "1.24390557635720517122423359799283E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_DOWN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_FLOOR, result is negative.
- */
- public void testDivideRoundFloorNeg() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "-1.24390557635720517122423359799284E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_FLOOR);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_FLOOR, result is positive.
- */
- public void testDivideRoundFloorPos() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "1.24390557635720517122423359799283E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_FLOOR);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_DOWN, result is negative;
- * distance = -1.
- */
- public void testDivideRoundHalfDownNeg() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "-1.24390557635720517122423359799284E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_DOWN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_DOWN, result is negative; distance = 1.
- */
- public void testDivideRoundHalfDownNeg1() {
- String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
- int aScale = -24;
- String b = "74723342238476237823754692930187879183479";
- int bScale = 13;
- String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_DOWN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_UP, result is negative; equidistant.
- */
- public void testDivideRoundHalfDownNeg2() {
- String a = "-37361671119238118911893939591735";
- int aScale = 10;
- String b = "74723342238476237823787879183470";
- int bScale = 15;
- String c = "0E+5";
- int resScale = -5;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_DOWN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_DOWN, result is positive;
- * distance = -1.
- */
- public void testDivideRoundHalfDownPos() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "1.24390557635720517122423359799284E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_DOWN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_DOWN, result is positive; distance = 1.
- */
- public void testDivideRoundHalfDownPos1() {
- String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
- int aScale = -24;
- String b = "74723342238476237823754692930187879183479";
- int bScale = 13;
- String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_DOWN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_EVEN, result is negative;
- * distance = -1.
- */
- public void testDivideRoundHalfEvenNeg() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "-1.24390557635720517122423359799284E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_EVEN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; distance = 1
- */
- public void testDivideRoundHalfEvenNeg1() {
- String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
- int aScale = -24;
- String b = "74723342238476237823754692930187879183479";
- int bScale = 13;
- String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_EVEN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_EVEN, result is negative; equidistant
- */
- public void testDivideRoundHalfEvenNeg2() {
- String a = "-37361671119238118911893939591735";
- int aScale = 10;
- String b = "74723342238476237823787879183470";
- int bScale = 15;
- String c = "0E+5";
- int resScale = -5;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_EVEN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_EVEN, result is positive; distance = -1
- */
- public void testDivideRoundHalfEvenPos() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "1.24390557635720517122423359799284E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_EVEN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_EVEN, result is positive; distance = 1
- */
- public void testDivideRoundHalfEvenPos1() {
- String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
- int aScale = -24;
- String b = "74723342238476237823754692930187879183479";
- int bScale = 13;
- String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_EVEN);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_UP, result is negative; distance = -1
- */
- public void testDivideRoundHalfUpNeg() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "-1.24390557635720517122423359799284E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_UP);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_UP, result is negative; distance = 1
- */
- public void testDivideRoundHalfUpNeg1() {
- String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
- int aScale = -24;
- String b = "74723342238476237823754692930187879183479";
- int bScale = 13;
- String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_UP);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_UP, result is negative; equidistant
- */
- public void testDivideRoundHalfUpNeg2() {
- String a = "-37361671119238118911893939591735";
- int aScale = 10;
- String b = "74723342238476237823787879183470";
- int bScale = 15;
- String c = "-1E+5";
- int resScale = -5;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_UP);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_UP, result is positive; distance = -1
- */
- public void testDivideRoundHalfUpPos() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "1.24390557635720517122423359799284E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_UP);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_HALF_UP, result is positive; distance = 1
- */
- public void testDivideRoundHalfUpPos1() {
- String a = "92948782094488478231212478987482988798104576347813847567949855464535634534563456";
- int aScale = -24;
- String b = "74723342238476237823754692930187879183479";
- int bScale = 13;
- String c = "1.2439055763572051712242335979928354832010167729111113605E+76";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale,
- BigDecimal.ROUND_HALF_UP);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_UP, result is negative
- */
- public void testDivideRoundUpNeg() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "-1.24390557635720517122423359799284E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_UP);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Divide: rounding mode is ROUND_UP, result is positive
- */
- public void testDivideRoundUpPos() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- String c = "1.24390557635720517122423359799284E+53";
- int resScale = -21;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_UP);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- public void testDivideSmall() {
- BigDecimal a = BigDecimal.valueOf(6);
- BigDecimal b = BigDecimal.valueOf(2);
- BigDecimal quotient = a.divide(b);
- assertEquals("3", quotient.toString());
- quotient = a.divideToIntegralValue(b);
- assertEquals("3", quotient.toString());
- quotient = a.divide(BigDecimal.ONE);
- assertEquals("6", quotient.toString());
- quotient = a.divide(BigDecimal.ONE.negate());
- assertEquals("-6", quotient.toString());
- }
-
- /**
- * divideToIntegralValue(BigDecimal)
- */
- public void testDivideToIntegralValue() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 70;
- String c = "277923185514690367474770683";
- int resScale = 0;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divideToIntegralValue(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * divideToIntegralValue(BigDecimal, MathContext)
- */
- public void testDivideToIntegralValueMathContextDOWN() {
- String a = "3736186567876876578956958769675785435673453453653543654354365435675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 70;
- int precision = 75;
- RoundingMode rm = RoundingMode.DOWN;
- MathContext mc = new MathContext(precision, rm);
- String c = "2.7792318551469036747477068339450205874992634417590178670822889E+62";
- int resScale = -1;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divideToIntegralValue(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * divideToIntegralValue(BigDecimal, MathContext)
- */
- public void testDivideToIntegralValueMathContextUP() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 70;
- int precision = 32;
- RoundingMode rm = RoundingMode.UP;
- MathContext mc = new MathContext(precision, rm);
- String c = "277923185514690367474770683";
- int resScale = 0;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.divideToIntegralValue(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- public void testDivideZero() {
- BigDecimal quotient = BigDecimal.ZERO.divide(BigDecimal.ONE);
- assertEquals(BigDecimal.ZERO, quotient);
- quotient = BigDecimal.ZERO.negate().divide(BigDecimal.ONE);
- assertEquals(BigDecimal.ZERO, quotient);
- try {
- quotient = BigDecimal.ZERO.divide(BigDecimal.ZERO);
- fail("Expected ArithmeticException, divide by zero");
- } catch (ArithmeticException expected) {
- }
- assertEquals(BigDecimal.ZERO, quotient);
- try {
- quotient = BigDecimal.ONE.divide(BigDecimal.ZERO);
- fail("Expected ArithmeticException, divide by zero");
- } catch (ArithmeticException expected) {
- }
- try {
- quotient = BigDecimal.ONE.divideToIntegralValue(BigDecimal.ZERO);
- fail("Expected ArithmeticException, divide by zero");
- } catch (ArithmeticException expected) {
- }
- }
-
- /**
- * Multiply two numbers of different scales
- */
- public void testMultiplyDiffScaleNegPos() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -15;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- String c = "9.20003122862175749786430095741145455670101391569026662845893091880727173060570190220616E+91";
- int cScale = -5;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.multiply(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Multiply two numbers of different scales
- */
- public void testMultiplyDiffScalePosNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 10;
- String b = "747233429293018787918347987234564568";
- int bScale = -10;
- String c = "920003122862175749786430095741145455670101391569026662845893091880727173060570190220616";
- int cScale = 0;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.multiply(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Multiply two numbers of negative scales
- */
- public void testMultiplyEqualScaleNegNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -15;
- String b = "747233429293018787918347987234564568";
- int bScale = -10;
- String c = "9.20003122862175749786430095741145455670101391569026662845893091880727173060570190220616E+111";
- int cScale = -25;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.multiply(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Multiply two numbers of different scales using MathContext
- */
- public void testMultiplyMathContextDiffScaleNegPos() {
- String a = "488757458676796558668876576576579097029810457634781384756794987";
- int aScale = -63;
- String b = "747233429293018787918347987234564568";
- int bScale = 63;
- String c = "3.6521591193960361339707130098174381429788164316E+98";
- int cScale = -52;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- MathContext mc = new MathContext(47, RoundingMode.HALF_UP);
- BigDecimal result = aNumber.multiply(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Multiply two numbers of different scales using MathContext
- */
- public void testMultiplyMathContextDiffScalePosNeg() {
- String a = "987667796597975765768768767866756808779810457634781384756794987";
- int aScale = 100;
- String b = "747233429293018787918347987234564568";
- int bScale = -70;
- String c = "7.3801839465418518653942222612429081498248509257207477E+68";
- int cScale = -16;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- MathContext mc = new MathContext(53, RoundingMode.HALF_UP);
- BigDecimal result = aNumber.multiply(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Multiply two numbers of positive scales using MathContext
- */
- public void testMultiplyMathContextScalePosPos() {
- String a = "97665696756578755423325476545428779810457634781384756794987";
- int aScale = -25;
- String b = "87656965586786097685674786576598865";
- int bScale = 10;
- String c = "8.561078619600910561431314228543672720908E+108";
- int cScale = -69;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- MathContext mc = new MathContext(40, RoundingMode.HALF_DOWN);
- BigDecimal result = aNumber.multiply(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Multiply two numbers of positive scales
- */
- public void testMultiplyScalePosPos() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 15;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- String c = "92000312286217574978643009574114545567010139156902666284589309.1880727173060570190220616";
- int cScale = 25;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.multiply(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * pow(int)
- */
- public void testPow() {
- String a = "123121247898748298842980";
- int aScale = 10;
- int exp = 10;
- String c = "8004424019039195734129783677098845174704975003788210729597"
- + "4875206425711159855030832837132149513512555214958035390490"
- + "798520842025826.594316163502809818340013610490541783276343"
- + "6514490899700151256484355936102754469438371850240000000000";
- int cScale = 100;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.pow(exp);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * pow(0)
- */
- public void testPow0() {
- String a = "123121247898748298842980";
- int aScale = 10;
- int exp = 0;
- String c = "1";
- int cScale = 0;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.pow(exp);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * pow(int, MathContext)
- */
- public void testPowMathContext() {
- String a = "123121247898748298842980";
- int aScale = 10;
- int exp = 10;
- String c = "8.0044E+130";
- int cScale = -126;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- MathContext mc = new MathContext(5, RoundingMode.HALF_UP);
- BigDecimal result = aNumber.pow(exp, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * remainder(BigDecimal)
- */
- public void testRemainder1() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 10;
- String res = "3736186567876.876578956958765675671119238118911893939591735";
- int resScale = 45;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.remainder(bNumber);
- assertEquals("incorrect quotient value", res, result.toString());
- assertEquals("incorrect quotient scale", resScale, result.scale());
- }
-
- /**
- * remainder(BigDecimal)
- */
- public void testRemainder2() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = -45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 10;
- String res = "1149310942946292909508821656680979993738625937.2065885780";
- int resScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.remainder(bNumber);
- assertEquals("incorrect quotient value", res, result.toString());
- assertEquals("incorrect quotient scale", resScale, result.scale());
- }
-
- /**
- * remainder(BigDecimal, MathContext)
- */
- public void testRemainderMathContextHALF_DOWN() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = -45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 10;
- int precision = 75;
- RoundingMode rm = RoundingMode.HALF_DOWN;
- MathContext mc = new MathContext(precision, rm);
- String res = "1149310942946292909508821656680979993738625937.2065885780";
- int resScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.remainder(bNumber, mc);
- assertEquals("incorrect quotient value", res, result.toString());
- assertEquals("incorrect quotient scale", resScale, result.scale());
- }
-
- /**
- * remainder(BigDecimal, MathContext)
- */
- public void testRemainderMathContextHALF_UP() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- String b = "134432345432345748766876876723342238476237823787879183470";
- int bScale = 10;
- int precision = 15;
- RoundingMode rm = RoundingMode.HALF_UP;
- MathContext mc = new MathContext(precision, rm);
- String res = "3736186567876.876578956958765675671119238118911893939591735";
- int resScale = 45;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.remainder(bNumber, mc);
- assertEquals("incorrect quotient value", res, result.toString());
- assertEquals("incorrect quotient scale", resScale, result.scale());
- }
-
- /**
- * round(BigDecimal, MathContext)
- */
- public void testRoundMathContextHALF_DOWN() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = -45;
- int precision = 75;
- RoundingMode rm = RoundingMode.HALF_DOWN;
- MathContext mc = new MathContext(precision, rm);
- String res = "3.736186567876876578956958765675671119238118911893939591735E+102";
- int resScale = -45;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.round(mc);
- assertEquals("incorrect quotient value", res, result.toString());
- assertEquals("incorrect quotient scale", resScale, result.scale());
- }
-
- /**
- * round(BigDecimal, MathContext)
- */
- public void testRoundMathContextHALF_UP() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- int precision = 15;
- RoundingMode rm = RoundingMode.HALF_UP;
- MathContext mc = new MathContext(precision, rm);
- String res = "3736186567876.88";
- int resScale = 2;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.round(mc);
- assertEquals("incorrect quotient value", res, result.toString());
- assertEquals("incorrect quotient scale", resScale, result.scale());
- }
-
- /**
- * round(BigDecimal, MathContext) when precision = 0
- */
- public void testRoundMathContextPrecision0() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- int precision = 0;
- RoundingMode rm = RoundingMode.HALF_UP;
- MathContext mc = new MathContext(precision, rm);
- String res = "3736186567876.876578956958765675671119238118911893939591735";
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.round(mc);
- assertEquals("incorrect quotient value", res, result.toString());
- assertEquals("incorrect quotient scale", aScale, result.scale());
- }
-
- /**
- * Subtract two numbers of different scales; the first is negative
- */
- public void testSubtractDiffScaleNegPos() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -15;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- String c = "1231212478987482988429808779810457634781310033452057698121208165201.2765435432";
- int cScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.subtract(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Subtract two numbers of different scales; the first is positive
- */
- public void testSubtractDiffScalePosNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 15;
- String b = "747233429293018787918347987234564568";
- int bScale = -10;
- String c = "-7472334291698975400195996883915836900189542365.218615243205013";
- int cScale = 15;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.subtract(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Subtract two numbers of equal negative scales
- */
- public void testSubtractEqualScaleNegNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -10;
- String b = "747233429293018787918347987234564568";
- int bScale = -10;
- String c = "1.231212478987482241196379486791669716433397522230419E+61";
- int cScale = -10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.subtract(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Subtract two numbers of equal positive scales
- */
- public void testSubtractEqualScalePosPos() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 10;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- String c = "123121247898748224119637948679166971643339.7522230419";
- int cScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal result = aNumber.subtract(bNumber);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Subtract two numbers of different scales using MathContext; the first is
- * negative
- */
- public void testSubtractMathContextDiffScaleNegPos() {
- String a = "986798656676789766678767876078779810457634781384756794987";
- int aScale = -15;
- String b = "747233429293018787918347987234564568";
- int bScale = 40;
- String c = "9.867986566767897666787678760787798104576347813847567949870000000000000E+71";
- int cScale = -2;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- MathContext mc = new MathContext(70, RoundingMode.HALF_DOWN);
- BigDecimal result = aNumber.subtract(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Subtract two numbers of different scales using MathContext; the first is
- * positive
- */
- public void testSubtractMathContextDiffScalePosNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 15;
- String b = "747233429293018787918347987234564568";
- int bScale = -10;
- String c = "-7.4723342916989754E+45";
- int cScale = -29;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- MathContext mc = new MathContext(17, RoundingMode.DOWN);
- BigDecimal result = aNumber.subtract(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * Subtract two numbers of equal positive scales using MathContext
- */
- public void testSubtractMathContextEqualScalePosPos() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 10;
- String b = "747233429293018787918347987234564568";
- int bScale = 10;
- String c = "1.23121247898749E+41";
- int cScale = -27;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- MathContext mc = new MathContext(15, RoundingMode.CEILING);
- BigDecimal result = aNumber.subtract(bNumber, mc);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-
- /**
- * ulp() of a negative BigDecimal
- */
- public void testUlpNeg() {
- String a = "-3736186567876876578956958765675671119238118911893939591735";
- int aScale = 45;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.ulp();
- String res = "1E-45";
- int resScale = 45;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * ulp() of a positive BigDecimal
- */
- public void testUlpPos() {
- String a = "3736186567876876578956958765675671119238118911893939591735";
- int aScale = -45;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.ulp();
- String res = "1E+45";
- int resScale = -45;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * ulp() of a negative BigDecimal
- */
- public void testUlpZero() {
- String a = "0";
- int aScale = 2;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.ulp();
- String res = "0.01";
- int resScale = 2;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * ZERO.pow(0)
- */
- public void testZeroPow0() {
- String c = "1";
- int cScale = 0;
- BigDecimal result = BigDecimal.ZERO.pow(0);
- assertEquals("incorrect value", c, result.toString());
- assertEquals("incorrect scale", cScale, result.scale());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigDecimalCompareTest.java b/user/test/com/google/gwt/emultest/java/math/BigDecimalCompareTest.java
deleted file mode 100644
index d91f5b1..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigDecimalCompareTest.java
+++ /dev/null
@@ -1,529 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.math.MathContext;
-import java.math.RoundingMode;
-
-/**
- * Class: java.math.BigDecimal Methods: abs, compareTo, equals, hashCode, max,
- * min, negate, signum.
- */
-public class BigDecimalCompareTest extends EmulTestBase {
-
- /**
- * Abs(MathContext) of a negative BigDecimal.
- */
- public void testAbsMathContextNeg() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigDecimal aNumber = new BigDecimal(a);
- int precision = 15;
- RoundingMode rm = RoundingMode.HALF_DOWN;
- MathContext mc = new MathContext(precision, rm);
- String result = "1.23809648392385E+53";
- int resScale = -39;
- BigDecimal res = aNumber.abs(mc);
- assertEquals("incorrect value", result, res.toString());
- assertEquals("incorrect scale", resScale, res.scale());
- }
-
- /**
- * Abs(MathContext) of a positive BigDecimal.
- */
- public void testAbsMathContextPos() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigDecimal aNumber = new BigDecimal(a);
- int precision = 41;
- RoundingMode rm = RoundingMode.HALF_EVEN;
- MathContext mc = new MathContext(precision, rm);
- String result = "1.2380964839238475457356735674573563567890E+53";
- int resScale = -13;
- BigDecimal res = aNumber.abs(mc);
- assertEquals("incorrect value", result, res.toString());
- assertEquals("incorrect scale", resScale, res.scale());
- }
-
- /**
- * Abs() of a negative BigDecimal.
- */
- public void testAbsNeg() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "123809648392384754573567356745735635678902957849027687.87678287";
- assertEquals("incorrect value", result, aNumber.abs().toString());
- }
-
- /**
- * Abs() of a positive BigDecimal.
- */
- public void testAbsPos() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "123809648392384754573567356745735635678902957849027687.87678287";
- assertEquals("incorrect value", result, aNumber.abs().toString());
- }
-
- /**
- * Compare to a number of an equal scale.
- */
- public void testCompareEqualScale1() {
- String a = "12380964839238475457356735674573563567890295784902768787678287";
- int aScale = 18;
- String b = "4573563567890295784902768787678287";
- int bScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- int result = 1;
- assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
- }
-
- /**
- * Compare to a number of an equal scale.
- */
- public void testCompareEqualScale2() {
- String a = "12380964839238475457356735674573563567890295784902768787678287";
- int aScale = 18;
- String b = "4573563923487289357829759278282992758247567890295784902768787678287";
- int bScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- int result = -1;
- assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
- }
-
- /**
- * Compare to a number of an greater scale.
- */
- public void testCompareGreaterScale1() {
- String a = "12380964839238475457356735674573563567890295784902768787678287";
- int aScale = 28;
- String b = "4573563567890295784902768787678287";
- int bScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- int result = 1;
- assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
- }
-
- /**
- * Compare to a number of an greater scale.
- */
- public void testCompareGreaterScale2() {
- String a = "12380964839238475457356735674573563567890295784902768787678287";
- int aScale = 48;
- String b = "4573563567890295784902768787678287";
- int bScale = 2;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- int result = -1;
- assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
- }
-
- /**
- * Compare to a number of an less scale.
- */
- public void testCompareLessScale1() {
- String a = "12380964839238475457356735674573563567890295784902768787678287";
- int aScale = 18;
- String b = "4573563567890295784902768787678287";
- int bScale = 28;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- int result = 1;
- assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
- }
-
- /**
- * Compare to a number of an less scale.
- */
- public void testCompareLessScale2() {
- String a = "12380964839238475457356735674573";
- int aScale = 36;
- String b = "45735635948573894578349572001798379183767890295784902768787678287";
- int bScale = 48;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- int result = -1;
- assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
- }
-
- /**
- * equals() for equal BigDecimals.
- */
- public void testEqualsEqual() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "92948782094488478231212478987482988429808779810457634781384756794987";
- int bScale = -24;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- assertEquals(aNumber, bNumber);
- }
-
- /**
- * equals() for equal BigDecimals.
- */
- public void testEqualsNull() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- assertFalse(aNumber.equals(null));
- }
-
- /**
- * Equals() for unequal BigDecimals.
- */
- public void testEqualsUnequal1() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "7472334223847623782375469293018787918347987234564568";
- int bScale = 13;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- assertFalse(aNumber.equals(bNumber));
- }
-
- /**
- * Equals() for unequal BigDecimals.
- */
- public void testEqualsUnequal2() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "92948782094488478231212478987482988429808779810457634781384756794987";
- int bScale = 13;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- assertFalse(aNumber.equals(bNumber));
- }
-
- /**
- * Equals() for unequal BigDecimals.
- */
- public void testEqualsUnequal3() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "92948782094488478231212478987482988429808779810457634781384756794987";
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- assertFalse(aNumber.equals(b));
- }
-
- /**
- * hashCode() for equal BigDecimals.
- */
- public void testHashCodeEqual() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = -24;
- String b = "92948782094488478231212478987482988429808779810457634781384756794987";
- int bScale = -24;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- assertEquals("incorrect value", aNumber.hashCode(), bNumber.hashCode());
- }
-
- /**
- * hashCode() for unequal BigDecimals.
- */
- public void testHashCodeUnequal() {
- String a = "8478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- String b = "92948782094488478231212478987482988429808779810457634781384756794987";
- int bScale = -24;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- assertTrue("incorrect value", aNumber.hashCode() != bNumber.hashCode());
- }
-
- /**
- * max() for equal BigDecimals.
- */
- public void testMaxEqual() {
- String a = "8478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- String b = "8478231212478987482988429808779810457634781384756794987";
- int bScale = 41;
- String c = "8478231212478987482988429808779810457634781384756794987";
- int cScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
- assertEquals("incorrect value", cNumber, aNumber.max(bNumber));
- }
-
- /**
- * max() for unequal BigDecimals.
- */
- public void testMaxUnequal1() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 24;
- String b = "92948782094488478231212478987482988429808779810457634781384756794987";
- int bScale = 41;
- String c = "92948782094488478231212478987482988429808779810457634781384756794987";
- int cScale = 24;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
- assertEquals("incorrect value", cNumber, aNumber.max(bNumber));
- }
-
- /**
- * max() for unequal BigDecimals.
- */
- public void testMaxUnequal2() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- String b = "94488478231212478987482988429808779810457634781384756794987";
- int bScale = 41;
- String c = "92948782094488478231212478987482988429808779810457634781384756794987";
- int cScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
- assertEquals("incorrect value", cNumber, aNumber.max(bNumber));
- }
-
- /**
- * min() for equal BigDecimals.
- */
- public void testMinEqual() {
- String a = "8478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- String b = "8478231212478987482988429808779810457634781384756794987";
- int bScale = 41;
- String c = "8478231212478987482988429808779810457634781384756794987";
- int cScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
- assertEquals("incorrect value", cNumber, aNumber.min(bNumber));
- }
-
- /**
- * min() for unequal BigDecimals.
- */
- public void testMinUnequal1() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 24;
- String b = "92948782094488478231212478987482988429808779810457634781384756794987";
- int bScale = 41;
- String c = "92948782094488478231212478987482988429808779810457634781384756794987";
- int cScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
- assertEquals("incorrect value", cNumber, aNumber.min(bNumber));
- }
-
- /**
- * min() for unequal BigDecimals.
- */
- public void testMinUnequal2() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- String b = "94488478231212478987482988429808779810457634781384756794987";
- int bScale = 41;
- String c = "94488478231212478987482988429808779810457634781384756794987";
- int cScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
- BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
- assertEquals("incorrect value", cNumber, aNumber.min(bNumber));
- }
-
- /**
- * negate(MathContext) for a negative BigDecimal.
- */
- public void testNegateMathContextNegative() {
- if (!GWT.isScript()) {
- // OpenJDK fails this test, so for now we only run it in web mode
- return;
- }
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 49;
- int precision = 46;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- String c = "9294878209448847823.121247898748298842980877981";
- int cScale = 27;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal res = aNumber.negate(mc);
- assertEquals("incorrect value", c, res.toString());
- assertEquals("incorrect scale", cScale, res.scale());
- }
-
- /**
- * negate(MathContext) for a positive BigDecimal.
- */
- public void testNegateMathContextPositive() {
- if (!GWT.isScript()) {
- // OpenJDK fails this test, so for now we only run it in web mode
- return;
- }
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- int precision = 37;
- RoundingMode rm = RoundingMode.FLOOR;
- MathContext mc = new MathContext(precision, rm);
- String c = "-929487820944884782312124789.8748298842";
- int cScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal res = aNumber.negate(mc);
- assertEquals("incorrect value", c, res.toString());
- assertEquals("incorrect scale", cScale, res.scale());
- }
-
- /**
- * negate() for a negative BigDecimal.
- */
- public void testNegateNegative() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- String c = "92948782094488478231212478987482988429808779810457634781384756794987";
- int cScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
- assertEquals("incorrect value", cNumber, aNumber.negate());
- }
-
- /**
- * negate() for a positive BigDecimal.
- */
- public void testNegatePositive() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- String c = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int cScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
- assertEquals("incorrect value", cNumber, aNumber.negate());
- }
-
- /**
- * plus(MathContext) for a negative BigDecimal.
- */
- public void testPlusMathContextNegative() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 49;
- int precision = 46;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- String c = "-9294878209448847823.121247898748298842980877981";
- int cScale = 27;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal res = aNumber.plus(mc);
- assertEquals("incorrect value", c, res.toString());
- assertEquals("incorrect scale", cScale, res.scale());
- }
-
- /**
- * plus(MathContext) for a positive BigDecimal.
- */
- public void testPlusMathContextPositive() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- int precision = 37;
- RoundingMode rm = RoundingMode.FLOOR;
- MathContext mc = new MathContext(precision, rm);
- String c = "929487820944884782312124789.8748298842";
- int cScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal res = aNumber.plus(mc);
- assertEquals("incorrect value", c, res.toString());
- assertEquals("incorrect scale", cScale, res.scale());
- }
-
- /**
- * plus() for a negative BigDecimal.
- */
- public void testPlusNegative() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- String c = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int cScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
- assertEquals("incorrect value", cNumber, aNumber.plus());
- }
-
- /**
- * plus() for a positive BigDecimal.
- */
- public void testPlusPositive() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- String c = "92948782094488478231212478987482988429808779810457634781384756794987";
- int cScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
- assertEquals("incorrect value", cNumber, aNumber.plus());
- }
-
- /**
- * signum() for a negative BigDecimal.
- */
- public void testSignumNegative() {
- String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- assertEquals("incorrect value", -1, aNumber.signum());
- }
-
- /**
- * signum() for a positive BigDecimal.
- */
- public void testSignumPositive() {
- String a = "92948782094488478231212478987482988429808779810457634781384756794987";
- int aScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- assertEquals("incorrect value", 1, aNumber.signum());
- }
-
- /**
- * signum() for zero.
- */
- public void testSignumZero() {
- String a = "0";
- int aScale = 41;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- assertEquals("incorrect value", 0, aNumber.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigDecimalConstructorsTest.java b/user/test/com/google/gwt/emultest/java/math/BigDecimalConstructorsTest.java
deleted file mode 100644
index fc87dd3..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigDecimalConstructorsTest.java
+++ /dev/null
@@ -1,762 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-import com.google.gwt.junit.DoNotRunWith;
-import com.google.gwt.junit.Platform;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.math.MathContext;
-import java.math.RoundingMode;
-
-/**
- * Class: java.math.BigDecimal Methods: constructors and fields.
- */
-public class BigDecimalConstructorsTest extends EmulTestBase {
-
- /**
- * new BigDecimal(BigInteger value).
- */
- public void testConstrBI() {
- String a = "1231212478987482988429808779810457634781384756794987";
- BigInteger bA = new BigInteger(a);
- BigDecimal aNumber = new BigDecimal(bA);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", 0, aNumber.scale());
-
- try {
- new BigDecimal((BigInteger) null);
- fail("No NullPointerException");
- } catch (NullPointerException e) {
- // expected
- }
- }
-
- /**
- * new BigDecimal(BigInteger value, MathContext).
- */
- public void testConstrBigIntegerMathContext() {
- String a = "1231212478987482988429808779810457634781384756794987";
- BigInteger bA = new BigInteger(a);
- int precision = 46;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- String res = "1231212478987482988429808779810457634781384757";
- int resScale = -6;
- BigDecimal result = new BigDecimal(bA, mc);
- assertEquals("incorrect value", res, result.unscaledValue().toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * new BigDecimal(BigInteger value, int scale, MathContext).
- */
- public void testConstrBigIntegerScaleMathContext() {
- String a = "1231212478987482988429808779810457634781384756794987";
- BigInteger bA = new BigInteger(a);
- int aScale = 10;
- int precision = 46;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- String res = "1231212478987482988429808779810457634781384757";
- int resScale = 4;
- BigDecimal result = new BigDecimal(bA, aScale, mc);
- assertEquals("incorrect value", res, result.unscaledValue().toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * new BigDecimal(BigInteger value, int scale).
- */
- public void testConstrBIScale() {
- String a = "1231212478987482988429808779810457634781384756794987";
- BigInteger bA = new BigInteger(a);
- int aScale = 10;
- BigDecimal aNumber = new BigDecimal(bA, aScale);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(char[] value).
- */
- public void testConstrChar() {
- char value[] = {
- '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4',
- '2', '3'};
- BigDecimal result = new BigDecimal(value);
- String res = "-1.23804738E-419";
- int resScale = 427;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
-
- try {
- // Regression for HARMONY-783
- new BigDecimal(new char[] {});
- fail("NumberFormatException has not been thrown");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(char[] value, int offset, int len).
- */
- public void testConstrCharIntInt() {
- char value[] = {
- '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4',
- '2', '3'};
- int offset = 3;
- int len = 12;
- BigDecimal result = new BigDecimal(value, offset, len);
- String res = "3.804738E-40";
- int resScale = 46;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
-
- try {
- // Regression for HARMONY-783
- new BigDecimal(new char[] {}, 0, 0);
- fail("NumberFormatException has not been thrown");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(char[] value, int offset, int len, MathContext mc).
- */
- public void testConstrCharIntIntMathContext() {
- char value[] = {
- '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4',
- '2', '3'};
- int offset = 3;
- int len = 12;
- int precision = 4;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- BigDecimal result = new BigDecimal(value, offset, len, mc);
- String res = "3.805E-40";
- int resScale = 43;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
-
- try {
- // Regression for HARMONY-783
- new BigDecimal(new char[] {}, 0, 0, MathContext.DECIMAL32);
- fail("NumberFormatException has not been thrown");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(char[] value, int offset, int len, MathContext mc).
- */
- public void testConstrCharIntIntMathContextException1() {
- char value[] = {
- '-', '1', '2', '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4',
- '2', '3'};
- int offset = 3;
- int len = 120;
- int precision = 4;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- try {
- new BigDecimal(value, offset, len, mc);
- fail("NumberFormatException has not been thrown");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(char[] value, int offset, int len, MathContext mc).
- */
- public void testConstrCharIntIntMathContextException2() {
- char value[] = {
- '-', '1', '2', '3', '8', '0', ',', '4', '7', '3', '8', 'E', '-', '4',
- '2', '3'};
- int offset = 3;
- int len = 120;
- int precision = 4;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- try {
- new BigDecimal(value, offset, len, mc);
- fail("NumberFormatException has not been thrown");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(char[] value, MathContext mc).
- */
- public void testConstrCharMathContext() {
- char value[] = {
- '3', '8', '0', '.', '4', '7', '3', '8', 'E', '-', '4', '2'
- };
- int precision = 4;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- BigDecimal result = new BigDecimal(value, mc);
- String res = "3.805E-40";
- int resScale = 43;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
-
- // Regression for HARMONY-783
- try {
- new BigDecimal(new char[] {}, MathContext.DECIMAL32);
- fail("NumberFormatException has not been thrown");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(double value).
- */
- public void testConstrDouble() {
- double a = 732546982374982347892379283571094797.287346782359284756;
- BigDecimal aNumber = new BigDecimal(a);
- BigDecimal expected = new BigDecimal(
- "732546982374982347892379283571094797.287346782359284756");
- assertEquals(expected, aNumber, 1e21);
- }
-
- /**
- * new BigDecimal(0.1).
- */
- public void testConstrDouble01() {
- double a = 1.E-1;
- BigDecimal aNumber = new BigDecimal(a);
- BigDecimal expected = new BigDecimal(
- ".1000000000000000055511151231257827021181583404541015625");
- assertEquals(expected, aNumber, 1e-9);
- }
-
- /**
- * new BigDecimal(0.555).
- */
- public void testConstrDouble02() {
- double a = 0.555;
- BigDecimal aNumber = new BigDecimal(a);
- BigDecimal expected = new BigDecimal(
- ".55500000000000004884981308350688777863979339599609375");
- assertEquals(expected, aNumber, 1e-8);
- }
-
- /**
- * new BigDecimal(double value) when value is denormalized.
- */
- @DoNotRunWith(Platform.HtmlUnit)
- public void testConstrDoubleDenormalized() {
- // HtmlUnit incorrectly converts the following double to a string
- double a = 2.274341322658976E-309;
- BigDecimal aNumber = new BigDecimal(a);
- BigDecimal expected = new BigDecimal(
- "2.274341322658976E-309");
- assertEquals(expected, aNumber, 1e-310);
- }
-
- /**
- * new BigDecimal(double, MathContext).
- */
- public void testConstrDoubleMathContext() {
- double a = 732546982374982347892379283571094797.287346782359284756;
- int precision = 21;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- BigDecimal result = new BigDecimal(a, mc);
- BigDecimal expected = new BigDecimal("732546982374982e21");
- assertEquals(expected, result, 1e21);
- try {
- new BigDecimal(Double.NaN);
- fail("Expected NumberFormatException on NaN");
- } catch (NumberFormatException expectedException) {
- }
- try {
- new BigDecimal(Double.POSITIVE_INFINITY);
- fail("Expected NumberFormatException on +Infinity");
- } catch (NumberFormatException expectedException) {
- }
- try {
- new BigDecimal(Double.NEGATIVE_INFINITY);
- fail("Expected NumberFormatException on -Infinity");
- } catch (NumberFormatException expectedException) {
- }
- }
-
- /**
- * new BigDecimal(-0.1).
- */
- public void testConstrDoubleMinus01() {
- double a = -1.E-1;
- BigDecimal aNumber = new BigDecimal(a);
- BigDecimal expected = new BigDecimal(
- "-.1000000000000000055511151231257827021181583404541015625");
- assertEquals(expected, aNumber, 1e-9);
- }
-
- /**
- * new BigDecimal(double value) when value is NaN.
- */
- public void testConstrDoubleNaN() {
- double a = Double.NaN;
- try {
- new BigDecimal(a);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- assertEquals("Improper exception message", "Infinite or NaN",
- e.getMessage());
- }
- }
-
- /**
- * new BigDecimal(double value) when value is positive infinity.
- */
- public void testConstrDoubleNegInfinity() {
- double a = Double.NEGATIVE_INFINITY;
- try {
- new BigDecimal(a);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- assertEquals("Improper exception message", "Infinite or NaN",
- e.getMessage());
- }
- }
-
- /**
- * new BigDecimal(double value) when value is positive infinity.
- */
- public void testConstrDoublePosInfinity() {
- double a = Double.POSITIVE_INFINITY;
- try {
- new BigDecimal(a);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- assertEquals("Improper exception message", "Infinite or NaN",
- e.getMessage());
- }
- }
-
- /**
- * new BigDecimal(int value).
- */
- public void testConstrInt() {
- int a = 732546982;
- String res = "732546982";
- int resScale = 0;
- BigDecimal result = new BigDecimal(a);
- assertEquals("incorrect value", res, result.unscaledValue().toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * new BigDecimal(int, MathContext).
- */
- public void testConstrIntMathContext() {
- int a = 732546982;
- int precision = 21;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- String res = "732546982";
- int resScale = 0;
- BigDecimal result = new BigDecimal(a, mc);
- assertEquals("incorrect value", res, result.unscaledValue().toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * new BigDecimal(long value).
- */
- public void testConstrLong() {
- long a = 4576578677732546982L;
- String res = "4576578677732546982";
- int resScale = 0;
- BigDecimal result = new BigDecimal(a);
- assertEquals("incorrect value", res, result.unscaledValue().toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * new BigDecimal(long, MathContext).
- */
- public void testConstrLongMathContext() {
- long a = 4576578677732546982L;
- int precision = 5;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- String res = "45766";
- int resScale = -14;
- BigDecimal result = new BigDecimal(a, mc);
- assertEquals("incorrect value", res, result.unscaledValue().toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * new BigDecimal(String value) when value is not a valid representation of
- * BigDecimal.
- */
- public void testConstrStringException() {
- String a = "-238768.787678287a+10";
- try {
- new BigDecimal(a);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(String value) when exponent is empty.
- */
- public void testConstrStringExceptionEmptyExponent1() {
- String a = "-238768.787678287e";
- try {
- new BigDecimal(a);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(String value) when exponent is empty.
- */
- public void testConstrStringExceptionEmptyExponent2() {
- String a = "-238768.787678287e-";
- try {
- new BigDecimal(a);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(String value) when exponent is greater than
- * Integer.MAX_VALUE.
- */
- public void testConstrStringExceptionExponentGreaterIntegerMax() {
- String a = "-238768.787678287e214748364767876";
- try {
- new BigDecimal(a);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(String value) when exponent is less than Integer.MIN_VALUE.
- */
- public void testConstrStringExceptionExponentLessIntegerMin() {
- String a = "-238768.787678287e-214748364767876";
- try {
- new BigDecimal(a);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * new BigDecimal(String value) when exponent is Integer.MAX_VALUE.
- */
- public void testConstrStringExponentIntegerMax() {
- String a = "-238768.787678287e2147483647";
- int aScale = -2147483638;
- BigInteger bA = new BigInteger("-238768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value) when exponent is Integer.MIN_VALUE.
- */
- public void testConstrStringExponentIntegerMin() {
- String a = ".238768e-2147483648";
- try {
- new BigDecimal(a);
- fail("NumberFormatException expected");
- } catch (NumberFormatException e) {
- assertEquals("Improper exception message", "Scale out of range.",
- e.getMessage());
- }
- }
-
- /**
- * new BigDecimal(String value, MathContext).
- */
- public void testConstrStringMathContext() {
- String a = "-238768787678287e214";
- int precision = 5;
- RoundingMode rm = RoundingMode.CEILING;
- MathContext mc = new MathContext(precision, rm);
- String res = "-23876";
- int resScale = -224;
- BigDecimal result = new BigDecimal(a, mc);
- assertEquals("incorrect value", res, result.unscaledValue().toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * new BigDecimal(String value); value contains exponent and does not contain
- * decimal point.
- */
- public void testConstrStringWithExponentWithoutPoint1() {
- String a = "-238768787678287e214";
- int aScale = -214;
- BigInteger bA = new BigInteger("-238768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value contains exponent and does not contain
- * decimal point.
- */
- public void testConstrStringWithExponentWithoutPoint2() {
- String a = "-238768787678287e-214";
- int aScale = 214;
- BigInteger bA = new BigInteger("-238768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value contains exponent and does not contain
- * decimal point.
- */
- public void testConstrStringWithExponentWithoutPoint3() {
- String a = "238768787678287e-214";
- int aScale = 214;
- BigInteger bA = new BigInteger("238768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value contains exponent and does not contain
- * decimal point.
- */
- public void testConstrStringWithExponentWithoutPoint4() {
- String a = "238768787678287e+214";
- int aScale = -214;
- BigInteger bA = new BigInteger("238768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value contains exponent and does not contain
- * decimal point.
- */
- public void testConstrStringWithExponentWithoutPoint5() {
- String a = "238768787678287E214";
- int aScale = -214;
- BigInteger bA = new BigInteger("238768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value contains both exponent and decimal
- * point.
- */
- public void testConstrStringWithExponentWithPoint1() {
- String a = "23985439837984782435652424523876878.7678287e+214";
- int aScale = -207;
- BigInteger bA = new BigInteger("239854398379847824356524245238768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value contains both exponent and decimal
- * point.
- */
- public void testConstrStringWithExponentWithPoint2() {
- String a = "238096483923847545735673567457356356789029578490276878.7678287e-214";
- int aScale = 221;
- BigInteger bA = new BigInteger(
- "2380964839238475457356735674573563567890295784902768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value contains both exponent and decimal
- * point.
- */
- public void testConstrStringWithExponentWithPoint3() {
- String a = "2380964839238475457356735674573563567890.295784902768787678287E+21";
- int aScale = 0;
- BigInteger bA = new BigInteger(
- "2380964839238475457356735674573563567890295784902768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value contains both exponent and decimal
- * point.
- */
- public void testConstrStringWithExponentWithPoint4() {
- String a = "23809648392384754573567356745735635678.90295784902768787678287E+21";
- int aScale = 2;
- BigInteger bA = new BigInteger(
- "2380964839238475457356735674573563567890295784902768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value contains both exponent and decimal
- * point.
- */
- public void testConstrStringWithExponentWithPoint5() {
- String a = "238096483923847545735673567457356356789029.5784902768787678287E+21";
- int aScale = -2;
- BigInteger bA = new BigInteger(
- "2380964839238475457356735674573563567890295784902768787678287");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value does not contain exponent.
- */
- public void testConstrStringWithoutExpNeg() {
- String a = "-732546982374982347892379283571094797.287346782359284756";
- int aScale = 18;
- BigInteger bA = new BigInteger(
- "-732546982374982347892379283571094797287346782359284756");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value does not contain exponent.
- */
- public void testConstrStringWithoutExpPos1() {
- String a = "732546982374982347892379283571094797.287346782359284756";
- int aScale = 18;
- BigInteger bA = new BigInteger(
- "732546982374982347892379283571094797287346782359284756");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value does not contain exponent.
- */
- public void testConstrStringWithoutExpPos2() {
- String a = "+732546982374982347892379283571094797.287346782359284756";
- int aScale = 18;
- BigInteger bA = new BigInteger(
- "732546982374982347892379283571094797287346782359284756");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * new BigDecimal(String value); value does not contain exponent and decimal
- * point.
- */
- public void testConstrStringWithoutExpWithoutPoint() {
- String a = "-732546982374982347892379283571094797287346782359284756";
- int aScale = 0;
- BigInteger bA = new BigInteger(
- "-732546982374982347892379283571094797287346782359284756");
- BigDecimal aNumber = new BigDecimal(a);
- assertEquals("incorrect value", bA, aNumber.unscaledValue());
- assertEquals("incorrect scale", aScale, aNumber.scale());
- }
-
- /**
- * check ONE.
- */
- public void testFieldONE() {
- String oneS = "1";
- double oneD = 1.0;
- assertEquals("incorrect string value", oneS, BigDecimal.ONE.toString());
- assertEquals("incorrect double value", oneD, BigDecimal.ONE.doubleValue(),
- 0);
- }
-
- /**
- * check TEN.
- */
- public void testFieldTEN() {
- String oneS = "10";
- double oneD = 10.0;
- assertEquals("incorrect string value", oneS, BigDecimal.TEN.toString());
- assertEquals("incorrect double value", oneD, BigDecimal.TEN.doubleValue(),
- 0);
- }
-
- /**
- * check ZERO.
- */
- public void testFieldZERO() {
- String oneS = "0";
- double oneD = 0.0;
- assertEquals("incorrect string value", oneS, BigDecimal.ZERO.toString());
- assertEquals("incorrect double value", oneD, BigDecimal.ZERO.doubleValue(),
- 0);
- }
-
- private void assertEquals(BigDecimal expected, BigDecimal actual,
- double delta) {
- BigDecimal actualDeltaDecimal = actual.subtract(expected);
- double actualDelta = actualDeltaDecimal.abs().doubleValue();
- if (actualDelta >= delta) {
- fail("expected=" + expected + " actual=" + actual + " delta="
- + actualDelta);
- }
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigDecimalConvertTest.java b/user/test/com/google/gwt/emultest/java/math/BigDecimalConvertTest.java
deleted file mode 100644
index e43953f..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigDecimalConvertTest.java
+++ /dev/null
@@ -1,656 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigDecimal. Methods: doubleValue, floatValue, intValue,
- * longValue, valueOf, toString, toBigInteger
- */
-public class BigDecimalConvertTest extends EmulTestBase {
-
- public void testByteValue() {
- assertEquals((byte) 1, BigDecimal.ONE.byteValue());
- assertEquals((byte) -1, BigDecimal.valueOf(255).byteValue());
- assertEquals((byte) 1, BigDecimal.ONE.byteValueExact());
- try {
- BigDecimal.valueOf(255).byteValueExact();
- fail("Expected ArithmeticException on byteValueExact(255)");
- } catch (ArithmeticException expected) {
- }
- }
-
- /**
- * Double value of a small negative BigDecimal.
- */
- // TODO(jat): add back after Double.doubleToLongBits is implemented
-// public void testDoubleValueMinusZero() {
-// String a = "-123809648392384754573567356745735.63567890295784902768787678287E-400";
-// BigDecimal aNumber = new BigDecimal(a);
-// long minusZero = -9223372036854775808L;
-// double result = aNumber.doubleValue();
-// assertTrue("incorrect value", Double.doubleToLongBits(result) == minusZero);
-// }
-
- /**
- * Double value of a negative BigDecimal.
- */
- public void testDoubleValueNeg() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigDecimal aNumber = new BigDecimal(a);
- double result = -1.2380964839238476E53;
- assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
- }
-
- /**
- * Double value of a large negative BigDecimal.
- */
- public void testDoubleValueNegInfinity() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E+400";
- BigDecimal aNumber = new BigDecimal(a);
- double result = Double.NEGATIVE_INFINITY;
- assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
- }
-
- /**
- * Double value of a small positive BigDecimal.
- */
- // TODO(jat): add back after Double.doubleToLongBits is implemented
-// public void testDoubleValuePlusZero() {
-// String a = "123809648392384754573567356745735.63567890295784902768787678287E-400";
-// BigDecimal aNumber = new BigDecimal(a);
-// long zero = 0;
-// double result = aNumber.doubleValue();
-// assertTrue("incorrect value", Double.doubleToLongBits(result) == zero);
-// }
-
- /**
- * Double value of a positive BigDecimal.
- */
- public void testDoubleValuePos() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigDecimal aNumber = new BigDecimal(a);
- double result = 1.2380964839238476E53;
- assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
- }
-
- /**
- * Double value of a large positive BigDecimal.
- */
- public void testDoubleValuePosInfinity() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E+400";
- BigDecimal aNumber = new BigDecimal(a);
- double result = Double.POSITIVE_INFINITY;
- assertEquals("incorrect value", result, aNumber.doubleValue(), 0);
- }
-
- /**
- * Float value of a small negative BigDecimal.
- */
- // TODO(jat): add back after Float.floatToIntBits is implemented
-// public void testFloatValueMinusZero() {
-// String a = "-123809648392384754573567356745735.63567890295784902768787678287E-400";
-// BigDecimal aNumber = new BigDecimal(a);
-// int minusZero = -2147483648;
-// float result = aNumber.floatValue();
-// assertTrue("incorrect value", Float.floatToIntBits(result) == minusZero);
-// }
-
- /**
- * Float value of a negative BigDecimal.
- */
- public void testFloatValueNeg() {
- String a = "-1238096483923847.6356789029578E+21";
- BigDecimal aNumber = new BigDecimal(a);
- float result = -1.2380965E36F;
- // Use range rather than exact value check, since GWT uses doubles anyway
- assertEquals("incorrect value", aNumber.floatValue(), result, 1E29);
- }
-
- /**
- * Float value of a large negative BigDecimal.
- */
- public void testFloatValueNegInfinity() {
- String a = "-123809648392384755735.63567887678287E+200";
- BigDecimal aNumber = new BigDecimal(a);
- float result = Float.NEGATIVE_INFINITY;
- assertTrue("incorrect value", aNumber.floatValue() == result);
- }
-
- /**
- * Float value of a small positive BigDecimal.
- */
- // TODO(jat): add back after Float.floatToIntBits is implemented
-// public void testFloatValuePlusZero() {
-// String a = "123809648392384754573567356745735.63567890295784902768787678287E-400";
-// BigDecimal aNumber = new BigDecimal(a);
-// int zero = 0;
-// float result = aNumber.floatValue();
-// assertTrue("incorrect value", Float.floatToIntBits(result) == zero);
-// }
-
- /**
- * Float value of a positive BigDecimal.
- */
- public void testFloatValuePos() {
- String a = "1238096483923847.6356789029578E+21";
- BigDecimal aNumber = new BigDecimal(a);
- float result = 1.2380965E36F;
- // Use range rather than exact value check, since GWT uses doubles anyway
- assertEquals("incorrect value", aNumber.floatValue(), result, 1E29);
- }
-
- /**
- * Float value of a large positive BigDecimal.
- */
- public void testFloatValuePosInfinity() {
- String a = "123809648373567356745735.6356789787678287E+200";
- BigDecimal aNumber = new BigDecimal(a);
- float result = Float.POSITIVE_INFINITY;
- assertTrue("incorrect value", aNumber.floatValue() == result);
- }
-
- /**
- * Integer value of a negative BigDecimal.
- */
- public void testIntValueNeg() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigDecimal aNumber = new BigDecimal(a);
- int result = 218520473;
- assertEquals("incorrect value", result, aNumber.intValue());
- try {
- aNumber.intValueExact();
- fail("Expected ArithmeticException on intValueExact");
- } catch (ArithmeticException expected) {
- }
- }
-
- /**
- * Integer value of a positive BigDecimal.
- */
- public void testIntValuePos() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigDecimal aNumber = new BigDecimal(a);
- int result = -218520473;
- assertEquals("incorrect value", result, aNumber.intValue());
- try {
- aNumber.intValueExact();
- fail("Expected ArithmeticException on intValueExact");
- } catch (ArithmeticException expected) {
- }
- }
-
- /**
- * Long value of a negative BigDecimal.
- */
- public void testLongValueNeg() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigDecimal aNumber = new BigDecimal(a);
- long result = -1246043477766677607L;
- assertTrue("incorrect value", aNumber.longValue() == result);
- try {
- aNumber.longValueExact();
- fail("Expected ArithmeticException on longValueExact");
- } catch (ArithmeticException expected) {
- }
- }
-
- /**
- * Long value of a positive BigDecimal.
- */
- public void testLongValuePos() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigDecimal aNumber = new BigDecimal(a);
- long result = 1246043477766677607L;
- assertTrue("incorrect value", aNumber.longValue() == result);
- try {
- aNumber.longValueExact();
- fail("Expected ArithmeticException on longValueExact");
- } catch (ArithmeticException expected) {
- }
- }
-
- /**
- * scaleByPowerOfTen(int n).
- */
- public void testScaleByPowerOfTen1() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 13;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.scaleByPowerOfTen(10);
- String res = "1231212478987482988429808779810457634781384756794.987";
- int resScale = 3;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * scaleByPowerOfTen(int n).
- */
- public void testScaleByPowerOfTen2() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -13;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.scaleByPowerOfTen(10);
- String res = "1.231212478987482988429808779810457634781384756794987E+74";
- int resScale = -23;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- public void testShortValue() {
- BigDecimal value = BigDecimal.valueOf(0x13fff);
- assertEquals(0x3fff, value.shortValue());
- try {
- value.shortValueExact();
- fail("Expected ArithmeticException");
- } catch (ArithmeticException expected) {
- }
- }
-
- /**
- * toBigIntegerExact().
- */
- public void testToBigIntegerExact1() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E+45";
- BigDecimal aNumber = new BigDecimal(a);
- String res = "-123809648392384754573567356745735635678902957849027687876782870000000000000000";
- BigInteger result = aNumber.toBigIntegerExact();
- assertEquals("incorrect value", res, result.toString());
- }
-
- /**
- * toBigIntegerExact().
- */
- public void testToBigIntegerExactException() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E-10";
- BigDecimal aNumber = new BigDecimal(a);
- try {
- aNumber.toBigIntegerExact();
- fail("java.lang.ArithmeticException has not been thrown");
- } catch (java.lang.ArithmeticException e) {
- return;
- }
- }
-
- /**
- * Convert a negative BigDecimal to BigInteger.
- */
- public void testToBigIntegerNeg1() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigInteger bNumber = new BigInteger(
- "-123809648392384754573567356745735635678902957849027687");
- BigDecimal aNumber = new BigDecimal(a);
- BigInteger result = aNumber.toBigInteger();
- assertTrue("incorrect value", result.equals(bNumber));
- }
-
- /**
- * Convert a negative BigDecimal to BigInteger.
- */
- public void testToBigIntegerNeg2() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E+15";
- BigInteger bNumber = new BigInteger(
- "-123809648392384754573567356745735635678902957849");
- BigDecimal aNumber = new BigDecimal(a);
- BigInteger result = aNumber.toBigInteger();
- assertTrue("incorrect value", result.equals(bNumber));
- }
-
- /**
- * Convert a negative BigDecimal to BigInteger.
- */
- public void testToBigIntegerNeg3() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E+45";
- BigInteger bNumber = new BigInteger(
- "-123809648392384754573567356745735635678902957849027687876782870000000000000000");
- BigDecimal aNumber = new BigDecimal(a);
- BigInteger result = aNumber.toBigInteger();
- assertTrue("incorrect value", result.equals(bNumber));
- }
-
- /**
- * Convert a positive BigDecimal to BigInteger.
- */
- public void testToBigIntegerPos1() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
- BigInteger bNumber = new BigInteger(
- "123809648392384754573567356745735635678902957849027687");
- BigDecimal aNumber = new BigDecimal(a);
- BigInteger result = aNumber.toBigInteger();
- assertTrue("incorrect value", result.equals(bNumber));
- }
-
- /**
- * Convert a positive BigDecimal to BigInteger.
- */
- public void testToBigIntegerPos2() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E+15";
- BigInteger bNumber = new BigInteger(
- "123809648392384754573567356745735635678902957849");
- BigDecimal aNumber = new BigDecimal(a);
- BigInteger result = aNumber.toBigInteger();
- assertTrue("incorrect value", result.equals(bNumber));
- }
-
- /**
- * Convert a positive BigDecimal to BigInteger.
- */
- public void testToBigIntegerPos3() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E+45";
- BigInteger bNumber = new BigInteger(
- "123809648392384754573567356745735635678902957849027687876782870000000000000000");
- BigDecimal aNumber = new BigDecimal(a);
- BigInteger result = aNumber.toBigInteger();
- assertTrue("incorrect value", result.equals(bNumber));
- }
-
- /**
- * Convert a small BigDecimal to BigInteger.
- */
- public void testToBigIntegerZero() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E-500";
- BigInteger bNumber = new BigInteger("0");
- BigDecimal aNumber = new BigDecimal(a);
- BigInteger result = aNumber.toBigInteger();
- assertTrue("incorrect value", result.equals(bNumber));
- }
-
- /**
- * Convert a negative BigDecimal to an engineering string representation.
- */
- public void testToEngineeringStringNeg() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E-501";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "-123.80964839238475457356735674573563567890295784902768787678287E-471";
- assertEquals("incorrect value", result, aNumber.toEngineeringString());
- }
-
- /**
- * Convert a positive BigDecimal to an engineering string representation.
- */
- public void testToEngineeringStringPos() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E-501";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "123.80964839238475457356735674573563567890295784902768787678287E-471";
- assertEquals("incorrect value", result, aNumber.toEngineeringString());
- }
-
- /**
- * Convert a negative BigDecimal to an engineering string representation.
- */
- public void testToEngineeringStringZeroNegExponent() {
- String a = "0.0E-16";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "0.00E-15";
- assertEquals("incorrect value", result, aNumber.toEngineeringString());
- }
-
- /**
- * Convert a negative BigDecimal to an engineering string representation.
- */
- public void testToEngineeringStringZeroPosExponent() {
- String a = "0.0E+16";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "0E+15";
- assertEquals("incorrect value", result, aNumber.toEngineeringString());
- }
-
- /**
- * Convert a negative BigDecimal with a negative exponent to a plain string
- * representation; scale == 0.
- */
- public void testToPlainStringNegNegExp() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E-100";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "-0.000000000000000000000000000000000000000000000000000000000000000000012380964839238475457356735674573563567890295784902768787678287";
- assertTrue("incorrect value", aNumber.toPlainString().equals(result));
- }
-
- /**
- * Convert a negative BigDecimal with a positive exponent to a plain string
- * representation; scale == 0.
- */
- public void testToPlainStringNegPosExp() {
- String a = "-123809648392384754573567356745735.63567890295784902768787678287E100";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "-1238096483923847545735673567457356356789029578490276878767828700000000000000000000000000000000000000000000000000000000000000000000000";
- assertTrue("incorrect value", aNumber.toPlainString().equals(result));
- }
-
- /**
- * Convert a positive BigDecimal with a negative exponent to a plain string
- * representation; scale == 0.
- */
- public void testToPlainStringPosNegExp() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E-100";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "0.000000000000000000000000000000000000000000000000000000000000000000012380964839238475457356735674573563567890295784902768787678287";
- assertTrue("incorrect value", aNumber.toPlainString().equals(result));
- }
-
- /**
- * Convert a negative BigDecimal with a negative exponent to a plain string
- * representation; scale == 0.
- */
- public void testToPlainStringPosPosExp() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E+100";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "1238096483923847545735673567457356356789029578490276878767828700000000000000000000000000000000000000000000000000000000000000000000000";
- assertTrue("incorrect value", aNumber.toPlainString().equals(result));
- }
-
- /**
- * Convert a negative BigDecimal to a string representation.
- */
- public void testToStringNeg() {
- String a = "-123.4564563673567380964839238475457356735674573563567890295784902768787678287E-5";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "-0.001234564563673567380964839238475457356735674573563567890295784902768787678287";
- assertTrue("incorrect value", aNumber.toString().equals(result));
- }
-
- /**
- * Convert a positive BigDecimal to a string representation.
- */
- public void testToStringPos() {
- String a = "123809648392384754573567356745735.63567890295784902768787678287E-500";
- BigDecimal aNumber = new BigDecimal(a);
- String result = "1.2380964839238475457356735674573563567890295784902768787678287E-468";
- assertTrue("incorrect value", aNumber.toString().equals(result));
- }
-
- /**
- * Convert a BigDecimal to a string representation; scale == 0.
- */
- public void testToStringZeroScale() {
- String a = "-123809648392384754573567356745735635678902957849027687876782870";
- BigDecimal aNumber = new BigDecimal(new BigInteger(a));
- String result = "-123809648392384754573567356745735635678902957849027687876782870";
- assertTrue("incorrect value", aNumber.toString().equals(result));
- }
-
- /**
- * valueOf(Double.NaN).
- */
- public void testValueOfDoubleNaN() {
- double a = Double.NaN;
- try {
- BigDecimal.valueOf(a);
- fail("NumberFormatException has not been thrown for Double.NaN");
- } catch (NumberFormatException e) {
- return;
- }
- }
-
- /**
- * Create a BigDecimal from a negative double value.
- */
- public void testValueOfDoubleNeg() {
- double a = -65678765876567576.98788767;
- BigDecimal result = BigDecimal.valueOf(a);
- String res = "-65678765876567576";
- int resScale = 0;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Create a BigDecimal from a positive double value.
- */
- public void testValueOfDoublePos1() {
- double a = 65678765876567576.98788767;
- BigDecimal result = BigDecimal.valueOf(a);
- String res = "65678765876567576";
- int resScale = 0;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Create a BigDecimal from a positive double value.
- */
- public void testValueOfDoublePos2() {
- double a = 12321237576.98788767;
- BigDecimal result = BigDecimal.valueOf(a);
- String res = "12321237576.987888";
- int resScale = 6;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Create a BigDecimal from a positive double value.
- */
- public void testValueOfDoublePos3() {
- double a = 12321237576.9878838;
- BigDecimal result = BigDecimal.valueOf(a);
- String res = "12321237576.987885";
- int resScale = 6;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Create a BigDecimal from a negative long value; scale is negative.
- */
- public void testValueOfNegScaleNeg() {
- long a = -98374823947823578L;
- int scale = -12;
- BigDecimal aNumber = BigDecimal.valueOf(a, scale);
- String result = "-9.8374823947823578E+28";
- assertTrue("incorrect value", aNumber.toString().equals(result));
- }
-
- /**
- * Create a BigDecimal from a negative long value; scale is positive.
- */
- public void testValueOfNegScalePos() {
- long a = -98374823947823578L;
- int scale = 12;
- BigDecimal aNumber = BigDecimal.valueOf(a, scale);
- String result = "-98374.823947823578";
- assertTrue("incorrect value", aNumber.toString().equals(result));
- }
-
- /**
- * Create a BigDecimal from a negative long value; scale is 0.
- */
- public void testValueOfNegZeroScale() {
- long a = -98374823947823578L;
- BigDecimal aNumber = BigDecimal.valueOf(a);
- String result = "-98374823947823578";
- assertTrue("incorrect value", aNumber.toString().equals(result));
- }
-
- /**
- * Create a BigDecimal from a negative long value; scale is negative.
- */
- public void testValueOfPosScaleNeg() {
- long a = 98374823947823578L;
- int scale = -12;
- BigDecimal aNumber = BigDecimal.valueOf(a, scale);
- String result = "9.8374823947823578E+28";
- assertTrue("incorrect value", aNumber.toString().equals(result));
- }
-
- /**
- * Create a BigDecimal from a negative long value; scale is positive.
- */
- public void testValueOfPosScalePos() {
- long a = 98374823947823578L;
- int scale = 12;
- BigDecimal aNumber = BigDecimal.valueOf(a, scale);
- String result = "98374.823947823578";
- assertTrue("incorrect value", aNumber.toString().equals(result));
- }
-
- /**
- * Create a BigDecimal from a positive long value; scale == 0.
- */
- public void testValueOfPosZeroScale() {
- long a = 98374823947823578L;
- BigDecimal aNumber = BigDecimal.valueOf(a);
- String result = "98374823947823578";
- assertTrue("incorrect value", aNumber.toString().equals(result));
- }
-
- /**
- * Create a BigDecimal from a zero value; with a small negative scale.
- */
- public void testValueOfZeroScaleNeg() {
- int scale = -2;
- BigDecimal number = BigDecimal.valueOf(0L, scale);
- assertEquals("incorrect value", "0E+2", number.toString());
- assertEquals("bad scale", scale, number.scale());
- }
-
- /**
- * Create a BigDecimal from a zero value; with a small positive scale.
- */
- public void testValueOfZeroScalePos() {
- int scale = 1;
- BigDecimal number = BigDecimal.valueOf(0L, scale);
- assertEquals("incorrect value", "0.0", number.toString());
- assertEquals("bad scale", scale, number.scale());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigDecimalScaleOperationsTest.java b/user/test/com/google/gwt/emultest/java/math/BigDecimalScaleOperationsTest.java
deleted file mode 100644
index ab9a5c7..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigDecimalScaleOperationsTest.java
+++ /dev/null
@@ -1,377 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.math.RoundingMode;
-
-/**
- * Class: java.math.BigDecimal Methods: movePointLeft, movePointRight, scale,
- * setScale, unscaledValue *
- */
-public class BigDecimalScaleOperationsTest extends EmulTestBase {
-
- public void testScaleByPowerOfTen() {
- BigDecimal val = BigDecimal.ONE.scaleByPowerOfTen(1);
- assertEquals(10, val.intValue());
- }
-
- /**
- * Check the default scale
- */
- public void testScaleDefault() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int cScale = 0;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a));
- assertTrue("incorrect scale", aNumber.scale() == cScale);
- }
-
- /**
- * Check a negative scale
- */
- public void testScaleNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = -10;
- int cScale = -10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- assertTrue("incorrect scale", aNumber.scale() == cScale);
- }
-
- /**
- * Check a positive scale
- */
- public void testScalePos() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 10;
- int cScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- assertTrue("incorrect scale", aNumber.scale() == cScale);
- }
-
- /**
- * Check the zero scale
- */
- public void testScaleZero() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 0;
- int cScale = 0;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- assertTrue("incorrect scale", aNumber.scale() == cScale);
- }
-
- /**
- * Check the unscaled value
- */
- public void testUnscaledValue() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 100;
- BigInteger bNumber = new BigInteger(a);
- BigDecimal aNumber = new BigDecimal(bNumber, aScale);
- assertTrue("incorrect unscaled value", aNumber.unscaledValue().equals(
- bNumber));
- }
-
- /**
- * Set a greater new scale
- */
- public void testSetScaleGreater() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 18;
- int newScale = 28;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.setScale(newScale);
- assertTrue("incorrect scale", bNumber.scale() == newScale);
- assertEquals("incorrect value", 0, bNumber.compareTo(aNumber));
- }
-
- /**
- * Set a less new scale; this.scale == 8; newScale == 5.
- */
- public void testSetScaleLess() {
- String a = "2.345726458768760000E+10";
- int newScale = 5;
- BigDecimal aNumber = new BigDecimal(a);
- BigDecimal bNumber = aNumber.setScale(newScale);
- assertTrue("incorrect scale", bNumber.scale() == newScale);
- assertEquals("incorrect value", 0, bNumber.compareTo(aNumber));
- }
-
- /**
- * Verify an exception when setting a new scale
- */
- public void testSetScaleException() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 28;
- int newScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- try {
- aNumber.setScale(newScale);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "Rounding necessary",
- e.getMessage());
- }
- }
-
- /**
- * Set the same new scale
- */
- public void testSetScaleSame() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 18;
- int newScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.setScale(newScale);
- assertTrue("incorrect scale", bNumber.scale() == newScale);
- assertTrue("incorrect value", bNumber.equals(aNumber));
- }
-
- /**
- * Set a new scale
- */
- public void testSetScaleRoundUp() {
- String a = "1231212478987482988429808779810457634781384756794987";
- String b = "123121247898748298842980877981045763478139";
- int aScale = 28;
- int newScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_UP);
- assertTrue("incorrect scale", bNumber.scale() == newScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
- }
-
- /**
- * Set a new scale
- */
- public void testSetScaleRoundDown() {
- String a = "1231212478987482988429808779810457634781384756794987";
- String b = "123121247898748298842980877981045763478138";
- int aScale = 28;
- int newScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_DOWN);
- assertTrue("incorrect scale", bNumber.scale() == newScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
- }
-
- /**
- * Set a new scale
- */
- public void testSetScaleRoundCeiling() {
- String a = "1231212478987482988429808779810457634781384756794987";
- String b = "123121247898748298842980877981045763478139";
- int aScale = 28;
- int newScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_CEILING);
- assertTrue("incorrect scale", bNumber.scale() == newScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
- }
-
- /**
- * Set a new scale
- */
- public void testSetScaleRoundFloor() {
- String a = "1231212478987482988429808779810457634781384756794987";
- String b = "123121247898748298842980877981045763478138";
- int aScale = 28;
- int newScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_FLOOR);
- assertTrue("incorrect scale", bNumber.scale() == newScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
- }
-
- /**
- * Set a new scale
- */
- public void testSetScaleRoundHalfUp() {
- String a = "1231212478987482988429808779810457634781384756794987";
- String b = "123121247898748298842980877981045763478138";
- int aScale = 28;
- int newScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_HALF_UP);
- assertTrue("incorrect scale", bNumber.scale() == newScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
- }
-
- /**
- * Set a new scale
- */
- public void testSetScaleRoundHalfDown() {
- String a = "1231212478987482988429808779810457634781384756794987";
- String b = "123121247898748298842980877981045763478138";
- int aScale = 28;
- int newScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_HALF_DOWN);
- assertTrue("incorrect scale", bNumber.scale() == newScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
- }
-
- /**
- * Set a new scale
- */
- public void testSetScaleRoundHalfEven() {
- String a = "1231212478987482988429808779810457634781384756794987";
- String b = "123121247898748298842980877981045763478138";
- int aScale = 28;
- int newScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.setScale(newScale, BigDecimal.ROUND_HALF_EVEN);
- assertTrue("incorrect scale", bNumber.scale() == newScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
- }
-
- /**
- * SetScale(int, RoundingMode)
- */
- public void testSetScaleIntRoundingMode() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 28;
- int newScale = 18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal result = aNumber.setScale(newScale, RoundingMode.HALF_EVEN);
- String res = "123121247898748298842980.877981045763478138";
- int resScale = 18;
- assertEquals("incorrect value", res, result.toString());
- assertEquals("incorrect scale", resScale, result.scale());
- }
-
- /**
- * Move the decimal point to the left; the shift value is positive
- */
- public void testMovePointLeftPos() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 28;
- int shift = 18;
- int resScale = 46;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.movePointLeft(shift);
- assertTrue("incorrect scale", bNumber.scale() == resScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(a));
- }
-
- /**
- * Move the decimal point to the left; the shift value is positive
- */
- public void testMovePointLeftNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 28;
- int shift = -18;
- int resScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.movePointLeft(shift);
- assertTrue("incorrect scale", bNumber.scale() == resScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(a));
- }
-
- /**
- * Move the decimal point to the right; the shift value is positive
- */
- public void testMovePointRightPosGreater() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 28;
- int shift = 18;
- int resScale = 10;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.movePointRight(shift);
- assertTrue("incorrect scale", bNumber.scale() == resScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(a));
- }
-
- /**
- * Move the decimal point to the right; the shift value is positive
- */
- public void testMovePointRightPosLess() {
- String a = "1231212478987482988429808779810457634781384756794987";
- String b = "123121247898748298842980877981045763478138475679498700";
- int aScale = 28;
- int shift = 30;
- int resScale = 0;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.movePointRight(shift);
- assertTrue("incorrect scale", bNumber.scale() == resScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(b));
- }
-
- /**
- * Move the decimal point to the right; the shift value is positive
- */
- public void testMovePointRightNeg() {
- String a = "1231212478987482988429808779810457634781384756794987";
- int aScale = 28;
- int shift = -18;
- int resScale = 46;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- BigDecimal bNumber = aNumber.movePointRight(shift);
- assertTrue("incorrect scale", bNumber.scale() == resScale);
- assertTrue("incorrect value", bNumber.unscaledValue().toString().equals(a));
- }
-
- /**
- * Move the decimal point to the right when the scale overflows
- */
- public void testMovePointRightException() {
- String a = "12312124789874829887348723648726347429808779810457634781384756794987";
- int aScale = Integer.MAX_VALUE; // 2147483647
- int shift = -18;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- try {
- aNumber.movePointRight(shift);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "Underflow", e.getMessage());
- }
- }
-
- /**
- * precision()
- */
- public void testPrecision() {
- String a = "12312124789874829887348723648726347429808779810457634781384756794987";
- int aScale = 14;
- BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
- int prec = aNumber.precision();
- assertEquals(68, prec);
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerAddTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerAddTest.java
deleted file mode 100644
index aa125d1..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerAddTest.java
+++ /dev/null
@@ -1,503 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Method: add
- */
-public class BigIntegerAddTest extends EmulTestBase {
-
- /**
- * Add two positive numbers of the same length
- */
- public void testCase1() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {11, 22, 33, 44, 55, 66, 77, 11, 22, 33};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add two negative numbers of the same length
- */
- public void testCase2() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-12, -23, -34, -45, -56, -67, -78, -12, -23, -33};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Add two numbers of the same length. The first one is positive and the
- * second is negative. The first one is greater in absolute value.
- */
- public void testCase3() {
- byte aBytes[] = {3, 4, 5, 6, 7, 8, 9};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {2, 2, 2, 2, 2, 2, 2};
- int aSign = 1;
- int bSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add two numbers of the same length. The first one is negative and the
- * second is positive. The first one is greater in absolute value.
- */
- public void testCase4() {
- byte aBytes[] = {3, 4, 5, 6, 7, 8, 9};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {-3, -3, -3, -3, -3, -3, -2};
- int aSign = -1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Add two numbers of the same length. The first is positive and the second is
- * negative. The first is less in absolute value.
- */
- public void testCase5() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {3, 4, 5, 6, 7, 8, 9};
- byte rBytes[] = {-3, -3, -3, -3, -3, -3, -2};
- int aSign = 1;
- int bSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Add two numbers of the same length. The first one is negative and the
- * second is positive. The first one is less in absolute value.
- */
- public void testCase6() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {3, 4, 5, 6, 7, 8, 9};
- byte rBytes[] = {2, 2, 2, 2, 2, 2, 2};
- int aSign = -1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add two positive numbers of different length. The first is longer.
- */
- public void testCase7() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add two positive numbers of different length. The second is longer.
- */
- public void testCase8() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
- BigInteger aNumber = new BigInteger(aBytes);
- BigInteger bNumber = new BigInteger(bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add two negative numbers of different length. The first is longer.
- */
- public void testCase9() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {
- -2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Add two negative numbers of different length. The second is longer.
- */
- public void testCase10() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {
- -2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Add two numbers of different length and sign. The first is positive. The
- * first is longer.
- */
- public void testCase11() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add two numbers of different length and sign. The first is positive. The
- * second is longer.
- */
- public void testCase12() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Add two numbers of different length and sign. The first is negative. The
- * first is longer.
- */
- public void testCase13() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Add two numbers of different length and sign. The first is negative. The
- * second is longer.
- */
- public void testCase14() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add two equal numbers of different signs
- */
- public void testCase15() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {0};
- int aSign = -1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Add zero to a number
- */
- public void testCase16() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {0};
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add a number to zero
- */
- public void testCase17() {
- byte aBytes[] = {0};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add zero to zero
- */
- public void testCase18() {
- byte aBytes[] = {0};
- byte bBytes[] = {0};
- byte rBytes[] = {0};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Add ZERO to a number
- */
- public void testCase19() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ZERO;
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add a number to zero
- */
- public void testCase20() {
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int bSign = 1;
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add ZERO to ZERO
- */
- public void testCase21() {
- byte rBytes[] = {0};
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = BigInteger.ZERO;
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Add ONE to ONE
- */
- public void testCase22() {
- byte rBytes[] = {2};
- BigInteger aNumber = BigInteger.ONE;
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Add two numbers so that carry is 1
- */
- public void testCase23() {
- byte aBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
- byte bBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {1, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -2};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.add(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerAndTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerAndTest.java
deleted file mode 100644
index d1db148..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerAndTest.java
+++ /dev/null
@@ -1,475 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Method: and
- */
-public class BigIntegerAndTest extends EmulTestBase {
-
- /**
- * And for two negative numbers; the first is longer
- */
- public void testNegNegFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {
- -1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88,
- -88, 16, 73};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * And for two negative numbers; the first is shorter
- */
- public void testNegNegFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {
- -1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88,
- -88, 16, 73};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * And for two negative numbers of the same length
- */
- public void testNegNegSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {
- -1, 1, 2, 3, 3, 0, 65, -96, -48, -124, -60, 12, -40, -31, 97};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * And for a negative number and zero
- */
- public void testNegPos() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {0};
- int aSign = -1;
- int bSign = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * And for a negative and a positive numbers; the first is longer
- */
- public void testNegPosFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 3};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for a negative and a positive numbers; the first is shorter
- */
- public void testNegPosFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {
- 0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31,
- -95};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for two numbers of different signs and the same length
- */
- public void testNegPosSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {0, -2, 125, -60, -104, 1, 10, 6, 2, 32, 56, 2, 4, 4, 21};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for one and one
- */
- public void testOneOne() {
- BigInteger aNumber = BigInteger.ONE;
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.and(bNumber);
- assertTrue(result.equals(BigInteger.ONE));
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for a positive and a negative numbers; the first is longer
- */
- public void testPosNegFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {
- 0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31,
- -95};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for a positive and a negative numbers; the first is shorter
- */
- public void testPosNegFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 3};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for two numbers of different signs and the same length
- */
- public void testPosNegSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {0, -6, -80, 72, 8, 75, 2, -79, 34, 16, -119};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for two positive numbers; the first is longer
- */
- public void testPosPosFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {0, -2, -76, 88, 44, 1, 2, 17, 35, 16, 9, 2, 5, 6, 21};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for two positive numbers; the first is shorter
- */
- public void testPosPosFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {0, -2, -76, 88, 44, 1, 2, 17, 35, 16, 9, 2, 5, 6, 21};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for two positive numbers of the same length
- */
- public void testPosPosSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {0, -128, 56, 100, 4, 4, 17, 37, 16, 1, 64, 1, 10, 3};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for a positive number and zero
- */
- public void testPosZero() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {0};
- int aSign = 1;
- int bSign = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Test for a special case
- */
- public void testSpecialCase1() {
- byte aBytes[] = {-1, -1, -1, -1};
- byte bBytes[] = {5, -4, -3, -2};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-1, 0, 0, 0, 0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Test for a special case
- */
- public void testSpecialCase2() {
- byte aBytes[] = {-51};
- byte bBytes[] = {-52, -51, -50, -49, -48};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {0, -52, -51, -50, -49, 16};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * And for zero and a negative number
- */
- public void testZeroNeg() {
- byte aBytes[] = {0};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 0;
- int bSign = -1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * And for zero and one
- */
- public void testZeroOne() {
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.and(bNumber);
- assertTrue(result.equals(BigInteger.ZERO));
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * And for zero and a positive number
- */
- public void testZeroPos() {
- byte aBytes[] = {0};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 0;
- int bSign = 1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * And for zero and zero
- */
- public void testZeroZero() {
- byte aBytes[] = {0};
- byte bBytes[] = {0};
- int aSign = 0;
- int bSign = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.and(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerCompareTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerCompareTest.java
deleted file mode 100644
index 8b56def..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerCompareTest.java
+++ /dev/null
@@ -1,530 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Methods: abs, compareTo, equals, max, min,
- * negate, signum
- */
-public class BigIntegerCompareTest extends EmulTestBase {
- /**
- * abs() for a negative number
- */
- public void testAbsNegative() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int aSign = -1;
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.abs();
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * abs() for a positive number
- */
- public void testAbsPositive() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.abs();
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * compareTo(BigInteger a). Compare two negative numbers. The first is less in
- * absolute value.
- */
- public void testCompareNegNeg2() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = -1;
- int bSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- assertEquals(1, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare two numbers of different signs. The first
- * is positive.
- */
- public void testCompareToDiffSigns1() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- assertEquals(1, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare two numbers of different signs. The first
- * is negative.
- */
- public void testCompareToDiffSigns2() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- assertEquals(-1, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare two equal negative numbers.
- */
- public void testCompareToEqualNeg() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = -1;
- int bSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- assertEquals(0, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare two equal positive numbers.
- */
- public void testCompareToEqualPos() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- assertEquals(0, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare two negative numbers. The first is greater
- * in absolute value.
- */
- public void testCompareToNegNeg1() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- assertEquals(-1, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare a negative number to ZERO.
- */
- public void testCompareToNegZero() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ZERO;
- assertEquals(-1, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare two positive numbers. The first is
- * greater.
- */
- public void testCompareToPosPos1() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- assertEquals(1, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare two positive numbers. The first is less.
- */
- public void testCompareToPosPos2() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- assertEquals(-1, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare a positive number to ZERO.
- */
- public void testCompareToPosZero() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ZERO;
- assertEquals(1, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare ZERO to a negative number.
- */
- public void testCompareToZeroNeg() {
- byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int bSign = -1;
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- assertEquals(1, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare ZERO to a positive number.
- */
- public void testCompareToZeroPos() {
- byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int bSign = 1;
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- assertEquals(-1, aNumber.compareTo(bNumber));
- }
-
- /**
- * compareTo(BigInteger a). Compare ZERO to ZERO.
- */
- public void testCompareToZeroZero() {
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = BigInteger.ZERO;
- assertEquals(0, aNumber.compareTo(bNumber));
- }
-
- /**
- * equals(Object obj). obj is a BigInteger. numbers are not equal.
- */
- public void testEqualsBigIntegerFalse() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- Object bNumber = new BigInteger(bSign, bBytes);
- assertFalse(aNumber.equals(bNumber));
- }
-
- /**
- * equals(Object obj). obj is a BigInteger. numbers are equal.
- */
- public void testEqualsBigIntegerTrue() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- Object bNumber = new BigInteger(bSign, bBytes);
- assertTrue(aNumber.equals(bNumber));
- }
-
- /**
- * equals(null).
- */
- public void testEqualsNull() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertFalse(aNumber.equals(null));
- }
-
- /**
- * equals(Object obj). obj is not a BigInteger
- */
- public void testEqualsObject() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- Object obj = new Object();
- assertFalse(aNumber.equals(obj));
- }
-
- /**
- * max(BigInteger val). numbers are equal.
- */
- public void testMaxEqual() {
- byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.max(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * max(BigInteger val). the first is greater.
- */
- public void testMaxGreater() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.max(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- result = bNumber.max(aNumber);
- assertEquals(aNumber, result);
- }
-
- /**
- * max(BigInteger val). the first is less.
- */
- public void testMaxLess() {
- byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.max(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * max(BigInteger val). max of negative and ZERO.
- */
- public void testMaxNegZero() {
- byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = -1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ZERO;
- BigInteger result = aNumber.max(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * min(BigInteger val). numbers are equal.
- */
- public void testMinEqual() {
- byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.min(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * min(BigInteger val). the first is greater.
- */
- public void testMinGreater() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.min(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * min(BigInteger val). the first is less.
- */
- public void testMinLess() {
- byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- byte bBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.min(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * max(BigInteger val). min of positive and ZERO.
- */
- public void testMinPosZero() {
- byte aBytes[] = {45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ZERO;
- BigInteger result = aNumber.min(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == 0);
- }
-
- /**
- * negate() a negative number.
- */
- public void testNegateNegative() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = -1;
- byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.negate();
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- } for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
-
- assertTrue("incorrect sign", result.signum() == 1);
- }
-
- /**
- * negate() a positive number.
- */
- public void testNegatePositive() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- byte rBytes[] = {
- -13, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -27, -4, -91};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.negate();
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertTrue("incorrect sign", result.signum() == -1);
- }
-
- /**
- * negate() ZERO.
- */
- public void testNegateZero() {
- byte rBytes[] = {0};
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger result = aNumber.negate();
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * signum() of a negative number.
- */
- public void testSignumNegative() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * signum() of a positive number.
- */
- public void testSignumPositive() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * signum() of ZERO.
- */
- public void testSignumZero() {
- BigInteger aNumber = BigInteger.ZERO;
- assertEquals("incorrect sign", 0, aNumber.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerConstructorsTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerConstructorsTest.java
deleted file mode 100644
index 6024e6f..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerConstructorsTest.java
+++ /dev/null
@@ -1,779 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-import java.util.Random;
-
-/**
- * Class: java.math.BigInteger Constructors: BigInteger(byte[] a),
- * BigInteger(int sign, byte[] a), BigInteger(String val, int radix)
- */
-public class BigIntegerConstructorsTest extends EmulTestBase {
- /**
- * Create a number from an array of bytes. Verify an exception thrown if an
- * array is zero bytes long
- */
- public void testConstructorBytesException() {
- byte aBytes[] = {};
- try {
- new BigInteger(aBytes);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- assertEquals("Improper exception message", "Zero length BigInteger",
- e.getMessage());
- }
- }
-
- /**
- * Create a negative number from an array of bytes. The number fits in an
- * array of integers.
- */
- public void testConstructorBytesNegative1() {
- byte aBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte rBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- BigInteger aNumber = new BigInteger(aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a negative number from an array of bytes. The number fits in an
- * integer.
- */
- public void testConstructorBytesNegative2() {
- byte aBytes[] = {-12, 56, 100};
- byte rBytes[] = {-12, 56, 100};
- BigInteger aNumber = new BigInteger(aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a negative number from an array of bytes. The number of bytes is 4.
- */
- public void testConstructorBytesNegative3() {
- byte aBytes[] = {-128, -12, 56, 100};
- byte rBytes[] = {-128, -12, 56, 100};
- BigInteger aNumber = new BigInteger(aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a negative number from an array of bytes. The number of bytes is
- * multiple of 4.
- */
- public void testConstructorBytesNegative4() {
- byte aBytes[] = {-128, -12, 56, 100, -13, 56, 93, -78};
- byte rBytes[] = {-128, -12, 56, 100, -13, 56, 93, -78};
- BigInteger aNumber = new BigInteger(aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a positive number from an array of bytes. The number of bytes is
- * multiple of 4.
- */
- public void testConstructorBytesPositive() {
- byte aBytes[] = {127, 56, 100, -1, 14, 75, -24, -100};
- byte rBytes[] = {127, 56, 100, -1, 14, 75, -24, -100};
- BigInteger aNumber = new BigInteger(aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from an array of bytes. The number fits in an
- * array of integers.
- */
- public void testConstructorBytesPositive1() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- BigInteger aNumber = new BigInteger(aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from an array of bytes. The number fits in an
- * integer.
- */
- public void testConstructorBytesPositive2() {
- byte aBytes[] = {12, 56, 100};
- byte rBytes[] = {12, 56, 100};
- BigInteger aNumber = new BigInteger(aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from an array of bytes. The number of bytes is 4.
- */
- public void testConstructorBytesPositive3() {
- byte aBytes[] = {127, 56, 100, -1};
- byte rBytes[] = {127, 56, 100, -1};
- BigInteger aNumber = new BigInteger(aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a zero number from an array of zero bytes.
- */
- public void testConstructorBytesZero() {
- byte aBytes[] = {0, 0, 0, -0, +0, 0, -0};
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, aNumber.signum());
- }
-
- /**
- * Create a prime number of 25 bits length.
- */
- public void testConstructorPrime() {
- int bitLen = 25;
- Random rnd = new Random();
- BigInteger aNumber = new BigInteger(bitLen, 80, rnd);
- assertTrue("incorrect bitLength", aNumber.bitLength() == bitLen);
- }
-
- /**
- * Create a prime number of 2 bits length.
- */
- public void testConstructorPrime2() {
- int bitLen = 2;
- Random rnd = new Random();
- BigInteger aNumber = new BigInteger(bitLen, 80, rnd);
- assertTrue("incorrect bitLength", aNumber.bitLength() == bitLen);
- int num = aNumber.intValue();
- assertTrue("incorrect value", num == 2 || num == 3);
- }
-
- /**
- * Create a random number of 75 bits length.
- */
- public void testConstructorRandom() {
- int bitLen = 75;
- Random rnd = new Random();
- BigInteger aNumber = new BigInteger(bitLen, rnd);
- assertTrue("incorrect bitLength", aNumber.bitLength() <= bitLen);
- }
-
- /**
- * Create a number from a sign and an array of bytes. Verify an exception
- * thrown if a sign has improper value.
- */
- public void testConstructorSignBytesException1() {
- byte aBytes[] = {123, 45, -3, -76};
- int aSign = 3;
- try {
- new BigInteger(aSign, aBytes);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- assertEquals("Improper exception message", "Invalid signum value",
- e.getMessage());
- }
- }
-
- /**
- * Create a number from a sign and an array of bytes. Verify an exception
- * thrown if the array contains non-zero bytes while the sign is 0.
- */
- public void testConstructorSignBytesException2() {
- byte aBytes[] = {123, 45, -3, -76};
- int aSign = 0;
- try {
- new BigInteger(aSign, aBytes);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- assertEquals("Improper exception message", "signum-magnitude mismatch",
- e.getMessage());
- }
- }
-
- /**
- * Create a negative number from a sign and an array of bytes. The number fits
- * in an array of integers. The most significant byte is positive.
- */
- public void testConstructorSignBytesNegative1() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
- int aSign = -1;
- byte rBytes[] = {-13, -57, -101, 1, 75, -90, -46, -92, -4, 15};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a negative number from a sign and an array of bytes. The number fits
- * in an array of integers. The most significant byte is negative.
- */
- public void testConstructorSignBytesNegative2() {
- byte aBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
- int aSign = -1;
- byte rBytes[] = {-1, 11, -57, -101, 1, 75, -90, -46, -92, -4, 15};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a negative number from a sign and an array of bytes. The number fits
- * in an integer.
- */
- public void testConstructorSignBytesNegative3() {
- byte aBytes[] = {-12, 56, 100};
- int aSign = -1;
- byte rBytes[] = {-1, 11, -57, -100};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a negative number from a sign and an array of bytes. The number of
- * bytes is 4. The most significant byte is positive.
- */
- public void testConstructorSignBytesNegative4() {
- byte aBytes[] = {127, 56, 100, -2};
- int aSign = -1;
- byte rBytes[] = {-128, -57, -101, 2};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a negative number from a sign and an array of bytes. The number of
- * bytes is 4. The most significant byte is negative.
- */
- public void testConstructorSignBytesNegative5() {
- byte aBytes[] = {-127, 56, 100, -2};
- int aSign = -1;
- byte rBytes[] = {-1, 126, -57, -101, 2};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a negative number from a sign and an array of bytes. The number of
- * bytes is multiple of 4. The most significant byte is positive.
- */
- public void testConstructorSignBytesNegative6() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
- int aSign = -1;
- byte rBytes[] = {-13, -57, -101, 1, 75, -90, -46, -92, -4, 14, -24, 101};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a negative number from a sign and an array of bytes. The number of
- * bytes is multiple of 4. The most significant byte is negative.
- */
- public void testConstructorSignBytesNegative7() {
- byte aBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
- int aSign = -1;
- byte rBytes[] = {-1, 11, -57, -101, 1, 75, -90, -46, -92, -4, 14, -24, 101};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a positive number from a sign and an array of bytes. The number fits
- * in an array of integers. The most significant byte is positive.
- */
- public void testConstructorSignBytesPositive1() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
- int aSign = 1;
- byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from a sign and an array of bytes. The number fits
- * in an array of integers. The most significant byte is negative.
- */
- public void testConstructorSignBytesPositive2() {
- byte aBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
- int aSign = 1;
- byte rBytes[] = {0, -12, 56, 100, -2, -76, 89, 45, 91, 3, -15};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from a sign and an array of bytes. The number fits
- * in an integer.
- */
- public void testConstructorSignBytesPositive3() {
- byte aBytes[] = {-12, 56, 100};
- int aSign = 1;
- byte rBytes[] = {0, -12, 56, 100};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from a sign and an array of bytes. The number of
- * bytes is 4. The most significant byte is positive.
- */
- public void testConstructorSignBytesPositive4() {
- byte aBytes[] = {127, 56, 100, -2};
- int aSign = 1;
- byte rBytes[] = {127, 56, 100, -2};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from a sign and an array of bytes. The number of
- * bytes is 4. The most significant byte is negative.
- */
- public void testConstructorSignBytesPositive5() {
- byte aBytes[] = {-127, 56, 100, -2};
- int aSign = 1;
- byte rBytes[] = {0, -127, 56, 100, -2};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from a sign and an array of bytes. The number of
- * bytes is multiple of 4. The most significant byte is positive.
- */
- public void testConstructorSignBytesPositive6() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
- int aSign = 1;
- byte rBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from a sign and an array of bytes. The number of
- * bytes is multiple of 4. The most significant byte is negative.
- */
- public void testConstructorSignBytesPositive7() {
- byte aBytes[] = {-12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
- int aSign = 1;
- byte rBytes[] = {0, -12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 23, -101};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a zero number from a sign and an array of zero bytes. The sign is
- * -1.
- */
- public void testConstructorSignBytesZero1() {
- byte aBytes[] = {-0, 0, +0, 0, 0, 00, 000};
- int aSign = -1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, aNumber.signum());
- }
-
- /**
- * Create a zero number from a sign and an array of zero bytes. The sign is 0.
- */
- public void testConstructorSignBytesZero2() {
- byte aBytes[] = {-0, 0, +0, 0, 0, 00, 000};
- int aSign = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, aNumber.signum());
- }
-
- /**
- * Create a zero number from a sign and an array of zero bytes. The sign is 1.
- */
- public void testConstructorSignBytesZero3() {
- byte aBytes[] = {-0, 0, +0, 0, 0, 00, 000};
- int aSign = 1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, aNumber.signum());
- }
-
- /**
- * Create a zero number from a sign and an array of zero length. The sign is
- * -1.
- */
- public void testConstructorSignBytesZeroNull1() {
- byte aBytes[] = {};
- int aSign = -1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, aNumber.signum());
- }
-
- /**
- * Create a zero number from a sign and an array of zero length. The sign is
- * 0.
- */
- public void testConstructorSignBytesZeroNull2() {
- byte aBytes[] = {};
- int aSign = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, aNumber.signum());
- }
-
- /**
- * Create a zero number from a sign and an array of zero length. The sign is
- * 1.
- */
- public void testConstructorSignBytesZeroNull3() {
- byte aBytes[] = {};
- int aSign = 1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, aNumber.signum());
- }
-
- /**
- * Create a number from a string value and radix. Verify an exception thrown
- * if a radix is out of range
- */
- public void testConstructorStringException1() {
- String value = "9234853876401";
- int radix = 45;
- try {
- new BigInteger(value, radix);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- assertEquals("Improper exception message", "Radix out of range",
- e.getMessage());
- }
- }
-
- /**
- * Create a number from a string value and radix. Verify an exception thrown
- * if the string starts with a space.
- */
- public void testConstructorStringException2() {
- String value = " 9234853876401";
- int radix = 10;
- try {
- new BigInteger(value, radix);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * Create a number from a string value and radix. Verify an exception thrown
- * if the string contains improper characters.
- */
- public void testConstructorStringException3() {
- String value = "92348$*#78987";
- int radix = 34;
- try {
- new BigInteger(value, radix);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * Create a number from a string value and radix. Verify an exception thrown
- * if some digits are greater than radix.
- */
- public void testConstructorStringException4() {
- String value = "98zv765hdsaiy";
- int radix = 20;
- try {
- new BigInteger(value, radix);
- fail("NumberFormatException has not been caught");
- } catch (NumberFormatException e) {
- }
- }
-
- /**
- * Create a positive number from a string value and radix 10.
- */
- public void testConstructorStringRadix10() {
- String value = "987328901348934898";
- int radix = 10;
- byte rBytes[] = {13, -77, -78, 103, -103, 97, 68, -14};
- BigInteger aNumber = new BigInteger(value, radix);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a negative number from a string value and radix 10.
- */
- public void testConstructorStringRadix10Negative() {
- String value = "-234871376037";
- int radix = 36;
- byte rBytes[] = {-4, 48, 71, 62, -76, 93, -105, 13};
- BigInteger aNumber = new BigInteger(value, radix);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * Create a zero number from a string value and radix 36.
- */
- public void testConstructorStringRadix10Zero() {
- String value = "-00000000000000";
- int radix = 10;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(value, radix);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, aNumber.signum());
- }
-
- /**
- * Create a positive number from a string value and radix 16.
- */
- public void testConstructorStringRadix16() {
- String value = "fe2340a8b5ce790";
- int radix = 16;
- byte rBytes[] = {15, -30, 52, 10, -117, 92, -25, -112};
- BigInteger aNumber = new BigInteger(value, radix);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from a string value and radix 2.
- */
- public void testConstructorStringRadix2() {
- String value = "10101010101010101";
- int radix = 2;
- byte rBytes[] = {1, 85, 85};
- BigInteger aNumber = new BigInteger(value, radix);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from a string value and radix 36.
- */
- public void testConstructorStringRadix36() {
- String value = "skdjgocvhdjfkl20jndjkf347ejg457";
- int radix = 36;
- byte rBytes[] = {
- 0, -12, -116, 112, -105, 12, -36, 66, 108, 66, -20, -37, -15, 108, -7,
- 52, -99, -109, -8, -45, -5};
- BigInteger aNumber = new BigInteger(value, radix);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * Create a positive number from a string value and radix 8.
- */
- public void testConstructorStringRadix8() {
- String value = "76356237071623450";
- int radix = 8;
- byte rBytes[] = {7, -50, -28, -8, -25, 39, 40};
- BigInteger aNumber = new BigInteger(value, radix);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerConvertTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerConvertTest.java
deleted file mode 100644
index df634f5..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerConvertTest.java
+++ /dev/null
@@ -1,811 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Methods: intValue, longValue, toByteArray(),
- * valueOf(long val), floatValue(), doubleValue()
- */
-public class BigIntegerConvertTest extends EmulTestBase {
- /**
- * Convert a negative number to a double value. The number's bit length is
- * less than 64 bits.
- */
- public void testDoubleValueNegative1() {
- String a = "-27467238945";
- double result = -2.7467238945E10;
- double aNumber = new BigInteger(a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a negative number to a double value. The number's bit length is
- * inside [63, 1024].
- */
- public void testDoubleValueNegative2() {
- String a = "-2746723894572364578265426346273456972";
- double result = -2.7467238945723645E36;
- double aNumber = new BigInteger(a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a negative number to a double value. The number's bit length is
- * greater than 1024.
- */
- public void testDoubleValueNegativeInfinity1() {
- String a = "-2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863";
- double aNumber = new BigInteger(a).doubleValue();
- assertTrue(aNumber == Double.NEGATIVE_INFINITY);
- }
-
- /**
- * Convert a negative number to a double value. The exponent is 1023 and the
- * mantissa is all 0s. The rounding bit is 0. The result is
- * Double.NEGATIVE_INFINITY.
- */
- public void testDoubleValueNegativeInfinity2() {
- byte[] a = {
- -1, -1, -1, -1, -1, -1, -1, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = -1;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == Double.NEGATIVE_INFINITY);
- }
-
- /**
- * Convert a positive number to a double value. The exponent is 1023 and the
- * mantissa is all 0s but the 54th bit (implicit) is 1.
- */
- public void testDoubleValueNegMantissaIsZero() {
- byte[] a = {
- -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = -1;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == -8.98846567431158E307);
- }
-
- /**
- * Convert a negative number to a double value. The exponent is 1023 and the
- * mantissa is all 1s. The result is -Double.MAX_VALUE.
- */
- public void testDoubleValueNegMaxValue() {
- byte[] a = {
- 0, -1, -1, -1, -1, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1};
- int aSign = -1;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == -Double.MAX_VALUE);
- }
-
- /**
- * Convert a positive number to a double value. Rounding is NOT needed.
- */
- public void testDoubleValueNegNotRounded() {
- byte[] a = {-128, 1, 2, 3, 4, 5, -128, 23, 1, -3, -5};
- int aSign = -1;
- double result = -1.5474726438794828E26;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a positive number to a double value. Rounding is needed.
- */
- public void testDoubleValueNegRounded1() {
- byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5};
- int aSign = -1;
- double result = -1.54747264387948E26;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a positive number to a double value. Rounding is needed. The
- * rounding bit is 1 and the next bit to the left is 0 but some of dropped
- * bits are 1s.
- */
- public void testDoubleValueNegRounded2() {
- byte[] a = {-128, 1, 2, 3, 4, 5, 36, 23, 1, -3, -5};
- int aSign = -1;
- double result = -1.547472643879479E26;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a positive number to a double value. The number's length is less
- * than 64 bits.
- */
- public void testDoubleValuePositive1() {
- String a = "27467238945";
- double result = 2.7467238945E10;
- double aNumber = new BigInteger(a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a positive number to a double value. The number's bit length is
- * inside [63, 1024].
- */
- public void testDoubleValuePositive2() {
- String a = "2746723894572364578265426346273456972";
- double result = 2.7467238945723645E36;
- double aNumber = new BigInteger(a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a positive number to a double value. The exponent is 1023 and the
- * mantissa is all 1s. The rounding bit is 1. The result is
- * Double.POSITIVE_INFINITY.
- */
- public void testDoubleValuePositiveInfinity1() {
- byte[] a = {
- -1, -1, -1, -1, -1, -1, -1, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = 1;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == Double.POSITIVE_INFINITY);
- }
-
- /**
- * Convert a positive number to a double value. The number's bit length is
- * greater than 1024.
- */
- public void testDoubleValuePositiveInfinity2() {
- String a = "2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863";
- double aNumber = new BigInteger(a).doubleValue();
- assertTrue(aNumber == Double.POSITIVE_INFINITY);
- }
-
- /**
- * Convert a positive number to a double value. The exponent is 1023 and the
- * mantissa is all 0s but the 54th bit (implicit) is 1.
- */
- public void testDoubleValuePosMantissaIsZero() {
- byte[] a = {
- -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = 1;
- double result = 8.98846567431158E307;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a positive number to a double value. The exponent is 1023 and the
- * mantissa is all 1s. The rounding bit is 0. The result is Double.MAX_VALUE.
- */
- public void testDoubleValuePosMaxValue() {
- byte[] a = {
- 0, -1, -1, -1, -1, -1, -1, -8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1};
- int aSign = 1;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == Double.MAX_VALUE);
- }
-
- /**
- * Convert a positive number to a double value. Rounding is NOT needed.
- */
- public void testDoubleValuePosNotRounded() {
- byte[] a = {-128, 1, 2, 3, 4, 5, -128, 23, 1, -3, -5};
- int aSign = 1;
- double result = 1.5474726438794828E26;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a positive number to a double value. Rounding is needed. The
- * rounding bit is 1 and the next bit to the left is 1.
- */
- public void testDoubleValuePosRounded1() {
- byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5};
- int aSign = 1;
- double result = 1.54747264387948E26;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a positive number to a double value. Rounding is needed. The
- * rounding bit is 1 and the next bit to the left is 0 but some of dropped
- * bits are 1s.
- */
- public void testDoubleValuePosRounded2() {
- byte[] a = {-128, 1, 2, 3, 4, 5, 36, 23, 1, -3, -5};
- int aSign = 1;
- double result = 1.547472643879479E26;
- double aNumber = new BigInteger(aSign, a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Return the double value of ZERO.
- */
- public void testDoubleValueZero() {
- String a = "0";
- double result = 0.0;
- double aNumber = new BigInteger(a).doubleValue();
- assertTrue(aNumber == result);
- }
-
- /**
- * Convert a negative number to a float value. The number's bit length is less
- * than 32 bits.
- */
- public void testFloatValueBug2482() {
- String a = "2147483649";
- float result = 2.14748365E9f;
- float aNumber = new BigInteger(a).floatValue();
- assertEquals("incorrect value", aNumber, result, 1);
- }
-
- /**
- * Convert a negative number to a float value. The value is near
- * Float.MAX_VALUE, but since all calculation in JS is done in double
- * precision, it can't be completely accurate about passing that value
- * through.
- */
- public void testFloatValueNearNegMaxValue() {
- byte[] a = {
- 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = -1;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(-3.4028235e38, aNumber, 1e31);
- }
-
- /**
- * Convert a positive number to a float value. The value is near
- * Float.MAX_VALUE, but since all calculation in JS is done in double
- * precision, it can't be completely accurate about passing that value
- * through.
- */
- public void testFloatValueNearPosMaxValue() {
- byte[] a = {
- 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = 1;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(3.4028235e38, aNumber, 1e31);
- }
-
- /**
- * Convert a negative number to a float value. The number's bit length is less
- * than 32 bits.
- */
- public void testFloatValueNegative1() {
- String a = "-27467238";
- float result = -2.7467238E7f;
- float aNumber = new BigInteger(a).floatValue();
- assertEquals("incorrect value", result, aNumber, 1);
- }
-
- /**
- * Convert a negative number to a double value. The number's bit length
- * is inside [63, 1024].
- */
- public void testFloatValueNegative2() {
- String a = "-27467238945723645782";
- float result = -2.7467239E19f;
- float aNumber = new BigInteger(a).floatValue();
- assertEquals("incorrect value", result, aNumber, 1e12);
- }
-
- /**
- * Convert a negative number to a float value. The number's bit length is
- * greater than 127.
- */
- public void testFloatValueNegativeInfinity1() {
- String a = "-2746723894572364578265426346273456972283746872364768676747462342342342342342342342323423423423423423426767456345745293762384756238475634563456845634568934568347586346578648576478568456457634875673845678456786587345873645767456834756745763457863485768475678465783456702897830296720476846578634576384567845678346573465786457863";
- float aNumber = new BigInteger(a).floatValue();
- assertEquals("incorrect value", Float.NEGATIVE_INFINITY, aNumber);
- }
-
- /**
- * Convert a negative number to a float value. The exponent is 1023 and the
- * mantissa is all 0s. The rounding bit is 0. The result is
- * Float.NEGATIVE_INFINITY.
- */
- public void testFloatValueNegativeInfinity2() {
- byte[] a = {
- 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
- int aSign = -1;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(Float.NEGATIVE_INFINITY, aNumber);
- }
-
- /**
- * Convert a positive number to a double value. The exponent is 1023 and the
- * mantissa is all 0s but the 54th bit (implicit) is 1.
- */
- public void testFloatValueNegMantissaIsZero() {
- byte[] a = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = -1;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(Float.NEGATIVE_INFINITY, aNumber);
- }
-
- /**
- * Convert a positive number to a float value. Rounding is NOT needed.
- */
- public void testFloatValueNegNotRounded() {
- byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5};
- int aSign = -1;
- float result = -1.5474726E26f;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(result, aNumber, 1e19);
- }
-
- /**
- * Convert a positive number to a float value. Rounding is needed.
- */
- public void testFloatValueNegRounded1() {
- byte[] a = {-128, 1, -1, -4, 4, 5, 60, 23, 1, -3, -5};
- int aSign = -1;
- float result = -1.5475195E26f;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(result, aNumber, 1e19);
- }
-
- /**
- * Convert a positive number to a float value. Rounding is needed. The
- * rounding bit is 1 and the next bit to the left is 0 but some of dropped
- * bits are 1s.
- */
- public void testFloatValueNegRounded2() {
- byte[] a = {-128, 1, 2, -128, 4, 5, 60, 23, 1, -3, -5};
- int aSign = -1;
- float result = -1.5474728E26f;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(result, aNumber, 1e19);
- }
-
- /**
- * Convert a negative number beyond Float.MAX_VALUE, ensuring that it is
- * converted to Float.NEGATIVE_INFINITY.
- */
- public void testFloatValuePastNegMaxValue() {
- byte[] a = {
- 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
- int aSign = -1;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(Float.NEGATIVE_INFINITY, aNumber);
- }
-
- /**
- * Convert a positive number beyond Float.MAX_VALUE, ensuring that it is
- * converted to Float.POSITIVE_INFINITY.
- */
- public void testFloatValuePastPosMaxValue() {
- byte[] a = {
- 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
- int aSign = 1;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(Float.POSITIVE_INFINITY, aNumber);
- }
-
- /**
- * Convert a positive number to a float value. The number's length is less
- * than 32 bits.
- */
- public void testFloatValuePositive1() {
- String a = "27467238";
- float result = 2.7467238E7f;
- float aNumber = new BigInteger(a).floatValue();
- assertEquals(result, aNumber);
- }
-
- /**
- * Convert a positive number to a float value. The number's bit length is
- * inside [32, 127].
- */
- public void testFloatValuePositive2() {
- String a = "27467238945723645782";
- float result = 2.7467239E19f;
- float aNumber = new BigInteger(a).floatValue();
- assertEquals(result, aNumber, 1e12);
- }
-
- /**
- * Convert a positive number to a float value. The exponent is 1023 and the
- * mantissa is all 1s. The rounding bit is 1. The result is
- * Float.POSITIVE_INFINITY.
- */
- public void testFloatValuePositiveInfinity1() {
- byte[] a = {
- 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
- int aSign = 1;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(Float.POSITIVE_INFINITY, aNumber);
- }
-
- /**
- * Convert a positive number to a float value. The number's bit length is
- * greater than 127.
- */
- public void testFloatValuePositiveInfinity2() {
- String a = "274672389457236457826542634627345697228374687236476867674746234"
- + "23423423423423423423234234234234234234267674563457452937623847562384"
- + "75634563456845634568934568347586346578648576478568456457634875673845"
- + "67845678658734587364576745683475674576345786348576847567846578345670"
- + "2897830296720476846578634576384567845678346573465786457863";
- float aNumber = new BigInteger(a).floatValue();
- assertEquals(Float.POSITIVE_INFINITY, aNumber);
- }
-
- /**
- * Convert a positive number to a float value. The exponent is 1023 and the
- * mantissa is all 0s but the 54th bit (implicit) is 1.
- */
- public void testFloatValuePosMantissaIsZero() {
- byte[] a = {-128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = 1;
- float result = 1.7014118E38f;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(result, aNumber, 1e31);
- }
-
- /**
- * Convert a positive number to a float value. Rounding is NOT needed.
- */
- public void testFloatValuePosNotRounded() {
- byte[] a = {-128, 1, 2, 3, 4, 5, 60, 23, 1, -3, -5};
- int aSign = 1;
- float result = 1.5474726E26f;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(result, aNumber, 1e19);
- }
-
- /**
- * Convert a positive number to a float value. Rounding is needed. The
- * rounding bit is 1 and the next bit to the left is 1.
- */
- public void testFloatValuePosRounded1() {
- byte[] a = {-128, 1, -1, -4, 4, 5, 60, 23, 1, -3, -5};
- int aSign = 1;
- float result = 1.5475195E26f;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(result, aNumber, 1e19);
- }
-
- /**
- * Convert a positive number to a float value. Rounding is needed. The
- * rounding bit is 1 and the next bit to the left is 0 but some of dropped
- * bits are 1s.
- */
- public void testFloatValuePosRounded2() {
- byte[] a = {-128, 1, 2, -128, 4, 5, 60, 23, 1, -3, -5};
- int aSign = 1;
- float result = 1.5474728E26f;
- float aNumber = new BigInteger(aSign, a).floatValue();
- assertEquals(result, aNumber, 1e19);
- }
-
- /**
- * Return the float value of ZERO.
- */
- public void testFloatValueZero() {
- String a = "0";
- float result = 0.0f;
- float aNumber = new BigInteger(a).floatValue();
- assertEquals(result, aNumber);
- }
-
- /**
- * Convert a negative BigInteger to an integer value. The low digit is
- * negative.
- */
- public void testIntValueNegative1() {
- byte aBytes[] = {12, 56, 100, -2, -76, -128, 45, 91, 3};
- int sign = -1;
- int resInt = 2144511229;
- int aNumber = new BigInteger(sign, aBytes).intValue();
- assertEquals(resInt, aNumber);
- }
-
- /**
- * Convert a negative BigInteger to an integer value. The low digit is
- * negative.
- */
- public void testIntValueNegative2() {
- byte aBytes[] = {-12, 56, 100};
- int result = -771996;
- int aNumber = new BigInteger(aBytes).intValue();
- assertEquals(result, aNumber);
- }
-
- /**
- * Convert a negative BigInteger to an integer value. The low digit is
- * positive.
- */
- public void testIntValueNegative3() {
- byte aBytes[] = {12, 56, 100, -2, -76, 127, 45, 91, 3};
- int sign = -1;
- int resInt = -2133678851;
- int aNumber = new BigInteger(sign, aBytes).intValue();
- assertEquals(resInt, aNumber);
- }
-
- /**
- * Convert a positive BigInteger to an integer value. The low digit is
- * positive
- */
- public void testIntValuePositive1() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3};
- int resInt = 1496144643;
- int aNumber = new BigInteger(aBytes).intValue();
- assertEquals(resInt, aNumber);
- }
-
- /**
- * Convert a positive BigInteger to an integer value. The low digit is
- * positive
- */
- public void testIntValuePositive2() {
- byte aBytes[] = {12, 56, 100};
- int resInt = 800868;
- int aNumber = new BigInteger(aBytes).intValue();
- assertEquals(resInt, aNumber);
- }
-
- /**
- * Convert a positive BigInteger to an integer value. The low digit is
- * negative.
- */
- public void testIntValuePositive3() {
- byte aBytes[] = {56, 13, 78, -12, -5, 56, 100};
- int sign = 1;
- int resInt = -184862620;
- int aNumber = new BigInteger(sign, aBytes).intValue();
- assertEquals(resInt, aNumber);
- }
-
- /**
- * Convert a number to a negative long value The BigInteger is longer than
- * int.
- */
- public void testLongValueNegative1() {
- byte aBytes[] = {12, -1, 100, -2, -76, -128, 45, 91, 3};
- long result = -43630045168837885L;
- long aNumber = new BigInteger(aBytes).longValue();
- assertEquals(result, aNumber);
- }
-
- /**
- * Convert a number to a negative long value The number fits in a long.
- */
- public void testLongValueNegative2() {
- byte aBytes[] = {-12, 56, 100, 45, -101, 45, 98};
- long result = -3315696807498398L;
- long aNumber = new BigInteger(aBytes).longValue();
- assertEquals(result, aNumber);
- }
-
- /**
- * Convert a BigInteger to a positive long value The BigInteger is longer than
- * int.
- */
- public void testLongValuePositive1() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, 120, -34, -12, 45, 98};
- long result = 3268209772258930018L;
- long aNumber = new BigInteger(aBytes).longValue();
- assertEquals(result, aNumber);
- }
-
- /**
- * Convert a number to a positive long value The number fits in a long.
- */
- public void testLongValuePositive2() {
- byte aBytes[] = {12, 56, 100, 18, -105, 34, -18, 45};
- long result = 880563758158769709L;
- long aNumber = new BigInteger(aBytes).longValue();
- assertEquals(result, aNumber);
- }
-
- /**
- * valueOf (long val): convert Integer.MAX_VALUE to a BigInteger.
- */
- public void testValueOfIntegerMax() {
- long longVal = Integer.MAX_VALUE;
- BigInteger aNumber = BigInteger.valueOf(longVal);
- byte rBytes[] = {127, -1, -1, -1};
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * valueOf (long val): convert Integer.MIN_VALUE to a BigInteger.
- */
- public void testValueOfIntegerMin() {
- long longVal = Integer.MIN_VALUE;
- BigInteger aNumber = BigInteger.valueOf(longVal);
- byte rBytes[] = {-128, 0, 0, 0};
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * valueOf (long val): convert Long.MAX_VALUE to a BigInteger.
- */
- public void testValueOfLongMax() {
- long longVal = Long.MAX_VALUE;
- BigInteger aNumber = BigInteger.valueOf(longVal);
- byte rBytes[] = {127, -1, -1, -1, -1, -1, -1, -1};
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * valueOf (long val): convert Long.MIN_VALUE to a BigInteger.
- */
- public void testValueOfLongMin() {
- long longVal = Long.MIN_VALUE;
- BigInteger aNumber = BigInteger.valueOf(longVal);
- byte rBytes[] = {-128, 0, 0, 0, 0, 0, 0, 0};
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * valueOf (long val): convert a negative long value to a BigInteger.
- */
- public void testValueOfLongNegative1() {
- long longVal = -268209772258930018L;
- BigInteger aNumber = BigInteger.valueOf(longVal);
- byte rBytes[] = {-4, 71, 32, -94, 23, 55, -46, -98};
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * valueOf (long val): convert a negative long value to a BigInteger. The long
- * value fits in integer.
- */
- public void testValueOfLongNegative2() {
- long longVal = -58930018L;
- BigInteger aNumber = BigInteger.valueOf(longVal);
- byte rBytes[] = {-4, 124, -52, -98};
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", -1, aNumber.signum());
- }
-
- /**
- * valueOf (long val): convert a positive long value to a BigInteger.
- */
- public void testValueOfLongPositive1() {
- long longVal = 268209772258930018L;
- BigInteger aNumber = BigInteger.valueOf(longVal);
- byte rBytes[] = {3, -72, -33, 93, -24, -56, 45, 98};
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * valueOf (long val): convert a positive long value to a BigInteger. The long
- * value fits in integer.
- */
- public void testValueOfLongPositive2() {
- long longVal = 58930018L;
- BigInteger aNumber = BigInteger.valueOf(longVal);
- byte rBytes[] = {3, -125, 51, 98};
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, aNumber.signum());
- }
-
- /**
- * valueOf (long val): convert a zero long value to a BigInteger.
- */
- public void testValueOfLongZero() {
- long longVal = 0L;
- BigInteger aNumber = BigInteger.valueOf(longVal);
- byte rBytes[] = {0};
- byte resBytes[] = new byte[rBytes.length];
- resBytes = aNumber.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 0, aNumber.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerDivideTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerDivideTest.java
deleted file mode 100644
index 5975a2b..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerDivideTest.java
+++ /dev/null
@@ -1,687 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Methods: divide, remainder, mod, and
- * divideAndRemainder
- */
-public class BigIntegerDivideTest extends EmulTestBase {
- /**
- * Divide by zero
- */
- public void testCase1() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {0};
- int aSign = 1;
- int bSign = 0;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- try {
- aNumber.divide(bNumber);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "BigInteger divide by zero",
- e.getMessage());
- }
- }
-
- /**
- * Divide two negative numbers.
- */
- public void testCase10() {
- byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
- byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {23, 115, 11, 78, 35, -11};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Divide zero by a negative number.
- */
- public void testCase11() {
- byte aBytes[] = {0};
- byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
- int aSign = 0;
- int bSign = -1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Divide ZERO by a negative number.
- */
- public void testCase12() {
- byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
- int bSign = -1;
- byte rBytes[] = {0};
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Divide a positive number by ONE.
- */
- public void testCase13() {
- byte aBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
- int aSign = 1;
- byte rBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Divide ONE by ONE.
- */
- public void testCase14() {
- byte rBytes[] = {1};
- BigInteger aNumber = BigInteger.ONE;
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Remainder of division by zero
- */
- public void testCase15() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {0};
- int aSign = 1;
- int bSign = 0;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- try {
- aNumber.remainder(bNumber);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "BigInteger divide by zero",
- e.getMessage());
- }
- }
-
- /**
- * Remainder of division of equal numbers
- */
- public void testCase16() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
- byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.remainder(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Remainder of division of two positive numbers
- */
- public void testCase17() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
- byte bBytes[] = {27, -15, 65, 39, 100};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {12, -21, 73, 56, 27};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.remainder(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Remainder of division of two negative numbers
- */
- public void testCase18() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
- byte bBytes[] = {27, -15, 65, 39, 100};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-13, 20, -74, -57, -27};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.remainder(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Remainder of division of two numbers of different signs. The first is
- * positive.
- */
- public void testCase19() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
- byte bBytes[] = {27, -15, 65, 39, 100};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {12, -21, 73, 56, 27};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.remainder(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Divide by ZERO
- */
- public void testCase2() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ZERO;
- try {
- aNumber.divide(bNumber);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "BigInteger divide by zero",
- e.getMessage());
- }
- }
-
- /**
- * Remainder of division of two numbers of different signs. The first is
- * negative.
- */
- public void testCase20() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
- byte bBytes[] = {27, -15, 65, 39, 100};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {-13, 20, -74, -57, -27};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.remainder(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * divideAndRemainder of two numbers of different signs. The first is
- * negative.
- */
- public void testCase21() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
- byte bBytes[] = {27, -15, 65, 39, 100};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[][] = { {-5, 94, -115, -74, -85, 84}, {-13, 20, -74, -57, -27}};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result[] = aNumber.divideAndRemainder(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result[0].toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- if (resBytes[i] != rBytes[0][i]) {
- fail("Incorrect quotation");
- }
- }
- assertEquals(-1, result[0].signum());
- resBytes = result[1].toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- if (resBytes[i] != rBytes[1][i]) {
- fail("Incorrect remainder");
- }
- assertEquals(-1, result[1].signum());
- }
- }
-
- /**
- * mod when modulus is negative
- */
- public void testCase22() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {1, 30, 40, 56, -1, 45};
- int aSign = 1;
- int bSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- try {
- aNumber.mod(bNumber);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message",
- "BigInteger: modulus not positive", e.getMessage());
- }
- }
-
- /**
- * mod when a divisor is positive
- */
- public void testCase23() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
- byte bBytes[] = {27, -15, 65, 39, 100};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {12, -21, 73, 56, 27};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.mod(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * mod when a divisor is negative
- */
- public void testCase24() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75};
- byte bBytes[] = {27, -15, 65, 39, 100};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {15, 5, -9, -17, 73};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.mod(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Divide two equal positive numbers
- */
- public void testCase3() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
- byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {1};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Divide two equal in absolute value numbers of different signs.
- */
- public void testCase4() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
- byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {-1};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Divide two numbers of different length and different signs. The second is
- * longer.
- */
- public void testCase5() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127};
- byte bBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 1, 2, 3, 4, 5};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Divide two positive numbers of the same length. The second is greater.
- */
- public void testCase6() {
- byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127};
- byte bBytes[] = {15, 100, 56, 7, 98, -1, 39, -128, 127};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Divide two positive numbers.
- */
- public void testCase7() {
- byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
- byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {23, 115, 11, 78, 35, -11};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Divide a positive number by a negative one.
- */
- public void testCase8() {
- byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
- byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {-24, -116, -12, -79, -36, 11};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Divide a negative number by a positive one.
- */
- public void testCase9() {
- byte aBytes[] = {1, 100, 56, 7, 98, -1, 39, -128, 127, 5, 6, 7, 8, 9};
- byte bBytes[] = {15, 48, -29, 7, 98, -1, 39, -128};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {-24, -116, -12, -79, -36, 11};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Verifies the case when borrow != 0 in the private divide method.
- */
- public void testDivisionKnuth1() {
- byte aBytes[] = {-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {-3, -3, -3, -3};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {0, -5, -12, -33, -96, -36, -105, -56, 92, 15, 48, -109};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Verifies the case when the first digits of the dividend and divisor equal.
- */
- public void testDivisionKnuthFirstDigitsEqual() {
- byte aBytes[] = {2, -3, -4, -5, -1, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5};
- byte bBytes[] = {2, -3, -4, -5, -1, -1, -1, -1};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {0, -1, -1, -1, -1, -2, -88, -60, 41};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Verifies the case when the divisor is already normalized.
- */
- public void testDivisionKnuthIsNormalized() {
- byte aBytes[] = {-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5};
- byte bBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {0, -9, -8, -7, -6, -5, -4, -3};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Divide the number of multi digits by the number of one digit
- */
- public void testDivisionKnuthMultiDigitsByOneDigit() {
- byte aBytes[] = {113, -83, 123, -5, 18, -34, 67, 39, -29};
- byte bBytes[] = {2, -3, -4, -5};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {-38, 2, 7, 30, 109, -43};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Divide the number of one digit by the number of one digit
- */
- public void testDivisionKnuthOneDigitByOneDigit() {
- byte aBytes[] = {113, -83, 123, -5};
- byte bBytes[] = {2, -3, -4, -5};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {-37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.divide(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Tests the step D6 from the Knuth algorithm
- */
- public void testRemainderKnuth1() {
- byte aBytes[] = {-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1};
- byte bBytes[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7, 7, 18, -89};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.remainder(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Divide the number of multi digits by the number of one digit
- */
- public void testRemainderKnuthMultiDigitsByOneDigit() {
- byte aBytes[] = {113, -83, 123, -5, 18, -34, 67, 39, -29};
- byte bBytes[] = {2, -3, -4, -50};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {2, -37, -60, 59};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.remainder(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Divide the number of one digit by the number of one digit
- */
- public void testRemainderKnuthOneDigitByOneDigit() {
- byte aBytes[] = {113, -83, 123, -5};
- byte bBytes[] = {2, -3, -4, -50};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {2, -9, -14, 53};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.remainder(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerHashCodeTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerHashCodeTest.java
deleted file mode 100644
index 1e311c0..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerHashCodeTest.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Method: hashCode()
- */
-public class BigIntegerHashCodeTest extends EmulTestBase {
- /**
- * Test hash codes for equal objects.
- */
- public void testEqualObjects() {
- String value1 = "12378246728727834290276457386374882976782849";
- String value2 = "12378246728727834290276457386374882976782849";
- BigInteger aNumber1 = new BigInteger(value1);
- BigInteger aNumber2 = new BigInteger(value2);
- int code1 = aNumber1.hashCode();
- int code2 = aNumber2.hashCode();
- if (aNumber1.equals(aNumber2)) {
- assertTrue("hash codes for equal objects are unequal", code1 == code2);
- }
- }
-
- /**
- * Test hash codes for the same object
- */
- public void testSameObject() {
- String value1 = "12378246728727834290276457386374882976782849";
- String value2 = "-5634562095872038262928728727834290276457386374882976782849";
- BigInteger aNumber1 = new BigInteger(value1);
- BigInteger aNumber2 = new BigInteger(value2);
- int code1 = aNumber1.hashCode();
- aNumber1.add(aNumber2).shiftLeft(125);
- aNumber1.subtract(aNumber2).shiftRight(125);
- aNumber1.multiply(aNumber2).toByteArray();
- aNumber1.divide(aNumber2).bitLength();
- aNumber1.gcd(aNumber2).pow(7);
- int code2 = aNumber1.hashCode();
- assertTrue("hash codes for the same object differ", code1 == code2);
- }
-
- /**
- * Test hash codes for unequal objects. The codes are unequal.
- */
- public void testUnequalObjectsUnequal() {
- String value1 = "12378246728727834290276457386374882976782849";
- String value2 = "-5634562095872038262928728727834290276457386374882976782849";
- BigInteger aNumber1 = new BigInteger(value1);
- BigInteger aNumber2 = new BigInteger(value2);
- int code1 = aNumber1.hashCode();
- int code2 = aNumber2.hashCode();
- if (!aNumber1.equals(aNumber2)) {
- assertTrue("hash codes for unequal objects are equal", code1 != code2);
- }
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerModPowTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerModPowTest.java
deleted file mode 100644
index c3bb24f..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerModPowTest.java
+++ /dev/null
@@ -1,355 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Methods: modPow, modInverse, and gcd
- */
-public class BigIntegerModPowTest extends EmulTestBase {
- /**
- * gcd: both numbers are zeros
- */
- public void testGcdBothZeros() {
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger("0");
- BigInteger bNumber = BigInteger.valueOf(0L);
- BigInteger result = aNumber.gcd(bNumber);
- byte resBytes[] = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * gcd: the first number is longer
- */
- public void testGcdFirstLonger() {
- byte aBytes[] = {
- -15, 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28,
- -127};
- byte bBytes[] = {-12, 1, 0, 0, 0, 23, 44, 55, 66};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {7};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.gcd(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * gcd: the first number is zero
- */
- public void testGcdFirstZero() {
- byte aBytes[] = {0};
- byte bBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.gcd(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * gcd: the first number is ZERO
- */
- public void testGcdFirstZERO() {
- byte bBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
- int bSign = 1;
- byte rBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.gcd(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * gcd: the second number is longer
- */
- public void testGcdSecondLonger() {
- byte aBytes[] = {-12, 1, 0, 0, 0, 23, 44, 55, 66};
- byte bBytes[] = {
- -15, 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28,
- -127};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {7};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.gcd(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * gcd: the second number is zero
- */
- public void testGcdSecondZero() {
- byte aBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
- byte bBytes[] = {0};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.gcd(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * modInverse: non-positive modulus
- */
- public void testmodInverseException() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte mBytes[] = {1, 2, 3};
- int aSign = 1;
- int mSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger modulus = new BigInteger(mSign, mBytes);
- try {
- aNumber.modInverse(modulus);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message",
- "BigInteger: modulus not positive", e.getMessage());
- }
- }
-
- /**
- * modInverse: negative number
- */
- public void testmodInverseNeg1() {
- byte aBytes[] = {
- 15, 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28,
- -127};
- byte mBytes[] = {2, 122, 45, 36, 100};
- int aSign = -1;
- int mSign = 1;
- byte rBytes[] = {0, -41, 4, -91, 27};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger modulus = new BigInteger(mSign, mBytes);
- BigInteger result = aNumber.modInverse(modulus);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * modInverse: negative number (another case: x < 0)
- */
- public void testmodInverseNeg2() {
- byte aBytes[] = {-15, 24, 123, 57, -15, 24, 123, 57, -15, 24, 123, 57};
- byte mBytes[] = {122, 2, 4, 122, 2, 4};
- byte rBytes[] = {85, 47, 127, 4, -128, 45};
- BigInteger aNumber = new BigInteger(aBytes);
- BigInteger modulus = new BigInteger(mBytes);
- BigInteger result = aNumber.modInverse(modulus);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * modInverse: non-invertible number
- */
- public void testmodInverseNonInvertible() {
- byte aBytes[] = {
- -15, 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28,
- -127};
- byte mBytes[] = {-12, 1, 0, 0, 0, 23, 44, 55, 66};
- int aSign = 1;
- int mSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger modulus = new BigInteger(mSign, mBytes);
- try {
- aNumber.modInverse(modulus);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "BigInteger not invertible.",
- e.getMessage());
- }
- }
-
- /**
- * modInverse: positive number
- */
- public void testmodInversePos1() {
- byte aBytes[] = {
- 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28, -127};
- byte mBytes[] = {122, 45, 36, 100, 122, 45};
- int aSign = 1;
- int mSign = 1;
- byte rBytes[] = {47, 3, 96, 62, 87, 19};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger modulus = new BigInteger(mSign, mBytes);
- BigInteger result = aNumber.modInverse(modulus);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * modInverse: positive number (another case: a < 0)
- */
- public void testmodInversePos2() {
- byte aBytes[] = {
- 15, 24, 123, 56, -11, -112, -34, -98, 8, 10, 12, 14, 25, 125, -15, 28,
- -127};
- byte mBytes[] = {2, 122, 45, 36, 100};
- int aSign = 1;
- int mSign = 1;
- byte rBytes[] = {1, -93, 40, 127, 73};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger modulus = new BigInteger(mSign, mBytes);
- BigInteger result = aNumber.modInverse(modulus);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * modPow: non-positive modulus
- */
- public void testModPowException() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- byte eBytes[] = {1, 2, 3, 4, 5};
- byte mBytes[] = {1, 2, 3};
- int aSign = 1;
- int eSign = 1;
- int mSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger exp = new BigInteger(eSign, eBytes);
- BigInteger modulus = new BigInteger(mSign, mBytes);
- try {
- aNumber.modPow(exp, modulus);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message",
- "BigInteger: modulus not positive", e.getMessage());
- }
- }
-
- /**
- * modPow: negative exponent
- */
- public void testModPowNegExp() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75, 48, -7};
- byte eBytes[] = {27, -15, 65, 39};
- byte mBytes[] = {-128, 2, 3, 4, 5};
- int aSign = 1;
- int eSign = -1;
- int mSign = 1;
- byte rBytes[] = {12, 118, 46, 86, 92};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger exp = new BigInteger(eSign, eBytes);
- BigInteger modulus = new BigInteger(mSign, mBytes);
- BigInteger result = aNumber.modPow(exp, modulus);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * modPow: positive exponent.
- */
- public void testModPowPosExp() {
- byte aBytes[] = {-127, 100, 56, 7, 98, -1, 39, -128, 127, 75, 48, -7};
- byte eBytes[] = {27, -15, 65, 39};
- byte mBytes[] = {-128, 2, 3, 4, 5};
- int aSign = 1;
- int eSign = 1;
- int mSign = 1;
- byte rBytes[] = {113, 100, -84, -28, -85};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger exp = new BigInteger(eSign, eBytes);
- BigInteger modulus = new BigInteger(mSign, mBytes);
- BigInteger result = aNumber.modPow(exp, modulus);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertEquals("Byte " + i, rBytes[i], resBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerMultiplyTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerMultiplyTest.java
deleted file mode 100644
index 5b24a50..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerMultiplyTest.java
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Method: multiply
- */
-public class BigIntegerMultiplyTest extends EmulTestBase {
- /**
- * Multiply two negative numbers of the same length
- */
- public void testCase1() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {
- 10, 40, 100, -55, 96, 51, 76, 40, -45, 85, 105, 4, 28, -86, -117, -52,
- 100, 120, 90};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Multiply a negative number by ONE.
- */
- public void testCase10() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
- int aSign = -1;
- byte rBytes[] = {-2, -3, -4, -5, -6, -7, -8, -2, -3, -4, -2, -3, -4, -5, -5};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Multiply two numbers of the same length and different signs. The first is
- * negative.
- */
- public void testCase2() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {
- -11, -41, -101, 54, -97, -52, -77, -41, 44, -86, -106, -5, -29, 85,
- 116, 51, -101, -121, -90};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Multiply two positive numbers of different length. The first is longer.
- */
- public void testCase3() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {
- 10, 40, 100, -55, 96, 51, 76, 40, -45, 85, 115, 44, -127, 115, -21,
- -62, -15, 85, 64, -87, -2, -36, -36, -106};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Multiply two positive numbers of different length. The second is longer.
- */
- public void testCase4() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {
- 10, 40, 100, -55, 96, 51, 76, 40, -45, 85, 115, 44, -127, 115, -21,
- -62, -15, 85, 64, -87, -2, -36, -36, -106};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Multiply two numbers of different length and different signs. The first is
- * positive. The first is longer.
- */
- public void testCase5() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {
- -11, -41, -101, 54, -97, -52, -77, -41, 44, -86, -116, -45, 126, -116,
- 20, 61, 14, -86, -65, 86, 1, 35, 35, 106};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Multiply two numbers of different length and different signs. The first is
- * positive. The second is longer.
- */
- public void testCase6() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {
- -11, -41, -101, 54, -97, -52, -77, -41, 44, -86, -116, -45, 126, -116,
- 20, 61, 14, -86, -65, 86, 1, 35, 35, 106};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Multiply a number by zero.
- */
- public void testCase7() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
- byte bBytes[] = {0};
- int aSign = 1;
- int bSign = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Multiply a number by ZERO.
- */
- public void testCase8() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
- int aSign = 1;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ZERO;
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * Multiply a positive number by ONE.
- */
- public void testCase9() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
- int aSign = 1;
- byte rBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Multiply two numbers of 4 bytes length.
- */
- public void testIntbyInt1() {
- byte aBytes[] = {10, 20, 30, 40};
- byte bBytes[] = {1, 2, 3, 4};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {-11, -41, -101, 55, 5, 15, 96};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Multiply two numbers of 4 bytes length.
- */
- public void testIntbyInt2() {
- byte aBytes[] = {-1, -1, -1, -1};
- byte bBytes[] = {-1, -1, -1, -1};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {0, -1, -1, -1, -2, 0, 0, 0, 1};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.multiply(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Negative exponent.
- */
- public void testPowException() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- int exp = -5;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- try {
- aNumber.pow(exp);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "Negative exponent",
- e.getMessage());
- }
- }
-
- /**
- * Exponentiation of a negative number to an even exponent.
- */
- public void testPowNegativeNumToEvenExp() {
- byte aBytes[] = {50, -26, 90, 69, 120, 32, 63, -103, -14, 35};
- int aSign = -1;
- int exp = 4;
- byte rBytes[] = {
- 102, 107, -122, -43, -52, -20, -27, 25, -9, 88, -13, 75, 78, 81, -33,
- -77, 39, 27, -37, 106, 121, -73, 108, -47, -101, 80, -25, 71, 13, 94,
- -7, -33, 1, -17, -65, -70, -61, -3, -47};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.pow(exp);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Exponentiation of a negative number to an odd exponent.
- */
- public void testPowNegativeNumToOddExp() {
- byte aBytes[] = {50, -26, 90, 69, 120, 32, 63, -103, -14, 35};
- int aSign = -1;
- int exp = 5;
- byte rBytes[] = {
- -21, -94, -42, -15, -127, 113, -50, -88, 115, -35, 3, 59, -92, 111,
- -75, 103, -42, 41, 34, -114, 99, -32, 105, -59, 127, 45, 108, 74, -93,
- 105, 33, 12, -5, -20, 17, -21, -119, -127, -115, 27, -122, 26, -67,
- 109, -125, 16, 91, -70, 109};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.pow(exp);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Exponentiation of a negative number to zero exponent.
- */
- public void testPowNegativeNumToZeroExp() {
- byte aBytes[] = {50, -26, 90, 69, 120, 32, 63, -103, -14, 35};
- int aSign = -1;
- int exp = 0;
- byte rBytes[] = {1};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.pow(exp);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Exponentiation of a positive number.
- */
- public void testPowPositiveNum() {
- byte aBytes[] = {50, -26, 90, 69, 120, 32, 63, -103, -14, 35};
- int aSign = 1;
- int exp = 5;
- byte rBytes[] = {
- 20, 93, 41, 14, 126, -114, 49, 87, -116, 34, -4, -60, 91, -112, 74,
- -104, 41, -42, -35, 113, -100, 31, -106, 58, -128, -46, -109, -75, 92,
- -106, -34, -13, 4, 19, -18, 20, 118, 126, 114, -28, 121, -27, 66, -110,
- 124, -17, -92, 69, -109};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.pow(exp);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Exponentiation of a negative number to zero exponent.
- */
- public void testPowPositiveNumToZeroExp() {
- byte aBytes[] = {50, -26, 90, 69, 120, 32, 63, -103, -14, 35};
- int aSign = 1;
- int exp = 0;
- byte rBytes[] = {1};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.pow(exp);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerNotTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerNotTest.java
deleted file mode 100644
index 9a1b4f7..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerNotTest.java
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Methods: and, andNot
- */
-public class BigIntegerNotTest extends EmulTestBase {
- /**
- * andNot for two negative numbers; the first is longer
- */
- public void testAndNotNegNegFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 2};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.andNot(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * andNot for two positive numbers; the first is longer
- */
- public void testAndNotPosPosFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {
- 0, -128, 9, 56, 100, 0, 0, 1, 1, 90, 1, -32, 0, 10, -126, 21, 82, -31,
- -96};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.andNot(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * andNot for two positive numbers; the first is shorter
- */
- public void testAndNotPosPosFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {73, -92, -48, 4, 12, 6, 4, 32, 48, 64, 0, 8, 2};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.andNot(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * andNot for a negative and a positive numbers; the first is longer
- */
- public void testNegPosFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {
- -1, 127, -10, -57, -101, 1, 2, 2, 2, -96, -16, 8, -40, -59, 68, -88,
- -88, 16, 72};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.andNot(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Not for a negative number
- */
- public void testNotNeg() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- int aSign = -1;
- byte rBytes[] = {
- 0, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -118};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.not();
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Not for ONE
- */
- public void testNotOne() {
- byte rBytes[] = {-2};
- BigInteger aNumber = BigInteger.ONE;
- BigInteger result = aNumber.not();
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Not for a positive number
- */
- public void testNotPos() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- int aSign = 1;
- byte rBytes[] = {
- -1, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -27, 116};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.not();
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Not for a negative number
- */
-
- public void testNotSpecialCase() {
- byte aBytes[] = {-1, -1, -1, -1};
- int aSign = 1;
- byte rBytes[] = {-1, 0, 0, 0, 0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.not();
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Not for ZERO
- */
- public void testNotZero() {
- byte rBytes[] = {-1};
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger result = aNumber.not();
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-}
\ No newline at end of file
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerOperateBitsTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerOperateBitsTest.java
deleted file mode 100644
index 3e62f59..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerOperateBitsTest.java
+++ /dev/null
@@ -1,1418 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Methods: bitLength, shiftLeft, shiftRight,
- * clearBit, flipBit, setBit, testBit
- */
-public class BigIntegerOperateBitsTest extends EmulTestBase {
- /**
- * bitCount() of a negative number.
- */
- public void testBitCountNeg() {
- BigInteger aNumber = new BigInteger(
- "-12378634756382937873487638746283767238657872368748726875");
- assertEquals(87, aNumber.bitCount());
- }
-
- /**
- * bitCount() of a negative number.
- */
- public void testBitCountPos() {
- BigInteger aNumber = new BigInteger(
- "12378634756343564757582937873487638746283767238657872368748726875");
- assertEquals(107, aNumber.bitCount());
- }
-
- /**
- * bitCount() of zero.
- */
- public void testBitCountZero() {
- BigInteger aNumber = new BigInteger("0");
- assertEquals(0, aNumber.bitCount());
- }
-
- /**
- * bitLength() of a negative number.
- */
- public void testBitLengthNegative1() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertEquals(108, aNumber.bitLength());
- }
-
- /**
- * bitLength() of a negative number with the leftmost bit set
- */
- public void testBitLengthNegative2() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertEquals(96, aNumber.bitLength());
- }
-
- /**
- * bitLength() of a negative number which is a power of 2
- */
- public void testBitLengthNegative3() {
- byte aBytes[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertEquals(80, aNumber.bitLength());
- }
-
- /**
- * bitLength() of a positive number.
- */
- public void testBitLengthPositive1() {
- byte aBytes[] = {12, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, 3, 91};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertEquals(108, aNumber.bitLength());
- }
-
- /**
- * bitLength() of a positive number with the leftmost bit set
- */
- public void testBitLengthPositive2() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertEquals(96, aNumber.bitLength());
- }
-
- /**
- * bitLength() of a positive number which is a power of 2
- */
- public void testBitLengthPositive3() {
- byte aBytes[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertEquals(81, aNumber.bitLength());
- }
-
- /**
- * bitLength() of zero.
- */
- public void testBitLengthZero() {
- BigInteger aNumber = new BigInteger("0");
- assertEquals(0, aNumber.bitLength());
- }
-
- /**
- * clearBit(int n) of a negative n
- */
- public void testClearBitException() {
- byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = -7;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- try {
- aNumber.clearBit(number);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "Negative bit address",
- e.getMessage());
- }
- }
-
- /**
- * clearBit(int n) inside a negative number
- */
- public void testClearBitNegativeInside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 15;
- byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, 92, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * clearBit(int n) inside a negative number
- */
- public void testClearBitNegativeInside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 44;
- byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -62, -92, -4, 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * clearBit(2) in the negative number with all ones in bit representation
- */
- public void testClearBitNegativeInside3() {
- String as = "-18446744073709551615";
- int number = 2;
- BigInteger aNumber = new BigInteger(as);
- BigInteger result = aNumber.clearBit(number);
- assertEquals(as, result.toString());
- }
-
- /**
- * clearBit(0) in the negative number of length 1 with all ones in bit
- * representation. the resulting number's length is 2.
- */
- public void testClearBitNegativeInside4() {
- String as = "-4294967295";
- String res = "-4294967296";
- int number = 0;
- BigInteger aNumber = new BigInteger(as);
- BigInteger result = aNumber.clearBit(number);
- assertEquals(res, result.toString());
- }
-
- /**
- * clearBit(0) in the negative number of length 2 with all ones in bit
- * representation. the resulting number's length is 3.
- */
- public void testClearBitNegativeInside5() {
- String as = "-18446744073709551615";
- String res = "-18446744073709551616";
- int number = 0;
- BigInteger aNumber = new BigInteger(as);
- BigInteger result = aNumber.clearBit(number);
- assertEquals(res, result.toString());
- }
-
- /**
- * clearBit(int n) outside a negative number
- */
- public void testClearBitNegativeOutside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 150;
- byte rBytes[] = {
- -65, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, 75, -90, -46, -92, -4,
- 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * clearBit(int n) outside a negative number
- */
- public void testClearBitNegativeOutside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 165;
- byte rBytes[] = {
- -33, -1, -1, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, 75, -90, -46,
- -92, -4, 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * clearBit(int n) inside a positive number
- */
- public void testClearBitPositiveInside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 20;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -31, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * clearBit(int n) inside a positive number
- */
- public void testClearBitPositiveInside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 17;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * clearBit(int n) inside a positive number
- */
- public void testClearBitPositiveInside3() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 45;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 13, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * clearBit(int n) inside a positive number
- */
- public void testClearBitPositiveInside4() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 50;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * clearBit(int n) inside a positive number
- */
- public void testClearBitPositiveInside5() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 63;
- byte rBytes[] = {1, -128, 56, 100, -2, 52, 89, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * clearBit(int n) outside a positive number
- */
- public void testClearBitPositiveOutside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 150;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * clearBit(int n) outside a positive number
- */
- public void testClearBitPositiveOutside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 191;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * clearBit(int n) the leftmost bit in a negative number
- */
- public void testClearBitTopNegative() {
- byte aBytes[] = {1, -128, 56, 100, -15, 35, 26};
- int aSign = -1;
- int number = 63;
- byte rBytes[] = {-1, 127, -2, 127, -57, -101, 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * clearBit(int n) outside zero
- */
- public void testClearBitZero() {
- byte aBytes[] = {0};
- int aSign = 0;
- int number = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * clearBit(int n) outside zero
- */
- public void testClearBitZeroOutside1() {
- byte aBytes[] = {0};
- int aSign = 0;
- int number = 95;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.clearBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * flipBit(int n) of a negative n
- */
- public void testFlipBitException() {
- byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = -7;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- try {
- aNumber.flipBit(number);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "Negative bit address",
- e.getMessage());
- }
- }
-
- /**
- * flipBit(int n) the leftmost bit in a negative number
- */
- public void testFlipBitLeftmostNegative() {
- byte aBytes[] = {1, -128, 56, 100, -15, 35, 26};
- int aSign = -1;
- int number = 48;
- byte rBytes[] = {-1, 127, -57, -101, 14, -36, -26, 49};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * flipBit(int n) the leftmost bit in a positive number
- */
- public void testFlipBitLeftmostPositive() {
- byte aBytes[] = {1, -128, 56, 100, -15, 35, 26};
- int aSign = 1;
- int number = 48;
- byte rBytes[] = {0, -128, 56, 100, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * flipBit(int n) inside a negative number
- */
- public void testFlipBitNegativeInside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 15;
- byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, 92, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * flipBit(int n) inside a negative number
- */
- public void testFlipBitNegativeInside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 45;
- byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -14, -92, -4, 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * flipBit(int n) inside a negative number with all ones in bit representation
- */
- public void testFlipBitNegativeInside3() {
- String as = "-18446744073709551615";
- String res = "-18446744073709551611";
- int number = 2;
- BigInteger aNumber = new BigInteger(as);
- BigInteger result = aNumber.flipBit(number);
- assertEquals(res, result.toString());
- }
-
- /**
- * flipBit(0) in the negative number of length 1 with all ones in bit
- * representation. the resulting number's length is 2.
- */
- public void testFlipBitNegativeInside4() {
- String as = "-4294967295";
- String res = "-4294967296";
- int number = 0;
- BigInteger aNumber = new BigInteger(as);
- BigInteger result = aNumber.flipBit(number);
- assertEquals(res, result.toString());
- }
-
- /**
- * flipBit(0) in the negative number of length 2 with all ones in bit
- * representation. the resulting number's length is 3.
- */
- public void testFlipBitNegativeInside5() {
- String as = "-18446744073709551615";
- String res = "-18446744073709551616";
- int number = 0;
- BigInteger aNumber = new BigInteger(as);
- BigInteger result = aNumber.flipBit(number);
- assertEquals(res, result.toString());
- }
-
- /**
- * flipBit(int n) outside a negative number
- */
- public void testFlipBitNegativeOutside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 150;
- byte rBytes[] = {
- -65, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1, 75, -90, -46, -92, -4,
- 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * flipBit(int n) outside a negative number
- */
- public void testFlipBitNegativeOutside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 191;
- byte rBytes[] = {
- -1, 127, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, 127, -57, -101, 1,
- 75, -90, -46, -92, -4, 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * flipBit(int n) inside a positive number
- */
- public void testFlipBitPositiveInside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 15;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, -93, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * flipBit(int n) inside a positive number
- */
- public void testFlipBitPositiveInside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 45;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 13, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * flipBit(int n) outside a positive number
- */
- public void testFlipBitPositiveOutside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 150;
- byte rBytes[] = {
- 64, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35,
- 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * flipBit(int n) outside a positive number
- */
- public void testFlipBitPositiveOutside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 191;
- byte rBytes[] = {
- 0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76, 89,
- 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * flipBit(int n) zero
- */
- public void testFlipBitZero() {
- byte aBytes[] = {0};
- int aSign = 0;
- int number = 0;
- byte rBytes[] = {1};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * flipBit(int n) outside zero
- */
- public void testFlipBitZeroOutside1() {
- byte aBytes[] = {0};
- int aSign = 0;
- int number = 62;
- byte rBytes[] = {64, 0, 0, 0, 0, 0, 0, 0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue("incorrect value", resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * flipBit(int n) outside zero
- */
- public void testFlipBitZeroOutside2() {
- byte aBytes[] = {0};
- int aSign = 0;
- int number = 63;
- byte rBytes[] = {0, -128, 0, 0, 0, 0, 0, 0, 0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.flipBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue("incorrect value", resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * setBit: check the case when the number of bit to be set can be represented
- * as n * 32 + 31, where n is an arbitrary integer. Here 191 = 5 * 32 + 31
- */
- public void testSetBitBug1331() {
- BigInteger result = BigInteger.valueOf(0L).setBit(191);
- assertEquals("incorrect value",
- "3138550867693340381917894711603833208051177722232017256448",
- result.toString());
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * setBit(int n) of a negative n
- */
- public void testSetBitException() {
- byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = -7;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- try {
- aNumber.setBit(number);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "Negative bit address",
- e.getMessage());
- }
- }
-
- /**
- * setBit(int n) the leftmost bit in a negative number
- */
- public void testSetBitLeftmostNegative() {
- byte aBytes[] = {1, -128, 56, 100, -15, 35, 26};
- int aSign = -1;
- int number = 48;
- byte rBytes[] = {-1, 127, -57, -101, 14, -36, -26, 49};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * setBit(int n) inside a negative number
- */
- public void testSetBitNegativeInside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 15;
- byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * setBit(int n) inside a negative number
- */
- public void testSetBitNegativeInside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 44;
- byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * setBit(int n) inside a negative number with all ones in bit representation
- */
- public void testSetBitNegativeInside3() {
- String as = "-18446744073709551615";
- String res = "-18446744073709551611";
- int number = 2;
- BigInteger aNumber = new BigInteger(as);
- BigInteger result = aNumber.setBit(number);
- assertEquals(res, result.toString());
- }
-
- /**
- * setBit(0) in the negative number of length 1 with all ones in bit
- * representation. the resulting number's length is 2.
- */
- public void testSetBitNegativeInside4() {
- String as = "-4294967295";
- int number = 0;
- BigInteger aNumber = new BigInteger(as);
- BigInteger result = aNumber.setBit(number);
- assertEquals(as, result.toString());
- }
-
- /**
- * setBit(0) in the negative number of length 2 with all ones in bit
- * representation. the resulting number's length is 3.
- */
- public void testSetBitNegativeInside5() {
- String as = "-18446744073709551615";
- int number = 0;
- BigInteger aNumber = new BigInteger(as);
- BigInteger result = aNumber.setBit(number);
- assertEquals(as, result.toString());
- }
-
- /**
- * setBit(int n) outside a negative number
- */
- public void testSetBitNegativeOutside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 150;
- byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * setBit(int n) outside a negative number
- */
- public void testSetBitNegativeOutside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 191;
- byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92, -4, 14, -36, -26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * setBit(int n) inside a positive number
- */
- public void testSetBitPositiveInside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 20;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * setBit(int n) inside a positive number
- */
- public void testSetBitPositiveInside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 17;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -13, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * setBit(int n) inside a positive number
- */
- public void testSetBitPositiveInside3() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 45;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * setBit(int n) inside a positive number
- */
- public void testSetBitPositiveInside4() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 50;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 93, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * setBit(int n) outside a positive number
- */
- public void testSetBitPositiveOutside1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 150;
- byte rBytes[] = {
- 64, 0, 0, 0, 0, 0, 1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35,
- 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * setBit(int n) outside a positive number
- */
- public void testSetBitPositiveOutside2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 223;
- byte rBytes[] = {
- 0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -128, 56, 100,
- -2, -76, 89, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * setBit(int n) the leftmost bit in a positive number
- */
- public void testSetBitTopPositive() {
- byte aBytes[] = {1, -128, 56, 100, -15, 35, 26};
- int aSign = 1;
- int number = 63;
- byte rBytes[] = {0, -128, 1, -128, 56, 100, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * setBit(int n) outside zero
- */
- public void testSetBitZero() {
- byte aBytes[] = {0};
- int aSign = 0;
- int number = 0;
- byte rBytes[] = {1};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * setBit(int n) outside zero
- */
- public void testSetBitZeroOutside1() {
- byte aBytes[] = {0};
- int aSign = 0;
- int number = 95;
- byte rBytes[] = {0, -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.setBit(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * shiftLeft(int n), n = 0
- */
- public void testShiftLeft1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 0;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftLeft(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * shiftLeft(int n), n < 0
- */
- public void testShiftLeft2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = -27;
- byte rBytes[] = {48, 7, 12, -97, -42, -117, 37, -85, 96};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftLeft(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * shiftLeft(int n) a positive number, n > 0
- */
- public void testShiftLeft3() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 27;
- byte rBytes[] = {
- 12, 1, -61, 39, -11, -94, -55, 106, -40, 31, -119, 24, -48, 0, 0, 0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftLeft(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * shiftLeft(int n) a positive number, n > 0
- */
- public void testShiftLeft4() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 45;
- byte rBytes[] = {
- 48, 7, 12, -97, -42, -117, 37, -85, 96, 126, 36, 99, 64, 0, 0, 0, 0, 0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftLeft(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * shiftLeft(int n) a negative number, n > 0
- */
- public void testShiftLeft5() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 45;
- byte rBytes[] = {
- -49, -8, -13, 96, 41, 116, -38, 84, -97, -127, -37, -100, -64, 0, 0, 0,
- 0, 0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftLeft(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * shiftRight(int n), n = 0
- */
- public void testShiftRight1() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 0;
- byte rBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftRight(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * shiftRight(int n), n < 0
- */
- public void testShiftRight2() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = -27;
- byte rBytes[] = {
- 12, 1, -61, 39, -11, -94, -55, 106, -40, 31, -119, 24, -48, 0, 0, 0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftRight(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * shiftRight(int n), 0 < n < 32
- */
- public void testShiftRight3() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 27;
- byte rBytes[] = {48, 7, 12, -97, -42, -117, 37, -85, 96};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftRight(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * shiftRight(int n), n > 32
- */
- public void testShiftRight4() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 45;
- byte rBytes[] = {12, 1, -61, 39, -11, -94, -55};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftRight(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * shiftRight(int n), n is greater than bitLength()
- */
- public void testShiftRight5() {
- byte aBytes[] = {1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 300;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftRight(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-
- /**
- * shiftRight a negative number; shift distance is NOT multiple of 32; shifted
- * bits are NOT zeroes.
- */
- public void testShiftRightNegNonZeroes() {
- byte aBytes[] = {
- 1, -128, 56, 100, -2, -76, 89, 45, 91, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = -1;
- int number = 68;
- byte rBytes[] = {-25, -4, 121, -80, 20, -70, 109, 42};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftRight(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * shiftRight a negative number; shift distance is multiple of 32; shifted
- * bits are NOT zeroes.
- */
- public void testShiftRightNegNonZeroesMul32() {
- byte aBytes[] = {
- 1, -128, 56, 100, -2, -76, 89, 45, 91, 1, 0, 0, 0, 0, 0, 0, 0};
- int aSign = -1;
- int number = 64;
- byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -92};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftRight(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * shiftRight a negative number; shift distance is NOT multiple of 32; shifted
- * bits are zeroes.
- */
- public void testShiftRightNegZeroes() {
- byte aBytes[] = {
- 1, -128, 56, 100, -2, -76, 89, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = -1;
- int number = 68;
- byte rBytes[] = {-25, -4, 121, -80, 20, -70, 109, 48};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftRight(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * shiftRight a negative number; shift distance is multiple of 32; shifted
- * bits are zeroes.
- */
- public void testShiftRightNegZeroesMul32() {
- byte aBytes[] = {
- 1, -128, 56, 100, -2, -76, 89, 45, 91, 0, 0, 0, 0, 0, 0, 0, 0};
- int aSign = -1;
- int number = 64;
- byte rBytes[] = {-2, 127, -57, -101, 1, 75, -90, -46, -91};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger result = aNumber.shiftRight(number);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * testBit(int n) of a negative n
- */
- public void testTestBitException() {
- byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = -7;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- try {
- aNumber.testBit(number);
- fail("ArithmeticException has not been caught");
- } catch (ArithmeticException e) {
- assertEquals("Improper exception message", "Negative bit address",
- e.getMessage());
- }
- }
-
- /**
- * testBit(int n) of a negative number
- */
- public void testTestBitNegative1() {
- byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 7;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertTrue(aNumber.testBit(number));
- }
-
- /**
- * testBit(int n) of a positive n
- */
- public void testTestBitNegative2() {
- byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 45;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertTrue(!aNumber.testBit(number));
- }
-
- /**
- * testBit(int n) of a positive n, n > bitLength()
- */
- public void testTestBitNegative3() {
- byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = -1;
- int number = 300;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertTrue(aNumber.testBit(number));
- }
-
- /**
- * testBit(int n) of a positive number
- */
- public void testTestBitPositive1() {
- byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 7;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertTrue(!aNumber.testBit(number));
- }
-
- /**
- * testBit(int n) of a positive number
- */
- public void testTestBitPositive2() {
- byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 45;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertTrue(aNumber.testBit(number));
- }
-
- /**
- * testBit(int n) of a positive number, n > bitLength()
- */
- public void testTestBitPositive3() {
- byte aBytes[] = {-1, -128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26};
- int aSign = 1;
- int number = 300;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- assertTrue(!aNumber.testBit(number));
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerOrTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerOrTest.java
deleted file mode 100644
index e67cb2e..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerOrTest.java
+++ /dev/null
@@ -1,467 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Method: or
- */
-public class BigIntegerOrTest extends EmulTestBase {
- /**
- * Or for two negative numbers; the first is longer
- */
- public void testNegNegFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {
- -1, 1, 75, -89, -45, -2, -3, -18, -36, -17, -10, -3, -6, -7, -21};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for two negative numbers; the first is shorter
- */
- public void testNegNegFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {
- -1, 1, 75, -89, -45, -2, -3, -18, -36, -17, -10, -3, -6, -7, -21};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for two negative numbers of the same length
- */
- public void testNegNegSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {
- -1, 127, -57, -101, -5, -5, -18, -38, -17, -2, -65, -2, -11, -3};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for a negative number and zero
- */
- public void testNegPos() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {0};
- int aSign = -1;
- int bSign = 0;
- byte rBytes[] = {
- -1, 1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for a negative and a positive numbers; the first is longer
- */
- public void testNegPosFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {
- -1, 127, -10, -57, -101, -1, -1, -2, -2, -91, -2, 31, -1, -11, 125,
- -22, -83, 30, 95};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for two negative numbers; the first is shorter
- */
- public void testNegPosFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {-74, 91, 47, -5, -13, -7, -5, -33, -49, -65, -1, -9, -3};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for two numbers of different signs and the same length
- */
- public void testNegPosSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {-1, 5, 79, -73, -9, -76, -3, 78, -35, -17, 119};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for one and one
- */
- public void testOneOne() {
- byte aBytes[] = {1};
- byte bBytes[] = {1};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {1};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Or for a positive and a negative numbers; the first is longer
- */
- public void testPosNegFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {-74, 91, 47, -5, -13, -7, -5, -33, -49, -65, -1, -9, -3};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for a positive and a negative number; the first is shorter
- */
- public void testPosNegFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {
- -1, 127, -10, -57, -101, -1, -1, -2, -2, -91, -2, 31, -1, -11, 125,
- -22, -83, 30, 95};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for two numbers of different signs and the same length
- */
- public void testPosNegSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {
- -1, 1, -126, 59, 103, -2, -11, -7, -3, -33, -57, -3, -5, -5, -21};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for two positive numbers; the first is longer
- */
- public void testPosPosFirstLonger() {
- byte aBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {
- 0, -128, 9, 56, 100, -2, -3, -3, -3, 95, 15, -9, 39, 58, -69, 87, 87,
- -17, -73};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Or for two positive numbers; the first is shorter
- */
- public void testPosPosFirstShorter() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {
- -128, 9, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117, 23, 87,
- -25, -75};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {
- 0, -128, 9, 56, 100, -2, -3, -3, -3, 95, 15, -9, 39, 58, -69, 87, 87,
- -17, -73};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Or for two positive numbers of the same length
- */
- public void testPosPosSameLength() {
- byte aBytes[] = {-128, 56, 100, -2, -76, 89, 45, 91, 3, -15, 35, 26, -117};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {
- 0, -2, -3, -4, -4, -1, -66, 95, 47, 123, 59, -13, 39, 30, -97};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Or for a positive number and zero
- */
- public void testPosZero() {
- byte aBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- byte bBytes[] = {0};
- int aSign = 1;
- int bSign = 0;
- byte rBytes[] = {0, -2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- public void testRegression() {
- // Regression test for HARMONY-1996
- BigInteger x = new BigInteger("-1023");
- BigInteger r1 = x.and((BigInteger.ZERO.not()).shiftLeft(32));
- BigInteger r3 = x.and((BigInteger.ZERO.not().shiftLeft(32)).not());
- BigInteger result = r1.or(r3);
- assertEquals(x, result);
- }
-
- /**
- * Or for zero and a negative number
- */
- public void testZeroNeg() {
- byte aBytes[] = {0};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 0;
- int bSign = -1;
- byte rBytes[] = {
- -1, 1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", -1, result.signum());
- }
-
- /**
- * Or for zero and one
- */
- public void testZeroOne() {
- byte aBytes[] = {0};
- byte bBytes[] = {1};
- int aSign = 0;
- int bSign = 1;
- byte rBytes[] = {1};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Or for zero and a positive number
- */
- public void testZeroPos() {
- byte aBytes[] = {0};
- byte bBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- int aSign = 0;
- int bSign = 1;
- byte rBytes[] = {0, -2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 1, result.signum());
- }
-
- /**
- * Or for zero and zero
- */
- public void testZeroZero() {
- byte aBytes[] = {0};
- byte bBytes[] = {0};
- int aSign = 0;
- int bSign = 0;
- byte rBytes[] = {0};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.or(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals("incorrect sign", 0, result.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerSubtractTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerSubtractTest.java
deleted file mode 100644
index 8e6290a..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerSubtractTest.java
+++ /dev/null
@@ -1,547 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Method: subtract
- */
-public class BigIntegerSubtractTest extends EmulTestBase {
- /**
- * Subtract two positive numbers of the same length. The first is greater.
- */
- public void testCase1() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {9, 18, 27, 36, 45, 54, 63, 9, 18, 27};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract two positive numbers of different length. The second is longer.
- */
- public void testCase10() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(-1, result.signum());
- }
-
- /**
- * Subtract two numbers of different length and different signs. The first is
- * positive. The first is greater in absolute value.
- */
- public void testCase11() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract two numbers of the same length and different signs. The first is
- * positive. The second is greater in absolute value.
- */
- public void testCase12() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract two numbers of different length and different signs. The first is
- * negative. The first is longer.
- */
- public void testCase13() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {
- -2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(-1, result.signum());
- }
-
- /**
- * Subtract two numbers of the same length and different signs. The first is
- * negative. The second is longer.
- */
- public void testCase14() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {
- -2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(-1, result.signum());
- }
-
- /**
- * Subtract two negative numbers of different length. The first is longer.
- */
- public void testCase15() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(-1, result.signum());
- }
-
- /**
- * Subtract two negative numbers of different length. The second is longer.
- */
- public void testCase16() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract two positive equal in absolute value numbers.
- */
- public void testCase17() {
- byte aBytes[] = {-120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
- byte bBytes[] = {-120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
- byte rBytes[] = {0};
- int aSign = 1;
- int bSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(0, result.signum());
- }
-
- /**
- * Subtract zero from a number. The number is positive.
- */
- public void testCase18() {
- byte aBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
- byte bBytes[] = {0};
- byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
- int aSign = 1;
- int bSign = 0;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract a number from zero. The number is negative.
- */
- public void testCase19() {
- byte aBytes[] = {0};
- byte bBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
- byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
- int aSign = 0;
- int bSign = -1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract two positive numbers of the same length. The second is greater.
- */
- public void testCase2() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {-10, -19, -28, -37, -46, -55, -64, -10, -19, -27};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(-1, result.signum());
- }
-
- /**
- * Subtract zero from zero.
- */
- public void testCase20() {
- byte aBytes[] = {0};
- byte bBytes[] = {0};
- byte rBytes[] = {0};
- int aSign = 0;
- int bSign = 0;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(0, result.signum());
- }
-
- /**
- * Subtract ZERO from a number. The number is positive.
- */
- public void testCase21() {
- byte aBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
- byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
- int aSign = 1;
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = BigInteger.ZERO;
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract a number from ZERO. The number is negative.
- */
- public void testCase22() {
- byte bBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
- byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
- int bSign = -1;
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract ZERO from ZERO.
- */
- public void testCase23() {
- byte rBytes[] = {0};
- BigInteger aNumber = BigInteger.ZERO;
- BigInteger bNumber = BigInteger.ZERO;
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(0, result.signum());
- }
-
- /**
- * Subtract ONE from ONE.
- */
- public void testCase24() {
- byte rBytes[] = {0};
- BigInteger aNumber = BigInteger.ONE;
- BigInteger bNumber = BigInteger.ONE;
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(0, result.signum());
- }
-
- /**
- * Subtract two numbers so that borrow is 1.
- */
- public void testCase25() {
- byte aBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
- byte bBytes[] = {-128, -128, -128, -128, -128, -128, -128, -128, -128};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {-128, 127, 127, 127, 127, 127, 127, 127, 127};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(-1, result.signum());
- }
-
- /**
- * Subtract two numbers of the same length and different signs. The first is
- * positive. The first is greater in absolute value.
- */
- public void testCase3() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {11, 22, 33, 44, 55, 66, 77, 11, 22, 33};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract two numbers of the same length and different signs. The first is
- * positive. The second is greater in absolute value.
- */
- public void testCase4() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = -1;
- byte rBytes[] = {11, 22, 33, 44, 55, 66, 77, 11, 22, 33};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract two negative numbers of the same length. The first is greater in
- * absolute value.
- */
- public void testCase5() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {-10, -19, -28, -37, -46, -55, -64, -10, -19, -27};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(-1, result.signum());
- }
-
- /**
- * Subtract two negative numbers of the same length. The second is greater in
- * absolute value.
- */
- public void testCase6() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = -1;
- byte rBytes[] = {9, 18, 27, 36, 45, 54, 63, 9, 18, 27};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-
- /**
- * Subtract two numbers of the same length and different signs. The first is
- * negative. The first is greater in absolute value.
- */
- public void testCase7() {
- byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {-12, -23, -34, -45, -56, -67, -78, -12, -23, -33};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(-1, result.signum());
- }
-
- /**
- * Subtract two numbers of the same length and different signs. The first is
- * negative. The second is greater in absolute value.
- */
- public void testCase8() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = -1;
- int bSign = 1;
- byte rBytes[] = {-12, -23, -34, -45, -56, -67, -78, -12, -23, -33};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(-1, result.signum());
- }
-
- /**
- * Subtract two positive numbers of different length. The first is longer.
- */
- public void testCase9() {
- byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
- byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
- int aSign = 1;
- int bSign = 1;
- byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
- BigInteger aNumber = new BigInteger(aSign, aBytes);
- BigInteger bNumber = new BigInteger(bSign, bBytes);
- BigInteger result = aNumber.subtract(bNumber);
- byte resBytes[] = new byte[rBytes.length];
- resBytes = result.toByteArray();
- for (int i = 0; i < resBytes.length; i++) {
- assertTrue(resBytes[i] == rBytes[i]);
- }
- assertEquals(1, result.signum());
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerToStringTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerToStringTest.java
deleted file mode 100644
index 958025c..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerToStringTest.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Method: toString(int radix)
- */
-public class BigIntegerToStringTest extends EmulTestBase {
- /**
- * test negative number of radix 10
- */
- public void testRadix10Neg() {
- String value = "-2489756308572364789878394872984";
- int radix = 16;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(radix);
- assertTrue(result.equals(value));
- }
-
- /**
- * test positive number of radix 10
- */
- public void testRadix10Pos() {
- String value = "2387627892347567398736473476";
- int radix = 16;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(radix);
- assertTrue(result.equals(value));
- }
-
- /**
- * test negative number of radix 16
- */
- public void testRadix16Neg() {
- String value = "-287628a883451b800865c67e8d7ff20";
- int radix = 16;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(radix);
- assertTrue(result.equals(value));
- }
-
- /**
- * test positive number of radix 16
- */
- public void testRadix16Pos() {
- String value = "287628a883451b800865c67e8d7ff20";
- int radix = 16;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(radix);
- assertTrue(result.equals(value));
- }
-
- /**
- * test negative number of radix 24
- */
- public void testRadix24Neg() {
- String value = "-287628a88gmn3451b8ijk00865c67e8d7ff20";
- int radix = 24;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(radix);
- assertTrue(result.equals(value));
- }
-
- /**
- * test positive number of radix 24
- */
- public void testRadix24Pos() {
- String value = "287628a883451bg80ijhk0865c67e8d7ff20";
- int radix = 24;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(radix);
- assertTrue(result.equals(value));
- }
-
- /**
- * test negative number of radix 2
- */
- public void testRadix2Neg() {
- String value = "-101001100010010001001010101110000101010110001010010101010101010101010101010101010101010101010010101";
- int radix = 2;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(radix);
- assertTrue(result.equals(value));
- }
-
- /**
- * test positive number of radix 2
- */
- public void testRadix2Pos() {
- String value = "101000011111000000110101010101010101010001001010101010101010010101010101010000100010010";
- int radix = 2;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(radix);
- assertTrue(result.equals(value));
- }
-
- /**
- * test negative number of radix 24
- */
- public void testRadix36Neg() {
- String value = "-uhguweut98iu4h3478tq3985pq98yeiuth33485yq4aiuhalai485yiaehasdkr8tywi5uhslei8";
- int radix = 36;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(radix);
- assertTrue(result.equals(value));
- }
-
- /**
- * test positive number of radix 24
- */
- public void testRadix36Pos() {
- String value = "23895lt45y6vhgliuwhgi45y845htsuerhsi4586ysuerhtsio5y68peruhgsil4568ypeorihtse48y6";
- int radix = 36;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(radix);
- assertTrue(result.equals(value));
- }
-
- /**
- * If 36 < radix < 2 it should be set to 10
- */
- public void testRadixOutOfRange() {
- String value = "442429234853876401";
- int radix = 10;
- BigInteger aNumber = new BigInteger(value, radix);
- String result = aNumber.toString(45);
- assertTrue(result.equals(value));
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerXorTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerXorTest.java
deleted file mode 100644
index 028fdfa..0000000
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerXorTest.java
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-/**
- * author Elena Semukhina
- */
-package com.google.gwt.emultest.java.math;
-
-import com.google.gwt.emultest.java.util.EmulTestBase;
-
-import java.math.BigInteger;
-
-/**
- * Class: java.math.BigInteger Method: xor
- */
-public class BigIntegerXorTest extends EmulTestBase {
- /**
- * Xor for two negative numbers; the first is longer
- */
- public void testNegNegFirstLonger() {
- String numA = "-2837462783428374767845648748973847593874837948575684767";
- String numB = "-293478573489347658763745839457637";
- String res = "2837462783428374767845615168483972194300564226167553530";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for two negative numbers; the first is shorter
- */
- public void testNegNegFirstShorter() {
- String numA = "293478573489347658763745839457637";
- String numB = "2837462783428374767845648748973847593874837948575684767";
- String res = "2837462783428374767845615168483972194300564226167553530";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for two negative numbers of the same length
- */
- public void testNegNegSameLength() {
- String numA = "-283746278342837476784564875684767";
- String numB = "-293478573489347658763745839457637";
- String res = "71412358434940908477702819237626";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for a negative number and zero
- */
- public void testNegPos() {
- String numA = "-27384627835298756289327365";
- String numB = "0";
- String res = "-27384627835298756289327365";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for a negative and a positive numbers; the first is longer
- */
- public void testNegPosFirstLonger() {
- String numA = "-2837462783428374767845648748973847593874837948575684767";
- String numB = "293478573489347658763745839457637";
- String res = "-2837462783428374767845615168483972194300564226167553532";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for two negative numbers; the first is shorter
- */
- public void testNegPosFirstShorter() {
- String numA = "-293478573489347658763745839457637";
- String numB = "2837462783428374767845648748973847593874837948575684767";
- String res = "-2837462783428374767845615168483972194300564226167553532";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for two numbers of different signs and the same length
- */
- public void testNegPosSameLength() {
- String numA = "-283746278342837476784564875684767";
- String numB = "293478573489347658763745839457637";
- String res = "-71412358434940908477702819237628";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for one and one
- */
- public void testOneOne() {
- String numA = "1";
- String numB = "1";
- String res = "0";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for a positive and a negative numbers; the first is longer
- */
- public void testPosNegFirstLonger() {
- String numA = "2837462783428374767845648748973847593874837948575684767";
- String numB = "-293478573489347658763745839457637";
- String res = "-2837462783428374767845615168483972194300564226167553532";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for a positive and a negative number; the first is shorter
- */
- public void testPosNegFirstShorter() {
- String numA = "293478573489347658763745839457637";
- String numB = "-2837462783428374767845648748973847593874837948575684767";
- String res = "-2837462783428374767845615168483972194300564226167553532";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for two numbers of different signs and the same length
- */
- public void testPosNegSameLength() {
- String numA = "283746278342837476784564875684767";
- String numB = "-293478573489347658763745839457637";
- String res = "-71412358434940908477702819237628";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for two positive numbers; the first is longer
- */
- public void testPosPosFirstLonger() {
- String numA = "2837462783428374767845648748973847593874837948575684767";
- String numB = "293478573489347658763745839457637";
- String res = "2837462783428374767845615168483972194300564226167553530";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for two positive numbers; the first is shorter
- */
- public void testPosPosFirstShorter() {
- String numA = "293478573489347658763745839457637";
- String numB = "2837462783428374767845648748973847593874837948575684767";
- String res = "2837462783428374767845615168483972194300564226167553530";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for two positive numbers of the same length
- */
- public void testPosPosSameLength() {
- String numA = "283746278342837476784564875684767";
- String numB = "293478573489347658763745839457637";
- String res = "71412358434940908477702819237626";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for a positive number and zero
- */
- public void testPosZero() {
- String numA = "27384627835298756289327365";
- String numB = "0";
- String res = "27384627835298756289327365";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for zero and a negative number
- */
- public void testZeroNeg() {
- String numA = "0";
- String numB = "-27384627835298756289327365";
- String res = "-27384627835298756289327365";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for zero and one
- */
- public void testZeroOne() {
- String numA = "0";
- String numB = "1";
- String res = "1";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for zero and a positive number
- */
- public void testZeroPos() {
- String numA = "0";
- String numB = "27384627835298756289327365";
- String res = "27384627835298756289327365";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-
- /**
- * Xor for zero and zero
- */
- public void testZeroZero() {
- String numA = "0";
- String numB = "0";
- String res = "0";
- BigInteger aNumber = new BigInteger(numA);
- BigInteger bNumber = new BigInteger(numB);
- BigInteger result = aNumber.xor(bNumber);
- assertTrue(res.equals(result.toString()));
- }
-}
diff --git a/user/test/com/google/gwt/emultest/java/util/RandomTest.java b/user/test/com/google/gwt/emultest/java/util/RandomTest.java
deleted file mode 100644
index 04a7985..0000000
--- a/user/test/com/google/gwt/emultest/java/util/RandomTest.java
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
- * 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 GOOGLE.
- */
-package com.google.gwt.emultest.java.util;
-
-import com.google.gwt.junit.client.GWTTestCase;
-
-import java.util.Random;
-
-/**
- * Test java.util.Random.
- */
-public class RandomTest extends GWTTestCase {
-
- private Random r = new Random();
-
- @Override
- public String getModuleName() {
- return "com.google.gwt.emultest.EmulSuite";
- }
-
- /**
- * Tests that two generators with the same seed produce the same sequence of
- * values.
- */
- public void test_ConstructorJ() {
- Random r = new Random(8409238L);
- Random r2 = new Random(8409238L);
- for (int i = 0; i < 100; i++) {
- assertEquals("Values from randoms with same seed don't match",
- r.nextInt(), r2.nextInt());
- }
- }
-
- /**
- * Tests {@link java.util.Random#nextBoolean()}.
- */
- public void test_nextBoolean() {
- boolean falseAppeared = false, trueAppeared = false;
- for (int counter = 0; counter < 100; counter++)
- if (r.nextBoolean()) {
- trueAppeared = true;
- } else {
- falseAppeared = true;
- }
- assertTrue("Calling nextBoolean() 100 times resulted in all trues",
- falseAppeared);
- assertTrue("Calling nextBoolean() 100 times resulted in all falses",
- trueAppeared);
- }
-
- /**
- * Tests {@link java.util.Random#nextBytes(byte[])}.
- */
- public void test_nextBytes$B() {
- boolean someDifferent = false;
- byte[] randomBytes = new byte[100];
- r.nextBytes(randomBytes);
- byte firstByte = randomBytes[0];
- for (int counter = 1; counter < randomBytes.length; counter++) {
- if (randomBytes[counter] != firstByte) {
- someDifferent = true;
- }
- }
- assertTrue("nextBytes() returned an array of length 100 of the same byte",
- someDifferent);
- }
-
- /**
- * Tests {@link java.util.Random#nextDouble()}.
- */
- public void test_nextDouble() {
- double lastNum = r.nextDouble();
- double nextNum;
- boolean someDifferent = false;
- boolean inRange = true;
- for (int counter = 0; counter < 100; counter++) {
- nextNum = r.nextDouble();
- if (nextNum != lastNum) {
- someDifferent = true;
- }
- if (!(0 <= nextNum && nextNum < 1.0)) {
- inRange = false;
- }
- lastNum = nextNum;
- }
- assertTrue("Calling nextDouble 100 times resulted in same number",
- someDifferent);
- assertTrue("Calling nextDouble resulted in a number out of range [0,1)",
- inRange);
- }
-
- /**
- * Tests {@link java.util.Random#nextFloat()}.
- */
- public void test_nextFloat() {
- float lastNum = r.nextFloat();
- float nextNum;
- boolean someDifferent = false;
- boolean inRange = true;
- for (int counter = 0; counter < 100; counter++) {
- nextNum = r.nextFloat();
- if (nextNum != lastNum) {
- someDifferent = true;
- }
- if (!(0 <= nextNum && nextNum < 1.0)) {
- inRange = false;
- }
- lastNum = nextNum;
- }
- assertTrue("Calling nextFloat 100 times resulted in same number",
- someDifferent);
- assertTrue("Calling nextFloat resulted in a number out of range [0,1)",
- inRange);
- }
-
- /**
- * Tests {@link java.util.Random#nextGaussian()}.
- */
- public void test_nextGaussian() {
- double lastNum = r.nextGaussian();
- double nextNum;
- boolean someDifferent = false;
- boolean someInsideStd = false;
- for (int counter = 0; counter < 100; counter++) {
- nextNum = r.nextGaussian();
- if (nextNum != lastNum) {
- someDifferent = true;
- }
- if (-1.0 <= nextNum && nextNum <= 1.0) {
- someInsideStd = true;
- }
- lastNum = nextNum;
- }
- assertTrue("Calling nextGaussian 100 times resulted in same number",
- someDifferent);
- assertTrue(
- "Calling nextGaussian 100 times resulted in no number within 1 std. deviation of mean",
- someInsideStd);
- }
-
- /**
- * Tests {@link java.util.Random#nextInt()}.
- */
- public void test_nextInt() {
- int lastNum = r.nextInt();
- int nextNum;
- boolean someDifferent = false;
- for (int counter = 0; counter < 100; counter++) {
- nextNum = r.nextInt();
- if (nextNum != lastNum) {
- someDifferent = true;
- }
- lastNum = nextNum;
- }
- assertTrue("Calling nextInt 100 times resulted in same number",
- someDifferent);
- }
-
- /**
- * Tests {@link java.util.Random#nextInt(int)}.
- */
- public void test_nextIntI() {
- final int range = 10;
- int lastNum = r.nextInt(range);
- int nextNum;
- boolean someDifferent = false;
- boolean inRange = true;
- for (int counter = 0; counter < 100; counter++) {
- nextNum = r.nextInt(range);
- if (nextNum != lastNum) {
- someDifferent = true;
- }
- if (!(0 <= nextNum && nextNum < range)) {
- inRange = false;
- }
- lastNum = nextNum;
- }
- assertTrue("Calling nextInt (range) 100 times resulted in same number",
- someDifferent);
- assertTrue("Calling nextInt (range) resulted in a number outside of [0, range)",
- inRange);
- }
-
- /**
- * Tests {@link java.util.Random#nextLong()}.
- */
- public void test_nextLong() {
- long lastNum = r.nextLong();
- long nextNum;
- boolean someDifferent = false;
- for (int counter = 0; counter < 100; counter++) {
- nextNum = r.nextLong();
- if (nextNum != lastNum) {
- someDifferent = true;
- }
- lastNum = nextNum;
- }
- assertTrue("Calling nextLong 100 times resulted in same number",
- someDifferent);
- }
-
- // two random create at a time should also generated different results
- // regression test for Harmony 4616
- public void test_random_generate() throws Exception {
- for (int i = 0; i < 100; i++) {
- Random random1 = new Random();
- Random random2 = new Random();
- assertFalse(random1.nextLong() == random2.nextLong());
- }
- }
-
- /**
- * Tests {@link java.util.Random#setSeed(long)}.
- */
- public void test_setSeedJ() {
- long[] randomArray = new long[100];
- boolean someDifferent = false;
- long firstSeed = 1000;
- long aLong, anotherLong, yetAnotherLong;
- Random aRandom = new Random();
- Random anotherRandom = new Random();
- Random yetAnotherRandom = new Random();
- aRandom.setSeed(firstSeed);
- anotherRandom.setSeed(firstSeed);
- for (int counter = 0; counter < randomArray.length; counter++) {
- aLong = aRandom.nextLong();
- anotherLong = anotherRandom.nextLong();
- assertEquals("Two randoms with same seeds gave differing nextLong values",
- aLong, anotherLong);
- yetAnotherLong = yetAnotherRandom.nextLong();
- randomArray[counter] = aLong;
- if (aLong != yetAnotherLong) {
- someDifferent = true;
- }
- }
- assertTrue("Two randoms with the different seeds gave the same chain of values",
- someDifferent);
- aRandom.setSeed(firstSeed);
- for (long element : randomArray) {
- assertEquals(
- "Reseting a random to its old seed did not result in the same chain of values as it gave before",
- element, aRandom.nextLong());
- }
- }
-}
diff --git a/user/test/com/google/gwt/i18n/client/I18NTest.java b/user/test/com/google/gwt/i18n/client/I18NTest.java
index 51a10ec..48d6f3a 100644
--- a/user/test/com/google/gwt/i18n/client/I18NTest.java
+++ b/user/test/com/google/gwt/i18n/client/I18NTest.java
@@ -33,8 +33,6 @@
import com.google.gwt.i18n.client.resolutiontest.Inners.InnerClass.LocalizableInnerInner;
import com.google.gwt.junit.client.GWTTestCase;
-import java.math.BigDecimal;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
@@ -561,21 +559,6 @@
assertEquals("estednay underscoray", m.nestedUnderscore());
}
- /**
- * Test that messages works with Number subclasses.
- */
- public void testNumber() {
- TestAnnotatedMessages m = GWT.create(TestAnnotatedMessages.class);
- BigInteger intVal = new BigInteger("1000000000000000000");
- assertEquals("Total is US$1,000,000,000,000,000,000.00",
- m.withNumberCurrency(intVal));
- BigDecimal decVal = new BigDecimal("1000000000000000000.01");
- assertEquals("Total is US$1,000,000,000,000,000,000.01",
- m.withNumberCurrency(decVal));
- assertEquals("Distance is 1.0E18", m.withNumberExponent(intVal));
- assertEquals("Distance is 100.0E6", m.withNumberExponent(1e8f));
- }
-
public void testShapesFamily() {
Shapes shapes = GWT.create(Shapes.class);
// test overload
diff --git a/user/test/com/google/gwt/i18n/client/NumberFormat_en_Test.java b/user/test/com/google/gwt/i18n/client/NumberFormat_en_Test.java
index 8c1c338..b729c16 100644
--- a/user/test/com/google/gwt/i18n/client/NumberFormat_en_Test.java
+++ b/user/test/com/google/gwt/i18n/client/NumberFormat_en_Test.java
@@ -13,15 +13,13 @@
* License for the specific language governing permissions and limitations under
* the License.
*/
+
package com.google.gwt.i18n.client;
import com.google.gwt.junit.client.GWTTestCase;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
/**
- * Test {@link NumberFormat} in the {@code en} locale.
+ * GWT JUnit tests must extend GWTTestCase.
*/
public class NumberFormat_en_Test extends GWTTestCase {
@@ -54,39 +52,18 @@
assertEquals("R$123,456.79", str);
}
+ /**
+ * Add as many tests as you like.
+ */
public void testBasicFormat() {
String str = NumberFormat.getFormat("0.0000").format(123.45789179565757f);
assertEquals("123.4579", str);
-
+
// tests for overflow of mantissa bits during formatting
str = NumberFormat.getFormat("#,##0.000").format(112589990684262.5);
assertEquals("112,589,990,684,262.500", str);
}
- public void testBigDecimal() {
- BigDecimal decVal = new BigDecimal("1000000000000000000000000");
- String str = NumberFormat.getFormat("0.000").format(decVal);
- assertEquals("1000000000000000000000000.000", str);
-
- decVal = decVal.add(new BigDecimal(".1"));
- str = NumberFormat.getFormat("#,##0.000").format(decVal);
- assertEquals("1,000,000,000,000,000,000,000,000.100", str);
-
- decVal = new BigDecimal(".1499999999999999999999");
- str = NumberFormat.getFormat(".0").format(decVal);
- assertEquals(".1", str);
-}
-
- public void testBigInteger() {
- BigInteger intVal = new BigInteger("1000000000000000000000000");
- String str = NumberFormat.getFormat("#,##0").format(intVal);
- assertEquals("1,000,000,000,000,000,000,000,000", str);
-
- intVal = intVal.add(BigInteger.ONE);
- str = NumberFormat.getFormat("#,##0").format(intVal);
- assertEquals("1,000,000,000,000,000,000,000,001", str);
- }
-
public void testCurrency() {
String str;
@@ -117,7 +94,7 @@
assertEquals("BRL 1,234.56", str);
str = formatter.format(-1234.56);
assertEquals("(BRL 1,234.56)", str);
-
+
// Test using a deprecated currency.
formatter = NumberFormat.getCurrencyFormat("ITL");
str = formatter.format(1234.556);
@@ -261,6 +238,18 @@
assertTrue(value == 12345.0);
}
+ public void testGrouping() {
+ String str;
+
+ str = NumberFormat.getFormat("#,###").format(1234567890);
+ assertEquals("1,234,567,890", str);
+ str = NumberFormat.getFormat("#,####").format(1234567890);
+ assertEquals("12,3456,7890", str);
+
+ str = NumberFormat.getFormat("#").format(1234567890);
+ assertEquals("1234567890", str);
+ }
+
public void testForceLatin() {
assertFalse(NumberFormat.forcedLatinDigits());
NumberFormat.setForcedLatinDigits(true);
@@ -274,51 +263,10 @@
NumberFormat unforced = NumberFormat.getDecimalFormat();
assertEquals("3.14", unforced.format(3.14));
}
-
- public void testGrouping() {
- String str;
-
- str = NumberFormat.getFormat("#,###").format(1234567890);
- assertEquals("1,234,567,890", str);
- str = NumberFormat.getFormat("#,####").format(1234567890);
- assertEquals("12,3456,7890", str);
-
- str = NumberFormat.getFormat("#").format(1234567890);
- assertEquals("1234567890", str);
- }
-
- // See external issue 3140
- public void testLeadingZeros() {
- String str;
-
- str = NumberFormat.getFormat("0,000,000,000.#").format(123456789.489123);
- assertEquals("0,123,456,789.5", str);
-
- str = NumberFormat.getFormat("#,###.####").format(0.414014);
- assertEquals("0.414", str); // why leading 0?
-
- str = NumberFormat.getFormat("#.####").format(0.414014);
- assertEquals("0.414", str); // why leading 0?
-
- str = NumberFormat.getFormat("#.0###").format(0.414014);
- assertEquals(".414", str);
-
- str = NumberFormat.getFormat("0.0###").format(0.414014);
- assertEquals("0.414", str);
-
- str = NumberFormat.getFormat("0.####").format(0.414014);
- assertEquals("0.414", str);
-
- str = NumberFormat.getFormat("0.0000").format(0.414014);
- assertEquals("0.4140", str);
-
- str = NumberFormat.getFormat("#.0000").format(0.414014);
- assertEquals(".4140", str);
- }
-
+
public void testNegative() {
String str;
-
+
// verify default negative pattern
str = NumberFormat.getFormat("#,##0.0").format(-0.15);
assertEquals("-0.2", str);
@@ -326,7 +274,7 @@
assertEquals("-15.3%", str);
str = NumberFormat.getFormat("X #,##0.0%").format(-0.1534);
assertEquals("-X 15.3%", str);
-
+
// verify we can specify percent/permille suffixes in both parts
str = NumberFormat.getFormat("#,##0.0%;#,##0.0%-").format(-0.152);
assertEquals("15.2%-", str);
@@ -340,7 +288,7 @@
public void testParseNotANumber() {
try {
- NumberFormat.getDecimalFormat().parse("blue");
+ double d = NumberFormat.getDecimalFormat().parse("blue");
fail("Expected a NumberFormatException");
} catch (NumberFormatException e) {
assertEquals("blue", e.getMessage());
@@ -375,67 +323,6 @@
assertEquals("a'b123", str);
}
- public void testRounding() {
- String str;
-
- str = NumberFormat.getFormat("#0.##").format(0.555);
- assertEquals("0.56", str);
-
- str = NumberFormat.getFormat("#.##").format(30.555);
- assertEquals("30.56", str);
-
- str = NumberFormat.getFormat("#.00").format(0.997);
- assertEquals("1.00", str);
-
- str = NumberFormat.getFormat("#.00").format(-0.997);
- assertEquals("-1.00", str);
-
- str = NumberFormat.getFormat("#.00").format(27.997);
- assertEquals("28.00", str);
-
- str = NumberFormat.getFormat("#.00").format(-27.997);
- assertEquals("-28.00", str);
-
- str = NumberFormat.getFormat("#0.00000").format(1.23456789E-03);
- assertEquals("0.00123", str);
-
- str = NumberFormat.getFormat("#0.0000000").format(1.23456789E-03);
- assertEquals("0.0012346", str);
-
- str = NumberFormat.getFormat("#0.0000").format(1.2E-03);
- assertEquals("0.0012", str);
-
- str = NumberFormat.getFormat("#0.000").format(1.2E-03);
- assertEquals("0.001", str);
-
- str = NumberFormat.getFormat("#0.00").format(1.2E-03);
- assertEquals("0.00", str);
-
- str = NumberFormat.getFormat("#0.0").format(1.2E-03);
- assertEquals("0.0", str);
-
- str = NumberFormat.getFormat("#0.00").format(11.2E-03);
- assertEquals("0.01", str);
-
- str = NumberFormat.getFormat("#0.00").format(111.2E-03);
- assertEquals("0.11", str);
-
- str = NumberFormat.getFormat("#0.00").format(1111.2E-03);
- assertEquals("1.11", str);
-
- str = NumberFormat.getFormat("#0.00000").format(1.23456789E-05);
- assertEquals("0.00001", str);
-
- str = NumberFormat.getFormat("#0.0000000").format(1.23456789E-05);
- assertEquals("0.0000123", str);
-
- str = NumberFormat.getFormat("#0.0000000").format(1.23756789E-05);
- assertEquals("0.0000124", str);
-
- str = NumberFormat.getFormat("#,##,###,##0.00000000000").format(111.18);
- assertEquals("111.18000000000", str);
- }
-
public void testStandardFormat() {
String str;
@@ -449,19 +336,6 @@
assertEquals("1E3", str);
}
- public void testToScaledString() {
- StringBuilder buf = new StringBuilder();
- int scale = NumberFormat.toScaledString(buf, .1);
- String str = buf.toString();
- assertStartsWith("100", str.substring(str.length() + scale));
- assertAllZeros(str, str.length() + scale);
- buf = new StringBuilder();
- scale = NumberFormat.toScaledString(buf, 12345e38);
- str = buf.toString();
- assertStartsWith("12345", str);
- assertEquals(43, scale + str.length());
- }
-
public void testZeros() {
String str;
@@ -483,17 +357,62 @@
str = NumberFormat.getFormat("#").format(0);
assertEquals("0", str);
}
-
- private void assertAllZeros(String str, int prefixLen) {
- if (prefixLen > str.length()) {
- prefixLen = str.length();
- }
- for (int i = 0; i < prefixLen; ++i) {
- assertEquals('0', str.charAt(i));
- }
- }
-
- private void assertStartsWith(String prefix, String str) {
- assertTrue(str + " does not start with " + prefix, str.startsWith(prefix));
+
+ public void testRounding() {
+ String str;
+
+ str = NumberFormat.getFormat("#0.##").format(0.555);
+ assertEquals("0.56", str);
+
+ str = NumberFormat.getFormat("#.##").format(30.555);
+ assertEquals("30.56", str);
+
+ str = NumberFormat.getFormat("#.00").format(0.997);
+ assertEquals("1.00", str);
+
+ str = NumberFormat.getFormat("#.00").format(-0.997);
+ assertEquals("-1.00", str);
+
+ str = NumberFormat.getFormat("#.00").format(27.997);
+ assertEquals("28.00", str);
+
+ str = NumberFormat.getFormat("#.00").format(-27.997);
+ assertEquals("-28.00", str);
+
+ str = NumberFormat.getFormat("#0.00000").format(1.23456789E-03);
+ assertEquals("0.00123", str);
+
+ str = NumberFormat.getFormat("#0.0000000").format(1.23456789E-03);
+ assertEquals("0.0012346", str);
+
+ str = NumberFormat.getFormat("#0.0000").format(1.2E-03);
+ assertEquals("0.0012", str);
+
+ str = NumberFormat.getFormat("#0.000").format(1.2E-03);
+ assertEquals("0.001", str);
+
+ str = NumberFormat.getFormat("#0.00").format(1.2E-03);
+ assertEquals("0.00", str);
+
+ str = NumberFormat.getFormat("#0.0").format(1.2E-03);
+ assertEquals("0.0", str);
+
+ str = NumberFormat.getFormat("#0.00").format(11.2E-03);
+ assertEquals("0.01", str);
+
+ str = NumberFormat.getFormat("#0.00").format(111.2E-03);
+ assertEquals("0.11", str);
+
+ str = NumberFormat.getFormat("#0.00").format(1111.2E-03);
+ assertEquals("1.11", str);
+
+ str = NumberFormat.getFormat("#0.00000").format(1.23456789E-05);
+ assertEquals("0.00001", str);
+
+ str = NumberFormat.getFormat("#0.0000000").format(1.23456789E-05);
+ assertEquals("0.0000123", str);
+
+ str = NumberFormat.getFormat("#0.0000000").format(1.23756789E-05);
+ assertEquals("0.0000124", str);
}
}
diff --git a/user/test/com/google/gwt/i18n/client/TestAnnotatedMessages.java b/user/test/com/google/gwt/i18n/client/TestAnnotatedMessages.java
index 0892190..55210ce 100644
--- a/user/test/com/google/gwt/i18n/client/TestAnnotatedMessages.java
+++ b/user/test/com/google/gwt/i18n/client/TestAnnotatedMessages.java
@@ -88,10 +88,4 @@
@PluralText({"one", "A {0}"})
String twoParamPlural(String name, @PluralCount
int count);
-
- @DefaultMessage("Total is {0,number,currency}")
- String withNumberCurrency(Number value);
-
- @DefaultMessage("Distance is {0,number,##0.0##E0}")
- String withNumberExponent(Number value);
}
