matrix-ops2.hpp File Reference

Operator instantiations for matrices and vectors. More...

Go to the source code of this file.

Classes
class	plll::linalg::implementation::comparison_impl< MT1, MT2 >
class	plll::linalg::implementation::DotImpl< MatrixType, MatrixType2 >
class	plll::linalg::implementation::NormSqImpl< MatrixType >
class	plll::linalg::implementation::SumImpl< MatrixType >

Namespaces
	plll
	Contains the plll library.
	plll::linalg
	Contains the matrix and vector library as long as other linear algebra functionality.

Functions
Swap functions.
template<typename T , int R, int C, typename ST , bool MO>
void	plll::linalg::swap (base_matrix< T, R, C, ST, MO > &A, base_matrix< T, R, C, ST, MO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_INLINE
	Swaps matrices A and B efficiently. More...
template<typename T , int R1, int C1, int R2, int C2, typename ST , bool MO1, bool MO2>
void	plll::linalg::swap (base_matrix< T, R1, C1, ST, MO1 > &A, base_matrix< T, R2, C2, ST, MO2 > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_INLINE
	Swaps matrices A and B efficiently. More...
template<template< typename AData > class AOp, typename AData , template< typename BData > class BOp, typename BData >
void	plll::linalg::swap (const implementation::expressions::expr< AOp, AData > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::do_swap(A, B)))
	Swaps matrices A and B componentwise. More...
template<template< typename AData > class AOp, typename AData , typename BT , int BRows, int BCols, typename BST , bool BMO>
void	plll::linalg::swap (const implementation::expressions::expr< AOp, AData > &A, base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(linalg::swap(A, implementation::expressions::make_matrix_expression(B))))
	Swaps matrices A and B componentwise. More...
template<typename AT , int ARows, int ACols, typename AST , bool AMO, template< typename BData > class BOp, typename BData >
void	plll::linalg::swap (base_matrix< AT, ARows, ACols, AST, AMO > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(linalg::swap(implementation::expressions::make_matrix_expression(A), B)))
	Swaps matrices A and B componentwise. More...
template<typename T , int ARows, int ACols, typename AST , bool AMO, int BRows, int BCols, typename BST , bool BMO>
void	plll::linalg::swap (base_matrix< T, ARows, ACols, AST, AMO > &A, base_matrix< T, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(linalg::swap(implementation::expressions::make_matrix_expression(A), implementation::expressions::make_matrix_expression(B))))
	Swaps matrices A and B componentwise. More...
Assignment functions.
template<template< typename SourceData > class SourceOp, typename SourceData , template< typename DestData > class DestOp, typename DestData , bool move>
void	plll::linalg::assign (const implementation::expressions::expr< DestOp, DestData > &destination, const implementation::expressions::expr< SourceOp, SourceData > &source, helper::BoolToType< move > ittm)
	Assigns the content of matrix source to matrix destination. Allows to force move. More...
template<template< typename SourceData > class SourceOp, typename SourceData , template< typename DestData > class DestOp, typename DestData >
void	plll::linalg::assign (const implementation::expressions::expr< DestOp, DestData > &destination, const implementation::expressions::expr< SourceOp, SourceData > &source)
	Assigns the content of matrix source to matrix destination. More...
template<typename SourceT , int SourceRows, int SourceCols, typename SourceST , bool SourceMO, template< typename DestData > class DestOp, typename DestData >
void	plll::linalg::assign (const implementation::expressions::expr< DestOp, DestData > &destination, const base_matrix< SourceT, SourceRows, SourceCols, SourceST, SourceMO > &source)
	Assigns the content of matrix source to matrix destination. More...
template<template< typename SourceData > class SourceOp, typename SourceData , typename DestT , int DestRows, int DestCols, typename DestST , bool DestMO>
void	plll::linalg::assign (base_matrix< DestT, DestRows, DestCols, DestST, DestMO > &destination, const implementation::expressions::expr< SourceOp, SourceData > &source)
	Assigns the content of matrix source to matrix destination. More...
template<typename SourceT , int SourceRows, int SourceCols, typename SourceST , bool SourceMO, typename DestT , int DestRows, int DestCols, typename DestST , bool DestMO>
void	plll::linalg::assign (base_matrix< DestT, DestRows, DestCols, DestST, DestMO > &destination, const base_matrix< SourceT, SourceRows, SourceCols, SourceST, SourceMO > &source)
	Assigns the content of matrix source to matrix destination. More...
Transpose functions.
template<template< typename SourceData > class SourceOp, typename SourceData , template< typename DestData > class DestOp, typename DestData , bool move>
void	plll::linalg::transpose (const implementation::expressions::expr< DestOp, DestData > &destination, const implementation::expressions::expr< SourceOp, SourceData > &source, helper::BoolToType< move > ittm)
	Transposes the content of matrix source and stores the result in the matrix destination. Allows to force move. More...
template<template< typename SourceData > class SourceOp, typename SourceData , template< typename DestData > class DestOp, typename DestData >
void	plll::linalg::transpose (const implementation::expressions::expr< DestOp, DestData > &destination, const implementation::expressions::expr< SourceOp, SourceData > &source)
	Transposes the content of matrix source and stores the result in the matrix destination. More...
template<typename SourceT , int SourceRows, int SourceCols, typename SourceST , bool SourceMO, template< typename DestData > class DestOp, typename DestData >
void	plll::linalg::transpose (const implementation::expressions::expr< DestOp, DestData > &destination, const base_matrix< SourceT, SourceRows, SourceCols, SourceST, SourceMO > &source)
	Transposes the content of matrix source and stores the result in the matrix destination. More...
template<template< typename SourceData > class SourceOp, typename SourceData , typename DestT , int DestRows, int DestCols, typename DestST , bool DestMO>
void	plll::linalg::transpose (base_matrix< DestT, DestRows, DestCols, DestST, DestMO > &destination, const implementation::expressions::expr< SourceOp, SourceData > &source)
	Transposes the content of matrix source and stores the result in the matrix destination. More...
template<typename SourceT , int SourceRows, int SourceCols, typename SourceST , bool SourceMO, typename DestT , int DestRows, int DestCols, typename DestST , bool DestMO>
void	plll::linalg::transpose (base_matrix< DestT, DestRows, DestCols, DestST, DestMO > &destination, const base_matrix< SourceT, SourceRows, SourceCols, SourceST, SourceMO > &source)
	Transposes the content of matrix source and stores the result in the matrix destination. More...
Operators.
template<typename T , int Rows, int Cols, typename ST , typename MT >
implementation::BinaryMatrixOperationImpl < base_matrix< T, Rows, Cols, ST, true >, MT > ::Mul_ReturnType	plll::linalg::operator* (const base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< base_matrix< T, Rows, Cols, ST, true >, MT >::multiply(A, B)))
	Computes the product of A with B. More...
template<typename T , int Rows, int Cols, typename ST >
implementation::BinaryMatrixOperationImpl < T, base_matrix< T, Rows, Cols, ST, true > >::Mul_ReturnType	plll::linalg::operator* (const T &A, const base_matrix< T, Rows, Cols, ST, true > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< T, base_matrix< T, Rows, Cols, ST, true > >::multiply(A, B)))
	Computes the product of A with B. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
implementation::BinaryMatrixOperationImpl < base_matrix< T, Rows, Cols, ST, true >, MT > ::Div_ReturnType	plll::linalg::operator/ (const base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< base_matrix< T, Rows, Cols, ST, true >, MT >::divide(A, B)))
	Computes the componentwise division of A with the scalar B. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
implementation::BinaryMatrixOperationImpl < base_matrix< T, Rows, Cols, ST, true >, MT > ::Mod_ReturnType	plll::linalg::operator% (const base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< base_matrix< T, Rows, Cols, ST, true >, MT >::modulo(A, B)))
	Computes the componentwise modulo of A with the scalar B. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
implementation::BinaryMatrixOperationImpl < base_matrix< T, Rows, Cols, ST, true >, MT > ::CwMul_ReturnType	plll::linalg::componentwise_mul (const base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< base_matrix< T, Rows, Cols, ST, true >, MT >::componentwise_mul(A, B)))
	Computes the componentwise multiplication of A with B. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
implementation::BinaryMatrixOperationImpl < base_matrix< T, Rows, Cols, ST, true >, MT > ::CwDiv_ReturnType	plll::linalg::componentwise_div (const base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< base_matrix< T, Rows, Cols, ST, true >, MT >::componentwise_div(A, B)))
	Computes the componentwise division of A with B. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
implementation::BinaryMatrixOperationImpl < base_matrix< T, Rows, Cols, ST, true >, MT > ::CwMod_ReturnType	plll::linalg::componentwise_mod (const base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< base_matrix< T, Rows, Cols, ST, true >, MT >::componentwise_mod(A, B)))
	Computes the componentwise modulo of A with B. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
implementation::BinaryMatrixOperationImpl < base_matrix< T, Rows, Cols, ST, true >, MT > ::Add_ReturnType	plll::linalg::operator+ (const base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< base_matrix< T, Rows, Cols, ST, true >, MT >::add(A, B)))
	Computes the sum of A and B. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
implementation::BinaryMatrixOperationImpl < base_matrix< T, Rows, Cols, ST, true >, MT > ::Sub_ReturnType	plll::linalg::operator- (const base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< base_matrix< T, Rows, Cols, ST, true >, MT >::sub(A, B)))
	Computes the difference of A and B. More...
template<typename T , int Rows, int Cols, typename ST >
implementation::UnaryMatrixOperationImpl < base_matrix< T, Rows, Cols, ST, true > >::Neg_ReturnType	plll::linalg::operator- (const base_matrix< T, Rows, Cols, ST, true > &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::UnaryMatrixOperationImpl< base_matrix< T, Rows, Cols, ST, true > >::negate(A)))
	Computes the negation of A. More...
template<template< typename DataType > class Operator, typename Data , typename MT >
implementation::BinaryMatrixOperationImpl < implementation::expressions::expr < Operator, Data >, MT > ::Mul_ReturnType	plll::linalg::operator* (const implementation::expressions::expr< Operator, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< implementation::expressions::expr< Operator, Data >, MT >::multiply(A, B)))
template<template< typename DataType > class Operator, typename Data >
implementation::BinaryMatrixOperationImpl < typename implementation::MatrixInfo < implementation::expressions::expr < Operator, Data > >::Type, implementation::expressions::expr < Operator, Data > >::Mul_ReturnType	plll::linalg::operator* (const typename implementation::MatrixInfo< implementation::expressions::expr< Operator, Data > >::Type &A, const implementation::expressions::expr< Operator, Data > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< typename implementation::MatrixInfo< implementation::expressions::expr< Operator, Data > >::Type, implementation::expressions::expr< Operator, Data > >::multiply(A, B)))
template<template< typename DataType > class Operator, typename Data , typename MT >
implementation::BinaryMatrixOperationImpl < implementation::expressions::expr < Operator, Data >, MT > ::Div_ReturnType	plll::linalg::operator/ (const implementation::expressions::expr< Operator, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< implementation::expressions::expr< Operator, Data >, MT >::divide(A, B)))
template<template< typename DataType > class Operator, typename Data , typename MT >
implementation::BinaryMatrixOperationImpl < implementation::expressions::expr < Operator, Data >, MT > ::Mod_ReturnType	plll::linalg::operator% (const implementation::expressions::expr< Operator, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< implementation::expressions::expr< Operator, Data >, MT >::modulo(A, B)))
template<template< typename DataType > class Operator, typename Data , typename MT >
implementation::BinaryMatrixOperationImpl < implementation::expressions::expr < Operator, Data >, MT > ::CwMul_ReturnType	plll::linalg::componentwise_mul (const implementation::expressions::expr< Operator, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< implementation::expressions::expr< Operator, Data >, MT >::componentwise_mul(A, B)))
template<template< typename DataType > class Operator, typename Data , typename MT >
implementation::BinaryMatrixOperationImpl < implementation::expressions::expr < Operator, Data >, MT > ::CwDiv_ReturnType	plll::linalg::componentwise_div (const implementation::expressions::expr< Operator, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< implementation::expressions::expr< Operator, Data >, MT >::componentwise_div(A, B)))
template<template< typename DataType > class Operator, typename Data , typename MT >
implementation::BinaryMatrixOperationImpl < implementation::expressions::expr < Operator, Data >, MT > ::CwMod_ReturnType	plll::linalg::componentwise_mod (const implementation::expressions::expr< Operator, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< implementation::expressions::expr< Operator, Data >, MT >::componentwise_mod(A, B)))
template<template< typename DataType > class Operator, typename Data , typename MT >
implementation::BinaryMatrixOperationImpl < implementation::expressions::expr < Operator, Data >, MT > ::Add_ReturnType	plll::linalg::operator+ (const implementation::expressions::expr< Operator, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< implementation::expressions::expr< Operator, Data >, MT >::add(A, B)))
template<template< typename DataType > class Operator, typename Data , typename MT >
implementation::BinaryMatrixOperationImpl < implementation::expressions::expr < Operator, Data >, MT > ::Mul_ReturnType	plll::linalg::operator- (const implementation::expressions::expr< Operator, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::BinaryMatrixOperationImpl< implementation::expressions::expr< Operator, Data >, MT >::sub(A, B)))
template<template< typename DataType > class Operator, typename Data >
implementation::UnaryMatrixOperationImpl < implementation::expressions::expr < Operator, Data > >::Neg_ReturnType	plll::linalg::operator- (const implementation::expressions::expr< Operator, Data > &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::UnaryMatrixOperationImpl< implementation::expressions::expr< Operator, Data > >::negate(A)))
Functional versions of operators.
template<typename T , int Rows, int Cols, typename ST , typename MT1 , typename MT2 >
void	plll::linalg::mul (base_matrix< T, Rows, Cols, ST, true > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::multiply(A, B))))
	Computes the product of A and B and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST , typename MT1 , typename MT2 >
void	plll::linalg::div (base_matrix< T, Rows, Cols, ST, true > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::divide(A, B))))
	Computes the componentwise division of A by B and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST , typename MT1 , typename MT2 >
void	plll::linalg::mod (base_matrix< T, Rows, Cols, ST, true > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::modulo(A, B))))
	Computes the componentwise modulo of A by B and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST , typename MT1 , typename MT2 >
void	plll::linalg::componentwise_mul (base_matrix< T, Rows, Cols, ST, true > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::componentwise_mul(A, B))))
	Computes the componentwise product of A and B and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST , typename MT1 , typename MT2 >
void	plll::linalg::componentwise_div (base_matrix< T, Rows, Cols, ST, true > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::componentwise_div(A, B))))
	Computes the componentwise division of A by B and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST , typename MT1 , typename MT2 >
void	plll::linalg::componentwise_mod (base_matrix< T, Rows, Cols, ST, true > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::componentwise_mod(A, B))))
	Computes the componentwise modulo of A by B and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST , typename MT1 , typename MT2 >
void	plll::linalg::add (base_matrix< T, Rows, Cols, ST, true > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::add(A, B))))
	Computes the sum of A and B and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST , typename MT1 , typename MT2 >
void	plll::linalg::sub (base_matrix< T, Rows, Cols, ST, true > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::sub(A, B))))
	Computes the difference of A and B and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
void	plll::linalg::neg (base_matrix< T, Rows, Cols, ST, true > &result, const MT &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::UnaryMatrixOperationImpl< MT >::negate(A))))
	Computes the negation of A and stores the result in result. More...
template<template< typename DataType > class Operator, typename Data , typename MT1 , typename MT2 >
void	plll::linalg::mul (const implementation::expressions::expr< Operator, Data > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::multiply(A, B))))
template<template< typename DataType > class Operator, typename Data , typename MT1 , typename MT2 >
void	plll::linalg::div (const implementation::expressions::expr< Operator, Data > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::divide(A, B))))
template<template< typename DataType > class Operator, typename Data , typename MT1 , typename MT2 >
void	plll::linalg::mod (const implementation::expressions::expr< Operator, Data > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::modulo(A, B))))
template<template< typename DataType > class Operator, typename Data , typename MT1 , typename MT2 >
void	plll::linalg::componentwise_mul (const implementation::expressions::expr< Operator, Data > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::componentwise_mul(A, B))))
template<template< typename DataType > class Operator, typename Data , typename MT1 , typename MT2 >
void	plll::linalg::componentwise_div (const implementation::expressions::expr< Operator, Data > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::componentwise_div(A, B))))
template<template< typename DataType > class Operator, typename Data , typename MT1 , typename MT2 >
void	plll::linalg::componentwise_mod (const implementation::expressions::expr< Operator, Data > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::componentwise_mod(A, B))))
template<template< typename DataType > class Operator, typename Data , typename MT1 , typename MT2 >
void	plll::linalg::add (const implementation::expressions::expr< Operator, Data > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::add(A, B))))
template<template< typename DataType > class Operator, typename Data , typename MT1 , typename MT2 >
void	plll::linalg::sub (const implementation::expressions::expr< Operator, Data > &result, const MT1 &A, const MT2 &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::BinaryMatrixOperationImpl< MT1, MT2 >::sub(A, B))))
template<template< typename DataType > class Operator, typename Data , typename MT >
void	plll::linalg::neg (const implementation::expressions::expr< Operator, Data > &result, const MT &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(assign(result, implementation::UnaryMatrixOperationImpl< MT >::negate(A))))
Assignment-operation operators.
template<typename T , int Rows, int Cols, typename ST , typename MT >
base_matrix< T, Rows, Cols, ST, true > &	plll::linalg::operator+= (base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)+=B))
	Adds B to the current matrix. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
base_matrix< T, Rows, Cols, ST, true > &	plll::linalg::operator-= (base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)-=B))
	Subtracts B from the current matrix. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
base_matrix< T, Rows, Cols, ST, true > &	plll::linalg::operator*= (base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)*=B))
	Multiplies the current matrix with B and stores the result in the current matrix. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
base_matrix< T, Rows, Cols, ST, true > &	plll::linalg::operator/= (base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)/=B))
	Divides the current matrix by the scalar B and stores the result in the current matrix. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
base_matrix< T, Rows, Cols, ST, true > &	plll::linalg::operator%= (base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)%=B))
	Takes the current matrix modulo the scalar B and stores the result in the current matrix. More...
template<template< typename DataType > class Op, typename Data , typename MT >
const implementation::expressions::expr < Op, Data > &	plll::linalg::operator+= (const implementation::expressions::expr< Op, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::AssignmentMatrixOperationImpl< implementation::expressions::expr< Op, Data >, MT >::add_assign(A, B)))
template<template< typename DataType > class Op, typename Data , typename MT >
const implementation::expressions::expr < Op, Data > &	plll::linalg::operator-= (const implementation::expressions::expr< Op, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::AssignmentMatrixOperationImpl< implementation::expressions::expr< Op, Data >, MT >::sub_assign(A, B)))
template<template< typename DataType > class Op, typename Data , typename MT >
const implementation::expressions::expr < Op, Data > &	plll::linalg::operator*= (const implementation::expressions::expr< Op, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::AssignmentMatrixOperationImpl< implementation::expressions::expr< Op, Data >, MT >::mul_assign(A, B)))
template<template< typename DataType > class Op, typename Data , typename MT >
const implementation::expressions::expr < Op, Data > &	plll::linalg::operator/= (const implementation::expressions::expr< Op, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::AssignmentMatrixOperationImpl< implementation::expressions::expr< Op, Data >, MT >::div_assign(A, B)))
template<template< typename DataType > class Op, typename Data , typename MT >
const implementation::expressions::expr < Op, Data > &	plll::linalg::operator%= (const implementation::expressions::expr< Op, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::AssignmentMatrixOperationImpl< implementation::expressions::expr< Op, Data >, MT >::mod_assign(A, B)))
Other operations.
template<typename RetType , typename T , int Rows, int Cols, typename ST >
void	plll::linalg::sum (RetType &result, const base_matrix< T, Rows, Cols, ST, true > &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::SumImpl< base_matrix< T, Rows, Cols, ST, true > >::sum(result, A)))
	Computes the sum of all entries of A and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST >
implementation::SumImpl < base_matrix< T, Rows, Cols, ST, true > >::RetValue	plll::linalg::sum (const base_matrix< T, Rows, Cols, ST, true > &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::SumImpl< base_matrix< T, Rows, Cols, ST, true > >::sum(A)))
	Computes the sum of all entries of A and returns the result. More...
template<typename RetType , template< typename DataType > class Operator, typename Data >
void	plll::linalg::sum (RetType &result, const implementation::expressions::expr< Operator, Data > &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::SumImpl< implementation::expressions::expr< Operator, Data > >::sum(result, A)))
template<template< typename DataType > class Operator, typename Data >
implementation::SumImpl < implementation::expressions::expr < Operator, Data > >::RetValue	plll::linalg::sum (const implementation::expressions::expr< Operator, Data > &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::SumImpl< implementation::expressions::expr< Operator, Data > >::sum(A)))
template<typename RetType , typename T , int Rows, int Cols, typename ST , typename MT >
void	plll::linalg::dot (RetType &result, const base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::DotImpl< base_matrix< T, Rows, Cols, ST, true >, MT >::dot(result, A, B)))
	Computes the dot product of A and B and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST , typename MT >
implementation::DotImpl < base_matrix< T, Rows, Cols, ST, true >, MT >::RetValue	plll::linalg::dot (const base_matrix< T, Rows, Cols, ST, true > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::DotImpl< base_matrix< T, Rows, Cols, ST, true >, MT >::dot(A, B)))
	Computes the dot product of A and B and returns the result. More...
template<typename RetType , template< typename DataType > class Operator, typename Data , typename MT >
void	plll::linalg::dot (RetType &result, const implementation::expressions::expr< Operator, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::DotImpl< implementation::expressions::expr< Operator, Data >, MT >::dot(result, A, B)))
template<template< typename DataType > class Operator, typename Data , typename MT >
implementation::DotImpl < implementation::expressions::expr < Operator, Data >, MT > ::RetValue	plll::linalg::dot (const implementation::expressions::expr< Operator, Data > &A, const MT &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::DotImpl< implementation::expressions::expr< Operator, Data >, MT >::dot(A, B)))
template<typename RetType , typename T , int Rows, int Cols, typename ST >
void	plll::linalg::normSq (RetType &result, const base_matrix< T, Rows, Cols, ST, true > &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::NormSqImpl< base_matrix< T, Rows, Cols, ST, true > >::normSq(result, A)))
	Computes the squared norm of A, i.e. the sum of the squares of all entries of A, and stores the result in result. More...
template<typename T , int Rows, int Cols, typename ST >
implementation::NormSqImpl < base_matrix< T, Rows, Cols, ST, true > >::RetValue	plll::linalg::normSq (const base_matrix< T, Rows, Cols, ST, true > &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::NormSqImpl< base_matrix< T, Rows, Cols, ST, true > >::normSq(A)))
	Computes the squared norm of A, i.e. the sum of the squares of all entries of A, and returns the result. More...
template<typename RetType , template< typename DataType > class Operator, typename Data >
void	plll::linalg::normSq (RetType &result, const implementation::expressions::expr< Operator, Data > &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::NormSqImpl< implementation::expressions::expr< Operator, Data > >::normSq(result, A)))
template<template< typename DataType > class Operator, typename Data >
implementation::NormSqImpl < implementation::expressions::expr < Operator, Data > >::RetValue	plll::linalg::normSq (const implementation::expressions::expr< Operator, Data > &A) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::NormSqImpl< implementation::expressions::expr< Operator, Data > >::normSq(A)))
template<typename T , int Rows, int Cols, typename ST , typename T1 , typename T2 >
void	plll::linalg::addmul (base_matrix< T, Rows, Cols, ST, true > &A, const T1 &B, const T2 &C)
	Computes A += B * C. More...
template<typename T , int Rows, int Cols, typename ST , typename T1 , typename T2 >
void	plll::linalg::submul (base_matrix< T, Rows, Cols, ST, true > &A, const T1 &B, const T2 &C)
	Computes A -= B * C. More...
template<template< typename DataType > class Op, typename Data , typename T1 , typename T2 >
void	plll::linalg::addmul (const implementation::expressions::expr< Op, Data > &A, const T1 &B, const T2 &C)
template<template< typename DataType > class Op, typename Data , typename T1 , typename T2 >
void	plll::linalg::submul (const implementation::expressions::expr< Op, Data > &A, const T1 &B, const T2 &C)
Comparisons.
template<template< typename AData > class AOp, typename AData , template< typename BData > class BOp, typename BData >
int	plll::linalg::compare (const implementation::expressions::expr< AOp, AData > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::comparison_impl< implementation::expressions::expr< AOp, AData >, implementation::expressions::expr< BOp, BData > >::compare(A, B)))
template<template< typename AData > class AOp, typename AData , typename BT , int BRows, int BCols, typename BST , bool BMO>
int	plll::linalg::compare (const implementation::expressions::expr< AOp, AData > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(compare(A, implementation::expressions::make_matrix_expression(B))))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, template< typename BData > class BOp, typename BData >
int	plll::linalg::compare (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(compare(implementation::expressions::make_matrix_expression(A), B)))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, typename BT , int BRows, int BCols, typename BST , bool BMO>
int	plll::linalg::compare (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(compare(implementation::expressions::make_matrix_expression(A), implementation::expressions::make_matrix_expression(B))))
	Lexicographically compares the matrices A and B. More...
template<template< typename AData > class AOp, typename AData , template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator== (const implementation::expressions::expr< AOp, AData > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::comparison_impl< implementation::expressions::expr< AOp, AData >, implementation::expressions::expr< BOp, BData > >::eq(A, B)))
template<template< typename AData > class AOp, typename AData , typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator== (const implementation::expressions::expr< AOp, AData > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(A==implementation::expressions::make_matrix_expression(B)))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator== (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)==B))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator== (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)==implementation::expressions::make_matrix_expression(B)))
	Tests A and B for equality. More...
template<template< typename AData > class AOp, typename AData , template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator!= (const implementation::expressions::expr< AOp, AData > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::comparison_impl< implementation::expressions::expr< AOp, AData >, implementation::expressions::expr< BOp, BData > >::neq(A, B)))
template<template< typename AData > class AOp, typename AData , typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator!= (const implementation::expressions::expr< AOp, AData > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(A!=implementation::expressions::make_matrix_expression(B)))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator!= (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)!=B))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator!= (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)!=implementation::expressions::make_matrix_expression(B)))
	Tests A and B for inequality. More...
template<template< typename AData > class AOp, typename AData , template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator< (const implementation::expressions::expr< AOp, AData > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::comparison_impl< implementation::expressions::expr< AOp, AData >, implementation::expressions::expr< BOp, BData > >::less(A, B)))
template<template< typename AData > class AOp, typename AData , typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator< (const implementation::expressions::expr< AOp, AData > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(A< implementation::expressions::make_matrix_expression(B)))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator< (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)< B))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator< (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)< implementation::expressions::make_matrix_expression(B)))
	Tests A and B lexicographically for A being less than B. More...
template<template< typename AData > class AOp, typename AData , template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator<= (const implementation::expressions::expr< AOp, AData > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::comparison_impl< implementation::expressions::expr< AOp, AData >, implementation::expressions::expr< BOp, BData > >::less_eq(A, B)))
template<template< typename AData > class AOp, typename AData , typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator<= (const implementation::expressions::expr< AOp, AData > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(A<=implementation::expressions::make_matrix_expression(B)))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator<= (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)<=B))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator<= (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A)<=implementation::expressions::make_matrix_expression(B)))
	Tests A and B lexicographically for A being less than or equal to B. More...
template<template< typename AData > class AOp, typename AData , template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator> (const implementation::expressions::expr< AOp, AData > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::comparison_impl< implementation::expressions::expr< AOp, AData >, implementation::expressions::expr< BOp, BData > >::greater(A, B)))
template<template< typename AData > class AOp, typename AData , typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator> (const implementation::expressions::expr< AOp, AData > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(A > implementation::expressions::make_matrix_expression(B)))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator> (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A) > B))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator> (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A) > implementation::expressions::make_matrix_expression(B)))
	Tests A and B lexicographically for A being greater than B. More...
template<template< typename AData > class AOp, typename AData , template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator>= (const implementation::expressions::expr< AOp, AData > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::comparison_impl< implementation::expressions::expr< AOp, AData >, implementation::expressions::expr< BOp, BData > >::greater_eq(A, B)))
template<template< typename AData > class AOp, typename AData , typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator>= (const implementation::expressions::expr< AOp, AData > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(A >=implementation::expressions::make_matrix_expression(B)))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, template< typename BData > class BOp, typename BData >
bool	plll::linalg::operator>= (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const implementation::expressions::expr< BOp, BData > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A) >=B))
template<typename AT , int ARows, int ACols, typename AST , bool AMO, typename BT , int BRows, int BCols, typename BST , bool BMO>
bool	plll::linalg::operator>= (const base_matrix< AT, ARows, ACols, AST, AMO > &A, const base_matrix< BT, BRows, BCols, BST, BMO > &B) PLLL_INTERNAL_NOTHROW_POSTFIX_CONDITIONAL(noexcept(implementation::expressions::make_matrix_expression(A) >=implementation::expressions::make_matrix_expression(B)))
	Tests A and B lexicographically for A being greater than or equal to B. More...

Detailed Description

Operator instantiations for matrices and vectors.

This header contains instantiations of the abstract templates in matrix-ops.hpp. They provide implementations to essentially all operations on matrices.

Definition in file matrix-ops2.hpp.