tdm::impl Namespace Reference

Functions
template<dim_t N, typename T >
void	minor (const mat< N, N, T > &input, dim_t dimensions, dim_t i, dim_t j, mat< N, N, T > &output)
template<dim_t N, typename T >
T	determinant (const mat< N, N, T > &m, dim_t dimensions)
template<dim_t N, typename T >
mat< N, N, T >	adjoint (const mat< N, N, T > &m)

Function Documentation

adjoint()

template<dim_t N, typename T >

mat< N, N, T > tdm::impl::adjoint ( const mat< N, N, T > &  m )

inline

                                                   {
    if (m.rows() == static_cast<dim_t>(1)) {
        return mat<N, N, T>{static_cast<T>(1)};
    }
 
    mat<N, N, T> result;
    mat<N, N, T> temp;
    for (dim_t row{}; row < m.rows(); ++row) {
        for (dim_t col{}; col < m.columns(); ++col) {
            minor(m, N, row, col, temp);
            const T sign = static_cast<T>((row + col) % 2u == 0u ? 1 : -1);
            result(col, row) = (sign * determinant(temp, N - 1));
        }
    }
    return result;
}

References determinant(), and minor().

Referenced by tdm::inverse().

determinant()

template<dim_t N, typename T >

T tdm::impl::determinant ( const mat< N, N, T > &  m, dim_t  dimensions  )

inline

                                                              {
    if (dimensions == static_cast<dim_t>(1)) {
        return m(0, 0);
    }
 
    T result{};
    mat<N, N, T> temp;
    auto sign = static_cast<T>(1);
    const dim_t i{};
    for (dim_t j{}; j < dimensions; ++j) {
        minor(m, dimensions, i, j, temp);
        result += (sign * m(i, j) * determinant(temp, dimensions - 1));
        sign = -sign;
    }
 
    return result;
}

References determinant(), and minor().

Referenced by adjoint(), tdm::determinant(), and determinant().

minor()

template<dim_t N, typename T >

void tdm::impl::minor ( const mat< N, N, T > &  input, dim_t  dimensions, dim_t  i, dim_t  j, mat< N, N, T > &  output  )

inline

                                                                                                       {
    for (dim_t outRow{}, inRow{}; inRow < dimensions; ++inRow) {
        for (dim_t outCol{}, inCol{}; inCol < dimensions; ++inCol) {
            if ((inRow != i) && (inCol != j)) {
                output(outRow, outCol) = input(inRow, inCol);
                ++outCol;
                if (outCol == (dimensions - static_cast<dim_t>(1))) {
                    outCol = {};
                    ++outRow;
                }
            }
        }
    }
}

Referenced by adjoint(), and determinant().