matrix: using vec_t for permutation logic

src/lol/math/matrix.h

@@ -571,19 +571,19 @@ T const & determinant(mat_t<T, 1, 1> const &m)
 }
 
 /*
- * Compute permutation matrix
+ * Compute permutation vector of a square matrix
  */
 
 template<typename T, int N>
-mat_t<T, N, N> p_matrix(mat_t<T, N, N> const & m)
+vec_t<int, N> p_vector(mat_t<T, N, N> const & m)
 {
-    int used[N];
-    int order[N];
+    vec_t<int, N> used;
+    vec_t<int, N> permutation;
 
     for (int i = 0 ; i < N ; ++i)
     {
         used[i] = 0;
-        order[i] = -1;
+        permutation[i] = -1;
     }
 
     for (int i = 0 ; i < N ; ++i)
@@ -599,15 +599,31 @@ mat_t<T, N, N> p_matrix(mat_t<T, N, N> const & m)
         ASSERT(index_max != -1);
         ASSERT(index_max < N);
 
-        order[i] = index_max;
+        permutation[i] = index_max;
         used[index_max] = 1;
     }
 
-    mat_t<T, N, N> P;
+    return permutation;
+}
+
+/*
+ * Compute the permutation of a square matrix according to the permutation vector
+ */
+
+template<typename T, int N>
+mat_t<T, N, N> permute(mat_t<T, N, N> const & m, vec_t<int, N> const & permutation)
+{
+    mat_t<T, N, N> result;
+
     for (int i = 0 ; i < N ; ++i)
-        P[order[i]][i] = 1.0f;
+    {
+        for (int j = 0 ; j < N ; ++j)
+        {
+            result[i][j] = m[i][permutation[j]];
+        }
+    }
 
-    return P;
+    return result;
 }
 
 /*

src/t/math/matrix.cpp

@@ -102,17 +102,17 @@ lolunit_declare_fixture(MatrixTest)
                vec4(0,  0,  0,  1),
                vec4(0,  0,  1,  0));
 
-        mat4 P1 = p_matrix(m1);
-        P1 = P1 * m1;
+        vec_t<int, 4> perm1 = p_vector(m1);
+        m1 = permute(m1, perm1);
 
         for (int i = 0 ; i < 4 ; ++i)
         {
             for (int j = 0 ; j < 4 ; ++j)
             {
                 if (i == j)
-                    lolunit_assert_equal(P1[i][j], 1);
+                    lolunit_assert_equal(m1[i][j], 1);
                 else
-                    lolunit_assert_equal(P1[i][j], 0);
+                    lolunit_assert_equal(m1[i][j], 0);
             }
         }
 
@@ -121,17 +121,17 @@ lolunit_declare_fixture(MatrixTest)
                vec4(0,  0,  0,  1),
                vec4(1,  0,  0,  0));
 
-        mat4 P2 = p_matrix(m2);
-        P2 = P2 * m2;
+        vec_t<int, 4> perm2 = p_vector(m2);
+        m2 = permute(m2, perm2);
 
         for (int i = 0 ; i < 4 ; ++i)
         {
             for (int j = 0 ; j < 4 ; ++j)
             {
                 if (i == j)
-                    lolunit_assert_equal(P2[i][j], 1);
+                    lolunit_assert_equal(m2[i][j], 1);
                 else
-                    lolunit_assert_equal(P2[i][j], 0);
+                    lolunit_assert_equal(m2[i][j], 0);
             }
         }
     }