polynomi.h
Go to the documentation of this file.
// polynomi.h - written and placed in the public domain by Wei Dai
//! \file
//! \headerfile polynomi.h
//! \brief Classes for polynomial basis and operations
#ifndef CRYPTOPP_POLYNOMI_H
#define CRYPTOPP_POLYNOMI_H
/*! \file */
#include "cryptlib.h"
#include "secblock.h"
#include "algebra.h"
#include "misc.h"
#include <iosfwd>
#include <vector>
NAMESPACE_BEGIN(CryptoPP)
//! represents single-variable polynomials over arbitrary rings
/*! \nosubgrouping */
template <class T> class PolynomialOver
{
public:
//! \name ENUMS, EXCEPTIONS, and TYPEDEFS
//@{
//! division by zero exception
class DivideByZero : public Exception
{
public:
DivideByZero() : Exception(OTHER_ERROR, "PolynomialOver<T>: division by zero") {}
};
//! specify the distribution for randomization functions
class RandomizationParameter
{
public:
RandomizationParameter(unsigned int coefficientCount, const typename T::RandomizationParameter &coefficientParameter )
: m_coefficientCount(coefficientCount), m_coefficientParameter(coefficientParameter) {}
private:
unsigned int m_coefficientCount;
typename T::RandomizationParameter m_coefficientParameter;
friend class PolynomialOver<T>;
};
typedef T Ring;
typedef typename T::Element CoefficientType;
//@}
//! \name CREATORS
//@{
//! creates the zero polynomial
PolynomialOver() {}
//!
PolynomialOver(const Ring &ring, unsigned int count)
: m_coefficients((size_t)count, ring.Identity()) {}
//! copy constructor
PolynomialOver(const PolynomialOver<Ring> &t)
: m_coefficients(t.m_coefficients.size()) {*this = t;}
//! construct constant polynomial
PolynomialOver(const CoefficientType &element)
: m_coefficients(1, element) {}
//! construct polynomial with specified coefficients, starting from coefficient of x^0
template <typename Iterator> PolynomialOver(Iterator begin, Iterator end)
: m_coefficients(begin, end) {}
//! convert from string
PolynomialOver(const char *str, const Ring &ring) {FromStr(str, ring);}
//! convert from big-endian byte array
PolynomialOver(const byte *encodedPolynomialOver, unsigned int byteCount);
//! convert from Basic Encoding Rules encoded byte array
explicit PolynomialOver(const byte *BEREncodedPolynomialOver);
//! convert from BER encoded byte array stored in a BufferedTransformation object
explicit PolynomialOver(BufferedTransformation &bt);
//! create a random PolynomialOver<T>
PolynomialOver(RandomNumberGenerator &rng, const RandomizationParameter &parameter, const Ring &ring)
{Randomize(rng, parameter, ring);}
//@}
//! \name ACCESSORS
//@{
//! the zero polynomial will return a degree of -1
int Degree(const Ring &ring) const {return int(CoefficientCount(ring))-1;}
//!
unsigned int CoefficientCount(const Ring &ring) const;
//! return coefficient for x^i
CoefficientType GetCoefficient(unsigned int i, const Ring &ring) const;
//@}
//! \name MANIPULATORS
//@{
//!
PolynomialOver<Ring>& operator=(const PolynomialOver<Ring>& t);
//!
void Randomize(RandomNumberGenerator &rng, const RandomizationParameter &parameter, const Ring &ring);
//! set the coefficient for x^i to value
void SetCoefficient(unsigned int i, const CoefficientType &value, const Ring &ring);
//!
void Negate(const Ring &ring);
//!
void swap(PolynomialOver<Ring> &t);
//@}
//! \name BASIC ARITHMETIC ON POLYNOMIALS
//@{
bool Equals(const PolynomialOver<Ring> &t, const Ring &ring) const;
bool IsZero(const Ring &ring) const {return CoefficientCount(ring)==0;}
PolynomialOver<Ring> Plus(const PolynomialOver<Ring>& t, const Ring &ring) const;
PolynomialOver<Ring> Minus(const PolynomialOver<Ring>& t, const Ring &ring) const;
PolynomialOver<Ring> Inverse(const Ring &ring) const;
PolynomialOver<Ring> Times(const PolynomialOver<Ring>& t, const Ring &ring) const;
PolynomialOver<Ring> DividedBy(const PolynomialOver<Ring>& t, const Ring &ring) const;
PolynomialOver<Ring> Modulo(const PolynomialOver<Ring>& t, const Ring &ring) const;
PolynomialOver<Ring> MultiplicativeInverse(const Ring &ring) const;
bool IsUnit(const Ring &ring) const;
PolynomialOver<Ring>& Accumulate(const PolynomialOver<Ring>& t, const Ring &ring);
PolynomialOver<Ring>& Reduce(const PolynomialOver<Ring>& t, const Ring &ring);
//!
PolynomialOver<Ring> Doubled(const Ring &ring) const {return Plus(*this, ring);}
//!
PolynomialOver<Ring> Squared(const Ring &ring) const {return Times(*this, ring);}
CoefficientType EvaluateAt(const CoefficientType &x, const Ring &ring) const;
PolynomialOver<Ring>& ShiftLeft(unsigned int n, const Ring &ring);
PolynomialOver<Ring>& ShiftRight(unsigned int n, const Ring &ring);
//! calculate r and q such that (a == d*q + r) && (0 <= degree of r < degree of d)
static void Divide(PolynomialOver<Ring> &r, PolynomialOver<Ring> &q, const PolynomialOver<Ring> &a, const PolynomialOver<Ring> &d, const Ring &ring);
//@}
//! \name INPUT/OUTPUT
//@{
std::istream& Input(std::istream &in, const Ring &ring);
std::ostream& Output(std::ostream &out, const Ring &ring) const;
//@}
private:
void FromStr(const char *str, const Ring &ring);
std::vector<CoefficientType> m_coefficients;
};
//! Polynomials over a fixed ring
/*! Having a fixed ring allows overloaded operators */
template <class T, int instance> class PolynomialOverFixedRing : private PolynomialOver<T>
{
typedef PolynomialOver<T> B;
typedef PolynomialOverFixedRing<T, instance> ThisType;
public:
typedef T Ring;
typedef typename T::Element CoefficientType;
typedef typename B::DivideByZero DivideByZero;
typedef typename B::RandomizationParameter RandomizationParameter;
//! \name CREATORS
//@{
//! creates the zero polynomial
PolynomialOverFixedRing(unsigned int count = 0) : B(ms_fixedRing, count) {}
//! copy constructor
PolynomialOverFixedRing(const ThisType &t) : B(t) {}
explicit PolynomialOverFixedRing(const B &t) : B(t) {}
//! construct constant polynomial
PolynomialOverFixedRing(const CoefficientType &element) : B(element) {}
//! construct polynomial with specified coefficients, starting from coefficient of x^0
template <typename Iterator> PolynomialOverFixedRing(Iterator first, Iterator last)
: B(first, last) {}
//! convert from string
explicit PolynomialOverFixedRing(const char *str) : B(str, ms_fixedRing) {}
//! convert from big-endian byte array
PolynomialOverFixedRing(const byte *encodedPoly, unsigned int byteCount) : B(encodedPoly, byteCount) {}
//! convert from Basic Encoding Rules encoded byte array
explicit PolynomialOverFixedRing(const byte *BEREncodedPoly) : B(BEREncodedPoly) {}
//! convert from BER encoded byte array stored in a BufferedTransformation object
explicit PolynomialOverFixedRing(BufferedTransformation &bt) : B(bt) {}
//! create a random PolynomialOverFixedRing
PolynomialOverFixedRing(RandomNumberGenerator &rng, const RandomizationParameter &parameter) : B(rng, parameter, ms_fixedRing) {}
static const ThisType &Zero();
static const ThisType &One();
//@}
//! \name ACCESSORS
//@{
//! the zero polynomial will return a degree of -1
int Degree() const {return B::Degree(ms_fixedRing);}
//! degree + 1
unsigned int CoefficientCount() const {return B::CoefficientCount(ms_fixedRing);}
//! return coefficient for x^i
CoefficientType GetCoefficient(unsigned int i) const {return B::GetCoefficient(i, ms_fixedRing);}
//! return coefficient for x^i
CoefficientType operator[](unsigned int i) const {return B::GetCoefficient(i, ms_fixedRing);}
//@}
//! \name MANIPULATORS
//@{
//!
ThisType& operator=(const ThisType& t) {B::operator=(t); return *this;}
//!
ThisType& operator+=(const ThisType& t) {Accumulate(t, ms_fixedRing); return *this;}
//!
ThisType& operator-=(const ThisType& t) {Reduce(t, ms_fixedRing); return *this;}
//!
ThisType& operator*=(const ThisType& t) {return *this = *this*t;}
//!
ThisType& operator/=(const ThisType& t) {return *this = *this/t;}
//!
ThisType& operator%=(const ThisType& t) {return *this = *this%t;}
//!
ThisType& operator<<=(unsigned int n) {ShiftLeft(n, ms_fixedRing); return *this;}
//!
ThisType& operator>>=(unsigned int n) {ShiftRight(n, ms_fixedRing); return *this;}
//! set the coefficient for x^i to value
void SetCoefficient(unsigned int i, const CoefficientType &value) {B::SetCoefficient(i, value, ms_fixedRing);}
//!
void Randomize(RandomNumberGenerator &rng, const RandomizationParameter &parameter) {B::Randomize(rng, parameter, ms_fixedRing);}
//!
void Negate() {B::Negate(ms_fixedRing);}
void swap(ThisType &t) {B::swap(t);}
//@}
//! \name UNARY OPERATORS
//@{
//!
bool operator!() const {return CoefficientCount()==0;}
//!
ThisType operator+() const {return *this;}
//!
ThisType operator-() const {return ThisType(Inverse(ms_fixedRing));}
//@}
//! \name BINARY OPERATORS
//@{
//!
friend ThisType operator>>(ThisType a, unsigned int n) {return ThisType(a>>=n);}
//!
friend ThisType operator<<(ThisType a, unsigned int n) {return ThisType(a<<=n);}
//@}
//! \name OTHER ARITHMETIC FUNCTIONS
//@{
//!
ThisType MultiplicativeInverse() const {return ThisType(B::MultiplicativeInverse(ms_fixedRing));}
//!
bool IsUnit() const {return B::IsUnit(ms_fixedRing);}
//!
ThisType Doubled() const {return ThisType(B::Doubled(ms_fixedRing));}
//!
ThisType Squared() const {return ThisType(B::Squared(ms_fixedRing));}
CoefficientType EvaluateAt(const CoefficientType &x) const {return B::EvaluateAt(x, ms_fixedRing);}
//! calculate r and q such that (a == d*q + r) && (0 <= r < abs(d))
static void Divide(ThisType &r, ThisType &q, const ThisType &a, const ThisType &d)
{B::Divide(r, q, a, d, ms_fixedRing);}
//@}
//! \name INPUT/OUTPUT
//@{
//!
friend std::istream& operator>>(std::istream& in, ThisType &a)
{return a.Input(in, ms_fixedRing);}
//!
friend std::ostream& operator<<(std::ostream& out, const ThisType &a)
{return a.Output(out, ms_fixedRing);}
//@}
private:
struct NewOnePolynomial
{
ThisType * operator()() const
{
return new ThisType(ms_fixedRing.MultiplicativeIdentity());
}
};
static const Ring ms_fixedRing;
};
//! Ring of polynomials over another ring
template <class T> class RingOfPolynomialsOver : public AbstractEuclideanDomain<PolynomialOver<T> >
{
public:
typedef T CoefficientRing;
typedef PolynomialOver<T> Element;
typedef typename Element::CoefficientType CoefficientType;
typedef typename Element::RandomizationParameter RandomizationParameter;
RingOfPolynomialsOver(const CoefficientRing &ring) : m_ring(ring) {}
Element RandomElement(RandomNumberGenerator &rng, const RandomizationParameter &parameter)
{return Element(rng, parameter, m_ring);}
bool Equal(const Element &a, const Element &b) const
{return a.Equals(b, m_ring);}
const Element& Identity() const
{return this->result = m_ring.Identity();}
const Element& Add(const Element &a, const Element &b) const
{return this->result = a.Plus(b, m_ring);}
Element& Accumulate(Element &a, const Element &b) const
{a.Accumulate(b, m_ring); return a;}
const Element& Inverse(const Element &a) const
{return this->result = a.Inverse(m_ring);}
const Element& Subtract(const Element &a, const Element &b) const
{return this->result = a.Minus(b, m_ring);}
Element& Reduce(Element &a, const Element &b) const
{return a.Reduce(b, m_ring);}
const Element& Double(const Element &a) const
{return this->result = a.Doubled(m_ring);}
const Element& MultiplicativeIdentity() const
{return this->result = m_ring.MultiplicativeIdentity();}
const Element& Multiply(const Element &a, const Element &b) const
{return this->result = a.Times(b, m_ring);}
const Element& Square(const Element &a) const
{return this->result = a.Squared(m_ring);}
bool IsUnit(const Element &a) const
{return a.IsUnit(m_ring);}
const Element& MultiplicativeInverse(const Element &a) const
{return this->result = a.MultiplicativeInverse(m_ring);}
const Element& Divide(const Element &a, const Element &b) const
{return this->result = a.DividedBy(b, m_ring);}
const Element& Mod(const Element &a, const Element &b) const
{return this->result = a.Modulo(b, m_ring);}
void DivisionAlgorithm(Element &r, Element &q, const Element &a, const Element &d) const
{Element::Divide(r, q, a, d, m_ring);}
class InterpolationFailed : public Exception
{
public:
InterpolationFailed() : Exception(OTHER_ERROR, "RingOfPolynomialsOver<T>: interpolation failed") {}
};
Element Interpolate(const CoefficientType x[], const CoefficientType y[], unsigned int n) const;
// a faster version of Interpolate(x, y, n).EvaluateAt(position)
CoefficientType InterpolateAt(const CoefficientType &position, const CoefficientType x[], const CoefficientType y[], unsigned int n) const;
/*
void PrepareBulkInterpolation(CoefficientType *w, const CoefficientType x[], unsigned int n) const;
void PrepareBulkInterpolationAt(CoefficientType *v, const CoefficientType &position, const CoefficientType x[], const CoefficientType w[], unsigned int n) const;
CoefficientType BulkInterpolateAt(const CoefficientType y[], const CoefficientType v[], unsigned int n) const;
*/
protected:
void CalculateAlpha(std::vector<CoefficientType> &alpha, const CoefficientType x[], const CoefficientType y[], unsigned int n) const;
CoefficientRing m_ring;
};
template <class Ring, class Element>
void PrepareBulkPolynomialInterpolation(const Ring &ring, Element *w, const Element x[], unsigned int n);
template <class Ring, class Element>
void PrepareBulkPolynomialInterpolationAt(const Ring &ring, Element *v, const Element &position, const Element x[], const Element w[], unsigned int n);
template <class Ring, class Element>
Element BulkPolynomialInterpolateAt(const Ring &ring, const Element y[], const Element v[], unsigned int n);
//!
template <class T, int instance>
inline bool operator==(const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return a.Equals(b, a.ms_fixedRing);}
//!
template <class T, int instance>
inline bool operator!=(const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return !(a==b);}
//!
template <class T, int instance>
inline bool operator> (const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return a.Degree() > b.Degree();}
//!
template <class T, int instance>
inline bool operator>=(const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return a.Degree() >= b.Degree();}
//!
template <class T, int instance>
inline bool operator< (const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return a.Degree() < b.Degree();}
//!
template <class T, int instance>
inline bool operator<=(const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return a.Degree() <= b.Degree();}
//!
template <class T, int instance>
inline CryptoPP::PolynomialOverFixedRing<T, instance> operator+(const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return CryptoPP::PolynomialOverFixedRing<T, instance>(a.Plus(b, a.ms_fixedRing));}
//!
template <class T, int instance>
inline CryptoPP::PolynomialOverFixedRing<T, instance> operator-(const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return CryptoPP::PolynomialOverFixedRing<T, instance>(a.Minus(b, a.ms_fixedRing));}
//!
template <class T, int instance>
inline CryptoPP::PolynomialOverFixedRing<T, instance> operator*(const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return CryptoPP::PolynomialOverFixedRing<T, instance>(a.Times(b, a.ms_fixedRing));}
//!
template <class T, int instance>
inline CryptoPP::PolynomialOverFixedRing<T, instance> operator/(const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return CryptoPP::PolynomialOverFixedRing<T, instance>(a.DividedBy(b, a.ms_fixedRing));}
//!
template <class T, int instance>
inline CryptoPP::PolynomialOverFixedRing<T, instance> operator%(const CryptoPP::PolynomialOverFixedRing<T, instance> &a, const CryptoPP::PolynomialOverFixedRing<T, instance> &b)
{return CryptoPP::PolynomialOverFixedRing<T, instance>(a.Modulo(b, a.ms_fixedRing));}
NAMESPACE_END
NAMESPACE_BEGIN(std)
template<class T> inline void swap(CryptoPP::PolynomialOver<T> &a, CryptoPP::PolynomialOver<T> &b)
{
a.swap(b);
}
template<class T, int i> inline void swap(CryptoPP::PolynomialOverFixedRing<T,i> &a, CryptoPP::PolynomialOverFixedRing<T,i> &b)
{
a.swap(b);
}
NAMESPACE_END
#endif
RingOfPolynomialsOver::DivisionAlgorithm
void DivisionAlgorithm(Element &r, Element &q, const Element &a, const Element &d) const
Performs the division algorithm on two elements in the ring.
Definition: polynomi.h:376
PolynomialOverFixedRing::operator[]
CoefficientType operator[](unsigned int i) const
return coefficient for x^i
Definition: polynomi.h:223
PolynomialOver::PolynomialOver
PolynomialOver()
creates the zero polynomial
Definition: polynomi.h:57
PolynomialOver
represents single-variable polynomials over arbitrary rings
Definition: polynomi.h:25
RingOfPolynomialsOver::Reduce
Element & Reduce(Element &a, const Element &b) const
Reduces an element in the congruence class.
Definition: polynomi.h:349
RingOfPolynomialsOver::InterpolationFailed
Definition: polynomi.h:379
PolynomialOver::PolynomialOver
PolynomialOver(RandomNumberGenerator &rng, const RandomizationParameter &parameter, const Ring &ring)
create a random PolynomialOver<T>
Definition: polynomi.h:88
RingOfPolynomialsOver
Ring of polynomials over another ring.
Definition: polynomi.h:318
PolynomialOver::DivideByZero
division by zero exception
Definition: polynomi.h:31
PolynomialOver::Divide
static void Divide(PolynomialOver< Ring > &r, PolynomialOver< Ring > &q, const PolynomialOver< Ring > &a, const PolynomialOver< Ring > &d, const Ring &ring)
calculate r and q such that (a == d*q + r) && (0 <= degree of r < degree of d)
Definition: polynomi.cpp:430
PolynomialOverFixedRing::PolynomialOverFixedRing
PolynomialOverFixedRing(unsigned int count=0)
creates the zero polynomial
Definition: polynomi.h:181
RingOfPolynomialsOver::MultiplicativeInverse
const Element & MultiplicativeInverse(const Element &a) const
Calculate the multiplicative inverse of an element in the group.
Definition: polynomi.h:367
secblock.h
Classes and functions for secure memory allocations.
BufferedTransformation
Interface for buffered transformations.
Definition: cryptlib.h:1352
RingOfPolynomialsOver::Double
const Element & Double(const Element &a) const
Doubles an element in the group.
Definition: polynomi.h:352
PolynomialOverFixedRing::GetCoefficient
CoefficientType GetCoefficient(unsigned int i) const
return coefficient for x^i
Definition: polynomi.h:221
PolynomialOverFixedRing::SetCoefficient
void SetCoefficient(unsigned int i, const CoefficientType &value)
set the coefficient for x^i to value
Definition: polynomi.h:247
RingOfPolynomialsOver::Multiply
const Element & Multiply(const Element &a, const Element &b) const
Multiplies elements in the group.
Definition: polynomi.h:358
PolynomialOver::PolynomialOver
PolynomialOver(const CoefficientType &element)
construct constant polynomial
Definition: polynomi.h:68
RingOfPolynomialsOver::Inverse
const Element & Inverse(const Element &a) const
Inverts the element in the group.
Definition: polynomi.h:343
PolynomialOverFixedRing::PolynomialOverFixedRing
PolynomialOverFixedRing(BufferedTransformation &bt)
convert from BER encoded byte array stored in a BufferedTransformation object
Definition: polynomi.h:205
PolynomialOverFixedRing::PolynomialOverFixedRing
PolynomialOverFixedRing(const ThisType &t)
copy constructor
Definition: polynomi.h:184
RingOfPolynomialsOver::Accumulate
Element & Accumulate(Element &a, const Element &b) const
TODO.
Definition: polynomi.h:340
PolynomialOver::RandomizationParameter
specify the distribution for randomization functions
Definition: polynomi.h:38
RingOfPolynomialsOver::Square
const Element & Square(const Element &a) const
Square an element in the group.
Definition: polynomi.h:361
RingOfPolynomialsOver::Add
const Element & Add(const Element &a, const Element &b) const
Adds elements in the group.
Definition: polynomi.h:337
PolynomialOverFixedRing::Divide
static void Divide(ThisType &r, ThisType &q, const ThisType &a, const ThisType &d)
calculate r and q such that (a == d*q + r) && (0 <= r < abs(d))
Definition: polynomi.h:291
PolynomialOverFixedRing::PolynomialOverFixedRing
PolynomialOverFixedRing(Iterator first, Iterator last)
construct polynomial with specified coefficients, starting from coefficient of x^0
Definition: polynomi.h:192
RandomNumberGenerator
Interface for random number generators.
Definition: cryptlib.h:1186
PolynomialOverFixedRing::PolynomialOverFixedRing
PolynomialOverFixedRing(RandomNumberGenerator &rng, const RandomizationParameter &parameter)
create a random PolynomialOverFixedRing
Definition: polynomi.h:208
operator>
bool operator>(const ::PolynomialMod2 &a, const ::PolynomialMod2 &b)
compares degree
Definition: gf2n.h:247
PolynomialOver::GetCoefficient
CoefficientType GetCoefficient(unsigned int i, const Ring &ring) const
return coefficient for x^i
Definition: polynomi.cpp:86
Exception
Base class for all exceptions thrown by the library.
Definition: cryptlib.h:139
operator==
bool operator==(const OID &lhs, const OID &rhs)
Compare two OIDs for equality.
misc.h
Utility functions for the Crypto++ library.
operator<=
bool operator<=(const ::PolynomialMod2 &a, const ::PolynomialMod2 &b)
compares degree
Definition: gf2n.h:256
PolynomialOver::Degree
int Degree(const Ring &ring) const
the zero polynomial will return a degree of -1
Definition: polynomi.h:95
PolynomialOver::PolynomialOver
PolynomialOver(Iterator begin, Iterator end)
construct polynomial with specified coefficients, starting from coefficient of x^0
Definition: polynomi.h:72
RingOfPolynomialsOver::Mod
const Element & Mod(const Element &a, const Element &b) const
Performs a modular reduction in the ring.
Definition: polynomi.h:373
PolynomialOverFixedRing::PolynomialOverFixedRing
PolynomialOverFixedRing(const byte *BEREncodedPoly)
convert from Basic Encoding Rules encoded byte array
Definition: polynomi.h:202
PolynomialOver::SetCoefficient
void SetCoefficient(unsigned int i, const CoefficientType &value, const Ring &ring)
set the coefficient for x^i to value
Definition: polynomi.cpp:182
RingOfPolynomialsOver::Subtract
const Element & Subtract(const Element &a, const Element &b) const
Subtracts elements in the group.
Definition: polynomi.h:346
PolynomialOver::PolynomialOver
PolynomialOver(const PolynomialOver< Ring > &t)
copy constructor
Definition: polynomi.h:64
PolynomialOverFixedRing::CoefficientCount
unsigned int CoefficientCount() const
degree + 1
Definition: polynomi.h:219
AbstractEuclideanDomain
Abstract Euclidean domain.
Definition: algebra.h:276
PolynomialOverFixedRing
Polynomials over a fixed ring.
Definition: polynomi.h:167
RingOfPolynomialsOver::Divide
const Element & Divide(const Element &a, const Element &b) const
Divides elements in the group.
Definition: polynomi.h:370
PolynomialOver::PolynomialOver
PolynomialOver(const char *str, const Ring &ring)
convert from string
Definition: polynomi.h:76
PolynomialOverFixedRing::Degree
int Degree() const
the zero polynomial will return a degree of -1
Definition: polynomi.h:217
PolynomialOverFixedRing::PolynomialOverFixedRing
PolynomialOverFixedRing(const char *str)
convert from string
Definition: polynomi.h:196
RingOfPolynomialsOver::IsUnit
bool IsUnit(const Element &a) const
Determines whether an element is a unit in the group.
Definition: polynomi.h:364
PolynomialOverFixedRing::PolynomialOverFixedRing
PolynomialOverFixedRing(const byte *encodedPoly, unsigned int byteCount)
convert from big-endian byte array
Definition: polynomi.h:199
algebra.h
Classes for performing mathematics over different fields.
CryptoPP
Crypto++ library namespace.
PolynomialOverFixedRing::PolynomialOverFixedRing
PolynomialOverFixedRing(const CoefficientType &element)
construct constant polynomial
Definition: polynomi.h:189
operator>=
bool operator>=(const ::PolynomialMod2 &a, const ::PolynomialMod2 &b)
compares degree
Definition: gf2n.h:250
RingOfPolynomialsOver::Equal
bool Equal(const Element &a, const Element &b) const
Compare two elements for equality.
Definition: polynomi.h:331
operator+
OID operator+(const OID &lhs, unsigned long rhs)
Append a value to an OID.
operator!=
bool operator!=(const OID &lhs, const OID &rhs)
Compare two OIDs for inequality.
Exception::Exception
Exception(ErrorType errorType, const std::string &s)
Construct a new Exception.
Definition: cryptlib.h:162
operator*
inline ::Integer operator*(const ::Integer &a, const ::Integer &b)
Definition: integer.h:595
Exception::OTHER_ERROR
@ OTHER_ERROR
Some other error occurred not belonging to other categories.
Definition: cryptlib.h:158
cryptlib.h
Abstract base classes that provide a uniform interface to this library.