/** * \file functions.h * Includes various trignometric functions * **/ #ifndef SYMENGINE_FUNCTIONS_H #define SYMENGINE_FUNCTIONS_H #include #include #include namespace SymEngine { class Function : public Basic { }; class OneArgFunction : public Function { private: RCP arg_; //! The `arg` in `OneArgFunction(arg)` public: //! Constructor OneArgFunction(const RCP &arg) : arg_{arg} {}; //! \return the hash inline hash_t __hash__() const override { hash_t seed = this->get_type_code(); hash_combine(seed, *arg_); return seed; } //! \return `arg_` inline RCP get_arg() const { return arg_; } inline vec_basic get_args() const override { return {arg_}; } //! Method to construct classes with canonicalization virtual RCP create(const RCP &arg) const = 0; inline RCP create(const vec_basic &b) const { SYMENGINE_ASSERT(b.size() == 1); return create(b[0]); } /*! Equality comparator * \param o - Object to be compared with * \return whether the 2 objects are equal * */ inline bool __eq__(const Basic &o) const override { return is_same_type(*this, o) and eq(*get_arg(), *down_cast(o).get_arg()); } //! Structural equality comparator inline int compare(const Basic &o) const override { SYMENGINE_ASSERT(is_same_type(*this, o)) return get_arg()->__cmp__( *(down_cast(o).get_arg())); } }; template class TwoArgBasic : public BaseClass { private: RCP a_; //! `a` in `TwoArgBasic(a, b)` RCP b_; //! `b` in `TwoArgBasic(a, b)` public: //! Constructor TwoArgBasic(const RCP &a, const RCP &b) : a_{a}, b_{b} {}; //! \return the hash inline hash_t __hash__() const override { hash_t seed = this->get_type_code(); hash_combine(seed, *a_); hash_combine(seed, *b_); return seed; } //! \return `arg_` inline RCP get_arg1() const { return a_; } //! \return `arg_` inline RCP get_arg2() const { return b_; } inline vec_basic get_args() const override { return {a_, b_}; } //! Method to construct classes with canonicalization virtual RCP create(const RCP &a, const RCP &b) const = 0; inline RCP create(const vec_basic &b) const { SYMENGINE_ASSERT(b.size() == 2); return create(b[0], b[1]); } /*! Equality comparator * \param o - Object to be compared with * \return whether the 2 objects are equal * */ inline bool __eq__(const Basic &o) const override { return is_same_type(*this, o) and eq(*get_arg1(), *down_cast(o).get_arg1()) and eq(*get_arg2(), *down_cast(o).get_arg2()); } //! Structural equality comparator inline int compare(const Basic &o) const override { SYMENGINE_ASSERT(is_same_type(*this, o)) const TwoArgBasic &t = down_cast(o); if (neq(*get_arg1(), *(t.get_arg1()))) { return get_arg1()->__cmp__( *(down_cast(o).get_arg1())); } else { return get_arg2()->__cmp__( *(down_cast(o).get_arg2())); } } }; typedef TwoArgBasic TwoArgFunction; class MultiArgFunction : public Function { private: vec_basic arg_; public: //! Constructor MultiArgFunction(const vec_basic &arg) : arg_{arg} {}; //! \return the hash inline hash_t __hash__() const override { hash_t seed = this->get_type_code(); for (const auto &a : arg_) hash_combine(seed, *a); return seed; } inline vec_basic get_args() const override { return arg_; } inline const vec_basic &get_vec() const { return arg_; } //! Method to construct classes with canonicalization virtual RCP create(const vec_basic &v) const = 0; /*! Equality comparator * \param o - Object to be compared with * \return whether the 2 objects are equal * */ inline bool __eq__(const Basic &o) const override { return is_same_type(*this, o) and unified_eq(get_vec(), down_cast(o).get_vec()); } //! Structural equality comparator inline int compare(const Basic &o) const override { SYMENGINE_ASSERT(is_same_type(*this, o)) return unified_compare( get_vec(), down_cast(o).get_vec()); } }; class Sign : public OneArgFunction { public: IMPLEMENT_TYPEID(SYMENGINE_SIGN) //! Sign constructor Sign(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized sign RCP create(const RCP &arg) const override; }; //! Canonicalize Sign RCP sign(const RCP &arg); class Floor : public OneArgFunction { public: IMPLEMENT_TYPEID(SYMENGINE_FLOOR) //! Floor Constructor Floor(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized floor RCP create(const RCP &arg) const override; }; //! Canonicalize Floor: RCP floor(const RCP &arg); class Ceiling : public OneArgFunction { public: IMPLEMENT_TYPEID(SYMENGINE_CEILING) //! Ceiling Constructor Ceiling(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized ceiling RCP create(const RCP &arg) const override; }; //! Canonicalize Ceiling: RCP ceiling(const RCP &arg); class Truncate : public OneArgFunction { public: IMPLEMENT_TYPEID(SYMENGINE_TRUNCATE) //! Truncate Constructor Truncate(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized truncate RCP create(const RCP &arg) const override; }; //! Canonicalize Truncate: RCP truncate(const RCP &arg); class Conjugate : public OneArgFunction { public: IMPLEMENT_TYPEID(SYMENGINE_CONJUGATE) //! Conjugate constructor Conjugate(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized conjugate RCP create(const RCP &arg) const override; }; //! Canonicalize Conjugate RCP conjugate(const RCP &arg); class TrigBase : public OneArgFunction { public: //! Constructor TrigBase(RCP arg) : OneArgFunction(arg){}; }; class TrigFunction : public TrigBase { public: //! Constructor TrigFunction(RCP arg) : TrigBase(arg){}; }; class InverseTrigFunction : public TrigBase { public: //! Constructor InverseTrigFunction(RCP arg) : TrigBase(arg){}; }; /*! \return `true` if `arg` is of form `m + n*pi` where `n` is a rational * */ bool get_pi_shift(const RCP &arg, const Ptr> &n, const Ptr> &m); //! \return `true` if `arg` contains a negative sign. bool could_extract_minus(const Basic &arg); bool handle_minus(const RCP &arg, const Ptr> &rarg); /*! returns `true` if the given argument `t` is found in the * lookup table `d`. It also returns the value in `index` **/ bool inverse_lookup(const umap_basic_basic &d, const RCP &t, const Ptr> &index); // \return true of conjugate has to be returned finally else false bool trig_simplify(const RCP &arg, unsigned period, bool odd, bool conj_odd, // input const Ptr> &rarg, int &index, int &sign); // output //! \return `sqrt` of the `arg` RCP sqrt(const RCP &arg); //! \return `cbrt` of the `arg` RCP cbrt(const RCP &arg); class Sin : public TrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_SIN) //! Sin Constructor Sin(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized sin RCP create(const RCP &arg) const override; }; //! Canonicalize Sin: RCP sin(const RCP &arg); class Cos : public TrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_COS) //! Cos Constructor Cos(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized cos RCP create(const RCP &arg) const override; }; //! Canonicalize Cos: RCP cos(const RCP &arg); class Tan : public TrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_TAN) //! Tan Constructor Tan(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized tan RCP create(const RCP &arg) const override; }; //! Canonicalize Tan: RCP tan(const RCP &arg); class Cot : public TrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_COT) //! Cot Constructor Cot(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized cot RCP create(const RCP &arg) const override; }; //! Canonicalize Cot: RCP cot(const RCP &arg); class Csc : public TrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_CSC) //! Csc Constructor Csc(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized csc RCP create(const RCP &arg) const override; }; //! Canonicalize Csc: RCP csc(const RCP &arg); class Sec : public TrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_SEC) //! Sec Constructor Sec(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized sec RCP create(const RCP &arg) const override; }; //! Canonicalize Sec: RCP sec(const RCP &arg); class ASin : public InverseTrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_ASIN) //! ASin Constructor ASin(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized asin RCP create(const RCP &arg) const override; }; //! Canonicalize ASin: RCP asin(const RCP &arg); class ACos : public InverseTrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_ACOS) //! ACos Constructor ACos(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized acos RCP create(const RCP &arg) const override; }; //! Canonicalize ACos: RCP acos(const RCP &arg); class ASec : public InverseTrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_ASEC) //! ASec Constructor ASec(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized asec RCP create(const RCP &arg) const override; }; //! Canonicalize ASec: RCP asec(const RCP &arg); class ACsc : public InverseTrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_ACSC) //! ACsc Constructor ACsc(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized acsc RCP create(const RCP &arg) const override; }; //! Canonicalize ACsc: RCP acsc(const RCP &arg); class ATan : public InverseTrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_ATAN) //! ATan Constructor ATan(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized atan RCP create(const RCP &arg) const override; }; //! Canonicalize ATan: RCP atan(const RCP &arg); class ACot : public InverseTrigFunction { public: IMPLEMENT_TYPEID(SYMENGINE_ACOT) //! ACot Constructor ACot(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized acot RCP create(const RCP &arg) const override; }; //! Canonicalize ACot: RCP acot(const RCP &arg); class ATan2 : public TwoArgFunction { public: IMPLEMENT_TYPEID(SYMENGINE_ATAN2) //! ATan2 Constructor ATan2(const RCP &num, const RCP &den); //! \return `true` if canonical bool is_canonical(const RCP &num, const RCP &den) const; //! \return `y` in `atan2(y, x)` inline RCP get_num() const { return get_arg1(); } //! \return `x` in `atan2(y, x)` inline RCP get_den() const { return get_arg2(); } //! \return canonicalized `atan2` RCP create(const RCP &a, const RCP &b) const override; }; //! Canonicalize ATan2: RCP atan2(const RCP &num, const RCP &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 Constructor Log(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return canonicalized `log` RCP create(const RCP &arg) const override; }; //! Returns the Natural Logarithm from argument `arg` RCP log(const RCP &arg); //! \return Log from argument `arg` wrt base `b` RCP log(const RCP &arg, const RCP &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 Constructor LambertW(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return canonicalized lambertw RCP create(const RCP &arg) const override; }; //! Create a new LambertW instance: RCP lambertw(const RCP &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 Constructor Zeta(const RCP &s, const RCP &a); //! Zeta Constructor Zeta(const RCP &s); //! \return `s_` inline RCP get_s() const { return get_arg1(); } //! \return `a_` inline RCP get_a() const { return get_arg2(); } //! \return `true` if canonical bool is_canonical(const RCP &s, const RCP &a) const; //! \return canonicalized `zeta` RCP create(const RCP &a, const RCP &b) const override; }; //! Create a new Zeta instance: RCP zeta(const RCP &s, const RCP &a); RCP zeta(const RCP &s); class Dirichlet_eta : public OneArgFunction { // See http://en.wikipedia.org/wiki/Dirichlet_eta_function public: IMPLEMENT_TYPEID(SYMENGINE_DIRICHLET_ETA) //! Dirichlet_eta Constructor Dirichlet_eta(const RCP &s); //! \return `s` inline RCP get_s() const { return get_arg(); } //! \return `true` if canonical bool is_canonical(const RCP &s) const; //! Rewrites in the form of zeta RCP rewrite_as_zeta() const; //! \return Canonicalized zeta RCP create(const RCP &arg) const override; using OneArgFunction::create; }; //! Create a new Dirichlet_eta instance: RCP dirichlet_eta(const RCP &s); class FunctionSymbol : public MultiArgFunction { protected: std::string name_; //! The `f` in `f(x+y, z)` public: IMPLEMENT_TYPEID(SYMENGINE_FUNCTIONSYMBOL) //! FunctionSymbol Constructors FunctionSymbol(std::string name, const vec_basic &arg); FunctionSymbol(std::string name, const RCP &arg); //! \return Size of the hash hash_t __hash__() const override; /*! Equality comparator * \param o Object to be compared with * \return whether the 2 objects are equal * */ bool __eq__(const Basic &o) const override; int compare(const Basic &o) const override; //! \return `name_` inline const std::string &get_name() const { return name_; } //! \return `true` if canonical bool is_canonical(const vec_basic &arg) const; RCP create(const vec_basic &x) const override; }; //! Create a new FunctionSymbol instance: RCP function_symbol(std::string name, const RCP &arg); RCP function_symbol(std::string name, const vec_basic &arg); /*! Use this class to define custom functions by overriding * the defaut behaviour for create, eval, diff, __eq__, compare etc. * */ class FunctionWrapper : public FunctionSymbol { public: IMPLEMENT_TYPEID(SYMENGINE_FUNCTIONWRAPPER) FunctionWrapper(std::string name, const vec_basic &arg); FunctionWrapper(std::string name, const RCP &arg); RCP create(const vec_basic &v) const override = 0; virtual RCP eval(long bits) const = 0; virtual RCP diff_impl(const RCP &s) const = 0; }; /*! Derivative operator * Derivative(f, [x, y, ...]) represents a derivative of `f` with respect to * `x`, `y`, and so on. * */ class Derivative : public Basic { private: RCP arg_; //! The expression to be differentiated // The symbols are declared as Basic (and checked by is_canonical() below), // to avoid issues with converting vector> to // vector>, see [1], [2]. The problem is that even though Symbol // inherits from Basic, vector> does not inherit from // vector>, 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>. // [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_; //! x, y, ... public: IMPLEMENT_TYPEID(SYMENGINE_DERIVATIVE) Derivative(const RCP &arg, const multiset_basic &x); static RCP create(const RCP &arg, const multiset_basic &x) { return make_rcp(arg, x); } hash_t __hash__() const override; bool __eq__(const Basic &o) const override; int compare(const Basic &o) const override; inline RCP 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 &arg, const multiset_basic &x) const; }; /*! Subs operator * Subs(f, {x1 : x2, y1: y2, ...}) represents `f` after substituting * `x1` with `x2`, `y1` with `y2`, and so on. * */ class Subs : public Basic { private: RCP arg_; map_basic_basic dict_; public: IMPLEMENT_TYPEID(SYMENGINE_SUBS) Subs(const RCP &arg, const map_basic_basic &x); static RCP create(const RCP &arg, const map_basic_basic &x) { return make_rcp(arg, x); } hash_t __hash__() const override; bool __eq__(const Basic &o) const override; int compare(const Basic &o) const override; inline const RCP &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 &arg, const map_basic_basic &x) const; }; class HyperbolicBase : public OneArgFunction { public: //! Constructor HyperbolicBase(RCP arg) : OneArgFunction{arg} {}; }; class HyperbolicFunction : public HyperbolicBase { public: //! Constructor HyperbolicFunction(RCP arg) : HyperbolicBase{arg} {}; }; class InverseHyperbolicFunction : public HyperbolicBase { public: //! Constructor InverseHyperbolicFunction(RCP arg) : HyperbolicBase{arg} {}; }; class Sinh : public HyperbolicFunction { //! The hyperbolic sine function, `\frac{e^x - e^{-x}}{2}`. public: IMPLEMENT_TYPEID(SYMENGINE_SINH) //! Sinh Constructor Sinh(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized sinh RCP create(const RCP &arg) const override; }; //! Canonicalize Sinh: RCP sinh(const RCP &arg); class Csch : public HyperbolicFunction { //! The hyperbolic cosecant function, `\frac{2}{e^x - e^{-x}}`. public: IMPLEMENT_TYPEID(SYMENGINE_CSCH) //! Csch Constructor Csch(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized csch RCP create(const RCP &arg) const override; }; //! Canonicalize Csch: RCP csch(const RCP &arg); class Cosh : public HyperbolicFunction { //! The hyperbolic cosine function, `\frac{e^x + e^{-x}}{2}`. public: IMPLEMENT_TYPEID(SYMENGINE_COSH) //! Cosh Constructor Cosh(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized cosh RCP create(const RCP &arg) const override; }; //! Canonicalize Cosh: RCP cosh(const RCP &arg); class Sech : public HyperbolicFunction { //! The hyperbolic secant function, `\frac{2}{e^x + e^{-x}}`. public: IMPLEMENT_TYPEID(SYMENGINE_SECH) //! Sech Constructor Sech(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized sech RCP create(const RCP &arg) const override; }; //! Canonicalize Sech: RCP sech(const RCP &arg); class Tanh : public HyperbolicFunction { //! The hyperbolic tangent function, `\frac{\sinh(x)}{\cosh(x)}`. public: IMPLEMENT_TYPEID(SYMENGINE_TANH) //! Tanh Constructor Tanh(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized tanh RCP create(const RCP &arg) const override; }; //! Canonicalize Tanh: RCP tanh(const RCP &arg); class Coth : public HyperbolicFunction { //! The hyperbolic tangent function, `\frac{\cosh(x)}{\sinh(x)}`. public: IMPLEMENT_TYPEID(SYMENGINE_COTH) //! Coth Constructor Coth(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized coth RCP create(const RCP &arg) const override; }; //! Canonicalize Coth: RCP coth(const RCP &arg); class ASinh : public InverseHyperbolicFunction { //! The inverse hyperbolic sine function. public: IMPLEMENT_TYPEID(SYMENGINE_ASINH) //! ASinh Constructor ASinh(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized asinh RCP create(const RCP &arg) const override; }; //! Canonicalize ASinh: RCP asinh(const RCP &arg); class ACsch : public InverseHyperbolicFunction { //! The inverse hyperbolic cosecant function. public: IMPLEMENT_TYPEID(SYMENGINE_ACSCH) //! ACsch Constructor ACsch(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized acsch RCP create(const RCP &arg) const override; }; //! Canonicalize ACsch: RCP acsch(const RCP &arg); class ACosh : public InverseHyperbolicFunction { //! The inverse hyperbolic cosine function. public: IMPLEMENT_TYPEID(SYMENGINE_ACOSH) //! ACosh Constructor ACosh(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized acosh RCP create(const RCP &arg) const override; }; //! Canonicalize ACosh: RCP acosh(const RCP &arg); class ATanh : public InverseHyperbolicFunction { //! The inverse hyperbolic tangent function. public: IMPLEMENT_TYPEID(SYMENGINE_ATANH) //! ATanh Constructor ATanh(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized atanh RCP create(const RCP &arg) const override; }; //! Canonicalize ATanh: RCP atanh(const RCP &arg); class ACoth : public InverseHyperbolicFunction { //! The inverse hyperbolic cotangent function. public: IMPLEMENT_TYPEID(SYMENGINE_ACOTH) //! ACoth Constructor ACoth(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized acoth RCP create(const RCP &arg) const override; }; //! Canonicalize ACoth: RCP acoth(const RCP &arg); class ASech : public InverseHyperbolicFunction { //! The inverse hyperbolic secant function. public: IMPLEMENT_TYPEID(SYMENGINE_ASECH) //! ASech Constructor ASech(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized asech RCP create(const RCP &arg) const override; }; //! Canonicalize ASech: RCP asech(const RCP &arg); class KroneckerDelta : public TwoArgFunction { /*! The discrete, or Kronecker, delta function. * A function that takes in two integers `i` and `j`. It returns `0` if `i` *and `j` are * not equal or it returns `1` if `i` and `j` are equal. * http://en.wikipedia.org/wiki/Kronecker_delta **/ public: using TwoArgFunction::create; IMPLEMENT_TYPEID(SYMENGINE_KRONECKERDELTA) //! KroneckerDelta Constructor KroneckerDelta(const RCP &i, const RCP &j); //! \return `true` if canonical bool is_canonical(const RCP &i, const RCP &j) const; //! \return canonicalized `KroneckerDelta` RCP create(const RCP &a, const RCP &b) const override; }; //! Canonicalize KroneckerDelta: RCP kronecker_delta(const RCP &i, const RCP &j); class LeviCivita : public MultiArgFunction { /*! Represent the Levi-Civita symbol. * For even permutations of indices it returns 1, for odd permutations -1, *and * for everything else (a repeated index) it returns 0. * * Thus it represents an alternating pseudotensor. **/ public: IMPLEMENT_TYPEID(SYMENGINE_LEVICIVITA) //! LeviCivita Constructor LeviCivita(const vec_basic &&arg); //! \return `true` if canonical bool is_canonical(const vec_basic &arg) const; //! \return canonicalized Max RCP create(const vec_basic &arg) const override; }; //! Canonicalize LeviCivita: RCP 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 Constructor Erf(const RCP &arg) : OneArgFunction(arg) { SYMENGINE_ASSIGN_TYPEID() SYMENGINE_ASSERT(is_canonical(arg)) } //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized erf RCP create(const RCP &arg) const override; }; //! Canonicalize Erf: RCP erf(const RCP &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 Constructor Erfc(const RCP &arg) : OneArgFunction(arg) { SYMENGINE_ASSIGN_TYPEID() SYMENGINE_ASSERT(is_canonical(arg)) } //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized erfc RCP create(const RCP &arg) const override; }; //! Canonicalize Erfc: RCP erfc(const RCP &arg); class Gamma : public OneArgFunction { /*! The gamma function * * .. math:: * \Gamma(x) := \int^{\infty}_{0} t^{x-1} e^{t} \mathrm{d}t. * * The ``gamma`` function implements the function which passes through the * values of the factorial function, i.e. `\Gamma(n) = (n - 1)!` when n is * an integer. More general, `\Gamma(z)` is defined in the whole complex * plane except at the negative integers where there are simple poles. **/ public: IMPLEMENT_TYPEID(SYMENGINE_GAMMA) //! Gamma Constructor Gamma(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return Canonicalized gamma RCP create(const RCP &arg) const override; }; //! Canonicalize Gamma: RCP gamma(const RCP &arg); class LowerGamma : public TwoArgFunction { //! The lower incomplete gamma function. public: using TwoArgFunction::create; IMPLEMENT_TYPEID(SYMENGINE_LOWERGAMMA) //! LowerGamma Constructor LowerGamma(const RCP &s, const RCP &x); //! \return `true` if canonical bool is_canonical(const RCP &s, const RCP &x) const; //! \return canonicalized `LowerGamma` RCP create(const RCP &a, const RCP &b) const override; }; //! Canonicalize LowerGamma: RCP lowergamma(const RCP &s, const RCP &x); class UpperGamma : public TwoArgFunction { //! The upper incomplete gamma function. public: using TwoArgFunction::create; IMPLEMENT_TYPEID(SYMENGINE_UPPERGAMMA) //! UpperGamma Constructor UpperGamma(const RCP &s, const RCP &x); //! \return `true` if canonical bool is_canonical(const RCP &s, const RCP &x) const; //! \return canonicalized `UpperGamma` RCP create(const RCP &a, const RCP &b) const override; }; //! Canonicalize UpperGamma: RCP uppergamma(const RCP &s, const RCP &x); class LogGamma : public OneArgFunction { /*! The loggamma function The `loggamma` function implements the logarithm of the gamma function i.e, `\log\Gamma(x)`. **/ public: IMPLEMENT_TYPEID(SYMENGINE_LOGGAMMA) //! LogGamma Constructor LogGamma(const RCP &arg) : OneArgFunction(arg) { SYMENGINE_ASSIGN_TYPEID() SYMENGINE_ASSERT(is_canonical(arg)) } //! \return `true` if canonical bool is_canonical(const RCP &arg) const; RCP rewrite_as_gamma() const; //! \return canonicalized loggamma RCP create(const RCP &arg) const override; }; //! Canonicalize LogGamma: RCP loggamma(const RCP &arg); class Beta : public TwoArgFunction { /*! The beta function, also called the Euler integral * of the first kind, is a special function defined by * * .. math:: * \Beta(x, y) := \int^{1}_{0} t^{x-1} (1-t)^{y-1} \mathrm{d}t. **/ public: using TwoArgFunction::create; IMPLEMENT_TYPEID(SYMENGINE_BETA) //! Beta Constructor Beta(const RCP &x, const RCP &y) : TwoArgFunction(x, y) { SYMENGINE_ASSIGN_TYPEID() SYMENGINE_ASSERT(is_canonical(x, y)) } //! return `Beta` with ordered arguments static RCP from_two_basic(const RCP &x, const RCP &y); //! \return `true` if canonical bool is_canonical(const RCP &s, const RCP &x); RCP rewrite_as_gamma() const; //! \return canonicalized `Beta` RCP create(const RCP &a, const RCP &b) const override; }; //! Canonicalize Beta: RCP beta(const RCP &x, const RCP &y); class PolyGamma : public TwoArgFunction { /*! The polygamma function * * It is a meromorphic function on `\mathbb{C}` and defined as the *(n+1)-th * derivative of the logarithm of the gamma function: * * .. math:: * \psi^{(n)} (z) := \frac{\mathrm{d}^{n+1}}{\mathrm{d} z^{n+1}} *\log\Gamma(z). **/ public: using TwoArgFunction::create; IMPLEMENT_TYPEID(SYMENGINE_POLYGAMMA) //! PolyGamma Constructor PolyGamma(const RCP &n, const RCP &x) : TwoArgFunction(n, x) { SYMENGINE_ASSIGN_TYPEID() SYMENGINE_ASSERT(is_canonical(n, x)) } bool is_canonical(const RCP &n, const RCP &x); RCP rewrite_as_zeta() const; //! \return canonicalized `PolyGamma` RCP create(const RCP &a, const RCP &b) const override; }; //! Canonicalize PolyGamma RCP polygamma(const RCP &n, const RCP &x); RCP digamma(const RCP &x); RCP trigamma(const RCP &x); class Abs : public OneArgFunction { /*! The absolute value function **/ public: IMPLEMENT_TYPEID(SYMENGINE_ABS) //! Abs Constructor Abs(const RCP &arg); //! \return `true` if canonical bool is_canonical(const RCP &arg) const; //! \return canonicalized abs RCP create(const RCP &arg) const override; }; //! Canonicalize Abs: RCP abs(const RCP &arg); class Max : public MultiArgFunction { public: IMPLEMENT_TYPEID(SYMENGINE_MAX) //! Max Constructor Max(const vec_basic &&arg); //! \return `true` if canonical bool is_canonical(const vec_basic &arg) const; //! \return canonicalized Max RCP create(const vec_basic &arg) const override; }; //! Canonicalize Max: RCP