| Methods Summary |
|---|
| public java.math.BigInteger | abs()Returns a (new) {@code BigInteger} whose value is the absolute value of
{@code this}.
validate1("abs()", this);
if (bigInt.sign() >= 0) return this;
else {
BigInt a = bigInt.copy();
a.setSign(1);
return new BigInteger(a);
}
|
| public java.math.BigInteger | add(java.math.BigInteger val)Returns a new {@code BigInteger} whose value is {@code this + val}.
validate2("add", this, val);
if (val.bigInt.sign() == 0) return this;
if (bigInt.sign() == 0) return val;
return new BigInteger(BigInt.addition(bigInt, val.bigInt));
|
| public java.math.BigInteger | and(java.math.BigInteger val)Returns a new {@code BigInteger} whose value is {@code this & val}.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
this.establishOldRepresentation("and1");
val.establishOldRepresentation("and2");
return Logical.and(this, val).withNewRepresentation("and");
|
| public java.math.BigInteger | andNot(java.math.BigInteger 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())}.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
this.establishOldRepresentation("andNot1");
val.establishOldRepresentation("andNot2");
return Logical.andNot(this, val).withNewRepresentation("andNot");
|
| public int | bitCount()Use {@code bitLength(0)} if you want to know the length of the binary
value in bits.
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}.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
establishOldRepresentation("bitCount");
return BitLevel.bitCount(this);
|
| public int | bitLength()Returns the length of the value's two's complement representation without
leading zeros for positive numbers / without leading ones for negative
values.
The two's complement representation of {@code this} will be at least
{@code bitLength() + 1} bits long.
The value will fit into an {@code int} if {@code bitLength() < 32} or
into a {@code long} if {@code bitLength() < 64}.
// Optimization to avoid unnecessary duplicate representation:
if (!bigIntIsValid && oldReprIsValid) return BitLevel.bitLength(this);
// else:
validate1("bitLength", this);
return bigInt.bitLength();
|
| public java.math.BigInteger | clearBit(int n)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)}.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
establishOldRepresentation("clearBit");
if (testBit(n)) {
return BitLevel.flipBit(this, n);
} else {
return this;
}
|
| public int | compareTo(java.math.BigInteger val)Compares this {@code BigInteger} with {@code val}. Returns one of the
three values 1, 0, or -1.
validate2("compareTo", this, val);
return BigInt.cmp(bigInt, val.bigInt);
|
| java.math.BigInteger | copy()
establishOldRepresentation("copy()");
int[] copyDigits = new int[numberLength];
System.arraycopy(digits, 0, copyDigits, 0, numberLength);
return new BigInteger(sign, numberLength, copyDigits);
|
| final void | cutOffLeadingZeroes()Decreases {@code numberLength} if there are zero high elements.
while ((numberLength > 0) && (digits[--numberLength] == 0)) {
;
}
if (digits[numberLength++] == 0) {
sign = 0;
}
|
| public java.math.BigInteger | divide(java.math.BigInteger divisor)Returns a new {@code BigInteger} whose value is {@code this / divisor}.
validate2("divide", this, divisor);
BigInt quotient = new BigInt();
BigInt.division(bigInt, divisor.bigInt, null, quotient, null);
return new BigInteger(quotient);
|
| public java.math.BigInteger[] | divideAndRemainder(java.math.BigInteger divisor)Returns a {@code BigInteger} array which contains {@code this / divisor}
at index 0 and {@code this % divisor} at index 1.
validate2("divideAndRemainder", this, divisor);
BigInt quotient = new BigInt();
BigInt remainder = new BigInt();
BigInt.division(bigInt, divisor.bigInt, null, quotient, remainder);
BigInteger[] a = new BigInteger[2];
a[0] = new BigInteger(quotient);
a[1] = new BigInteger(remainder);
a[0].validate("divideAndRemainder", "quotient");
a[1].validate("divideAndRemainder", "remainder");
return a;
|
| public double | doubleValue()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.
establishOldRepresentation("doubleValue()");
return Conversion.bigInteger2Double(this);
|
| public boolean | equals(java.lang.Object x)Returns {@code true} if {@code x} is a BigInteger instance and if this
instance is equal to this {@code BigInteger}.
if (this == x) {
return true;
}
if (x instanceof BigInteger) {
return this.compareTo((BigInteger)x) == 0;
}
return false;
|
| void | establishOldRepresentation(java.lang.String caller)
if (!oldReprIsValid) {
sign = bigInt.sign();
if (sign != 0) digits = bigInt.littleEndianIntsMagnitude();
else digits = new int[] { 0 };
numberLength = digits.length;
oldReprIsValid = true;
}
|
| public java.math.BigInteger | flipBit(int n)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}.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
establishOldRepresentation("flipBit");
if (n < 0) {
// math.15=Negative bit address
throw new ArithmeticException(Messages.getString("math.15")); //$NON-NLS-1$
}
return BitLevel.flipBit(this, n);
|
| public float | floatValue()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.
establishOldRepresentation("floatValue()");
return (float) doubleValue();
|
| public java.math.BigInteger | gcd(java.math.BigInteger val)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.
validate2("gcd", this, val);
return new BigInteger(BigInt.gcd(bigInt, val.bigInt, null));
|
| int | getFirstNonzeroDigit()
// validate1("Cordoba-BigInteger: getFirstNonzeroDigit", this);
if( firstNonzeroDigit == -2 ){
int i;
if( this.sign == 0 ){
i = -1;
} else{
for(i=0; digits[i]==0; i++)
;
}
firstNonzeroDigit = i;
}
return firstNonzeroDigit;
|
| public int | getLowestSetBit()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.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
establishOldRepresentation("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]));
|
| public int | hashCode()Returns a hash code for this {@code BigInteger}.
validate1("hashCode", this);
if (hashCode != 0) {
return hashCode;
}
establishOldRepresentation("hashCode");
for (int i = 0; i < digits.length; i ++) {
hashCode = (int)(hashCode * 33 + (digits[i] & 0xffffffff));
}
hashCode = hashCode * sign;
return hashCode;
|
| static int | inplaceAdd(int[] a, int aSize, 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;
|
| public int | intValue()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.
if (bigIntIsValid && (bigInt.twosCompFitsIntoBytes(4))) {
return (int)bigInt.longInt();
}
else {
this.establishOldRepresentation("intValue()");
return (sign * digits[0]);
}
|
| boolean | isOne()Tests if {@code this.abs()} is equals to {@code ONE}
// System.out.println("isOne");
return ((numberLength == 1) && (digits[0] == 1));
|
| public boolean | isProbablePrime(int certainty)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.
validate1("isProbablePrime", this);
return bigInt.isPrime(certainty, null, null);
|
| public long | longValue()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.
if (bigIntIsValid && (bigInt.twosCompFitsIntoBytes(8))) {
establishOldRepresentation("longValue()");
return bigInt.longInt();
}
else {
establishOldRepresentation("longValue()");
long value = (numberLength > 1) ? (((long) digits[1]) << 32)
| (digits[0] & 0xFFFFFFFFL) : (digits[0] & 0xFFFFFFFFL);
return (sign * value);
}
|
| public java.math.BigInteger | max(java.math.BigInteger val)Returns the maximum of this {@code BigInteger} and {@code val}.
return ((this.compareTo(val) == 1) ? this : val);
|
| public java.math.BigInteger | min(java.math.BigInteger val)Returns the minimum of this {@code BigInteger} and {@code val}.
return ((this.compareTo(val) == -1) ? this : val);
|
| public java.math.BigInteger | mod(java.math.BigInteger m)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.
if (m.signum() <= 0) {
// math.18=BigInteger: modulus not positive
throw new ArithmeticException(Messages.getString("math.18")); //$NON-NLS-1$
}
validate2("mod", this, m);
return new BigInteger(BigInt.modulus(bigInt, m.bigInt, null));
|
| public java.math.BigInteger | modInverse(java.math.BigInteger m)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.
if (m.signum() <= 0) {
// math.18=BigInteger: modulus not positive
throw new ArithmeticException(Messages.getString("math.18")); //$NON-NLS-1$
}
validate2("modInverse", this, m);
return new BigInteger(BigInt.modInverse(bigInt, m.bigInt, null));
|
| public java.math.BigInteger | modPow(java.math.BigInteger exponent, java.math.BigInteger m)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.
if (m.signum() <= 0) {
// math.18=BigInteger: modulus not positive
throw new ArithmeticException(Messages.getString("math.18")); //$NON-NLS-1$
}
BigInteger base;
if (exponent.signum() < 0) {
base = modInverse(m);
// exponent = exponent.negate(); // Not needed as sign is ignored anyway!
} else {
base = this;
}
validate3("modPow", base, exponent, m);
return new BigInteger(BigInt.modExp(base.bigInt, exponent.bigInt, m.bigInt, null));
|
| public java.math.BigInteger | multiply(java.math.BigInteger val)Returns a new {@code BigInteger} whose value is {@code this * val}.
validate2("multiply", this, val);
return new BigInteger(BigInt.product(bigInt, val.bigInt, null));
|
| static int | multiplyByInt(int[] res, int[] a, int aSize, int factor)
long carry = 0;
for (int i = 0; i < aSize; i++) {
carry += (a[i] & 0xFFFFFFFFL) * (factor & 0xFFFFFFFFL);
res[i] = (int)carry;
carry >>>= 32;
}
return (int)carry;
|
| public java.math.BigInteger | negate()Returns a new {@code BigInteger} whose value is the {@code -this}.
validate1("negate()", this);
int sign = bigInt.sign();
if (sign == 0) return this;
else {
BigInt a = bigInt.copy();
a.setSign(-sign);
return new BigInteger(a);
}
|
| public java.math.BigInteger | nextProbablePrime()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).
if (sign < 0) {
// math.1A=start < 0: {0}
throw new ArithmeticException(Messages.getString("math.1A", this)); //$NON-NLS-1$
}
return Primality.nextProbablePrime(this);
|
| public java.math.BigInteger | not()Returns a new {@code BigInteger} whose value is {@code ~this}. The result
of this operation is {@code -this-1}.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
this.establishOldRepresentation("not");
return Logical.not(this).withNewRepresentation("not");
|
| public java.math.BigInteger | or(java.math.BigInteger val)Returns a new {@code BigInteger} whose value is {@code this | val}.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
this.establishOldRepresentation("or1");
val.establishOldRepresentation("or2");
return Logical.or(this, val).withNewRepresentation("or");
|
| public java.math.BigInteger | pow(int exp)Returns a new {@code BigInteger} whose value is {@code this ^ exp}.
if (exp < 0) {
// math.16=Negative exponent
throw new ArithmeticException(Messages.getString("math.16")); //$NON-NLS-1$
}
validate1("pow", this);
return new BigInteger(BigInt.exp(bigInt, exp, null));
|
| public static java.math.BigInteger | probablePrime(int bitLength, java.util.Random rnd)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).
Implementation Note: Currently {@code rnd} is ignored.
return new BigInteger(bitLength, 100, rnd);
|
| private void | readObject(java.io.ObjectInputStream in)Assignes all transient fields upon deserialization of a
{@code BigInteger} instance.
in.defaultReadObject();
bigInt = new BigInt();
bigInt.putBigEndian(magnitude, (signum < 0));
bigIntIsValid = true;
// !oldReprIsValid
|
| public java.math.BigInteger | remainder(java.math.BigInteger divisor)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.
validate2("remainder", this, divisor);
BigInt remainder = new BigInt();
BigInt.division(bigInt, divisor.bigInt, null, null, remainder);
return new BigInteger(remainder);
|
| public java.math.BigInteger | setBit(int n)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}.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
establishOldRepresentation("setBit");
if( !testBit( n ) ){
return BitLevel.flipBit(this, n);
}else{
return this;
}
|
| private static void | setFromString(java.math.BigInteger bi, java.lang.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 = multiplyByInt(digits, digits, digitIndex, bigRadix);
newDigit += inplaceAdd(digits, digitIndex, bigRadixDigit);
digits[digitIndex++] = newDigit;
}
numberLength = digitIndex;
bi.sign = sign;
bi.numberLength = numberLength;
bi.digits = digits;
bi.cutOffLeadingZeroes();
bi.oldReprIsValid = true;
bi.withNewRepresentation("Cordoba-BigInteger: private static setFromString");
|
| public java.math.BigInteger | shiftLeft(int n)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))}.
Implementation Note: Usage of this method on negative values is
not recommended as the current implementation is not efficient.
if (n == 0) return this;
int sign = signum();
if (sign == 0) return this;
if ((sign > 0) || (n >= 0)) {
validate1("shiftLeft", this);
return new BigInteger(BigInt.shift(bigInt, n));
}
else {
// Negative numbers faking 2's complement:
// Not worth optimizing this:
// Sticking to Harmony Java implementation.
//
return BitLevel.shiftRight(this, -n);
}
|
| public java.math.BigInteger | shiftRight(int 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.
Implementation Note: Usage of this method on negative values is
not recommended as the current implementation is not efficient.
return shiftLeft(-n);
|
| public int | signum()Returns the sign of this {@code BigInteger}.
// Optimization to avoid unnecessary duplicate representation:
if (oldReprIsValid) return sign;
// else:
validate1("signum", this);
return bigInt.sign();
|
| public java.math.BigInteger | subtract(java.math.BigInteger val)Returns a new {@code BigInteger} whose value is {@code this - val}.
validate2("subtract", this, val);
if (val.bigInt.sign() == 0) return this;
else return new BigInteger(BigInt.subtraction(bigInt, val.bigInt));
|
| public boolean | testBit(int n)Tests whether the bit at position n in {@code this} is set. The result is
equivalent to {@code this & (2^n) != 0}.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
if (n < 0) {
// math.15=Negative bit address
throw new ArithmeticException(Messages.getString("math.15")); //$NON-NLS-1$
}
int sign = signum();
if ((sign > 0) && bigIntIsValid && !oldReprIsValid) {
validate1("testBit", this);
return bigInt.isBitSet(n);
}
else {
// Negative numbers faking 2's complement:
// Not worth optimizing this:
// Sticking to Harmony Java implementation.
//
establishOldRepresentation("testBit");
if (n == 0) {
return ((digits[0] & 1) != 0);
}
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);
}
|
| public byte[] | toByteArray()Returns the two's complement representation of this BigInteger in a byte
array.
return twosComplement();
|
| public java.lang.String | toString()Returns a string representation of this {@code BigInteger} in decimal
form.
validate1("toString()", this);
return bigInt.decString();
|
| public java.lang.String | toString(int radix)Returns a string containing a string representation of this {@code
BigInteger} with base radix. If {@code radix < Character.MIN_RADIX} or
{@code radix > Character.MAX_RADIX} then a decimal representation is
returned. The characters of the string representation are generated with
method {@code Character.forDigit}.
validate1("toString(int radix)", this);
if (radix == 10) {
return bigInt.decString();
// } else if (radix == 16) {
// return bigInt.hexString();
} else {
establishOldRepresentation("toString(int radix)");
return Conversion.bigInteger2String(this, radix);
}
|
| private byte[] | twosComplement()Returns the two's complement representation of this BigInteger in a byte
array.
establishOldRepresentation("twosComplement()");
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;
|
| void | unCache()
firstNonzeroDigit = -2;
|
| void | validate(java.lang.String caller, java.lang.String param)
if (bigIntIsValid) {
if (bigInt == null)
System.out.print("Claiming bigIntIsValid BUT bigInt == null, ");
else if (bigInt.getNativeBIGNUM() == 0)
System.out.print("Claiming bigIntIsValid BUT bigInt.bignum == 0, ");
}
else {
if (oldReprIsValid) { // establish new representation
if (bigInt == null) bigInt = new BigInt();
bigInt.putLittleEndianInts(digits, (sign < 0));
bigIntIsValid = true;
}
else {
throw new IllegalArgumentException(caller + ":" + param);
}
}
|
| static void | validate1(java.lang.String caller, java.math.BigInteger a)
a.validate(caller, "1");
|
| static void | validate2(java.lang.String caller, java.math.BigInteger a, java.math.BigInteger b)
a.validate(caller, "1");
b.validate(caller, "2");
|
| static void | validate3(java.lang.String caller, java.math.BigInteger a, java.math.BigInteger b, java.math.BigInteger c)
a.validate(caller, "1");
b.validate(caller, "2");
c.validate(caller, "3");
|
| static void | validate4(java.lang.String caller, java.math.BigInteger a, java.math.BigInteger b, java.math.BigInteger c, java.math.BigInteger d)
a.validate(caller, "1");
b.validate(caller, "2");
c.validate(caller, "3");
d.validate(caller, "4");
|
| public static java.math.BigInteger | valueOf(long val)Creates a new {@code BigInteger} whose value is equal to the specified
{@code long} argument.
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);
}
|
| java.math.BigInteger | withNewRepresentation(java.lang.String caller)
bigIntIsValid = false;
return this;
|
| private void | writeObject(java.io.ObjectOutputStream out)Prepares this {@code BigInteger} for serialization, i.e. the
non-transient fields {@code signum} and {@code magnitude} are assigned.
validate("writeObject", "this");
signum = bigInt.sign();
// if (magnitude == null)
magnitude = bigInt.bigEndianMagnitude();
out.defaultWriteObject();
|
| public java.math.BigInteger | xor(java.math.BigInteger val)Returns a new {@code BigInteger} whose value is {@code this ^ val}.
Implementation Note: Usage of this method is not recommended as
the current implementation is not efficient.
this.establishOldRepresentation("xor1");
val.establishOldRepresentation("xor2");
return Logical.xor(this, val).withNewRepresentation("xor");
|
