SmallMatrix< numberOfRows, numberOfColumns > Class Template Reference

Data type for small dense matrix. More...

#include <SmallMatrix.h>

Public Member Functions
	SmallMatrix ()
	Constructs a matrix of size n-rows by m-columns. More...
	SmallMatrix (const SmallVector< numberOfRows > &other)
	SmallMatrix (const Mdouble &c)
	Constructs a matrix of size n-rows by m-columns and initialises all entry to a constant. More...
	SmallMatrix (const std::initializer_list< SmallVector< numberOfRows >> &entries)
	SmallMatrix (const SmallMatrix &other)
	Construct and copy Matrix from another Matrix i.e. B(A) where B and A are both matrices. More...
	SmallMatrix (std::array< SmallVector< numberOfRows >, numberOfColumns > entries)
	Glues one or more vectors with the same number of rows together. More...
	SmallMatrix (SmallMatrix &&other)
	Move Matrix from another Matrix. More...
Mdouble &	operator() (unsigned int n, unsigned int m)
	defines the operator(n,m) to access the element on row n and column m More...
const Mdouble &	operator() (unsigned int n, unsigned int m) const
	defines the operator(n,m) to access the element on row n and column m More...
Mdouble &	operator[] (const unsigned int n)
	Access the n linear element in the matrix. More...
const Mdouble &	operator[] (const unsigned int n) const
SmallVector< numberOfRows >	operator* (SmallVector< numberOfColumns > &right)
	Defines Matrix A times vector B and return vector C i.e. C_,j= A_ij B_,j. More...
SmallVector< numberOfRows >	operator* (SmallVector< numberOfColumns > &right) const
SmallMatrix	operator* (const Mdouble &right) const
	Does matrix A_ij=scalar*B_ij. More...
template<unsigned int K>
SmallMatrix< numberOfRows, K >	operator* (const SmallMatrix< numberOfColumns, K > &other)
	Does matrix A_ij = B_ik * C_kj. More...
template<unsigned int K>
SmallMatrix< numberOfRows, K >	operator* (const SmallMatrix< numberOfColumns, K > &other) const
SmallMatrix &	operator+= (const SmallMatrix &other)
SmallMatrix &	operator-= (const SmallMatrix &other)
SmallMatrix	operator+ (const SmallMatrix &other) const
SmallMatrix	operator- (const SmallMatrix &other) const
SmallMatrix	operator- () const
SmallMatrix &	operator*= (const Mdouble &scalar)
	Does matrix A_ij=scalar*A_ij. More...
SmallMatrix &	operator*= (const SmallMatrix< numberOfColumns, numberOfColumns > &other)
	Does matrix A_ij = A_ik * B_kj note that other must be square because this is a fixed-size matrix. More...
SmallMatrix &	operator/= (const Mdouble &scalar)
	Does matrix A_ij=scalar*A_ij. More...
SmallMatrix	operator/ (const Mdouble &scalar) const
	this does element by divided by a scalar More...
SmallMatrix &	operator= (const SmallMatrix &right)
	Assigns one matrix to another. More...
SmallMatrix &	operator= (SmallMatrix &&right)
	Assigns one matrix to another. More...
SmallVector< numberOfRows >	computeWedgeStuffVector () const
	computeWedgeStuffVector. More...
void	axpy (Mdouble a, const SmallMatrix &x)
	Applies the matrix y=ax + y, where x is another matrix and a is a scalar. More...
unsigned int	size () const
	Get total number of Matrix entries. More...
unsigned int	getNumberOfRows () const
	Get the number of rows. More...
unsigned int	getNRows () const
unsigned int	getNumberOfColumns () const
	Get the number of columns. More...
unsigned int	getNCols () const
SmallVector< numberOfRows >	getColumn (unsigned int j) const
	get the j^th column More...
SmallVector< numberOfColumns >	getRow (unsigned int i) const
	get the i^th row More...
SmallMatrix	LUfactorisation () const
	Return the LUfactorisation of the matrix. More...
Mdouble	determinant () const
SmallMatrix	inverse () const
	return the inverse in the vector result. The size of result matches the matrix. More...
SmallMatrix< numberOfColumns, numberOfRows >	transpose () const
template<unsigned int numberOfRightHandSideColumns>
void	solve (SmallMatrix< numberOfRows, numberOfRightHandSideColumns > &B) const
	solves Ax=B where A is the current matrix and B is passed in. The result is returned in B. More...
void	solve (SmallVector< numberOfRows > &b) const
	solves Ax=b where A is the current matrix and NumericalVector b is the input parameter. The result is returned in b. More...
Mdouble *	data ()
const Mdouble *	data () const

Private Attributes
std::array< Mdouble, numberOfRows *numberOfColumns >	data_
	The actually data of the matrix class. More...

Detailed Description

template<unsigned int numberOfRows, unsigned int numberOfColumns>
class SmallMatrix< numberOfRows, numberOfColumns >

Data type for small dense matrix.

Stores small dense matrix efficiently. It only store Mdoubles as this is the main type linear algebra is done on in hpGEM It stores the matrix in fortran style (column-major) to give quicker access to extern BLAS libraries. For example, the order they are stored in a 2x2 matrix is 0 2 1 3

Constructor & Destructor Documentation

SmallMatrix() [1/7]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix< numberOfRows, numberOfColumns >::SmallMatrix ( )

inline

Constructs a matrix of size n-rows by m-columns.

            : data_()
    {
    }

SmallMatrix() [2/7]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix< numberOfRows, numberOfColumns >::SmallMatrix ( const SmallVector< numberOfRows > &  other )

inline

            : data_()
    {
        logger.assert_debug(numberOfColumns == 1, "Trying to construct a matrix with more than 1 columns from a vector");
        std::copy(other.data(), other.data() + numberOfRows, data_.begin());
    }

References copy(), SmallVector< numberOfRows >::data(), SmallMatrix< numberOfRows, numberOfColumns >::data_, and logger.

SmallMatrix() [3/7]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix< numberOfRows, numberOfColumns >::SmallMatrix ( const Mdouble &  c )

inline

Constructs a matrix of size n-rows by m-columns and initialises all entry to a constant.

            : data_()
    {
        data_.fill(c);
    }

References calibrate::c, and SmallMatrix< numberOfRows, numberOfColumns >::data_.

SmallMatrix() [4/7]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix< numberOfRows, numberOfColumns >::SmallMatrix ( const std::initializer_list< SmallVector< numberOfRows >> &  entries )

inline

            : data_()
    {
        logger.assert_debug(entries.size() == numberOfColumns, "expected a matrix with % "
                                                         "columns, but got a matrix with % columns", numberOfColumns,
                      entries.size());
        unsigned int column = 0;
        for (const SmallVector<numberOfRows>& entry : entries)
        {
            for (unsigned int i = 0; i < numberOfRows; ++i)
            {
                (*this)(i, column) = entry[i];
            }
            ++column;
        }
    }

References i, and logger.

SmallMatrix() [5/7]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix< numberOfRows, numberOfColumns >::SmallMatrix ( const SmallMatrix< numberOfRows, numberOfColumns > &  other )

inline

Construct and copy Matrix from another Matrix i.e. B(A) where B and A are both matrices.

            : data_()
    {
        std::copy(other.data_.begin(), other.data_.end(), data_.begin());
    }

References copy(), and SmallMatrix< numberOfRows, numberOfColumns >::data_.

SmallMatrix() [6/7]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix< numberOfRows, numberOfColumns >::SmallMatrix ( std::array< SmallVector< numberOfRows >, numberOfColumns >  entries )

inline

Glues one or more vectors with the same number of rows together.

            : data_()
    {
        for (unsigned int i = 0; i < numberOfRows; ++i)
        {
            for (unsigned int j = 0; j < numberOfColumns; ++j)
            {
                (*this)(i, j) = entries[j][i];
            }
        }
    }

References i, and j.

SmallMatrix() [7/7]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix< numberOfRows, numberOfColumns >::SmallMatrix ( SmallMatrix< numberOfRows, numberOfColumns > &&  other )

inline

Move Matrix from another Matrix.

            : data_(std::move(other.data_))
    {
    }

Member Function Documentation

axpy()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

void SmallMatrix< numberOfRows, numberOfColumns >::axpy ( Mdouble  a, const SmallMatrix< numberOfRows, numberOfColumns > &  x  )

inline

Applies the matrix y=ax + y, where x is another matrix and a is a scalar.

    {
        for (unsigned int i = 0; i < numberOfRows * numberOfColumns; ++i)
        {
            data_[i] += a * x[i];
        }
    }

References a, SmallMatrix< numberOfRows, numberOfColumns >::data_, i, and plotDoE::x.

Referenced by main().

computeWedgeStuffVector()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallVector< numberOfRows > SmallMatrix< numberOfRows, numberOfColumns >::computeWedgeStuffVector

computeWedgeStuffVector.

{
    //copied from MiddleSizeMatrix to prevent constructing a temporary MiddleSizeMatrix
    logger.assert_debug(numberOfColumns == numberOfRows - 1,
                  "Matrix has wrong dimensions to construct the wedge stuff vector");
    SmallVector<numberOfRows> result;
    
    switch (numberOfRows)
    {
        case 2:
            result[0] = -(*this)(1, 0);
            result[1] = +(*this)(0, 0);
            break;
        case 3:
            result[0] = (*this)(1, 0) * (*this)(2, 1) - (*this)(2, 0) * (*this)(1, 1);
            result[1] = (*this)(0, 1) * (*this)(2, 0) - (*this)(0, 0) * (*this)(2, 1); // includes minus sign already!
            result[2] = (*this)(0, 0) * (*this)(1, 1) - (*this)(1, 0) * (*this)(0, 1);
            break;
        case 4:
            result[0] = (*this)(1, 0) * (-(*this)(2, 1) * (*this)(3, 2) + (*this)(3, 1) * (*this)(2, 2)) +
                        (*this)(2, 0) * ((*this)(1, 1) * (*this)(3, 2) - (*this)(3, 1) * (*this)(1, 2)) +
                        (*this)(3, 0) * (-(*this)(1, 1) * (*this)(2, 2) + (*this)(2, 1) * (*this)(1, 2));
            
            result[1] = (*this)(0, 0) * ((*this)(2, 1) * (*this)(3, 2) - (*this)(3, 1) * (*this)(2, 2)) +
                        (*this)(2, 0) * (-(*this)(0, 1) * (*this)(3, 2) + (*this)(3, 1) * (*this)(0, 2)) +
                        (*this)(3, 0) * ((*this)(0, 1) * (*this)(2, 2) - (*this)(2, 1) * (*this)(0, 2));
            result[2] = (*this)(0, 0) * (-(*this)(1, 1) * (*this)(3, 2) + (*this)(3, 1) * (*this)(1, 2)) +
                        (*this)(1, 0) * ((*this)(0, 1) * (*this)(3, 2) - (*this)(3, 1) * (*this)(0, 2)) +
                        (*this)(3, 0) * (-(*this)(0, 1) * (*this)(1, 2) + (*this)(1, 1) * (*this)(0, 2));
            result[3] = (*this)(0, 0) * ((*this)(1, 1) * (*this)(2, 2) - (*this)(2, 1) * (*this)(1, 2)) +
                        (*this)(1, 0) * (-(*this)(0, 1) * (*this)(2, 2) + (*this)(2, 1) * (*this)(0, 2)) +
                        (*this)(2, 0) * ((*this)(0, 1) * (*this)(1, 2) - (*this)(1, 1) * (*this)(0, 2));
            break;
        default:
            logger(ERROR, "Wedge product not implemented for this dimension");
    } //end switch
    
    return (result);
}

References ERROR, and logger.

data() [1/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

Mdouble* SmallMatrix< numberOfRows, numberOfColumns >::data ( )

inline

    {
        return data_.data();
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_.

Referenced by gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenQuaternionPrinter::children(), SmallMatrix< numberOfRows, numberOfColumns >::getColumn(), SmallMatrix< numberOfRows, numberOfColumns >::inverse(), SmallMatrix< numberOfRows, numberOfColumns >::LUfactorisation(), main(), SmallMatrix< numberOfRows, numberOfColumns >::operator*(), SmallMatrix< numberOfRows, numberOfColumns >::solve(), gdb.printers.EigenMatrixPrinter::to_string(), gdb.printers.EigenSparseMatrixPrinter::to_string(), and gdb.printers.EigenQuaternionPrinter::to_string().

data() [2/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

const Mdouble* SmallMatrix< numberOfRows, numberOfColumns >::data ( ) const

inline

    {
        return data_.data();
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_.

Referenced by gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenQuaternionPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), gdb.printers.EigenSparseMatrixPrinter::to_string(), and gdb.printers.EigenQuaternionPrinter::to_string().

determinant()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

Mdouble SmallMatrix< numberOfRows, numberOfColumns >::determinant

{
    logger.assert_debug(numberOfRows == numberOfColumns, "Matrix should be square to have a determinant!");
    
    switch (numberOfRows)
    {
        case 0:
            return 1;
        case 1:
            return (*this)(0, 0);
        case 2:
            return (*this)(0, 0) * (*this)(1, 1) - (*this)(0, 1) * (*this)(1, 0);
        
        case 3:
            return (*this)(0, 0) * ((*this)(1, 1) * (*this)(2, 2) - (*this)(1, 2) * (*this)(2, 1)) -
                   (*this)(0, 1) * ((*this)(1, 0) * (*this)(2, 2) - (*this)(2, 0) * (*this)(1, 2)) +
                   (*this)(0, 2) * ((*this)(1, 0) * (*this)(2, 1) - (*this)(2, 0) * (*this)(1, 1));
        
        case 4:
            return ((*this)(3, 0) * (*this)(2, 1) * (*this)(0, 3) - (*this)(2, 0) * (*this)(3, 1) * (*this)(0, 3)) *
                   (*this)(1, 2) +
                   (-(*this)(3, 0) * (*this)(0, 3) * (*this)(2, 2) + (*this)(2, 0) * (*this)(0, 3) * (*this)(3, 2)) *
                   (*this)(1, 1) +
                   ((*this)(3, 1) * (*this)(0, 3) * (*this)(2, 2) - (*this)(2, 1) * (*this)(0, 3) * (*this)(3, 2)) *
                   (*this)(1, 0) +
                   (-(*this)(3, 0) * (*this)(2, 1) * (*this)(1, 3) + (*this)(2, 0) * (*this)(3, 1) * (*this)(1, 3) +
                    (-(*this)(2, 0) * (*this)(3, 3) + (*this)(3, 0) * (*this)(2, 3)) * (*this)(1, 1) +
                    ((*this)(2, 1) * (*this)(3, 3) - (*this)(3, 1) * (*this)(2, 3)) * (*this)(1, 0)) * (*this)(0, 2) +
                   ((*this)(3, 0) * (*this)(1, 3) * (*this)(2, 2) - (*this)(2, 0) * (*this)(1, 3) * (*this)(3, 2) +
                    ((*this)(2, 0) * (*this)(3, 3) - (*this)(3, 0) * (*this)(2, 3)) * (*this)(1, 2) +
                    (-(*this)(2, 2) * (*this)(3, 3) + (*this)(2, 3) * (*this)(3, 2)) * (*this)(1, 0)) * (*this)(0, 1) +
                   (-(*this)(3, 1) * (*this)(1, 3) * (*this)(2, 2) + (*this)(2, 1) * (*this)(1, 3) * (*this)(3, 2) +
                    ((*this)(3, 1) * (*this)(2, 3) - (*this)(2, 1) * (*this)(3, 3)) * (*this)(1, 2) +
                    (*this)(1, 1) * ((*this)(2, 2) * (*this)(3, 3) - (*this)(2, 3) * (*this)(3, 2))) * (*this)(0, 0);
            // ... says Maple; this can possibly be done more efficiently,
            // maybe even with LU (with pivoting, though...)
        default:
            logger(ERROR, "Computing the Determinant for size % is not implemented", numberOfRows);
            break;
    }
    return 0;
}

References ERROR, and logger.

getColumn()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallVector<numberOfRows> SmallMatrix< numberOfRows, numberOfColumns >::getColumn ( unsigned int  j ) const

inline

get the j^th column

    {
        logger.assert_debug(j < numberOfColumns, "Asked for column %, but there are only % columns", j, numberOfColumns);
        return SmallVector<numberOfRows>(data() + j * numberOfRows);
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data(), j, and logger.

getNCols()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

unsigned int SmallMatrix< numberOfRows, numberOfColumns >::getNCols ( ) const

inline

    {
        return getNumberOfColumns();
    }

References SmallMatrix< numberOfRows, numberOfColumns >::getNumberOfColumns().

Referenced by main().

getNRows()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

unsigned int SmallMatrix< numberOfRows, numberOfColumns >::getNRows ( ) const

inline

Deprecated:

Does not conform naming convention, please use getNumberOfRows instead.

    {
        return getNumberOfRows();
    }

References SmallMatrix< numberOfRows, numberOfColumns >::getNumberOfRows().

getNumberOfColumns()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

unsigned int SmallMatrix< numberOfRows, numberOfColumns >::getNumberOfColumns ( ) const

inline

Get the number of columns.

    {
        return numberOfColumns;
    }

Referenced by SmallMatrix< numberOfRows, numberOfColumns >::getNCols().

getNumberOfRows()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

unsigned int SmallMatrix< numberOfRows, numberOfColumns >::getNumberOfRows ( ) const

inline

Get the number of rows.

    {
        return numberOfRows;
    }

Referenced by SmallMatrix< numberOfRows, numberOfColumns >::getNRows(), and main().

getRow()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallVector<numberOfColumns> SmallMatrix< numberOfRows, numberOfColumns >::getRow ( unsigned int  i ) const

inline

get the i^th row

    {
        logger.assert_debug(i < numberOfRows, "Asked for row %, but there are only % rows", i, numberOfRows);
        SmallVector<numberOfColumns> result;
        for (unsigned int j = 0; j < numberOfColumns; ++j)
        {
            result[j] = (*this)(i, j);
        }
        return result;
    }

References i, j, and logger.

inverse()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix< numberOfRows, numberOfColumns > SmallMatrix< numberOfRows, numberOfColumns >::inverse

return the inverse in the vector result. The size of result matches the matrix.

{
    logger.assert_debug(numberOfRows == numberOfColumns, "Cannot invert a non-square matrix");
    SmallMatrix<numberOfRows, numberOfColumns> result = (*this);
    
    int nr = numberOfRows;
    int nc = numberOfColumns;
    
    int nPivot = numberOfRows;
    int iPivot[nPivot];
    
    int info = 0;
    
    dgetrf_(&nr, &nc, result.data(), &nr, iPivot, &info);
    
    int lwork = numberOfRows * numberOfColumns;
    SmallMatrix work;
    dgetri_(&nc, result.data(), &nc, iPivot, work.data(), &lwork, &info);
    
    return result;
}

References SmallMatrix< numberOfRows, numberOfColumns >::data(), dgetrf_(), dgetri_(), info, and logger.

Referenced by main().

LUfactorisation()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix< numberOfRows, numberOfColumns > SmallMatrix< numberOfRows, numberOfColumns >::LUfactorisation

Return the LUfactorisation of the matrix.

{
    int nr = numberOfRows;
    int nc = numberOfColumns;
    int nPivot = std::min(numberOfRows, numberOfColumns);
    int iPivot[nPivot];
    
    SmallMatrix result(*this);
    
    int info;
    
    dgetrf_(&nr, &nc, result.data(), &nr, iPivot, &info);
    
    return result;
}

References SmallMatrix< numberOfRows, numberOfColumns >::data(), dgetrf_(), info, and min.

operator()() [1/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

Mdouble& SmallMatrix< numberOfRows, numberOfColumns >::operator() ( unsigned int  n, unsigned int  m  )

inline

defines the operator(n,m) to access the element on row n and column m

    {
        logger.assert_debug(n < numberOfRows, "Requested row number % for a matrix with only % rows", n, numberOfRows);
        logger.assert_debug(m < numberOfColumns, "Requested column number % for a matrix with only % columns", m,
                      numberOfColumns);
        return data_[n + m * numberOfRows];
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, logger, m, and n.

operator()() [2/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

const Mdouble& SmallMatrix< numberOfRows, numberOfColumns >::operator() ( unsigned int  n, unsigned int  m  ) const

inline

defines the operator(n,m) to access the element on row n and column m

    {
        logger.assert_debug(n < numberOfRows, "Requested row number % for a matrix with only % rows", n, numberOfRows);
        logger.assert_debug(m < numberOfColumns, "Requested column number % for a matrix with only % columns", m,
                      numberOfColumns);
        return data_[n + m * numberOfRows];
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, logger, m, and n.

operator*() [1/5]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix SmallMatrix< numberOfRows, numberOfColumns >::operator* ( const Mdouble &  right ) const

inline

Does matrix A_ij=scalar*B_ij.

    {
        SmallMatrix result;
        std::transform(data_.begin(), data_.end(), result.data_.begin(),
                       std::bind(std::multiplies<Mdouble>(), std::placeholders::_1, right));
        return result;
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, and transform().

operator*() [2/5]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

template<unsigned int K>

SmallMatrix< numberOfRows, K > SmallMatrix< numberOfRows, numberOfColumns >::operator*

(

const SmallMatrix< numberOfColumns, K > &

other

)

Does matrix A_ij = B_ik * C_kj.

{
    int i = numberOfRows;
    int j = numberOfColumns;
    int k = K;
    
    if (numberOfColumns == 0)
    {
        logger(WARN, "Trying to multiply a matrix with a matrix without any columns.");
        return SmallMatrix<numberOfRows, K>();
    }
    //The result of the matrix is left.numberOfRows, right.numberOfColumns()
    SmallMatrix<numberOfRows, K> C;
    
    double d_one = 1.0;
    double d_zero = 0.0;
    
    //Let the actual multiplication be done by Fortran
    dgemm_("N", "N", &i, &k, &j, &d_one, this->data(), &i, const_cast<double*>(other.data()), &j, &d_zero, C.data(),
           &i);
    
    return C;
}

References SmallMatrix< numberOfRows, numberOfColumns >::data(), data, dgemm_(), i, j, k, PlanarWave::K, logger, and WARN.

operator*() [3/5]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

template<unsigned int K>

SmallMatrix< numberOfRows, K > SmallMatrix< numberOfRows, numberOfColumns >::operator*

(

const SmallMatrix< numberOfColumns, K > &

other

)

const

{
    int i = numberOfRows;
    int j = numberOfColumns;
    int k = K;
    
    if (numberOfColumns == 0)
    {
        logger(WARN, "Trying to multiply a matrix with a matrix without any columns.");
        return SmallMatrix<numberOfRows, K>();
    }
    //The result of the matrix is left.Nrows, right.NCols()
    SmallMatrix<numberOfRows, K> C;
    
    double d_one = 1.0;
    double d_zero = 0.0;
    
    //Let the actual multiplication be done by Fortran
    dgemm_("N", "N", &i, &k, &j, &d_one, const_cast<double*>(this->data()), &i, const_cast<double*>(other.data()), &j,
           &d_zero, C.data(), &i);
    
    return C;
}

References SmallMatrix< numberOfRows, numberOfColumns >::data(), data, dgemm_(), i, j, k, PlanarWave::K, logger, and WARN.

operator*() [4/5]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallVector< numberOfRows > SmallMatrix< numberOfRows, numberOfColumns >::operator*

(

SmallVector< numberOfColumns > &

right

)

Defines Matrix A times vector B and return vector C i.e. C_,j= A_ij B_,j.

{
    if (numberOfRows == 0)
    {
        logger(WARN, "Trying to multiply a vector with a matrix without any rows.");
        return SmallVector<numberOfRows>();
    }
    if (numberOfColumns == 0)
    {
        logger(WARN, "Trying to multiply a vector with a matrix without any columns.");
        return SmallVector<numberOfRows>();
    }
    int nr = numberOfRows;
    int nc = numberOfColumns;
    
    int i_one = 1;
    double d_one = 1.0;
    double d_zero = 0.0;
    
    SmallVector<numberOfRows> result;
    
    logger(DEBUG, "Matrix size: % x % \n Vector size: %", nr, nc, right.size());
    
    dgemv_("N", &nr, &nc, &d_one, this->data(), &nr, right.data(), &i_one, &d_zero, result.data(), &i_one);
    return result;
}

References SmallVector< numberOfRows >::data(), data, DEBUG, dgemv_(), logger, SmallVector< numberOfRows >::size(), and WARN.

operator*() [5/5]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallVector< numberOfRows > SmallMatrix< numberOfRows, numberOfColumns >::operator*

(

SmallVector< numberOfColumns > &

right

)

const

{
    if (numberOfRows == 0)
    {
        logger(WARN, "Trying to multiply a vector with a matrix without any rows.");
        return SmallVector<numberOfRows>();
    }
    if (numberOfColumns == 0)
    {
        logger(WARN, "Trying to multiply a vector with a matrix without any columns.");
        return SmallVector<numberOfRows>();
    }
    int nr = numberOfRows;
    int nc = numberOfColumns;
    
    int i_one = 1;
    double d_one = 1.0;
    double d_zero = 0.0;
    
    SmallVector<numberOfRows> result;
    
    logger(DEBUG, "Matrix size: % x % \n Vector size: %", nr, nc, right.size());
    
    dgemv_("N", &nr, &nc, &d_one, (const_cast<double*>(this->data())), &nr, right.data(), &i_one, &d_zero,
           result.data(), &i_one);
    return result;
}

References SmallVector< numberOfRows >::data(), data, DEBUG, dgemv_(), logger, SmallVector< numberOfRows >::size(), and WARN.

operator*=() [1/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix& SmallMatrix< numberOfRows, numberOfColumns >::operator*= ( const Mdouble &  scalar )

inline

Does matrix A_ij=scalar*A_ij.

    {
        std::transform(data_.begin(), data_.end(), data_.begin(),
                       std::bind(std::multiplies<Mdouble>(), std::placeholders::_1, scalar));
        return *this;
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, and transform().

operator*=() [2/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix< numberOfRows, numberOfColumns > & SmallMatrix< numberOfRows, numberOfColumns >::operator*=

(

const SmallMatrix< numberOfColumns, numberOfColumns > &

other

)

Does matrix A_ij = A_ik * B_kj note that other must be square because this is a fixed-size matrix.

{
    //blas does not support in-place multiply
    return (*this) = (*this) * other;
}

operator+()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix SmallMatrix< numberOfRows, numberOfColumns >::operator+ ( const SmallMatrix< numberOfRows, numberOfColumns > &  other ) const

inline

    {
        SmallMatrix result;
        std::transform(data_.begin(), data_.end(), other.data_.begin(), result.data_.begin(), std::plus<Mdouble>());
        return result;
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, and transform().

operator+=()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix& SmallMatrix< numberOfRows, numberOfColumns >::operator+= ( const SmallMatrix< numberOfRows, numberOfColumns > &  other )

inline

    {
        std::transform(data_.begin(), data_.end(), other.data_.begin(), data_.begin(), std::plus<Mdouble>());
        return *this;
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, and transform().

operator-() [1/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix SmallMatrix< numberOfRows, numberOfColumns >::operator- ( void  ) const

inline

    {
        return *this * -1.;
    }

operator-() [2/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix SmallMatrix< numberOfRows, numberOfColumns >::operator- ( const SmallMatrix< numberOfRows, numberOfColumns > &  other ) const

inline

    {
        SmallMatrix result;
        std::transform(data_.begin(), data_.end(), other.data_.begin(), result.data_.begin(), std::minus<Mdouble>());
        return result;
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, and transform().

operator-=()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix& SmallMatrix< numberOfRows, numberOfColumns >::operator-= ( const SmallMatrix< numberOfRows, numberOfColumns > &  other )

inline

    {
        std::transform(data_.begin(), data_.end(), other.data_.begin(), data_.begin(), std::minus<Mdouble>());
        return *this;
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, and transform().

operator/()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix SmallMatrix< numberOfRows, numberOfColumns >::operator/ ( const Mdouble &  scalar ) const

inline

this does element by divided by a scalar

    {
        SmallMatrix result;
        std::transform(data_.begin(), data_.end(), result.data_.begin(),
                       std::bind(std::divides<Mdouble>(), std::placeholders::_1, scalar));
        return result;
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, and transform().

operator/=()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix& SmallMatrix< numberOfRows, numberOfColumns >::operator/= ( const Mdouble &  scalar )

inline

Does matrix A_ij=scalar*A_ij.

    {
        std::transform(data_.begin(), data_.end(), data_.begin(),
                       std::bind(std::divides<Mdouble>(), std::placeholders::_1, scalar));
        return *this;
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, and transform().

operator=() [1/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix& SmallMatrix< numberOfRows, numberOfColumns >::operator= ( const SmallMatrix< numberOfRows, numberOfColumns > &  right )

inline

Assigns one matrix to another.

    {
        std::copy(right.data_.begin(), right.data_.end(), data_.begin());
        return *this;
    }

References copy(), and SmallMatrix< numberOfRows, numberOfColumns >::data_.

operator=() [2/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix& SmallMatrix< numberOfRows, numberOfColumns >::operator= ( SmallMatrix< numberOfRows, numberOfColumns > &&  right )

inline

Assigns one matrix to another.

    {
        std::move(right.data_.begin(), right.data_.end(), data_.begin());
        return *this;
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_.

operator[]() [1/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

Mdouble& SmallMatrix< numberOfRows, numberOfColumns >::operator[] ( const unsigned int  n )

inline

Access the n linear element in the matrix.

    {
        logger.assert_debug(n < numberOfRows * numberOfColumns, "Requested entry % for a matrix with only % entries", n,
                      numberOfRows * numberOfColumns);
        return data_[n];
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, logger, and n.

operator[]() [2/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

const Mdouble& SmallMatrix< numberOfRows, numberOfColumns >::operator[] ( const unsigned int  n ) const

inline

    {
        logger.assert_debug(n < numberOfRows * numberOfColumns, "Requested entry % for a matrix with only % entries", n,
                      numberOfRows * numberOfColumns);
        return data_[n];
    }

References SmallMatrix< numberOfRows, numberOfColumns >::data_, logger, and n.

size()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

unsigned int SmallMatrix< numberOfRows, numberOfColumns >::size ( ) const

inline

Get total number of Matrix entries.

    {
        return numberOfRows * numberOfColumns;
    }

Referenced by main().

solve() [1/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

template<unsigned int numberOfRightHandSideColumns>

void SmallMatrix< numberOfRows, numberOfColumns >::solve

(

SmallMatrix< numberOfRows, numberOfRightHandSideColumns > &

B

)

const

solves Ax=B where A is the current matrix and B is passed in. The result is returned in B.

{
    logger.assert_debug(numberOfRows == numberOfColumns, "can only solve for square matrixes");
    
    int n = numberOfRows;
    int nrhs = numberOfRightHandSideColumns;
    int info;
    
    int IPIV[numberOfRows];
    SmallMatrix<numberOfRows, numberOfColumns> matThis = *this;
    dgesv_(&n, &nrhs, matThis.data(), &n, IPIV, B.data(), &n, &info);
}

References SmallMatrix< numberOfRows, numberOfColumns >::data(), dgesv_(), info, logger, and n.

Referenced by SuperQuadricParticle::computeContactPoint(), and main().

solve() [2/2]

template<unsigned int numberOfRows, unsigned int numberOfColumns>

void SmallMatrix< numberOfRows, numberOfColumns >::solve

(

SmallVector< numberOfRows > &

b

)

const

solves Ax=b where A is the current matrix and NumericalVector b is the input parameter. The result is returned in b.

{
    logger.assert_debug(numberOfRows == numberOfColumns, "can only solve for square matrixes");
    
    int n = numberOfRows;
    int nrhs = 1;
    int info;
    
    int IPIV[numberOfRows];
    SmallMatrix matThis = *this;
    dgesv_(&n, &nrhs, matThis.data(), &n, IPIV, b.data(), &n, &info);
}

References b, SmallMatrix< numberOfRows, numberOfColumns >::data(), dgesv_(), info, logger, and n.

transpose()

template<unsigned int numberOfRows, unsigned int numberOfColumns>

SmallMatrix<numberOfColumns, numberOfRows> SmallMatrix< numberOfRows, numberOfColumns >::transpose ( ) const

inline

    {
        SmallMatrix<numberOfColumns, numberOfRows> result;
        for (unsigned int i = 0; i < numberOfRows; ++i)
        {
            for (unsigned int j = 0; j < numberOfColumns; ++j)
            {
                result(j, i) = (*this)(i, j);
            }
        }
        return result;
    }

References i, and j.

Referenced by SuperQuadricParticle::getCurvature(), main(), ShapeGradientHessianTester::testCushion(), ShapeGradientHessianTester::testEllipsoid(), and ShapeGradientHessianTester::testRoundedBeam().

Member Data Documentation

data_

template<unsigned int numberOfRows, unsigned int numberOfColumns>

std::array<Mdouble, numberOfRows * numberOfColumns> SmallMatrix< numberOfRows, numberOfColumns >::data_

private

The actually data of the matrix class.

Referenced by SmallMatrix< numberOfRows, numberOfColumns >::axpy(), SmallMatrix< numberOfRows, numberOfColumns >::data(), SmallMatrix< numberOfRows, numberOfColumns >::operator()(), SmallMatrix< numberOfRows, numberOfColumns >::operator*(), SmallMatrix< numberOfRows, numberOfColumns >::operator*=(), SmallMatrix< numberOfRows, numberOfColumns >::operator+(), SmallMatrix< numberOfRows, numberOfColumns >::operator+=(), SmallMatrix< numberOfRows, numberOfColumns >::operator-(), SmallMatrix< numberOfRows, numberOfColumns >::operator-=(), SmallMatrix< numberOfRows, numberOfColumns >::operator/(), SmallMatrix< numberOfRows, numberOfColumns >::operator/=(), SmallMatrix< numberOfRows, numberOfColumns >::operator=(), SmallMatrix< numberOfRows, numberOfColumns >::operator[](), and SmallMatrix< numberOfRows, numberOfColumns >::SmallMatrix().

---

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

• SmallMatrix.h
• SmallMatrix_impl.h