Main Page | Modules | Namespace List | Class Hierarchy | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages

PIR_ntl_ZZ_p Class Reference
[linbox/field]

#include <PIR-ntl-ZZ_p.h>

Inheritance diagram for PIR_ntl_ZZ_p:

UnparametricField< NTL::ZZ_p > FieldInterface

Detailed Description

extend Wrapper of ZZ_p from NTL. Add PIR functions


Public Types

typedef NTL::ZZ_p Element

Public Member Functions

template<class Element2>  PIR_ntl_ZZ_p (const Element2 &d)
 PIR_ntl_ZZ_p (const NTL::ZZ &d)
 PIR_ntl_ZZ_p (const integer &d, int exp=1)
std::istream & read (std::istream &in)

Static Public Member Functions

integer & cardinality (integer &c)
NTL::ZZ & cardinality (NTL::ZZ &c)
integer & characteristic (integer &c)
std::ostream & write (std::ostream &out)
template<class Element2> Element & init (Element &x, const Element2 &y)
 Init x from y.

Element & init (Element &x, const Element &y)
 Init from a NTL::ZZ_p.

Element & init (Element &x, const integer &y)
 I don't know how to init from integer.

integer & convert (integer &x, const Element &y)
 Convert y to an Element.

Element & assign (Element &x, const Element &y)
 x = y.

bool areEqual (const Element &x, const Element &y)
 Test if x == y.

bool isZero (const Element &x)
 Test if x == 0.

bool isOne (const Element &x)
 Test if x == 1.

Element & add (Element &x, const Element &y, const Element &z)
 return x = y + z

Element & sub (Element &x, const Element &y, const Element &z)
 return x = y - z

template<class Int> Element & mul (Element &x, const Element &y, const Int &z)
 return x = y * z

Element & div (Element &x, const Element &y, const Element &z)
 If exists a, such that a * z =y, return x = one of them. Otherwise, throw an exception.

Element & inv (Element &x, const Element &y)
 If y is a unit, return x = 1 / y, otherwsie, throw an exception.

Element & neg (Element &x, const Element &y)
 return x = -y;

template<class Int> Element & axpy (Element &r, const Element &a, const Int &x, const Element &y)
 return r = a x + y

Element & addin (Element &x, const Element &y)
 return x += y;

Element & subin (Element &x, const Element &y)
 return x -= y;

template<class Int> Element & mulin (Element &x, const Int &y)
 return x *= y;

Element & divin (Element &x, const Element &y)
 If y divides x, return x /= y, otherwise throw an exception.

Element & invin (Element &x)
 If x is a unit, x = 1 / x, otherwise, throw an exception.

Element & negin (Element &x)
 return x = -x;

template<class Int> Element & axpyin (Element &r, const Element &a, const Int &x)
 return r += a x

std::ostream & write (std::ostream &out, const Element &y)
 out << y;

std::istream & read (std::istream &in, Element &x)
 read x from istream in

bool isUnit (const Element &x)
 Test if x is a unit.

Element & gcd (Element &g, const Element &a, const Element &b)
 return g = gcd (a, b)

Element & gcdin (Element &g, const Element &b)
 return g = gcd (g, b)

Element & xgcd (Element &g, Element &s, Element &t, const Element &a, const Element &b)
 g = gcd(a, b) = a*s + b*t. and gcd (s, t) is a unit.

Element & dxgcd (Element &g, Element &s, Element &t, Element &a1, Element &b1, const Element &a, const Element &b)
 g = gcd(a, b) = a*s + b*t. and gcd (s, t) is a unit. s * a1 + t * b1 = a unit.

bool isDivisor (const Element &a, const Element &b)
 Test if a | b.

Element & normal (Element &a, const Element &b)
 a = normalization of b.

Element & normalIn (Element &a)
integer getMaxModulus ()

Member Typedef Documentation

typedef NTL::ZZ_p Element
 

The field's element type. Type K must provide a default constructor, a copy constructor, a destructor, and an assignment operator.

Reimplemented from UnparametricField< NTL::ZZ_p >.

Constructor & Destructor Documentation

PIR_ntl_ZZ_p (  const Element2 &  d  )  [inline]
 

PIR_ntl_ZZ_p (  const NTL::ZZ &  d  )  [inline]
 

PIR_ntl_ZZ_p (  const integer &  d,
int  exp = 1
)  [inline]
 

Member Function Documentation

integer& cardinality (  integer &  c  )  [inline, static]
 

NTL::ZZ& cardinality (  NTL::ZZ &  c  )  [inline, static]
 

integer& characteristic (  integer &  c  )  [inline, static]
 

std::ostream& write (  std::ostream &  out  )  [inline, static]
 

std::istream& read (  std::istream &  in  )  [inline]
 

Element& init (  Element &  x,
const Element2 &  y
)  [inline, static]
 

Init x from y.

Element& init (  Element &  x,
const Element &  y
)  [inline, static]
 

Init from a NTL::ZZ_p.

Element& init (  Element &  x,
const integer &  y
)  [inline, static]
 

I don't know how to init from integer.

integer& convert (  integer &  x,
const Element &  y
)  [inline, static]
 

Convert y to an Element.

Element& assign (  Element &  x,
const Element &  y
)  [inline, static]
 

x = y.

bool areEqual (  const Element &  x,
const Element &  y
)  [inline, static]
 

Test if x == y.

bool isZero (  const Element &  x  )  [inline, static]
 

Test if x == 0.

bool isOne (  const Element &  x  )  [inline, static]
 

Test if x == 1.

Element& add (  Element &  x,
const Element &  y,
const Element &  z
)  [inline, static]
 

return x = y + z

Element& sub (  Element &  x,
const Element &  y,
const Element &  z
)  [inline, static]
 

return x = y - z

Element& mul (  Element &  x,
const Element &  y,
const Int &  z
)  [inline, static]
 

return x = y * z

Element& div (  Element &  x,
const Element &  y,
const Element &  z
)  [inline, static]
 

If exists a, such that a * z =y, return x = one of them. Otherwise, throw an exception.

Element& inv (  Element &  x,
const Element &  y
)  [inline, static]
 

If y is a unit, return x = 1 / y, otherwsie, throw an exception.

Element& neg (  Element &  x,
const Element &  y
)  [inline, static]
 

return x = -y;

Element& axpy (  Element &  r,
const Element &  a,
const Int &  x,
const Element &  y
)  [inline, static]
 

return r = a x + y

Element& addin (  Element &  x,
const Element &  y
)  [inline, static]
 

return x += y;

Element& subin (  Element &  x,
const Element &  y
)  [inline, static]
 

return x -= y;

Element& mulin (  Element &  x,
const Int &  y
)  [inline, static]
 

return x *= y;

Element& divin (  Element &  x,
const Element &  y
)  [inline, static]
 

If y divides x, return x /= y, otherwise throw an exception.

Element& invin (  Element &  x  )  [inline, static]
 

If x is a unit, x = 1 / x, otherwise, throw an exception.

Element& negin (  Element &  x  )  [inline, static]
 

return x = -x;

Element& axpyin (  Element &  r,
const Element &  a,
const Int &  x
)  [inline, static]
 

return r += a x

std::ostream& write (  std::ostream &  out,
const Element &  y
)  [inline, static]
 

out << y;

std::istream& read (  std::istream &  in,
Element &  x
)  [inline, static]
 

read x from istream in

bool isUnit (  const Element &  x  )  [inline, static]
 

Test if x is a unit.

Element& gcd (  Element &  g,
const Element &  a,
const Element &  b
)  [inline, static]
 

return g = gcd (a, b)

Element& gcdin (  Element &  g,
const Element &  b
)  [inline, static]
 

return g = gcd (g, b)

Element& xgcd (  Element &  g,
Element &  s,
Element &  t,
const Element &  a,
const Element &  b
)  [inline, static]
 

g = gcd(a, b) = a*s + b*t. and gcd (s, t) is a unit.

Element& dxgcd (  Element &  g,
Element &  s,
Element &  t,
Element &  a1,
Element &  b1,
const Element &  a,
const Element &  b
)  [inline, static]
 

g = gcd(a, b) = a*s + b*t. and gcd (s, t) is a unit. s * a1 + t * b1 = a unit.

bool isDivisor (  const Element &  a,
const Element &  b
)  [inline, static]
 

Test if a | b.

Element& normal (  Element &  a,
const Element &  b
)  [inline, static]
 

a = normalization of b.

Element& normalIn (  Element &  a  )  [inline, static]
 

integer getMaxModulus (   )  [inline, static]
 

Generated on Fri Jul 8 10:29:54 2005 for linbox by doxygen 1.3.7