SymEngine::BasicToUPolyBase< P, V > Class Template Reference

Inheritance diagram for SymEngine::BasicToUPolyBase< P, V >:

Collaboration diagram for SymEngine::BasicToUPolyBase< P, V >:

Public Types
using	D = typename P::container_type

Public Member Functions
	BasicToUPolyBase (const RCP< const Basic > &gen_)
D	apply (const Basic &b)
void	dict_set (unsigned int pow, const Basic &x)
void	bvisit (const Pow &x)
void	bvisit (const Add &x)
void	bvisit (const Mul &x)
void	bvisit (const Integer &x)
template<typename Poly , typename = enable_if_t< ((std::is_base_of<UIntPolyBase<typename P::container_type, P>, P>::value and std::is_base_of< UIntPolyBase<typename Poly::container_type, Poly>, Poly>::value) or (std::is_base_of<URatPolyBase<typename P::container_type, P>, P>::value and (std::is_base_of< UIntPolyBase<typename Poly::container_type, Poly>, Poly>::value or std::is_base_of< URatPolyBase<typename Poly::container_type, Poly>, Poly>::value)) or (std::is_same<P, UExprPoly>::value and std::is_base_of< UPolyBase<typename Poly::container_type, Poly>, Poly>::value)) and not std::is_same<Poly, GaloisField>::value>>
void	bvisit (const Poly &x)
void	bvisit (const Basic &x)

Data Fields
RCP< const Basic >	gen
D	dict

Detailed Description

template<typename P, typename V>
class SymEngine::BasicToUPolyBase< P, V >

Definition at line 37 of file basic_conversions.h.

Member Typedef Documentation

D

template<typename P , typename V >

using SymEngine::BasicToUPolyBase< P, V >::D = typename P::container_type

Definition at line 41 of file basic_conversions.h.

Constructor & Destructor Documentation

BasicToUPolyBase()

template<typename P , typename V >

SymEngine::BasicToUPolyBase< P, V >::BasicToUPolyBase ( const RCP< const Basic > &  gen_ )

inline

Definition at line 44 of file basic_conversions.h.

    {
        gen = gen_;
    }

Member Function Documentation

apply()

template<typename P , typename V >

D SymEngine::BasicToUPolyBase< P, V >::apply ( const Basic &  b )

inline

Definition at line 49 of file basic_conversions.h.

    {
        b.accept(*this);
        return std::move(dict);
    }

bvisit() [1/6]

template<typename P , typename V >

void SymEngine::BasicToUPolyBase< P, V >::bvisit ( const Add &  x )

inline

Definition at line 113 of file basic_conversions.h.

    {
        D res = apply(*x.get_coef());
        for (auto const &it : x.get_dict())
            res += apply(*it.first) * apply(*it.second);
        dict = std::move(res);
    }

bvisit() [2/6]

template<typename P , typename V >

void SymEngine::BasicToUPolyBase< P, V >::bvisit ( const Basic &  x )

inline

Definition at line 161 of file basic_conversions.h.

    {
        RCP<const Basic> genpow = one, genbase = gen, powr;
        if (is_a<const Pow>(*gen)) {
            genpow = down_cast<const Pow &>(*gen).get_exp();
            genbase = down_cast<const Pow &>(*gen).get_base();
        }
        if (eq(*genbase, x)) {
            powr = div(one, genpow);
            if (is_a<const Integer>(*powr)) {
                int i = numeric_cast<int>(
                    down_cast<const Integer &>(*powr).as_int());
                if (i > 0) {
                    dict = P::container_from_dict(
                        gen, {{i, typename P::coef_type(1)}});
                    return;
                }
            }
        }
        if (is_a<const Symbol>(*gen)) {
            if (has_symbol(x, *gen)) {
                throw SymEngineException("Not a Polynomial");
            }
        }
        dict_set(0, x);
    }

bvisit() [3/6]

template<typename P , typename V >

void SymEngine::BasicToUPolyBase< P, V >::bvisit ( const Integer &  x )

inline

Definition at line 129 of file basic_conversions.h.

    {
        integer_class i = x.as_integer_class();
        dict = P::container_from_dict(gen, {{0, typename P::coef_type(i)}});
    }

bvisit() [4/6]

template<typename P , typename V >

void SymEngine::BasicToUPolyBase< P, V >::bvisit ( const Mul &  x )

inline

Definition at line 121 of file basic_conversions.h.

    {
        D res = apply(*x.get_coef());
        for (auto const &it : x.get_dict())
            res *= apply(*pow(it.first, it.second));
        dict = std::move(res);
    }

bvisit() [5/6]

template<typename P , typename V >

template<typename Poly , typename = enable_if_t< ((std::is_base_of<UIntPolyBase<typename P::container_type, P>, P>::value and std::is_base_of< UIntPolyBase<typename Poly::container_type, Poly>, Poly>::value) or (std::is_base_of<URatPolyBase<typename P::container_type, P>, P>::value and (std::is_base_of< UIntPolyBase<typename Poly::container_type, Poly>, Poly>::value or std::is_base_of< URatPolyBase<typename Poly::container_type, Poly>, Poly>::value)) or (std::is_same<P, UExprPoly>::value and std::is_base_of< UPolyBase<typename Poly::container_type, Poly>, Poly>::value)) and not std::is_same<Poly, GaloisField>::value>>

void SymEngine::BasicToUPolyBase< P, V >::bvisit ( const Poly &  x )

inline

Definition at line 156 of file basic_conversions.h.

    {
        dict = (P::from_poly(x))->get_poly();
    }

bvisit() [6/6]

template<typename P , typename V >

void SymEngine::BasicToUPolyBase< P, V >::bvisit ( const Pow &  x )

inline

Definition at line 60 of file basic_conversions.h.

    {
        if (is_a<const Integer>(*x.get_exp())) {
            int i = numeric_cast<int>(
                down_cast<const Integer &>(*x.get_exp()).as_int());
            if (i > 0) {
                dict
                    = pow_upoly(*P::from_container(gen, _basic_to_upoly<D, P>(
                                                            x.get_base(), gen)),
                                i)
                          ->get_poly();
                return;
            }
        }
 
        RCP<const Basic> genbase = gen, genpow = one, coef = one, tmp;
        if (is_a<const Pow>(*gen)) {
            genbase = down_cast<const Pow &>(*gen).get_base();
            genpow = down_cast<const Pow &>(*gen).get_exp();
        }
 
        if (eq(*genbase, *x.get_base())) {
 
            set_basic expos;
 
            if (is_a<const Add>(*x.get_exp())) {
                RCP<const Add> addx = rcp_static_cast<const Add>(x.get_exp());
                for (auto const &it : addx->get_dict())
                    expos.insert(mul(it.first, it.second));
                if (not addx->get_coef()->is_zero())
                    expos.insert(addx->get_coef());
            } else {
                expos.insert(x.get_exp());
            }
 
            int powr = 0;
            for (auto const &it : expos) {
                tmp = div(it, genpow);
                if (is_a<const Integer>(*tmp)) {
                    RCP<const Integer> i = rcp_static_cast<const Integer>(tmp);
                    if (i->is_positive()) {
                        powr = static_cast<int>(i->as_int());
                        continue;
                    }
                }
                coef = mul(coef, pow(genbase, it));
            }
            dict_set(powr, *coef);
        } else {
            this->bvisit((const Basic &)x);
        }
    }

dict_set()

template<typename P , typename V >

void SymEngine::BasicToUPolyBase< P, V >::dict_set ( unsigned int  pow, const Basic &  x  )

inline

Definition at line 55 of file basic_conversions.h.

    {
        down_cast<V *>(this)->dict_set(pow, x);
    }

Field Documentation

dict

template<typename P , typename V >

D SymEngine::BasicToUPolyBase< P, V >::dict

Definition at line 42 of file basic_conversions.h.

gen

template<typename P , typename V >

RCP<const Basic> SymEngine::BasicToUPolyBase< P, V >::gen

Definition at line 40 of file basic_conversions.h.

---

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

• /home/runner/work/symengine/symengine/symengine/polys/basic_conversions.h