SymEngine::UExprDict Class Reference

Inheritance diagram for SymEngine::UExprDict:

Collaboration diagram for SymEngine::UExprDict:

Public Member Functions
	UExprDict (UExprDict &&other) SYMENGINE_NOEXCEPT
	UExprDict (const int &i)
	UExprDict (const map_int_Expr &p)
	UExprDict (const Expression &expr)
	UExprDict (const std::string &s)
	UExprDict (const UExprDict &)=default
UExprDict &	operator= (const UExprDict &)=default
UExprDict &	operator/= (const Expression &other)
std::string	__str__ (const std::string name) const
const RCP< const Basic >	get_basic (std::string var) const
int	compare (const UExprDict &other) const
Expression	find_cf (int deg) const
Public Member Functions inherited from SymEngine::ODictWrapper< int, Expression, UExprDict >
	ODictWrapper (const int &i)
	ODictWrapper (const std::map< int, Expression > &p)
	ODictWrapper (std::map< int, Expression > &&p)
	ODictWrapper (const Expression &p)
	ODictWrapper (std::string s)
UExprDict &	operator= (UExprDict &&other) SYMENGINE_NOEXCEPT
UExprDict &	operator+= (const UExprDict &other)
UExprDict	operator- () const
UExprDict &	operator-= (const UExprDict &other)
UExprDict &	operator*= (const UExprDict &other)
bool	operator!= (const UExprDict &other) const
const std::map< int, Expression > &	get_dict () const
size_t	size () const
bool	empty () const
int	degree () const
Expression	get_coeff (int x) const
Expression	get_lc () const

Friends
std::ostream &	operator<< (std::ostream &os, const UExprDict &expr)
UExprDict	operator/ (const UExprDict &a, const Expression &b)

Additional Inherited Members
Public Types inherited from SymEngine::ODictWrapper< int, Expression, UExprDict >
typedef int	key_type
Static Public Member Functions inherited from SymEngine::ODictWrapper< int, Expression, UExprDict >
static UExprDict	from_vec (const std::vector< Expression > &v)
static UExprDict	mul (const UExprDict &a, const UExprDict &b)
static UExprDict	pow (const UExprDict &a, unsigned int p)
static UExprDict	from_poly (const FromPoly &p)
Data Fields inherited from SymEngine::ODictWrapper< int, Expression, UExprDict >
std::map< int, Expression >	dict_

Detailed Description

Definition at line 15 of file uexprpoly.h.

Constructor & Destructor Documentation

UExprDict() [1/6]

SymEngine::UExprDict::UExprDict ( )

inline

Definition at line 19 of file uexprpoly.h.

{}

~UExprDict()

SymEngine::UExprDict::~UExprDict ( )

inline

Definition at line 20 of file uexprpoly.h.

{}

UExprDict() [2/6]

SymEngine::UExprDict::UExprDict ( UExprDict &&  other )

inline

Definition at line 21 of file uexprpoly.h.

        : ODictWrapper(std::move(other))
    {
    }

UExprDict() [3/6]

SymEngine::UExprDict::UExprDict ( const int &  i )

inline

Definition at line 25 of file uexprpoly.h.

: ODictWrapper(i) {}

UExprDict() [4/6]

SymEngine::UExprDict::UExprDict ( const map_int_Expr &  p )

inline

Definition at line 26 of file uexprpoly.h.

: ODictWrapper(p) {}

UExprDict() [5/6]

SymEngine::UExprDict::UExprDict ( const Expression &  expr )

inline

Definition at line 27 of file uexprpoly.h.

: ODictWrapper(expr) {}

UExprDict() [6/6]

SymEngine::UExprDict::UExprDict ( const std::string &  s )

inline

Definition at line 29 of file uexprpoly.h.

: ODictWrapper(s) {}

Member Function Documentation

__str__()

std::string SymEngine::UExprDict::__str__ ( const std::string  name ) const

inline

Definition at line 51 of file uexprpoly.h.

    {
        std::ostringstream o;
        bool first = true;
        for (auto it = dict_.rbegin(); it != dict_.rend(); ++it) {
            std::string t;
            // if exponent is 0, then print only coefficient
            if (it->first == 0) {
                if (first) {
                    o << it->second;
                } else {
                    t = detail::poly_print(it->second);
                    if (t[0] == '-') {
                        o << " - " << t.substr(1);
                    } else {
                        o << " + " << t;
                    }
                }
                first = false;
                continue;
            }
            // if the coefficient of a term is +1 or -1
            if (it->second == 1 or it->second == -1) {
                // in cases of -x, print -x
                // in cases of x**2 - x, print - x
                if (first) {
                    if (it->second == -1)
                        o << "-";
                } else {
                    if (down_cast<const Integer &>(*it->second.get_basic())
                            .as_integer_class()
                        < 0) {
                        o << " "
                          << "-"
                          << " ";
                    } else {
                        o << " "
                          << "+"
                          << " ";
                    }
                }
            }
            // if the coefficient of a term is 0, skip
            else if (it->second == 0)
                continue;
            // same logic is followed as above
            else {
                // in cases of -2*x, print -2*x
                // in cases of x**2 - 2*x, print - 2*x
                if (first) {
                    o << detail::poly_print(it->second) << "*";
                } else {
                    t = detail::poly_print(it->second);
                    if (t[0] == '-') {
                        o << " - " << t.substr(1);
                    } else {
                        o << " + " << t;
                    }
                    o << "*";
                }
            }
            o << name;
            // if exponent is not 1, print the exponent;
            if (it->first > 1) {
                o << "**" << it->first;
            } else if (it->first < 0) {
                o << "**(" << it->first << ")";
            }
            // corner cases of only first term handled successfully, switch the
            // bool
            first = false;
        }
        return o.str();
    }

compare()

int SymEngine::UExprDict::compare ( const UExprDict &  other ) const

inline

Definition at line 146 of file uexprpoly.h.

    {
        return unified_compare(dict_, other.dict_);
    }

find_cf()

Expression SymEngine::UExprDict::find_cf ( int  deg ) const

inline

Definition at line 151 of file uexprpoly.h.

    {
        if (dict_.find(deg) != dict_.end())
            return dict_.at(deg);
        else
            return Expression(0);
    }

get_basic()

const RCP< const Basic > SymEngine::UExprDict::get_basic ( std::string  var ) const

inline

Definition at line 127 of file uexprpoly.h.

    {
        RCP<const Symbol> x = symbol(var);
        umap_basic_num dict;
        RCP<const Number> coeff = zero;
        for (const auto &it : dict_) {
            if (it.first != 0) {
                auto term
                    = SymEngine::mul(it.second.get_basic(),
                                     SymEngine::pow(x, integer(it.first)));
                Add::coef_dict_add_term(outArg(coeff), dict, one, term);
            } else {
                Add::coef_dict_add_term(outArg(coeff), dict, one,
                                        it.second.get_basic());
            }
        }
        return Add::from_dict(coeff, std::move(dict));
    }

operator/=()

UExprDict & SymEngine::UExprDict::operator/= ( const Expression &  other )

inline

Definition at line 45 of file uexprpoly.h.

    {
        *this *= (1 / other);
        return *this;
    }

Friends And Related Symbol Documentation

operator/

UExprDict operator/ ( const UExprDict &  a, const Expression &  b  )

friend

Definition at line 40 of file uexprpoly.h.

    {
        return a * (1 / b);
    }

operator<<

std::ostream & operator<< ( std::ostream &  os, const UExprDict &  expr  )

friend

Definition at line 34 of file uexprpoly.h.

    {
        os << expr.dict_;
        return os;
    }

---

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

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