Classes
class	CTAdd
	Addition operator node. More...

class	CTArrayRef
	Array variable value, referencing an entry in an indexable container of T types. More...

class	CTBase
	All compile time derivative system objects derive from this (empty) base class. More...

class	CTBinary
	Base class for a binary operator/function. More...

class	CTCompare
	Binary comparison operator node. More...

class	CTConditional
	Base class for a ternary functions. More...

class	CTDiv
	Division operator node. More...

class	CTIPow
	Integer exponent power operator. More...

class	CTMatrix

class	CTMul
	Multiplication operator node. More...

class	CTNull
	Template class to represent a "zero" value. More...

class	CTNullBase

class	CTOne
	Template class to represent a "one" value. More...

class	CTOneBase

class	CTPow
	Power operator where both base and exponent can be arbitrary operators. More...

class	CTRef
	Variable value, referencing a variable of type T. More...

class	CTStandardDeviation

class	CTSub
	Subtraction operator node. More...

struct	CTSuperType

struct	CTSuperType< T >

struct	CTSuperType< T1, T2, Ts... >

class	CTUnary
	Base class for a unary operator/function. More...

class	CTUnaryMinus
	Unary minus. More...

class	CTValue
	Constant value. More...

Typedefs
template<typename T >
using	CTCleanType = typename std::remove_const< typename std::remove_reference< T >::type >::type

using	CTTag = int
	Operators representing variable values need to be tagged.

template<typename L , typename R >
using	CTCompareLess = CTCompare< CTComparisonEnum::Less, L, R >
	template aliases for the comparison operator nodes

template<typename L , typename R >
using	CTCompareLessEqual = CTCompare< CTComparisonEnum::LessEqual, L, R >

template<typename L , typename R >
using	CTCompareGreater = CTCompare< CTComparisonEnum::Greater, L, R >

template<typename L , typename R >
using	CTCompareGreaterEqual = CTCompare< CTComparisonEnum::GreaterEqual, L, R >

template<typename L , typename R >
using	CTCompareEqual = CTCompare< CTComparisonEnum::Equal, L, R >

template<typename L , typename R >
using	CTCompareUnequal = CTCompare< CTComparisonEnum::Unequal, L, R >

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

Functions
template<CTTag tag>
std::string	printTag ()

template<typename B , typename E >
auto	pow (const B &base, const E &exp)
	pow(base, exponent) function overload.

template<int E, typename B >
auto	pow (const B &base)
	pow<exponent>(base) template for integer powers.

template<typename T >
auto	exp (const T &)

template<typename T >
auto	log (const T &)

template<typename T , class = std::enable_if_t<std::is_base_of<CTBase, T>::value>>
auto	operator- (const T &arg)

template<typename C , typename L , typename R >
auto	conditional (const C &, const L &, const R &)

template<typename L , typename R >
auto	min (const L &left, const R &right)

template<typename L , typename R >
auto	max (const L &left, const R &right)

template<CTTag tag = CTNoTag, typename T >
auto	makeValue (T value)
	Helper function to build a (potentially tagged) value.

template<CTTag start_tag, typename... Values, CTTag... Tags>
auto	makeValuesHelper (const std::tuple< Values... > &values, std::integer_sequence< CTTag, Tags... >)

template<CTTag start_tag = CTNoTag, typename... Ts>
auto	makeValues (Ts... values)
	Helper function to build a list of (potentially tagged) values.

template<CTTag tag = CTNoTag, typename T >
auto	makeRef (const T &ref)
	Helper function to build a tagged reference to a variable.

template<CTTag start_tag, typename... Refs, CTTag... Tags>
auto	makeRefsHelper (const std::tuple< Refs... > &refs, std::integer_sequence< CTTag, Tags... >)

template<CTTag start_tag = CTNoTag, typename... Ts>
auto	makeRefs (const Ts &... refs)
	Helper function to build a list of tagged references to variables.

template<CTTag tag = CTNoTag, typename T , typename I >
auto	makeRef (const T &ref, const I &idx)
	Helper function to build a tagged reference to a vector/array entry.

	CT_OPERATOR_BINARY (+, CTAdd) CT_OPERATOR_BINARY(-

CTSub CT_OPERATOR_BINARY CTMul	CT_OPERATOR_BINARY (/, CTDiv) CT_OPERATOR_BINARY(<

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess	CT_OPERATOR_BINARY (<=, CTCompareLessEqual) CT_OPERATOR_BINARY(>

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater	CT_OPERATOR_BINARY (>=, CTCompareGreaterEqual) CT_OPERATOR_BINARY(

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual	CT_OPERATOR_BINARY (!=, CTCompareUnequal) CT_SIMPLE_UNARY_FUNCTION(exp
	Macro for implementing a simple unary function overload.

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual	exp (_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(log

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	D< dtag > ()/_arg) CT_SIMPLE_UNARY_FUNCTION(sin

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	cos (_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(cos

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template *	sin (_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tan

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	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 *	sqrt (_arg)) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tanh

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	pow< 2 > (tanh(_arg))) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(sinh

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	cosh (_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(cosh

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template	sinh (_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(erf

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template *	exp (-pow< 2 >(_arg))/sqrt(libMesh
	Macro for implementing a simple binary function overload.

	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	makeStandardDeviationHelper (const T &f, std::integer_sequence< CTTag, Tags... >)

template<CTTag start_tag, typename T , int N>
auto	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.

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

int	N

Typedef Documentation

◆ CTCleanType

template<typename T >

using CompileTimeDerivatives::CTCleanType = typedef typename std::remove_const<typename std::remove_reference<T>::type>::type

Definition at line 41 of file CompileTimeDerivatives.h.

◆ CTCompareEqual

template<typename L , typename R >

using CompileTimeDerivatives::CTCompareEqual = typedef CTCompare<CTComparisonEnum::Equal, L, R>

Definition at line 659 of file CompileTimeDerivatives.h.

◆ CTCompareGreater

template<typename L , typename R >

using CompileTimeDerivatives::CTCompareGreater = typedef CTCompare<CTComparisonEnum::Greater, L, R>

Definition at line 655 of file CompileTimeDerivatives.h.

◆ CTCompareGreaterEqual

template<typename L , typename R >

using CompileTimeDerivatives::CTCompareGreaterEqual = typedef CTCompare<CTComparisonEnum::GreaterEqual, L, R>

Definition at line 657 of file CompileTimeDerivatives.h.

◆ CTCompareLess

template<typename L , typename R >

using CompileTimeDerivatives::CTCompareLess = typedef CTCompare<CTComparisonEnum::Less, L, R>

template aliases for the comparison operator nodes

Definition at line 651 of file CompileTimeDerivatives.h.

◆ CTCompareLessEqual

template<typename L , typename R >

using CompileTimeDerivatives::CTCompareLessEqual = typedef CTCompare<CTComparisonEnum::LessEqual, L, R>

Definition at line 653 of file CompileTimeDerivatives.h.

◆ CTCompareUnequal

template<typename L , typename R >

using CompileTimeDerivatives::CTCompareUnequal = typedef CTCompare<CTComparisonEnum::Unequal, L, R>

Definition at line 661 of file CompileTimeDerivatives.h.

◆ CTTag

using CompileTimeDerivatives::CTTag = typedef int

Operators representing variable values need to be tagged.

The tag identifies the object when a compile time derivative is taken. We use a type that can be supplied as a template argument. int does the trick.

Definition at line 66 of file CompileTimeDerivatives.h.

Enumeration Type Documentation

◆ CTComparisonEnum

enum class CompileTimeDerivatives::CTComparisonEnum

strong

Enumerator
Less
LessEqual
Greater
GreaterEqual
Equal
Unequal

Definition at line 586 of file CompileTimeDerivatives.h.

{
  Less,
  LessEqual,
  Greater,
  GreaterEqual,
  Equal,
  Unequal
};

Function Documentation

◆ conditional()

template<typename C , typename L , typename R >

auto CompileTimeDerivatives::conditional	(	const C &	condition,
		const L &	left,
		const R &	right
	)

Definition at line 262 of file CompileTimeDerivatives.h.

{
  return CTConditional<C, L, R>(condition, left, right);
}

Referenced by CompileTimeDerivatives::CTConditional< C, L, R >::D().

◆ cos()

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template CompileTimeDerivatives::cos ( _arg )

◆ cosh()

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template CompileTimeDerivatives::cosh ( _arg )

◆ CT_OPERATOR_BINARY() [1/5]

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual CompileTimeDerivatives::CT_OPERATOR_BINARY	(	!	,
		CTCompareUnequal
	)

Macro for implementing a simple unary function overload.

No function specific optimizations are possible. The parameters are the function name and the expression that returns the derivative of the function.

◆ CT_OPERATOR_BINARY() [2/5]

CompileTimeDerivatives::CT_OPERATOR_BINARY	(	+	,
		CTAdd
	)

◆ CT_OPERATOR_BINARY() [3/5]

CTSub CT_OPERATOR_BINARY CTMul CompileTimeDerivatives::CT_OPERATOR_BINARY	(	/	,
		CTDiv
	)

◆ CT_OPERATOR_BINARY() [4/5]

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CompileTimeDerivatives::CT_OPERATOR_BINARY	(	<=	,
		CTCompareLessEqual
	)

◆ CT_OPERATOR_BINARY() [5/5]

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CompileTimeDerivatives::CT_OPERATOR_BINARY	(	>=	,
		CTCompareGreaterEqual
	)

◆ CT_SIMPLE_BINARY_FUNCTION_CLASS()

CompileTimeDerivatives::CT_SIMPLE_BINARY_FUNCTION_CLASS	(	atan2	,
		(-_left _right.template D< dtag >()+ _left.template D< dtag >() _right)/(pow< 2 >(_left)+pow< 2 >(_right))
	)

◆ D< dtag >()

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template CompileTimeDerivatives::D< dtag > ( )

Referenced by CompileTimeDerivatives::CTUnaryMinus< T >::D(), CompileTimeDerivatives::CTConditional< C, L, R >::D(), CompileTimeDerivatives::CTAdd< L, R >::D(), CompileTimeDerivatives::CTSub< L, R >::D(), CompileTimeDerivatives::CTMul< L, R >::D(), CompileTimeDerivatives::CTDiv< L, R >::D(), CompileTimeDerivatives::CTPow< L, R >::D(), and CompileTimeDerivatives::CTIPow< B, E >::D().

◆ exp() [1/3]

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * CompileTimeDerivatives::exp ( -pow< 2 > _arg )

Macro for implementing a simple binary function overload.

No function specific optimizations are possible. The parameters are the function name and the expression that returns the derivative of the function.

Definition at line 865 of file CompileTimeDerivatives.h.

                  : public CTBinary<L, R>                                                          \
  {                                                                                                \
  public:                                                                                          \
    CTF##name(L left, R right) : CTBinary<L, R>(left, right) {}                                    \
    auto operator()() const                                                                        \
    {                                                                                              \
      using std::name;                                                                             \
      return name(_left(), _right());                                                              \
    }                                                                                              \
    template <CTTag dtag>                                                                          \
    auto D() const                                                                                 \
    {                                                                                              \
      return derivative;                                                                           \
    }                                                                                              \
    std::string print() const { return #name "(" + _left.print() + ", " + _right.print() + ")"; }  \
    constexpr static int precedence() { return 2; }                                                \
    using typename CTBinary<L, R>::ResultType;                                                     \
    using CTBinary<L, R>::_left;                                                                   \
    using CTBinary<L, R>::_right;                                                                  \
  };

◆ exp() [2/3]

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual CompileTimeDerivatives::exp ( _arg )

◆ exp() [3/3]

template<typename T >

auto CompileTimeDerivatives::exp ( const T & )

Referenced by pow().

◆ log()

template<typename T >

auto CompileTimeDerivatives::log ( const T & )

Referenced by CompileTimeDerivatives::CTPow< L, R >::D().

◆ makeRef() [1/2]

template<CTTag tag = CTNoTag, typename T >

auto CompileTimeDerivatives::makeRef ( const T & ref )

Helper function to build a tagged reference to a variable.

Definition at line 367 of file CompileTimeDerivatives.h.

{
  return CTRef<tag, T>(ref);
}

◆ makeRef() [2/2]

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.

Definition at line 430 of file CompileTimeDerivatives.h.

{
  return CTArrayRef<tag, T, I>(ref, idx);
}

◆ makeRefs()

template<CTTag start_tag = CTNoTag, typename... Ts>

auto CompileTimeDerivatives::makeRefs ( const Ts &... refs )

Helper function to build a list of tagged references to variables.

Definition at line 387 of file CompileTimeDerivatives.h.

{
  return makeRefsHelper<start_tag>(std::tie(refs...),
                                   std::make_integer_sequence<CTTag, sizeof...(refs)>{});
}

◆ makeRefsHelper()

template<CTTag start_tag, typename... Refs, CTTag... Tags>

auto CompileTimeDerivatives::makeRefsHelper	(	const std::tuple< Refs... > &	refs,
		std::integer_sequence< CTTag, Tags... >
	)

Definition at line 374 of file CompileTimeDerivatives.h.

{
  if constexpr (start_tag == CTNoTag)
    return std::make_tuple(CTRef<CTNoTag, Refs>(std::get<Tags>(refs))...);
  else
    return std::make_tuple(CTRef<Tags + start_tag, Refs>(std::get<Tags>(refs))...);
}

◆ makeStandardDeviation()

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.

Definition at line 977 of file CompileTimeDerivatives.h.

{
  return CTStandardDeviation(
      makeStandardDeviationHelper<start_tag>(f, std::make_integer_sequence<CTTag, N>{}),
      covariance);
}

◆ makeStandardDeviationHelper()

template<CTTag start_tag, typename T , CTTag... Tags>

auto CompileTimeDerivatives::makeStandardDeviationHelper	(	const T &	f,
		std::integer_sequence< CTTag, Tags... >
	)

Definition at line 966 of file CompileTimeDerivatives.h.

{
  return std::make_tuple(f.template D<Tags + start_tag>()...);
}

◆ makeValue()

template<CTTag tag = CTNoTag, typename T >

auto CompileTimeDerivatives::makeValue ( T value )

Helper function to build a (potentially tagged) value.

Definition at line 309 of file CompileTimeDerivatives.h.

{
  return CTValue<tag, T>(value);
}

Referenced by pow(), and pow().

◆ makeValues()

template<CTTag start_tag = CTNoTag, typename... Ts>

auto CompileTimeDerivatives::makeValues ( Ts... values )

Helper function to build a list of (potentially tagged) values.

Definition at line 329 of file CompileTimeDerivatives.h.

{
  return makeValuesHelper<start_tag>(std::tuple(values...),
                                     std::make_integer_sequence<CTTag, sizeof...(values)>{});
}

◆ makeValuesHelper()

template<CTTag start_tag, typename... Values, CTTag... Tags>

auto CompileTimeDerivatives::makeValuesHelper	(	const std::tuple< Values... > &	values,
		std::integer_sequence< CTTag, Tags... >
	)

Definition at line 316 of file CompileTimeDerivatives.h.

{
  if constexpr (start_tag == CTNoTag)
    return std::make_tuple(CTValue<CTNoTag, Values>(std::get<Tags>(values))...);
  else
    return std::make_tuple(CTValue<Tags + start_tag, Values>(std::get<Tags>(values))...);
}

◆ max()

template<typename L , typename R >

auto CompileTimeDerivatives::max	(	const L &	left,
		const R &	right
	)

Definition at line 276 of file CompileTimeDerivatives.h.

{
  return CTConditional<decltype(left > right), L, R>(left > right, left, right);
}

◆ min()

template<typename L , typename R >

auto CompileTimeDerivatives::min	(	const L &	left,
		const R &	right
	)

Definition at line 269 of file CompileTimeDerivatives.h.

{
  return CTConditional<decltype(left < right), L, R>(left < right, left, right);
}

◆ operator-()

template<typename T , class = std::enable_if_t<std::is_base_of<CTBase, T>::value>>

auto CompileTimeDerivatives::operator- ( const T & arg )

Definition at line 183 of file CompileTimeDerivatives.h.

{
  return CTUnaryMinus<T>(arg);
}

◆ pow() [1/2]

template<int E, typename B >

auto CompileTimeDerivatives::pow ( const B & base )

pow<exponent>(base) template for integer powers.

Definition at line 777 of file CompileTimeDerivatives.h.

{
  if constexpr (std::is_base_of<CTBase, B>::value)
    return CTIPow<B, E>(base);
  else
    return CTIPow<CTValue<CTNoTag, B>, E>(makeValue(base));
}

◆ pow() [2/2]

template<typename B , typename E >

auto CompileTimeDerivatives::pow	(	const B &	base,
		const E &	exp
	)

pow(base, exponent) function overload.

Definition at line 715 of file CompileTimeDerivatives.h.

{
  if constexpr (std::is_base_of<CTBase, B>::value && std::is_base_of<CTBase, E>::value)
    return CTPow(base, exp);
  else if constexpr (std::is_base_of<CTBase, E>::value)
    return CTPow(makeValue(base), exp);
  else if constexpr (std::is_base_of<CTBase, B>::value)
    return CTPow(base, makeValue(exp));
  else
    return CTPow(makeValue(base), makeValue(exp));
}

Referenced by CompileTimeDerivatives::CTPow< L, R >::D(), and CompileTimeDerivatives::CTIPow< B, E >::D().

◆ pow< 2 >() [1/2]

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template CompileTimeDerivatives::pow< 2 > ( tan(_arg) )

◆ pow< 2 >() [2/2]

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template CompileTimeDerivatives::pow< 2 > ( tanh(_arg) )

◆ printTag()

template<CTTag tag>

std::string CompileTimeDerivatives::printTag ( )

Definition at line 71 of file CompileTimeDerivatives.h.

{
  if constexpr (tag == CTNoTag)
    return "";
  else
    return Moose::stringify(tag);
}

◆ sin()

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * CompileTimeDerivatives::sin ( _arg )

◆ sinh()

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template CompileTimeDerivatives::sinh ( _arg )

◆ sqrt()

CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * CompileTimeDerivatives::sqrt ( _arg )

Variable Documentation

◆ CTNoTag

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

constexpr

Definition at line 67 of file CompileTimeDerivatives.h.

Referenced by makeRefsHelper(), makeValuesHelper(), and printTag().

◆ N

int CompileTimeDerivatives::N

Definition at line 916 of file CompileTimeDerivatives.h.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ CTCleanType

◆ CTCompareEqual

◆ CTCompareGreater

◆ CTCompareGreaterEqual

◆ CTCompareLess

◆ CTCompareLessEqual

◆ CTCompareUnequal

◆ CTTag

Enumeration Type Documentation

◆ CTComparisonEnum

Function Documentation

◆ conditional()

◆ cos()

◆ cosh()

◆ CT_OPERATOR_BINARY() [1/5]

◆ CT_OPERATOR_BINARY() [2/5]

◆ CT_OPERATOR_BINARY() [3/5]

◆ CT_OPERATOR_BINARY() [4/5]

◆ CT_OPERATOR_BINARY() [5/5]

◆ CT_SIMPLE_BINARY_FUNCTION_CLASS()

◆ D< dtag >()

◆ exp() [1/3]

◆ exp() [2/3]

◆ exp() [3/3]

◆ log()

◆ makeRef() [1/2]

◆ makeRef() [2/2]

◆ makeRefs()

◆ makeRefsHelper()

◆ makeStandardDeviation()

◆ makeStandardDeviationHelper()

◆ makeValue()

◆ makeValues()

◆ makeValuesHelper()

◆ max()

◆ min()

◆ operator-()

◆ pow() [1/2]

◆ pow() [2/2]

◆ pow< 2 >() [1/2]

◆ pow< 2 >() [2/2]

◆ printTag()

◆ sin()

◆ sinh()

◆ sqrt()

Variable Documentation

◆ CTNoTag

◆ N