Oasis::Exponent< BaseT, PowerT > Class Template Reference

The exponent expression creates an exponent two expressions. More...

#include <Oasis/Exponent.hpp>

Inheritance diagram for Oasis::Exponent< BaseT, PowerT >:

Collaboration diagram for Oasis::Exponent< BaseT, PowerT >:

Public Member Functions
	Exponent ()=default
	Exponent (const Exponent< BaseT, PowerT > &other)
	Exponent (const BaseT &base, const PowerT &power)
auto	operator= (const Exponent &other) -> Exponent &=default
Public Member Functions inherited from Oasis::BinaryExpression< DerivedT, MostSigOpT, LeastSigOpT >
	BinaryExpression ()=default
	BinaryExpression (const BinaryExpression &other)
	BinaryExpression (const MostSigOpT &mostSigOp, const LeastSigOpT &leastSigOp)
template<IExpression Op1T, IExpression Op2T, IExpression... OpsT>
	BinaryExpression (const Op1T &op1, const Op2T &op2, const OpsT &... ops)
auto	Copy () const -> std::unique_ptr< Expression > final
	Copies this expression.
auto	Differentiate (const Expression &differentiationVariable) const -> std::unique_ptr< Expression > override
	Tries to differentiate this function.
auto	Equals (const Expression &other) const -> bool final
	Compares this expression to another expression for equality.
auto	Generalize () const -> std::unique_ptr< Expression > final
	Converts this expression to a more general expression.
auto	Integrate (const Expression &integrationVariable) const -> std::unique_ptr< Expression > override
	Attempts to integrate this expression using integration rules.
auto	StructurallyEquivalent (const Expression &other) const -> bool final
	Checks whether this expression is structurally equivalent to another expression.
auto	Flatten (std::vector< std::unique_ptr< Expression > > &out) const -> void
	Flattens this expression.
auto	GetMostSigOp () const -> const MostSigOpT &
	Gets the most significant operand of this expression.
auto	GetLeastSigOp () const -> const LeastSigOpT &
	Gets the least significant operand of this expression.
auto	HasMostSigOp () const -> bool
	Gets whether this expression has a most significant operand.
auto	HasLeastSigOp () const -> bool
	Gets whether this expression has a least significant operand.
template<typename T > requires IsAnyOf<T, MostSigOpT, Expression>
auto	SetMostSigOp (const T &op) -> bool
	Sets the most significant operand of this expression.
template<typename T > requires IsAnyOf<T, LeastSigOpT, Expression>
auto	SetLeastSigOp (const T &op) -> bool
	Sets the least significant operand of this expression.
auto	Substitute (const Expression &var, const Expression &val) -> std::unique_ptr< Expression > override
auto	SwapOperands () const -> DerivedT< LeastSigOpT, MostSigOpT >
	Swaps the operands of this expression.
auto	operator= (const BinaryExpression &other) -> BinaryExpression &=default
auto	AcceptInternal (Visitor &visitor) const -> any override
	This function serializes the expression object.
Public Member Functions inherited from Oasis::Expression
auto	FindZeros () const -> std::vector< std::unique_ptr< Expression > >
	The FindZeros function finds all rational real zeros, and up to 2 irrational/complex zeros of a polynomial.
virtual auto	GetCategory () const -> uint32_t
	Gets the category of this expression.
virtual auto	GetType () const -> ExpressionType
	Gets the type of this expression.
virtual auto	IntegrateWithBounds (const Expression &, const Expression &, const Expression &) -> std::unique_ptr< Expression >
	Attempts to integrate this expression using integration rules.
template<IExpression T>
bool	Is () const
	Gets whether this expression is of a specific type.
template<template< typename > typename T> requires (DerivedFromUnaryExpression<T<Expression>> && !DerivedFromBinaryExpression<T<Expression>>)
bool	Is () const
template<template< typename, typename > typename T> requires DerivedFromBinaryExpression<T<Expression, Expression>>
bool	Is () const
auto	Simplify () const -> std::unique_ptr< Expression >
	Simplifies this expression.
template<IVisitor T> requires ExpectedWithString<typename T::RetT>
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

Additional Inherited Members
Public Attributes inherited from Oasis::BinaryExpression< DerivedT, MostSigOpT, LeastSigOpT >
std::unique_ptr< MostSigOpT >	mostSigOp
std::unique_ptr< LeastSigOpT >	leastSigOp

Detailed Description

template<typename BaseT = Expression, typename PowerT = BaseT>
class Oasis::Exponent< BaseT, PowerT >

The exponent expression creates an exponent two expressions.

Parameters:

Template Parameters

BaseT	The expression to be used as the base.
PowerT	The expression to be used as the power.

Example Usage:

Evaluating Real values:

// std::string exp = {"x+5"};
 
 Oasis::Exponent exp {
     Oasis::Real{5},
     Oasis::Real{5}
 };
 Oasis::InFixSerializer result;
 
 auto resultant = exp.Simplify();
 
 std::println("Result: {}", resultant->Accept(result).value());
 // Will print: 3125

Raising an Expression by another Expression:

Note

While Exponent will accept two expressions, it may not be in its simplest form.

std::string exp1 = {"x+5"};
 std::string exp2 = {"2x+3y+12"};
 
 const auto preproc1 = Oasis::PreProcessInFix(exp1);
 const auto preproc2 = Oasis::PreProcessInFix(exp2);
 auto midResult1 = Oasis::FromInFix(preproc1);
 auto midResult2 = Oasis::FromInFix(preproc2);
 
 const std::unique_ptr<Oasis::Expression> expression1 = std::move(midResult1).value();
 const std::unique_ptr<Oasis::Expression> expression2 = std::move(midResult2).value();
 
 Oasis::Exponent exp {
     *expression1,
     *expression2
 };
 Oasis::InFixSerializer result;
 
 auto resultant = exp.Simplify();
 
 std::println("Result: {}", resultant->Accept(result).value());
 // Will print: ((x+5)^(((2*x)+(3*y))+12))

Constructor & Destructor Documentation

Exponent() [1/3]

template<typename BaseT = Expression, typename PowerT = BaseT>

Oasis::Exponent< BaseT, PowerT >::Exponent ( )

default

Exponent() [2/3]

template<typename BaseT = Expression, typename PowerT = BaseT>

Oasis::Exponent< BaseT, PowerT >::Exponent ( const Exponent< BaseT, PowerT > & other )

inline

Exponent() [3/3]

template<typename BaseT = Expression, typename PowerT = BaseT>

Oasis::Exponent< BaseT, PowerT >::Exponent ( const BaseT & base, const PowerT & power )

inline

Member Function Documentation

operator=()

template<typename BaseT = Expression, typename PowerT = BaseT>

auto Oasis::Exponent< BaseT, PowerT >::operator= ( const Exponent< BaseT, PowerT > & other ) -> Exponent &=default

default

---

The documentation for this class was generated from the following file:

• include/Oasis/Exponent.hpp