java.lang.Object
- totalcross.util.BigInteger

All Implemented Interfaces:

Comparable
```
public class BigInteger
extends java.lang.Object
implements Comparable
```
Written using on-line Java Platform 1.2 API Specification, as well as "The Java class libraries", 2nd edition (Addison-Wesley, 1998) and "Applied Cryptography, Second Edition" by Bruce Schneier (Wiley, 1996). Based primarily on IntNum.java BitOps.java by Per Bothner (per@bothner.com) (found in Kawa 1.6.62).

Field Summary

Fields
Modifier and Type	Field	Description
`static BigInteger`	`ONE`	The constant one as a BigInteger.
`static BigInteger`	`TEN`	The constant ten as a BigInteger.
`static BigInteger`	`ZERO`	The constant zero as a BigInteger.

Constructor Summary

Constructors
Constructor	Description
`BigInteger(byte[] val)`
`BigInteger(int signum, byte[] magnitude)`
`BigInteger(int bitLength, int certainty, Random rnd)`
`BigInteger(int numBits, Random rnd)`
`BigInteger(java.lang.String val)`
`BigInteger(java.lang.String s, int radix)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`BigInteger`	`abs()`
`BigInteger`	`add(BigInteger val)`
`BigInteger`	`and(BigInteger y)`	Return the logical (bit-wise) "and" of two BigIntegers.
`BigInteger`	`andNot(BigInteger val)`
`int`	`bitCount()`	Count one bits in a BigInteger.
`int`	`bitLength()`	Calculates ceiling(log2(this < 0 ? -this : this+1)) See Common Lisp: the Language, 2nd ed, p.
`BigInteger`	`clearBit(int n)`
`int`	`compareTo(java.lang.Object other)`	Must return > 0 if this object is greater than the other one, < 0 if its smaller, and 0 if they are equal.
`int`	`compareTo(BigInteger val)`
`BigInteger`	`divide(BigInteger val)`
`BigInteger[]`	`divideAndRemainder(BigInteger val)`
`double`	`doubleValue()`
`boolean`	`equals(java.lang.Object obj)`
`BigInteger`	`flipBit(int n)`
`BigInteger`	`gcd(BigInteger y)`
`int`	`getLowestSetBit()`
`int`	`hashCode()`
`int`	`intValue()`
`boolean`	`isProbablePrime(int certainty)`	Returns `true` if this BigInteger is probably prime, `false` if it's definitely composite.
`long`	`longValue()`
`BigInteger`	`max(BigInteger val)`
`BigInteger`	`min(BigInteger val)`
`BigInteger`	`mod(BigInteger m)`
`BigInteger`	`modInverse(BigInteger y)`
`BigInteger`	`modPow(BigInteger exponent, BigInteger m)`
`BigInteger`	`multiply(BigInteger y)`
`BigInteger`	`negate()`
`BigInteger`	`not()`	Return the logical (bit-wise) negation of a BigInteger.
`BigInteger`	`or(BigInteger y)`	Return the logical (bit-wise) "(inclusive) or" of two BigIntegers.
`BigInteger`	`pow(int exponent)`	Calculate the integral power of a BigInteger.
`static BigInteger`	`probablePrime(int bitLength, Random rnd)`	Return a BigInteger that is bitLength bits long with a probability < 2^-100 of being composite.
`BigInteger`	`remainder(BigInteger val)`
`BigInteger`	`setBit(int n)`
`BigInteger`	`shiftLeft(int n)`
`BigInteger`	`shiftRight(int n)`
`int`	`signum()`
`BigInteger`	`subtract(BigInteger val)`
`boolean`	`testBit(int n)`
`byte[]`	`toByteArray()`
`java.lang.String`	`toString()`
`java.lang.String`	`toString(int radix)`
`void`	`toStringBuffer(int radix, java.lang.StringBuffer sb)`
`static BigInteger`	`valueOf(long val)`	Return a (possibly-shared) BigInteger with a given long value.
`BigInteger`	`xor(BigInteger y)`	Return the logical (bit-wise) "exclusive or" of two BigIntegers.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail
- ZERO
```
public static final BigInteger ZERO
```
  The constant zero as a BigInteger.
- ONE
```
public static final BigInteger ONE
```
  The constant one as a BigInteger.
- TEN
```
public static final BigInteger TEN
```
  The constant ten as a BigInteger.

Constructor Detail

BigInteger

public BigInteger(java.lang.String s,
                  int radix)
           throws InvalidNumberException

Throws:: InvalidNumberException

BigInteger

public BigInteger(java.lang.String val)
           throws InvalidNumberException

Throws:: InvalidNumberException

BigInteger

public BigInteger(byte[] val)
           throws InvalidNumberException

Throws:: InvalidNumberException

BigInteger

public BigInteger(int signum,
                  byte[] magnitude)
           throws InvalidNumberException

Throws:: InvalidNumberException

BigInteger

public BigInteger(int numBits,
                  Random rnd)

BigInteger

public BigInteger(int bitLength,
                  int certainty,
                  Random rnd)

Method Detail

probablePrime
```
public static BigInteger probablePrime(int bitLength,
                                       Random rnd)
```
Return a BigInteger that is bitLength bits long with a probability < 2^-100 of being composite.

Parameters:

bitLength - length in bits of resulting number

rnd - random number generator to use

Throws:

java.lang.ArithmeticException - if bitLength < 2

valueOf
```
public static BigInteger valueOf(long val)
```
Return a (possibly-shared) BigInteger with a given long value.

signum
```
public int signum()
```

compareTo

public int compareTo(BigInteger val)

min

public BigInteger min(BigInteger val)

max

public BigInteger max(BigInteger val)

add

public BigInteger add(BigInteger val)

subtract

public BigInteger subtract(BigInteger val)

multiply

public BigInteger multiply(BigInteger y)

divide

public BigInteger divide(BigInteger val)

remainder

public BigInteger remainder(BigInteger val)

divideAndRemainder

public BigInteger[] divideAndRemainder(BigInteger val)

mod

public BigInteger mod(BigInteger m)

pow
```
public BigInteger pow(int exponent)
```
Calculate the integral power of a BigInteger.

Parameters:

exponent - the exponent (must be non-negative)

modInverse

public BigInteger modInverse(BigInteger y)

modPow

public BigInteger modPow(BigInteger exponent,
                         BigInteger m)

gcd

public BigInteger gcd(BigInteger y)

isProbablePrime
```
public boolean isProbablePrime(int certainty)
```
Returns true if this BigInteger is probably prime, false if it's definitely composite. If certainty is <= 0, true is returned.

Parameters:

certainty - a measure of the uncertainty that the caller is willing to tolerate: if the call returns true the probability that this BigInteger is prime exceeds (1 - 1/2^certainty). The execution time of this method is proportional to the value of this parameter.

Returns:

true if this BigInteger is probably prime, false if it's definitely composite.

shiftLeft

public BigInteger shiftLeft(int n)

shiftRight

public BigInteger shiftRight(int n)

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

toString

public java.lang.String toString(int radix)

toStringBuffer

public void toStringBuffer(int radix,
                           java.lang.StringBuffer sb)

intValue
```
public int intValue()
```

longValue
```
public long longValue()
```

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class java.lang.Object

equals

public boolean equals(java.lang.Object obj)

Overrides:: equals in class java.lang.Object

doubleValue
```
public double doubleValue()
```

abs
```
public BigInteger abs()
```

negate
```
public BigInteger negate()
```

bitLength
```
public int bitLength()
```
Calculates ceiling(log2(this < 0 ? -this : this+1)) See Common Lisp: the Language, 2nd ed, p. 361.

toByteArray
```
public byte[] toByteArray()
```

and
```
public BigInteger and(BigInteger y)
```
Return the logical (bit-wise) "and" of two BigIntegers.

or
```
public BigInteger or(BigInteger y)
```
Return the logical (bit-wise) "(inclusive) or" of two BigIntegers.

xor
```
public BigInteger xor(BigInteger y)
```
Return the logical (bit-wise) "exclusive or" of two BigIntegers.

not
```
public BigInteger not()
```
Return the logical (bit-wise) negation of a BigInteger.

andNot

public BigInteger andNot(BigInteger val)

clearBit
```
public BigInteger clearBit(int n)
```

setBit
```
public BigInteger setBit(int n)
```

testBit
```
public boolean testBit(int n)
```

flipBit
```
public BigInteger flipBit(int n)
```

getLowestSetBit
```
public int getLowestSetBit()
```

bitCount
```
public int bitCount()
```
Count one bits in a BigInteger. If argument is negative, count zero bits instead.

compareTo
```
public int compareTo(java.lang.Object other)
              throws java.lang.ClassCastException
```
Description copied from interface: Comparable

Must return > 0 if this object is greater than the other one, < 0 if its smaller, and 0 if they are equal.

Specified by:

compareTo in interface Comparable

Throws:

java.lang.ClassCastException

Class BigInteger

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ZERO

ONE

TEN

Constructor Detail

BigInteger

BigInteger

BigInteger

BigInteger

BigInteger

BigInteger

Method Detail

probablePrime

valueOf

signum

compareTo

min

max

add

subtract

multiply

divide

remainder

divideAndRemainder

mod

pow

modInverse

modPow

gcd

isProbablePrime

shiftLeft

shiftRight

toString

toString

toStringBuffer

intValue

longValue

hashCode

equals

doubleValue

abs

negate

bitLength

toByteArray

and

or

xor

not

andNot

clearBit

setBit

testBit

flipBit

getLowestSetBit

bitCount

compareTo