Expression.hpp

Go to the documentation of this file.

#ifndef OASIS_EXPRESSION_HPP
#define OASIS_EXPRESSION_HPP
 
#include <cstdint>
#include <expected>
#include <memory>
#include <vector>
 
#include <boost/any/unique_any.hpp>
 
#include "Concepts.hpp"
 
namespace Oasis {
 
using any = boost::anys::unique_any;
 
class Visitor;
 
enum class ExpressionType {
    None,
    Real,
    Imaginary,
    Variable,
    Add,
    Subtract,
    Multiply,
    Divide,
    Exponent,
    Log,
    Integral,
    Limit,
    Derivative,
    Negate,
    Sqrt,
    Matrix,
    Pi,
    EulerNumber,
    Magnitude
};
enum class ExpressionType {…};
 
enum ExpressionCategory : uint32_t {
    None = 0,
    Associative = 1,
    Commutative = 1 << 1,
    BinExp = 1 << 2,
    UnExp = 1 << 3,
};
enum ExpressionCategory : uint32_t {…};
 
class Expression {
public:
    [[nodiscard]] virtual auto Copy() const -> std::unique_ptr<Expression> = 0;
 
    [[nodiscard]] virtual auto Differentiate(const Expression&) const -> std::unique_ptr<Expression>;
 
    [[nodiscard]] virtual auto Equals(const Expression& other) const -> bool = 0;
 
    auto FindZeros() const -> std::vector<std::unique_ptr<Expression>>;
 
    [[nodiscard]] virtual auto GetCategory() const -> uint32_t;
 
    [[nodiscard]] virtual auto GetType() const -> ExpressionType;
 
    [[nodiscard]] virtual auto Generalize() const -> std::unique_ptr<Expression>;
 
    [[nodiscard]] virtual auto Integrate(const Expression&) const -> std::unique_ptr<Expression>;
 
    [[nodiscard]] virtual auto IntegrateWithBounds(const Expression&, const Expression&, const Expression&) -> std::unique_ptr<Expression>;
 
    template <IExpression T>
    [[nodiscard]] bool Is() const
    {
        return GetType() == T::GetStaticType();
    }
    [[nodiscard]] bool Is() const {…}
 
    template <template <typename> typename T>
        requires(DerivedFromUnaryExpression<T<Expression>> && !DerivedFromBinaryExpression<T<Expression>>)
    [[nodiscard]] bool Is() const
    {
        return GetType() == T<Expression>::GetStaticType();
    }
    [[nodiscard]] bool Is() const {…}
 
    template <template <typename, typename> typename T>
        requires DerivedFromBinaryExpression<T<Expression, Expression>>
    [[nodiscard]] bool Is() const
    {
        return GetType() == T<Expression, Expression>::GetStaticType();
    }
    [[nodiscard]] bool Is() const {…}
 
    [[nodiscard]] virtual auto Simplify() const -> std::unique_ptr<Expression>;
 
    [[nodiscard]] virtual auto StructurallyEquivalent(const Expression& other) const -> bool = 0;
 
    [[nodiscard]] virtual auto Substitute(const Expression& var, const Expression& val) -> std::unique_ptr<Expression> = 0;
 
    template <IVisitor T>
    auto Accept(T& visitor) const -> std::expected<typename T::RetT, std::string_view>;
 
    template <IVisitor T>
        requires ExpectedWithString<typename T::RetT>
    auto Accept(T& visitor) const -> typename T::RetT;
 
    virtual ~Expression() = default;
 
protected:
    virtual any AcceptInternal(Visitor& visitor) const = 0;
};
class Expression {…};
 
template <IVisitor T>
auto Expression::Accept(T& visitor) const -> std::expected<typename T::RetT, std::string_view>
{
    try {
        return boost::any_cast<typename T::RetT>(this->AcceptInternal(visitor));
    } catch (boost::bad_any_cast& e) {
        return std::unexpected { e.what() };
    }
}
auto Expression::Accept(T& visitor) const -> std::expected<typename T::RetT, std::string_view> {…}
 
template <IVisitor T>
    requires ExpectedWithString<typename T::RetT>
auto Expression::Accept(T& visitor) const -> typename T::RetT
{
    try {
        return boost::any_cast<typename T::RetT>(this->AcceptInternal(visitor));
    } catch (boost::bad_any_cast& e) {
        return std::unexpected { e.what() };
    }
}
 
#define EXPRESSION_TYPE(type)                       \
    auto GetType() const -> ExpressionType override \
    {                                               \
        return ExpressionType::type;                \
    }                                               \
                                                    \
    static auto GetStaticType() -> ExpressionType   \
    {                                               \
        return ExpressionType::type;                \
    }
#define EXPRESSION_TYPE(type)                       \ …
 
#define EXPRESSION_CATEGORY(category)                     \
    auto GetCategory() const -> uint32_t override         \
    {                                                     \
        return category;                                  \
    }                                                     \
                                                          \
    constexpr static auto GetStaticCategory() -> uint32_t \
    {                                                     \
        return category;                                  \
    }
#define EXPRESSION_CATEGORY(category)                     \ …
 
} // namespace Oasis
 
std::unique_ptr<Oasis::Expression> operator+(const std::unique_ptr<Oasis::Expression>& lhs, const std::unique_ptr<Oasis::Expression>& rhs);
std::unique_ptr<Oasis::Expression> operator-(const std::unique_ptr<Oasis::Expression>& lhs, const std::unique_ptr<Oasis::Expression>& rhs);
std::unique_ptr<Oasis::Expression> operator*(const std::unique_ptr<Oasis::Expression>& lhs, const std::unique_ptr<Oasis::Expression>& rhs);
std::unique_ptr<Oasis::Expression> operator/(const std::unique_ptr<Oasis::Expression>& lhs, const std::unique_ptr<Oasis::Expression>& rhs);
 
#endif // OASIS_EXPRESSION_HPP