diff --git a/glm/gtx/matrix_factorisation.hpp b/glm/gtx/matrix_factorisation.hpp
index 9acc7f3a..fafbff09 100644
--- a/glm/gtx/matrix_factorisation.hpp
+++ b/glm/gtx/matrix_factorisation.hpp
@@ -29,26 +29,27 @@ Suggestions:
  - Implement other types of matrix factorisation, such as: QL and LQ, L(D)U, eigendecompositions, etc...
 */
 
-namespace glm{
+namespace glm
+{
 	/// @addtogroup gtx_matrix_factorisation
 	/// @{
 
 	/// Flips the matrix rows up and down.
 	/// From GLM_GTX_matrix_factorisation extension.
 	template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
-	GLM_FUNC_DECL matType<C, R, T, P> flipud(const matType<C, R, T, P>& in);
+	GLM_FUNC_DECL matType<C, R, T, P> flipud(matType<C, R, T, P> const& in);
 
 	/// Flips the matrix columns right and left.
 	/// From GLM_GTX_matrix_factorisation extension.
 	template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
-	GLM_FUNC_DECL matType<C, R, T, P> fliplr(const matType<C, R, T, P>& in);
+	GLM_FUNC_DECL matType<C, R, T, P> fliplr(matType<C, R, T, P> const& in);
 
 	/// Performs QR factorisation of a matrix.
 	/// Returns 2 matrices, q and r, such that the columns of q are orthonormal and span the same subspace than those of the input matrix, r is an upper triangular matrix, and q*r=in.
 	/// Given an n-by-m input matrix, q has dimensions min(n,m)-by-m, and r has dimensions n-by-min(n,m).
 	/// From GLM_GTX_matrix_factorisation extension.
 	template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
-	GLM_FUNC_DECL void qr_decompose(matType<(C < R ? C : R), R, T, P>& q, matType<C, (C < R ? C : R), T, P>& r, const matType<C, R, T, P>& in);
+	GLM_FUNC_DECL void qr_decompose(matType<C, R, T, P> const& in, matType<(C < R ? C : R), R, T, P>& q, matType<C, (C < R ? C : R), T, P>& r);
 
 	/// Performs RQ factorisation of a matrix.
 	/// Returns 2 matrices, r and q, such that r is an upper triangular matrix, the rows of q are orthonormal and span the same subspace than those of the input matrix, and r*q=in.
@@ -56,7 +57,7 @@ namespace glm{
 	/// Given an n-by-m input matrix, r has dimensions min(n,m)-by-m, and q has dimensions n-by-min(n,m).
 	/// From GLM_GTX_matrix_factorisation extension.
 	template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
-	GLM_FUNC_DECL void rq_decompose(matType<(C < R ? C : R), R, T, P>& r, matType<C, (C < R ? C : R), T, P>& q, const matType<C, R, T, P>& in);
+	GLM_FUNC_DECL void rq_decompose(matType<C, R, T, P> const& in, matType<(C < R ? C : R), R, T, P>& r, matType<C, (C < R ? C : R), T, P>& q);
 
 	/// @}
 }
diff --git a/glm/gtx/matrix_factorisation.inl b/glm/gtx/matrix_factorisation.inl
index f165016f..be7d6c8c 100644
--- a/glm/gtx/matrix_factorisation.inl
+++ b/glm/gtx/matrix_factorisation.inl
@@ -1,9 +1,11 @@
 /// @ref gtx_matrix_factorisation
 /// @file glm/gtx/matrix_factorisation.inl
 
-namespace glm {
+namespace glm
+{
 	template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
-	GLM_FUNC_QUALIFIER matType<C, R, T, P> flipud(const matType<C, R, T, P>& in) {
+	GLM_FUNC_QUALIFIER matType<C, R, T, P> flipud(matType<C, R, T, P> const& in)
+	{
 		matType<R, C, T, P> tin = transpose(in);
 		tin = fliplr(tin);
 		matType<C, R, T, P> out = transpose(tin);
@@ -12,9 +14,11 @@ namespace glm {
 	}
 
 	template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
-	GLM_FUNC_QUALIFIER matType<C, R, T, P> fliplr(const matType<C, R, T, P>& in) {
+	GLM_FUNC_QUALIFIER matType<C, R, T, P> fliplr(matType<C, R, T, P> const& in)
+	{
 		matType<C, R, T, P> out;
-		for (length_t i = 0; i < C; i++) {
+		for (length_t i = 0; i < C; i++)
+		{
 			out[i] = in[(C - i) - 1];
 		}
 
@@ -22,21 +26,24 @@ namespace glm {
 	}
 
 	template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
-	GLM_FUNC_QUALIFIER void qr_decompose(matType<(C < R ? C : R), R, T, P>& q, matType<C, (C < R ? C : R), T, P>& r, const matType<C, R, T, P>& in) {
+	GLM_FUNC_QUALIFIER void qr_decompose(matType<C, R, T, P> const& in, matType<(C < R ? C : R), R, T, P>& q, matType<C, (C < R ? C : R), T, P>& r)
+	{
 		// Uses modified Gram-Schmidt method
 		// Source: https://en.wikipedia.org/wiki/Gram–Schmidt_process
 		// And https://en.wikipedia.org/wiki/QR_decomposition
 
 		//For all the linearly independs columns of the input...
 		// (there can be no more linearly independents columns than there are rows.)
-		for (length_t i = 0; i < (C < R ? C : R); i++) {
+		for (length_t i = 0; i < (C < R ? C : R); i++)
+		{
 			//Copy in Q the input's i-th column.
 			q[i] = in[i];
 
 			//j = [0,i[
 			// Make that column orthogonal to all the previous ones by substracting to it the non-orthogonal projection of all the previous columns.
 			// Also: Fill the zero elements of R
-			for (length_t j = 0; j < i; j++) {
+			for (length_t j = 0; j < i; j++)
+			{
 				q[i] -= dot(q[i], q[j])*q[j];
 				r[j][i] = 0;
 			}
@@ -46,14 +53,16 @@ namespace glm {
 
 			//j = [i,C[
 			//Finally, compute the corresponding coefficients of R by computing the projection of the resulting column on the other columns of the input.
-			for (length_t j = i; j < C; j++) {
+			for (length_t j = i; j < C; j++)
+			{
 				r[j][i] = dot(in[j], q[i]);
 			}
 		}
 	}
 
 	template <length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
-	GLM_FUNC_QUALIFIER void rq_decompose(matType<(C < R ? C : R), R, T, P>& r, matType<C, (C < R ? C : R), T, P>& q, const matType<C, R, T, P>& in) {
+	GLM_FUNC_QUALIFIER void rq_decompose(matType<C, R, T, P> const& in, matType<(C < R ? C : R), R, T, P>& r, matType<C, (C < R ? C : R), T, P>& q)
+	{
 		// From https://en.wikipedia.org/wiki/QR_decomposition:
 		// The RQ decomposition transforms a matrix A into the product of an upper triangular matrix R (also known as right-triangular) and an orthogonal matrix Q. The only difference from QR decomposition is the order of these matrices.
 		// QR decomposition is Gram–Schmidt orthogonalization of columns of A, started from the first column.