Added Trig functions Sine, Cosine, Tan, Cotan, Secant, Cosecant, Arcsine, Arccosine, Arctan.

include/CMakeLists.txt

@@ -1,8 +1,14 @@
 set(Oasis_HEADERS
     # cmake-format: sortable
     Oasis/Add.hpp
+    Oasis/Arccosine.hpp
+    Oasis/Arcsine.hpp
+    Oasis/Arctan.hpp
     Oasis/BinaryExpression.hpp
     Oasis/Concepts.hpp
+    Oasis/Cosecant.hpp
+    Oasis/Cosine.hpp
+    Oasis/Cotan.hpp
     Oasis/Derivative.hpp
     Oasis/DifferentiateVisitor.hpp
     Oasis/Divide.hpp
@@ -22,9 +28,11 @@ set(Oasis_HEADERS
     Oasis/Pi.hpp
     Oasis/Real.hpp
     Oasis/RecursiveCast.hpp
+    Oasis/Secant.hpp
     Oasis/SimplifyVisitor.hpp
     Oasis/Sine.hpp
     Oasis/Subtract.hpp
+    Oasis/Tan.hpp
     Oasis/UnaryExpression.hpp
     Oasis/Undefined.hpp
     Oasis/Variable.hpp

include/Oasis/Arccosine.hpp

@@ -0,0 +1,35 @@
+//
+// Created by Gregory Lemonnier 2/xx/26.
+//
+
+#ifndef OASIS_ARCCOSINE_HPP
+#define OASIS_ARCCOSINE_HPP
+
+#include "Expression.hpp"
+#include "UnaryExpression.hpp"
+
+namespace Oasis {
+
+template <typename OperandT = Expression>
+class Arccosine final :public UnaryExpression<Arccosine, OperandT> {
+public:
+    Arccosine() = default;
+    Arccosine(const Arccosine& other)
+        : UnaryExpression<Arccosine, OperandT>(other)
+    {
+    }
+
+    explicit Arccosine(const OperandT& operand)
+        : UnaryExpression<Arccosine, OperandT>(operand)
+    {
+    }
+
+    [[nodiscard]] auto Integrate(const Expression& var) const -> std::unique_ptr<Expression> final;
+
+    EXPRESSION_TYPE(Arccosine)
+    EXPRESSION_CATEGORY(UnExp)
+};
+
+} // Oasis
+
+#endif // OASIS_ARCCOSINE_HPP

include/Oasis/Arcsine.hpp

@@ -0,0 +1,36 @@
+//
+// Created by Gregory Lemonnier on 3/27/26.
+//
+
+#ifndef OASIS_ARCSINE_HPP
+#define OASIS_ARCSINE_HPP
+
+#include "Expression.hpp"
+#include "UnaryExpression.hpp"
+
+namespace Oasis {
+
+template <typename OperandT = Expression>
+class Arcsine final : public UnaryExpression<Arcsine, OperandT> {
+public:
+    Arcsine() = default;
+    Arcsine(const Arcsine& other)
+        : UnaryExpression<Arcsine, OperandT>(other)
+    {
+    }
+
+    explicit Arcsine(const OperandT& operand)
+        : UnaryExpression<Arcsine, OperandT>(operand)
+    {
+    }
+
+
+    [[nodiscard]] auto Integrate(const Expression& var) const -> std::unique_ptr<Expression> final;
+
+    EXPRESSION_TYPE(Arcsine)
+    EXPRESSION_CATEGORY(UnExp)
+};
+
+} // Oasis
+
+#endif // OASIS_ARCSINE_HPP

include/Oasis/Arctan.hpp

@@ -0,0 +1,31 @@
+#ifndef OASIS_ARCTAN_HPP
+#define OASIS_ARCTAN_HPP
+
+#include "Expression.hpp"
+#include "UnaryExpression.hpp"
+
+namespace Oasis {
+
+template <typename OperandT = Expression>
+class Arctan final : public UnaryExpression<Arctan, OperandT> {
+public:
+    Arctan() = default;
+    Arctan(const Arctan& other)
+        : UnaryExpression<Arctan, OperandT>(other)
+    {
+    }
+
+    explicit Arctan(const OperandT& operand)
+        : UnaryExpression<Arctan, OperandT>(operand)
+    {
+    }
+
+    [[nodiscard]] auto Integrate(const Expression& var) const -> std::unique_ptr<Expression> final;
+
+    EXPRESSION_TYPE(Arctan)
+    EXPRESSION_CATEGORY(UnExp)
+};
+
+} // Oasis
+
+#endif // OASIS_ARCTAN_HPP

include/Oasis/Cosecant.hpp

@@ -0,0 +1,36 @@
+//
+// Created by Gregory Lemonnier 2/27/26.
+//
+
+#ifndef OASIS_COSECANT_HPP
+#define OASIS_COSECANT_HPP
+
+#include "Expression.hpp"
+#include "UnaryExpression.hpp"
+
+namespace Oasis {
+
+template <typename OperandT = Expression>
+class Cosecant final :public UnaryExpression<Cosecant, OperandT> {
+public:
+    Cosecant() = default;
+    Cosecant(const Cosecant& other)
+        : UnaryExpression<Cosecant, OperandT>(other)
+    {
+    }
+
+    explicit Cosecant(const OperandT& operand)
+        : UnaryExpression<Cosecant, OperandT>(operand)
+    {
+    }
+
+
+    [[nodiscard]] auto Integrate(const Expression& var) const -> std::unique_ptr<Expression> final;
+
+    EXPRESSION_TYPE(Cosecant)
+    EXPRESSION_CATEGORY(UnExp)
+};
+
+} // Oasis
+
+#endif // OASIS_COSECANT_HPP

include/Oasis/Cosine.hpp

@@ -0,0 +1,35 @@
+//
+// Created by Gregory Lemonnier 2/xx/26.
+//
+
+#ifndef OASIS_COSINE_HPP
+#define OASIS_COSINE_HPP
+
+#include "Expression.hpp"
+#include "UnaryExpression.hpp"
+
+namespace Oasis {
+
+template <typename OperandT = Expression>
+class Cosine final :public UnaryExpression<Cosine, OperandT> {
+public:
+    Cosine() = default;
+    Cosine(const Cosine& other)
+        : UnaryExpression<Cosine, OperandT>(other)
+    {
+    }
+
+    explicit Cosine(const OperandT& operand)
+        : UnaryExpression<Cosine, OperandT>(operand)
+    {
+    }
+
+    [[nodiscard]] auto Integrate(const Expression& vra) const -> std::unique_ptr<Expression> final;
+
+    EXPRESSION_TYPE(Cosine)
+    EXPRESSION_CATEGORY(UnExp)
+};
+
+} // Oasis
+
+#endif // OASIS_COSINE_HPP

include/Oasis/Cotan.hpp

@@ -0,0 +1,35 @@
+//
+// Created by Gregory Lemonnier 2/xx/26.
+//
+
+#ifndef OASIS_COTAN_HPP
+#define OASIS_COTAN_HPP
+
+#include "Expression.hpp"
+#include "UnaryExpression.hpp"
+
+namespace Oasis {
+
+template <typename OperandT = Expression>
+class Cotan final :public UnaryExpression<Cotan, OperandT> {
+public:
+    Cotan() = default;
+    Cotan(const Cotan& other)
+        : UnaryExpression<Cotan, OperandT>(other)
+    {
+    }
+
+    explicit Cotan(const OperandT& operand)
+        : UnaryExpression<Cotan, OperandT>(operand)
+    {
+    }
+
+    [[nodiscard]] auto Integrate(const Expression& var) const -> std::unique_ptr<Expression> final;
+
+    EXPRESSION_TYPE(Cotan)
+    EXPRESSION_CATEGORY(UnExp)
+};
+
+} // Oasis
+
+#endif // OASIS_COTAN_HPP

include/Oasis/DifferentiateVisitor.hpp

@@ -39,6 +39,14 @@ class DifferentiateVisitor final : public TypedVisitor<std::expected<gsl_lite::n
     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 Cosine<Expression>& cosine) -> RetT override;
+    auto TypedVisit(const Tan<Expression>& tan) -> RetT override;
+    auto TypedVisit(const Secant<Expression>& secant) -> RetT override;
+    auto TypedVisit(const Cosecant<Expression>& cosecant) -> RetT override;
+    auto TypedVisit(const Cotan<Expression>& cotan) -> RetT override;
+    auto TypedVisit(const Arcsine<Expression>& arcsine) -> RetT override;
+    auto TypedVisit(const Arccosine<Expression>& arccosine) -> RetT override;
+    auto TypedVisit(const Arctan<Expression>& arctan) -> 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;

include/Oasis/Expression.hpp

@@ -39,7 +39,15 @@ enum class ExpressionType {
     Pi,
     EulerNumber,
     Magnitude,
-    Sine
+    Sine,
+    Cosine,
+    Tan,
+    Cosecant,
+    Secant,
+    Cotan,
+    Arcsine,
+    Arccosine,
+    Arctan
 };
 
 /**

include/Oasis/FwdDecls.hpp

@@ -19,6 +19,15 @@ class Pi;
 template <typename, typename>
 class Add;
 
+template <typename>
+class Arcsine;
+
+template <typename>
+class Arccosine;
+
+template <typename>
+class Arctan;
+
 template <typename, typename>
 class Subtract;
 
@@ -43,6 +52,21 @@ class Magnitude;
 template <typename>
 class Sine;
 
+template <typename>
+class Cosine;
+
+template <typename>
+class Tan;
+
+template <typename>
+class Cosecant;
+
+template <typename>
+class Secant;
+
+template <typename>
+class Cotan;
+
 template <typename, typename>
 class Derivative;
 

include/Oasis/Secant.hpp

@@ -0,0 +1,35 @@
+//
+// Created by Gregory Lemonnier 2/xx/26.
+//
+
+#ifndef OASIS_SECANT_HPP
+#define OASIS_SECANT_HPP
+
+#include "Expression.hpp"
+#include "UnaryExpression.hpp"
+
+namespace Oasis {
+
+template <typename OperandT = Expression>
+class Secant final :public UnaryExpression<Secant, OperandT> {
+public:
+    Secant() = default;
+    Secant(const Secant& other)
+        : UnaryExpression<Secant, OperandT>(other)
+    {
+    }
+
+    explicit Secant(const OperandT& operand)
+        : UnaryExpression<Secant, OperandT>(operand)
+    {
+    }
+
+    [[nodiscard]] auto Integrate(const Expression& var) const -> std::unique_ptr<Expression> final;
+
+    EXPRESSION_TYPE(Secant)
+    EXPRESSION_CATEGORY(UnExp)
+};
+
+} // Oasis
+
+#endif // OASIS_SECANT_HPP

include/Oasis/SimplifyVisitor.hpp

@@ -37,13 +37,21 @@ class SimplifyVisitor final : public TypedVisitor<std::expected<gsl_lite::not_nu
     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 Arcsine<Expression>& arcsine) -> RetT override;
+    auto TypedVisit(const Arccosine<Expression>& arccosine) -> RetT override;
+    auto TypedVisit(const Arctan<Expression>& arctan) -> 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 Cosine<Expression>& cosine) -> RetT override;
+    auto TypedVisit(const Tan<Expression>& tan) -> RetT override;
+    auto TypedVisit(const Cosecant<Expression>& cosecant) -> RetT override;
+    auto TypedVisit(const Secant<Expression>& secant) -> RetT override;
+    auto TypedVisit(const Cotan<Expression>& cotan) -> 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;