binary_ops.hpp File Reference

Go to the source code of this file.

Classes
struct	sym::detail::Add
struct	sym::ApplySymbolicOps< LHS, RHS >
	Simple combination rule to enable Symbolic operations, but avoid redundantly specifying where two SymbolicOperator classes are operated on. More...
struct	sym::BinaryOp< LHS, Op, RHS >
	Symbolic representation of a binary symbolic operation. More...
struct	sym::distributive< Op, OverOp >
struct	sym::detail::Divide
struct	sym::left_distributive< Op, OverOp >
struct	sym::left_distributive< detail::Multiply, detail::Add >
struct	sym::detail::Multiply
struct	sym::detail::NoIdentity
struct	sym::detail::Power
struct	sym::right_distributive< Op, OverOp >
struct	sym::right_distributive< detail::Divide, detail::Add >
struct	sym::right_distributive< detail::Power, detail::Multiply >
struct	sym::detail::Subtract

Namespaces
	sym
	The stator symbolic math library.
	sym::detail
	Namespace containing the details of the implmentation for general stator components.

Typedefs
template<class LHS , class RHS >
using	sym::AddOp = BinaryOp< LHS, detail::Add, RHS >
template<class LHS , class RHS >
using	sym::DivideOp = BinaryOp< LHS, detail::Divide, RHS >
template<class LHS , class RHS >
using	sym::MultiplyOp = BinaryOp< LHS, detail::Multiply, RHS >
template<class LHS , class RHS >
using	sym::PowerOp = BinaryOp< LHS, detail::Power, RHS >
template<class LHS , class RHS >
using	sym::SubtractOp = BinaryOp< LHS, detail::Subtract, RHS >

Enumerations
enum	sym::detail::Associativity { sym::detail::Associativity::LEFT, sym::detail::Associativity::RIGHT, sym::detail::Associativity::NONE }

Functions
template<class Op >
constexpr int	sym::detail::NBP ()
template<class LHS , class RHS , typename = typename std::enable_if<(std::is_arithmetic<LHS>::value && std::is_arithmetic<RHS>::value)>::type>
auto	sym::pow (const LHS &l, const RHS &r) -> STATOR_AUTORETURN(std::pow(l, r))
template<class LHS , std::intmax_t num, std::intmax_t den, typename = typename std::enable_if<std::is_arithmetic<LHS>::value>::type>
auto	sym::pow (const LHS &l, const C< num, den > &r) -> STATOR_AUTORETURN(std::pow(l, double(r)))
template<class LHS , typename = typename std::enable_if<std::is_arithmetic<LHS>::value>::type>
auto	sym::pow (const LHS &l, const C< 1, 3 > &r) -> STATOR_AUTORETURN(std::cbrt(l))
template<class LHS , typename = typename std::enable_if<std::is_arithmetic<LHS>::value>::type>
auto	sym::pow (const LHS &l, const C< 1, 2 > &r) -> STATOR_AUTORETURN(std::sqrt(l))
template<class LHS , typename = typename std::enable_if<std::is_base_of<Eigen::EigenBase<LHS>, LHS>::value>::type>
auto	sym::pow (const LHS &l, const C< 2, 1 > &r) -> STATOR_AUTORETURN_BYVALUE(l.squaredNorm())
template<class LHS >
auto	sym::pow (const LHS &l, const C< 1, 1 > &r) -> STATOR_AUTORETURN(l)
template<std::intmax_t num1, std::intmax_t den1, std::intmax_t num2>
auto	sym::pow (const C< num1, den1 > &l, const C< num2, 1 > &r) -> STATOR_AUTORETURN(PowerOpSub< num2 >::eval(sub(l, num2)))
template<class Op >
constexpr int	sym::detail::RBP ()
template<class LHS , class RHS , class Op , class Var , class Arg >
auto	sym::sub (BinaryOp< LHS, Op, RHS > f, Relation< Var, Arg > x) -> STATOR_AUTORETURN_BYVALUE(Op::apply(sub(f._l, x), sub(f._r, x)))
Symbolic algebra
template<class Arg , typename = typename std::enable_if<IsSymbolic<SymbolicOperator>::value>::type>
Arg	sym::operator+ (const Arg &l)
	Symbolic unary positive operator. More...
template<class Arg , typename = typename std::enable_if<IsSymbolic<SymbolicOperator>::value>::type>
auto	sym::operator- (const Arg &l) -> STATOR_AUTORETURN(C<-1 >() *l) template< class LHS, class RHS, typename=typename std::enable_if< ApplySymbolicOps< LHS, RHS >::value >::type > auto operator+(const LHS &l, const RHS &r) -> STATOR_AUTORETURN((AddOp< decltype(store(l)), decltype(store(r))>(l, r))) template< class LHS, class RHS, typename=typename std::enable_if< ApplySymbolicOps< LHS, RHS >::value >::type > auto operator*(const LHS &l, const RHS &r) -> STATOR_AUTORETURN((MultiplyOp< decltype(store(l)), decltype(store(r))>(l, r))) template< class LHS, class RHS, typename=typename std::enable_if< ApplySymbolicOps< LHS, RHS >::value >::type > auto operator-(const LHS &l, const RHS &r) -> STATOR_AUTORETURN((SubtractOp< decltype(store(l)), decltype(store(r))>(l, r))) template< class LHS, class RHS, typename=typename std::enable_if< ApplySymbolicOps< LHS, RHS >::value >::type > auto operator/(const LHS &l, const RHS &r) -> STATOR_AUTORETURN((DivideOp< decltype(store(l)), decltype(store(r))>(l, r))) template< class LHS, class RHS, typename=typename std::enable_if< ApplySymbolicOps< LHS, RHS >::value >::type > auto pow(const LHS &l, const RHS &r) -> STATOR_AUTORETURN((PowerOp< decltype(store(l)), decltype(store(r))>(l, r)))
	Symbolic unary negation operator. More...
template<class Var , class LHS , class RHS >
auto	sym::derivative (const AddOp< LHS, RHS > &f, Var v) -> STATOR_AUTORETURN(derivative(f._l, v)+derivative(f._r, v)) template< class Var, class LHS, class RHS > auto derivative(const SubtractOp< LHS, RHS > &f, Var v) -> STATOR_AUTORETURN(derivative(f._l, v) - derivative(f._r, v)) template< class Var, class LHS, class RHS > auto derivative(const MultiplyOp< LHS, RHS > &f, Var v) -> STATOR_AUTORETURN(derivative(f._l, v) *f._r+f._l *derivative(f._r, v)) template< class Var, class LHS, class RHS > auto derivative(const DivideOp< LHS, RHS > &f, Var v) -> STATOR_AUTORETURN((derivative(f._l, v) *f._r - f._l *derivative(f._r, v))/pow(f._r, C< 2 >())) template< class Var, class Arg, std::intmax_t num, std::intmax_t den > auto derivative(const PowerOp< Arg, C< num, den > > &f, Var v) -> STATOR_AUTORETURN((C< num, den >() *derivative(f._l, v) *pow(f._l, C< num, den >() -C< 1 >())))
	Derivatives of AddOp operations. More...
template<class Var , class Arg , class Power >
auto	sym::derivative (const PowerOp< Arg, Power > &f, Var v) -> STATOR_AUTORETURN(f._r *derivative(f._l, v) *pow(f._l, f._r - C< 1 >())+derivative(f._r, v) *log(f._l) *f)
	Derivative of a PowerOp operation. More...