This class implement the standard arithmetic with Modulo Elements. More...

#include <modular-implem.h>

Inheritance diagram for Modular_implem< _Storage_t, _Compute_t, _Residu_t >:

Public Types
enum	{ size_rep = sizeof(Element) }

using	Element = _Storage_t

using	Element_ptr = Element*

using	ConstElement = const Element

using	ConstElement_ptr = const Element*

using	Self_t = Modular_implem<_Storage_t, _Compute_t, _Residu_t>

using	Storage_t = _Storage_t

using	Compute_t = _Compute_t

using	Residu_t = _Residu_t

using	is_elt_integral = std::is_integral<Element>

using	is_elt_floating_point = std::is_floating_point<Element>

Public Member Functions
	Modular_implem ()

	Modular_implem (const Residu_t p)

template<typename Source>
	Modular_implem (const Source &p)

	Modular_implem (const Self_t &F)

virtual	~Modular_implem ()=default

Element	minElement () const

Element	maxElement () const

Residu_t	residu () const

Residu_t	size () const

Residu_t	characteristic () const

Residu_t	cardinality () const

template<class T>
T &	characteristic (T &p) const

template<class T>
T &	cardinality (T &p) const

bool	isZero (const Element &a) const

bool	isOne (const Element &a) const

bool	isMOne (const Element &a) const

bool	areEqual (const Element &a, const Element &b) const

bool	isUnit (const Element &a) const

size_t	length (const Element a) const

bool	operator== (const Self_t &F) const

bool	operator!= (const Self_t &F) const

Self_t &	operator= (const Self_t &F)

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

template<typename T>
T &	convert (T &r, const Element &a) const

virtual Element &	init (Element &, const Integer &) const =0

std::ostream &	write (std::ostream &s, const Element &a) const

template<typename E = Element, typename std::enable_if<(! std::is_floating_point< E >::value &&sizeof(E)==1), int >::type * = nullptr>
std::ostream &	write (std::ostream &s, const E &a) const

template<typename E = Element, typename std::enable_if<(! std::is_floating_point< E >::value &&sizeof(E) > 1), int >::type * = nullptr>
std::ostream &	write (std::ostream &s, const E &a) const

template<typename E = Element, typename std::enable_if<(std::is_floating_point< E >::value), int >::type * = nullptr>
std::ostream &	write (std::ostream &s, const E &a) const

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

template<typename E = Element, typename std::enable_if<(sizeof(E)==1), int >::type * = nullptr>
std::ostream &	write (std::ostream &s) const

template<typename E = Element, typename std::enable_if<(sizeof(E) > 1), int >::type * = nullptr>
std::ostream &	write (std::ostream &s) const

std::istream &	read (std::istream &s)

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

Static Public Member Functions
static Residu_t	minCardinality ()

template<typename S = Storage_t, typename std::enable_if<(std::is_integral< S >::value &&(sizeof(S)==sizeof(Compute_t))), int >::type * = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(std::is_integral< S >::value &&std::is_signed< S >::value &&(2 sizeof(S)==sizeof(Compute_t))), int >::type = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(std::is_integral< S >::value &&std::is_unsigned< S >::value &&(2 sizeof(S)==sizeof(Compute_t))), int >::type = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(std::is_same< S, float >::value &&std::is_same< S, Compute_t >::value), int >::type * = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(std::is_same< S, float >::value &&! std::is_same< S, Compute_t >::value), int >::type * = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(std::is_same< S, double >::value), int >::type * = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(std::is_same< S, Integer >::value), int >::type * = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(is_same_ruint< S, Compute_t >::value), int >::type * = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(is_same_rint< S, Compute_t >::value), int >::type * = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(is_ruint< Compute_t >::value &&(ISEQUAL(RecInt_K< S >::value, RecInt_K< Compute_t >::value))), int >::type * = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(is_smaller_ruint< S, Compute_t >::value), int >::type * = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(is_smaller_rint< S, Compute_t >::value), int >::type * = nullptr>
static Residu_t	maxCardinality ()

template<typename S = Storage_t, typename std::enable_if<(! std::is_integral< S >::value &&! std::is_floating_point< S >::value &&! std::is_same< S, Integer >::value &&!is_ruint< S >::value &&!is_rint< S >::value), int >::type * = nullptr>
static Residu_t	maxCardinality ()

static const std::string	type_string ()

Data Fields
const Element	zero

const Element	one

const Element	mOne

Static Public Attributes
static constexpr bool	is_elt_integral_v = is_elt_integral::value

static constexpr bool	is_elt_floating_point_v = is_elt_floating_point::value

Protected Attributes
Residu_t	_p

Compute_t	_pc

Detailed Description

template<typename _Storage_t, typename _Compute_t, typename _Residu_t>
class Givaro::Modular_implem< _Storage_t, _Compute_t, _Residu_t >

This class implement the standard arithmetic with Modulo Elements.

The representation of an integer a in Zpz is the value a % p
m max is 46341
p max is 46337