Skip to content

Commit f331ae1

Browse files
hansonrhansonr
hansonr
authored and
hansonr
committed
BigInteger tests passing; BigDecimal testing
1 parent bc47990 commit f331ae1

File tree

8 files changed

+1756
-685
lines changed

8 files changed

+1756
-685
lines changed

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

Lines changed: 172 additions & 134 deletions
Large diffs are not rendered by default.

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

Lines changed: 335 additions & 284 deletions
Large diffs are not rendered by default.

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

Lines changed: 31 additions & 14 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];// SwingJS 24-bit ints are unsigned + Integer.MIN_VALUE;
298+
int b2 = bval[j];// + Integer.MIN_VALUE;
299299
if (b1 < b2)
300300
return -1;
301301
if (b1 > b2)
@@ -326,7 +326,7 @@ final int compareHalf(MutableBigInteger b) {
326326
if (len != blen) { // len == blen - 1
327327
if (bval[bstart] == 1) {
328328
++bstart;
329-
carry = 0x80000000;
329+
carry = BigInteger.CARRY_BIT;
330330
} else
331331
return -1;
332332
}
@@ -339,7 +339,7 @@ final int compareHalf(MutableBigInteger b) {
339339
long v = BigInteger.getLowBits(val[i++]);
340340
if (v != hb)
341341
return v < hb ? -1 : 1;
342-
carry = ((bv & 1) == 1 ? (int)BigInteger.TWO_TO_THE[BigInteger.BITS_PER_INT - 1] : 0);
342+
carry = ((bv & 1) == 1 ? BigInteger.CARRY_BIT : 0);
343343
// (bv & 1) << BigInteger.BITS_PER_INT - 1; // carry will be either 0x80000000 or 0
344344
}
345345
return carry == 0 ? 0 : -1;
@@ -1369,7 +1369,11 @@ private MutableBigInteger divide3n2n(MutableBigInteger b, MutableBigInteger quot
13691369

13701370
MutableBigInteger r;
13711371
MutableBigInteger d;
1372+
1373+
13721374
if (compareShifted(b, n) < 0) {
1375+
1376+
13731377
// step 3a: if a1<b1, let quotient=a12/b1 and r=a12%b1
13741378
r = a12.divide2n1n(b1, quotient);
13751379

@@ -2035,13 +2039,13 @@ MutableBigInteger modInverseMP2(int k) {
20352039
if (k > 64)
20362040
return euclidModInverse(k);
20372041

2038-
int t = inverseMod32(value[offset+intLen-1]);
2042+
int t = inverseMod24(value[offset+intLen-1]);
20392043

20402044
if (k <= BigInteger.BITS_PER_INT) {
20412045
t = (k == BigInteger.BITS_PER_INT ? t : t & ((1 << k) - 1));
20422046
return new MutableBigInteger(t);
20432047
}
2044-
2048+
20452049
long pLong = BigInteger.getLowBits(value[offset+intLen-1]);
20462050
if (intLen > 1)
20472051
pLong += BigInteger.toHighBits(value[offset+intLen-2]);
@@ -2057,17 +2061,30 @@ MutableBigInteger modInverseMP2(int k) {
20572061
return result;
20582062
}
20592063

2064+
// /**
2065+
// * Returns the multiplicative inverse of val mod 2^32. Assumes val is odd.
2066+
// */
2067+
// static int inverseMod32(int val) {
2068+
// // Newton's iteration!
2069+
// int t = val;
2070+
// t *= 2 - val*t;
2071+
// t *= 2 - val*t;
2072+
// t *= 2 - val*t;
2073+
// t *= 2 - val*t;
2074+
// return t;
2075+
// }
2076+
20602077
/**
2061-
* Returns the multiplicative inverse of val mod 2^32. Assumes val is odd.
2078+
* SwingJS: Returns the multiplicative inverse of val mod 2^24. Assumes val is odd.
20622079
*/
2063-
static int inverseMod32(int val) {
2080+
static int inverseMod24(int val) {
2081+
// we must use 24 bits in SwingJS for 24-bit integer
2082+
// see http://marc-b-reynolds.github.io/math/2017/09/18/ModInverse.html
20642083
// Newton's iteration!
20652084
int t = val;
2066-
t *= 2 - val*t;
2067-
t *= 2 - val*t;
2068-
t *= 2 - val*t;
2069-
t *= 2 - val*t;
2070-
return t;
2085+
t = (t * ((2 - val*t)&0xFFFFFF))&0xFFFFFF;
2086+
t = (t * ((2 - val*t)&0xFFFFFF))&0xFFFFFF;
2087+
return (t * ((2 - val*t)&0xFFFFFF))&0xFFFFFF;
20712088
}
20722089

20732090
/**
@@ -2149,7 +2166,7 @@ static MutableBigInteger fixup(MutableBigInteger c, MutableBigInteger p,
21492166
int k) {
21502167
MutableBigInteger temp = new MutableBigInteger();
21512168
// Set r to the multiplicative inverse of p mod 2^32
2152-
int r = -inverseMod32(p.value[p.offset+p.intLen-1]);
2169+
int r = -inverseMod24(p.value[p.offset+p.intLen-1]);
21532170

21542171
for (int i=0, numWords = k / BigInteger.BITS_PER_INT; i < numWords; i++) {
21552172
// V = R * c (mod 2^j)

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

Lines changed: 135 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,135 @@
1+
/*
2+
* Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
3+
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+
*
5+
* This code is free software; you can redistribute it and/or modify it
6+
* under the terms of the GNU General Public License version 2 only, as
7+
* published by the Free Software Foundation. Oracle designates this
8+
* particular file as subject to the "Classpath" exception as provided
9+
* by Oracle in the LICENSE file that accompanied this code.
10+
*
11+
* This code is distributed in the hope that it will be useful, but WITHOUT
12+
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+
* version 2 for more details (a copy is included in the LICENSE file that
15+
* accompanied this code).
16+
*
17+
* You should have received a copy of the GNU General Public License version
18+
* 2 along with this work; if not, write to the Free Software Foundation,
19+
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+
*
21+
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+
* or visit www.oracle.com if you need additional information or have any
23+
* questions.
24+
*/
25+
26+
package java.math;
27+
28+
/**
29+
* A class used to represent multiprecision integers that makes efficient
30+
* use of allocated space by allowing a number to occupy only part of
31+
* an array so that the arrays do not have to be reallocated as often.
32+
* When performing an operation with many iterations the array used to
33+
* hold a number is only increased when necessary and does not have to
34+
* be the same size as the number it represents. A mutable number allows
35+
* calculations to occur on the same number without having to create
36+
* a new number for every step of the calculation as occurs with
37+
* BigIntegers.
38+
*
39+
* Note that SignedMutableBigIntegers only support signed addition and
40+
* subtraction. All other operations occur as with MutableBigIntegers.
41+
*
42+
* @see BigInteger
43+
* @author Michael McCloskey
44+
* @since 1.3
45+
*/
46+
47+
class SignedMutableBigInteger extends MutableBigInteger {
48+
49+
/**
50+
* The sign of this MutableBigInteger.
51+
*/
52+
int sign = 1;
53+
54+
// Constructors
55+
56+
/**
57+
* The default constructor. An empty MutableBigInteger is created with
58+
* a one word capacity.
59+
*/
60+
SignedMutableBigInteger() {
61+
super();
62+
}
63+
64+
/**
65+
* Construct a new MutableBigInteger with a magnitude specified by
66+
* the int val.
67+
*/
68+
SignedMutableBigInteger(int val) {
69+
super(val);
70+
}
71+
72+
/**
73+
* Construct a new MutableBigInteger with a magnitude equal to the
74+
* specified MutableBigInteger.
75+
*/
76+
SignedMutableBigInteger(MutableBigInteger val) {
77+
super(val);
78+
}
79+
80+
// Arithmetic Operations
81+
82+
/**
83+
* Signed addition built upon unsigned add and subtract.
84+
*/
85+
void signedAdd(SignedMutableBigInteger addend) {
86+
if (sign == addend.sign)
87+
add(addend);
88+
else
89+
sign = sign * subtract(addend);
90+
91+
}
92+
93+
/**
94+
* Signed addition built upon unsigned add and subtract.
95+
*/
96+
void signedAdd(MutableBigInteger addend) {
97+
if (sign == 1)
98+
add(addend);
99+
else
100+
sign = sign * subtract(addend);
101+
102+
}
103+
104+
/**
105+
* Signed subtraction built upon unsigned add and subtract.
106+
*/
107+
void signedSubtract(SignedMutableBigInteger addend) {
108+
if (sign == addend.sign)
109+
sign = sign * subtract(addend);
110+
else
111+
add(addend);
112+
113+
}
114+
115+
/**
116+
* Signed subtraction built upon unsigned add and subtract.
117+
*/
118+
void signedSubtract(MutableBigInteger addend) {
119+
if (sign == 1)
120+
sign = sign * subtract(addend);
121+
else
122+
add(addend);
123+
if (intLen == 0)
124+
sign = 1;
125+
}
126+
127+
/**
128+
* Print out the first intLen ints of this MutableBigInteger's value
129+
* array starting at offset.
130+
*/
131+
public String toString() {
132+
return this.toBigInteger(sign).toString();
133+
}
134+
135+
}

0 commit comments

Comments
 (0)