Expression layer for composable calculus. More...

Namespaces
namespace	concepts

namespace	detail

namespace	transforms

Classes
struct	AbsTag

struct	AcoshTag

struct	AcosTag

struct	Add

struct	antiderivative_impl

struct	antiderivative_impl< Dim, Binary< Add, L, R > >

struct	antiderivative_impl< Dim, Binary< Mul, Const< T >, R > >

struct	antiderivative_impl< Dim, Binary< Mul, L, Const< T > > >

struct	antiderivative_impl< Dim, Binary< Sub, L, R > >

struct	antiderivative_impl< Dim, Const< T > >

struct	antiderivative_impl< Dim, One< T > >

struct	antiderivative_impl< Dim, Pow< Var< Dim, T >, N > >

struct	antiderivative_impl< Dim, Unary< Neg, E > >

struct	antiderivative_impl< Dim, UnaryFunc< CosTag, Var< Dim, T > > >

struct	antiderivative_impl< Dim, UnaryFunc< ExpTag, Var< Dim, T > > >

struct	antiderivative_impl< Dim, UnaryFunc< SinTag, Var< Dim, T > > >

struct	antiderivative_impl< Dim, Var< Dim, T > >

struct	antiderivative_impl< Dim, Zero< T > >

struct	AnyExpr

struct	AsinhTag

struct	AsinTag

struct	AtanhTag

struct	AtanTag

struct	Binary

struct	BinaryFunc

struct	BoundExpr

struct	BoxIntegral
	N-dimensional integral over a rectangular box. More...

struct	Conditional

struct	Const

struct	ConstBound
	Constant integration bound (e.g., 0.0, 1.0) More...

struct	ConstrainedBoxIntegral
	Box integral with constraint for irregular regions. More...

struct	CoshTag

struct	CosTag

struct	DerivativeBuilder
	Fluent builder for computing symbolic derivatives. More...

struct	Div

struct	ExprBound
	Expression-valued integration bound (depends on outer variables) More...

struct	ExpTag

struct	FiniteProduct

struct	FiniteSum

struct	has_antiderivative

struct	has_antiderivative< Binary< Add, L, R >, Dim >

struct	has_antiderivative< Binary< Mul, L, R >, Dim, std::enable_if_t< has_antiderivative_v< L, Dim > &&(is_const_expr_v< R >\|\|is_zero_v< R >\|\|is_one_v< R >) &&!is_const_expr_v< L > &&!is_zero_v< L > &&!is_one_v< L > > >

struct	has_antiderivative< Binary< Mul, L, R >, Dim, std::enable_if_t<(is_const_expr_v< L >\|\|is_zero_v< L >\|\|is_one_v< L >\|\|(is_expr_node_v< L > &&!std::is_same_v< L, Var< Dim, typename L::value_type > > &&L::arity_v<=Dim)) &&has_antiderivative_v< R, Dim > > >

struct	has_antiderivative< Binary< Sub, L, R >, Dim >

struct	has_antiderivative< Const< T >, Dim >

struct	has_antiderivative< One< T >, Dim >

struct	has_antiderivative< Pow< E, N >, Dim, std::enable_if_t< N !=-1 &&has_antiderivative_v< E, Dim > &&std::is_same_v< E, Var< Dim, typename E::value_type > > > >

struct	has_antiderivative< Unary< Neg, E >, Dim >

struct	has_antiderivative< UnaryFunc< CosTag, E >, Dim, std::enable_if_t< std::is_same_v< E, Var< Dim, typename E::value_type > > > >

struct	has_antiderivative< UnaryFunc< ExpTag, E >, Dim, std::enable_if_t< std::is_same_v< E, Var< Dim, typename E::value_type > > > >

struct	has_antiderivative< UnaryFunc< SinTag, E >, Dim, std::enable_if_t< std::is_same_v< E, Var< Dim, typename E::value_type > > > >

struct	has_antiderivative< Var< N, T >, Dim >

struct	has_antiderivative< Zero< T >, Dim >

struct	Integral
	Definite integral expression node. More...

struct	IntegralBuilder
	Fluent builder for constructing integrals. More...

struct	is_box_integral

struct	is_box_integral< BoxIntegral< E, D > >

struct	is_conditional

struct	is_conditional< Conditional< C, T, E > >

struct	is_const_expr

struct	is_const_expr< Const< T > >

struct	is_constrained_box_integral

struct	is_constrained_box_integral< ConstrainedBoxIntegral< E, D, C > >

struct	is_derivative_builder

struct	is_derivative_builder< DerivativeBuilder< E > >

struct	is_expr_node

struct	is_expr_node< T, std::void_t< decltype(T::arity_v)> >

struct	is_finite_product

struct	is_finite_product< FiniteProduct< E, I > >

struct	is_finite_sum

struct	is_finite_sum< FiniteSum< E, I > >

struct	is_integral

struct	is_integral< Integral< E, Dim, Lo, Hi > >

struct	is_named_var

struct	is_named_var< NamedVar< T > >

struct	is_product_integral

struct	is_product_integral< ProductIntegral< I1, I2 > >

struct	is_separable

struct	is_static_named_var

struct	is_static_named_var< StaticNamedVar< N, T > >

struct	LogTag

struct	MaxTag

struct	MinTag

struct	Mul

struct	NamedVar

struct	Neg

struct	negation_inner

struct	negation_inner< Unary< Neg, E > >

struct	One

struct	Pow

struct	pow_base

struct	pow_base< Pow< E, N > >

struct	PowTag

struct	ProductIntegral
	Product of two independent integrals. More...

struct	SinhTag

struct	SinTag

struct	SqrtTag

struct	StaticNamedVar

struct	Sub

struct	TanhTag

struct	TanTag

struct	TransformedIntegral
	Integral with change of variables (substitution). More...

struct	Unary

struct	UnaryFunc

struct	Var

struct	variable_set

struct	variable_set< Binary< Op, L, R > >
	Binary<Op, L, R>: Union of both children's dependencies. More...

struct	variable_set< BoundExpr< E, Dim, BoundValue > >
	BoundExpr: Remove the bound dimension, keep remaining dependencies. More...

struct	variable_set< ExprBound< E > >
	ExprBound<E>: Same dependencies as the expression. More...

struct	variable_set< Integral< E, Dim, Lo, Hi > >

struct	variable_set< Unary< Op, E > >
	Unary<Op, E>: Same dependencies as child. More...

struct	variable_set< UnaryFunc< Tag, E > >
	UnaryFunc<Tag, E>: Same dependencies as child. More...

struct	variable_set< Var< N, T > >
	Var<N, T>: Variable N depends on dimension N. More...

struct	Zero

Concepts
concept	EvaluableIntegral
	Concept for types that can be evaluated as integrals.

Typedefs
template<typename L , typename R >
using	RuntimePow = BinaryFunc< PowTag, L, R >

template<typename L , typename R >
using	Max = BinaryFunc< MaxTag, L, R >

template<typename L , typename R >
using	Min = BinaryFunc< MinTag, L, R >

template<typename E >
using	pow_base_t = typename pow_base< E >::type

template<typename E >
using	Exp = UnaryFunc< ExpTag, E >

template<typename E >
using	Log = UnaryFunc< LogTag, E >

template<typename E >
using	Sin = UnaryFunc< SinTag, E >

template<typename E >
using	Cos = UnaryFunc< CosTag, E >

template<typename E >
using	Sqrt = UnaryFunc< SqrtTag, E >

template<typename E >
using	Abs = UnaryFunc< AbsTag, E >

template<typename E >
using	Tan = UnaryFunc< TanTag, E >

template<typename E >
using	Sinh = UnaryFunc< SinhTag, E >

template<typename E >
using	Cosh = UnaryFunc< CoshTag, E >

template<typename E >
using	Tanh = UnaryFunc< TanhTag, E >

template<typename E >
using	Asin = UnaryFunc< AsinTag, E >

template<typename E >
using	Acos = UnaryFunc< AcosTag, E >

template<typename E >
using	Atan = UnaryFunc< AtanTag, E >

template<typename E >
using	Asinh = UnaryFunc< AsinhTag, E >

template<typename E >
using	Acosh = UnaryFunc< AcoshTag, E >

template<typename E >
using	Atanh = UnaryFunc< AtanhTag, E >

template<typename E >
using	negation_inner_t = typename negation_inner< E >::type

Functions
template<std::size_t D1, std::size_t D2, typename E >
constexpr auto	separate (E const &expr)

template<std::size_t Dim, typename E >
constexpr auto	antiderivative (E expr)

template<std::size_t Dim, typename E , typename T >
constexpr T	definite_integral_symbolic (E expr, T a, T b)

template<typename E , std::size_t Dims>
constexpr auto	over_box (E expr, std::array< std::pair< typename E::value_type, typename E::value_type >, Dims > bounds)
	Create a box integral from an expression.

template<typename E >
auto	box2d (E expr, typename E::value_type x0, typename E::value_type x1, typename E::value_type y0, typename E::value_type y1)
	Create a 2D box integral (specialization for common case)

template<typename E >
auto	box3d (E expr, typename E::value_type x0, typename E::value_type x1, typename E::value_type y0, typename E::value_type y1, typename E::value_type z0, typename E::value_type z1)
	Create a 3D box integral (specialization for common case)

template<std::size_t Dim, typename E > requires is_expr_node_v<E>
constexpr auto	derivative (E expr)

template<typename E > requires is_expr_node_v<E>
auto	derivative (E expr, std::size_t dim)

template<typename E > requires is_expr_node_v<E>
constexpr auto	gradient (E expr)

template<std::size_t Dim, std::size_t... Dims, typename E > requires is_expr_node_v<E>
constexpr auto	derivative_n (E expr)

template<typename E > requires (is_expr_node_v<E> && !is_derivative_builder_v<E>)
constexpr auto	derivative (E expr)
	Create a DerivativeBuilder for fluent derivative computation.

template<typename T > requires std::is_arithmetic_v<T>
constexpr auto	make_bound (T value)

template<typename E > requires is_expr_node_v<E>
constexpr auto	make_bound (E expr)

template<typename E > requires is_expr_node_v<E>
constexpr auto	integral (E expr)
	Create an IntegralBuilder for fluent integral construction.

template<typename L , typename R > requires (is_expr_node_v<L> && is_expr_node_v<R>)
constexpr auto	operator+ (L l, R r)

template<typename L , typename T > requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)
constexpr auto	operator+ (L l, T r)

template<typename T , typename R > requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)
constexpr auto	operator+ (T l, R r)

template<typename L , typename R > requires (is_expr_node_v<L> && is_expr_node_v<R>)
constexpr auto	operator- (L l, R r)

template<typename L , typename T > requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)
constexpr auto	operator- (L l, T r)

template<typename T , typename R > requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)
constexpr auto	operator- (T l, R r)

template<typename L , typename R > requires (is_expr_node_v<L> && is_expr_node_v<R> && !is_integral<L>::value && !is_integral<R>::value)
constexpr auto	operator* (L l, R r)

template<typename L , typename T > requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)
constexpr auto	operator* (L l, T r)

template<typename T , typename R > requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)
constexpr auto	operator* (T l, R r)

template<typename L , typename R > requires (is_expr_node_v<L> && is_expr_node_v<R>)
constexpr auto	operator/ (L l, R r)

template<typename L , typename T > requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)
constexpr auto	operator/ (L l, T r)

template<typename T , typename R > requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)
constexpr auto	operator/ (T l, R r)

template<typename L , typename R > requires (is_expr_node_v<L> && is_expr_node_v<R>)
constexpr auto	pow (L base, R exponent)

template<typename L , typename T > requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)
constexpr auto	pow (L base, T exponent)

template<typename T , typename R > requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)
constexpr auto	pow (T base, R exponent)

template<typename L , typename R > requires (is_expr_node_v<L> && is_expr_node_v<R>)
constexpr auto	max (L a, R b)

template<typename L , typename T > requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)
constexpr auto	max (L a, T b)

template<typename T , typename R > requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)
constexpr auto	max (T a, R b)

template<typename L , typename R > requires (is_expr_node_v<L> && is_expr_node_v<R>)
constexpr auto	min (L a, R b)

template<typename L , typename T > requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)
constexpr auto	min (L a, T b)

template<typename T , typename R > requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)
constexpr auto	min (T a, R b)

template<std::size_t Dim, typename E , typename T > requires is_expr_node_v<E>
constexpr auto	bind (E expr, T value)

template<std::size_t Dim, std::size_t... Dims, typename E , typename T , typename... Ts> requires is_expr_node_v<E>
constexpr auto	bind_all (E expr, T value, Ts... values)

template<typename E , typename T > requires is_expr_node_v<E>
constexpr auto	partial (E expr, T value)

template<typename E , typename T > requires is_expr_node_v<E>
constexpr auto	partial_right (E expr, T value)

template<typename C , typename T , typename E > requires (is_expr_node_v<C> && is_expr_node_v<T> && is_expr_node_v<E>)
constexpr auto	if_then_else (C cond, T then_expr, E else_expr)

template<typename C , typename T > requires (is_expr_node_v<C> && std::is_arithmetic_v<T>)
constexpr auto	if_then_else (C cond, T then_val, T else_val)

template<typename E > requires is_expr_node_v<E>
constexpr auto	heaviside (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	ramp (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	sign (E e)

template<typename E , typename T > requires (is_expr_node_v<E> && std::is_arithmetic_v<T>)
constexpr auto	clamp (E e, T lo, T hi)

template<typename E > requires is_expr_node_v<E>
constexpr auto	indicator (E e)

template<typename T >
	Const (T) -> Const< T >

template<typename T >
constexpr auto	constant (T value) noexcept

template<typename T = double>
constexpr NamedVar< T >	var (std::size_t dim, std::string_view name) noexcept

template<std::size_t N, typename T = double>
constexpr StaticNamedVar< N, T >	named (std::string_view name) noexcept

template<std::size_t N, typename T , std::size_t... Is>
constexpr auto	declare_vars_impl (std::array< std::string_view, N > const &names, std::index_sequence< Is... >)

template<std::size_t N, typename T = double, typename... Names> requires (sizeof...(Names) == N)
constexpr auto	declare_vars (Names... names)
	Usage: auto [x, y, z] = declare_vars<3>("x", "y", "z");.

template<typename T = double>
constexpr auto	vars_xy (std::string_view x_name="x", std::string_view y_name="y")

template<typename T = double>
constexpr auto	vars_xyz (std::string_view x_name="x", std::string_view y_name="y", std::string_view z_name="z")

template<int N, typename E > requires is_expr_node_v<E>
constexpr auto	pow (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	square (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	cube (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	exp (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	log (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	sin (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	cos (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	sqrt (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	abs (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	tan (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	sinh (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	cosh (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	tanh (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	asin (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	acos (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	atan (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	asinh (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	acosh (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	atanh (E e)

template<std::size_t IndexDim, typename E > requires is_expr_node_v<E>
constexpr auto	sum (E body, int lo, int hi)

template<std::size_t IndexDim, typename E > requires is_expr_node_v<E>
constexpr auto	product (E body, int lo, int hi)

template<typename E > requires is_expr_node_v<E>
constexpr auto	operator- (E e)

template<typename E > requires is_expr_node_v<E>
constexpr auto	operator+ (E e)

template<typename I1 , typename I2 > requires (is_integral_v<I1> && is_integral_v<I2>)
constexpr auto	operator* (I1 const &i1, I2 const &i2)

template<typename I1 , typename I2 , typename I3 > requires is_integral_v<I3>
constexpr auto	operator* (ProductIntegral< I1, I2 > const &pi, I3 const &i3)
	Multiply ProductIntegral with another integral.

template<typename I1 , typename I2 , typename I3 > requires is_integral_v<I3>
constexpr auto	operator* (I3 const &i3, ProductIntegral< I1, I2 > const &pi)
	Multiply integral with ProductIntegral.

template<typename I1 , typename I2 > requires (EvaluableIntegral<I1> && EvaluableIntegral<I2>)
constexpr auto	product (I1 const &i1, I2 const &i2)
	Create a product of two independent integrals.

template<typename I1 , typename I2 , typename... Is> requires (EvaluableIntegral<I1> && EvaluableIntegral<I2> && (EvaluableIntegral<Is> && ...))
constexpr auto	product (I1 const &i1, I2 const &i2, Is const &... is)
	Create a product of multiple independent integrals.

template<typename E > requires is_expr_node_v<E>
std::string	to_string (E const &expr)

template<typename E > requires is_expr_node_v<E>
std::string	pretty_print (E const &expr)

template<typename E > requires is_expr_node_v<E>
std::ostream &	operator<< (std::ostream &os, E const &expr)

Variables
template<typename E >
constexpr std::uint64_t	variable_set_v = variable_set<E>::value
	Helper variable template for cleaner syntax.

template<typename E , std::size_t Dim>
constexpr bool	depends_on_v = (variable_set<E>::value & (1ULL << Dim)) != 0
	Check if an expression depends on a specific dimension.

template<typename E , std::uint64_t Mask>
constexpr bool	depends_on_any_v = (variable_set<E>::value & Mask) != 0
	Check if an expression depends on any of the given dimensions (mask)

template<typename E , std::uint64_t Mask>
constexpr bool	depends_on_all_v = (variable_set<E>::value & Mask) == Mask
	Check if an expression depends on all of the given dimensions (mask)

template<typename E >
constexpr bool	is_constant_v = (variable_set<E>::value == 0)
	Check if an expression is constant (depends on no variables)

template<typename E >
constexpr std::size_t	dependency_count_v
	Count the number of dimensions an expression depends on.

template<typename E >
constexpr std::size_t	max_dimension_v
	Get the maximum dimension index an expression depends on (0 if constant)

template<typename E , std::size_t D1, std::size_t D2>
constexpr bool	is_separable_v = is_separable<E, D1, D2>::value

template<typename E , std::size_t Dim>
constexpr bool	has_antiderivative_v = has_antiderivative<E, Dim>::value

template<typename T >
constexpr bool	is_box_integral_v = is_box_integral<T>::value

template<typename T >
constexpr bool	is_constrained_box_integral_v = is_constrained_box_integral<T>::value

template<typename T >
constexpr bool	is_derivative_builder_v = is_derivative_builder<T>::value

template<typename T >
constexpr bool	is_integral_v = is_integral<T>::value

template<typename T >
constexpr bool	is_const_expr_v = is_const_expr<T>::value

template<typename T >
constexpr bool	is_expr_node_v = is_expr_node<T>::value

template<typename E >
constexpr bool	is_binary_func_v = false

template<typename Tag , typename L , typename R >
constexpr bool	is_binary_func_v< BinaryFunc< Tag, L, R > > = true

template<typename E >
constexpr bool	is_runtime_pow_v = false

template<typename L , typename R >
constexpr bool	is_runtime_pow_v< BinaryFunc< PowTag, L, R > > = true

template<typename E >
constexpr bool	is_max_v = false

template<typename L , typename R >
constexpr bool	is_max_v< BinaryFunc< MaxTag, L, R > > = true

template<typename E >
constexpr bool	is_min_v = false

template<typename L , typename R >
constexpr bool	is_min_v< BinaryFunc< MinTag, L, R > > = true

template<typename T >
constexpr bool	is_conditional_v = is_conditional<T>::value

template<typename E >
constexpr bool	is_zero_v = false

template<typename T >
constexpr bool	is_zero_v< Zero< T > > = true

template<typename E >
constexpr bool	is_one_v = false

template<typename T >
constexpr bool	is_one_v< One< T > > = true

template<typename T >
constexpr bool	is_named_var_v = is_named_var<T>::value

template<typename T >
constexpr bool	is_static_named_var_v = is_static_named_var<T>::value

template<typename E >
constexpr bool	is_pow_v = false

template<typename E , int N>
constexpr bool	is_pow_v< Pow< E, N > > = true

template<typename E >
constexpr int	pow_exponent_v = 0

template<typename E , int N>
constexpr int	pow_exponent_v< Pow< E, N > > = N

template<typename T >
constexpr bool	is_finite_sum_v = is_finite_sum<T>::value

template<typename T >
constexpr bool	is_finite_product_v = is_finite_product<T>::value

template<typename E >
constexpr bool	is_negation_v = false

template<typename E >
constexpr bool	is_negation_v< Unary< Neg, E > > = true

template<typename T = double>
constexpr Var< 0, T >	x {}

template<typename T = double>
constexpr Var< 1, T >	y {}

template<typename T = double>
constexpr Var< 2, T >	z {}

template<std::size_t N, typename T = double>
constexpr Var< N, T >	arg {}

template<typename T >
constexpr bool	is_product_integral_v = is_product_integral<T>::value

template<typename I1 , typename I2 >
constexpr bool	are_independent_integrals_v
	Check if multiplying integrals is valid (they must be over independent dimensions)

Detailed Description

Expression layer for composable calculus.

This namespace contains all the types and functions for building mathematical expressions, computing derivatives, and evaluating integrals.

Key types:

Var, NamedVar - Variables
Const, Zero, One - Constants
Binary, Unary - Composite expressions
UnaryFunc - Mathematical functions (sin, cos, exp, log, etc.)
Integral, BoxIntegral - Integration expressions
ProductIntegral - Separable integral composition

Key functions:

derivative(f).wrt<D>() - Symbolic differentiation
integral(f).over<D>(a, b) - Definite integration
integral(f).over_box(...) - N-dimensional box integration

Typedef Documentation

◆ Abs

template<typename E >

using limes::expr::Abs = typedef UnaryFunc<AbsTag, E>

Definition at line 242 of file primitives.hpp.

◆ Acos

template<typename E >

using limes::expr::Acos = typedef UnaryFunc<AcosTag, E>

Definition at line 248 of file primitives.hpp.

◆ Acosh

template<typename E >

using limes::expr::Acosh = typedef UnaryFunc<AcoshTag, E>

Definition at line 251 of file primitives.hpp.

◆ Asin

template<typename E >

using limes::expr::Asin = typedef UnaryFunc<AsinTag, E>

Definition at line 247 of file primitives.hpp.

◆ Asinh

template<typename E >

using limes::expr::Asinh = typedef UnaryFunc<AsinhTag, E>

Definition at line 250 of file primitives.hpp.

◆ Atan

template<typename E >

using limes::expr::Atan = typedef UnaryFunc<AtanTag, E>

Definition at line 249 of file primitives.hpp.

◆ Atanh

template<typename E >

using limes::expr::Atanh = typedef UnaryFunc<AtanhTag, E>

Definition at line 252 of file primitives.hpp.

◆ Cos

template<typename E >

using limes::expr::Cos = typedef UnaryFunc<CosTag, E>

Definition at line 240 of file primitives.hpp.

◆ Cosh

template<typename E >

using limes::expr::Cosh = typedef UnaryFunc<CoshTag, E>

Definition at line 245 of file primitives.hpp.

◆ Exp

template<typename E >

using limes::expr::Exp = typedef UnaryFunc<ExpTag, E>

Definition at line 237 of file primitives.hpp.

◆ Log

template<typename E >

using limes::expr::Log = typedef UnaryFunc<LogTag, E>

Definition at line 238 of file primitives.hpp.

◆ Max

template<typename L , typename R >

using limes::expr::Max = typedef BinaryFunc<MaxTag, L, R>

Definition at line 207 of file binary_func.hpp.

◆ Min

template<typename L , typename R >

using limes::expr::Min = typedef BinaryFunc<MinTag, L, R>

Definition at line 210 of file binary_func.hpp.

◆ negation_inner_t

template<typename E >

using limes::expr::negation_inner_t = typedef typename negation_inner<E>::type

Definition at line 19 of file unary.hpp.

◆ pow_base_t

template<typename E >

using limes::expr::pow_base_t = typedef typename pow_base<E>::type

Definition at line 18 of file pow.hpp.

◆ RuntimePow

template<typename L , typename R >

using limes::expr::RuntimePow = typedef BinaryFunc<PowTag, L, R>

Definition at line 204 of file binary_func.hpp.

◆ Sin

template<typename E >

using limes::expr::Sin = typedef UnaryFunc<SinTag, E>

Definition at line 239 of file primitives.hpp.

◆ Sinh

template<typename E >

using limes::expr::Sinh = typedef UnaryFunc<SinhTag, E>

Definition at line 244 of file primitives.hpp.

◆ Sqrt

template<typename E >

using limes::expr::Sqrt = typedef UnaryFunc<SqrtTag, E>

Definition at line 241 of file primitives.hpp.

◆ Tan

template<typename E >

using limes::expr::Tan = typedef UnaryFunc<TanTag, E>

Definition at line 243 of file primitives.hpp.

◆ Tanh

template<typename E >

using limes::expr::Tanh = typedef UnaryFunc<TanhTag, E>

Definition at line 246 of file primitives.hpp.

Function Documentation

◆ abs()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::abs ( E e )

constexpr

Definition at line 194 of file primitives.hpp.

◆ acos()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::acos ( E e )

constexpr

Definition at line 218 of file primitives.hpp.

◆ acosh()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::acosh ( E e )

constexpr

Definition at line 230 of file primitives.hpp.

◆ antiderivative()

template<std::size_t Dim, typename E >

constexpr auto limes::expr::antiderivative ( E expr )

constexpr

Definition at line 120 of file antiderivatives.hpp.

◆ asin()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::asin ( E e )

constexpr

Definition at line 214 of file primitives.hpp.

◆ asinh()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::asinh ( E e )

constexpr

Definition at line 226 of file primitives.hpp.

◆ atan()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::atan ( E e )

constexpr

Definition at line 222 of file primitives.hpp.

◆ atanh()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::atanh ( E e )

constexpr

Definition at line 234 of file primitives.hpp.

◆ bind()

template<std::size_t Dim, typename E , typename T >
requires is_expr_node_v<E>

constexpr auto limes::expr::bind	(	E	expr,
		T	value
	)

constexpr

Definition at line 98 of file bound.hpp.

◆ bind_all()

template<std::size_t Dim, std::size_t... Dims, typename E , typename T , typename... Ts>
requires is_expr_node_v<E>

constexpr auto limes::expr::bind_all	(	E	expr,
		T	value,
		Ts...	values
	)

constexpr

Definition at line 114 of file bound.hpp.

References bind_all().

Referenced by bind_all().

◆ clamp()

template<typename E , typename T >
requires (is_expr_node_v<E> && std::is_arithmetic_v<T>)

constexpr auto limes::expr::clamp	(	E	e,
		T	lo,
		T	hi
	)

constexpr

Definition at line 116 of file conditional.hpp.

References if_then_else().

◆ Const()

template<typename T >

limes::expr::Const ( T ) -> Const< T >

◆ constant()

template<typename T >

constexpr auto limes::expr::constant ( T value )

constexprnoexcept

Definition at line 107 of file const.hpp.

◆ cos()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::cos ( E e )

constexpr

Definition at line 186 of file primitives.hpp.

Referenced by limes::expr::antiderivative_impl< Dim, UnaryFunc< SinTag, Var< Dim, T > > >::compute().

◆ cosh()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::cosh ( E e )

constexpr

Definition at line 206 of file primitives.hpp.

◆ cube()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::cube ( E e )

constexpr

Definition at line 98 of file pow.hpp.

◆ declare_vars()

template<std::size_t N, typename T = double, typename... Names>
requires (sizeof...(Names) == N)

constexpr auto limes::expr::declare_vars ( Names... names )

constexpr

Usage: auto [x, y, z] = declare_vars<3>("x", "y", "z");.

Definition at line 152 of file named_var.hpp.

◆ declare_vars_impl()

template<std::size_t N, typename T , std::size_t... Is>

constexpr auto limes::expr::declare_vars_impl	(	std::array< std::string_view, N > const &	names,
		std::index_sequence< Is... >
	)

constexpr

Definition at line 144 of file named_var.hpp.

◆ definite_integral_symbolic()

template<std::size_t Dim, typename E , typename T >

constexpr T limes::expr::definite_integral_symbolic	(	E	expr,
		T	a,
		T	b
	)

constexpr

Definition at line 256 of file antiderivatives.hpp.

◆ derivative() [1/2]

template<std::size_t Dim, typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::derivative ( E expr )

constexpr

Definition at line 16 of file derivative.hpp.

◆ derivative() [2/2]

template<typename E >
requires is_expr_node_v<E>

auto limes::expr::derivative	(	E	expr,
		std::size_t	dim
	)

Definition at line 87 of file derivative.hpp.

References limes::expr::detail::derivative_dispatch_impl().

◆ derivative_n()

template<std::size_t Dim, std::size_t... Dims, typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::derivative_n ( E expr )

constexpr

Definition at line 112 of file derivative.hpp.

References derivative_n().

Referenced by derivative_n().

◆ exp()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::exp ( E e )

constexpr

Definition at line 174 of file primitives.hpp.

Referenced by limes::expr::antiderivative_impl< Dim, UnaryFunc< ExpTag, Var< Dim, T > > >::compute().

◆ gradient()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::gradient ( E expr )

constexpr

Definition at line 104 of file derivative.hpp.

References limes::expr::detail::gradient_impl().

◆ heaviside()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::heaviside ( E e )

constexpr

Definition at line 91 of file conditional.hpp.

References if_then_else().

Referenced by indicator().

◆ if_then_else() [1/2]

template<typename C , typename T , typename E >
requires (is_expr_node_v<C> && is_expr_node_v<T> && is_expr_node_v<E>)

constexpr auto limes::expr::if_then_else	(	C	cond,
		T	then_expr,
		E	else_expr
	)

constexpr

Definition at line 71 of file conditional.hpp.

Referenced by clamp(), heaviside(), ramp(), and sign().

◆ if_then_else() [2/2]

template<typename C , typename T >
requires (is_expr_node_v<C> && std::is_arithmetic_v<T>)

constexpr auto limes::expr::if_then_else	(	C	cond,
		T	then_val,
		T	else_val
	)

constexpr

Definition at line 77 of file conditional.hpp.

◆ indicator()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::indicator ( E e )

constexpr

Definition at line 127 of file conditional.hpp.

References heaviside().

◆ log()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::log ( E e )

constexpr

Definition at line 178 of file primitives.hpp.

◆ max() [1/3]

template<typename L , typename R >
requires (is_expr_node_v<L> && is_expr_node_v<R>)

constexpr auto limes::expr::max	(	L	a,
		R	b
	)

constexpr

Definition at line 147 of file binary_func.hpp.

Referenced by max(), and max().

◆ max() [2/3]

template<typename L , typename T >
requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)

constexpr auto limes::expr::max	(	L	a,
		T	b
	)

constexpr

Definition at line 160 of file binary_func.hpp.

References max().

◆ max() [3/3]

template<typename T , typename R >
requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)

constexpr auto limes::expr::max	(	T	a,
		R	b
	)

constexpr

Definition at line 168 of file binary_func.hpp.

References max().

◆ min() [1/3]

template<typename L , typename R >
requires (is_expr_node_v<L> && is_expr_node_v<R>)

constexpr auto limes::expr::min	(	L	a,
		R	b
	)

constexpr

Definition at line 176 of file binary_func.hpp.

Referenced by min(), and min().

◆ min() [2/3]

template<typename L , typename T >
requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)

constexpr auto limes::expr::min	(	L	a,
		T	b
	)

constexpr

Definition at line 189 of file binary_func.hpp.

References min().

◆ min() [3/3]

template<typename T , typename R >
requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)

constexpr auto limes::expr::min	(	T	a,
		R	b
	)

constexpr

Definition at line 197 of file binary_func.hpp.

References min().

◆ named()

template<std::size_t N, typename T = double>

constexpr StaticNamedVar< N, T > limes::expr::named ( std::string_view name )

constexprnoexcept

Definition at line 137 of file named_var.hpp.

◆ operator*() [1/3]

template<typename L , typename R >
requires (is_expr_node_v<L> && is_expr_node_v<R> && !is_integral<L>::value && !is_integral<R>::value)

constexpr auto limes::expr::operator*	(	L	l,
		R	r
	)

constexpr

Definition at line 186 of file binary.hpp.

References limes::expr::Const< T >::value.

◆ operator*() [2/3]

template<typename L , typename T >
requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)

constexpr auto limes::expr::operator*	(	L	l,
		T	r
	)

constexpr

Definition at line 205 of file binary.hpp.

◆ operator*() [3/3]

template<typename T , typename R >
requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)

constexpr auto limes::expr::operator*	(	T	l,
		R	r
	)

constexpr

Definition at line 213 of file binary.hpp.

◆ operator+() [1/4]

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::operator+ ( E e )

constexpr

Definition at line 77 of file unary.hpp.

◆ operator+() [2/4]

template<typename L , typename R >
requires (is_expr_node_v<L> && is_expr_node_v<R>)

constexpr auto limes::expr::operator+	(	L	l,
		R	r
	)

constexpr

Definition at line 119 of file binary.hpp.

References limes::expr::Const< T >::value.

◆ operator+() [3/4]

template<typename L , typename T >
requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)

constexpr auto limes::expr::operator+	(	L	l,
		T	r
	)

constexpr

Definition at line 137 of file binary.hpp.

◆ operator+() [4/4]

template<typename T , typename R >
requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)

constexpr auto limes::expr::operator+	(	T	l,
		R	r
	)

constexpr

Definition at line 145 of file binary.hpp.

◆ operator-() [1/4]

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::operator- ( E e )

constexpr

Definition at line 64 of file unary.hpp.

◆ operator-() [2/4]

template<typename L , typename R >
requires (is_expr_node_v<L> && is_expr_node_v<R>)

constexpr auto limes::expr::operator-	(	L	l,
		R	r
	)

constexpr

Definition at line 153 of file binary.hpp.

References limes::expr::Const< T >::value.

◆ operator-() [3/4]

template<typename L , typename T >
requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)

constexpr auto limes::expr::operator-	(	L	l,
		T	r
	)

constexpr

Definition at line 170 of file binary.hpp.

◆ operator-() [4/4]

template<typename T , typename R >
requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)

constexpr auto limes::expr::operator-	(	T	l,
		R	r
	)

constexpr

Definition at line 178 of file binary.hpp.

◆ operator/() [1/3]

template<typename L , typename R >
requires (is_expr_node_v<L> && is_expr_node_v<R>)

constexpr auto limes::expr::operator/	(	L	l,
		R	r
	)

constexpr

Definition at line 221 of file binary.hpp.

References limes::expr::Const< T >::value.

◆ operator/() [2/3]

template<typename L , typename T >
requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)

constexpr auto limes::expr::operator/	(	L	l,
		T	r
	)

constexpr

Definition at line 238 of file binary.hpp.

◆ operator/() [3/3]

template<typename T , typename R >
requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)

constexpr auto limes::expr::operator/	(	T	l,
		R	r
	)

constexpr

Definition at line 246 of file binary.hpp.

◆ operator<<()

template<typename E >
requires is_expr_node_v<E>

std::ostream & limes::expr::operator<<	(	std::ostream &	os,
		E const &	expr
	)

Definition at line 39 of file to_string.hpp.

◆ partial()

template<typename E , typename T >
requires is_expr_node_v<E>

constexpr auto limes::expr::partial	(	E	expr,
		T	value
	)

constexpr

Definition at line 126 of file bound.hpp.

◆ partial_right()

template<typename E , typename T >
requires is_expr_node_v<E>

constexpr auto limes::expr::partial_right	(	E	expr,
		T	value
	)

constexpr

Definition at line 133 of file bound.hpp.

◆ pow() [1/4]

template<int N, typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::pow ( E e )

constexpr

Definition at line 80 of file pow.hpp.

◆ pow() [2/4]

template<typename L , typename R >
requires (is_expr_node_v<L> && is_expr_node_v<R>)

constexpr auto limes::expr::pow	(	L	base,
		R	exponent
	)

constexpr

Definition at line 114 of file binary_func.hpp.

Referenced by pow(), and pow().

◆ pow() [3/4]

template<typename L , typename T >
requires (is_expr_node_v<L> && std::is_arithmetic_v<T>)

constexpr auto limes::expr::pow	(	L	base,
		T	exponent
	)

constexpr

Definition at line 131 of file binary_func.hpp.

References pow().

◆ pow() [4/4]

template<typename T , typename R >
requires (std::is_arithmetic_v<T> && is_expr_node_v<R>)

constexpr auto limes::expr::pow	(	T	base,
		R	exponent
	)

constexpr

Definition at line 139 of file binary_func.hpp.

References pow().

◆ pretty_print()

template<typename E >
requires is_expr_node_v<E>

std::string limes::expr::pretty_print ( E const & expr )

Definition at line 30 of file to_string.hpp.

References limes::expr::detail::pretty_print_impl().

◆ product()

template<std::size_t IndexDim, typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::product	(	E	body,
		int	lo,
		int	hi
	)

constexpr

Definition at line 152 of file sum_product.hpp.

Referenced by product().

◆ ramp()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::ramp ( E e )

constexpr

Definition at line 99 of file conditional.hpp.

References if_then_else().

◆ separate()

template<std::size_t D1, std::size_t D2, typename E >

constexpr auto limes::expr::separate ( E const & expr )

constexpr

Separate a multiplicative expression f(x,y) = g(x) * h(y) Returns a pair (g, h) where g depends on D1 and h depends on D2

Precondition: is_separable_v<E, D1, D2> must be true

Definition at line 302 of file analysis.hpp.

◆ sign()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::sign ( E e )

constexpr

Definition at line 107 of file conditional.hpp.

References if_then_else().

◆ sin()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::sin ( E e )

constexpr

Definition at line 182 of file primitives.hpp.

Referenced by limes::expr::antiderivative_impl< Dim, UnaryFunc< CosTag, Var< Dim, T > > >::compute().

◆ sinh()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::sinh ( E e )

constexpr

Definition at line 202 of file primitives.hpp.

◆ sqrt()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::sqrt ( E e )

constexpr

Definition at line 190 of file primitives.hpp.

◆ square()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::square ( E e )

constexpr

Definition at line 92 of file pow.hpp.

◆ sum()

template<std::size_t IndexDim, typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::sum	(	E	body,
		int	lo,
		int	hi
	)

constexpr

Definition at line 146 of file sum_product.hpp.

Referenced by limes::expr::BoxIntegral< E, Dims >::eval(), limes::expr::ConstrainedBoxIntegral< E, Dims, Constraint >::eval(), and limes::expr::FiniteSum< Expr, IndexDim >::eval().

◆ tan()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::tan ( E e )

constexpr

Definition at line 198 of file primitives.hpp.

◆ tanh()

template<typename E >
requires is_expr_node_v<E>

constexpr auto limes::expr::tanh ( E e )

constexpr

Definition at line 210 of file primitives.hpp.

◆ to_string()

template<typename E >
requires is_expr_node_v<E>

std::string limes::expr::to_string ( E const & expr )

Definition at line 13 of file to_string.hpp.

◆ var()

template<typename T = double>

constexpr NamedVar< T > limes::expr::var	(	std::size_t	dim,
		std::string_view	name
	)

constexprnoexcept

Definition at line 79 of file named_var.hpp.

◆ vars_xy()

template<typename T = double>

constexpr auto limes::expr::vars_xy	(	std::string_view	x_name = `"x"`,
		std::string_view	y_name = `"y"`
	)

constexpr

Definition at line 158 of file named_var.hpp.

◆ vars_xyz()

template<typename T = double>

constexpr auto limes::expr::vars_xyz	(	std::string_view	x_name = `"x"`,
		std::string_view	y_name = `"y"`,
		std::string_view	z_name = `"z"`
	)

constexpr

Definition at line 165 of file named_var.hpp.

Variable Documentation

◆ arg

template<std::size_t N, typename T = double>

constexpr Var<N, T> limes::expr::arg {}

inlineconstexpr

Definition at line 55 of file var.hpp.

◆ dependency_count_v

template<typename E >

constexpr std::size_t limes::expr::dependency_count_v

inlineconstexpr

Initial value:

= []() constexpr {
    std::uint64_t bits = variable_set<E>::value;
    std::size_t count = 0;
    while (bits) {
        count += bits & 1;
        bits >>= 1;
    }
    return count;
}()

Count the number of dimensions an expression depends on.

Definition at line 105 of file analysis.hpp.

◆ depends_on_all_v

template<typename E , std::uint64_t Mask>

constexpr bool limes::expr::depends_on_all_v = (variable_set<E>::value & Mask) == Mask

inlineconstexpr

Check if an expression depends on all of the given dimensions (mask)

Definition at line 97 of file analysis.hpp.

◆ depends_on_any_v

template<typename E , std::uint64_t Mask>

constexpr bool limes::expr::depends_on_any_v = (variable_set<E>::value & Mask) != 0

inlineconstexpr

Check if an expression depends on any of the given dimensions (mask)

Definition at line 93 of file analysis.hpp.

◆ depends_on_v

template<typename E , std::size_t Dim>

constexpr bool limes::expr::depends_on_v = (variable_set<E>::value & (1ULL << Dim)) != 0

inlineconstexpr

Check if an expression depends on a specific dimension.

Definition at line 89 of file analysis.hpp.

◆ has_antiderivative_v

template<typename E , std::size_t Dim>

constexpr bool limes::expr::has_antiderivative_v = has_antiderivative<E, Dim>::value

inlineconstexpr

Definition at line 24 of file antiderivatives.hpp.

◆ is_binary_func_v

template<typename E >

constexpr bool limes::expr::is_binary_func_v = false

inlineconstexpr

Definition at line 21 of file binary_func.hpp.

◆ is_binary_func_v< BinaryFunc< Tag, L, R > >

template<typename Tag , typename L , typename R >

constexpr bool limes::expr::is_binary_func_v< BinaryFunc< Tag, L, R > > = true

inlineconstexpr

Definition at line 23 of file binary_func.hpp.

◆ is_conditional_v

template<typename T >

constexpr bool limes::expr::is_conditional_v = is_conditional<T>::value

inlineconstexpr

Definition at line 65 of file conditional.hpp.

◆ is_const_expr_v

template<typename T >

constexpr bool limes::expr::is_const_expr_v = is_const_expr<T>::value

inlineconstexpr

Definition at line 102 of file binary.hpp.

◆ is_constant_v

template<typename E >

constexpr bool limes::expr::is_constant_v = (variable_set<E>::value == 0)

inlineconstexpr

Check if an expression is constant (depends on no variables)

Definition at line 101 of file analysis.hpp.

◆ is_expr_node_v

template<typename T >

constexpr bool limes::expr::is_expr_node_v = is_expr_node<T>::value

inlineconstexpr

Definition at line 111 of file binary.hpp.

◆ is_finite_product_v

template<typename T >

constexpr bool limes::expr::is_finite_product_v = is_finite_product<T>::value

inlineconstexpr

Definition at line 140 of file sum_product.hpp.

◆ is_finite_sum_v

template<typename T >

constexpr bool limes::expr::is_finite_sum_v = is_finite_sum<T>::value

inlineconstexpr

Definition at line 131 of file sum_product.hpp.

◆ is_max_v

template<typename E >

constexpr bool limes::expr::is_max_v = false

inlineconstexpr

Definition at line 29 of file binary_func.hpp.

◆ is_max_v< BinaryFunc< MaxTag, L, R > >

template<typename L , typename R >

constexpr bool limes::expr::is_max_v< BinaryFunc< MaxTag, L, R > > = true

inlineconstexpr

Definition at line 31 of file binary_func.hpp.

◆ is_min_v

template<typename E >

constexpr bool limes::expr::is_min_v = false

inlineconstexpr

Definition at line 33 of file binary_func.hpp.

◆ is_min_v< BinaryFunc< MinTag, L, R > >

template<typename L , typename R >

constexpr bool limes::expr::is_min_v< BinaryFunc< MinTag, L, R > > = true

inlineconstexpr

Definition at line 35 of file binary_func.hpp.

◆ is_named_var_v

template<typename T >

constexpr bool limes::expr::is_named_var_v = is_named_var<T>::value

inlineconstexpr

Definition at line 76 of file named_var.hpp.

◆ is_negation_v

template<typename E >

constexpr bool limes::expr::is_negation_v = false

inlineconstexpr

Definition at line 14 of file unary.hpp.

◆ is_negation_v< Unary< Neg, E > >

template<typename E >

constexpr bool limes::expr::is_negation_v< Unary< Neg, E > > = true

inlineconstexpr

Definition at line 15 of file unary.hpp.

◆ is_one_v

template<typename E >

constexpr bool limes::expr::is_one_v = false

inlineconstexpr

Definition at line 18 of file const.hpp.

◆ is_one_v< One< T > >

template<typename T >

constexpr bool limes::expr::is_one_v< One< T > > = true

inlineconstexpr

Definition at line 19 of file const.hpp.

◆ is_pow_v

template<typename E >

constexpr bool limes::expr::is_pow_v = false

inlineconstexpr

Definition at line 13 of file pow.hpp.

◆ is_pow_v< Pow< E, N > >

template<typename E , int N>

constexpr bool limes::expr::is_pow_v< Pow< E, N > > = true

inlineconstexpr

Definition at line 14 of file pow.hpp.

◆ is_runtime_pow_v

template<typename E >

constexpr bool limes::expr::is_runtime_pow_v = false

inlineconstexpr

Definition at line 25 of file binary_func.hpp.

◆ is_runtime_pow_v< BinaryFunc< PowTag, L, R > >

template<typename L , typename R >

constexpr bool limes::expr::is_runtime_pow_v< BinaryFunc< PowTag, L, R > > = true

inlineconstexpr

Definition at line 27 of file binary_func.hpp.

◆ is_separable_v

template<typename E , std::size_t D1, std::size_t D2>

constexpr bool limes::expr::is_separable_v = is_separable<E, D1, D2>::value

inlineconstexpr

Definition at line 214 of file analysis.hpp.

◆ is_static_named_var_v

template<typename T >

constexpr bool limes::expr::is_static_named_var_v = is_static_named_var<T>::value

inlineconstexpr

Definition at line 134 of file named_var.hpp.

◆ is_zero_v

template<typename E >

constexpr bool limes::expr::is_zero_v = false

inlineconstexpr

Definition at line 15 of file const.hpp.

◆ is_zero_v< Zero< T > >

template<typename T >

constexpr bool limes::expr::is_zero_v< Zero< T > > = true

inlineconstexpr

Definition at line 16 of file const.hpp.

◆ max_dimension_v

template<typename E >

constexpr std::size_t limes::expr::max_dimension_v

inlineconstexpr

Initial value:

= []() constexpr {
    std::uint64_t bits = variable_set<E>::value;
    if (bits == 0) return std::size_t{0};
    std::size_t max_dim = 0;
    for (std::size_t i = 0; i < 64; ++i) {
        if (bits & (1ULL << i)) {
            max_dim = i;
        }
    }
    return max_dim;
}()

Get the maximum dimension index an expression depends on (0 if constant)

Definition at line 117 of file analysis.hpp.

◆ pow_exponent_v

template<typename E >

constexpr int limes::expr::pow_exponent_v = 0

inlineconstexpr

Definition at line 20 of file pow.hpp.

◆ pow_exponent_v< Pow< E, N > >

template<typename E , int N>

constexpr int limes::expr::pow_exponent_v< Pow< E, N > > = N

inlineconstexpr

Definition at line 21 of file pow.hpp.

◆ variable_set_v

template<typename E >

constexpr std::uint64_t limes::expr::variable_set_v = variable_set<E>::value

inlineconstexpr

Helper variable template for cleaner syntax.

Definition at line 85 of file analysis.hpp.

◆ x

template<typename T = double>

constexpr Var<0, T> limes::expr::x {}

inlineconstexpr

Definition at line 46 of file var.hpp.

Referenced by limes::expr::antiderivative_impl< Dim, Const< T > >::compute(), limes::expr::antiderivative_impl< Dim, Pow< Var< Dim, T >, N > >::compute(), limes::expr::antiderivative_impl< Dim, UnaryFunc< CosTag, Var< Dim, T > > >::compute(), limes::expr::antiderivative_impl< Dim, UnaryFunc< ExpTag, Var< Dim, T > > >::compute(), limes::expr::antiderivative_impl< Dim, UnaryFunc< SinTag, Var< Dim, T > > >::compute(), limes::expr::antiderivative_impl< Dim, Var< Dim, T > >::compute(), limes::expr::TransformedIntegral< OriginalIntegral, Phi, Jacobian >::eval(), and limes::expr::detail::make_integrand_fn().

◆ y

template<typename T = double>

constexpr Var<1, T> limes::expr::y {}

inlineconstexpr

Definition at line 49 of file var.hpp.

Referenced by limes::expr::BoxIntegral< E, Dims >::eval(), and limes::expr::ConstrainedBoxIntegral< E, Dims, Constraint >::eval().

◆ z

template<typename T = double>

constexpr Var<2, T> limes::expr::z {}

inlineconstexpr

Definition at line 52 of file var.hpp.

Namespaces

Classes

Concepts

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ Abs

◆ Acos

◆ Acosh

◆ Asin

◆ Asinh

◆ Atan

◆ Atanh

◆ Cos

◆ Cosh

◆ Exp

◆ Log

◆ Max

◆ Min

◆ negation_inner_t

◆ pow_base_t

◆ RuntimePow

◆ Sin

◆ Sinh

◆ Sqrt

◆ Tan

◆ Tanh

Function Documentation

◆ abs()

◆ acos()

◆ acosh()

◆ antiderivative()

◆ asin()

◆ asinh()

◆ atan()

◆ atanh()

◆ bind()

◆ bind_all()

◆ clamp()

◆ Const()

◆ constant()

◆ cos()

◆ cosh()

◆ cube()

◆ declare_vars()

◆ declare_vars_impl()

◆ definite_integral_symbolic()

◆ derivative() [1/2]

◆ derivative() [2/2]

◆ derivative_n()

◆ exp()

◆ gradient()

◆ heaviside()

◆ if_then_else() [1/2]

◆ if_then_else() [2/2]

◆ indicator()

◆ log()

◆ max() [1/3]

◆ max() [2/3]

◆ max() [3/3]

◆ min() [1/3]

◆ min() [2/3]

◆ min() [3/3]

◆ named()

◆ operator*() [1/3]

◆ operator*() [2/3]

◆ operator*() [3/3]

◆ operator+() [1/4]

◆ operator+() [2/4]

◆ operator+() [3/4]

◆ operator+() [4/4]

◆ operator-() [1/4]

◆ operator-() [2/4]

◆ operator-() [3/4]

◆ operator-() [4/4]

◆ operator/() [1/3]

◆ operator/() [2/3]

◆ operator/() [3/3]