Skip to content

Commit 4b9cbc6

Browse files
hansonrhansonr
hansonr
authored and
hansonr
committed
BigDecimal.divide fix
1 parent 0a0b5b2 commit 4b9cbc6

File tree

1 file changed

+76
-71
lines changed

1 file changed

+76
-71
lines changed

‎sources/net.sf.j2s.java.core/src/java/math/BigDecimal.java‎

Lines changed: 76 additions & 71 deletions
Original file line numberDiff line numberDiff line change
@@ -270,11 +270,11 @@ public class BigDecimal extends Number implements Comparable<BigDecimal> {
270270
*/
271271
private transient long intCompact;
272272

273-
private static StringBuilderHelper myStringBuilder;
273+
// private static StringBuilderHelper myStringBuilder;
274274

275275
// All 18-digit base ten strings fit into a long; not all 19-digit
276276
// strings will
277-
private static final int MAX_COMPACT_DIGITS = 18;
277+
private static final int MAX_COMPACT_DIGITS = 9;
278278

279279
/* Appease the serialization gods */
280280
private static final long serialVersionUID = 6108874887143696463L;
@@ -1010,26 +1010,26 @@ public BigDecimal(double val, MathContext mc) {
10101010

10111011
private final static double[] bufd;
10121012
private final static int[] bufi2;
1013-
private final static byte[] bufb8;
1013+
// private final static byte[] bufb8;
10141014

10151015
static {
10161016
@SuppressWarnings("unused")
10171017
Object buf8 = /** @j2sNative new ArrayBuffer(8) || */null;
10181018
bufd = /** @j2sNative new Float64Array(buf8) || */null;
10191019
bufi2 = /** @j2sNative new Uint32Array(buf8) || */null;
1020-
bufb8 = /** @j2sNative new Uint8Array(buf8) || */null;
1020+
// bufb8 = /** @j2sNative new Uint8Array(buf8) || */null;
10211021
}
10221022

10231023
private static int[] doubleToInt2(double val) {
10241024
bufd[0] = val;
10251025
return bufi2;
10261026
}
10271027

1028-
private static byte[] int2ToByte8(int high, int low) {
1029-
bufi2[0] = low;
1030-
bufi2[1] = high;
1031-
return bufb8;
1032-
}
1028+
// private static byte[] int2ToByte8(int high, int low) {
1029+
// bufi2[0] = low;
1030+
// bufi2[1] = high;
1031+
// return bufb8;
1032+
// }
10331033

10341034
/**
10351035
* Translates a {@code BigInteger} into a {@code BigDecimal}.
@@ -1622,19 +1622,22 @@ public BigDecimal multiply(BigDecimal multiplicand, MathContext mc) {
16221622
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) {
16231623
if (roundingMode < ROUND_UP || roundingMode > ROUND_UNNECESSARY)
16241624
throw new IllegalArgumentException("Invalid rounding mode");
1625-
if (this.intCompact != INFLATED) {
1626-
if ((divisor.intCompact != INFLATED)) {
1627-
return divide(this.intCompact, this.scale, divisor.intCompact, divisor.scale, scale, roundingMode);
1628-
} else {
1629-
return divide(this.intCompact, this.scale, divisor.intVal, divisor.scale, scale, roundingMode);
1630-
}
1631-
} else {
1632-
if ((divisor.intCompact != INFLATED)) {
1633-
return divide(this.intVal, this.scale, divisor.intCompact, divisor.scale, scale, roundingMode);
1634-
} else {
1635-
return divide(this.intVal, this.scale, divisor.intVal, divisor.scale, scale, roundingMode);
1636-
}
1637-
}
1625+
// if (this.intCompact != INFLATED) {
1626+
// if ((divisor.intCompact != INFLATED)) {
1627+
// return divide(this.intCompact, this.scale, divisor.intCompact, divisor.scale, scale, roundingMode);
1628+
// } else {
1629+
// return divide(this.intCompact, this.scale, divisor.intVal, divisor.scale, scale, roundingMode);
1630+
// }
1631+
// } else {
1632+
// if ((divisor.intCompact != INFLATED)) {
1633+
// return divide(this.intVal, this.scale, divisor.intCompact, divisor.scale, scale, roundingMode);
1634+
// } else {
1635+
return divide(this.intVal == null ? BigInteger.valueOf(this.intCompact) : this.intVal,
1636+
this.scale,
1637+
divisor.intVal == null ? BigInteger.valueOf(divisor.intCompact) : divisor.intVal ,
1638+
divisor.scale, scale, roundingMode);
1639+
// }
1640+
// }
16381641
}
16391642

16401643
/**
@@ -2686,7 +2689,8 @@ public BigDecimal stripTrailingZeros() {
26862689
* @return -1, 0, or 1 as this {@code BigDecimal} is numerically
26872690
* less than, equal to, or greater than {@code val}.
26882691
*/
2689-
public int compareTo(BigDecimal val) {
2692+
@Override
2693+
public int compareTo(BigDecimal val) {
26902694
// Quick path for equal scale and non-inflated case.
26912695
if (scale == val.scale) {
26922696
long xs = intCompact;
@@ -3122,7 +3126,8 @@ public BigInteger toBigIntegerExact() {
31223126
*
31233127
* @return this {@code BigDecimal} converted to a {@code long}.
31243128
*/
3125-
public long longValue(){
3129+
@Override
3130+
public long longValue(){
31263131
return (intCompact != INFLATED && scale == 0) ?
31273132
intCompact:
31283133
toBigInteger().longValue();
@@ -3190,7 +3195,8 @@ public static void check(BigDecimal num) {
31903195
*
31913196
* @return this {@code BigDecimal} converted to an {@code int}.
31923197
*/
3193-
public int intValue() {
3198+
@Override
3199+
public int intValue() {
31943200
return (intCompact != INFLATED && scale == 0) ?
31953201
(int)intCompact :
31963202
toBigInteger().intValue();
@@ -3272,7 +3278,8 @@ public byte byteValueExact() {
32723278
*
32733279
* @return this {@code BigDecimal} converted to a {@code float}.
32743280
*/
3275-
public float floatValue(){
3281+
@Override
3282+
public float floatValue(){
32763283
if(intCompact != INFLATED) {
32773284
if (scale == 0) {
32783285
return (float)intCompact;
@@ -3315,7 +3322,8 @@ public float floatValue(){
33153322
*
33163323
* @return this {@code BigDecimal} converted to a {@code double}.
33173324
*/
3318-
public double doubleValue(){
3325+
@Override
3326+
public double doubleValue(){
33193327
if(intCompact != INFLATED) {
33203328
if (scale == 0) {
33213329
return (double)intCompact;
@@ -3952,6 +3960,9 @@ private int checkScale(long val) {
39523960
* {@code BigInteger}.
39533961
*/
39543962
private static long compactValFor(BigInteger b) {
3963+
if (true)
3964+
return INFLATED;
3965+
// SwingJS -- for now we do not allow compact BigInt values
39553966
if (b.isOneInt())
39563967
return b.intValue();
39573968
int[] m = b.mag;
@@ -5282,52 +5293,46 @@ private static BigDecimal divide(long dividend, int dividendScale, long divisor,
52825293
}
52835294
}
52845295

5285-
private static BigDecimal divide(BigInteger dividend, int dividendScale, long divisor, int divisorScale, int scale, int roundingMode) {
5286-
if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) {
5287-
int newScale = scale + divisorScale;
5288-
int raise = newScale - dividendScale;
5289-
BigInteger scaledDividend = bigMultiplyPowerTen(dividend, raise);
5290-
return divideAndRound(scaledDividend, divisor, scale, roundingMode, scale);
5291-
} else {
5292-
int newScale = checkScale(divisor,(long)dividendScale - scale);
5293-
int raise = newScale - divisorScale;
5294-
if(raise<LONG_TEN_POWERS_TABLE.length) {
5295-
long ys = divisor;
5296-
if ((ys = longMultiplyPowerTen(ys, raise)) != INFLATED) {
5297-
return divideAndRound(dividend, ys, scale, roundingMode, scale);
5298-
}
5299-
}
5300-
BigInteger scaledDivisor = bigMultiplyPowerTen(divisor, raise);
5301-
return divideAndRound(dividend, scaledDivisor, scale, roundingMode, scale);
5302-
}
5303-
}
5304-
5305-
private static BigDecimal divide(long dividend, int dividendScale, BigInteger divisor, int divisorScale, int scale, int roundingMode) {
5306-
if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) {
5307-
int newScale = scale + divisorScale;
5308-
int raise = newScale - dividendScale;
5309-
BigInteger scaledDividend = bigMultiplyPowerTen(dividend, raise);
5310-
return divideAndRound(scaledDividend, divisor, scale, roundingMode, scale);
5311-
} else {
5312-
int newScale = checkScale(divisor,(long)dividendScale - scale);
5313-
int raise = newScale - divisorScale;
5314-
BigInteger scaledDivisor = bigMultiplyPowerTen(divisor, raise);
5315-
return divideAndRound(BigInteger.valueOf(dividend), scaledDivisor, scale, roundingMode, scale);
5316-
}
5317-
}
5296+
// private static BigDecimal divide(BigInteger dividend, int dividendScale, long divisor, int divisorScale, int scale, int roundingMode) {
5297+
// if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) {
5298+
// int newScale = scale + divisorScale;
5299+
// int raise = newScale - dividendScale;
5300+
// BigInteger scaledDividend = bigMultiplyPowerTen(dividend, raise);
5301+
// return divideAndRound(scaledDividend, divisor, scale, roundingMode, scale);
5302+
// } else {
5303+
// int newScale = checkScale(divisor,(long)dividendScale - scale);
5304+
// int raise = newScale - divisorScale;
5305+
// if(raise<LONG_TEN_POWERS_TABLE.length) {
5306+
// long ys = divisor;
5307+
// if ((ys = longMultiplyPowerTen(ys, raise)) != INFLATED) {
5308+
// return divideAndRound(dividend, ys, scale, roundingMode, scale);
5309+
// }
5310+
// }
5311+
// BigInteger scaledDivisor = bigMultiplyPowerTen(divisor, raise);
5312+
// return divideAndRound(dividend, scaledDivisor, scale, roundingMode, scale);
5313+
// }
5314+
// }
5315+
//
5316+
// private static BigDecimal divide(long dividend, int dividendScale, BigInteger divisor, int divisorScale, int scale, int roundingMode) {
5317+
// if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) {
5318+
// int newScale = scale + divisorScale;
5319+
// int raise = newScale - dividendScale;
5320+
// BigInteger scaledDividend = bigMultiplyPowerTen(dividend, raise);
5321+
// return divideAndRound(scaledDividend, divisor, scale, roundingMode, scale);
5322+
// } else {
5323+
// int newScale = checkScale(divisor,(long)dividendScale - scale);
5324+
// int raise = newScale - divisorScale;
5325+
// BigInteger scaledDivisor = bigMultiplyPowerTen(divisor, raise);
5326+
// return divideAndRound(BigInteger.valueOf(dividend), scaledDivisor, scale, roundingMode, scale);
5327+
// }
5328+
// }
53185329

53195330
private static BigDecimal divide(BigInteger dividend, int dividendScale, BigInteger divisor, int divisorScale, int scale, int roundingMode) {
5320-
if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) {
5321-
int newScale = scale + divisorScale;
5322-
int raise = newScale - dividendScale;
5323-
BigInteger scaledDividend = bigMultiplyPowerTen(dividend, raise);
5324-
return divideAndRound(scaledDividend, divisor, scale, roundingMode, scale);
5325-
} else {
5326-
int newScale = checkScale(divisor,(long)dividendScale - scale);
5327-
int raise = newScale - divisorScale;
5328-
BigInteger scaledDivisor = bigMultiplyPowerTen(divisor, raise);
5329-
return divideAndRound(dividend, scaledDivisor, scale, roundingMode, scale);
5330-
}
5331+
int newScale = (checkScale(dividend,(long)scale + divisorScale) > dividendScale ?
5332+
scale + divisorScale : checkScale(divisor,(long)dividendScale - scale));
5333+
int raise = newScale - divisorScale;
5334+
BigInteger scaledDividend = bigMultiplyPowerTen(dividend, raise);
5335+
return divideAndRound(scaledDividend, divisor, scale, roundingMode, scale);
53315336
}
53325337

53335338
}

0 commit comments

Comments
 (0)