Add new functions and rework operators

fintarin · Mar 15, 2024 · c971777 · c971777
1 parent 1879e2c
commit c971777
Show file tree

Hide file tree

Showing 62 changed files with 912 additions and 482 deletions.
diff --git a/include/fintamath/core/MathObjectType.hpp b/include/fintamath/core/MathObjectType.hpp
@@ -119,37 +119,40 @@ struct MathObjectType final {
     Integral,
     Frac,
     FracMixed,
-    PowFunction,
     Floor,
     Ceil,
+    Add,
+    Mul,
+    Pow,
+    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(),
   };

diff --git a/include/fintamath/expressions/Expression.hpp b/include/fintamath/expressions/Expression.hpp
@@ -92,7 +92,7 @@ class Expression final : public IExpressionCRTP<Expression> {
     getTermParser().registerType(std::move(constructor));
   }
 
-  template <typename Function, bool isPolynomial = false>
+  template <typename Function>
   static void registerFunctionExpressionMaker(ExpressionMaker maker);
 
   static constexpr MathObjectType getTypeStatic() {
@@ -195,7 +195,7 @@ Expression operator/(const Expression &lhs, const Variable &rhs);
 
 Expression operator/(const Variable &lhs, const Expression &rhs);
 
-template <typename Function, bool isPolynomial>
+template <typename Function>
 void Expression::registerFunctionExpressionMaker(ExpressionMaker maker) {
   ExpressionParser::Constructor constructor = [maker = std::move(maker)](ArgumentPtrVector &&args) {
     static const size_t argSize = Function{}.getArgumentTypes().size();
@@ -204,11 +204,6 @@ void Expression::registerFunctionExpressionMaker(ExpressionMaker maker) {
     if constexpr (Function::isVariadicStatic()) {
       res = maker(std::move(args));
     }
-    else if constexpr (isPolynomial) {
-      if (argSize <= args.size()) {
-        res = maker(std::move(args));
-      }
-    }
     else {
       if (argSize == args.size()) {
         res = maker(std::move(args));

diff --git a/include/fintamath/expressions/ExpressionUtils.hpp b/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);

diff --git a/include/fintamath/expressions/IExpression.hpp b/include/fintamath/expressions/IExpression.hpp
@@ -50,6 +50,12 @@ class IExpression : public IArithmetic {
   }
 
 protected:
+  virtual bool isTermOrderInversed() const;
+
+  virtual bool isComparableOrderInversed() const;
+
+  virtual std::strong_ordering compare(const ArgumentPtr &lhs, const ArgumentPtr &rhs) const;
+
   virtual ArgumentPtr simplify() const;
 
   virtual ArgumentPtr preSimplify() const;

diff --git a/include/fintamath/expressions/interfaces/IPolynomExpression.hpp b/include/fintamath/expressions/interfaces/IPolynomExpression.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <compare>
 #include <functional>
 #include <memory>
 #include <string>
@@ -43,16 +42,10 @@ class IPolynomExpression : public IExpression {
 
   virtual std::string childToString(const IOperator &oper, const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const;
 
-  virtual std::strong_ordering compare(const ArgumentPtr &lhs, const ArgumentPtr &rhs) const;
-
   ArgumentPtr preSimplify() const override;
 
   ArgumentPtr postSimplify() const override;
 
-  virtual bool isTermOrderInversed() const;
-
-  virtual bool isComparableOrderInversed() const;
-
 private:
   void simplifyRec(bool isPostSimplify);
 

diff --git a/include/fintamath/functions/IFunctionCRTP.hpp b/include/fintamath/functions/IFunctionCRTP.hpp
@@ -24,7 +24,7 @@ class IFunctionCRTP_ : public IFunction {
 
   bool doArgsMatch(const ArgumentRefVector &argVect) const override {
     if constexpr (Derived::isVariadicStatic()) {
-      return doAnyArgsMatch(argVect);
+      return doVariadicArgsMatch(argVect);
     }
     else {
       if (argVect.size() != argTypes.size()) {
@@ -75,27 +75,32 @@ class IFunctionCRTP_ : public IFunction {
 
 private:
   template <size_t i, typename Head, typename... Tail>
-  bool doArgsMatch(const ArgumentRefVector &argVect) const {
-    if (!is<Head>(argVect[i]) || detail::isExpression(argVect[i])) {
+  static bool doArgsMatch(const ArgumentRefVector &argVect) {
+    if (!doArgMatch<Head>(argVect[i])) {
       return false;
     }
 
     return doArgsMatch<i + 1, Tail...>(argVect);
   }
 
   template <size_t>
-  bool doArgsMatch(const ArgumentRefVector & /*unused*/) const {
+  static bool doArgsMatch(const ArgumentRefVector &) {
     return true;
   }
 
-  bool doAnyArgsMatch(const ArgumentRefVector &argVect) const {
-    using AnyArgsType = typename std::tuple_element_t<0, std::tuple<Args...>>;
+  static bool doVariadicArgsMatch(const ArgumentRefVector &argVect) {
+    using ExpectedArg = typename std::tuple_element_t<0, std::tuple<Args...>>;
 
     return stdr::all_of(argVect, [](const auto &arg) {
-      return is<AnyArgsType>(arg);
+      return doArgMatch<ExpectedArg>(arg);
     });
   }
 
+  template <typename Expected>
+  static bool doArgMatch(const ArgumentRef &arg) {
+    return is<Expected>(arg) && !detail::isExpression(arg);
+  }
+
 private:
   inline static const ArgumentTypeVector argTypes = {Args::getTypeStatic()...};
 

diff --git a/include/fintamath/functions/arithmetic/Add.hpp b/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"};
   }

diff --git a/include/fintamath/functions/arithmetic/AddOper.hpp b/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;
+};
+
+}
diff --git a/include/fintamath/functions/arithmetic/Mul.hpp b/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"};
   }

diff --git a/include/fintamath/functions/arithmetic/MulOper.hpp b/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;
+};
+
+}
diff --git a/include/fintamath/functions/logic/And.hpp b/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"};
   }

diff --git a/include/fintamath/functions/logic/AndOper.hpp b/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;
+};
+
+}