linbox
Data Structures | Public Types | Protected Attributes
PowerOfTwoModular< Ints > Class Template Reference

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

#include <poweroftwomodular.h>

Data Structures

struct  RandIter
 Random iterator generator type. More...

Public Types

typedef Ints Element
 Element type.

Public Member Functions

Object Management
 PowerOfTwoModular (void)
 Default constructor.
integerconvert (integer &x, const Element &y) const
 Conversion of field base element to a template class T.
Elementinit (Element &x, const Ints &y=0) const
 Initialization of field base element from an integer.
Elementassign (Element &x, const Element &y) const
 Assignment of one field base element to another.
integercardinality (integer &c) const
 Cardinality.
integercharacteristic (integer &c) const
 Characteristic.
int & poweroftwo (int &c)
 poweroftwo
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
 Equality of two elements.
bool isZero (const Element &x) const
 Zero equality.
bool isOne (const Element &x) const
 One equality.
bool isUnit (const Element &x) const
 isUnit.
bool isZeroDivisor (const Element &x) const
 isZeroDivisor.
Elementgcd_poweroftwo (Element &x, const Element &y) const
 Gcd with 2^_poweroftwo .
bool doesdivide (const Element &x, const Element &y) const
 Does x divide y.
int poweroftwoinx (const Element &x) const
 Power of two in x Input Element x = 2^n*y where y is odd Output n.
Elementbezout (const Element &x, const Element &y, Element &gcd, Element &u, Element &v) const
 bezout.
Elementadd (Element &x, const Element &y, const Element &z) const
 Addition.
Elementsub (Element &x, const Element &y, const Element &z) const
 Subtraction.
Elementmul (Element &x, const Element &y, const Element &z) const
 Multiplication.
Elementdiv (Element &x, const Element &y, const Element &z) const
 Division.
Elementneg (Element &x, const Element &y) const
 Additive Inverse (Negation).
Elementinv (Element &x, const Element &y) const
 Multiplicative Inverse.
Elementinv2 (Element &x, const Element &y) const
 Multiplicative Inverse 2.
Elementaxpy (Element &r, const Element &a, const Element &x, const Element &y) const
 Natural AXPY.
Input/Output Operations
std::ostream & write (std::ostream &os) const
 Print field.
std::istream & read (std::istream &is)
 Read field.
std::ostream & write (std::ostream &os, const Element &x) const
 Print field base element.
std::istream & read (std::istream &is, Element &x) const
 Read field base element.
Inplace Arithmetic Operations

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

Elementaddin (Element &x, const Element &y) const
 Inplace Addition.
Elementsubin (Element &x, const Element &y) const
 Inplace Subtraction.
Elementmulin (Element &x, const Element &y) const
 Inplace Multiplication.
Elementdivin (Element &x, const Element &y) const
 Inplace Division.
Elementnegin (Element &x) const
 Inplace Additive Inverse (Inplace Negation).
Elementinvin (Element &x) const
 Inplace Multiplicative Inverse.
Elementaxpyin (Element &r, const Element &a, const Element &x) const
 Inplace AXPY.

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 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.
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.
bool isUnit ( const Element x) const [inline]

isUnit.

Parameters:
x
bool isZeroDivisor ( const Element x) const [inline]

isZeroDivisor.

Parameters:
x
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

Parameters:
x
y
Element& bezout ( const Element x,
const Element y,
Element gcd,
Element u,
Element v 
) const [inline]

bezout.

Parameters:
x,y
gcd
u,v
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: