FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

BigInteger.java (euclidInv): Return array of `BigInteger's.

Browse source 
2003-02-17  Raif S. Naffah <raif@fl.net.au>

	* java/math/BigInteger.java (euclidInv): Return array of
	`BigInteger's.  Changed all callers.

From-SVN: r63014
This commit is contained in:
Raif S. Naffah 2003-02-17 23:18:39 +00:00 • committed by Tom Tromey
parent 9b0c0e9fb2
commit b9e16504f9
2 changed files with 20 additions and 18 deletions
Download patch file Download diff file Expand all files Collapse all files

5
libjava/ChangeLog
View file

@ -1,3 +1,8 @@
2003-02-17 Raif S. Naffah <raif@fl.net.au>
* java/math/BigInteger.java (euclidInv): Return array of
`BigInteger's. Changed all callers.
2003-02-17 Ranjit Mathew <rmathew@hotmail.com> 2003-02-17 Ranjit Mathew <rmathew@hotmail.com>
* java/util/Properties.java (store): Move the code formerly in * java/util/Properties.java (store): Move the code formerly in

33
libjava/java/math/BigInteger.java
View file

@ -1017,9 +1017,8 @@ public class BigInteger extends Number implements Comparable
return xy; return xy;
} }
private static final void euclidInv(BigInteger a, BigInteger b, private static final BigInteger[] euclidInv(BigInteger a, BigInteger b,
BigInteger prevDiv, BigInteger xy0, BigInteger prevDiv)
BigInteger xy1, BigInteger xy2)
{ {
if (b.isZero()) if (b.isZero())
throw new ArithmeticException("not invertible"); throw new ArithmeticException("not invertible");
@ -1028,20 +1027,20 @@ public class BigInteger extends Number implements Comparable
{ {
// Success: values are indeed invertible! // Success: values are indeed invertible!
// Bottom of the recursion reached; start unwinding. // Bottom of the recursion reached; start unwinding.
// WARNING: xy1 is, and xy0 may be, a shared BI! return new BigInteger[] { neg(prevDiv), ONE };
xy0 = neg(prevDiv);
xy1 = ONE;
return;
} }
BigInteger[] result;
// Recursion happens in the following conditional! // Recursion happens in the following conditional!
// If a just contains an int, then use integer math for the rest. // If a just contains an int, then use integer math for the rest.
if (a.words == null) if (a.words == null)
{ {
int[] xyInt = euclidInv(b.ival, a.ival % b.ival, a.ival / b.ival); int[] xyInt = euclidInv(b.ival, a.ival % b.ival, a.ival / b.ival);
xy0 = new BigInteger(xyInt[0]); // non-shared BI result = new BigInteger[] { // non-shared BI
xy1 = new BigInteger(xyInt[1]); // non-shared BI new BigInteger(xyInt[0]),
new BigInteger(xyInt[1])
};
} }
else else
{ {
@ -1051,15 +1050,13 @@ public class BigInteger extends Number implements Comparable
// quot and rem may not be in canonical form. ensure // quot and rem may not be in canonical form. ensure
rem.canonicalize(); rem.canonicalize();
quot.canonicalize(); quot.canonicalize();
euclidInv(b, rem, quot, xy0, xy1, xy2); result = euclidInv(b, rem, quot);
} }
// xy2 is just temp storage for intermediate results in the following BigInteger t = result[0];
// calculation. This saves us a bit of space over having a BigInteger result[0] = add(result[1], times(t, prevDiv), -1);
// allocated at every level of this recursive method. result[1] = t;
xy2 = xy0; return result;
xy0 = add(xy1, times(xy2, prevDiv), -1);
xy1 = xy2;
} }
public BigInteger modInverse(BigInteger y) public BigInteger modInverse(BigInteger y)
@ -1129,8 +1126,8 @@ public class BigInteger extends Number implements Comparable
quot.canonicalize(); quot.canonicalize();
BigInteger xy0 = new BigInteger(); BigInteger xy0 = new BigInteger();
BigInteger xy1 = new BigInteger(); BigInteger xy1 = new BigInteger();
euclidInv(y, rem, quot, xy0, xy1, result); BigInteger[] xy = euclidInv(y, rem, quot);
result = swapped ? xy0 : xy1; result = swapped ? xy[0] : xy[1];
// Result can't be negative, so make it positive by adding the // Result can't be negative, so make it positive by adding the
// original modulus, y (which is now x if they were swapped). // original modulus, y (which is now x if they were swapped).