graph Namespace Reference

Name space for graph nodes. More...

Classes
class	add_node
	An addition node. More...
class	and_node
	A and node. More...
class	apply_u_node
	U Collision node. More...
class	apply_xi_node
	Xi Collision node. More...
class	arctan_node
	Class representing a sine_node leaf. More...
class	argument_node
	Node class to contain the index argument. More...
class	atomic_accumulate_1D_node
	Class representing a 1D accumulated array. More...
class	branch_node
	Class representing a branch node. More...
class	constant_node
	Class representing data that cannot change. More...
class	copysign_node
	A copysign node. More...
class	cosine_node
	Class representing a cosine_node leaf. More...
class	divide_node
	A division node. More...
class	equal_node
	An equal node. More...
class	erf_node
	An error function node. More...
class	erfi_node
	An imaginary error function node. More...
class	exp_node
	A exp node. More...
class	fma_node
	A fused multiply add node. More...
class	greater_than_equal_node
	A greater than equal node. More...
class	greater_than_node
	A greater than node. More...
struct	has_no_derivative
	Type trait for not having a valid derivative. More...
class	hypot_node
	A hypot node. More...
class	if_node
	An If conditional node. More...
class	index_1D_node
	Class representing a 1D index. More...
class	index_2D_node
	Class representing a 2D index. More...
class	index_node
	Index node. More...
class	isinf_node
	isinf node. More...
class	isnan_node
	isnan node. More...
class	leaf_node
	Class representing a node leaf. More...
class	less_than_equal_node
	A less than equal node. More...
class	less_than_node
	A less than node. More...
class	log_node
	A log node. More...
class	matrix_quantity
	Class to represent matrix quantities. More...
class	min_node
	A Min node. More...
class	modulo_node
	An Modulo node. More...
class	multiply_node
	A multiplication node. More...
class	n_branch_node
	Class representing a N branch node. More...
class	no_derivative
	Nodes without derivatives. More...
class	not_equal_node
	A not equal node. More...
class	not_node
	Not node. More...
class	or_node
	A or node. More...
class	piecewise_1D_node
	Class representing a 1D piecewise constant. More...
class	piecewise_2D_node
	Class representing a 2D piecewise constant. More...
class	pow_node
	An power node. More...
class	pseudo_variable_node
	Class representing a subexpression that acts like a variable. More...
class	random_node
	Class representing a random_node leaf. More...
class	random_state_node
	Random state. More...
class	sine_node
	Class representing a sine_node leaf. More...
class	sqrt_node
	A sqrt node. More...
class	straight_node
	Class representing a straight node. More...
class	subtract_node
	A subtraction node. More...
class	triple_node
	Class representing a triple branch node. More...
class	variable_node
	Class representing data that can change. More...
class	vector_quantity
	Class to represent vector quantities. More...

Typedefs
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_add = std::shared_ptr< add_node< T, SAFE_MATH > >
	Convenience type alias for shared add nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_subtract = std::shared_ptr< subtract_node< T, SAFE_MATH > >
	Convenience type alias for shared subtract nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_multiply = std::shared_ptr< multiply_node< T, SAFE_MATH > >
	Convenience type alias for shared multiply nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_divide = std::shared_ptr< divide_node< T, SAFE_MATH > >
	Convenience type alias for shared divide nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_fma = std::shared_ptr< fma_node< T, SAFE_MATH > >
	Convenience type alias for shared add nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_modulo = std::shared_ptr< modulo_node< T, SAFE_MATH > >
	Convenience type alias for shared modulo nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_isinf = std::shared_ptr< isinf_node< T, SAFE_MATH > >
	Convenience type alias for shared isinf nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_isnan = std::shared_ptr< isnan_node< T, SAFE_MATH > >
	Convenience type alias for shared isnan nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_not = std::shared_ptr< not_node< T, SAFE_MATH > >
	Convenience type alias for shared not nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_equal = std::shared_ptr< equal_node< T, SAFE_MATH > >
	Convenience type alias for shared equal nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_not_equal = std::shared_ptr< not_equal_node< T, SAFE_MATH > >
	Convenience type alias for shared not equal nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_greater_than = std::shared_ptr< greater_than_node< T, SAFE_MATH > >
	Convenience type alias for shared greater than nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_less_than = std::shared_ptr< less_than_node< T, SAFE_MATH > >
	Convenience type alias for shared less than nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_greater_than_equal = std::shared_ptr< greater_than_equal_node< T, SAFE_MATH > >
	Convenience type alias for shared greater than equal nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_less_than_equal = std::shared_ptr< less_than_equal_node< T, SAFE_MATH > >
	Convenience type alias for shared less than equal nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_and = std::shared_ptr< and_node< T, SAFE_MATH > >
	Convenience type alias for shared and nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_or = std::shared_ptr< or_node< T, SAFE_MATH > >
	Convenience type alias for shared or nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_if = std::shared_ptr< if_node< T, SAFE_MATH > >
	Convenience type alias for shared add nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_min = std::shared_ptr< min_node< T, SAFE_MATH > >
	Convenience type alias for shared min nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_sqrt = std::shared_ptr< sqrt_node< T, SAFE_MATH > >
	Convenience type alias for shared sqrt nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_exp = std::shared_ptr< exp_node< T, SAFE_MATH > >
	Convenience type alias for shared exp nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_log = std::shared_ptr< log_node< T, SAFE_MATH > >
	Convenience type alias for shared log nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_pow = std::shared_ptr< pow_node< T, SAFE_MATH > >
	Convenience type alias for shared add nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_erf = std::shared_ptr< erf_node< T, SAFE_MATH > >
	Convenience type alias for shared erf nodes.
template<jit::complex_scalar T, bool SAFE_MATH = false>
using	shared_erfi = std::shared_ptr< erfi_node< T, SAFE_MATH > >
	Convenience type alias for shared erfi nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_hypot = std::shared_ptr< hypot_node< T, SAFE_MATH > >
	Convenience type alias for shared hypot nodes.
template<std::floating_point T, bool SAFE_MATH = false>
using	shared_copysign = std::shared_ptr< copysign_node< T, SAFE_MATH > >
	Convenience type alias for shared copysign nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_leaf = std::shared_ptr< leaf_node< T, SAFE_MATH > >
	Convenience type alias for shared leaf nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	output_nodes = std::vector< shared_leaf< T, SAFE_MATH > >
	Convenience type alias for a vector of output nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_index = std::shared_ptr< index_node< T, SAFE_MATH > >
	Convenience type alias for shared index nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_constant = std::shared_ptr< constant_node< T, SAFE_MATH > >
	Convenience type alias for shared constant nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_variable = std::shared_ptr< variable_node< T, SAFE_MATH > >
	Convenience type alias for shared variable nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	input_nodes = std::vector< shared_variable< T, SAFE_MATH > >
	Convenience type alias for a vector of inputs.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	map_nodes = std::vector< std::pair< shared_leaf< T, SAFE_MATH >, shared_variable< T, SAFE_MATH > > >
	Convenience type alias for mapping end codes back to inputs.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	copy_nodes = std::vector< std::pair< shared_variable< T, SAFE_MATH >, shared_variable< T, SAFE_MATH > > >
	Convenience type alias for copying buffers.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_pseudo_variable = std::shared_ptr< pseudo_variable_node< T, SAFE_MATH > >
	Convenience type alias for shared pseudo variable nodes.
template<std::floating_point T>
using	shared_apply_u = std::shared_ptr< apply_u_node< T > >
	Convenience type alias for shared sqrt nodes.
template<std::floating_point T>
using	shared_apply_xi = std::shared_ptr< apply_xi_node< T > >
	Convenience type alias for shared sqrt nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_argument = std::shared_ptr< argument_node< T, SAFE_MATH > >
	Convenience type alias for shared argument nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_piecewise_1D = std::shared_ptr< piecewise_1D_node< T, SAFE_MATH > >
	Convenience type alias for shared piecewise 1D nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_piecewise_2D = std::shared_ptr< piecewise_2D_node< T, SAFE_MATH > >
	Convenience type alias for shared piecewise 2D nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_index_1D = std::shared_ptr< index_1D_node< T, SAFE_MATH > >
	Convenience type alias for shared index 1D nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_index_2D = std::shared_ptr< index_2D_node< T, SAFE_MATH > >
	Convenience type alias for shared index 2D nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_atomic_accumulate_1D = std::shared_ptr< atomic_accumulate_1D_node< T, SAFE_MATH > >
	Convenience type alias for shared atomic accumulate 1D nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_random_state = std::shared_ptr< random_state_node< T, SAFE_MATH > >
	Convenience type alias for shared sqrt nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_random = std::shared_ptr< random_node< T, SAFE_MATH > >
	Convenience type alias for shared sqrt nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_sine = std::shared_ptr< sine_node< T, SAFE_MATH > >
	Convenience type alias for shared sine nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_cosine = std::shared_ptr< cosine_node< T, SAFE_MATH > >
	Convenience type alias for shared cosine nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_atan = std::shared_ptr< arctan_node< T, SAFE_MATH > >
	Convenience type alias for shared atan nodes.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_vector = std::shared_ptr< vector_quantity< T, SAFE_MATH > >
	Convenience type for shared vector quantities.
template<jit::float_scalar T, bool SAFE_MATH = false>
using	shared_matrix = std::shared_ptr< matrix_quantity< T, SAFE_MATH > >
	Convenience type for shared vector quantities.

Functions
template<jit::float_scalar T, bool SAFE_MATH = false>
bool	is_constant_combinable (shared_leaf< T, SAFE_MATH > a, shared_leaf< T, SAFE_MATH > b)
	Check if nodes are constant combinable.
template<jit::float_scalar T, bool SAFE_MATH = false>
bool	is_constant_promotable (shared_leaf< T, SAFE_MATH > a, shared_leaf< T, SAFE_MATH > b)
	Check if the constants are promotable.
template<jit::float_scalar T, bool SAFE_MATH = false>
bool	is_variable_combinable (shared_leaf< T, SAFE_MATH > a, shared_leaf< T, SAFE_MATH > b)
	Check if the variable is combinable.
template<jit::float_scalar T, bool SAFE_MATH = false>
bool	is_variable_promotable (shared_leaf< T, SAFE_MATH > a, shared_leaf< T, SAFE_MATH > b)
	Check if the variable is variable is promotable.
template<jit::float_scalar T, bool SAFE_MATH = false>
bool	is_greater_exponent (shared_leaf< T, SAFE_MATH > a, shared_leaf< T, SAFE_MATH > b)
	Check if the exponent is greater than the other.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	add (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build add node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator+ (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build add node from two leaves.
template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator+ (const L l, shared_leaf< T, SAFE_MATH > r)
	Build add node from two leaves.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator+ (shared_leaf< T, SAFE_MATH > l, const R r)
	Build add node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_add< T, SAFE_MATH >	add_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a add node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	subtract (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build subtract node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator- (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build subtract node from two leaves.
template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator- (const L l, shared_leaf< T, SAFE_MATH > r)
	Build subtract node from two leaves.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator- (shared_leaf< T, SAFE_MATH > l, const R r)
	Build subtract node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator- (shared_leaf< T, SAFE_MATH > a)
	Negate a node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_subtract< T, SAFE_MATH >	subtract_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a subtract node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	multiply (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build multiply node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator* (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build multiply node from two leaves.
template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator* (const L l, shared_leaf< T, SAFE_MATH > r)
	Build multiply node from two leaves.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator* (shared_leaf< T, SAFE_MATH > l, const R r)
	Build multiply node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_multiply< T, SAFE_MATH >	multiply_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a multiply node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	divide (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build divide node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator/ (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build divide node from two leaves.
template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator/ (const L l, shared_leaf< T, SAFE_MATH > r)
	Build divide node from two leaves.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator/ (shared_leaf< T, SAFE_MATH > l, const R r)
	Build multiply node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_divide< T, SAFE_MATH >	divide_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a divide node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	fma (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > m, shared_leaf< T, SAFE_MATH > r)
	Build fused multiply add node.
template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	fma (const L l, shared_leaf< T, SAFE_MATH > m, shared_leaf< T, SAFE_MATH > r)
	Build divide node from two leaves.
template<jit::float_scalar T, jit::float_scalar M, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	fma (shared_leaf< T, SAFE_MATH > l, const M m, shared_leaf< T, SAFE_MATH > r)
	Build divide node from two leaves.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	fma (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > m, const R r)
	Build multiply node from two leaves.
template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar M, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	fma (const L l, const M m, shared_leaf< T, SAFE_MATH > r)
	Build divide node from two leaves.
template<jit::float_scalar T, jit::float_scalar M, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	fma (shared_leaf< T, SAFE_MATH > l, const M m, const R r)
	Build divide node from two leaves.
template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	fma (const L l, shared_leaf< T, SAFE_MATH > m, const R r)
	Build multiply node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_fma< T, SAFE_MATH >	fma_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a fma node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	modulo (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build modulo node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator% (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build modulo node from two leaves.
template<std::floating_point T, std::floating_point L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator% (const L l, shared_leaf< T, SAFE_MATH > r)
	Build modulo node from two leaves.
template<std::floating_point T, std::floating_point R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator% (shared_leaf< T, SAFE_MATH > l, const R r)
	Build modulo node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_modulo< T, SAFE_MATH >	modulo_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a modulo node.
template<jit::float_scalar T, bool SAFE_MATH = false>
constexpr shared_leaf< T, SAFE_MATH >	true_constant ()
	Convenience type for true constant.
template<jit::float_scalar T, bool SAFE_MATH = false>
constexpr shared_leaf< T, SAFE_MATH >	false_constant ()
	Convenience type for false constant.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	isinf (shared_leaf< T, SAFE_MATH > arg)
	Build not node from the argument leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_isinf< T, SAFE_MATH >	isinf_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a isinf node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	isnan (shared_leaf< T, SAFE_MATH > arg)
	Build isnan node from the argument leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_isnan< T, SAFE_MATH >	isnan_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to an isnan node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	not_ (shared_leaf< T, SAFE_MATH > arg)
	Build not node from the argument leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator! (shared_leaf< T, SAFE_MATH > arg)
	Build not node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_not< T, SAFE_MATH >	not_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a not node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	equal (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build equal node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator== (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build equal node from two leaves.
template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator== (const L l, shared_leaf< T, SAFE_MATH > r)
	Build equal node from two leaves.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator== (shared_leaf< T, SAFE_MATH > l, const R r)
	Build equal node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_equal< T, SAFE_MATH >	equal_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a equal node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	not_equal (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build note equal node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator!= (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build not equal node from two leaves.
template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator!= (const L l, shared_leaf< T, SAFE_MATH > r)
	Build not equal node from two leaves.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator!= (shared_leaf< T, SAFE_MATH > l, const R r)
	Build not equal node from two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_not_equal< T, SAFE_MATH >	not_equal_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a equal node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	greater_than (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build greater than node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator> (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build greater than node from two leaves.
template<std::floating_point T, std::floating_point L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator> (const L l, shared_leaf< T, SAFE_MATH > r)
	Build greater than node from two leaves.
template<std::floating_point T, std::floating_point R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator> (shared_leaf< T, SAFE_MATH > l, const R r)
	Build greater than node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_greater_than< T, SAFE_MATH >	greater_than_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a greater than node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	less_than (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build less than node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator< (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build less than node from two leaves.
template<std::floating_point T, std::floating_point L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator< (const L l, shared_leaf< T, SAFE_MATH > r)
	Build less than node from two leaves.
template<std::floating_point T, std::floating_point R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator< (shared_leaf< T, SAFE_MATH > l, const R r)
	Build less than node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_less_than< T, SAFE_MATH >	less_than_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a less than node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	greater_than_equal (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build greater than equal node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator>= (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build greater than equal node from two leaves.
template<std::floating_point T, std::floating_point L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator>= (const L l, shared_leaf< T, SAFE_MATH > r)
	Build greater than equal node from two leaves.
template<std::floating_point T, std::floating_point R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator>= (shared_leaf< T, SAFE_MATH > l, const R r)
	Build greater than equal node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_greater_than_equal< T, SAFE_MATH >	greater_than_equal_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a greater than equal node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	less_than_equal (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build less than equal node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator<= (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build less than equal node from two leaves.
template<std::floating_point T, std::floating_point L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator<= (const L l, shared_leaf< T, SAFE_MATH > r)
	Build less than equal node from two leaves.
template<std::floating_point T, std::floating_point R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator<= (shared_leaf< T, SAFE_MATH > l, const R r)
	Build less than equal node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_less_than_equal< T, SAFE_MATH >	less_than_equal_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a less than equal node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	and_ (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build and node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator&& (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build and node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator&& (const bool l, shared_leaf< T, SAFE_MATH > r)
	Build and node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator&& (shared_leaf< T, SAFE_MATH > l, const bool r)
	Build and node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_and< T, SAFE_MATH >	and_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to an and node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	or_ (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build or node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator|| (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build or node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator|| (const bool l, shared_leaf< T, SAFE_MATH > r)
	Build or node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	operator|| (shared_leaf< T, SAFE_MATH > l, const bool r)
	Build or node from two leaves.
template<std::floating_point T, bool SAFE_MATH = false>
shared_or< T, SAFE_MATH >	or_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a or node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	if_ (shared_leaf< T, SAFE_MATH > c, shared_leaf< T, SAFE_MATH > t, shared_leaf< T, SAFE_MATH > f)
	Build an if node from a condition and two leaves.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_if< T, SAFE_MATH >	if_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to an if node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	min (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build a max node from a condition and two leaves.
template<std::floating_point T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	min (const L l, shared_leaf< T, SAFE_MATH > r)
	Build min node.
template<std::floating_point T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	min (shared_leaf< T, SAFE_MATH > l, const R r)
	Build min node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_min< T, SAFE_MATH >	min_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to an min node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	sqrt (shared_leaf< T, SAFE_MATH > x)
	Define sqrt convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_sqrt< T, SAFE_MATH >	sqrt_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a sqrt node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	exp (shared_leaf< T, SAFE_MATH > x)
	Define exp convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_exp< T, SAFE_MATH >	exp_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a exp node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	log (shared_leaf< T, SAFE_MATH > x)
	Define log convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_log< T, SAFE_MATH >	log_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a exp node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	pow (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build power node.
template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	pow (const L l, shared_leaf< T, SAFE_MATH > r)
	Build power node.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	pow (shared_leaf< T, SAFE_MATH > l, const R r)
	Build power node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_pow< T, SAFE_MATH >	pow_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a power node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	erf (shared_leaf< T, SAFE_MATH > x)
	Define erf convenience function.
template<std::floating_point T, bool SAFE_MATH = false>
shared_erf< T, SAFE_MATH >	erf_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a erf node.
template<jit::complex_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	erfi (shared_leaf< T, SAFE_MATH > x)
	Define erfi convenience function.
template<jit::complex_scalar T, bool SAFE_MATH = false>
shared_erfi< T, SAFE_MATH >	erfi_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a erfi node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	hypot (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build hypot node.
template<std::floating_point T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	hypot (const L l, shared_leaf< T, SAFE_MATH > r)
	Build hypot node.
template<std::floating_point T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	hypot (shared_leaf< T, SAFE_MATH > l, const R r)
	Build hypot node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_hypot< T, SAFE_MATH >	hypot_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a hypot node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	copysign (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build copysign node.
template<std::floating_point T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	copysign (const L l, shared_leaf< T, SAFE_MATH > r)
	Build copysign node.
template<std::floating_point T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	copysign (shared_leaf< T, SAFE_MATH > l, const R r)
	Build power node.
template<std::floating_point T, bool SAFE_MATH = false>
shared_copysign< T, SAFE_MATH >	copysign_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a copysign node.
template<jit::float_scalar T, bool SAFE_MATH = false>
constexpr shared_leaf< T, SAFE_MATH >	null_leaf ()
	Create a null leaf.
template<jit::float_scalar T, bool SAFE_MATH = false>
constexpr shared_leaf< T, SAFE_MATH >	zero ()
	Forward declare for zero.
template<jit::float_scalar T, bool SAFE_MATH = false>
constexpr shared_leaf< T, SAFE_MATH >	one ()
	Forward declare for one.
template<jit::float_scalar T, bool SAFE_MATH = false>
void	make_vizgraph (shared_leaf< T, SAFE_MATH > node)
	Build the vizgraph input.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	index ()
	Construct an index.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_index< T, SAFE_MATH >	index_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a index node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	constant (const backend::buffer< T > &d)
	Construct a constant.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	constant (const T d)
	Construct a constant.
template<jit::float_scalar T, bool SAFE_MATH = false>
constexpr shared_leaf< T, SAFE_MATH >	none ()
	Create a one constant.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_constant< T, SAFE_MATH >	constant_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a constant node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	variable (const size_t s, const std::string &symbol)
	Construct a variable.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	variable (const size_t s, const T d, const std::string &symbol)
	Construct a variable.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	variable (const std::vector< T > &d, const std::string &symbol)
	Construct a variable.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	variable (const backend::buffer< T > &d, const std::string &symbol)
	Construct a variable.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_variable< T, SAFE_MATH >	variable_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a variable node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	pseudo_variable (shared_leaf< T, SAFE_MATH > x)
	Define pseudo variable convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_pseudo_variable< T, SAFE_MATH >	pseudo_variable_cast (shared_leaf< T, SAFE_MATH > &x)
	Cast to a pseudo variable node.
template<std::floating_point T>
shared_leaf< T >	apply_u (shared_leaf< T > x, shared_leaf< T > i, shared_leaf< T > rand, shared_leaf< T > mof, shared_leaf< T > tbnu_e_dt, shared_leaf< T > A, shared_leaf< T > B)
	Build apply_u node.
template<std::floating_point T>
shared_apply_u< T >	apply_u_cast (shared_leaf< T > x)
	Cast to a apply_u node.
template<std::floating_point T>
shared_leaf< T >	apply_xi (shared_leaf< T > x, shared_leaf< T > i, shared_leaf< T > rand, shared_leaf< T > nu_D_dt)
	Build apply_xi node.
template<std::floating_point T>
shared_apply_xi< T >	apply_xi_cast (shared_leaf< T > x)
	Cast to a apply_u node.
template<jit::float_scalar T>
void	compile_index (std::ostringstream &stream, const std::string &register_name, const size_t length, const T scale, const T offset)
	Compile an index.
template<jit::float_scalar T>
void	compile_2D_index (std::ostringstream &stream, const std::string &x_register_name, const std::string &y_register_name, const size_t num_columns)
	Compile an 2D index.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	argument (shared_leaf< T, SAFE_MATH > x, const T scale, const T offset, const size_t length)
	Define argument convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_argument< T, SAFE_MATH >	argument_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a argument node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	piecewise_1D (const backend::buffer< T > &d, shared_leaf< T, SAFE_MATH > x)
	Define piecewise_1D convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	piecewise_1D (const backend::buffer< T > &d, shared_leaf< T, SAFE_MATH > x, const T scale, const T offset)
	Define piecewise_1D convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_piecewise_1D< T, SAFE_MATH >	piecewise_1D_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a piecewise 1D node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	piecewise_2D (const backend::buffer< T > &d, const size_t n, shared_leaf< T, SAFE_MATH > x, shared_leaf< T, SAFE_MATH > y)
	Define piecewise_2D convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	piecewise_2D (const backend::buffer< T > &d, const size_t n, shared_leaf< T, SAFE_MATH > x, const T x_scale, const T x_offset, shared_leaf< T, SAFE_MATH > y, const T y_scale, const T y_offset)
	Define piecewise_2D convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_piecewise_2D< T, SAFE_MATH >	piecewise_2D_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a piecewise 2D node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	index_1D (shared_leaf< T, SAFE_MATH > v, shared_leaf< T, SAFE_MATH > x)
	Define index_1D convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	index_1D (shared_leaf< T, SAFE_MATH > v, shared_leaf< T, SAFE_MATH > x, const T scale, const T offset)
	Define index_1D convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_index_1D< T, SAFE_MATH >	index_1D_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a index 1D node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	index_2D (shared_leaf< T, SAFE_MATH > v, const size_t n, shared_leaf< T, SAFE_MATH > x, shared_leaf< T, SAFE_MATH > y)
	Define index_2D convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	index_2D (shared_leaf< T, SAFE_MATH > v, const size_t n, shared_leaf< T, SAFE_MATH > x, const T x_scale, const T x_offset, shared_leaf< T, SAFE_MATH > y, const T y_scale, const T y_offset)
	Define index_2D convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_index_2D< T, SAFE_MATH >	index_2D_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a index 2D node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	atomic_accumulate_1D (shared_leaf< T, SAFE_MATH > v, shared_leaf< T, SAFE_MATH > i, shared_leaf< T, SAFE_MATH > x)
	Define atomic_accumulate_1D convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	atomic_accumulate_1D (shared_leaf< T, SAFE_MATH > v, shared_leaf< T, SAFE_MATH > x, const T scale, const T offset, shared_leaf< T, SAFE_MATH > y)
	Define atomic_accumulate_1D convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_atomic_accumulate_1D< T, SAFE_MATH >	atomic_accumulate_1D_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a atomic accumulate 1D node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	random_state (const size_t size, const uint32_t seed=0)
	Define random_state convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_random_state< T, SAFE_MATH >	random_state_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a random_state node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	random (shared_random_state< T, SAFE_MATH > state)
	Define random convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_random< T, SAFE_MATH >	random_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a random node.
template<jit::float_scalar T, bool SAFE_MATH = false>
constexpr shared_leaf< T, SAFE_MATH >	random_scale ()
	Create a random_scale constant.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
constexpr shared_leaf< T, SAFE_MATH >	uniform_random (const R min, const R max, shared_random_state< T, SAFE_MATH > state)
	Create a uniform random number.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	sin (shared_leaf< T, SAFE_MATH > x)
	Define sine convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_sine< T, SAFE_MATH >	sin_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a sine node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	cos (shared_leaf< T, SAFE_MATH > x)
	Define cosine convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_cosine< T, SAFE_MATH >	cos_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a cosine node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	tan (shared_leaf< T, SAFE_MATH > x)
	Define tangent convenience function.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	atan (shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
	Build arctan node.
template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	atan (const L l, shared_leaf< T, SAFE_MATH > r)
	Build power node.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	atan (shared_leaf< T, SAFE_MATH > l, const R r)
	Build power node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_atan< T, SAFE_MATH >	atan_cast (shared_leaf< T, SAFE_MATH > x)
	Cast to a power node.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	vector (shared_leaf< T, SAFE_MATH > x, shared_leaf< T, SAFE_MATH > y, shared_leaf< T, SAFE_MATH > z)
	Build a shared vector quantity.
template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	vector (const L x, shared_leaf< T, SAFE_MATH > y, shared_leaf< T, SAFE_MATH > z)
	Build a shared vector quantity.
template<jit::float_scalar T, jit::float_scalar M, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	vector (shared_leaf< T, SAFE_MATH > x, const M y, shared_leaf< T, SAFE_MATH > z)
	Build a shared vector quantity.
template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	vector (shared_leaf< T, SAFE_MATH > x, shared_leaf< T, SAFE_MATH > y, const R z)
	Build a shared vector quantity.
template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar M, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	vector (const L x, const M y, shared_leaf< T, SAFE_MATH > z)
	Build a shared vector quantity.
template<jit::float_scalar T, jit::float_scalar M, jit::float_scalar R, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	vector (shared_leaf< T, SAFE_MATH > x, const M y, const R z)
	Build a shared vector quantity.
template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar R, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	vector (const L x, shared_leaf< T, SAFE_MATH > y, const R z)
	Build a shared vector quantity.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	vector (const T x, const T y, const T z)
	Build a shared vector quantity.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	operator+ (shared_vector< T, SAFE_MATH > l, shared_vector< T, SAFE_MATH > r)
	Addition operator.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	operator- (shared_vector< T, SAFE_MATH > l, shared_vector< T, SAFE_MATH > r)
	Subtraction operator.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	operator* (shared_leaf< T, SAFE_MATH > s, shared_vector< T, SAFE_MATH > v)
	Multiplication operator.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_vector< T, SAFE_MATH >	operator/ (shared_vector< T, SAFE_MATH > v, shared_leaf< T, SAFE_MATH > s)
	Division operator.
template<jit::float_scalar T, bool SAFE_MATH = false>
shared_matrix< T, SAFE_MATH >	matrix (shared_vector< T, SAFE_MATH > r1, shared_vector< T, SAFE_MATH > r2, shared_vector< T, SAFE_MATH > r3)
	Build a shared vector quantity.

Variables
template<jit::complex_scalar T>
constexpr T	i = T(0.0, 1.0)
	Convenience type for imaginary constant.

Detailed Description

Name space for graph nodes.

Function Documentation

add()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::add	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build add node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

add_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_add< T, SAFE_MATH > graph::add_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a add node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

and_()

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::and_	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build and node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

and_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_and< T, SAFE_MATH > graph::and_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to an and node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

apply_u()

template<std::floating_point T>

shared_leaf< T > graph::apply_u	(	shared_leaf< T >	x,
		shared_leaf< T >	i,
		shared_leaf< T >	rand,
		shared_leaf< T >	mof,
		shared_leaf< T >	tbnu_e_dt,
		shared_leaf< T >	A,
		shared_leaf< T >	B
	)

Build apply_u node.

Template Parameters

T	Base type of the calculation.

Parameters

[in]	x	Argument to apply collision to.
[in]	i	Number of collision iterations.
[in]	rand	A random value of 32 0s and 1s.
[in]	mof	Mass over 2 e.
[in]	tbnu_e_dt	Temperature of species b times normalized collision rate.
[in]	A	A collision factor.
[in]	B	B collision factor.

Returns

A reduced apply_u node.

apply_u_cast()

template<std::floating_point T>

shared_apply_u< T > graph::apply_u_cast

(

shared_leaf< T >

x

)

Cast to a apply_u node.

Template Parameters

T	Base type of the calculation.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic case.

apply_xi()

template<std::floating_point T>

shared_leaf< T > graph::apply_xi	(	shared_leaf< T >	x,
		shared_leaf< T >	i,
		shared_leaf< T >	rand,
		shared_leaf< T >	nu_D_dt
	)

Build apply_xi node.

Template Parameters

T	Base type of the calculation.

Parameters

[in]	x	Argument to apply collision to.
[in]	i	Number of collision iterations.
[in]	rand	A random value of 32 0s and 1s.
[in]	nu_D_dt	Normalized step rate.

Returns

A reduced apply_xi node.

apply_xi_cast()

template<std::floating_point T>

shared_apply_xi< T > graph::apply_xi_cast

(

shared_leaf< T >

x

)

Cast to a apply_u node.

Template Parameters

T	Base type of the calculation.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic case.

argument()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::argument	(	shared_leaf< T, SAFE_MATH >	x,
		const T	scale,
		const T	offset,
		const size_t	length
	)

Define argument convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	x	Argument.
[in]	scale	Argument scale factor.
[in]	offset	Argument offset factor.
[in]	length	The array length.

Returns

A reduced argument node.

argument_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_argument< T, SAFE_MATH > graph::argument_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a argument node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

atan() [1/3]

template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::atan	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build power node.

Template Parameters

T	Base type of the calculation.
L	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

atan() [2/3]

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::atan	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build power node.

Template Parameters

T	Base type of the calculation.
R	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

atan() [3/3]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::atan	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build arctan node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

atan_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_atan< T, SAFE_MATH > graph::atan_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a power node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

atomic_accumulate_1D() [1/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::atomic_accumulate_1D	(	shared_leaf< T, SAFE_MATH >	v,
		shared_leaf< T, SAFE_MATH >	i,
		shared_leaf< T, SAFE_MATH >	x
	)

Define atomic_accumulate_1D convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	v	Variable to index.
[in]	i	Index into the variable.
[in]	x	Argument.

Returns

A reduced atomic_accumulate_1D node.

atomic_accumulate_1D() [2/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::atomic_accumulate_1D	(	shared_leaf< T, SAFE_MATH >	v,
		shared_leaf< T, SAFE_MATH >	x,
		const T	scale,
		const T	offset,
		shared_leaf< T, SAFE_MATH >	y
	)

Define atomic_accumulate_1D convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	v	Variable to index.
[in]	x	Index Argument.
[in]	scale	Argument scale factor.
[in]	offset	Argument offset factor.
[in]	y	Argument.

Returns

A reduced atomic_accumulate_1D node.

atomic_accumulate_1D_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_atomic_accumulate_1D< T, SAFE_MATH > graph::atomic_accumulate_1D_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a atomic accumulate 1D node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

compile_2D_index()

template<jit::float_scalar T>

void graph::compile_2D_index	(	std::ostringstream &	stream,
		const std::string &	x_register_name,
		const std::string &	y_register_name,
		const size_t	num_columns
	)

Compile an 2D index.

2D indicies are flattened to a single index.

Template Parameters

T	Base type of the calculation.

Parameters

[in,out]	stream	String buffer stream.
[in]	x_register_name	Register for the x argument.
[in]	y_register_name	Register for the x argument.
[in]	num_columns	The y index.

compile_index()

template<jit::float_scalar T>

void graph::compile_index	(	std::ostringstream &	stream,
		const std::string &	register_name,
		const size_t	length,
		const T	scale,
		const T	offset
	)

Compile an index.

Template Parameters

T	Base type of the calculation.

Parameters

[in,out]	stream	String buffer stream.
[in]	register_name	Register for the argument.
[in]	length	Dimension length of argument.
[in]	scale	Argument scale factor.
[in]	offset	Argument offset factor.

constant() [1/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::constant

(

const backend::buffer< T > &

d

)

Construct a constant.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

d

Array buffer.

Returns

A reduced constant node.

constant() [2/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::constant

(

const T

d

)

Construct a constant.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

d

Scalar data to initialize.

Returns

A reduced constant node.

constant_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_constant< T, SAFE_MATH > graph::constant_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a constant node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic case.

copysign() [1/3]

template<std::floating_point T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::copysign	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build copysign node.

Template Parameters

T	Base type of the calculation.
L	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

copysign a reduced node.

copysign() [2/3]

template<std::floating_point T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::copysign	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build power node.

Template Parameters

T	Base type of the calculation.
R	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

copysign a reduced node.

copysign() [3/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::copysign	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build copysign node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

copysign a reduced node.

copysign_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_copysign< T, SAFE_MATH > graph::copysign_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a copysign node.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

cos()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::cos

(

shared_leaf< T, SAFE_MATH >

x

)

Define cosine convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Argument.

Returns

A reduced cos node.

cos_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_cosine< T, SAFE_MATH > graph::cos_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a cosine node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

divide()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::divide	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build divide node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

divide_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_divide< T, SAFE_MATH > graph::divide_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a divide node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

equal()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::equal	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build equal node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

equal_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_equal< T, SAFE_MATH > graph::equal_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a equal node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

erf()

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::erf

(

shared_leaf< T, SAFE_MATH >

x

)

Define erf convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Argument.

Returns

A reduced exp node.

erf_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_erf< T, SAFE_MATH > graph::erf_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a erf node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

erfi()

template<jit::complex_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::erfi

(

shared_leaf< T, SAFE_MATH >

x

)

Define erfi convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Argument.

Returns

A reduced exp node.

erfi_cast()

template<jit::complex_scalar T, bool SAFE_MATH = false>

shared_erfi< T, SAFE_MATH > graph::erfi_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a erfi node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

exp()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::exp

(

shared_leaf< T, SAFE_MATH >

x

)

Define exp convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Argument.

Returns

A reduced exp node.

exp_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_exp< T, SAFE_MATH > graph::exp_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a exp node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic case.

fma() [1/7]

template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar M, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::fma	(	const L	l,
		const M	m,
		shared_leaf< T, SAFE_MATH >	r
	)

Build divide node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
M	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	m	Middle branch.
[in]	r	Right branch.

fma() [2/7]

template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::fma	(	const L	l,
		shared_leaf< T, SAFE_MATH >	m,
		const R	r
	)

Build multiply node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	m	Middle branch.
[in]	r	Right branch.

fma() [3/7]

template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::fma	(	const L	l,
		shared_leaf< T, SAFE_MATH >	m,
		shared_leaf< T, SAFE_MATH >	r
	)

Build divide node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	m	Middle branch.
[in]	r	Right branch.

fma() [4/7]

template<jit::float_scalar T, jit::float_scalar M, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::fma	(	shared_leaf< T, SAFE_MATH >	l,
		const M	m,
		const R	r
	)

Build divide node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
M	Float type for the constant.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	m	Middle branch.
[in]	r	Right branch.

fma() [5/7]

template<jit::float_scalar T, jit::float_scalar M, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::fma	(	shared_leaf< T, SAFE_MATH >	l,
		const M	m,
		shared_leaf< T, SAFE_MATH >	r
	)

Build divide node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
M	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	m	Middle branch.
[in]	r	Right branch.

fma() [6/7]

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::fma	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	m,
		const R	r
	)

Build multiply node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	m	Middle branch.
[in]	r	Right branch.

fma() [7/7]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::fma	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	m,
		shared_leaf< T, SAFE_MATH >	r
	)

Build fused multiply add node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	m	Middle branch.
[in]	r	Right branch.

fma_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_fma< T, SAFE_MATH > graph::fma_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a fma node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

greater_than()

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::greater_than	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build greater than node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

greater_than_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_greater_than< T, SAFE_MATH > graph::greater_than_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a greater than node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

greater_than_equal()

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::greater_than_equal	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build greater than equal node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

greater_than_equal_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_greater_than_equal< T, SAFE_MATH > graph::greater_than_equal_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a greater than equal node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

hypot() [1/3]

template<std::floating_point T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::hypot	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build hypot node.

Template Parameters

T	Base type of the calculation.
L	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

A reduced hypot node.

hypot() [2/3]

template<std::floating_point T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::hypot	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build hypot node.

Template Parameters

T	Base type of the calculation.
R	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

A reduced hypot node.

hypot() [3/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::hypot	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build hypot node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

A reduced hypot node.

hypot_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_hypot< T, SAFE_MATH > graph::hypot_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a hypot node.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

if_()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::if_	(	shared_leaf< T, SAFE_MATH >	c,
		shared_leaf< T, SAFE_MATH >	t,
		shared_leaf< T, SAFE_MATH >	f
	)

Build an if node from a condition and two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	c	Condition branch.
[in]	t	True branch.
[in]	f	False branch.

Returns

A reduced if node.

if_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_if< T, SAFE_MATH > graph::if_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to an if node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

index()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::index

(

)

Construct an index.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Returns

A reduced constant node.

index_1D() [1/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::index_1D	(	shared_leaf< T, SAFE_MATH >	v,
		shared_leaf< T, SAFE_MATH >	x
	)

Define index_1D convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	v	Variable to index.
[in]	x	Argument.

Returns

A reduced index_1D node.

index_1D() [2/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::index_1D	(	shared_leaf< T, SAFE_MATH >	v,
		shared_leaf< T, SAFE_MATH >	x,
		const T	scale,
		const T	offset
	)

Define index_1D convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	v	Variable to index.
[in]	x	Argument.
[in]	scale	Argument scale factor.
[in]	offset	Argument offset factor.

Returns

A reduced index_1D node.

index_1D_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_index_1D< T, SAFE_MATH > graph::index_1D_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a index 1D node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

index_2D() [1/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::index_2D	(	shared_leaf< T, SAFE_MATH >	v,
		const size_t	n,
		shared_leaf< T, SAFE_MATH >	x,
		const T	x_scale,
		const T	x_offset,
		shared_leaf< T, SAFE_MATH >	y,
		const T	y_scale,
		const T	y_offset
	)

Define index_2D convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	v	Variable to index.
[in]	n	Number of columns.
[in]	x	X argument.
[in]	x_scale	Scale for x argument.
[in]	x_offset	Offset for x argument.
[in]	y	Argument.
[in]	y_scale	Scale for y argument.
[in]	y_offset	Offset for y argument.

Returns

A reduced sqrt node.

index_2D() [2/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::index_2D	(	shared_leaf< T, SAFE_MATH >	v,
		const size_t	n,
		shared_leaf< T, SAFE_MATH >	x,
		shared_leaf< T, SAFE_MATH >	y
	)

Define index_2D convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	v	Variable to index.
[in]	n	Number of columns.
[in]	x	X argument.
[in]	y	Argument.

Returns

A reduced sqrt node.

index_2D_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_index_2D< T, SAFE_MATH > graph::index_2D_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a index 2D node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

index_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_index< T, SAFE_MATH > graph::index_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a index node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic case.

is_constant_combinable()

template<jit::float_scalar T, bool SAFE_MATH = false>

bool graph::is_constant_combinable	(	shared_leaf< T, SAFE_MATH >	a,
		shared_leaf< T, SAFE_MATH >	b
	)

Check if nodes are constant combinable.

Template Parameters

T	Base type of the nodes.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	a	Operand A
[in]	b	Operand B

Returns

True if a and b are combinable.

is_constant_promotable()

template<jit::float_scalar T, bool SAFE_MATH = false>

bool graph::is_constant_promotable	(	shared_leaf< T, SAFE_MATH >	a,
		shared_leaf< T, SAFE_MATH >	b
	)

Check if the constants are promotable.

Template Parameters

T	Base type of the nodes.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	a	Operand A
[in]	b	Operand B

Returns

True if a is promotable over b.

is_greater_exponent()

template<jit::float_scalar T, bool SAFE_MATH = false>

bool graph::is_greater_exponent	(	shared_leaf< T, SAFE_MATH >	a,
		shared_leaf< T, SAFE_MATH >	b
	)

Check if the exponent is greater than the other.

Template Parameters

T	Base type of the nodes.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	a	Operand A
[in]	b	Operand B

Returns

True if a and b are combinable.

is_variable_combinable()

template<jit::float_scalar T, bool SAFE_MATH = false>

bool graph::is_variable_combinable	(	shared_leaf< T, SAFE_MATH >	a,
		shared_leaf< T, SAFE_MATH >	b
	)

Check if the variable is combinable.

Template Parameters

T	Base type of the nodes.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	a	Operand A
[in]	b	Operand B

Returns

True if a and b are combinable.

is_variable_promotable()

template<jit::float_scalar T, bool SAFE_MATH = false>

bool graph::is_variable_promotable	(	shared_leaf< T, SAFE_MATH >	a,
		shared_leaf< T, SAFE_MATH >	b
	)

Check if the variable is variable is promotable.

Template Parameters

T	Base type of the nodes.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	a	Operand A
[in]	b	Operand B

Returns

True if a and b are combinable.

isinf()

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::isinf

(

shared_leaf< T, SAFE_MATH >

arg

)

Build not node from the argument leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

arg

Arguement

isinf_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_isinf< T, SAFE_MATH > graph::isinf_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a isinf node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

isnan()

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::isnan

(

shared_leaf< T, SAFE_MATH >

arg

)

Build isnan node from the argument leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

arg

Arguement

isnan_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_isnan< T, SAFE_MATH > graph::isnan_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to an isnan node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

less_than()

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::less_than	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build less than node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

less_than_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_less_than< T, SAFE_MATH > graph::less_than_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a less than node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

less_than_equal()

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::less_than_equal	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build less than equal node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

less_than_equal_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_less_than_equal< T, SAFE_MATH > graph::less_than_equal_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a less than equal node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

log()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::log

(

shared_leaf< T, SAFE_MATH >

x

)

Define log convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Argument.

Returns

A reduced log node.

log_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_log< T, SAFE_MATH > graph::log_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a exp node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic case.

make_vizgraph()

template<jit::float_scalar T, bool SAFE_MATH = false>

void graph::make_vizgraph

(

shared_leaf< T, SAFE_MATH >

node

)

Build the vizgraph input.

Parameters

[in]

node

Node to build the graph of.

matrix()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_matrix< T, SAFE_MATH > graph::matrix	(	shared_vector< T, SAFE_MATH >	r1,
		shared_vector< T, SAFE_MATH >	r2,
		shared_vector< T, SAFE_MATH >	r3
	)

Build a shared vector quantity.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	r1	Row 1 matrix component.
[in]	r2	Row 2 matrix component.
[in]	r3	Row 3 matrix component.

Returns

A matrix.

min() [1/3]

template<std::floating_point T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::min	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build min node.

Template Parameters

T	Base type of the calculation.
L	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

A reduced min node.

min() [2/3]

template<std::floating_point T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::min	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build min node.

Template Parameters

T	Base type of the calculation.
R	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

A reduced min node.

min() [3/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::min	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build a max node from a condition and two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

A reduced min node.

min_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_min< T, SAFE_MATH > graph::min_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to an min node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

modulo()

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::modulo	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build modulo node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

modulo_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_modulo< T, SAFE_MATH > graph::modulo_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a modulo node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

multiply()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::multiply	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build multiply node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

multiply_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_multiply< T, SAFE_MATH > graph::multiply_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a multiply node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

none()

template<jit::float_scalar T, bool SAFE_MATH = false>

constexpr shared_leaf< T, SAFE_MATH > graph::none ( )

constexpr

Create a one constant.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Returns

A one constant.

not_()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::not_

(

shared_leaf< T, SAFE_MATH >

arg

)

Build not node from the argument leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

arg

Arguement

not_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_not< T, SAFE_MATH > graph::not_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a not node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

not_equal()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::not_equal	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build note equal node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

not_equal_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_not_equal< T, SAFE_MATH > graph::not_equal_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a equal node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

null_leaf()

template<jit::float_scalar T, bool SAFE_MATH = false>

constexpr shared_leaf< T, SAFE_MATH > graph::null_leaf ( )

constexpr

Create a null leaf.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Returns

A null leaf.

one()

template<jit::float_scalar T, bool SAFE_MATH = false>

constexpr shared_leaf< T, SAFE_MATH > graph::one ( )

constexpr

Forward declare for one.

Create a one constant.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Returns

A one constant.

operator!()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator!

(

shared_leaf< T, SAFE_MATH >

arg

)

Build not node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

arg

Arguement

operator!=() [1/3]

template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator!=	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build not equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator!=() [2/3]

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator!=	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build not equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator!=() [3/3]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator!=	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build not equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator%() [1/3]

template<std::floating_point T, std::floating_point L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator%	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build modulo node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator%() [2/3]

template<std::floating_point T, std::floating_point R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator%	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build modulo node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator%() [3/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator%	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build modulo node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator&&() [1/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator&&	(	const bool	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build and node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator&&() [2/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator&&	(	shared_leaf< T, SAFE_MATH >	l,
		const bool	r
	)

Build and node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator&&() [3/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator&&	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build and node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator*() [1/4]

template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator*	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build multiply node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator*() [2/4]

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator*	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build multiply node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator*() [3/4]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator*	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build multiply node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator*() [4/4]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::operator*	(	shared_leaf< T, SAFE_MATH >	s,
		shared_vector< T, SAFE_MATH >	v
	)

Multiplication operator.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	s	Scalar term.
[in]	v	Vector term.

Returns

The scalar vector multiply.

operator+() [1/4]

template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator+	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build add node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator+() [2/4]

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator+	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build add node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator+() [3/4]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator+	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build add node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator+() [4/4]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::operator+	(	shared_vector< T, SAFE_MATH >	l,
		shared_vector< T, SAFE_MATH >	r
	)

Addition operator.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left vector.
[in]	r	Right vector.

Returns

The vector vector addition.

operator-() [1/5]

template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator-	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build subtract node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

l - r

operator-() [2/5]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator-

(

shared_leaf< T, SAFE_MATH >

a

)

Negate a node.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

a

Argument to negate.

Returns

-1.0*a

operator-() [3/5]

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator-	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build subtract node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

l - r

operator-() [4/5]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator-	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build subtract node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

l - r

operator-() [5/5]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::operator-	(	shared_vector< T, SAFE_MATH >	l,
		shared_vector< T, SAFE_MATH >	r
	)

Subtraction operator.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left vector.
[in]	r	Right vector.

Returns

The vector vector addition.

operator/() [1/4]

template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator/	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build divide node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator/() [2/4]

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator/	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build multiply node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator/() [3/4]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator/	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build divide node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator/() [4/4]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::operator/	(	shared_vector< T, SAFE_MATH >	v,
		shared_leaf< T, SAFE_MATH >	s
	)

Division operator.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	v	Vector numerator.
[in]	s	Scalar denominator.

Returns

The vector scalar division.

operator<() [1/3]

template<std::floating_point T, std::floating_point L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator<	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build less than node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator<() [2/3]

template<std::floating_point T, std::floating_point R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator<	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build less than node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator<() [3/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator<	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build less than node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator<=() [1/3]

template<std::floating_point T, std::floating_point L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator<=	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build less than equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator<=() [2/3]

template<std::floating_point T, std::floating_point R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator<=	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build less than equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator<=() [3/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator<=	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build less than equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator==() [1/3]

template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator==	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator==() [2/3]

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator==	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator==() [3/3]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator==	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator>() [1/3]

template<std::floating_point T, std::floating_point L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator>	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build greater than node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator>() [2/3]

template<std::floating_point T, std::floating_point R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator>	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build greater than node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator>() [3/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator>	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build greater than node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator>=() [1/3]

template<std::floating_point T, std::floating_point L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator>=	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build greater than equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator>=() [2/3]

template<std::floating_point T, std::floating_point R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator>=	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build greater than equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator>=() [3/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator>=	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build greater than equal node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator||() [1/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator||	(	const bool	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build or node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator||() [2/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator||	(	shared_leaf< T, SAFE_MATH >	l,
		const bool	r
	)

Build or node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

operator||() [3/3]

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::operator||	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build or node from two leaves.

Note use templates here to defer this so it can be used in the above classes.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

or_()

template<std::floating_point T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::or_	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build or node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

or_cast()

template<std::floating_point T, bool SAFE_MATH = false>

shared_or< T, SAFE_MATH > graph::or_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a or node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

piecewise_1D() [1/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::piecewise_1D	(	const backend::buffer< T > &	d,
		shared_leaf< T, SAFE_MATH >	x
	)

Define piecewise_1D convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	d	Data to initialize the piecewise constant.
[in]	x	Argument.

Returns

A reduced piecewise_1D node.

piecewise_1D() [2/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::piecewise_1D	(	const backend::buffer< T > &	d,
		shared_leaf< T, SAFE_MATH >	x,
		const T	scale,
		const T	offset
	)

Define piecewise_1D convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	d	Data to initialize the piecewise constant.
[in]	x	Argument.
[in]	scale	Argument scale factor.
[in]	offset	Argument offset factor.

Returns

A reduced piecewise_1D node.

piecewise_1D_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_piecewise_1D< T, SAFE_MATH > graph::piecewise_1D_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a piecewise 1D node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

piecewise_2D() [1/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::piecewise_2D	(	const backend::buffer< T > &	d,
		const size_t	n,
		shared_leaf< T, SAFE_MATH >	x,
		const T	x_scale,
		const T	x_offset,
		shared_leaf< T, SAFE_MATH >	y,
		const T	y_scale,
		const T	y_offset
	)

Define piecewise_2D convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	d	Data to initialize the piecewise constant.
[in]	n	Number of columns.
[in]	x	X argument.
[in]	x_scale	Scale for x argument.
[in]	x_offset	Offset for x argument.
[in]	y	Y argument.
[in]	y_scale	Scale for y argument.
[in]	y_offset	Offset for y argument.

Returns

A reduced sqrt node.

piecewise_2D() [2/2]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::piecewise_2D	(	const backend::buffer< T > &	d,
		const size_t	n,
		shared_leaf< T, SAFE_MATH >	x,
		shared_leaf< T, SAFE_MATH >	y
	)

Define piecewise_2D convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	d	Data to initialize the piecewise constant.
[in]	n	Number of columns.
[in]	x	X argument.
[in]	y	Y argument.

Returns

A reduced piecewise_2D node.

piecewise_2D_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_piecewise_2D< T, SAFE_MATH > graph::piecewise_2D_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a piecewise 2D node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

pow() [1/3]

template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::pow	(	const L	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build power node.

Template Parameters

T	Base type of the calculation.
L	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

pow() [2/3]

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::pow	(	shared_leaf< T, SAFE_MATH >	l,
		const R	r
	)

Build power node.

Template Parameters

T	Base type of the calculation.
R	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

pow() [3/3]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::pow	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build power node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

pow_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_pow< T, SAFE_MATH > graph::pow_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a power node.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

pseudo_variable()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::pseudo_variable

(

shared_leaf< T, SAFE_MATH >

x

)

Define pseudo variable convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Argument.

Returns

A reduced pseudo variable node.

pseudo_variable_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_pseudo_variable< T, SAFE_MATH > graph::pseudo_variable_cast

(

shared_leaf< T, SAFE_MATH > &

x

)

Cast to a pseudo variable node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic case.

random()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::random

(

shared_random_state< T, SAFE_MATH >

state

)

Define random convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

state

Random state node.

Returns

A reduced random node.

random_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_random< T, SAFE_MATH > graph::random_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a random node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

random_scale()

template<jit::float_scalar T, bool SAFE_MATH = false>

constexpr shared_leaf< T, SAFE_MATH > graph::random_scale ( )

constexpr

Create a random_scale constant.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Returns

A random_scale constant.

random_state()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::random_state	(	const size_t	size,
		const uint32_t	seed = 0
	)

Define random_state convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	size	Number of random states.
[in]	seed	Initial random seed.

Returns

A reduced random_state node.

random_state_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_random_state< T, SAFE_MATH > graph::random_state_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a random_state node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

sin()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::sin

(

shared_leaf< T, SAFE_MATH >

x

)

Define sine convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Argument.

Returns

A reduced sin node.

sin_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_sine< T, SAFE_MATH > graph::sin_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a sine node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

sqrt()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::sqrt

(

shared_leaf< T, SAFE_MATH >

x

)

Define sqrt convenience function.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Argument.

Returns

A reduced sqrt node.

sqrt_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_sqrt< T, SAFE_MATH > graph::sqrt_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a sqrt node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic case.

subtract()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::subtract	(	shared_leaf< T, SAFE_MATH >	l,
		shared_leaf< T, SAFE_MATH >	r
	)

Build subtract node from two leaves.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	l	Left branch.
[in]	r	Right branch.

Returns

l - r

subtract_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_subtract< T, SAFE_MATH > graph::subtract_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a subtract node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic cast.

tan()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::tan

(

shared_leaf< T, SAFE_MATH >

x

)

Define tangent convenience function.

tan(x) = sin(x)/cos(x)

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Argument.

Returns

A reduced tan node.

uniform_random()

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

constexpr shared_leaf< T, SAFE_MATH > graph::uniform_random ( const R  min, const R  max, shared_random_state< T, SAFE_MATH >  state  )

constexpr

Create a uniform random number.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	min	Minimum value.
[in]	max	Maximum value.
[in]	state	Random state node.

Returns

A uniform random constant.

variable() [1/4]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::variable	(	const backend::buffer< T > &	d,
		const std::string &	symbol
	)

Construct a variable.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	d	Array buffer.
[in]	symbol	Symbol of the variable used in equations.

variable() [2/4]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::variable	(	const size_t	s,
		const std::string &	symbol
	)

Construct a variable.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	s	Size of the data buffer.
[in]	symbol	Symbol of the variable used in equations.

variable() [3/4]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::variable	(	const size_t	s,
		const T	d,
		const std::string &	symbol
	)

Construct a variable.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	s	Size of he data buffer.
[in]	d	Scalar data to initialize.
[in]	symbol	Symbol of the variable used in equations.

variable() [4/4]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_leaf< T, SAFE_MATH > graph::variable	(	const std::vector< T > &	d,
		const std::string &	symbol
	)

Construct a variable.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	d	Array buffer.
[in]	symbol	Symbol of the variable used in equations.

variable_cast()

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_variable< T, SAFE_MATH > graph::variable_cast

(

shared_leaf< T, SAFE_MATH >

x

)

Cast to a variable node.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]

x

Leaf node to attempt cast.

Returns

An attempted dynamic case.

vector() [1/8]

template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar M, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::vector	(	const L	x,
		const M	y,
		shared_leaf< T, SAFE_MATH >	z
	)

Build a shared vector quantity.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
M	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	x	X vector component.
[in]	y	Y vector component.
[in]	z	Z Vector component.

Returns

A vector.

vector() [2/8]

template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar R, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::vector	(	const L	x,
		shared_leaf< T, SAFE_MATH >	y,
		const R	z
	)

Build a shared vector quantity.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	x	X vector component.
[in]	y	Y vector component.
[in]	z	Z Vector component.

Returns

A vector.

vector() [3/8]

template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::vector	(	const L	x,
		shared_leaf< T, SAFE_MATH >	y,
		shared_leaf< T, SAFE_MATH >	z
	)

Build a shared vector quantity.

Template Parameters

T	Base type of the calculation.
L	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	x	X vector component.
[in]	y	Y vector component.
[in]	z	Z Vector component.

Returns

A vector.

vector() [4/8]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::vector	(	const T	x,
		const T	y,
		const T	z
	)

Build a shared vector quantity.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	x	X vector component.
[in]	y	Y vector component.
[in]	z	Z Vector component.

Returns

A vector.

vector() [5/8]

template<jit::float_scalar T, jit::float_scalar M, jit::float_scalar R, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::vector	(	shared_leaf< T, SAFE_MATH >	x,
		const M	y,
		const R	z
	)

Build a shared vector quantity.

Template Parameters

T	Base type of the calculation.
M	Float type for the constant.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	x	X vector component.
[in]	y	Y vector component.
[in]	z	Z Vector component.

Returns

A vector.

vector() [6/8]

template<jit::float_scalar T, jit::float_scalar M, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::vector	(	shared_leaf< T, SAFE_MATH >	x,
		const M	y,
		shared_leaf< T, SAFE_MATH >	z
	)

Build a shared vector quantity.

Template Parameters

T	Base type of the calculation.
M	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	x	X vector component.
[in]	y	Y vector component.
[in]	z	Z Vector component.

Returns

A vector.

vector() [7/8]

template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::vector	(	shared_leaf< T, SAFE_MATH >	x,
		shared_leaf< T, SAFE_MATH >	y,
		const R	z
	)

Build a shared vector quantity.

Template Parameters

T	Base type of the calculation.
R	Float type for the constant.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	x	X vector component.
[in]	y	Y vector component.
[in]	z	Z Vector component.

Returns

A vector.

vector() [8/8]

template<jit::float_scalar T, bool SAFE_MATH = false>

shared_vector< T, SAFE_MATH > graph::vector	(	shared_leaf< T, SAFE_MATH >	x,
		shared_leaf< T, SAFE_MATH >	y,
		shared_leaf< T, SAFE_MATH >	z
	)

Build a shared vector quantity.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Parameters

[in]	x	X vector component.
[in]	y	Y vector component.
[in]	z	Z Vector component.

Returns

A vector.

zero()

template<jit::float_scalar T, bool SAFE_MATH = false>

constexpr shared_leaf< T, SAFE_MATH > graph::zero ( )

constexpr

Forward declare for zero.

Create a zero constant.

Template Parameters

T	Base type of the calculation.
SAFE_MATH	Use Safe Math operations.

Returns

A zero constant.