viennamath Namespace Reference

The main ViennaMath namespace. All types and functions for the user reside here. More...

Namespaces
namespace	detail
	Implementation details for functionality in ViennaMath. Not intended for direct use.
namespace	result_of
	The namespace containing a set of metafunctions which can be used by the ViennaMath library user.
namespace	traits
	Any generic free functions for unifying interfaces are defined here.
Data Structures
struct	op_plus
	Tag for addition. More...
struct	op_minus
	Tag for subtraction. More...
struct	op_mult
	Tag for multiplication. More...
struct	op_div
	Tag for division. More...
class	ct_binary_expr
	A compile time expression consisting of two operands and one operation (taking two arguments). More...
class	ct_constant
	A compiletime constant. More...
class	ct_equation
	A compile time equation. More...
struct	unknown_tag
	A compiletime tag for an unknown function: More...
struct	test_tag
	A compiletime tag for a test function: More...
class	ct_function_symbol
	A function symbol. Can be used for unknown functions, test functions, etc. Cannot be evaluated, but substituted with an evaluable object. More...
class	ct_interval
	A compile time interval. More...
class	ct_unary_expr
	Defines a unary expression f(e), where f is function and 'e' is an expression. More...
struct	type_by_index
	Helper metafunction for returning the 'id'-th entry of a compiletime vector. More...
struct	type_by_index< vmath_vector, 0 >
	Accesses the first entry in a compiletime vector. More...
struct	type_by_index< vmath_vector, 1 >
	Accesses the second entry in a compiletime vector. More...
struct	type_by_index< vmath_vector, 2 >
	Accesses the third entry in a compiletime vector. More...
struct	variable_traits
	Helper struct for accessing the i-th element of a vector at runtime. More...
struct	variable_traits< ct_vector_1< T0 >, id >
	Helper struct for accessing the i-th element of a vector at runtime. Specialization for a ViennaMath compiletime vector with one entry. More...
struct	variable_traits< ct_vector_2< T0, T1 >, id >
	Helper struct for accessing the i-th element of a vector at runtime. Specialization for a ViennaMath compiletime vector with two entries. More...
struct	variable_traits< ct_vector_3< T0, T1, T2 >, id >
	Helper struct for accessing the i-th element of a vector at runtime. Specialization for a ViennaMath compiletime vector with three entries. More...
struct	variable_traits< ct_constant< value_ >, 0 >
	Helper struct for accessing the 0-th element of a constant at runtime. More...
struct	variable_traits< ct_constant< value_ >, id >
	Compiletime guard for index out of bounds. More...
struct	ct_variable
	Representation of a mathematical variable. If the supplied argument is some vector type, a traits system accesses the id-th component. More...
class	ct_vector_1
	Compiletime vector with one element. More...
class	ct_vector_2
	Compiletime vector with one element. More...
class	ct_vector_3
	Compiletime vector with one element. More...
struct	promote_traits
	For two numeric types T and U with objects t and u respectively, the result type of t+u is returned. Default case: return the basic numeric type for ViennaMath. More...
struct	promote_traits< T, OP, T >
	The result type of two operands of the same type is of the same type again (cf. standard C/C++ behavior for integers). More...
struct	promote_traits< double, OP, long >
struct	promote_traits< long, OP, double >
struct	promote_traits< double, OP, int >
struct	promote_traits< int, OP, double >
struct	promote_traits< double, OP, float >
struct	promote_traits< float, OP, double >
struct	promote_traits< float, OP, long >
struct	promote_traits< long, OP, float >
struct	promote_traits< float, OP, int >
struct	promote_traits< int, OP, float >
struct	promote_traits< long, op_div< NumericType >, long >
struct	promote_traits< long, op_div< NumericType >, int >
struct	promote_traits< int, op_div< NumericType >, long >
struct	op_id
	Identity mapping: x |--> x. More...
struct	op_exp
	Exponential mapping: x |--> exp(x). More...
struct	op_sin
	Sine function: x |--> sin(x). More...
struct	op_cos
	Cosine function: x |--> cos(x). More...
struct	op_tan
	Tangent function: x |--> tan(x). More...
struct	op_fabs
	Modulus: x |--> |x|. More...
struct	op_sqrt
	Square root: x |--> \sqrt{x}. More...
struct	op_log
	Natural logarithm function: x |--> ln(x). More...
struct	op_log10
	Logarithm with base 10: x |--> \log_{10}(x). More...
struct	op_gradient
	Gradient operator: f |--> grad(x). More...
struct	op_divergence
	Divergence operator: f |--> div(f). More...
class	op_partial_deriv
	Divergence operator: f |--> d f / (d x_i). More...
class	op_ct_integral
	Integration operator: f |--> \int_I f d x. More...
struct	integration_without_integral_exception
	Exception for the case that an integration over expressions without integral is attempted. More...
struct	symbolic_integral_evaluation_not_possible_exception
	Analytic integration at runtime not supported. More...
struct	analytic_integration_not_supported_exception
	Analytic integration at runtime not supported. More...
struct	no_rhs_provided_exception
	An exception which is thrown if no right hand side operand is passed to a binary operation. More...
struct	rhs_provided_for_unary_operation_exception
	An exception which is thrown if a right hand side argument is passed to a unary operation. More...
class	expression_not_evaluable_exception
	An exception which is thrown if an expression should be evaluated to a floating point number using eval(), but at least one of the leaves in the expression tree cannot be evaluated (e.g. is a function symbol). More...
class	expression_not_unwrappable_exception
	An exception which is thrown if an expression should be reduced to a floating point number using unwrap(), but at least one of the leaves in the expression tree is not a constant (e.g. is a variable). More...
class	expression_not_differentiable_exception
	An exception which is thrown if an expression should be differentiated, but at least one of the leaves in the expression tree cannot be differentiated (e.g. is a function symbol). More...
class	variable_index_out_of_bounds_exception
	An exception which is thrown if a variable index is out of bounds. Similar to the C++ STL, index checks are performed on vectors using the .at() member function only. More...
struct	enable_if
	Simple enable-if variant that uses the SFINAE pattern. More...
struct	enable_if< false, T >
struct	cartesian
	A tag representing a Cartesian coordinate system in arbitrary dimensions. More...
class	numeric_type_proxy
	A proxy object which allows for the use of plain default_numeric_type with template operator+, operator-, operator*, operator/ without running into problems with ambiguity. With the proxy object, one additional conversion is required, thus resolving the ambiguity. More...
struct	ct_index
	Compiletime respresentation of a vector access index. More...
struct	expression_traits
	A traits system for expressions. For now provides a deduction of the const reference type only. More...
struct	expression_traits< ct_constant< value > >
	Specialization of the expression traits system: A compiletime constant can be copied with no extra cost, thus no need for const reference. More...
struct	expression_traits< rt_constant< T, InterfaceType > >
	Specialization of the expression traits system: A runtime constant does not allow for copying, otherwise one runs into problems with tempories. More...
class	rt_latex_processor_interface
	The abstract interface for each LaTeX processor module. More...
class	rt_latex_translator
	The main LaTeX translator class. To be used and manipulated by the ViennaMath library user. More...
class	rt_latex_binary_expr_processor
	A LaTeX processor responsible for translating binary expressions to LaTeX code. More...
class	rt_latex_unary_expr_processor
	A LaTeX processor responsible for translating unary expressions to LaTeX code. More...
class	rt_latex_constant_processor
	A LaTeX processor responsible for translating ViennaMath runtime constants to LaTeX code. More...
class	rt_latex_variable_processor
	A LaTeX processor responsible for translating ViennaMath runtime variables to LaTeX code. More...
class	rt_latex_function_symbol_processor
	A LaTeX processor responsible for translating ViennaMath runtime function symbols to LaTeX code. More...
class	rt_binary_expr
	Runtime representation of a binary expression F(x,y), where F is a function of two argument (e.g. +) and x,y are expressions. More...
class	op_binary
	This is the common wrapper class for binary operations. More...
class	rt_constant
	Representation of a constant within the expression setting of ViennaMath. More...
class	rt_equation
	Runtime representation of a equation by a left hand side and a right hand side expresssion. More...
class	rt_expr
	This class represents a smart pointer to all types expressions. More...
class	rt_expression_interface
	Abstract interface for all ViennaMath runtime expressions. More...
class	rt_function_symbol
	A function symbol. Can be used for unknown functions, test functions, etc. Cannot be evaluated, but substituted with an evaluable object. More...
class	rt_manipulation_interface
	The abstract runtime interface for all expression manipulators. More...
class	rt_manipulation_wrapper
	A wrapper using type erasure for manipulation functors acting on expressions. More...
class	rt_traversal_interface
	The abstract runtime interface for all expression traversal routines. More...
class	rt_traversal_wrapper
	A wrapper using type erasure for traversal functions acting on expressions. More...
struct	callback_if_castable
	A helper class which calls a provided functor if the supplied expression pointer can be cast to the target type. More...
class	op_rt_integral
	A unary operation defining an integral over an interval. More...
class	op_rt_symbolic_integral
	A unary operation encoding a symbolic interval. Cannot be evaluated and is meant to be replaced by a concrete integration later on. More...
class	rt_interval
	Represents an interval [a,b] at runtime. Note that the interval boundaries do not need to be constants. More...
class	numerical_quadrature_interface
	The abstract runtime interface for all numerical quadrature rules. More...
class	rt_gauss_quad_1
	Gauss quadrature rule with first-order accuracy. More...
class	rt_numerical_quadrature
	The main numerical quadrature rule class. Wraps the integration rule and performs all the book-keeping for the evaluation. More...
class	op_interface
	The abstract runtime interface for all operations (unary and binary). More...
class	rt_symbolic_interval
	A symbolic runtime interval. More...
class	rt_unary_expr
	Runtime representation of a unary expression F(e), where F is a function of one argument (e.g. log()) and e is an expression. More...
class	op_unary
	Main class for all unary operations. More...
class	rt_variable
	Representation of an variable (a variable). If the supplied argument is some vector type, a traits system accesses the id-th component. More...
class	rt_vector_expr
	An tweaked auto_ptr for run time rt_expr types. More...
Typedefs
typedef double	default_numeric_type
	The underlying floating point type to be used in case of doubt (e.g. when new constants are created during manipulation).
typedef unsigned long	id_type
	Type used for any kind of IDs (variable, etc.).
typedef rt_expression_interface < default_numeric_type >	default_interface_type
	Convenience type definition for the default expression interface.
typedef rt_variable	variable
typedef rt_constant	constant
typedef rt_binary_expr	binary_expr
typedef rt_unary_expr	unary_expr
typedef rt_expr	expr
typedef rt_vector_expr	vector_expr
typedef rt_function_symbol	function_symbol
typedef rt_equation	equation
typedef rt_interval	interval
typedef rt_symbolic_interval	symbolic_interval
typedef rt_latex_translator	latex_translator
	Convenience typedef for the latex translator in order to avoid the ugly '<>' for the default template parameter of rt_latex_translator.
typedef rt_gauss_quad_1	gauss_quad_1
typedef rt_numerical_quadrature	numerical_quadrature
Functions
template<typename LHS , typename OP , typename RHS >
std::ostream &	operator<< (std::ostream &stream, ct_binary_expr< LHS, OP, RHS > const &other)
	Convenience overload for printing a compiletime binary expression to an output stream.
template<long value_>
std::ostream &	operator<< (std::ostream &stream, ct_constant< value_ > const &c)
	Convenience overload for printing a compiletime constant to an output stream.
template<typename LHS , typename RHS >
std::ostream &	operator<< (std::ostream &stream, ct_equation< LHS, RHS > const &u)
	Convenience overload for printing a compiletime equation to an output stream.
template<typename LHS1 , typename OP1 , typename RHS1 , typename LHS2 , typename OP2 , typename RHS2 >
ct_equation< ct_binary_expr < LHS1, OP1, RHS1 > , ct_binary_expr< LHS2, OP2, RHS2 > >	make_equation (ct_binary_expr< LHS1, OP1, RHS1 > const &lhs, ct_binary_expr< LHS2, OP2, RHS2 > const &rhs)
	Generates an equation from two binary expressions at compiletime.
template<typename LHS1 , typename OP1 , typename RHS1 , typename LHS2 , typename OP2 >
ct_equation< ct_binary_expr < LHS1, OP1, RHS1 > , ct_unary_expr< LHS2, OP2 > >	make_equation (ct_binary_expr< LHS1, OP1, RHS1 > const &lhs, ct_unary_expr< LHS2, OP2 > const &rhs)
	Generates an equation from a binary expressions and a unary expression at compiletime.
template<typename LHS1 , typename OP1 , typename RHS1 , long value>
ct_equation< ct_binary_expr < LHS1, OP1, RHS1 > , ct_constant< value > >	make_equation (ct_binary_expr< LHS1, OP1, RHS1 > const &lhs, ct_constant< value > const &rhs)
	Generates an equation from a binary expressions and a constant at compiletime.
template<typename LHS1 , typename OP1 , typename RHS1 , typename TAG >
ct_equation< ct_binary_expr < LHS1, OP1, RHS1 > , ct_function_symbol< TAG > >	make_equation (ct_binary_expr< LHS1, OP1, RHS1 > const &lhs, ct_function_symbol< TAG > const &rhs)
	Generates an equation from a binary expressions and a function symbol at compiletime.
template<typename LHS1 , typename OP1 , typename RHS1 , id_type id>
ct_equation< ct_binary_expr < LHS1, OP1, RHS1 > , ct_variable< id > >	make_equation (ct_binary_expr< LHS1, OP1, RHS1 > const &lhs, ct_variable< id > const &rhs)
	Generates an equation from a binary expressions and a variable at compiletime.
template<typename LHS1 , typename OP1 , typename LHS2 , typename OP2 , typename RHS2 >
ct_equation< ct_unary_expr < LHS1, OP1 >, ct_binary_expr < LHS2, OP2, RHS2 > >	make_equation (ct_unary_expr< LHS1, OP1 > const &lhs, ct_binary_expr< LHS2, OP2, RHS2 > const &rhs)
	Generates an equation from a unary expressions and a binary expression at compiletime.
template<typename LHS1 , typename OP1 , typename LHS2 , typename OP2 >
ct_equation< ct_unary_expr < LHS1, OP1 >, ct_unary_expr < LHS2, OP2 > >	make_equation (ct_unary_expr< LHS1, OP1 > const &lhs, ct_unary_expr< LHS2, OP2 > const &rhs)
	Generates an equation from two unary expressions at compiletime.
template<typename LHS1 , typename OP1 , long value>
ct_equation< ct_unary_expr < LHS1, OP1 >, ct_constant < value > >	make_equation (ct_unary_expr< LHS1, OP1 > const &lhs, ct_constant< value > const &rhs)
	Generates an equation from a unary expressions and a constant at compiletime.
template<typename LHS1 , typename OP1 , typename TAG >
ct_equation< ct_unary_expr < LHS1, OP1 > , ct_function_symbol< TAG > >	make_equation (ct_unary_expr< LHS1, OP1 > const &lhs, ct_function_symbol< TAG > const &rhs)
	Generates an equation from a unary expressions and a function symbol at compiletime.
template<typename LHS1 , typename OP1 , id_type id>
ct_equation< ct_unary_expr < LHS1, OP1 >, ct_variable< id > >	make_equation (ct_unary_expr< LHS1, OP1 > const &lhs, ct_variable< id > const &rhs)
	Generates an equation from a unary expressions and a variable at compiletime.
template<long value1, typename LHS2 , typename OP2 , typename RHS2 >
ct_equation< ct_constant < value1 >, ct_binary_expr < LHS2, OP2, RHS2 > >	make_equation (ct_constant< value1 > const &lhs, ct_binary_expr< LHS2, OP2, RHS2 > const &rhs)
	Generates an equation from a constant and a binary expression at compiletime.
template<long value1, typename LHS2 , typename OP2 >
ct_equation< ct_constant < value1 >, ct_unary_expr < LHS2, OP2 > >	make_equation (ct_constant< value1 > const &lhs, ct_unary_expr< LHS2, OP2 > const &rhs)
	Generates an equation from a constant and a unary expression at compiletime.
template<long value1, long value2>
ct_equation< ct_constant < value1 >, ct_constant < value2 > >	make_equation (ct_constant< value1 > const &lhs, ct_constant< value2 > const &rhs)
	Generates an equation from two constants at compiletime.
template<long value1, typename TAG >
ct_equation< ct_constant < value1 >, ct_function_symbol < TAG > >	make_equation (ct_constant< value1 > const &lhs, ct_function_symbol< TAG > const &rhs)
	Generates an equation from a constant and a function symbol at compiletime.
template<long value1, id_type id>
ct_equation< ct_constant < value1 >, ct_variable< id > >	make_equation (ct_constant< value1 > const &lhs, ct_variable< id > const &rhs)
	Generates an equation from a constant and a variable at compiletime.
template<typename TAG , typename LHS2 , typename OP2 , typename RHS2 >
ct_equation < ct_function_symbol< TAG > , ct_binary_expr< LHS2, OP2, RHS2 > >	make_equation (ct_function_symbol< TAG > const &lhs, ct_binary_expr< LHS2, OP2, RHS2 > const &rhs)
	Generates an equation from a function symbol and a binary expression at compiletime.
template<typename TAG , typename LHS2 , typename OP2 >
ct_equation < ct_function_symbol< TAG > , ct_unary_expr< LHS2, OP2 > >	make_equation (ct_function_symbol< TAG > const &lhs, ct_unary_expr< LHS2, OP2 > const &rhs)
	Generates an equation from a function symbol and a unary expression at compiletime.
template<typename TAG , long value>
ct_equation < ct_function_symbol< TAG > , ct_constant< value > >	make_equation (ct_function_symbol< TAG > const &lhs, ct_constant< value > const &rhs)
	Generates an equation from a function symbol and a constant at compiletime.
template<typename TAG1 , typename TAG2 >
ct_equation < ct_function_symbol< TAG1 > , ct_function_symbol< TAG2 > >	make_equation (ct_function_symbol< TAG1 > const &lhs, ct_function_symbol< TAG2 > const &rhs)
	Generates an equation from two function symbols at compiletime.
template<typename TAG , id_type id>
ct_equation < ct_function_symbol< TAG > , ct_variable< id > >	make_equation (ct_function_symbol< TAG > const &lhs, ct_variable< id > const &rhs)
	Generates an equation from a function symbol and a variable at compiletime.
template<id_type id1, typename LHS2 , typename OP2 , typename RHS2 >
ct_equation< ct_variable< id1 > , ct_binary_expr< LHS2, OP2, RHS2 > >	make_equation (ct_variable< id1 > const &lhs, ct_binary_expr< LHS2, OP2, RHS2 > const &rhs)
	Generates an equation from a variable and a binary expression at compiletime.
template<id_type id1, typename LHS2 , typename OP2 >
ct_equation< ct_variable< id1 > , ct_unary_expr< LHS2, OP2 > >	make_equation (ct_variable< id1 > const &lhs, ct_unary_expr< LHS2, OP2 > const &rhs)
	Generates an equation from a variable and a unary expression at compiletime.
template<id_type id1, long value2>
ct_equation< ct_variable< id1 > , ct_constant< value2 > >	make_equation (ct_variable< id1 > const &lhs, ct_constant< value2 > const &rhs)
	Generates an equation from a variable and a constant at compiletime.
template<id_type id1, typename TAG >
ct_equation< ct_variable< id1 > , ct_function_symbol< TAG > >	make_equation (ct_variable< id1 > const &lhs, ct_function_symbol< TAG > const &rhs)
	Generates an equation from a variable and a function symbol at compiletime.
template<id_type id1, id_type id2>
ct_equation< ct_variable< id1 > , ct_variable< id2 > >	make_equation (ct_variable< id1 > const &lhs, ct_variable< id2 > const &rhs)
	Generates an equation from two variables at compiletime.
template<typename Tag >
std::ostream &	operator<< (std::ostream &stream, ct_function_symbol< Tag > const &v)
	Convenience overload for printing a compiletime function symbol to an output stream.
template<typename LHS , typename RHS >
std::ostream &	operator<< (std::ostream &stream, ct_interval< LHS, RHS > const &u)
	Convenience overload for printing a compiletime interval to an output stream.
template<typename LHS1 , typename OP1 , typename RHS1 , typename LHS2 , typename OP2 , typename RHS2 >
ct_interval< ct_binary_expr < LHS1, OP1, RHS1 > , ct_binary_expr< LHS2, OP2, RHS2 > >	make_interval (ct_binary_expr< LHS1, OP1, RHS1 > const &lhs, ct_binary_expr< LHS2, OP2, RHS2 > const &rhs)
	Generates an interval from two binary expressions at compiletime.
template<typename LHS1 , typename OP1 , typename RHS1 , typename LHS2 , typename OP2 >
ct_interval< ct_binary_expr < LHS1, OP1, RHS1 > , ct_unary_expr< LHS2, OP2 > >	make_interval (ct_binary_expr< LHS1, OP1, RHS1 > const &lhs, ct_unary_expr< LHS2, OP2 > const &rhs)
	Generates an interval from a binary expression and a unary expression at compiletime.
template<typename LHS1 , typename OP1 , typename RHS1 , long value>
ct_interval< ct_binary_expr < LHS1, OP1, RHS1 > , ct_constant< value > >	make_interval (ct_binary_expr< LHS1, OP1, RHS1 > const &lhs, ct_constant< value > const &rhs)
	Generates an interval from a binary expression and a constant at compiletime.
template<typename LHS1 , typename OP1 , typename RHS1 , typename TAG >
ct_interval< ct_binary_expr < LHS1, OP1, RHS1 > , ct_function_symbol< TAG > >	make_interval (ct_binary_expr< LHS1, OP1, RHS1 > const &lhs, ct_function_symbol< TAG > const &rhs)
	Generates an interval from a binary expression and a function symbol at compiletime.
template<typename LHS1 , typename OP1 , typename RHS1 , id_type id>
ct_interval< ct_binary_expr < LHS1, OP1, RHS1 > , ct_variable< id > >	make_interval (ct_binary_expr< LHS1, OP1, RHS1 > const &lhs, ct_variable< id > const &rhs)
	Generates an interval from a binary expression and a variable at compiletime.
template<typename LHS1 , typename OP1 , typename LHS2 , typename OP2 , typename RHS2 >
ct_interval< ct_unary_expr < LHS1, OP1 >, ct_binary_expr < LHS2, OP2, RHS2 > >	make_interval (ct_unary_expr< LHS1, OP1 > const &lhs, ct_binary_expr< LHS2, OP2, RHS2 > const &rhs)
	Generates an interval from a unary expression and a binary expression at compiletime.
template<typename LHS1 , typename OP1 , typename LHS2 , typename OP2 >
ct_interval< ct_unary_expr < LHS1, OP1 >, ct_unary_expr < LHS2, OP2 > >	make_interval (ct_unary_expr< LHS1, OP1 > const &lhs, ct_unary_expr< LHS2, OP2 > const &rhs)
	Generates an interval from two unary expressions at compiletime.
template<typename LHS1 , typename OP1 , long value>
ct_interval< ct_unary_expr < LHS1, OP1 >, ct_constant < value > >	make_interval (ct_unary_expr< LHS1, OP1 > const &lhs, ct_constant< value > const &rhs)
	Generates an interval from a unary expression and a constant at compiletime.
template<typename LHS1 , typename OP1 , typename TAG >
ct_interval< ct_unary_expr < LHS1, OP1 > , ct_function_symbol< TAG > >	make_interval (ct_unary_expr< LHS1, OP1 > const &lhs, ct_function_symbol< TAG > const &rhs)
	Generates an interval from a unary expression and a function symbol at compiletime.
template<typename LHS1 , typename OP1 , id_type id>
ct_interval< ct_unary_expr < LHS1, OP1 >, ct_variable< id > >	make_interval (ct_unary_expr< LHS1, OP1 > const &lhs, ct_variable< id > const &rhs)
	Generates an interval from a unary expression and a variable at compiletime.
template<long value1, typename LHS2 , typename OP2 , typename RHS2 >
ct_interval< ct_constant < value1 >, ct_binary_expr < LHS2, OP2, RHS2 > >	make_interval (ct_constant< value1 > const &lhs, ct_binary_expr< LHS2, OP2, RHS2 > const &rhs)
	Generates an interval from a constant and a binary expression at compiletime.
template<long value1, typename LHS2 , typename OP2 >
ct_interval< ct_constant < value1 >, ct_unary_expr < LHS2, OP2 > >	make_interval (ct_constant< value1 > const &lhs, ct_unary_expr< LHS2, OP2 > const &rhs)
	Generates an interval from a constant and a unary expression at compiletime.
template<long value1, long value2>
ct_interval< ct_constant < value1 >, ct_constant < value2 > >	make_interval (ct_constant< value1 > const &lhs, ct_constant< value2 > const &rhs)
	Generates an interval from two constants at compiletime.
template<long value1, typename TAG >
ct_interval< ct_constant < value1 >, ct_function_symbol < TAG > >	make_interval (ct_constant< value1 > const &lhs, ct_function_symbol< TAG > const &rhs)
	Generates an interval from a constant and a function symbol at compiletime.
template<long value1, id_type id>
ct_interval< ct_constant < value1 >, ct_variable< id > >	make_interval (ct_constant< value1 > const &lhs, ct_variable< id > const &rhs)
	Generates an interval from a constant and a variable at compiletime.
template<typename TAG , typename LHS2 , typename OP2 , typename RHS2 >
ct_interval < ct_function_symbol< TAG > , ct_binary_expr< LHS2, OP2, RHS2 > >	make_interval (ct_function_symbol< TAG > const &lhs, ct_binary_expr< LHS2, OP2, RHS2 > const &rhs)
	Generates an interval from a function symbol and a binary expression at compiletime.
template<typename TAG , typename LHS2 , typename OP2 >
ct_interval < ct_function_symbol< TAG > , ct_unary_expr< LHS2, OP2 > >	make_interval (ct_function_symbol< TAG > const &lhs, ct_unary_expr< LHS2, OP2 > const &rhs)
	Generates an interval from a function symbol and a unary expression at compiletime.
template<typename TAG , long value>
ct_interval < ct_function_symbol< TAG > , ct_constant< value > >	make_interval (ct_function_symbol< TAG > const &lhs, ct_constant< value > const &rhs)
	Generates an interval from a function symbol and a constant at compiletime.
template<typename TAG1 , typename TAG2 >
ct_interval < ct_function_symbol< TAG1 > , ct_function_symbol< TAG2 > >	make_interval (ct_function_symbol< TAG1 > const &lhs, ct_function_symbol< TAG2 > const &rhs)
	Generates an interval from two function symbols at compiletime.
template<typename TAG , id_type id>
ct_interval < ct_function_symbol< TAG > , ct_variable< id > >	make_interval (ct_function_symbol< TAG > const &lhs, ct_variable< id > const &rhs)
	Generates an interval from a function symbol and a variable at compiletime.
template<id_type id1, typename LHS2 , typename OP2 , typename RHS2 >
ct_interval< ct_variable< id1 > , ct_binary_expr< LHS2, OP2, RHS2 > >	make_interval (ct_variable< id1 > const &lhs, ct_binary_expr< LHS2, OP2, RHS2 > const &rhs)
	Generates an interval from a variable and a binary expression at compiletime.
template<id_type id1, typename LHS2 , typename OP2 >
ct_interval< ct_variable< id1 > , ct_unary_expr< LHS2, OP2 > >	make_interval (ct_variable< id1 > const &lhs, ct_unary_expr< LHS2, OP2 > const &rhs)
	Generates an interval from a variable and a unary expression at compiletime.
template<id_type id1, long value2>
ct_interval< ct_variable< id1 > , ct_constant< value2 > >	make_interval (ct_variable< id1 > const &lhs, ct_constant< value2 > const &rhs)
	Generates an interval from a variable and a constant at compiletime.
template<id_type id1, typename TAG >
ct_interval< ct_variable< id1 > , ct_function_symbol< TAG > >	make_interval (ct_variable< id1 > const &lhs, ct_function_symbol< TAG > const &rhs)
	Generates an interval from a variable and a function symbol at compiletime.
template<id_type id1, id_type id2>
ct_interval< ct_variable< id1 > , ct_variable< id2 > >	make_interval (ct_variable< id1 > const &lhs, ct_variable< id2 > const &rhs)
	Generates an interval from two variables at compiletime.
template<typename LHS , typename OP >
std::ostream &	operator<< (std::ostream &stream, ct_unary_expr< LHS, OP > const &other)
	Convenience overload for printing a compiletime unary expression to an output stream.
template<id_type id>
std::ostream &	operator<< (std::ostream &stream, ct_variable< id > const &u)
	Convenience overload for printing a variable to an output stream.
template<typename T0 >
std::ostream &	operator<< (std::ostream &stream, ct_vector_1< T0 > const &v)
	Convenience functionality for printing a compiletime vector with one entry to an output stream.
template<typename T0 , typename T1 >
std::ostream &	operator<< (std::ostream &stream, ct_vector_2< T0, T1 > const &v)
	Convenience functionality for printing a compiletime vector with two entries to an output stream.
template<typename T0 , typename T1 , typename T2 >
std::ostream &	operator<< (std::ostream &stream, ct_vector_3< T0, T1, T2 > const &v)
	Convenience functionality for printing a compiletime vector with three entries to an output stream.
template<typename T0 >
ct_vector_1< T0 >	make_vector (T0 const &t0)
	Helper function for creating a compiletime vector with one element.
template<typename T0 , typename T1 >
ct_vector_2< T0, T1 >	make_vector (T0 const &t0, T1 const &t1)
	Helper function for creating a compiletime vector with two elements.
template<typename T0 , typename T1 , typename T2 >
ct_vector_3< T0, T1, T2 >	make_vector (T0 const &t0, T1 const &t1, T2 const &t2)
	Helper function for creating a compiletime vector with three elements.
template<long value, typename ScalarType , typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < long, op_plus < default_numeric_type > , ScalarType >::result_type > , op_plus < default_numeric_type >, RHS >	operator+ (ct_constant< value > const &lhs, ct_binary_expr< rt_constant< ScalarType >, op_plus< default_numeric_type >, RHS > const &other)
	Special overload: ct_c1 + (c2 + X) -> [ct_c1 + c2] + X, where ct_c1 is a compiletime constant, c2 is a runtime constant, and X is any other expression.
template<long value, long value2, typename RHS >
ct_binary_expr< ct_constant < value+value2 >, op_plus < default_numeric_type >, RHS >	operator+ (ct_constant< value > const &lhs, ct_binary_expr< ct_constant< value2 >, op_plus< default_numeric_type >, RHS > const &other)
	Special overload: ct_c1 + (ct_c2 + X) -> [ct_c1 + ct_c2] + X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<long value, typename ScalarType , typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < long, op_plus < default_numeric_type > , ScalarType >::result_type > , op_minus < default_numeric_type >, RHS >	operator+ (ct_constant< value > const &lhs, ct_binary_expr< rt_constant< ScalarType >, op_minus< default_numeric_type >, RHS > const &other)
	Special overload: ct_c1 + (c2 - X) -> [ct_c1 + c2] - X, where ct_c1 is a compiletime constant, c2 is a runtime constant, and X is any other expression.
template<long value, long value2, typename RHS >
ct_binary_expr< ct_constant < value+value2 >, op_minus < default_numeric_type >, RHS >	operator+ (ct_constant< value > const &lhs, ct_binary_expr< ct_constant< value2 >, op_minus< default_numeric_type >, RHS > const &other)
	Special overload: ct_c1 + (ct_c2 - X) -> [ct_c1 + ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<long value, long other_value>
ct_constant< value+other_value >	operator+ (ct_constant< value > const &lhs, ct_constant< other_value > const &other)
	Special overload: Condense addition of two compiletime constants into one constant.
template<long value, typename ScalarType , typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < long, op_minus < default_numeric_type > , ScalarType >::result_type > , op_minus < default_numeric_type >, RHS >	operator- (ct_constant< value > const &lhs, ct_binary_expr< rt_constant< ScalarType >, op_plus< default_numeric_type >, RHS > const &other)
	Special overload: ct_c1 - (c2 + X) -> [ct_c1 - c2] - X, where ct_c1 is a compiletime constant, c2 is a runtime constant, and X is any other expression.
template<long value, long value2, typename RHS >
ct_binary_expr< ct_constant < value-value2 >, op_minus < default_numeric_type >, RHS >	operator- (ct_constant< value > const &lhs, ct_binary_expr< ct_constant< value2 >, op_plus< default_numeric_type >, RHS > const &other)
	Special overload: ct_c1 - (ct_c2 + X) -> [ct_c1 - ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<long value, typename ScalarType , typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < long, op_minus < default_numeric_type > , ScalarType >::result_type > , op_plus < default_numeric_type >, RHS >	operator- (ct_constant< value > const &lhs, ct_binary_expr< rt_constant< ScalarType >, op_minus< default_numeric_type >, RHS > const &other)
	Special overload: ct_c1 - (c2 - X) -> [ct_c1 - c2] + X, where ct_c1 is a compiletime constant, c2 is a runtime constant, and X is any other expression.
template<long value, long value2, typename RHS >
ct_binary_expr< ct_constant < value-value2 >, op_plus < default_numeric_type >, RHS >	operator- (ct_constant< value > const &lhs, ct_binary_expr< ct_constant< value2 >, op_minus< default_numeric_type >, RHS > const &other)
	Special overload: ct_c1 - (ct_c2 - X) -> [ct_c1 - ct_c2] + X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<long value, long other_value>
ct_constant< value-other_value >	operator- (ct_constant< value > const &lhs, ct_constant< other_value > const &other)
	Special overload: Condense subtraction of two compiletime constants into one constant.
template<long value, long other_value>
ct_constant< value *other_value >	operator* (ct_constant< value > const &lhs, ct_constant< other_value > const &other)
	Special overload: Condense multiplication of two compiletime constants into one constant.
template<typename ScalarType , long value_1, typename RHS , long value_2>
ct_binary_expr< ct_constant < value_1+value_2 >, op_plus < ScalarType >, RHS >	operator+ (ct_binary_expr< ct_constant< value_1 >, op_plus< ScalarType >, RHS > const &lhs, ct_constant< value_2 > const &other)
	Special overload: (ct_c1 + X) + ct_c2 becomes [ct_c1 + ct_c2] + X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<typename ScalarType , long value_1, typename RHS , long value_2>
ct_binary_expr< ct_constant < value_1+value_2 >, op_minus < ScalarType >, RHS >	operator+ (ct_binary_expr< ct_constant< value_1 >, op_minus< ScalarType >, RHS > const &lhs, ct_constant< value_2 > const &other)
	Special overload: (ct_c1 - X) + ct_c2 becomes [ct_c1 + ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<typename ScalarType , typename OtherScalarType , typename RHS , long value>
ct_binary_expr< rt_constant < typename promote_traits < OtherScalarType, op_plus < ScalarType >, long > ::result_type >, op_minus < ScalarType >, RHS >	operator+ (ct_binary_expr< rt_constant< OtherScalarType >, op_minus< ScalarType >, RHS > const &lhs, ct_constant< value > const &other)
	Special overload: (c1 - X) + ct_c2 -> [c1 + ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<typename ScalarType , id_type id, typename RHS >
RHS	operator- (ct_binary_expr< ct_variable< id >, op_plus< ScalarType >, RHS > const &lhs, ct_variable< id > const &other)
	Special overload: (A + B) - A -> B, where A is an variable and X can be anything.
template<long value_1, typename RHS , long value_2, typename T >
ct_binary_expr< ct_constant < value_1-value_2 >, op_plus < T >, RHS >	operator- (ct_binary_expr< ct_constant< value_1 >, op_plus< T >, RHS > const &lhs, ct_constant< value_2 > const &other)
	Special overload: (ct_c1 + X) - ct_c2 -> [ct_c1 - ct_c2] + X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<typename OtherScalarType , typename RHS , long value, typename T >
ct_binary_expr< rt_constant < typename promote_traits < OtherScalarType, op_plus< T > , long >::result_type > , op_plus< T >, RHS >	operator- (ct_binary_expr< rt_constant< OtherScalarType >, op_plus< T >, RHS > const &lhs, ct_constant< value > const &other)
	Special overload: (c1 + X) - ct_c2 -> [c1 - ct_c2] + X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<long value_1, typename RHS , long value_2, typename T >
ct_binary_expr< ct_constant < value_1-value_2 >, op_minus < T >, RHS >	operator- (ct_binary_expr< ct_constant< value_1 >, op_minus< T >, RHS > const &lhs, ct_constant< value_2 > const &other)
	Special overload: (ct_c1 - X) - ct_c2 -> [ct_c1 - ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<typename OtherScalarType , typename RHS , long value, typename T >
ct_binary_expr< rt_constant < typename promote_traits < OtherScalarType, op_plus< T > , long >::result_type > , op_minus< T >, RHS >	operator- (ct_binary_expr< rt_constant< OtherScalarType >, op_minus< T >, RHS > const &lhs, ct_constant< value > const &other)
	Special overload: (c1 - X) - ct_c2 -> [c1 - ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.
template<typename LHS , typename OP , typename RHS >
ct_constant< 1 >	operator/ (ct_binary_expr< LHS, OP, RHS > const &lhs, ct_binary_expr< LHS, OP, RHS > const &other)
	Special overload: division of the same thing leads to '1'.
template<id_type id>
ct_binary_expr< ct_constant < 2 >, op_mult < default_numeric_type > , ct_variable< id > >	operator+ (ct_variable< id > const &lhs, ct_variable< id > const &other)
	Special overload: x + x becomes 2*x.
template<id_type id>
ct_constant< 0 >	operator- (ct_variable< id > const &lhs, ct_variable< id > const &other)
	Special overload: x - x becomes 0.
template<id_type id>
ct_constant< 1 >	operator/ (ct_variable< id > const &lhs, ct_variable< id > const &other)
	Special overload: x / x becomes 1.
template<typename T >
bool	unary_op_equal (op_partial_deriv< T > const &lhs, op_partial_deriv< T > const &rhs)
	Compares two partial derivatives for equality with respect to the differentiation variable.
template<typename LHS , typename RHS >
enable_if < result_of::is_viennamath < LHS >::value||result_of::is_viennamath < RHS >::value, typename result_of::add< LHS, RHS > ::type >::type	operator+ (LHS const &lhs, RHS const &rhs)
	Generic overload of the addition operator for ViennaMath types. Uses SFINAE to control the scope, otherwise one may run into very tricky problems with operator+ being considered outside the viennamath namespace.
template<typename LHS , typename RHS >
enable_if < result_of::is_viennamath < LHS >::value||result_of::is_viennamath < RHS >::value, typename result_of::subtract< LHS, RHS > ::type >::type	operator- (LHS const &lhs, RHS const &rhs)
	Generic overload of the subtraction operator for ViennaMath types. Uses SFINAE to control the scope, otherwise one may run into very tricky problems with operator- being considered outside the viennamath namespace.
template<typename LHS , typename RHS >
enable_if < result_of::is_viennamath < LHS >::value||result_of::is_viennamath < RHS >::value, typename result_of::mult< LHS, RHS > ::type >::type	operator* (LHS const &lhs, RHS const &rhs)
	Generic overload of the multiplication operator for ViennaMath types. Uses SFINAE to control the scope, otherwise one may run into very tricky problems with operator* being considered outside the viennamath namespace.
template<typename LHS , typename RHS >
enable_if < result_of::is_viennamath < LHS >::value||result_of::is_viennamath < RHS >::value, typename result_of::div< LHS, RHS > ::type >::type	operator/ (LHS const &lhs, RHS const &rhs)
	Generic overload of the division operator for ViennaMath types. Uses SFINAE to control the scope, otherwise one may run into very tricky problems with operator/ being considered outside the viennamath namespace.
template<typename InterfaceType >
rt_expr< InterfaceType >	apply_coordinate_system (cartesian< 1 >, rt_expr< InterfaceType > const &ex)
	Transforms the expression to a Cartesian coordinate system in one dimension.
template<typename InterfaceType >
rt_expr< InterfaceType >	apply_coordinate_system (cartesian< 1 >, rt_unary_expr< InterfaceType > const &ex)
	Transforms the expression to a Cartesian coordinate system in one dimension.
template<typename InterfaceType >
rt_expr< InterfaceType >	apply_coordinate_system (cartesian< 1 >, rt_binary_expr< InterfaceType > const &ex)
	Transforms the expression to a Cartesian coordinate system in one dimension.
template<typename InterfaceType >
rt_expr< InterfaceType >	apply_coordinate_system (cartesian< 2 >, rt_expr< InterfaceType > const &ex)
	Transforms the expression to a Cartesian coordinate system in two dimensions.
template<typename InterfaceType >
rt_expr< InterfaceType >	apply_coordinate_system (cartesian< 2 >, rt_unary_expr< InterfaceType > const &ex)
	Transforms the expression to a Cartesian coordinate system in two dimensions.
template<typename InterfaceType >
rt_expr< InterfaceType >	apply_coordinate_system (cartesian< 2 >, rt_binary_expr< InterfaceType > const &ex)
	Transforms the expression to a Cartesian coordinate system in two dimensions.
template<typename InterfaceType >
rt_expr< InterfaceType >	apply_coordinate_system (cartesian< 3 >, rt_expr< InterfaceType > const &ex)
	Transforms the expression to a Cartesian coordinate system in two dimensions.
template<typename InterfaceType >
rt_expr< InterfaceType >	apply_coordinate_system (cartesian< 3 >, rt_unary_expr< InterfaceType > const &ex)
	Transforms the expression to a Cartesian coordinate system in three dimensions.
template<typename InterfaceType >
rt_expr< InterfaceType >	apply_coordinate_system (cartesian< 3 >, rt_binary_expr< InterfaceType > const &ex)
	Transforms the expression to a Cartesian coordinate system in three dimensions.
template<typename InterfaceType , id_type dim>
rt_equation< InterfaceType >	apply_coordinate_system (cartesian< dim >, rt_equation< InterfaceType > const &equ)
	Convenience overload which automatically applies the coordinate transformation to the right hand left hand side of an equation.
template<typename FactorType , typename ExpressionType >
viennamath::result_of::coefficient < FactorType, ExpressionType > ::type	coefficient (FactorType const &f, ExpressionType const &e)
	User function for extracting the coefficient of a variable or sub-expression from an expression.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *lhs, op_plus< NumericT >, const InterfaceType *rhs, const InterfaceType *diff_var)
	Implementation of the differentation of e1 + e1, where e1 and e2 are expressions.
template<typename InterfaceType , typename NumericT >
InterfaceType *	simplify_impl (const InterfaceType *lhs, op_plus< NumericT >, const InterfaceType *rhs)
	Implementation of the simplification procedures for an expression of the form e1 + e2.
template<typename InterfaceType , typename NumericT >
bool	can_simplify_impl (const InterfaceType *lhs, op_plus< NumericT >, const InterfaceType *rhs)
	Checks whether an expression of the form e1 + e2 can be simplified.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *lhs, op_minus< NumericT >, const InterfaceType *rhs, const InterfaceType *diff_var)
	Implementation of the differentation of e1 - e1, where e1 and e2 are expressions.
template<typename InterfaceType , typename NumericT >
InterfaceType *	simplify_impl (const InterfaceType *lhs, op_minus< NumericT >, const InterfaceType *rhs)
	Implementation of the simplification procedures for an expression of the form e1 - e2.
template<typename InterfaceType , typename NumericT >
bool	can_simplify_impl (const InterfaceType *lhs, op_minus< NumericT >, const InterfaceType *rhs)
	Checks whether an expression of the form e1 - e2 can be simplified.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *lhs, op_mult< NumericT >, const InterfaceType *rhs, const InterfaceType *diff_var)
	Implementation of the differentation of e1 * e1, where e1 and e2 are expressions.
template<typename InterfaceType , typename NumericT >
InterfaceType *	simplify_impl (const InterfaceType *lhs, op_mult< NumericT >, const InterfaceType *rhs)
	Implementation of the simplification procedures for an expression of the form e1 * e2.
template<typename InterfaceType , typename NumericT >
bool	can_simplify_impl (const InterfaceType *lhs, op_mult< NumericT >, const InterfaceType *rhs)
	Checks whether an expression of the form e1 * e2 can be simplified.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *lhs, op_div< NumericT >, const InterfaceType *rhs, const InterfaceType *diff_var)
	Implementation of the differentation of e1 / e1, where e1 and e2 are expressions.
template<typename InterfaceType , typename NumericT >
InterfaceType *	simplify_impl (const InterfaceType *lhs, op_div< NumericT >, const InterfaceType *rhs)
	Implementation of the simplification procedures for an expression of the form e1 / e2.
template<typename InterfaceType , typename NumericT >
bool	can_simplify_impl (const InterfaceType *lhs, op_div< NumericT >, const InterfaceType *rhs)
	Checks whether an expression of the form e1 / e2 can be simplified.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_id< NumericT >, const InterfaceType *diff_var)
	Differentation of a unary expression containing identity.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_exp< NumericT >, const InterfaceType *diff_var)
	Differentation of exp(e), where e is an expression.
template<typename NumericT , typename InterfaceType >
rt_unary_expr< InterfaceType >	exp (rt_constant< NumericT, InterfaceType > const &other)
	Overload of the exponential function for a ViennaMath runtime constant.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	exp (rt_variable< InterfaceType > const &other)
	Overload of the exponential function for a ViennaMath runtime variable.
template<id_type id>
rt_unary_expr	exp (ct_variable< id > const &other)
	Overload of the exponential function for a ViennaMath compiletime variable.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	exp (rt_binary_expr< InterfaceType > const &other)
	Overload of the exponential function for a ViennaMath runtime binary expression.
template<typename LHS , typename OP , typename RHS >
rt_unary_expr	exp (ct_binary_expr< LHS, OP, RHS > const &other)
	Overload of the exponential function for a ViennaMath compiletime binary expression.
template<typename LHS , typename OP >
rt_unary_expr	exp (ct_unary_expr< LHS, OP > const &other)
	Overload of the exponential function for a ViennaMath compiletime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	exp (rt_expr< InterfaceType > const &other)
	Overload of the exponential function for a ViennaMath runtime expression wrapper.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_sin< NumericT >, const InterfaceType *diff_var)
	Differentation of sin(e), where e is an expression.
template<typename NumericT , typename InterfaceType >
rt_unary_expr< InterfaceType >	sin (rt_constant< NumericT, InterfaceType > const &other)
	Overload of the sine function for a ViennaMath runtime constant.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	sin (rt_variable< InterfaceType > const &other)
	Overload of the sine function for a ViennaMath runtime variable.
template<id_type id>
rt_unary_expr	sin (ct_variable< id > const &other)
	Overload of the sine function for a ViennaMath compiletime variable.
template<typename LHS , typename OP , typename RHS >
rt_unary_expr	sin (ct_binary_expr< LHS, OP, RHS > const &other)
	Overload of the sine function for a ViennaMath compiletime binary expression.
template<typename LHS , typename OP >
rt_unary_expr	sin (ct_unary_expr< LHS, OP > const &other)
	Overload of the sine function for a ViennaMath compiletime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	sin (rt_unary_expr< InterfaceType > const &other)
	Overload of the sine function for a ViennaMath runtime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	sin (rt_binary_expr< InterfaceType > const &other)
	Overload of the sine function for a ViennaMath runtime binary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	sin (rt_expr< InterfaceType > const &other)
	Overload of the sine function for a ViennaMath runtime expression wrapper.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_cos< NumericT >, const InterfaceType *diff_var)
	Differentation of cos(e), where e is an expression.
template<typename NumericT , typename InterfaceType >
rt_unary_expr< InterfaceType >	cos (rt_constant< NumericT, InterfaceType > const &other)
	Overload of the cosine function for a ViennaMath runtime constant.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	cos (rt_variable< InterfaceType > const &other)
	Overload of the cosine function for a ViennaMath runtime variable.
template<id_type id>
rt_unary_expr	cos (ct_variable< id > const &other)
	Overload of the cosine function for a ViennaMath compiletime variable.
template<typename LHS , typename OP , typename RHS >
rt_unary_expr	cos (ct_binary_expr< LHS, OP, RHS > const &other)
	Overload of the cosine function for a ViennaMath compiletime binary expression.
template<typename LHS , typename OP >
rt_unary_expr	cos (ct_unary_expr< LHS, OP > const &other)
	Overload of the cosine function for a ViennaMath compiletime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	cos (rt_unary_expr< InterfaceType > const &other)
	Overload of the cosine function for a ViennaMath runtime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	cos (rt_binary_expr< InterfaceType > const &other)
	Overload of the cosine function for a ViennaMath runtime binary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	cos (rt_expr< InterfaceType > const &other)
	Overload of the cosine function for a ViennaMath runtime expression wrapper.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_tan< NumericT >, const InterfaceType *diff_var)
	Differentation of tan(e), where e is an expression.
template<typename NumericT , typename InterfaceType >
rt_unary_expr< InterfaceType >	tan (rt_constant< NumericT, InterfaceType > const &other)
	Overload of the tangent function for a ViennaMath runtime constant.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	tan (rt_variable< InterfaceType > const &other)
	Overload of the tangent function for a ViennaMath runtime variable.
template<id_type id>
rt_unary_expr	tan (ct_variable< id > const &other)
	Overload of the tangent function for a ViennaMath compiletime variable.
template<typename LHS , typename OP , typename RHS >
rt_unary_expr	tan (ct_binary_expr< LHS, OP, RHS > const &other)
	Overload of the tangent function for a ViennaMath compiletime binary expression.
template<typename LHS , typename OP >
rt_unary_expr	tan (ct_unary_expr< LHS, OP > const &other)
	Overload of the tangent function for a ViennaMath compiletime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	tan (rt_unary_expr< InterfaceType > const &other)
	Overload of the tangent function for a ViennaMath runtime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	tan (rt_binary_expr< InterfaceType > const &other)
	Overload of the tangent function for a ViennaMath runtime binary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	tan (rt_expr< InterfaceType > const &other)
	Overload of the tangent function for a ViennaMath runtime expression wrapper.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_fabs< NumericT >, const InterfaceType *diff_var)
	Implementation of the differentation of |e|, where e is an expression. Since the modulus is not differentiable everywhere, an exception is thrown.
template<typename NumericT , typename InterfaceType >
rt_unary_expr< InterfaceType >	fabs (rt_constant< NumericT, InterfaceType > const &other)
	Overload of the modulus function for a ViennaMath runtime constant.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	fabs (rt_variable< InterfaceType > const &other)
	Overload of the modulus function for a ViennaMath runtime variable.
template<id_type id>
rt_unary_expr	fabs (ct_variable< id > const &other)
	Overload of the modulus function for a ViennaMath compiletime variable.
template<typename LHS , typename OP , typename RHS >
rt_unary_expr	fabs (ct_binary_expr< LHS, OP, RHS > const &other)
	Overload of the modulus function for a ViennaMath compiletime binary expression.
template<typename LHS , typename OP >
rt_unary_expr	fabs (ct_unary_expr< LHS, OP > const &other)
	Overload of the modulus function for a ViennaMath compiletime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	fabs (rt_unary_expr< InterfaceType > const &other)
	Overload of the modulus function for a ViennaMath runtime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	fabs (rt_binary_expr< InterfaceType > const &other)
	Overload of the modulus function for a ViennaMath runtime binary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	fabs (rt_expr< InterfaceType > const &other)
	Overload of the modulus function for a ViennaMath runtime expression wrapper.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_sqrt< NumericT >, const InterfaceType *diff_var)
	Implementation of the differentation of \sqrt{e}, where e is an expression.
template<typename NumericT , typename InterfaceType >
rt_unary_expr< InterfaceType >	sqrt (rt_constant< NumericT, InterfaceType > const &other)
	Overload of the square-root function for a ViennaMath runtime constant.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	sqrt (rt_variable< InterfaceType > const &other)
	Overload of the square-root function for a ViennaMath runtime variable.
template<id_type id>
rt_unary_expr	sqrt (ct_variable< id > const &other)
	Overload of the square-root function for a ViennaMath compiletime variable.
template<typename LHS , typename OP , typename RHS >
rt_unary_expr	sqrt (ct_binary_expr< LHS, OP, RHS > const &other)
	Overload of the square-root function for a ViennaMath compiletime binary expression.
template<typename LHS , typename OP >
rt_unary_expr	sqrt (ct_unary_expr< LHS, OP > const &other)
	Overload of the square-root function for a ViennaMath compiletime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	sqrt (rt_unary_expr< InterfaceType > const &other)
	Overload of the square-root function for a ViennaMath runtime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	sqrt (rt_binary_expr< InterfaceType > const &other)
	Overload of the square-root function for a ViennaMath runtime binary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	sqrt (rt_expr< InterfaceType > const &other)
	Overload of the square-root function for a ViennaMath runtime expression wrapper.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_log< NumericT >, const InterfaceType *diff_var)
	Implementation of the differentation of ln(e), where e is an expression.
template<typename NumericT , typename InterfaceType >
rt_unary_expr< InterfaceType >	log (rt_constant< NumericT, InterfaceType > const &other)
	Overload of the natural logarithm function for a ViennaMath runtime constant.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	log (rt_variable< InterfaceType > const &other)
	Overload of the natural logarithm function for a ViennaMath runtime variable.
template<id_type id>
rt_unary_expr	log (ct_variable< id > const &other)
	Overload of the natural logarithm function for a ViennaMath compiletime variable.
template<typename LHS , typename OP , typename RHS >
rt_unary_expr	log (ct_binary_expr< LHS, OP, RHS > const &other)
	Overload of the natural logarithm function for a ViennaMath compiletime binary expression.
template<typename LHS , typename OP >
rt_unary_expr	log (ct_unary_expr< LHS, OP > const &other)
	Overload of the natural logarithm function for a ViennaMath compiletime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	log (rt_unary_expr< InterfaceType > const &other)
	Overload of the natural logarithm function for a ViennaMath runtime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	log (rt_binary_expr< InterfaceType > const &other)
	Overload of the natural logarithm function for a ViennaMath runtime binary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	log (rt_expr< InterfaceType > const &other)
	Overload of the natural logarithm function for a ViennaMath runtime expression wrapper.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_log10< NumericT >, const InterfaceType *diff_var)
	Implementation of the differentation of log10(e), where e is an expression.
template<typename NumericT , typename InterfaceType >
rt_unary_expr< InterfaceType >	log10 (rt_constant< NumericT, InterfaceType > const &other)
	Overload of the logarithm with base 10 for a ViennaMath runtime constant.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	log10 (rt_variable< InterfaceType > const &other)
	Overload of the logarithm with base 10 for a ViennaMath runtime variable.
template<id_type id>
rt_unary_expr	log10 (ct_variable< id > const &other)
	Overload of the logarithm with base 10 for a ViennaMath compiletime variable.
template<typename LHS , typename OP , typename RHS >
rt_unary_expr	log10 (ct_binary_expr< LHS, OP, RHS > const &other)
	Overload of the logarithm with base 10 for a ViennaMath compiletime binary expression.
template<typename LHS , typename OP >
rt_unary_expr	log10 (ct_unary_expr< LHS, OP > const &other)
	Overload of the logarithm with base 10 for a ViennaMath compiletime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	log10 (rt_unary_expr< InterfaceType > const &other)
	Overload of the logarithm with base 10 for a ViennaMath runtime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	log10 (rt_binary_expr< InterfaceType > const &other)
	Overload of the logarithm with base 10 for a ViennaMath runtime binary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	log10 (rt_expr< InterfaceType > const &other)
	Overload of the logarithm with base 10 for a ViennaMath runtime expression wrapper.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_gradient< NumericT >, const InterfaceType *diff_var)
	Implementation of the differentation of a gradient. This is currently not supported, thus an exception is thrown.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	grad (rt_function_symbol< InterfaceType > const &other)
	Overload of the gradient function for a ViennaMath runtime function symbol.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	grad (rt_unary_expr< InterfaceType > const &other)
	Overload of the gradient function for a ViennaMath runtime unary expression.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_divergence< NumericT >, const InterfaceType *diff_var)
	Implementation of the differentation of the divergence operator. This is currently not supported, thus an exception is thrown.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	div (rt_expr< InterfaceType > const &other)
	Overload of the divergence function for a ViennaMath runtime expression wrapper.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	div (rt_unary_expr< InterfaceType > const &other)
	Overload of the divergence function for a ViennaMath runtime unary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	div (rt_binary_expr< InterfaceType > const &other)
	Overload of the divergence function for a ViennaMath runtime binary expression.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	div (rt_function_symbol< InterfaceType > const &other)
	Overload of the divergence function for a ViennaMath runtime function symbol.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	laplace (rt_expr< InterfaceType > const &other)
	For convenience, the Laplace operator (divergence of the gradient) is provided as a separate function.
template<typename InterfaceType >
rt_unary_expr< InterfaceType >	laplace (rt_function_symbol< InterfaceType > const &other)
	For convenience, the Laplace operator (divergence of the gradient) is provided as a separate function.
template<typename InterfaceType , typename NumericT >
InterfaceType *	diff_impl (const InterfaceType *e, op_partial_deriv< NumericT >, const InterfaceType *diff_var)
	Implementation of the differentation of a partial derivative. This is currently not supported, thus an exception is thrown.
template<typename InterfaceType >
InterfaceType *	diff_impl (const InterfaceType *e, op_rt_integral< InterfaceType >, const InterfaceType *diff_var)
	Implementation of the differentation of an integral. This is currently not supported, thus an exception is thrown.
template<typename InterfaceType >
InterfaceType *	diff_impl (const InterfaceType *e, op_rt_symbolic_integral< InterfaceType >, const InterfaceType *diff_var)
	Implementation of the differentation of an integral with symbolic integration domain. This is currently not supported, thus an exception is thrown.
template<typename InterfaceType >
rt_expr< InterfaceType >	diff (rt_binary_expr< InterfaceType > const &e, rt_variable< InterfaceType > const &var)
	Returns the derivative of the provided runtime binary expression.
template<typename InterfaceType >
rt_expr< InterfaceType >	diff (rt_unary_expr< InterfaceType > const &e, rt_variable< InterfaceType > const &var)
	Returns the derivative of the provided runtime unary expression.
template<typename InterfaceType >
rt_expr< InterfaceType >	diff (rt_expr< InterfaceType > const &e, rt_variable< InterfaceType > const &var)
	Returns the derivative of the provided runtime expression wrapper.
template<typename InterfaceType , id_type id>
rt_expr< InterfaceType >	diff (rt_binary_expr< InterfaceType > const &e, ct_variable< id > const &var)
	Returns the derivative of the provided runtime binary expression.
template<typename InterfaceType , id_type id>
rt_expr< InterfaceType >	diff (rt_unary_expr< InterfaceType > const &e, ct_variable< id > const &var)
	Returns the derivative of the provided runtime unary expression.
template<typename InterfaceType , id_type id>
rt_expr< InterfaceType >	diff (rt_expr< InterfaceType > const &e, ct_variable< id > const &var)
	Returns the derivative of the provided runtime expression wrapper.
template<typename InterfaceType >
rt_expr< InterfaceType >	diff (rt_function_symbol< InterfaceType > const &other, rt_variable< InterfaceType > const &var)
	Returns a symbolic representation of a differentiated function.
template<typename InterfaceType , id_type id>
rt_expr< InterfaceType >	diff (rt_function_symbol< InterfaceType > const &other, ct_variable< id > const &var)
	Returns a symbolic representation of a differentiated function.
template<typename InterfaceType >
rt_constant< typename InterfaceType::numeric_type >	diff (typename InterfaceType::numeric_type value, rt_variable< InterfaceType > const &var)
	Overload for the derivative of a function.
template<typename OtherScalarType , typename InterfaceType >
rt_constant< typename InterfaceType::numeric_type >	diff (rt_constant< OtherScalarType, InterfaceType > const &c, rt_variable< InterfaceType > const &var)
	Overload for the derivative of a ViennaMath runtime constant.
template<id_type other_id, typename InterfaceType , id_type id>
rt_constant< typename InterfaceType::numeric_type >	diff (rt_variable< InterfaceType > const &c, rt_variable< InterfaceType > const &var)
	Overload for computing the derivative of a runtime variable.
template<typename ExpressionType , id_type id>
result_of::diff < ExpressionType, ct_variable < id > >::result_type	diff (ExpressionType const &c, ct_variable< id > const &var)
	The user function for differentiation of a compile time expression with respect to a compile time variable.
template<typename FactorType , typename ExpressionType >
result_of::drop_dependent_terms < FactorType, ExpressionType > ::type	drop_dependent_terms (FactorType const &f, ExpressionType const &e)
	Main user function for dropping all terms from an expression which depend on a certain variable or expression.
template<typename ExpressionType , typename VectorType >
enable_if < result_of::is_ct_evaluable < ExpressionType >::value &&result_of::is_ct_vector < VectorType >::value, default_numeric_type >::type	eval (ExpressionType const &e, VectorType const &v)
	Main user function for the evaluation of a compiletime expression at compiletime.
template<typename VectorType >
default_numeric_type	eval (default_numeric_type value, VectorType const &v)
	Evaluation of a numeric constant at a vector: Return the constant.
template<typename VectorType >
long	eval (long value, VectorType const &v)
	Evaluation of a long integer at a vector: Return the integer.
template<typename T , typename InterfaceType , typename VectorType >
InterfaceType::numeric_type	eval (rt_constant< T, InterfaceType > c, VectorType const &v)
	Evaluation of a runtime constant at a vector: Return the runtime constant.
template<typename InterfaceType , typename VectorType >
InterfaceType::numeric_type	eval (rt_expr< InterfaceType > e, VectorType const &v)
	Evaluation of a ViennaMath expression wrapper.
template<typename InterfaceType , typename VectorType >
InterfaceType::numeric_type	eval (rt_binary_expr< InterfaceType > e, VectorType const &v)
	Evaluation of a ViennaMath binary expression.
template<typename InterfaceType , typename VectorType >
InterfaceType::numeric_type	eval (rt_unary_expr< InterfaceType > e, VectorType const &v)
	Evaluation of a ViennaMath unary expression.
template<typename InterfaceType , typename VectorType >
InterfaceType::numeric_type	eval (rt_variable< InterfaceType > e, VectorType const &v)
	Evaluation of a ViennaMath variable.
template<typename LHS , typename OP , typename RHS , typename VectorType >
enable_if <!result_of::is_ct_evaluable < ct_binary_expr< LHS, OP, RHS > >::value||!result_of::is_ct_vector < VectorType >::value, default_numeric_type >::type	eval (ct_binary_expr< LHS, OP, RHS > ex, VectorType const &v)
	Evaluation of a ViennaMath compiletime binary expression using a runtime vector.
template<typename LHS , typename OP , typename VectorType >
enable_if <!result_of::is_ct_evaluable < ct_unary_expr< LHS, OP > >::value||!result_of::is_ct_vector < VectorType >::value, default_numeric_type >::type	eval (ct_unary_expr< LHS, OP > ex, VectorType const &v)
	Evaluation of a ViennaMath compiletime unary expression using a runtime vector.
template<long value, typename VectorType >
default_numeric_type	eval (ct_constant< value > c, VectorType const &v)
	Evaluation of a ViennaMath compiletime constant using a runtime vector.
template<id_type id, typename VectorType >
default_numeric_type	eval (ct_variable< id > c, VectorType const &v)
	Evaluation of a ViennaMath compiletime variable using a runtime vector.
template<id_type id, typename T0 >
default_numeric_type	eval (ct_variable< id > c, ct_vector_1< T0 > const &v)
	Evaluation of a ViennaMath compiletime variable using a compiletime vector with one entry.
template<id_type id, typename T0 , typename T1 >
default_numeric_type	eval (ct_variable< id > c, ct_vector_2< T0, T1 > const &v)
	Evaluation of a ViennaMath compiletime variable using a compiletime vector with two entries.
template<id_type id, typename T0 , typename T1 , typename T2 >
default_numeric_type	eval (ct_variable< id > c, ct_vector_3< T0, T1, T2 > const &v)
	Evaluation of a ViennaMath compiletime variable using a compiletime vector with three entries.
template<typename ExpressionType >
result_of::expand < ExpressionType >::type	expand (ExpressionType const &type)
	User function for expanding a compile time expression.
template<typename LowerBound , typename UpperBound , typename IntegrandType , typename VariableType >
result_of::integrate < LowerBound, UpperBound, IntegrandType, VariableType > ::type	integrate (ct_interval< LowerBound, UpperBound > const &interv, IntegrandType const &integrand, VariableType const &var)
	The user function for the compile time integration of a compile time expression.
template<typename ExpressionType >
result_of::simplify < ExpressionType >::type	simplify (ExpressionType const &e)
	The generic interface function for compiletime manipulations.
template<typename InterfaceType >
void	inplace_simplify (rt_expr< InterfaceType > &e)
	Simplifies an expression. Directly manipulates the provided expression.
template<typename InterfaceType >
void	inplace_simplify (rt_unary_expr< InterfaceType > &e)
	Simplifies an expression. Directly manipulates the provided expression.
template<typename InterfaceType >
void	inplace_simplify (rt_binary_expr< InterfaceType > &e)
	Simplifies an expression. Directly manipulates the provided expression.
template<typename T >
void	inplace_simplify (T &e)
	Simplifies an expression. Directly manipulates the provided expression.
template<typename InterfaceType >
rt_expr< InterfaceType >	simplify (rt_expr< InterfaceType > const &e)
	Returns a new, simplified expression.
template<typename InterfaceType >
rt_expr< InterfaceType >	simplify (rt_unary_expr< InterfaceType > const &e)
	Returns a new, simplified expression.
template<typename InterfaceType >
rt_expr< InterfaceType >	simplify (rt_binary_expr< InterfaceType > const &e)
	Returns a new, simplified expression.
template<typename T >
T	simplify (T const &e)
	Returns a new, simplified expression.
template<typename SearchType , typename ReplacementType , typename ExpressionType >
result_of::substitute < SearchType, ReplacementType, ExpressionType >::type	substitute (SearchType const &, ReplacementType const &, ExpressionType const &ex)
	The generic interface function for compiletime substitution.
template<typename InterfaceType , typename ReplacementType , typename ExpressionType >
rt_expr< InterfaceType >	substitute (rt_variable< InterfaceType > const &u, ReplacementType const &repl, ExpressionType const &e)
	Replaces all occurances of the variable 'u' in the expression 'e' with 'repl'.
template<typename InterfaceType , typename ReplacementType >
rt_expr< InterfaceType >	substitute (rt_variable< InterfaceType > const &u, ReplacementType const &repl, rt_expr< InterfaceType > const &e)
	Replaces all occurances of the variable 'u' in the expression 'e' with 'repl'.
template<typename InterfaceType >
rt_expr< InterfaceType >	substitute (rt_variable< InterfaceType > const &u, default_numeric_type repl, rt_expr< InterfaceType > const &e)
	Replaces all occurances of the variable 'u' in the expression 'e' with 'repl'.
template<typename InterfaceType >
rt_expr< InterfaceType >	substitute (rt_function_symbol< InterfaceType > const &u, default_numeric_type repl, rt_expr< InterfaceType > const &e)
	Replaces all occurances of the function symbol 'u' in the expression 'e' with 'repl'.
template<typename InterfaceType >
rt_expr< InterfaceType >	substitute (rt_function_symbol< InterfaceType > const &u, rt_expr< InterfaceType > const &repl, rt_expr< InterfaceType > const &e)
	Replaces all occurances of the function symbol 'u' in the expression 'e' with 'repl'.
template<typename InterfaceType , typename ReplacementType >
rt_expr< InterfaceType >	substitute (rt_unary_expr< InterfaceType > const &search, ReplacementType const &repl, rt_expr< InterfaceType > const &e)
	Replaces all occurances of the unary expression 'search' in the expression 'e' with 'repl'.
template<typename InterfaceType >
rt_expr< InterfaceType >	substitute (rt_unary_expr< InterfaceType > const &search, rt_expr< InterfaceType > const &repl, rt_expr< InterfaceType > const &e)
	Replaces all occurances of the unary expression 'search' in the expression 'e' with 'repl'.
template<typename InterfaceType , typename ReplacementType >
rt_expr< InterfaceType >	substitute (rt_binary_expr< InterfaceType > const &search, ReplacementType const &repl, rt_expr< InterfaceType > const &e)
	Replaces all occurances of the binary expression 'search' in the expression 'e' with 'repl'.
template<typename InterfaceType >
rt_expr< InterfaceType >	substitute (rt_expr< InterfaceType > const &search, rt_expr< InterfaceType > const &repl, rt_expr< InterfaceType > const &e)
	Replaces all occurances of the expression 'search' in the expression 'e' with 'repl'.
template<typename InterfaceType >
rt_expr< InterfaceType >	substitute (std::vector< rt_expr< InterfaceType > > const &search, std::vector< rt_expr< InterfaceType > > const &repl, rt_expr< InterfaceType > const &e)
	Replaces all occurances of the the expressions in 'search' in the expression 'e' with the corresponding expressions in 'repl'.
template<typename InterfaceType , typename PairType >
rt_expr< InterfaceType >	substitute (rt_symbolic_interval< InterfaceType > const &search, PairType const &repl, rt_expr< InterfaceType > const &e)
	Substitutes a symbolic interval with a concrete interval.
template<typename InterfaceType >
std::ostream &	operator<< (std::ostream &stream, rt_binary_expr< InterfaceType > const &e)
	Overload of the stream operator in order to allow for a convenient conversion of a unary expression to a string.
template<typename ScalarType , typename InterfaceType >
std::ostream &	operator<< (std::ostream &stream, rt_constant< ScalarType, InterfaceType > const &c)
	Convenience operator overload for streaming a runtime constant to std::cout or any other STL-compatible output stream.
template<typename InterfaceType >
std::ostream &	operator<< (std::ostream &stream, rt_equation< InterfaceType > const &e)
	Convenience operator overload for streaming a runtime equation to std::cout or any other STL-compatible output stream.
template<typename NumericT , typename InterfaceType , typename RHSType >
rt_equation< InterfaceType >	make_equation (typename InterfaceType::numeric_type lhs, rt_constant< NumericT, InterfaceType > const &rhs)
	Generator for an equation with a (floating point) constant as left hand side and a ViennaMath runtime constant as right hand side.
template<typename InterfaceType >
rt_equation< InterfaceType >	make_equation (typename InterfaceType::numeric_type lhs, rt_variable< InterfaceType > const &rhs)
	Generator for an equation with a (floating point) constant as left hand side and a ViennaMath runtime variable as right hand side.
template<id_type id>
rt_equation	make_equation (default_numeric_type lhs, ct_variable< id > const &rhs)
	Generator for an equation with a (floating point) constant as left hand side and a ViennaMath compiletime variable as right hand side.
template<typename InterfaceType >
rt_equation< InterfaceType >	make_equation (typename InterfaceType::numeric_type lhs, rt_unary_expr< InterfaceType > const &rhs)
	Generator for an equation with a (floating point) constant as left hand side and a ViennaMath runtime unary expression as right hand side.
template<typename InterfaceType >
rt_equation< InterfaceType >	make_equation (typename InterfaceType::numeric_type lhs, rt_binary_expr< InterfaceType > const &rhs)
	Generator for an equation with a (floating point) constant as left hand side and a ViennaMath runtime binary expression as right hand side.
template<typename InterfaceType >
rt_equation< InterfaceType >	make_equation (typename InterfaceType::numeric_type lhs, rt_expr< InterfaceType > const &rhs)
	Generator for an equation with a (floating point) constant as left hand side and a ViennaMath runtime expression wrapper as right hand side.
template<typename NumericT , typename InterfaceType , typename RHSType >
rt_equation< InterfaceType >	make_equation (rt_constant< NumericT, InterfaceType > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath runtime constant as left hand side.
template<typename InterfaceType , typename RHSType >
rt_equation< InterfaceType >	make_equation (rt_variable< InterfaceType > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath runtime variable as left hand side.
template<typename InterfaceType , typename RHSType >
rt_equation< InterfaceType >	make_equation (rt_function_symbol< InterfaceType > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath runtime function symbol as left hand side.
template<typename InterfaceType , typename RHSType >
rt_equation< InterfaceType >	make_equation (rt_unary_expr< InterfaceType > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath runtime unary expression as left hand side.
template<typename InterfaceType , typename RHSType >
rt_equation< InterfaceType >	make_equation (rt_binary_expr< InterfaceType > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath runtime binary expression as left hand side.
template<typename InterfaceType , typename RHSType >
rt_equation< InterfaceType >	make_equation (rt_expr< InterfaceType > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath runtime expression wrapper as left hand side.
template<typename LHS , typename OP , typename RHS , typename RHSType >
rt_equation	make_equation (ct_binary_expr< LHS, OP, RHS > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath compiletime binary expression as left hand side.
template<typename LHS , typename OP , typename RHSType >
rt_equation	make_equation (ct_unary_expr< LHS, OP > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath compiletime unary expression as left hand side.
template<long val, typename RHSType >
rt_equation	make_equation (ct_constant< val > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath compiletime constant as left hand side.
template<typename TAG , typename RHSType >
rt_equation	make_equation (ct_function_symbol< TAG > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath compiletime function symbol as left hand side.
template<id_type id, typename RHSType >
rt_equation	make_equation (ct_variable< id > const &lhs, RHSType const &rhs)
	Generator for an equation with a ViennaMath compiletime variable as left hand side.
template<typename InterfaceType >
std::ostream &	operator<< (std::ostream &stream, rt_expr< InterfaceType > const &e)
template<typename InterfaceType >
std::ostream &	operator<< (std::ostream &stream, rt_function_symbol< InterfaceType > const &v)
template<typename InterfaceType >
rt_expr< InterfaceType >	integral (rt_interval< InterfaceType > const &interv, rt_expr< InterfaceType > const &integrand, rt_variable< InterfaceType > const &var)
	Creates an expression encoding the integral of an expression with respect to a runtime variable over a certain interval.
template<typename InterfaceType , id_type id>
rt_expr< InterfaceType >	integral (rt_interval< InterfaceType > const &interv, rt_expr< InterfaceType > const &integrand, ct_variable< id > const &var)
	Creates an expression encoding the integral of an expression with respect to a compiletime variable over a certain interval.
template<typename InterfaceType , id_type id>
rt_expr< InterfaceType >	integral (rt_interval< InterfaceType > const &interv, rt_binary_expr< InterfaceType > const &integrand, ct_variable< id > const &var)
	Creates an expression encoding the integral of a binary expression with respect to a compiletime variable over a certain interval.
template<typename InterfaceType >
rt_expr< InterfaceType >	integral (rt_symbolic_interval< InterfaceType > const &interv, rt_expr< InterfaceType > const &integrand)
	Integral generator function taking a symbolic interval and a runtime expression wrapper for the integrand.
template<typename InterfaceType >
rt_expr< InterfaceType >	integral (rt_symbolic_interval< InterfaceType > const &interv, rt_binary_expr< InterfaceType > const &integrand)
	Integral generator function taking a symbolic interval and a runtime binary expression for the integrand.
template<typename InterfaceType >
rt_expr< InterfaceType >	integral (rt_symbolic_interval< InterfaceType > const &interv, rt_unary_expr< InterfaceType > const &integrand)
	Integral generator function taking a symbolic interval and a runtime unary expression for the integrand.
template<typename InterfaceType , typename T >
rt_expr< InterfaceType >	integral (rt_symbolic_interval< InterfaceType > const &interv, rt_constant< T, InterfaceType > const &integrand)
	Integral generator function taking a symbolic interval and a ViennaMath runtime constant for the integrand.
template<typename InterfaceType >
rt_expr< InterfaceType >	integral (rt_symbolic_interval< InterfaceType > const &interv, rt_variable< InterfaceType > const &integrand)
	Integral generator function taking a symbolic interval and a ViennaMath runtime variable for the integrand.
template<typename InterfaceType >
rt_expr< InterfaceType >	integral (rt_symbolic_interval< InterfaceType > const &interv, rt_function_symbol< InterfaceType > const &integrand)
	Integral generator function taking a symbolic interval and a ViennaMath runtime function symbol for the integrand.
template<typename InterfaceType >
std::ostream &	operator<< (std::ostream &stream, rt_interval< InterfaceType > const &e)
	Convenience overload for streaming an interval to an output stream.
rt_interval	make_interval (default_numeric_type lhs, default_numeric_type rhs)
	Creates an interval with two numerical limits.
template<typename NumericT , typename InterfaceType , typename RHSType >
rt_interval< InterfaceType >	make_interval (typename InterfaceType::numeric_type lhs, rt_constant< NumericT, InterfaceType > const &rhs)
	Creates an interval, where the upper bound is given by a ViennaMath constant.
template<typename InterfaceType >
rt_interval< InterfaceType >	make_interval (typename InterfaceType::numeric_type lhs, rt_variable< InterfaceType > const &rhs)
	Creates an interval, where the upper bound is given by a ViennaMath runtime variable.
template<id_type id>
rt_interval	make_interval (default_numeric_type lhs, ct_variable< id > const &rhs)
	Creates an interval, where the upper bound is given by a ViennaMath compiletime variable.
template<typename InterfaceType >
rt_interval< InterfaceType >	make_interval (typename InterfaceType::numeric_type lhs, rt_unary_expr< InterfaceType > const &rhs)
	Creates an interval, where the upper bound is given by a ViennaMath unary expression.
template<typename InterfaceType >
rt_interval< InterfaceType >	make_interval (typename InterfaceType::numeric_type lhs, rt_binary_expr< InterfaceType > const &rhs)
	Creates an interval, where the upper bound is given by a ViennaMath binary expression.
template<typename InterfaceType >
rt_interval< InterfaceType >	make_interval (typename InterfaceType::numeric_type lhs, rt_expr< InterfaceType > const &rhs)
	Creates an interval, where the upper bound is given by a ViennaMath expression wrapper.
template<typename NumericT , typename InterfaceType , typename RHSType >
rt_interval< InterfaceType >	make_interval (rt_constant< NumericT, InterfaceType > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath runtime constant.
template<typename InterfaceType , typename RHSType >
rt_interval< InterfaceType >	make_interval (rt_variable< InterfaceType > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath runtime variable.
template<id_type id, typename RHSType >
rt_interval	make_interval (ct_variable< id > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath compiletime variable.
template<typename InterfaceType , typename RHSType >
rt_interval< InterfaceType >	make_interval (rt_function_symbol< InterfaceType > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath runtime function symbol.
template<typename InterfaceType , typename RHSType >
rt_interval< InterfaceType >	make_interval (rt_unary_expr< InterfaceType > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath runtime unary expression.
template<typename InterfaceType , typename RHSType >
rt_interval< InterfaceType >	make_interval (rt_binary_expr< InterfaceType > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath runtime binary expression.
template<typename InterfaceType , typename RHSType >
rt_interval< InterfaceType >	make_interval (rt_expr< InterfaceType > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath runtime expression wrapper.
template<typename LHS , typename OP , typename RHS , typename RHSType >
rt_interval< typename RHSType::interface_type >	make_interval (ct_binary_expr< LHS, OP, RHS > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath compiletime binary expression.
template<typename LHS , typename OP , typename RHSType >
rt_interval< typename RHSType::interface_type >	make_interval (ct_unary_expr< LHS, OP > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath compiletime unary expression.
template<long val, typename RHSType >
rt_interval< typename RHSType::interface_type >	make_interval (ct_constant< val > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath compiletime constant.
template<typename TAG , typename RHSType >
rt_interval< typename RHSType::interface_type >	make_interval (ct_function_symbol< TAG > const &lhs, RHSType const &rhs)
	Creates an interval, where the lower bound is given by a ViennaMath compiletime function symbol.
template<typename ScalarType , typename InterfaceType , typename OtherScalarType , typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < ScalarType, op_plus < typename InterfaceType::numeric_type > , OtherScalarType > ::result_type, InterfaceType > , op_plus< typename InterfaceType::numeric_type > , RHS >	operator+ (rt_constant< ScalarType, InterfaceType > const &lhs, ct_binary_expr< rt_constant< OtherScalarType, InterfaceType >, op_plus< typename InterfaceType::numeric_type >, RHS > const &other)
	Special overload for c1 + (c2 + X) -> [c1 + c2] + X, where c1 and c2 are runtime constants and X is any expression:
template<typename ScalarType , typename InterfaceType , long value, typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < ScalarType, op_plus < typename InterfaceType::numeric_type > , long >::result_type, InterfaceType >, op_plus < typename InterfaceType::numeric_type > , RHS >	operator+ (rt_constant< ScalarType, InterfaceType > const &lhs, ct_binary_expr< ct_constant< value >, op_plus< typename InterfaceType::numeric_type >, RHS > const &other)
	Special overload for c1 + (ct_c2 + X) -> [c1 + ct_c2] + X, where c1 is a runtime constant, ct_c2 is a compiletime constant, and X is any expression:
template<typename ScalarType , typename InterfaceType , typename OtherScalarType , typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < ScalarType, op_plus < typename InterfaceType::numeric_type > , OtherScalarType > ::result_type, InterfaceType > , op_minus< typename InterfaceType::numeric_type > , RHS >	operator+ (rt_constant< ScalarType, InterfaceType > const &lhs, ct_binary_expr< rt_constant< OtherScalarType, InterfaceType >, op_minus< typename InterfaceType::numeric_type >, RHS > const &other)
	Special overload for c1 + (c2 - X) -> [c1 + c2] - X, where c1 and c2 are runtime constants and X is any expression:
template<typename ScalarType , typename InterfaceType , long value, typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < ScalarType, op_plus < typename InterfaceType::numeric_type > , long >::result_type, InterfaceType >, op_minus < typename InterfaceType::numeric_type > , RHS >	operator+ (rt_constant< ScalarType, InterfaceType > const &lhs, ct_binary_expr< ct_constant< value >, op_minus< typename InterfaceType::numeric_type >, RHS > const &other)
	Special overload for c1 + (ct_c2 - X) -> [c1 + ct_c2] - X, where c1 is a runtime constant, ct_c2 is a compiletime constant, and X is any expression:
template<long value, typename RHS , typename ScalarType , typename T , typename InterfaceType >
ct_binary_expr< rt_constant < typename promote_traits < long, op_plus< T > , ScalarType >::result_type > , op_plus< T >, RHS >	operator+ (ct_binary_expr< ct_constant< value >, op_plus< T >, RHS > const &lhs, rt_constant< ScalarType, InterfaceType > const &other)
	Special overload for (ct_c1 + X) + c2 -> [ct_c1 + c2] + X, where ct_c1 is a compile constant, c2 is a runtime constant, and X is any expression:
template<long value, typename RHS , typename ScalarType , typename InterfaceType >
ct_binary_expr< rt_constant < default_numeric_type, InterfaceType >, op_minus < default_numeric_type >, RHS >	operator+ (ct_binary_expr< ct_constant< value >, op_minus< default_numeric_type >, RHS > const &lhs, rt_constant< ScalarType, InterfaceType > const &other)
	Special overload for (ct_c1 - X) + c2 -> [ct_c1 + c2] - X, where ct_c1 is a compile constant, c2 is a runtime constant, and X is any expression:
template<typename ScalarType , typename InterfaceType , typename OtherScalarType , typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < ScalarType, op_minus < typename InterfaceType::numeric_type > , OtherScalarType > ::result_type, InterfaceType > , op_minus< typename InterfaceType::numeric_type > , RHS >	operator- (rt_constant< ScalarType, InterfaceType > const &lhs, ct_binary_expr< rt_constant< OtherScalarType, InterfaceType >, op_plus< typename InterfaceType::numeric_type >, RHS > const &other)
	Special overload for c1 - (c2 + X) -> [c1 - c2] - X, where c1 and c2 are runtime constants and X is any expression:
template<typename ScalarType , typename InterfaceType , long value, typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < ScalarType, op_minus < typename InterfaceType::numeric_type > , long >::result_type, InterfaceType >, op_minus < typename InterfaceType::numeric_type > , RHS >	operator- (rt_constant< ScalarType, InterfaceType > const &lhs, ct_binary_expr< ct_constant< value >, op_plus< typename InterfaceType::numeric_type >, RHS > const &other)
	Special overload for c1 - (ct_c2 + X) -> [c1 - ct_c2] - X, where c1 is a runtime constant, ct_c2 is a compiletime constant, and X is any expression:
template<typename ScalarType , typename InterfaceType , typename OtherScalarType , typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < ScalarType, op_minus < typename InterfaceType::numeric_type > , OtherScalarType > ::result_type, InterfaceType > , op_plus< typename InterfaceType::numeric_type > , RHS >	operator- (rt_constant< ScalarType, InterfaceType > const &lhs, ct_binary_expr< rt_constant< OtherScalarType, InterfaceType >, op_minus< typename InterfaceType::numeric_type >, RHS > const &other)
	Special overload for c1 - (c2 - X) -> [c1 - c2] + X, where c1 and c2 are runtime constants and X is any expression:
template<typename ScalarType , typename InterfaceType , long value, typename RHS >
ct_binary_expr< rt_constant < typename promote_traits < ScalarType, op_minus < typename InterfaceType::numeric_type > , long >::result_type, InterfaceType >, op_plus < typename InterfaceType::numeric_type > , RHS >	operator- (rt_constant< ScalarType, InterfaceType > const &lhs, ct_binary_expr< ct_constant< value >, op_minus< typename InterfaceType::numeric_type >, RHS > const &other)
	Special overload for c1 - (ct_c2 - X) -> [c1 - ct_c2] + X, where c1 is a runtime constant, ct_c2 is a compiletime constant, and X is any expression:
template<typename NumericT , typename InterfaceType >
rt_binary_expr< InterfaceType >	operator* (rt_constant< NumericT, InterfaceType > const &lhs, rt_function_symbol< InterfaceType > const &rhs)
	Special overload for the multiplication of a function symbol with a ViennaMath runtime constant.
template<typename InterfaceType >
rt_binary_expr< InterfaceType >	operator* (rt_expr< InterfaceType > const &lhs, rt_function_symbol< InterfaceType > const &rhs)
	Special overload for the multiplication of a function symbol with a ViennaMath runtime expression wrapper.
template<typename InterfaceType >
std::ostream &	operator<< (std::ostream &stream, rt_symbolic_interval< InterfaceType > const &e)
	Convenience overload for obtaining a string representation of a symbolic interval.
template<typename InterfaceType >
std::ostream &	operator<< (std::ostream &stream, rt_unary_expr< InterfaceType > const &e)
	Overload of the stream operator in order to allow for a convenient conversion of a unary expression to a string.
template<typename T >
bool	unary_op_equal (T const &lhs, T const &rhs)
	Helper function returning true if the two arguments are of the same type.
template<typename VectorType >
VectorType::value_type	get_from_vector (VectorType const &vec, id_type i)
	Generic wrapper function for accessing the i-th entry of a vector. Provides a uniform interface for compile-time and run-time vectors.
template<typename T1 >
default_numeric_type	get_from_vector (ct_vector_1< T1 > const &vec, id_type i)
	Generic wrapper function for accessing the i-th entry of a vector. Provides a uniform interface for compile-time and run-time vectors.
template<typename T1 , typename T2 >
default_numeric_type	get_from_vector (ct_vector_2< T1, T2 > const &vec, id_type i)
	Generic wrapper function for accessing the i-th entry of a vector. Provides a uniform interface for compile-time and run-time vectors.
template<typename T1 , typename T2 , typename T3 >
default_numeric_type	get_from_vector (ct_vector_3< T1, T2, T3 > const &vec, id_type i)
	Generic wrapper function for accessing the i-th entry of a vector. Provides a uniform interface for compile-time and run-time vectors.
template<typename InterfaceType >
std::ostream &	operator<< (std::ostream &stream, rt_variable< InterfaceType > const &u)
	Output stream overload, mostly used for printing an expression to screen.
template<typename InterfaceType >
std::ostream &	operator<< (std::ostream &stream, rt_vector_expr< InterfaceType > const &e)
template<typename InterfaceType , typename T >
rt_vector_expr< InterfaceType >	operator* (rt_vector_expr< InterfaceType > const &lhs, T const &rhs)
template<typename T , typename InterfaceType >
rt_vector_expr< InterfaceType >	operator* (T const &lhs, rt_vector_expr< InterfaceType > const &rhs)
template<typename InterfaceType >
rt_expr< InterfaceType >	operator* (rt_vector_expr< InterfaceType > const &lhs, rt_vector_expr< InterfaceType > const &rhs)
template<typename InterfaceType , typename T >
rt_vector_expr< InterfaceType >	operator/ (rt_vector_expr< InterfaceType > const &lhs, T const &rhs)
template<typename T , typename InterfaceType >
rt_vector_expr< InterfaceType >	operator/ (T const &lhs, rt_vector_expr< InterfaceType > const &rhs)

---

Detailed Description

The main ViennaMath namespace. All types and functions for the user reside here.

---

Typedef Documentation

typedef rt_binary_expr binary_expr

typedef rt_constant constant

typedef rt_expression_interface<default_numeric_type> default_interface_type

Convenience type definition for the default expression interface.

typedef double default_numeric_type

The underlying floating point type to be used in case of doubt (e.g. when new constants are created during manipulation).

typedef rt_equation equation

typedef rt_expr expr

typedef rt_function_symbol function_symbol

typedef rt_gauss_quad_1 gauss_quad_1

typedef unsigned long id_type

Type used for any kind of IDs (variable, etc.).

typedef rt_interval interval

typedef rt_latex_translator latex_translator

Convenience typedef for the latex translator in order to avoid the ugly '<>' for the default template parameter of rt_latex_translator.

typedef rt_numerical_quadrature numerical_quadrature

typedef rt_symbolic_interval symbolic_interval

typedef rt_unary_expr unary_expr

typedef rt_variable variable

typedef rt_vector_expr vector_expr

---

Function Documentation

rt_expr<InterfaceType> viennamath::apply_coordinate_system	(	cartesian< 1 >	,
		rt_expr< InterfaceType > const &	ex
	)

Transforms the expression to a Cartesian coordinate system in one dimension.

Parameters:

ex

The runtime expression wrapper to be transformed

rt_expr<InterfaceType> viennamath::apply_coordinate_system	(	cartesian< 1 >	,
		rt_unary_expr< InterfaceType > const &	ex
	)

Transforms the expression to a Cartesian coordinate system in one dimension.

Parameters:

ex

The runtime unary expression to be transformed

rt_expr<InterfaceType> viennamath::apply_coordinate_system	(	cartesian< 1 >	,
		rt_binary_expr< InterfaceType > const &	ex
	)

Transforms the expression to a Cartesian coordinate system in one dimension.

Parameters:

ex

The runtime binary expression to be transformed

rt_expr<InterfaceType> viennamath::apply_coordinate_system	(	cartesian< 2 >	,
		rt_expr< InterfaceType > const &	ex
	)

Transforms the expression to a Cartesian coordinate system in two dimensions.

Parameters:

ex

The runtime expression wrapper to be transformed

rt_expr<InterfaceType> viennamath::apply_coordinate_system	(	cartesian< 2 >	,
		rt_unary_expr< InterfaceType > const &	ex
	)

Transforms the expression to a Cartesian coordinate system in two dimensions.

Parameters:

ex

The runtime unary expression to be transformed

rt_expr<InterfaceType> viennamath::apply_coordinate_system	(	cartesian< 2 >	,
		rt_binary_expr< InterfaceType > const &	ex
	)

Transforms the expression to a Cartesian coordinate system in two dimensions.

Parameters:

ex

The runtime binary expression to be transformed

rt_expr<InterfaceType> viennamath::apply_coordinate_system	(	cartesian< 3 >	,
		rt_expr< InterfaceType > const &	ex
	)

Transforms the expression to a Cartesian coordinate system in two dimensions.

Parameters:

ex

The runtime expression wrapper to be transformed

rt_expr<InterfaceType> viennamath::apply_coordinate_system	(	cartesian< 3 >	,
		rt_unary_expr< InterfaceType > const &	ex
	)

Transforms the expression to a Cartesian coordinate system in three dimensions.

Parameters:

ex

The runtime unary expression to be transformed

rt_expr<InterfaceType> viennamath::apply_coordinate_system	(	cartesian< 3 >	,
		rt_binary_expr< InterfaceType > const &	ex
	)

Transforms the expression to a Cartesian coordinate system in three dimensions.

Parameters:

ex

The runtime binary expression to be transformed

rt_equation<InterfaceType> viennamath::apply_coordinate_system	(	cartesian< dim >	,
		rt_equation< InterfaceType > const &	equ
	)

Convenience overload which automatically applies the coordinate transformation to the right hand left hand side of an equation.

bool can_simplify_impl	(	const InterfaceType *	lhs,
		op_plus< NumericT >	,
		const InterfaceType *	rhs
	)

Checks whether an expression of the form e1 + e2 can be simplified.

bool can_simplify_impl	(	const InterfaceType *	lhs,
		op_minus< NumericT >	,
		const InterfaceType *	rhs
	)

Checks whether an expression of the form e1 - e2 can be simplified.

bool can_simplify_impl	(	const InterfaceType *	lhs,
		op_mult< NumericT >	,
		const InterfaceType *	rhs
	)

Checks whether an expression of the form e1 * e2 can be simplified.

bool can_simplify_impl	(	const InterfaceType *	lhs,
		op_div< NumericT >	,
		const InterfaceType *	rhs
	)

Checks whether an expression of the form e1 / e2 can be simplified.

viennamath::result_of::coefficient<FactorType, ExpressionType>::type viennamath::coefficient	(	FactorType const &	f,
		ExpressionType const &	e
	)

User function for extracting the coefficient of a variable or sub-expression from an expression.

Parameters:

	f	The variable or sub-expression to be extracted
	e	The expression from which the coefficient is to be extracted

rt_unary_expr<InterfaceType> viennamath::cos

(

rt_constant< NumericT, InterfaceType > const &

other

)

Overload of the cosine function for a ViennaMath runtime constant.

rt_unary_expr<InterfaceType> viennamath::cos

(

rt_variable< InterfaceType > const &

other

)

Overload of the cosine function for a ViennaMath runtime variable.

rt_unary_expr viennamath::cos

(

ct_variable< id > const &

other

)

Overload of the cosine function for a ViennaMath compiletime variable.

rt_unary_expr viennamath::cos

(

ct_binary_expr< LHS, OP, RHS > const &

other

)

Overload of the cosine function for a ViennaMath compiletime binary expression.

rt_unary_expr viennamath::cos

(

ct_unary_expr< LHS, OP > const &

other

)

Overload of the cosine function for a ViennaMath compiletime unary expression.

rt_unary_expr<InterfaceType> viennamath::cos

(

rt_unary_expr< InterfaceType > const &

other

)

Overload of the cosine function for a ViennaMath runtime unary expression.

rt_unary_expr<InterfaceType> viennamath::cos

(

rt_binary_expr< InterfaceType > const &

other

)

Overload of the cosine function for a ViennaMath runtime binary expression.

rt_unary_expr<InterfaceType> viennamath::cos

(

rt_expr< InterfaceType > const &

other

)

Overload of the cosine function for a ViennaMath runtime expression wrapper.

rt_expr<InterfaceType> viennamath::diff	(	rt_binary_expr< InterfaceType > const &	e,
		rt_variable< InterfaceType > const &	var
	)

Returns the derivative of the provided runtime binary expression.

Parameters:

	e	The expression to be differentiated
	var	The differentiation variable

rt_expr<InterfaceType> viennamath::diff	(	rt_unary_expr< InterfaceType > const &	e,
		rt_variable< InterfaceType > const &	var
	)

Returns the derivative of the provided runtime unary expression.

Parameters:

	e	The expression to be differentiated
	var	The differentiation variable

rt_expr<InterfaceType> viennamath::diff	(	rt_expr< InterfaceType > const &	e,
		rt_variable< InterfaceType > const &	var
	)

Returns the derivative of the provided runtime expression wrapper.

Parameters:

	e	The expression to be differentiated
	var	The differentiation variable

rt_expr<InterfaceType> viennamath::diff	(	rt_binary_expr< InterfaceType > const &	e,
		ct_variable< id > const &	var
	)

Returns the derivative of the provided runtime binary expression.

Parameters:

	e	The expression to be differentiated
	var	The differentiation variable

rt_expr<InterfaceType> viennamath::diff	(	rt_unary_expr< InterfaceType > const &	e,
		ct_variable< id > const &	var
	)

Returns the derivative of the provided runtime unary expression.

Parameters:

	e	The expression to be differentiated
	var	The differentiation variable

rt_expr<InterfaceType> viennamath::diff	(	rt_expr< InterfaceType > const &	e,
		ct_variable< id > const &	var
	)

Returns the derivative of the provided runtime expression wrapper.

Parameters:

	e	The expression to be differentiated
	var	The differentiation variable

rt_expr<InterfaceType> viennamath::diff	(	rt_function_symbol< InterfaceType > const &	other,
		rt_variable< InterfaceType > const &	var
	)

Returns a symbolic representation of a differentiated function.

rt_expr<InterfaceType> viennamath::diff	(	rt_function_symbol< InterfaceType > const &	other,
		ct_variable< id > const &	var
	)

Returns a symbolic representation of a differentiated function.

rt_constant<typename InterfaceType::numeric_type> viennamath::diff	(	typename InterfaceType::numeric_type	value,
		rt_variable< InterfaceType > const &	var
	)

Overload for the derivative of a function.

rt_constant<typename InterfaceType::numeric_type> viennamath::diff	(	rt_constant< OtherScalarType, InterfaceType > const &	c,
		rt_variable< InterfaceType > const &	var
	)

Overload for the derivative of a ViennaMath runtime constant.

rt_constant<typename InterfaceType::numeric_type> viennamath::diff	(	rt_variable< InterfaceType > const &	c,
		rt_variable< InterfaceType > const &	var
	)

Overload for computing the derivative of a runtime variable.

result_of::diff<ExpressionType, ct_variable<id> >::result_type viennamath::diff	(	ExpressionType const &	c,
		ct_variable< id > const &	var
	)

The user function for differentiation of a compile time expression with respect to a compile time variable.

InterfaceType * diff_impl	(	const InterfaceType *	e,
		op_cos< NumericT >	,
		const InterfaceType *	diff_var
	)

Differentation of cos(e), where e is an expression.

InterfaceType * diff_impl	(	const InterfaceType *	e,
		op_tan< NumericT >	,
		const InterfaceType *	diff_var
	)

Differentation of tan(e), where e is an expression.

InterfaceType * diff_impl	(	const InterfaceType *	e,
		op_fabs< NumericT >	,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of |e|, where e is an expression. Since the modulus is not differentiable everywhere, an exception is thrown.

InterfaceType * diff_impl	(	const InterfaceType *	e,
		op_sqrt< NumericT >	,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of \sqrt{e}, where e is an expression.

InterfaceType * diff_impl	(	const InterfaceType *	e,
		op_log< NumericT >	,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of ln(e), where e is an expression.

InterfaceType * diff_impl	(	const InterfaceType *	e,
		op_log10< NumericT >	,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of log10(e), where e is an expression.

Uses the rule (log10(f))' = f' / (ln(f) * ln(10))

InterfaceType* viennamath::diff_impl	(	const InterfaceType *	e,
		op_gradient< NumericT >	,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of a gradient. This is currently not supported, thus an exception is thrown.

InterfaceType* viennamath::diff_impl	(	const InterfaceType *	e,
		op_divergence< NumericT >	,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of the divergence operator. This is currently not supported, thus an exception is thrown.

InterfaceType* viennamath::diff_impl	(	const InterfaceType *	e,
		op_partial_deriv< NumericT >	,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of a partial derivative. This is currently not supported, thus an exception is thrown.

InterfaceType* viennamath::diff_impl	(	const InterfaceType *	e,
		op_rt_integral< InterfaceType >	,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of an integral. This is currently not supported, thus an exception is thrown.

InterfaceType* viennamath::diff_impl	(	const InterfaceType *	e,
		op_rt_symbolic_integral< InterfaceType >	,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of an integral with symbolic integration domain. This is currently not supported, thus an exception is thrown.

InterfaceType * diff_impl	(	const InterfaceType *	lhs,
		op_plus< NumericT >	,
		const InterfaceType *	rhs,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of e1 + e1, where e1 and e2 are expressions.

InterfaceType * diff_impl	(	const InterfaceType *	lhs,
		op_minus< NumericT >	,
		const InterfaceType *	rhs,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of e1 - e1, where e1 and e2 are expressions.

InterfaceType * diff_impl	(	const InterfaceType *	lhs,
		op_mult< NumericT >	,
		const InterfaceType *	rhs,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of e1 * e1, where e1 and e2 are expressions.

InterfaceType * diff_impl	(	const InterfaceType *	lhs,
		op_div< NumericT >	,
		const InterfaceType *	rhs,
		const InterfaceType *	diff_var
	)

Implementation of the differentation of e1 / e1, where e1 and e2 are expressions.

InterfaceType * diff_impl	(	const InterfaceType *	e,
		op_id< NumericT >	,
		const InterfaceType *	diff_var
	)

Differentation of a unary expression containing identity.

InterfaceType * diff_impl	(	const InterfaceType *	e,
		op_exp< NumericT >	,
		const InterfaceType *	diff_var
	)

Differentation of exp(e), where e is an expression.

InterfaceType * diff_impl	(	const InterfaceType *	e,
		op_sin< NumericT >	,
		const InterfaceType *	diff_var
	)

Differentation of sin(e), where e is an expression.

rt_unary_expr<InterfaceType> viennamath::div

(

rt_expr< InterfaceType > const &

other

)

Overload of the divergence function for a ViennaMath runtime expression wrapper.

rt_unary_expr<InterfaceType> viennamath::div

(

rt_unary_expr< InterfaceType > const &

other

)

Overload of the divergence function for a ViennaMath runtime unary expression.

rt_unary_expr<InterfaceType> viennamath::div

(

rt_binary_expr< InterfaceType > const &

other

)

Overload of the divergence function for a ViennaMath runtime binary expression.

rt_unary_expr<InterfaceType> viennamath::div

(

rt_function_symbol< InterfaceType > const &

other

)

Overload of the divergence function for a ViennaMath runtime function symbol.

result_of::drop_dependent_terms<FactorType, ExpressionType>::type viennamath::drop_dependent_terms	(	FactorType const &	f,
		ExpressionType const &	e
	)

Main user function for dropping all terms from an expression which depend on a certain variable or expression.

Technically, this is accomplished by replacing the respective factor by zero

Parameters:

	f	The factor which should be set to zero
	e	The full expression from which the dependent terms should be dropped

enable_if<result_of::is_ct_evaluable<ExpressionType>::value && result_of::is_ct_vector<VectorType>::value, default_numeric_type>::type viennamath::eval	(	ExpressionType const &	e,
		VectorType const &	v
	)

Main user function for the evaluation of a compiletime expression at compiletime.

Parameters:

	e	The compiletime expression
	v	A compiletime vector

default_numeric_type viennamath::eval	(	default_numeric_type	value,
		VectorType const &	v
	)

Evaluation of a numeric constant at a vector: Return the constant.

long viennamath::eval	(	long	value,
		VectorType const &	v
	)

Evaluation of a long integer at a vector: Return the integer.

InterfaceType::numeric_type viennamath::eval	(	rt_constant< T, InterfaceType >	c,
		VectorType const &	v
	)

Evaluation of a runtime constant at a vector: Return the runtime constant.

InterfaceType::numeric_type viennamath::eval	(	rt_expr< InterfaceType >	e,
		VectorType const &	v
	)

Evaluation of a ViennaMath expression wrapper.

Parameters:

	e	The expression wrapper
	v	Either a single number (typically of type double) or a vector type offering bracket-access

InterfaceType::numeric_type viennamath::eval	(	rt_binary_expr< InterfaceType >	e,
		VectorType const &	v
	)

Evaluation of a ViennaMath binary expression.

Parameters:

	e	The expression wrapper
	v	Either a single number (typically of type double) or a vector type offering bracket-access

InterfaceType::numeric_type viennamath::eval	(	rt_unary_expr< InterfaceType >	e,
		VectorType const &	v
	)

Evaluation of a ViennaMath unary expression.

Parameters:

	e	The expression wrapper
	v	Either a single number (typically of type double) or a vector type offering bracket-access

InterfaceType::numeric_type viennamath::eval	(	rt_variable< InterfaceType >	e,
		VectorType const &	v
	)

Evaluation of a ViennaMath variable.

Parameters:

	e	The expression wrapper
	v	Either a single number (typically of type double) or a vector type offering bracket-access

enable_if<!result_of::is_ct_evaluable< ct_binary_expr<LHS, OP, RHS> >::value || !result_of::is_ct_vector<VectorType>::value, default_numeric_type>::type viennamath::eval	(	ct_binary_expr< LHS, OP, RHS >	ex,
		VectorType const &	v
	)

Evaluation of a ViennaMath compiletime binary expression using a runtime vector.

Parameters:

	ex	The compiletime binary expression
	v	Either a single number (typically of type double) or a vector type offering bracket-access (e.g. std::vector<>)

enable_if<!result_of::is_ct_evaluable< ct_unary_expr<LHS, OP> >::value || !result_of::is_ct_vector<VectorType>::value, default_numeric_type>::type viennamath::eval	(	ct_unary_expr< LHS, OP >	ex,
		VectorType const &	v
	)

Evaluation of a ViennaMath compiletime unary expression using a runtime vector.

Parameters:

	ex	The compiletime unary expression
	v	Either a single number (typically of type double) or a vector type offering bracket-access (e.g. std::vector<>)

default_numeric_type viennamath::eval	(	ct_constant< value >	c,
		VectorType const &	v
	)

Evaluation of a ViennaMath compiletime constant using a runtime vector.

Parameters:

	c	The compiletime constant
	v	Either a single number (typically of type double) or a vector type offering bracket-access (e.g. std::vector<>)

default_numeric_type viennamath::eval	(	ct_variable< id >	c,
		VectorType const &	v
	)

Evaluation of a ViennaMath compiletime variable using a runtime vector.

Parameters:

	c	The compiletime variable
	v	Either a single number (typically of type double) or a vector type offering bracket-access (e.g. std::vector<>)

default_numeric_type viennamath::eval	(	ct_variable< id >	c,
		ct_vector_1< T0 > const &	v
	)

Evaluation of a ViennaMath compiletime variable using a compiletime vector with one entry.

default_numeric_type viennamath::eval	(	ct_variable< id >	c,
		ct_vector_2< T0, T1 > const &	v
	)

Evaluation of a ViennaMath compiletime variable using a compiletime vector with two entries.

default_numeric_type viennamath::eval	(	ct_variable< id >	c,
		ct_vector_3< T0, T1, T2 > const &	v
	)

Evaluation of a ViennaMath compiletime variable using a compiletime vector with three entries.

rt_unary_expr<InterfaceType> viennamath::exp

(

rt_constant< NumericT, InterfaceType > const &

other

)

Overload of the exponential function for a ViennaMath runtime constant.

rt_unary_expr<InterfaceType> viennamath::exp

(

rt_variable< InterfaceType > const &

other

)

Overload of the exponential function for a ViennaMath runtime variable.

rt_unary_expr viennamath::exp

(

ct_variable< id > const &

other

)

Overload of the exponential function for a ViennaMath compiletime variable.

rt_unary_expr viennamath::exp

(

ct_binary_expr< LHS, OP, RHS > const &

other

)

Overload of the exponential function for a ViennaMath compiletime binary expression.

rt_unary_expr viennamath::exp

(

ct_unary_expr< LHS, OP > const &

other

)

Overload of the exponential function for a ViennaMath compiletime unary expression.

rt_unary_expr<InterfaceType> viennamath::exp

(

rt_expr< InterfaceType > const &

other

)

Overload of the exponential function for a ViennaMath runtime expression wrapper.

rt_unary_expr<InterfaceType> viennamath::exp

(

rt_binary_expr< InterfaceType > const &

other

)

Overload of the exponential function for a ViennaMath runtime binary expression.

result_of::expand<ExpressionType>::type viennamath::expand

(

ExpressionType const &

type

)

User function for expanding a compile time expression.

Template Parameters:

ExpressionType

The compiletime expression for expansion

rt_unary_expr<InterfaceType> viennamath::fabs

(

rt_constant< NumericT, InterfaceType > const &

other

)

Overload of the modulus function for a ViennaMath runtime constant.

rt_unary_expr<InterfaceType> viennamath::fabs

(

rt_variable< InterfaceType > const &

other

)

Overload of the modulus function for a ViennaMath runtime variable.

rt_unary_expr viennamath::fabs

(

ct_variable< id > const &

other

)

Overload of the modulus function for a ViennaMath compiletime variable.

rt_unary_expr viennamath::fabs

(

ct_binary_expr< LHS, OP, RHS > const &

other

)

Overload of the modulus function for a ViennaMath compiletime binary expression.

rt_unary_expr viennamath::fabs

(

ct_unary_expr< LHS, OP > const &

other

)

Overload of the modulus function for a ViennaMath compiletime unary expression.

rt_unary_expr<InterfaceType> viennamath::fabs

(

rt_unary_expr< InterfaceType > const &

other

)

Overload of the modulus function for a ViennaMath runtime unary expression.

rt_unary_expr<InterfaceType> viennamath::fabs

(

rt_binary_expr< InterfaceType > const &

other

)

Overload of the modulus function for a ViennaMath runtime binary expression.

rt_unary_expr<InterfaceType> viennamath::fabs

(

rt_expr< InterfaceType > const &

other

)

Overload of the modulus function for a ViennaMath runtime expression wrapper.

VectorType::value_type viennamath::get_from_vector	(	VectorType const &	vec,
		id_type	i
	)

Generic wrapper function for accessing the i-th entry of a vector. Provides a uniform interface for compile-time and run-time vectors.

This is the default implementation.

default_numeric_type viennamath::get_from_vector	(	ct_vector_1< T1 > const &	vec,
		id_type	i
	)

Generic wrapper function for accessing the i-th entry of a vector. Provides a uniform interface for compile-time and run-time vectors.

This is the overload for a compile-time vector of size 1

default_numeric_type viennamath::get_from_vector	(	ct_vector_2< T1, T2 > const &	vec,
		id_type	i
	)

Generic wrapper function for accessing the i-th entry of a vector. Provides a uniform interface for compile-time and run-time vectors.

This is the overload for a compile-time vector of size 2

default_numeric_type viennamath::get_from_vector	(	ct_vector_3< T1, T2, T3 > const &	vec,
		id_type	i
	)

Generic wrapper function for accessing the i-th entry of a vector. Provides a uniform interface for compile-time and run-time vectors.

This is the overload for a compile-time vector of size 3

rt_unary_expr<InterfaceType> viennamath::grad

(

rt_unary_expr< InterfaceType > const &

other

)

Overload of the gradient function for a ViennaMath runtime unary expression.

rt_unary_expr<InterfaceType> viennamath::grad

(

rt_function_symbol< InterfaceType > const &

other

)

Overload of the gradient function for a ViennaMath runtime function symbol.

void viennamath::inplace_simplify

(

rt_expr< InterfaceType > &

e

)

Simplifies an expression. Directly manipulates the provided expression.

void viennamath::inplace_simplify

(

rt_unary_expr< InterfaceType > &

e

)

Simplifies an expression. Directly manipulates the provided expression.

void viennamath::inplace_simplify

(

rt_binary_expr< InterfaceType > &

e

)

Simplifies an expression. Directly manipulates the provided expression.

void viennamath::inplace_simplify

(

T &

e

)

Simplifies an expression. Directly manipulates the provided expression.

rt_expr<InterfaceType> viennamath::integral	(	rt_interval< InterfaceType > const &	interv,
		rt_expr< InterfaceType > const &	integrand,
		rt_variable< InterfaceType > const &	var
	)

Creates an expression encoding the integral of an expression with respect to a runtime variable over a certain interval.

rt_expr<InterfaceType> viennamath::integral	(	rt_interval< InterfaceType > const &	interv,
		rt_expr< InterfaceType > const &	integrand,
		ct_variable< id > const &	var
	)

Creates an expression encoding the integral of an expression with respect to a compiletime variable over a certain interval.

rt_expr<InterfaceType> viennamath::integral	(	rt_interval< InterfaceType > const &	interv,
		rt_binary_expr< InterfaceType > const &	integrand,
		ct_variable< id > const &	var
	)

Creates an expression encoding the integral of a binary expression with respect to a compiletime variable over a certain interval.

rt_expr<InterfaceType> viennamath::integral	(	rt_symbolic_interval< InterfaceType > const &	interv,
		rt_expr< InterfaceType > const &	integrand
	)

Integral generator function taking a symbolic interval and a runtime expression wrapper for the integrand.

rt_expr<InterfaceType> viennamath::integral	(	rt_symbolic_interval< InterfaceType > const &	interv,
		rt_binary_expr< InterfaceType > const &	integrand
	)

Integral generator function taking a symbolic interval and a runtime binary expression for the integrand.

rt_expr<InterfaceType> viennamath::integral	(	rt_symbolic_interval< InterfaceType > const &	interv,
		rt_unary_expr< InterfaceType > const &	integrand
	)

Integral generator function taking a symbolic interval and a runtime unary expression for the integrand.

rt_expr<InterfaceType> viennamath::integral	(	rt_symbolic_interval< InterfaceType > const &	interv,
		rt_variable< InterfaceType > const &	integrand
	)

Integral generator function taking a symbolic interval and a ViennaMath runtime variable for the integrand.

rt_expr<InterfaceType> viennamath::integral	(	rt_symbolic_interval< InterfaceType > const &	interv,
		rt_function_symbol< InterfaceType > const &	integrand
	)

Integral generator function taking a symbolic interval and a ViennaMath runtime function symbol for the integrand.

rt_expr<InterfaceType> viennamath::integral	(	rt_symbolic_interval< InterfaceType > const &	interv,
		rt_constant< T, InterfaceType > const &	integrand
	)

Integral generator function taking a symbolic interval and a ViennaMath runtime constant for the integrand.

result_of::integrate<LowerBound, UpperBound, IntegrandType, VariableType>::type viennamath::integrate	(	ct_interval< LowerBound, UpperBound > const &	interv,
		IntegrandType const &	integrand,
		VariableType const &	var
	)

The user function for the compile time integration of a compile time expression.

Parameters:

	interv	The compiletime integration interval
	integrand	A compiletime integrand
	var	A compiletime variable

rt_unary_expr<InterfaceType> viennamath::laplace

(

rt_expr< InterfaceType > const &

other

)

For convenience, the Laplace operator (divergence of the gradient) is provided as a separate function.

rt_unary_expr<InterfaceType> viennamath::laplace

(

rt_function_symbol< InterfaceType > const &

other

)

For convenience, the Laplace operator (divergence of the gradient) is provided as a separate function.

rt_unary_expr<InterfaceType> viennamath::log

(

rt_constant< NumericT, InterfaceType > const &

other

)

Overload of the natural logarithm function for a ViennaMath runtime constant.

rt_unary_expr<InterfaceType> viennamath::log

(

rt_variable< InterfaceType > const &

other

)

Overload of the natural logarithm function for a ViennaMath runtime variable.

rt_unary_expr viennamath::log

(

ct_variable< id > const &

other

)

Overload of the natural logarithm function for a ViennaMath compiletime variable.

rt_unary_expr viennamath::log

(

ct_binary_expr< LHS, OP, RHS > const &

other

)

Overload of the natural logarithm function for a ViennaMath compiletime binary expression.

rt_unary_expr viennamath::log

(

ct_unary_expr< LHS, OP > const &

other

)

Overload of the natural logarithm function for a ViennaMath compiletime unary expression.

rt_unary_expr<InterfaceType> viennamath::log

(

rt_unary_expr< InterfaceType > const &

other

)

Overload of the natural logarithm function for a ViennaMath runtime unary expression.

rt_unary_expr<InterfaceType> viennamath::log

(

rt_binary_expr< InterfaceType > const &

other

)

Overload of the natural logarithm function for a ViennaMath runtime binary expression.

rt_unary_expr<InterfaceType> viennamath::log

(

rt_expr< InterfaceType > const &

other

)

Overload of the natural logarithm function for a ViennaMath runtime expression wrapper.

rt_unary_expr<InterfaceType> viennamath::log10

(

rt_constant< NumericT, InterfaceType > const &

other

)

Overload of the logarithm with base 10 for a ViennaMath runtime constant.

rt_unary_expr<InterfaceType> viennamath::log10

(

rt_variable< InterfaceType > const &

other

)

Overload of the logarithm with base 10 for a ViennaMath runtime variable.

rt_unary_expr viennamath::log10

(

ct_variable< id > const &

other

)

Overload of the logarithm with base 10 for a ViennaMath compiletime variable.

rt_unary_expr viennamath::log10

(

ct_binary_expr< LHS, OP, RHS > const &

other

)

Overload of the logarithm with base 10 for a ViennaMath compiletime binary expression.

rt_unary_expr viennamath::log10

(

ct_unary_expr< LHS, OP > const &

other

)

Overload of the logarithm with base 10 for a ViennaMath compiletime unary expression.

rt_unary_expr<InterfaceType> viennamath::log10

(

rt_unary_expr< InterfaceType > const &

other

)

Overload of the logarithm with base 10 for a ViennaMath runtime unary expression.

rt_unary_expr<InterfaceType> viennamath::log10

(

rt_binary_expr< InterfaceType > const &

other

)

Overload of the logarithm with base 10 for a ViennaMath runtime binary expression.

rt_unary_expr<InterfaceType> viennamath::log10

(

rt_expr< InterfaceType > const &

other

)

Overload of the logarithm with base 10 for a ViennaMath runtime expression wrapper.

rt_equation viennamath::make_equation	(	default_numeric_type	lhs,
		ct_variable< id > const &	rhs
	)

Generator for an equation with a (floating point) constant as left hand side and a ViennaMath compiletime variable as right hand side.

rt_equation<InterfaceType> viennamath::make_equation	(	typename InterfaceType::numeric_type	lhs,
		rt_unary_expr< InterfaceType > const &	rhs
	)

Generator for an equation with a (floating point) constant as left hand side and a ViennaMath runtime unary expression as right hand side.

rt_equation<InterfaceType> viennamath::make_equation	(	typename InterfaceType::numeric_type	lhs,
		rt_binary_expr< InterfaceType > const &	rhs
	)

Generator for an equation with a (floating point) constant as left hand side and a ViennaMath runtime binary expression as right hand side.

rt_equation<InterfaceType> viennamath::make_equation	(	typename InterfaceType::numeric_type	lhs,
		rt_expr< InterfaceType > const &	rhs
	)

Generator for an equation with a (floating point) constant as left hand side and a ViennaMath runtime expression wrapper as right hand side.

rt_equation<InterfaceType> viennamath::make_equation	(	rt_constant< NumericT, InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath runtime constant as left hand side.

rt_equation<InterfaceType> viennamath::make_equation	(	rt_variable< InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath runtime variable as left hand side.

rt_equation<InterfaceType> viennamath::make_equation	(	rt_function_symbol< InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath runtime function symbol as left hand side.

ct_equation<ct_binary_expr<LHS1, OP1, RHS1>, ct_variable<id> > viennamath::make_equation	(	ct_binary_expr< LHS1, OP1, RHS1 > const &	lhs,
		ct_variable< id > const &	rhs
	)

Generates an equation from a binary expressions and a variable at compiletime.

rt_equation<InterfaceType> viennamath::make_equation	(	rt_binary_expr< InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath runtime binary expression as left hand side.

rt_equation<InterfaceType> viennamath::make_equation	(	rt_expr< InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath runtime expression wrapper as left hand side.

rt_equation viennamath::make_equation	(	ct_binary_expr< LHS, OP, RHS > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath compiletime binary expression as left hand side.

ct_equation<ct_constant<value1>, ct_constant<value2> > viennamath::make_equation	(	ct_constant< value1 > const &	lhs,
		ct_constant< value2 > const &	rhs
	)

Generates an equation from two constants at compiletime.

rt_equation viennamath::make_equation	(	ct_constant< val > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath compiletime constant as left hand side.

rt_equation viennamath::make_equation	(	ct_variable< id > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath compiletime variable as left hand side.

ct_equation<ct_constant<value1>, ct_function_symbol<TAG> > viennamath::make_equation	(	ct_constant< value1 > const &	lhs,
		ct_function_symbol< TAG > const &	rhs
	)

Generates an equation from a constant and a function symbol at compiletime.

ct_equation<ct_unary_expr<LHS1, OP1>, ct_binary_expr<LHS2, OP2, RHS2> > viennamath::make_equation	(	ct_unary_expr< LHS1, OP1 > const &	lhs,
		ct_binary_expr< LHS2, OP2, RHS2 > const &	rhs
	)

Generates an equation from a unary expressions and a binary expression at compiletime.

ct_equation<ct_constant<value1>, ct_variable<id> > viennamath::make_equation	(	ct_constant< value1 > const &	lhs,
		ct_variable< id > const &	rhs
	)

Generates an equation from a constant and a variable at compiletime.

ct_equation<ct_function_symbol<TAG>, ct_binary_expr<LHS2, OP2, RHS2> > viennamath::make_equation	(	ct_function_symbol< TAG > const &	lhs,
		ct_binary_expr< LHS2, OP2, RHS2 > const &	rhs
	)

Generates an equation from a function symbol and a binary expression at compiletime.

ct_equation<ct_function_symbol<TAG>, ct_unary_expr<LHS2, OP2> > viennamath::make_equation	(	ct_function_symbol< TAG > const &	lhs,
		ct_unary_expr< LHS2, OP2 > const &	rhs
	)

Generates an equation from a function symbol and a unary expression at compiletime.

ct_equation<ct_function_symbol<TAG>, ct_constant<value> > viennamath::make_equation	(	ct_function_symbol< TAG > const &	lhs,
		ct_constant< value > const &	rhs
	)

Generates an equation from a function symbol and a constant at compiletime.

ct_equation<ct_function_symbol<TAG1>, ct_function_symbol<TAG2> > viennamath::make_equation	(	ct_function_symbol< TAG1 > const &	lhs,
		ct_function_symbol< TAG2 > const &	rhs
	)

Generates an equation from two function symbols at compiletime.

ct_equation<ct_binary_expr<LHS1, OP1, RHS1>, ct_binary_expr<LHS2, OP2, RHS2> > viennamath::make_equation	(	ct_binary_expr< LHS1, OP1, RHS1 > const &	lhs,
		ct_binary_expr< LHS2, OP2, RHS2 > const &	rhs
	)

Generates an equation from two binary expressions at compiletime.

ct_equation<ct_unary_expr<LHS1, OP1>, ct_constant<value> > viennamath::make_equation	(	ct_unary_expr< LHS1, OP1 > const &	lhs,
		ct_constant< value > const &	rhs
	)

Generates an equation from a unary expressions and a constant at compiletime.

ct_equation<ct_function_symbol<TAG>, ct_variable<id> > viennamath::make_equation	(	ct_function_symbol< TAG > const &	lhs,
		ct_variable< id > const &	rhs
	)

Generates an equation from a function symbol and a variable at compiletime.

ct_equation<ct_binary_expr<LHS1, OP1, RHS1>, ct_unary_expr<LHS2, OP2> > viennamath::make_equation	(	ct_binary_expr< LHS1, OP1, RHS1 > const &	lhs,
		ct_unary_expr< LHS2, OP2 > const &	rhs
	)

Generates an equation from a binary expressions and a unary expression at compiletime.

ct_equation<ct_unary_expr<LHS1, OP1>, ct_unary_expr<LHS2, OP2> > viennamath::make_equation	(	ct_unary_expr< LHS1, OP1 > const &	lhs,
		ct_unary_expr< LHS2, OP2 > const &	rhs
	)

Generates an equation from two unary expressions at compiletime.

ct_equation<ct_variable<id1>, ct_binary_expr<LHS2, OP2, RHS2> > viennamath::make_equation	(	ct_variable< id1 > const &	lhs,
		ct_binary_expr< LHS2, OP2, RHS2 > const &	rhs
	)

Generates an equation from a variable and a binary expression at compiletime.

ct_equation<ct_binary_expr<LHS1, OP1, RHS1>, ct_constant<value> > viennamath::make_equation	(	ct_binary_expr< LHS1, OP1, RHS1 > const &	lhs,
		ct_constant< value > const &	rhs
	)

Generates an equation from a binary expressions and a constant at compiletime.

ct_equation<ct_unary_expr<LHS1, OP1>, ct_function_symbol<TAG> > viennamath::make_equation	(	ct_unary_expr< LHS1, OP1 > const &	lhs,
		ct_function_symbol< TAG > const &	rhs
	)

Generates an equation from a unary expressions and a function symbol at compiletime.

ct_equation<ct_variable<id1>, ct_unary_expr<LHS2, OP2> > viennamath::make_equation	(	ct_variable< id1 > const &	lhs,
		ct_unary_expr< LHS2, OP2 > const &	rhs
	)

Generates an equation from a variable and a unary expression at compiletime.

ct_equation<ct_variable<id1>, ct_constant<value2> > viennamath::make_equation	(	ct_variable< id1 > const &	lhs,
		ct_constant< value2 > const &	rhs
	)

Generates an equation from a variable and a constant at compiletime.

ct_equation<ct_unary_expr<LHS1, OP1>, ct_variable<id> > viennamath::make_equation	(	ct_unary_expr< LHS1, OP1 > const &	lhs,
		ct_variable< id > const &	rhs
	)

Generates an equation from a unary expressions and a variable at compiletime.

rt_equation viennamath::make_equation	(	ct_unary_expr< LHS, OP > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath compiletime unary expression as left hand side.

ct_equation<ct_variable<id1>, ct_function_symbol<TAG> > viennamath::make_equation	(	ct_variable< id1 > const &	lhs,
		ct_function_symbol< TAG > const &	rhs
	)

Generates an equation from a variable and a function symbol at compiletime.

rt_equation viennamath::make_equation	(	ct_function_symbol< TAG > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath compiletime function symbol as left hand side.

rt_equation<InterfaceType> viennamath::make_equation	(	rt_unary_expr< InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Generator for an equation with a ViennaMath runtime unary expression as left hand side.

ct_equation<ct_variable<id1>, ct_variable<id2> > viennamath::make_equation	(	ct_variable< id1 > const &	lhs,
		ct_variable< id2 > const &	rhs
	)

Generates an equation from two variables at compiletime.

ct_equation<ct_binary_expr<LHS1, OP1, RHS1>, ct_function_symbol<TAG> > viennamath::make_equation	(	ct_binary_expr< LHS1, OP1, RHS1 > const &	lhs,
		ct_function_symbol< TAG > const &	rhs
	)

Generates an equation from a binary expressions and a function symbol at compiletime.

ct_equation<ct_constant<value1>, ct_binary_expr<LHS2, OP2, RHS2> > viennamath::make_equation	(	ct_constant< value1 > const &	lhs,
		ct_binary_expr< LHS2, OP2, RHS2 > const &	rhs
	)

Generates an equation from a constant and a binary expression at compiletime.

ct_equation<ct_constant<value1>, ct_unary_expr<LHS2, OP2> > viennamath::make_equation	(	ct_constant< value1 > const &	lhs,
		ct_unary_expr< LHS2, OP2 > const &	rhs
	)

Generates an equation from a constant and a unary expression at compiletime.

rt_equation<InterfaceType> viennamath::make_equation	(	typename InterfaceType::numeric_type	lhs,
		rt_constant< NumericT, InterfaceType > const &	rhs
	)

Generator for an equation with a (floating point) constant as left hand side and a ViennaMath runtime constant as right hand side.

rt_equation<InterfaceType> viennamath::make_equation	(	typename InterfaceType::numeric_type	lhs,
		rt_variable< InterfaceType > const &	rhs
	)

Generator for an equation with a (floating point) constant as left hand side and a ViennaMath runtime variable as right hand side.

rt_interval<InterfaceType> viennamath::make_interval	(	typename InterfaceType::numeric_type	lhs,
		rt_unary_expr< InterfaceType > const &	rhs
	)

Creates an interval, where the upper bound is given by a ViennaMath unary expression.

ct_interval<ct_binary_expr<LHS1, OP1, RHS1>, ct_constant<value> > viennamath::make_interval	(	ct_binary_expr< LHS1, OP1, RHS1 > const &	lhs,
		ct_constant< value > const &	rhs
	)

Generates an interval from a binary expression and a constant at compiletime.

ct_interval<ct_binary_expr<LHS1, OP1, RHS1>, ct_function_symbol<TAG> > viennamath::make_interval	(	ct_binary_expr< LHS1, OP1, RHS1 > const &	lhs,
		ct_function_symbol< TAG > const &	rhs
	)

Generates an interval from a binary expression and a function symbol at compiletime.

ct_interval<ct_binary_expr<LHS1, OP1, RHS1>, ct_variable<id> > viennamath::make_interval	(	ct_binary_expr< LHS1, OP1, RHS1 > const &	lhs,
		ct_variable< id > const &	rhs
	)

Generates an interval from a binary expression and a variable at compiletime.

rt_interval<InterfaceType> viennamath::make_interval	(	typename InterfaceType::numeric_type	lhs,
		rt_constant< NumericT, InterfaceType > const &	rhs
	)

Creates an interval, where the upper bound is given by a ViennaMath constant.

rt_interval<InterfaceType> viennamath::make_interval	(	typename InterfaceType::numeric_type	lhs,
		rt_variable< InterfaceType > const &	rhs
	)

Creates an interval, where the upper bound is given by a ViennaMath runtime variable.

rt_interval viennamath::make_interval	(	default_numeric_type	lhs,
		ct_variable< id > const &	rhs
	)

Creates an interval, where the upper bound is given by a ViennaMath compiletime variable.

ct_interval<ct_unary_expr<LHS1, OP1>, ct_binary_expr<LHS2, OP2, RHS2> > viennamath::make_interval	(	ct_unary_expr< LHS1, OP1 > const &	lhs,
		ct_binary_expr< LHS2, OP2, RHS2 > const &	rhs
	)

Generates an interval from a unary expression and a binary expression at compiletime.

rt_interval<typename RHSType::interface_type> viennamath::make_interval	(	ct_function_symbol< TAG > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath compiletime function symbol.

rt_interval<typename RHSType::interface_type> viennamath::make_interval	(	ct_unary_expr< LHS, OP > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath compiletime unary expression.

rt_interval<InterfaceType> viennamath::make_interval	(	typename InterfaceType::numeric_type	lhs,
		rt_binary_expr< InterfaceType > const &	rhs
	)

Creates an interval, where the upper bound is given by a ViennaMath binary expression.

rt_interval<InterfaceType> viennamath::make_interval	(	typename InterfaceType::numeric_type	lhs,
		rt_expr< InterfaceType > const &	rhs
	)

Creates an interval, where the upper bound is given by a ViennaMath expression wrapper.

rt_interval<InterfaceType> viennamath::make_interval	(	rt_constant< NumericT, InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath runtime constant.

rt_interval< typename RHSType::interface_type > make_interval	(	ct_variable< id > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath compiletime variable.

rt_interval<InterfaceType> viennamath::make_interval	(	rt_function_symbol< InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath runtime function symbol.

rt_interval<InterfaceType> viennamath::make_interval	(	rt_unary_expr< InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath runtime unary expression.

rt_interval<InterfaceType> viennamath::make_interval	(	rt_expr< InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath runtime expression wrapper.

rt_interval<typename RHSType::interface_type> viennamath::make_interval	(	ct_binary_expr< LHS, OP, RHS > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath compiletime binary expression.

ct_interval<ct_unary_expr<LHS1, OP1>, ct_unary_expr<LHS2, OP2> > viennamath::make_interval	(	ct_unary_expr< LHS1, OP1 > const &	lhs,
		ct_unary_expr< LHS2, OP2 > const &	rhs
	)

Generates an interval from two unary expressions at compiletime.

ct_interval<ct_unary_expr<LHS1, OP1>, ct_constant<value> > viennamath::make_interval	(	ct_unary_expr< LHS1, OP1 > const &	lhs,
		ct_constant< value > const &	rhs
	)

Generates an interval from a unary expression and a constant at compiletime.

rt_interval<InterfaceType> viennamath::make_interval	(	rt_variable< InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath runtime variable.

ct_interval<ct_unary_expr<LHS1, OP1>, ct_function_symbol<TAG> > viennamath::make_interval	(	ct_unary_expr< LHS1, OP1 > const &	lhs,
		ct_function_symbol< TAG > const &	rhs
	)

Generates an interval from a unary expression and a function symbol at compiletime.

ct_interval<ct_unary_expr<LHS1, OP1>, ct_variable<id> > viennamath::make_interval	(	ct_unary_expr< LHS1, OP1 > const &	lhs,
		ct_variable< id > const &	rhs
	)

Generates an interval from a unary expression and a variable at compiletime.

ct_interval<ct_constant<value1>, ct_binary_expr<LHS2, OP2, RHS2> > viennamath::make_interval	(	ct_constant< value1 > const &	lhs,
		ct_binary_expr< LHS2, OP2, RHS2 > const &	rhs
	)

Generates an interval from a constant and a binary expression at compiletime.

ct_interval<ct_constant<value1>, ct_unary_expr<LHS2, OP2> > viennamath::make_interval	(	ct_constant< value1 > const &	lhs,
		ct_unary_expr< LHS2, OP2 > const &	rhs
	)

Generates an interval from a constant and a unary expression at compiletime.

ct_interval<ct_constant<value1>, ct_constant<value2> > viennamath::make_interval	(	ct_constant< value1 > const &	lhs,
		ct_constant< value2 > const &	rhs
	)

Generates an interval from two constants at compiletime.

ct_interval<ct_constant<value1>, ct_function_symbol<TAG> > viennamath::make_interval	(	ct_constant< value1 > const &	lhs,
		ct_function_symbol< TAG > const &	rhs
	)

Generates an interval from a constant and a function symbol at compiletime.

ct_interval<ct_constant<value1>, ct_variable<id> > viennamath::make_interval	(	ct_constant< value1 > const &	lhs,
		ct_variable< id > const &	rhs
	)

Generates an interval from a constant and a variable at compiletime.

ct_interval<ct_function_symbol<TAG>, ct_binary_expr<LHS2, OP2, RHS2> > viennamath::make_interval	(	ct_function_symbol< TAG > const &	lhs,
		ct_binary_expr< LHS2, OP2, RHS2 > const &	rhs
	)

Generates an interval from a function symbol and a binary expression at compiletime.

ct_interval<ct_function_symbol<TAG>, ct_unary_expr<LHS2, OP2> > viennamath::make_interval	(	ct_function_symbol< TAG > const &	lhs,
		ct_unary_expr< LHS2, OP2 > const &	rhs
	)

Generates an interval from a function symbol and a unary expression at compiletime.

ct_interval<ct_function_symbol<TAG>, ct_constant<value> > viennamath::make_interval	(	ct_function_symbol< TAG > const &	lhs,
		ct_constant< value > const &	rhs
	)

Generates an interval from a function symbol and a constant at compiletime.

rt_interval viennamath::make_interval	(	default_numeric_type	lhs,
		default_numeric_type	rhs
	)			[inline]

Creates an interval with two numerical limits.

ct_interval<ct_function_symbol<TAG1>, ct_function_symbol<TAG2> > viennamath::make_interval	(	ct_function_symbol< TAG1 > const &	lhs,
		ct_function_symbol< TAG2 > const &	rhs
	)

Generates an interval from two function symbols at compiletime.

rt_interval<typename RHSType::interface_type> viennamath::make_interval	(	ct_constant< val > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath compiletime constant.

ct_interval<ct_function_symbol<TAG>, ct_variable<id> > viennamath::make_interval	(	ct_function_symbol< TAG > const &	lhs,
		ct_variable< id > const &	rhs
	)

Generates an interval from a function symbol and a variable at compiletime.

ct_interval<ct_variable<id1>, ct_binary_expr<LHS2, OP2, RHS2> > viennamath::make_interval	(	ct_variable< id1 > const &	lhs,
		ct_binary_expr< LHS2, OP2, RHS2 > const &	rhs
	)

Generates an interval from a variable and a binary expression at compiletime.

ct_interval<ct_binary_expr<LHS1, OP1, RHS1>, ct_unary_expr<LHS2, OP2> > viennamath::make_interval	(	ct_binary_expr< LHS1, OP1, RHS1 > const &	lhs,
		ct_unary_expr< LHS2, OP2 > const &	rhs
	)

Generates an interval from a binary expression and a unary expression at compiletime.

ct_interval<ct_variable<id1>, ct_unary_expr<LHS2, OP2> > viennamath::make_interval	(	ct_variable< id1 > const &	lhs,
		ct_unary_expr< LHS2, OP2 > const &	rhs
	)

Generates an interval from a variable and a unary expression at compiletime.

ct_interval<ct_variable<id1>, ct_constant<value2> > viennamath::make_interval	(	ct_variable< id1 > const &	lhs,
		ct_constant< value2 > const &	rhs
	)

Generates an interval from a variable and a constant at compiletime.

rt_interval<InterfaceType> viennamath::make_interval	(	rt_binary_expr< InterfaceType > const &	lhs,
		RHSType const &	rhs
	)

Creates an interval, where the lower bound is given by a ViennaMath runtime binary expression.

ct_interval<ct_variable<id1>, ct_function_symbol<TAG> > viennamath::make_interval	(	ct_variable< id1 > const &	lhs,
		ct_function_symbol< TAG > const &	rhs
	)

Generates an interval from a variable and a function symbol at compiletime.

ct_interval<ct_variable<id1>, ct_variable<id2> > viennamath::make_interval	(	ct_variable< id1 > const &	lhs,
		ct_variable< id2 > const &	rhs
	)

Generates an interval from two variables at compiletime.

ct_interval<ct_binary_expr<LHS1, OP1, RHS1>, ct_binary_expr<LHS2, OP2, RHS2> > viennamath::make_interval	(	ct_binary_expr< LHS1, OP1, RHS1 > const &	lhs,
		ct_binary_expr< LHS2, OP2, RHS2 > const &	rhs
	)

Generates an interval from two binary expressions at compiletime.

ct_vector_3<T0, T1, T2> viennamath::make_vector	(	T0 const &	t0,
		T1 const &	t1,
		T2 const &	t2
	)

Helper function for creating a compiletime vector with three elements.

ct_vector_1<T0> viennamath::make_vector

(

T0 const &

t0

)

Helper function for creating a compiletime vector with one element.

ct_vector_2<T0, T1> viennamath::make_vector	(	T0 const &	t0,
		T1 const &	t1
	)

Helper function for creating a compiletime vector with two elements.

rt_binary_expr<InterfaceType> viennamath::operator*	(	rt_expr< InterfaceType > const &	lhs,
		rt_function_symbol< InterfaceType > const &	rhs
	)

Special overload for the multiplication of a function symbol with a ViennaMath runtime expression wrapper.

rt_vector_expr<InterfaceType> viennamath::operator*	(	rt_vector_expr< InterfaceType > const &	lhs,
		T const &	rhs
	)

rt_vector_expr<InterfaceType> viennamath::operator*	(	T const &	lhs,
		rt_vector_expr< InterfaceType > const &	rhs
	)

rt_expr<InterfaceType> viennamath::operator*	(	rt_vector_expr< InterfaceType > const &	lhs,
		rt_vector_expr< InterfaceType > const &	rhs
	)

enable_if< result_of::is_viennamath<LHS>::value || result_of::is_viennamath<RHS>::value, typename result_of::mult<LHS, RHS>::type >::type viennamath::operator*	(	LHS const &	lhs,
		RHS const &	rhs
	)

Generic overload of the multiplication operator for ViennaMath types. Uses SFINAE to control the scope, otherwise one may run into very tricky problems with operator* being considered outside the viennamath namespace.

rt_binary_expr<InterfaceType> viennamath::operator*	(	rt_constant< NumericT, InterfaceType > const &	lhs,
		rt_function_symbol< InterfaceType > const &	rhs
	)

Special overload for the multiplication of a function symbol with a ViennaMath runtime constant.

ct_constant<value * other_value> viennamath::operator*	(	ct_constant< value > const &	lhs,
		ct_constant< other_value > const &	other
	)

Special overload: Condense multiplication of two compiletime constants into one constant.

ct_binary_expr< rt_constant<typename promote_traits<OtherScalarType, op_plus<ScalarType>, long>::result_type >, op_minus<ScalarType>, RHS > viennamath::operator+	(	ct_binary_expr< rt_constant< OtherScalarType >, op_minus< ScalarType >, RHS > const &	lhs,
		ct_constant< value > const &	other
	)

Special overload: (c1 - X) + ct_c2 -> [c1 + ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_binary_expr<rt_constant< typename promote_traits<long, op_plus<default_numeric_type>, ScalarType>::result_type >, op_plus<default_numeric_type>, RHS > viennamath::operator+	(	ct_constant< value > const &	lhs,
		ct_binary_expr< rt_constant< ScalarType >, op_plus< default_numeric_type >, RHS > const &	other
	)

Special overload: ct_c1 + (c2 + X) -> [ct_c1 + c2] + X, where ct_c1 is a compiletime constant, c2 is a runtime constant, and X is any other expression.

ct_constant<value + other_value> viennamath::operator+	(	ct_constant< value > const &	lhs,
		ct_constant< other_value > const &	other
	)

Special overload: Condense addition of two compiletime constants into one constant.

ct_binary_expr< rt_constant<typename promote_traits<long, op_plus<T>, ScalarType>::result_type >, op_plus<T>, RHS > viennamath::operator+	(	ct_binary_expr< ct_constant< value >, op_plus< T >, RHS > const &	lhs,
		rt_constant< ScalarType, InterfaceType > const &	other
	)

Special overload for (ct_c1 + X) + c2 -> [ct_c1 + c2] + X, where ct_c1 is a compile constant, c2 is a runtime constant, and X is any expression:

ct_binary_expr< rt_constant<default_numeric_type, InterfaceType >, op_minus<default_numeric_type>, RHS > viennamath::operator+	(	ct_binary_expr< ct_constant< value >, op_minus< default_numeric_type >, RHS > const &	lhs,
		rt_constant< ScalarType, InterfaceType > const &	other
	)

Special overload for (ct_c1 - X) + c2 -> [ct_c1 + c2] - X, where ct_c1 is a compile constant, c2 is a runtime constant, and X is any expression:

ct_binary_expr<ct_constant< value_1 + value_2 >, op_plus<ScalarType>, RHS > viennamath::operator+	(	ct_binary_expr< ct_constant< value_1 >, op_plus< ScalarType >, RHS > const &	lhs,
		ct_constant< value_2 > const &	other
	)

Special overload: (ct_c1 + X) + ct_c2 becomes [ct_c1 + ct_c2] + X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_binary_expr<ct_constant< value_1 + value_2 >, op_minus<ScalarType>, RHS > viennamath::operator+	(	ct_binary_expr< ct_constant< value_1 >, op_minus< ScalarType >, RHS > const &	lhs,
		ct_constant< value_2 > const &	other
	)

Special overload: (ct_c1 - X) + ct_c2 becomes [ct_c1 + ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_binary_expr<rt_constant<typename promote_traits<ScalarType, op_plus<typename InterfaceType::numeric_type>, long>::result_type, InterfaceType >, op_plus<typename InterfaceType::numeric_type>, RHS > viennamath::operator+	(	rt_constant< ScalarType, InterfaceType > const &	lhs,
		ct_binary_expr< ct_constant< value >, op_plus< typename InterfaceType::numeric_type >, RHS > const &	other
	)

Special overload for c1 + (ct_c2 + X) -> [c1 + ct_c2] + X, where c1 is a runtime constant, ct_c2 is a compiletime constant, and X is any expression:

ct_binary_expr<ct_constant<2>, op_mult<default_numeric_type>, ct_variable<id> > viennamath::operator+	(	ct_variable< id > const &	lhs,
		ct_variable< id > const &	other
	)

Special overload: x + x becomes 2*x.

ct_binary_expr<rt_constant<typename promote_traits<ScalarType, op_plus<typename InterfaceType::numeric_type>, OtherScalarType>::result_type, InterfaceType >, op_minus<typename InterfaceType::numeric_type>, RHS > viennamath::operator+	(	rt_constant< ScalarType, InterfaceType > const &	lhs,
		ct_binary_expr< rt_constant< OtherScalarType, InterfaceType >, op_minus< typename InterfaceType::numeric_type >, RHS > const &	other
	)

Special overload for c1 + (c2 - X) -> [c1 + c2] - X, where c1 and c2 are runtime constants and X is any expression:

enable_if< result_of::is_viennamath<LHS>::value || result_of::is_viennamath<RHS>::value, typename result_of::add<LHS, RHS>::type >::type viennamath::operator+	(	LHS const &	lhs,
		RHS const &	rhs
	)

Generic overload of the addition operator for ViennaMath types. Uses SFINAE to control the scope, otherwise one may run into very tricky problems with operator+ being considered outside the viennamath namespace.

ct_binary_expr<ct_constant<value + value2>, op_plus<default_numeric_type>, RHS > viennamath::operator+	(	ct_constant< value > const &	lhs,
		ct_binary_expr< ct_constant< value2 >, op_plus< default_numeric_type >, RHS > const &	other
	)

Special overload: ct_c1 + (ct_c2 + X) -> [ct_c1 + ct_c2] + X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_binary_expr<ct_constant<value + value2>, op_minus<default_numeric_type>, RHS > viennamath::operator+	(	ct_constant< value > const &	lhs,
		ct_binary_expr< ct_constant< value2 >, op_minus< default_numeric_type >, RHS > const &	other
	)

Special overload: ct_c1 + (ct_c2 - X) -> [ct_c1 + ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_binary_expr<rt_constant<typename promote_traits<ScalarType, op_plus<typename InterfaceType::numeric_type>, long>::result_type, InterfaceType >, op_minus<typename InterfaceType::numeric_type>, RHS > viennamath::operator+	(	rt_constant< ScalarType, InterfaceType > const &	lhs,
		ct_binary_expr< ct_constant< value >, op_minus< typename InterfaceType::numeric_type >, RHS > const &	other
	)

Special overload for c1 + (ct_c2 - X) -> [c1 + ct_c2] - X, where c1 is a runtime constant, ct_c2 is a compiletime constant, and X is any expression:

ct_binary_expr<rt_constant<typename promote_traits<ScalarType, op_plus<typename InterfaceType::numeric_type>, OtherScalarType>::result_type, InterfaceType >, op_plus<typename InterfaceType::numeric_type>, RHS > viennamath::operator+	(	rt_constant< ScalarType, InterfaceType > const &	lhs,
		ct_binary_expr< rt_constant< OtherScalarType, InterfaceType >, op_plus< typename InterfaceType::numeric_type >, RHS > const &	other
	)

Special overload for c1 + (c2 + X) -> [c1 + c2] + X, where c1 and c2 are runtime constants and X is any expression:

ct_binary_expr<rt_constant< typename promote_traits<long, op_plus<default_numeric_type>, ScalarType>::result_type >, op_minus<default_numeric_type>, RHS > viennamath::operator+	(	ct_constant< value > const &	lhs,
		ct_binary_expr< rt_constant< ScalarType >, op_minus< default_numeric_type >, RHS > const &	other
	)

Special overload: ct_c1 + (c2 - X) -> [ct_c1 + c2] - X, where ct_c1 is a compiletime constant, c2 is a runtime constant, and X is any other expression.

ct_binary_expr< rt_constant<typename promote_traits<OtherScalarType, op_plus<T>, long>::result_type >, op_plus<T>, RHS > viennamath::operator-	(	ct_binary_expr< rt_constant< OtherScalarType >, op_plus< T >, RHS > const &	lhs,
		ct_constant< value > const &	other
	)

Special overload: (c1 + X) - ct_c2 -> [c1 - ct_c2] + X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_binary_expr<ct_constant<value - value2>, op_plus<default_numeric_type>, RHS > viennamath::operator-	(	ct_constant< value > const &	lhs,
		ct_binary_expr< ct_constant< value2 >, op_minus< default_numeric_type >, RHS > const &	other
	)

Special overload: ct_c1 - (ct_c2 - X) -> [ct_c1 - ct_c2] + X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_constant<value - other_value> viennamath::operator-	(	ct_constant< value > const &	lhs,
		ct_constant< other_value > const &	other
	)

Special overload: Condense subtraction of two compiletime constants into one constant.

ct_binary_expr<rt_constant<typename promote_traits<ScalarType, op_minus<typename InterfaceType::numeric_type>, long>::result_type, InterfaceType >, op_minus<typename InterfaceType::numeric_type>, RHS > viennamath::operator-	(	rt_constant< ScalarType, InterfaceType > const &	lhs,
		ct_binary_expr< ct_constant< value >, op_plus< typename InterfaceType::numeric_type >, RHS > const &	other
	)

Special overload for c1 - (ct_c2 + X) -> [c1 - ct_c2] - X, where c1 is a runtime constant, ct_c2 is a compiletime constant, and X is any expression:

ct_binary_expr<rt_constant<typename promote_traits<ScalarType, op_minus<typename InterfaceType::numeric_type>, OtherScalarType>::result_type, InterfaceType >, op_plus<typename InterfaceType::numeric_type>, RHS > viennamath::operator-	(	rt_constant< ScalarType, InterfaceType > const &	lhs,
		ct_binary_expr< rt_constant< OtherScalarType, InterfaceType >, op_minus< typename InterfaceType::numeric_type >, RHS > const &	other
	)

Special overload for c1 - (c2 - X) -> [c1 - c2] + X, where c1 and c2 are runtime constants and X is any expression:

ct_binary_expr< rt_constant<typename promote_traits<OtherScalarType, op_plus<T>, long>::result_type >, op_minus<T>, RHS > viennamath::operator-	(	ct_binary_expr< rt_constant< OtherScalarType >, op_minus< T >, RHS > const &	lhs,
		ct_constant< value > const &	other
	)

Special overload: (c1 - X) - ct_c2 -> [c1 - ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_constant<0> viennamath::operator-	(	ct_variable< id > const &	lhs,
		ct_variable< id > const &	other
	)

Special overload: x - x becomes 0.

enable_if< result_of::is_viennamath<LHS>::value || result_of::is_viennamath<RHS>::value, typename result_of::subtract<LHS, RHS>::type >::type viennamath::operator-	(	LHS const &	lhs,
		RHS const &	rhs
	)

Generic overload of the subtraction operator for ViennaMath types. Uses SFINAE to control the scope, otherwise one may run into very tricky problems with operator- being considered outside the viennamath namespace.

ct_binary_expr<ct_constant<value - value2>, op_minus<default_numeric_type>, RHS > viennamath::operator-	(	ct_constant< value > const &	lhs,
		ct_binary_expr< ct_constant< value2 >, op_plus< default_numeric_type >, RHS > const &	other
	)

Special overload: ct_c1 - (ct_c2 + X) -> [ct_c1 - ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_binary_expr<rt_constant< typename promote_traits<long, op_minus<default_numeric_type>, ScalarType>::result_type >, op_plus<default_numeric_type>, RHS > viennamath::operator-	(	ct_constant< value > const &	lhs,
		ct_binary_expr< rt_constant< ScalarType >, op_minus< default_numeric_type >, RHS > const &	other
	)

Special overload: ct_c1 - (c2 - X) -> [ct_c1 - c2] + X, where ct_c1 is a compiletime constant, c2 is a runtime constant, and X is any other expression.

ct_binary_expr< ct_constant< value_1 - value_2 >, op_plus<T>, RHS > viennamath::operator-	(	ct_binary_expr< ct_constant< value_1 >, op_plus< T >, RHS > const &	lhs,
		ct_constant< value_2 > const &	other
	)

Special overload: (ct_c1 + X) - ct_c2 -> [ct_c1 - ct_c2] + X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_binary_expr<rt_constant<typename promote_traits<ScalarType, op_minus<typename InterfaceType::numeric_type>, long>::result_type, InterfaceType >, op_plus<typename InterfaceType::numeric_type>, RHS > viennamath::operator-	(	rt_constant< ScalarType, InterfaceType > const &	lhs,
		ct_binary_expr< ct_constant< value >, op_minus< typename InterfaceType::numeric_type >, RHS > const &	other
	)

Special overload for c1 - (ct_c2 - X) -> [c1 - ct_c2] + X, where c1 is a runtime constant, ct_c2 is a compiletime constant, and X is any expression:

ct_binary_expr<rt_constant<typename promote_traits<ScalarType, op_minus<typename InterfaceType::numeric_type>, OtherScalarType>::result_type, InterfaceType >, op_minus<typename InterfaceType::numeric_type>, RHS > viennamath::operator-	(	rt_constant< ScalarType, InterfaceType > const &	lhs,
		ct_binary_expr< rt_constant< OtherScalarType, InterfaceType >, op_plus< typename InterfaceType::numeric_type >, RHS > const &	other
	)

Special overload for c1 - (c2 + X) -> [c1 - c2] - X, where c1 and c2 are runtime constants and X is any expression:

ct_binary_expr<rt_constant< typename promote_traits<long, op_minus<default_numeric_type>, ScalarType>::result_type >, op_minus<default_numeric_type>, RHS > viennamath::operator-	(	ct_constant< value > const &	lhs,
		ct_binary_expr< rt_constant< ScalarType >, op_plus< default_numeric_type >, RHS > const &	other
	)

Special overload: ct_c1 - (c2 + X) -> [ct_c1 - c2] - X, where ct_c1 is a compiletime constant, c2 is a runtime constant, and X is any other expression.

RHS viennamath::operator-	(	ct_binary_expr< ct_variable< id >, op_plus< ScalarType >, RHS > const &	lhs,
		ct_variable< id > const &	other
	)

Special overload: (A + B) - A -> B, where A is an variable and X can be anything.

ct_binary_expr< ct_constant< value_1 - value_2 >, op_minus<T>, RHS > viennamath::operator-	(	ct_binary_expr< ct_constant< value_1 >, op_minus< T >, RHS > const &	lhs,
		ct_constant< value_2 > const &	other
	)

Special overload: (ct_c1 - X) - ct_c2 -> [ct_c1 - ct_c2] - X, where ct_c1 and ct_c2 are compiletime constants and X is any other expression.

ct_constant<1> viennamath::operator/	(	ct_binary_expr< LHS, OP, RHS > const &	lhs,
		ct_binary_expr< LHS, OP, RHS > const &	other
	)

Special overload: division of the same thing leads to '1'.

ct_constant<1> viennamath::operator/	(	ct_variable< id > const &	lhs,
		ct_variable< id > const &	other
	)

Special overload: x / x becomes 1.

enable_if< result_of::is_viennamath<LHS>::value || result_of::is_viennamath<RHS>::value, typename result_of::div<LHS, RHS>::type >::type viennamath::operator/	(	LHS const &	lhs,
		RHS const &	rhs
	)

Generic overload of the division operator for ViennaMath types. Uses SFINAE to control the scope, otherwise one may run into very tricky problems with operator/ being considered outside the viennamath namespace.

rt_vector_expr<InterfaceType> viennamath::operator/	(	rt_vector_expr< InterfaceType > const &	lhs,
		T const &	rhs
	)

rt_vector_expr<InterfaceType> viennamath::operator/	(	T const &	lhs,
		rt_vector_expr< InterfaceType > const &	rhs
	)

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		rt_variable< InterfaceType > const &	u
	)

Output stream overload, mostly used for printing an expression to screen.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		rt_function_symbol< InterfaceType > const &	v
	)

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		rt_constant< ScalarType, InterfaceType > const &	c
	)

Convenience operator overload for streaming a runtime constant to std::cout or any other STL-compatible output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		rt_vector_expr< InterfaceType > const &	e
	)

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		rt_symbolic_interval< InterfaceType > const &	e
	)

Convenience overload for obtaining a string representation of a symbolic interval.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		ct_equation< LHS, RHS > const &	u
	)

Convenience overload for printing a compiletime equation to an output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		rt_unary_expr< InterfaceType > const &	e
	)

Overload of the stream operator in order to allow for a convenient conversion of a unary expression to a string.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		rt_expr< InterfaceType > const &	e
	)

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		rt_interval< InterfaceType > const &	e
	)

Convenience overload for streaming an interval to an output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		ct_vector_2< T0, T1 > const &	v
	)

Convenience functionality for printing a compiletime vector with two entries to an output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		ct_function_symbol< Tag > const &	v
	)

Convenience overload for printing a compiletime function symbol to an output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		rt_binary_expr< InterfaceType > const &	e
	)

Overload of the stream operator in order to allow for a convenient conversion of a unary expression to a string.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		rt_equation< InterfaceType > const &	e
	)

Convenience operator overload for streaming a runtime equation to std::cout or any other STL-compatible output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		ct_interval< LHS, RHS > const &	u
	)

Convenience overload for printing a compiletime interval to an output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		ct_constant< value_ > const &	c
	)

Convenience overload for printing a compiletime constant to an output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		ct_unary_expr< LHS, OP > const &	other
	)

Convenience overload for printing a compiletime unary expression to an output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		ct_variable< id > const &	u
	)

Convenience overload for printing a variable to an output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		ct_vector_1< T0 > const &	v
	)

Convenience functionality for printing a compiletime vector with one entry to an output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		ct_vector_3< T0, T1, T2 > const &	v
	)

Convenience functionality for printing a compiletime vector with three entries to an output stream.

std::ostream& viennamath::operator<<	(	std::ostream &	stream,
		ct_binary_expr< LHS, OP, RHS > const &	other
	)

Convenience overload for printing a compiletime binary expression to an output stream.

result_of::simplify<ExpressionType>::type viennamath::simplify

(

ExpressionType const &

e

)

The generic interface function for compiletime manipulations.

rt_expr<InterfaceType> viennamath::simplify

(

rt_expr< InterfaceType > const &

e

)

Returns a new, simplified expression.

rt_expr<InterfaceType> viennamath::simplify

(

rt_binary_expr< InterfaceType > const &

e

)

Returns a new, simplified expression.

T viennamath::simplify

(

T const &

e

)

Returns a new, simplified expression.

rt_expr<InterfaceType> viennamath::simplify

(

rt_unary_expr< InterfaceType > const &

e

)

Returns a new, simplified expression.

InterfaceType * simplify_impl	(	const InterfaceType *	lhs,
		op_div< NumericT >	,
		const InterfaceType *	rhs
	)

Implementation of the simplification procedures for an expression of the form e1 / e2.

InterfaceType * simplify_impl	(	const InterfaceType *	lhs,
		op_plus< NumericT >	,
		const InterfaceType *	rhs
	)

Implementation of the simplification procedures for an expression of the form e1 + e2.

InterfaceType * simplify_impl	(	const InterfaceType *	lhs,
		op_minus< NumericT >	,
		const InterfaceType *	rhs
	)

Implementation of the simplification procedures for an expression of the form e1 - e2.

InterfaceType * simplify_impl	(	const InterfaceType *	lhs,
		op_mult< NumericT >	,
		const InterfaceType *	rhs
	)

Implementation of the simplification procedures for an expression of the form e1 * e2.

rt_unary_expr<InterfaceType> viennamath::sin

(

rt_expr< InterfaceType > const &

other

)

Overload of the sine function for a ViennaMath runtime expression wrapper.

rt_unary_expr viennamath::sin

(

ct_variable< id > const &

other

)

Overload of the sine function for a ViennaMath compiletime variable.

rt_unary_expr<InterfaceType> viennamath::sin

(

rt_unary_expr< InterfaceType > const &

other

)

Overload of the sine function for a ViennaMath runtime unary expression.

rt_unary_expr<InterfaceType> viennamath::sin

(

rt_binary_expr< InterfaceType > const &

other

)

Overload of the sine function for a ViennaMath runtime binary expression.

rt_unary_expr<InterfaceType> viennamath::sin

(

rt_constant< NumericT, InterfaceType > const &

other

)

Overload of the sine function for a ViennaMath runtime constant.

rt_unary_expr viennamath::sin

(

ct_binary_expr< LHS, OP, RHS > const &

other

)

Overload of the sine function for a ViennaMath compiletime binary expression.

rt_unary_expr<InterfaceType> viennamath::sin

(

rt_variable< InterfaceType > const &

other

)

Overload of the sine function for a ViennaMath runtime variable.

rt_unary_expr viennamath::sin

(

ct_unary_expr< LHS, OP > const &

other

)

Overload of the sine function for a ViennaMath compiletime unary expression.

rt_unary_expr viennamath::sqrt

(

ct_variable< id > const &

other

)

Overload of the square-root function for a ViennaMath compiletime variable.

rt_unary_expr<InterfaceType> viennamath::sqrt

(

rt_unary_expr< InterfaceType > const &

other

)

Overload of the square-root function for a ViennaMath runtime unary expression.

rt_unary_expr<InterfaceType> viennamath::sqrt

(

rt_variable< InterfaceType > const &

other

)

Overload of the square-root function for a ViennaMath runtime variable.

rt_unary_expr<InterfaceType> viennamath::sqrt

(

rt_binary_expr< InterfaceType > const &

other

)

Overload of the square-root function for a ViennaMath runtime binary expression.

rt_unary_expr viennamath::sqrt

(

ct_binary_expr< LHS, OP, RHS > const &

other

)

Overload of the square-root function for a ViennaMath compiletime binary expression.

rt_unary_expr<InterfaceType> viennamath::sqrt

(

rt_expr< InterfaceType > const &

other

)

Overload of the square-root function for a ViennaMath runtime expression wrapper.

rt_unary_expr<InterfaceType> viennamath::sqrt

(

rt_constant< NumericT, InterfaceType > const &

other

)

Overload of the square-root function for a ViennaMath runtime constant.

rt_unary_expr viennamath::sqrt

(

ct_unary_expr< LHS, OP > const &

other

)

Overload of the square-root function for a ViennaMath compiletime unary expression.

rt_expr<InterfaceType> viennamath::substitute	(	rt_variable< InterfaceType > const &	u,
		default_numeric_type	repl,
		rt_expr< InterfaceType > const &	e
	)

Replaces all occurances of the variable 'u' in the expression 'e' with 'repl'.

rt_expr<InterfaceType> viennamath::substitute	(	rt_unary_expr< InterfaceType > const &	search,
		rt_expr< InterfaceType > const &	repl,
		rt_expr< InterfaceType > const &	e
	)

Replaces all occurances of the unary expression 'search' in the expression 'e' with 'repl'.

rt_expr<InterfaceType> viennamath::substitute	(	rt_function_symbol< InterfaceType > const &	u,
		rt_expr< InterfaceType > const &	repl,
		rt_expr< InterfaceType > const &	e
	)

Replaces all occurances of the function symbol 'u' in the expression 'e' with 'repl'.

result_of::substitute< SearchType, ReplacementType, ExpressionType>::type viennamath::substitute	(	SearchType const &	,
		ReplacementType const &	,
		ExpressionType const &	ex
	)

The generic interface function for compiletime substitution.

Template Parameters:

	SearchType	Type of the expression to be substituted
	ReplacementType	Type of the expression used as replacement
	ExpressionType	Type of the expression in which the substitution is carried out

rt_expr<InterfaceType> viennamath::substitute	(	rt_symbolic_interval< InterfaceType > const &	search,
		PairType const &	repl,
		rt_expr< InterfaceType > const &	e
	)

Substitutes a symbolic interval with a concrete interval.

Parameters:

	search	The symbolic interval to be replaced
	repl	A pair consisting of the integration interval and the integration variable. Must be interface compatible with std::pair<>.
	e	The expression on which the substitution is carried out

rt_expr<InterfaceType> viennamath::substitute	(	rt_variable< InterfaceType > const &	u,
		ReplacementType const &	repl,
		ExpressionType const &	e
	)

Replaces all occurances of the variable 'u' in the expression 'e' with 'repl'.

rt_expr<InterfaceType> viennamath::substitute	(	rt_variable< InterfaceType > const &	u,
		ReplacementType const &	repl,
		rt_expr< InterfaceType > const &	e
	)

Replaces all occurances of the variable 'u' in the expression 'e' with 'repl'.

rt_expr<InterfaceType> viennamath::substitute	(	std::vector< rt_expr< InterfaceType > > const &	search,
		std::vector< rt_expr< InterfaceType > > const &	repl,
		rt_expr< InterfaceType > const &	e
	)

Replaces all occurances of the the expressions in 'search' in the expression 'e' with the corresponding expressions in 'repl'.

rt_expr<InterfaceType> viennamath::substitute	(	rt_unary_expr< InterfaceType > const &	search,
		ReplacementType const &	repl,
		rt_expr< InterfaceType > const &	e
	)

Replaces all occurances of the unary expression 'search' in the expression 'e' with 'repl'.

rt_expr<InterfaceType> viennamath::substitute	(	rt_binary_expr< InterfaceType > const &	search,
		ReplacementType const &	repl,
		rt_expr< InterfaceType > const &	e
	)

Replaces all occurances of the binary expression 'search' in the expression 'e' with 'repl'.

rt_expr<InterfaceType> viennamath::substitute	(	rt_function_symbol< InterfaceType > const &	u,
		default_numeric_type	repl,
		rt_expr< InterfaceType > const &	e
	)

Replaces all occurances of the function symbol 'u' in the expression 'e' with 'repl'.

rt_expr<InterfaceType> viennamath::substitute	(	rt_expr< InterfaceType > const &	search,
		rt_expr< InterfaceType > const &	repl,
		rt_expr< InterfaceType > const &	e
	)

Replaces all occurances of the expression 'search' in the expression 'e' with 'repl'.

rt_unary_expr<InterfaceType> viennamath::tan

(

rt_binary_expr< InterfaceType > const &

other

)

Overload of the tangent function for a ViennaMath runtime binary expression.

rt_unary_expr<InterfaceType> viennamath::tan

(

rt_unary_expr< InterfaceType > const &

other

)

Overload of the tangent function for a ViennaMath runtime unary expression.

rt_unary_expr<InterfaceType> viennamath::tan

(

rt_constant< NumericT, InterfaceType > const &

other

)

Overload of the tangent function for a ViennaMath runtime constant.

rt_unary_expr<InterfaceType> viennamath::tan

(

rt_expr< InterfaceType > const &

other

)

Overload of the tangent function for a ViennaMath runtime expression wrapper.

rt_unary_expr<InterfaceType> viennamath::tan

(

rt_variable< InterfaceType > const &

other

)

Overload of the tangent function for a ViennaMath runtime variable.

rt_unary_expr viennamath::tan

(

ct_unary_expr< LHS, OP > const &

other

)

Overload of the tangent function for a ViennaMath compiletime unary expression.

rt_unary_expr viennamath::tan

(

ct_variable< id > const &

other

)

Overload of the tangent function for a ViennaMath compiletime variable.

rt_unary_expr viennamath::tan

(

ct_binary_expr< LHS, OP, RHS > const &

other

)

Overload of the tangent function for a ViennaMath compiletime binary expression.

bool viennamath::unary_op_equal	(	T const &	lhs,
		T const &	rhs
	)

Helper function returning true if the two arguments are of the same type.

bool viennamath::unary_op_equal	(	op_partial_deriv< T > const &	lhs,
		op_partial_deriv< T > const &	rhs
	)

Compares two partial derivatives for equality with respect to the differentiation variable.