Integer Class Reference

Multiple precision integer with arithmetic operations. More...

`#include <integer.h>`

Inheritance diagram for Integer:

## Classes

class | DivideByZero
| Exception thrown when division by 0 is encountered. More...
class | RandomNumberNotFound
| Exception thrown when a random number cannot be found that satisfies the condition. More...
class | OpenPGPDecodeErr
| Exception thrown when an error is encountered decoding an OpenPGP integer. More...

## ENUMS, EXCEPTIONS, and TYPEDEFS

enum | Sign { POSITIVE =0 , NEGATIVE =1 }
| Used internally to represent the integer. More...
enum | Signedness { UNSIGNED , SIGNED }
| Used when importing and exporting integers. More...
enum | RandomNumberType { ANY , PRIME }
| Properties of a random integer. More...

## INPUT/OUTPUT

CRYPTOPP_DLL std::istream & | operator>> (std::istream &in, Integer &a)
| Extraction operator.
CRYPTOPP_DLL std::ostream & | operator<< (std::ostream &out, const Integer &a)
| Insertion operator.
CRYPTOPP_DLL friend Integer | a_times_b_mod_c (const Integer &x, const Integer &y, const Integer &m)
| Modular multiplication.
CRYPTOPP_DLL friend Integer | a_exp_b_mod_c (const Integer &x, const Integer &e, const Integer &m)
| Modular exponentiation.

## CREATORS

| Integer ()
| Creates the zero integer.
| Integer (const Integer &t)
| copy constructor
| Integer (signed long value)
| Convert from signed long.
| Integer (Sign sign, lword value)
| Convert from lword.
| Integer (Sign sign, word highWord, word lowWord)
| Convert from two words.
| Integer (const char *str, ByteOrder order=BIG_ENDIAN_ORDER)
| Convert from a C-string.
| Integer (const wchar_t *str, ByteOrder order=BIG_ENDIAN_ORDER)
| Convert from a wide C-string.
| Integer (const byte *encodedInteger, size_t byteCount, Signedness sign=UNSIGNED, ByteOrder order=BIG_ENDIAN_ORDER)
| Convert from a big-endian byte array.
| Integer (BufferedTransformation &bt, size_t byteCount, Signedness sign=UNSIGNED, ByteOrder order=BIG_ENDIAN_ORDER)
| Convert from a big-endian array.
| Integer (BufferedTransformation &bt)
| Convert from a BER encoded byte array.
| Integer (RandomNumberGenerator &rng, size_t bitCount)
| Create a random integer.
| Integer (RandomNumberGenerator &rng, const Integer &min, const Integer &max, RandomNumberType rnType=ANY, const Integer &equiv=Zero(), const Integer &mod=One())
| Create a random integer of special form.
static const Integer & | Zero ()
| Integer representing 0.
static const Integer & | One ()
| Integer representing 1.
static const Integer & | Two ()
| Integer representing 2.
static Integer | Power2 (size_t e)
| Exponentiates to a power of 2.

## ENCODE/DECODE

size_t | MinEncodedSize (Signedness sign=UNSIGNED) const
| Minimum number of bytes to encode this integer.
void | Encode (byte *output, size_t outputLen, Signedness sign=UNSIGNED) const
| Encode in big-endian format.
void | Encode (BufferedTransformation &bt, size_t outputLen, Signedness sign=UNSIGNED) const
| Encode in big-endian format.
void | DEREncode (BufferedTransformation &bt) const
| Encode in DER format.
void | DEREncodeAsOctetString (BufferedTransformation &bt, size_t length) const
| Encode absolute value as big-endian octet string.
size_t | OpenPGPEncode (byte *output, size_t bufferSize) const
| Encode absolute value in OpenPGP format.
size_t | OpenPGPEncode (BufferedTransformation &bt) const
| Encode absolute value in OpenPGP format.
void | Decode (const byte *input, size_t inputLen, Signedness sign=UNSIGNED)
| Decode from big-endian byte array.
void | Decode (BufferedTransformation &bt, size_t inputLen, Signedness sign=UNSIGNED)
| Decode nonnegative value from big-endian byte array.
void | BERDecode (const byte *input, size_t inputLen)
| Decode from BER format.
void | BERDecode (BufferedTransformation &bt)
| Decode from BER format.
void | BERDecodeAsOctetString (BufferedTransformation &bt, size_t length)
| Decode nonnegative value from big-endian octet string.
void | OpenPGPDecode (const byte *input, size_t inputLen)
| Decode from OpenPGP format.
void | OpenPGPDecode (BufferedTransformation &bt)
| Decode from OpenPGP format.

## ACCESSORS

bool | IsConvertableToLong () const
| Determines if the Integer is convertable to Long.
signed long | ConvertToLong () const
| Convert the Integer to Long.
unsigned int | BitCount () const
| Determines the number of bits required to represent the Integer.
unsigned int | ByteCount () const
| Determines the number of bytes required to represent the Integer.
unsigned int | WordCount () const
| Determines the number of words required to represent the Integer.
bool | GetBit (size_t i) const
| Provides the i-th bit of the Integer.
byte | GetByte (size_t i) const
| Provides the i-th byte of the Integer.
lword | GetBits (size_t i, size_t n) const
| Provides the low order bits of the Integer.
bool | IsZero () const
| Determines if the Integer is 0.
bool | NotZero () const
| Determines if the Integer is non-0.
bool | IsNegative () const
| Determines if the Integer is negative.
bool | NotNegative () const
| Determines if the Integer is non-negative.
bool | IsPositive () const
| Determines if the Integer is positive.
bool | NotPositive () const
| Determines if the Integer is non-positive.
bool | IsEven () const
| Determines if the Integer is even parity.
bool | IsOdd () const
| Determines if the Integer is odd parity.

## MANIPULATORS

Integer & | operator= (const Integer &t)
| Assignment.
Integer & | operator+= (const Integer &t)
| Addition Assignment.
Integer & | operator-= (const Integer &t)
| Subtraction Assignment.
Integer & | operator*= (const Integer &t)
| Multiplication Assignment.
Integer & | operator/= (const Integer &t)
| Division Assignment.
Integer & | operator%= (const Integer &t)
| Remainder Assignment.
Integer & | operator/= (word t)
| Division Assignment.
Integer & | operator%= (word t)
| Remainder Assignment.
Integer & | operator<<= (size_t n)
| Left-shift Assignment.
Integer & | operator>>= (size_t n)
| Right-shift Assignment.
Integer & | operator&= (const Integer &t)
| Bitwise AND Assignment.
Integer & | operator|= (const Integer &t)
| Bitwise OR Assignment.
Integer & | operator^= (const Integer &t)
| Bitwise XOR Assignment.
void | Randomize (RandomNumberGenerator &rng, size_t bitCount)
| Set this Integer to random integer.
void | Randomize (RandomNumberGenerator &rng, const Integer &min, const Integer &max)
| Set this Integer to random integer.
bool | Randomize (RandomNumberGenerator &rng, const Integer &min, const Integer &max, RandomNumberType rnType, const Integer &equiv=Zero(), const Integer &mod=One())
| Set this Integer to random integer of special form.
bool | GenerateRandomNoThrow (RandomNumberGenerator &rng, const NameValuePairs &params=g_nullNameValuePairs)
| Generate a random number.
void | GenerateRandom (RandomNumberGenerator &rng, const NameValuePairs &params=g_nullNameValuePairs)
| Generate a random number.
void | SetBit (size_t n, bool value=1)
| Set the n-th bit to value.
void | SetByte (size_t n, byte value)
| Set the n-th byte to value.
void | Negate ()
| Reverse the Sign of the Integer.
void | SetPositive ()
| Sets the Integer to positive.
void | SetNegative ()
| Sets the Integer to negative.
void | swap (Integer &a)
| Swaps this Integer with another Integer.

## UNARY OPERATORS

bool | operator! () const
| Negation.
Integer | operator+ () const
| Addition.
Integer | operator- () const
| Subtraction.
Integer & | operator++ ()
| Pre-increment.
Integer & | operator-- ()
| Pre-decrement.
Integer | operator++ (int)
| Post-increment.
Integer | operator-- (int)
| Post-decrement.

## BINARY OPERATORS

int | Compare (const Integer &a) const
| Perform signed comparison.
Integer | Plus (const Integer &b) const
| Addition.
Integer | Minus (const Integer &b) const
| Subtraction.
Integer | Times (const Integer &b) const
| Multiplication.
Integer | DividedBy (const Integer &b) const
| Division.
Integer | Modulo (const Integer &b) const
| Remainder.
Integer | DividedBy (word b) const
| Division.
word | Modulo (word b) const
| Remainder.
Integer | And (const Integer &t) const
| Bitwise AND.
Integer | Or (const Integer &t) const
| Bitwise OR.
Integer | Xor (const Integer &t) const
| Bitwise XOR.
Integer | operator>> (size_t n) const
| Right-shift.
Integer | operator<< (size_t n) const
| Left-shift.

## OTHER ARITHMETIC FUNCTIONS

Integer | AbsoluteValue () const
| Retrieve the absolute value of this integer.
Integer | Doubled () const
| Add this integer to itself.
Integer | Squared () const
| Multiply this integer by itself.
Integer | SquareRoot () const
| Extract square root.
bool | IsSquare () const
| Determine whether this integer is a perfect square.
bool | IsUnit () const
| Determine if 1 or -1.
Integer | MultiplicativeInverse () const
| Calculate multiplicative inverse.
Integer | InverseMod (const Integer &n) const
| Calculate multiplicative inverse.
word | InverseMod (word n) const
| Calculate multiplicative inverse.
static void | Divide (Integer &r, Integer &q, const Integer &a, const Integer &d)
| Extended Division.
static void | Divide (word &r, Integer &q, const Integer &a, word d)
| Extended Division.
static void | DivideByPowerOf2 (Integer &r, Integer &q, const Integer &a, unsigned int n)
| Extended Division.
static Integer | Gcd (const Integer &a, const Integer &n)
| Calculate greatest common divisor.

## Additional Inherited Members

Public Member Functions inherited from ASN1Object
virtual void | BEREncode (BufferedTransformation &bt) const
| Encode this object into a BufferedTransformation.

## Detailed Description

Multiple precision integer with arithmetic operations.

The Integer class can represent positive and negative integers with absolute value less than (256**sizeof(word))(256**sizeof(int)).

Internally, the library uses a sign magnitude representation, and the class has two data members. The first is a IntegerSecBlock (a SecBlock<word>) and it is used to hold the representation. The second is a Sign (an enumeration), and it is used to track the sign of the Integer.

For details on how the Integer class initializes its function pointers using InitializeInteger and how it creates Integer::Zero(), Integer::One(), and Integer::Two(), then see the comments at the top of integer.cpp.

Since
  Crypto++ 1.0

Definition at line 49 of file integer.h.

## Member Enumeration Documentation

## Sign

enum Integer::Sign

Used internally to represent the integer.

Sign is used internally to represent the integer. It is also used in a few API functions.

See also
  SetPositive(), SetNegative(), Signedness

Enumerator
POSITIVE | the value is positive or 0
NEGATIVE | the value is negative

Definition at line 73 of file integer.h.

## Signedness

enum Integer::Signedness

Used when importing and exporting integers.

Signedness is usually used in API functions.

See also
  Sign

Enumerator
UNSIGNED | an unsigned value
SIGNED | a signed value

Definition at line 83 of file integer.h.

## RandomNumberType

enum Integer::RandomNumberType

Properties of a random integer.

Enumerator
ANY | a number with no special properties
PRIME | a number which is probabilistically prime

Definition at line 91 of file integer.h.

## Constructor & Destructor Documentation

## Integer() [1/9]

Integer::Integer | ( | Sign | sign,
|  | lword | value )

Convert from lword.

Parameters

  sign | enumeration indicating Sign
  value | the long word

## Integer() [2/9]

Integer::Integer | ( | Sign | sign,
|  | word | highWord,
|  | word | lowWord )

Convert from two words.

Parameters

  sign | enumeration indicating Sign
  highWord | the high word
  lowWord | the low word

## Integer() [3/9]

Integer::Integer | ( | const char * | str,
|  | ByteOrder | order = BIG_ENDIAN_ORDER )

explicit

Convert from a C-string.

Parameters

  str | C-string value
  order | the ByteOrder of the string to be processed

`str` can be in base 8, 10, or 16. Base is determined by a case insensitive suffix of 'o' (8), '.' (10), or 'h' (16). No suffix means base 10.

Byte order was added at Crypto++ 5.7 to allow use of little-endian integers with curve25519, Poly1305 and Microsoft CAPI.

## Integer() [4/9]

Integer::Integer | ( | const wchar_t * | str,
|  | ByteOrder | order = BIG_ENDIAN_ORDER )

explicit

Convert from a wide C-string.

Parameters

  str | wide C-string value
  order | the ByteOrder of the string to be processed

`str` can be in base 8, 10, or 16. Base is determined by a case insensitive suffix of 'o' (8), '.' (10), or 'h' (16). No suffix means base 10.

Byte order was added at Crypto++ 5.7 to allow use of little-endian integers with curve25519, Poly1305 and Microsoft CAPI.

## Integer() [5/9]

Integer::Integer | ( | const byte * | encodedInteger,
|  | size_t | byteCount,
|  | Signedness | sign = UNSIGNED,
|  | ByteOrder | order = BIG_ENDIAN_ORDER )

Convert from a big-endian byte array.

Parameters

  encodedInteger | big-endian byte array
  byteCount | length of the byte array
  sign | enumeration indicating Signedness
  order | the ByteOrder of the array to be processed

Byte order was added at Crypto++ 5.7 to allow use of little-endian integers with curve25519, Poly1305 and Microsoft CAPI.

## Integer() [6/9]

Integer::Integer | ( | BufferedTransformation & | bt,
|  | size_t | byteCount,
|  | Signedness | sign = UNSIGNED,
|  | ByteOrder | order = BIG_ENDIAN_ORDER )

Convert from a big-endian array.

Parameters

  bt | BufferedTransformation object with big-endian byte array
  byteCount | length of the byte array
  sign | enumeration indicating Signedness
  order | the ByteOrder of the data to be processed

Byte order was added at Crypto++ 5.7 to allow use of little-endian integers with curve25519, Poly1305 and Microsoft CAPI.

## Integer() [7/9]

Integer::Integer | ( | BufferedTransformation & | bt | ) |

explicit

Convert from a BER encoded byte array.

Parameters

  bt | BufferedTransformation object with BER encoded byte array

## Integer() [8/9]

Integer::Integer | ( | RandomNumberGenerator & | rng,
|  | size_t | bitCount )

Create a random integer.

Parameters

  rng | RandomNumberGenerator used to generate material
  bitCount | the number of bits in the resulting integer

The random integer created is uniformly distributed over [0, 2bitCount].

## Integer() [9/9]

Integer::Integer | ( | RandomNumberGenerator & | rng,
|  | const Integer & | min,
|  | const Integer & | max,
|  | RandomNumberType | rnType = ANY,
|  | const Integer & | equiv = Zero(),
|  | const Integer & | mod = One() )

Create a random integer of special form.

Parameters

  rng | RandomNumberGenerator used to generate material
  min | the minimum value
  max | the maximum value
  rnType | RandomNumberType to specify the type
  equiv | the equivalence class based on the parameter `mod`
  mod | the modulus used to reduce the equivalence class

Exceptions

  RandomNumberNotFound | if the set is empty.

Ideally, the random integer created should be uniformly distributed over {x | min <= x <= max and `x` is of rnType and x % mod == equiv}. However the actual distribution may not be uniform because sequential search is used to find an appropriate number from a random starting point.

May return (with very small probability) a pseudoprime when a prime is requested and max > lastSmallPrime*lastSmallPrime. `lastSmallPrime` is declared in nbtheory.h.

## Member Function Documentation

## Zero()

const Integer & Integer::Zero | ( |  | ) |

static

Integer representing 0.

Returns
  an Integer representing 0

Zero() avoids calling constructors for frequently used integers

## One()

const Integer & Integer::One | ( |  | ) |

static

Integer representing 1.

Returns
  an Integer representing 1

One() avoids calling constructors for frequently used integers

## Two()

const Integer & Integer::Two | ( |  | ) |

static

Integer representing 2.

Returns
  an Integer representing 2

Two() avoids calling constructors for frequently used integers

## Power2()

Integer Integer::Power2 | ( | size_t | e | ) |

static

Exponentiates to a power of 2.

Returns
  the Integer 2e

See also
  a_times_b_mod_c() and a_exp_b_mod_c()

## MinEncodedSize()

size_t Integer::MinEncodedSize | ( | Signedness | sign = UNSIGNED | ) | const

Minimum number of bytes to encode this integer.

Parameters

  sign | enumeration indicating Signedness

Note
  The MinEncodedSize() of 0 is 1.

## Encode() [1/2]

void Integer::Encode | ( | byte * | output,
|  | size_t | outputLen,
|  | Signedness | sign = UNSIGNED ) const

Encode in big-endian format.

Parameters

  output | big-endian byte array
  outputLen | length of the byte array
  sign | enumeration indicating Signedness

Unsigned means encode absolute value, signed means encode two's complement if negative.

outputLen can be used to ensure an Integer is encoded to an exact size (rather than a minimum size). An exact size is useful, for example, when encoding to a field element size.

## Encode() [2/2]

void Integer::Encode | ( | BufferedTransformation & | bt,
|  | size_t | outputLen,
|  | Signedness | sign = UNSIGNED ) const

Encode in big-endian format.

Parameters

  bt | BufferedTransformation object
  outputLen | length of the encoding
  sign | enumeration indicating Signedness

Unsigned means encode absolute value, signed means encode two's complement if negative.

outputLen can be used to ensure an Integer is encoded to an exact size (rather than a minimum size). An exact size is useful, for example, when encoding to a field element size.

## DEREncode()

void Integer::DEREncode | ( | BufferedTransformation & | bt | ) | const

virtual

Encode in DER format.

Parameters

  bt | BufferedTransformation object

Encodes the Integer using Distinguished Encoding Rules The result is placed into a BufferedTransformation object

Implements ASN1Object.

## DEREncodeAsOctetString()

void Integer::DEREncodeAsOctetString | ( | BufferedTransformation & | bt,
|  | size_t | length ) const

Encode absolute value as big-endian octet string.

Parameters

  bt | BufferedTransformation object
  length | the number of mytes to decode

## OpenPGPEncode() [1/2]

size_t Integer::OpenPGPEncode | ( | byte * | output,
|  | size_t | bufferSize ) const

Encode absolute value in OpenPGP format.

Parameters

  output | big-endian byte array
  bufferSize | length of the byte array

Returns
  length of the output

OpenPGPEncode places result into the buffer and returns the number of bytes used for the encoding

## OpenPGPEncode() [2/2]

size_t Integer::OpenPGPEncode | ( | BufferedTransformation & | bt | ) | const

Encode absolute value in OpenPGP format.

Parameters

  bt | BufferedTransformation object

Returns
  length of the output

OpenPGPEncode places result into a BufferedTransformation object and returns the number of bytes used for the encoding

## Decode() [1/2]

void Integer::Decode | ( | const byte * | input,
|  | size_t | inputLen,
|  | Signedness | sign = UNSIGNED )

Decode from big-endian byte array.

Parameters

  input | big-endian byte array
  inputLen | length of the byte array
  sign | enumeration indicating Signedness

## Decode() [2/2]

void Integer::Decode | ( | BufferedTransformation & | bt,
|  | size_t | inputLen,
|  | Signedness | sign = UNSIGNED )

Decode nonnegative value from big-endian byte array.

Parameters

  bt | BufferedTransformation object
  inputLen | length of the byte array
  sign | enumeration indicating Signedness

Note
  bt.MaxRetrievable() >= inputLen.

## BERDecode() [1/2]

void Integer::BERDecode | ( | const byte * | input,
|  | size_t | inputLen )

Decode from BER format.

Parameters

  input | big-endian byte array
  inputLen | length of the byte array

## BERDecode() [2/2]

void Integer::BERDecode | ( | BufferedTransformation & | bt | ) |

virtual

Decode from BER format.

Parameters

  bt | BufferedTransformation object

Implements ASN1Object.

## BERDecodeAsOctetString()

void Integer::BERDecodeAsOctetString | ( | BufferedTransformation & | bt,
|  | size_t | length )

Decode nonnegative value from big-endian octet string.

Parameters

  bt | BufferedTransformation object
  length | length of the byte array

## OpenPGPDecode() [1/2]

void Integer::OpenPGPDecode | ( | const byte * | input,
|  | size_t | inputLen )

Decode from OpenPGP format.

Parameters

  input | big-endian byte array
  inputLen | length of the byte array

## OpenPGPDecode() [2/2]

void Integer::OpenPGPDecode | ( | BufferedTransformation & | bt | ) |

Decode from OpenPGP format.

Parameters

  bt | BufferedTransformation object

## IsConvertableToLong()

bool Integer::IsConvertableToLong | ( |  | ) | const

Determines if the Integer is convertable to Long.

Returns
  true if *this can be represented as a signed long

See also
  ConvertToLong()

## ConvertToLong()

signed long Integer::ConvertToLong | ( |  | ) | const

Convert the Integer to Long.

Returns
  equivalent signed long if possible, otherwise undefined

See also
  IsConvertableToLong()

## BitCount()

unsigned int Integer::BitCount | ( |  | ) | const

Determines the number of bits required to represent the Integer.

Returns
  number of significant bits

BitCount is calculated as floor(log2(abs(*this))) + 1.

## ByteCount()

unsigned int Integer::ByteCount | ( |  | ) | const

Determines the number of bytes required to represent the Integer.

Returns
  number of significant bytes

ByteCount is calculated as ceiling(BitCount()/8).

## WordCount()

unsigned int Integer::WordCount | ( |  | ) | const

Determines the number of words required to represent the Integer.

Returns
  number of significant words

WordCount is calculated as ceiling(ByteCount()/sizeof(word)).

## GetBit()

bool Integer::GetBit | ( | size_t | i | ) | const

Provides the i-th bit of the Integer.

Returns
  the i-th bit, i=0 being the least significant bit

## GetByte()

byte Integer::GetByte | ( | size_t | i | ) | const

Provides the i-th byte of the Integer.

Returns
  the i-th byte

## GetBits()

lword Integer::GetBits | ( | size_t | i,
|  | size_t | n ) const

Provides the low order bits of the Integer.

Returns
  n lowest bits of *this >> i

## IsZero()

bool Integer::IsZero | ( |  | ) | const

inline

Determines if the Integer is 0.

Returns
  true if the Integer is 0, false otherwise

Definition at line 335 of file integer.h.

## NotZero()

bool Integer::NotZero | ( |  | ) | const

inline

Determines if the Integer is non-0.

Returns
  true if the Integer is non-0, false otherwise

Definition at line 338 of file integer.h.

## IsNegative()

bool Integer::IsNegative | ( |  | ) | const

inline

Determines if the Integer is negative.

Returns
  true if the Integer is negative, false otherwise

Definition at line 341 of file integer.h.

## NotNegative()

bool Integer::NotNegative | ( |  | ) | const

inline

Determines if the Integer is non-negative.

Returns
  true if the Integer is non-negative, false otherwise

Definition at line 344 of file integer.h.

## IsPositive()

bool Integer::IsPositive | ( |  | ) | const

inline

Determines if the Integer is positive.

Returns
  true if the Integer is positive, false otherwise

Definition at line 347 of file integer.h.

## NotPositive()

bool Integer::NotPositive | ( |  | ) | const

inline

Determines if the Integer is non-positive.

Returns
  true if the Integer is non-positive, false otherwise

Definition at line 350 of file integer.h.

## IsEven()

bool Integer::IsEven | ( |  | ) | const

inline

Determines if the Integer is even parity.

Returns
  true if the Integer is even, false otherwise

Definition at line 353 of file integer.h.

## IsOdd()

bool Integer::IsOdd | ( |  | ) | const

inline

Determines if the Integer is odd parity.

Returns
  true if the Integer is odd, false otherwise

Definition at line 356 of file integer.h.

## operator=()

Integer & Integer::operator= | ( | const Integer & | t | ) |

Assignment.

Parameters

  t | the other Integer

Returns
  the result of assignment

## operator+=()

Integer & Integer::operator+= | ( | const Integer & | t | ) |

Addition Assignment.

Parameters

  t | the other Integer

Returns
  the result of *this + t

## operator-=()

Integer & Integer::operator-= | ( | const Integer & | t | ) |

Subtraction Assignment.

Parameters

  t | the other Integer

Returns
  the result of *this - t

## operator*=()

Integer & Integer::operator*= | ( | const Integer & | t | ) |

inline

Multiplication Assignment.

Parameters

  t | the other Integer

Returns
  the result of *this * t

See also
  a_times_b_mod_c() and a_exp_b_mod_c()

Definition at line 377 of file integer.h.

## operator/=() [1/2]

Integer & Integer::operator/= | ( | const Integer & | t | ) |

inline

Division Assignment.

Parameters

  t | the other Integer

Returns
  the result of *this / t

Definition at line 381 of file integer.h.

## operator%=() [1/2]

Integer & Integer::operator%= | ( | const Integer & | t | ) |

inline

Remainder Assignment.

Parameters

  t | the other Integer

Returns
  the result of *this % t

See also
  a_times_b_mod_c() and a_exp_b_mod_c()

Definition at line 386 of file integer.h.

## operator/=() [2/2]

Integer & Integer::operator/= | ( | word | t | ) |

inline

Division Assignment.

Parameters

  t | the other word

Returns
  the result of *this / t

Definition at line 390 of file integer.h.

## operator%=() [2/2]

Integer & Integer::operator%= | ( | word | t | ) |

inline

Remainder Assignment.

Parameters

  t | the other word

Returns
  the result of *this % t

See also
  a_times_b_mod_c() and a_exp_b_mod_c()

Definition at line 395 of file integer.h.

## operator<<=()

Integer & Integer::operator<<= | ( | size_t | n | ) |

Left-shift Assignment.

Parameters

  n | number of bits to shift

Returns
  reference to this Integer

## operator>>=()

Integer & Integer::operator>>= | ( | size_t | n | ) |

Right-shift Assignment.

Parameters

  n | number of bits to shift

Returns
  reference to this Integer

## operator&=()

Integer & Integer::operator&= | ( | const Integer & | t | ) |

Bitwise AND Assignment.

Parameters

  t | the other Integer

Returns
  the result of *this & t

operator&=() performs a bitwise AND on *this. Missing bits are truncated at the most significant bit positions, so the result is as small as the smaller of the operands.

Internally, Crypto++ uses a sign-magnitude representation. The library does not attempt to interpret bits, and the result is always POSITIVE. If needed, the integer should be converted to a 2's compliment representation before performing the operation.

Since
  Crypto++ 6.0

## operator|=()

Integer & Integer::operator|= | ( | const Integer & | t | ) |

Bitwise OR Assignment.

Parameters

  t | the second Integer

Returns
  the result of *this | t

operator|=() performs a bitwise OR on *this. Missing bits are shifted in at the most significant bit positions, so the result is as large as the larger of the operands.

Internally, Crypto++ uses a sign-magnitude representation. The library does not attempt to interpret bits, and the result is always POSITIVE. If needed, the integer should be converted to a 2's compliment representation before performing the operation.

Since
  Crypto++ 6.0

## operator^=()

Integer & Integer::operator^= | ( | const Integer & | t | ) |

Bitwise XOR Assignment.

Parameters

  t | the other Integer

Returns
  the result of *this ^ t

operator^=() performs a bitwise XOR on *this. Missing bits are shifted in at the most significant bit positions, so the result is as large as the larger of the operands.

Internally, Crypto++ uses a sign-magnitude representation. The library does not attempt to interpret bits, and the result is always POSITIVE. If needed, the integer should be converted to a 2's compliment representation before performing the operation.

Since
  Crypto++ 6.0

## Randomize() [1/3]

void Integer::Randomize | ( | RandomNumberGenerator & | rng,
|  | size_t | bitCount )

Set this Integer to random integer.

Parameters

  rng | RandomNumberGenerator used to generate material
  bitCount | the number of bits in the resulting integer

The random integer created is uniformly distributed over [0, 2bitCount].

Note
  If `bitCount` is 0, then this Integer is set to 0 (and not 0 or 1).

## Randomize() [2/3]

void Integer::Randomize | ( | RandomNumberGenerator & | rng,
|  | const Integer & | min,
|  | const Integer & | max )

Set this Integer to random integer.

Parameters

  rng | RandomNumberGenerator used to generate material
  min | the minimum value
  max | the maximum value

The random integer created is uniformly distributed over [min, max].

## Randomize() [3/3]

bool Integer::Randomize | ( | RandomNumberGenerator & | rng,
|  | const Integer & | min,
|  | const Integer & | max,
|  | RandomNumberType | rnType,
|  | const Integer & | equiv = Zero(),
|  | const Integer & | mod = One() )

Set this Integer to random integer of special form.

Parameters

  rng | RandomNumberGenerator used to generate material
  min | the minimum value
  max | the maximum value
  rnType | RandomNumberType to specify the type
  equiv | the equivalence class based on the parameter `mod`
  mod | the modulus used to reduce the equivalence class

Exceptions

  RandomNumberNotFound | if the set is empty.

Ideally, the random integer created should be uniformly distributed over {x | min <= x <= max and `x` is of rnType and x % mod == equiv}. However the actual distribution may not be uniform because sequential search is used to find an appropriate number from a random starting point.

May return (with very small probability) a pseudoprime when a prime is requested and max > lastSmallPrime*lastSmallPrime. `lastSmallPrime` is declared in nbtheory.h.

## GenerateRandomNoThrow()

bool Integer::GenerateRandomNoThrow | ( | RandomNumberGenerator & | rng,
|  | const NameValuePairs & | params = g_nullNameValuePairs )

Generate a random number.

Parameters

  rng | RandomNumberGenerator used to generate material
  params | additional parameters that cannot be passed directly to the function

Returns
  true if a random number was generated, false otherwise

GenerateRandomNoThrow attempts to generate a random number according to the parameters specified in params. The function does not throw RandomNumberNotFound.

The example below generates a prime number using NameValuePairs that Integer class recognizes. The names are not provided in argnames.h.

       AutoSeededRandomPool prng;
       AlgorithmParameters params = MakeParameters("BitLength", 2048)
                                                  ("RandomNumberType", Integer::PRIME);
       Integer x;
       if (x.GenerateRandomNoThrow(prng, params) == false)
           throw std::runtime_error("Failed to generate prime number");

## GenerateRandom()

void Integer::GenerateRandom | ( | RandomNumberGenerator & | rng,
|  | const NameValuePairs & | params = g_nullNameValuePairs )

inline

Generate a random number.

Parameters

  rng | RandomNumberGenerator used to generate material
  params | additional parameters that cannot be passed directly to the function

Exceptions

  RandomNumberNotFound | if a random number is not found

GenerateRandom attempts to generate a random number according to the parameters specified in params.

The example below generates a prime number using NameValuePairs that Integer class recognizes. The names are not provided in argnames.h.

       AutoSeededRandomPool prng;
       AlgorithmParameters params = MakeParameters("BitLength", 2048)
                                                  ("RandomNumberType", Integer::PRIME);
       Integer x;
       try { x.GenerateRandom(prng, params); }
       catch (RandomNumberNotFound&) { x = -1; }

Definition at line 509 of file integer.h.

## SetBit()

void Integer::SetBit | ( | size_t | n,
|  | bool | value = 1 )

Set the n-th bit to value.

0-based numbering.

## SetByte()

void Integer::SetByte | ( | size_t | n,
|  | byte | value )

Set the n-th byte to value.

0-based numbering.

## SetPositive()

void Integer::SetPositive | ( |  | ) |

inline

Sets the Integer to positive.

Definition at line 527 of file integer.h.

## SetNegative()

void Integer::SetNegative | ( |  | ) |

inline

Sets the Integer to negative.

Definition at line 530 of file integer.h.

## operator+()

Integer Integer::operator+ | ( |  | ) | const

inline

Addition.

Definition at line 541 of file integer.h.

## operator++()

Integer Integer::operator++ | ( | int |  | ) |

inline

Post-increment.

Definition at line 549 of file integer.h.

## operator--()

Integer Integer::operator-- | ( | int |  | ) |

inline

Post-decrement.

Definition at line 551 of file integer.h.

## Compare()

int Integer::Compare | ( | const Integer & | a | ) | const

Perform signed comparison.

Parameters

  a | the Integer to compare

Return values

  -1 | if *this < a
  0 | if *this = a
  1 | if *this > a

## Times()

Integer Integer::Times | ( | const Integer & | b | ) | const

Multiplication.

See also
  a_times_b_mod_c() and a_exp_b_mod_c()

## Modulo() [1/2]

Integer Integer::Modulo | ( | const Integer & | b | ) | const

Remainder.

See also
  a_times_b_mod_c() and a_exp_b_mod_c()

## Modulo() [2/2]

word Integer::Modulo | ( | word | b | ) | const

Remainder.

See also
  a_times_b_mod_c() and a_exp_b_mod_c()

## And()

Integer Integer::And | ( | const Integer & | t | ) | const

Bitwise AND.

Parameters

  t | the other Integer

Returns
  the result of *this & t

And() performs a bitwise AND on the operands. Missing bits are truncated at the most significant bit positions, so the result is as small as the smaller of the operands.

Internally, Crypto++ uses a sign-magnitude representation. The library does not attempt to interpret bits, and the result is always POSITIVE. If needed, the integer should be converted to a 2's compliment representation before performing the operation.

Since
  Crypto++ 6.0

## Or()

Integer Integer::Or | ( | const Integer & | t | ) | const

Bitwise OR.

Parameters

  t | the other Integer

Returns
  the result of *this | t

Or() performs a bitwise OR on the operands. Missing bits are shifted in at the most significant bit positions, so the result is as large as the larger of the operands.

Internally, Crypto++ uses a sign-magnitude representation. The library does not attempt to interpret bits, and the result is always POSITIVE. If needed, the integer should be converted to a 2's compliment representation before performing the operation.

Since
  Crypto++ 6.0

## Xor()

Integer Integer::Xor | ( | const Integer & | t | ) | const

Bitwise XOR.

Parameters

  t | the other Integer

Returns
  the result of *this ^ t

Xor() performs a bitwise XOR on the operands. Missing bits are shifted in at the most significant bit positions, so the result is as large as the larger of the operands.

Internally, Crypto++ uses a sign-magnitude representation. The library does not attempt to interpret bits, and the result is always POSITIVE. If needed, the integer should be converted to a 2's compliment representation before performing the operation.

Since
  Crypto++ 6.0

## operator>>()

Integer Integer::operator>> | ( | size_t | n | ) | const

inline

Right-shift.

Definition at line 621 of file integer.h.

## operator<<()

Integer Integer::operator<< | ( | size_t | n | ) | const

inline

Left-shift.

Definition at line 623 of file integer.h.

## Doubled()

Integer Integer::Doubled | ( |  | ) | const

inline

Add this integer to itself.

Definition at line 631 of file integer.h.

## Squared()

Integer Integer::Squared | ( |  | ) | const

inline

Multiply this integer by itself.

See also
  a_times_b_mod_c() and a_exp_b_mod_c()

Definition at line 634 of file integer.h.

## SquareRoot()

Integer Integer::SquareRoot | ( |  | ) | const

Extract square root.

if negative return 0, else return floor of square root

## IsUnit()

bool Integer::IsUnit | ( |  | ) | const

Determine if 1 or -1.

Returns
  true if this integer is 1 or -1, false otherwise

## MultiplicativeInverse()

Integer Integer::MultiplicativeInverse | ( |  | ) | const

Calculate multiplicative inverse.

Returns
  MultiplicativeInverse inverse if 1 or -1, otherwise return 0.

## Divide() [1/2]

void Integer::Divide | ( | Integer & | r,
|  | Integer & | q,
|  | const Integer & | a,
|  | const Integer & | d )

static

Extended Division.

Parameters

  r | a reference for the remainder
  q | a reference for the quotient
  a | reference to the dividend
  d | reference to the divisor

Divide calculates r and q such that (a == d*q + r) && (0 <= r < abs(d)).

## Divide() [2/2]

void Integer::Divide | ( | word & | r,
|  | Integer & | q,
|  | const Integer & | a,
|  | word | d )

static

Extended Division.

Parameters

  r | a reference for the remainder
  q | a reference for the quotient
  a | reference to the dividend
  d | reference to the divisor

Divide calculates r and q such that (a == d*q + r) && (0 <= r < abs(d)). This overload uses a faster division algorithm because the divisor is short.

## DivideByPowerOf2()

void Integer::DivideByPowerOf2 | ( | Integer & | r,
|  | Integer & | q,
|  | const Integer & | a,
|  | unsigned int | n )

static

Extended Division.

Parameters

  r | a reference for the remainder
  q | a reference for the quotient
  a | reference to the dividend
  n | reference to the divisor

DivideByPowerOf2 calculates r and q such that (a == d*q + r) && (0 <= r < abs(d)). It returns same result as Divide(r, q, a, Power2(n)), but faster. This overload uses a faster division algorithm because the divisor is a power of 2.

## Gcd()

Integer Integer::Gcd | ( | const Integer & | a,
|  | const Integer & | n )

static

Calculate greatest common divisor.

Parameters

  a | reference to the first number
  n | reference to the secind number

Returns
  the greatest common divisor a and n.

## InverseMod() [1/2]

Integer Integer::InverseMod | ( | const Integer & | n | ) | const

Calculate multiplicative inverse.

Parameters

  n | reference to the modulus

Returns
  an Integer *this % n.

InverseMod returns the multiplicative inverse of the Integer *this modulo the Integer n. If no Integer exists then Integer 0 is returned.

See also
  a_times_b_mod_c() and a_exp_b_mod_c()

## InverseMod() [2/2]

word Integer::InverseMod | ( | word | n | ) | const

Calculate multiplicative inverse.

Parameters

  n | the modulus

Returns
  a word *this % n.

InverseMod returns the multiplicative inverse of the Integer *this modulo the word n. If no Integer exists then word 0 is returned.

See also
  a_times_b_mod_c() and a_exp_b_mod_c()

## Friends And Related Symbol Documentation

## operator>>

CRYPTOPP_DLL std::istream & operator>> | ( | std::istream & | in,
|  | Integer & | a )

friend

Extraction operator.

Parameters

  in | reference to a std::istream
  a | reference to an Integer

Returns
  reference to a std::istream reference

## operator<<

CRYPTOPP_DLL std::ostream & operator<< | ( | std::ostream & | out,
|  | const Integer & | a )

friend

Insertion operator.

Parameters

  out | reference to a std::ostream
  a | a constant reference to an Integer

Returns
  reference to a std::ostream reference

The output integer responds to hex, std::oct, std::hex, std::upper and std::lower. The output includes the suffix h (for hex), . (dot, for dec) and o (for octal). There is currently no way to suppress the suffix.

If you want to print an Integer without the suffix or using an arbitrary base, then use IntToString<Integer>().

See also
  IntToString<Integer>

## a_times_b_mod_c

CRYPTOPP_DLL friend Integer a_times_b_mod_c | ( | const Integer & | x,
|  | const Integer & | y,
|  | const Integer & | m )

friend

Modular multiplication.

Parameters

  x | reference to the first term
  y | reference to the second term
  m | reference to the modulus

Returns
  an Integer (a * b) % m.

## a_exp_b_mod_c

CRYPTOPP_DLL friend Integer a_exp_b_mod_c | ( | const Integer & | x,
|  | const Integer & | e,
|  | const Integer & | m )

friend

Modular exponentiation.

Parameters

  x | reference to the base
  e | reference to the exponent
  m | reference to the modulus

Returns
  an Integer (a ^ b) % m.

The documentation for this class was generated from the following file:

- integer.h