SymEngine::XReplaceVisitor Class Reference

Inheritance diagram for SymEngine::XReplaceVisitor:

Collaboration diagram for SymEngine::XReplaceVisitor:

Public Member Functions
	XReplaceVisitor (const map_basic_basic &subs_dict, bool cache=true)
void	bvisit (const Basic &x)
void	bvisit (const Add &x)
void	bvisit (const Mul &x)
void	bvisit (const Pow &x)
void	bvisit (const OneArgFunction &x)
template<class T >
void	bvisit (const TwoArgBasic< T > &x)
void	bvisit (const MultiArgFunction &x)
void	bvisit (const FunctionSymbol &x)
void	bvisit (const Contains &x)
void	bvisit (const And &x)
void	bvisit (const Or &x)
void	bvisit (const Not &x)
void	bvisit (const Xor &x)
void	bvisit (const FiniteSet &x)
void	bvisit (const ImageSet &x)
void	bvisit (const Union &x)
void	bvisit (const Piecewise &pw)
void	bvisit (const Derivative &x)
void	bvisit (const Subs &x)
void	bvisit (const ComplexBase &x)
RCP< const Basic >	apply (const Basic &x)
RCP< const Basic >	apply (const RCP< const Basic > &x)

Protected Attributes
RCP< const Basic >	result_
const map_basic_basic &	subs_dict_
map_basic_basic	visited
bool	cache

Detailed Description

Definition at line 25 of file subs.h.

Constructor & Destructor Documentation

XReplaceVisitor()

SymEngine::XReplaceVisitor::XReplaceVisitor ( const map_basic_basic &  subs_dict, bool  cache = true  )

inline

Definition at line 35 of file subs.h.

        : subs_dict_(subs_dict), cache(cache)
    {
        if (cache) {
            visited = subs_dict;
        }
    }

Member Function Documentation

apply() [1/2]

RCP< const Basic > SymEngine::XReplaceVisitor::apply ( const Basic &  x )

inline

Definition at line 319 of file subs.h.

    {
        return apply(x.rcp_from_this());
    }

apply() [2/2]

RCP< const Basic > SymEngine::XReplaceVisitor::apply ( const RCP< const Basic > &  x )

inline

Definition at line 324 of file subs.h.

    {
        if (cache) {
            auto it = visited.find(x);
            if (it != visited.end()) {
                result_ = it->second;
            } else {
                x->accept(*this);
                insert(visited, x, result_);
            }
        } else {
            auto it = subs_dict_.find(x);
            if (it != subs_dict_.end()) {
                result_ = it->second;
            } else {
                x->accept(*this);
            }
        }
        return result_;
    }

bvisit() [1/20]

void SymEngine::XReplaceVisitor::bvisit ( const Add &  x )

inline

Definition at line 48 of file subs.h.

    {
        SymEngine::umap_basic_num d;
        RCP<const Number> coef;
 
        auto it = subs_dict_.find(x.get_coef());
        if (it != subs_dict_.end()) {
            coef = zero;
            Add::coef_dict_add_term(outArg(coef), d, one, it->second);
        } else {
            coef = x.get_coef();
        }
 
        for (const auto &p : x.get_dict()) {
            auto it
                = subs_dict_.find(Add::from_dict(zero, {{p.first, p.second}}));
            if (it != subs_dict_.end()) {
                Add::coef_dict_add_term(outArg(coef), d, one, it->second);
            } else {
                it = subs_dict_.find(p.second);
                if (it != subs_dict_.end()) {
                    Add::coef_dict_add_term(outArg(coef), d, one,
                                            mul(it->second, apply(p.first)));
                } else {
                    Add::coef_dict_add_term(outArg(coef), d, p.second,
                                            apply(p.first));
                }
            }
        }
        result_ = Add::from_dict(coef, std::move(d));
    }

bvisit() [2/20]

void SymEngine::XReplaceVisitor::bvisit ( const And &  x )

inline

Definition at line 191 of file subs.h.

    {
        set_boolean v;
        for (const auto &elem : x.get_container()) {
            auto a = apply(elem);
            if (not is_a_Boolean(*a))
                throw SymEngineException("expected an object of type Boolean");
            v.insert(rcp_static_cast<const Boolean>(a));
        }
        result_ = logical_and(v);
    }

bvisit() [3/20]

void SymEngine::XReplaceVisitor::bvisit ( const Basic &  x )

inline

Definition at line 43 of file subs.h.

    {
        result_ = x.rcp_from_this();
    }

bvisit() [4/20]

void SymEngine::XReplaceVisitor::bvisit ( const ComplexBase &  x )

inline

Definition at line 308 of file subs.h.

    {
        auto it = subs_dict_.find(I);
        if (it != subs_dict_.end()) {
            result_ = add(apply(x.real_part()),
                          mul(apply(x.imaginary_part()), it->second));
        } else {
            result_ = x.rcp_from_this();
        }
    }

bvisit() [5/20]

void SymEngine::XReplaceVisitor::bvisit ( const Contains &  x )

inline

Definition at line 178 of file subs.h.

    {
        RCP<const Basic> a = apply(x.get_expr());
        auto c = apply(x.get_set());
        if (not is_a_Set(*c))
            throw SymEngineException("expected an object of type Set");
        RCP<const Set> b = rcp_static_cast<const Set>(c);
        if (a == x.get_expr() and b == x.get_set())
            result_ = x.rcp_from_this();
        else
            result_ = x.create(a, b);
    }

bvisit() [6/20]

void SymEngine::XReplaceVisitor::bvisit ( const Derivative &  x )

inline

Definition at line 285 of file subs.h.

    {
        auto expr = apply(x.get_arg());
        for (const auto &sym : x.get_symbols()) {
            auto s = apply(sym);
            if (not is_a<Symbol>(*s)) {
                throw SymEngineException("expected an object of type Symbol");
            }
            expr = expr->diff(rcp_static_cast<const Symbol>(s));
        }
        result_ = expr;
    }

bvisit() [7/20]

void SymEngine::XReplaceVisitor::bvisit ( const FiniteSet &  x )

inline

Definition at line 235 of file subs.h.

    {
        set_basic v;
        for (const auto &elem : x.get_container()) {
            v.insert(apply(elem));
        }
        result_ = x.create(v);
    }

bvisit() [8/20]

void SymEngine::XReplaceVisitor::bvisit ( const FunctionSymbol &  x )

inline

Definition at line 169 of file subs.h.

    {
        vec_basic v = x.get_args();
        for (auto &elem : v) {
            elem = apply(elem);
        }
        result_ = x.create(v);
    }

bvisit() [9/20]

void SymEngine::XReplaceVisitor::bvisit ( const ImageSet &  x )

inline

Definition at line 244 of file subs.h.

    {
        RCP<const Basic> s = apply(x.get_symbol());
        RCP<const Basic> expr = apply(x.get_expr());
        auto bs_ = apply(x.get_baseset());
        if (not is_a_Set(*bs_))
            throw SymEngineException("expected an object of type Set");
        RCP<const Set> bs = rcp_static_cast<const Set>(bs_);
        if (s == x.get_symbol() and expr == x.get_expr()
            and bs == x.get_baseset()) {
            result_ = x.rcp_from_this();
        } else {
            result_ = x.create(s, expr, bs);
        }
    }

bvisit() [10/20]

void SymEngine::XReplaceVisitor::bvisit ( const Mul &  x )

inline

Definition at line 80 of file subs.h.

    {
        RCP<const Number> coef = one;
        map_basic_basic d;
        for (const auto &p : x.get_dict()) {
            RCP<const Basic> factor_old;
            if (eq(*p.second, *one)) {
                factor_old = p.first;
            } else {
                factor_old = make_rcp<Pow>(p.first, p.second);
            }
            RCP<const Basic> factor = apply(factor_old);
            if (factor == factor_old) {
                // TODO: Check if Mul::dict_add_term is enough
                Mul::dict_add_term_new(outArg(coef), d, p.second, p.first);
            } else if (is_a_Number(*factor)) {
                imulnum(outArg(coef), rcp_static_cast<const Number>(factor));
            } else if (is_a<Mul>(*factor)) {
                RCP<const Mul> tmp = rcp_static_cast<const Mul>(factor);
                imulnum(outArg(coef), tmp->get_coef());
                for (const auto &q : tmp->get_dict()) {
                    Mul::dict_add_term_new(outArg(coef), d, q.second, q.first);
                }
            } else {
                RCP<const Basic> exp, t;
                Mul::as_base_exp(factor, outArg(exp), outArg(t));
                Mul::dict_add_term_new(outArg(coef), d, exp, t);
            }
        }
 
        // Replace the coefficient
        RCP<const Basic> factor = apply(x.get_coef());
        if (is_a_Number(*factor)) {
            imulnum(outArg(coef), rcp_static_cast<const Number>(factor));
        } else if (is_a<Mul>(*factor)) {
            RCP<const Mul> tmp = rcp_static_cast<const Mul>(factor);
            imulnum(outArg(coef), tmp->get_coef());
            for (const auto &q : tmp->get_dict()) {
                Mul::dict_add_term_new(outArg(coef), d, q.second, q.first);
            }
        } else {
            RCP<const Basic> exp, t;
            Mul::as_base_exp(factor, outArg(exp), outArg(t));
            Mul::dict_add_term_new(outArg(coef), d, exp, t);
        }
        result_ = Mul::from_dict(coef, std::move(d));
    }

bvisit() [11/20]

void SymEngine::XReplaceVisitor::bvisit ( const MultiArgFunction &  x )

inline

Definition at line 160 of file subs.h.

    {
        vec_basic v = x.get_args();
        for (auto &elem : v) {
            elem = apply(elem);
        }
        result_ = x.create(v);
    }

bvisit() [12/20]

void SymEngine::XReplaceVisitor::bvisit ( const Not &  x )

inline

Definition at line 215 of file subs.h.

    {
        RCP<const Basic> a = apply(x.get_arg());
        if (not is_a_Boolean(*a))
            throw SymEngineException("expected an object of type Boolean");
        result_ = logical_not(rcp_static_cast<const Boolean>(a));
    }

bvisit() [13/20]

void SymEngine::XReplaceVisitor::bvisit ( const OneArgFunction &  x )

inline

Definition at line 139 of file subs.h.

    {
        apply(x.get_arg());
        if (result_ == x.get_arg()) {
            result_ = x.rcp_from_this();
        } else {
            result_ = x.create(result_);
        }
    }

bvisit() [14/20]

void SymEngine::XReplaceVisitor::bvisit ( const Or &  x )

inline

Definition at line 203 of file subs.h.

    {
        set_boolean v;
        for (const auto &elem : x.get_container()) {
            auto a = apply(elem);
            if (not is_a_Boolean(*a))
                throw SymEngineException("expected an object of type Boolean");
            v.insert(rcp_static_cast<const Boolean>(a));
        }
        result_ = logical_or(v);
    }

bvisit() [15/20]

void SymEngine::XReplaceVisitor::bvisit ( const Piecewise &  pw )

inline

Definition at line 272 of file subs.h.

    {
        PiecewiseVec pwv;
        pwv.reserve(pw.get_vec().size());
        for (const auto &expr_pred : pw.get_vec()) {
            const auto expr = apply(*expr_pred.first);
            const auto pred = apply(*expr_pred.second);
            pwv.emplace_back(
                std::make_pair(expr, rcp_static_cast<const Boolean>(pred)));
        }
        result_ = piecewise(std::move(pwv));
    }

bvisit() [16/20]

void SymEngine::XReplaceVisitor::bvisit ( const Pow &  x )

inline

Definition at line 128 of file subs.h.

    {
        RCP<const Basic> base_new = apply(x.get_base());
        RCP<const Basic> exp_new = apply(x.get_exp());
        if (base_new == x.get_base() and exp_new == x.get_exp()) {
            result_ = x.rcp_from_this();
        } else {
            result_ = pow(base_new, exp_new);
        }
    }

bvisit() [17/20]

void SymEngine::XReplaceVisitor::bvisit ( const Subs &  x )

inline

Definition at line 298 of file subs.h.

    {
        auto expr = apply(x.get_arg());
        map_basic_basic new_subs_dict;
        for (const auto &sym : x.get_dict()) {
            insert(new_subs_dict, apply(sym.first), apply(sym.second));
        }
        result_ = subs(expr, new_subs_dict);
    }

bvisit() [18/20]

template<class T >

void SymEngine::XReplaceVisitor::bvisit ( const TwoArgBasic< T > &  x )

inline

Definition at line 150 of file subs.h.

    {
        RCP<const Basic> a = apply(x.get_arg1());
        RCP<const Basic> b = apply(x.get_arg2());
        if (a == x.get_arg1() and b == x.get_arg2())
            result_ = x.rcp_from_this();
        else
            result_ = x.create(a, b);
    }

bvisit() [19/20]

void SymEngine::XReplaceVisitor::bvisit ( const Union &  x )

inline

Definition at line 260 of file subs.h.

    {
        set_set v;
        for (const auto &elem : x.get_container()) {
            auto a = apply(elem);
            if (not is_a_Set(*a))
                throw SymEngineException("expected an object of type Set");
            v.insert(rcp_static_cast<const Set>(a));
        }
        result_ = x.create(v);
    }

bvisit() [20/20]

void SymEngine::XReplaceVisitor::bvisit ( const Xor &  x )

inline

Definition at line 223 of file subs.h.

    {
        vec_boolean v;
        for (const auto &elem : x.get_container()) {
            auto a = apply(elem);
            if (not is_a_Boolean(*a))
                throw SymEngineException("expected an object of type Boolean");
            v.push_back(rcp_static_cast<const Boolean>(a));
        }
        result_ = logical_xor(v);
    }

Field Documentation

cache

bool SymEngine::XReplaceVisitor::cache

protected

Definition at line 32 of file subs.h.

result_

RCP<const Basic> SymEngine::XReplaceVisitor::result_

protected

Definition at line 29 of file subs.h.

subs_dict_

const map_basic_basic& SymEngine::XReplaceVisitor::subs_dict_

protected

Definition at line 30 of file subs.h.

visited

map_basic_basic SymEngine::XReplaceVisitor::visited

protected

Definition at line 31 of file subs.h.

---

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

• /home/runner/work/symengine/symengine/symengine/subs.h