Simplify with complex numbers

fintarin · Aug 26, 2023 · 92efe87 · 92efe87
1 parent 61febb3
commit 92efe87
Show file tree

Hide file tree

Showing 64 changed files with 438 additions and 123 deletions.
diff --git a/include/fintamath/expressions/ExpressionUtils.hpp b/include/fintamath/expressions/ExpressionUtils.hpp
@@ -15,6 +15,8 @@ std::string putInSpaces(const std::string &str);
 
 std::string functionToString(const IFunction &func, const ArgumentsPtrVector &args);
 
+std::string operatorChildToString(const IOperator &oper, const ArgumentPtr &child);
+
 std::string binaryOperatorToString(const IOperator &oper, const ArgumentPtr &lhs, const ArgumentPtr &rhs);
 
 std::string prefixUnaryOperatorToString(const IOperator &oper, const ArgumentPtr &rhs);
@@ -27,6 +29,8 @@ bool hasVariable(const ArgumentPtr &arg, const Variable &var);
 
 bool hasInfinity(const ArgumentPtr &arg);
 
+bool hasComplex(const ArgumentPtr &arg);
+
 bool isInfinity(const ArgumentPtr &arg);
 
 bool isNegated(const ArgumentPtr &arg);

diff --git a/include/fintamath/expressions/interfaces/IPolynomExpression.hpp b/include/fintamath/expressions/interfaces/IPolynomExpression.hpp
@@ -43,7 +43,7 @@ class IPolynomExpression : public IExpression {
 
   virtual SimplifyFunctionsVector getFunctionsForPostSimplify() const;
 
-  virtual std::string operatorChildToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const;
+  virtual std::string childToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const;
 
   /**
    * @brief

diff --git a/include/fintamath/functions/powers/Pow.hpp b/include/fintamath/functions/powers/Pow.hpp
@@ -8,6 +8,7 @@ namespace fintamath {
 class Integer;
 class Rational;
 class Real;
+class Complex;
 
 class Pow : public IOperatorCRTP<INumber, Pow, INumber, INumber> {
 public:
@@ -33,6 +34,8 @@ class Pow : public IOperatorCRTP<INumber, Pow, INumber, INumber> {
   static std::unique_ptr<IMathObject> powSimplify(const Rational &lhs, const Rational &rhs);
 
   static std::unique_ptr<IMathObject> powSimplify(const Real &lhs, const Real &rhs);
+
+  static std::unique_ptr<IMathObject> powSimplify(const Complex &lhs, const Complex &rhs);
 };
 
 FINTAMATH_FUNCTION_EXPRESSION(Pow, powExpr);

diff --git a/src/fintamath/expressions/ExpressionUtils.cpp b/src/fintamath/expressions/ExpressionUtils.cpp
@@ -6,11 +6,13 @@
 #include "fintamath/functions/arithmetic/Div.hpp"
 #include "fintamath/functions/arithmetic/Mul.hpp"
 #include "fintamath/functions/arithmetic/Neg.hpp"
+#include "fintamath/functions/arithmetic/Sub.hpp"
 #include "fintamath/functions/powers/Pow.hpp"
 #include "fintamath/literals/constants/ComplexInf.hpp"
 #include "fintamath/literals/constants/Inf.hpp"
 #include "fintamath/literals/constants/NegInf.hpp"
 #include "fintamath/literals/constants/Undefined.hpp"
+#include "fintamath/numbers/Complex.hpp"
 #include "fintamath/numbers/Rational.hpp"
 #include "fintamath/numbers/Real.hpp"
 
@@ -47,7 +49,20 @@ std::string operatorChildToString(const IOperator &oper, const ArgumentPtr &chil
   if (const auto childExpr = cast<IExpression>(child)) {
     childOper = cast<IOperator>(childExpr->getOutputFunction());
   }
-  else if (operPriority <= IOperator::Priority::PrefixUnary && childStr.front() == Neg().toString().front()) {
+  else if (const auto childComplex = cast<Complex>(child)) {
+    if (childComplex->real() != Integer(0)) {
+      childOper = std::make_shared<Add>();
+    }
+    else if (childComplex->imag() != Integer(1)) {
+      if (childComplex->imag() == Integer(-1)) {
+        childOper = std::make_shared<Neg>();
+      }
+      else {
+        childOper = std::make_shared<Mul>();
+      }
+    }
+  }
+  else if (childStr.front() == Neg().toString().front()) {
     childOper = std::make_shared<Neg>();
   }
   else if (is<Rational>(child)) {
@@ -62,12 +77,11 @@ std::string operatorChildToString(const IOperator &oper, const ArgumentPtr &chil
   if (childOper) {
     IOperator::Priority lhsOperPriority = childOper->getOperatorPriority();
 
-    if (operPriority == IOperator::Priority::Multiplication) {
-      return putInBrackets(childStr);
-    }
-
-    if (lhsOperPriority >= operPriority ||
-        (lhsOperPriority == operPriority && !oper.isAssociative())) {
+    if (lhsOperPriority > operPriority ||
+        (lhsOperPriority == operPriority &&
+         childOper->getFunctionType() == IFunction::Type::Unary) ||
+        (!oper.isAssociative() &&
+         childOper->getFunctionType() != IFunction::Type::Unary)) {
 
       return putInBrackets(childStr);
     }
@@ -169,6 +183,29 @@ bool hasInfinity(const ArgumentPtr &arg) {
   });
 }
 
+bool hasComplex(const ArgumentPtr &arg) {
+  if (const auto num = cast<INumber>(arg); num && num->isComplex()) {
+    return true;
+  }
+
+  auto expr = cast<IExpression>(arg);
+  if (!expr) {
+    return false;
+  }
+
+  ArgumentsPtrVector children = expr->getChildren();
+
+  return std::any_of(children.begin(), children.end(), [](const auto &child) {
+    bool res = false;
+
+    if (hasComplex(child)) {
+      res = true;
+    }
+
+    return res;
+  });
+}
+
 bool isInfinity(const ArgumentPtr &arg) {
   return is<Inf>(arg) || is<NegInf>(arg) || is<ComplexInf>(arg);
 }

diff --git a/src/fintamath/expressions/IExpression.cpp b/src/fintamath/expressions/IExpression.cpp
@@ -142,13 +142,7 @@ ArgumentPtr IExpression::callFunction(const IFunction &func, const ArgumentsPtrV
     return {};
   }
 
-  ArgumentPtr res;
-  try {
-    res = func(args);
-  }
-  catch (const UndefinedException &) {
-    return {};
-  }
+  ArgumentPtr res = func(args);
 
   if (areArgumentsPrecise) {
     if (const auto num = cast<INumber>(res); num && !num->isPrecise()) {

diff --git a/src/fintamath/expressions/binary/CompExpression.cpp b/src/fintamath/expressions/binary/CompExpression.cpp
@@ -55,6 +55,12 @@ ArgumentPtr CompExpression::preSimplify() const {
     if (!simplExpr->isSolution &&
         (!is<Integer>(rhsChild) || *rhsChild != Integer(0))) {
 
+      if (*func != Eqv() && *func != Neqv() &&
+          (hasComplex(lhsChild) || hasComplex(rhsChild))) {
+
+        return simpl;
+      }
+
       if (!hasInfinity(lhsChild) && !hasInfinity(rhsChild)) {
         ArgumentPtr resLhs = subExpr(simplExpr->lhsChild, simplExpr->rhsChild);
         preSimplifyChild(resLhs);

diff --git a/src/fintamath/expressions/interfaces/IPolynomExpression.cpp b/src/fintamath/expressions/interfaces/IPolynomExpression.cpp
@@ -26,10 +26,10 @@ std::string IPolynomExpression::toString() const {
 
   std::string result;
 
-  result += operatorChildToString(children.front(), {});
+  result += childToString(children.front(), {});
 
   for (size_t i = 1; i < children.size(); i++) {
-    result += operatorChildToString(children[i], children[i - 1]);
+    result += childToString(children[i], children[i - 1]);
   }
 
   return result;
@@ -180,22 +180,16 @@ ArgumentPtr IPolynomExpression::preciseSimplify() const {
   return preciseExpr;
 }
 
-std::string IPolynomExpression::operatorChildToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const {
-  std::string result = inChild->toString();
-
-  if (const auto exprChild = cast<IExpression>(inChild)) {
-    const auto oper = cast<IOperator>(func);
-    const auto childOper = cast<IOperator>(exprChild->getFunction());
-
-    if (oper &&
-        childOper &&
-        oper->getOperatorPriority() <= childOper->getOperatorPriority()) {
-
-      result = putInBrackets(result);
-    }
+std::string IPolynomExpression::childToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const {
+  std::string childStr;
+  if (const auto oper = cast<IOperator>(func)) {
+    childStr = operatorChildToString(*oper, inChild);
+  }
+  else {
+    childStr = inChild->toString();
   }
 
-  return prevChild ? (putInSpaces(func->toString()) + result) : result;
+  return prevChild ? (putInSpaces(func->toString()) + childStr) : childStr;
 }
 
 bool IPolynomExpression::isTermsOrderInversed() const {

diff --git a/src/fintamath/expressions/polynomial/AddExpression.cpp b/src/fintamath/expressions/polynomial/AddExpression.cpp
@@ -22,11 +22,10 @@ AddExpression::AddExpression(const ArgumentsPtrVector &inChildren)
     : IPolynomExpressionCRTP(Add(), inChildren) {
 }
 
-std::string AddExpression::operatorChildToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const {
+std::string AddExpression::childToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const {
+  std::string result = operatorChildToString(Add(), inChild);
   bool isChildNegated = false;
 
-  std::string result = inChild->toString();
-
   if (result.size() > 1 &&
       result.front() == Neg().toString().front()) {
 

diff --git a/src/fintamath/expressions/polynomial/AddExpression.hpp b/src/fintamath/expressions/polynomial/AddExpression.hpp
@@ -17,7 +17,7 @@ class AddExpression : public IPolynomExpressionCRTP<AddExpression> {
 
   SimplifyFunctionsVector getFunctionsForPostSimplify() const override;
 
-  std::string operatorChildToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const override;
+  std::string childToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const override;
 
   /**
    * @brief

diff --git a/src/fintamath/expressions/polynomial/MulExpression.cpp b/src/fintamath/expressions/polynomial/MulExpression.cpp
@@ -50,7 +50,7 @@ std::string MulExpression::toString() const {
   return IPolynomExpression::toString();
 }
 
-std::string MulExpression::operatorChildToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const {
+std::string MulExpression::childToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const {
   if (!prevChild && *inChild == Integer(-1)) {
     return Neg().toString();
   }
@@ -65,7 +65,7 @@ std::string MulExpression::operatorChildToString(const ArgumentPtr &inChild, con
     }
   }
 
-  return operStr + inChild->toString();
+  return operStr + operatorChildToString(Mul(), inChild);
 }
 
 MulExpression::SimplifyFunctionsVector MulExpression::getFunctionsForPreSimplify() const {

diff --git a/src/fintamath/expressions/polynomial/MulExpression.hpp b/src/fintamath/expressions/polynomial/MulExpression.hpp
@@ -14,7 +14,7 @@ class MulExpression : public IPolynomExpressionCRTP<MulExpression> {
   }
 
 protected:
-  std::string operatorChildToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const override;
+  std::string childToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const override;
 
   SimplifyFunctionsVector getFunctionsForPreSimplify() const override;
 

diff --git a/src/fintamath/expressions/polynomial/OrExpression.cpp b/src/fintamath/expressions/polynomial/OrExpression.cpp
@@ -11,8 +11,8 @@ OrExpression::OrExpression(const ArgumentsPtrVector &inChildren)
     : IPolynomExpressionCRTP(Or(), inChildren) {
 }
 
-std::string OrExpression::operatorChildToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const {
-  std::string result = inChild->toString();
+std::string OrExpression::childToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const {
+  std::string result = operatorChildToString(Or(), inChild);
 
   if (const auto &childExpr = cast<IExpression>(inChild);
       childExpr && is<And>(childExpr->getFunction())) {

diff --git a/src/fintamath/expressions/polynomial/OrExpression.hpp b/src/fintamath/expressions/polynomial/OrExpression.hpp
@@ -13,7 +13,7 @@ class OrExpression : public IPolynomExpressionCRTP<OrExpression> {
   }
 
 protected:
-  std::string operatorChildToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const override;
+  std::string childToString(const ArgumentPtr &inChild, const ArgumentPtr &prevChild) const override;
 
   ArgumentPtr postSimplify() const override;
 

diff --git a/src/fintamath/functions/calculus/Max.cpp b/src/fintamath/functions/calculus/Max.cpp
@@ -1,5 +1,7 @@
 #include "fintamath/functions/calculus/Max.hpp"
 
+#include "fintamath/numbers/Complex.hpp"
+
 namespace fintamath {
 
 std::unique_ptr<IMathObject> Max::call(const ArgumentsRefVector &argsVect) const {
@@ -8,10 +10,9 @@ std::unique_ptr<IMathObject> Max::call(const ArgumentsRefVector &argsVect) const
   for (size_t i = 1; i < argsVect.size(); i++) {
     std::reference_wrapper<const IComparable> arg = cast<IComparable>(argsVect[i].get());
 
-    // TODO! uncomment
-    // if (is<Complex>(arg)) {
-    //   return {};
-    // }
+    if (is<Complex>(arg)) {
+      return {};
+    }
 
     if (res < arg) {
       res = arg;

diff --git a/src/fintamath/functions/calculus/Min.cpp b/src/fintamath/functions/calculus/Min.cpp
@@ -1,4 +1,5 @@
 #include "fintamath/functions/calculus/Min.hpp"
+#include "fintamath/numbers/Complex.hpp"
 
 namespace fintamath {
 
@@ -8,10 +9,9 @@ std::unique_ptr<IMathObject> Min::call(const ArgumentsRefVector &argsVect) const
   for (size_t i = 1; i < argsVect.size(); i++) {
     std::reference_wrapper<const IComparable> arg = cast<IComparable>(argsVect[i].get());
 
-    // TODO! uncomment
-    // if (is<Complex>(arg)) {
-    //   return {};
-    // }
+    if (is<Complex>(arg)) {
+      return {};
+    }
 
     if (res > arg) {
       res = arg;

diff --git a/src/fintamath/functions/comparison/Less.cpp b/src/fintamath/functions/comparison/Less.cpp
@@ -1,17 +1,16 @@
 #include "fintamath/functions/comparison/Less.hpp"
 
-#include "fintamath/literals/constants/Undefined.hpp"
+#include "fintamath/numbers/Complex.hpp"
 
 namespace fintamath {
 
 std::unique_ptr<IMathObject> Less::call(const ArgumentsRefVector &argsVect) const {
   const auto &lhs = cast<IComparable>(argsVect.front().get());
   const auto &rhs = cast<IComparable>(argsVect.back().get());
 
-  // TODO! uncomment
-  // if (is<Complex>(lhs) || is<Complex>(rhs)) {
-  //   return {};
-  // }
+  if (is<Complex>(lhs) || is<Complex>(rhs)) {
+    return {};
+  }
 
   return Boolean(lhs < rhs).clone();
 }

diff --git a/src/fintamath/functions/comparison/LessEqv.cpp b/src/fintamath/functions/comparison/LessEqv.cpp
@@ -1,15 +1,16 @@
 #include "fintamath/functions/comparison/LessEqv.hpp"
 
+#include "fintamath/numbers/Complex.hpp"
+
 namespace fintamath {
 
 std::unique_ptr<IMathObject> LessEqv::call(const ArgumentsRefVector &argsVect) const {
   const auto &lhs = cast<IComparable>(argsVect.front().get());
   const auto &rhs = cast<IComparable>(argsVect.back().get());
 
-  // TODO! uncomment
-  // if (is<Complex>(lhs) || is<Complex>(rhs)) {
-  //   return {};
-  // }
+  if (is<Complex>(lhs) || is<Complex>(rhs)) {
+    return {};
+  }
 
   return Boolean(lhs <= rhs).clone();
 }

diff --git a/src/fintamath/functions/comparison/More.cpp b/src/fintamath/functions/comparison/More.cpp
@@ -1,15 +1,16 @@
 #include "fintamath/functions/comparison/More.hpp"
 
+#include "fintamath/numbers/Complex.hpp"
+
 namespace fintamath {
 
 std::unique_ptr<IMathObject> More::call(const ArgumentsRefVector &argsVect) const {
   const auto &lhs = cast<IComparable>(argsVect.front().get());
   const auto &rhs = cast<IComparable>(argsVect.back().get());
 
-  // TODO! uncomment
-  // if (is<Complex>(lhs) || is<Complex>(rhs)) {
-  //   return {};
-  // }
+  if (is<Complex>(lhs) || is<Complex>(rhs)) {
+    return {};
+  }
 
   return Boolean(lhs > rhs).clone();
 }

diff --git a/src/fintamath/functions/comparison/MoreEqv.cpp b/src/fintamath/functions/comparison/MoreEqv.cpp
@@ -1,15 +1,16 @@
 #include "fintamath/functions/comparison/MoreEqv.hpp"
 
+#include "fintamath/numbers/Complex.hpp"
+
 namespace fintamath {
 
 std::unique_ptr<IMathObject> MoreEqv::call(const ArgumentsRefVector &argsVect) const {
   const auto &lhs = cast<IComparable>(argsVect.front().get());
   const auto &rhs = cast<IComparable>(argsVect.back().get());
 
-  // TODO! uncomment
-  // if (is<Complex>(lhs) || is<Complex>(rhs)) {
-  //   return {};
-  // }
+  if (is<Complex>(lhs) || is<Complex>(rhs)) {
+    return {};
+  }
 
   return Boolean(lhs >= rhs).clone();
 }