functions.h

Go to the documentation of this file.

 
#ifndef SYMENGINE_FUNCTIONS_H
#define SYMENGINE_FUNCTIONS_H
 
#include <symengine/basic.h>
#include <symengine/symengine_casts.h>
#include <symengine/constants.h>
 
namespace SymEngine
{
 
class Function : public Basic
{
};
 
class OneArgFunction : public Function
{
private:
    RCP<const Basic> arg_; 
public:
    OneArgFunction(const RCP<const Basic> &arg) : arg_{arg} {};
    inline hash_t __hash__() const override
    {
        hash_t seed = this->get_type_code();
        hash_combine<Basic>(seed, *arg_);
        return seed;
    }
    inline RCP<const Basic> get_arg() const
    {
        return arg_;
    }
    inline vec_basic get_args() const override
    {
        return {arg_};
    }
    virtual RCP<const Basic> create(const RCP<const Basic> &arg) const = 0;
 
    inline RCP<const Basic> create(const vec_basic &b) const
    {
        SYMENGINE_ASSERT(b.size() == 1);
        return create(b[0]);
    }
 
    inline bool __eq__(const Basic &o) const override
    {
        return is_same_type(*this, o)
               and eq(*get_arg(),
                      *down_cast<const OneArgFunction &>(o).get_arg());
    }
    inline int compare(const Basic &o) const override
    {
        SYMENGINE_ASSERT(is_same_type(*this, o))
        return get_arg()->__cmp__(
            *(down_cast<const OneArgFunction &>(o).get_arg()));
    }
};
 
template <class BaseClass>
class TwoArgBasic : public BaseClass
{
private:
    RCP<const Basic> a_; 
    RCP<const Basic> b_; 
public:
    TwoArgBasic(const RCP<const Basic> &a, const RCP<const Basic> &b)
        : a_{a}, b_{b} {};
    inline hash_t __hash__() const override
    {
        hash_t seed = this->get_type_code();
        hash_combine<Basic>(seed, *a_);
        hash_combine<Basic>(seed, *b_);
        return seed;
    }
    inline RCP<const Basic> get_arg1() const
    {
        return a_;
    }
    inline RCP<const Basic> get_arg2() const
    {
        return b_;
    }
    inline vec_basic get_args() const override
    {
        return {a_, b_};
    }
    virtual RCP<const Basic> create(const RCP<const Basic> &a,
                                    const RCP<const Basic> &b) const = 0;
 
    inline RCP<const Basic> create(const vec_basic &b) const
    {
        SYMENGINE_ASSERT(b.size() == 2);
        return create(b[0], b[1]);
    }
 
    inline bool __eq__(const Basic &o) const override
    {
        return is_same_type(*this, o)
               and eq(*get_arg1(),
                      *down_cast<const TwoArgBasic &>(o).get_arg1())
               and eq(*get_arg2(),
                      *down_cast<const TwoArgBasic &>(o).get_arg2());
    }
    inline int compare(const Basic &o) const override
    {
        SYMENGINE_ASSERT(is_same_type(*this, o))
        const TwoArgBasic &t = down_cast<const TwoArgBasic &>(o);
        if (neq(*get_arg1(), *(t.get_arg1()))) {
            return get_arg1()->__cmp__(
                *(down_cast<const TwoArgBasic &>(o).get_arg1()));
        } else {
            return get_arg2()->__cmp__(
                *(down_cast<const TwoArgBasic &>(o).get_arg2()));
        }
    }
};
 
typedef TwoArgBasic<Function> TwoArgFunction;
 
class MultiArgFunction : public Function
{
private:
    vec_basic arg_;
 
public:
    MultiArgFunction(const vec_basic &arg) : arg_{arg} {};
    inline hash_t __hash__() const override
    {
        hash_t seed = this->get_type_code();
        for (const auto &a : arg_)
            hash_combine<Basic>(seed, *a);
        return seed;
    }
    inline vec_basic get_args() const override
    {
        return arg_;
    }
    inline const vec_basic &get_vec() const
    {
        return arg_;
    }
    virtual RCP<const Basic> create(const vec_basic &v) const = 0;
    inline bool __eq__(const Basic &o) const override
    {
        return is_same_type(*this, o)
               and unified_eq(get_vec(),
                              down_cast<const MultiArgFunction &>(o).get_vec());
    }
    inline int compare(const Basic &o) const override
    {
        SYMENGINE_ASSERT(is_same_type(*this, o))
        return unified_compare(
            get_vec(), down_cast<const MultiArgFunction &>(o).get_vec());
    }
};
 
class Sign : public OneArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_SIGN)
    Sign(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> sign(const RCP<const Basic> &arg);
 
class Floor : public OneArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_FLOOR)
    Floor(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> floor(const RCP<const Basic> &arg);
 
class Ceiling : public OneArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_CEILING)
    Ceiling(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> ceiling(const RCP<const Basic> &arg);
 
class Truncate : public OneArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_TRUNCATE)
    Truncate(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> truncate(const RCP<const Basic> &arg);
 
class Conjugate : public OneArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_CONJUGATE)
    Conjugate(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> conjugate(const RCP<const Basic> &arg);
 
class TrigBase : public OneArgFunction
{
public:
    TrigBase(RCP<const Basic> arg) : OneArgFunction(arg){};
};
 
class TrigFunction : public TrigBase
{
public:
    TrigFunction(RCP<const Basic> arg) : TrigBase(arg){};
};
 
class InverseTrigFunction : public TrigBase
{
public:
    InverseTrigFunction(RCP<const Basic> arg) : TrigBase(arg){};
};
 
bool get_pi_shift(const RCP<const Basic> &arg, const Ptr<RCP<const Number>> &n,
                  const Ptr<RCP<const Basic>> &m);
 
bool could_extract_minus(const Basic &arg);
 
bool handle_minus(const RCP<const Basic> &arg,
                  const Ptr<RCP<const Basic>> &rarg);
 
bool inverse_lookup(const umap_basic_basic &d, const RCP<const Basic> &t,
                    const Ptr<RCP<const Basic>> &index);
 
// \return true of conjugate has to be returned finally else false
bool trig_simplify(const RCP<const Basic> &arg, unsigned period, bool odd,
                   bool conj_odd, // input
                   const Ptr<RCP<const Basic>> &rarg, int &index,
                   int &sign); // output
 
RCP<const Basic> sqrt(const RCP<const Basic> &arg);
 
RCP<const Basic> cbrt(const RCP<const Basic> &arg);
 
class Sin : public TrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_SIN)
    Sin(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> sin(const RCP<const Basic> &arg);
 
class Cos : public TrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_COS)
    Cos(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> cos(const RCP<const Basic> &arg);
 
class Tan : public TrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_TAN)
    Tan(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
RCP<const Basic> tan(const RCP<const Basic> &arg);
 
class Cot : public TrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_COT)
    Cot(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
RCP<const Basic> cot(const RCP<const Basic> &arg);
 
class Csc : public TrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_CSC)
    Csc(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
RCP<const Basic> csc(const RCP<const Basic> &arg);
 
class Sec : public TrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_SEC)
    Sec(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
RCP<const Basic> sec(const RCP<const Basic> &arg);
 
class ASin : public InverseTrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_ASIN)
    ASin(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> asin(const RCP<const Basic> &arg);
 
class ACos : public InverseTrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_ACOS)
    ACos(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> acos(const RCP<const Basic> &arg);
 
class ASec : public InverseTrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_ASEC)
    ASec(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> asec(const RCP<const Basic> &arg);
 
class ACsc : public InverseTrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_ACSC)
    ACsc(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> acsc(const RCP<const Basic> &arg);
 
class ATan : public InverseTrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_ATAN)
    ATan(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> atan(const RCP<const Basic> &arg);
 
class ACot : public InverseTrigFunction
{
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_ACOT)
    ACot(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> acot(const RCP<const Basic> &arg);
 
class ATan2 : public TwoArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_ATAN2)
    ATan2(const RCP<const Basic> &num, const RCP<const Basic> &den);
    bool is_canonical(const RCP<const Basic> &num,
                      const RCP<const Basic> &den) const;
    inline RCP<const Basic> get_num() const
    {
        return get_arg1();
    }
    inline RCP<const Basic> get_den() const
    {
        return get_arg2();
    }
    RCP<const Basic> create(const RCP<const Basic> &a,
                            const RCP<const Basic> &b) const override;
};
 
RCP<const Basic> atan2(const RCP<const Basic> &num,
                       const RCP<const Basic> &den);
 
class Log : public OneArgFunction
{
    // Logarithms are taken with the natural base, `e`. To get
    // a logarithm of a different base `b`, use `log(x, b)`,
    // which is essentially short-hand for `log(x)/log(b)`.
public:
    IMPLEMENT_TYPEID(SYMENGINE_LOG)
    Log(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> log(const RCP<const Basic> &arg);
RCP<const Basic> log(const RCP<const Basic> &arg, const RCP<const Basic> &b);
 
class LambertW : public OneArgFunction
{
    // Lambert W function, defined as the inverse function of
    // x*exp(x). This function represents the principal branch
    // of this inverse function, which is multivalued.
    // For more information, see:
    // http://en.wikipedia.org/wiki/Lambert_W_function
public:
    IMPLEMENT_TYPEID(SYMENGINE_LAMBERTW)
    LambertW(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> lambertw(const RCP<const Basic> &arg);
 
class Zeta : public TwoArgFunction
{
    // Hurwitz zeta function (or Riemann zeta function).
    //
    // For `\operatorname{Re}(a) > 0` and `\operatorname{Re}(s) > 1`, this
    // function is defined as
    //
    // .. math:: \zeta(s, a) = \sum_{n=0}^\infty \frac{1}{(n + a)^s},
    //
    // where the standard choice of argument for :math:`n + a` is used.
    // If no value is passed for :math:`a`, by this function assumes a default
    // value
    // of :math:`a = 1`, yielding the Riemann zeta function.
public:
    using TwoArgFunction::create;
    IMPLEMENT_TYPEID(SYMENGINE_ZETA)
    Zeta(const RCP<const Basic> &s, const RCP<const Basic> &a);
    Zeta(const RCP<const Basic> &s);
    inline RCP<const Basic> get_s() const
    {
        return get_arg1();
    }
    inline RCP<const Basic> get_a() const
    {
        return get_arg2();
    }
    bool is_canonical(const RCP<const Basic> &s,
                      const RCP<const Basic> &a) const;
    RCP<const Basic> create(const RCP<const Basic> &a,
                            const RCP<const Basic> &b) const override;
};
 
RCP<const Basic> zeta(const RCP<const Basic> &s, const RCP<const Basic> &a);
RCP<const Basic> zeta(const RCP<const Basic> &s);
 
class Dirichlet_eta : public OneArgFunction
{
    // See http://en.wikipedia.org/wiki/Dirichlet_eta_function
public:
    IMPLEMENT_TYPEID(SYMENGINE_DIRICHLET_ETA)
    Dirichlet_eta(const RCP<const Basic> &s);
    inline RCP<const Basic> get_s() const
    {
        return get_arg();
    }
    bool is_canonical(const RCP<const Basic> &s) const;
    RCP<const Basic> rewrite_as_zeta() const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
    using OneArgFunction::create;
};
 
RCP<const Basic> dirichlet_eta(const RCP<const Basic> &s);
 
class FunctionSymbol : public MultiArgFunction
{
protected:
    std::string name_; 
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_FUNCTIONSYMBOL)
    FunctionSymbol(std::string name, const vec_basic &arg);
    FunctionSymbol(std::string name, const RCP<const Basic> &arg);
    hash_t __hash__() const override;
    bool __eq__(const Basic &o) const override;
    int compare(const Basic &o) const override;
    inline const std::string &get_name() const
    {
        return name_;
    }
    bool is_canonical(const vec_basic &arg) const;
    RCP<const Basic> create(const vec_basic &x) const override;
};
 
RCP<const Basic> function_symbol(std::string name, const RCP<const Basic> &arg);
RCP<const Basic> function_symbol(std::string name, const vec_basic &arg);
 
class FunctionWrapper : public FunctionSymbol
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_FUNCTIONWRAPPER)
    FunctionWrapper(std::string name, const vec_basic &arg);
    FunctionWrapper(std::string name, const RCP<const Basic> &arg);
    RCP<const Basic> create(const vec_basic &v) const override = 0;
    virtual RCP<const Number> eval(long bits) const = 0;
    virtual RCP<const Basic> diff_impl(const RCP<const Symbol> &s) const = 0;
};
 
class Derivative : public Basic
{
private:
    RCP<const Basic> arg_; 
    // The symbols are declared as Basic (and checked by is_canonical() below),
    // to avoid issues with converting vector<RCP<Symbol>> to
    // vector<RCP<Basic>>, see [1], [2]. The problem is that even though Symbol
    // inherits from Basic, vector<RCP<Symbol>> does not inherit from
    // vector<RCP<Basic>>, so the compiler can't cast the derived type to the
    // base type when calling functions like unified_eq() that are only
    // defined for the base type vector<RCP<Basic>>.
    // [1]
    // http://stackoverflow.com/questions/14964909/how-to-cast-a-vector-of-shared-ptrs-of-a-derived-class-to-a-vector-of-share-ptrs
    // [2]
    // http://stackoverflow.com/questions/114819/getting-a-vectorderived-into-a-function-that-expects-a-vectorbase
    multiset_basic x_; 
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_DERIVATIVE)
    Derivative(const RCP<const Basic> &arg, const multiset_basic &x);
 
    static RCP<const Derivative> create(const RCP<const Basic> &arg,
                                        const multiset_basic &x)
    {
        return make_rcp<const Derivative>(arg, x);
    }
 
    hash_t __hash__() const override;
    bool __eq__(const Basic &o) const override;
    int compare(const Basic &o) const override;
    inline RCP<const Basic> get_arg() const
    {
        return arg_;
    }
    inline const multiset_basic &get_symbols() const
    {
        return x_;
    }
    vec_basic get_args() const override
    {
        vec_basic args = {arg_};
        args.insert(args.end(), x_.begin(), x_.end());
        return args;
    }
    bool is_canonical(const RCP<const Basic> &arg,
                      const multiset_basic &x) const;
};
 
class Subs : public Basic
{
private:
    RCP<const Basic> arg_;
    map_basic_basic dict_;
 
public:
    IMPLEMENT_TYPEID(SYMENGINE_SUBS)
    Subs(const RCP<const Basic> &arg, const map_basic_basic &x);
 
    static RCP<const Subs> create(const RCP<const Basic> &arg,
                                  const map_basic_basic &x)
    {
        return make_rcp<const Subs>(arg, x);
    }
 
    hash_t __hash__() const override;
    bool __eq__(const Basic &o) const override;
    int compare(const Basic &o) const override;
    inline const RCP<const Basic> &get_arg() const
    {
        return arg_;
    }
    inline const map_basic_basic &get_dict() const
    {
        return dict_;
    };
    virtual vec_basic get_variables() const;
    virtual vec_basic get_point() const;
    vec_basic get_args() const override;
 
    bool is_canonical(const RCP<const Basic> &arg,
                      const map_basic_basic &x) const;
};
 
class HyperbolicBase : public OneArgFunction
{
public:
    HyperbolicBase(RCP<const Basic> arg) : OneArgFunction{arg} {};
};
 
class HyperbolicFunction : public HyperbolicBase
{
public:
    HyperbolicFunction(RCP<const Basic> arg) : HyperbolicBase{arg} {};
};
 
class InverseHyperbolicFunction : public HyperbolicBase
{
public:
    InverseHyperbolicFunction(RCP<const Basic> arg) : HyperbolicBase{arg} {};
};
 
class Sinh : public HyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_SINH)
    Sinh(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> sinh(const RCP<const Basic> &arg);
 
class Csch : public HyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_CSCH)
    Csch(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> csch(const RCP<const Basic> &arg);
 
class Cosh : public HyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_COSH)
    Cosh(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> cosh(const RCP<const Basic> &arg);
 
class Sech : public HyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_SECH)
    Sech(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> sech(const RCP<const Basic> &arg);
 
class Tanh : public HyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_TANH)
    Tanh(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> tanh(const RCP<const Basic> &arg);
 
class Coth : public HyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_COTH)
    Coth(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> coth(const RCP<const Basic> &arg);
 
class ASinh : public InverseHyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_ASINH)
    ASinh(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> asinh(const RCP<const Basic> &arg);
 
class ACsch : public InverseHyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_ACSCH)
    ACsch(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> acsch(const RCP<const Basic> &arg);
 
class ACosh : public InverseHyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_ACOSH)
    ACosh(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> acosh(const RCP<const Basic> &arg);
 
class ATanh : public InverseHyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_ATANH)
    ATanh(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> atanh(const RCP<const Basic> &arg);
 
class ACoth : public InverseHyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_ACOTH)
    ACoth(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> acoth(const RCP<const Basic> &arg);
 
class ASech : public InverseHyperbolicFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_ASECH)
    ASech(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> asech(const RCP<const Basic> &arg);
 
class KroneckerDelta : public TwoArgFunction
{
public:
    using TwoArgFunction::create;
    IMPLEMENT_TYPEID(SYMENGINE_KRONECKERDELTA)
    KroneckerDelta(const RCP<const Basic> &i, const RCP<const Basic> &j);
    bool is_canonical(const RCP<const Basic> &i,
                      const RCP<const Basic> &j) const;
    RCP<const Basic> create(const RCP<const Basic> &a,
                            const RCP<const Basic> &b) const override;
};
 
RCP<const Basic> kronecker_delta(const RCP<const Basic> &i,
                                 const RCP<const Basic> &j);
 
class LeviCivita : public MultiArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_LEVICIVITA)
    LeviCivita(const vec_basic &&arg);
    bool is_canonical(const vec_basic &arg) const;
    RCP<const Basic> create(const vec_basic &arg) const override;
};
 
RCP<const Basic> levi_civita(const vec_basic &arg);
 
class Erf : public OneArgFunction
{
    /*   The Gauss error function. This function is defined as:
     *
     *   .. math::
     *      \mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2}
     *\mathrm{d}t.
     **/
public:
    IMPLEMENT_TYPEID(SYMENGINE_ERF)
    Erf(const RCP<const Basic> &arg) : OneArgFunction(arg)
    {
        SYMENGINE_ASSIGN_TYPEID()
        SYMENGINE_ASSERT(is_canonical(arg))
    }
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> erf(const RCP<const Basic> &arg);
 
class Erfc : public OneArgFunction
{
    /*   The complementary error function. This function is defined as:
     *
     *   .. math::
     *      \mathrm{erfc}(x) = 1 - \frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2}
     *       \mathrm{d}t.
     **/
public:
    IMPLEMENT_TYPEID(SYMENGINE_ERFC)
    Erfc(const RCP<const Basic> &arg) : OneArgFunction(arg)
    {
        SYMENGINE_ASSIGN_TYPEID()
        SYMENGINE_ASSERT(is_canonical(arg))
    }
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> erfc(const RCP<const Basic> &arg);
 
class Gamma : public OneArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_GAMMA)
    Gamma(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> gamma(const RCP<const Basic> &arg);
 
class LowerGamma : public TwoArgFunction
{
public:
    using TwoArgFunction::create;
    IMPLEMENT_TYPEID(SYMENGINE_LOWERGAMMA)
    LowerGamma(const RCP<const Basic> &s, const RCP<const Basic> &x);
    bool is_canonical(const RCP<const Basic> &s,
                      const RCP<const Basic> &x) const;
    RCP<const Basic> create(const RCP<const Basic> &a,
                            const RCP<const Basic> &b) const override;
};
 
RCP<const Basic> lowergamma(const RCP<const Basic> &s,
                            const RCP<const Basic> &x);
 
class UpperGamma : public TwoArgFunction
{
public:
    using TwoArgFunction::create;
    IMPLEMENT_TYPEID(SYMENGINE_UPPERGAMMA)
    UpperGamma(const RCP<const Basic> &s, const RCP<const Basic> &x);
    bool is_canonical(const RCP<const Basic> &s,
                      const RCP<const Basic> &x) const;
    RCP<const Basic> create(const RCP<const Basic> &a,
                            const RCP<const Basic> &b) const override;
};
 
RCP<const Basic> uppergamma(const RCP<const Basic> &s,
                            const RCP<const Basic> &x);
 
class LogGamma : public OneArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_LOGGAMMA)
    LogGamma(const RCP<const Basic> &arg) : OneArgFunction(arg)
    {
        SYMENGINE_ASSIGN_TYPEID()
        SYMENGINE_ASSERT(is_canonical(arg))
    }
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> rewrite_as_gamma() const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> loggamma(const RCP<const Basic> &arg);
 
class Beta : public TwoArgFunction
{
public:
    using TwoArgFunction::create;
    IMPLEMENT_TYPEID(SYMENGINE_BETA)
    Beta(const RCP<const Basic> &x, const RCP<const Basic> &y)
        : TwoArgFunction(x, y)
    {
        SYMENGINE_ASSIGN_TYPEID()
        SYMENGINE_ASSERT(is_canonical(x, y))
    }
    static RCP<const Beta> from_two_basic(const RCP<const Basic> &x,
                                          const RCP<const Basic> &y);
    bool is_canonical(const RCP<const Basic> &s, const RCP<const Basic> &x);
    RCP<const Basic> rewrite_as_gamma() const;
    RCP<const Basic> create(const RCP<const Basic> &a,
                            const RCP<const Basic> &b) const override;
};
 
RCP<const Basic> beta(const RCP<const Basic> &x, const RCP<const Basic> &y);
 
class PolyGamma : public TwoArgFunction
{
public:
    using TwoArgFunction::create;
    IMPLEMENT_TYPEID(SYMENGINE_POLYGAMMA)
    PolyGamma(const RCP<const Basic> &n, const RCP<const Basic> &x)
        : TwoArgFunction(n, x)
    {
        SYMENGINE_ASSIGN_TYPEID()
        SYMENGINE_ASSERT(is_canonical(n, x))
    }
    bool is_canonical(const RCP<const Basic> &n, const RCP<const Basic> &x);
    RCP<const Basic> rewrite_as_zeta() const;
    RCP<const Basic> create(const RCP<const Basic> &a,
                            const RCP<const Basic> &b) const override;
};
 
RCP<const Basic> polygamma(const RCP<const Basic> &n,
                           const RCP<const Basic> &x);
 
RCP<const Basic> digamma(const RCP<const Basic> &x);
 
RCP<const Basic> trigamma(const RCP<const Basic> &x);
 
class Abs : public OneArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_ABS)
    Abs(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> abs(const RCP<const Basic> &arg);
 
class Max : public MultiArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_MAX)
    Max(const vec_basic &&arg);
    bool is_canonical(const vec_basic &arg) const;
    RCP<const Basic> create(const vec_basic &arg) const override;
};
 
RCP<const Basic> max(const vec_basic &arg);
 
class Min : public MultiArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_MIN)
    Min(const vec_basic &&arg);
    bool is_canonical(const vec_basic &arg) const;
    RCP<const Basic> create(const vec_basic &arg) const override;
};
 
RCP<const Basic> min(const vec_basic &arg);
 
RCP<const Basic> trig_to_sqrt(const RCP<const Basic> &arg);
 
class UnevaluatedExpr : public OneArgFunction
{
public:
    IMPLEMENT_TYPEID(SYMENGINE_UNEVALUATED_EXPR)
    UnevaluatedExpr(const RCP<const Basic> &arg);
    bool is_canonical(const RCP<const Basic> &arg) const;
    RCP<const Basic> create(const RCP<const Basic> &arg) const override;
};
 
RCP<const Basic> unevaluated_expr(const RCP<const Basic> &arg);
 
} // namespace SymEngine
 
#endif