The main \( n \times m \) matrix type template Matrix_t. This is a base class type for "useful" types which are derived from this. More...

#include <matrix.h>

Public Member Functions
	Matrix_t ()=default
	Define default constructors to ensure std::is_trivial.

T	e (const int i, const int j) const
	Standard array indexing operation for matrices and vectors.

template<int q = n, int p = m, std::enable_if_t<(q==1\|\|p==1), int > = 0>
T	operator[] (const int i) const
	Indexing operation [] defined only for vectors.

RowVector< m, T >	row (int r) const
	Return row of a matrix as a RowVector.

template<typename S , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>
void	set_row (int r, const RowVector< m, S > &v)
	Set row of Matrix with RowVector if types are assignable.

Vector< n, T >	column (int c) const
	Returns column vector as value at index c.

template<typename S , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>
void	set_column (int c, const Vector< n, S > &v)
	get column of a matrix

DiagonalMatrix< n, T >	diagonal ()
	Return diagonal of square matrix.

template<typename S , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>
void	set_diagonal (const Vector< n, S > &v)
	Set diagonal of square matrix to Vector which is passed to the method.

const Array< n, m, T > &	asArray () const
	Cast Matrix to Array.

template<int mm = m, std::enable_if_t< mm==1, int > = 0>
const DiagonalMatrix< n, T > &	asDiagonalMatrix () const
	Cast Vector to DiagonalMatrix.

Mtype	operator- () const
	Unary - operator.

const auto &	operator+ () const
	Unary + operator.

template<typename S , int n2, int m2>
bool	operator== (const Matrix< n2, m2, S > &rhs) const
	Boolean operator == to determine if two matrices are exactly the same.

template<typename S >
bool	operator!= (const Matrix< n, m, S > &rhs) const
	Boolean operator != to check if matrices are exactly different.

template<typename S , typename MT , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>
auto &	operator= (const Matrix_t< n, m, S, MT > &rhs) &
	Assignment operator = to assign values to matrix.

template<typename S , typename MT , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>
auto &	operator+= (const Matrix_t< n, m, S, MT > &rhs) &
	Add assign operator with matrix or scalar.

template<typename S , typename MT , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>
auto &	operator-= (const Matrix_t< n, m, S, MT > &rhs) &
	Subtract assign operator with matrix or scalar.

template<int p, typename S , typename MT , std::enable_if_t< hila::is_assignable< T &, hila::type_mul< T, S > >::value, int > = 0>
auto &	operator*= (const Matrix_t< m, p, S, MT > &rhs) &
	Multiply assign scalar or matrix.

template<typename S , std::enable_if_t< hila::is_assignable< T &, hila::type_div< T, S > >::value, int > = 0>
auto &	operator/= (const S rhs) &
	Divide assign scalar.

template<typename S , std::enable_if_t< hila::is_assignable< T &, hila::type_plus< T, S > >::value, int > = 0>
auto &	operator+= (const DiagonalMatrix< n, S > &rhs) &
	add and sub assign a DiagonalMatrix

template<typename S , std::enable_if_t< hila::is_assignable< T &, hila::type_mul< T, S > >::value, int > = 0>
auto &	*operator=** (const DiagonalMatrix< m, S > &rhs) &
	mult and divide assign a diagonal - cols must match diagonal matrix rows

template<typename S , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>
const auto &	fill (const S rhs)
	Matrix fill.

template<int mm = m, typename Rtype = typename std::conditional<n == m, Matrix_t, Matrix<m, n, T>>::type, std::enable_if_t<(mm !=1 &&n !=1), int > = 0>
Rtype	transpose () const
	Transpose of matrix.

template<int mm = m, std::enable_if_t< mm==1, int > = 0>
const RowVector< n, T > &	transpose () const
	Transpose of vector.

Mtype	conj () const
	Returns complex conjugate of Matrix.

template<typename Rtype = typename std::conditional<n == m, Mtype, Matrix<m, n, T>>::type>
Rtype	dagger () const
	Hermitian conjugate of matrix.

template<typename Rtype = typename std::conditional<n == m, Mtype, Matrix<m, n, T>>::type>
Rtype	adjoint () const
	Adjoint of matrix.

auto	abs () const
	Returns absolute value of Matrix.

Matrix< n, m, hila::arithmetic_type< T > >	real () const
	Returns real part of Matrix or Vector.

Matrix< n, m, hila::arithmetic_type< T > >	imag () const
	Returns imaginary part of Matrix or Vector.

T	trace () const
	Computes Trace for Matrix.

template<int p, int q, typename S , typename MT >
hila::type_mul< T, S >	mul_trace (const Matrix_t< p, q, S, MT > &rm) const
	Multiply with given matrix and compute trace of result.

hila::arithmetic_type< T >	squarenorm () const
	Calculate square norm - sum of squared elements.

template<typename S = T, std::enable_if_t< hila::is_floating_point< hila::arithmetic_type< S > >::value, int > = 0>
hila::arithmetic_type< T >	norm () const
	Calculate vector norm - sqrt of squarenorm.

template<typename S = T, std::enable_if_t< hila::is_arithmetic< S >::value, int > = 0>
T	max () const
	Find max or min value - only for arithmetic types.

template<int p, int q, typename S , typename R = hila::type_mul<T, S>>
R	dot (const Matrix< p, q, S > &rhs) const
	Dot product.

template<int p, int q, typename S , typename R = hila::type_mul<T, S>>
Matrix< n, p, R >	outer_product (const Matrix< p, q, S > &rhs) const
	Outer product.

Mtype &	random ()
	dot with matrix - matrix

Mtype &	gaussian_random (base_type width=1.0)
	Fills Matrix with gaussian random elements.

Mtype	permute_columns (const Vector< m, int > &permutation) const
	permute columns of Matrix

Mtype	permute_rows (const Vector< n, int > &permutation) const
	permute rows of Matrix

template<int N>
Mtype	permute (const Vector< N, int > &permutation) const
	Permute elements of vector.

template<int N>
Mtype	sort (Vector< N, int > &permutation, hila::sort order=hila::sort::ascending) const
	Sort method for Vector.

template<typename R , typename Mt >
void	mult_by_2x2_left (int p, int q, const Matrix_t< 2, 2, R, Mt > &M)
	Multiply \( n \times m \)-matrix from the left by \( n \times m \) matrix defined by \( 2 \times 2 \) sub matrix.

template<typename R , typename Mt >
void	mult_by_2x2_right (int p, int q, const Matrix_t< 2, 2, R, Mt > &M)
	Multiply \( n \times m \)-matrix from the right by \( n \times m \) matrix defined by \( 2 \times 2 \) sub matrix.

T	det_lu () const
	following calculate the determinant of a square matrix det() is the generic interface, using laplace for small matrices and LU for large

T	det_laplace () const
	Determinant of matrix, using Laplace method.

T	det () const
	determinant function - if matrix size is < 5, use Laplace, otherwise LU

template<typename Et , typename Mt , typename MT >
int	eigen_hermitean (DiagonalMatrix< n, Et > &eigenvalues, Matrix_t< n, n, Mt, MT > &eigenvectors, enum hila::sort sorted=hila::sort::unsorted) const
	Calculate eigenvalues and -vectors of an hermitean (or symmetric) matrix.

eigen_result< Mtype >	eigen_hermitean (enum hila::sort sorted=hila::sort::unsorted) const
	eigenvalues and -vectors of hermitean/symmetric matrix, alternative interface

template<typename Et , typename Mt , typename MT >
int	svd (Matrix_t< n, n, Mt, MT > &_U, DiagonalMatrix< n, Et > &_D, Matrix_t< n, n, Mt, MT > &_V, enum hila::sort sorted=hila::sort::unsorted) const
	Singular value decomposition: divide matrix A = U S V*, where U,V unitary and S diagonal matrix of real singular values. Unpivoted Jacobi rotations.

svd_result< Mtype >	svd (enum hila::sort sorted=hila::sort::unsorted) const
	svd and svd_pivot - alternative interface

template<typename Et , typename Mt , typename MT >
int	svd_pivot (Matrix_t< n, n, Mt, MT > &_U, DiagonalMatrix< n, Et > &_D, Matrix_t< n, n, Mt, MT > &_V, enum hila::sort sorted=hila::sort::unsorted) const
	Singular value decomposition: divide matrix A = U S V*, where U,V unitary and S diagonal matrix of real singular values. Fully pivoted Jacobi rotations.

std::string	str (int prec=8, char separator=' ') const

Static Public Member Functions
static constexpr bool	is_vector ()
	Returns true if Matrix is a vector.

static constexpr bool	is_square ()
	Returns true if matrix is a square matrix.

static constexpr int	rows ()
	Define constant methods rows(), columns() - may be useful in template code.

static constexpr int	columns ()
	Returns column length.

template<int q = n, int p = m, std::enable_if_t< q==1, int > = 0>
static constexpr int	size ()
	Returns size of Vector or square Matrix.

Public Attributes
T	c [n *m]
	The data as a one dimensional array.

Detailed Description

template<const int n, const int m, typename T, typename Mtype>
class Matrix_t< n, m, T, Mtype >

The main \( n \times m \) matrix type template Matrix_t. This is a base class type for "useful" types which are derived from this.

Uses curiously recurring template pattern (CRTP), where the last template parameter is the template itself

Example: the Matrix type below is defined as

template <int n, int m, typename T>

class Matrix : public Matrix_t<n, m, T, Matrix<n, m, T>> { .. }

Matrix_t

The main matrix type template Matrix_t. This is a base class type for "useful" types which are deriv...

Definition matrix.h:106

Matrix

Matrix class which defines matrix operations.

Definition matrix.h:1620

This pattern is used because stupid c++ makes it complicated to write generic code, in this case derived functions to return derived type

Template Parameters

n	Number of rows
m	Number of columns
T	Matrix element type
Mtype	Specific "Matrix" type for CRTP

Definition at line 106 of file matrix.h.

Member Function Documentation

◆ abs()

template<const int n, const int m, typename T , typename Mtype >

auto Matrix_t< n, m, T, Mtype >::abs ( ) const

inline

Returns absolute value of Matrix.

For Matrix<n,m,Complex<T>> case type is changed to Matrix<n,m,T> as expected since absolute value of a complex number is real

Template Parameters

M

Returns: Mtype

Definition at line 1031 of file matrix.h.

◆ adjoint()

template<const int n, const int m, typename T , typename Mtype >

template<typename Rtype = typename std::conditional<n == m, Mtype, Matrix<m, n, T>>::type>

Rtype Matrix_t< n, m, T, Mtype >::adjoint ( ) const

inline

Adjoint of matrix.

Alias to dagger

Template Parameters

std::conditional<n,Mtype,Matrix<m,n,T>>::type

Returns: Rtype

Definition at line 1019 of file matrix.h.

◆ asArray()

template<const int n, const int m, typename T , typename Mtype >

const Array< n, m, T > & Matrix_t< n, m, T, Mtype >::asArray ( ) const

inline

Cast Matrix to Array.

used for array operations

Returns: Array<n, m, T>&

Definition at line 443 of file matrix.h.

◆ asDiagonalMatrix()

template<const int n, const int m, typename T , typename Mtype >

template<int mm = m, std::enable_if_t< mm==1, int > = 0>

const DiagonalMatrix< n, T > & Matrix_t< n, m, T, Mtype >::asDiagonalMatrix ( ) const

inline

Cast Vector to DiagonalMatrix.

Returns: DiagonalMatrix<n,T>

Definition at line 458 of file matrix.h.

◆ column()

template<const int n, const int m, typename T , typename Mtype >

Vector< n, T > Matrix_t< n, m, T, Mtype >::column ( int c ) const

inline

Returns column vector as value at index c.

Parameters

c	index of column vector to be returned

Returns: const Vector<n, T>

Definition at line 368 of file matrix.h.

◆ columns()

template<const int n, const int m, typename T , typename Mtype >

static constexpr int Matrix_t< n, m, T, Mtype >::columns ( )

inlinestaticconstexpr

Returns column length.

Returns: constexpr int

Definition at line 234 of file matrix.h.

◆ conj()

template<const int n, const int m, typename T , typename Mtype >

Mtype Matrix_t< n, m, T, Mtype >::conj ( ) const

inline

Returns complex conjugate of Matrix.

Returns: const Mtype

Definition at line 986 of file matrix.h.

◆ dagger()

template<const int n, const int m, typename T , typename Mtype >

template<typename Rtype = typename std::conditional<n == m, Mtype, Matrix<m, n, T>>::type>

Rtype Matrix_t< n, m, T, Mtype >::dagger ( ) const

inline

Hermitian conjugate of matrix.

for square matrix return type is same, for non square it is Matrix<m,n,MyType>

Template Parameters

std::conditional<n,Mtype,Matrix<m,n,T>>::type

Returns: const Rtype

Definition at line 1002 of file matrix.h.

◆ det_laplace()

template<int n, int m, typename T , typename Mtype >

T Matrix_t< n, m, T, Mtype >::det_laplace

Determinant of matrix, using Laplace method.

Defined only for square matrices

For perfomance overloads exist for \( 1 \times 1 \), \( 2 \times 2 \) and \( 3 \times 3 \) matrices.

Parameters

mat	matrix to compute determinant for

Returns: T result determinant

Definition at line 636 of file matrix_linalg.h.

◆ det_lu()

template<int n, int m, typename T , typename Mtype >

T Matrix_t< n, m, T, Mtype >::det_lu

following calculate the determinant of a square matrix det() is the generic interface, using laplace for small matrices and LU for large

Matrix determinant with LU decomposition.

Algorithm: numerical Recipes, 2nd ed. p. 47 ff Works for Real and Complex matrices Defined only for square matrices

Returns: Complex<radix> Determinant

Definition at line 676 of file matrix_linalg.h.

◆ diagonal()

template<const int n, const int m, typename T , typename Mtype >

DiagonalMatrix< n, T > Matrix_t< n, m, T, Mtype >::diagonal ( )

inline

Return diagonal of square matrix.

If called for non square matrix the program will throw an error.

Returns: Vector<n, T> returned vector.

Definition at line 406 of file matrix.h.

◆ dot()

template<const int n, const int m, typename T , typename Mtype >

template<int p, int q, typename S , typename R = hila::type_mul<T, S>>

R Matrix_t< n, m, T, Mtype >::dot ( const Matrix< p, q, S > & rhs ) const

inline

Dot product.

Only works between two Vector objects

Vector<m,MyType> V,W;
.
.
.
V.dot(W); // valid operation

RowVector<m,MyType> V,W;
.
.
.
V.dot(W); // not valid operation

Template Parameters

p	Row length for rhs
q	Column length for rhs
S	Type for rhs
R	Gives resulting type of lhs and rhs multiplication

Parameters

rhs	Vector to compute dot product with

Returns: R Value of dot product

Definition at line 1220 of file matrix.h.

◆ e()

template<const int n, const int m, typename T , typename Mtype >

T Matrix_t< n, m, T, Mtype >::e	(	const int	i,
		const int	j
	)		const

inline

Standard array indexing operation for matrices and vectors.

Accessing singular elements is insufficient, but matrix elements are often quite small.

Exammple for matrix:

Matrix<n,m,MyType> M;

MyType a = M.e(i,j); \\ i <= n, j <= m

Complex

Complex definition.

Definition cmplx.h:56

Matrix_t::e

T e(const int i, const int j) const

Standard array indexing operation for matrices and vectors.

Definition matrix.h:286

Example for vector:

Vector<n,MyType> V;

MyType a = V.e(i) \\ i <= n

Parameters

i	row index
j	column index

Returns: T matrix element type

Definition at line 286 of file matrix.h.

◆ eigen_hermitean() [1/2]

template<int n, int m, typename T , typename Mtype >

template<typename Et , typename Mt , typename MT >

int Matrix_t< n, m, T, Mtype >::eigen_hermitean	(	DiagonalMatrix< n, Et > &	E,
		Matrix_t< n, n, Mt, MT > &	U,
		enum hila::sort	sorted = `hila::sort::unsorted`
	)		const

Calculate eigenvalues and -vectors of an hermitean (or symmetric) matrix.

Calculate eigenvalues and vectors of an hermitean or real symmetric matrix.

Returns the number of Jacobi iterations, or -1 if did not converge. Arguments will contain eigenvalues and eigenvectors in columns of the "eigenvectors" matrix. Computation is done in double precision despite the input matrix types.

Parameters

eigenvaluevec	Vector of computed eigenvalue
eigenvectors	Eigenvectors as columns of \( n \times n \) Matrix

Algorithm uses fully pivoted Jacobi rotations.

Two interfaces:

H.eigen_hermitean(E, U, [optional: sort]); E: output is DiagnoalMatrix containing real eigenvalues U: nxn unitary matrix, columns are normalized eigenvectors

auto res = H.eigen_hermitean([optional: sort]); This saves the trouble of defining E and U (see below)

Thus, H = U E U^* and H U = U E

Both interfaces allow optional sorting according to eigenvalues: hila::sort::unsorted [default] hila::sort::ascending / descending

Example:

SquareMatrix<n,Complex<double>> M;
M = ... // make unitary
DiagonalMatrix<n,double> eigenvalues;
SquareMatrix<n,Complex<double>> eigenvectors;
 
int rotations = M.eigen_hermitean(eigenvalues,eigenvectors,hila::sort::ascending);

Note: The matrix has to be hermitean/symmetric

Parameters

E	diagonal matrix of real eigenvalues
U	Unitary nxn matrix of eigenvectors
sorted	sorting of eigenvalues (default:unsorted)

Returns: int number of jacobi rotations

Definition at line 200 of file matrix_linalg.h.

◆ eigen_hermitean() [2/2]

template<int n, int m, typename T , typename Mtype >

eigen_result< Mtype > Matrix_t< n, m, T, Mtype >::eigen_hermitean ( enum hila::sort sorted = hila::sort::unsorted ) const

eigenvalues and -vectors of hermitean/symmetric matrix, alternative interface

result = eigen_hermitean(hila::sort [optional]) returns struct eigen_result<Mtype>, with fields eigenvalues: DiagonalMatrix of eigenvalues eigenvectors: nxn unitary matrix of eigenvectors

Example:

Field<SquareMatrix<n,double>> M, sn;
M[ALL] = .. // make symmetric
 
onsites(ALL) {
    auto R = M[X].svd();
 
    // Use EV decomposition to evaluate function: sin(M) = U sin(eigenvals) U^T
    sn[X] = R.eigenvectors * sin(R.eigenvalues) * R.eigenvectors.dagger();
}

This interface saves the trouble of defining the eigenvalue and -vector variables.

Definition at line 306 of file matrix_linalg.h.

◆ fill()

template<const int n, const int m, typename T , typename Mtype >

template<typename S , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>

const auto & Matrix_t< n, m, T, Mtype >::fill ( const S rhs )

inline

Matrix fill.

Fills the matrix with element if it is assignable to matrix type T

Works as follows:

Matrix<n,m,MyType> M;

M.fill(2) \\ Matrix is filled with 2

Matrix_t::fill

const auto & fill(const S rhs)

Matrix fill.

Definition matrix.h:937

Template Parameters

S	Element type to be assigned

Parameters

rhs	Element to fill matrix with

Returns: const Mtype&

Definition at line 937 of file matrix.h.

◆ gaussian_random()

template<const int n, const int m, typename T , typename Mtype >

Mtype & Matrix_t< n, m, T, Mtype >::gaussian_random ( base_type width = 1.0 )

inline

Fills Matrix with gaussian random elements.

Works only for real valued elements such as float or double

Parameters

width

Returns: Mtype&

Definition at line 1314 of file matrix.h.

◆ imag()

template<const int n, const int m, typename T , typename Mtype >

Matrix< n, m, hila::arithmetic_type< T > > Matrix_t< n, m, T, Mtype >::imag ( ) const

inline

Returns imaginary part of Matrix or Vector.

Returns: Matrix<n, m, hila::arithmetic_type<T>>

Definition at line 1064 of file matrix.h.

◆ is_square()

template<const int n, const int m, typename T , typename Mtype >

static constexpr bool Matrix_t< n, m, T, Mtype >::is_square ( )

inlinestaticconstexpr

Returns true if matrix is a square matrix.

Returns: true; false

Definition at line 142 of file matrix.h.

◆ is_vector()

template<const int n, const int m, typename T , typename Mtype >

static constexpr bool Matrix_t< n, m, T, Mtype >::is_vector ( )

inlinestaticconstexpr

Returns true if Matrix is a vector.

Returns: true; false

Definition at line 132 of file matrix.h.

◆ mul_trace()

template<const int n, const int m, typename T , typename Mtype >

template<int p, int q, typename S , typename MT >

hila::type_mul< T, S > Matrix_t< n, m, T, Mtype >::mul_trace ( const Matrix_t< p, q, S, MT > & rm ) const

inline

Multiply with given matrix and compute trace of result.

Slightly cheaper operation than

(M*N).trace()

Matrix_t::trace

T trace() const

Computes Trace for Matrix.

Definition matrix.h:1079

Template Parameters

p
q
S
MT

Parameters

rm

Returns: hila::type_mul<T, S>

Definition at line 1100 of file matrix.h.

◆ mult_by_2x2_left()

template<const int n, const int m, typename T , typename Mtype >

template<typename R , typename Mt >

void Matrix_t< n, m, T, Mtype >::mult_by_2x2_left	(	int	p,
		int	q,
		const Matrix_t< 2, 2, R, Mt > &	M
	)

inline

Multiply \( n \times m \)-matrix from the left by \( n \times m \) matrix defined by \( 2 \times 2 \) sub matrix.

The multiplication is defined as follows, let \(M\) as the \( 2 \times 2 \) input matrix and \(B\) be (this) matrix, being the matrix stored in the object this method is called for. Let \(A = I\) be a \( n \times m \) unit matrix. We then set the values of A to be:

\begin{align} A_{p,p} = M_{0,0}, \hspace{5px} A_{p,q} = M_{0,1}, \hspace{5px} A_{q,p} = M_{1,0}, \hspace{5px} A_{q,q} = M_{1,1}. \end{align}

Then the resulting matrix will be:

\begin{align} B = A \cdot B \end{align}

Template Parameters

R	Element type of M
Mt	Matrix type of M

Parameters

p	First row and column
q	Second row and column
M	\( 2 \times 2\) Matrix to multiply with

Definition at line 1473 of file matrix.h.

◆ mult_by_2x2_right()

template<const int n, const int m, typename T , typename Mtype >

template<typename R , typename Mt >

void Matrix_t< n, m, T, Mtype >::mult_by_2x2_right	(	int	p,
		int	q,
		const Matrix_t< 2, 2, R, Mt > &	M
	)

inline

Multiply \( n \times m \)-matrix from the right by \( n \times m \) matrix defined by \( 2 \times 2 \) sub matrix.

See Matrix::mult_by_2x2_left, only difference being that the multiplication is from the right.

Template Parameters

R	Element type of M
Mt	Matrix type of M

Parameters

p	First row and column
q	Second row and column
M	\( 2 \times 2\) Matrix to multiply with

Definition at line 1502 of file matrix.h.

◆ norm()

template<const int n, const int m, typename T , typename Mtype >

template<typename S = T, std::enable_if_t< hila::is_floating_point< hila::arithmetic_type< S > >::value, int > = 0>

hila::arithmetic_type< T > Matrix_t< n, m, T, Mtype >::norm ( ) const

inline

Calculate vector norm - sqrt of squarenorm.

Template Parameters

S

Returns: hila::arithmetic_type<T>

Definition at line 1133 of file matrix.h.

◆ operator!=()

template<const int n, const int m, typename T , typename Mtype >

template<typename S >

bool Matrix_t< n, m, T, Mtype >::operator!= ( const Matrix< n, m, S > & rhs ) const

inline

Boolean operator != to check if matrices are exactly different.

if matrices are exactly the same then this will return false

Template Parameters

S	Type for MAtrix which is being compared to

Parameters

rhs	right hand side Matrix which we are comparing

Returns: true; false

Definition at line 544 of file matrix.h.

◆ operator*=()

template<const int n, const int m, typename T , typename Mtype >

template<int p, typename S , typename MT , std::enable_if_t< hila::is_assignable< T &, hila::type_mul< T, S > >::value, int > = 0>

auto & Matrix_t< n, m, T, Mtype >::operator*= ( const Matrix_t< m, p, S, MT > & rhs ) &

inline

Multiply assign scalar or matrix.

Multiplication works as defined for matrix multiplication and scalar matrix multiplication.

Matrix multiply assign only defined for square matrices, since the matrix dimensions would change otherwise.

Multiply assign operator can be used in the following ways

Multiply assign matrix:

Matrix<n,m,MyType> M,N;
.
. Fill matrices M and N
.
M *= N; \\ M = M*N

Multiply assign scalar:

Matrix<n,m,MyType> M;
.
. Fill whole matrix with 1
.
M *= 2 ; \\ M is filled with 2

Parameters

rhs	Matrix to multiply with

Returns: template <int p, typename S, typename MT, std::enable_if_t<hila::is_assignable<T &, hila::type_mul<T, S>>::value, int> = 0>&

Definition at line 796 of file matrix.h.

◆ operator+()

template<const int n, const int m, typename T , typename Mtype >

const auto & Matrix_t< n, m, T, Mtype >::operator+ ( ) const

inline

Unary + operator.

Equivalent to identity operator meaning that matrix stays as is.

Returns: const Mtype&

Definition at line 507 of file matrix.h.

◆ operator+=() [1/2]

template<const int n, const int m, typename T , typename Mtype >

template<typename S , std::enable_if_t< hila::is_assignable< T &, hila::type_plus< T, S > >::value, int > = 0>

auto & Matrix_t< n, m, T, Mtype >::operator+= ( const DiagonalMatrix< n, S > & rhs ) &

inline

add and sub assign a DiagonalMatrix

This is possible only for square matrices

Definition at line 877 of file matrix.h.

◆ operator+=() [2/2]

template<const int n, const int m, typename T , typename Mtype >

template<typename S , typename MT , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>

auto & Matrix_t< n, m, T, Mtype >::operator+= ( const Matrix_t< n, m, S, MT > & rhs ) &

inline

Add assign operator with matrix or scalar.

Add assign operator can be used in the following ways

Add assign matrix:

Matrix<n,m,MyType> M,N;
M = 1;
N = 1;
M += N; \\M = 2*I

Add assign scalar:

Adds scalar \( a \) to square matrix as \( M + a\cdot\mathbb{1} \)

Matrix<n,m,MyType> M = 1;

M += 1 ; \\ M = 2*I

Template Parameters

S	Element type of rhs
MT	Matrix type of rhs

Parameters

rhs	Matrix to add

Returns: Mtype&

Definition at line 690 of file matrix.h.

◆ operator-()

template<const int n, const int m, typename T , typename Mtype >

Mtype Matrix_t< n, m, T, Mtype >::operator- ( ) const

inline

Unary - operator.

casting from one Matrix (number) type to another: do not do this automatically. but require an explicit cast operator. This makes it easier to write code. or should it be automatic? keep/remove explicit? TODO: CHECK AVX CONVERSIONS

Returns matrix with the signs of all the elements in the Matrix flipped.

Returns: Mtype

Definition at line 493 of file matrix.h.

◆ operator-=()

template<const int n, const int m, typename T , typename Mtype >

template<typename S , typename MT , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>

auto & Matrix_t< n, m, T, Mtype >::operator-= ( const Matrix_t< n, m, S, MT > & rhs ) &

inline

Subtract assign operator with matrix or scalar.

Subtract assign operator can be used in the following ways

Subtract assign matrix:

Matrix<n,m,MyType> M,N;
M = 3;
N = 1;
M -= N; \\M = 2*I

Subtract assign scalar:

Subtract scalar \( a \) to square matrix as \( M - a\cdot\mathbb{1} \)

Matrix<n,m,MyType> M = 3;

M -= 1 ; \\ M = 2*I

Parameters

rhs	Matrix to subtract with

Returns: template <typename S, typename MT, std::enable_if_t<hila::is_assignable<T &, S>::value, int> = 0>&

Definition at line 726 of file matrix.h.

◆ operator/=()

template<const int n, const int m, typename T , typename Mtype >

template<typename S , std::enable_if_t< hila::is_assignable< T &, hila::type_div< T, S > >::value, int > = 0>

auto & Matrix_t< n, m, T, Mtype >::operator/= ( const S rhs ) &

inline

Divide assign scalar.

Divide works as defined for scalar matrix division.

Division assign operator can be used in the following ways

Divide assign scalar:

Matrix<n,m,MyType> M;
.
. Fill whole matrix with 2
.
M /= 2 ; \\ M is filled with 1

Parameters

rhs	Matrix to divide with

Returns: template <int p, typename S, typename MT, std::enable_if_t<hila::is_assignable<T &, hila::type_mul<T, S>>::value, int> = 0>&

Definition at line 863 of file matrix.h.

◆ operator=()

template<const int n, const int m, typename T , typename Mtype >

template<typename S , typename MT , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>

auto & Matrix_t< n, m, T, Mtype >::operator= ( const Matrix_t< n, m, S, MT > & rhs ) &

inline

Assignment operator = to assign values to matrix.

The following ways to assign a matrix are:

Assignment from Matrix:

Matrix<n,m,MyType> M_0;
.
. M_0 has values assigned to it
.
Matrix<n,m,MyType> M; \\ undefined matrix
M = M_0; \\ Assignment from M_0

Assignment from 0:

Matrix<n,m,MyType> M;

M = 0; Zero matrix;

Assignment from scalar:

Assignment from scalar assigns the scalar to the diagonal elements as \( M = I\cdot a\)

MyType a = hila::random;
Matrix<n,m,MyType> M;
M = a; M = I*a

Initializer list:

Assignment from c++ initializer list.

Matrix<2,2,int> M ;
M = {1, 0
     0, 1};

Definition at line 594 of file matrix.h.

◆ operator==()

template<const int n, const int m, typename T , typename Mtype >

template<typename S , int n2, int m2>

bool Matrix_t< n, m, T, Mtype >::operator== ( const Matrix< n2, m2, S > & rhs ) const

inline

Boolean operator == to determine if two matrices are exactly the same.

Tolerance for equivalence is zero, meaning that the matrices must be exactly the same.

Template Parameters

S	Type for Matrix which is being compared to

Parameters

rhs	right hand side Matrix which we are comparing

Returns: true; false

Definition at line 522 of file matrix.h.

◆ operator[]()

template<const int n, const int m, typename T , typename Mtype >

template<int q = n, int p = m, std::enable_if_t<(q==1||p==1), int > = 0>

T Matrix_t< n, m, T, Mtype >::operator[] ( const int i ) const

inline

Indexing operation [] defined only for vectors.

Example:

Vector<n,MyType> V;

MyType a = V[i] \\ i <= n

Template Parameters

q	row size n
p	column size m

Parameters

i	row or vector index depending on which is being indexed

Returns: T

Definition at line 327 of file matrix.h.

◆ outer_product()

template<const int n, const int m, typename T , typename Mtype >

template<int p, int q, typename S , typename R = hila::type_mul<T, S>>

Matrix< n, p, R > Matrix_t< n, m, T, Mtype >::outer_product ( const Matrix< p, q, S > & rhs ) const

inline

Outer product.

Only works between two Vector objects

Vector<n,MyType> V,W;
.
.
.
V.outer_product(W); \\ Valid operation

RowVector<m,MyType> V,W;
.
.
.
V.outer_product(W); // not valid operation

Template Parameters

p	Row length for rhs
q	Column length for rhs
S	Element type for rhs
R	Type between lhs and rhs multiplication

Parameters

rhs	Vector to compute outer product with

Returns: Matrix<n, p, R>

Definition at line 1263 of file matrix.h.

◆ permute()

template<const int n, const int m, typename T , typename Mtype >

template<int N>

Mtype Matrix_t< n, m, T, Mtype >::permute ( const Vector< N, int > & permutation ) const

inline

Permute elements of vector.

Reordering is done based off of permutation vector

Parameters

permutation Vector of integers to permute rows

Returns: Mtype

Definition at line 1377 of file matrix.h.

◆ permute_columns()

template<const int n, const int m, typename T , typename Mtype >

Mtype Matrix_t< n, m, T, Mtype >::permute_columns ( const Vector< m, int > & permutation ) const

inline

permute columns of Matrix

Reordering is done based off of permutation vector

Parameters

permutation Vector of integers to permute columns

Returns: Mtype

Definition at line 1347 of file matrix.h.

◆ permute_rows()

template<const int n, const int m, typename T , typename Mtype >

Mtype Matrix_t< n, m, T, Mtype >::permute_rows ( const Vector< n, int > & permutation ) const

inline

permute rows of Matrix

Reordering is done based off of permutation vector

Parameters

permutation Vector of integers to permute rows

Returns: Mtype

Definition at line 1361 of file matrix.h.

◆ random()

template<const int n, const int m, typename T , typename Mtype >

Mtype & Matrix_t< n, m, T, Mtype >::random ( )

inline

dot with matrix - matrix

Generate random elements

Fills Matrix with random elements

Works only for real valued elements such as float or double

Returns: Mtype&

Definition at line 1296 of file matrix.h.

◆ real()

template<const int n, const int m, typename T , typename Mtype >

Matrix< n, m, hila::arithmetic_type< T > > Matrix_t< n, m, T, Mtype >::real ( ) const

inline

Returns real part of Matrix or Vector.

Returns: Matrix<n, m, hila::arithmetic_type<T>>

Definition at line 1051 of file matrix.h.

◆ row()

template<const int n, const int m, typename T , typename Mtype >

RowVector< m, T > Matrix_t< n, m, T, Mtype >::row ( int r ) const

inline

Return row of a matrix as a RowVector.

Parameters

r	index of row to be referenced

Returns: const RowVector<m, T>&

Definition at line 342 of file matrix.h.

◆ rows()

template<const int n, const int m, typename T , typename Mtype >

static constexpr int Matrix_t< n, m, T, Mtype >::rows ( )

inlinestaticconstexpr

Define constant methods rows(), columns() - may be useful in template code.

Returns row length

Returns: constexpr int

Definition at line 226 of file matrix.h.

◆ set_column()

template<const int n, const int m, typename T , typename Mtype >

template<typename S , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>

void Matrix_t< n, m, T, Mtype >::set_column	(	int	c,
		const Vector< n, S > &	v
	)

inline

get column of a matrix

Set column of Matrix with Vector if types are assignable

Template Parameters

S	Vector type

Parameters

c	Index of column to be set
v	Vector to be set

Definition at line 395 of file matrix.h.

◆ set_diagonal()

template<const int n, const int m, typename T , typename Mtype >

template<typename S , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>

void Matrix_t< n, m, T, Mtype >::set_diagonal ( const Vector< n, S > & v )

inline

Set diagonal of square matrix to Vector which is passed to the method.

If called for non square matrix the program will throw an error.

Example:

SquareMatrix<n,MyType> S = 0; \\ Zero matrix
Vector<n,MyType> V = 1; \\ Vector assigned to 1 at all elements
S.set_diagonal(V); \\ Results in Identity matrix of size n

Template Parameters

S	type vector to assign values to

Parameters

v	Vector to assign to diagonal

Definition at line 430 of file matrix.h.

◆ set_row()

template<const int n, const int m, typename T , typename Mtype >

template<typename S , std::enable_if_t< hila::is_assignable< T &, S >::value, int > = 0>

void Matrix_t< n, m, T, Mtype >::set_row	(	int	r,
		const RowVector< m, S > &	v
	)

inline

Set row of Matrix with RowVector if types are assignable.

Template Parameters

S	RowVector type

Parameters

r	Index of row to be set
v	RowVector to be set

Definition at line 357 of file matrix.h.

◆ size()

template<const int n, const int m, typename T , typename Mtype >

template<int q = n, int p = m, std::enable_if_t< q==1, int > = 0>

static constexpr int Matrix_t< n, m, T, Mtype >::size ( )

inlinestaticconstexpr

Returns size of Vector or square Matrix.

Template Parameters

q	row size n
p	column size m

Returns: constexpr int

Definition at line 248 of file matrix.h.

◆ sort()

template<const int n, const int m, typename T , typename Mtype >

template<int N>

Mtype Matrix_t< n, m, T, Mtype >::sort	(	Vector< N, int > &	permutation,
		hila::sort	order = `hila::sort::ascending`
	)		const

inline

Sort method for Vector.

Two interfaces: first returns permutation vector, which can be used to permute other vectors/matrices second does only sort

Direct sort:

Vector<n,MyType> V;
V.random();
V.sort(); // V is sorted

Permutation vector:

Vector<n,MyType> V;
Vector<n,int> perm;
V.random();
V.sort(perm);
V.permute(perm); // V is sorted

Definition at line 1416 of file matrix.h.

◆ squarenorm()

template<const int n, const int m, typename T , typename Mtype >

hila::arithmetic_type< T > Matrix_t< n, m, T, Mtype >::squarenorm ( ) const

inline

Calculate square norm - sum of squared elements.

Returns: hila::arithmetic_type<T>

Definition at line 1117 of file matrix.h.

◆ str()

template<const int n, const int m, typename T , typename Mtype >

std::string Matrix_t< n, m, T, Mtype >::str	(	int	prec = `8`,
		char	separator = `' '`
	)		const

inline

Convert to string for printing

Definition at line 1587 of file matrix.h.

◆ svd() [1/2]

template<int n, int m, typename T , typename Mtype >

svd_result< Mtype > Matrix_t< n, m, T, Mtype >::svd ( enum hila::sort sorted = hila::sort::unsorted ) const

svd and svd_pivot - alternative interface

svd(hila::sort [optional]) returns struct svd_result<Mtype>, with fields U: nxn unitary matrix singularvalues: DiagonalMatrix of singular values (real, > 0) V: nxn unitary matrix

auto res = M.svd(); now res.U : nxn unitary res.singularvalues : DiagonalMatrix of singular values res.V : nxn unitary

result satifies M = res.U res.singularvalues res.V.dagger()

Definition at line 576 of file matrix_linalg.h.

◆ svd() [2/2]

template<int n, int m, typename T , typename Mtype >

template<typename Et , typename Mt , typename MT >

int Matrix_t< n, m, T, Mtype >::svd	(	Matrix_t< n, n, Mt, MT > &	_U,
		DiagonalMatrix< n, Et > &	_S,
		Matrix_t< n, n, Mt, MT > &	_V,
		enum hila::sort	sorted = `hila::sort::unsorted`
	)		const

Singular value decomposition: divide matrix A = U S V*, where U,V unitary and S diagonal matrix of real singular values. Unpivoted Jacobi rotations.

Unpivoted rotation is generally faster than pivoted (esp. on gpu), but a bit less accurate

Use: M.svd(U, S, V, [sorted]);

Result satisfies M = U S V.dagger()

The algorithm works by one-sided Jacobi rotations.

U = V = 1
Loop
- for i=0..(n-2); j=(i+1)..(n-1)
  - calculate B_ii, B_ij, B_jj, (B_ij = (A^* A)_ij)
  - If B_ij > 0
    - diagonalize J^* [ B_ii B_ij ] J = diag(D_ii, D_jj) [ B_ji B_jj ]
    - A <- A J , Columns i and j change
    - V <- V J
- endfor
- if nothing changed, break Loop
Endloop Now A = U S, A^* A = S* S = S^2
S_ii = A_ii / |A_i| (norm of column i)
U = A / S

Definition at line 468 of file matrix_linalg.h.

◆ svd_pivot()

template<int n, int m, typename T , typename Mtype >

template<typename Et , typename Mt , typename MT >

int Matrix_t< n, m, T, Mtype >::svd_pivot	(	Matrix_t< n, n, Mt, MT > &	_U,
		DiagonalMatrix< n, Et > &	_S,
		Matrix_t< n, n, Mt, MT > &	_V,
		enum hila::sort	sorted = `hila::sort::unsorted`
	)		const

Singular value decomposition: divide matrix A = U S V*, where U,V unitary and S diagonal matrix of real singular values. Fully pivoted Jacobi rotations.

Use: M.svd_pivot(U, S, V, [sorted]);

The algorithm works by one-sided Jacobi rotations.

U = V = 1
Compute Gram matrix B = A^* A. B is Hermitean, with B_ii >= 0.
Loop:
- Find largest B_ij, j > i - full pivoting if |B_ij|^2 <= tol * B_ii B_jj we're done
- find J to diagonalize J^* [ B_ii B_ij ] J = diag(D_ii, D_jj) [ B_ji B_jj ]
- A <- A J , Columns i and j change
- V <- V J
- Recompute B_ik and B_jk, k /= i,j (B_ii = D_ii, B_jj = D_jj, B_ij = 0) (n^2)
Endloop Now A = U S, A^* A = S* S = S^2
S_ii = A_ii / |A_i| (norm of column i)
U = A / S

Parameters

U

Definition at line 344 of file matrix_linalg.h.

◆ trace()

template<const int n, const int m, typename T , typename Mtype >

T Matrix_t< n, m, T, Mtype >::trace ( ) const

inline

Computes Trace for Matrix.

Not define for non square matrices. Static assert will stop code from compiling if executed for non square matrices.

Returns: T

Definition at line 1079 of file matrix.h.

◆ transpose() [1/2]

template<const int n, const int m, typename T , typename Mtype >

template<int mm = m, typename Rtype = typename std::conditional<n == m, Matrix_t, Matrix<m, n, T>>::type, std::enable_if_t<(mm !=1 &&n !=1), int > = 0>

Rtype Matrix_t< n, m, T, Mtype >::transpose ( ) const

inline

Transpose of matrix.

Return type for square matrix is same input, for non square return type is Matrix<n,m,MyType>

Template Parameters

mm
std::conditional<n,Mtype,Matrix<m,n,T>>::type

Returns: const Rtype

Definition at line 954 of file matrix.h.

◆ transpose() [2/2]

template<const int n, const int m, typename T , typename Mtype >

template<int mm = m, std::enable_if_t< mm==1, int > = 0>

const RowVector< n, T > & Matrix_t< n, m, T, Mtype >::transpose ( ) const

inline

Transpose of vector.

Returns reference

Template Parameters

mm

Returns: const RowVector<n, T>&

Definition at line 971 of file matrix.h.

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ abs()

◆ adjoint()

◆ asArray()

◆ asDiagonalMatrix()

◆ column()

◆ columns()

◆ conj()

◆ dagger()

◆ det_laplace()

◆ det_lu()

◆ diagonal()

◆ dot()

◆ e()

◆ eigen_hermitean() [1/2]

◆ eigen_hermitean() [2/2]

◆ fill()

◆ gaussian_random()

◆ imag()

◆ is_square()

◆ is_vector()

◆ mul_trace()

◆ mult_by_2x2_left()

◆ mult_by_2x2_right()

◆ norm()

◆ operator!=()

◆ operator*=()

◆ operator+()

◆ operator+=() [1/2]

◆ operator+=() [2/2]

◆ operator-()

◆ operator-=()

◆ operator/=()

◆ operator=()

◆ operator==()

◆ operator[]()

◆ outer_product()

◆ permute()

◆ permute_columns()

◆ permute_rows()

◆ random()

◆ real()

◆ row()

◆ rows()

◆ set_column()

◆ set_diagonal()

◆ set_row()

◆ size()

◆ sort()

◆ squarenorm()

◆ str()

◆ svd() [1/2]

◆ svd() [2/2]

◆ svd_pivot()

◆ trace()

◆ transpose() [1/2]

◆ transpose() [2/2]