Differentiate Visitor

.github/workflows/cmake-linux.yml

@@ -121,7 +121,7 @@ jobs:
             # Uploads the build, test, and code coverage artifacts.
           - name: Upload artifacts
             if: ${{ matrix.build_profiling }}
-            uses: actions/upload-artifact@v4
+            uses: actions/upload-artifact@v7
             with:
               name: build-linux-${{ matrix.build_type }}-${{ matrix.c_compiler }}
               path: |
@@ -131,7 +131,7 @@ jobs:
               overwrite: true
 
           - name: Upload PR number
-            uses: actions/upload-artifact@v4
+            uses: actions/upload-artifact@v7
             with:
               name: pr-number
               path: ${{ steps.strings.outputs.pr-dir }}

cli/main.cpp

@@ -14,6 +14,7 @@
 #include <fmt/color.h>
 #include <isocline.h>
 
+#include "Oasis/DifferentiateVisitor.hpp"
 #include "Oasis/SimplifyVisitor.hpp"
 
 template <typename FnT>

include/CMakeLists.txt

@@ -4,6 +4,7 @@ set(Oasis_HEADERS
     Oasis/BinaryExpression.hpp
     Oasis/Concepts.hpp
     Oasis/Derivative.hpp
+    Oasis/DifferentiateVisitor.hpp
     Oasis/Divide.hpp
     Oasis/EulerNumber.hpp
     Oasis/Exponent.hpp

include/Oasis/Add.hpp

@@ -18,7 +18,6 @@ class Add<
     using BinaryExpression::BinaryExpression;
 
     [[nodiscard]] auto Integrate(const Expression& integrationVariable) const -> std::unique_ptr<Expression> final;
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> final;
 
     EXPRESSION_TYPE(Add)
     EXPRESSION_CATEGORY(Associative | Commutative | BinExp)

include/Oasis/BinaryExpression.hpp

@@ -129,10 +129,6 @@ class BinaryExpression : public Expression {
         return std::make_unique<DerivedSpecialized>(*static_cast<const DerivedSpecialized*>(this));
     }
 
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> override
-    {
-        return Generalize()->Differentiate(differentiationVariable);
-    }
     [[nodiscard]] auto Equals(const Expression& other) const -> bool final
     {
         if (this->GetType() != other.GetType()) {

include/Oasis/BoundedBinaryExpression.hpp

@@ -71,10 +71,7 @@ class BoundedBinaryExpression : public BoundedExpression<LowerBoundT, UpperBound
 
         return std::make_unique<DerivedSpecialized>(copy);
     }
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> override
-    {
-        return Generalize()->Differentiate(differentiationVariable);
-    }
+
     [[nodiscard]] auto Equals(const Expression& other) const -> bool final
     {
         if (this->GetType() != other.GetType()) {

include/Oasis/Derivative.hpp

@@ -18,8 +18,6 @@ class Derivative<Expression, Expression> : public BinaryExpression<Derivative> {
 
     Derivative(const Expression& Exp, const Expression& Var);
 
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> override;
-
     EXPRESSION_TYPE(Derivative)
     EXPRESSION_CATEGORY(BinExp)
 };

include/Oasis/DifferentiateVisitor.hpp

@@ -0,0 +1,56 @@
+//
+// Created by Andrew Nazareth on 9/23/25.
+//
+
+#ifndef DIFFERENTIATEVISITOR_HPP
+#define DIFFERENTIATEVISITOR_HPP
+
+#include <format>
+#include <string>
+
+#include <gsl-lite/gsl-lite.hpp>
+
+#include "Oasis/Visit.hpp"
+
+namespace Oasis {
+
+struct DifferentiationOpts {
+    enum class Multivariate {
+        SINGLE_VARIABLE,
+        MULTI_VARIABLE,
+    } multivariate
+        = Multivariate::SINGLE_VARIABLE;
+};
+
+class DifferentiateVisitor final : public TypedVisitor<std::expected<gsl_lite::not_null<std::unique_ptr<Expression>>, std::string>> {
+public:
+    explicit DifferentiateVisitor(const std::unique_ptr<Expression>& differentiationVariable);
+    explicit DifferentiateVisitor(const std::unique_ptr<Expression>& differentiationVariable, const DifferentiationOpts& opts);
+
+    auto TypedVisit(const Real& real) -> RetT override;
+    auto TypedVisit(const Imaginary& imaginary) -> RetT override;
+    auto TypedVisit(const Variable& variable) -> RetT override;
+    auto TypedVisit(const Undefined& undefined) -> RetT override;
+    auto TypedVisit(const Add<Expression, Expression>& add) -> RetT override;
+    auto TypedVisit(const Subtract<Expression, Expression>& subtract) -> RetT override;
+    auto TypedVisit(const Multiply<Expression, Expression>& multiply) -> RetT override;
+    auto TypedVisit(const Divide<Expression, Expression>& divide) -> RetT override;
+    auto TypedVisit(const Exponent<Expression, Expression>& exponent) -> RetT override;
+    auto TypedVisit(const Log<Expression, Expression>& log) -> RetT override;
+    auto TypedVisit(const Negate<Expression>& negate) -> RetT override;
+    auto TypedVisit(const Sine<Expression>& sine) -> RetT override;
+    auto TypedVisit(const Derivative<Expression, Expression>& derivative) -> RetT override;
+    auto TypedVisit(const Integral<Expression, Expression>& integral) -> RetT override;
+    auto TypedVisit(const Matrix& matrix) -> RetT override;
+    auto TypedVisit(const EulerNumber&) -> RetT override;
+    auto TypedVisit(const Pi&) -> RetT override;
+    auto TypedVisit(const Magnitude<Expression>& magnitude) -> RetT override;
+
+private:
+    std::unique_ptr<Expression> differentiationVariable;
+    DifferentiationOpts opts;
+};
+
+} // Oasis
+
+#endif // DIFFERENTIATEVISITOR_HPP

include/Oasis/Divide.hpp

@@ -18,8 +18,6 @@ class Divide<Expression, Expression> : public BinaryExpression<Divide> {
 
     Divide(const Expression& dividend, const Expression& divisor);
 
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> final;
-
     [[nodiscard]] auto Integrate(const Expression& integrationVariable) const -> std::unique_ptr<Expression> final;
 
     EXPRESSION_TYPE(Divide)

include/Oasis/EulerNumber.hpp

@@ -72,8 +72,6 @@ class EulerNumber : public LeafExpression<EulerNumber> {
 
     [[nodiscard]] auto Integrate(const Expression& integrationVariable) const -> std::unique_ptr<Expression> final;
 
-    [[nodiscard]] auto Differentiate(const Expression&) const -> std::unique_ptr<Expression> final;
-
     EXPRESSION_TYPE(EulerNumber)
     EXPRESSION_CATEGORY(UnExp)
 

include/Oasis/Exponent.hpp

@@ -19,8 +19,6 @@ class Exponent<Expression, Expression> : public BinaryExpression<Exponent> {
 
     Exponent(const Expression& base, const Expression& power);
 
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> final;
-
     [[nodiscard]] auto Integrate(const Expression& integrationVariable) const -> std::unique_ptr<Expression> final;
 
     EXPRESSION_TYPE(Exponent)

include/Oasis/Expression.hpp

@@ -72,7 +72,7 @@ class Expression {
      * Tries to differentiate this function.
      * @return the differentiated expression.
      */
-    [[nodiscard]] virtual auto Differentiate(const Expression&) const -> std::unique_ptr<Expression>;
+    [[nodiscard]] auto Differentiate(const Expression&) const -> std::unique_ptr<Expression>;
 
     /**
      * Compares this expression to another expression for equality.

include/Oasis/Integral.hpp

@@ -20,8 +20,6 @@ class Integral<Expression, Expression> : public BinaryExpression<Integral> {
 
     Integral(const Expression& integrand, const Expression& differential);
 
-    [[deprecated]] [[nodiscard]] auto Simplify(const Expression& upper, const Expression& lower) const -> std::unique_ptr<Expression> /* final */;
-
     EXPRESSION_TYPE(Integral)
     EXPRESSION_CATEGORY(Associative | Commutative)
 };

include/Oasis/LeafExpression.hpp

@@ -35,10 +35,6 @@ class LeafExpression : public Expression {
         return Generalize()->Integrate(integrationVariable);
     }
 
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> override
-    {
-        return Generalize()->Differentiate(differentiationVariable);
-    }
     auto Substitute(const Expression&, const Expression&) -> std::unique_ptr<Expression> override
     {
         return this->Copy();

include/Oasis/Log.hpp

@@ -20,7 +20,6 @@ class Log<Expression, Expression> : public BinaryExpression<Log> {
     Log(const Expression& base, const Expression& argument);
 
     [[nodiscard]] auto Integrate(const Expression& integrationVariable) const -> std::unique_ptr<Expression> final;
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> final;
 
     EXPRESSION_TYPE(Log)
     EXPRESSION_CATEGORY(BinExp)

include/Oasis/Magnitude.hpp

@@ -39,18 +39,6 @@ class Magnitude final : public UnaryExpression<Magnitude, OperandT> {
     {
     }
 
-    [[nodiscard]] auto Differentiate(const Expression& var) const -> std::unique_ptr<Expression> override
-    {
-        // TODO: Implement
-        Oasis::SimplifyVisitor simplifyVisitor {};
-
-        const std::unique_ptr<Expression> operandDerivative = this->GetOperand().Differentiate(var);
-        return Magnitude<Expression> {
-            *operandDerivative
-        }
-            .Generalize();
-    }
-
     [[nodiscard]] auto Integrate(const Expression& integrationVar) const -> std::unique_ptr<Expression> override
     {
         // TODO: Implement

include/Oasis/Matrix.hpp

@@ -61,8 +61,6 @@ class Matrix : public LeafExpression<Matrix> {
 
     [[nodiscard]] auto Identity() const -> std::unique_ptr<Expression>;
 
-    [[nodiscard]] auto Differentiate(const Expression&) const -> std::unique_ptr<Expression> final;
-
     auto operator=(const Matrix& other) -> Matrix& = default;
 
 private:

include/Oasis/Multiply.hpp

@@ -16,8 +16,6 @@ class Multiply<Expression, Expression> : public BinaryExpression<Multiply> {
 public:
     using BinaryExpression::BinaryExpression;
 
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> final;
-
     [[nodiscard]] auto Integrate(const Expression& integrationVariable) const -> std::unique_ptr<Expression> final;
 
     EXPRESSION_TYPE(Multiply)

include/Oasis/Negate.hpp

@@ -24,15 +24,6 @@ class Negate final : public UnaryExpression<Negate, OperandT> {
     {
     }
 
-    [[nodiscard]] auto Differentiate(const Expression& var) const -> std::unique_ptr<Expression> override
-    {
-        const std::unique_ptr<Expression> operandDerivative = this->GetOperand().Differentiate(var);
-        return Negate<Expression> {
-            *operandDerivative
-        }
-            .Generalize(); // TODO: FIX WITH VISITOR
-    }
-
     EXPRESSION_TYPE(Negate)
     EXPRESSION_CATEGORY(UnExp)
 };

include/Oasis/Real.hpp

@@ -32,8 +32,6 @@ class Real : public LeafExpression<Real> {
 
     [[nodiscard]] auto Integrate(const Expression& integrationVariable) const -> std::unique_ptr<Expression> final;
 
-    [[nodiscard]] auto Differentiate(const Expression&) const -> std::unique_ptr<Expression> final;
-
     auto operator=(const Real& other) -> Real& = default;
 
 private:

include/Oasis/Sine.hpp

@@ -26,8 +26,6 @@ class Sine<Expression> final : public UnaryExpression<Sine> {
     {
     }
 
-    [[nodiscard]] auto Differentiate(const Expression& var) const -> std::unique_ptr<Expression> override;
-
     [[nodiscard]] auto Integrate(const Expression& var) const -> std::unique_ptr<Expression> override;
 
     EXPRESSION_TYPE(Sine)

include/Oasis/Subtract.hpp

@@ -19,8 +19,6 @@ class Subtract<Expression, Expression> : public BinaryExpression<Subtract> {
 
     Subtract(const Expression& minuend, const Expression& subtrahend);
 
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> final;
-
     [[nodiscard]] auto Integrate(const Expression& integrationVariable) const -> std::unique_ptr<Expression> final;
 
     EXPRESSION_TYPE(Subtract)

include/Oasis/Variable.hpp

@@ -46,8 +46,6 @@ class Variable : public LeafExpression<Variable> {
      */
     [[nodiscard]] auto GetName() const -> std::string;
 
-    [[nodiscard]] auto Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression> final;
-
     [[nodiscard]] auto Integrate(const Expression& integrationVariable) const -> std::unique_ptr<Expression> final;
 
     auto Substitute(const Expression& var, const Expression& val) -> std::unique_ptr<Expression> override;

src/Add.cpp

@@ -62,19 +62,4 @@ auto Add<Expression>::Integrate(const Expression& integrationVariable) const ->
     return integral.Copy();
 }
 
-auto Add<Expression>::Differentiate(const Expression& differentiationVariable) const -> std::unique_ptr<Expression>
-{
-    if (auto variable = RecursiveCast<Variable>(differentiationVariable); variable != nullptr) {
-        auto left = mostSigOp->Differentiate(differentiationVariable);
-        auto right = leastSigOp->Differentiate(differentiationVariable);
-        SimplifyVisitor simplifyVisitor;
-        auto simplified = Add<Expression> { *left, *right }.Accept(simplifyVisitor);
-        if (!simplified) {
-            Add<Expression> { *left, *right };
-        }
-        return std::move(simplified).value();
-    }
-    return Copy();
-}
-
 } // Oasis

src/CMakeLists.txt

@@ -10,6 +10,7 @@ set(Oasis_SOURCES
     Add.cpp
     # DefiniteIntegral.cpp
     Derivative.cpp
+    DifferentiateVisitor.cpp
     Divide.cpp
     EulerNumber.cpp
     Exponent.cpp

src/Derivative.cpp

@@ -22,9 +22,4 @@ Derivative<Expression>::Derivative(const Expression& exp, const Expression& var)
 {
 }
 
-std::unique_ptr<Expression> Derivative<Expression, Expression>::Differentiate(const Expression&) const
-{
-    return mostSigOp->Differentiate(*leastSigOp);
-}
-
 }