Refactor some functions

fintarin · Jul 30, 2023 · 9ab4d85 · 9ab4d85
1 parent 1e0a98d
commit 9ab4d85
Show file tree

Hide file tree

Showing 6 changed files with 62 additions and 43 deletions.
diff --git a/include/fintamath/functions/arithmetic/Div.hpp b/include/fintamath/functions/arithmetic/Div.hpp
@@ -6,6 +6,7 @@
 namespace fintamath {
 
 class Integer;
+class INumber;
 
 class Div : public IOperatorCRTP<IArithmetic, Div, IArithmetic, IArithmetic> {
 public:
@@ -24,6 +25,8 @@ class Div : public IOperatorCRTP<IArithmetic, Div, IArithmetic, IArithmetic> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 
 private:
+  static std::unique_ptr<IMathObject> multiDivSimpl(const IArithmetic &lhs, const IArithmetic &rhs);
+
   static std::unique_ptr<IMathObject> divSimpl(const Integer &lhs, const Integer &rhs);
 };
 

diff --git a/include/fintamath/functions/powers/Pow.hpp b/include/fintamath/functions/powers/Pow.hpp
@@ -26,6 +26,8 @@ class Pow : public IOperatorCRTP<INumber, Pow, INumber, INumber> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 
 private:
+  static std::unique_ptr<IMathObject> multiPowSimpl(const INumber &lhs, const INumber &rhs);
+
   static std::unique_ptr<IMathObject> powSimpl(const Integer &lhs, const Integer &rhs);
 
   static std::unique_ptr<IMathObject> powSimpl(const Rational &lhs, const Rational &rhs);

diff --git a/include/fintamath/functions/powers/Root.hpp b/include/fintamath/functions/powers/Root.hpp
@@ -25,6 +25,8 @@ class Root : public IFunctionCRTP<INumber, Root, INumber, INumber> {
   std::unique_ptr<IMathObject> call(const ArgumentsRefVector &argsVect) const override;
 
 private:
+  static std::unique_ptr<IMathObject> multiRootSimpl(const INumber &lhs, const INumber &rhs);
+
   static std::unique_ptr<IMathObject> rootSimpl(const Integer &lhs, const Integer &rhs);
 
   static std::unique_ptr<IMathObject> rootSimpl(const Rational &lhs, const Integer &rhs);

diff --git a/src/fintamath/functions/arithmetic/Div.cpp b/src/fintamath/functions/arithmetic/Div.cpp
@@ -9,16 +9,6 @@
 namespace fintamath {
 
 std::unique_ptr<IMathObject> Div::call(const ArgumentsRefVector &argsVect) const {
-  static const auto multiPow = [] {
-    static MultiMethod<std::unique_ptr<IMathObject>(const IArithmetic &, const IArithmetic &)> outMultiPow;
-
-    outMultiPow.add<Integer, Integer>([](const Integer &lhs, const Integer &rhs) {
-      return divSimpl(lhs, rhs);
-    });
-
-    return outMultiPow;
-  }();
-
   const auto &lhs = cast<IArithmetic>(argsVect.front().get());
   const auto &rhs = cast<IArithmetic>(argsVect.back().get());
 
@@ -30,7 +20,21 @@ std::unique_ptr<IMathObject> Div::call(const ArgumentsRefVector &argsVect) const
     return ComplexInf().clone();
   }
 
-  if (auto res = multiPow(lhs, rhs)) {
+  return multiDivSimpl(lhs, rhs);
+}
+
+std::unique_ptr<IMathObject> Div::multiDivSimpl(const IArithmetic &lhs, const IArithmetic &rhs) {
+  static const auto multiDiv = [] {
+    static MultiMethod<std::unique_ptr<IMathObject>(const IArithmetic &, const IArithmetic &)> outMultiPow;
+
+    outMultiPow.add<Integer, Integer>([](const Integer &lhs, const Integer &rhs) {
+      return divSimpl(lhs, rhs);
+    });
+
+    return outMultiPow;
+  }();
+
+  if (auto res = multiDiv(lhs, rhs)) {
     return res;
   }
 

diff --git a/src/fintamath/functions/powers/Pow.cpp b/src/fintamath/functions/powers/Pow.cpp
@@ -12,6 +12,21 @@
 namespace fintamath {
 
 std::unique_ptr<IMathObject> Pow::call(const ArgumentsRefVector &argsVect) const {
+  const auto &lhs = cast<INumber>(argsVect.front().get());
+  const auto &rhs = cast<INumber>(argsVect.back().get());
+
+  if (lhs == Integer(0) && rhs == Integer(0)) {
+    return Undefined().clone();
+  }
+
+  if (rhs < Integer(0)) {
+    return multiPowSimpl(*(Rational(1) / lhs), *(-rhs));
+  }
+
+  return multiPowSimpl(lhs, rhs);
+}
+
+std::unique_ptr<IMathObject> Pow::multiPowSimpl(const INumber &lhs, const INumber &rhs) {
   static const auto multiPow = [] {
     static MultiMethod<std::unique_ptr<IMathObject>(const INumber &, const INumber &)> outMultiPow;
 
@@ -30,17 +45,6 @@ std::unique_ptr<IMathObject> Pow::call(const ArgumentsRefVector &argsVect) const
     return outMultiPow;
   }();
 
-  const auto &lhs = cast<INumber>(argsVect.front().get());
-  const auto &rhs = cast<INumber>(argsVect.back().get());
-
-  if (lhs == Integer(0) && rhs == Integer(0)) {
-    return Undefined().clone();
-  }
-
-  if (rhs < Integer(0)) {
-    return Pow()(*(Rational(1) / lhs), *(-rhs));
-  }
-
   if (auto rhsConv = cast<INumber>(convert(lhs, rhs))) {
     return multiPow(lhs, *rhsConv);
   }
@@ -73,10 +77,10 @@ std::unique_ptr<IMathObject> Pow::powSimpl(const Rational &lhs, const Rational &
   }
 
   if (lhsDenominator == 1) {
-    return Root()(*Pow()(lhsNumerator, rhsNumerator), rhsDenominator);
+    return Root()(*multiPowSimpl(lhsNumerator, rhsNumerator), rhsDenominator);
   }
 
-  return Root()(*Pow()(lhs, rhsNumerator), rhsDenominator);
+  return Root()(*multiPowSimpl(lhs, rhsNumerator), rhsDenominator);
 }
 
 std::unique_ptr<IMathObject> Pow::powSimpl(const Real &lhs, const Real &rhs) {

diff --git a/src/fintamath/functions/powers/Root.cpp b/src/fintamath/functions/powers/Root.cpp
@@ -13,24 +13,6 @@
 namespace fintamath {
 
 std::unique_ptr<IMathObject> Root::call(const ArgumentsRefVector &argsVect) const {
-  static const auto multiRoot = [] {
-    static MultiMethod<std::unique_ptr<IMathObject>(const INumber &, const INumber &)> outMultiRoot;
-
-    outMultiRoot.add<Integer, Integer>([](const Integer &lhs, const Integer &rhs) {
-      return rootSimpl(lhs, rhs);
-    });
-
-    outMultiRoot.add<Rational, Integer>([](const Rational &lhs, const Integer &rhs) {
-      return rootSimpl(lhs, rhs);
-    });
-
-    outMultiRoot.add<Real, Integer>([](const Real &lhs, const Integer &rhs) {
-      return rootSimpl(lhs, rhs);
-    });
-
-    return outMultiRoot;
-  }();
-
   const auto &lhs = cast<INumber>(argsVect.front().get());
   const auto &rhs = cast<INumber>(argsVect.back().get());
 
@@ -47,13 +29,35 @@ std::unique_ptr<IMathObject> Root::call(const ArgumentsRefVector &argsVect) cons
         throw UndefinedFunctionException(toString(), {lhs.toString(), rhs.toString()});
       }
 
-      return multiRoot(lhs, rhsInt);
+      return multiRootSimpl(lhs, rhsInt);
     }
   }
 
   return Pow()(lhs, *(Rational(1) / rhs));
 }
 
+std::unique_ptr<IMathObject> Root::multiRootSimpl(const INumber &lhs, const INumber &rhs) {
+  static const auto multiRoot = [] {
+    static MultiMethod<std::unique_ptr<IMathObject>(const INumber &, const INumber &)> outMultiRoot;
+
+    outMultiRoot.add<Integer, Integer>([](const Integer &lhs, const Integer &rhs) {
+      return rootSimpl(lhs, rhs);
+    });
+
+    outMultiRoot.add<Rational, Integer>([](const Rational &lhs, const Integer &rhs) {
+      return rootSimpl(lhs, rhs);
+    });
+
+    outMultiRoot.add<Real, Integer>([](const Real &lhs, const Integer &rhs) {
+      return rootSimpl(lhs, rhs);
+    });
+
+    return outMultiRoot;
+  }();
+
+  return multiRoot(lhs, rhs);
+}
+
 std::unique_ptr<IMathObject> Root::rootSimpl(const Integer &lhs, const Integer &rhs) {
   if (auto res = perfectRoot(lhs, rhs)) {
     return res;