let Namespace Reference


Detailed Description

Namespace for explicit type conversion.

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


SYNAPS DOCUMENTATION
logo