Add new functions and rework operators

include/fintamath/core/MathObjectType.hpp

@@ -79,6 +79,9 @@ struct MathObjectType final {
 
     IFunction = 11000,
 
+    Add,
+    Mul,
+    Pow,
     Abs,
     Log,
     Ln,
@@ -119,37 +122,37 @@ struct MathObjectType final {
     Integral,
     Frac,
     FracMixed,
-    PowFunction,
     Floor,
     Ceil,
+    And,
+    Or,
 
     IOperator = 12000,
-
-    Add,
+    AddOper,
+    UnaryPlus,
     Sub,
-    Mul,
-    Div,
     Neg,
-    UnaryPlus,
+    MulOper,
+    Div,
+    Mod,
+    PowOper,
     Factorial,
     Percent,
-    Pow,
+    Deg,
+    Index,
+    Comma,
     Eqv,
     Neqv,
     Less,
     More,
     LessEqv,
     MoreEqv,
     Not,
-    And,
-    Or,
+    AndOper,
+    OrOper,
     Impl,
     Equiv,
     Nequiv,
-    Index,
-    Deg,
-    Comma,
-    Mod,
 
     None = std::numeric_limits<size_t>::max(),
   };

include/fintamath/expressions/ExpressionUtils.hpp

@@ -76,6 +76,8 @@ std::pair<ArgumentPtr, ArgumentPtr> splitRational(const ArgumentPtr &arg);
 
 ArgumentPtr negate(const ArgumentPtr &arg);
 
+ArgumentPtr invert(const ArgumentPtr &arg);
+
 ArgumentPtr makePolynom(const IFunction &func, ArgumentPtrVector &&args);
 
 ArgumentPtr makePolynom(const IFunction &func, const ArgumentPtrVector &args);

include/fintamath/functions/arithmetic/Add.hpp

@@ -8,24 +8,20 @@
 #include "fintamath/core/MathObjectType.hpp"
 #include "fintamath/functions/FunctionArguments.hpp"
 #include "fintamath/functions/FunctionUtils.hpp"
-#include "fintamath/functions/IOperator.hpp"
+#include "fintamath/functions/IFunction.hpp"
 
 namespace fintamath {
 
-class Add final : public IOperatorCRTP<IArithmetic, Add, IArithmetic, IArithmetic> {
+class Add final : public IFunctionCRTP<IArithmetic, Add, IArithmetic> {
 public:
   std::string toString() const override {
-    return "+";
+    return "add";
   }
 
-  static constexpr bool isAssociativeStatic() {
+  static constexpr bool isVariadicStatic() {
     return true;
   }
 
-  static constexpr Priority getPriorityStatic() {
-    return Priority::Addition;
-  }
-
   static constexpr MathObjectType getTypeStatic() {
     return {MathObjectType::Add, "Add"};
   }

include/fintamath/functions/arithmetic/AddOper.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "fintamath/core/IArithmetic.hpp"
+#include "fintamath/core/IMathObject.hpp"
+#include "fintamath/core/MathObjectType.hpp"
+#include "fintamath/functions/FunctionArguments.hpp"
+#include "fintamath/functions/IOperator.hpp"
+
+namespace fintamath {
+
+class AddOper final : public IOperatorCRTP<IArithmetic, AddOper, IArithmetic, IArithmetic> {
+public:
+  std::string toString() const override {
+    return "+";
+  }
+
+  static constexpr bool isAssociativeStatic() {
+    return true;
+  }
+
+  static constexpr Priority getPriorityStatic() {
+    return Priority::Addition;
+  }
+
+  static constexpr MathObjectType getTypeStatic() {
+    return {MathObjectType::AddOper, "AddOper"};
+  }
+
+protected:
+  std::unique_ptr<IMathObject> call(const ArgumentRefVector &argVect) const override;
+};
+
+}

include/fintamath/functions/arithmetic/Mul.hpp

@@ -8,24 +8,20 @@
 #include "fintamath/core/MathObjectType.hpp"
 #include "fintamath/functions/FunctionArguments.hpp"
 #include "fintamath/functions/FunctionUtils.hpp"
-#include "fintamath/functions/IOperator.hpp"
+#include "fintamath/functions/IFunction.hpp"
 
 namespace fintamath {
 
-class Mul final : public IOperatorCRTP<IArithmetic, Mul, IArithmetic, IArithmetic> {
+class Mul final : public IFunctionCRTP<IArithmetic, Mul, IArithmetic> {
 public:
   std::string toString() const override {
-    return "*";
+    return "mul";
   }
 
-  static constexpr bool isAssociativeStatic() {
+  static constexpr bool isVariadicStatic() {
     return true;
   }
 
-  static constexpr Priority getPriorityStatic() {
-    return Priority::Multiplication;
-  }
-
   static constexpr MathObjectType getTypeStatic() {
     return {MathObjectType::Mul, "Mul"};
   }

include/fintamath/functions/arithmetic/MulOper.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "fintamath/core/IArithmetic.hpp"
+#include "fintamath/core/IMathObject.hpp"
+#include "fintamath/core/MathObjectType.hpp"
+#include "fintamath/functions/FunctionArguments.hpp"
+#include "fintamath/functions/IOperator.hpp"
+
+namespace fintamath {
+
+class MulOper final : public IOperatorCRTP<IArithmetic, MulOper, IArithmetic, IArithmetic> {
+public:
+  std::string toString() const override {
+    return "*";
+  }
+
+  static constexpr bool isAssociativeStatic() {
+    return true;
+  }
+
+  static constexpr Priority getPriorityStatic() {
+    return Priority::Multiplication;
+  }
+
+  static constexpr MathObjectType getTypeStatic() {
+    return {MathObjectType::MulOper, "MulOper"};
+  }
+
+protected:
+  std::unique_ptr<IMathObject> call(const ArgumentRefVector &argVect) const override;
+};
+
+}

include/fintamath/functions/logic/And.hpp

@@ -7,25 +7,22 @@
 #include "fintamath/core/MathObjectType.hpp"
 #include "fintamath/functions/FunctionArguments.hpp"
 #include "fintamath/functions/FunctionUtils.hpp"
+#include "fintamath/functions/IFunction.hpp"
 #include "fintamath/functions/IOperator.hpp"
 #include "fintamath/literals/Boolean.hpp"
 
 namespace fintamath {
 
-class And final : public IOperatorCRTP<Boolean, And, Boolean, Boolean> {
+class And final : public IFunctionCRTP<Boolean, And, Boolean> {
 public:
   std::string toString() const override {
-    return "&";
+    return "and";
   }
 
-  static constexpr bool isAssociativeStatic() {
+  static constexpr bool isVariadicStatic() {
     return true;
   }
 
-  static constexpr Priority getPriorityStatic() {
-    return Priority::Conjunction;
-  }
-
   static constexpr MathObjectType getTypeStatic() {
     return {MathObjectType::And, "And"};
   }

include/fintamath/functions/logic/AndOper.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "fintamath/core/IMathObject.hpp"
+#include "fintamath/core/MathObjectType.hpp"
+#include "fintamath/functions/FunctionArguments.hpp"
+#include "fintamath/functions/IOperator.hpp"
+#include "fintamath/literals/Boolean.hpp"
+
+namespace fintamath {
+
+class AndOper final : public IOperatorCRTP<Boolean, AndOper, Boolean, Boolean> {
+public:
+  std::string toString() const override {
+    return "&";
+  }
+
+  static constexpr bool isAssociativeStatic() {
+    return true;
+  }
+
+  static constexpr Priority getPriorityStatic() {
+    return Priority::Conjunction;
+  }
+
+  static constexpr MathObjectType getTypeStatic() {
+    return {MathObjectType::AndOper, "AndOper"};
+  }
+
+protected:
+  std::unique_ptr<IMathObject> call(const ArgumentRefVector &argVect) const override;
+};
+
+}

include/fintamath/functions/logic/Or.hpp

@@ -7,25 +7,21 @@
 #include "fintamath/core/MathObjectType.hpp"
 #include "fintamath/functions/FunctionArguments.hpp"
 #include "fintamath/functions/FunctionUtils.hpp"
-#include "fintamath/functions/IOperator.hpp"
+#include "fintamath/functions/IFunction.hpp"
 #include "fintamath/literals/Boolean.hpp"
 
 namespace fintamath {
 
-class Or final : public IOperatorCRTP<Boolean, Or, Boolean, Boolean> {
+class Or final : public IFunctionCRTP<Boolean, Or, Boolean, Boolean> {
 public:
   std::string toString() const override {
-    return "|";
+    return "or";
   }
 
-  static constexpr bool isAssociativeStatic() {
+  static constexpr bool isVariadicStatic() {
     return true;
   }
 
-  static constexpr Priority getPriorityStatic() {
-    return Priority::Disjunction;
-  }
-
   static constexpr MathObjectType getTypeStatic() {
     return {MathObjectType::Or, "Or"};
   }

include/fintamath/functions/logic/OrOper.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "fintamath/core/IMathObject.hpp"
+#include "fintamath/core/MathObjectType.hpp"
+#include "fintamath/functions/FunctionArguments.hpp"
+#include "fintamath/functions/FunctionUtils.hpp"
+#include "fintamath/functions/IFunction.hpp"
+#include "fintamath/functions/IOperator.hpp"
+#include "fintamath/literals/Boolean.hpp"
+
+namespace fintamath {
+
+class OrOper final : public IOperatorCRTP<Boolean, OrOper, Boolean, Boolean> {
+public:
+  std::string toString() const override {
+    return "|";
+  }
+
+  static constexpr bool isAssociativeStatic() {
+    return true;
+  }
+
+  static constexpr Priority getPriorityStatic() {
+    return Priority::Disjunction;
+  }
+
+  static constexpr MathObjectType getTypeStatic() {
+    return {MathObjectType::OrOper, "OrOper"};
+  }
+
+protected:
+  std::unique_ptr<IMathObject> call(const ArgumentRefVector &argVect) const override;
+};
+
+}

include/fintamath/functions/powers/Pow.hpp

@@ -17,14 +17,10 @@ class Rational;
 class Real;
 class Complex;
 
-class Pow final : public IOperatorCRTP<INumber, Pow, INumber, INumber> {
+class Pow final : public IFunctionCRTP<INumber, Pow, INumber, INumber> {
 public:
   std::string toString() const override {
-    return "^";
-  }
-
-  static constexpr Priority getPriorityStatic() {
-    return Priority::Exponentiation;
+    return "pow";
   }
 
   static constexpr MathObjectType getTypeStatic() {

include/fintamath/functions/powers/PowFunction.hpp → include/fintamath/functions/powers/PowOper.hpp

@@ -7,18 +7,22 @@
 #include "fintamath/core/IMathObject.hpp"
 #include "fintamath/core/MathObjectType.hpp"
 #include "fintamath/functions/FunctionArguments.hpp"
-#include "fintamath/functions/IFunction.hpp"
+#include "fintamath/functions/IOperator.hpp"
 
 namespace fintamath {
 
-class PowFunction final : public IFunctionCRTP<IArithmetic, PowFunction, IArithmetic, IArithmetic> {
+class PowOper final : public IOperatorCRTP<IArithmetic, PowOper, IArithmetic, IArithmetic> {
 public:
   std::string toString() const override {
-    return "pow";
+    return "^";
+  }
+
+  static constexpr Priority getPriorityStatic() {
+    return Priority::Exponentiation;
   }
 
   static constexpr MathObjectType getTypeStatic() {
-    return {MathObjectType::PowFunction, "PowFunction"};
+    return {MathObjectType::PowOper, "PowOper"};
   }
 
 protected: