#include <gmp-rational.h>

Inheritance diagram for GMPRationalField:

Public Member Functions
Object Management
x <- convert (y)
	GMPRationalField (const GMPRationalField &)
	Copy constructor.

	~GMPRationalField (void)
	Destructor.

GMPRationalField &	operator= (const GMPRationalField &)
	Assignment operator.

Element &	init (Element &x, const integer &y=0) const
	Initialization of field element from an integer.

Element &	init (Element &x, const integer &num, const integer &den) const
	Copy constructor.

Element &	init (Element &x, const int64_t &y) const
	Copy constructor.

Element &	init (Element &x, const uint64_t &y) const
	Copy constructor.

integer &	convert (integer &x, const Element &y=0) const
	Conversion of field element to an integer.

Element &	assign (Element &x, const Element &y) const
	Assignment of one field element to another.

integer &	cardinality (integer &c) const
	is infinite (signified by -1 here)

integer &	characteristic (integer &c) const
	of the rationals is 0.

integer	cardinality () const
	Copy constructor.

integer	characteristic () const
	Copy constructor.

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 elements will give undefined results.
bool	areEqual (const Element &x, const Element &y) const
	Equality of two elements.

Element &	add (Element &x, const Element &y, const Element &z) const
	Addition.

Element &	sub (Element &x, const Element &y, const Element &z) const
	Subtraction.

Element &	mul (Element &x, const Element &y, const Element &z) const
	Multiplication.

Element &	div (Element &x, const Element &y, const Element &z) const
	Division.

Element &	neg (Element &x, const Element &y) const
	Additive Inverse (Negation).

Element &	inv (Element &x, const Element &y) const
	Multiplicative Inverse.

Inplace Arithmetic Operations
x <- x op y; x <- op x These operations require all elements, including x, to be initialized before the operation is called. Uninitialized field elements will give undefined results.
bool	isZero (const Element &x) const
	Zero equality.

bool	isOne (const Element &x) const
	One equality.

bool	isMOne (const Element &x) const
	MOne equality.

bool	isUnit (const Element &x) const
	Zero equality.

Element &	addin (Element &x, const Element &y) const
	Inplace Addition.

Element &	subin (Element &x, const Element &y) const
	Inplace Subtraction.

Element &	mulin (Element &x, const Element &y) const
	Inplace Multiplication.

Element &	axpy (Element &r, const Element &a, const Element &x, const Element &y) const
	axpy.

Element &	axpyin (Element &r, const Element &a, const Element &x) const
	axpyin.

Element &	divin (Element &x, const Element &y) const
	Inplace Division.

Element &	negin (Element &x) const
	Inplace Additive Inverse (Inplace Negation).

Element &	invin (Element &x) const
	Inplace Multiplicative Inverse.

Common Object Interface for a LinBox Field.
These methods are required of all LinBox fields.
typedef GMPRationalElement	Element
	element type.

typedef GMPRationalElement *	Element_ptr
	pointer to element type.

typedef const Element_ptr	ConstElement_ptr
	const pointer to element type.

typedef GMPRationalRandIter	RandIter
	Random iterator generator type.

const Element	zero
	element type.

const Element	one
	element type.

const Element	mOne
	element type.

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 element.

std::istream &	read (std::istream &is, Element &x) const
	Read field element.

	GMPRationalField (int p=0, int exp=1)
	Print field.

integer &	get_num (integer &x, const Element &y) const
	get numerator.

integer &	get_den (integer &x, const Element &y) const
	get denominator.

int	sign (const Element &x) const
	sign.

integer &	bitsize (integer &bs, const Element &q) const
	Bitsize as sum of bitsizes of numerator and denominator.

static int	maxCardinality ()
	max modulus.

Member Typedef Documentation

◆ Element

typedef GMPRationalElement Element

element type.

◆ Element_ptr

typedef GMPRationalElement* Element_ptr

pointer to element type.

◆ ConstElement_ptr

typedef const Element_ptr ConstElement_ptr

const pointer to element type.

◆ RandIter

typedef GMPRationalRandIter RandIter

Random iterator generator type.

Constructor & Destructor Documentation

◆ GMPRationalField() [1/2]

GMPRationalField ( const GMPRationalField & )

inline

Copy constructor.

Vacuous, since this field is unparametric so there is no need to construct multiple field objects

◆ ~GMPRationalField()

~GMPRationalField ( void )

inline

Destructor.

Also vacuous, since there is no de-initialization system

◆ GMPRationalField() [2/2]

GMPRationalField	(	int	p = 0,
		int	exp = 1 )

inline

Print field.

Returns: output stream to which field is written.

Parameters

os	output stream to which field is written.

This does not do much...

Member Function Documentation

◆ operator=()

GMPRationalField & operator= ( const GMPRationalField & )

inline

Assignment operator.

Also vacuous

◆ init() [1/4]

Element & init	(	Element &	x,
		const integer &	y = 0 ) const

inline

Initialization of field element from an integer.

Behaves like C++ allocator construct. This function assumes the output field element x has already been constructed, but that it is not necessarily already initialized. In this implementation, this means the _elem_ptr of x exists, but that it may be the null pointer.

Returns: reference to field element.

Parameters

x	field element to contain output (reference returned).
y	constant reference to integer.

◆ init() [2/4]

Element & init	(	Element &	x,
		const integer &	num,
		const integer &	den ) const

inline

Copy constructor.

Vacuous, since this field is unparametric so there is no need to construct multiple field objects

◆ init() [3/4]

Element & init	(	Element &	x,
		const int64_t &	y ) const

inline

Copy constructor.

Vacuous, since this field is unparametric so there is no need to construct multiple field objects

◆ init() [4/4]

Element & init	(	Element &	x,
		const uint64_t &	y ) const

inline

Copy constructor.

Vacuous, since this field is unparametric so there is no need to construct multiple field objects

◆ convert()

integer & convert	(	integer &	x,
		const Element &	y = 0 ) const

inline

Conversion of field element to an integer.

This function assumes the output field element x has already been constructed, but that it is not already initialized. In this implementation, this means the _elem_ptr of y exists, and that it is not the null pointer.

Returns floor (numerator (y) / denominator (y))

Returns: reference to integer.

Parameters

x	reference to integer to contain output (reference returned).
y	constant reference to field element.

◆ assign()

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

inline

Assignment of one field element to another.

This function assumes both field elements have already been constructed and initialized. In this implementation, this means for both x and y, _elem_ptr exists and does not point to null.

Returns: reference to x

Parameters

x	field element (reference returned).
y	field element.

FIXME: Is this x := y? I am assuming so.

◆ cardinality() [1/2]

integer & cardinality ( integer & c ) const

inline

is infinite (signified by -1 here)

◆ characteristic() [1/2]

integer & characteristic ( integer & c ) const

inline

of the rationals is 0.

◆ cardinality() [2/2]

integer cardinality ( ) const

inline

Copy constructor.

Vacuous, since this field is unparametric so there is no need to construct multiple field objects

◆ characteristic() [2/2]

integer characteristic ( ) const

inline

Copy constructor.

Vacuous, since this field is unparametric so there is no need to construct multiple field objects

◆ areEqual()

bool areEqual	(	const Element &	x,
		const Element &	y ) const

inline

Equality of two elements.

This function assumes both field elements have already been constructed and initialized. In this implementation, this means for both x and y, _elem_ptr exists and does not point to null.

Returns: boolean true if equal, false if not.

Parameters

x	field element
y	field element

◆ add()

Element & add	(	Element &	x,
		const Element &	y,
		const Element &	z ) const

inline

Addition.

x = y + z This function assumes all the field elements have already been constructed and initialized. In this implementation, this means for x, y, and z, _elem_ptr exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).
y	field element.
z	field element.

◆ sub()

Element & sub	(	Element &	x,
		const Element &	y,
		const Element &	z ) const

inline

Subtraction.

x = y - z This function assumes all the field elements have already been constructed and initialized. In this implementation, this means for x, y, and z, _elem_ptr exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).
y	field element.
z	field element.

◆ mul()

Element & mul	(	Element &	x,
		const Element &	y,
		const Element &	z ) const

inline

Multiplication.

x = y * z This function assumes all the field elements have already been constructed and initialized. In this implementation, this means for x, y, and z, _elem_ptr exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).
y	field element.
z	field element.

◆ div()

Element & div	(	Element &	x,
		const Element &	y,
		const Element &	z ) const

inline

Division.

x = y / z This function assumes all the field elements have already been constructed and initialized. In this implementation, this means for x, y, and z, _elem_ptr exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).
y	field element.
z	field element.

◆ neg()

Element & neg	(	Element &	x,
		const Element &	y ) const

inline

Additive Inverse (Negation).

x = - y This function assumes both field elements have already been constructed and initialized. In this implementation, this means for both x and y _elem_ptr exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).
y	field element.

◆ inv()

Element & inv	(	Element &	x,
		const Element &	y ) const

inline

Multiplicative Inverse.

x = 1 / y This function assumes both field elements have already been constructed and initialized. In this implementation, this means for both x and y _elem_ptr exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).
y	field element.

◆ isZero()

bool isZero ( const Element & x ) const

inline

Zero equality.

Test if field element is equal to zero. This function assumes the field element has already been constructed and initialized. In this implementation, this means the _elem_ptr of x exists and does not point to null.

Returns: boolean true if equals zero, false if not.

Parameters

x	field element.

◆ isOne()

bool isOne ( const Element & x ) const

inline

One equality.

Test if field element is equal to one. This function assumes the field element has already been constructed and initialized. In this implementation, this means the _elem_ptr of x exists and does not point to null.

Returns: boolean true if equals one, false if not.

Parameters

x	field element.

◆ isMOne()

bool isMOne ( const Element & x ) const

inline

MOne equality.

Test if field element is equal to one. This function assumes the field element has already been constructed and initialized. In this implementation, this means the _elem_ptr of x exists and does not point to null.

Returns: boolean true if equals one, false if not.

Parameters

x	field element.

◆ isUnit()

bool isUnit ( const Element & x ) const

inline

Zero equality.

Test if field element is equal to zero. This function assumes the field element has already been constructed and initialized. In this implementation, this means the _elem_ptr of x exists and does not point to null.

Returns: boolean true if equals zero, false if not.

Parameters

x	field element.

◆ addin()

Element & addin	(	Element &	x,
		const Element &	y ) const

inline

Inplace Addition.

x += y This function assumes both field elements have already been constructed and initialized. In this implementation, this means for both x and y _elem_ptr exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).
y	field element.

◆ subin()

Element & subin	(	Element &	x,
		const Element &	y ) const

inline

Inplace Subtraction.

x -= y This function assumes both field elements have already been constructed and initialized. In this implementation, this means for both x and y _elem_ptr exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).
y	field element.

◆ mulin()

Element & mulin	(	Element &	x,
		const Element &	y ) const

inline

Inplace Multiplication.

x *= y This function assumes both field elements have already been constructed and initialized. In this implementation, this means for both x and y _elem_ptr exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).
y	field element.

◆ axpy()

Element & axpy	(	Element &	r,
		const Element &	a,
		const Element &	x,
		const Element &	y ) const

inline

axpy.

r = a*x + y

Parameters

r
a
x
y

◆ axpyin()

Element & axpyin	(	Element &	r,
		const Element &	a,
		const Element &	x ) const

inline

axpyin.

r += a*x

Parameters

r
a
x

◆ divin()

Element & divin	(	Element &	x,
		const Element &	y ) const

inline

Inplace Division.

x /= y This function assumes both field elements have already been constructed and initialized. In this implementation, this means for both x and y _elem_ptr exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).
y	field element.

◆ negin()

Element & negin ( Element & x ) const

inline

Inplace Additive Inverse (Inplace Negation).

x = - x This function assumes the field element has already been constructed and initialized. In this implementation, this means the _elem_ptr of x exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).

◆ invin()

Element & invin ( Element & x ) const

inline

Inplace Multiplicative Inverse.

x = 1 / x This function assumes the field elementhas already been constructed and initialized. In this implementation, this means the _elem_ptr of x exists and does not point to null.

Returns: reference to x.

Parameters

x	field element (reference returned).

◆ write() [1/2]

std::ostream & write ( std::ostream & os ) const

inline

Print field.

Returns: output stream to which field is written.

Parameters

os	output stream to which field is written.

This does not do much...

◆ read() [1/2]

std::istream & read ( std::istream & is )

inline

Read field.

Returns: input stream from which field is read.

Parameters

is	input stream from which field is read.

This does not do much either...

FIXME: Read the same thing written above, and throw an exception if the strings do not match.

◆ write() [2/2]

std::ostream & write	(	std::ostream &	os,
		const Element &	x ) const

inline

Print field element.

This function assumes the field element has already been constructed and initialized. In this implementation, this means for the _elem_ptr for x exists and does not point to null.

Returns: output stream to which field element is written.

Parameters

os	output stream to which field element is written.
x	field element.

◆ read() [2/2]

std::istream & read	(	std::istream &	is,
		Element &	x ) const

inline

Read field element.

This function assumes the field element has already been constructed and initialized. In this implementation, this means for the _elem_ptr for x exists and does not point to null.

Returns: input stream from which field element is read.

Parameters

is	input stream from which field element is read.
x	field element.

FIXME: Avoid the magical limit on size here FIXME: Right now it skips over everything until it finds something that looks like a number. Is this really the correct policy?

aniau.nosp@m.@ast.nosp@m.ronet.nosp@m..pl: 06/2009: supports scientific E/e notation for decimal fractions

◆ maxCardinality()

static int maxCardinality ( )

inlinestatic

max modulus.

◆ get_num()

integer & get_num	(	integer &	x,
		const Element &	y ) const

inline

get numerator.

Parameters

x	numerator of y
y

◆ get_den()

integer & get_den	(	integer &	x,
		const Element &	y ) const

inline

get denominator.

Parameters

x	denominator of y
y

◆ sign()

int sign ( const Element & x ) const

inline

sign.

Parameters

x

Returns: sign of x

◆ bitsize()

integer & bitsize	(	integer &	bs,
		const Element &	q ) const

inline

Bitsize as sum of bitsizes of numerator and denominator.

Parameters

bs
q

Returns: bs

Field Documentation

◆ zero

const Element zero

element type.

◆ one

const Element one

element type.

◆ mOne

const Element mOne

element type.

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

field/gmp-rational.h

Public Member Functions

Common Object Interface for a LinBox Field.

Input/Output Operations

Member Typedef Documentation

◆ Element

◆ Element_ptr

◆ ConstElement_ptr

◆ RandIter

Constructor & Destructor Documentation

◆ GMPRationalField() [1/2]

◆ ~GMPRationalField()

◆ GMPRationalField() [2/2]

Member Function Documentation

◆ operator=()

◆ init() [1/4]

◆ init() [2/4]

◆ init() [3/4]

◆ init() [4/4]

◆ convert()

◆ assign()

◆ cardinality() [1/2]

◆ characteristic() [1/2]

◆ cardinality() [2/2]

◆ characteristic() [2/2]

◆ areEqual()

◆ add()

◆ sub()

◆ mul()

◆ div()

◆ neg()

◆ inv()

◆ isZero()

◆ isOne()

◆ isMOne()

◆ isUnit()

◆ addin()

◆ subin()

◆ mulin()

◆ axpy()

◆ axpyin()

◆ divin()

◆ negin()

◆ invin()

◆ write() [1/2]

◆ read() [1/2]

◆ write() [2/2]

◆ read() [2/2]

◆ maxCardinality()

◆ get_num()

◆ get_den()

◆ sign()

◆ bitsize()

Field Documentation

◆ zero

◆ one

◆ mOne