Oasis::Add< AugendT, AddendT > Class Template Reference

The Add expression adds two expressions together. More...

#include <Oasis/Add.hpp>

Inheritance diagram for Oasis::Add< AugendT, AddendT >:

Collaboration diagram for Oasis::Add< AugendT, AddendT >:

Public Member Functions
	Add ()=default
	Add (const Add< AugendT, AddendT > &other)
	Add (const AugendT &addend1, const AddendT &addend2)
auto	operator= (const Add &other) -> Add &=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 AugendT = Expression, typename AddendT = AugendT>
class Oasis::Add< AugendT, AddendT >

The Add expression adds two expressions together.

The Add expression takes in two parameters of any Oasis type. The Add expression may take in more than two parameters of Real types.

Parameters

Template Parameters

AugendT	The type of the expression to add be added to.
AddendT	The type of the expression to add to the augend.

Usage:

The Add expression can take in a multitude of Oasis classes.

Adding two Real values together:

Oasis::Add myAdditionSimple {
     Oasis::Real{4},
     Oasis::Real{4},
 };
 Oasis::InFixSerializer result;
 
   auto resultant = myAdditionSimple.Simplify();
 
 std::println("Result of addition: {}", resultant->Accept(result).value());
 // Will print 8

Adding a Real value and a Variable together:

Oasis::Add myAddition {
     Oasis::Variable{"x"},
     Oasis::Real{4}
 };
 //Oasis::InFixSerializer result;
 
 resultant = myAddition.Simplify();
 
 std::println("Result of addition: {}", resultant->Accept(result).value());
 // Will print x+4

Adding two Variables together:

Oasis::Add myAdditionX {
     Oasis::Variable{"x"},
     Oasis::Variable{"x"}
 };
 
 resultant = myAdditionX.Simplify();
 
 std::println("Result of addition: {}", resultant->Accept(result).value());
 // Will print 2*x

if they are not the same variable:

Oasis::Add myAdditionXY {
     Oasis::Variable{"x"},
     Oasis::Variable{"y"}
 };
 
 resultant = myAdditionXY.SimplifyVisitor();
 
 std::println("Result of addition: {}", resultant->Accept(result).value());
 // Will print x+y

Adding more than two values together:

auto myAdditionSimple = Oasis::Add<> {
    Oasis::Real{4},
    Oasis::Real{4},
    Oasis::Real{4}
};
Oasis::InFixSerializer result;
 
auto resultant = myAdditionSimple.Simplify();
 
std::println("Result of addition: {}", resultant->Accept(result).value());

Adding two expressions together:

std::string expr1 = {"2x+3y+15"};
std::string expr2 = {"5x+9y-10"};
 
const auto prepoc1 = Oasis::PreProcessInFix(expr1);
const auto prepoc2 = Oasis::PreProcessInFix(expr2);
 
auto midResult1 = Oasis::FromInFix(prepoc1);
auto midResult2 = Oasis::FromInFix(prepoc2);
 
const std::unique_ptr<Oasis::Expression> expression1 = std::move(midResult1).value();
const std::unique_ptr<Oasis::Expression> expression2 = std::move(midResult2).value();
 
Oasis::Add exprAdd {
    *expression1,
    *expression2
};
Oasis::InFixSerializer result;
 
auto resultant = exprAdd.Simplify();
 
std::println("Result: {}", resultant->Accept(result).value());
// Will print (((7*x)+(12*y))+5)

Constructor & Destructor Documentation

Add() [1/3]

template<typename AugendT = Expression, typename AddendT = AugendT>

Oasis::Add< AugendT, AddendT >::Add ( )

default

Add() [2/3]

template<typename AugendT = Expression, typename AddendT = AugendT>

Oasis::Add< AugendT, AddendT >::Add ( const Add< AugendT, AddendT > & other )

inline

Add() [3/3]

template<typename AugendT = Expression, typename AddendT = AugendT>

Oasis::Add< AugendT, AddendT >::Add ( const AugendT & addend1, const AddendT & addend2 )

inline

Member Function Documentation

operator=()

template<typename AugendT = Expression, typename AddendT = AugendT>

auto Oasis::Add< AugendT, AddendT >::operator= ( const Add< AugendT, AddendT > & other ) -> Add &=default

default

---

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

• include/Oasis/Add.hpp