BigInteger

java.lang.Object
- java.lang.Number
- - eve.math.BigInteger

All Implemented Interfaces:

ByteEncodable, Comparable
```
public class BigInteger
extends Number
implements Comparable, ByteEncodable
```
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 (found in Kawa 1.6.62). Status: Believed complete and correct.

Field Summary

Fields
Modifier and Type Field and Description

static BigInteger ONE

static BigInteger ZERO

Fields
Modifier and Type	Field and Description
`static BigInteger`	`ONE`
`static BigInteger`	`ZERO`

Constructor Summary

Constructors
Constructor and Description
`BigInteger(byte[] val)`
`BigInteger(byte[] val, int offset, int numBytes)`
`BigInteger(int value)`
`BigInteger(int signum, byte[] magnitude)`
`BigInteger(int bitLength, int certainty, Random rnd)`
`BigInteger(int numBits, Random rnd)`
`BigInteger(String val)`
`BigInteger(String val, int radix)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and 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 ?
`BigInteger`	`clearBit(int n)`
`int`	`compareTo(BigInteger val)`
`int`	`compareTo(Object obj)` Compare this object with another.
`BigInteger`	`divide(BigInteger val)`
`BigInteger[]`	`divideAndRemainder(BigInteger val)`
`double`	`doubleValue()` Return the value of this `Number` as a `float`.
`byte[]`	`encodeBytes()`
`int`	`encodeBytes(ByteArray dest)` This requests the Object to encode itself as a stream of bytes which is appended to the destination ByteArray.
`boolean`	`equals(Object obj)` Returns if this object is considered equal to the other object.
`BigInteger`	`flipBit(int n)`
`float`	`floatValue()` Return the value of this `Number` as a `float`.
`BigInteger`	`gcd(BigInteger y)`
`int`	`getLowestSetBit()`
`int`	`hashCode()` Returns a hashCode for the object.
`int`	`intValue()` Return the value of this `Number` as an `int`.
`boolean`	`isProbablePrime(int certainty)` Returns `true` if this BigInteger is probably prime, `false` if it's definitely composite.
`long`	`longValue()` Return the value of this `Number` as a `long`.
`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()`
`String`	`toString()` Return a String representation of this object.
`CharArray`	`toString(CharArray dest, int radix)`
`String`	`toString(int radix)`
`static BigInteger`	`valueOf(long val)` Return a (possibly-shared) BigInteger with a given long value.
`int`	`write(byte[] bytes, int offset)` Write the BigInteger as a series of bytes, or find out how many bytes are needed for storing the BigInteger.
`BigInteger`	`xor(BigInteger y)` Return the logical (bit-wise) "exclusive or" of two BigIntegers.

Methods inherited from class java.lang.Number
byteValue, shortValue

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

- Field Detail
  - ZERO
```
public static final BigInteger ZERO
```
  - ONE
```
public static final BigInteger ONE
```
- Constructor Detail
  - BigInteger
```
public BigInteger(int value)
```
  - BigInteger
```
public BigInteger(String val,
                  int radix)
```
  - BigInteger
```
public BigInteger(String val)
```
  - BigInteger
```
public BigInteger(byte[] val)
```
  - BigInteger
```
public BigInteger(byte[] val,
                  int offset,
                  int numBytes)
```
  - BigInteger
```
public BigInteger(int signum,
                  byte[] magnitude)
```
  - 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:
    
    ArithmeticException - if bitLength < 2
    
    Since:
    
    1.4
  - 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(Object obj)
```
    Description copied from interface: Comparable
    
    Compare this object with another. It should return: less than 0 if this object is considered LESS than the "other" object; greater than 0 if this object is considered GREATER than the "other" object; 0 if this object is considered EQUAL to the "other" object. (i.e. it is an implicit subtraction).
    
    Specified by:
    
    compareTo in interface Comparable
  - 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 CharArray toString(CharArray dest,
                          int radix)
```
  - toString
```
public String toString()
```
    Description copied from class: Object
    
    Return a String representation of this object.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a String representing this object.
  - toString
```
public String toString(int radix)
```
  - intValue
```
public int intValue()
```
    Description copied from class: Number
    
    Return the value of this Number as an int.
    
    Specified by:
    
    intValue in class Number
    
    Returns:
    
    the int value
  - longValue
```
public long longValue()
```
    Description copied from class: Number
    
    Return the value of this Number as a long.
    
    Specified by:
    
    longValue in class Number
    
    Returns:
    
    the long value
  - hashCode
```
public int hashCode()
```
    Description copied from class: Object
    
    Returns a hashCode for the object. The general contract of hashCode is:
  - An object must return the same hash code for its entire existence.
  - If two objects are considered equal by the equals() method, they should return the same hash code. Not all Objects will do this and you should only use hashCode() from Objects which declare an overrided version of hashCode(). The only Objects which provide consistent and correct hash codes under Ewe are Object, String and Class.

Overrides:: hashCode in class Object

equals
```
public boolean equals(Object obj)
```
Description copied from class: Object

Returns if this object is considered equal to the other object.

Overrides:

equals in class Object

Parameters:

obj - Another object to compare to.

Returns:

true if this object is considered equal to the other object.

doubleValue
```
public double doubleValue()
```
Description copied from class: Number

Return the value of this Number as a float.

Specified by:

doubleValue in class Number

Returns:

the double value

floatValue
```
public float floatValue()
```
Description copied from class: Number

Return the value of this Number as a float.

Specified by:

floatValue in class Number

Returns:

the float value

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()
```

write
```
public int write(byte[] bytes,
                 int offset)
```
Write the BigInteger as a series of bytes, or find out how many bytes are needed for storing the BigInteger.

Parameters:

data - The destination byte array or null to find out how many bytes are needed.

offset - The offset in the byte array to write to.

Returns:

The number of bytes written or needed to be written.

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.

encodeBytes
```
public int encodeBytes(ByteArray dest)
```
Description copied from interface: ByteEncodable

This requests the Object to encode itself as a stream of bytes which is appended to the destination ByteArray. If the destination ByteArray is null, then the object should report how many bytes would be used if the object was encoded.

Specified by:

encodeBytes in interface ByteEncodable

Parameters:

dest - The destination ByteArray, or null to determine the number of bytes needed to encode.

Returns:

The number of bytes appended to the ByteArray or the number of bytes needed to encode.

encodeBytes
```
public byte[] encodeBytes()
```
Specified by:

encodeBytes in interface ByteEncodable

Class BigInteger

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Field Detail

ZERO

ONE

Constructor Detail

BigInteger

BigInteger

BigInteger

BigInteger

BigInteger

BigInteger

BigInteger

BigInteger

Method Detail

probablePrime

valueOf

signum

compareTo

compareTo

min

max

add

subtract

multiply

divide

remainder

divideAndRemainder

mod

pow

modInverse

modPow

gcd

isProbablePrime

shiftLeft

shiftRight

toString

toString

toString

intValue

longValue

hashCode

equals

doubleValue

floatValue

abs

negate

bitLength

toByteArray

write

and

or

xor

not

andNot

clearBit

setBit

testBit

flipBit

getLowestSetBit

bitCount

encodeBytes

encodeBytes