Added fmin, fmax and fclamp to GTX_extended_min_max #372

glm/gtx/extended_min_max.hpp

@@ -130,6 +130,96 @@ namespace glm
 		C<T> const& z, 
 		C<T> const& w);
 
+	/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	/// 
+	/// @see gtx_extented_min_max
+	template<typename genType>
+	GLM_FUNC_DECL genType fmin(genType x, genType y);
+
+	/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtx_extented_min_max
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& x, T y);
+
+	/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtx_extented_min_max
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	/// 
+	/// @tparam genType Floating-point; scalar or vector types.
+	/// 
+	/// @see gtx_extented_min_max
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<typename genType>
+	GLM_FUNC_DECL genType fmax(genType x, genType y);
+
+	/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	/// 
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	/// 
+	/// @see gtx_extented_min_max
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& x, T y);
+
+	/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
+	/// 
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	/// 
+	/// @see gtx_extented_min_max
+	/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see gtx_extented_min_max
+	template<typename genType>
+	GLM_FUNC_DECL genType fclamp(genType x, genType minVal, genType maxVal);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtx_extented_min_max
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fclamp(vec<L, T, Q> const& x, T minVal, T maxVal);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
+	///
+	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
+	/// @tparam T Floating-point scalar types
+	/// @tparam Q Value from qualifier enum
+	///
+	/// @see gtx_extented_min_max
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_DECL vec<L, T, Q> fclamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal);
+
+
 	/// @}
 }//namespace glm
 

glm/gtx/extended_min_max.inl

@@ -137,4 +137,83 @@ namespace glm
 		return glm::max(glm::max(x, y), glm::max(z, w));
 	}
 
+	// fmin
+#	if GLM_HAS_CXX11_STL
+		using std::fmin;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType fmin(genType x, genType y)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fmin' only accept floating-point input");
+
+			if (isnan(y))
+				return x;
+			if (isnan(y))
+				return x;
+
+			return min(x, y);
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmin(vec<L, T, Q> const& a, T b)
+	{
+		return detail::functor2<L, T, Q>::call(fmin, a, vec<L, T, Q>(b));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmin(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		return detail::functor2<L, T, Q>::call(fmin, a, b);
+	}
+
+	// fmax
+#	if GLM_HAS_CXX11_STL
+		using std::fmax;
+#	else
+		template<typename genType>
+		GLM_FUNC_QUALIFIER genType fmax(genType x, genType y)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fmax' only accept floating-point input");
+
+			if (isnan(y))
+				return x;
+			if (isnan(y))
+				return x;
+
+			return max(x, y);
+		}
+#	endif
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmax(vec<L, T, Q> const& a, T b)
+	{
+		return detail::functor2<L, T, Q>::call(fmax, a, vec<L, T, Q>(b));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+	{
+		return detail::functor2<L, T, Q>::call(fmax, a, b);
+	}
+
+	// fclamp
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType fclamp(genType x, genType minVal, genType maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fclamp' only accept floating-point or integer inputs");
+		return fmin(fmax(x, minVal), maxVal);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fclamp(vec<L, T, Q> const& x, T minVal, T maxVal)
+	{
+		return fmin(fmax(x, vec<L, T, Q>(minVal)), vec<L, T, Q>(maxVal));
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> fclamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal)
+	{
+		return fmin(fmax(x, minVal), maxVal);
+	}
 }//namespace glm

readme.md

@@ -62,6 +62,7 @@ glm::mat4 camera(float Translate, glm::vec2 const& Rotate)
 - Added packing functions for integer vectors #639
 - Added conan packaging configuration #643 #641
 - Added quatLookAt to GTX_quaternion #659
+- Added fmin, fmax and fclamp to GTX_extended_min_max #372
 
 #### Improvements:
 - No more default initialization of vector, matrix and quaternion types

test/gtx/gtx_extended_min_max.cpp

@@ -1,9 +1,92 @@
 #define GLM_ENABLE_EXPERIMENTAL
 #include <glm/gtx/extended_min_max.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtc/epsilon.hpp>
+
+// This file has divisions by zero to test isnan
+#if GLM_COMPILER & GLM_COMPILER_VC
+#	pragma warning(disable : 4723)
+#endif
+
+namespace fmin_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		float Zero_f = 0.0f;
+		glm::vec1 A0 = glm::fmin(glm::vec1(1), glm::vec1(Zero_f / 0.0f));
+		Error += glm::epsilonEqual(A0.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+
+		glm::vec2 B0 = glm::fmin(glm::vec2(1), glm::vec2(1));
+		glm::vec2 B1 = glm::fmin(glm::vec2(1), 1.0f);
+		bool B2 = glm::all(glm::equal(B0, B1));
+		Error += B2 ? 0 : 1;
+
+		glm::vec3 C0 = glm::fmin(glm::vec3(1), glm::vec3(1));
+		glm::vec3 C1 = glm::fmin(glm::vec3(1), 1.0f);
+		bool C2 = glm::all(glm::equal(C0, C1));
+		Error += C2 ? 0 : 1;
+
+		glm::vec4 D0 = glm::fmin(glm::vec4(1), glm::vec4(1));
+		glm::vec4 D1 = glm::fmin(glm::vec4(1), 1.0f);
+		bool D2 = glm::all(glm::equal(D0, D1));
+		Error += D2 ? 0 : 1;
+
+		return Error;
+	}
+}//namespace fmin_
+
+namespace fmax_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		float Zero_f = 0.0f;
+		glm::vec1 A0 = glm::fmax(glm::vec1(1), glm::vec1(Zero_f / 0.0f));
+		Error += glm::epsilonEqual(A0.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+
+		glm::vec2 B0 = glm::fmax(glm::vec2(1), glm::vec2(1));
+		glm::vec2 B1 = glm::fmax(glm::vec2(1), 1.0f);
+		bool B2 = glm::all(glm::equal(B0, B1));
+		Error += B2 ? 0 : 1;
+
+		glm::vec3 C0 = glm::fmax(glm::vec3(1), glm::vec3(1));
+		glm::vec3 C1 = glm::fmax(glm::vec3(1), 1.0f);
+		bool C2 = glm::all(glm::equal(C0, C1));
+		Error += C2 ? 0 : 1;
+
+		glm::vec4 D0 = glm::fmax(glm::vec4(1), glm::vec4(1));
+		glm::vec4 D1 = glm::fmax(glm::vec4(1), 1.0f);
+		bool D2 = glm::all(glm::equal(D0, D1));
+		Error += D2 ? 0 : 1;
+
+		return Error;
+	}
+}//namespace fmax_
+
+namespace fclamp_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		float Zero_f = 0.0f;
+		glm::vec1 A0 = glm::fclamp(glm::vec1(1), glm::vec1(Zero_f / 0.0f), glm::vec1(2.0f));
+		Error += glm::epsilonEqual(A0.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace fclamp_
 
 int main()
 {
-	int Error(0);
+	int Error = 0;
+
+	Error += fmin_::test();
+	Error += fmax_::test();
+	Error += fclamp_::test();
 
 	return Error;
 }