Chusov::Math Namespace Reference

A namespace containing mathematical functions and components. More...

Classes
struct	divmod_value
	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
	Performs compile time calculation of division of the specified template arguments with ceiling. The result is written to a value field. More...
struct	rank
	Calculates a rank of an array of type T at a compile time. More...
struct	array_size
	Calculates a size of a one-dimensional vector. Can be used instead of array_size C macro. More...
struct	minmax
	Statically chooses minimum and maximum values from a set of values. More...
struct	logical_and
	Statically calculates a result of the logical AND operation upon the template parameters. More...
struct	logical_or
	Statically calculates a result of the logical OR operation upon the template parameters. More...
struct	make_Nary_type_template
	Produces a new variadic template which accept a specified number of type parameters. More...
struct	is_satisfied_by_all
	Checks if every type in a pack satisfies a specified compile-time predicate. More...
struct	is_satisfied_by_one
	Checks if at least one type in a pack satisfies a specified compile-time predicate. More...
struct	gcd_value
	Calculates the greatest common divisor of multiply template arguments at a compile time. More...
struct	get_bit_mask_by_indices_value
	Defines a static data member holding an integral value which specifies a mask of bits set with respect to indices specified as the template parameters. More...
struct	inverse_bits_value
	Defines a value field resolving to an integral value of unsigned type which holds an integral parameter Value with inverted bits, as specified by integral bit indices in a template parameter list. More...
struct	additive_group_algebraic_tag
	A containing class implements an algebraic group over addition. More...
struct	rng_algebraic_tag
	A containing class satisfies the rng_concept. More...
struct	ring_algebraic_tag
	A containing class satisfies the ring_concept. More...
struct	commutative_ring_algebraic_tag
	A containing class satisfies the commutative_ring_concept. More...
struct	division_ring_algebraic_tag
	A containing class satisfies the division_ring_concept. More...
struct	field_algebraic_tag
	A containing class satisfies the field_concept. More...
struct	not_an_algebraic_type_tag
	An explicit tag declaring that an enclosing type is not algebraic, which is useful when the type derives from an algebraic type. More...
struct	algebraic_traits
	Is a trait class that provides uniform interface to assess whether a type implements an abstract algebra structure, such as Rng, ring, field, etc. 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
	Encapsulates statically defined policy for an implementation of the Matrix class. More...
struct	matrix_execution_policy_traits
	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
	Provides a field type designating common policy for the policies given by policy_t parameter pack. More...
struct	is_matrix
	Performs compile time check whether the type T is a matrix type. More...
class	matrix_column
	Implements a column of a matrix with direct access to the elements of the matrix. More...
class	Matrix
	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
	Specializes the Matrix template for fixed-sized matrices. More...

Typedefs
template<class algebraic_tag_t , class T >
using	is_algebraic_structure = decltype(Implementation::is_algebraic_structure< algebraic_tag_t, T >(int()))
	Resolves to std::true_type if a supplied type T implements operations as required by an algebraic structure identified by an algebraic tag. More...
template<class T >
using	is_algebraic_category_defined = decltype(Implementation::algebraic_category_defined< T >(int()))
	Resolves to std::true_type if the type in the template parameter list defines and algebraic type by either defining an algebraic_category type field or being some built-in arithmetic type, like int or double. Otherwise, the template alias resolves to std::false_type.
template<class T >
using	is_additive_group = is_algebraic_structure< additive_group_algebraic_tag, T >
	Resolves to std::true_type, if the type T is declared to implement a group with an addition operation and supposed to adhere the requirements of the additive_group_concept, or to std::false_type otherwise.
template<class T >
using	is_rng = is_algebraic_structure< rng_algebraic_tag, T >
	Resolves to std::true_type, if the type is declared to implement an Rng and supposed to adhere the requirements of the rng_concept, or to std::false_type otherwise.
template<class T >
using	is_ring = is_algebraic_structure< ring_algebraic_tag, T >
	Resolves to std::true_type, if the type is declared to implement an algebraic ring and supposed to adhere the requirements of the ring_concept, or to std::false_type otherwise.
template<class T >
using	is_commutative_ring = is_algebraic_structure< commutative_ring_algebraic_tag, T >
	Resolves to std::true_type, if the type is declared to implement a commutative ring and supposed to adhere the requirements of the commutative_ring_concept, or to std::false_type otherwise.
template<class T >
using	is_division_ring = is_algebraic_structure< division_ring_algebraic_tag, T >
	Resolves to std::true_type, if the type is declared to implement a division ring and supposed to adhere the requirements of the division_ring_concept, or to std::false_type otherwise.
template<class T >
using	is_field = is_algebraic_structure< field_algebraic_tag, T >
	Resolves to std::true_type, if the type is declared to implement an algebraic field and supposed to adhere the requirements of the field_concept, or to std::false_type otherwise.
typedef matrix_execution_policy< matrix_dynamically_customizable_parallelism >	default_matrix_execution_policy
	A policy for a Matrix implementation by default.

Enumerations
enum	identity_t { additive_identity , multiplicative_identity }
	Special values to be supported as the only parameters of constructors of user-defined algebraic types. More...
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<unsigned... IndicesOfBits>
constexpr unsigned	inverse_bits (unsigned val)
	Inverses the specified bits of an integral parameter and returns the resulting value. More...
template<class T >
T &	MultiplicativeInverseMe (T &x) noexcept(Implementation::is_nothrow_invertible< T >::value)
	A helper function that calculates a multiplicative inversion of a given value of a given type and writes result to the same location as the input value. More...
template<class T >
T	MultiplicativeInverse (const T &x)
	A helper function that calculates a multiplicative inversion of a given value of a given type and returns the result. 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 namespace containing mathematical functions and components.