- License
- Botan is released under the Simplified BSD License (see LICENSE.md)
BigInt
struct BigInt;
Arbitrary precision integer
class DivideByZero: object.Exception;
DivideByZero Exception
this(T)(T n) if (isNumeric!T);
- Parameters
T n initial value of this BigInt
Create BigInt from any integer
ref BigInt opAssign(size_t other);
Move constructor
this(in string str);
- Parameters
string str the string to parse for an integer value
Create BigInt from a string. If the string starts with 0x the rest of the string will be interpreted as hexadecimal digits. Otherwise, it will be interpreted as a decimal number.
this(const(ubyte)* input, size_t length, Base base = Binary);
- Parameters
const(ubyte)* input the ubyte array holding the value size_t length size of buf Base base is the number base of the integer in buf
Create a BigInt from an integer in a ubyte array
this(RandomNumberGenerator rng, size_t bits);
- Parameters
RandomNumberGenerator rng random number generator size_t bits size in bits
Create a random BigInt of the specified size
this(Sign s, size_t size);
- Parameters
Sign s the sign size_t size of the internal register in words
Create BigInt of specified size, all zeros
this()(auto ref BigInt other);
Move constructor
void opAssign()(auto ref BigInt other);
Move assignment
void swap()(auto ref BigInt other);
- Parameters
BigInt other BigInt to swap values with
Copy assignment
Swap this value with another
void opOpAssign(string op)(auto ref const BigInt y) if (op == "+");
- Parameters
BigInt y the BigInt to add to this
+= operator
void opOpAssign(string op)(auto ref const BigInt y) if (op == "-");
- Parameters
BigInt y the BigInt to subtract from this
-= operator
void opOpAssign(string op)(ref const BigInt y) if (op == "*");
- Parameters
BigInt y the BigInt to multiply with this
*= operator
void opOpAssign(string op)(auto ref const BigInt y) if (op == "/");
- Parameters
BigInt y the BigInt to divide this by
/= operator
void opOpAssign(string op)(auto ref const BigInt mod) if (op == "%");
- Parameters
BigInt mod the modulus to reduce this by
Modulo operator
void opOpAssign(string op)(word mod) if (op == "%");
- Parameters
word mod the modulus (word) to reduce this by
Modulo operator
void opOpAssign(string op)(size_t shift) if (op == "<<");
- Parameters
size_t shift the number of bits to shift this left by
Left shift operator
void opOpAssign(string op)(size_t shift) if (op == ">>");
- Parameters
size_t shift the number of bits to shift this right by
Right shift operator
ref BigInt opUnary(string op)() if (op == "++");
Increment operator
ref BigInt opUnary(string op)() if (op == "--");
Decrement operator
const BigInt opUnary(string op)() if (op == "-");
- Returns
- negative this
Unary negation operator
const T opCast(T : bool)();
- Returns
- true iff this is not zero, otherwise false
bool cast
void clear();
Zeroize the BigInt. The size of the underlying register is not modified.
const int cmp(ref const BigInt other, bool check_signs = true);
- Parameters
BigInt other the BigInt value to compare with bool check_signs include sign in comparison? - Returns
- if (this
Compare this to another BigInt
const bool isEven();
- Returns
- true if the integer is even, false otherwise
Test if the integer has an even value
const bool isOdd();
- Returns
- true if the integer is odd, false otherwise
Test if the integer has an odd value
const bool isNonzero();
- Returns
- true if the integer is non-zero, false otherwise
Test if the integer is not zero
const bool isZero();
- Returns
- true if the integer is zero, false otherwise
Test if the integer is zero
void setBit(size_t n);
- Parameters
size_t n bit position to set
Set bit at specified position
void clearBit(size_t n);
- Parameters
size_t n bit position to clear
Clear bit at specified position
void maskBits(size_t n);
- Parameters
size_t n amount of bits to keep
Clear all but the lowest n bits
const bool getBit(size_t n);
- Parameters
size_t n the bit offset to test - Returns
- true, if the bit at position n is set, false otherwise
Return bit value at specified position
const uint getSubstring(size_t offset, size_t length);
- Parameters
size_t offset the offset to start extracting size_t length amount of bits to extract (starting at offset) - Returns
- the integer extracted from the register starting at offset with specified length
Return (a maximum of) 32 bits of the complete value
const uint toUint();
- Returns
- the value as a uint if conversion is possible
Convert this value into a uint, if it is in the range [0 ... 2**32-1], or otherwise throw new an exception.
const ubyte byteAt(size_t n);
- Parameters
size_t n the offset to get a ubyte from - Returns
- ubyte at offset n
const word wordAt(size_t n);
- Parameters
size_t n position in the register - Returns
- value at position n
Return the word at a specified position of the internal register
const bool isNegative();
- Returns
- true, iff the integer has a negative sign
Tests if the sign of the integer is negative
const bool isPositive();
- Returns
- true, iff the integer has a positive sign
Tests if the sign of the integer is positive
const Sign sign();
const Sign reverseSign();
- Returns
- the opposite sign of the represented integer value
void flipSign();
Flip the sign of this BigInt
void setSign(Sign s);
- Parameters
Sign s new Sign to set
Set sign of the integer
const BigInt abs();
- Returns
- absolute (positive) value of this
const size_t size();
const size_t sigWords();
- Returns
- significant words of the represented integer value
Return how many words we need to hold this value
const size_t bytes();
- Returns
- ubyte length of the represented integer value
Give ubyte length of the integer
const size_t bits();
- Returns
- bit length of the represented integer value
Get the bit length of the integer
word* mutablePtr();
- Returns
- a pointer to the start of the internal register
Return a mutable pointer to the register
const @property const(word*) ptr();
- Returns
- a pointer to the start of the internal register
Return a const pointer to the register
void growTo(size_t n);
- Parameters
size_t n new size of register
Increase internal register buffer to at least n words
void randomize(RandomNumberGenerator rng, size_t bitsize = 0);
- Parameters
RandomNumberGenerator rng the random number generator to use size_t bitsize number of bits the created random value should have
Fill BigInt with a random number with size of bitsize
const void binaryEncode(ubyte* output);
- Parameters
ubyte* output destination ubyte array for the integer value
Store BigInt-value in a given ubyte array
void binaryDecode(const(ubyte)* buf, size_t length);
- Parameters
const(ubyte)* buf ubyte array buffer containing the integer size_t length size of buf
Read integer value from a ubyte array with given size
void binaryDecode(ALLOC)(auto ref const Vector!(ubyte, ALLOC) buf);
void binaryDecode(ALLOC)(auto ref const RefCounted!(Vector!(ubyte, ALLOC), ALLOC) buf);
- Parameters
Vector!(ubyte, ALLOC) buf the array to load from
Read integer value from a ubyte array (SecureVector!ubyte)
const size_t encodedSize(Base base = Binary);
- Parameters
Base base the base to measure the size for - Returns
- size of this integer in base base
BigInt randomInteger()(RandomNumberGenerator rng, auto ref const BigInt min, auto ref const BigInt max);
- Parameters
RandomNumberGenerator rng a random number generator BigInt min the minimum value BigInt max the maximum value - Returns
- random integer in [min,max)
static BigInt powerOf2(size_t n);
- Parameters
size_t n the power of two to create - Returns
- bigint representing 2^n
Create a power of two
Vector!ubyte encode()(auto ref const BigInt n, Base base = Binary);
- Parameters
BigInt n the BigInt to use as integer source Base base number-base of resulting ubyte array representation - Returns
- SecureVector of bytes containing the integer with given base
Encode the integer value from a BigInt to an Array of bytes
SecureVector!ubyte encodeLocked()(auto ref const BigInt n, Base base = Binary);
- Parameters
BigInt n the BigInt to use as integer source Base base number-base of resulting ubyte array representation - Returns
- SecureVector of bytes containing the integer with given base
Encode the integer value from a BigInt to a Secure Array of bytes
void encode()(ubyte* output, auto ref const BigInt n, Base base = Binary);
- Parameters
ubyte* output destination ubyte array for the encoded integer value with given base BigInt n the BigInt to use as integer source Base base number-base of resulting ubyte array representation
Encode the integer value from a BigInt to a ubyte array
static BigInt decode(const(ubyte)* buf, size_t length, Base base = Binary);
- Parameters
const(ubyte)* buf the binary value to load size_t length size of buf Base base number-base of the integer in buf - Returns
- BigInt representing the integer in the ubyte array
Create a BigInt from an integer in a ubyte array
BigInt decode(ALLOC)(auto ref const RefCounted!(Vector!(ubyte, ALLOC), ALLOC) buf, Base base = Binary);
- Parameters
RefCounted!(Vector!(ubyte, ALLOC), ALLOC) buf the binary value to load Base base number-base of the integer in buf - Returns
- BigInt representing the integer in the ubyte array
Create a BigInt from an integer in a ubyte array
BigInt decode(ALLOC)(auto ref const Vector!(ubyte, ALLOC) buf, Base base = Binary);
- Parameters
Vector!(ubyte, ALLOC) buf the binary value to load Base base number-base of the integer in buf - Returns
- BigInt representing the integer in the ubyte array
Create a BigInt from an integer in a ubyte array
SecureVector!ubyte encode1363()(auto ref const BigInt n, size_t bytes);
- Parameters
BigInt n the BigInt to encode size_t bytes the length of the resulting SecureVector!ubyte - Returns
- a SecureVector!ubyte containing the encoded BigInt
Encode a BigInt to a ubyte array according to IEEE 1363