Add Inf and Indeterminate

include/fintamath/core/MathObjectTypes.hpp

@@ -64,6 +64,9 @@ enum class MathObjectType : MathObjectTypeId {
   Pi,
   True,
   False,
+  Inf,
+  NegInf,
+  Indeterminate,
 
   IFunction = 11000,
 
@@ -144,19 +147,19 @@ class MathObjectBoundTypeIds {
     using Type = MathObjectType;
 
     static std::unordered_map<Id, Id> ids{
-        {Id(Type::IMathObject), Id(Type::None)},                     //
-        {Id(Type::IArithmetic), Id(Type::ILiteral)},                 //
-        {Id(Type::IExpression), Id(Type::IComparable)},              //
-        {Id(Type::IUnaryExpression), Id(Type::IBinaryExpression)},   //
-        {Id(Type::IBinaryExpression), Id(Type::IPolynomExpression)}, //
-        {Id(Type::IPolynomExpression), Id(Type::IComparable)},       //
-        {Id(Type::IComparable), Id(Type::ILiteral)},                 //
-        {Id(Type::INumber), Id(Type::ILiteral)},                     //
-        {Id(Type::IInteger), Id(Type::ILiteral)},                    //
-        {Id(Type::ILiteral), Id(Type::IFunction)},                   //
-        {Id(Type::IConstant), Id(Type::IFunction)},                  //
-        {Id(Type::IFunction), Id(Type::None)},                       //
-        {Id(Type::IOperator), Id(Type::None)},                       //
+        {Id(Type::IMathObject), Id(Type::None)},
+        {Id(Type::IArithmetic), Id(Type::ILiteral)},
+        {Id(Type::IExpression), Id(Type::IComparable)},
+        {Id(Type::IUnaryExpression), Id(Type::IBinaryExpression)},
+        {Id(Type::IBinaryExpression), Id(Type::IPolynomExpression)},
+        {Id(Type::IPolynomExpression), Id(Type::IComparable)},
+        {Id(Type::IComparable), Id(Type::ILiteral)},
+        {Id(Type::INumber), Id(Type::ILiteral)},
+        {Id(Type::IInteger), Id(Type::ILiteral)},
+        {Id(Type::ILiteral), Id(Type::IFunction)},
+        {Id(Type::IConstant), Id(Type::IFunction)},
+        {Id(Type::IFunction), Id(Type::None)},
+        {Id(Type::IOperator), Id(Type::None)},
     };
 
     return ids;
@@ -166,6 +169,7 @@ class MathObjectBoundTypeIds {
 inline bool isBaseOf(size_t toTypeId, size_t fromTypeId) {
   if (auto toTypeBoundaries = MathObjectBoundTypeIds::get().find(toTypeId);
       toTypeBoundaries != MathObjectBoundTypeIds::get().end()) {
+
     return fromTypeId >= toTypeBoundaries->first && fromTypeId < toTypeBoundaries->second;
   }
 

include/fintamath/literals/constants/Indeterminate.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "fintamath/literals/constants/IConstant.hpp"
+
+namespace fintamath {
+
+class Indeterminate : public IConstantCRTP<IMathObject, Indeterminate> {
+public:
+  std::string toString() const override {
+    return "Indeterminate";
+  }
+
+  static MathObjectTypeId getTypeIdStatic() {
+    return MathObjectTypeId(MathObjectType::Indeterminate);
+  }
+
+protected:
+  std::unique_ptr<IMathObject> call() const override;
+};
+
+}

include/fintamath/literals/constants/Inf.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "fintamath/literals/constants/IConstant.hpp"
+#include "fintamath/numbers/INumber.hpp"
+
+namespace fintamath {
+
+class Inf : public IConstantCRTP<INumber, Inf> {
+public:
+  std::string toString() const override {
+    return "Inf";
+  }
+
+  static MathObjectTypeId getTypeIdStatic() {
+    return MathObjectTypeId(MathObjectType::Inf);
+  }
+
+protected:
+  std::unique_ptr<IMathObject> call() const override;
+};
+
+}

include/fintamath/literals/constants/NegInf.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "fintamath/literals/constants/IConstant.hpp"
+#include "fintamath/numbers/INumber.hpp"
+
+namespace fintamath {
+
+class NegInf : public IConstantCRTP<INumber, NegInf> {
+public:
+  std::string toString() const override {
+    return "-Inf";
+  }
+
+  static MathObjectTypeId getTypeIdStatic() {
+    return MathObjectTypeId(MathObjectType::NegInf);
+  }
+
+protected:
+  std::unique_ptr<IMathObject> call() const override;
+};
+
+}

src/fintamath/config/ParserConfig.cpp

@@ -65,6 +65,9 @@
 #include "fintamath/literals/constants/E.hpp"
 #include "fintamath/literals/constants/False.hpp"
 #include "fintamath/literals/constants/IConstant.hpp"
+#include "fintamath/literals/constants/Indeterminate.hpp"
+#include "fintamath/literals/constants/Inf.hpp"
+#include "fintamath/literals/constants/NegInf.hpp"
 #include "fintamath/literals/constants/Pi.hpp"
 #include "fintamath/literals/constants/True.hpp"
 #include "fintamath/numbers/IInteger.hpp"
@@ -165,6 +168,9 @@ struct ParserConfig {
     IConstant::registerType<Pi>();
     IConstant::registerType<True>();
     IConstant::registerType<False>();
+    IConstant::registerType<Inf>();
+    IConstant::registerType<NegInf>();
+    IConstant::registerType<Indeterminate>();
 
     IFunction::registerType<Abs>();
     IFunction::registerType<Log>();

src/fintamath/expressions/Expression.cpp

@@ -459,7 +459,7 @@ void Expression::validateFunctionArgs(const std::shared_ptr<IFunction> &func, co
     else if (const auto childConst = cast<IConstant>(arg)) {
       const MathObjectTypeId childTypeId = childConst->getReturnTypeId();
 
-      if (!isBaseOf(typeId, childTypeId)) {
+      if (!isBaseOf(typeId, childTypeId) && !isBaseOf(childTypeId, typeId)) {
         throw InvalidInputFunctionException(func->toString(), argumentVectorToStringVector(args));
       }
     }

src/fintamath/expressions/ExpressionUtils.cpp

@@ -4,7 +4,9 @@
 #include "fintamath/expressions/IExpression.hpp"
 #include "fintamath/functions/arithmetic/Div.hpp"
 #include "fintamath/functions/arithmetic/Mul.hpp"
+#include "fintamath/functions/arithmetic/Neg.hpp"
 #include "fintamath/functions/powers/Pow.hpp"
+#include "fintamath/literals/constants/NegInf.hpp"
 #include "fintamath/numbers/Rational.hpp"
 #include "fintamath/numbers/Real.hpp"
 

src/fintamath/expressions/IExpression.cpp

@@ -5,6 +5,7 @@
 #include "fintamath/functions/other/Index.hpp"
 #include "fintamath/literals/Variable.hpp"
 #include "fintamath/literals/constants/IConstant.hpp"
+#include "fintamath/literals/constants/Indeterminate.hpp"
 #include "fintamath/numbers/INumber.hpp"
 #include "fintamath/numbers/Real.hpp"
 

src/fintamath/expressions/binary/CompExpression.cpp

@@ -46,15 +46,16 @@ std::string CompExpression::toString() const {
 
 ArgumentPtr CompExpression::preSimplify() const {
   auto simpl = IBinaryExpression::preSimplify();
-  auto simplExpr = cast<CompExpression>(simpl);
 
-  if (!simplExpr->isSolution && (!is<Integer>(rhsChild) || *rhsChild != Integer(0))) {
-    ArgumentPtr resLhs = makeExpr(Sub(), simplExpr->lhsChild, simplExpr->rhsChild);
-    preSimplifyChild(resLhs);
-    return std::make_shared<CompExpression>(cast<IOperator>(*func), resLhs, std::make_shared<Integer>(0));
+  if (auto simplExpr = cast<CompExpression>(simpl)) {
+    if (!simplExpr->isSolution && (!is<Integer>(rhsChild) || *rhsChild != Integer(0))) {
+      ArgumentPtr resLhs = makeExpr(Sub(), simplExpr->lhsChild, simplExpr->rhsChild);
+      preSimplifyChild(resLhs);
+      return std::make_shared<CompExpression>(cast<IOperator>(*func), resLhs, std::make_shared<Integer>(0));
+    }
   }
 
-  return simplExpr;
+  return simpl;
 }
 
 CompExpression::SimplifyFunctionsVector CompExpression::getFunctionsForPostSimplify() const {

src/fintamath/expressions/binary/DivExpression.cpp

@@ -8,6 +8,9 @@
 #include "fintamath/functions/arithmetic/Neg.hpp"
 #include "fintamath/functions/arithmetic/Sub.hpp"
 #include "fintamath/functions/powers/Pow.hpp"
+#include "fintamath/literals/constants/Indeterminate.hpp"
+#include "fintamath/literals/constants/Inf.hpp"
+#include "fintamath/literals/constants/NegInf.hpp"
 #include "fintamath/numbers/IntegerFunctions.hpp"
 #include "fintamath/numbers/Rational.hpp"
 
@@ -28,16 +31,16 @@ std::string DivExpression::toString() const {
 
 DivExpression::SimplifyFunctionsVector DivExpression::getFunctionsForPreSimplify() const {
   static const DivExpression::SimplifyFunctionsVector simplifyFunctions = {
-      &DivExpression::zeroSimplify, //
-      &DivExpression::divSimplify,  //
-      &DivExpression::mulSimplify,  //
+      &DivExpression::constSimplify, //
+      &DivExpression::divSimplify,   //
+      &DivExpression::mulSimplify,   //
   };
   return simplifyFunctions;
 }
 
 DivExpression::SimplifyFunctionsVector DivExpression::getFunctionsForPostSimplify() const {
   static const DivExpression::SimplifyFunctionsVector simplifyFunctions = {
-      &DivExpression::zeroSimplify,            //
+      &DivExpression::constSimplify,           //
       &DivExpression::negSimplify,             //
       &DivExpression::numSimplify,             //
       &DivExpression::divSimplify,             //
@@ -49,19 +52,29 @@ DivExpression::SimplifyFunctionsVector DivExpression::getFunctionsForPostSimplif
   return simplifyFunctions;
 }
 
-ArgumentPtr DivExpression::zeroSimplify(const IFunction & /*func*/, const ArgumentPtr &lhs, const ArgumentPtr &rhs) {
+ArgumentPtr DivExpression::constSimplify(const IFunction & /*func*/, const ArgumentPtr &lhs, const ArgumentPtr &rhs) {
+  if ((*lhs == Integer(0) || is<Inf>(lhs) || is<NegInf>(lhs)) &&
+      (*rhs == Integer(0) || is<Inf>(rhs) || is<NegInf>(rhs))) {
+
+    return Indeterminate().clone();
+  }
+
+  if (*lhs == Integer(0)) {
+    return lhs;
+  }
+
   if (*rhs == Integer(0)) {
-    throw UndefinedBinaryOperatorException(Div().toString(), lhs->toString(), rhs->toString());
+    return Inf().clone();
+  }
+
+  if (is<Inf>(rhs) || is<NegInf>(rhs)) {
+    return Integer(0).clone();
   }
 
   return {};
 }
 
 ArgumentPtr DivExpression::numSimplify(const IFunction & /*func*/, const ArgumentPtr &lhs, const ArgumentPtr &rhs) {
-  if (*lhs == Integer(0)) {
-    return lhs;
-  }
-
   static const Integer one = 1;
 
   if (Div().doArgsMatch({one, *rhs})) {

src/fintamath/expressions/binary/DivExpression.hpp

@@ -21,7 +21,7 @@ class DivExpression : public IBinaryExpressionCRTP<DivExpression> {
   SimplifyFunctionsVector getFunctionsForPostSimplify() const override;
 
 private:
-  static ArgumentPtr zeroSimplify(const IFunction &func, const ArgumentPtr &lhs, const ArgumentPtr &rhs);
+  static ArgumentPtr constSimplify(const IFunction &func, const ArgumentPtr &lhs, const ArgumentPtr &rhs);
 
   static ArgumentPtr numSimplify(const IFunction &func, const ArgumentPtr &lhs, const ArgumentPtr &rhs);
 

src/fintamath/expressions/binary/PowExpression.cpp

@@ -9,6 +9,9 @@
 #include "fintamath/functions/powers/Pow.hpp"
 #include "fintamath/functions/powers/Root.hpp"
 #include "fintamath/functions/powers/Sqrt.hpp"
+#include "fintamath/literals/constants/Indeterminate.hpp"
+#include "fintamath/literals/constants/Inf.hpp"
+#include "fintamath/literals/constants/NegInf.hpp"
 #include "fintamath/numbers/Integer.hpp"
 #include "fintamath/numbers/IntegerFunctions.hpp"
 #include "fintamath/numbers/Rational.hpp"
@@ -87,7 +90,7 @@ PowExpression::SimplifyFunctionsVector PowExpression::getFunctionsForPreSimplify
 
 PowExpression::SimplifyFunctionsVector PowExpression::getFunctionsForPostSimplify() const {
   static const PowExpression::SimplifyFunctionsVector simplifyFunctions = {
-      &PowExpression::numSimplify,     //
+      &PowExpression::constSimplify,   //
       &PowExpression::polynomSimplify, //
       &PowExpression::negSimplify,     //
       &PowExpression::powSimplify,     //
@@ -200,32 +203,51 @@ ArgumentPtr PowExpression::powSimplify(const IFunction & /*func*/, const Argumen
   return res;
 }
 
-ArgumentPtr PowExpression::numSimplify(const IFunction & /*func*/, const ArgumentPtr &lhs, const ArgumentPtr &rhs) {
-  auto lhsInt = cast<Integer>(lhs);
-  auto rhsInt = cast<Integer>(rhs);
+ArgumentPtr PowExpression::constSimplify(const IFunction & /*func*/, const ArgumentPtr &lhs, const ArgumentPtr &rhs) {
+  if (*rhs == Integer(1)) {
+    return lhs;
+  }
 
-  if (rhsInt) {
-    if (*rhsInt == 0) {
-      return std::make_shared<Integer>(1);
-    }
+  if (*rhs == Integer(-1)) {
+    ArgumentPtr divLhs = Integer(1).clone();
+    ArgumentPtr divRhs = lhs;
+    return makeExpr(Div(), divLhs, divRhs);
+  }
 
-    if (*rhsInt == 1 || (lhsInt && *lhsInt == 1)) {
-      return lhs;
-    }
+  if (const auto rhsComp = cast<IComparable>(rhs); is<NegInf>(rhs) || (rhsComp && *rhsComp < Integer(0))) {
+    ArgumentPtr divLhs = Integer(1).clone();
+    ArgumentPtr divRhs = makeExpr(Pow(), lhs, makeExpr(Neg(), rhs));
+    return makeExpr(Div(), divLhs, divRhs);
+  }
+
+  if (is<NegInf>(lhs)) {
+    ArgumentPtr mulLhs = makeExpr(Pow(), Integer(-1).clone(), rhs);
+    ArgumentPtr mulRhs = makeExpr(Pow(), Inf().clone(), rhs);
+    return makeExpr(Mul(), mulLhs, mulRhs);
+  }
 
-    if (*rhsInt == -1) {
-      ArgumentPtr res = makeExpr(Div(), std::make_shared<Integer>(1), lhs);
-      return res;
+  if (is<Inf>(lhs)) {
+    if (*rhs == Integer(0)) {
+      return Indeterminate().clone();
     }
+
+    return lhs;
   }
 
-  if (lhsInt && *lhsInt == 0) {
+  if (*lhs == Integer(0)) {
     return lhs;
   }
 
-  if (const auto rhsComp = cast<IComparable>(rhs); rhsComp && *rhsComp < Integer(0)) {
-    ArgumentPtr res = makeExpr(Div(), std::make_shared<Integer>(1), makeExpr(Pow(), lhs, makeExpr(Neg(), rhs)));
-    return res;
+  if (*lhs == Integer(1)) {
+    if (is<Inf>(rhs)) {
+      return Indeterminate().clone();
+    }
+
+    return lhs;
+  }
+
+  if (*rhs == Integer(0)) {
+    return Integer(1).clone();
   }
 
   return {};

src/fintamath/expressions/binary/PowExpression.hpp

@@ -37,7 +37,7 @@ class PowExpression : public IBinaryExpressionCRTP<PowExpression> {
 
   static ArgumentPtr powSimplify(const IFunction &func, const ArgumentPtr &lhs, const ArgumentPtr &rhs);
 
-  static ArgumentPtr numSimplify(const IFunction &func, const ArgumentPtr &lhs, const ArgumentPtr &rhs);
+  static ArgumentPtr constSimplify(const IFunction &func, const ArgumentPtr &lhs, const ArgumentPtr &rhs);
 
   static ArgumentPtr polynomSimplify(const IFunction &func, const ArgumentPtr &lhs, const ArgumentPtr &rhs);
 

src/fintamath/expressions/interfaces/IBinaryExpression.cpp

@@ -1,6 +1,7 @@
 #include "fintamath/expressions/interfaces/IBinaryExpression.hpp"
 
 #include "fintamath/expressions/ExpressionUtils.hpp"
+#include "fintamath/literals/constants/Indeterminate.hpp"
 
 namespace fintamath {
 
@@ -25,6 +26,10 @@ ArgumentPtr IBinaryExpression::preSimplify() const {
   preSimplifyChild(simpl->lhsChild);
   preSimplifyChild(simpl->rhsChild);
 
+  if (is<Indeterminate>(simpl->lhsChild) || is<Indeterminate>(simpl->rhsChild)) {
+    return Indeterminate().clone();
+  }
+
   ArgumentPtr res = simpl->useSimplifyFunctions(getFunctionsForPreSimplify());
 
   if (res && *res != *simpl) {
@@ -40,6 +45,10 @@ ArgumentPtr IBinaryExpression::postSimplify() const {
   postSimplifyChild(simpl->lhsChild);
   postSimplifyChild(simpl->rhsChild);
 
+  if (is<Indeterminate>(simpl->lhsChild) || is<Indeterminate>(simpl->rhsChild)) {
+    return Indeterminate().clone();
+  }
+
   if (ArgumentPtr res = callFunction(*simpl->func, {simpl->lhsChild, simpl->rhsChild})) {
     return res;
   }