Skip to content

Commit a826557

Browse files
BobHansonBobHanson
committed
fixes MutableBigInteger (mostly for BigDecimal) not set to roll over
integer on overflow. issue #270 and related
1 parent 8d78ad0 commit a826557

File tree

2 files changed

+56
-39
lines changed

2 files changed

+56
-39
lines changed

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

Lines changed: 33 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,6 @@
11
/*
2+
* 2024.02.21 BH modified for SwingJS with a few (more!) (x + 0x80000000)|0 adjustments
3+
*
24
* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
35
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
46
*
@@ -25,7 +27,7 @@
2527

2628
package java.math;
2729

28-
/**
30+
/**
2931
* A class used to represent multiprecision integers that makes efficient
3032
* use of allocated space by allowing a number to occupy only part of
3133
* an array so that the arrays do not have to be reallocated as often.
@@ -294,8 +296,8 @@ private int compareShifted(MutableBigInteger b, int ints) {
294296
// comparison.
295297
int[] bval = b.value;
296298
for (int i = offset, j = b.offset; i < alen + offset; i++, j++) {
297-
int b1 = value[i] + 0x80000000;
298-
int b2 = bval[j] + 0x80000000;
299+
int b1 = (value[i] + 0x80000000)| 0;
300+
int b2 = (bval[j] + 0x80000000)| 0;
299301
if (b1 < b2)
300302
return -1;
301303
if (b1 > b2)
@@ -339,7 +341,7 @@ final int compareHalf(MutableBigInteger b) {
339341
long v = val[i++] & LONG_MASK;
340342
if (v != hb)
341343
return v < hb ? -1 : 1;
342-
carry = (bv & 1) << 31; // carray will be either 0x80000000 or 0
344+
carry = ((bv & 1) << 31)|0; // carray will be either 0x80000000 or 0
343345
}
344346
return carry == 0 ? 0 : -1;
345347
}
@@ -1131,7 +1133,6 @@ int divideOneWord(int divisor, MutableBigInteger quotient) {
11311133
quotient.value[intLen - xlen] = q;
11321134
remLong = rem & LONG_MASK;
11331135
}
1134-
11351136
quotient.normalize();
11361137
// Unnormalize
11371138
if (shift > 0)
@@ -1362,8 +1363,7 @@ private MutableBigInteger divide3n2n(MutableBigInteger b, MutableBigInteger quot
13621363
if (compareShifted(b, n) < 0) {
13631364
// step 3a: if a1<b1, let quotient=a12/b1 and r=a12%b1
13641365
r = a12.divide2n1n(b1, quotient);
1365-
1366-
// step 4: d=quotient*b2
1366+
// step 4: d=quotient*b2
13671367
d = new MutableBigInteger(quotient.toBigInteger().multiply(b2));
13681368
} else {
13691369
// step 3b: if a1>=b1, let quotient=beta^n-1 and r=a12-b1*2^n+b1
@@ -1378,7 +1378,7 @@ private MutableBigInteger divide3n2n(MutableBigInteger b, MutableBigInteger quot
13781378
d.leftShift(32 * n);
13791379
d.subtract(new MutableBigInteger(b2));
13801380
}
1381-
1381+
13821382
// step 5: r = r*beta^n + a3 - d (paper says a4)
13831383
// However, don't subtract d until after the while loop so r doesn't become negative
13841384
r.leftShift(32 * n);
@@ -1548,13 +1548,13 @@ private MutableBigInteger divideMagnitude(MutableBigInteger div,
15481548
int qrem = 0;
15491549
boolean skipCorrection = false;
15501550
int nh = rem.value[j+rem.offset];
1551-
int nh2 = nh + 0x80000000;
1551+
int nh2 = (nh + 0x80000000)| 0;
15521552
int nm = rem.value[j+1+rem.offset];
15531553

15541554
if (nh == dh) {
15551555
qhat = ~0;
15561556
qrem = nh + nm;
1557-
skipCorrection = qrem + 0x80000000 < nh2;
1557+
skipCorrection = ((qrem + 0x80000000)| 0) < nh2;
15581558
} else {
15591559
long nChunk = (((long)nh) << 32) | (nm & LONG_MASK);
15601560
if (nChunk >= 0) {
@@ -1607,13 +1607,13 @@ private MutableBigInteger divideMagnitude(MutableBigInteger div,
16071607
int qrem = 0;
16081608
boolean skipCorrection = false;
16091609
int nh = rem.value[limit - 1 + rem.offset];
1610-
int nh2 = nh + 0x80000000;
1610+
int nh2 = (nh + 0x80000000)|0;
16111611
int nm = rem.value[limit + rem.offset];
16121612

16131613
if (nh == dh) {
16141614
qhat = ~0;
16151615
qrem = nh + nm;
1616-
skipCorrection = qrem + 0x80000000 < nh2;
1616+
skipCorrection = ((qrem + 0x80000000)|0) < nh2;
16171617
} else {
16181618
long nChunk = (((long) nh) << 32) | (nm & LONG_MASK);
16191619
if (nChunk >= 0) {
@@ -1653,7 +1653,7 @@ private MutableBigInteger divideMagnitude(MutableBigInteger div,
16531653
borrow = mulsubBorrow(rem.value, divisor, qhat, dlen, limit - 1 + rem.offset);
16541654

16551655
// D5 Test remainder
1656-
if (borrow + 0x80000000 > nh2) {
1656+
if (((borrow + 0x80000000)|0) > nh2) {
16571657
// D6 Add back
16581658
if(needRemainder)
16591659
divadd(divisor, rem.value, limit - 1 + 1 + rem.offset);
@@ -1723,13 +1723,13 @@ private MutableBigInteger divideLongMagnitude(long ldivisor, MutableBigInteger q
17231723
int qrem = 0;
17241724
boolean skipCorrection = false;
17251725
int nh = rem.value[j + rem.offset];
1726-
int nh2 = nh + 0x80000000;
1726+
int nh2 = (nh + 0x80000000)|0;
17271727
int nm = rem.value[j + 1 + rem.offset];
17281728

17291729
if (nh == dh) {
17301730
qhat = ~0;
17311731
qrem = nh + nm;
1732-
skipCorrection = qrem + 0x80000000 < nh2;
1732+
skipCorrection = ((qrem + 0x80000000)|0) < nh2;
17331733
} else {
17341734
long nChunk = (((long) nh) << 32) | (nm & LONG_MASK);
17351735
if (nChunk >= 0) {
@@ -1767,7 +1767,7 @@ private MutableBigInteger divideLongMagnitude(long ldivisor, MutableBigInteger q
17671767
int borrow = mulsubLong(rem.value, dh, dl, qhat, j + rem.offset);
17681768

17691769
// D5 Test remainder
1770-
if (borrow + 0x80000000 > nh2) {
1770+
if (((borrow + 0x80000000)|0) > nh2) {
17711771
// D6 Add back
17721772
divaddLong(dh,dl, rem.value, j + 1 + rem.offset);
17731773
qhat--;
@@ -1963,7 +1963,7 @@ static int binaryGcd(int a, int b) {
19631963
int t = (aZeros < bZeros ? aZeros : bZeros);
19641964

19651965
while (a != b) {
1966-
if ((a+0x80000000) > (b+0x80000000)) { // a > b as unsigned
1966+
if (((a + 0x80000000)|0) > ((b + 0x80000000)|0)) { // a > b as unsigned
19671967
a -= b;
19681968
a >>>= Integer.numberOfTrailingZeros(a);
19691969
} else {
@@ -2246,4 +2246,20 @@ MutableBigInteger euclidModInverse(int k) {
22462246
mod.subtract(t1);
22472247
return mod;
22482248
}
2249+
2250+
// static {
2251+
// int a = 100;
2252+
// int b = a + 0x80000000;
2253+
// System.out.println(b);
2254+
// System.out.println((a + 0x80000000) | 0);
2255+
// System.out.println(a + 0x80000000L); // NOT in Java
2256+
// System.out.println((int) (a + 0x80000000L));
2257+
// a = -100;
2258+
// b = a + 0x80000000;
2259+
// System.out.println("?");
2260+
// System.out.println(b); //NOT in JS
2261+
// System.out.println((a + 0x80000000) | 0);
2262+
// System.out.println(a + 0x80000000L);
2263+
// System.out.println((int) (a + 0x80000000L));
2264+
// }
22492265
}

‎sources/net.sf.j2s.java.core/src/test/math/MutableBigInteger.java‎

Lines changed: 23 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -294,8 +294,8 @@ private int compareShifted(MutableBigInteger b, int ints) {
294294
// comparison.
295295
int[] bval = b.value;
296296
for (int i = offset, j = b.offset; i < alen + offset; i++, j++) {
297-
int b1 = value[i] + 0x80000000;
298-
int b2 = bval[j] + 0x80000000;
297+
int b1 = (value[i] + 0x80000000)|0;
298+
int b2 = (bval[j] + 0x80000000)|0;
299299
if (b1 < b2)
300300
return -1;
301301
if (b1 > b2)
@@ -889,9 +889,11 @@ void addDisjoint(MutableBigInteger addend, int n) {
889889
for (int i=rstart+1-y+len; i < rstart+1; i++)
890890
result[i] = 0;
891891

892-
value = result;
893892
intLen = resultLen;
894893
offset = result.length - resultLen;
894+
895+
value = result;
896+
895897
}
896898

897899
/**
@@ -939,18 +941,17 @@ int subtract(MutableBigInteger b) {
939941
// Subtract common parts of both numbers
940942
while (y > 0) {
941943
x--; y--;
942-
943-
diff = (a.value[x+a.offset] & LONG_MASK) -
944-
(b.value[y+b.offset] & LONG_MASK) - ((int)-(diff>>32));
944+
// 2024.02.22 BH long-long-int fails, now (long-long)-int
945+
diff = ((a.value[x+a.offset] & LONG_MASK)
946+
- (b.value[y+b.offset] & LONG_MASK)) - (int)-(diff>>32);
945947
result[rstart--] = (int)diff;
946948
}
947-
// Subtract remainder of longer number
949+
// Subtract remainder of longer number
948950
while (x > 0) {
949951
x--;
950-
diff = (a.value[x+a.offset] & LONG_MASK) - ((int)-(diff>>32));
952+
diff = (a.value[x+a.offset] & LONG_MASK) - (int)-(diff>>32);
951953
result[rstart--] = (int)diff;
952954
}
953-
954955
value = result;
955956
intLen = resultLen;
956957
offset = value.length - resultLen;
@@ -1261,6 +1262,8 @@ MutableBigInteger divideAndRemainderBurnikelZiegler(MutableBigInteger b, Mutable
12611262
int n = j * m; // step 2b: block length in 32-bit units
12621263
long n32 = 32L * n; // block length in bits
12631264
int sigma = (int) Math.max(0, n32 - b.bitLength()); // step 3: sigma = max{T | (2^T)*B < beta^n}
1265+
1266+
12641267
MutableBigInteger bShifted = new MutableBigInteger(b);
12651268
bShifted.safeLeftShift(sigma); // step 4a: shift b so its length is a multiple of n
12661269
MutableBigInteger aShifted = new MutableBigInteger (this);
@@ -1278,7 +1281,6 @@ MutableBigInteger divideAndRemainderBurnikelZiegler(MutableBigInteger b, Mutable
12781281
// step 7: z[t-2] = [a[t-1], a[t-2]]
12791282
MutableBigInteger z = aShifted.getBlock(t-2, t, n); // the second to most significant block
12801283
z.addDisjoint(a1, n); // z[t-2]
1281-
12821284
// do schoolbook division on blocks, dividing 2-block numbers by 1-block numbers
12831285
MutableBigInteger qi = new MutableBigInteger();
12841286
MutableBigInteger ri;
@@ -1356,7 +1358,6 @@ private MutableBigInteger divide3n2n(MutableBigInteger b, MutableBigInteger quot
13561358
MutableBigInteger b1 = new MutableBigInteger(b);
13571359
b1.safeRightShift(n * 32);
13581360
BigInteger b2 = b.getLower(n);
1359-
13601361
MutableBigInteger r;
13611362
MutableBigInteger d;
13621363
if (compareShifted(b, n) < 0) {
@@ -1381,6 +1382,7 @@ private MutableBigInteger divide3n2n(MutableBigInteger b, MutableBigInteger quot
13811382

13821383
// step 5: r = r*beta^n + a3 - d (paper says a4)
13831384
// However, don't subtract d until after the while loop so r doesn't become negative
1385+
13841386
r.leftShift(32 * n);
13851387
r.addLower(this, n);
13861388

@@ -1390,7 +1392,6 @@ private MutableBigInteger divide3n2n(MutableBigInteger b, MutableBigInteger quot
13901392
quotient.subtract(MutableBigInteger.ONE);
13911393
}
13921394
r.subtract(d);
1393-
13941395
return r;
13951396
}
13961397

@@ -1548,13 +1549,13 @@ private MutableBigInteger divideMagnitude(MutableBigInteger div,
15481549
int qrem = 0;
15491550
boolean skipCorrection = false;
15501551
int nh = rem.value[j+rem.offset];
1551-
int nh2 = nh + 0x80000000;
1552+
int nh2 = (nh + 0x80000000)|0;
15521553
int nm = rem.value[j+1+rem.offset];
15531554

15541555
if (nh == dh) {
15551556
qhat = ~0;
15561557
qrem = nh + nm;
1557-
skipCorrection = qrem + 0x80000000 < nh2;
1558+
skipCorrection = ((qrem + 0x80000000)|0) < nh2;
15581559
} else {
15591560
long nChunk = (((long)nh) << 32) | (nm & LONG_MASK);
15601561
if (nChunk >= 0) {
@@ -1592,7 +1593,7 @@ private MutableBigInteger divideMagnitude(MutableBigInteger div,
15921593
int borrow = mulsub(rem.value, divisor, qhat, dlen, j+rem.offset);
15931594

15941595
// D5 Test remainder
1595-
if (borrow + 0x80000000 > nh2) {
1596+
if (((borrow + 0x80000000)|0) > nh2) {
15961597
// D6 Add back
15971598
divadd(divisor, rem.value, j+1+rem.offset);
15981599
qhat--;
@@ -1607,13 +1608,13 @@ private MutableBigInteger divideMagnitude(MutableBigInteger div,
16071608
int qrem = 0;
16081609
boolean skipCorrection = false;
16091610
int nh = rem.value[limit - 1 + rem.offset];
1610-
int nh2 = nh + 0x80000000;
1611+
int nh2 = (nh + 0x80000000)|0;
16111612
int nm = rem.value[limit + rem.offset];
16121613

16131614
if (nh == dh) {
16141615
qhat = ~0;
16151616
qrem = nh + nm;
1616-
skipCorrection = qrem + 0x80000000 < nh2;
1617+
skipCorrection = ((qrem + 0x80000000)|0) < nh2;
16171618
} else {
16181619
long nChunk = (((long) nh) << 32) | (nm & LONG_MASK);
16191620
if (nChunk >= 0) {
@@ -1653,7 +1654,7 @@ private MutableBigInteger divideMagnitude(MutableBigInteger div,
16531654
borrow = mulsubBorrow(rem.value, divisor, qhat, dlen, limit - 1 + rem.offset);
16541655

16551656
// D5 Test remainder
1656-
if (borrow + 0x80000000 > nh2) {
1657+
if (((borrow + 0x80000000)|0) > nh2) {
16571658
// D6 Add back
16581659
if(needRemainder)
16591660
divadd(divisor, rem.value, limit - 1 + 1 + rem.offset);
@@ -1723,13 +1724,13 @@ private MutableBigInteger divideLongMagnitude(long ldivisor, MutableBigInteger q
17231724
int qrem = 0;
17241725
boolean skipCorrection = false;
17251726
int nh = rem.value[j + rem.offset];
1726-
int nh2 = nh + 0x80000000;
1727+
int nh2 = (nh + 0x80000000)|0;
17271728
int nm = rem.value[j + 1 + rem.offset];
17281729

17291730
if (nh == dh) {
17301731
qhat = ~0;
17311732
qrem = nh + nm;
1732-
skipCorrection = qrem + 0x80000000 < nh2;
1733+
skipCorrection = ((qrem + 0x80000000)|0) < nh2;
17331734
} else {
17341735
long nChunk = (((long) nh) << 32) | (nm & LONG_MASK);
17351736
if (nChunk >= 0) {
@@ -1767,7 +1768,7 @@ private MutableBigInteger divideLongMagnitude(long ldivisor, MutableBigInteger q
17671768
int borrow = mulsubLong(rem.value, dh, dl, qhat, j + rem.offset);
17681769

17691770
// D5 Test remainder
1770-
if (borrow + 0x80000000 > nh2) {
1771+
if (((borrow + 0x80000000)|0) > nh2) {
17711772
// D6 Add back
17721773
divaddLong(dh,dl, rem.value, j + 1 + rem.offset);
17731774
qhat--;
@@ -1963,7 +1964,7 @@ static int binaryGcd(int a, int b) {
19631964
int t = (aZeros < bZeros ? aZeros : bZeros);
19641965

19651966
while (a != b) {
1966-
if ((a+0x80000000) > (b+0x80000000)) { // a > b as unsigned
1967+
if (((a+0x80000000)|0) > ((b+0x80000000)|0)) { // a > b as unsigned
19671968
a -= b;
19681969
a >>>= Integer.numberOfTrailingZeros(a);
19691970
} else {

0 commit comments

Comments
 (0)