anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Rely on STL functions for GLM functions using the same prototype #233

Browse Source
master
Christophe Riccio ago%!(EXTRA string=11 years)
parent 4a701c6760
commit ac3c2e37f1
8 changed files with 287 additions and 150 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 13
      glm/detail/_vectorize.hpp
  2. 157
      glm/detail/func_common.inl
  3. 23
      glm/detail/func_exponential.inl
  4. 2
      glm/detail/func_trigonometric.hpp
  5. 117
      glm/detail/func_trigonometric.inl
  6. 114
      test/core/core_func_exponential.cpp
  7. 2
      test/core/core_func_trigonometric.cpp
  8. 1
      test/gtx/gtx_integer.cpp

13
glm/detail/_vectorize.hpp
Unescape View File

@ -141,6 +141,18 @@
VECTORIZE3_VEC_SCA(func) \ VECTORIZE3_VEC_SCA(func) \
VECTORIZE4_VEC_SCA(func) VECTORIZE4_VEC_SCA(func)
#define VECTORIZE1_VEC_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec1<T, P> func \
( \
detail::tvec1<T, P> const & x, \
detail::tvec1<T, P> const & y \
) \
{ \
return detail::tvec1<T, P>( \
func(x.x, y.x)); \
}
#define VECTORIZE2_VEC_VEC(func) \ #define VECTORIZE2_VEC_VEC(func) \
template <typename T, precision P> \ template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec2<T, P> func \ GLM_FUNC_QUALIFIER detail::tvec2<T, P> func \
@ -184,6 +196,7 @@
} }
#define VECTORIZE_VEC_VEC(func) \ #define VECTORIZE_VEC_VEC(func) \
VECTORIZE1_VEC_VEC(func) \
VECTORIZE2_VEC_VEC(func) \ VECTORIZE2_VEC_VEC(func) \
VECTORIZE3_VEC_VEC(func) \ VECTORIZE3_VEC_VEC(func) \
VECTORIZE4_VEC_VEC(func) VECTORIZE4_VEC_VEC(func)

157
glm/detail/func_common.inl
Unescape View File

@ -254,6 +254,8 @@ namespace detail
VECTORIZE_VEC(roundEven) VECTORIZE_VEC(roundEven)
// ceil // ceil
using std::ceil;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType ceil(genType const & x) GLM_FUNC_QUALIFIER genType ceil(genType const & x)
{ {
@ -263,7 +265,7 @@ namespace detail
return ::std::ceil(x); return ::std::ceil(x);
} }
*/
VECTORIZE_VEC(ceil) VECTORIZE_VEC(ceil)
// fract // fract
@ -273,9 +275,7 @@ namespace detail
genType const & x genType const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fract' only accept floating-point inputs");
std::numeric_limits<genType>::is_iec559,
"'fract' only accept floating-point inputs");
return x - floor(x); return x - floor(x);
} }
@ -290,9 +290,7 @@ namespace detail
genType const & y genType const & y
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'mod' only accept floating-point inputs");
std::numeric_limits<genType>::is_iec559,
"'mod' only accept floating-point inputs");
return x - y * floor(x / y); return x - y * floor(x / y);
} }
@ -308,9 +306,7 @@ namespace detail
genType & i genType & i
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'modf' only accept floating-point inputs");
std::numeric_limits<genType>::is_iec559,
"'modf' only accept floating-point inputs");
return std::modf(x, &i); return std::modf(x, &i);
} }
@ -573,9 +569,7 @@ namespace detail
vecType<T, P> const & x vecType<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'step' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'step' only accept floating-point inputs");
return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, vecType<T, P>(edge))); return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, vecType<T, P>(edge)));
} }
@ -589,9 +583,7 @@ namespace detail
genType const & x genType const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'smoothstep' only accept floating-point inputs");
std::numeric_limits<genType>::is_iec559,
"'smoothstep' only accept floating-point inputs");
genType tmp = clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1)); genType tmp = clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1));
return tmp * tmp * (genType(3) - genType(2) * tmp); return tmp * tmp * (genType(3) - genType(2) * tmp);
@ -605,9 +597,7 @@ namespace detail
detail::tvec2<T, P> const & x detail::tvec2<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec2<T, P>( return detail::tvec2<T, P>(
smoothstep(edge0, edge1, x.x), smoothstep(edge0, edge1, x.x),
@ -622,9 +612,7 @@ namespace detail
detail::tvec3<T, P> const & x detail::tvec3<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec3<T, P>( return detail::tvec3<T, P>(
smoothstep(edge0, edge1, x.x), smoothstep(edge0, edge1, x.x),
@ -640,9 +628,7 @@ namespace detail
detail::tvec4<T, P> const & x detail::tvec4<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec4<T, P>( return detail::tvec4<T, P>(
smoothstep(edge0, edge1, x.x), smoothstep(edge0, edge1, x.x),
@ -659,9 +645,7 @@ namespace detail
detail::tvec2<T, P> const & x detail::tvec2<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec2<T, P>( return detail::tvec2<T, P>(
smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.x, edge1.x, x.x),
@ -676,9 +660,7 @@ namespace detail
detail::tvec3<T, P> const & x detail::tvec3<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec3<T, P>( return detail::tvec3<T, P>(
smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.x, edge1.x, x.x),
@ -694,9 +676,7 @@ namespace detail
detail::tvec4<T, P> const & x detail::tvec4<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'smoothstep' only accept floating-point inputs");
return detail::tvec4<T, P>( return detail::tvec4<T, P>(
smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.x, edge1.x, x.x),
@ -709,9 +689,7 @@ namespace detail
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER bool isnan(genType const & x) GLM_FUNC_QUALIFIER bool isnan(genType const & x)
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isnan' only accept floating-point inputs");
std::numeric_limits<genType>::is_iec559,
"'isnan' only accept floating-point inputs");
# if(GLM_LANG & GLM_LANG_CXX11_FLAG) # if(GLM_LANG & GLM_LANG_CXX11_FLAG)
return std::isnan(x); return std::isnan(x);
@ -730,15 +708,25 @@ namespace detail
# endif # endif
} }
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec1<T, P>::bool_type isnan
(
detail::tvec1<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
return typename detail::tvec1<T, P>::bool_type(
isnan(x.x));
}
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isnan GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isnan
( (
detail::tvec2<T, P> const & x detail::tvec2<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'isnan' only accept floating-point inputs");
return typename detail::tvec2<T, P>::bool_type( return typename detail::tvec2<T, P>::bool_type(
isnan(x.x), isnan(x.x),
@ -751,9 +739,7 @@ namespace detail
detail::tvec3<T, P> const & x detail::tvec3<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'isnan' only accept floating-point inputs");
return typename detail::tvec3<T, P>::bool_type( return typename detail::tvec3<T, P>::bool_type(
isnan(x.x), isnan(x.x),
@ -767,9 +753,7 @@ namespace detail
detail::tvec4<T, P> const & x detail::tvec4<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'isnan' only accept floating-point inputs");
return typename detail::tvec4<T, P>::bool_type( return typename detail::tvec4<T, P>::bool_type(
isnan(x.x), isnan(x.x),
@ -802,15 +786,25 @@ namespace detail
# endif # endif
} }
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec1<T, P>::bool_type isinf
(
detail::tvec1<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
return typename detail::tvec1<T, P>::bool_type(
isinf(x.x));
}
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isinf GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isinf
( (
detail::tvec2<T, P> const & x detail::tvec2<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'isinf' only accept floating-point inputs");
return typename detail::tvec2<T, P>::bool_type( return typename detail::tvec2<T, P>::bool_type(
isinf(x.x), isinf(x.x),
@ -823,9 +817,7 @@ namespace detail
detail::tvec3<T, P> const & x detail::tvec3<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'isinf' only accept floating-point inputs");
return typename detail::tvec3<T, P>::bool_type( return typename detail::tvec3<T, P>::bool_type(
isinf(x.x), isinf(x.x),
@ -839,9 +831,7 @@ namespace detail
detail::tvec4<T, P> const & x detail::tvec4<T, P> const & x
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'isinf' only accept floating-point inputs");
return typename detail::tvec4<T, P>::bool_type( return typename detail::tvec4<T, P>::bool_type(
isinf(x.x), isinf(x.x),
@ -912,13 +902,23 @@ namespace detail
int & exp int & exp
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'frexp' only accept floating-point inputs");
std::numeric_limits<genType>::is_iec559,
"'frexp' only accept floating-point inputs");
return std::frexp(x, exp); return std::frexp(x, exp);
} }
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec1<T, P> frexp
(
detail::tvec1<T, P> const & x,
detail::tvec1<int, P> & exp
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
return detail::tvec1<T, P>(std::frexp(x.x, exp.x));
}
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> frexp GLM_FUNC_QUALIFIER detail::tvec2<T, P> frexp
( (
@ -926,9 +926,7 @@ namespace detail
detail::tvec2<int, P> & exp detail::tvec2<int, P> & exp
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'frexp' only accept floating-point inputs");
return detail::tvec2<T, P>( return detail::tvec2<T, P>(
frexp(x.x, exp.x), frexp(x.x, exp.x),
@ -942,9 +940,7 @@ namespace detail
detail::tvec3<int, P> & exp detail::tvec3<int, P> & exp
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'frexp' only accept floating-point inputs");
return detail::tvec3<T, P>( return detail::tvec3<T, P>(
frexp(x.x, exp.x), frexp(x.x, exp.x),
@ -959,9 +955,7 @@ namespace detail
detail::tvec4<int, P> & exp detail::tvec4<int, P> & exp
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'frexp' only accept floating-point inputs");
return detail::tvec4<T, P>( return detail::tvec4<T, P>(
frexp(x.x, exp.x), frexp(x.x, exp.x),
@ -977,13 +971,24 @@ namespace detail
int const & exp int const & exp
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'ldexp' only accept floating-point inputs");
std::numeric_limits<genType>::is_iec559,
"'frexp' only accept floating-point inputs");
return std::ldexp(x, exp); return std::ldexp(x, exp);
} }
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec1<T, P> ldexp
(
detail::tvec1<T, P> const & x,
detail::tvec1<int, P> const & exp
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
return detail::tvec1<T, P>(
ldexp(x.x, exp.x));
}
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> ldexp GLM_FUNC_QUALIFIER detail::tvec2<T, P> ldexp
( (
@ -991,9 +996,7 @@ namespace detail
detail::tvec2<int, P> const & exp detail::tvec2<int, P> const & exp
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'ldexp' only accept floating-point inputs");
return detail::tvec2<T, P>( return detail::tvec2<T, P>(
ldexp(x.x, exp.x), ldexp(x.x, exp.x),
@ -1007,9 +1010,7 @@ namespace detail
detail::tvec3<int, P> const & exp detail::tvec3<int, P> const & exp
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'ldexp' only accept floating-point inputs");
return detail::tvec3<T, P>( return detail::tvec3<T, P>(
ldexp(x.x, exp.x), ldexp(x.x, exp.x),
@ -1024,9 +1025,7 @@ namespace detail
detail::tvec4<int, P> const & exp detail::tvec4<int, P> const & exp
) )
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
std::numeric_limits<T>::is_iec559,
"'ldexp' only accept floating-point inputs");
return detail::tvec4<T, P>( return detail::tvec4<T, P>(
ldexp(x.x, exp.x), ldexp(x.x, exp.x),

23
glm/detail/func_exponential.inl
Unescape View File

@ -29,6 +29,7 @@
#include "func_vector_relational.hpp" #include "func_vector_relational.hpp"
#include "_vectorize.hpp" #include "_vectorize.hpp"
#include <limits> #include <limits>
#include <cmath>
#include <cassert> #include <cassert>
namespace glm{ namespace glm{
@ -47,7 +48,11 @@ namespace detail
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER T operator() (T const & Value) const GLM_FUNC_QUALIFIER T operator() (T const & Value) const
{ {
return static_cast<T>(::std::log(Value)) * static_cast<T>(1.4426950408889634073599246810019); # if(GLM_LANG & GLM_LANG_CXX11_FLAG)
return std::log2(Value);
# else
return std::log(Value) * static_cast<T>(1.4426950408889634073599246810019);
# endif
} }
}; };
@ -78,6 +83,9 @@ namespace detail
}//namespace detail }//namespace detail
// pow // pow
using std::pow;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType pow GLM_FUNC_QUALIFIER genType pow
( (
@ -91,10 +99,14 @@ namespace detail
return std::pow(x, y); return std::pow(x, y);
} }
*/
VECTORIZE_VEC_VEC(pow) VECTORIZE_VEC_VEC(pow)
// exp // exp
using std::exp;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType exp GLM_FUNC_QUALIFIER genType exp
( (
@ -107,10 +119,13 @@ namespace detail
return std::exp(x); return std::exp(x);
} }
*/
VECTORIZE_VEC(exp) VECTORIZE_VEC(exp)
// log // log
using std::log;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType log GLM_FUNC_QUALIFIER genType log
( (
@ -123,7 +138,7 @@ namespace detail
return std::log(x); return std::log(x);
} }
*/
VECTORIZE_VEC(log) VECTORIZE_VEC(log)
//exp2, ln2 = 0.69314718055994530941723212145818f //exp2, ln2 = 0.69314718055994530941723212145818f
@ -195,6 +210,8 @@ namespace detail
}//namespace detail }//namespace detail
// sqrt // sqrt
using std::sqrt;
/*
GLM_FUNC_QUALIFIER float sqrt(float x) GLM_FUNC_QUALIFIER float sqrt(float x)
{ {
# ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6 # ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
@ -214,7 +231,7 @@ namespace detail
return detail::compute_sqrt<detail::tvec1, double, highp>::call(x).x; return detail::compute_sqrt<detail::tvec1, double, highp>::call(x).x;
# endif # endif
} }
*/
template <typename T, precision P, template <typename, precision> class vecType> template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x) GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
{ {

2
glm/detail/func_trigonometric.hpp
Unescape View File

@ -39,6 +39,8 @@
#pragma once #pragma once
#include "setup.hpp"
namespace glm namespace glm
{ {
/// @addtogroup core_func_trigonometric /// @addtogroup core_func_trigonometric

117
glm/detail/func_trigonometric.inl
Unescape View File

@ -61,6 +61,8 @@ namespace glm
VECTORIZE_VEC(degrees) VECTORIZE_VEC(degrees)
// sin // sin
using std::sin;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType sin GLM_FUNC_QUALIFIER genType sin
( (
@ -71,10 +73,12 @@ namespace glm
return genType(::std::sin(angle)); return genType(::std::sin(angle));
} }
*/
VECTORIZE_VEC(sin) VECTORIZE_VEC(sin)
// cos // cos
using std::cos;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType cos(genType const & angle) GLM_FUNC_QUALIFIER genType cos(genType const & angle)
{ {
@ -82,10 +86,13 @@ namespace glm
return genType(::std::cos(angle)); return genType(::std::cos(angle));
} }
*/
VECTORIZE_VEC(cos) VECTORIZE_VEC(cos)
// tan // tan
using std::tan;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType tan GLM_FUNC_QUALIFIER genType tan
( (
@ -96,10 +103,13 @@ namespace glm
return genType(::std::tan(angle)); return genType(::std::tan(angle));
} }
*/
VECTORIZE_VEC(tan) VECTORIZE_VEC(tan)
// asin // asin
using std::asin;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType asin GLM_FUNC_QUALIFIER genType asin
( (
@ -110,10 +120,12 @@ namespace glm
return genType(::std::asin(x)); return genType(::std::asin(x));
} }
*/
VECTORIZE_VEC(asin) VECTORIZE_VEC(asin)
// acos // acos
using std::acos;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType acos GLM_FUNC_QUALIFIER genType acos
( (
@ -122,9 +134,9 @@ namespace glm
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acos' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acos' only accept floating-point input");
return genType(::std::acos(x)); return ::std::acos(x);
} }
*/
VECTORIZE_VEC(acos) VECTORIZE_VEC(acos)
// atan // atan
@ -137,11 +149,13 @@ namespace glm
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input");
return genType(::std::atan2(y, x)); return ::std::atan2(y, x);
} }
VECTORIZE_VEC_VEC(atan) VECTORIZE_VEC_VEC(atan)
using std::atan;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType atan GLM_FUNC_QUALIFIER genType atan
( (
@ -150,12 +164,14 @@ namespace glm
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input");
return genType(::std::atan(x)); return ::std::atan(x);
} }
*/
VECTORIZE_VEC(atan) VECTORIZE_VEC(atan)
// sinh // sinh
using std::sinh;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType sinh GLM_FUNC_QUALIFIER genType sinh
( (
@ -164,12 +180,14 @@ namespace glm
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'sinh' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'sinh' only accept floating-point input");
return genType(std::sinh(angle)); return ::std::sinh(angle);
} }
*/
VECTORIZE_VEC(sinh) VECTORIZE_VEC(sinh)
// cosh // cosh
using std::cosh;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType cosh GLM_FUNC_QUALIFIER genType cosh
( (
@ -178,12 +196,14 @@ namespace glm
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'cosh' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'cosh' only accept floating-point input");
return genType(std::cosh(angle)); return ::std::cosh(angle);
} }
*/
VECTORIZE_VEC(cosh) VECTORIZE_VEC(cosh)
// tanh // tanh
using std::tanh;
/*
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType tanh GLM_FUNC_QUALIFIER genType tanh
( (
@ -192,54 +212,57 @@ namespace glm
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'tanh' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'tanh' only accept floating-point input");
return genType(std::tanh(angle)); return ::std::tanh(angle);
} }
*/
VECTORIZE_VEC(tanh) VECTORIZE_VEC(tanh)
// asinh // asinh
template <typename genType> # if(GLM_LANG & GLM_LANG_CXX11_FLAG)
GLM_FUNC_QUALIFIER genType asinh using std::asinh;
( # else
genType const & x template <typename genType>
) GLM_FUNC_QUALIFIER genType asinh(genType const & x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asinh' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asinh' only accept floating-point input");
return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x)); return (x < static_cast<genType>(0) ? static_cast<genType>(-1) : (x > static_cast<genType>(0) ? static_cast<genType>(1) : static_cast<genType>(0))) * log(abs(x) + sqrt(static_cast<genType>(1) + x * x));
} }
# endif
VECTORIZE_VEC(asinh) VECTORIZE_VEC(asinh)
// acosh // acosh
template <typename genType> # if(GLM_LANG & GLM_LANG_CXX11_FLAG)
GLM_FUNC_QUALIFIER genType acosh using std::acosh;
( # else
genType const & x template <typename genType>
) GLM_FUNC_QUALIFIER genType acosh(genType const & x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acosh' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acosh' only accept floating-point input");
if(x < genType(1)) if(x < static_cast<genType>(1))
return genType(0); return static_cast<genType>(0);
return log(x + sqrt(x * x - genType(1))); return log(x + sqrt(x * x - static_cast<genType>(1)));
} }
# endif
VECTORIZE_VEC(acosh) VECTORIZE_VEC(acosh)
// atanh // atanh
template <typename genType> # if(GLM_LANG & GLM_LANG_CXX11_FLAG)
GLM_FUNC_QUALIFIER genType atanh using std::atanh;
( # else
genType const & x template <typename genType>
) GLM_FUNC_QUALIFIER genType atanh(genType const & x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atanh' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atanh' only accept floating-point input");
if(abs(x) >= genType(1)) if(abs(x) >= static_cast<genType>(1))
return 0; return 0;
return genType(0.5) * log((genType(1) + x) / (genType(1) - x)); return static_cast<genType>(0.5) * log((static_cast<genType>(1) + x) / (static_cast<genType>(1) - x));
} }
# endif
VECTORIZE_VEC(atanh) VECTORIZE_VEC(atanh)

114
test/core/core_func_exponential.cpp
Unescape View File

@ -10,34 +10,116 @@
#include <glm/common.hpp> #include <glm/common.hpp>
#include <glm/exponential.hpp> #include <glm/exponential.hpp>
#include <glm/gtc/ulp.hpp> #include <glm/gtc/ulp.hpp>
#include <glm/gtx/vec1.hpp>
namespace inversesqrt int test_pow()
{ {
int test() int Error(0);
{
int Error(0); float A = glm::pow(10.f, 10.f);
glm::vec1 B = glm::pow(glm::vec1(10.f), glm::vec1(10.f));
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::vec4 E = glm::pow(glm::vec4(10.f), glm::vec4(10.f));
return Error;
}
int test_exp()
{
int Error(0);
float A = glm::exp(10.f);
glm::vec1 B = glm::exp(glm::vec1(10.f));
glm::vec2 C = glm::exp(glm::vec2(10.f));
glm::vec3 D = glm::exp(glm::vec3(10.f));
glm::vec4 E = glm::exp(glm::vec4(10.f));
return Error;
}
int test_log()
{
int Error(0);
float A = glm::log(10.f);
glm::vec1 B = glm::log(glm::vec1(10.f));
glm::vec2 C = glm::log(glm::vec2(10.f));
glm::vec3 D = glm::log(glm::vec3(10.f));
glm::vec4 E = glm::log(glm::vec4(10.f));
return Error;
}
glm::uint ulp(0); int test_exp2()
float diff(0.0f); {
int Error(0);
for(float f = 0.001f; f < 10.f; f *= 1.001f) float A = glm::exp2(10.f);
{ glm::vec1 B = glm::exp2(glm::vec1(10.f));
glm::lowp_fvec1 lowp_v = glm::inversesqrt(glm::lowp_fvec1(f)); glm::vec2 C = glm::exp2(glm::vec2(10.f));
float defaultp_v = glm::inversesqrt(f); glm::vec3 D = glm::exp2(glm::vec3(10.f));
glm::vec4 E = glm::exp2(glm::vec4(10.f));
ulp = glm::max(glm::float_distance(lowp_v.x, defaultp_v), ulp); return Error;
diff = glm::abs(lowp_v.x - defaultp_v); }
}
return Error; int test_log2()
{
int Error(0);
float A = glm::log2(10.f);
glm::vec1 B = glm::log2(glm::vec1(10.f));
glm::vec2 C = glm::log2(glm::vec2(10.f));
glm::vec3 D = glm::log2(glm::vec3(10.f));
glm::vec4 E = glm::log2(glm::vec4(10.f));
return Error;
}
int test_sqrt()
{
int Error(0);
float A = glm::sqrt(10.f);
glm::vec1 B = glm::sqrt(glm::vec1(10.f));
glm::vec2 C = glm::sqrt(glm::vec2(10.f));
glm::vec3 D = glm::sqrt(glm::vec3(10.f));
glm::vec4 E = glm::sqrt(glm::vec4(10.f));
return Error;
}
int test_inversesqrt()
{
int Error(0);
glm::uint ulp(0);
float diff(0.0f);
for(float f = 0.001f; f < 10.f; f *= 1.001f)
{
glm::lowp_fvec1 lowp_v = glm::inversesqrt(glm::lowp_fvec1(f));
float defaultp_v = glm::inversesqrt(f);
ulp = glm::max(glm::float_distance(lowp_v.x, defaultp_v), ulp);
diff = glm::abs(lowp_v.x - defaultp_v);
} }
}//namespace inversesqrt
return Error;
}
int main() int main()
{ {
int Error(0); int Error(0);
Error += inversesqrt::test(); Error += test_pow();
Error += test_exp();
Error += test_log();
Error += test_exp2();
Error += test_log2();
Error += test_sqrt();
Error += test_inversesqrt();
return Error; return Error;
} }

2
test/core/core_func_trigonometric.cpp
Unescape View File

@ -7,7 +7,7 @@
// File : test/core/func_trigonometric.cpp // File : test/core/func_trigonometric.cpp
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
#include <glm/glm.hpp> #include <glm/trigonometric.hpp>
int main() int main()
{ {

1
test/gtx/gtx_integer.cpp
Unescape View File

@ -7,6 +7,7 @@
// File : test/gtx/gtx_integer.cpp // File : test/gtx/gtx_integer.cpp
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
#include <glm/exponential.hpp>
#include <glm/gtc/epsilon.hpp> #include <glm/gtc/epsilon.hpp>
#include <glm/gtx/integer.hpp> #include <glm/gtx/integer.hpp>
#include <cstdio> #include <cstdio>

Write Preview
Loading…
Cancel
Save