linbox  1
Classes | Public Types | Protected Attributes
PowerOfTwoModular< Ints > Class Template Reference

Ring of elements modulo some power of two. More...

#include <poweroftwomodular.h>

List of all members.

Classes

struct  RandIter

Public Types

typedef Ints Element

Public Member Functions

Object Management
 PowerOfTwoModular (void)
integerconvert (integer &x, const Element &y) const
Elementinit (Element &x, const Ints &y=0) const
Elementassign (Element &x, const Element &y) const
integercardinality (integer &c) const
integercharacteristic (integer &c) const
int & poweroftwo (int &c)
Arithmetic Operations

x <- y op z; x <- op y These operations require all elements, including x, to be initialized before the operation is called. Uninitialized field base elements will give undefined results.

bool areEqual (const Element &x, const Element &y) const
bool isZero (const Element &x) const
bool isOne (const Element &x) const
bool isUnit (const Element &x) const
bool isZeroDivisor (const Element &x) const
Elementgcd_poweroftwo (Element &x, const Element &y) const
bool doesdivide (const Element &x, const Element &y) const
int poweroftwoinx (const Element &x) const
Elementbezout (const Element &x, const Element &y, Element &gcd, Element &u, Element &v) const
Elementadd (Element &x, const Element &y, const Element &z) const
Elementsub (Element &x, const Element &y, const Element &z) const
Elementmul (Element &x, const Element &y, const Element &z) const
Elementdiv (Element &x, const Element &y, const Element &z) const
Elementneg (Element &x, const Element &y) const
Elementinv (Element &x, const Element &y) const
Elementinv2 (Element &x, const Element &y) const
Elementaxpy (Element &r, const Element &a, const Element &x, const Element &y) const
Input/Output Operations
std::ostream & write (std::ostream &os) const
std::istream & read (std::istream &is)
std::ostream & write (std::ostream &os, const Element &x) const
std::istream & read (std::istream &is, Element &x) const
Inplace Arithmetic Operations

x <- x op y; x <- op x

Elementaddin (Element &x, const Element &y) const
Elementsubin (Element &x, const Element &y) const
Elementmulin (Element &x, const Element &y) const
Elementdivin (Element &x, const Element &y) const
Elementnegin (Element &x) const
Elementinvin (Element &x) const
Elementaxpyin (Element &r, const Element &a, const Element &x) const

Protected Attributes

Element _poweroftwo
 Private (non-static) element for modulus.

Detailed Description

template<class Ints>
class LinBox::PowerOfTwoModular< Ints >

Ring of elements modulo some power of two.

Parameters:
elementElement type, e.g. long or integer
IntermediateType to use for intermediate computations. This should be a data type that can support integers twice the length of the maximal modulus used

Member Typedef Documentation

typedef Ints Element

Element type


Constructor & Destructor Documentation

PowerOfTwoModular ( void  ) [inline]

Default constructor.


Member Function Documentation

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

Conversion of field base element to a template class T. This function assumes the output field base element x has already been constructed, but that it is not already initialized.

Returns:
reference to template class T.
Parameters:
xtemplate class T to contain output (reference returned).
yconstant field base element.
Element& init ( Element x,
const Ints &  y = 0 
) const [inline]

Initialization of field base element from an integer. Behaves like C++ allocator construct. This function assumes the output field base element x has already been constructed, but that it is not already initialized. This is not a specialization of the template function because such a specialization is not allowed inside the class declaration.

Returns:
reference to field base element.
Parameters:
xfield base element to contain output (reference returned).
yinteger.
Element& assign ( Element x,
const Element y 
) const [inline]

Assignment of one field base element to another. This function assumes both field base elements have already been constructed and initialized.

Returns:
reference to x
Parameters:
xfield base element (reference returned).
yfield base element.
integer& cardinality ( integer c) const [inline]

Cardinality. Return integer representing cardinality of the domain. Returns a non-negative integer for all domains with finite cardinality, and returns -1 to signify a domain of infinite cardinality.

Returns:
integer representing cardinality of the domain
integer& characteristic ( integer c) const [inline]

Characteristic. Return integer representing characteristic of the domain. Returns a positive integer to all domains with finite characteristic, and returns 0 to signify a domain of infinite characteristic.

Returns:
integer representing characteristic of the domain.
int& poweroftwo ( int &  c) [inline]

poweroftwo

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

Equality of two elements. This function assumes both field base elements have already been constructed and initialized.

Returns:
boolean true if equal, false if not.
Parameters:
xfield base element
yfield base element
bool isZero ( const Element x) const [inline]

Zero equality. Test if field base element is equal to zero. This function assumes the field base element has already been constructed and initialized.

Returns:
boolean true if equals zero, false if not.
Parameters:
xfield base element.
bool isOne ( const Element x) const [inline]

One equality. Test if field base element is equal to one. This function assumes the field base element has already been constructed and initialized.

Returns:
boolean true if equals one, false if not.
Parameters:
xfield base element.
Element& gcd_poweroftwo ( Element x,
const Element y 
) const [inline]

Gcd with 2^_poweroftwo * Valid for Ints up to 32 bits * Specialization is required for bigger Ints

bool doesdivide ( const Element x,
const Element y 
) const [inline]

Does x divide y

int poweroftwoinx ( const Element x) const [inline]

Power of two in x Input Element x = 2^n*y where y is odd Output n

std::ostream& write ( std::ostream &  os) const [inline]

Print field.

Returns:
output stream to which field is written.
Parameters:
osoutput stream to which field is written.
std::istream& read ( std::istream &  is) [inline]

Read field.

Returns:
input stream from which field is read.
Parameters:
isinput stream from which field is read.
std::ostream& write ( std::ostream &  os,
const Element x 
) const [inline]

Print field base element. This function assumes the field base element has already been constructed and initialized.

Returns:
output stream to which field base element is written.
Parameters:
osoutput stream to which field base element is written.
xfield base element.
std::istream& read ( std::istream &  is,
Element x 
) const [inline]

Read field base element. This function assumes the field base element has already been constructed and initialized.

Returns:
input stream from which field base element is read.
Parameters:
isinput stream from which field base element is read.
xfield base element.
Element& add ( Element x,
const Element y,
const Element z 
) const [inline]

Addition. x = y + z This function assumes all the field base elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
zfield base element.
Element& sub ( Element x,
const Element y,
const Element z 
) const [inline]

Subtraction. x = y - z This function assumes all the field base elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
zfield base element.
Element& mul ( Element x,
const Element y,
const Element z 
) const [inline]

Multiplication. x = y * z This function assumes all the field base elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
zfield base element.
Element& div ( Element x,
const Element y,
const Element z 
) const [inline]

Division. x = y / z This function assumes all the field base elements have already been constructed and initialized. This fonction assumes that x divides y. That can be verified by using doesdivide(x,y)

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
zfield base element.
Element& neg ( Element x,
const Element y 
) const [inline]

Additive Inverse (Negation). x = - y This function assumes both field base elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
Element& inv ( Element x,
const Element y 
) const [inline]

Multiplicative Inverse. x = 1 / y This function assumes both field base elements have already been constructed and initialized. This function assumes that y is odd (ie 1/y exists)

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
Element& inv2 ( Element x,
const Element y 
) const [inline]

Multiplicative Inverse 2. x = 1 / y This function assumes both field base elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
Element& axpy ( Element r,
const Element a,
const Element x,
const Element y 
) const [inline]

Natural AXPY. r = a * x + y This function assumes all field elements have already been constructed and initialized.

Returns:
reference to r.
Parameters:
rfield element (reference returned).
afield element.
xfield element.
yfield element.
Element& addin ( Element x,
const Element y 
) const [inline]

Inplace Addition. x += y This function assumes both field base elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
Element& subin ( Element x,
const Element y 
) const [inline]

Inplace Subtraction. x -= y This function assumes both field base elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
Element& mulin ( Element x,
const Element y 
) const [inline]

Inplace Multiplication. x *= y This function assumes both field base elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
Element& divin ( Element x,
const Element y 
) const [inline]

Inplace Division. x /= y This function assumes both field base elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
yfield base element.
Element& negin ( Element x) const [inline]

Inplace Additive Inverse (Inplace Negation). x = - x This function assumes the field base element has already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
Element& invin ( Element x) const [inline]

Inplace Multiplicative Inverse. x = 1 / x This function assumes the field base elementhas already been constructed and initialized.

Returns:
reference to x.
Parameters:
xfield base element (reference returned).
Element& axpyin ( Element r,
const Element a,
const Element x 
) const [inline]

Inplace AXPY. r += a * x This function assumes all field elements have already been constructed and initialized. Purely virtual

Returns:
reference to r.
Parameters:
rfield element (reference returned).
afield element.
xfield element.

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