From c9a0b87c7bb64222a737dcb1d1d4636f5273f95f Mon Sep 17 00:00:00 2001
From: Christophe Riccio <mail@g-truc.net>
Date: Fri, 9 Nov 2012 01:24:22 +0100
Subject: [PATCH] Fixed spaces

---
 glm/core/type_mat3x3.inl       | 764 ++++++++++++++++-----------------
 test/core/core_type_mat2x2.cpp |  38 +-
 2 files changed, 416 insertions(+), 386 deletions(-)

diff --git a/glm/core/type_mat3x3.inl b/glm/core/type_mat3x3.inl
index 95ba360d..84fc9452 100644
--- a/glm/core/type_mat3x3.inl
+++ b/glm/core/type_mat3x3.inl
@@ -29,11 +29,11 @@
 namespace glm{
 namespace detail
 {
-    template <typename T>
-    GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat3x3<T>::size_type tmat3x3<T>::length() const
-    {
-        return 3;
-    }
+	template <typename T>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat3x3<T>::size_type tmat3x3<T>::length() const
+	{
+		return 3;
+	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER typename tmat3x3<T>::size_type tmat3x3<T>::col_size()
@@ -72,74 +72,74 @@ namespace detail
 		return this->value[i];
 	}
 
-    //////////////////////////////////////////////////////////////
-    // Constructors
+	//////////////////////////////////////////////////////////////
+	// Constructors
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3()
-    {
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3()
+	{
 		value_type const Zero(0);
 		value_type const One(1);
-        this->value[0] = col_type(One, Zero, Zero);
-        this->value[1] = col_type(Zero, One, Zero);
-        this->value[2] = col_type(Zero, Zero, One);
-    }
+		this->value[0] = col_type(One, Zero, Zero);
+		this->value[1] = col_type(Zero, One, Zero);
+		this->value[2] = col_type(Zero, Zero, One);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		tmat3x3<T> const & m
 	)
-    {
-        this->value[0] = m.value[0];
-        this->value[1] = m.value[1];
-        this->value[2] = m.value[2];
-    }
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+		this->value[2] = m.value[2];
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		ctor
 	)
-    {}
+	{}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		value_type const & s
 	)
-    {
+	{
 		value_type const Zero(0);
-        this->value[0] = col_type(s, Zero, Zero);
-        this->value[1] = col_type(Zero, s, Zero);
-        this->value[2] = col_type(Zero, Zero, s);
-    }
+		this->value[0] = col_type(s, Zero, Zero);
+		this->value[1] = col_type(Zero, s, Zero);
+		this->value[2] = col_type(Zero, Zero, s);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-    (
-        value_type const & x0, value_type const & y0, value_type const & z0, 
-        value_type const & x1, value_type const & y1, value_type const & z1,
-        value_type const & x2, value_type const & y2, value_type const & z2
-    )
-    {
-        this->value[0] = col_type(x0, y0, z0);
-        this->value[1] = col_type(x1, y1, z1);
-        this->value[2] = col_type(x2, y2, z2);
-    }
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		value_type const & x0, value_type const & y0, value_type const & z0, 
+		value_type const & x1, value_type const & y1, value_type const & z1,
+		value_type const & x2, value_type const & y2, value_type const & z2
+	)
+	{
+		this->value[0] = col_type(x0, y0, z0);
+		this->value[1] = col_type(x1, y1, z1);
+		this->value[2] = col_type(x2, y2, z2);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-    (
-        col_type const & v0, 
-        col_type const & v1, 
-        col_type const & v2
-    )
-    {
-        this->value[0] = v0;
-        this->value[1] = v1;
-        this->value[2] = v2;
-    }
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		col_type const & v0, 
+		col_type const & v1, 
+		col_type const & v2
+	)
+	{
+		this->value[0] = v0;
+		this->value[1] = v1;
+		this->value[2] = v2;
+	}
 
 	//////////////////////////////////////
 	// Convertion constructors
@@ -151,9 +151,9 @@ namespace detail
 	)
 	{
 		value_type const Zero(0);
-        this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
-        this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
-        this->value[2] = tvec3<T>(Zero, Zero, value_type(s));
+		this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
+		this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
+		this->value[2] = tvec3<T>(Zero, Zero, value_type(s));
 	}
 	
 	template <typename T> 
@@ -168,9 +168,9 @@ namespace detail
 		X3 const & x3, Y3 const & y3, Z3 const & z3 
 	)		
 	{
-        this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
-        this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
-        this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3));
+		this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
+		this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
+		this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3));
 	}
 	
 	template <typename T> 
@@ -182,443 +182,443 @@ namespace detail
 		tvec3<V3> const & v3
 	)		
 	{
-        this->value[0] = col_type(v1);
-        this->value[1] = col_type(v2);
-        this->value[2] = col_type(v3);
+		this->value[0] = col_type(v1);
+		this->value[1] = col_type(v2);
+		this->value[2] = col_type(v3);
 	}
 
-    //////////////////////////////////////////////////////////////
-    // Conversions
+	//////////////////////////////////////////////////////////////
+	// Conversions
 
-    template <typename T> 
-    template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	template <typename U> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		tmat3x3<U> const & m
 	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+		this->value[2] = col_type(m[2]);
 	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		tmat2x2<T> const & m
 	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
-    }
+	{
+		this->value[0] = col_type(m[0], value_type(0));
+		this->value[1] = col_type(m[1], value_type(0));
+		this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		tmat4x4<T> const & m
 	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-    }
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+		this->value[2] = col_type(m[2]);
+	}
 
 	template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		tmat2x3<T> const & m
 	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
-    }
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		tmat3x2<T> const & m
 	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(m[2], value_type(1));
-    }
+	{
+		this->value[0] = col_type(m[0], value_type(0));
+		this->value[1] = col_type(m[1], value_type(0));
+		this->value[2] = col_type(m[2], value_type(1));
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		tmat2x4<T> const & m
 	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
-    }
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+		this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		tmat4x2<T> const & m
 	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(m[2], value_type(1));
-    }
+	{
+		this->value[0] = col_type(m[0], value_type(0));
+		this->value[1] = col_type(m[1], value_type(0));
+		this->value[2] = col_type(m[2], value_type(1));
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		tmat3x4<T> const & m
 	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-    }
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+		this->value[2] = col_type(m[2]);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
 	(
 		tmat4x3<T> const & m
 	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-    }
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+	}
 
-    //////////////////////////////////////////////////////////////
-    // Operators
+	//////////////////////////////////////////////////////////////
+	// Operators
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
 	(
 		tmat3x3<T> const & m
 	)
-    {
-	    this->value[0] = m[0];
-	    this->value[1] = m[1];
-        this->value[2] = m[2];
-	    return *this;
-    }
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		return *this;
+	}
 
-    template <typename T> 
-    template <typename U> 
+	template <typename T> 
+	template <typename U> 
 	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
 	(
 		tmat3x3<U> const & m
 	)
-    {
-	    this->value[0] = m[0];
-	    this->value[1] = m[1];
-        this->value[2] = m[2];
-	    return *this;
-    }
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		this->value[2] = m[2];
+		return *this;
+	}
 
-    template <typename T> 
+	template <typename T> 
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+= 
 	(
 		U const & s
 	)
-    {
-	    this->value[0] += s;
-	    this->value[1] += s;
-        this->value[2] += s;
-	    return *this;
-    }
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		this->value[2] += s;
+		return *this;
+	}
 
-    template <typename T> 
+	template <typename T> 
 	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+=
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+=
 	(
 		tmat3x3<U> const & m
 	)
-    {
-	    this->value[0] += m[0];
-	    this->value[1] += m[1];
-        this->value[2] += m[2];
-	    return *this;
-    }
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		this->value[2] += m[2];
+		return *this;
+	}
 
-    template <typename T> 
+	template <typename T> 
 	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= 
 	(
 		U const & s
 	)
-    {
-	    this->value[0] -= s;
-	    this->value[1] -= s;
-        this->value[2] -= s;
-	    return *this;
-    }
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		this->value[2] -= s;
+		return *this;
+	}
 
-    template <typename T> 
+	template <typename T> 
 	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= 
 	(
 		tmat3x3<U> const & m
 	)
-    {
-	    this->value[0] -= m[0];
-	    this->value[1] -= m[1];
-        this->value[2] -= m[2];
-	    return *this;
-    }
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		this->value[2] -= m[2];
+		return *this;
+	}
 
-    template <typename T> 
+	template <typename T> 
 	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= 
 	(
 		U const & s
 	)
-    {
-	    this->value[0] *= s;
-	    this->value[1] *= s;
-        this->value[2] *= s;
-	    return *this;
-    }
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		this->value[2] *= s;
+		return *this;
+	}
 
-    template <typename T> 
+	template <typename T> 
 	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= 
 	(
 		tmat3x3<U> const & m
 	)
-    {
-        return (*this = *this * m);
-    }
+	{
+		return (*this = *this * m);
+	}
 
-    template <typename T> 
+	template <typename T> 
 	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= 
 	(
 		U const & s
 	)
-    {
-	    this->value[0] /= s;
-	    this->value[1] /= s;
-        this->value[2] /= s;
-	    return *this;
-    }
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		this->value[2] /= s;
+		return *this;
+	}
 
-    template <typename T> 
+	template <typename T> 
 	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= 
 	(
 		tmat3x3<U> const & m
 	)
-    {
-        return (*this = *this / m);
-    }
+	{
+		return (*this = *this / m);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator++ ()
-    {
-	    ++this->value[0];
-	    ++this->value[1];
-        ++this->value[2];
-	    return *this;
-    }
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator++ ()
+	{
+		++this->value[0];
+		++this->value[1];
+		++this->value[2];
+		return *this;
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-- ()
-    {
-	    --this->value[0];
-	    --this->value[1];
-        --this->value[2];
-	    return *this;
-    }
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-- ()
+	{
+		--this->value[0];
+		--this->value[1];
+		--this->value[2];
+		return *this;
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> tmat3x3<T>::_inverse() const
-    {
-        T S00 = value[0][0];
-        T S01 = value[0][1];
-        T S02 = value[0][2];
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> tmat3x3<T>::_inverse() const
+	{
+		T S00 = value[0][0];
+		T S01 = value[0][1];
+		T S02 = value[0][2];
 
-        T S10 = value[1][0];
-        T S11 = value[1][1];
-        T S12 = value[1][2];
+		T S10 = value[1][0];
+		T S11 = value[1][1];
+		T S12 = value[1][2];
 
-        T S20 = value[2][0];
-        T S21 = value[2][1];
-        T S22 = value[2][2];
+		T S20 = value[2][0];
+		T S21 = value[2][1];
+		T S22 = value[2][2];
 /*
-        tmat3x3<T> Inverse(
-            + (S11 * S22 - S21 * S12),
-            - (S10 * S22 - S20 * S12),
-            + (S10 * S21 - S20 * S11),
-            - (S01 * S22 - S21 * S02),
-            + (S00 * S22 - S20 * S02),
-            - (S00 * S21 - S20 * S01),
-            + (S01 * S12 - S11 * S02),
-            - (S00 * S12 - S10 * S02),
-            + (S00 * S11 - S10 * S01));
+		tmat3x3<T> Inverse(
+			+ (S11 * S22 - S21 * S12),
+			- (S10 * S22 - S20 * S12),
+			+ (S10 * S21 - S20 * S11),
+			- (S01 * S22 - S21 * S02),
+			+ (S00 * S22 - S20 * S02),
+			- (S00 * S21 - S20 * S01),
+			+ (S01 * S12 - S11 * S02),
+			- (S00 * S12 - S10 * S02),
+			+ (S00 * S11 - S10 * S01));
 */
-        tmat3x3<T> Inverse(
-            S11 * S22 - S21 * S12,
-            S12 * S20 - S22 * S10,
-            S10 * S21 - S20 * S11,
-            S02 * S21 - S01 * S22,
-            S00 * S22 - S02 * S20,
-            S01 * S20 - S00 * S21,
-            S12 * S01 - S11 * S02,
-            S10 * S02 - S12 * S00,
-            S11 * S00 - S10 * S01);
+		tmat3x3<T> Inverse(
+			S11 * S22 - S21 * S12,
+			S12 * S20 - S22 * S10,
+			S10 * S21 - S20 * S11,
+			S02 * S21 - S01 * S22,
+			S00 * S22 - S02 * S20,
+			S01 * S20 - S00 * S21,
+			S12 * S01 - S11 * S02,
+			S10 * S02 - S12 * S00,
+			S11 * S00 - S10 * S01);
 
-        T Determinant = S00 * (S11 * S22 - S21 * S12)
-                      - S10 * (S01 * S22 - S21 * S02)
-                      + S20 * (S01 * S12 - S11 * S02);
+		T Determinant = S00 * (S11 * S22 - S21 * S12)
+						- S10 * (S01 * S22 - S21 * S02)
+						+ S20 * (S01 * S12 - S11 * S02);
 
-        Inverse /= Determinant;
-        return Inverse;
-    }
+		Inverse /= Determinant;
+		return Inverse;
+	}
 
-    //////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////
 	// Binary operators
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
 	(
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::value_type const & s
 	)
-    {
-        return tmat3x3<T>(
-            m[0] + s,
-            m[1] + s,
-            m[2] + s);
-    }
+	{
+		return tmat3x3<T>(
+			m[0] + s,
+			m[1] + s,
+			m[2] + s);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
 	(
 		typename tmat3x3<T>::value_type const & s, 
 		tmat3x3<T> const & m
 	)
-    {
-        return tmat3x3<T>(
-            m[0] + s,
-            m[1] + s,
-            m[2] + s);
-    }
+	{
+		return tmat3x3<T>(
+			m[0] + s,
+			m[1] + s,
+			m[2] + s);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
 	(
 		tmat3x3<T> const & m1, 
 		tmat3x3<T> const & m2
 	)
-    {
-        return tmat3x3<T>(
-            m1[0] + m2[0],
-            m1[1] + m2[1],
-            m1[2] + m2[2]);
-    }
+	{
+		return tmat3x3<T>(
+			m1[0] + m2[0],
+			m1[1] + m2[1],
+			m1[2] + m2[2]);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
 	(
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::value_type const & s
 	)
-    {
-        return tmat3x3<T>(
-            m[0] - s,
-            m[1] - s,
-            m[2] - s);
-    }
+	{
+		return tmat3x3<T>(
+			m[0] - s,
+			m[1] - s,
+			m[2] - s);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
 	(
 		typename tmat3x3<T>::value_type const & s, 
 		tmat3x3<T> const & m
 	)
-    {
-        return tmat3x3<T>(
-            s - m[0],
-            s - m[1],
-            s - m[2]);
-    }
+	{
+		return tmat3x3<T>(
+			s - m[0],
+			s - m[1],
+			s - m[2]);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
 	(
 		tmat3x3<T> const & m1, 
 		tmat3x3<T> const & m2
 	)
-    {
-        return tmat3x3<T>(
-            m1[0] - m2[0],
-            m1[1] - m2[1],
-            m1[2] - m2[2]);
-    }
+	{
+		return tmat3x3<T>(
+			m1[0] - m2[0],
+			m1[1] - m2[1],
+			m1[2] - m2[2]);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
 	(
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::value_type const & s
 	)
-    {
-        return tmat3x3<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s);
-    }
+	{
+		return tmat3x3<T>(
+			m[0] * s,
+			m[1] * s,
+			m[2] * s);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
 	(
 		typename tmat3x3<T>::value_type const & s, 
 		tmat3x3<T> const & m
 	)
-    {
-        return tmat3x3<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s);
-    }
+	{
+		return tmat3x3<T>(
+			m[0] * s,
+			m[1] * s,
+			m[2] * s);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator* 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator* 
 	(
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::row_type const & v
 	)
-    {
-        return typename tmat3x3<T>::col_type(
-            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
-            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
-            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
-    }
+	{
+		return typename tmat3x3<T>::col_type(
+			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
+			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat3x3<T>::row_type operator* 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER typename tmat3x3<T>::row_type operator* 
 	(
 		typename tmat3x3<T>::col_type const & v, 
 		tmat3x3<T> const & m
 	)
-    {
-        return typename tmat3x3<T>::row_type(
-            m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
-            m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
-            m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
-    }
+	{
+		return typename tmat3x3<T>::row_type(
+			m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
+			m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
+			m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
 	(
 		tmat3x3<T> const & m1, 
 		tmat3x3<T> const & m2
 	)
-    {
+	{
 		typename tmat3x3<T>::value_type const SrcA00 = m1[0][0];
 		typename tmat3x3<T>::value_type const SrcA01 = m1[0][1];
 		typename tmat3x3<T>::value_type const SrcA02 = m1[0][2];
@@ -650,7 +650,7 @@ namespace detail
 		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
 		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
 		return Result;
-    }
+	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
@@ -690,31 +690,31 @@ namespace detail
 			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]);
 	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
 	(
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::value_type const & s
 	)
-    {
-        return tmat3x3<T>(
-            m[0] / s,
-            m[1] / s,
-            m[2] / s);
-    }
+	{
+		return tmat3x3<T>(
+			m[0] / s,
+			m[1] / s,
+			m[2] / s);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
 	(
 		typename tmat3x3<T>::value_type const & s, 
 		tmat3x3<T> const & m
 	)
-    {
-        return tmat3x3<T>(
-            s / m[0],
-            s / m[1],
-            s / m[2]);
-    }
+	{
+		return tmat3x3<T>(
+			s / m[0],
+			s / m[1],
+			s / m[2]);
+	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator/ 
@@ -747,43 +747,43 @@ namespace detail
 	}
 
 	// Unary constant operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> const operator- 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> const operator- 
 	(
 		tmat3x3<T> const & m
 	)
-    {
-        return tmat3x3<T>(
-            -m[0], 
-            -m[1],
-            -m[2]);
-    }
+	{
+		return tmat3x3<T>(
+			-m[0], 
+			-m[1],
+			-m[2]);
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> const operator++ 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> const operator++ 
 	(
 		tmat3x3<T> const & m, 
 		int
 	) 
-    {
-        return tmat3x3<T>(
-            m[0] + T(1),
-            m[1] + T(1),
-            m[2] + T(1));
-    }
+	{
+		return tmat3x3<T>(
+			m[0] + T(1),
+			m[1] + T(1),
+			m[2] + T(1));
+	}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> const operator-- 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> const operator-- 
 	(
 		tmat3x3<T> const & m, 
 		int
 	) 
-    {
-        return tmat3x3<T>(
-            m[0] - T(1),
-            m[1] - T(1),
-            m[2] - T(1));
-    }
+	{
+		return tmat3x3<T>(
+			m[0] - T(1),
+			m[1] - T(1),
+			m[2] - T(1));
+	}
 
 	//////////////////////////////////////
 	// Boolean operators
diff --git a/test/core/core_type_mat2x2.cpp b/test/core/core_type_mat2x2.cpp
index fc2cd5b2..5ea12670 100644
--- a/test/core/core_type_mat2x2.cpp
+++ b/test/core/core_type_mat2x2.cpp
@@ -8,8 +8,9 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include <glm/glm.hpp>
+#include <glm/gtc/epsilon.hpp>
 
-static int test_operators()
+int test_operators()
 {
 	glm::mat2x2 l(1.0f);
 	glm::mat2x2 m(1.0f);
@@ -28,11 +29,40 @@ static int test_operators()
 	return (S && !R) ? 0 : 1;
 }
 
-int main()
+int test_inverse()
 {
-	int Error = 0;
+	int Error(0);
 
-	Error += test_operators();
+	{
+		glm::mat2 Matrix(1, 2, 3, 4);
+		glm::mat2 Inverse = glm::inverse(Matrix);
+		glm::mat2 Identity = Matrix * Inverse;
+
+		Error += glm::epsilonEqual(Identity[0][0], 1.0f, 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(Identity[0][1], 0.0f, 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(Identity[1][0], 0.0f, 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(Identity[1][1], 1.0f, 0.01f) ? 0 : 1;
+	}
+
+	{
+		glm::mat2 Matrix(1, 2, 3, 4);
+		glm::mat2 Identity = Matrix / Matrix;
+
+		Error += glm::epsilonEqual(Identity[0][0], 1.0f, 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(Identity[0][1], 0.0f, 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(Identity[1][0], 0.0f, 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(Identity[1][1], 1.0f, 0.01f) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_operators();
+	Error += test_inverse();
 
 	return Error;
 }