Mathematical components

A group of mathematical functions and components. More...

Collaboration diagram for Mathematical components:

Modules
	Abstract algebra elements
	Defines abstract algebra elements, such as types which correspond to various algebraic structures, as well as ancillary operations upon them.
	Helper operations upon bits within integral values
	A set of ancillary operations upon bits that constitute an integral values, such as compile-time bit inversion for indices, bit mask generation and so on.

Classes
struct	divmod_value< int_t, Dividend, Divisor >
	Performs compile time calculation of the division of integral values, specified, together with specific type, as the template arguments. The result is a pair of a quotient and a remainder. More...
struct	ceildiv_value< int_t, Dividend, Divisor >
	Performs compile time calculation of division of the specified template arguments with ceiling. The result is written to a value field. More...
struct	rank< T >
	Calculates a rank of an array of type T at a compile time. More...
struct	array_size< T >
	Calculates a size of a one-dimensional vector. Can be used instead of array_size C macro. More...
struct	minmax< T, values >
	Statically chooses minimum and maximum values from a set of values. More...
struct	logical_and< rest >
	Statically calculates a result of the logical AND operation upon the template parameters. More...
struct	logical_or< rest >
	Statically calculates a result of the logical OR operation upon the template parameters. More...
struct	make_Nary_type_template< InsertBefore, N, BaseTemplate, InvariantTypes >
	Produces a new variadic template which accept a specified number of type parameters. More...
struct	is_satisfied_by_all< predicate, T >
	Checks if every type in a pack satisfies a specified compile-time predicate. More...
struct	is_satisfied_by_one< predicate, T >
	Checks if at least one type in a pack satisfies a specified compile-time predicate. More...
struct	gcd_value< params >
	Calculates the greatest common divisor of multiply template arguments at a compile time. More...
struct	matrix_always_parallel
	A policy for implementing matrix operations for running in multiple SMP threads where possible. More...
struct	matrix_always_sequential
	A policy for implementing matrix operations for running in a single thread only. More...
struct	matrix_dynamically_customizable_parallelism
	A policy for implementing matrix operations for running both in a single-thread-only mode and in parallel mode depending on a dynamically provided value of a special flag set by the Matrix::set_parallel_mode and Matrix::reset_parallel_mode methods of the matrix instantiated for this policy. More...
struct	matrix_execution_policy< parallelism_policy_tag >
	Encapsulates statically defined policy for an implementation of the Matrix class. More...
struct	matrix_execution_policy_traits< Policy >
	Provides the same fields as the matrix_execution_policy class does, but for an arbitriary Policy class specifying a matrix policy. The Policy class definition is allowed to skip policy specifications in order to specify default behaviour. More...
struct	common_policy< policy_t >
	Provides a field type designating common policy for the policies given by policy_t parameter pack. More...
struct	is_matrix< T >
	Performs compile time check whether the type T is a matrix type. More...
class	matrix_column< MatrixType >
	Implements a column of a matrix with direct access to the elements of the matrix. More...
class	Matrix< Val, Alloc, Derived_t, Policy >
	A class template for matrices of elements of various types and semantics, including types which do not have any numeric semantics, as well as types satisfying algebraic_type requirements. More...
class	FixedMatrix< Val, ColumnCount, RowCount, Alloc, Derived_t, ExecutionPolicy >
	Specializes the Matrix template for fixed-sized matrices. More...

Typedefs
typedef matrix_execution_policy< matrix_dynamically_customizable_parallelism >	default_matrix_execution_policy
	A policy for a Matrix implementation by default.

Enumerations
enum class	matrix_stats {   lower_triangular = 1 , upper_triangular = 2 , diagonal = 3 , square = 4 ,   orthogonal = 0xC , permuation = 0x1C , scaling = 0x2C , identity = 0x3f }
	Defines flags which can be set for a matrix by the get_matrix_stats function. More...
enum class	LU_status : std::uint_fast32_t { rearranged = 2 , rearranged_odd = 3 , singularity = 4 , failure = 1u << 31 }
	A bitmask enumeration type used to return properties of an LUP-transformation of a matrix. More...

Functions
template<class IntegralType >
constexpr IntegralType	ceildiv (IntegralType nDividend, IntegralType nDivisor) noexcept
	Integer division with rounding towards infinity. More...
template<class ArithmeticType >
constexpr ArithmeticType	abs (ArithmeticType val) noexcept
	Returns an absolute value of a scalar. More...
template<class Tpl , class BinOp >
constexpr auto	accumulate (Tpl &&tpl, BinOp &&binop) noexcept(noexcept(Implementation::accumulate(std::declval< Tpl && >(), std::declval< BinOp && >(), std::integral_constant< std::size_t, std::tuple_size< typename std::remove_reference< Tpl >::type >::value >()))) -> decltype(Implementation::accumulate(std::declval< Tpl && >(), std::declval< BinOp && >(), std::integral_constant< std::size_t, std::tuple_size< typename std::remove_reference< Tpl >::type >::value >()))
	Consequently forwards elements of a tuple to a specified binary functor and returns the result. More...
template<class... integral_tn>
T	gcd (integral_tn..integral_values)
	Calculates the greatest common divisor of a pack of integral values. Types of distinct parameters should be implicitly convertible to each other.
template<class... integral_tn>
T	lcm (integral_tn..integral_values)
	Calculates the least common multiplier of a pack of integral values. Types of distinct parameters should be implicitly convertible to each other.
template<class T >
constexpr T	eulers_constant () noexcept(noexcept(T(double())))
	Returns a numeric value of the Euler's constant. More...
template<class T >
constexpr T	pi () noexcept(noexcept(T(double())))
	Returns a numeric value of pi. More...
template<class T >
constexpr T	log_e_of_2 () noexcept(noexcept(T(double())))
	Returns a natural logarithm of two. More...
template<class T >
constexpr T	log_2_of_e () noexcept(noexcept(T(double())))
	Returns a binary logarithm of the Euler's constant. More...
template<class T >
constexpr T	log_e_of_10 () noexcept(noexcept(T(double())))
	Returns a natural logarithm of ten. More...
template<class T >
constexpr T	log_10_of_e () noexcept(noexcept(T(double())))
	Returns a decimal logarithm of the Euler's constant. More...
template<class T >
constexpr T	sqr_of_2 () noexcept(noexcept(T(double())))
	Returns a square root of two. More...
template<class T >
constexpr T	sqr_of_pi () noexcept(noexcept(T(double())))
	Returns a square root of pi. More...
template<class T >
constexpr T	fmadd (const T &multiplicand1, const T &multiplicand2, const T &addend) noexcept(std::is_nothrow_move_constructible< T >::value)
	Generic implementation of fused multiple-add (FMA). More...
template<class T >
constexpr T	fmsub (const T &multiplicand1, const T &multiplicand2, const T &subtrahend) noexcept(std::is_nothrow_move_constructible< T >::value)
	Generic implementation of fused multiple-subtract. More...
template<class ValueType >
bool	is_lower_triangular_matrix (const ValueType *column_matrix, std::size_t columns, std::size_t rows) noexcept
	Checks whether a matrix given by an array of columns is a lower-triangular matrix. More...
template<class ValueType >
bool	is_upper_triangular_matrix (const ValueType *column_matrix, std::size_t columns, std::size_t rows) noexcept
	Checks whether a matrix given by an array of columns is an upper-triangular matrix. More...
template<class ValueType >
bool	is_diagonal_matrix (const ValueType *column_matrix, std::size_t columns, std::size_t rows) noexcept
	Checks whether a matrix given by an array of columns is a diagonal matrix. More...
template<class ValueType >
bool	is_identity_matrix (const ValueType *column_matrix, std::size_t n) noexcept
	Checks whether a matrix given by an array of columns is an identity matrix. More...
template<class ValueType >
bool	is_scaling_matrix (const ValueType *column_matrix, std::size_t n) noexcept
	Checks whether a matrix given by an array of columns represents a omnidirectional scaling transformation. More...
template<class ValueType >
bool	is_permutation_matrix (const ValueType *column_matrix, std::size_t n) noexcept
	Checks whether a matrix given by an array of columns is a permutation matrix. More...
template<class ValueType >
bool	is_orthogonal_matrix (const ValueType *column_matrix, std::size_t n) noexcept
	Checks whether a matrix given by an array of columns is orthogonal, i.e. its transposition equals its reciprocal. More...
template<class ValueType >
matrix_stats	get_matrix_stats (const ValueType *column_matrix, std::size_t columns, std::size_t rows)
	Given a column matrix, returns bitmask of flags representing properties of the matrix. More...
template<class ValueType >
void	set_zero_matrix (ValueType *column_matrix, std::size_t columns, std::size_t rows) noexcept(std::is_nothrow_default_constructible< ValueType >::value &&std::is_nothrow_copy_assignable< ValueType >::value)
	Copy-assigns a default-constructed element, assumed to represent zero, to all elements of the specified matrix. More...
template<class ValueType >
void	construct_zero_matrix (ValueType *column_matrix, std::size_t columns, std::size_t rows) noexcept(std::is_nothrow_default_constructible< ValueType >::value)
	Constructs a zero matrix by default-constructing its elements in a buffer. More...
template<class ValueType >
void	set_diagonal_matrix (ValueType *column_matrix, std::size_t columns, std::size_t rows, ValueType diag) noexcept(std::is_nothrow_default_constructible< ValueType >::value &&std::is_nothrow_copy_assignable< ValueType >::value)
	Assigns a diagonal matrix to elements in a buffer considered a column-major matrix representation. More...
template<class ValueType >
void	construct_diagonal_matrix (ValueType *column_matrix, std::size_t columns, std::size_t rows, ValueType diag) noexcept(std::is_nothrow_default_constructible< ValueType >::value &&std::is_nothrow_copy_constructible< ValueType >::value)
	Constructs a diagonal column-major matrix in a specified buffer. More...
template<class ValueType >
void	set_permutation_scaling_matrix (ValueType *restrict column_matrix, std::size_t n, const std::size_t *restrict permutation_indices, ValueType scaling) noexcept(std::is_nothrow_default_constructible< ValueType >::value &&std::is_nothrow_copy_assignable< ValueType >::value)
	Assigns a permutation matrix from a vector of integral indices of elements within each column of a matrix. More...
template<class ValueType >
void	construct_permutation_scaling_matrix (ValueType *restrict column_matrix, std::size_t n, const std::size_t *restrict permutation_indices, ValueType scaling) noexcept(std::is_nothrow_default_constructible< ValueType >::value &&std::is_nothrow_copy_constructible< ValueType >::value)
	Constructs a permutation matrix as a two-dimensional array of columns of elements from a vector of integral indices of elements within each column of a matrix. More...
template<class ValueType >
void	rearrange_matrix_copy (const ValueType *restrict column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict output, const std::size_t *restrict permutation_indices) noexcept(std::is_nothrow_copy_assignable< ValueType >::value)
	Rearranges columns of a matrix specified by a column-major two-dimensional array with respect to an array of integral indices of the columns and respectively copy-assigns the result to a destination buffer. More...
template<class ValueType >
void	rearrange_matrix_construct (const ValueType *restrict column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict output, const std::size_t *restrict permutation_indices) noexcept(std::is_nothrow_copy_constructible< ValueType >::value)
	Rearranges columns of a matrix specified by a column-major two-dimensional array with respect to an array of integral indices of the columns constructing the rearrangement in a destination buffer. More...
template<class ValueType >
void	rearrange_matrix_inplace (ValueType *restrict column_matrix, std::size_t columns, std::size_t rows, const std::size_t *restrict permutation_indices) noexcept(std::is_nothrow_swappable< ValueType >::value)
	Performs an in-place permutation of columns of a matrix specified by a column-major two-dimensional array with respect to an array of integral indices of the columns. More...
template<class ValueType >
ValueType	determinant_field (const ValueType *matrix_elements, std::size_t n)
	Computes a determinant of a square matrix defined over a field. More...
template<class ValueType >
void	add_matrix_copy (const ValueType *left_column_matrix, const ValueType *right_column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict result)
	Calculates a sum of two matrices specified as two-dimensional arrays of scalars and assigns the result to a third matrix. More...
template<class ValueType >
void	add_matrix_construct (const ValueType *left_column_matrix, const ValueType *right_column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict result)
	Calculates a sum of two matrices specified as two-dimensional arrays of scalars and constructs the resulting matrix in an uninitialized buffer. More...
template<class ValueType >
void	add_matrix_inplace (ValueType *left_column_matrix, const ValueType *right_column_matrix, std::size_t columns, std::size_t rows)
	Performs an in-place addition of two matrices using two-dimensional array representation. More...
template<class ValueType >
void	neg_matrix_copy (const ValueType *restrict input_column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict result)
	Computes arithmetic negation of a matrix and assigns the result to a different matrix. More...
template<class ValueType >
void	neg_matrix_construct (const ValueType *restrict input_column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict result)
	Computes arithmetic negation of a matrix and constructs the result in an uninitialized buffer. More...
template<class ValueType >
void	neg_matrix_inplace (ValueType *column_matrix, std::size_t columns, std::size_t rows)
	Performs an in-place negation of a matrix represented by a two-dimensional array. More...
template<class ValueType >
void	sub_matrix_copy (const ValueType *restrict left_column_matrix, const ValueType *restrict right_column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict result)
	Calculates a difference between two matrices specified as two-dimensional arrays of scalars and assigns the result to a third matrix. More...
template<class ValueType >
void	sub_matrix_construct (const ValueType *restrict left_column_matrix, const ValueType *restrict right_column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict result)
	Calculates a difference between two matrices specified as two-dimensional arrays of scalars and constructs the resulting matrix in an uninitialized buffer. More...
template<class ValueType >
void	sub_matrix_inplace (ValueType *minuend_column_matrix, const ValueType *subtrahend_column_matrix, std::size_t columns, std::size_t rows)
	Performs a subtraction of two matrices using two-dimensional array representation and writes the difference in place of the minuend. More...
template<class ValueType >
void	sub_matrix_inplace_rev (const ValueType *minuend_column_matrix, ValueType *subtrahend_column_matrix, std::size_t columns, std::size_t rows)
	Performs a subtraction of two matrices using two-dimensional array representation and writes the difference in place of the subtrahend. More...
template<class ValueType >
bool	equal_matrix (const ValueType *left_column_matrix, const ValueType *right_column_matrix, std::size_t columns, std::size_t rows)
	Tests two matrices, represented by two-dimensional arrays, for equality using elementwise equality comparison. More...
template<class ValueType >
void	mul_matrix_copy (const ValueType *left_column_matrix, const ValueType *right_column_matrix, std::size_t left_rows, std::size_t left_columns_right_rows, std::size_t right_columns, ValueType *restrict result)
	Calculates a product of two matrices specified as two-dimensional arrays of scalars and assigns the result to a third matrix. More...
template<class ValueType >
void	mul_matrix_construct (const ValueType *left_column_matrix, const ValueType *right_column_matrix, std::size_t left_rows, std::size_t left_columns_right_rows, std::size_t right_columns, ValueType *restrict result)
	Calculates a product of two matrices specified as two-dimensional arrays of scalars and constructs the resulting matrix in an uninitialized buffer. More...
template<class ValueType >
void	mul_matrix_inplace (ValueType *left_column_matrix, const ValueType *right_column_matrix, std::size_t left_rows, std::size_t left_columns_right_rows, std::size_t right_columns)
	Performs a multiplication of two matrices represented by two-dimensional column-major arrays and writes the result in place of the left multiplicand. More...
template<class ValueType >
void	mul_matrix_inplace_rev (const ValueType *left_column_matrix, ValueType *right_column_matrix, std::size_t left_rows, std::size_t left_columns_right_rows, std::size_t right_columns)
	Performs a multiplication of two matrices represented by two-dimensional column-major arrays and writes the result in place of the right multiplicand. More...
template<class ValueType >
LU_status	decompose_lup_explicit_copy (const ValueType *restrict column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict L, ValueType *restrict U, ValueType *restrict P) noexcept(Implementation::is_nothrow_invertible< ValueType >::value)
	Performs an LUP decomposition of a column-major matrix and copy-assigns the three results to three separate buffers. More...
template<class ValueType >
LU_status	decompose_lup_explicit_construct (const ValueType *restrict column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict L, ValueType *restrict U, ValueType *restrict P) noexcept(Implementation::is_nothrow_invertible< ValueType >::value)
	Performs an LUP decomposition of a column-major matrix and constructs the three results in three separate buffers. More...
template<class ValueType >
LU_status	decompose_lup_copy (const ValueType *restrict column_matrix, std::size_t n, ValueType *restrict lu, std::size_t *restrict P) noexcept(Implementation::is_nothrow_invertible< ValueType >::value)
	Performs an LUP decomposition of a square column-major matrix, assigning the L and U components, as a single matrix, to a buffer and writing the permutation of LU expressed as an array of column indices. More...
template<class ValueType >
LU_status	decompose_lup_construct (const ValueType *restrict column_matrix, std::size_t n, ValueType *restrict lu, std::size_t *restrict P) noexcept(Implementation::is_nothrow_invertible< ValueType >::value)
	Performs an LUP decomposition of a square column-major matrix, constructing the L and U components, as a single matrix, in a buffer and writing the permutation of LU expressed as an array of column indices. More...
template<class ValueType >
LU_status	decompose_lup_inplace (ValueType *restrict column_matrix, std::size_t n, std::size_t *restrict P) noexcept(Implementation::is_nothrow_invertible< ValueType >::value)
	Performs an in-place LUP decomposition of a square column-major matrix with the L and U components packed to a single square matrix and writes the permutation of LU expressed as an array of column indices. More...
template<class ValueType >
bool	matrix_inverse_inplace (ValueType *column_matrix, std::size_t n)
	Computes a multiplicative inverse of a matrix in place. More...
template<class ValueType >
bool	matrix_inverse_inplace_parallel (ValueType *column_matrix, std::size_t n)
	Computes a multiplicative inverse of a matrix in place and in parallel. More...
template<class ValueType >
bool	matrix_inverse_copy (const ValueType *restrict column_matrix, std::size_t n, ValueType *restrict inverse)
	Computes a multiplicative inverse of a matrix and assigns it to a different matrix. More...
template<class ValueType >
bool	matrix_inverse_copy_parallel (const ValueType *restrict column_matrix, std::size_t n, ValueType *restrict inverse)
	Performs a parallel evaluation of a multiplicative inverse of a matrix and assigns the result to a different matrix. More...
template<class ValueType >
bool	matrix_inverse_construct (const ValueType *restrict column_matrix, std::size_t n, ValueType *restrict inverse)
	Computes a multiplicative inverse of a matrix and constructs the reciprocal matrix in an uninitialized memory buffer. More...
template<class ValueType >
bool	matrix_inverse_construct_parallel (const ValueType *restrict column_matrix, std::size_t n, ValueType *restrict inverse)
	Performs a parallel evaluation of a multiplicative inverse of a matrix and constructs the reciprocal matrix in an uninitialized memory buffer. More...
template<class ValueType >
void	transpose_copy (const ValueType *restrict column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict result) noexcept(std::is_nothrow_copy_assignable< ValueType >::value)
	Transposes a matrix assigning the result to a non-overlapping array of existing elements. More...
template<class ValueType >
void	transpose_construct (const ValueType *restrict column_matrix, std::size_t columns, std::size_t rows, ValueType *restrict result) noexcept(std::is_nothrow_copy_constructible< ValueType >::value)
	Transposes a matrix constructing the result in a provided uninitialized buffer. More...
template<class ValueType >
void	transpose_inplace (ValueType *column_matrix, std::size_t columns, std::size_t rows)
	Performs an in-place transposition of a matrix. More...
template<class MatrixType >
void	swap (matrix_column< MatrixType > &left, matrix_column< MatrixType > &right)
	Swaps contents of two matrix columns. More...
unspecified_type	make_matrix_parallelism_policy (const Chusov::Math::Matrix &...matrices)
	Retrieves a common parallelism policy for a set of matrices and, if the common policy is matrix_dynamically_customizable_parallelism, sets its parallelism flag to a value with respect to the rules for forming the common policy, as specified in the description of the common_policy metafunction. The returned type is unspecified and defined by the implementation. More...
template<class Val , class Alloc , class Derived_t >
bool	operator== (const Matrix< Val, Alloc, Derived_t > &left, const Matrix< Val, Alloc, Derived_t > &right)
	Checks two matrices for equality, that is if dimensions of the matrices are mutually equal, and if the elements of the matrices are equal to one another. . More...
template<class Val , class Alloc , class Derived_t >
bool	operator!= (const Matrix< Val, Alloc, Derived_t > &left, const Matrix< Val, Alloc, Derived_t > &right)
	Checks two matrices for inequality, that is if dimensions of the matrices are not mutually equal, or elements of one matrix are not respectively equal to elements of another one, i.e. the operator is the opposite of the equality operator. More...
template<class aug1_t , class... aug_t_n>
Matrix< common_value_type, common_allocator_type, void, common_policy_type >	make_augmentation_matrix (aug1_t &&aug1, aug_t_n &&... aug_n)
	Creates a Matrix object as an augmentation of other matrices, columns, or ranges of iterators of thereof. More...
template<class aug1_t , class... aug_t_n>
Matrix< common_value_type, common_allocator_type, void, common_policy_type >	make_stacked_matrix (aug1_t &&aug1, aug_t_n &&... aug_n)
	Creates a Matrix object as set other matrices stacked to the bottom of each other consequently. More...
template<class aug1_t , class... aug_t_n>
FixedMatrix< aug1_t::value_type, sum_of_columns, rows, aug1_t::allocator_type >	make_fixed_augmentation_matrix (aug1_t &&aug1, aug_t_n &&...aug_n)
	Creates a FixedMatrix object as an augmentation of other fixed-sized matrices, columns, or ranges of iterators of thereof. More...

Arithmetic operations over matrices.
A group of arithmetic operators conditionally defined as static functions over matrices. One can redefine operators for derivations of the Matrix class (see Matrix::derived_type) in order to provide optimizations of the operators for specific cases. Each operator is defined conditionally depending on specific properties of operands and/or the result. See specific operators for further information on the conditions.
template<class val1_t , class alloc1_t , class der1_t , class policy1_t , class val2_t , class alloc2_t , class der2_t , class policy2_t >
derived_type &	operator+= (Matrix< val1_t, alloc1_t, der1_t, policy1_t > &left, const Matrix< val2_t, alloc2_t, der2_t, policy2_t > &right)
	Performs an addition of two matrices with an assignment of the result to the first operand. More...
template<class val1_t , class alloc1_t , class der1_t , class policy1_t , class val2_t , class alloc2_t , class der2_t , class policy2_t >
Matrix< common_value, common_allocator, void, common_policy >	operator+ (const Matrix< val1_t, alloc1_t, der1_t, policy1_t > &left, const Matrix< val2_t, alloc2_t, der2_t, policy2_t > &right)
	Adds up two matrices. More...
template<class val1_t , class alloc1_t , class der1_t , class policy1_t , class val2_t , class alloc2_t , class der2_t , class policy2_t >
derived_type &	operator-= (Matrix< val1_t, alloc1_t, der1_t, policy1_t > &left, const Matrix< val2_t, alloc2_t, der2_t, policy2_t > &right)
	Performs a subtraction of two matrices with an assignment of the result to the first operand. More...
template<class val1_t , class alloc1_t , class der1_t , class policy1_t , class val2_t , class alloc2_t , class der2_t , class policy2_t >
Matrix< common_value, common_allocator, void, common_policy >	operator- (const Matrix< val1_t, alloc1_t, der1_t, policy1_t > &left, const Matrix< val2_t, alloc2_t, der2_t, policy2_t > &right)
	Subtracts two matrices. More...
template<class val1_t , class alloc1_t , class der1_t , class policy1_t , class val2_t , class alloc2_t , class der2_t , class policy2_t >
Matrix< common_value, common_allocator, void, common_policy >	operator* (const Matrix< val1_t, alloc1_t, der1_t, policy1_t > &left, const Matrix< val2_t, alloc2_t, der2_t, policy2_t > &right)
	Multiplies two matrices. More...
template<class val1_t , class alloc1_t , class der1_t , class policy1_t , class val2_t , class alloc2_t , class der2_t , class policy2_t >
derived_type &	operator*= (Matrix< val1_t, alloc1_t, der1_t, policy1_t > &left, const Matrix< val2_t, alloc2_t, der2_t, policy2_t > &right)
	Calculates a product of two matrices with an assignment of the result to the first operand. More...
template<class val_t , class alloc_t , class der_t , class policy_t , class elem_t >
std::enable_if< is_rng< val_t >::value &&std::is_convertible< elem_t, val_t >::value, typename Matrix< val_t, alloc_t, der_t, policy_t >::derived_type & >::type	operator*= (Matrix< val_t, alloc_t, der_t, policy_t > &left, elem_t &&val)
	Multiplies a matrix and a scalar and assigns the product to the matrix. More...
template<class val_t , class alloc_t , class der_t , class policy_t , class elem_t >
Matrix< common_type, typename std::allocator_traits< alloc_t >::template rebind_alloc< common_type >, void, policy_t >	operator* (const Matrix< val_t, alloc_t, der_t, policy_t > &left, elem_t &&val)
	Multiplies a matrix and a scalar. More...
template<class elem_t , class val_t , class alloc_t , class der_t , class policy_t >
Matrix< common_type, typename std::allocator_traits< alloc_t >::template rebind_alloc< common_type >, void, policy_t >	operator* (elem_t &&val, const Matrix< val_t, alloc_t, der_t, policy_t > &right)
	Multiplies a scalar and a matrix. More...

Detailed Description

A group of mathematical functions and components.