diff --git a/glm/gtc/vec1.hpp b/glm/gtc/vec1.hpp index 29370b30..9ff69cfb 100644 --- a/glm/gtc/vec1.hpp +++ b/glm/gtc/vec1.hpp @@ -74,7 +74,7 @@ namespace glm /// 1 component vector of low precision floating-point numbers. /// There is no guarantee on the actual precision. /// @see gtc_vec1 extension. - typedef lowp_dvec1_t lowp_dvec1; + typedef lowp_dvec1_t lowp_dvec1; /// 1 component vector of high precision signed integer numbers. /// There is no guarantee on the actual precision. diff --git a/test/core/core_func_integer_bit_count.cpp b/test/core/core_func_integer_bit_count.cpp index bc9124d4..2e9d748a 100644 --- a/test/core/core_func_integer_bit_count.cpp +++ b/test/core/core_func_integer_bit_count.cpp @@ -5,9 +5,10 @@ #include //To define "exit", req'd by XLC. #include -unsigned rotatel(unsigned x, int n) { - if ((unsigned)n > 63) {printf("rotatel, n out of range.\n"); exit(1);} - return (x << n) | (x >> (32 - n)); +unsigned rotatel(unsigned x, int n) +{ + if ((unsigned)n > 63) {printf("rotatel, n out of range.\n"); exit(1);} + return (x << n) | (x >> (32 - n)); } int pop0(unsigned x) @@ -20,45 +21,49 @@ int pop0(unsigned x) return x; } -int pop1(unsigned x) { - x = x - ((x >> 1) & 0x55555555); - x = (x & 0x33333333) + ((x >> 2) & 0x33333333); - x = (x + (x >> 4)) & 0x0F0F0F0F; - x = x + (x >> 8); - x = x + (x >> 16); - return x & 0x0000003F; +int pop1(unsigned x) +{ + x = x - ((x >> 1) & 0x55555555); + x = (x & 0x33333333) + ((x >> 2) & 0x33333333); + x = (x + (x >> 4)) & 0x0F0F0F0F; + x = x + (x >> 8); + x = x + (x >> 16); + return x & 0x0000003F; } /* Note: an alternative to the last three executable lines above is: return x*0x01010101 >> 24; if your machine has a fast multiplier (suggested by Jari Kirma). */ -int pop2(unsigned x) { - unsigned n; - - n = (x >> 1) & 033333333333; // Count bits in - x = x - n; // each 3-bit - n = (n >> 1) & 033333333333; // field. - x = x - n; - x = (x + (x >> 3)) & 030707070707; // 6-bit sums. - return x%63; // Add 6-bit sums. +int pop2(unsigned x) +{ + unsigned n; + + n = (x >> 1) & 033333333333; // Count bits in + x = x - n; // each 3-bit + n = (n >> 1) & 033333333333; // field. + x = x - n; + x = (x + (x >> 3)) & 030707070707; // 6-bit sums. + return x%63; // Add 6-bit sums. } + /* An alternative to the "return" statement above is: return ((x * 0404040404) >> 26) + // Add 6-bit sums. (x >> 30); which runs faster on most machines (suggested by Norbert Juffa). */ -int pop3(unsigned x) { - unsigned n; - - n = (x >> 1) & 0x77777777; // Count bits in - x = x - n; // each 4-bit - n = (n >> 1) & 0x77777777; // field. - x = x - n; - n = (n >> 1) & 0x77777777; - x = x - n; - x = (x + (x >> 4)) & 0x0F0F0F0F; // Get byte sums. - x = x*0x01010101; // Add the bytes. - return x >> 24; +int pop3(unsigned x) +{ + unsigned n; + + n = (x >> 1) & 0x77777777; // Count bits in + x = x - n; // each 4-bit + n = (n >> 1) & 0x77777777; // field. + x = x - n; + n = (n >> 1) & 0x77777777; + x = x - n; + x = (x + (x >> 4)) & 0x0F0F0F0F; // Get byte sums. + x = x*0x01010101; // Add the bytes. + return x >> 24; } int pop4(unsigned x) @@ -101,67 +106,72 @@ int pop5a(unsigned x) return sum; } -int pop6(unsigned x) { // Table lookup. - static char table[256] = { - 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8}; - - return table[x & 0xFF] + - table[(x >> 8) & 0xFF] + - table[(x >> 16) & 0xFF] + - table[(x >> 24)]; +int pop6(unsigned x) +{ // Table lookup. + static char table[256] = { + 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + + 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, + 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8}; + + return table[x & 0xFF] + + table[(x >> 8) & 0xFF] + + table[(x >> 16) & 0xFF] + + table[(x >> 24)]; } // The following works only for 8-bit quantities. -int pop7(unsigned x) { - x = x*0x08040201; // Make 4 copies. - x = x >> 3; // So next step hits proper bits. - x = x & 0x11111111; // Every 4th bit. - x = x*0x11111111; // Sum the digits (each 0 or 1). - x = x >> 28; // Position the result. - return x; +int pop7(unsigned x) +{ + x = x*0x08040201; // Make 4 copies. + x = x >> 3; // So next step hits proper bits. + x = x & 0x11111111; // Every 4th bit. + x = x*0x11111111; // Sum the digits (each 0 or 1). + x = x >> 28; // Position the result. + return x; } // The following works only for 7-bit quantities. -int pop8(unsigned x) { - x = x*0x02040810; // Make 4 copies, left-adjusted. - x = x & 0x11111111; // Every 4th bit. - x = x*0x11111111; // Sum the digits (each 0 or 1). - x = x >> 28; // Position the result. - return x; +int pop8(unsigned x) +{ + x = x*0x02040810; // Make 4 copies, left-adjusted. + x = x & 0x11111111; // Every 4th bit. + x = x*0x11111111; // Sum the digits (each 0 or 1). + x = x >> 28; // Position the result. + return x; } // The following works only for 15-bit quantities. -int pop9(unsigned x) { - unsigned long long y; - y = x * 0x0002000400080010ULL; - y = y & 0x1111111111111111ULL; - y = y * 0x1111111111111111ULL; - y = y >> 60; - return y; +int pop9(unsigned x) +{ + unsigned long long y; + y = x * 0x0002000400080010ULL; + y = y & 0x1111111111111111ULL; + y = y * 0x1111111111111111ULL; + y = y >> 60; + return y; } int errors; -void error(int x, int y) { - errors = errors + 1; - printf("Error for x = %08x, got %08x\n", x, y); +void error(int x, int y) +{ + errors = errors + 1; + printf("Error for x = %08x, got %08x\n", x, y); } int main() diff --git a/test/core/core_type_vec1.cpp b/test/core/core_type_vec1.cpp index d32d4be8..3a33cad1 100644 --- a/test/core/core_type_vec1.cpp +++ b/test/core/core_type_vec1.cpp @@ -52,7 +52,6 @@ int test_vec1_ctor() Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; - Error += std::has_trivial_copy_constructor::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; #endif diff --git a/test/core/core_type_vec2.cpp b/test/core/core_type_vec2.cpp index 5a797cb8..f0142786 100644 --- a/test/core/core_type_vec2.cpp +++ b/test/core/core_type_vec2.cpp @@ -11,6 +11,7 @@ #include #include #include +#include int test_vec2_operators() { @@ -209,7 +210,6 @@ int test_vec2_ctor() Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; - Error += std::has_trivial_copy_constructor::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; #endif diff --git a/test/core/core_type_vec3.cpp b/test/core/core_type_vec3.cpp index f2fe3ad2..7e49244c 100644 --- a/test/core/core_type_vec3.cpp +++ b/test/core/core_type_vec3.cpp @@ -28,7 +28,6 @@ int test_vec3_ctor() Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; - Error += std::has_trivial_copy_constructor::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; #endif diff --git a/test/core/core_type_vec4.cpp b/test/core/core_type_vec4.cpp index 3bd25f40..9fb11e09 100644 --- a/test/core/core_type_vec4.cpp +++ b/test/core/core_type_vec4.cpp @@ -43,9 +43,11 @@ int test_vec4_ctor() { int Error = 0; - glm::ivec4 A(1, 2, 3, 4); - glm::ivec4 B(A); - Error += glm::all(glm::equal(A, B)) ? 0 : 1; + { + glm::ivec4 A(1, 2, 3, 4); + glm::ivec4 B(A); + Error += glm::all(glm::equal(A, B)) ? 0 : 1; + } #if (GLM_LANG & GLM_LANG_CXX11_FLAG) || (GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12) // Error += std::is_trivially_default_constructible::value ? 0 : 1; @@ -55,7 +57,6 @@ int test_vec4_ctor() Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; - Error += std::has_trivial_copy_constructor::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; #endif diff --git a/test/gtc/gtc_quaternion.cpp b/test/gtc/gtc_quaternion.cpp index 6f897e9f..a7d39f19 100644 --- a/test/gtc/gtc_quaternion.cpp +++ b/test/gtc/gtc_quaternion.cpp @@ -281,8 +281,6 @@ int test_quat_ctr() Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; - Error += std::has_trivial_copy_constructor::value ? 0 : 1; - Error += std::has_trivial_copy_constructor::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; #endif diff --git a/test/gtc/gtc_random.cpp b/test/gtc/gtc_random.cpp index 7429554f..19303826 100644 --- a/test/gtc/gtc_random.cpp +++ b/test/gtc/gtc_random.cpp @@ -194,10 +194,10 @@ int test_linearRand() for(std::size_t i = 0; i < 100000; ++i) { - glm::f32vec2 const A(glm::linearRand(glm::f32vec2(Min), glm::f32vec2(Max))); - if(!glm::all(glm::lessThanEqual(A, glm::f32vec2(Max)))) + glm::f32vec2 const A(glm::linearRand(glm::f32vec2(static_cast(Min)), glm::f32vec2(static_cast(Max)))); + if(!glm::all(glm::lessThanEqual(A, glm::f32vec2(static_cast(Max))))) ++Error; - if(!glm::all(glm::greaterThanEqual(A, glm::f32vec2(Min)))) + if(!glm::all(glm::greaterThanEqual(A, glm::f32vec2(static_cast(Min))))) ++Error; glm::f64vec2 const B(glm::linearRand(glm::f64vec2(Min), glm::f64vec2(Max))); diff --git a/test/gtx/gtx_dual_quaternion.cpp b/test/gtx/gtx_dual_quaternion.cpp index 38d72360..53608aaa 100644 --- a/test/gtx/gtx_dual_quaternion.cpp +++ b/test/gtx/gtx_dual_quaternion.cpp @@ -174,8 +174,6 @@ int test_dual_quat_ctr() Error += std::is_trivially_copyable::value ? 0 : 1; Error += std::is_trivially_copyable::value ? 0 : 1; - Error += std::has_trivial_copy_constructor::value ? 0 : 1; - Error += std::has_trivial_copy_constructor::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; Error += std::is_copy_constructible::value ? 0 : 1; #endif