Real algebraic numbers

This namespace provides convertion and assign functions for various types. It allows to control type transformations. The function assign(A& a, const B& b) set the variable a to the value b. The function B convert(const A& a, astype<B>()) returns an object of type B, let by astype.


Functions
template<typename NT_>
void	assign (diadic< NT_ > &x, int i)
template<typename NT>
double	convert (const diadic< NT > &q, type::As< double >)
double	to_XT (double a)
double	numerator (const double &a)
double	denominator (const double &a)
void	assign (QQ &x, char *s)
void	assign (ZZ &z, char *s)
void	assign (ZZ &z, int n)
void	assign (ZZ &z, double d)
void	assign (ZZ &x, const ZZ &r)
void	assign (int &x, const ZZ &r)
void	assign (long int &x, const ZZ &r)
void	assign (double &r, const ZZ &z)
void	assign (QQ &x, const ZZ &r)
void	assign (QQ &q, double d)
void	assign (RR &r, double d)
void	assign (double &r, const QQ &z)
void	assign (double &r, const RR &z)
void	assign (RR &r, char *s)
void	assign (RR &x, const RR &r)
double	convert (const QQ &q, type::As< double >)
double	convert (const ZZ &z, type::As< double >)
double	convert (const RR &r, type::As< double >)
void	assign (Interval< double, 3 > &a, const QQ &b)
template<class R, class T>
void	assign (R &r, const VAL< T > &x)
template<class R, class X>
void	assign (R &r, const OP<'+', X, int > &x)
template<class R, class X, class Y>
void	assign (R &r, const OP<'+', X, Y > &x)
template<class R, class X>
void	assign (R &r, const OP<'-', X, int > &x)
template<class R, class X, class Y>
void	assign (R &r, const OP<'-', X, Y > &x)
template<class R, class X>
void	assign (R &r, const OP<'*', X, int > &x)
template<class R, class X, class Y>
void	assign (R &r, const OP<'*', X, Y > &x)
template<class R, class X>
void	assign (R &r, const OP<'/', X, int > &x)
template<class R, class X, class Y>
void	assign (R &r, const OP<'/', X, Y > &x)
template<class V, class S>
void	assign (V &r, const OP<'*', VAL< S >, V > M)
template<class V, class S>
void	assign (V &r, const OP<'*', V, VAL< S > > M)
template<class V, class S, class T>
void	assign (V &r, const OP<'*', VAL< S >, VAL< T > > M)
template<class V, class S>
void	assign (V &r, const OP<'.', VAL< S >, V > &M)
template<class V, class S>
void	assign (V &r, const OP<'.', V, VAL< S > > &M)
template<class V, class S, class T>
void	assign (V &r, const OP<'.', VAL< S >, VAL< T > > &M)
template<class V, class S>
void	assign (V &r, const OP<'/', VAL< S >, V > &M)
template<class V, class S>
void	assign (V &r, const OP<'/', V, VAL< S > > &M)
template<class V, class S, class T>
void	assign (V &r, const OP<'/', VAL< S >, VAL< T > > &M)
template<class X, class Y, int r0, int r1>
void	assign (Interval< X, r0 > &a, const Interval< Y, r1 > &b)
template<class A, class B>
void	assign (A &a, const B &b)
	Generic definition of the assignement function.
template<class A, class B>
void	copy (A &a, const B &b)
void	assign (int &a, double d)
void	assign (double &d, int i)
void	assign (double &d, unsigned i)
void	assign (double &d, double z)
template<class X>
const X &	convert (const X &x, const type::As< X > &mth)
	Obvious conversion.
template<class X, class Y>
Y	convert (const X &x, const type::As< Y > &mth)
template<typename FT, typename T>
FT	convert (const T &a, const T &b, const type::As< FT > &mth)
template<class T>
double	convert (const T &a, const T &b, const type::As< double > &mth)
double	convert (double a, double b, const type::As< double > &mth)
template<class C>
void	assign (std::complex< C > &z, const C &x)
template<class X>
void	assign (X &a, char *s)
template<>
void	assign (int &i, char *s)
template<>
void	assign (long int &i, char *s)
template<>
void	assign (long long int &i, char *s)
void	assign (float &d, char *s)
void	assign (double &d, char *s)
void	assign (long double &d, char *s)
void	assign (std::complex< double > &z, const char *s)
template<typename T, typename S>
void	assign (T &a, const Rational< S > &x)
template<typename T>
void	assign (Rational< T > &a, const T &x)
void	assign (double &a, const Rational< double > &x)
template<class R, class E>
void	assign (R &r, const arithm::template_expression< E > &exp)
template<class C, class R, class S>
void	assign (Seq< C, R > &r, const Seq< C, S > &x)
template<class C, class I, class N>
void	assign (shared_object< seq1d< C, I, N > > &a, const shared_object< seq1d< C, I, N > > &b)
template<class Ca, class Ra, class Cb, class Rb>
void	assign (VectDse< Ca, Ra > &a, const VectDse< Cb, Rb > &b)
template<class Ca, class Ra, class Cb, class Rb>
void	copy (VectDse< Ca, Ra > &v, VectDse< Cb, Rb > *t)
template<class Ca, class Ra, class Cb, class Rb>
void	copy (VectDse< Ca, Ra > &a, const VectDse< Cb, Rb > &b)
template<class Ca, class Ra, class TEXP>
void	copy (VectDse< Ca, Ra > &a, const TEXP &b)
template<class R, class C, class S>
void	assign (MatrStr< R > &r, const MatrDse< C, S > &M)
template<class R>
void	assign (MatrStr< R > &r, const MatrStr< R > *M)
template<class POL, class C, class R>
POL	convert (const Monom< C, R > &m, type::As< POL >)
template<class C, class R>
C	convert (const Monom< C, R > &m, type::As< C >)
template<class U, class S, class C, class O, class R>
void	assign (UPolDse< U, S > &u, const MPol< C, O, R > &p, int v)
template<typename RT, typename O, typename R>
MPol< RT, O, R >	convert (const ALGEBRAIC::MPoly_2_2< RT > &f, type::As< MPol< RT, O, R > >)
template<typename RT, typename O, typename R>
ALGEBRAIC::MPoly_2_2< RT >	convert (const MPol< RT, O, R > &f, type::As< ALGEBRAIC::MPoly_2_2< RT > >)
template<class C, class R>
void	assign (C &r, const Monom< C, R > &m)
template<class C, class R>
const C &	convert (const Monom< C, R > &m, const type::As< C > &)
template<class P, class S, class C, class O, class R>
void	assign (MPol< double, P, S > &r, const MPol< C, O, R > &p)
template<class Ca, class Ra, class Cb, class Ob, class Rb>
void	convert (UPolDse< Ca, Ra > &p, const MPol< Cb, Ob, Rb > &mp, int v)
template<class Ca, class Ra, class Cb, class Ob, class Rb, class Rp, class Ru>
void	convert (UPolDse< UPolDse< Ca, Ra >, Rp > &p, const UPolDse< MPol< Cb, Ob, Rb >, Ru > &ump, int v)
template<class Ca, class Ra, class Rp, class Cb, class Ob, class Rb>
void	convert (UPolDse< UPolDse< Ca, Ra >, Rp > &p, const MPol< Cb, Ob, Rb > &mp, int a, int b)
	convert mp in C[$...,x_a,...,x_b,...$] into (C[...])[xa,xb]
template<class C, class O, class Ra, class Rb, class Rc>
void	convert (UPolDse< UPolDse< C, Ra >, Rb > &p, const MPol< C, O, Rc > &mp, const char a, const char b, const Variables &vars=Variables::default_)
template<class C, class O, class Rm, class Ru>
void	convert (MPol< C, O, Rm > &result, const UPolDse< MPol< C, O, Rm >, Ru > &p, int v)
template<class C, class R, class D, class S>
void	assign (UPolDse< C, R > &u, const UPolDse< D, S > &P)
template<class POL, class C, class S>
POL	convert (const UPolDse< C, S > &P, type::As< POL >)

Function Documentation

template<class C, class R, class D, class S>

void let::assign	(	UPolDse< C, R > &	u,
		const UPolDse< D, S > &	P
	)

Assign a univariate polynomial with coefficients of type D and internal representation S to a polynomial with coefficients of type C. It uses the function let::assign on the coefficients.

Definition at line 583 of file UPolDse.h.

References degree(), UPolDse< C, R >::resize(), and UPolDse< C, R >::size().

template<class P, class S, class C, class O, class R>

void let::assign	(	MPol< double, P, S > &	r,
		const MPol< C, O, R > &	p
	)

Convert a multivariate polynomial to a polynomial which double coefficients.

Definition at line 306 of file MPol.h.

References MPol< C, O, R >::begin(), and MPol< C, O, R >::end().

template<class A, class B>

void let::assign	(	A &	a,
		const B &	b
	)

Generic definition of the assignement function.

Definition at line 35 of file let.h.

template<class POL, class C, class S>

POL let::convert	(	const UPolDse< C, S > &	P,
		type::As< POL >
	)

Similar to the previous assign function, which is used for this convertion.

Definition at line 594 of file UPolDse.h.

References degree().

template<class Ca, class Ra, class Rp, class Cb, class Ob, class Rb>

void let::convert	(	UPolDse< UPolDse< Ca, Ra >, Rp > &	p,
		const MPol< Cb, Ob, Rb > &	mp,
		int	a,
		int	b
	)

convert mp in C[$...,x_a,...,x_b,...$] into (C[...])[xa,xb]

Definition at line 354 of file MPol.h.

References convert().

template<class Ca, class Ra, class Cb, class Ob, class Rb>

void let::convert	(	UPolDse< Ca, Ra > &	p,
		const MPol< Cb, Ob, Rb > &	mp,
		int	v
	)

transform the polynomial the multivariate polynomial mp$(x_0,..,x_v,..,x_n)$ as p$ with coefficient in $C[x_0,...,x_{v-1},x_{v+1},..,x_n]$

Definition at line 322 of file MPol.h.

References MPol< C, O, R >::begin(), UPolDse< C, R >::begin(), convert(), degree(), MPol< C, O, R >::end(), UPolDse< C, R >::end(), and UPolDse< C, R >::resize().

template<class X>

const X& let::convert	(	const X &	x,
		const type::As< X > &	mth
	)

Obvious conversion.

Definition at line 53 of file let.h.

let Namespace Reference

Detailed Description

Functions

Function Documentation