From da6e485aadf9e06cd89c26363e288d4d5fedfb56 Mon Sep 17 00:00:00 2001
From: Christophe Riccio <mail@g-truc.net>
Date: Tue, 17 Sep 2013 22:27:29 +0200
Subject: [PATCH] Fixed B /= B.y bug for all assignment operators of matrix
 classes. #116

---
 glm/core/type_mat2x2.hpp |  8 +++----
 glm/core/type_mat2x2.inl | 50 ++++++++--------------------------------
 glm/core/type_mat2x3.hpp |  8 +++----
 glm/core/type_mat2x3.inl | 45 ++++++++----------------------------
 glm/core/type_mat2x4.hpp |  8 +++----
 glm/core/type_mat2x4.inl | 45 ++++++++----------------------------
 glm/core/type_mat3x2.hpp |  8 +++----
 glm/core/type_mat3x2.inl | 45 ++++++++----------------------------
 glm/core/type_mat3x3.hpp |  8 +++----
 glm/core/type_mat3x3.inl | 50 ++++++++--------------------------------
 glm/core/type_mat3x4.hpp |  8 +++----
 glm/core/type_mat3x4.inl | 45 ++++++++----------------------------
 glm/core/type_mat4x2.hpp |  8 +++----
 glm/core/type_mat4x2.inl | 35 ++++++----------------------
 glm/core/type_mat4x3.hpp |  8 +++----
 glm/core/type_mat4x3.inl | 35 ++++++----------------------
 glm/core/type_mat4x4.hpp |  8 +++----
 glm/core/type_mat4x4.inl | 40 +++++++-------------------------
 18 files changed, 114 insertions(+), 348 deletions(-)

diff --git a/glm/core/type_mat2x2.hpp b/glm/core/type_mat2x2.hpp
index 2c7766b8..4ef7dc45 100644
--- a/glm/core/type_mat2x2.hpp
+++ b/glm/core/type_mat2x2.hpp
@@ -123,19 +123,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T, P> & operator+=(U const & s);
+		GLM_FUNC_DECL tmat2x2<T, P> & operator+=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T, P> & operator+=(tmat2x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T, P> & operator-=(U const & s);
+		GLM_FUNC_DECL tmat2x2<T, P> & operator-=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T, P> & operator-=(tmat2x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T, P> & operator*=(U const & s);
+		GLM_FUNC_DECL tmat2x2<T, P> & operator*=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T, P> & operator*=(tmat2x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T, P> & operator/=(U const & s);
+		GLM_FUNC_DECL tmat2x2<T, P> & operator/=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T, P> & operator/=(tmat2x2<U, P> const & m);
 
diff --git a/glm/core/type_mat2x2.inl b/glm/core/type_mat2x2.inl
index decae56f..64655c95 100644
--- a/glm/core/type_mat2x2.inl
+++ b/glm/core/type_mat2x2.inl
@@ -291,10 +291,7 @@ namespace detail
 
 	// This function shouldn't required but it seems that VC7.1 have an optimisation bug if this operator wasn't declared
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator=
-	(
-		tmat2x2<T, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator= (tmat2x2<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -303,10 +300,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator=
-	(
-		tmat2x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator= (tmat2x2<U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -315,10 +309,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -327,10 +318,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+=
-	(
-		tmat2x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+= (tmat2x2<U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -339,10 +327,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -351,10 +336,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-=
-	(
-		tmat2x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-= (tmat2x2<U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -363,10 +345,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -375,20 +354,14 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*=
-	(
-		tmat2x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*= (tmat2x2<U, P> const & m)
 	{
 		return (*this = *this * m);
 	}
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -397,10 +370,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/=
-	(
-		tmat2x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/= (tmat2x2<U, P> const & m)
 	{
 		return (*this = *this / m);
 	}
diff --git a/glm/core/type_mat2x3.hpp b/glm/core/type_mat2x3.hpp
index b0a7f0b3..02d7f4fc 100644
--- a/glm/core/type_mat2x3.hpp
+++ b/glm/core/type_mat2x3.hpp
@@ -115,19 +115,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x3<T, P> & operator=  (tmat2x3<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T, P> & operator+= (U const & s);
+		GLM_FUNC_DECL tmat2x3<T, P> & operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x3<T, P> & operator+= (tmat2x3<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T, P> & operator-= (U const & s);
+		GLM_FUNC_DECL tmat2x3<T, P> & operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x3<T, P> & operator-= (tmat2x3<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T, P> & operator*= (U const & s);
+		GLM_FUNC_DECL tmat2x3<T, P> & operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x3<T, P> & operator*= (tmat2x3<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T, P> & operator/= (U const & s);
+		GLM_FUNC_DECL tmat2x3<T, P> & operator/= (U s);
 
 		//////////////////////////////////////
 		// Increment and decrement operators
diff --git a/glm/core/type_mat2x3.inl b/glm/core/type_mat2x3.inl
index adc850ed..d2ad0c65 100644
--- a/glm/core/type_mat2x3.inl
+++ b/glm/core/type_mat2x3.inl
@@ -278,10 +278,7 @@ namespace detail
 	// Unary updatable operators
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator= 
-	(
-		tmat2x3<T, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator= (tmat2x3<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -290,10 +287,7 @@ namespace detail
 
 	template <typename T, precision P> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator= 
-	(
-		tmat2x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator= (tmat2x3<U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -302,10 +296,7 @@ namespace detail
 
 	template <typename T, precision P> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator+= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -314,10 +305,7 @@ namespace detail
 
 	template <typename T, precision P> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator+=
-	(
-		tmat2x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator+= (tmat2x3<U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -326,10 +314,7 @@ namespace detail
 
 	template <typename T, precision P> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator-= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -338,10 +323,7 @@ namespace detail
 
 	template <typename T, precision P> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator-= 
-	(
-		tmat2x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator-= (tmat2x3<U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -350,10 +332,7 @@ namespace detail
 
 	template <typename T, precision P> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator*= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -362,20 +341,14 @@ namespace detail
 
 	template <typename T, precision P> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator*= 
-	(
-		tmat2x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator*= (tmat2x3<U, P> const & m)
 	{
 		return (*this = tmat2x3<U, P>(*this * m));
 	}
 
 	template <typename T, precision P>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator/= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat2x4.hpp b/glm/core/type_mat2x4.hpp
index 7f76d4ec..d3608dac 100644
--- a/glm/core/type_mat2x4.hpp
+++ b/glm/core/type_mat2x4.hpp
@@ -117,19 +117,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x4<T, P>& operator=  (tmat2x4<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T, P>& operator+= (U const & s);
+		GLM_FUNC_DECL tmat2x4<T, P>& operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x4<T, P>& operator+= (tmat2x4<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T, P>& operator-= (U const & s);
+		GLM_FUNC_DECL tmat2x4<T, P>& operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x4<T, P>& operator-= (tmat2x4<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T, P>& operator*= (U const & s);
+		GLM_FUNC_DECL tmat2x4<T, P>& operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x4<T, P>& operator*= (tmat2x4<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T, P>& operator/= (U const & s);
+		GLM_FUNC_DECL tmat2x4<T, P>& operator/= (U s);
 
 		//////////////////////////////////////
 		// Increment and decrement operators
diff --git a/glm/core/type_mat2x4.inl b/glm/core/type_mat2x4.inl
index 7a21b024..96543cc9 100644
--- a/glm/core/type_mat2x4.inl
+++ b/glm/core/type_mat2x4.inl
@@ -281,10 +281,7 @@ namespace detail
 	// Unary updatable operators
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator=
-	(
-		tmat2x4<T, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator= (tmat2x4<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -293,10 +290,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator=
-	(
-		tmat2x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator= (tmat2x4<U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -305,10 +299,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -317,10 +308,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator+=
-	(
-		tmat2x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator+= (tmat2x4<U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -329,10 +317,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -341,10 +326,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator-=
-	(
-		tmat2x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator-= (tmat2x4<U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -353,10 +335,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -365,20 +344,14 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator*=
-	(
-		tmat2x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator*= (tmat2x4<U, P> const & m)
 	{
 		return (*this = tmat2x4<T, P>(*this * m));
 	}
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> & tmat2x4<T, P>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T, P> & tmat2x4<T, P>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat3x2.hpp b/glm/core/type_mat3x2.hpp
index be78b035..d4f78d04 100644
--- a/glm/core/type_mat3x2.hpp
+++ b/glm/core/type_mat3x2.hpp
@@ -121,19 +121,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x2<T, P> & operator=  (tmat3x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T, P> & operator+= (U const & s);
+		GLM_FUNC_DECL tmat3x2<T, P> & operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x2<T, P> & operator+= (tmat3x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T, P> & operator-= (U const & s);
+		GLM_FUNC_DECL tmat3x2<T, P> & operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x2<T, P> & operator-= (tmat3x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T, P> & operator*= (U const & s);
+		GLM_FUNC_DECL tmat3x2<T, P> & operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x2<T, P> & operator*= (tmat3x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T, P> & operator/= (U const & s);
+		GLM_FUNC_DECL tmat3x2<T, P> & operator/= (U s);
 
 		//////////////////////////////////////
 		// Increment and decrement operators
diff --git a/glm/core/type_mat3x2.inl b/glm/core/type_mat3x2.inl
index acfc4dc4..2d992955 100644
--- a/glm/core/type_mat3x2.inl
+++ b/glm/core/type_mat3x2.inl
@@ -301,10 +301,7 @@ namespace detail
 	// Unary updatable operators
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator= 
-	(
-		tmat3x2<T, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator= (tmat3x2<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -314,10 +311,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator=
-	(
-		tmat3x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator= (tmat3x2<U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -327,10 +321,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -340,10 +331,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator+=
-	(
-		tmat3x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator+= (tmat3x2<U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -353,10 +341,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -366,10 +351,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator-=
-	(
-		tmat3x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator-= (tmat3x2<U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -379,10 +361,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -392,20 +371,14 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator*=
-	(
-		tmat3x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator*= (tmat3x2<U, P> const & m)
 	{
 		return (*this = tmat3x2<T, P>(*this * m));
 	}
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> & tmat3x2<T, P>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T, P> & tmat3x2<T, P>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat3x3.hpp b/glm/core/type_mat3x3.hpp
index 7af73089..4d52815b 100644
--- a/glm/core/type_mat3x3.hpp
+++ b/glm/core/type_mat3x3.hpp
@@ -126,19 +126,19 @@ namespace detail
 		template <typename U>
 		GLM_FUNC_DECL tmat3x3<T, P>& operator=  (tmat3x3<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P>& operator+= (U const & s);
+		GLM_FUNC_DECL tmat3x3<T, P>& operator+= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat3x3<T, P>& operator+= (tmat3x3<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P>& operator-= (U const & s);
+		GLM_FUNC_DECL tmat3x3<T, P>& operator-= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat3x3<T, P>& operator-= (tmat3x3<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P>& operator*= (U const & s);
+		GLM_FUNC_DECL tmat3x3<T, P>& operator*= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat3x3<T, P>& operator*= (tmat3x3<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P>& operator/= (U const & s);
+		GLM_FUNC_DECL tmat3x3<T, P>& operator/= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat3x3<T, P>& operator/= (tmat3x3<U, P> const & m);
 
diff --git a/glm/core/type_mat3x3.inl b/glm/core/type_mat3x3.inl
index 368dc687..d131ba83 100644
--- a/glm/core/type_mat3x3.inl
+++ b/glm/core/type_mat3x3.inl
@@ -304,10 +304,7 @@ namespace detail
 	// Operators
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator=
-	(
-		tmat3x3<T, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator= (tmat3x3<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -317,10 +314,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator=
-	(
-		tmat3x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator= (tmat3x3<U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -330,10 +324,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -343,10 +334,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator+=
-	(
-		tmat3x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator+= (tmat3x3<U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -356,10 +344,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -369,10 +354,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator-=
-	(
-		tmat3x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator-= (tmat3x3<U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -382,10 +364,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -395,20 +374,14 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator*=
-	(
-		tmat3x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator*= (tmat3x3<U, P> const & m)
 	{
 		return (*this = *this * m);
 	}
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -418,10 +391,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator/=
-	(
-		tmat3x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator/= (tmat3x3<U, P> const & m)
 	{
 		return (*this = *this / m);
 	}
diff --git a/glm/core/type_mat3x4.hpp b/glm/core/type_mat3x4.hpp
index e71b635a..0d16a51a 100644
--- a/glm/core/type_mat3x4.hpp
+++ b/glm/core/type_mat3x4.hpp
@@ -121,19 +121,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x4<T, P> & operator=  (tmat3x4<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T, P> & operator+= (U const & s);
+		GLM_FUNC_DECL tmat3x4<T, P> & operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x4<T, P> & operator+= (tmat3x4<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T, P> & operator-= (U const & s);
+		GLM_FUNC_DECL tmat3x4<T, P> & operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x4<T, P> & operator-= (tmat3x4<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T, P> & operator*= (U const & s);
+		GLM_FUNC_DECL tmat3x4<T, P> & operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x4<T, P> & operator*= (tmat3x4<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T, P> & operator/= (U const & s);
+		GLM_FUNC_DECL tmat3x4<T, P> & operator/= (U s);
 
 		//////////////////////////////////////
 		// Increment and decrement operators
diff --git a/glm/core/type_mat3x4.inl b/glm/core/type_mat3x4.inl
index 65fa94e5..0186fc5d 100644
--- a/glm/core/type_mat3x4.inl
+++ b/glm/core/type_mat3x4.inl
@@ -300,10 +300,7 @@ namespace detail
 	// Unary updatable operators
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator=
-	(
-		tmat3x4<T, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator= (tmat3x4<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -313,10 +310,7 @@ namespace detail
 
 	template <typename T, precision P> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator=
-	(
-		tmat3x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator= (tmat3x4<U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -326,10 +320,7 @@ namespace detail
 
 	template <typename T, precision P> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -339,10 +330,7 @@ namespace detail
 
 	template <typename T, precision P> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator+=
-	(
-		tmat3x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator+= (tmat3x4<U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -352,10 +340,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -365,10 +350,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator-=
-	(
-		tmat3x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator-= (tmat3x4<U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -378,10 +360,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -391,20 +370,14 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator*=
-	(
-		tmat3x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator*= (tmat3x4<U, P> const & m)
 	{
 		return (*this = tmat3x4<T, P>(*this * m));
 	}
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> & tmat3x4<T, P>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T, P> & tmat3x4<T, P>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat4x2.hpp b/glm/core/type_mat4x2.hpp
index efa6034e..00250389 100644
--- a/glm/core/type_mat4x2.hpp
+++ b/glm/core/type_mat4x2.hpp
@@ -126,19 +126,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x2<T, P>& operator=  (tmat4x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T, P>& operator+= (U const & s);
+		GLM_FUNC_DECL tmat4x2<T, P>& operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x2<T, P>& operator+= (tmat4x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T, P>& operator-= (U const & s);
+		GLM_FUNC_DECL tmat4x2<T, P>& operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x2<T, P>& operator-= (tmat4x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T, P>& operator*= (U const & s);
+		GLM_FUNC_DECL tmat4x2<T, P>& operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x2<T, P>& operator*= (tmat4x2<U, P> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T, P>& operator/= (U const & s);
+		GLM_FUNC_DECL tmat4x2<T, P>& operator/= (U s);
 
 		//////////////////////////////////////
 		// Increment and decrement operators
diff --git a/glm/core/type_mat4x2.inl b/glm/core/type_mat4x2.inl
index df00250f..6b3e8120 100644
--- a/glm/core/type_mat4x2.inl
+++ b/glm/core/type_mat4x2.inl
@@ -348,10 +348,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -362,10 +359,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator+=
-	(
-		tmat4x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator+= (tmat4x2<U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -376,10 +370,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -390,10 +381,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator-=
-	(
-		tmat4x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator-= (tmat4x2<U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -404,10 +392,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -418,20 +403,14 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator*=
-	(
-		tmat4x2<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator*= (tmat4x2<U, P> const & m)
 	{
 		return (*this = tmat4x2<T, P>(*this * m));
 	}
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat4x3.hpp b/glm/core/type_mat4x3.hpp
index 495121a0..76e71c7d 100644
--- a/glm/core/type_mat4x3.hpp
+++ b/glm/core/type_mat4x3.hpp
@@ -126,19 +126,19 @@ namespace detail
 		template <typename U>
 		GLM_FUNC_DECL tmat4x3<T, P> & operator=  (tmat4x3<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator+= (U const & s);
+		GLM_FUNC_DECL tmat4x3<T, P> & operator+= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x3<T, P> & operator+= (tmat4x3<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator-= (U const & s);
+		GLM_FUNC_DECL tmat4x3<T, P> & operator-= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x3<T, P> & operator-= (tmat4x3<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator*= (U const & s);
+		GLM_FUNC_DECL tmat4x3<T, P> & operator*= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x3<T, P> & operator*= (tmat4x3<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator/= (U const & s);
+		GLM_FUNC_DECL tmat4x3<T, P> & operator/= (U s);
 
 		//////////////////////////////////////
 		// Increment and decrement operators
diff --git a/glm/core/type_mat4x3.inl b/glm/core/type_mat4x3.inl
index 39957387..d43ebfcf 100644
--- a/glm/core/type_mat4x3.inl
+++ b/glm/core/type_mat4x3.inl
@@ -348,10 +348,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -362,10 +359,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator+=
-	(
-		tmat4x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator+= (tmat4x3<U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -376,10 +370,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -390,10 +381,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator-=
-	(
-		tmat4x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator-= (tmat4x3<U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -404,10 +392,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -418,20 +403,14 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator*=
-	(
-		tmat4x3<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator*= (tmat4x3<U, P> const & m)
 	{
 		return (*this = tmat4x3<T, P>(*this * m));
 	}
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat4x4.hpp b/glm/core/type_mat4x4.hpp
index c4335764..b390dc91 100644
--- a/glm/core/type_mat4x4.hpp
+++ b/glm/core/type_mat4x4.hpp
@@ -131,19 +131,19 @@ namespace detail
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T, P> & operator=  (tmat4x4<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator+= (U const & s);
+		GLM_FUNC_DECL tmat4x4<T, P> & operator+= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T, P> & operator+= (tmat4x4<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator-= (U const & s);
+		GLM_FUNC_DECL tmat4x4<T, P> & operator-= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T, P> & operator-= (tmat4x4<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator*= (U const & s);
+		GLM_FUNC_DECL tmat4x4<T, P> & operator*= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T, P> & operator*= (tmat4x4<U, P> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator/= (U const & s);
+		GLM_FUNC_DECL tmat4x4<T, P> & operator/= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T, P> & operator/= (tmat4x4<U, P> const & m);
 
diff --git a/glm/core/type_mat4x4.inl b/glm/core/type_mat4x4.inl
index 9b2b52ab..ea40f327 100644
--- a/glm/core/type_mat4x4.inl
+++ b/glm/core/type_mat4x4.inl
@@ -387,10 +387,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>& tmat4x4<T, P>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P>& tmat4x4<T, P>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -401,10 +398,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>& tmat4x4<T, P>::operator+=
-	(
-		tmat4x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P>& tmat4x4<T, P>::operator+= (tmat4x4<U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -415,10 +409,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -429,10 +420,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator-=
-	(
-		tmat4x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator-= (tmat4x4<U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -443,10 +431,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -457,20 +442,14 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator*=
-	(
-		tmat4x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator*= (tmat4x4<U, P> const & m)
 	{
 		return (*this = *this * m);
 	}
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -481,10 +460,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator/=
-	(
-		tmat4x4<U, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator/= (tmat4x4<U, P> const & m)
 	{
 		return (*this = *this / m);
 	}