diff --git a/glm/detail/_vectorize.hpp b/glm/detail/_vectorize.hpp
index fe065a8c..203213d7 100644
--- a/glm/detail/_vectorize.hpp
+++ b/glm/detail/_vectorize.hpp
@@ -155,54 +155,6 @@ namespace detail
 }//namespace detail
 }//namespace glm
 
-#define VECTORIZE1_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER tvec1<T, P> func(	\
-		tvec1<T, P> const & v)				\
-	{												\
-		return tvec1<T, P>(					\
-			func(v.x));								\
-	}
-
-#define VECTORIZE2_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER tvec2<T, P> func(	\
-		tvec2<T, P> const & v)				\
-	{												\
-		return tvec2<T, P>(					\
-			func(v.x),								\
-			func(v.y));								\
-	}
-
-#define VECTORIZE3_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER tvec3<T, P> func(	\
-		tvec3<T, P> const & v)				\
-	{												\
-		return tvec3<T, P>(					\
-			func(v.x),								\
-			func(v.y),								\
-			func(v.z));								\
-	}
-
-#define VECTORIZE4_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER tvec4<T, P> func(	\
-		tvec4<T, P> const & v)				\
-	{												\
-		return tvec4<T, P>(					\
-			func(v.x),								\
-			func(v.y),								\
-			func(v.z),								\
-			func(v.w));								\
-	}
-
-#define VECTORIZE_VEC(func)		\
-	VECTORIZE1_VEC(func)		\
-	VECTORIZE2_VEC(func)		\
-	VECTORIZE3_VEC(func)		\
-	VECTORIZE4_VEC(func)
-
 #define VECTORIZE1_VEC_SCA(func)							\
 	template <typename T, precision P>						\
 	GLM_FUNC_QUALIFIER tvec1<T, P> func				\
@@ -263,66 +215,6 @@ namespace detail
 	VECTORIZE3_VEC_SCA(func)		\
 	VECTORIZE4_VEC_SCA(func)
 
-#define VECTORIZE1_VEC_VEC(func)					\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER tvec1<T, P> func		\
-	(												\
-		tvec1<T, P> const & x,				\
-		tvec1<T, P> const & y				\
-	)												\
-	{												\
-		return tvec1<T, P>(					\
-			func(x.x, y.x));						\
-	}
-
-#define VECTORIZE2_VEC_VEC(func)					\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER tvec2<T, P> func		\
-	(												\
-		tvec2<T, P> const & x,				\
-		tvec2<T, P> const & y				\
-	)												\
-	{												\
-		return tvec2<T, P>(					\
-			func(x.x, y.x),							\
-			func(x.y, y.y));						\
-	}
-
-#define VECTORIZE3_VEC_VEC(func)					\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER tvec3<T, P> func		\
-	(												\
-		tvec3<T, P> const & x,				\
-		tvec3<T, P> const & y				\
-	)												\
-	{												\
-		return tvec3<T, P>(					\
-			func(x.x, y.x),							\
-			func(x.y, y.y),							\
-			func(x.z, y.z));						\
-	}
-
-#define VECTORIZE4_VEC_VEC(func)				\
-	template <typename T, precision P>			\
-	GLM_FUNC_QUALIFIER tvec4<T, P> func	\
-	(											\
-		tvec4<T, P> const & x,			\
-		tvec4<T, P> const & y			\
-	)											\
-	{											\
-		return tvec4<T, P>(				\
-			func(x.x, y.x),						\
-			func(x.y, y.y),						\
-			func(x.z, y.z),						\
-			func(x.w, y.w));					\
-	}
-
-#define VECTORIZE_VEC_VEC(func)		\
-	VECTORIZE1_VEC_VEC(func)		\
-	VECTORIZE2_VEC_VEC(func)		\
-	VECTORIZE3_VEC_VEC(func)		\
-	VECTORIZE4_VEC_VEC(func)
-
 namespace glm{
 namespace detail
 {
diff --git a/glm/gtc/random.hpp b/glm/gtc/random.hpp
index 7c4b616f..68074235 100644
--- a/glm/gtc/random.hpp
+++ b/glm/gtc/random.hpp
@@ -60,8 +60,8 @@ namespace glm
 	/// @see gtc_random
 	template <typename genTYpe>
 	GLM_FUNC_DECL genTYpe linearRand(
-		genTYpe const & Min,
-		genTYpe const & Max);
+		genTYpe Min,
+		genTYpe Max);
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL vecType<T, P> linearRand(
@@ -75,8 +75,8 @@ namespace glm
 	/// @see gtc_random
 	template <typename genType>
 	GLM_FUNC_DECL genType gaussRand(
-		genType const & Mean,
-		genType const & Deviation);
+		genType Mean,
+		genType Deviation);
 	
 	/// Generate a random 2D vector which coordinates are regulary distributed on a circle of a given radius
 	/// 
@@ -84,7 +84,7 @@ namespace glm
 	/// @see gtc_random
 	template <typename T>
 	GLM_FUNC_DECL tvec2<T, defaultp> circularRand(
-		T const & Radius);
+		T Radius);
 	
 	/// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius
 	/// 
@@ -92,7 +92,7 @@ namespace glm
 	/// @see gtc_random
 	template <typename T>
 	GLM_FUNC_DECL tvec3<T, defaultp> sphericalRand(
-		T const & Radius);
+		T Radius);
 	
 	/// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius
 	/// 
@@ -100,7 +100,7 @@ namespace glm
 	/// @see gtc_random
 	template <typename T>
 	GLM_FUNC_DECL tvec2<T, defaultp> diskRand(
-		T const & Radius);
+		T Radius);
 	
 	/// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius
 	/// 
@@ -108,7 +108,7 @@ namespace glm
 	/// @see gtc_random
 	template <typename T>
 	GLM_FUNC_DECL tvec3<T, defaultp> ballRand(
-		T const & Radius);
+		T Radius);
 	
 	/// @}
 }//namespace glm
diff --git a/glm/gtc/random.inl b/glm/gtc/random.inl
index 60859871..d2131ff0 100644
--- a/glm/gtc/random.inl
+++ b/glm/gtc/random.inl
@@ -280,46 +280,22 @@ namespace detail
 	};
 }//namespace detail
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> linearRand
-	(
-		vecType<T, P> const & Min,
-		vecType<T, P> const & Max
-	)
-	{
-		return detail::compute_linearRand<T, P, vecType>::call(Min, Max);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER float linearRand<float>
-	(
-		float const & Min,
-		float const & Max
-	)
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType linearRand(genType Min, genType Max)
 	{
-		return detail::compute_linearRand<float, highp, tvec1>::call(
-			tvec1<float, highp>(Min),
-			tvec1<float, highp>(Max)).x;
+		return detail::compute_linearRand<genType, highp, tvec1>::call(
+			tvec1<genType, highp>(Min),
+			tvec1<genType, highp>(Max)).x;
 	}
 
-	template <>
-	GLM_FUNC_QUALIFIER double linearRand<double>
-	(
-		double const & Min,
-		double const & Max
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> linearRand(vecType<T, P> const & Min, vecType<T, P> const & Max)
 	{
-		return detail::compute_linearRand<double, highp, tvec1>::call(
-			tvec1<double, highp>(Min),
-			tvec1<double, highp>(Max)).x;
+		return detail::compute_linearRand<T, P, vecType>::call(Min, Max);
 	}
 
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType gaussRand
-	(
-		genType const & Mean,
-		genType const & Deviation
-	)
+	GLM_FUNC_QUALIFIER genType gaussRand(genType Mean, genType Deviation)
 	{
 		genType w, x1, x2;
 	
@@ -334,13 +310,14 @@ namespace detail
 		return x2 * Deviation * Deviation * sqrt((genType(-2) * log(w)) / w) + Mean;
 	}
 
-	VECTORIZE_VEC_VEC(gaussRand)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> gaussRand(vecType<T, P> const & Mean, vecType<T, P> const & Deviation)
+	{
+		return detail::functor2<T, T, P, vecType>::call(gaussRand, Mean, Deviation);
+	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T, defaultp> diskRand
-	(
-		T const & Radius
-	)
+	GLM_FUNC_QUALIFIER tvec2<T, defaultp> diskRand(T Radius)
 	{		
 		tvec2<T, defaultp> Result(T(0));
 		T LenRadius(T(0));
@@ -358,10 +335,7 @@ namespace detail
 	}
 	
 	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T, defaultp> ballRand
-	(
-		T const & Radius
-	)
+	GLM_FUNC_QUALIFIER tvec3<T, defaultp> ballRand(T Radius)
 	{		
 		tvec3<T, defaultp> Result(T(0));
 		T LenRadius(T(0));
@@ -379,20 +353,14 @@ namespace detail
 	}
 	
 	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T, defaultp> circularRand
-	(
-		T const & Radius
-	)
+	GLM_FUNC_QUALIFIER tvec2<T, defaultp> circularRand(T Radius)
 	{
 		T a = linearRand(T(0), T(6.283185307179586476925286766559f));
 		return tvec2<T, defaultp>(cos(a), sin(a)) * Radius;		
 	}
 	
 	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T, defaultp> sphericalRand
-	(
-		T const & Radius
-	)
+	GLM_FUNC_QUALIFIER tvec3<T, defaultp> sphericalRand(T Radius)
 	{
 		T z = linearRand(T(-1), T(1));
 		T a = linearRand(T(0), T(6.283185307179586476925286766559f));
diff --git a/glm/gtx/fast_exponential.hpp b/glm/gtx/fast_exponential.hpp
index cc151457..15641fb0 100644
--- a/glm/gtx/fast_exponential.hpp
+++ b/glm/gtx/fast_exponential.hpp
@@ -52,42 +52,63 @@ namespace glm
 
 	/// Faster than the common pow function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename genType> 
-	GLM_FUNC_DECL genType fastPow(
-		genType const & x, 
-		genType const & y);
+	template <typename genType>
+	GLM_FUNC_DECL genType fastPow(genType x, genType y);
 
 	/// Faster than the common pow function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename genTypeT, typename genTypeU> 
-	GLM_FUNC_DECL genTypeT fastPow(
-		genTypeT const & x, 
-		genTypeU const & y);
-		
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> fastPow(vecType<T, P> const & x, vecType<T, P> const & y);
+
+	/// Faster than the common pow function but less accurate.
+	/// @see gtx_fast_exponential
+	template <typename genTypeT, typename genTypeU>
+	GLM_FUNC_DECL genTypeT fastPow(genTypeT x, genTypeU y);
+
+	/// Faster than the common pow function but less accurate.
+	/// @see gtx_fast_exponential
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> fastPow(vecType<T, P> const & x);
+
+	/// Faster than the common exp function but less accurate.
+	/// @see gtx_fast_exponential
+	template <typename T>
+	GLM_FUNC_DECL T fastExp(T x);
+
 	/// Faster than the common exp function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T> 
-	GLM_FUNC_DECL T fastExp(const T& x);
-		
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> fastExp(vecType<T, P> const & x);
+
 	/// Faster than the common log function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T> 
-	GLM_FUNC_DECL T fastLog(const T& x);
+	template <typename T>
+	GLM_FUNC_DECL T fastLog(T x);
 
 	/// Faster than the common exp2 function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T> 
-	GLM_FUNC_DECL T fastExp2(const T& x);
-		
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> fastLog(vecType<T, P> const & x);
+
+	/// Faster than the common exp2 function but less accurate.
+	/// @see gtx_fast_exponential
+	template <typename T>
+	GLM_FUNC_DECL T fastExp2(T x);
+
+	/// Faster than the common exp2 function but less accurate.
+	/// @see gtx_fast_exponential
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> fastExp2(vecType<T, P> const & x);
+
 	/// Faster than the common log2 function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T> 
-	GLM_FUNC_DECL T fastLog2(const T& x);
+	template <typename T>
+	GLM_FUNC_DECL T fastLog2(T x);
 
-	/// Faster than the common ln function but less accurate.
+	/// Faster than the common log2 function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T> 
-	GLM_FUNC_DECL T fastLn(const T& x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> fastLog2(vecType<T, P> const & x);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/fast_exponential.inl b/glm/gtx/fast_exponential.inl
index 0ef5b1ae..babedf3b 100644
--- a/glm/gtx/fast_exponential.inl
+++ b/glm/gtx/fast_exponential.inl
@@ -11,15 +11,19 @@ namespace glm
 {
 	// fastPow:
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastPow(genType const & x, genType const & y)
+	GLM_FUNC_QUALIFIER genType fastPow(genType x, genType y)
 	{
 		return exp(y * log(x));
 	}
 
-	VECTORIZE_VEC_VEC(fastPow)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastPow(vecType<T, P> const & x, vecType<T, P> const & y)
+	{
+		return exp(y * log(x));
+	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER T fastPow(const T x, int y)
+	GLM_FUNC_QUALIFIER T fastPow(T x, int y)
 	{
 		T f = static_cast<T>(1);
 		for(int i = 0; i < y; ++i)
@@ -27,43 +31,19 @@ namespace glm
 		return f;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> fastPow(
-		const tvec2<T, P>& x, 
-		const tvec2<int, P>& y)
-	{
-		return tvec2<T, P>(
-			fastPow(x.x, y.x),
-			fastPow(x.y, y.y));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> fastPow(
-		const tvec3<T, P>& x, 
-		const tvec3<int, P>& y)
-	{
-		return tvec3<T, P>(
-			fastPow(x.x, y.x),
-			fastPow(x.y, y.y),
-			fastPow(x.z, y.z));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> fastPow(
-		const tvec4<T, P>& x, 
-		const tvec4<int, P>& y)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastPow(vecType<T, P> const & x, vecType<int, P> const & y)
 	{
-		return tvec4<T, P>(
-			fastPow(x.x, y.x),
-			fastPow(x.y, y.y),
-			fastPow(x.z, y.z),
-			fastPow(x.w, y.w));
+		vecType<T, P> Result(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+			Result[i] = fastPow(x[i], y[i]);
+		return Result;
 	}
 
 	// fastExp
 	// Note: This function provides accurate results only for value between -1 and 1, else avoid it.
 	template <typename T>
-	GLM_FUNC_QUALIFIER T fastExp(const T x)
+	GLM_FUNC_QUALIFIER T fastExp(T x)
 	{
 		// This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
 		// return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
@@ -107,11 +87,15 @@ namespace glm
 	}
 	*/
 
-	VECTORIZE_VEC(fastExp)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastExp(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(fastExp, x);
+	}
 
 	// fastLog
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastLog(genType const & x)
+	GLM_FUNC_QUALIFIER genType fastLog(genType x)
 	{
 		return std::log(x);
 	}
@@ -125,24 +109,35 @@ namespace glm
 	}
 	*/
 
-	VECTORIZE_VEC(fastLog)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastLog(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(fastLog, x);
+	}
 
 	//fastExp2, ln2 = 0.69314718055994530941723212145818f
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastExp2(genType const & x)
+	GLM_FUNC_QUALIFIER genType fastExp2(genType x)
 	{
 		return fastExp(0.69314718055994530941723212145818f * x);
 	}
 
-	VECTORIZE_VEC(fastExp2)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastExp2(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(fastExp2, x);
+	}
 
 	// fastLog2, ln2 = 0.69314718055994530941723212145818f
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastLog2(genType const & x)
+	GLM_FUNC_QUALIFIER genType fastLog2(genType x)
 	{
 		return fastLog(x) / 0.69314718055994530941723212145818f;
 	}
 
-	VECTORIZE_VEC(fastLog2)
-
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastLog2(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(fastLog2, x);
+	}
 }//namespace glm
diff --git a/glm/gtx/fast_square_root.hpp b/glm/gtx/fast_square_root.hpp
index f62bc278..75f74a01 100644
--- a/glm/gtx/fast_square_root.hpp
+++ b/glm/gtx/fast_square_root.hpp
@@ -54,12 +54,12 @@ namespace glm
 	//! Faster than the common sqrt function but less accurate.
 	//! From GLM_GTX_fast_square_root extension.
 	template <typename genType> 
-	GLM_FUNC_DECL genType fastSqrt(genType const & x);
+	GLM_FUNC_DECL genType fastSqrt(genType x);
 
 	//! Faster than the common inversesqrt function but less accurate.
 	//! From GLM_GTX_fast_square_root extension.
 	template <typename genType> 
-	GLM_FUNC_DECL genType fastInverseSqrt(genType const & x);
+	GLM_FUNC_DECL genType fastInverseSqrt(genType x);
 
 	//! Faster than the common inversesqrt function but less accurate.
 	//! From GLM_GTX_fast_square_root extension.
@@ -73,8 +73,13 @@ namespace glm
 
 	//! Faster than the common distance function but less accurate.
 	//! From GLM_GTX_fast_square_root extension.
-	template <typename genType> 
-	GLM_FUNC_DECL typename genType::value_type fastDistance(genType const & x, genType const & y);
+	template <typename genType>
+	GLM_FUNC_DECL genType fastDistance(genType x, genType y);
+
+	//! Faster than the common distance function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL T fastDistance(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	//! Faster than the common normalize function but less accurate.
 	//! From GLM_GTX_fast_square_root extension.
diff --git a/glm/gtx/fast_square_root.inl b/glm/gtx/fast_square_root.inl
index 31bd02c7..c912c509 100644
--- a/glm/gtx/fast_square_root.inl
+++ b/glm/gtx/fast_square_root.inl
@@ -11,170 +11,77 @@ namespace glm
 {
 	// fastSqrt
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastSqrt
-	(
-		genType const & x
-	)
+	GLM_FUNC_QUALIFIER genType fastSqrt(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fastSqrt' only accept floating-point input");
 
 		return genType(1) / fastInverseSqrt(x);
 	}
 
-	VECTORIZE_VEC(fastSqrt)
-
-	// fastInversesqrt
-	template <>
-	GLM_FUNC_QUALIFIER float fastInverseSqrt<float>(float const & x)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastSqrt(vecType<T, P> const & x)
 	{
-#		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			tvec1<T, P> tmp(detail::compute_inversesqrt<tvec1, float, lowp>::call(tvec1<float, lowp>(x)));
-			return tmp.x;
-#		else
-			return detail::compute_inversesqrt<tvec1, float, lowp>::call(tvec1<float, lowp>(x)).x;
-#		endif
+		return detail::functor1<T, T, P, vecType>::call(fastSqrt, x);
 	}
 
-	template <>
-	GLM_FUNC_QUALIFIER double fastInverseSqrt<double>(double const & x)
+	// fastInversesqrt
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType fastInverseSqrt(genType x)
 	{
 #		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			tvec1<T, P> tmp(detail::compute_inversesqrt<tvec1, double, lowp>::call(tvec1<double, lowp>(x)));
+			tvec1<T, P> tmp(detail::compute_inversesqrt<tvec1, genType, lowp>::call(tvec1<genType, lowp>(x)));
 			return tmp.x;
 #		else
-			return detail::compute_inversesqrt<tvec1, double, lowp>::call(tvec1<double, lowp>(x)).x;
+			return detail::compute_inversesqrt<tvec1, genType, lowp>::call(tvec1<genType, lowp>(x)).x;
 #		endif
 	}
 
-	template <template <class, precision> class vecType, typename T, precision P>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastInverseSqrt
-	(
-		vecType<T, P> const & x
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastInverseSqrt(vecType<T, P> const & x)
 	{
 		return detail::compute_inversesqrt<vecType, T, P>::call(x);
 	}
 
-	VECTORIZE_VEC(fastInverseSqrt)
-
 	// fastLength
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastLength
-	(
-		genType const & x
-	)
+	GLM_FUNC_QUALIFIER genType fastLength(genType x)
 	{
-		return abs(x);
-	}
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fastLength' only accept floating-point inputs");
 
-	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER valType fastLength
-	(
-		tvec2<valType, P> const & x
-	)
-	{
-		valType sqr = x.x * x.x + x.y * x.y;
-		return fastSqrt(sqr);
+		return abs(x);
 	}
 
-	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER valType fastLength
-	(
-		tvec3<valType, P> const & x
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T fastLength(vecType<T, P> const & x)
 	{
-		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
-		return fastSqrt(sqr);
-	}
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fastLength' only accept floating-point inputs");
 
-	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER valType fastLength
-	(
-		tvec4<valType, P> const & x
-	)
-	{
-		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
-		return fastSqrt(sqr);
+		return fastSqrt(dot(x, x));
 	}
 
 	// fastDistance
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastDistance
-	(
-		genType const & x,
-		genType const & y
-	)
+	GLM_FUNC_QUALIFIER genType fastDistance(genType x, genType y)
 	{
 		return fastLength(y - x);
 	}
 
-	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER valType fastDistance
-	(
-		tvec2<valType, P> const & x,
-		tvec2<valType, P> const & y
-	)
-	{
-		return fastLength(y - x);
-	}
-
-	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER valType fastDistance
-	(
-		tvec3<valType, P> const & x,
-		tvec3<valType, P> const & y
-	)
-	{
-		return fastLength(y - x);
-	}
-
-	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER valType fastDistance
-	(
-		tvec4<valType, P> const & x,
-		tvec4<valType, P> const & y
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T fastDistance(vecType<T, P> const & x, vecType<T, P> const & y)
 	{
 		return fastLength(y - x);
 	}
 
 	// fastNormalize
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastNormalize
-	(
-		genType const & x
-	)
+	GLM_FUNC_QUALIFIER genType fastNormalize(genType x)
 	{
 		return x > genType(0) ? genType(1) : -genType(1);
 	}
 
-	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER tvec2<valType, P> fastNormalize
-	(
-		tvec2<valType, P> const & x
-	)
-	{
-		valType sqr = x.x * x.x + x.y * x.y;
-		return x * fastInverseSqrt(sqr);
-	}
-
-	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER tvec3<valType, P> fastNormalize
-	(
-		tvec3<valType, P> const & x
-	)
-	{
-		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
-		return x * fastInverseSqrt(sqr);
-	}
-
-	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER tvec4<valType, P> fastNormalize
-	(
-		tvec4<valType, P> const & x
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastNormalize(vecType<T, P> const & x)
 	{
-		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
-		return x * fastInverseSqrt(sqr);
+		return x * fastInverseSqrt(dot(x, x));
 	}
 }//namespace glm
diff --git a/glm/gtx/fast_trigonometry.hpp b/glm/gtx/fast_trigonometry.hpp
index f89a6df6..148c23f5 100644
--- a/glm/gtx/fast_trigonometry.hpp
+++ b/glm/gtx/fast_trigonometry.hpp
@@ -53,43 +53,43 @@ namespace glm
 	//! Defined between -2pi and 2pi. 
 	//! From GLM_GTX_fast_trigonometry extension.
 	template <typename T> 
-	GLM_FUNC_DECL T fastSin(const T& angle);
+	GLM_FUNC_DECL T fastSin(T angle);
 
 	//! Faster than the common cos function but less accurate.
 	//! Defined between -2pi and 2pi.
 	//! From GLM_GTX_fast_trigonometry extension.
 	template <typename T> 
-	GLM_FUNC_DECL T fastCos(const T& angle);
+	GLM_FUNC_DECL T fastCos(T angle);
 
 	//! Faster than the common tan function but less accurate. 
 	//! Defined between -2pi and 2pi. 
 	//! From GLM_GTX_fast_trigonometry extension.
 	template <typename T> 
-	GLM_FUNC_DECL T fastTan(const T& angle);
+	GLM_FUNC_DECL T fastTan(T angle);
 
 	//! Faster than the common asin function but less accurate. 
 	//! Defined between -2pi and 2pi.
 	//! From GLM_GTX_fast_trigonometry extension.
 	template <typename T> 
-	GLM_FUNC_DECL T fastAsin(const T& angle);
+	GLM_FUNC_DECL T fastAsin(T angle);
 
 	//! Faster than the common acos function but less accurate. 
 	//! Defined between -2pi and 2pi. 
 	//! From GLM_GTX_fast_trigonometry extension.
 	template <typename T> 
-	GLM_FUNC_DECL T fastAcos(const T& angle);
+	GLM_FUNC_DECL T fastAcos(T angle);
 
 	//! Faster than the common atan function but less accurate.
 	//! Defined between -2pi and 2pi. 
 	//! From GLM_GTX_fast_trigonometry extension.
 	template <typename T> 
-	GLM_FUNC_DECL T fastAtan(const T& y, const T& x);
+	GLM_FUNC_DECL T fastAtan(T y, T x);
 
 	//! Faster than the common atan function but less accurate. 
 	//! Defined between -2pi and 2pi.
 	//! From GLM_GTX_fast_trigonometry extension.
 	template <typename T> 
-	GLM_FUNC_DECL T fastAtan(const T& angle);
+	GLM_FUNC_DECL T fastAtan(T angle);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/fast_trigonometry.inl b/glm/gtx/fast_trigonometry.inl
index b68e8fd5..55c09b0c 100644
--- a/glm/gtx/fast_trigonometry.inl
+++ b/glm/gtx/fast_trigonometry.inl
@@ -11,65 +11,92 @@ namespace glm
 {
 	// sin
 	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastSin(T const & x)
+	GLM_FUNC_QUALIFIER T fastSin(T x)
 	{
 		return x - ((x * x * x) / T(6)) + ((x * x * x * x * x) / T(120)) - ((x * x * x * x * x * x * x) / T(5040));
 	}
 
-	VECTORIZE_VEC(fastSin)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastSin(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(fastSin, x);
+	}
 
 	// cos
 	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastCos(T const & x)
+	GLM_FUNC_QUALIFIER T fastCos(T x)
 	{
 		return T(1) - (x * x * T(0.5)) + (x * x * x * x * T(0.041666666666)) - (x * x * x * x * x * x * T(0.00138888888888));
 	}
 
-	VECTORIZE_VEC(fastCos)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastCos(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(fastCos, x);
+	}
 
 	// tan
 	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastTan(T const & x)
+	GLM_FUNC_QUALIFIER T fastTan(T x)
 	{
 		return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539));
 	}
 
-	VECTORIZE_VEC(fastTan)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastTan(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(fastTan, x);
+	}
 
 	// asin
 	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastAsin(T const & x)
+	GLM_FUNC_QUALIFIER T fastAsin(T x)
 	{
 		return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159));
 	}
 
-	VECTORIZE_VEC(fastAsin)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastAsin(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(fastAsin, x);
+	}
 
 	// acos
 	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastAcos(T const & x)
+	GLM_FUNC_QUALIFIER T fastAcos(T x)
 	{
 		return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2)
 	}
 
-	VECTORIZE_VEC(fastAcos)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastAcos(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(fastAcos, x);
+	}
 
 	// atan
 	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastAtan(T const & y, T const & x)
+	GLM_FUNC_QUALIFIER T fastAtan(T y, T x)
 	{
 		T sgn = sign(y) * sign(x);
 		return abs(fastAtan(y / x)) * sgn;
 	}
 
-	VECTORIZE_VEC_VEC(fastAtan)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastAtan(vecType<T, P> const & y, vecType<T, P> const & x)
+	{
+		return detail::functor2<T, T, P, vecType>::call(fastAtan, y, x);
+	}
 
 	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastAtan(T const & x)
+	GLM_FUNC_QUALIFIER T fastAtan(T x)
 	{
 		return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909));
 	}
 
-	VECTORIZE_VEC(fastAtan)
-
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastAtan(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(fastAtan, x);
+	}
 }//namespace glm
diff --git a/glm/gtx/multiple.hpp b/glm/gtx/multiple.hpp
index a1e485b5..068a71c9 100644
--- a/glm/gtx/multiple.hpp
+++ b/glm/gtx/multiple.hpp
@@ -59,8 +59,8 @@ namespace glm
 	/// @see gtx_multiple
 	template <typename genType>
 	GLM_FUNC_DECL genType higherMultiple(
-		genType const & Source,
-		genType const & Multiple);
+		genType Source,
+		genType Multiple);
 
 	/// Lower multiple number of Source.
 	///
@@ -71,8 +71,8 @@ namespace glm
 	/// @see gtx_multiple
 	template <typename genType>
 	GLM_FUNC_DECL genType lowerMultiple(
-		genType const & Source,
-		genType const & Multiple);
+		genType Source,
+		genType Multiple);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/multiple.inl b/glm/gtx/multiple.inl
index 5a395671..043934e9 100644
--- a/glm/gtx/multiple.inl
+++ b/glm/gtx/multiple.inl
@@ -17,13 +17,9 @@ namespace detail
 	struct higherMultiple
 	{
 		template <typename genType>
-		GLM_FUNC_QUALIFIER genType operator()
-		(
-			genType const & Source,
-			genType const & Multiple
-		)
+		GLM_FUNC_QUALIFIER genType operator()(genType Source, genType Multiple)
 		{
-			if (Source > genType(0))
+			if(Source > genType(0))
 			{
 				genType Tmp = Source - genType(1);
 				return Tmp + (Multiple - (Tmp % Multiple));
@@ -37,11 +33,7 @@ namespace detail
 	struct higherMultiple<false>
 	{
 		template <typename genType>
-		GLM_FUNC_QUALIFIER genType operator()
-		(
-			genType const & Source,
-			genType const & Multiple
-		)
+		GLM_FUNC_QUALIFIER genType operator()(genType Source, genType Multiple)
 		{
 			genType Tmp = Source - genType(1);
 			return Tmp + (Multiple - (Tmp % Multiple));
@@ -53,24 +45,16 @@ namespace detail
 	// higherMultiple
 
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType higherMultiple
-	(
-		genType const & Source,
-		genType const & Multiple
-	)
+	GLM_FUNC_QUALIFIER genType higherMultiple(genType Source, genType Multiple)
 	{
 		detail::higherMultiple<std::numeric_limits<genType>::is_signed> Compute;
 		return Compute(Source, Multiple);
 	}
 
 	template <>
-	GLM_FUNC_QUALIFIER float higherMultiple
-	(	
-		float const & Source,
-		float const & Multiple
-	)
+	GLM_FUNC_QUALIFIER float higherMultiple(float Source, float Multiple)
 	{
-		if (Source > float(0))
+		if(Source > float(0))
 		{
 			float Tmp = Source - float(1);
 			return Tmp + (Multiple - std::fmod(Tmp, Multiple));
@@ -80,13 +64,9 @@ namespace detail
 	}
 
 	template <>
-	GLM_FUNC_QUALIFIER double higherMultiple
-	(
-		double const & Source,
-		double const & Multiple
-	)
+	GLM_FUNC_QUALIFIER double higherMultiple(double Source, double Multiple)
 	{
-		if (Source > double(0))
+		if(Source > double(0))
 		{
 			double Tmp = Source - double(1);
 			return Tmp + (Multiple - std::fmod(Tmp, Multiple));
@@ -95,19 +75,19 @@ namespace detail
 			return Source + std::fmod(-Source, Multiple);
 	}
 
-	VECTORIZE_VEC_VEC(higherMultiple)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> higherMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple)
+	{
+		return detail::functor2<T, T, P, vecType>::call(higherMultiple, Source, Multiple);
+	}
 
 	//////////////////////
 	// lowerMultiple
 
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType lowerMultiple
-	(
-		genType const & Source,
-		genType const & Multiple
-	)
+	GLM_FUNC_QUALIFIER genType lowerMultiple(genType Source, genType Multiple)
 	{
-		if (Source >= genType(0))
+		if(Source >= genType(0))
 			return Source - Source % Multiple;
 		else
 		{
@@ -117,13 +97,9 @@ namespace detail
 	}
 
 	template <>
-	GLM_FUNC_QUALIFIER float lowerMultiple
-	(
-		float const & Source,
-		float const & Multiple
-	)
+	GLM_FUNC_QUALIFIER float lowerMultiple(float Source, float Multiple)
 	{
-		if (Source >= float(0))
+		if(Source >= float(0))
 			return Source - std::fmod(Source, Multiple);
 		else
 		{
@@ -133,11 +109,7 @@ namespace detail
 	}
 
 	template <>
-	GLM_FUNC_QUALIFIER double lowerMultiple
-	(
-		double const & Source,
-		double const & Multiple
-	)
+	GLM_FUNC_QUALIFIER double lowerMultiple(double Source, double Multiple)
 	{
 		if (Source >= double(0))
 			return Source - std::fmod(Source, Multiple);
@@ -148,5 +120,9 @@ namespace detail
 		}
 	}
 
-	VECTORIZE_VEC_VEC(lowerMultiple)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> lowerMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple)
+	{
+		return detail::functor2<T, T, P, vecType>::call(lowerMultiple, Source, Multiple);
+	}
 }//namespace glm