anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Updated GTX_matrix_factorisation to be more consistency with the rest of the codebase #654

Browse Source
master
Christophe Riccio ago%!(EXTRA string=8 years)
parent 1ce38b4fad
commit 64cfbc0451
2 changed files with 24 additions and 14 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 11
      glm/gtx/matrix_factorisation.hpp
  2. 27
      glm/gtx/matrix_factorisation.inl

11
glm/gtx/matrix_factorisation.hpp
Unescape View File

@ -29,26 +29,27 @@ Suggestions:
- Implement other types of matrix factorisation, such as: QL and LQ, L(D)U, eigendecompositions, etc...
*/
namespace glm{
namespace glm
{
/// @addtogroup gtx_matrix_factorisation
/// @{
/// Flips the matrix rows up and down.
/// From GLM_GTX_matrix_factorisation extension.
template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
GLM_FUNC_DECL matType<C, R, T, P> flipud(const matType<C, R, T, P>& in);
GLM_FUNC_DECL matType<C, R, T, P> flipud(matType<C, R, T, P> const& in);
/// Flips the matrix columns right and left.
/// From GLM_GTX_matrix_factorisation extension.
template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
GLM_FUNC_DECL matType<C, R, T, P> fliplr(const matType<C, R, T, P>& in);
GLM_FUNC_DECL matType<C, R, T, P> fliplr(matType<C, R, T, P> const& in);
/// Performs QR factorisation of a matrix.
/// Returns 2 matrices, q and r, such that the columns of q are orthonormal and span the same subspace than those of the input matrix, r is an upper triangular matrix, and q*r=in.
/// Given an n-by-m input matrix, q has dimensions min(n,m)-by-m, and r has dimensions n-by-min(n,m).
/// From GLM_GTX_matrix_factorisation extension.
template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
GLM_FUNC_DECL void qr_decompose(matType<(C < R ? C : R), R, T, P>& q, matType<C, (C < R ? C : R), T, P>& r, const matType<C, R, T, P>& in);
GLM_FUNC_DECL void qr_decompose(matType<C, R, T, P> const& in, matType<(C < R ? C : R), R, T, P>& q, matType<C, (C < R ? C : R), T, P>& r);
/// Performs RQ factorisation of a matrix.
/// Returns 2 matrices, r and q, such that r is an upper triangular matrix, the rows of q are orthonormal and span the same subspace than those of the input matrix, and r*q=in.
@ -56,7 +57,7 @@ namespace glm{
/// Given an n-by-m input matrix, r has dimensions min(n,m)-by-m, and q has dimensions n-by-min(n,m).
/// From GLM_GTX_matrix_factorisation extension.
template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
GLM_FUNC_DECL void rq_decompose(matType<(C < R ? C : R), R, T, P>& r, matType<C, (C < R ? C : R), T, P>& q, const matType<C, R, T, P>& in);
GLM_FUNC_DECL void rq_decompose(matType<C, R, T, P> const& in, matType<(C < R ? C : R), R, T, P>& r, matType<C, (C < R ? C : R), T, P>& q);
/// @}
}

27
glm/gtx/matrix_factorisation.inl
Unescape View File

@ -1,9 +1,11 @@
/// @ref gtx_matrix_factorisation
/// @file glm/gtx/matrix_factorisation.inl
namespace glm {
namespace glm
{
template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
GLM_FUNC_QUALIFIER matType<C, R, T, P> flipud(const matType<C, R, T, P>& in) {
GLM_FUNC_QUALIFIER matType<C, R, T, P> flipud(matType<C, R, T, P> const& in)
{
matType<R, C, T, P> tin = transpose(in);
tin = fliplr(tin);
matType<C, R, T, P> out = transpose(tin);
@ -12,9 +14,11 @@ namespace glm {
}
template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
GLM_FUNC_QUALIFIER matType<C, R, T, P> fliplr(const matType<C, R, T, P>& in) {
GLM_FUNC_QUALIFIER matType<C, R, T, P> fliplr(matType<C, R, T, P> const& in)
{
matType<C, R, T, P> out;
for (length_t i = 0; i < C; i++) {
for (length_t i = 0; i < C; i++)
{
out[i] = in[(C - i) - 1];
}
@ -22,21 +26,24 @@ namespace glm {
}
template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
GLM_FUNC_QUALIFIER void qr_decompose(matType<(C < R ? C : R), R, T, P>& q, matType<C, (C < R ? C : R), T, P>& r, const matType<C, R, T, P>& in) {
GLM_FUNC_QUALIFIER void qr_decompose(matType<C, R, T, P> const& in, matType<(C < R ? C : R), R, T, P>& q, matType<C, (C < R ? C : R), T, P>& r)
{
// Uses modified Gram-Schmidt method
// Source: https://en.wikipedia.org/wiki/Gram–Schmidt_process
// And https://en.wikipedia.org/wiki/QR_decomposition
//For all the linearly independs columns of the input...
// (there can be no more linearly independents columns than there are rows.)
for (length_t i = 0; i < (C < R ? C : R); i++) {
for (length_t i = 0; i < (C < R ? C : R); i++)
{
//Copy in Q the input's i-th column.
q[i] = in[i];
//j = [0,i[
// Make that column orthogonal to all the previous ones by substracting to it the non-orthogonal projection of all the previous columns.
// Also: Fill the zero elements of R
for (length_t j = 0; j < i; j++) {
for (length_t j = 0; j < i; j++)
{
q[i] -= dot(q[i], q[j])*q[j];
r[j][i] = 0;
}
@ -46,14 +53,16 @@ namespace glm {
//j = [i,C[
//Finally, compute the corresponding coefficients of R by computing the projection of the resulting column on the other columns of the input.
for (length_t j = i; j < C; j++) {
for (length_t j = i; j < C; j++)
{
r[j][i] = dot(in[j], q[i]);
}
}
}
template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
GLM_FUNC_QUALIFIER void rq_decompose(matType<(C < R ? C : R), R, T, P>& r, matType<C, (C < R ? C : R), T, P>& q, const matType<C, R, T, P>& in) {
GLM_FUNC_QUALIFIER void rq_decompose(matType<C, R, T, P> const& in, matType<(C < R ? C : R), R, T, P>& r, matType<C, (C < R ? C : R), T, P>& q)
{
// From https://en.wikipedia.org/wiki/QR_decomposition:
// The RQ decomposition transforms a matrix A into the product of an upper triangular matrix R (also known as right-triangular) and an orthogonal matrix Q. The only difference from QR decomposition is the order of these matrices.
// QR decomposition is Gram–Schmidt orthogonalization of columns of A, started from the first column.

Write Preview
Loading…
Cancel
Save