Engine
abstract class Engine implements Serializable (View source)
Base Engine.
Properties
protected mixed | $value | Holds the BigInteger's value | |
protected bool | $is_negative | Holds the BigInteger's sign | |
protected | $precision | Precision | |
protected | $bitmask | Precision Bitmask | |
protected callable | $reduce | Recurring Modulo Function |
Methods
Default constructor
Sets engine type.
Converts a BigInteger to a byte string (eg. base-256).
Converts a BigInteger to a hex string (eg. base-16).
Converts a BigInteger to a bit string (eg. base-2).
Serialize
Serialize
Converts a BigInteger to a base-10 number.
__debugInfo() magic method
Set Precision
Get Precision
Set Bitmask
Logical Not
Logical Left Shift
Logical Left Rotate
Logical Right Rotate
Returns the smallest and largest n-bit number
Return the size of a BigInteger in bits
Return the size of a BigInteger in bytes
Sliding Window k-ary Modular Exponentiation
Generates a random prime number of a certain size
Performs some post-processing for randomRangePrime
Sets the $t parameter for primality testing
Tests Primality
Checks a numer to see if it's prime
Performs a few preliminary checks on root
Calculates the nth root of a biginteger.
Return the minimum BigInteger between an arbitrary number of BigIntegers.
Return the minimum BigInteger between an arbitrary number of BigIntegers.
Create Recurring Modulo Function
Calculates the greatest common divisor and Bezout's identity.
Bitwise Split
Details
__construct(mixed $x, int $base)
Default constructor
static
setModExpEngine(string $engine)
Sets engine type.
Throws an exception if the type is invalid
protected string
toBytesHelper()
Converts a BigInteger to a byte string (eg. base-256).
Negative numbers are saved as positive numbers, unless $twos_compliment is set to true, at which point, they're saved as two's compliment.
string
toHex(bool $twos_compliment = false)
Converts a BigInteger to a hex string (eg. base-16).
string
toBits(bool $twos_compliment = false)
Converts a BigInteger to a bit string (eg. base-2).
Negative numbers are saved as positive numbers, unless $twos_compliment is set to true, at which point, they're saved as two's compliment.
protected Engine|false
modInverseHelper(Engine $n)
Calculates modular inverses.
Say you have (30 mod 17 * x mod 17) mod 17 == 1. x can be found using modular inverses.
{@internal See {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf#page=21 HAC 14.64} for more information.}
string
serialize()
Serialize
Will be called, automatically, when serialize() is called on a BigInteger object.
unserialize(string $serialized)
Serialize
Will be called, automatically, when unserialize() is called on a BigInteger object.
string
__toString()
Converts a BigInteger to a base-10 number.
__debugInfo()
__debugInfo() magic method
Will be called, automatically, when print_r() or var_dump() are called
setPrecision(int $bits)
Set Precision
Some bitwise operations give different results depending on the precision being used. Examples include left shift, not, and rotates.
int
getPrecision()
Get Precision
Returns the precision if it exists, -1 if it doesn't
static protected Engine
setBitmask(int $bits)
Set Bitmask
Engine|string
bitwise_not()
Logical Not
static protected string
base256_lshift(string $x, int $shift)
Logical Left Shift
Shifts binary strings $shift bits, essentially multiplying by 2**$shift.
Engine
bitwise_leftRotate(int $shift)
Logical Left Rotate
Instead of the top x bits being dropped they're appended to the shifted bit string.
Engine
bitwise_rightRotate(int $shift)
Logical Right Rotate
Instead of the bottom x bits being dropped they're prepended to the shifted bit string.
static Engine[]
minMaxBits(int $bits)
Returns the smallest and largest n-bit number
int
getLength()
Return the size of a BigInteger in bits
int
getLengthInBytes()
Return the size of a BigInteger in bytes
static protected Engine
slidingWindow(Engine $x, Engine $e, Engine $n, string $class)
Sliding Window k-ary Modular Exponentiation
Based on {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf#page=27 HAC 14.85} / {@link http://math.libtomcrypt.com/files/tommath.pdf#page=210 MPM 7.7}. In a departure from those algorithims, however, this function performs a modular reduction after every multiplication and squaring operation. As such, this function has the same preconditions that the reductions being used do.
static Engine
random(int $size)
Generates a random number of a certain size
Bit length is equal to $size
static Engine
randomPrime(int $size)
Generates a random prime number of a certain size
Bit length is equal to $size
static protected bool|Engine
randomRangePrimeOuter(Engine $min, Engine $max)
Performs some pre-processing for randomRangePrime
static protected Engine
randomRangeHelper(Engine $min, Engine $max)
Generate a random number between a range
Returns a random number between $min and $max where $min and $max can be defined using one of the two methods:
BigInteger::randomRange($min, $max) BigInteger::randomRange($max, $min)
static protected bool|Engine
randomRangePrimeInner(Engine $x, Engine $min, Engine $max)
Performs some post-processing for randomRangePrime
protected int
setupIsPrime()
Sets the $t parameter for primality testing
protected bool
testPrimality(int $t)
Tests Primality
Uses the {@link http://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test Miller-Rabin primality test}. See {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap4.pdf#page=8 HAC 4.24} for more info.
bool
isPrime(int|bool $t = false)
Checks a numer to see if it's prime
Assuming the $t parameter is not set, this function has an error rate of 2**-80. The main motivation for the $t parameter is distributability. BigInteger::randomPrime() can be distributed across multiple pageloads on a website instead of just one.
protected Engine
rootHelper(int $n)
Performs a few preliminary checks on root
protected Engine
rootInner(int $n)
Calculates the nth root of a biginteger.
Returns the nth root of a positive biginteger, where n defaults to 2
{@internal This function is based off of {@link http://mathforum.org/library/drmath/view/52605.html this page} and {@link http://stackoverflow.com/questions/11242920/calculating-nth-root-with-bcmath-in-php this stackoverflow question}.}
Engine
root(int $n = 2)
Calculates the nth root of a biginteger.
static protected Engine
minHelper(array $nums)
Return the minimum BigInteger between an arbitrary number of BigIntegers.
static protected Engine
maxHelper(array $nums)
Return the minimum BigInteger between an arbitrary number of BigIntegers.
callable
createRecurringModuloFunction()
Create Recurring Modulo Function
Sometimes it may be desirable to do repeated modulos with the same number outside of modular exponentiation
protected Engine
extendedGCDHelper(Engine $n, Engine $stop = null)
Calculates the greatest common divisor and Bezout's identity.
Engine[]
bitwise_split(int $split)
Bitwise Split
Splits BigInteger's into chunks of $split bits
protected Engine
bitwiseAndHelper(Engine $x)
Logical And
protected Engine
bitwiseOrHelper(Engine $x)
Logical Or
protected Engine
bitwiseXorHelper(Engine $x)
Logical Exclusive Or