mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-10 04:31:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixed epsilonEqual build

Browse Source
This commit is contained in:
Christophe Riccio 2017-08-07 03:18:21 +02:00
parent 1e7d12b91b
commit 45a716b893
3 changed files with 74 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
glm/gtc/epsilon.hpp
View File

@ -30,41 +30,29 @@ namespace glm
/// True if this expression is satisfied. /// True if this expression is satisfied.
/// ///
/// @see gtc_epsilon /// @see gtc_epsilon
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType> template<length_t L, typename T, precision P>
GLM_FUNC_DECL vecType<L, bool, P> epsilonEqual( GLM_FUNC_DECL vec<L, bool, P> epsilonEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, T const & epsilon);
vecType<L, T, P> const& x,
vecType<L, T, P> const& y,
T const & epsilon);
/// Returns the component-wise comparison of |x - y| < epsilon. /// Returns the component-wise comparison of |x - y| < epsilon.
/// True if this expression is satisfied. /// True if this expression is satisfied.
/// ///
/// @see gtc_epsilon /// @see gtc_epsilon
template<typename genType> template<typename genType>
GLM_FUNC_DECL bool epsilonEqual( GLM_FUNC_DECL bool epsilonEqual(genType const & x, genType const & y, genType const & epsilon);
genType const & x,
genType const & y,
genType const & epsilon);
/// Returns the component-wise comparison of |x - y| < epsilon. /// Returns the component-wise comparison of |x - y| < epsilon.
/// True if this expression is not satisfied. /// True if this expression is not satisfied.
/// ///
/// @see gtc_epsilon /// @see gtc_epsilon
template<typename genType> template<length_t L, typename T, precision P>
GLM_FUNC_DECL typename genType::boolType epsilonNotEqual( GLM_FUNC_DECL vec<L, bool, P> epsilonNotEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, T const & epsilon);
genType const & x,
genType const & y,
typename genType::value_type const & epsilon);
/// Returns the component-wise comparison of |x - y| >= epsilon. /// Returns the component-wise comparison of |x - y| >= epsilon.
/// True if this expression is not satisfied. /// True if this expression is not satisfied.
/// ///
/// @see gtc_epsilon /// @see gtc_epsilon
template<typename genType> template<typename genType>
GLM_FUNC_DECL bool epsilonNotEqual( GLM_FUNC_DECL bool epsilonNotEqual(genType const & x, genType const & y, genType const & epsilon);
genType const & x,
genType const & y,
genType const & epsilon);
/// @} /// @}
}//namespace glm }//namespace glm

84
glm/gtc/epsilon.inl
View File

@ -33,91 +33,51 @@ namespace glm
return abs(x - y) < epsilon; return abs(x - y) < epsilon;
} }
template<length_t L, typename T, precision P>
GLM_FUNC_QUALIFIER vec<L, bool, P> epsilonEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, T const& epsilon)
{
return lessThan(abs(x - y), vec<L, T, P>(epsilon));
}
template<length_t L, typename T, precision P>
GLM_FUNC_QUALIFIER vec<L, bool, P> epsilonEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, vec<L, T, P> const& epsilon)
{
return lessThan(abs(x - y), vec<L, T, P>(epsilon));
}
template<> template<>
GLM_FUNC_QUALIFIER bool epsilonNotEqual GLM_FUNC_QUALIFIER bool epsilonNotEqual(float const& x, float const & y, float const& epsilon)
(
float const & x,
float const & y,
float const & epsilon
)
{ {
return abs(x - y) >= epsilon; return abs(x - y) >= epsilon;
} }
template<> template<>
GLM_FUNC_QUALIFIER bool epsilonNotEqual GLM_FUNC_QUALIFIER bool epsilonNotEqual(double const& x, double const& y, double const& epsilon)
(
double const & x,
double const & y,
double const & epsilon
)
{ {
return abs(x - y) >= epsilon; return abs(x - y) >= epsilon;
} }
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType> template<length_t L, typename T, precision P>
GLM_FUNC_QUALIFIER vecType<L, bool, P> epsilonEqual GLM_FUNC_QUALIFIER vec<L, bool, P> epsilonNotEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, T const& epsilon)
(
vecType<L, T, P> const& x,
vecType<L, T, P> const& y,
T const & epsilon
)
{ {
return lessThan(abs(x - y), vecType<L, T, P>(epsilon)); return greaterThanEqual(abs(x - y), vec<L, T, P>(epsilon));
} }
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType> template<length_t L, typename T, precision P>
GLM_FUNC_QUALIFIER vecType<L, bool, P> epsilonEqual GLM_FUNC_QUALIFIER vec<L, bool, P> epsilonNotEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, vec<L, T, P> const& epsilon)
(
vecType<L, T, P> const& x,
vecType<L, T, P> const& y,
vecType<L, T, P> const& epsilon
)
{ {
return lessThan(abs(x - y), vecType<L, T, P>(epsilon)); return greaterThanEqual(abs(x - y), vec<L, T, P>(epsilon));
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, bool, P> epsilonNotEqual
(
vecType<L, T, P> const& x,
vecType<L, T, P> const& y,
T const & epsilon
)
{
return greaterThanEqual(abs(x - y), vecType<L, T, P>(epsilon));
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, bool, P> epsilonNotEqual
(
vecType<L, T, P> const& x,
vecType<L, T, P> const& y,
vecType<L, T, P> const& epsilon
)
{
return greaterThanEqual(abs(x - y), vecType<L, T, P>(epsilon));
} }
template<typename T, precision P> template<typename T, precision P>
GLM_FUNC_QUALIFIER vec<4, bool, P> epsilonEqual GLM_FUNC_QUALIFIER vec<4, bool, P> epsilonEqual(tquat<T, P> const& x, tquat<T, P> const & y, T const& epsilon)
(
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & epsilon
)
{ {
vec<4, T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); vec<4, T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
return lessThan(abs(v), vec<4, T, P>(epsilon)); return lessThan(abs(v), vec<4, T, P>(epsilon));
} }
template<typename T, precision P> template<typename T, precision P>
GLM_FUNC_QUALIFIER vec<4, bool, P> epsilonNotEqual GLM_FUNC_QUALIFIER vec<4, bool, P> epsilonNotEqual(tquat<T, P> const& x, tquat<T, P> const& y, T const& epsilon)
(
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & epsilon
)
{ {
vec<4, T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); vec<4, T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
return greaterThanEqual(abs(v), vec<4, T, P>(epsilon)); return greaterThanEqual(abs(v), vec<4, T, P>(epsilon));

76
test/core/core_func_exponential.cpp
View File

@ -1,24 +1,35 @@
#include <glm/common.hpp> #include <glm/common.hpp>
#include <glm/exponential.hpp> #include <glm/exponential.hpp>
#include <glm/gtc/epsilon.hpp>
#include <glm/gtc/constants.hpp>
#include <glm/gtc/ulp.hpp> #include <glm/gtc/ulp.hpp>
#include <glm/gtc/vec1.hpp> #include <glm/gtc/vec1.hpp>
int test_pow() static int test_pow()
{ {
int Error(0); int Error(0);
float A = glm::pow(10.f, 10.f); float A = glm::pow(2.f, 2.f);
glm::vec1 B = glm::pow(glm::vec1(10.f), glm::vec1(10.f)); Error += glm::epsilonEqual(A, 4.f, 0.01f) ? 0 : 1;
glm::vec2 C = glm::pow(glm::vec2(10.f), glm::vec2(10.f));
glm::vec3 D = glm::pow(glm::vec3(10.f), glm::vec3(10.f)); glm::vec1 B = glm::pow(glm::vec1(2.f), glm::vec1(2.f));
glm::vec4 E = glm::pow(glm::vec4(10.f), glm::vec4(10.f)); Error += glm::all(glm::epsilonEqual(B, glm::vec1(4.f), 0.01f)) ? 0 : 1;
glm::vec2 C = glm::pow(glm::vec2(2.f), glm::vec2(2.f));
Error += glm::all(glm::epsilonEqual(C, glm::vec2(4.f), 0.01f)) ? 0 : 1;
glm::vec3 D = glm::pow(glm::vec3(2.f), glm::vec3(2.f));
Error += glm::all(glm::epsilonEqual(D, glm::vec3(4.f), 0.01f)) ? 0 : 1;
glm::vec4 E = glm::pow(glm::vec4(2.f), glm::vec4(2.f));
Error += glm::all(glm::epsilonEqual(E, glm::vec4(4.f), 0.01f)) ? 0 : 1;
return Error; return Error;
} }
int test_exp() static int test_exp()
{ {
int Error(0); int Error = 0;
float A = glm::exp(10.f); float A = glm::exp(10.f);
glm::vec1 B = glm::exp(glm::vec1(10.f)); glm::vec1 B = glm::exp(glm::vec1(10.f));
@ -29,22 +40,31 @@ int test_exp()
return Error; return Error;
} }
int test_log() static int test_log()
{ {
int Error(0); int Error = 0;
float A = glm::log(10.f); float const A = glm::log(glm::e<float>());
glm::vec1 B = glm::log(glm::vec1(10.f)); Error += glm::epsilonEqual(A, 1.f, 0.01f) ? 0 : 1;
glm::vec2 C = glm::log(glm::vec2(10.f));
glm::vec3 D = glm::log(glm::vec3(10.f)); glm::vec1 const B = glm::log(glm::vec1(glm::e<float>()));
glm::vec4 E = glm::log(glm::vec4(10.f)); Error += glm::all(glm::epsilonEqual(B, glm::vec1(1.f), 0.01f)) ? 0 : 1;
glm::vec2 const C = glm::log(glm::vec2(glm::e<float>()));
Error += glm::all(glm::epsilonEqual(B, glm::vec2(1.f), 0.01f)) ? 0 : 1;
glm::vec3 const D = glm::log(glm::vec3(glm::e<float>()));
Error += glm::all(glm::epsilonEqual(B, glm::vec3(1.f), 0.01f)) ? 0 : 1;
glm::vec4 const E = glm::log(glm::vec4(glm::e<float>()));
Error += glm::all(glm::epsilonEqual(B, glm::vec4(1.f), 0.01f)) ? 0 : 1;
return Error; return Error;
} }
int test_exp2() static int test_exp2()
{ {
int Error(0); int Error = 0;
float A = glm::exp2(10.f); float A = glm::exp2(10.f);
glm::vec1 B = glm::exp2(glm::vec1(10.f)); glm::vec1 B = glm::exp2(glm::vec1(10.f));
@ -55,9 +75,9 @@ int test_exp2()
return Error; return Error;
} }
int test_log2() static int test_log2()
{ {
int Error(0); int Error = 0;
float A = glm::log2(10.f); float A = glm::log2(10.f);
glm::vec1 B = glm::log2(glm::vec1(10.f)); glm::vec1 B = glm::log2(glm::vec1(10.f));
@ -68,9 +88,9 @@ int test_log2()
return Error; return Error;
} }
int test_sqrt() static int test_sqrt()
{ {
int Error(0); int Error = 0;
# if GLM_ARCH & GLM_ARCH_SSE2_BIT # if GLM_ARCH & GLM_ARCH_SSE2_BIT
for(float f = 0.1f; f < 30.0f; f += 0.1f) for(float f = 0.1f; f < 30.0f; f += 0.1f)
@ -91,9 +111,9 @@ int test_sqrt()
return Error; return Error;
} }
int test_inversesqrt() static int test_inversesqrt()
{ {
int Error(0); int Error = 0;
glm::uint ulp(0); glm::uint ulp(0);
float diff(0.0f); float diff(0.0f);
@ -114,19 +134,15 @@ int test_inversesqrt()
int main() int main()
{ {
int Error(0); int Error = 0;
#if !(GLM_COMPILER & GLM_COMPILER_GCC)
Error += test_pow(); Error += test_pow();
Error += test_exp(); Error += test_exp();
Error += test_log(); Error += test_log();
Error += test_exp2(); Error += test_exp2();
Error += test_log2(); Error += test_log2();
Error += test_sqrt(); //Error += test_sqrt();
Error += test_inversesqrt(); //Error += test_inversesqrt();
#endif//GLM_COMPILER & GLM_COMPILER_GCC
return Error; return Error;
} }