tdm::mat< R, C, T > Struct Template Reference

#include <Mat.h>

Collaboration diagram for tdm::mat< R, C, T >:

Public Types
using	value_type = T
using	row_type = vec< C, value_type >
using	column_type = vec< R, value_type >

Public Member Functions
	mat ()
	~mat ()=default
	mat (const mat &)=default
mat &	operator= (const mat &)=default
	mat (mat &&)=default
mat &	operator= (mat &&)=default
template<typename U >
	mat (U scalar)
template<typename ... Us, typename std::enable_if< sizeof...(Us)==R *C >::type * = nullptr>
	mat (Us... scalars)
template<typename U >
	mat (const mat< R, C, U > &rhs)
template<typename U >
mat &	operator= (const mat< R, C, U > &rhs)
template<typename ... Us, typename std::enable_if< sizeof...(Us)==R >::type * = nullptr>
	mat (const vec< C, Us > &... vs)
row_type &	operator[] (dim_t index)
const row_type &	operator[] (dim_t index) const
T &	operator() (dim_t rowIndex, dim_t colIndex)
const T &	operator() (dim_t rowIndex, dim_t colIndex) const
template<typename F >
mat &	apply (F func)
template<typename F >
const mat &	apply (F func) const
mat &	operator++ ()
mat &	operator-- ()
template<typename U >
mat &	operator+= (U rhs)
template<typename U >
mat &	operator+= (const mat< R, C, U > &rhs)
mat &	operator+= (const mat &rhs)
template<typename U >
mat &	operator-= (U rhs)
template<typename U >
mat &	operator-= (const mat< R, C, U > &rhs)
mat &	operator-= (const mat &rhs)
template<typename U >
mat &	operator*= (U rhs)
template<typename U >
mat &	operator*= (const mat< R, C, U > &rhs)
mat &	operator*= (const mat &rhs)
template<typename U >
mat &	operator/= (U rhs)
template<typename U >
mat &	operator/= (const mat< R, C, U > &rhs)
mat &	operator/= (const mat &rhs)
template<typename ... , dim_t H = R, dim_t W = C>
std::enable_if< H==W, mat & >::type	transpose ()
mat &	negate ()
row_type	row (dim_t index) const
column_type	column (dim_t index) const
template<dim_t H, dim_t W>
std::enable_if<(H >1 &&W >1 &&H<=R &&W<=C), mat< H, W, T > >::type	submat (dim_t y, dim_t x) const

Static Public Member Functions
static constexpr dim_t	rows ()
static constexpr dim_t	columns ()
template<typename ... Us, typename std::enable_if< sizeof...(Us)==R >::type * = nullptr>
static mat	fromRows (const vec< C, Us > &... vs)
template<typename ... Us, typename std::enable_if< sizeof...(Us)==C >::type * = nullptr>
static mat	fromColumns (const vec< R, Us > &... vs)
template<typename U , typename ... , dim_t H = R, dim_t W = C>
static std::enable_if< H==W, mat >::type	diagonal (U scalar)
template<typename U , typename ... , dim_t H = R, dim_t W = C>
static std::enable_if< H==W, mat >::type	diagonal (const vec< W, U > &scalars)
template<typename ... Us, dim_t H = R, dim_t W = C>
static std::enable_if<(H==W)&&(sizeof...(Us)==H), mat >::type	diagonal (Us... scalars)
template<typename ... , dim_t H = R, dim_t W = C>
static std::enable_if< H==W, mat >::type	identity ()

Private Attributes
row_type	values [R]

Member Typedef Documentation

column_type

template<dim_t R, dim_t C, typename T >

using tdm::mat< R, C, T >::column_type = vec<R, value_type>

row_type

template<dim_t R, dim_t C, typename T >

using tdm::mat< R, C, T >::row_type = vec<C, value_type>

value_type

template<dim_t R, dim_t C, typename T >

using tdm::mat< R, C, T >::value_type = T

Constructor & Destructor Documentation

mat() [1/7]

template<dim_t R, dim_t C, typename T >

tdm::mat< R, C, T >::mat ( )

inline

              : values{} {
        }

~mat()

template<dim_t R, dim_t C, typename T >

tdm::mat< R, C, T >::~mat ( )

default

mat() [2/7]

template<dim_t R, dim_t C, typename T >

tdm::mat< R, C, T >::mat ( const mat< R, C, T > &  )

default

mat() [3/7]

template<dim_t R, dim_t C, typename T >

tdm::mat< R, C, T >::mat ( mat< R, C, T > &&  )

default

mat() [4/7]

template<dim_t R, dim_t C, typename T >

template<typename U >

tdm::mat< R, C, T >::mat ( U  scalar )

inlineexplicit

                               {
            apply([scalar](row_type& row, dim_t  /*unused*/) {
                row = row_type{scalar};
            });
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

mat() [5/7]

template<dim_t R, dim_t C, typename T >

template<typename ... Us, typename std::enable_if< sizeof...(Us)==R *C >::type * = nullptr>

tdm::mat< R, C, T >::mat ( Us...  scalars )

inline

                           {
            T tmp[sizeof...(Us)] = {static_cast<T>(scalars)...};
            apply([&tmp](row_type& row, dim_t ri) {
                row.apply([&tmp, ri](value_type& value, dim_t ci) {
                    value = tmp[ri * columns() + ci];
                });
            });
        }

References tdm::mat< R, C, T >::apply(), tdm::vec< L, T >::apply(), tdm::mat< R, C, T >::columns(), and tdm::mat< R, C, T >::row().

mat() [6/7]

template<dim_t R, dim_t C, typename T >

template<typename U >

tdm::mat< R, C, T >::mat ( const mat< R, C, U > &  rhs )

inline

                                     {
            apply([&rhs](row_type& row, dim_t ri) {
                row = rhs[ri];
            });
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

mat() [7/7]

template<dim_t R, dim_t C, typename T >

template<typename ... Us, typename std::enable_if< sizeof...(Us)==R >::type * = nullptr>

tdm::mat< R, C, T >::mat ( const vec< C, Us > &...  vs )

inline

                                      : values{row_type{vs} ...} {
        }

Member Function Documentation

apply() [1/2]

template<dim_t R, dim_t C, typename T >

template<typename F >

mat & tdm::mat< R, C, T >::apply ( F  func )

inline

                           {
            for (dim_t ri{}; ri != rows(); ++ri) {
                func(values[ri], ri);
            }
            return *this;
        }

References tdm::mat< R, C, T >::rows(), and tdm::mat< R, C, T >::values.

Referenced by tdm::mat< R, C, T >::column(), tdm::mat< R, C, T >::diagonal(), tdm::mat< R, C, T >::mat(), tdm::mat< R, C, T >::negate(), tdm::operator*(), tdm::mat< R, C, T >::operator*=(), tdm::mat< R, C, T >::operator++(), tdm::mat< R, C, T >::operator+=(), tdm::mat< R, C, T >::operator--(), tdm::mat< R, C, T >::operator-=(), tdm::operator/(), tdm::mat< R, C, T >::operator/=(), tdm::operator==(), tdm::mat< R, C, T >::submat(), and tdm::transpose().

apply() [2/2]

template<dim_t R, dim_t C, typename T >

template<typename F >

const mat & tdm::mat< R, C, T >::apply ( F  func ) const

inline

                                       {
            for (dim_t ri{}; ri != rows(); ++ri) {
                func(values[ri], ri);
            }
            return *this;
        }

References tdm::mat< R, C, T >::rows(), and tdm::mat< R, C, T >::values.

column()

template<dim_t R, dim_t C, typename T >

column_type tdm::mat< R, C, T >::column ( dim_t  index ) const

inline

                                              {
            column_type col;
            apply([&col, index](const row_type& row, dim_t ri) {
                col[ri] = row[index];
            });
            return col;
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

Referenced by tdm::operator*().

columns()

template<dim_t R, dim_t C, typename T >

static constexpr dim_t tdm::mat< R, C, T >::columns ( )

inlinestaticconstexpr

                                     {
        return row_type::dimensions();
    }

References tdm::vec< C, value_type >::dimensions().

Referenced by tdm::mat< R, C, T >::mat(), and tdm::mat< R, C, T >::submat().

diagonal() [1/3]

template<dim_t R, dim_t C, typename T >

template<typename U , typename ... , dim_t H = R, dim_t W = C>

static std::enable_if< H==W, mat >::type tdm::mat< R, C, T >::diagonal ( const vec< W, U > &  scalars )

inlinestatic

                                                                                         {
            mat ret;
            ret.apply([&scalars](row_type& row, dim_t ri) {
                row[ri] = scalars[ri];
            });
            return ret;
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

diagonal() [2/3]

template<dim_t R, dim_t C, typename T >

template<typename U , typename ... , dim_t H = R, dim_t W = C>

static std::enable_if< H==W, mat >::type tdm::mat< R, C, T >::diagonal ( U  scalar )

inlinestatic

                                                                         {
            mat ret;
            ret.apply([scalar](row_type& row, dim_t ri) {
                row[ri] = scalar;
            });
            return ret;
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

Referenced by tdm::mat< R, C, T >::diagonal(), tdm::mat< R, C, T >::identity(), and tdm::affine::scale().

diagonal() [3/3]

template<dim_t R, dim_t C, typename T >

template<typename ... Us, dim_t H = R, dim_t W = C>

static std::enable_if<(H==W)&&(sizeof...(Us)==H), mat >::type tdm::mat< R, C, T >::diagonal ( Us...  scalars )

inlinestatic

                                                                                                        {
            return diagonal(vec<R, T>{scalars ...});
        }

References tdm::mat< R, C, T >::diagonal().

fromColumns()

template<dim_t R, dim_t C, typename T >

template<typename ... Us, typename std::enable_if< sizeof...(Us)==C >::type * = nullptr>

static mat tdm::mat< R, C, T >::fromColumns ( const vec< R, Us > &...  vs )

inlinestatic

                                                         {
            mat<sizeof...(vs), R, T> tmp{vs ...};
            return tdm::transpose(tmp);
        }

References tdm::transpose().

fromRows()

template<dim_t R, dim_t C, typename T >

template<typename ... Us, typename std::enable_if< sizeof...(Us)==R >::type * = nullptr>

static mat tdm::mat< R, C, T >::fromRows ( const vec< C, Us > &...  vs )

inlinestatic

                                                      {
            return mat{vs ...};
        }

identity()

template<dim_t R, dim_t C, typename T >

template<typename ... , dim_t H = R, dim_t W = C>

static std::enable_if< H==W, mat >::type tdm::mat< R, C, T >::identity ( )

inlinestatic

                                                                 {
            return diagonal(static_cast<T>(1));
        }

References tdm::mat< R, C, T >::diagonal().

Referenced by dnac::extractTranslationMatrix().

negate()

template<dim_t R, dim_t C, typename T >

mat & tdm::mat< R, C, T >::negate ( )

inline

                      {
            apply([](row_type& row, dim_t  /*unused*/) {
                row.negate();
            });
            return *this;
        }

References tdm::mat< R, C, T >::apply(), tdm::vec< L, T >::negate(), and tdm::mat< R, C, T >::row().

operator()() [1/2]

template<dim_t R, dim_t C, typename T >

T & tdm::mat< R, C, T >::operator() ( dim_t  rowIndex, dim_t  colIndex  )

inline

                                                      {
            return operator[](rowIndex)[colIndex];
        }

References tdm::mat< R, C, T >::operator[]().

operator()() [2/2]

template<dim_t R, dim_t C, typename T >

const T & tdm::mat< R, C, T >::operator() ( dim_t  rowIndex, dim_t  colIndex  ) const

inline

                                                                  {
            return operator[](rowIndex)[colIndex];
        }

References tdm::mat< R, C, T >::operator[]().

operator*=() [1/3]

template<dim_t R, dim_t C, typename T >

mat & tdm::mat< R, C, T >::operator*= ( const mat< R, C, T > &  rhs )

inline

                                        {
            return operator*=<T>(rhs);
        }

operator*=() [2/3]

template<dim_t R, dim_t C, typename T >

template<typename U >

mat & tdm::mat< R, C, T >::operator*= ( const mat< R, C, U > &  rhs )

inline

                                                 {
            return (*this = *this * rhs);
        }

operator*=() [3/3]

template<dim_t R, dim_t C, typename T >

template<typename U >

mat & tdm::mat< R, C, T >::operator*= ( U  rhs )

inline

                               {
            return apply([rhs](row_type& row, dim_t  /*unused*/) {
                row *= rhs;
            });
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

Referenced by tdm::mat< R, C, T >::operator/=().

operator++()

template<dim_t R, dim_t C, typename T >

mat & tdm::mat< R, C, T >::operator++ ( )

inline

                          {
            return apply([](row_type& row, dim_t  /*unused*/) {
                ++row;
            });
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

operator+=() [1/3]

template<dim_t R, dim_t C, typename T >

mat & tdm::mat< R, C, T >::operator+= ( const mat< R, C, T > &  rhs )

inline

                                        {
            return operator+=<T>(rhs);
        }

operator+=() [2/3]

template<dim_t R, dim_t C, typename T >

template<typename U >

mat & tdm::mat< R, C, T >::operator+= ( const mat< R, C, U > &  rhs )

inline

                                                 {
            return apply([&rhs](row_type& row, dim_t ri) {
                row += rhs[ri];
            });
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

operator+=() [3/3]

template<dim_t R, dim_t C, typename T >

template<typename U >

mat & tdm::mat< R, C, T >::operator+= ( U  rhs )

inline

                               {
            return apply([rhs](row_type& row, dim_t  /*unused*/) {
                row += rhs;
            });
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

operator--()

template<dim_t R, dim_t C, typename T >

mat & tdm::mat< R, C, T >::operator-- ( )

inline

                          {
            return apply([](row_type& row, dim_t  /*unused*/) {
                --row;
            });
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

operator-=() [1/3]

template<dim_t R, dim_t C, typename T >

mat & tdm::mat< R, C, T >::operator-= ( const mat< R, C, T > &  rhs )

inline

                                        {
            return operator-=<T>(rhs);
        }

operator-=() [2/3]

template<dim_t R, dim_t C, typename T >

template<typename U >

mat & tdm::mat< R, C, T >::operator-= ( const mat< R, C, U > &  rhs )

inline

                                                 {
            return apply([&rhs](row_type& row, dim_t ri) {
                row -= rhs[ri];
            });
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

operator-=() [3/3]

template<dim_t R, dim_t C, typename T >

template<typename U >

mat & tdm::mat< R, C, T >::operator-= ( U  rhs )

inline

                               {
            return apply([rhs](row_type& row, dim_t  /*unused*/) {
                row -= rhs;
            });
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

operator/=() [1/3]

template<dim_t R, dim_t C, typename T >

mat & tdm::mat< R, C, T >::operator/= ( const mat< R, C, T > &  rhs )

inline

                                        {
            return operator/=<T>(rhs);
        }

operator/=() [2/3]

template<dim_t R, dim_t C, typename T >

template<typename U >

mat & tdm::mat< R, C, T >::operator/= ( const mat< R, C, U > &  rhs )

inline

                                                 {
            return operator*=(inverse(rhs));
        }

References tdm::inverse(), and tdm::mat< R, C, T >::operator*=().

operator/=() [3/3]

template<dim_t R, dim_t C, typename T >

template<typename U >

mat & tdm::mat< R, C, T >::operator/= ( U  rhs )

inline

                               {
            return apply([rhs](row_type& row, dim_t  /*unused*/) {
                row /= rhs;
            });
        }

References tdm::mat< R, C, T >::apply(), and tdm::mat< R, C, T >::row().

operator=() [1/3]

template<dim_t R, dim_t C, typename T >

mat & tdm::mat< R, C, T >::operator= ( const mat< R, C, T > &  )

default

Referenced by tdm::mat< R, C, T >::operator=().

operator=() [2/3]

template<dim_t R, dim_t C, typename T >

template<typename U >

mat & tdm::mat< R, C, T >::operator= ( const mat< R, C, U > &  rhs )

inline

                                                {
            return operator=(mat<R, C, T>{rhs});
        }

References tdm::mat< R, C, T >::operator=().

operator=() [3/3]

template<dim_t R, dim_t C, typename T >

mat & tdm::mat< R, C, T >::operator= ( mat< R, C, T > &&  )

default

operator[]() [1/2]

template<dim_t R, dim_t C, typename T >

row_type & tdm::mat< R, C, T >::operator[] ( dim_t  index )

inline

                                          {
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay,hicpp-no-array-decay)
            assert(index < rows());
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
            return values[index];
        }

References tdm::mat< R, C, T >::rows(), and tdm::mat< R, C, T >::values.

Referenced by tdm::mat< R, C, T >::operator()(), and tdm::mat< R, C, T >::row().

operator[]() [2/2]

template<dim_t R, dim_t C, typename T >

const row_type & tdm::mat< R, C, T >::operator[] ( dim_t  index ) const

inline

                                                      {
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay,hicpp-no-array-decay)
            assert(index < rows());
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
            return values[index];
        }

References tdm::mat< R, C, T >::rows(), and tdm::mat< R, C, T >::values.

row()

template<dim_t R, dim_t C, typename T >

row_type tdm::mat< R, C, T >::row ( dim_t  index ) const

inline

                                        {
            return operator[](index);
        }

References tdm::mat< R, C, T >::operator[]().

Referenced by tdm::mat< R, C, T >::column(), tdm::mat< R, C, T >::diagonal(), tdm::mat< R, C, T >::mat(), tdm::mat< R, C, T >::negate(), tdm::mat< R, C, T >::operator*=(), tdm::mat< R, C, T >::operator++(), tdm::mat< R, C, T >::operator+=(), tdm::mat< R, C, T >::operator--(), tdm::mat< R, C, T >::operator-=(), tdm::mat< R, C, T >::operator/=(), and tdm::mat< R, C, T >::submat().

rows()

template<dim_t R, dim_t C, typename T >

static constexpr dim_t tdm::mat< R, C, T >::rows ( )

inlinestaticconstexpr

                                  {
        return column_type::dimensions();
    }

References tdm::vec< L, T >::dimensions().

Referenced by tdm::mat< R, C, T >::apply(), tdm::mat< R, C, T >::operator[](), and tdm::mat< R, C, T >::submat().

submat()

template<dim_t R, dim_t C, typename T >

template<dim_t H, dim_t W>

std::enable_if<(H >1 &&W >1 &&H<=R &&W<=C), mat< H, W, T > >::type tdm::mat< R, C, T >::submat ( dim_t  y, dim_t  x  ) const

inline

                                                                                                                      {
            assert(H + y <= rows());
            assert(W + x <= columns());
            mat<H, W, T> ret;
            ret.apply([this, y, x](typename mat<H, W, T>::row_type& row, dim_t ri) {
                row.apply([this, y, x, ri](value_type& value, dim_t ci) {
                    value = values[y + ri][x + ci];
                });
            });
            return ret;
        }

References tdm::mat< R, C, T >::apply(), tdm::vec< L, T >::apply(), tdm::mat< R, C, T >::columns(), tdm::mat< R, C, T >::row(), tdm::mat< R, C, T >::rows(), and tdm::mat< R, C, T >::values.

transpose()

template<dim_t R, dim_t C, typename T >

template<typename ... , dim_t H = R, dim_t W = C>

std::enable_if< H==W, mat & >::type tdm::mat< R, C, T >::transpose ( )

inline

                                                            {
            return (*this = tdm::transpose(*this));
        }

References tdm::transpose().

Member Data Documentation

values

template<dim_t R, dim_t C, typename T >

row_type tdm::mat< R, C, T >::values[R]

private

Referenced by tdm::mat< R, C, T >::apply(), tdm::mat< R, C, T >::operator[](), and tdm::mat< R, C, T >::submat().

---

The documentation for this struct was generated from the following file:

• Mat.h