Created GTC_random

glm/gtc/random.hpp

@@ -0,0 +1,108 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref gtc_random
+/// @file glm/gtc/random.hpp
+/// @date 2011-09-18 / 2011-09-18
+/// @author Christophe Riccio
+///
+/// @see core (dependence)
+/// @see gtc_half_float (dependence)
+/// @see gtx_random (extended)
+///
+/// @defgroup gtc_random GLM_GTC_random: Random number generation
+/// @ingroup gtc
+/// 
+/// @brief Generate random number from various distribution methods
+/// 
+/// <glm/gtc/random.hpp> need to be included to use these functionalities.
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef GLM_GTC_random
+#define GLM_GTC_random GLM_VERSION
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/half_float.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTC_random extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_random
+	/// @{
+
+	/// Generate a random number in the interval [-1, 1], according a linear distribution.
+	/// From GLM_GTC_random extension.
+    template <typename T> T signedRand1();
+	
+	template <> float signedRand1(); //!< \brief Generate a random number in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <> double signedRand1(); //!< \brief Generate a random number in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> signedRand2(); //!< \brief Generate 2 random numbers in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> signedRand3(); //!< \brief Generate 3 random numbers in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> signedRand4(); //!< \brief Generate 4 random numbers in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
+    
+	template <typename T> detail::tvec2<T> normalizedRand2(); //!< \brief Generate a normalized 2D vector regulary distribute on a circle (From GLM_GTX_random extension)
+	template <typename T> detail::tvec2<T> normalizedRand2(T Min, T Max); //!< \brief Generate a scaled and normalized 2D vector regulary distribute on a circle (From GLM_GTX_random extension)
+	template <typename T> detail::tvec3<T> normalizedRand3(); //!< \brief Generate a normalized 3D vector regulary distribute on a sphere (From GLM_GTX_random extension)
+	template <typename T> detail::tvec3<T> normalizedRand3(T Min, T Max); //!< \brief Generate a scaled and normalized 3D vector regulary distribute on a sphere (From GLM_GTX_random extension)
+
+    template <typename T> T compRand1(); //!< \brief Generate a random number in the interval [0, 1], according a linear distribution (From GLM_GTX_random extension)
+	template <> float compRand1(); //!< \brief Generate a random number in the interval [0, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <> double compRand1(); //!< \brief Generate a random number in the interval [0, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> T compRand1(T Min, T Max); //!< \brief Generate a random number in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> compRand2(T Min, T Max); //!< \brief Generate 2 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> compRand3(T Min, T Max); //!< \brief Generate 3 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> compRand4(T Min, T Max); //!< \brief Generate 4 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> compRand2(const detail::tvec2<T>& Min, const detail::tvec2<T>& Max); //!< \brief Generate 2 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> compRand3(const detail::tvec3<T>& Min, const detail::tvec3<T>& Max); //!< \brief Generate 3 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> compRand4(const detail::tvec4<T>& Min, const detail::tvec4<T>& Max); //!< \brief Generate 4 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+
+    template <typename T> detail::tvec2<T> vecRand2(); //!< \brief Generate a random normalized 2 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> vecRand2(T MinRadius, T MaxRadius); //!< \brief Generate a random normalized 2 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> vecRand3(); //!< \brief Generate a random normalized 3 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> vecRand3(T MinRadius, T MaxRadius); //!< \brief Generate a random normalized 3 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> vecRand4(); //!< \brief Generate a random normalized 4 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> vecRand4(T MinRadius, T MaxRadius); //!< \brief Generate a random normalized 4 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+
+    template <typename T> T gaussRand1(T mean, T std_deviation); //!< \brief Gererate a random floating number according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> gaussRand2(T mean, T std_deviation); //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> gaussRand3(T mean, T std_deviation); //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> gaussRand4(T mean, T std_deviation); //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> gaussRand2(const detail::tvec2<T>& mean, T std_deviation); //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> gaussRand3(const detail::tvec3<T>& mean, T std_deviation); //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> gaussRand4(const detail::tvec4<T>& mean, T std_deviation); //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> gaussRand2(T  mean, const detail::tvec2<T>& std_deviation); //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> gaussRand3(T  mean, const detail::tvec3<T>& std_deviation); //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> gaussRand4(T  mean, const detail::tvec4<T>& std_deviation); //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> gaussRand2(const detail::tvec2<T>& mean, const detail::tvec2<T>& std_deviation); //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> gaussRand3(const detail::tvec3<T>& mean, const detail::tvec3<T>& std_deviation); //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> gaussRand4(const detail::tvec4<T>& mean, const detail::tvec4<T>& std_deviation); //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+
+	/// @}
+}//namespace glm
+
+#include "random.inl"
+
+#endif//GLM_GTC_random

glm/gtc/random.inl

@@ -0,0 +1,532 @@
+//////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+//////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-09-19
+// Updated : 2011-09-19
+// Licence : This source is under MIT License
+// File    : glm/gtc/random.inl
+//////////////////////////////////////////////////////////////////////////////////
+
+#include <ctime>
+#include <cassert>
+
+namespace glm{
+
+template <>
+GLM_FUNC_QUALIFIER float signedRand1()
+{
+	#if(GLM_COMPILER & GLM_COMPILER_VC)// && (GLM_COMPILER < GLM_COMPILER_VC2010)
+	#define RAND_SHIFT_NUM 5
+	#else
+	#define RAND_SHIFT_NUM 0
+	#endif
+	return float((std::rand() - (RAND_MAX >> 1) - 1) << 1) / float(RAND_MAX - RAND_SHIFT_NUM);
+}
+
+template <>
+GLM_FUNC_QUALIFIER double signedRand1()
+{
+	return double(signedRand1<float>());
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> signedRand2()
+{
+	return detail::tvec2<T>(
+		signedRand1<float>(),
+		signedRand1<float>());
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> signedRand3()
+{
+	return detail::tvec3<T>(
+		signedRand1<float>(),
+		signedRand1<float>(),
+		signedRand1<float>());
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> signedRand4()
+{
+	return detail::tvec4<T>(
+		signedRand1<float>(),
+		signedRand1<float>(),
+		signedRand1<float>(),
+		signedRand1<float>());
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> normalizedRand2()
+{
+    T a = compRand1<T>(T(0), T(6.283185307179586476925286766559f));
+    return detail::tvec2<T>(cos(a), sin(a));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> normalizedRand3()
+{
+	T z = compRand1(T(-1), T(1));
+	T a = compRand1(T(0), T(6.283185307179586476925286766559f));
+
+    T r = sqrt(T(1) - z * z);
+
+	T x = r * cos(a);
+	T y = r * sin(a);
+
+    return detail::tvec3<T>(x, y, z);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> normalizedRand3(
+	T Min, 
+	T Max)
+{
+    return normalizedRand3<T>() * compRand1(Min, Max);
+}
+
+template <>
+GLM_FUNC_QUALIFIER float compRand1()
+{
+	return float(std::rand()) / float(RAND_MAX);
+}
+
+template <>
+GLM_FUNC_QUALIFIER double compRand1()
+{
+	return double(std::rand()) / double(RAND_MAX);
+}
+
+GLM_FUNC_QUALIFIER detail::thalf compRand1(
+	detail::thalf Min, 
+	detail::thalf Max)
+{
+	return compRand1<detail::thalf>() * (Max - Min) + Min;
+}
+
+GLM_FUNC_QUALIFIER float compRand1(
+	float Min, 
+	float Max)
+{
+	return compRand1<float>() * (Max - Min) + Min;
+}
+
+GLM_FUNC_QUALIFIER double compRand1(
+	double Min, 
+	double Max)
+{
+	return compRand1<double>() * (Max - Min) + Min;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER T compRand1(
+	T Min, 
+	T Max)
+{
+	return T(compRand1<double>() * double(Max - Min) + double(Min));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
+	T Min, 
+	T Max)
+{
+	return detail::tvec2<T>(
+		compRand1(Min, Max),
+		compRand1(Min, Max));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
+	T Min, 
+	T Max)
+{
+	return detail::tvec3<T>(
+		compRand1(Min, Max),
+		compRand1(Min, Max),
+		compRand1(Min, Max));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
+	T Min, 
+	T Max)
+{
+	return detail::tvec4<T>(
+		compRand1(Min, Max),
+		compRand1(Min, Max),
+		compRand1(Min, Max),
+		compRand1(Min, Max));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
+	T Min, 
+	const detail::tvec2<T>& Max)
+{
+	return detail::tvec2<T>(
+		compRand1(Min.x, Max.x),
+		compRand1(Min.y, Max.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
+	T Min, 
+	const detail::tvec3<T>& Max)
+{
+	return detail::tvec3<T>(
+		compRand1(Min.x, Max.x),
+		compRand1(Min.y, Max.y),
+		compRand1(Min.z, Max.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
+	T Min, 
+	const detail::tvec4<T>& Max)
+{
+	return detail::tvec4<T>(
+		compRand1(Min.x, Max.x),
+		compRand1(Min.y, Max.y),
+		compRand1(Min.z, Max.z),
+		compRand1(Min.w, Max.w));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
+	const detail::tvec2<T>& Min, 
+	T Max)
+{
+	return detail::tvec2<T>(
+		compRand1(Min.x, Max.x),
+		compRand1(Min.y, Max.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
+	const detail::tvec3<T>& Min, 
+	T Max)
+{
+	return detail::tvec3<T>(
+		compRand1(Min.x, Max.x),
+		compRand1(Min.y, Max.y),
+		compRand1(Min.z, Max.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
+	const detail::tvec4<T>& Min, 
+	T Max)
+{
+	return detail::tvec4<T>(
+		compRand1(Min.x, Max.x),
+		compRand1(Min.y, Max.y),
+		compRand1(Min.z, Max.z),
+		compRand1(Min.w, Max.w));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
+	const detail::tvec2<T>& Min, 
+	const detail::tvec2<T>& Max)
+{
+	return detail::tvec2<T>(
+		compRand1(Min.x, Max.x),
+		compRand1(Min.y, Max.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
+	const detail::tvec3<T>& Min, 
+	const detail::tvec3<T>& Max)
+{
+	return detail::tvec3<T>(
+		compRand1(Min.x, Max.x),
+		compRand1(Min.y, Max.y),
+		compRand1(Min.z, Max.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
+	const detail::tvec4<T>& Min, 
+	const detail::tvec4<T>& Max)
+{
+	return detail::tvec4<T>(
+		compRand1(Min.x, Max.x),
+		compRand1(Min.y, Max.y),
+		compRand1(Min.z, Max.z),
+		compRand1(Min.w, Max.w));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<float> vecRand2()
+{
+	detail::tvec2<float> result(float(0));
+	do
+	{
+		result = compRand2(float(-1), float(1));
+	} while (length(result) > float(1));
+
+    return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<double> vecRand2()
+{
+	detail::tvec2<double> result(double(0));
+	do
+	{
+		result = compRand2(double(-1), double(1));
+	} while (length(result) > double(1));
+
+    return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> vecRand2(
+	T MinRadius, 
+	T MaxRadius)
+{
+	assert(MinRadius <= MaxRadius);
+
+	detail::tvec2<T> Result(T(0));
+	T LenRadius(0);
+
+	do
+	{
+		Result = compRand2(-MaxRadius, MaxRadius);
+		LenRadius = length(Result);
+	}
+	while(LenRadius > MaxRadius || LenRadius < MinRadius);
+
+    return Result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> vecRand3()
+{
+	detail::tvec3<T> Result(T(0));
+	do
+	{
+		Result = compRand3(T(-1), T(1));
+	}
+	while(length(Result) > T(1));
+
+    return Result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> vecRand3(
+	T MinRadius, 
+	T MaxRadius)
+{
+	assert(MinRadius <= MaxRadius);
+
+	detail::tvec3<T> Result(0);
+	T LenRadius(0);
+
+	do
+	{
+		Result = compRand3(-MaxRadius, MaxRadius);
+		LenRadius = length(Result);
+	}
+	while(LenRadius > MaxRadius || LenRadius < MinRadius);
+
+    return Result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<float> vecRand4()
+{
+	detail::tvec4<float> result(float(0));
+	do
+	{
+		result = compRand4(float(-1), float(1));
+	} while (length(result) > float(1));
+
+    return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<double> vecRand4()
+{
+	detail::tvec4<double> result(double(0));
+	do
+	{
+		result = compRand4(double(-1), double(1));
+	} while (length(result) > double(1));
+
+    return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> vecRand4(
+	T MinRadius, 
+	T MaxRadius)
+{
+	assert(MinRadius <= MaxRadius);
+
+	detail::tvec4<T> Result(T(0));
+	T LenRadius(T(0));
+
+	do
+	{
+		Result = compRand4(-MaxRadius, MaxRadius);
+		LenRadius = length(Result);
+	}
+	while(LenRadius > MaxRadius || LenRadius < MinRadius);
+
+    return Result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER T gaussRand1(
+	T mean, 
+	T std_deviation)
+{
+    T w, x1, x2;
+
+    do
+    {
+        x1 = compRand1(T(-1), T(1));
+        x2 = compRand1(T(-1), T(1));
+
+        w = x1 * x1 + x2 * x2;
+    } while(w > T(1));
+
+    return x2 * std_deviation * std_deviation * sqrt((T(-2) * log(w)) / w) + mean;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
+	T mean, 
+	T std_deviation)
+{
+    return detail::tvec2<T>(
+        gaussRand1(mean, std_deviation),
+        gaussRand1(mean, std_deviation));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
+	T mean, 
+	T std_deviation)
+{
+    return detail::tvec3<T>(
+        gaussRand1(mean, std_deviation),
+        gaussRand1(mean, std_deviation),
+        gaussRand1(mean, std_deviation));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
+	T mean, 
+	T std_deviation)
+{
+    return detail::tvec4<T>(
+        gaussRand1(mean, std_deviation),
+        gaussRand1(mean, std_deviation),
+        gaussRand1(mean, std_deviation),
+        gaussRand1(mean, std_deviation));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
+	T mean, 
+	const detail::tvec2<T>& std_deviation)
+{
+    return detail::tvec2<T>(
+        gaussRand1(mean, std_deviation.x),
+        gaussRand1(mean, std_deviation.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
+	T mean, 
+	const detail::tvec3<T>& std_deviation)
+{
+    return detail::tvec3<T>(
+        gaussRand1(mean, std_deviation.x),
+        gaussRand1(mean, std_deviation.y),
+        gaussRand1(mean, std_deviation.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
+	T mean, 
+	const detail::tvec4<T>& std_deviation)
+{
+    return detail::tvec4<T>(
+        gaussRand1(mean, std_deviation.x),
+        gaussRand1(mean, std_deviation.y),
+        gaussRand1(mean, std_deviation.z),
+        gaussRand1(mean, std_deviation.w));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
+	const detail::tvec2<T>& mean, 
+	T std_deviation)
+{
+    return detail::tvec2<T>(
+        gaussRand1(mean.x, std_deviation),
+        gaussRand1(mean.y, std_deviation));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
+	const detail::tvec3<T>& mean, 
+	T std_deviation)
+{
+    return detail::tvec3<T>(
+        gaussRand1(mean.x, std_deviation),
+        gaussRand1(mean.y, std_deviation),
+        gaussRand1(mean.z, std_deviation));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
+	const detail::tvec4<T>& mean, 
+	T std_deviation)
+{
+    return detail::tvec4<T>(
+        gaussRand1(mean.x, std_deviation),
+        gaussRand1(mean.y, std_deviation),
+        gaussRand1(mean.z, std_deviation),
+        gaussRand1(mean.w, std_deviation));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
+	const detail::tvec2<T>& mean, 
+	const detail::tvec2<T>& std_deviation)
+{
+    return detail::tvec2<T>(
+        gaussRand1(mean.x, std_deviation.x),
+        gaussRand1(mean.y, std_deviation.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
+	const detail::tvec3<T>& mean, 
+	const detail::tvec3<T>& std_deviation)
+{
+    return detail::tvec3<T>(
+        gaussRand1(mean.x, std_deviation.x),
+        gaussRand1(mean.y, std_deviation.y),
+        gaussRand1(mean.z, std_deviation.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
+	const detail::tvec4<T>& mean, 
+	const detail::tvec4<T>& std_deviation)
+{
+    return detail::tvec4<T>(
+        gaussRand1(mean.x, std_deviation.x),
+        gaussRand1(mean.y, std_deviation.y),
+        gaussRand1(mean.z, std_deviation.z),
+        gaussRand1(mean.w, std_deviation.w));
+}
+
+}//namespace glm

glm/gtx/random.hpp

@@ -41,7 +41,7 @@
 
 // Dependency:
 #include "../glm.hpp"
-#include "../gtc/half_float.hpp"
+#include "../gtc/random.hpp"
 
 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
 #	pragma message("GLM: GLM_GTX_random extension included")

test/gtc/CMakeLists.txt

@@ -4,6 +4,7 @@ glmCreateTestGTC(gtc_matrix_integer)
 glmCreateTestGTC(gtc_matrix_inverse)
 glmCreateTestGTC(gtc_matrix_transform)
 glmCreateTestGTC(gtc_quaternion)
+glmCreateTestGTC(gtc_random)
 glmCreateTestGTC(gtc_swizzle)
 glmCreateTestGTC(gtc_type_precision)
 glmCreateTestGTC(gtc_type_ptr)

test/gtc/gtc_random.cpp

@@ -0,0 +1,99 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-05-31
+// Updated : 2011-05-31
+// Licence : This source is under MIT licence
+// File    : test/gtx/random.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtx/random.hpp>
+#include <glm/gtx/epsilon.hpp>
+#include <iostream>
+
+int test_signedRand1()
+{
+	int Error = 0;
+
+	{
+		float ResultFloat = 0.0f;
+		double ResultDouble = 0.0f;
+		for(std::size_t i = 0; i < 100000; ++i)
+		{
+			ResultFloat += glm::signedRand1<float>();
+			ResultDouble += glm::signedRand1<double>();
+		}
+
+		Error += glm::equalEpsilon(ResultFloat, 0.0f, 0.0001f);
+		Error += glm::equalEpsilon(ResultDouble, 0.0, 0.0001);
+	}
+
+	return Error;
+}
+
+int test_normalizedRand2()
+{
+	int Error = 0;
+
+	{
+		std::size_t Max = 100000;
+		float ResultFloat = 0.0f;
+		double ResultDouble = 0.0f;
+		for(std::size_t i = 0; i < Max; ++i)
+		{
+			ResultFloat += glm::length(glm::normalizedRand2<float>());
+			ResultDouble += glm::length(glm::normalizedRand2<double>());
+		}
+
+		Error += glm::equalEpsilon(ResultFloat, float(Max), 0.000001f) ? 0 : 1;
+		Error += glm::equalEpsilon(ResultDouble, double(Max), 0.000001) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_normalizedRand3()
+{
+	int Error = 0;
+
+	{
+		std::size_t Max = 100000;
+		float ResultFloatA = 0.0f;
+		float ResultFloatB = 0.0f;
+		float ResultFloatC = 0.0f;
+		double ResultDoubleA = 0.0f;
+		double ResultDoubleB = 0.0f;
+		double ResultDoubleC = 0.0f;
+		for(std::size_t i = 0; i < Max; ++i)
+		{
+			ResultFloatA += glm::length(glm::normalizedRand3<float>());
+			ResultDoubleA += glm::length(glm::normalizedRand3<double>());
+			ResultFloatB += glm::length(glm::normalizedRand3(2.0f, 2.0f));
+			ResultDoubleB += glm::length(glm::normalizedRand3(2.0, 2.0));
+			ResultFloatC += glm::length(glm::normalizedRand3(1.0f, 3.0f));
+			ResultDoubleC += glm::length(glm::normalizedRand3(1.0, 3.0));
+		}
+
+		Error += glm::equalEpsilon(ResultFloatA, float(Max), 0.0001f) ? 0 : 1;
+		Error += glm::equalEpsilon(ResultDoubleA, double(Max), 0.0001) ? 0 : 1;
+		Error += glm::equalEpsilon(ResultFloatB, float(Max * 2), 0.0001f) ? 0 : 1;
+		Error += glm::equalEpsilon(ResultDoubleB, double(Max * 2), 0.0001) ? 0 : 1;
+		Error += (ResultFloatC >= float(Max) && ResultFloatC <= float(Max * 3)) ? 0 : 1;
+		Error += (ResultDoubleC >= double(Max) && ResultDoubleC <= double(Max * 3)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_signedRand1();
+	Error += test_normalizedRand2();
+	Error += test_normalizedRand3();
+
+	return Error;
+}