Name space for graph nodes. More...

Classes
class	add_node
	An addition node. More...

class	arctan_node
	Class representing a sine_node leaf. More...

class	branch_node
	Class representing a branch node. More...

class	constant_node
	Class representing data that cannot change. More...

class	cosine_node
	Class representing a cosine_node leaf. More...

class	divide_node
	A division 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	leaf_node
	Class representing a node leaf. More...

class	log_node
	A log node. More...

class	matrix_quantity
	Class to represent matrix quantities. More...

class	multiply_node
	A multiplcation 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<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<jit::complex_scalar T, bool SAFE_MATH = false>
using	shared_erfi = std::shared_ptr< erfi_node< T, SAFE_MATH > >
	Convenience type alias for shared exp 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_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 maping end codes back to inputs.

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<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_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 add 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_combineable (shared_leaf< T, SAFE_MATH > a, shared_leaf< T, SAFE_MATH > b)
	Check if nodes are constant combineable.

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_combineable (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<jit::float_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	sqrt (shared_leaf< T, SAFE_MATH > x)
	Define sqrt convience 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 convience 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 convience 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<jit::complex_scalar T, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	erfi (shared_leaf< T, SAFE_MATH > x)
	Define erfi convience 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 exp 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 >	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 convience 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<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, 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 convience 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, 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 convience 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 >	random_state (const size_t size, const uint32_t seed=0)
	Define random_state convience 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 convience 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, bool SAFE_MATH = false>
shared_leaf< T, SAFE_MATH >	sin (shared_leaf< T, SAFE_MATH > x)
	Define sine convience 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 convience 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 convience 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)
	Convinece 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 attemped dynamic case.

◆ 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 attemped dynamic case.

◆ 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	Reister 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 initalize.

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 attemped dynamic case.

◆ 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 convience 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 attemped dynamic case.

◆ 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 attemped dynamic case.

◆ 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 convience 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 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 attemped dynamic case.

◆ 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 convience 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 attemped 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 attemped dynamic case.

◆ is_constant_combineable()

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

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

Check if nodes are constant combineable.

Template Parameters

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

Parameters

[in]	a	Opperand A
[in]	b	Opperand 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	Opperand A
[in]	b	Opperand B

Returns: True if a is promoteable 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	Opperand A
[in]	b	Opperand B

Returns: True if a and b are combinable.

◆ is_variable_combineable()

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

bool graph::is_variable_combineable	(	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	Opperand A
[in]	b	Opperand 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	Opperand A
[in]	b	Opperand B

Returns: True if a and b are combinable.

◆ 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 convience 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 attemped 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.

◆ 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 attemped dynamic case.

◆ 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.

◆ 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*() [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.

◆ piecewise_1D()

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 convience function.

Template Parameters

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

Parameters

[in]	d	Data to initalize 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 attemped dynamic case.

◆ piecewise_2D()

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 convience function.

Template Parameters

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

Parameters

[in]	d	Data to initalize 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	Argument.
[in]	y_scale	Scale for y argument.
[in]	y_offset	Offset for y argument.

Returns: A reduced sqrt 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 attemped dynamic case.

◆ 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 attemped dynamic case.

◆ 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 convience 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 attemped 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 convience 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 attemped dynamic case.

◆ 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 convience function.

Template Parameters

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

Parameters

[in]	size	Number of random states.
[in]	seed	Inital 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 attemped dynamic case.

◆ 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 convience 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 attemped dynamic case.

◆ 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 convience 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 attemped 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 attemped dynamic case.

◆ 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 convience 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.

◆ 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 initalize.
[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 attemped 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.

Classes

Typedefs

Functions

Variables

Detailed Description

Function Documentation

◆ add()

◆ add_cast()

◆ atan() [1/3]

◆ atan() [2/3]

◆ atan() [3/3]

◆ atan_cast()

◆ compile_index()

◆ constant() [1/2]

◆ constant() [2/2]

◆ constant_cast()

◆ cos()

◆ cos_cast()

◆ divide()

◆ divide_cast()

◆ erfi()

◆ erfi_cast()

◆ exp()

◆ exp_cast()

◆ fma() [1/7]

◆ fma() [2/7]

◆ fma() [3/7]

◆ fma() [4/7]

◆ fma() [5/7]

◆ fma() [6/7]

◆ fma() [7/7]

◆ fma_cast()

◆ is_constant_combineable()

◆ is_constant_promotable()

◆ is_greater_exponent()

◆ is_variable_combineable()

◆ is_variable_promotable()

◆ log()

◆ log_cast()

◆ make_vizgraph()

◆ matrix()

◆ multiply()

◆ multiply_cast()

◆ none()

◆ null_leaf()

◆ one()

◆ operator*() [1/4]

◆ operator*() [2/4]

◆ operator*() [3/4]

◆ operator*() [4/4]

◆ operator+() [1/4]

◆ operator+() [2/4]

◆ operator+() [3/4]

◆ operator+() [4/4]

◆ operator-() [1/5]

◆ operator-() [2/5]

◆ operator-() [3/5]

◆ operator-() [4/5]

◆ operator-() [5/5]

◆ operator/() [1/4]

◆ operator/() [2/4]

◆ operator/() [3/4]

◆ operator/() [4/4]

◆ piecewise_1D()

◆ piecewise_1D_cast()

◆ piecewise_2D()

◆ piecewise_2D_cast()

◆ pow() [1/3]

◆ pow() [2/3]

◆ pow() [3/3]

◆ pow_cast()

◆ pseudo_variable()

◆ pseudo_variable_cast()

◆ random()

◆ random_cast()

◆ random_scale()

◆ random_state()

◆ random_state_cast()

◆ sin()

◆ sin_cast()