) 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.
/// \details 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
/// \nosubgrouping
class CRYPTOPP_DLL Integer : private InitializeInteger, public ASN1Object
{
public:
/// \name ENUMS, EXCEPTIONS, and TYPEDEFS
//@{
/// \brief Exception thrown when division by 0 is encountered
class DivideByZero : public Exception
{
public:
DivideByZero() : Exception(OTHER_ERROR, "Integer: division by zero") {}
};
/// \brief Exception thrown when a random number cannot be found that
/// satisfies the condition
class RandomNumberNotFound : public Exception
{
public:
RandomNumberNotFound() : Exception(OTHER_ERROR, "Integer: no integer satisfies the given parameters") {}
};
/// \enum Sign
/// \brief Used internally to represent the integer
/// \details Sign is used internally to represent the integer. It is also used in a few API functions.
/// \sa SetPositive(), SetNegative(), Signedness
enum Sign {
/// \brief the value is positive or 0
POSITIVE=0,
/// \brief the value is negative
NEGATIVE=1};
/// \enum Signedness
/// \brief Used when importing and exporting integers
/// \details Signedness is usually used in API functions.
/// \sa Sign
enum Signedness {
/// \brief an unsigned value
UNSIGNED,
/// \brief a signed value
SIGNED};
/// \enum RandomNumberType
/// \brief Properties of a random integer
enum RandomNumberType {
/// \brief a number with no special properties
ANY,
/// \brief a number which is probabilistically prime
PRIME};
//@}
/// \name CREATORS
//@{
/// \brief Creates the zero integer
Integer();
/// copy constructor
Integer(const Integer& t);
/// \brief Convert from signed long
Integer(signed long value);
/// \brief Convert from lword
/// \param sign enumeration indicating Sign
/// \param value the long word
Integer(Sign sign, lword value);
/// \brief Convert from two words
/// \param sign enumeration indicating Sign
/// \param highWord the high word
/// \param lowWord the low word
Integer(Sign sign, word highWord, word lowWord);
/// \brief Convert from a C-string
/// \param str C-string value
/// \param order the ByteOrder of the string to be processed
/// \details \p 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.
/// \details Byte order was added at Crypto++ 5.7 to allow use of little-endian
/// integers with curve25519, Poly1305 and Microsoft CAPI.
explicit Integer(const char *str, ByteOrder order = BIG_ENDIAN_ORDER);
/// \brief Convert from a wide C-string
/// \param str wide C-string value
/// \param order the ByteOrder of the string to be processed
/// \details \p 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.
/// \details Byte order was added at Crypto++ 5.7 to allow use of little-endian
/// integers with curve25519, Poly1305 and Microsoft CAPI.
explicit Integer(const wchar_t *str, ByteOrder order = BIG_ENDIAN_ORDER);
/// \brief Convert from a big-endian byte array
/// \param encodedInteger big-endian byte array
/// \param byteCount length of the byte array
/// \param sign enumeration indicating Signedness
/// \param order the ByteOrder of the array to be processed
/// \details Byte order was added at Crypto++ 5.7 to allow use of little-endian
/// integers with curve25519, Poly1305 and Microsoft CAPI.
Integer(const byte *encodedInteger, size_t byteCount, Signedness sign=UNSIGNED, ByteOrder order = BIG_ENDIAN_ORDER);
/// \brief Convert from a big-endian array
/// \param bt BufferedTransformation object with big-endian byte array
/// \param byteCount length of the byte array
/// \param sign enumeration indicating Signedness
/// \param order the ByteOrder of the data to be processed
/// \details Byte order was added at Crypto++ 5.7 to allow use of little-endian
/// integers with curve25519, Poly1305 and Microsoft CAPI.
Integer(BufferedTransformation &bt, size_t byteCount, Signedness sign=UNSIGNED, ByteOrder order = BIG_ENDIAN_ORDER);
/// \brief Convert from a BER encoded byte array
/// \param bt BufferedTransformation object with BER encoded byte array
explicit Integer(BufferedTransformation &bt);
/// \brief Create a random integer
/// \param rng RandomNumberGenerator used to generate material
/// \param bitCount the number of bits in the resulting integer
/// \details The random integer created is uniformly distributed over [0, 2bitCount].
Integer(RandomNumberGenerator &rng, size_t bitCount);
/// \brief Integer representing 0
/// \return an Integer representing 0
/// \details Zero() avoids calling constructors for frequently used integers
static const Integer & CRYPTOPP_API Zero();
/// \brief Integer representing 1
/// \return an Integer representing 1
/// \details One() avoids calling constructors for frequently used integers
static const Integer & CRYPTOPP_API One();
/// \brief Integer representing 2
/// \return an Integer representing 2
/// \details Two() avoids calling constructors for frequently used integers
static const Integer & CRYPTOPP_API Two();
/// \brief Create a random integer of special form
/// \param rng RandomNumberGenerator used to generate material
/// \param min the minimum value
/// \param max the maximum value
/// \param rnType RandomNumberType to specify the type
/// \param equiv the equivalence class based on the parameter \p mod
/// \param mod the modulus used to reduce the equivalence class
/// \throw RandomNumberNotFound if the set is empty.
/// \details Ideally, the random integer created should be uniformly distributed
/// over {x | min \<= x \<= max and \p 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.
/// \details May return (with very small probability) a pseudoprime when a prime
/// is requested and max \> lastSmallPrime*lastSmallPrime. \p lastSmallPrime
/// is declared in nbtheory.h.
Integer(RandomNumberGenerator &rng, const Integer &min, const Integer &max, RandomNumberType rnType=ANY, const Integer &equiv=Zero(), const Integer &mod=One());
/// \brief Exponentiates to a power of 2
/// \return the Integer 2e
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
static Integer CRYPTOPP_API Power2(size_t e);
//@}
/// \name ENCODE/DECODE
//@{
/// \brief Minimum number of bytes to encode this integer
/// \param sign enumeration indicating Signedness
/// \note The MinEncodedSize() of 0 is 1.
size_t MinEncodedSize(Signedness sign=UNSIGNED) const;
/// \brief Encode in big-endian format
/// \param output big-endian byte array
/// \param outputLen length of the byte array
/// \param sign enumeration indicating Signedness
/// \details Unsigned means encode absolute value, signed means encode two's complement if negative.
/// \details 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.
void Encode(byte *output, size_t outputLen, Signedness sign=UNSIGNED) const;
/// \brief Encode in big-endian format
/// \param bt BufferedTransformation object
/// \param outputLen length of the encoding
/// \param sign enumeration indicating Signedness
/// \details Unsigned means encode absolute value, signed means encode two's complement if negative.
/// \details 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.
void Encode(BufferedTransformation &bt, size_t outputLen, Signedness sign=UNSIGNED) const;
/// \brief Encode in DER format
/// \param bt BufferedTransformation object
/// \details Encodes the Integer using Distinguished Encoding Rules
/// The result is placed into a BufferedTransformation object
void DEREncode(BufferedTransformation &bt) const;
/// \brief Encode absolute value as big-endian octet string
/// \param bt BufferedTransformation object
/// \param length the number of mytes to decode
void DEREncodeAsOctetString(BufferedTransformation &bt, size_t length) const;
/// \brief Encode absolute value in OpenPGP format
/// \param output big-endian byte array
/// \param bufferSize length of the byte array
/// \return length of the output
/// \details OpenPGPEncode places result into the buffer and returns the
/// number of bytes used for the encoding
size_t OpenPGPEncode(byte *output, size_t bufferSize) const;
/// \brief Encode absolute value in OpenPGP format
/// \param bt BufferedTransformation object
/// \return length of the output
/// \details OpenPGPEncode places result into a BufferedTransformation object and returns the
/// number of bytes used for the encoding
size_t OpenPGPEncode(BufferedTransformation &bt) const;
/// \brief Decode from big-endian byte array
/// \param input big-endian byte array
/// \param inputLen length of the byte array
/// \param sign enumeration indicating Signedness
void Decode(const byte *input, size_t inputLen, Signedness sign=UNSIGNED);
/// \brief Decode nonnegative value from big-endian byte array
/// \param bt BufferedTransformation object
/// \param inputLen length of the byte array
/// \param sign enumeration indicating Signedness
/// \note bt.MaxRetrievable() \>= inputLen.
void Decode(BufferedTransformation &bt, size_t inputLen, Signedness sign=UNSIGNED);
/// \brief Decode from BER format
/// \param input big-endian byte array
/// \param inputLen length of the byte array
void BERDecode(const byte *input, size_t inputLen);
/// \brief Decode from BER format
/// \param bt BufferedTransformation object
void BERDecode(BufferedTransformation &bt);
/// \brief Decode nonnegative value from big-endian octet string
/// \param bt BufferedTransformation object
/// \param length length of the byte array
void BERDecodeAsOctetString(BufferedTransformation &bt, size_t length);
/// \brief Exception thrown when an error is encountered decoding an OpenPGP integer
class OpenPGPDecodeErr : public Exception
{
public:
OpenPGPDecodeErr() : Exception(INVALID_DATA_FORMAT, "OpenPGP decode error") {}
};
/// \brief Decode from OpenPGP format
/// \param input big-endian byte array
/// \param inputLen length of the byte array
void OpenPGPDecode(const byte *input, size_t inputLen);
/// \brief Decode from OpenPGP format
/// \param bt BufferedTransformation object
void OpenPGPDecode(BufferedTransformation &bt);
//@}
/// \name ACCESSORS
//@{
/// \brief Determines if the Integer is convertable to Long
/// \return true if *this can be represented as a signed long
/// \sa ConvertToLong()
bool IsConvertableToLong() const;
/// \brief Convert the Integer to Long
/// \return equivalent signed long if possible, otherwise undefined
/// \sa IsConvertableToLong()
signed long ConvertToLong() const;
/// \brief Determines the number of bits required to represent the Integer
/// \return number of significant bits
/// \details BitCount is calculated as floor(log2(abs(*this))) + 1.
unsigned int BitCount() const;
/// \brief Determines the number of bytes required to represent the Integer
/// \return number of significant bytes
/// \details ByteCount is calculated as ceiling(BitCount()/8).
unsigned int ByteCount() const;
/// \brief Determines the number of words required to represent the Integer
/// \return number of significant words
/// \details WordCount is calculated as ceiling(ByteCount()/sizeof(word)).
unsigned int WordCount() const;
/// \brief Provides the i-th bit of the Integer
/// \return the i-th bit, i=0 being the least significant bit
bool GetBit(size_t i) const;
/// \brief Provides the i-th byte of the Integer
/// \return the i-th byte
byte GetByte(size_t i) const;
/// \brief Provides the low order bits of the Integer
/// \return n lowest bits of *this >> i
lword GetBits(size_t i, size_t n) const;
/// \brief Determines if the Integer is 0
/// \return true if the Integer is 0, false otherwise
bool IsZero() const {return !*this;}
/// \brief Determines if the Integer is non-0
/// \return true if the Integer is non-0, false otherwise
bool NotZero() const {return !IsZero();}
/// \brief Determines if the Integer is negative
/// \return true if the Integer is negative, false otherwise
bool IsNegative() const {return sign == NEGATIVE;}
/// \brief Determines if the Integer is non-negative
/// \return true if the Integer is non-negative, false otherwise
bool NotNegative() const {return !IsNegative();}
/// \brief Determines if the Integer is positive
/// \return true if the Integer is positive, false otherwise
bool IsPositive() const {return NotNegative() && NotZero();}
/// \brief Determines if the Integer is non-positive
/// \return true if the Integer is non-positive, false otherwise
bool NotPositive() const {return !IsPositive();}
/// \brief Determines if the Integer is even parity
/// \return true if the Integer is even, false otherwise
bool IsEven() const {return GetBit(0) == 0;}
/// \brief Determines if the Integer is odd parity
/// \return true if the Integer is odd, false otherwise
bool IsOdd() const {return GetBit(0) == 1;}
//@}
/// \name MANIPULATORS
//@{
/// \brief Assignment
/// \param t the other Integer
/// \return the result of assignment
Integer& operator=(const Integer& t);
/// \brief Addition Assignment
/// \param t the other Integer
/// \return the result of *this + t
Integer& operator+=(const Integer& t);
/// \brief Subtraction Assignment
/// \param t the other Integer
/// \return the result of *this - t
Integer& operator-=(const Integer& t);
/// \brief Multiplication Assignment
/// \param t the other Integer
/// \return the result of *this * t
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
Integer& operator*=(const Integer& t) {return *this = Times(t);}
/// \brief Division Assignment
/// \param t the other Integer
/// \return the result of *this / t
Integer& operator/=(const Integer& t) {return *this = DividedBy(t);}
/// \brief Remainder Assignment
/// \param t the other Integer
/// \return the result of *this % t
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
Integer& operator%=(const Integer& t) {return *this = Modulo(t);}
/// \brief Division Assignment
/// \param t the other word
/// \return the result of *this / t
Integer& operator/=(word t) {return *this = DividedBy(t);}
/// \brief Remainder Assignment
/// \param t the other word
/// \return the result of *this % t
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
Integer& operator%=(word t) {return *this = Integer(POSITIVE, 0, Modulo(t));}
/// \brief Left-shift Assignment
/// \param n number of bits to shift
/// \return reference to this Integer
Integer& operator<<=(size_t n);
/// \brief Right-shift Assignment
/// \param n number of bits to shift
/// \return reference to this Integer
Integer& operator>>=(size_t n);
/// \brief Bitwise AND Assignment
/// \param t the other Integer
/// \return the result of *this & t
/// \details 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.
/// \details 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
Integer& operator&=(const Integer& t);
/// \brief Bitwise OR Assignment
/// \param t the second Integer
/// \return the result of *this | t
/// \details 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.
/// \details 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
Integer& operator|=(const Integer& t);
/// \brief Bitwise XOR Assignment
/// \param t the other Integer
/// \return the result of *this ^ t
/// \details 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.
/// \details 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
Integer& operator^=(const Integer& t);
/// \brief Set this Integer to random integer
/// \param rng RandomNumberGenerator used to generate material
/// \param bitCount the number of bits in the resulting integer
/// \details The random integer created is uniformly distributed over [0, 2bitCount].
void Randomize(RandomNumberGenerator &rng, size_t bitCount);
/// \brief Set this Integer to random integer
/// \param rng RandomNumberGenerator used to generate material
/// \param min the minimum value
/// \param max the maximum value
/// \details The random integer created is uniformly distributed over [min, max].
void Randomize(RandomNumberGenerator &rng, const Integer &min, const Integer &max);
/// \brief Set this Integer to random integer of special form
/// \param rng RandomNumberGenerator used to generate material
/// \param min the minimum value
/// \param max the maximum value
/// \param rnType RandomNumberType to specify the type
/// \param equiv the equivalence class based on the parameter \p mod
/// \param mod the modulus used to reduce the equivalence class
/// \throw RandomNumberNotFound if the set is empty.
/// \details Ideally, the random integer created should be uniformly distributed
/// over {x | min \<= x \<= max and \p 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.
/// \details May return (with very small probability) a pseudoprime when a prime
/// is requested and max \> lastSmallPrime*lastSmallPrime. \p lastSmallPrime
/// is declared in nbtheory.h.
bool Randomize(RandomNumberGenerator &rng, const Integer &min, const Integer &max, RandomNumberType rnType, const Integer &equiv=Zero(), const Integer &mod=One());
/// \brief Generate a random number
/// \param rng RandomNumberGenerator used to generate material
/// \param params additional parameters that cannot be passed directly to the function
/// \return true if a random number was generated, false otherwise
/// \details GenerateRandomNoThrow attempts to generate a random number according to the
/// parameters specified in params. The function does not throw RandomNumberNotFound.
/// \details 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");
///
bool GenerateRandomNoThrow(RandomNumberGenerator &rng, const NameValuePairs ¶ms = g_nullNameValuePairs);
/// \brief Generate a random number
/// \param rng RandomNumberGenerator used to generate material
/// \param params additional parameters that cannot be passed directly to the function
/// \throw RandomNumberNotFound if a random number is not found
/// \details GenerateRandom attempts to generate a random number according to the
/// parameters specified in params.
/// \details 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; }
///
void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs ¶ms = g_nullNameValuePairs)
{
if (!GenerateRandomNoThrow(rng, params))
throw RandomNumberNotFound();
}
/// \brief Set the n-th bit to value
/// \details 0-based numbering.
void SetBit(size_t n, bool value=1);
/// \brief Set the n-th byte to value
/// \details 0-based numbering.
void SetByte(size_t n, byte value);
/// \brief Reverse the Sign of the Integer
void Negate();
/// \brief Sets the Integer to positive
void SetPositive() {sign = POSITIVE;}
/// \brief Sets the Integer to negative
void SetNegative() {if (!!(*this)) sign = NEGATIVE;}
/// \brief Swaps this Integer with another Integer
void swap(Integer &a);
//@}
/// \name UNARY OPERATORS
//@{
/// \brief Negation
bool operator!() const;
/// \brief Addition
Integer operator+() const {return *this;}
/// \brief Subtraction
Integer operator-() const;
/// \brief Pre-increment
Integer& operator++();
/// \brief Pre-decrement
Integer& operator--();
/// \brief Post-increment
Integer operator++(int) {Integer temp = *this; ++*this; return temp;}
/// \brief Post-decrement
Integer operator--(int) {Integer temp = *this; --*this; return temp;}
//@}
/// \name BINARY OPERATORS
//@{
/// \brief Perform signed comparison
/// \param a the Integer to compare
/// \retval -1 if *this < a
/// \retval 0 if *this = a
/// \retval 1 if *this > a
int Compare(const Integer& a) const;
/// \brief Addition
Integer Plus(const Integer &b) const;
/// \brief Subtraction
Integer Minus(const Integer &b) const;
/// \brief Multiplication
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
Integer Times(const Integer &b) const;
/// \brief Division
Integer DividedBy(const Integer &b) const;
/// \brief Remainder
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
Integer Modulo(const Integer &b) const;
/// \brief Division
Integer DividedBy(word b) const;
/// \brief Remainder
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
word Modulo(word b) const;
/// \brief Bitwise AND
/// \param t the other Integer
/// \return the result of *this & t
/// \details 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.
/// \details 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
Integer And(const Integer& t) const;
/// \brief Bitwise OR
/// \param t the other Integer
/// \return the result of *this | t
/// \details 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.
/// \details 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
Integer Or(const Integer& t) const;
/// \brief Bitwise XOR
/// \param t the other Integer
/// \return the result of *this ^ t
/// \details 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.
/// \details 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
Integer Xor(const Integer& t) const;
/// \brief Right-shift
Integer operator>>(size_t n) const {return Integer(*this)>>=n;}
/// \brief Left-shift
Integer operator<<(size_t n) const {return Integer(*this)<<=n;}
//@}
/// \name OTHER ARITHMETIC FUNCTIONS
//@{
/// \brief Retrieve the absolute value of this integer
Integer AbsoluteValue() const;
/// \brief Add this integer to itself
Integer Doubled() const {return Plus(*this);}
/// \brief Multiply this integer by itself
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
Integer Squared() const {return Times(*this);}
/// \brief Extract square root
/// \details if negative return 0, else return floor of square root
Integer SquareRoot() const;
/// \brief Determine whether this integer is a perfect square
bool IsSquare() const;
/// \brief Determine if 1 or -1
/// \return true if this integer is 1 or -1, false otherwise
bool IsUnit() const;
/// \brief Calculate multiplicative inverse
/// \return MultiplicativeInverse inverse if 1 or -1, otherwise return 0.
Integer MultiplicativeInverse() const;
/// \brief Extended Division
/// \param r a reference for the remainder
/// \param q a reference for the quotient
/// \param a reference to the dividend
/// \param d reference to the divisor
/// \details Divide calculates r and q such that (a == d*q + r) && (0 <= r < abs(d)).
static void CRYPTOPP_API Divide(Integer &r, Integer &q, const Integer &a, const Integer &d);
/// \brief Extended Division
/// \param r a reference for the remainder
/// \param q a reference for the quotient
/// \param a reference to the dividend
/// \param d reference to the divisor
/// \details 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.
static void CRYPTOPP_API Divide(word &r, Integer &q, const Integer &a, word d);
/// \brief Extended Division
/// \param r a reference for the remainder
/// \param q a reference for the quotient
/// \param a reference to the dividend
/// \param n reference to the divisor
/// \details 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.
static void CRYPTOPP_API DivideByPowerOf2(Integer &r, Integer &q, const Integer &a, unsigned int n);
/// \brief Calculate greatest common divisor
/// \param a reference to the first number
/// \param n reference to the secind number
/// \return the greatest common divisor a and n.
static Integer CRYPTOPP_API Gcd(const Integer &a, const Integer &n);
/// \brief Calculate multiplicative inverse
/// \param n reference to the modulus
/// \return an Integer *this % n.
/// \details InverseMod returns the multiplicative inverse of the Integer *this
/// modulo the Integer n. If no Integer exists then Integer 0 is returned.
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
Integer InverseMod(const Integer &n) const;
/// \brief Calculate multiplicative inverse
/// \param n the modulus
/// \return a word *this % n.
/// \details InverseMod returns the multiplicative inverse of the Integer *this
/// modulo the word n. If no Integer exists then word 0 is returned.
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
word InverseMod(word n) const;
//@}
/// \name INPUT/OUTPUT
//@{
/// \brief Extraction operator
/// \param in reference to a std::istream
/// \param a reference to an Integer
/// \return reference to a std::istream reference
friend CRYPTOPP_DLL std::istream& CRYPTOPP_API operator>>(std::istream& in, Integer &a);
/// \brief Insertion operator
/// \param out reference to a std::ostream
/// \param a a constant reference to an Integer
/// \return reference to a std::ostream reference
/// \details The output integer responds to hex, std::oct, std::hex, std::upper and
/// std::lower. The output includes the suffix \a h (for hex), \a . (\a dot, for dec)
/// and \a o (for octal). There is currently no way to suppress the suffix.
/// \details If you want to print an Integer without the suffix or using an arbitrary base, then
/// use IntToString().
/// \sa IntToString
friend CRYPTOPP_DLL std::ostream& CRYPTOPP_API operator<<(std::ostream& out, const Integer &a);
//@}
/// \brief Modular multiplication
/// \param x reference to the first term
/// \param y reference to the second term
/// \param m reference to the modulus
/// \return an Integer (a * b) % m.
CRYPTOPP_DLL friend Integer CRYPTOPP_API a_times_b_mod_c(const Integer &x, const Integer& y, const Integer& m);
/// \brief Modular exponentiation
/// \param x reference to the base
/// \param e reference to the exponent
/// \param m reference to the modulus
/// \return an Integer (a ^ b) % m.
CRYPTOPP_DLL friend Integer CRYPTOPP_API a_exp_b_mod_c(const Integer &x, const Integer& e, const Integer& m);
protected:
// http://github.com/weidai11/cryptopp/issues/602
Integer InverseModNext(const Integer &n) const;
private:
Integer(word value, size_t length);
int PositiveCompare(const Integer &t) const;
IntegerSecBlock reg;
Sign sign;
#ifndef CRYPTOPP_DOXYGEN_PROCESSING
friend class ModularArithmetic;
friend class MontgomeryRepresentation;
friend class HalfMontgomeryRepresentation;
friend void PositiveAdd(Integer &sum, const Integer &a, const Integer &b);
friend void PositiveSubtract(Integer &diff, const Integer &a, const Integer &b);
friend void PositiveMultiply(Integer &product, const Integer &a, const Integer &b);
friend void PositiveDivide(Integer &remainder, Integer "ient, const Integer ÷nd, const Integer &divisor);
#endif
};
/// \brief Comparison
inline bool operator==(const CryptoPP::Integer& a, const CryptoPP::Integer& b) {return a.Compare(b)==0;}
/// \brief Comparison
inline bool operator!=(const CryptoPP::Integer& a, const CryptoPP::Integer& b) {return a.Compare(b)!=0;}
/// \brief Comparison
inline bool operator> (const CryptoPP::Integer& a, const CryptoPP::Integer& b) {return a.Compare(b)> 0;}
/// \brief Comparison
inline bool operator>=(const CryptoPP::Integer& a, const CryptoPP::Integer& b) {return a.Compare(b)>=0;}
/// \brief Comparison
inline bool operator< (const CryptoPP::Integer& a, const CryptoPP::Integer& b) {return a.Compare(b)< 0;}
/// \brief Comparison
inline bool operator<=(const CryptoPP::Integer& a, const CryptoPP::Integer& b) {return a.Compare(b)<=0;}
/// \brief Addition
inline CryptoPP::Integer operator+(const CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.Plus(b);}
/// \brief Subtraction
inline CryptoPP::Integer operator-(const CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.Minus(b);}
/// \brief Multiplication
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
inline CryptoPP::Integer operator*(const CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.Times(b);}
/// \brief Division
inline CryptoPP::Integer operator/(const CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.DividedBy(b);}
/// \brief Remainder
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
inline CryptoPP::Integer operator%(const CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.Modulo(b);}
/// \brief Division
inline CryptoPP::Integer operator/(const CryptoPP::Integer &a, CryptoPP::word b) {return a.DividedBy(b);}
/// \brief Remainder
/// \sa a_times_b_mod_c() and a_exp_b_mod_c()
inline CryptoPP::word operator%(const CryptoPP::Integer &a, CryptoPP::word b) {return a.Modulo(b);}
/// \brief Bitwise AND
/// \param a the first Integer
/// \param b the second Integer
/// \return the result of a & b
/// \details operator&() 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.
/// \details 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
inline CryptoPP::Integer operator&(const CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.And(b);}
/// \brief Bitwise OR
/// \param a the first Integer
/// \param b the second Integer
/// \return the result of a | b
/// \details operator|() 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.
/// \details 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
inline CryptoPP::Integer operator|(const CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.Or(b);}
/// \brief Bitwise XOR
/// \param a the first Integer
/// \param b the second Integer
/// \return the result of a ^ b
/// \details operator^() 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.
/// \details 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
inline CryptoPP::Integer operator^(const CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.Xor(b);}
NAMESPACE_END
#ifndef __BORLANDC__
NAMESPACE_BEGIN(std)
inline void swap(CryptoPP::Integer &a, CryptoPP::Integer &b)
{
a.swap(b);
}
NAMESPACE_END
#endif
#endif