lolengine
/
lol
mirror of https://github.com/lolengine/lol
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2448 Commits
5 Branches
93 MiB
 
 
 
Tree: 7c907f6f3e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7c907f6f3e'
${ noResults }
lol/src/lol/math/matrix.h

661 lines
19 KiB
Raw Blame History 

  1. //

  2. // Lol Engine

  3. //

  4. // Copyright: (c) 2010-2014 Sam Hocevar <sam@hocevar.net>

  5. //   This program is free software; you can redistribute it and/or

  6. //   modify it under the terms of the Do What The Fuck You Want To

  7. //   Public License, Version 2, as published by Sam Hocevar. See

  8. //   http://www.wtfpl.net/ for more details.

  9. //

  10. 

  11. #pragma once

  12. 

  13. //

  14. // The matrix classes

  15. // ------------------

  16. //

  17. 

  18. #include <ostream>

  19. 

  20. #include <lol/math/vector.h>

  21. #include <lol/math/transform.h>

  22. 

  23. namespace lol

  24. {

  25. 

  26. #if !LOL_FEATURE_CXX11_CONSTEXPR

  27. #   define constexpr /* */

  28. #endif

  29. 

  30. /*

  31.  * The generic “mat_t” type, which is fixed-size

  32.  */

  33. 

  34. template<typename T, int COLS, int ROWS>

  35. struct mat_t

  36.   : public linear_ops::base<vec_t<T,ROWS>>

  37. {

  38.     static int const count = COLS;

  39.     typedef vec_t<T,ROWS> element;

  40.     typedef mat_t<T,COLS,ROWS> type;

  41. 

  42.     inline mat_t() {}

  43. 

  44.     explicit inline mat_t(T const &val)

  45.     {

  46.         T const zero = T(0);

  47.         for (int i = 0; i < COLS; ++i)

  48.             for (int j = 0; j < ROWS; ++j)

  49.                 m_data[i][j] = i == j ? val : zero;

  50.     }

  51. 

  52.     /* Explicit constructor for type conversion */

  53.     template<typename U>

  54.     explicit inline mat_t(mat_t<U, COLS, ROWS> const &m)

  55.     {

  56.         for (int i = 0; i < COLS; ++i)

  57.             m_data[i] = (vec_t<T,ROWS>)m[i];

  58.     }

  59. 

  60.     inline vec_t<T,ROWS>& operator[](size_t n) { return m_data[n]; }

  61.     inline vec_t<T,ROWS> const& operator[](size_t n) const { return m_data[n]; }

  62. 

  63. private:

  64.     vec_t<T,ROWS> m_data[COLS];

  65. };

  66. 

  67. /*

  68.  * 2×2-element matrices

  69.  */

  70. 

  71. template <typename T>

  72. struct mat_t<T, 2, 2>

  73.   : public linear_ops::base<vec_t<T,2>>

  74. {

  75.     static int const count = 2;

  76.     typedef vec_t<T,2> element;

  77.     typedef mat_t<T,2,2> type;

  78. 

  79.     inline mat_t() {}

  80.     inline mat_t(vec_t<T,2> v0, vec_t<T,2> v1)

  81. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  82.       : m_data{ v0, v1 } {}

  83. #else

  84.       : m_v0(v0), m_v1(v1) {}

  85. #endif

  86. 

  87.     explicit inline mat_t(T const &val)

  88. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  89.       : m_data{ vec_t<T,2>(val, T(0)),

  90.                 vec_t<T,2>(T(0), val) } {}

  91. #else

  92.       : m_v0(val, T(0)),

  93.         m_v1(T(0), val) {}

  94. #endif

  95. 

  96.     explicit inline mat_t(mat_t<T,4,4> const &m)

  97. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  98.       : m_data{ m[0].xy, m[1].xy } {}

  99. #else

  100.       : m_v0(m[0].xy), m_v1(m[1].xy) {}

  101. #endif

  102. 

  103.     /* Explicit constructor for type conversion */

  104.     template<typename U>

  105.     explicit inline mat_t(mat_t<U,2,2> const &m)

  106. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  107.       : m_data{ (element)m[0], (element)m[1] } {}

  108. #else

  109.       : m_v0((element)m[0]), m_v1((element)m[1]) {}

  110. #endif

  111. 

  112. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  113.     inline vec_t<T,2>& operator[](size_t n) { return m_data[n]; }

  114.     inline vec_t<T,2> const& operator[](size_t n) const { return m_data[n]; }

  115. #else

  116.     inline vec_t<T,2>& operator[](size_t n) { return (&m_v0)[n]; }

  117.     inline vec_t<T,2> const& operator[](size_t n) const { return (&m_v0)[n]; }

  118. #endif

  119. 

  120.     /* Helpers for transformation matrices */

  121.     static mat_t<T,2,2> rotate(T degrees);

  122.     static inline mat_t<T,2,2> rotate(mat_t<T,2,2> m, T degrees)

  123.     {

  124.         return rotate(degrees) * m;

  125.     }

  126. 

  127.     void printf() const;

  128.     String tostring() const;

  129. 

  130.     template<class U>

  131.     friend std::ostream &operator<<(std::ostream &stream,

  132.                                     mat_t<U,2,2> const &m);

  133. 

  134.     static const mat_t<T,2,2> identity;

  135. 

  136. private:

  137. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  138.     vec_t<T,2> m_data[2];

  139. #else

  140.     vec_t<T,2> m_v0, m_v1;

  141. #endif

  142. };

  143. 

  144. static_assert(sizeof(imat2) == 16, "sizeof(imat2) == 16");

  145. #if LOL_FEATURE_CXX11_UNRESTRICTED_UNIONS

  146. static_assert(sizeof(f16mat2) == 8, "sizeof(f16mat2) == 8");

  147. #endif

  148. static_assert(sizeof(mat2) == 16, "sizeof(mat2) == 16");

  149. static_assert(sizeof(dmat2) == 32, "sizeof(dmat2) == 32");

  150. 

  151. /*

  152.  * 3×3-element matrices

  153.  */

  154. 

  155. template <typename T>

  156. struct mat_t<T, 3, 3>

  157.   : public linear_ops::base<vec_t<T,3>>

  158. {

  159.     static int const count = 3;

  160.     typedef vec_t<T,3> element;

  161.     typedef mat_t<T,3,3> type;

  162. 

  163.     inline mat_t() {}

  164.     inline mat_t(vec_t<T,3> v0, vec_t<T,3> v1, vec_t<T,3> v2)

  165. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  166.       : m_data{ v0, v1, v2 } {}

  167. #else

  168.       : m_v0(v0), m_v1(v1), m_v2(v2) {}

  169. #endif

  170. 

  171.     explicit inline mat_t(T const &val)

  172. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  173.       : m_data{ vec_t<T,3>(val, (T)0, (T)0),

  174.                 vec_t<T,3>((T)0, val, (T)0),

  175.                 vec_t<T,3>((T)0, (T)0, val) } {}

  176. #else

  177.       : m_v0(val, (T)0, (T)0),

  178.         m_v1((T)0, val, (T)0),

  179.         m_v2((T)0, (T)0, val) {}

  180. #endif

  181. 

  182.     explicit inline mat_t(mat_t<T,2,2> m, T const &val = T(1))

  183. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  184.       : m_data{ vec_t<T,3>(m[0], (T)0),

  185.                 vec_t<T,3>(m[1], (T)0),

  186.                 vec_t<T,3>((T)0, (T)0, val) } {}

  187. #else

  188.       : m_v0(m[0], (T)0),

  189.         m_v1(m[1], (T)0),

  190.         m_v2((T)0, (T)0, val) {}

  191. #endif

  192. 

  193.     explicit inline mat_t(mat_t<T,4,4> const &m)

  194. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  195.       : m_data{ m[0].xyz, m[1].xyz, m[2].xyz } {}

  196. #else

  197.       : m_v0(m[0].xyz), m_v1(m[1].xyz), m_v2(m[2].xyz) {}

  198. #endif

  199. 

  200.     /* Explicit constructor for type conversion */

  201.     template<typename U>

  202.     explicit inline mat_t(mat_t<U,3,3> const &m)

  203. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  204.       : m_data{ (element)m[0], (element)m[1], (element)m[2] } {}

  205. #else

  206.       : m_v0((element)m[0]), m_v1((element)m[1]), m_v2((element)m[2]) {}

  207. #endif

  208. 

  209.     explicit mat_t(quat_t<T> const &q);

  210. 

  211. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  212.     inline vec_t<T,3>& operator[](size_t n) { return m_data[n]; }

  213.     inline vec_t<T,3> const& operator[](size_t n) const { return m_data[n]; }

  214. #else

  215.     inline vec_t<T,3>& operator[](size_t n) { return (&m_v0)[n]; }

  216.     inline vec_t<T,3> const& operator[](size_t n) const { return (&m_v0)[n]; }

  217. #endif

  218. 

  219.     /* Helpers for transformation matrices */

  220.     static mat_t<T,3,3> scale(T x);

  221.     static mat_t<T,3,3> scale(T x, T y, T z);

  222.     static mat_t<T,3,3> scale(vec_t<T,3> v);

  223.     static mat_t<T,3,3> rotate(T degrees, T x, T y, T z);

  224.     static mat_t<T,3,3> rotate(T degrees, vec_t<T,3> v);

  225. 

  226.     static mat_t<T,3,3> fromeuler_xyz(vec_t<T,3> const &v);

  227.     static mat_t<T,3,3> fromeuler_xzy(vec_t<T,3> const &v);

  228.     static mat_t<T,3,3> fromeuler_yxz(vec_t<T,3> const &v);

  229.     static mat_t<T,3,3> fromeuler_yzx(vec_t<T,3> const &v);

  230.     static mat_t<T,3,3> fromeuler_zxy(vec_t<T,3> const &v);

  231.     static mat_t<T,3,3> fromeuler_zyx(vec_t<T,3> const &v);

  232.     static mat_t<T,3,3> fromeuler_xyz(T phi, T theta, T psi);

  233.     static mat_t<T,3,3> fromeuler_xzy(T phi, T theta, T psi);

  234.     static mat_t<T,3,3> fromeuler_yxz(T phi, T theta, T psi);

  235.     static mat_t<T,3,3> fromeuler_yzx(T phi, T theta, T psi);

  236.     static mat_t<T,3,3> fromeuler_zxy(T phi, T theta, T psi);

  237.     static mat_t<T,3,3> fromeuler_zyx(T phi, T theta, T psi);

  238. 

  239.     static mat_t<T,3,3> fromeuler_xyx(vec_t<T,3> const &v);

  240.     static mat_t<T,3,3> fromeuler_xzx(vec_t<T,3> const &v);

  241.     static mat_t<T,3,3> fromeuler_yxy(vec_t<T,3> const &v);

  242.     static mat_t<T,3,3> fromeuler_yzy(vec_t<T,3> const &v);

  243.     static mat_t<T,3,3> fromeuler_zxz(vec_t<T,3> const &v);

  244.     static mat_t<T,3,3> fromeuler_zyz(vec_t<T,3> const &v);

  245.     static mat_t<T,3,3> fromeuler_xyx(T phi, T theta, T psi);

  246.     static mat_t<T,3,3> fromeuler_xzx(T phi, T theta, T psi);

  247.     static mat_t<T,3,3> fromeuler_yxy(T phi, T theta, T psi);

  248.     static mat_t<T,3,3> fromeuler_yzy(T phi, T theta, T psi);

  249.     static mat_t<T,3,3> fromeuler_zxz(T phi, T theta, T psi);

  250.     static mat_t<T,3,3> fromeuler_zyz(T phi, T theta, T psi);

  251. 

  252.     static inline mat_t<T,3,3> rotate(mat_t<T,3,3> m, T degrees, vec_t<T,3> v)

  253.     {

  254.         return rotate(degrees, v) * m;

  255.     }

  256. 

  257.     void printf() const;

  258.     String tostring() const;

  259. 

  260.     template<class U>

  261.     friend std::ostream &operator<<(std::ostream &stream,

  262.                                     mat_t<U,3,3> const &m);

  263. 

  264.     static const mat_t<T,3,3> identity;

  265. 

  266. private:

  267. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  268.     vec_t<T,3> m_data[3];

  269. #else

  270.     vec_t<T,3> m_v0, m_v1, m_v2;

  271. #endif

  272. };

  273. 

  274. static_assert(sizeof(imat3) == 36, "sizeof(imat3) == 36");

  275. #if LOL_FEATURE_CXX11_UNRESTRICTED_UNIONS

  276. static_assert(sizeof(f16mat3) == 18, "sizeof(f16mat3) == 18");

  277. #endif

  278. static_assert(sizeof(mat3) == 36, "sizeof(mat3) == 36");

  279. static_assert(sizeof(dmat3) == 72, "sizeof(dmat3) == 72");

  280. 

  281. /*

  282.  * 4×4-element matrices

  283.  */

  284. 

  285. template <typename T>

  286. struct mat_t<T, 4, 4>

  287.   : public linear_ops::base<vec_t<T,4>>

  288. {

  289.     static int const count = 4;

  290.     typedef vec_t<T,4> element;

  291.     typedef mat_t<T,4,4> type;

  292. 

  293.     inline mat_t() {}

  294.     inline mat_t(vec_t<T,4> v0, vec_t<T,4> v1, vec_t<T,4> v2, vec_t<T,4> v3)

  295. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  296.       : m_data{ v0, v1, v2, v3 } {}

  297. #else

  298.       : m_v0(v0), m_v1(v1), m_v2(v2), m_v3(v3) {}

  299. #endif

  300. 

  301.     explicit inline mat_t(T const &val)

  302. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  303.       : m_data{ vec_t<T,4>(val, (T)0, (T)0, (T)0),

  304.                 vec_t<T,4>((T)0, val, (T)0, (T)0),

  305.                 vec_t<T,4>((T)0, (T)0, val, (T)0),

  306.                 vec_t<T,4>((T)0, (T)0, (T)0, val) } {}

  307. #else

  308.       : m_v0(val, (T)0, (T)0, (T)0),

  309.         m_v1((T)0, val, (T)0, (T)0),

  310.         m_v2((T)0, (T)0, val, (T)0),

  311.         m_v3((T)0, (T)0, (T)0, val) {}

  312. #endif

  313. 

  314.     explicit inline mat_t(mat_t<T,2,2> m, T const &val = T(1))

  315. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  316.       : m_data{ vec_t<T,4>(m[0], (T)0, (T)0),

  317.                 vec_t<T,4>(m[1], (T)0, (T)0),

  318.                 vec_t<T,4>((T)0, (T)0, val, (T)0),

  319.                 vec_t<T,4>((T)0, (T)0, (T)0, val) } {}

  320. #else

  321.       : m_v0(m[0], (T)0, (T)0),

  322.         m_v1(m[1], (T)0, (T)0),

  323.         m_v2((T)0, (T)0, val, (T)0),

  324.         m_v3((T)0, (T)0, (T)0, val) {}

  325. #endif

  326. 

  327.     explicit inline mat_t(mat_t<T,3,3> m, T const &val = T(1))

  328. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  329.       : m_data{ vec_t<T,4>(m[0], (T)0),

  330.                 vec_t<T,4>(m[1], (T)0),

  331.                 vec_t<T,4>(m[2], (T)0),

  332.                 vec_t<T,4>((T)0, (T)0, (T)0, val) } {}

  333. #else

  334.       : m_v0(m[0], (T)0),

  335.         m_v1(m[1], (T)0),

  336.         m_v2(m[2], (T)0),

  337.         m_v3((T)0, (T)0, (T)0, val) {}

  338. #endif

  339. 

  340.     /* Explicit constructor for type conversion */

  341.     template<typename U>

  342.     explicit inline mat_t(mat_t<U,4,4> const &m)

  343. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  344.       : m_data{ (element)m[0], (element)m[1],

  345.                 (element)m[2], (element)m[3] } {}

  346. #else

  347.       : m_v0((element)m[0]), m_v1((element)m[1]),

  348.         m_v2((element)m[2]), m_v3((element)m[3]) {}

  349. #endif

  350. 

  351.     explicit mat_t(quat_t<T> const &q);

  352. 

  353. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  354.     inline vec_t<T,4>& operator[](size_t n) { return m_data[n]; }

  355.     inline vec_t<T,4> const& operator[](size_t n) const { return m_data[n]; }

  356. #else

  357.     inline vec_t<T,4>& operator[](size_t n) { return (&m_v0)[n]; }

  358.     inline vec_t<T,4> const& operator[](size_t n) const { return (&m_v0)[n]; }

  359. #endif

  360. 

  361.     /* Helpers for transformation matrices */

  362.     static mat_t<T,4,4> translate(T x, T y, T z);

  363.     static mat_t<T,4,4> translate(vec_t<T,3> v);

  364. 

  365.     static inline mat_t<T,4,4> scale(T x)

  366.     {

  367.         return mat_t<T,4,4>(mat_t<T,3,3>::scale(x), (T)1);

  368.     }

  369. 

  370.     static inline mat_t<T,4,4> scale(T x, T y, T z)

  371.     {

  372.         return mat_t<T,4,4>(mat_t<T,3,3>::scale(x, y, z), (T)1);

  373.     }

  374. 

  375.     static inline mat_t<T,4,4> scale(vec_t<T,3> v)

  376.     {

  377.         return mat_t<T,4,4>(mat_t<T,3,3>::scale(v), (T)1);

  378.     }

  379. 

  380.     static inline mat_t<T,4,4> translate(mat_t<T,4,4> const &m, vec_t<T,3> v)

  381.     {

  382.         return translate(v) * m;

  383.     }

  384. 

  385.     static inline mat_t<T,4,4> rotate(T degrees, T x, T y, T z)

  386.     {

  387.         return mat_t<T,4,4>(mat_t<T,3,3>::rotate(degrees, x, y, z), (T)1);

  388.     }

  389. 

  390.     static inline mat_t<T,4,4> rotate(T degrees, vec_t<T,3> v)

  391.     {

  392.         return mat_t<T,4,4>(mat_t<T,3,3>::rotate(degrees, v), (T)1);

  393.     }

  394. 

  395.     static inline mat_t<T,4,4> rotate(mat_t<T,4,4> &m, T degrees, vec_t<T,3> v)

  396.     {

  397.         return rotate(degrees, v) * m;

  398.     }

  399. 

  400.     static mat_t<T,4,4> fromeuler_xyz(vec_t<T,3> const &v);

  401.     static mat_t<T,4,4> fromeuler_xzy(vec_t<T,3> const &v);

  402.     static mat_t<T,4,4> fromeuler_yxz(vec_t<T,3> const &v);

  403.     static mat_t<T,4,4> fromeuler_yzx(vec_t<T,3> const &v);

  404.     static mat_t<T,4,4> fromeuler_zxy(vec_t<T,3> const &v);

  405.     static mat_t<T,4,4> fromeuler_zyx(vec_t<T,3> const &v);

  406.     static mat_t<T,4,4> fromeuler_xyz(T phi, T theta, T psi);

  407.     static mat_t<T,4,4> fromeuler_xzy(T phi, T theta, T psi);

  408.     static mat_t<T,4,4> fromeuler_yxz(T phi, T theta, T psi);

  409.     static mat_t<T,4,4> fromeuler_yzx(T phi, T theta, T psi);

  410.     static mat_t<T,4,4> fromeuler_zxy(T phi, T theta, T psi);

  411.     static mat_t<T,4,4> fromeuler_zyx(T phi, T theta, T psi);

  412. 

  413.     static mat_t<T,4,4> fromeuler_xyx(vec_t<T,3> const &v);

  414.     static mat_t<T,4,4> fromeuler_xzx(vec_t<T,3> const &v);

  415.     static mat_t<T,4,4> fromeuler_yxy(vec_t<T,3> const &v);

  416.     static mat_t<T,4,4> fromeuler_yzy(vec_t<T,3> const &v);

  417.     static mat_t<T,4,4> fromeuler_zxz(vec_t<T,3> const &v);

  418.     static mat_t<T,4,4> fromeuler_zyz(vec_t<T,3> const &v);

  419.     static mat_t<T,4,4> fromeuler_xyx(T phi, T theta, T psi);

  420.     static mat_t<T,4,4> fromeuler_xzx(T phi, T theta, T psi);

  421.     static mat_t<T,4,4> fromeuler_yxy(T phi, T theta, T psi);

  422.     static mat_t<T,4,4> fromeuler_yzy(T phi, T theta, T psi);

  423.     static mat_t<T,4,4> fromeuler_zxz(T phi, T theta, T psi);

  424.     static mat_t<T,4,4> fromeuler_zyz(T phi, T theta, T psi);

  425. 

  426.     /* Helpers for view matrices */

  427.     static mat_t<T,4,4> lookat(vec_t<T,3> eye, vec_t<T,3> center, vec_t<T,3> up);

  428. 

  429.     /* Helpers for projection matrices */

  430.     static mat_t<T,4,4> ortho(T left, T right, T bottom, T top, T near, T far);

  431.     static mat_t<T,4,4> ortho(T width, T height, T near, T far);

  432.     static mat_t<T,4,4> frustum(T left, T right, T bottom, T top, T near, T far);

  433.     static mat_t<T,4,4> perspective(T fov_y, T width, T height, T near, T far);

  434.     static mat_t<T,4,4> shifted_perspective(T fov_y, T screen_size, T screen_ratio_yx, T near, T far);

  435. 

  436.     void printf() const;

  437.     String tostring() const;

  438. 

  439.     template<class U>

  440.     friend std::ostream &operator<<(std::ostream &stream,

  441.                                     mat_t<U,4,4> const &m);

  442. 

  443.     static const mat_t<T,4,4> identity;

  444. 

  445. private:

  446. #if LOL_FEATURE_CXX11_ARRAY_INITIALIZERS

  447.     vec_t<T,4> m_data[4];

  448. #else

  449.     vec_t<T,4> m_v0, m_v1, m_v2, m_v3;

  450. #endif

  451. };

  452. 

  453. static_assert(sizeof(imat4) == 64, "sizeof(imat4) == 64");

  454. #if LOL_FEATURE_CXX11_UNRESTRICTED_UNIONS

  455. static_assert(sizeof(f16mat4) == 32, "sizeof(f16mat4) == 32");

  456. #endif

  457. static_assert(sizeof(mat4) == 64, "sizeof(mat4) == 64");

  458. static_assert(sizeof(dmat4) == 128, "sizeof(dmat4) == 128");

  459. 

  460. /*

  461.  * Transpose any matrix

  462.  */

  463. 

  464. template<typename T, int COLS, int ROWS>

  465. static inline mat_t<T, ROWS, COLS> transpose(mat_t<T, COLS, ROWS> const &m)

  466. {

  467.     mat_t<T, ROWS, COLS> ret;

  468.     for (int i = 0; i < COLS; ++i)

  469.         for (int j = 0; j < ROWS; ++j)

  470.             ret[j][i] = m[i][j];

  471.     return ret;

  472. }

  473. 

  474. /*

  475.  * Compute a square submatrix, useful for minors and cofactor matrices

  476.  */

  477. 

  478. template<typename T, int N>

  479. mat_t<T, N - 1, N - 1> submatrix(mat_t<T, N, N> const &m, int i, int j)

  480. {

  481.     ASSERT(i >= 0); ASSERT(j >= 0); ASSERT(i < N); ASSERT(j < N);

  482. 

  483.     mat_t<T, N - 1, N - 1> ret;

  484.     for (int i2 = 0; i2 < N - 1; ++i2)

  485.         for (int j2 = 0; j2 < N - 1; ++j2)

  486.             ret[i2][j2] = m[i2 + (i2 >= i)][j2 + (j2 >= j)];

  487. 

  488.     return ret;

  489. }

  490. 

  491. /*

  492.  * Compute square matrix cofactor

  493.  */

  494. 

  495. template<typename T, int N>

  496. T cofactor(mat_t<T, N, N> const &m, int i, int j)

  497. {

  498.     ASSERT(i >= 0); ASSERT(j >= 0); ASSERT(i < N); ASSERT(j < N);

  499.     T tmp = determinant(submatrix(m, i, j));

  500.     return ((i + j) & 1) ? -tmp : tmp;

  501. }

  502. 

  503. template<typename T>

  504. T cofactor(mat_t<T, 2, 2> const &m, int i, int j)

  505. {

  506.     /* This specialisation shouldn't be needed, but Visual Studio. */

  507.     ASSERT(i >= 0); ASSERT(j >= 0); ASSERT(i < 2); ASSERT(j < 2);

  508.     T tmp = m[1 - i][1 - j];

  509.     return (i ^ j) ? -tmp : tmp;

  510. }

  511. 

  512. /*

  513.  * Compute LU-decomposition

  514.  */

  515. 

  516. template<typename T, int N>

  517. void lu_decomposition(mat_t<T, N, N> const &m, mat_t<T, N, N> & L, mat_t<T, N, N> & U)

  518. {

  519.     for (int i = 0; i < N; ++i)

  520.     {

  521.         for (int j = 0; j < N; ++j)

  522.         {

  523.             T sum = 0;

  524.             for (int k = 0 ; k < min(i, j) ; ++k)

  525.                 sum += L[k][j] * U[i][k];

  526. 

  527.             if (i < j)

  528.             {

  529.                 U[i][j] = 0;

  530.                 L[i][j] = (m[i][j] - sum) / U[i][i];

  531.             }

  532.             else /* if (i >= j) */

  533.             {

  534.                 L[i][j] = i == j ? 1 : 0;

  535.                 U[i][j] = (m[i][j] - sum) / L[j][j];

  536.             }

  537.         }

  538.     }

  539. }

  540. 

  541. /*

  542.  * Compute square matrix determinant, with a specialisation for 1×1 matrices

  543.  */

  544. 

  545. template<typename T, int N>

  546. T determinant(mat_t<T, N, N> const &m)

  547. {

  548.     mat_t<T, N, N> L, U;

  549.     lu_decomposition(m, L, U);

  550. 

  551.     T det = 1;

  552.     for (int i = 0 ; i < N ; ++i)

  553.         det *= U[i][i];

  554. 

  555.     return det;

  556. }

  557. 

  558. /*

  559.  * Compute square matrix inverse

  560.  */

  561. 

  562. template<typename T, int N>

  563. mat_t<T, N, N> inverse(mat_t<T, N, N> const &m)

  564. {

  565.     mat_t<T, N, N> ret;

  566. 

  567.     T d = determinant(m);

  568.     if (d)

  569.     {

  570.         /* Transpose result matrix on the fly */

  571.         for (int i = 0; i < N; ++i)

  572.             for (int j = 0; j < N; ++j)

  573.                 ret[i][j] = cofactor(m, j, i) / d;

  574.     }

  575.     return ret;

  576. }

  577. 

  578. /*

  579.  * Matrix-vector and vector-matrix multiplication

  580.  */

  581. 

  582. template<typename T, int COLS, int ROWS, int SWIZZLE>

  583. static inline vec_t<T, ROWS> operator *(mat_t<T, COLS, ROWS> const &m,

  584.                                         vec_t<T, COLS, SWIZZLE> const &v)

  585. {

  586.     vec_t<T, ROWS> ret(T(0));

  587.     for (int i = 0; i < COLS; ++i)

  588.         ret += m[i] * v[i];

  589.     return ret;

  590. }

  591. 

  592. template<typename T, int COLS, int ROWS, int SWIZZLE>

  593. static inline vec_t<T, COLS> operator *(vec_t<T, ROWS, SWIZZLE> const &v,

  594.                                         mat_t<T, COLS, ROWS> const &m)

  595. {

  596.     vec_t<T, COLS> ret(T(0));

  597.     for (int i = 0; i < COLS; ++i)

  598.         ret[i] = dot(v, m[i]);

  599.     return ret;

  600. }

  601. 

  602. /*

  603.  * Matrix-matrix multiplication

  604.  */

  605. 

  606. template<typename T, int COLS, int N, int ROWS>

  607. static inline mat_t<T, COLS, ROWS> operator *(mat_t<T, N, ROWS> const &a,

  608.                                               mat_t<T, COLS, N> const &b)

  609. {

  610.     mat_t<T, COLS, ROWS> ret;

  611.     for (int i = 0; i < COLS; ++i)

  612.         ret[i] = a * b[i];

  613.     return ret;

  614. }

  615. 

  616. template<typename T, int N>

  617. static inline mat_t<T, N, N> &operator *=(mat_t<T, N, N> &a,

  618.                                           mat_t<T, N, N> const &b)

  619. {

  620.     return a = a * b;

  621. }

  622. 

  623. /*

  624.  * Vector-vector outer product

  625.  */

  626. 

  627. template<typename T, int COLS, int ROWS>

  628. static inline mat_t<T, COLS, ROWS> outer(vec_t<T, ROWS> const &a,

  629.                                          vec_t<T, COLS> const &b)

  630. {

  631.     /* Valid cast because mat_t and vec_t have similar layouts */

  632.     return *reinterpret_cast<mat_t<T, 1, ROWS> const *>(&a)

  633.          * *reinterpret_cast<mat_t<T, COLS, 1> const *>(&b);

  634. }

  635. 

  636. /*

  637.  * Matrix-matrix outer product (Kronecker product)

  638.  */

  639. 

  640. template<typename T, int COLS1, int COLS2, int ROWS1, int ROWS2>

  641. static inline mat_t<T, COLS1 * COLS2, ROWS1 * ROWS2>

  642. outer(mat_t<T, COLS1, ROWS1> const &a, mat_t<T, COLS2, ROWS2> const &b)

  643. {

  644.     mat_t<T, COLS1 * COLS2, ROWS1 * ROWS2> ret;

  645.     for (int i1 = 0; i1 < COLS1; ++i1)

  646.         for (int i2 = 0; i2 < COLS2; ++i2)

  647.         {

  648.             /* Valid cast because mat_t and vec_t have similar layouts */

  649.             *reinterpret_cast<mat_t<T, ROWS1, ROWS2> *>(&ret[i1 * COLS2 + i2])

  650.                 = outer(b[i2], a[i1]);

  651.         }

  652.     return ret;

  653. }

  654. 

  655. #if !LOL_FEATURE_CXX11_CONSTEXPR

  656. #undef constexpr

  657. #endif

  658. 

  659. } /* namespace lol */