Wrappers to makeExpr

include/fintamath/functions/FunctionUtils.hpp

@@ -7,6 +7,13 @@
 #include "fintamath/functions/FunctionArguments.hpp"
 #include "fintamath/parser/Parser.hpp"
 
+#define FINTAMATH_FUNCTION_EXPRESSION(Function, name) \
+  template <typename... Args>                         \
+  std::unique_ptr<IMathObject> name(Args &&...args) { \
+    static const Function f;                          \
+    return makeExpr(f, std::forward<Args>(args)...);  \
+  }
+
 namespace fintamath {
 
 class IFunction;

include/fintamath/functions/arithmetic/Abs.hpp

@@ -24,4 +24,6 @@ class Abs : public IFunctionCRTP<INumber, Abs, INumber> {
   static std::unique_ptr<IMathObject> multiAbsSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Abs, absExpr);
+
 }

include/fintamath/functions/arithmetic/Add.hpp

@@ -22,4 +22,6 @@ class Add : public IOperatorCRTP<IArithmetic, Add, IArithmetic, IArithmetic> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Add, addExpr);
+
 }

include/fintamath/functions/arithmetic/Div.hpp

@@ -30,4 +30,6 @@ class Div : public IOperatorCRTP<IArithmetic, Div, IArithmetic, IArithmetic> {
   static std::unique_ptr<IMathObject> divSimplify(const Integer &lhs, const Integer &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Div, divExpr);
+
 }

include/fintamath/functions/arithmetic/Mul.hpp

@@ -22,4 +22,6 @@ class Mul : public IOperatorCRTP<IArithmetic, Mul, IArithmetic, IArithmetic> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Mul, mulExpr);
+
 }

include/fintamath/functions/arithmetic/Neg.hpp

@@ -22,4 +22,6 @@ class Neg : public IOperatorCRTP<IArithmetic, Neg, IArithmetic> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Neg, negExpr);
+
 }

include/fintamath/functions/arithmetic/Sign.hpp

@@ -24,4 +24,6 @@ class Sign : public IFunctionCRTP<INumber, Sign, INumber> {
   static std::unique_ptr<IMathObject> multiSignSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Sign, signExpr);
+
 }

include/fintamath/functions/arithmetic/Sub.hpp

@@ -22,4 +22,6 @@ class Sub : public IOperatorCRTP<IArithmetic, Sub, IArithmetic, IArithmetic> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Sub, subExpr);
+
 }

include/fintamath/functions/calculus/Derivative.hpp

@@ -23,4 +23,6 @@ class Derivative : public IFunctionCRTP<IComparable, Derivative, IComparable, IC
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Derivative, derivativeExpr);
+
 }

include/fintamath/functions/calculus/Integral.hpp

@@ -23,4 +23,6 @@ class Integral : public IFunctionCRTP<IComparable, Integral, IComparable, ICompa
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Integral, integralExpr);
+
 }

include/fintamath/functions/calculus/Max.hpp

@@ -24,4 +24,6 @@ class Max : public IFunctionCRTP<IComparable, Max, IComparable> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Max, maxExpr);
+
 }

include/fintamath/functions/calculus/Min.hpp

@@ -24,4 +24,6 @@ class Min : public IFunctionCRTP<IComparable, Min, IComparable> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Min, minExpr);
+
 }

include/fintamath/functions/comparison/Eqv.hpp

@@ -23,4 +23,6 @@ class Eqv : public IOperatorCRTP<Boolean, Eqv, IComparable, IComparable> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Eqv, eqvExpr);
+
 }

include/fintamath/functions/comparison/Less.hpp

@@ -23,4 +23,6 @@ class Less : public IOperatorCRTP<Boolean, Less, IComparable, IComparable> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Less, lessExpr);
+
 }

include/fintamath/functions/comparison/LessEqv.hpp

@@ -23,4 +23,6 @@ class LessEqv : public IOperatorCRTP<Boolean, LessEqv, IComparable, IComparable>
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(LessEqv, lessEqvExpr);
+
 }

include/fintamath/functions/comparison/More.hpp

@@ -23,4 +23,6 @@ class More : public IOperatorCRTP<Boolean, More, IComparable, IComparable> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(More, moreExpr);
+
 }

include/fintamath/functions/comparison/MoreEqv.hpp

@@ -23,4 +23,6 @@ class MoreEqv : public IOperatorCRTP<Boolean, MoreEqv, IComparable, IComparable>
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(MoreEqv, moreEqvExpr);
+
 }

include/fintamath/functions/comparison/Neqv.hpp

@@ -23,4 +23,6 @@ class Neqv : public IOperatorCRTP<Boolean, Neqv, IComparable, IComparable> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Neqv, neqvExpr);
+
 }

include/fintamath/functions/hyperbolic/Acosh.hpp

@@ -28,4 +28,6 @@ class Acosh : public IFunctionCRTP<INumber, Acosh, INumber> {
   static std::unique_ptr<IMathObject> acoshSimplify(const Real &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Acosh, acoshExpr);
+
 }

include/fintamath/functions/hyperbolic/Acoth.hpp

@@ -28,4 +28,6 @@ class Acoth : public IFunctionCRTP<INumber, Acoth, INumber> {
   static std::unique_ptr<IMathObject> acothSimplify(const Real &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Acoth, acothExpr);
+
 }

include/fintamath/functions/hyperbolic/Asinh.hpp

@@ -24,4 +24,6 @@ class Asinh : public IFunctionCRTP<INumber, Asinh, INumber> {
   static std::unique_ptr<IMathObject> multiAsinhSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Asinh, asinhExpr);
+
 }

include/fintamath/functions/hyperbolic/Atanh.hpp

@@ -28,4 +28,6 @@ class Atanh : public IFunctionCRTP<INumber, Atanh, INumber> {
   static std::unique_ptr<IMathObject> atanhSimplify(const Real &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Atanh, atanhExpr);
+
 }

include/fintamath/functions/hyperbolic/Cosh.hpp

@@ -24,4 +24,6 @@ class Cosh : public IFunctionCRTP<INumber, Cosh, INumber> {
   static std::unique_ptr<IMathObject> multiCoshSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Cosh, coshExpr);
+
 }

include/fintamath/functions/hyperbolic/Coth.hpp

@@ -24,4 +24,6 @@ class Coth : public IFunctionCRTP<INumber, Coth, INumber> {
   static std::unique_ptr<IMathObject> multiCothSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Coth, cothExpr);
+
 }

include/fintamath/functions/hyperbolic/Sinh.hpp

@@ -24,4 +24,6 @@ class Sinh : public IFunctionCRTP<INumber, Sinh, INumber> {
   static std::unique_ptr<IMathObject> multiSinhSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Sinh, sinhExpr);
+
 }

include/fintamath/functions/hyperbolic/Tanh.hpp

@@ -24,4 +24,6 @@ class Tanh : public IFunctionCRTP<INumber, Tanh, INumber> {
   static std::unique_ptr<IMathObject> multiTanhSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Tanh, tanhExpr);
+
 }

include/fintamath/functions/logarithms/Lb.hpp

@@ -21,4 +21,6 @@ class Lb : public IFunctionCRTP<INumber, Lb, INumber> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Lb, lbExpr);
+
 }

include/fintamath/functions/logarithms/Lg.hpp

@@ -21,4 +21,6 @@ class Lg : public IFunctionCRTP<INumber, Lg, INumber> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Lg, lgExpr);
+
 }

include/fintamath/functions/logarithms/Ln.hpp

@@ -24,4 +24,6 @@ class Ln : public IFunctionCRTP<INumber, Ln, INumber> {
   static std::unique_ptr<IMathObject> multiLnSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Ln, lnExpr);
+
 }

include/fintamath/functions/logarithms/Log.hpp

@@ -32,4 +32,6 @@ class Log : public IFunctionCRTP<INumber, Log, INumber, INumber> {
   static std::unique_ptr<IMathObject> logSimplify(const Real &lhs, const Real &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Log, logExpr);
+
 }

include/fintamath/functions/logic/And.hpp

@@ -22,4 +22,6 @@ class And : public IOperatorCRTP<Boolean, And, Boolean, Boolean> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(And, andExpr);
+
 }

include/fintamath/functions/logic/Equiv.hpp

@@ -22,4 +22,6 @@ class Equiv : public IOperatorCRTP<Boolean, Equiv, Boolean, Boolean> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Equiv, equivExpr);
+
 }

include/fintamath/functions/logic/Impl.hpp

@@ -22,4 +22,6 @@ class Impl : public IOperatorCRTP<Boolean, Impl, Boolean, Boolean> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Impl, implExpr);
+
 }

include/fintamath/functions/logic/Nequiv.hpp

@@ -22,4 +22,6 @@ class Nequiv : public IOperatorCRTP<Boolean, Nequiv, Boolean, Boolean> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Nequiv, nequivExpr);
+
 }

include/fintamath/functions/logic/Not.hpp

@@ -22,4 +22,6 @@ class Not : public IOperatorCRTP<Boolean, Not, Boolean> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Not, notExpr);
+
 }

include/fintamath/functions/logic/Or.hpp

@@ -22,4 +22,6 @@ class Or : public IOperatorCRTP<Boolean, Or, Boolean, Boolean> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Or, orExpr);
+
 }

include/fintamath/functions/other/Deg.hpp

@@ -22,4 +22,6 @@ class Deg : public IOperatorCRTP<INumber, Deg, INumber> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Deg, degExpr);
+
 }

include/fintamath/functions/other/Factorial.hpp

@@ -49,4 +49,6 @@ class Factorial : public IOperatorCRTP<INumber, Factorial, INumber> {
   size_t order = 1;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Factorial, factorialExpr);
+
 }

include/fintamath/functions/other/Index.hpp

@@ -24,4 +24,6 @@ class Index : public IOperatorCRTP<Variable, Index, Variable, Integer> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Index, indexExpr);
+
 }

include/fintamath/functions/other/Percent.hpp

@@ -22,4 +22,6 @@ class Percent : public IOperatorCRTP<INumber, Percent, INumber> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Percent, percentExpr);
+
 }

include/fintamath/functions/powers/Exp.hpp

@@ -21,4 +21,6 @@ class Exp : public IFunctionCRTP<INumber, Exp, INumber> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Exp, expExpr);
+
 }

include/fintamath/functions/powers/Pow.hpp

@@ -35,4 +35,6 @@ class Pow : public IOperatorCRTP<INumber, Pow, INumber, INumber> {
   static std::unique_ptr<IMathObject> powSimplify(const Real &lhs, const Real &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Pow, powExpr);
+
 }

include/fintamath/functions/powers/Root.hpp

@@ -38,4 +38,6 @@ class Root : public IFunctionCRTP<INumber, Root, INumber, INumber> {
   static std::unique_ptr<IMathObject> perfectRoot(const Integer &lhs, const Integer &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Root, rootExpr);
+
 }

include/fintamath/functions/powers/Sqrt.hpp

@@ -21,4 +21,6 @@ class Sqrt : public IFunctionCRTP<INumber, Sqrt, INumber> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Sqrt, sqrtExpr);
+
 }

include/fintamath/functions/trigonometry/Acos.hpp

@@ -28,4 +28,6 @@ class Acos : public IFunctionCRTP<INumber, Acos, INumber> {
   static std::unique_ptr<IMathObject> acosSimplify(const Real &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Acos, acosExpr);
+
 }

include/fintamath/functions/trigonometry/Acot.hpp

@@ -24,4 +24,6 @@ class Acot : public IFunctionCRTP<INumber, Acot, INumber> {
   static std::unique_ptr<IMathObject> multiAcotSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Acot, acotExpr);
+
 }

include/fintamath/functions/trigonometry/Asin.hpp

@@ -28,4 +28,6 @@ class Asin : public IFunctionCRTP<INumber, Asin, INumber> {
   static std::unique_ptr<IMathObject> asinSimplify(const Real &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Asin, asinExpr);
+
 }

include/fintamath/functions/trigonometry/Atan.hpp

@@ -24,4 +24,6 @@ class Atan : public IFunctionCRTP<INumber, Atan, INumber> {
   static std::unique_ptr<IMathObject> multiAtanSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Atan, atanExpr);
+
 }

include/fintamath/functions/trigonometry/Cos.hpp

@@ -24,4 +24,9 @@ class Cos : public IFunctionCRTP<INumber, Cos, INumber> {
   static std::unique_ptr<IMathObject> multiCosSimplify(const INumber &rhs);
 };
 
+template <typename... Args>
+std ::unique_ptr<IMathObject> cosExpr(Args &&...args) {
+  static const Cos f;
+  return makeExpr(f, std ::forward<Args>(args)...);
+};
 }

include/fintamath/functions/trigonometry/Cot.hpp

@@ -24,4 +24,6 @@ class Cot : public IFunctionCRTP<INumber, Cot, INumber> {
   static std::unique_ptr<IMathObject> multiCotSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Cot, cotExpr);
+
 }

include/fintamath/functions/trigonometry/Sin.hpp

@@ -24,4 +24,6 @@ class Sin : public IFunctionCRTP<INumber, Sin, INumber> {
   static std::unique_ptr<IMathObject> multiSinSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Sin, sinExpr);
+
 }

include/fintamath/functions/trigonometry/Tan.hpp

@@ -24,4 +24,6 @@ class Tan : public IFunctionCRTP<INumber, Tan, INumber> {
   static std::unique_ptr<IMathObject> multiTanSimplify(const INumber &rhs);
 };
 
+FINTAMATH_FUNCTION_EXPRESSION(Tan, tanExpr);
+
 }

include/fintamath/parser/Parser.hpp

@@ -32,15 +32,15 @@ class Parser {
       return std::make_unique<Type>(args...);
     };
 
-    std::string name = std::make_unique<Type>()->toString();
+    static const std::string name = Type().toString();
     parserMap.insert({name, constructor});
 
     Tokenizer::registerToken(name);
   }
 
   template <typename Type, typename BasePtr, typename... Args>
   static void add(Map<BasePtr, Args...> &parserMap, Function<BasePtr, Args...> &&parserFunc) {
-    std::string name = std::make_unique<Type>()->toString();
+    static const std::string name = Type().toString();
     parserMap.insert({name, std::move(parserFunc)});
 
     Tokenizer::registerToken(name);