SymEngine::SubsVisitor Class Reference

Inheritance diagram for SymEngine::SubsVisitor:

Collaboration diagram for SymEngine::SubsVisitor:

Public Member Functions
	SubsVisitor (const map_basic_basic &subs_dict_, bool cache=true)
void	bvisit (const Pow &x)
void	bvisit (const Derivative &x)
void	bvisit (const Subs &x)
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)
Public Member Functions inherited from SymEngine::XReplaceVisitor
	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)

Additional Inherited Members
Protected Attributes inherited from SymEngine::XReplaceVisitor
RCP< const Basic >	result_
const map_basic_basic &	subs_dict_
map_basic_basic	visited
bool	cache

Detailed Description

Definition at line 354 of file subs.h.

Constructor & Destructor Documentation

SubsVisitor()

SymEngine::SubsVisitor::SubsVisitor ( const map_basic_basic &  subs_dict_, bool  cache = true  )

inline

Definition at line 359 of file subs.h.

        : BaseVisitor<SubsVisitor, XReplaceVisitor>(subs_dict_, cache)
    {
    }

Member Function Documentation

bvisit() [1/23]

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/23]

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/23]

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

inline

Definition at line 43 of file subs.h.

    {
        result_ = x.rcp_from_this();
    }

bvisit() [4/23]

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/23]

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/23]

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/23]

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

inline

Definition at line 389 of file subs.h.

    {
        RCP<const Symbol> s;
        map_basic_basic m, n;
        bool subs;
 
        for (const auto &p : subs_dict_) {
            // If the derivative arg is to be replaced in its entirety, allow
            // it.
            if (eq(*x.get_arg(), *p.first)) {
                RCP<const Basic> t = p.second;
                for (auto &sym : x.get_symbols()) {
                    if (not is_a<Symbol>(*sym)) {
                        throw SymEngineException("Error, expected a Symbol.");
                    }
                    t = t->diff(rcp_static_cast<const Symbol>(sym));
                }
                result_ = t;
                return;
            }
        }
        for (const auto &p : subs_dict_) {
            subs = true;
            if (eq(*x.get_arg()->subs({{p.first, p.second}}), *x.get_arg()))
                continue;
 
            // If p.first and p.second are symbols and arg_ is
            // independent of p.second, p.first can be replaced
            if (is_a<Symbol>(*p.first) and is_a<Symbol>(*p.second)
                and eq(
                    *x.get_arg()->diff(rcp_static_cast<const Symbol>(p.second)),
                    *zero)) {
                insert(n, p.first, p.second);
                continue;
            }
            for (const auto &d : x.get_symbols()) {
                if (is_a<Symbol>(*d)) {
                    s = rcp_static_cast<const Symbol>(d);
                    // If p.first or p.second has non zero derivates wrt to s
                    // p.first cannot be replaced
                    if (neq(*zero, *(p.first->diff(s)))
                        || neq(*zero, *(p.second->diff(s)))) {
                        subs = false;
                        break;
                    }
                } else {
                    result_
                        = make_rcp<const Subs>(x.rcp_from_this(), subs_dict_);
                    return;
                }
            }
            if (subs) {
                insert(n, p.first, p.second);
            } else {
                insert(m, p.first, p.second);
            }
        }
        auto t = x.get_arg()->subs(n);
        for (auto &p : x.get_symbols()) {
            auto t2 = p->subs(n);
            if (not is_a<Symbol>(*t2)) {
                throw SymEngineException("Error, expected a Symbol.");
            }
            t = t->diff(rcp_static_cast<const Symbol>(t2));
        }
        if (m.empty()) {
            result_ = t;
        } else {
            result_ = make_rcp<const Subs>(t, m);
        }
    }

bvisit() [8/23]

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() [9/23]

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() [10/23]

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() [11/23]

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() [12/23]

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() [13/23]

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() [14/23]

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() [15/23]

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() [16/23]

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() [17/23]

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() [18/23]

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

inline

Definition at line 364 of file subs.h.

    {
        RCP<const Basic> base_new = apply(x.get_base());
        RCP<const Basic> exp_new = apply(x.get_exp());
        if (subs_dict_.size() == 1 and is_a<Pow>(*((*subs_dict_.begin()).first))
            and not is_a<Add>(
                *down_cast<const Pow &>(*(*subs_dict_.begin()).first)
                     .get_exp())) {
            auto &subs_first
                = down_cast<const Pow &>(*(*subs_dict_.begin()).first);
            if (eq(*subs_first.get_base(), *base_new)) {
                auto newexpo = div(exp_new, subs_first.get_exp());
                if (is_a_Number(*newexpo) or is_a<Constant>(*newexpo)) {
                    result_ = pow((*subs_dict_.begin()).second, newexpo);
                    return;
                }
            }
        }
        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() [19/23]

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() [20/23]

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

inline

Definition at line 461 of file subs.h.

    {
        map_basic_basic m, n;
        for (const auto &p : subs_dict_) {
            bool found = false;
            for (const auto &s : x.get_dict()) {
                if (neq(*(s.first->subs({{p.first, p.second}})), *(s.first))) {
                    found = true;
                    break;
                }
            }
            // If p.first is not replaced in arg_ by dict_,
            // store p.first in n to replace in arg_
            if (not found) {
                insert(n, p.first, p.second);
            }
        }
        for (const auto &s : x.get_dict()) {
            insert(m, s.first, apply(s.second));
        }
        RCP<const Basic> presub = x.get_arg()->subs(n);
        if (is_a<Subs>(*presub)) {
            for (auto &q : down_cast<const Subs &>(*presub).get_dict()) {
                insert(m, q.first, q.second);
            }
            result_ = down_cast<const Subs &>(*presub).get_arg()->subs(m);
        } else {
            result_ = presub->subs(m);
        }
    }

bvisit() [21/23]

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() [22/23]

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() [23/23]

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);
    }

---

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

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