Chemical Data Processing Library C++ API - Version 1.1.1: CDPL::Math::Matrix< T, A > Class Template Reference

Chemical Data Processing Library C++ API - Version 1.1.1

#include <Matrix.hpp>

Inheritance diagram for CDPL::Math::Matrix< T, A >:

Public Types
typedef T	ValueType

typedef T &	Reference

typedef const T &	ConstReference

typedef A::size_type	SizeType

typedef A::difference_type	DifferenceType

typedef A	ArrayType

typedef T *	Pointer

typedef const T *	ConstPointer

typedef MatrixReference< SelfType >	ClosureType

typedef const MatrixReference< const SelfType >	ConstClosureType

typedef SelfType	MatrixTemporaryType

typedef Vector< T, A >	VectorTemporaryType

typedef std::shared_ptr< SelfType >	SharedPointer

typedef std::initializer_list< std::initializer_list< T > >	InitializerListType

Public Member Functions
	Matrix ()

	Matrix (SizeType m, SizeType n)

	Matrix (SizeType m, SizeType n, const ValueType &v)

	Matrix (const Matrix &m)

	Matrix (Matrix &&m)

	Matrix (InitializerListType l)

template<typename E >
	Matrix (const MatrixExpression< E > &e)

Reference	operator() (SizeType i, SizeType j)

ConstReference	operator() (SizeType i, SizeType j) const

bool	isEmpty () const

SizeType	getSize1 () const

SizeType	getSize2 () const

SizeType	getMaxSize () const

ArrayType &	getData ()

const ArrayType &	getData () const

Matrix &	operator= (const Matrix &m)

Matrix &	operator= (Matrix &&m)

template<typename C >
Matrix &	operator= (const MatrixContainer< C > &c)

Matrix &	operator= (InitializerListType l)

template<typename E >
Matrix &	operator= (const MatrixExpression< E > &e)

template<typename C >
Matrix &	operator+= (const MatrixContainer< C > &c)

Matrix &	operator+= (InitializerListType l)

template<typename E >
Matrix &	operator+= (const MatrixExpression< E > &e)

template<typename C >
Matrix &	operator-= (const MatrixContainer< C > &c)

Matrix &	operator-= (InitializerListType l)

template<typename E >
Matrix &	operator-= (const MatrixExpression< E > &e)

template<typename T1 >
std::enable_if< IsScalar< T1 >::value, Matrix >::type &	operator*= (const T1 &t)

template<typename T1 >
std::enable_if< IsScalar< T1 >::value, Matrix >::type &	operator/= (const T1 &t)

template<typename E >
Matrix &	assign (const MatrixExpression< E > &e)

Matrix &	assign (InitializerListType l)

template<typename E >
Matrix &	plusAssign (const MatrixExpression< E > &e)

Matrix &	plusAssign (InitializerListType l)

template<typename E >
Matrix &	minusAssign (const MatrixExpression< E > &e)

Matrix &	minusAssign (InitializerListType l)

void	swap (Matrix &m)

void	clear (const ValueType &v=ValueType())

void	resize (SizeType m, SizeType n, bool preserve=true, const ValueType &v=ValueType())

Friends
void	swap (Matrix &m1, Matrix &m2)

Member Typedef Documentation

◆ ValueType

template<typename T , typename A = std::vector<T>>

typedef T CDPL::Math::Matrix< T, A >::ValueType

◆ Reference

template<typename T , typename A = std::vector<T>>

typedef T& CDPL::Math::Matrix< T, A >::Reference

◆ ConstReference

template<typename T , typename A = std::vector<T>>

typedef const T& CDPL::Math::Matrix< T, A >::ConstReference

◆ SizeType

template<typename T , typename A = std::vector<T>>

typedef A::size_type CDPL::Math::Matrix< T, A >::SizeType

◆ DifferenceType

template<typename T , typename A = std::vector<T>>

typedef A::difference_type CDPL::Math::Matrix< T, A >::DifferenceType

◆ ArrayType

template<typename T , typename A = std::vector<T>>

typedef A CDPL::Math::Matrix< T, A >::ArrayType

◆ Pointer

template<typename T , typename A = std::vector<T>>

typedef T* CDPL::Math::Matrix< T, A >::Pointer

◆ ConstPointer

template<typename T , typename A = std::vector<T>>

typedef const T* CDPL::Math::Matrix< T, A >::ConstPointer

◆ ClosureType

template<typename T , typename A = std::vector<T>>

typedef MatrixReference<SelfType> CDPL::Math::Matrix< T, A >::ClosureType

◆ ConstClosureType

template<typename T , typename A = std::vector<T>>

typedef const MatrixReference<const SelfType> CDPL::Math::Matrix< T, A >::ConstClosureType

◆ MatrixTemporaryType

template<typename T , typename A = std::vector<T>>

typedef SelfType CDPL::Math::Matrix< T, A >::MatrixTemporaryType

◆ VectorTemporaryType

template<typename T , typename A = std::vector<T>>

typedef Vector<T, A> CDPL::Math::Matrix< T, A >::VectorTemporaryType

◆ SharedPointer

template<typename T , typename A = std::vector<T>>

typedef std::shared_ptr<SelfType> CDPL::Math::Matrix< T, A >::SharedPointer

◆ InitializerListType

template<typename T , typename A = std::vector<T>>

typedef std::initializer_list<std::initializer_list<T> > CDPL::Math::Matrix< T, A >::InitializerListType

Constructor & Destructor Documentation

◆ Matrix() [1/7]

template<typename T , typename A = std::vector<T>>

CDPL::Math::Matrix< T, A >::Matrix ( )

inline

◆ Matrix() [2/7]

template<typename T , typename A = std::vector<T>>

CDPL::Math::Matrix< T, A >::Matrix	(	SizeType	m,
		SizeType	n
	)

inline

◆ Matrix() [3/7]

template<typename T , typename A = std::vector<T>>

CDPL::Math::Matrix< T, A >::Matrix	(	SizeType	m,
		SizeType	n,
		const ValueType &	v
	)

inline

◆ Matrix() [4/7]

template<typename T , typename A = std::vector<T>>

CDPL::Math::Matrix< T, A >::Matrix ( const Matrix< T, A > & m )

inline

◆ Matrix() [5/7]

template<typename T , typename A = std::vector<T>>

CDPL::Math::Matrix< T, A >::Matrix ( Matrix< T, A > && m )

inline

◆ Matrix() [6/7]

template<typename T , typename A = std::vector<T>>

CDPL::Math::Matrix< T, A >::Matrix ( InitializerListType l )

inline

◆ Matrix() [7/7]

template<typename T , typename A = std::vector<T>>

template<typename E >

CDPL::Math::Matrix< T, A >::Matrix ( const MatrixExpression< E > & e )

inline

Member Function Documentation

◆ operator()() [1/2]

template<typename T , typename A = std::vector<T>>

Reference CDPL::Math::Matrix< T, A >::operator()	(	SizeType	i,
		SizeType	j
	)

inline

◆ operator()() [2/2]

template<typename T , typename A = std::vector<T>>

ConstReference CDPL::Math::Matrix< T, A >::operator()	(	SizeType	i,
		SizeType	j
	)		const

inline

◆ isEmpty()

template<typename T , typename A = std::vector<T>>

bool CDPL::Math::Matrix< T, A >::isEmpty ( ) const

inline

◆ getSize1()

template<typename T , typename A = std::vector<T>>

SizeType CDPL::Math::Matrix< T, A >::getSize1 ( ) const

inline

◆ getSize2()

template<typename T , typename A = std::vector<T>>

SizeType CDPL::Math::Matrix< T, A >::getSize2 ( ) const

inline

◆ getMaxSize()

template<typename T , typename A = std::vector<T>>

SizeType CDPL::Math::Matrix< T, A >::getMaxSize ( ) const

inline

◆ getData() [1/2]

template<typename T , typename A = std::vector<T>>

ArrayType& CDPL::Math::Matrix< T, A >::getData ( )

inline

◆ getData() [2/2]

template<typename T , typename A = std::vector<T>>

const ArrayType& CDPL::Math::Matrix< T, A >::getData ( ) const

inline

◆ operator=() [1/5]

template<typename T , typename A = std::vector<T>>

Matrix& CDPL::Math::Matrix< T, A >::operator= ( const Matrix< T, A > & m )

inline

◆ operator=() [2/5]

template<typename T , typename A = std::vector<T>>

Matrix& CDPL::Math::Matrix< T, A >::operator= ( Matrix< T, A > && m )

inline

◆ operator=() [3/5]

template<typename T , typename A = std::vector<T>>

template<typename C >

Matrix& CDPL::Math::Matrix< T, A >::operator= ( const MatrixContainer< C > & c )

inline

◆ operator=() [4/5]

template<typename T , typename A = std::vector<T>>

Matrix& CDPL::Math::Matrix< T, A >::operator= ( InitializerListType l )

inline

◆ operator=() [5/5]

template<typename T , typename A = std::vector<T>>

template<typename E >

Matrix& CDPL::Math::Matrix< T, A >::operator= ( const MatrixExpression< E > & e )

inline

◆ operator+=() [1/3]

template<typename T , typename A = std::vector<T>>

template<typename C >

Matrix& CDPL::Math::Matrix< T, A >::operator+= ( const MatrixContainer< C > & c )

inline

◆ operator+=() [2/3]

template<typename T , typename A = std::vector<T>>

Matrix& CDPL::Math::Matrix< T, A >::operator+= ( InitializerListType l )

inline

◆ operator+=() [3/3]

template<typename T , typename A = std::vector<T>>

template<typename E >

Matrix& CDPL::Math::Matrix< T, A >::operator+= ( const MatrixExpression< E > & e )

inline

◆ operator-=() [1/3]

template<typename T , typename A = std::vector<T>>

template<typename C >

Matrix& CDPL::Math::Matrix< T, A >::operator-= ( const MatrixContainer< C > & c )

inline

◆ operator-=() [2/3]

template<typename T , typename A = std::vector<T>>

Matrix& CDPL::Math::Matrix< T, A >::operator-= ( InitializerListType l )

inline

◆ operator-=() [3/3]

template<typename T , typename A = std::vector<T>>

template<typename E >

Matrix& CDPL::Math::Matrix< T, A >::operator-= ( const MatrixExpression< E > & e )

inline

◆ operator*=()

template<typename T , typename A = std::vector<T>>

template<typename T1 >

std::enable_if<IsScalar<T1>::value, Matrix>::type& CDPL::Math::Matrix< T, A >::operator*= ( const T1 & t )

inline

◆ operator/=()

template<typename T , typename A = std::vector<T>>

template<typename T1 >

std::enable_if<IsScalar<T1>::value, Matrix>::type& CDPL::Math::Matrix< T, A >::operator/= ( const T1 & t )

inline

◆ assign() [1/2]

template<typename T , typename A = std::vector<T>>

template<typename E >

Matrix& CDPL::Math::Matrix< T, A >::assign ( const MatrixExpression< E > & e )

inline

◆ assign() [2/2]

template<typename T , typename A = std::vector<T>>

Matrix& CDPL::Math::Matrix< T, A >::assign ( InitializerListType l )

inline

◆ plusAssign() [1/2]

template<typename T , typename A = std::vector<T>>

template<typename E >

Matrix& CDPL::Math::Matrix< T, A >::plusAssign ( const MatrixExpression< E > & e )

inline

◆ plusAssign() [2/2]

template<typename T , typename A = std::vector<T>>

Matrix& CDPL::Math::Matrix< T, A >::plusAssign ( InitializerListType l )

inline

◆ minusAssign() [1/2]

template<typename T , typename A = std::vector<T>>

template<typename E >

Matrix& CDPL::Math::Matrix< T, A >::minusAssign ( const MatrixExpression< E > & e )

inline

◆ minusAssign() [2/2]

template<typename T , typename A = std::vector<T>>

Matrix& CDPL::Math::Matrix< T, A >::minusAssign ( InitializerListType l )

inline

◆ swap()

template<typename T , typename A = std::vector<T>>

void CDPL::Math::Matrix< T, A >::swap ( Matrix< T, A > & m )

inline

◆ clear()

template<typename T , typename A = std::vector<T>>

void CDPL::Math::Matrix< T, A >::clear ( const ValueType & v = ValueType() )

inline

◆ resize()

template<typename T , typename A = std::vector<T>>

void CDPL::Math::Matrix< T, A >::resize	(	SizeType	m,
		SizeType	n,
		bool	preserve = `true`,
		const ValueType &	v = `ValueType()`
	)

inline

Friends And Related Function Documentation

◆ swap

template<typename T , typename A = std::vector<T>>

void swap	(	Matrix< T, A > &	m1,
		Matrix< T, A > &	m2
	)

friend

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