Inheritance diagram for SymEngine::RefineVisitor:

Collaboration diagram for SymEngine::RefineVisitor:

Public Member Functions
	RefineVisitor (const Assumptions *assumptions)

void	bvisit (const Abs &x)

void	bvisit (const Sign &x)

void	bvisit (const Floor &x)

void	bvisit (const Ceiling &x)

void	bvisit (const Conjugate &x)

void	bvisit (const Max &x)

void	bvisit (const Min &x)

void	bvisit (const Pow &x)

void	bvisit (const Log &x)

void	bvisit (const Interval &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 Piecewise &x)

Public Member Functions inherited from SymEngine::TransformVisitor
virtual RCP< const Basic >	apply (const RCP< const Basic > &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 Piecewise &x)

Private Attributes
const Assumptions *	assumptions_

Additional Inherited Members
Protected Attributes inherited from SymEngine::TransformVisitor
RCP< const Basic >	result_

Detailed Description

Definition at line 11 of file refine.h.

Constructor & Destructor Documentation

◆ RefineVisitor()

SymEngine::RefineVisitor::RefineVisitor ( const Assumptions * assumptions )

inline

Definition at line 19 of file refine.h.

        : BaseVisitor<RefineVisitor, TransformVisitor>(),
          assumptions_(assumptions)
    {
    }

Member Function Documentation

◆ bvisit() [1/18]

void SymEngine::RefineVisitor::bvisit ( const Abs & x )

Definition at line 6 of file refine.cpp.

{
    auto farg = x.get_arg();
    auto newarg = apply(farg);
    if (is_true(is_nonnegative(*newarg, assumptions_))) {
        result_ = newarg;
    } else if (is_true(is_nonpositive(*newarg, assumptions_))) {
        result_ = neg(newarg);
    } else if (is_a<Conjugate>(*newarg)) {
        result_ = abs(down_cast<const Conjugate &>(*newarg).get_arg());
    } else {
        result_ = abs(newarg);
    }
}

◆ bvisit() [2/18]

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

Definition at line 247 of file visitor.cpp.

{
    vec_basic newargs;
    for (const auto &a : x.get_args()) {
        newargs.push_back(apply(a));
    }
    result_ = add(newargs);
}

◆ bvisit() [3/18]

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

Definition at line 246 of file visitor.cpp.

{
    result_ = x.rcp_from_this();
}

◆ bvisit() [4/18]

void SymEngine::RefineVisitor::bvisit ( const Ceiling & x )

Definition at line 49 of file refine.cpp.

{
    auto farg = x.get_arg();
    auto newarg = apply(farg);
    if (is_true(is_integer(*newarg, assumptions_))) {
        result_ = newarg;
    } else if (could_extract_minus(*newarg)) {
        result_ = neg(floor(neg(newarg)));
    } else {
        result_ = ceiling(newarg);
    }
}

◆ bvisit() [5/18]

void SymEngine::RefineVisitor::bvisit ( const Conjugate & x )

Definition at line 62 of file refine.cpp.

{
    auto farg = x.get_arg();
    auto newarg = apply(farg);
    if (is_true(is_real(*newarg, assumptions_))) {
        result_ = newarg;
    } else {
        result_ = conjugate(newarg);
    }
}

◆ bvisit() [6/18]

void SymEngine::RefineVisitor::bvisit ( const Floor & x )

Definition at line 36 of file refine.cpp.

{
    auto farg = x.get_arg();
    auto newarg = apply(farg);
    if (is_true(is_integer(*newarg, assumptions_))) {
        result_ = newarg;
    } else if (could_extract_minus(*newarg)) {
        result_ = neg(ceiling(neg(newarg)));
    } else {
        result_ = floor(newarg);
    }
}

◆ bvisit() [7/18]

void SymEngine::RefineVisitor::bvisit ( const Interval & x )

Definition at line 196 of file refine.cpp.

{
    if (eq(*x.get_start(), *SymEngine::infty(-1))
        and eq(*x.get_end(), *SymEngine::infty(1))) {
        result_ = reals();
        return;
    }
    result_ = x.rcp_from_this();
}

◆ bvisit() [8/18]

void SymEngine::RefineVisitor::bvisit ( const Log & x )

Definition at line 171 of file refine.cpp.

{
    auto farg = x.get_arg();
    auto newarg = apply(farg);
    if (is_a<Pow>(*newarg)) {
        auto base = down_cast<const Pow &>(*newarg).get_base();
        if (is_true(is_positive(*base, assumptions_))) {
            auto exp = down_cast<const Pow &>(*newarg).get_exp();
            if (is_true(is_real(*exp, assumptions_))) {
                result_ = mul(exp, log(base));
                return;
            }
        }
    } else if (is_a<Integer>(*newarg)) {
        auto base_exp = mp_perfect_power_decomposition(
            down_cast<const Integer &>(*newarg).as_integer_class());
        if (base_exp.second != 1) {
            result_ = mul(make_rcp<const Integer>(base_exp.second),
                          log(make_rcp<const Integer>(base_exp.first)));
            return;
        }
    }
    result_ = log(newarg);
}

◆ bvisit() [9/18]

void SymEngine::RefineVisitor::bvisit ( const Max & x )

Definition at line 73 of file refine.cpp.

{
    // positive > nonpositive
    // nonnegative and positive > negative
    vec_basic nonpositive;
    vec_basic negative;
    vec_basic keep;
    bool have_positive = false;
    bool have_nonnegative = false;
    for (auto arg : x.get_args()) {
        auto newarg = apply(arg);
        if (is_true(is_positive(*newarg, assumptions_))) {
            keep.push_back(newarg);
            have_positive = true;
        } else if (is_true(is_nonnegative(*newarg, assumptions_))) {
            keep.push_back(newarg);
            have_nonnegative = true;
        } else if (is_true(is_negative(*newarg, assumptions_))) {
            negative.push_back(newarg);
        } else if (is_true(is_nonpositive(*newarg, assumptions_))) {
            nonpositive.push_back(newarg);
        } else {
            keep.push_back(newarg);
        }
    }
    if (not have_positive and not nonpositive.empty()) {
        std::copy(nonpositive.begin(), nonpositive.end(),
                  std::back_inserter(keep));
    }
    if (not have_nonnegative and not have_positive and not negative.empty()) {
        std::copy(negative.begin(), negative.end(), std::back_inserter(keep));
    }
 
    result_ = max(keep);
}

◆ bvisit() [10/18]

void SymEngine::RefineVisitor::bvisit ( const Min & x )

Definition at line 109 of file refine.cpp.

{
    // negative < nonnegative
    // nonpositive and negative < positive
    vec_basic nonnegative;
    vec_basic positive;
    vec_basic keep;
    bool have_negative = false;
    bool have_nonpositive = false;
    for (auto arg : x.get_args()) {
        auto newarg = apply(arg);
        if (is_true(is_negative(*newarg, assumptions_))) {
            keep.push_back(newarg);
            have_negative = true;
        } else if (is_true(is_nonpositive(*newarg, assumptions_))) {
            keep.push_back(newarg);
            have_nonpositive = true;
        } else if (is_true(is_positive(*newarg, assumptions_))) {
            positive.push_back(newarg);
        } else if (is_true(is_nonnegative(*newarg, assumptions_))) {
            nonnegative.push_back(newarg);
        } else {
            keep.push_back(newarg);
        }
    }
    if (not have_negative and not nonnegative.empty()) {
        std::copy(nonnegative.begin(), nonnegative.end(),
                  std::back_inserter(keep));
    }
    if (not have_nonpositive and not have_negative and not positive.empty()) {
        std::copy(positive.begin(), positive.end(), std::back_inserter(keep));
    }
 
    result_ = min(keep);
}

◆ bvisit() [11/18]

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

Definition at line 248 of file visitor.cpp.

{
    vec_basic newargs;
    for (const auto &a : x.get_args()) {
        newargs.push_back(apply(a));
    }
    result_ = mul(newargs);
}

◆ bvisit() [12/18]

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

Definition at line 264 of file visitor.cpp.

{
    auto fargs = x.get_args();
    vec_basic newargs;
    for (const auto &a : fargs) {
        newargs.push_back(apply(a));
    }
    auto nbarg = x.create(newargs);
    result_ = nbarg;
}

◆ bvisit() [13/18]

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

Definition at line 250 of file visitor.cpp.

{
    auto farg = x.get_arg();
    auto newarg = apply(farg);
    if (eq(*newarg, *farg)) {
        result_ = x.rcp_from_this();
    } else {
        result_ = x.create(newarg);
    }
}

◆ bvisit() [14/18]

void SymEngine::TransformVisitor::bvisit ( const Piecewise & x )

Definition at line 265 of file visitor.cpp.

{
    auto branch_cond_pairs = x.get_vec();
    PiecewiseVec new_pairs;
    for (const auto &branch_cond : branch_cond_pairs) {
        auto branch = branch_cond.first;
        auto cond = branch_cond.second;
        auto new_branch = apply(branch);
        auto new_cond = apply(cond);
        if (!is_a_Boolean(*new_cond)) {
            new_cond = Eq(new_cond, boolTrue);
        }
        new_pairs.push_back(
            {new_branch, rcp_static_cast<const Boolean>(new_cond)});
    }
    result_ = piecewise(new_pairs);
}

◆ bvisit() [15/18]

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

Definition at line 249 of file visitor.cpp.

{
    auto base_ = x.get_base(), exp_ = x.get_exp();
    auto newarg1 = apply(base_), newarg2 = apply(exp_);
    if (base_ != newarg1 or exp_ != newarg2) {
        result_ = pow(newarg1, newarg2);
    } else {
        result_ = x.rcp_from_this();
    }
}

◆ bvisit() [16/18]

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

Definition at line 145 of file refine.cpp.

{
    auto exp = x.get_exp();
    auto newexp = apply(exp);
    auto base = x.get_base();
    auto newbase = apply(base);
    // Handle cases when (x**k)**n = x**(k*n) or = abs(x)**(k*n)
    if (is_a<Pow>(*newbase) and is_a_Number(*newexp)) {
        const Pow &inner_pow = down_cast<const Pow &>(*newbase);
        auto inner_exp = inner_pow.get_exp();
        auto inner_base = inner_pow.get_base();
        if (is_true(is_real(*inner_base, assumptions_))
            and is_a_Number(*inner_exp)
            and not down_cast<const Number &>(*inner_exp).is_complex()
            and not down_cast<const Number &>(*newexp).is_complex()) {
            if (is_true(is_positive(*inner_base, assumptions_))) {
                result_ = pow(inner_base, mul(newexp, inner_exp));
            } else {
                result_ = pow(abs(inner_base), mul(newexp, inner_exp));
            }
            return;
        }
    }
    result_ = pow(newbase, newexp);
}

◆ bvisit() [17/18]

void SymEngine::RefineVisitor::bvisit ( const Sign & x )

Definition at line 21 of file refine.cpp.

{
    auto farg = x.get_arg();
    auto newarg = apply(farg);
    if (is_true(is_positive(*newarg, assumptions_))) {
        result_ = integer(1);
    } else if (is_true(is_negative(*newarg, assumptions_))) {
        result_ = integer(-1);
    } else if (is_true(is_zero(*newarg, assumptions_))) {
        result_ = integer(0);
    } else {
        result_ = sign(newarg);
    }
}

◆ bvisit() [18/18]

template<class T >

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