| add< LHS, RHS, b1, b2 > | Returns the type of adding two expressions together. Default case: both types are runtime expressions |
| add< LHS, RHS, true, true > | Metafunction for adding two compiletime expressions |
| analytic_integration_not_supported_exception | Analytic integration at runtime not supported |
| callback_if_castable< CastToType > | A helper class which calls a provided functor if the supplied expression pointer can be cast to the target type |
| cartesian< dim > | A tag representing a Cartesian coordinate system in arbitrary dimensions |
| coefficient< FactorType, ExpressionType > | User metafunction for extracting the coefficient of a variable or sub-expression from an expression |
| coefficient_impl< FactorType, ExpressionType > | |
| coefficient_impl< FactorType, ct_binary_expr< FactorType, op_mult< NumericT >, FactorType > > | |
| coefficient_impl< FactorType, ct_binary_expr< FactorType, op_mult< NumericT >, RHS > > | |
| coefficient_impl< FactorType, ct_binary_expr< LHS, op_div< NumericT >, RHS > > | |
| coefficient_impl< FactorType, ct_binary_expr< LHS, op_minus< NumericT >, RHS > > | |
| coefficient_impl< FactorType, ct_binary_expr< LHS, op_mult< NumericT >, FactorType > > | |
| coefficient_impl< FactorType, ct_binary_expr< LHS, op_mult< NumericT >, RHS > > | |
| coefficient_impl< FactorType, ct_binary_expr< LHS, op_plus< NumericT >, RHS > > | |
| coefficient_impl< FactorType, FactorType > | |
| ct_binary_expr< LHS, OP, RHS > | A compile time expression consisting of two operands and one operation (taking two arguments) |
| ct_constant< value_ > | A compiletime constant |
| ct_equation< LHS, RHS > | A compile time equation |
| ct_function_symbol< Tag > | A function symbol. Can be used for unknown functions, test functions, etc. Cannot be evaluated, but substituted with an evaluable object |
| ct_index< i > | Compiletime respresentation of a vector access index |
| ct_interval< LHS, RHS > | A compile time interval |
| ct_unary_expr< LHS, OP > | Defines a unary expression f(e), where f is function and 'e' is an expression |
| ct_variable< id > | Representation of a mathematical variable. If the supplied argument is some vector type, a traits system accesses the id-th component |
| ct_vector_1< T0 > | Compiletime vector with one element |
| ct_vector_2< T0, T1 > | Compiletime vector with one element |
| ct_vector_3< T0, T1, T2 > | Compiletime vector with one element |
| diff< ARG, VAR > | Returns the type of the expression after differentiation of 'ARG' with respect to the variable 'VAR' |
| diff< ct_binary_expr< LHS, op_div< default_numeric_type >, RHS >, ct_variable< id > > | Specialization implementing the rule (u/v)' = (u'*v - u*v') / v^2 |
| diff< ct_binary_expr< LHS, op_minus< default_numeric_type >, RHS >, ct_variable< id > > | Specialization implementing the rule (u - v)' = u' - v' |
| diff< ct_binary_expr< LHS, op_mult< default_numeric_type >, RHS >, ct_variable< id > > | Specialization implementing the rule (u * v)' = u'*v + u*v' |
| diff< ct_binary_expr< LHS, op_plus< default_numeric_type >, RHS >, ct_variable< id > > | Specialization implementing the rule (u + v)' = u' + v' |
| diff< ct_constant< value >, ct_variable< id > > | Specialization: The derivative of a constant is zero |
| diff< ct_variable< id >, ct_variable< id > > | Specialization for (d x) / (d x) = 1 |
| diff< ct_variable< other_id >, ct_variable< id > > | Specialization of (d x_i) / (d x_j) for i != j |
| div< LHS, RHS, b1, b2 > | Returns the type when dividing two expressions. Default case: both types are runtime expressions |
| div< LHS, RHS, true, true > | Metafunction for dividing two compiletime expressions |
| drop_dependent_terms< FactorType, ExpressionType > | Interface metafunction for removing dependent terms from an expression |
| enable_if< b, T > | Simple enable-if variant that uses the SFINAE pattern |
| enable_if< false, T > | |
| eval< ExpressionType, VectorType, ct_evaluable > | Main metafunction for compiletime evaluation |
| eval< ct_binary_expr< LHS, OP, RHS >, VectorType, true > | Specialization for the evaluation of a binary expression at compile time |
| eval< ct_constant< value >, VectorType, true > | Specialization for the evaluation of a constant at compile time |
| eval< ct_variable< 0 >, ct_constant< value >, true > | Specialization for the evaluation of a variable at compile time |
| eval< ct_variable< id >, VectorType, true > | Specialization for the evaluation of a variable at compile time |
| expand< T > | The main metafunction for expanding a compiletime expression |
| expand< ct_binary_expr< LHS, op_div< NumericT >, RHS > > | Specialization for a binary expression (division): Expand numerator and denominator of fractional expressions separately |
| expand< ct_binary_expr< LHS, op_minus< NumericT >, RHS > > | Specialization for a binary expression (subtraction): Expand both operands |
| expand< ct_binary_expr< LHS, op_mult< NumericT >, RHS > > | Specialization for a binary expression (product): Redirect to helper metafunction |
| expand< ct_binary_expr< LHS, op_plus< NumericT >, RHS > > | Specialization for a binary expression (addition): Expand both addends |
| expand< ct_constant< value > > | A constant cannot be further expanded, thus it is returned unmodified |
| expand< ct_function_symbol< TAG > > | A function symbol cannot be further expanded, thus it is returned unmodified |
| expand< ct_unary_expr< LHS, OP > > | A unary expression is not expanded further, since the operator is typically nonlinear |
| expand< ct_variable< id > > | A variable cannot be further expanded, thus it is returned unmodified |
| expand_product< LHS, RHS, lhs_expandable, rhs_expandable > | |
| expand_product< LHS, RHS, false, true > | |
| expand_product< LHS, RHS, true, false > | |
| expand_product< LHS, RHS, true, true > | |
| expand_with_factor< ExpressionType, FactorType, needs_expansion > | |
| expand_with_factor< ct_binary_expr< LHS, op_div< NumericT >, RHS >, FactorType, true > | |
| expand_with_factor< ct_binary_expr< LHS, op_minus< NumericT >, RHS >, FactorType, true > | |
| expand_with_factor< ct_binary_expr< LHS, op_mult< NumericT >, RHS >, FactorType, true > | |
| expand_with_factor< ct_binary_expr< LHS, op_plus< NumericT >, RHS >, FactorType, true > | |
| 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) |
| 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) |
| 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) |
| expression_traits< T > | A traits system for expressions. For now provides a deduction of the const reference type only |
| 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 |
| 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 |
| extract_factor_from_product< FactorType, LHS, NumericT, RHS, lhs_has_factor, rhs_has_factor > | |
| extract_factor_from_product< FactorType, LHS, NumericT, RHS, false, true > | |
| extract_factor_from_product< FactorType, LHS, NumericT, RHS, true, false > | |
| extract_factor_from_product< FactorType, LHS, NumericT, RHS, true, true > | |
| gcd< a, b > | Helper metafunction for computing the greatest common divisor of two numbers |
| gcd< 0, 0 > | Specialization forcing a compile time error, since the greatest common divisor of 0 and 0 is not defined |
| gcd< a, 0 > | Specialization for the computation of the greatest common divisor of a and 0, which is a |
| has_factor< FactorType, ExpressionType > | |
| has_factor< FactorType, ct_binary_expr< LHS, op_div< NumericT >, RHS > > | |
| has_factor< FactorType, ct_binary_expr< LHS, op_minus< NumericT >, RHS > > | |
| has_factor< FactorType, ct_binary_expr< LHS, op_mult< NumericT >, RHS > > | |
| has_factor< FactorType, ct_binary_expr< LHS, op_plus< NumericT >, RHS > > | |
| has_factor< FactorType, FactorType > | |
| has_plus_or_minus< T > | |
| has_plus_or_minus< ct_binary_expr< LHS, op_div< NumericT >, RHS > > | |
| has_plus_or_minus< ct_binary_expr< LHS, op_minus< NumericT >, RHS > > | |
| has_plus_or_minus< ct_binary_expr< LHS, op_mult< NumericT >, RHS > > | |
| has_plus_or_minus< ct_binary_expr< LHS, op_plus< NumericT >, RHS > > | |
| integral_substitution_functor< InterfaceType > | |
| integrate< LowerBound, UpperBound, IntegrandType, VariableType > | The main metafunction for the integration of a compiletime expression |
| integrate< LowerBound, UpperBound, ct_binary_expr< LHS, OP, RHS >, VariableType > | Specialization for the integration of a compiletime binary expression |
| integrate< LowerBound, UpperBound, ct_constant< value >, VariableType > | Specialization for the integration of a compile time constant. Forwards the integration to the worker metafunction integrate_impl |
| integrate< LowerBound, UpperBound, ct_function_symbol< TAG >, VariableType > | Specialization for the integration of a compiletime function symbol. This is a user error, since a function symbol should have been replaced already by another expression. Thus, a compile time error is forced |
| integrate< LowerBound, UpperBound, ct_unary_expr< LHS, OP >, VariableType > | Specialization for the integration of a compiletime unary expression. Not supported at the moment, thus a compile time error is forced |
| integrate< LowerBound, UpperBound, ct_variable< id >, VariableType > | Specialization for the integration of a compile time variable. Forwards the integration to the worker metafunction integrate_impl |
| integrate_impl< LowerBound, UpperBound, IntegrandType, VariableType > | The worker metafunction for compile time integration. Each specialization represents an integration rule |
| integrate_impl< LowerBound, UpperBound, ct_binary_expr< LHS, op_div< NumericT >, RHS >, VariableType > | |
| integrate_impl< LowerBound, UpperBound, ct_binary_expr< LHS, op_minus< NumericT >, RHS >, VariableType > | |
| integrate_impl< LowerBound, UpperBound, ct_binary_expr< LHS, op_mult< NumericT >, RHS >, VariableType > | |
| integrate_impl< LowerBound, UpperBound, ct_binary_expr< LHS, op_plus< NumericT >, RHS >, VariableType > | |
| integrate_impl< LowerBound, UpperBound, ct_constant< value >, VariableType > | |
| integrate_impl< LowerBound, UpperBound, ct_function_symbol< TAG >, VariableType > | |
| integrate_impl< LowerBound, UpperBound, ct_unary_expr< LHS, OP >, VariableType > | |
| integrate_impl< LowerBound, UpperBound, ct_variable< id >, VariableType > | |
| integrate_monomial< VariableType, exponent > | Metafunction for the integration of a monomial consisting of a single variable |
| integrate_monomial< VariableType, 0 > | Specialization for the integration of a constant: Return the variable directly |
| integration_without_integral_exception | Exception for the case that an integration over expressions without integral is attempted |
| interface< LHS, RHS > | A metafunction deducing the ViennaMath runtime expression interface (base class) from two types. The first argument has priority |
| interface< default_numeric_type, rt_binary_expr< T > > | Specialization of the runtime expression interface deduction for a ViennaMath runtime binary expression |
| interface< default_numeric_type, rt_variable< T > > | Specialization of the runtime expression interface deduction for a ViennaMath runtime variable |
| interface< double, rt_expr< T > > | Specialization of the runtime expression interface deduction for the ViennaMath runtime expression wrapper |
| interface< rt_binary_expr< T >, RHS > | Specialization of the runtime expression interface deduction for a ViennaMath runtime binary expression |
| interface< rt_constant< T, U >, RHS > | Specialization of the runtime expression interface deduction for a ViennaMath runtime constant |
| interface< rt_expr< T >, RHS > | Specialization of the runtime expression interface deduction for the ViennaMath runtime expression wrapper |
| interface< rt_unary_expr< T >, RHS > | Specialization of the runtime expression interface deduction for a ViennaMath runtime unary expression |
| interface< rt_variable< T >, RHS > | Specialization of the runtime expression interface deduction for a ViennaMath runtime variable |
| is_compiletime< T > | A metafunction returning a value 'true' if the provided argument is a ViennaMath compiletime expression type. Otherwise, false is returned |
| is_compiletime< ct_binary_expr< LHS, OP, RHS > > | Specialization of the metafunction for a ViennaMath compiletime binary expression |
| is_compiletime< ct_constant< val > > | Specialization of the metafunction for a ViennaMath compiletime constant |
| is_compiletime< ct_function_symbol< TAG > > | Specialization of the metafunction for a ViennaMath compiletime function symbol |
| is_compiletime< ct_unary_expr< LHS, OP > > | Specialization of the metafunction for a ViennaMath compiletime unary expression |
| is_compiletime< ct_variable< id > > | Specialization of the metafunction for a ViennaMath compiletime variable |
| is_ct_evaluable< E > | Returns nonzero if supplied expression can be evaluated at compile time |
| is_ct_evaluable< ct_binary_expr< LHS, OP, RHS > > | Specialization: Determines whether a binary expression is compiletime evaluable by recursively acting on the operands |
| is_ct_evaluable< ct_constant< val > > | Specialization: A constant is compiletime evaluable |
| is_ct_evaluable< ct_variable< id > > | Specialization: A variable is compiletime evaluable |
| is_ct_vector< VectorType > | Returns nonzero if the supplied vector type is a compile-time vector |
| is_ct_vector< ct_vector_1< T0 > > | Specialization of the helper function for the determination of whether a vector is a compiletime type |
| is_ct_vector< ct_vector_2< T0, T1 > > | Specialization of the helper function for the determination of whether a vector is a compiletime type |
| is_ct_vector< ct_vector_3< T0, T1, T2 > > | Specialization of the helper function for the determination of whether a vector is a compiletime type |
| is_viennamath< T > | A metafunction with value 'true' if the provided argument is a ViennaMath expression type. Otherwise, false is returned |
| is_viennamath< ct_binary_expr< LHS, OP, RHS > > | Specialization of the metafunction for a ViennaMath compiletime binary expression |
| is_viennamath< ct_constant< val > > | Specialization of the metafunction for a ViennaMath compiletime constant |
| is_viennamath< ct_function_symbol< TAG > > | Specialization of the metafunction for a ViennaMath compiletime function symbol |
| is_viennamath< ct_unary_expr< LHS, OP > > | Specialization of the metafunction for a ViennaMath compiletime unary expression |
| is_viennamath< ct_variable< id > > | Specialization of the metafunction for a ViennaMath compiletime variable |
| is_viennamath< rt_binary_expr< InterfaceType > > | Specialization of the metafunction for a ViennaMath runtime binary expression |
| is_viennamath< rt_constant< NumericType, InterfaceType > > | Specialization of the metafunction for a ViennaMath runtime constant |
| is_viennamath< rt_expr< InterfaceType > > | Specialization of the metafunction for a ViennaMath runtime expression |
| is_viennamath< rt_function_symbol< InterfaceType > > | Specialization of the metafunction for a ViennaMath runtime function symbol |
| is_viennamath< rt_unary_expr< InterfaceType > > | Specialization of the metafunction for a ViennaMath runtime unary expression |
| is_viennamath< rt_variable< InterfaceType > > | Specialization of the metafunction for a ViennaMath runtime variable |
| mult< LHS, RHS, b1, b2 > | Returns the type when multiplying two expressions. Default case: both types are runtime expressions |
| mult< LHS, RHS, true, true > | Metafunction for multiplying two compiletime expressions |
| no_rhs_provided_exception | An exception which is thrown if no right hand side operand is passed to a binary operation |
| numeric_type_proxy< NumericT > | 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 |
| numerical_quadrature_interface< InterfaceType > | The abstract runtime interface for all numerical quadrature rules |
| op_binary< BinaryOperation, InterfaceType > | This is the common wrapper class for binary operations |
| op_cos< NumericT > | Cosine function: x |--> cos(x) |
| op_ct_integral< IntervalType, integration_variable > | Integration operator: f |--> \int_I f d x |
| op_div< NumericT > | Tag for division |
| op_divergence< NumericT > | Divergence operator: f |--> div(f) |
| op_exp< NumericT > | Exponential mapping: x |--> exp(x) |
| op_fabs< NumericT > | Modulus: x |--> |x| |
| op_gradient< NumericT > | Gradient operator: f |--> grad(x) |
| op_id< NumericT > | Identity mapping: x |--> x |
| op_interface< InterfaceType > | The abstract runtime interface for all operations (unary and binary) |
| op_log< NumericT > | Natural logarithm function: x |--> ln(x) |
| op_log10< NumericT > | Logarithm with base 10: x |--> \log_{10}(x) |
| op_minus< NumericT > | Tag for subtraction |
| op_mult< NumericT > | Tag for multiplication |
| op_partial_deriv< NumericT > | Divergence operator: f |--> d f / (d x_i) |
| op_plus< NumericT > | Tag for addition |
| op_rt_integral< InterfaceType > | A unary operation defining an integral over an interval |
| op_rt_symbolic_integral< InterfaceType > | A unary operation encoding a symbolic interval. Cannot be evaluated and is meant to be replaced by a concrete integration later on |
| op_sin< NumericT > | Sine function: x |--> sin(x) |
| op_sqrt< NumericT > | Square root: x |--> \sqrt{x} |
| op_tan< NumericT > | Tangent function: x |--> tan(x) |
| op_unary< UnaryOperation, InterfaceType > | Main class for all unary operations |
| polynomial_degree< VariableType, ExpressionType > | Returns the power of ct_variable<id> inside an expression |
| polynomial_degree< VariableType, ct_binary_expr< LHS, op_div< NumericT >, RHS > > | Specialization for a division: The polynomial degree is given by the difference of the polynomial degree of the numerator and the denominator |
| polynomial_degree< VariableType, ct_binary_expr< LHS, op_minus< NumericT >, RHS > > | Specialization for forcing a compile time error if a difference of expressions is encountered |
| polynomial_degree< VariableType, ct_binary_expr< LHS, op_mult< NumericT >, RHS > > | Specialization for a product: The polynomial degree is given by the sum of the polynomial degree of each factor |
| polynomial_degree< VariableType, ct_binary_expr< LHS, op_plus< NumericT >, RHS > > | Specialization for forcing a compile time error if a sum of expressions is encountered |
| polynomial_degree< VariableType, VariableType > | Specialization for the power of a single variable, which is known to be 1 |
| pow< T, exponent > | Metafunction returning the power of an expression. Tries to balance the generated expression tree |
| pow< T, 0 > | Specialization for the zeroth power of an expression |
| pow< T, 1 > | Specialization for the first power of an expression |
| pow< T, 2 > | Specialization for the square of an expression |
| promote_traits< T, OP, U > | 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 |
| promote_traits< double, OP, float > | |
| promote_traits< double, OP, int > | |
| promote_traits< double, OP, long > | |
| promote_traits< float, OP, double > | |
| promote_traits< float, OP, int > | |
| promote_traits< float, OP, long > | |
| promote_traits< int, OP, double > | |
| promote_traits< int, OP, float > | |
| promote_traits< int, op_div< NumericType >, long > | |
| promote_traits< long, OP, double > | |
| promote_traits< long, OP, float > | |
| promote_traits< long, op_div< NumericType >, int > | |
| promote_traits< long, op_div< NumericType >, long > | |
| 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) |
| rhs_provided_for_unary_operation_exception | An exception which is thrown if a right hand side argument is passed to a unary operation |
| rt_binary_expr< InterfaceType > | Runtime representation of a binary expression F(x,y), where F is a function of two argument (e.g. +) and x,y are expressions |
| rt_constant< ScalarType, InterfaceType > | Representation of a constant within the expression setting of ViennaMath |
| rt_equation< InterfaceType > | Runtime representation of a equation by a left hand side and a right hand side expresssion |
| rt_expr< InterfaceType > | This class represents a smart pointer to all types expressions |
| rt_expression_interface< NumericT > | Abstract interface for all ViennaMath runtime expressions |
| rt_function_symbol< InterfaceType > | A function symbol. Can be used for unknown functions, test functions, etc. Cannot be evaluated, but substituted with an evaluable object |
| rt_gauss_quad_1< InterfaceType > | Gauss quadrature rule with first-order accuracy |
| rt_interval< InterfaceType > | Represents an interval [a,b] at runtime. Note that the interval boundaries do not need to be constants |
| rt_latex_binary_expr_processor< InterfaceType > | A LaTeX processor responsible for translating binary expressions to LaTeX code |
| rt_latex_constant_processor< InterfaceType > | A LaTeX processor responsible for translating ViennaMath runtime constants to LaTeX code |
| rt_latex_function_symbol_processor< InterfaceType > | A LaTeX processor responsible for translating ViennaMath runtime function symbols to LaTeX code |
| rt_latex_processor_interface< InterfaceType > | The abstract interface for each LaTeX processor module |
| rt_latex_translator< InterfaceType > | The main LaTeX translator class. To be used and manipulated by the ViennaMath library user |
| rt_latex_unary_expr_processor< InterfaceType > | A LaTeX processor responsible for translating unary expressions to LaTeX code |
| rt_latex_variable_processor< InterfaceType > | A LaTeX processor responsible for translating ViennaMath runtime variables to LaTeX code |
| rt_manipulation_interface< InterfaceType > | The abstract runtime interface for all expression manipulators |
| rt_manipulation_wrapper< InterfaceType > | A wrapper using type erasure for manipulation functors acting on expressions |
| rt_numerical_quadrature< InterfaceType > | The main numerical quadrature rule class. Wraps the integration rule and performs all the book-keeping for the evaluation |
| rt_symbolic_interval< InterfaceType > | A symbolic runtime interval |
| rt_traversal_interface< InterfaceType > | The abstract runtime interface for all expression traversal routines |
| rt_traversal_wrapper< InterfaceType > | A wrapper using type erasure for traversal functions acting on expressions |
| rt_unary_expr< InterfaceType > | Runtime representation of a unary expression F(e), where F is a function of one argument (e.g. log()) and e is an expression |
| rt_variable< InterfaceType > | Representation of an variable (a variable). If the supplied argument is some vector type, a traits system accesses the id-th component |
| rt_vector_expr< InterfaceType > | An tweaked auto_ptr for run time rt_expr types |
| simplify< ExpressionType, optimization_possible > | Top-level metafunction for the simplification of expressions. Loops over simplification rules until no more simplifications can be applied |
| simplify< ct_binary_expr< LHS, OP, RHS >, false > | Specialization for a binary expression, for which no optimizations can be applied: Return the unmodified expression |
| simplify< ct_binary_expr< LHS, OP, RHS >, true > | Specialization for a binary expression, for which optimizations can be applied |
| simplify< ct_constant< value >, false > | Specialization for a constant, for which no optimizations can be applied: Return the unmodified constant |
| simplify< ct_constant< value >, true > | Specialization for a constant, for which optimizations can be applied |
| simplify< ct_function_symbol< TAG >, false > | Specialization for a function symbol, for which no optimizations can be applied: Return the unmodified constant |
| simplify< ct_function_symbol< TAG >, true > | Specialization for a function symbol, for which optimizations can be applied |
| simplify< ct_unary_expr< LHS, OP >, false > | Specialization for a unary expression, for which no optimizations can be applied: Return the unmodified expression |
| simplify< ct_unary_expr< LHS, OP >, true > | Specialization for a unary expression, for which optimizations can be applied |
| simplify< ct_variable< id >, false > | Specialization for a compiletime variable, for which no optimizations can be applied: Return the unmodified constant |
| simplify< ct_variable< id >, true > | Specialization for a variable, for which optimizations can be applied |
| simplify_impl< ExpressionType > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< 0 >, op_minus< NumericT >, RHS1 >, op_minus< NumericT >, ct_binary_expr< ct_constant< 0 >, op_minus< NumericT >, RHS2 > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< 0 >, op_minus< NumericT >, RHS1 >, op_minus< NumericT >, RHS2 > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< 0 >, op_minus< NumericT >, RHS1 >, op_plus< NumericT >, ct_binary_expr< ct_constant< 0 >, op_minus< NumericT >, RHS2 > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< 0 >, op_minus< NumericT >, RHS1 >, op_plus< NumericT >, RHS2 > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< 1 >, op_div< NumericT >, RHS1 >, op_mult< NumericT >, ct_binary_expr< ct_constant< 1 >, op_div< NumericT >, RHS2 > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< 1 >, op_div< NumericT >, RHS1 >, op_mult< NumericT >, RHS2 > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< numerator_1 >, op_div< NumericT >, ct_constant< denominator_1 > >, op_div< NumericT >, ct_binary_expr< ct_constant< numerator_2 >, op_div< NumericT >, ct_constant< denominator_2 > > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< numerator_1 >, op_div< NumericT >, ct_constant< denominator_1 > >, op_div< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< numerator_1 >, op_div< NumericT >, ct_constant< denominator_1 > >, op_minus< NumericT >, ct_binary_expr< ct_constant< numerator_2 >, op_div< NumericT >, ct_constant< denominator_2 > > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< numerator_1 >, op_div< NumericT >, ct_constant< denominator_1 > >, op_minus< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< numerator_1 >, op_div< NumericT >, ct_constant< denominator_1 > >, op_minus< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< numerator_1 >, op_div< NumericT >, ct_constant< denominator_1 > >, op_mult< NumericT >, ct_binary_expr< ct_constant< numerator_2 >, op_div< NumericT >, ct_constant< denominator_2 > > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< numerator_1 >, op_div< NumericT >, ct_constant< denominator_1 > >, op_mult< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< numerator_1 >, op_div< NumericT >, ct_constant< denominator_1 > >, op_plus< NumericT >, ct_binary_expr< ct_constant< numerator_2 >, op_div< NumericT >, ct_constant< denominator_2 > > > > | |
| simplify_impl< ct_binary_expr< ct_binary_expr< ct_constant< numerator_1 >, op_div< NumericT >, ct_constant< denominator_1 > >, op_plus< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_div< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_div< NumericT >, ct_constant< 1 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_div< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_div< NumericT >, RHS > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_mult< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_mult< NumericT >, ct_constant< 1 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_mult< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_mult< NumericT >, RHS > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_plus< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_plus< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 0 >, op_plus< NumericT >, RHS > > | |
| simplify_impl< ct_binary_expr< ct_constant< 1 >, op_minus< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 1 >, op_mult< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 1 >, op_mult< NumericT >, ct_constant< 1 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 1 >, op_mult< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< 1 >, op_mult< NumericT >, RHS > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_div< NumericT >, ct_binary_expr< ct_constant< numerator_2 >, op_div< NumericT >, ct_constant< denominator_2 > > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_div< NumericT >, ct_constant< 1 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_div< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_div< NumericT >, ct_constant<-1 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_minus< NumericT >, ct_binary_expr< ct_constant< numerator_2 >, op_div< NumericT >, ct_constant< denominator_2 > > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_minus< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_mult< NumericT >, ct_binary_expr< ct_constant< numerator_2 >, op_div< NumericT >, ct_constant< denominator_2 > > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_mult< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_mult< NumericT >, ct_constant< 1 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_mult< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_plus< NumericT >, ct_binary_expr< ct_constant< numerator_2 >, op_div< NumericT >, ct_constant< denominator_2 > > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_plus< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< ct_constant< value_1 >, op_plus< NumericT >, ct_constant< value_2 > > > | |
| simplify_impl< ct_binary_expr< ct_constant<-1 >, op_minus< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< LHS, OP, RHS > > | |
| simplify_impl< ct_binary_expr< LHS, op_div< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< LHS, op_div< NumericT >, ct_constant< 1 > > > | |
| simplify_impl< ct_binary_expr< LHS, op_minus< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< LHS, op_mult< NumericT >, ct_binary_expr< ct_constant< 1 >, op_div< NumericT >, RHS > > > | |
| simplify_impl< ct_binary_expr< LHS, op_mult< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< LHS, op_mult< NumericT >, ct_constant< 1 > > > | |
| simplify_impl< ct_binary_expr< LHS, op_plus< NumericT >, ct_constant< 0 > > > | |
| simplify_impl< ct_binary_expr< LHS1, op_minus< NumericT >, ct_binary_expr< ct_constant< 0 >, op_minus< NumericT >, RHS2 > > > | |
| simplify_impl< ct_binary_expr< LHS1, op_plus< NumericT >, ct_binary_expr< ct_constant< 0 >, op_minus< NumericT >, RHS2 > > > | |
| substitute< SearchType, ReplacementType, ExpressionType > | Default case for the compiletime substitution metafunction: Do not define any return type. This provides SFINAE for the interface function |
| substitute< ct_binary_expr< LHS, OP, RHS >, ReplacementType, ct_binary_expr< LHS, OP, RHS > > | If there is a match for the binary expression, the replacement is returned |
| substitute< ct_constant< value >, ReplacementType, ct_constant< value > > | If there is a match for the compiletime constant, the replacement is returned |
| substitute< ct_function_symbol< TAG >, ReplacementType, ct_function_symbol< TAG > > | If there is a match for the compiletime function symbol, the replacement is returned |
| substitute< ct_unary_expr< LHS, OP >, ReplacementType, ct_unary_expr< LHS, OP > > | If there is a match for the unary expression, the replacement is returned |
| substitute< ct_variable< id >, ReplacementType, ct_variable< id > > | If there is a match for the compiletime variable, the replacement is returned |
| substitute< SearchType, ReplacementType, ct_binary_expr< LHS, OP, RHS > > | For a binary expression, the substitution is performed for both operands |
| substitute< SearchType, ReplacementType, ct_constant< value > > | By default, a compiletime constant is left unmodified (no match) |
| substitute< SearchType, ReplacementType, ct_function_symbol< TAG > > | By default, a compiletime function symbol is left unmodified (no match) |
| substitute< SearchType, ReplacementType, ct_unary_expr< LHS, OP > > | For a unary expression, the substitution is performed for the operand |
| substitute< SearchType, ReplacementType, ct_variable< id > > | By default, a compiletime variable is left unmodified (no match) |
| subtract< LHS, RHS, b1, b2 > | Returns the type when subtracting two expressions. Default case: both types are runtime expressions |
| subtract< LHS, RHS, true, true > | Metafunction for subtracting two compiletime expressions |
| symbolic_integral_evaluation_not_possible_exception | Analytic integration at runtime not supported |
| test_tag< ct_id > | A compiletime tag for a test function: |
| type_by_index< vmath_vector, id > | Helper metafunction for returning the 'id'-th entry of a compiletime vector |
| type_by_index< vmath_vector, 0 > | Accesses the first entry in a compiletime vector |
| type_by_index< vmath_vector, 1 > | Accesses the second entry in a compiletime vector |
| type_by_index< vmath_vector, 2 > | Accesses the third entry in a compiletime vector |
| unknown_tag< ct_id > | A compiletime tag for an unknown function: |
| 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 |
| variable_traits< VectorType, id > | Helper struct for accessing the i-th element of a vector at runtime |
| variable_traits< ct_constant< value_ >, 0 > | Helper struct for accessing the 0-th element of a constant at runtime |
| variable_traits< ct_constant< value_ >, id > | Compiletime guard for index out of bounds |
| 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 |
| 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 |
| 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 |
