test_visitors.h

#ifndef SYMENGINE_TEST_VISITORS_H
#define SYMENGINE_TEST_VISITORS_H
 
#include <symengine/visitor.h>
 
namespace SymEngine
{
 
class ZeroVisitor : public BaseVisitor<ZeroVisitor>
{
private:
    tribool is_zero_;
    const Assumptions *assumptions_;
 
    void error();
 
public:
    ZeroVisitor(const Assumptions *assumptions) : assumptions_(assumptions) {}
 
    void bvisit(const Basic &x);
    void bvisit(const Symbol &x);
    void bvisit(const Number &x);
    void bvisit(const Set &x);
    void bvisit(const Relational &x);
    void bvisit(const Boolean &x);
    void bvisit(const Constant &x);
    void bvisit(const Abs &x);
    void bvisit(const Conjugate &x);
    void bvisit(const Sign &x);
    void bvisit(const PrimePi &x);
 
    tribool apply(const Basic &b);
};
 
class PositiveVisitor : public BaseVisitor<PositiveVisitor>
{
private:
    tribool is_positive_;
    const Assumptions *assumptions_;
 
    void error();
 
public:
    PositiveVisitor(const Assumptions *assumptions)
        : assumptions_(assumptions){};
    void bvisit(const Symbol &x);
    void bvisit(const Number &x);
    void bvisit(const Constant &x);
    void bvisit(const Add &x);
    void bvisit(const Basic &x);
    void bvisit(const Set &x);
    void bvisit(const Relational &x);
    void bvisit(const Boolean &x);
 
    tribool apply(const Basic &b);
};
 
class NonPositiveVisitor : public BaseVisitor<NonPositiveVisitor>
{
private:
    tribool is_nonpositive_;
    const Assumptions *assumptions_;
 
    void error();
 
public:
    NonPositiveVisitor(const Assumptions *assumptions)
        : assumptions_(assumptions){};
    void bvisit(const Symbol &x);
    void bvisit(const Number &x);
    void bvisit(const Constant &x);
    void bvisit(const Basic &x);
    void bvisit(const Set &x);
    void bvisit(const Relational &x);
    void bvisit(const Boolean &x);
 
    tribool apply(const Basic &b);
};
 
class NegativeVisitor : public BaseVisitor<NegativeVisitor>
{
private:
    tribool is_negative_;
    const Assumptions *assumptions_;
 
    void error();
 
public:
    NegativeVisitor(const Assumptions *assumptions)
        : assumptions_(assumptions){};
    void bvisit(const Basic &x);
    void bvisit(const Symbol &x);
    void bvisit(const Number &x);
    void bvisit(const Set &x);
    void bvisit(const Relational &x);
    void bvisit(const Boolean &x);
    void bvisit(const Constant &x);
 
    tribool apply(const Basic &b);
};
 
class NonNegativeVisitor : public BaseVisitor<NonNegativeVisitor>
{
private:
    tribool is_nonnegative_;
    const Assumptions *assumptions_;
 
    void error();
 
public:
    NonNegativeVisitor(const Assumptions *assumptions)
        : assumptions_(assumptions){};
    void bvisit(const Basic &x);
    void bvisit(const Symbol &x);
    void bvisit(const Number &x);
    void bvisit(const Set &x);
    void bvisit(const Relational &x);
    void bvisit(const Boolean &x);
    void bvisit(const Constant &x);
 
    tribool apply(const Basic &b);
};
 
class IntegerVisitor : public BaseVisitor<IntegerVisitor>
{
private:
    tribool is_integer_;
    const Assumptions *assumptions_;
 
public:
    IntegerVisitor(const Assumptions *assumptions)
        : assumptions_(assumptions){};
    void bvisit(const Basic &x)
    {
        is_integer_ = tribool::indeterminate;
    };
    void bvisit(const Symbol &x);
    void bvisit(const Integer &x)
    {
        is_integer_ = tribool::tritrue;
    };
    void bvisit(const Number &x)
    {
        is_integer_ = tribool::trifalse;
    };
    void bvisit(const Set &x)
    {
        is_integer_ = tribool::trifalse;
    };
    void bvisit(const Relational &x)
    {
        is_integer_ = tribool::trifalse;
    };
    void bvisit(const Boolean &x)
    {
        is_integer_ = tribool::trifalse;
    };
    void bvisit(const Constant &x);
    void bvisit(const Add &x);
    void bvisit(const Mul &x);
    void bvisit(const Conjugate &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const KroneckerDelta &x)
    {
        is_integer_ = tribool::tritrue;
    };
 
    tribool apply(const Basic &b);
};
 
class RealVisitor : public BaseVisitor<RealVisitor>
{
private:
    tribool is_real_;
    const Assumptions *assumptions_;
 
    void check_power(const RCP<const Basic> &base, const RCP<const Basic> &exp);
 
public:
    RealVisitor(const Assumptions *assumptions) : assumptions_(assumptions){};
    void bvisit(const Basic &x)
    {
        is_real_ = tribool::indeterminate;
    };
    void bvisit(const Symbol &x);
    void bvisit(const Number &x);
    void bvisit(const Set &x)
    {
        is_real_ = tribool::trifalse;
    };
    void bvisit(const Relational &x)
    {
        is_real_ = tribool::trifalse;
    };
    void bvisit(const Boolean &x)
    {
        is_real_ = tribool::trifalse;
    };
    void bvisit(const Constant &x);
    void bvisit(const Add &x);
    void bvisit(const Mul &x);
    void bvisit(const Pow &x);
 
    tribool apply(const Basic &b);
};
 
class ComplexVisitor : public BaseVisitor<ComplexVisitor>
{
private:
    tribool is_complex_;
    const Assumptions *assumptions_;
 
    void check_power(const Basic &base, const Basic &exp);
    void complex_arg_not_zero(const OneArgFunction &x, const Basic &not_zero);
    void complex_arg_not_pm(const OneArgFunction &x, bool one);
 
public:
    ComplexVisitor(const Assumptions *assumptions)
        : assumptions_(assumptions){};
    void bvisit(const Basic &x)
    {
        is_complex_ = tribool::indeterminate;
    };
    void bvisit(const Symbol &x);
    void bvisit(const Number &x);
    void bvisit(const Integer &x)
    {
        is_complex_ = tribool::tritrue;
    }
    void bvisit(const Rational &x)
    {
        is_complex_ = tribool::tritrue;
    }
    void bvisit(const Set &x)
    {
        is_complex_ = tribool::trifalse;
    };
    void bvisit(const Relational &x)
    {
        is_complex_ = tribool::trifalse;
    };
    void bvisit(const Boolean &x)
    {
        is_complex_ = tribool::trifalse;
    };
    void bvisit(const Constant &x)
    {
        is_complex_ = tribool::tritrue;
    };
    void bvisit(const Add &x);
    void bvisit(const Mul &x);
    void bvisit(const Pow &x);
    void bvisit(const Cos &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const Sin &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const ASin &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const ACos &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const ATan &x);
    void bvisit(const ATanh &x);
    void bvisit(const ACot &x);
    void bvisit(const ACoth &x);
    void bvisit(const Sinh &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const Cosh &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const Tan &x);
    void bvisit(const Cot &x);
    void bvisit(const Sec &x);
    void bvisit(const ASec &x);
    void bvisit(const ASech &x);
    void bvisit(const Csc &x);
    void bvisit(const ACsc &x);
    void bvisit(const ACsch &x);
    void bvisit(const Log &x);
    void bvisit(const Sign &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const Floor &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const Ceiling &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const Abs &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const Conjugate &x)
    {
        x.get_arg()->accept(*this);
    };
    void bvisit(const KroneckerDelta &x)
    {
        is_complex_ = tribool::tritrue;
    };
 
    tribool apply(const Basic &b);
};
 
class PolynomialVisitor : public BaseVisitor<PolynomialVisitor>
{
private:
    bool is_polynomial_ = true;
    bool variables_allowed_ = true;
    const set_basic &variables_;
 
    void check_power(const Basic &base, const Basic &exp);
 
public:
    PolynomialVisitor(const set_basic &variables) : variables_(variables) {}
    void bvisit(const Basic &x);
    void bvisit(const Number &x){};
    void bvisit(const Constant &x){};
    void bvisit(const Symbol &x);
    void bvisit(const Add &x);
    void bvisit(const Mul &x);
    void bvisit(const Pow &x);
    void bvisit(const Set &x)
    {
        is_polynomial_ = false;
    };
    void bvisit(const Relational &x)
    {
        is_polynomial_ = false;
    };
 
    bool apply(const Basic &b);
};
 
bool is_polynomial(const Basic &b, const set_basic &variables = {});
 
class RationalVisitor : public BaseVisitor<RationalVisitor>
{
private:
    bool rational_; // are we testing for rational or irrational?
    tribool is_rational_;
    bool neither_ = false; // Neither rational or irrational (i.e. not real)
 
public:
    RationalVisitor(bool rational) : rational_{rational} {}
    void bvisit(const Basic &x)
    {
        is_rational_ = tribool::indeterminate;
    };
    void bvisit(const Symbol &x)
    {
        is_rational_ = tribool::indeterminate;
    };
    void bvisit(const Integer &x)
    {
        is_rational_ = tribool::tritrue;
    };
    void bvisit(const Rational &x)
    {
        is_rational_ = tribool::tritrue;
    };
    void bvisit(const Number &x);
    void bvisit(const Set &x)
    {
        is_rational_ = tribool::trifalse;
        neither_ = true;
    };
    void bvisit(const Relational &x)
    {
        is_rational_ = tribool::trifalse;
        neither_ = true;
    };
    void bvisit(const Boolean &x)
    {
        is_rational_ = tribool::trifalse;
        neither_ = true;
    };
    void bvisit(const Constant &x);
    void bvisit(const Add &x);
 
    tribool apply(const Basic &b);
};
 
class FiniteVisitor : public BaseVisitor<FiniteVisitor>
{
private:
    tribool is_finite_;
    const Assumptions *assumptions_;
 
    void error();
 
public:
    FiniteVisitor(const Assumptions *assumptions) : assumptions_(assumptions){};
 
    void bvisit(const Basic &x);
    void bvisit(const Symbol &x);
    void bvisit(const Infty &x);
    void bvisit(const NaN &x);
    void bvisit(const Number &x);
    void bvisit(const Set &x);
    void bvisit(const Relational &x);
    void bvisit(const Boolean &x);
    void bvisit(const Constant &x);
 
    tribool apply(const Basic &b);
};
 
class AlgebraicVisitor : public BaseVisitor<AlgebraicVisitor>
{
private:
    tribool is_algebraic_;
    const Assumptions *assumptions_;
 
    void trans_nonzero_and_algebraic(const Basic &b);
    void error();
 
public:
    AlgebraicVisitor(const Assumptions *assumptions) : assumptions_(assumptions)
    {
    }
 
    void bvisit(const Basic &x);
    void bvisit(const Add &x);
    void bvisit(const Symbol &x);
    void bvisit(const Integer &x);
    void bvisit(const Rational &x);
    void bvisit(const Set &x);
    void bvisit(const Relational &x);
    void bvisit(const Boolean &x);
    void bvisit(const Constant &x);
    void bvisit(const TrigFunction &x);
    void bvisit(const HyperbolicFunction &x);
    void bvisit(const LambertW &x);
 
    tribool apply(const Basic &b);
};
 
} // namespace SymEngine
 
#endif // SYMENGINE_TEST_VISITORS_H