Make IExpression non IArithmetic

include/fintamath/expressions/Expression.hpp

@@ -94,16 +94,6 @@ class Expression final : public IExpressionCRTP<Expression> {
   static void registerExpressionConstructor(ExpressionConstructor constructor);
 
 protected:
-  Expression &add(const Expression &rhs) override;
-
-  Expression &substract(const Expression &rhs) override;
-
-  Expression &multiply(const Expression &rhs) override;
-
-  Expression &divide(const Expression &rhs) override;
-
-  Expression &negate() override;
-
   ArgumentPtr simplify() const override;
 
 private:
@@ -169,30 +159,6 @@ class Expression final : public IExpressionCRTP<Expression> {
   mutable bool isSimplified = false;
 };
 
-Expression operator+(const Variable &lhs, const Variable &rhs);
-
-Expression operator+(const Expression &lhs, const Variable &rhs);
-
-Expression operator+(const Variable &lhs, const Expression &rhs);
-
-Expression operator-(const Variable &lhs, const Variable &rhs);
-
-Expression operator-(const Expression &lhs, const Variable &rhs);
-
-Expression operator-(const Variable &lhs, const Expression &rhs);
-
-Expression operator*(const Variable &lhs, const Variable &rhs);
-
-Expression operator*(const Expression &lhs, const Variable &rhs);
-
-Expression operator*(const Variable &lhs, const Expression &rhs);
-
-Expression operator/(const Variable &lhs, const Variable &rhs);
-
-Expression operator/(const Expression &lhs, const Variable &rhs);
-
-Expression operator/(const Variable &lhs, const Expression &rhs);
-
 template <typename Function, bool isPolynomial>
 void Expression::registerExpressionConstructor(ExpressionConstructor constructor) {
   getExpressionMaker()[Function::getClassStatic()] = [maker = std::move(constructor)](ArgumentPtrVector &&args) {

include/fintamath/expressions/ExpressionFunctions.hpp

@@ -5,21 +5,19 @@
 
 namespace fintamath {
 
-Expression add(const auto &...args) {
-  return (Expression(args) + ...);
-}
+Expression operator+(const Expression &lhs, const Expression &rhs);
 
-Expression mul(const auto &...args) {
-  return (Expression(args) * ...);
-}
+Expression operator+(const Expression &rhs);
 
-Expression sub(const Expression &lhs, const Expression &rhs);
+Expression operator-(const Expression &lhs, const Expression &rhs);
 
-Expression div(const Expression &lhs, const Expression &rhs);
+Expression operator-(const Expression &rhs);
 
-Expression mod(const Expression &lhs, const Expression &rhs);
+Expression operator*(const Expression &lhs, const Expression &rhs);
 
-Expression neg(const Expression &rhs);
+Expression operator/(const Expression &lhs, const Expression &rhs);
+
+Expression mod(const Expression &lhs, const Expression &rhs);
 
 Expression eqv(const Expression &lhs, const Expression &rhs);
 

include/fintamath/expressions/IExpression.hpp

@@ -18,7 +18,7 @@
 
 namespace fintamath {
 
-class IExpression : public IArithmetic {
+class IExpression : public IMathObject {
   FINTAMATH_PARENT_CLASS_BODY(IExpression)
 
 public:

include/fintamath/expressions/IExpressionBaseCRTP.hpp

@@ -9,9 +9,9 @@ class IExpressionBaseCRTP_ : public IExpression {
 
 #endif // I_EXPRESSION_BASE_CRTP
 
-#define I_ARITHMETIC_CRTP I_EXPRESSION_BASE_CRTP
-#include "fintamath/core/IArithmeticCRTP.hpp"
-#undef I_ARITHMETIC_CRTP
+#define I_MATH_OBJECT_CRTP I_EXPRESSION_BASE_CRTP
+#include "fintamath/core/IMathObjectCRTP.hpp"
+#undef I_MATH_OBJECT_CRTP
 
 private:
 #if !defined(I_EXPRESSION_BASE_CRTP) && !defined(NDEBUG)

include/fintamath/expressions/IExpressionCRTP.hpp

@@ -33,27 +33,6 @@ class IExpressionCRTP_ : public IExpressionBaseCRTP<Derived> {
     return true;
   }
 
-protected:
-  Derived &add(const Derived &rhs) override {
-    throw InvalidInputBinaryOperatorException("+", this->toString(), rhs.toString());
-  }
-
-  Derived &substract(const Derived &rhs) override {
-    throw InvalidInputBinaryOperatorException("-", this->toString(), rhs.toString());
-  }
-
-  Derived &multiply(const Derived &rhs) override {
-    throw InvalidInputBinaryOperatorException("*", this->toString(), rhs.toString());
-  }
-
-  Derived &divide(const Derived &rhs) override {
-    throw InvalidInputBinaryOperatorException("/", this->toString(), rhs.toString());
-  }
-
-  Derived &negate() override {
-    throw InvalidInputUnaryOperatorException("-", this->toString(), InvalidInputUnaryOperatorException::Type::Prefix);
-  }
-
 private:
 #if !defined(I_EXPRESSION_CRTP) && !defined(NDEBUG)
 };

include/fintamath/functions/IFunction.hpp

@@ -5,6 +5,7 @@
 #include <cstddef>
 #include <memory>
 #include <string>
+#include <tuple>
 #include <unordered_map>
 
 #include "fintamath/core/IMathObject.hpp"

include/fintamath/literals/Boolean.hpp

@@ -21,7 +21,7 @@ class Boolean final : public ILiteralCRTP<Boolean> {
 
   std::string toString() const override;
 
-  operator bool() const;
+  explicit operator bool() const;
 
 private:
   std::string name;

src/fintamath/config/TypeConfig.cpp

@@ -119,12 +119,12 @@
 namespace fintamath::detail {
 
 TypeConfig::TypeConfig() {
-  IMathObject::registerType<ILiteral>();
-  IMathObject::registerType<IFunction>();
   IMathObject::registerType<IArithmetic>();
+  IMathObject::registerType<IFunction>();
+  IMathObject::registerType<ILiteral>();
+  IMathObject::registerType<IExpression>();
 
   IArithmetic::registerType<IComparable>();
-  IArithmetic::registerType<IExpression>();
 
   IComparable::registerType<INumber>();
 

src/fintamath/expressions/Expression.cpp

@@ -82,36 +82,6 @@ const std::shared_ptr<IFunction> &Expression::getFunction() const {
   return func;
 }
 
-Expression &Expression::add(const Expression &rhs) {
-  child = makeExpr(Add{}, *child, *rhs.child);
-  isSimplified = false;
-  return *this;
-}
-
-Expression &Expression::substract(const Expression &rhs) {
-  child = makeExpr(Sub{}, *child, *rhs.child);
-  isSimplified = false;
-  return *this;
-}
-
-Expression &Expression::multiply(const Expression &rhs) {
-  child = makeExpr(Mul{}, *child, *rhs.child);
-  isSimplified = false;
-  return *this;
-}
-
-Expression &Expression::divide(const Expression &rhs) {
-  child = makeExpr(Div{}, *child, *rhs.child);
-  isSimplified = false;
-  return *this;
-}
-
-Expression &Expression::negate() {
-  child = makeExpr(Neg{}, *child);
-  isSimplified = false;
-  return *this;
-}
-
 const ArgumentPtrVector &Expression::getChildren() const {
   simplifyMutable();
   childrenCached.front() = child;
@@ -530,54 +500,6 @@ bool Expression::doesArgMatch(const MathObjectClass &expectedType, const Argumen
   return true;
 }
 
-Expression operator+(const Variable &lhs, const Variable &rhs) {
-  return Expression(addExpr(lhs, rhs));
-}
-
-Expression operator+(const Expression &lhs, const Variable &rhs) {
-  return Expression(addExpr(lhs, rhs));
-}
-
-Expression operator+(const Variable &lhs, const Expression &rhs) {
-  return Expression(addExpr(lhs, rhs));
-}
-
-Expression operator-(const Variable &lhs, const Variable &rhs) {
-  return Expression(subExpr(lhs, rhs));
-}
-
-Expression operator-(const Expression &lhs, const Variable &rhs) {
-  return Expression(subExpr(lhs, rhs));
-}
-
-Expression operator-(const Variable &lhs, const Expression &rhs) {
-  return Expression(subExpr(lhs, rhs));
-}
-
-Expression operator*(const Variable &lhs, const Variable &rhs) {
-  return Expression(mulExpr(lhs, rhs));
-}
-
-Expression operator*(const Expression &lhs, const Variable &rhs) {
-  return Expression(mulExpr(lhs, rhs));
-}
-
-Expression operator*(const Variable &lhs, const Expression &rhs) {
-  return Expression(mulExpr(lhs, rhs));
-}
-
-Expression operator/(const Variable &lhs, const Variable &rhs) {
-  return Expression(divExpr(lhs, rhs));
-}
-
-Expression operator/(const Expression &lhs, const Variable &rhs) {
-  return Expression(divExpr(lhs, rhs));
-}
-
-Expression operator/(const Variable &lhs, const Expression &rhs) {
-  return Expression(divExpr(lhs, rhs));
-}
-
 namespace detail {
 
 std::unique_ptr<IMathObject> makeExpr(const IFunction &func, ArgumentPtrVector args) {

src/fintamath/expressions/ExpressionFunctions.cpp

@@ -2,6 +2,11 @@
 
 #include "fintamath/expressions/Expression.hpp"
 #include "fintamath/functions/arithmetic/Abs.hpp"
+#include "fintamath/functions/arithmetic/Add.hpp"
+#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/calculus/Derivative.hpp"
 #include "fintamath/functions/comparison/Eqv.hpp"
 #include "fintamath/functions/comparison/Less.hpp"
@@ -47,20 +52,32 @@
 
 namespace fintamath {
 
-Expression sub(const Expression &lhs, const Expression &rhs) {
-  return lhs - rhs;
+Expression operator+(const Expression &lhs, const Expression &rhs) {
+  return Expression(addExpr(lhs, rhs));
 }
 
-Expression div(const Expression &lhs, const Expression &rhs) {
-  return lhs / rhs;
+Expression operator+(const Expression &rhs) {
+  return rhs;
 }
 
-Expression mod(const Expression &lhs, const Expression &rhs) {
-  return Expression(modExpr(lhs, rhs));
+Expression operator-(const Expression &lhs, const Expression &rhs) {
+  return Expression(subExpr(lhs, rhs));
+}
+
+Expression operator-(const Expression &rhs) {
+  return Expression(negExpr(rhs));
+}
+
+Expression operator*(const Expression &lhs, const Expression &rhs) {
+  return Expression(mulExpr(lhs, rhs));
+}
+
+Expression operator/(const Expression &lhs, const Expression &rhs) {
+  return Expression(divExpr(lhs, rhs));
 }
 
-Expression neg(const Expression &rhs) {
-  return -rhs;
+Expression mod(const Expression &lhs, const Expression &rhs) {
+  return Expression(modExpr(lhs, rhs));
 }
 
 Expression eqv(const Expression &lhs, const Expression &rhs) {

src/fintamath/expressions/functions/ExpressionFunctionSolve.cpp

@@ -135,11 +135,11 @@ ArgumentPtrVector solveQuadraticEquation(const ArgumentPtrVector &coeffAtPow) {
   const Expression b(coeffAtPow[1]);
   const Expression c(coeffAtPow[0]);
 
-  const ArgumentPtr discriminantArg = sub(pow(b, 2), mul(4, a, c)).toMinimalObject();
+  const ArgumentPtr discriminantArg = (pow(b, 2) - (4 * a * c)).toMinimalObject();
   const Expression discriminant(discriminantArg);
 
-  const Expression firstRoot = div(add(neg(b), sqrt(discriminant)), mul(2, a));
-  const Expression secondRoot = div(sub(neg(b), sqrt(discriminant)), mul(2, a));
+  const Expression firstRoot = (-b + sqrt(discriminant)) / 2 * a;
+  const Expression secondRoot = (-b - sqrt(discriminant)) / (2 * a);
 
   return {firstRoot.getChildren().front(), secondRoot.getChildren().front()};
 }

tests/src/FintamathTests.cpp

@@ -15,10 +15,10 @@ TEST(FintamathTests, fintamathTest) {
 
   //-------------------------------------------------------------------------------------//
 
-  expr = add(e(), pi(), Variable("a"), Variable("b"));
+  expr = e() + pi() + Variable("a") + Variable("b");
   EXPECT_EQ(expr.toString(), "a + b + E + Pi");
 
-  expr = mul(e(), pi(), Variable("a"), Variable("b"));
+  expr = e() * pi() * Variable("a") * Variable("b");
   EXPECT_EQ(expr.toString(), "E Pi a b");
 
   expr = pow(Variable("a"), Variable("b")) * Variable("c");