ampsci
High-precision calculations for one- and two-valence atomic systems
LinAlg::Matrix< T >

Matrix class; row-major. More...

#include <Matrix.hpp>

+ Inheritance diagram for LinAlg::Matrix< T >:

Public Member Functions

 Matrix ()
 Default initialiser.
 
 Matrix (std::size_t rows, std::size_t cols)
 Initialise a blank matrix rows*cols, filled with 0.
 
 Matrix (std::size_t rows, std::size_t cols, const T &value)
 Initialise a matrix rows*cols, filled with 'value'.
 
 Matrix (std::size_t dimension)
 Initialise a blank square matrix dimension*dimension, filled with 0.
 
 Matrix (std::initializer_list< std::initializer_list< T > > ll)
 Initialise a matrix from initialiser list. {{},{},{}}. Each row must be same length.
 
 Matrix (std::size_t rows, std::size_t cols, std::initializer_list< T > l)
 Initialise a matrix from single initialiser list. {...}.
 
 Matrix (std::size_t rows, std::size_t cols, std::vector< T > &&v)
 Initialise a matrix from single initialiser list. {...}.
 
 Matrix (std::size_t rows, std::size_t cols, const std::vector< T > &v)
 Initialise a matrix from single initialiser list. {...}.
 
void resize (std::size_t rows, std::size_t cols)
 Resizes matrix to new dimension; all values reset to default.
 
void resize (std::size_t rows, std::size_t cols, const T &value)
 Resizes matrix to new dimension; all values reset to 'value'.
 
std::size_t rows () const
 Return rows [major index size].
 
std::size_t cols () const
 Return columns [minor index size].
 
std::size_t size () const
 Return rows*columns [total array size].
 
T * data ()
 Returns pointer to first element. Note: for std::complex<T>, this is a pointer to complex<T>, not T.
 
const T * data () const
 As above, but const.
 
const T * operator[] (std::size_t i) const
 [] index access (with no range checking). [i][j] returns ith row, jth col
 
T * operator[] (std::size_t i)
 As above, but const.
 
T & at (std::size_t row_i, std::size_t col_j)
 () index access (with range checking). (i,j) returns ith row, jth col
 
at (std::size_t row_i, std::size_t col_j) const
 const () index access (with range checking). (i,j) ith row, jth col
 
const T & atc (std::size_t row_i, std::size_t col_j) const
 const ref () index access (with range checking). (i,j) ith row, jth col
 
T & operator() (std::size_t i, std::size_t j)
 () index access (with range checking). (i,j) returns ith row, jth col
 
operator() (std::size_t i, std::size_t j) const
 As above, but const.
 
auto begin ()
 iterators for underlying std::vector (entire data)
 
auto cbegin () const
 
auto end ()
 
auto cend () const
 
const T * row (std::size_t row) const
 Returns raw c pointer to start of a row.
 
View< T > row_view (std::size_t row)
 Returns a mutable 'View' of a row.
 
View< const T > row_view (std::size_t row) const
 Returns an immutable 'View' of a row.
 
View< T > column_view (std::size_t col)
 Returns a mutable 'View' of a column.
 
View< const T > column_view (std::size_t col) const
 Returns an immutable 'View' of a column.
 
auto as_gsl_view ()
 Returns gsl_matrix_view (or _float_view, _complex_view, _complex_float_view). Call .matrix to use as a GSL matrix (no copy is involved). Allows one to use all GSL built-in functions. Note: non-owning pointer - matrix AND gsl_view must remain in scope.
 
auto as_gsl_view () const
 As above, but const.
 
determinant () const
 Returns the determinant. Uses GSL; via LU decomposition. Only works for double/complex<double>
 
Matrix< T > & invert_in_place ()
 Inverts the matrix, in place. Uses GSL; via LU decomposition. Only works for double/complex<double>.
 
Matrix< T > inverse () const
 Returns inverse of the matrix. Leaves original matrix intact. Uses GSL; via LU decomposition. Only works for double/complex<double>
 
Matrix< T > transpose () const
 Returns transpose of matrix.
 
Matrix< T > & make_identity ()
 Constructs a diagonal unit matrix (identity), in place; only for square.
 
Matrix< T > & zero ()
 Sets all elements to zero, in place.
 
Matrix< T > conj () const
 Returns conjugate of matrix.
 
auto real () const
 Returns real part of complex matrix (changes type; returns a real matrix)
 
auto imag () const
 Returns imag part of complex matrix (changes type; returns a real matrix)
 
auto complex () const
 Converts a real to complex matrix (changes type; returns a complex matrix)
 
Matrix< T > & conj_in_place ()
 Conjugates matrix, in place.
 
Matrix< T > & mult_elements_by (const Matrix< T > &a)
 Muplitplies all the elements by those of matrix a, in place: M_ij *= a_ij.
 
Matrix< T > & operator+= (const Matrix< T > &rhs)
 Overload standard operators: do what expected.
 
Matrix< T > & operator-= (const Matrix< T > &rhs)
 
Matrix< T > & operator*= (const T x)
 
Matrix< T > & operator/= (const T x)
 
Matrix< T > & operator+= (T aI)
 Matrix<T> += T : T assumed to be *Identity!
 
Matrix< T > & operator-= (T aI)
 Matrix<T> -= T : T assumed to be *Identity!
 

Protected Attributes

std::size_t m_rows
 
std::size_t m_cols
 
std::vector< T > m_data {}
 

Friends

Matrix< T > mult_elements (Matrix< T > a, const Matrix< T > &b)
 Returns new matrix, C_ij = A_ij*B_ij.
 
Matrix< T > operator+ (Matrix< T > lhs, const Matrix< T > &rhs)
 
Matrix< T > operator- (Matrix< T > lhs, const Matrix< T > &rhs)
 
Matrix< T > operator* (const T x, Matrix< T > rhs)
 
Matrix< T > operator* (Matrix< T > lhs, const T x)
 
Matrix< T > operator/ (Matrix< T > lhs, const T x)
 
Matrix< T > operator+ (Matrix< T > M, T aI)
 
Matrix< T > operator- (Matrix< T > M, T aI)
 
template<typename U >
Matrix< U > operator* (const Matrix< U > &a, const Matrix< U > &b)
 Matrix multiplication: C_ij = sum_k A_ik*B_kj.
 
template<typename U >
std::ostream & operator<< (std::ostream &os, const Matrix< U > &a)
 

Detailed Description

template<typename T = double>
class LinAlg::Matrix< T >

Matrix class; row-major.

Constructor & Destructor Documentation

◆ Matrix() [1/8]

template<typename T = double>
LinAlg::Matrix< T >::Matrix ( )
inline

Default initialiser.

◆ Matrix() [2/8]

template<typename T = double>
LinAlg::Matrix< T >::Matrix ( std::size_t  rows,
std::size_t  cols 
)
inline

Initialise a blank matrix rows*cols, filled with 0.

◆ Matrix() [3/8]

template<typename T = double>
LinAlg::Matrix< T >::Matrix ( std::size_t  rows,
std::size_t  cols,
const T &  value 
)
inline

Initialise a matrix rows*cols, filled with 'value'.

◆ Matrix() [4/8]

template<typename T = double>
LinAlg::Matrix< T >::Matrix ( std::size_t  dimension)
inlineexplicit

Initialise a blank square matrix dimension*dimension, filled with 0.

◆ Matrix() [5/8]

template<typename T = double>
LinAlg::Matrix< T >::Matrix ( std::initializer_list< std::initializer_list< T > >  ll)
inline

Initialise a matrix from initialiser list. {{},{},{}}. Each row must be same length.

◆ Matrix() [6/8]

template<typename T = double>
LinAlg::Matrix< T >::Matrix ( std::size_t  rows,
std::size_t  cols,
std::initializer_list< T >  l 
)
inline

Initialise a matrix from single initialiser list. {...}.

◆ Matrix() [7/8]

template<typename T = double>
LinAlg::Matrix< T >::Matrix ( std::size_t  rows,
std::size_t  cols,
std::vector< T > &&  v 
)
inline

Initialise a matrix from single initialiser list. {...}.

◆ Matrix() [8/8]

template<typename T = double>
LinAlg::Matrix< T >::Matrix ( std::size_t  rows,
std::size_t  cols,
const std::vector< T > &  v 
)
inline

Initialise a matrix from single initialiser list. {...}.

Member Function Documentation

◆ resize() [1/2]

template<typename T = double>
void LinAlg::Matrix< T >::resize ( std::size_t  rows,
std::size_t  cols 
)
inline

Resizes matrix to new dimension; all values reset to default.

◆ resize() [2/2]

template<typename T = double>
void LinAlg::Matrix< T >::resize ( std::size_t  rows,
std::size_t  cols,
const T &  value 
)
inline

Resizes matrix to new dimension; all values reset to 'value'.

◆ rows()

template<typename T = double>
std::size_t LinAlg::Matrix< T >::rows ( ) const
inline

Return rows [major index size].

◆ cols()

template<typename T = double>
std::size_t LinAlg::Matrix< T >::cols ( ) const
inline

Return columns [minor index size].

◆ size()

template<typename T = double>
std::size_t LinAlg::Matrix< T >::size ( ) const
inline

Return rows*columns [total array size].

◆ data() [1/2]

template<typename T = double>
T * LinAlg::Matrix< T >::data ( )
inline

Returns pointer to first element. Note: for std::complex<T>, this is a pointer to complex<T>, not T.

◆ data() [2/2]

template<typename T = double>
const T * LinAlg::Matrix< T >::data ( ) const
inline

As above, but const.

◆ operator[]() [1/2]

template<typename T = double>
const T * LinAlg::Matrix< T >::operator[] ( std::size_t  i) const
inline

[] index access (with no range checking). [i][j] returns ith row, jth col

◆ operator[]() [2/2]

template<typename T = double>
T * LinAlg::Matrix< T >::operator[] ( std::size_t  i)
inline

As above, but const.

◆ at() [1/2]

template<typename T = double>
T & LinAlg::Matrix< T >::at ( std::size_t  row_i,
std::size_t  col_j 
)
inline

() index access (with range checking). (i,j) returns ith row, jth col

◆ at() [2/2]

template<typename T = double>
T LinAlg::Matrix< T >::at ( std::size_t  row_i,
std::size_t  col_j 
) const
inline

const () index access (with range checking). (i,j) ith row, jth col

◆ atc()

template<typename T = double>
const T & LinAlg::Matrix< T >::atc ( std::size_t  row_i,
std::size_t  col_j 
) const
inline

const ref () index access (with range checking). (i,j) ith row, jth col

◆ operator()() [1/2]

template<typename T = double>
T & LinAlg::Matrix< T >::operator() ( std::size_t  i,
std::size_t  j 
)
inline

() index access (with range checking). (i,j) returns ith row, jth col

◆ operator()() [2/2]

template<typename T = double>
T LinAlg::Matrix< T >::operator() ( std::size_t  i,
std::size_t  j 
) const
inline

As above, but const.

◆ begin()

template<typename T = double>
auto LinAlg::Matrix< T >::begin ( )
inline

iterators for underlying std::vector (entire data)

◆ row()

template<typename T = double>
const T * LinAlg::Matrix< T >::row ( std::size_t  row) const
inline

Returns raw c pointer to start of a row.

◆ row_view() [1/2]

template<typename T = double>
View< T > LinAlg::Matrix< T >::row_view ( std::size_t  row)
inline

Returns a mutable 'View' of a row.

◆ row_view() [2/2]

template<typename T = double>
View< const T > LinAlg::Matrix< T >::row_view ( std::size_t  row) const
inline

Returns an immutable 'View' of a row.

◆ column_view() [1/2]

template<typename T = double>
View< T > LinAlg::Matrix< T >::column_view ( std::size_t  col)
inline

Returns a mutable 'View' of a column.

◆ column_view() [2/2]

template<typename T = double>
View< const T > LinAlg::Matrix< T >::column_view ( std::size_t  col) const
inline

Returns an immutable 'View' of a column.

◆ as_gsl_view() [1/2]

template<typename T >
auto LinAlg::Matrix< T >::as_gsl_view ( )

Returns gsl_matrix_view (or _float_view, _complex_view, _complex_float_view). Call .matrix to use as a GSL matrix (no copy is involved). Allows one to use all GSL built-in functions. Note: non-owning pointer - matrix AND gsl_view must remain in scope.

◆ as_gsl_view() [2/2]

template<typename T >
auto LinAlg::Matrix< T >::as_gsl_view ( ) const

As above, but const.

◆ determinant()

template<typename T >
T LinAlg::Matrix< T >::determinant ( ) const

Returns the determinant. Uses GSL; via LU decomposition. Only works for double/complex<double>

◆ invert_in_place()

template<typename T >
Matrix< T > & LinAlg::Matrix< T >::invert_in_place ( )

Inverts the matrix, in place. Uses GSL; via LU decomposition. Only works for double/complex<double>.

◆ inverse()

template<typename T >
Matrix< T > LinAlg::Matrix< T >::inverse ( ) const

Returns inverse of the matrix. Leaves original matrix intact. Uses GSL; via LU decomposition. Only works for double/complex<double>

◆ transpose()

template<typename T >
Matrix< T > LinAlg::Matrix< T >::transpose ( ) const

Returns transpose of matrix.

◆ make_identity()

template<typename T >
Matrix< T > & LinAlg::Matrix< T >::make_identity ( )

Constructs a diagonal unit matrix (identity), in place; only for square.

◆ zero()

template<typename T >
Matrix< T > & LinAlg::Matrix< T >::zero ( )

Sets all elements to zero, in place.

◆ conj()

template<typename T >
Matrix< T > LinAlg::Matrix< T >::conj ( ) const

Returns conjugate of matrix.

◆ real()

template<typename T >
auto LinAlg::Matrix< T >::real ( ) const

Returns real part of complex matrix (changes type; returns a real matrix)

◆ imag()

template<typename T >
auto LinAlg::Matrix< T >::imag ( ) const

Returns imag part of complex matrix (changes type; returns a real matrix)

◆ complex()

template<typename T >
auto LinAlg::Matrix< T >::complex ( ) const

Converts a real to complex matrix (changes type; returns a complex matrix)

◆ conj_in_place()

template<typename T >
Matrix< T > & LinAlg::Matrix< T >::conj_in_place ( )

Conjugates matrix, in place.

◆ mult_elements_by()

template<typename T >
Matrix< T > & LinAlg::Matrix< T >::mult_elements_by ( const Matrix< T > &  a)

Muplitplies all the elements by those of matrix a, in place: M_ij *= a_ij.

◆ operator+=() [1/2]

template<typename T >
Matrix< T > & LinAlg::Matrix< T >::operator+= ( const Matrix< T > &  rhs)

Overload standard operators: do what expected.

◆ operator+=() [2/2]

template<typename T >
Matrix< T > & LinAlg::Matrix< T >::operator+= ( aI)

Matrix<T> += T : T assumed to be *Identity!

◆ operator-=()

template<typename T >
Matrix< T > & LinAlg::Matrix< T >::operator-= ( aI)

Matrix<T> -= T : T assumed to be *Identity!

Friends And Related Symbol Documentation

◆ mult_elements

template<typename T = double>
Matrix< T > mult_elements ( Matrix< T >  a,
const Matrix< T > &  b 
)
friend

Returns new matrix, C_ij = A_ij*B_ij.

◆ operator*

template<typename T = double>
template<typename U >
Matrix< U > operator* ( const Matrix< U > &  a,
const Matrix< U > &  b 
)
friend

Matrix multiplication: C_ij = sum_k A_ik*B_kj.


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