CompileTimeDerivatives.h File Reference

Go to the source code of this file.

Classes
class	CompileTimeDerivatives::CTBase
	All compile time derivative system objects derive from this (empty) base class. More...
class	CompileTimeDerivatives::CTNullBase
class	CompileTimeDerivatives::CTOneBase
struct	CompileTimeDerivatives::CTSuperType< Ts >
struct	CompileTimeDerivatives::CTSuperType< T >
struct	CompileTimeDerivatives::CTSuperType< T1, T2, Ts... >
class	CompileTimeDerivatives::CTNull< T >
	Template class to represent a "zero" value. More...
class	CompileTimeDerivatives::CTOne< T >
	Template class to represent a "one" value. More...
class	CompileTimeDerivatives::CTUnary< T >
	Base class for a unary operator/function. More...
class	CompileTimeDerivatives::CTUnaryMinus< T >
	Unary minus. More...
class	CompileTimeDerivatives::CTBinary< L, R >
	Base class for a binary operator/function. More...
class	CompileTimeDerivatives::CTConditional< C, L, R >
	Base class for a ternary functions. More...
class	CompileTimeDerivatives::CTValue< tag, T >
	Constant value. More...
class	CompileTimeDerivatives::CTRef< tag, T >
	Variable value, referencing a variable of type T. More...
class	CompileTimeDerivatives::CTArrayRef< tag, T, I >
	Array variable value, referencing an entry in an indexable container of T types. More...
class	CompileTimeDerivatives::CTAdd< L, R >
	Addition operator node. More...
class	CompileTimeDerivatives::CTSub< L, R >
	Subtraction operator node. More...
class	CompileTimeDerivatives::CTMul< L, R >
	Multiplication operator node. More...
class	CompileTimeDerivatives::CTDiv< L, R >
	Division operator node. More...
class	CompileTimeDerivatives::CTCompare< C, L, R >
	Binary comparison operator node. More...
class	CompileTimeDerivatives::CTPow< L, R >
	Power operator where both base and exponent can be arbitrary operators. More...
class	CompileTimeDerivatives::CTIPow< B, E >
	Integer exponent power operator. More...
class	CompileTimeDerivatives::CTMatrix
class	CompileTimeDerivatives::CTStandardDeviation< Ds >

Namespaces
	CompileTimeDerivatives

Typedefs
template<typename T >
using	CompileTimeDerivatives::CTCleanType = typename std::remove_const< typename std::remove_reference< T >::type >::type
using	CompileTimeDerivatives::CTTag = int
	Operators representing variable values need to be tagged. More...
template<typename L , typename R >
using	CompileTimeDerivatives::CTCompareLess = CTCompare< CTComparisonEnum::Less, L, R >
	template aliases for the comparison operator nodes More...
template<typename L , typename R >
using	CompileTimeDerivatives::CTCompareLessEqual = CTCompare< CTComparisonEnum::LessEqual, L, R >
template<typename L , typename R >
using	CompileTimeDerivatives::CTCompareGreater = CTCompare< CTComparisonEnum::Greater, L, R >
template<typename L , typename R >
using	CompileTimeDerivatives::CTCompareGreaterEqual = CTCompare< CTComparisonEnum::GreaterEqual, L, R >
template<typename L , typename R >
using	CompileTimeDerivatives::CTCompareEqual = CTCompare< CTComparisonEnum::Equal, L, R >
template<typename L , typename R >
using	CompileTimeDerivatives::CTCompareUnequal = CTCompare< CTComparisonEnum::Unequal, L, R >

Enumerations
enum	CompileTimeDerivatives::CTComparisonEnum {   CompileTimeDerivatives::CTComparisonEnum::Less, CompileTimeDerivatives::CTComparisonEnum::LessEqual, CompileTimeDerivatives::CTComparisonEnum::Greater, CompileTimeDerivatives::CTComparisonEnum::GreaterEqual,   CompileTimeDerivatives::CTComparisonEnum::Equal, CompileTimeDerivatives::CTComparisonEnum::Unequal }

Functions
template<CTTag tag>
std::string	CompileTimeDerivatives::printTag ()
template<typename B , typename E >
auto	CompileTimeDerivatives::pow (const B &base, const E &exp)
	pow(base, exponent) function overload. More...
template<int E, typename B >
auto	CompileTimeDerivatives::pow (const B &base)
	pow<exponent>(base) template for integer powers. More...
template<typename T >
auto	CompileTimeDerivatives::exp (const T &)
template<typename T >
auto	CompileTimeDerivatives::log (const T &)
template<typename T , class = std::enable_if_t<std::is_base_of<CTBase, T>::value>>
auto	CompileTimeDerivatives::operator- (const T &arg)
template<typename C , typename L , typename R >
auto	CompileTimeDerivatives::conditional (const C &, const L &, const R &)
template<typename L , typename R >
auto	CompileTimeDerivatives::min (const L &left, const R &right)
template<typename L , typename R >
auto	CompileTimeDerivatives::max (const L &left, const R &right)
template<CTTag tag = CTNoTag, typename T >
auto	CompileTimeDerivatives::makeValue (T value)
	Helper function to build a (potentially tagged) value. More...
template<CTTag start_tag, typename... Values, CTTag... Tags>
auto	CompileTimeDerivatives::makeValuesHelper (const std::tuple< Values... > &values, std::integer_sequence< CTTag, Tags... >)
template<CTTag start_tag = CTNoTag, typename... Ts>
auto	CompileTimeDerivatives::makeValues (Ts... values)
	Helper function to build a list of (potentially tagged) values. More...
template<CTTag tag = CTNoTag, typename T >
auto	CompileTimeDerivatives::makeRef (const T &ref)
	Helper function to build a tagged reference to a variable. More...
template<CTTag start_tag, typename... Refs, CTTag... Tags>
auto	CompileTimeDerivatives::makeRefsHelper (const std::tuple< Refs... > &refs, std::integer_sequence< CTTag, Tags... >)
template<CTTag start_tag = CTNoTag, typename... Ts>
auto	CompileTimeDerivatives::makeRefs (const Ts &... refs)
	Helper function to build a list of tagged references to variables. More...
template<CTTag tag = CTNoTag, typename T , typename I >
auto	CompileTimeDerivatives::makeRef (const T &ref, const I &idx)
	Helper function to build a tagged reference to a vector/array entry. More...
	CompileTimeDerivatives::CT_OPERATOR_BINARY (+, CTAdd) CT_OPERATOR_BINARY(-
CTSub CT_OPERATOR_BINARY CTMul	CompileTimeDerivatives::CT_OPERATOR_BINARY (/, CTDiv) CT_OPERATOR_BINARY(<
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess	CompileTimeDerivatives::CT_OPERATOR_BINARY (<=, CTCompareLessEqual) CT_OPERATOR_BINARY(>
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater	CompileTimeDerivatives::CT_OPERATOR_BINARY (>=, CTCompareGreaterEqual) CT_OPERATOR_BINARY(
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual	CompileTimeDerivatives::CT_OPERATOR_BINARY (!=, CTCompareUnequal) CT_SIMPLE_UNARY_FUNCTION(exp
	Macro for implementing a simple unary function overload. More...
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual	CompileTimeDerivatives::exp (_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(log
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	CompileTimeDerivatives::D< dtag > ()/_arg) CT_SIMPLE_UNARY_FUNCTION(sin
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	CompileTimeDerivatives::cos (_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(cos
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template *	CompileTimeDerivatives::sin (_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tan
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	CompileTimeDerivatives::pow< 2 > (tan(_arg))+1.0) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(sqrt
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template *	CompileTimeDerivatives::sqrt (_arg)) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tanh
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	CompileTimeDerivatives::pow< 2 > (tanh(_arg))) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(sinh
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	CompileTimeDerivatives::cosh (_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(cosh
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	CompileTimeDerivatives::sinh (_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(erf
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template *	CompileTimeDerivatives::exp (-pow< 2 >(_arg))/sqrt(libMesh
	Macro for implementing a simple binary function overload. More...
	CompileTimeDerivatives::CT_SIMPLE_BINARY_FUNCTION_CLASS (atan2,(-_left *_right.template D< dtag >()+_left.template D< dtag >() *_right)/(pow< 2 >(_left)+pow< 2 >(_right))) CT_SIMPLE_BINARY_FUNCTION_FUNC(atan2) template< typename T
template<CTTag start_tag, typename T , CTTag... Tags>
auto	CompileTimeDerivatives::makeStandardDeviationHelper (const T &f, std::integer_sequence< CTTag, Tags... >)
template<CTTag start_tag, typename T , int N>
auto	CompileTimeDerivatives::makeStandardDeviation (const T &f, const CTMatrix< Real, N, N > covariance)
	Helper function to build a standard deviation object for a function with N parameters with consecutive tags starting at start_tag, and an NxN covariance matrix for said parameters. More...

Variables
constexpr CTTag	CompileTimeDerivatives::CTNoTag = std::numeric_limits<CTTag>::max()
int	CompileTimeDerivatives::N