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

Fixed missing std:: namespace #898

Browse Source
master
Christophe Riccio ago%!(EXTRA string=6 years)
parent 823125a6cd
commit 61b2a73e21
17 changed files with 244 additions and 234 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      glm/gtx/string_cast.inl
  2. 32
      test/core/core_func_integer_bit_count.cpp
  3. 188
      test/core/core_func_integer_find_lsb.cpp
  4. 32
      test/core/core_func_integer_find_msb.cpp
  5. 2
      test/core/core_func_matrix.cpp
  6. 4
      test/core/core_type_vec4.cpp
  7. 10
      test/gtc/gtc_bitfield.cpp
  8. 14
      test/gtc/gtc_integer.cpp
  9. 26
      test/gtc/gtc_packing.cpp
  10. 4
      test/gtx/gtx_integer.cpp
  11. 18
      test/gtx/gtx_type_aligned.cpp
  12. 24
      test/perf/perf_matrix_div.cpp
  13. 24
      test/perf/perf_matrix_inverse.cpp
  14. 24
      test/perf/perf_matrix_mul.cpp
  15. 24
      test/perf/perf_matrix_mul_vector.cpp
  16. 24
      test/perf/perf_matrix_transpose.cpp
  17. 24
      test/perf/perf_vector_mul_matrix.cpp

4
glm/gtx/string_cast.inl
Unescape View File

@ -28,10 +28,10 @@ namespace detail
return std::string();
va_start(list, msg);
# if(GLM_COMPILER & GLM_COMPILER_VC)
# if (GLM_COMPILER & GLM_COMPILER_VC)
vsprintf_s(text, STRING_BUFFER, msg, list);
# else//
vsprintf(text, msg, list);
std::vsprintf(text, msg, list);
# endif//
va_end(list);

32
test/core/core_func_integer_bit_count.cpp
Unescape View File

@ -1,13 +1,13 @@
// This has the programs for computing the number of 1-bits
// in a word, or byte, etc.
// Max line length is 57, to fit in hacker.book.
#include <stdio.h>
#include <stdlib.h> //To define "exit", req'd by XLC.
#include <cstdio>
#include <cstdlib> //To define "exit", req'd by XLC.
#include <ctime>
unsigned rotatel(unsigned x, int n)
{
if (static_cast<unsigned>(n) > 63) {printf("rotatel, n out of range.\n"); exit(1);}
if (static_cast<unsigned>(n) > 63) { std::printf("rotatel, n out of range.\n"); std::exit(1);}
return (x << n) | (x >> (32 - n));
}
@ -171,7 +171,7 @@ int errors;
void error(int x, int y)
{
errors = errors + 1;
printf("Error for x = %08x, got %08x\n", x, y);
std::printf("Error for x = %08x, got %08x\n", x, y);
}
int main()
@ -199,7 +199,7 @@ int main()
if (pop0(test[i]) != test[i+1]) error(test[i], pop0(test[i]));}
TimestampEnd = std::clock();
printf("pop0: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop0: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -207,7 +207,7 @@ int main()
if (pop1(test[i]) != test[i+1]) error(test[i], pop1(test[i]));}
TimestampEnd = std::clock();
printf("pop1: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop1: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -215,7 +215,7 @@ int main()
if (pop2(test[i]) != test[i+1]) error(test[i], pop2(test[i]));}
TimestampEnd = std::clock();
printf("pop2: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop2: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -223,7 +223,7 @@ int main()
if (pop3(test[i]) != test[i+1]) error(test[i], pop3(test[i]));}
TimestampEnd = std::clock();
printf("pop3: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop3: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -231,7 +231,7 @@ int main()
if (pop4(test[i]) != test[i+1]) error(test[i], pop4(test[i]));}
TimestampEnd = std::clock();
printf("pop4: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop4: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -239,7 +239,7 @@ int main()
if (pop5(test[i]) != test[i+1]) error(test[i], pop5(test[i]));}
TimestampEnd = std::clock();
printf("pop5: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop5: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -247,7 +247,7 @@ int main()
if (pop5a(test[i]) != test[i+1]) error(test[i], pop5a(test[i]));}
TimestampEnd = std::clock();
printf("pop5a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop5a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -255,7 +255,7 @@ int main()
if (pop6(test[i]) != test[i+1]) error(test[i], pop6(test[i]));}
TimestampEnd = std::clock();
printf("pop6: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop6: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -264,7 +264,7 @@ int main()
if (pop7(test[i]) != test[i+1]) error(test[i], pop7(test[i]));}
TimestampEnd = std::clock();
printf("pop7: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop7: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -273,7 +273,7 @@ int main()
if (pop8(test[i]) != test[i+1]) error(test[i], pop8(test[i]));}
TimestampEnd = std::clock();
printf("pop8: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop8: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -282,10 +282,10 @@ int main()
if (pop9(test[i]) != test[i+1]) error(test[i], pop9(test[i]));}
TimestampEnd = std::clock();
printf("pop9: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("pop9: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
if (errors == 0)
printf("Passed all %d cases.\n", static_cast<int>(sizeof(test)/8));
std::printf("Passed all %d cases.\n", static_cast<int>(sizeof(test)/8));
# endif//NDEBUG
}

188
test/core/core_func_integer_find_lsb.cpp
Unescape View File

@ -3,72 +3,79 @@
#include <cstdlib> //To define "exit", req'd by XLC.
#include <ctime>
int nlz(unsigned x) {
int pop(unsigned x);
x = x | (x >> 1);
x = x | (x >> 2);
x = x | (x >> 4);
x = x | (x >> 8);
x = x | (x >>16);
return pop(~x);
int nlz(unsigned x)
{
int pop(unsigned x);
x = x | (x >> 1);
x = x | (x >> 2);
x = x | (x >> 4);
x = x | (x >> 8);
x = x | (x >>16);
return pop(~x);
}
int pop(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 >> 24;
int pop(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 >> 24;
}
int ntz1(unsigned x) {
return 32 - nlz(~x & (x-1));
int ntz1(unsigned x)
{
return 32 - nlz(~x & (x-1));
}
int ntz2(unsigned x) {
return pop(~x & (x - 1));
int ntz2(unsigned x)
{
return pop(~x & (x - 1));
}
int ntz3(unsigned x) {
int n;
if (x == 0) return(32);
n = 1;
if ((x & 0x0000FFFF) == 0) {n = n +16; x = x >>16;}
if ((x & 0x000000FF) == 0) {n = n + 8; x = x >> 8;}
if ((x & 0x0000000F) == 0) {n = n + 4; x = x >> 4;}
if ((x & 0x00000003) == 0) {n = n + 2; x = x >> 2;}
return n - (x & 1);
int ntz3(unsigned x)
{
int n;
if (x == 0) return(32);
n = 1;
if ((x & 0x0000FFFF) == 0) {n = n +16; x = x >>16;}
if ((x & 0x000000FF) == 0) {n = n + 8; x = x >> 8;}
if ((x & 0x0000000F) == 0) {n = n + 4; x = x >> 4;}
if ((x & 0x00000003) == 0) {n = n + 2; x = x >> 2;}
return n - (x & 1);
}
int ntz4(unsigned x) {
unsigned y;
int n;
if (x == 0) return 32;
n = 31;
y = x <<16; if (y != 0) {n = n -16; x = y;}
y = x << 8; if (y != 0) {n = n - 8; x = y;}
y = x << 4; if (y != 0) {n = n - 4; x = y;}
y = x << 2; if (y != 0) {n = n - 2; x = y;}
y = x << 1; if (y != 0) {n = n - 1;}
return n;
int ntz4(unsigned x)
{
unsigned y;
int n;
if (x == 0) return 32;
n = 31;
y = x <<16; if (y != 0) {n = n -16; x = y;}
y = x << 8; if (y != 0) {n = n - 8; x = y;}
y = x << 4; if (y != 0) {n = n - 4; x = y;}
y = x << 2; if (y != 0) {n = n - 2; x = y;}
y = x << 1; if (y != 0) {n = n - 1;}
return n;
}
int ntz4a(unsigned x) {
unsigned y;
int n;
if (x == 0) return 32;
n = 31;
y = x <<16; if (y != 0) {n = n -16; x = y;}
y = x << 8; if (y != 0) {n = n - 8; x = y;}
y = x << 4; if (y != 0) {n = n - 4; x = y;}
y = x << 2; if (y != 0) {n = n - 2; x = y;}
n = n - ((x << 1) >> 31);
return n;
int ntz4a(unsigned x)
{
unsigned y;
int n;
if (x == 0) return 32;
n = 31;
y = x <<16; if (y != 0) {n = n -16; x = y;}
y = x << 8; if (y != 0) {n = n - 8; x = y;}
y = x << 4; if (y != 0) {n = n - 4; x = y;}
y = x << 2; if (y != 0) {n = n - 2; x = y;}
n = n - ((x << 1) >> 31);
return n;
}
int ntz5(char x)
@ -90,16 +97,18 @@ int ntz5(char x)
else return 8;
}
int ntz6(unsigned x) {
int n;
x = ~x & (x - 1);
n = 0; // n = 32;
while(x != 0) { // while (x != 0) {
n = n + 1; // n = n - 1;
x = x >> 1; // x = x + x;
} // }
return n; // return n;
int ntz6(unsigned x)
{
int n;
x = ~x & (x - 1);
n = 0; // n = 32;
while(x != 0)
{ // while (x != 0) {
n = n + 1; // n = n - 1;
x = x >> 1; // x = x + x;
} // }
return n; // return n;
}
int ntz6a(unsigned x)
@ -201,15 +210,16 @@ int ntz8a(unsigned x)
/* Reiser's algorithm. Three ops including a "remainder,"
plus an indexed load. */
int ntz9(unsigned x) {
static char table[37] = {32, 0, 1, 26, 2, 23, 27,
u, 3, 16, 24, 30, 28, 11, u, 13, 4,
7, 17, u, 25, 22, 31, 15, 29, 10, 12,
6, u, 21, 14, 9, 5, 20, 8, 19, 18};
x = (x & -x)%37;
return table[x];
int ntz9(unsigned x)
{
static char table[37] = {
32, 0, 1, 26, 2, 23, 27,
u, 3, 16, 24, 30, 28, 11, u, 13, 4,
7, 17, u, 25, 22, 31, 15, 29, 10, 12,
6, u, 21, 14, 9, 5, 20, 8, 19, 18};
x = (x & -x)%37;
return table[x];
}
/* Using a de Bruijn sequence. This is a table lookup with a 32-entry
@ -257,7 +267,7 @@ int ntz11 (unsigned int n) {
int errors;
void error(int x, int y) {
errors = errors + 1;
printf("Error for x = %08x, got %d\n", x, y);
std::printf("Error for x = %08x, got %d\n", x, y);
}
int main()
@ -287,7 +297,7 @@ int main()
if (ntz1(test[i]) != test[i+1]) error(test[i], ntz1(test[i]));}
TimestampEnd = std::clock();
printf("ntz1: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz1: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -295,7 +305,7 @@ int main()
if (ntz2(test[i]) != test[i+1]) error(test[i], ntz2(test[i]));}
TimestampEnd = std::clock();
printf("ntz2: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz2: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -303,7 +313,7 @@ int main()
if (ntz3(test[i]) != test[i+1]) error(test[i], ntz3(test[i]));}
TimestampEnd = std::clock();
printf("ntz3: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz3: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -311,7 +321,7 @@ int main()
if (ntz4(test[i]) != test[i+1]) error(test[i], ntz4(test[i]));}
TimestampEnd = std::clock();
printf("ntz4: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz4: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -319,7 +329,7 @@ int main()
if (ntz4a(test[i]) != test[i+1]) error(test[i], ntz4a(test[i]));}
TimestampEnd = std::clock();
printf("ntz4a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz4a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for(std::size_t k = 0; k < Count; ++k)
@ -333,7 +343,7 @@ int main()
}
TimestampEnd = std::clock();
printf("ntz5: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz5: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -341,7 +351,7 @@ int main()
if (ntz6(test[i]) != test[i+1]) error(test[i], ntz6(test[i]));}
TimestampEnd = std::clock();
printf("ntz6: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz6: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -349,7 +359,7 @@ int main()
if (ntz6a(test[i]) != test[i+1]) error(test[i], ntz6a(test[i]));}
TimestampEnd = std::clock();
printf("ntz6a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz6a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -357,7 +367,7 @@ int main()
if (ntz7(test[i]) != test[i+1]) error(test[i], ntz7(test[i]));}
TimestampEnd = std::clock();
printf("ntz7: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz7: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -365,7 +375,7 @@ int main()
if (ntz7_christophe(test[i]) != test[i+1]) error(test[i], ntz7(test[i]));}
TimestampEnd = std::clock();
printf("ntz7_christophe: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz7_christophe: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -373,7 +383,7 @@ int main()
if (ntz8(test[i]) != test[i+1]) error(test[i], ntz8(test[i]));}
TimestampEnd = std::clock();
printf("ntz8: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz8: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -381,7 +391,7 @@ int main()
if (ntz8a(test[i]) != test[i+1]) error(test[i], ntz8a(test[i]));}
TimestampEnd = std::clock();
printf("ntz8a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz8a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -389,7 +399,7 @@ int main()
if (ntz9(test[i]) != test[i+1]) error(test[i], ntz9(test[i]));}
TimestampEnd = std::clock();
printf("ntz9: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz9: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -397,10 +407,10 @@ int main()
if (ntz10(test[i]) != test[i+1]) error(test[i], ntz10(test[i]));}
TimestampEnd = std::clock();
printf("ntz10: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("ntz10: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
if (errors == 0)
printf("Passed all %d cases.\n", static_cast<int>(sizeof(test)/8));
std::printf("Passed all %d cases.\n", static_cast<int>(sizeof(test)/8));
# endif//NDEBUG
}

32
test/core/core_func_integer_find_msb.cpp
Unescape View File

@ -298,7 +298,7 @@ int errors;
void error(int x, int y)
{
errors = errors + 1;
printf("Error for x = %08x, got %d\n", x, y);
std::printf("Error for x = %08x, got %d\n", x, y);
}
int main()
@ -327,7 +327,7 @@ int main()
if (nlz1(test[i]) != test[i+1]) error(test[i], nlz1(test[i]));}
TimestampEnd = std::clock();
printf("nlz1: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz1: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -335,7 +335,7 @@ int main()
if (nlz1a(test[i]) != test[i+1]) error(test[i], nlz1a(test[i]));}
TimestampEnd = std::clock();
printf("nlz1a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz1a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -343,7 +343,7 @@ int main()
if (nlz2(test[i]) != test[i+1]) error(test[i], nlz2(test[i]));}
TimestampEnd = std::clock();
printf("nlz2: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz2: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -351,7 +351,7 @@ int main()
if (nlz2a(test[i]) != test[i+1]) error(test[i], nlz2a(test[i]));}
TimestampEnd = std::clock();
printf("nlz2a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz2a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -359,7 +359,7 @@ int main()
if (nlz3(test[i]) != test[i+1]) error(test[i], nlz3(test[i]));}
TimestampEnd = std::clock();
printf("nlz3: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz3: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -367,7 +367,7 @@ int main()
if (nlz4(test[i]) != test[i+1]) error(test[i], nlz4(test[i]));}
TimestampEnd = std::clock();
printf("nlz4: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz4: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -375,7 +375,7 @@ int main()
if (nlz5(test[i]) != test[i+1]) error(test[i], nlz5(test[i]));}
TimestampEnd = std::clock();
printf("nlz5: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz5: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -383,7 +383,7 @@ int main()
if (nlz6(test[i]) != test[i+1]) error(test[i], nlz6(test[i]));}
TimestampEnd = std::clock();
printf("nlz6: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz6: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -391,7 +391,7 @@ int main()
if (nlz7(test[i]) != test[i+1]) error(test[i], nlz7(test[i]));}
TimestampEnd = std::clock();
printf("nlz7: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz7: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -399,7 +399,7 @@ int main()
if (nlz8(test[i]) != test[i+1]) error(test[i], nlz8(test[i]));}
TimestampEnd = std::clock();
printf("nlz8: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz8: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -407,7 +407,7 @@ int main()
if (nlz9(test[i]) != test[i+1]) error(test[i], nlz9(test[i]));}
TimestampEnd = std::clock();
printf("nlz9: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz9: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -415,7 +415,7 @@ int main()
if (nlz10(test[i]) != test[i+1]) error(test[i], nlz10(test[i]));}
TimestampEnd = std::clock();
printf("nlz10: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz10: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -423,7 +423,7 @@ int main()
if (nlz10a(test[i]) != test[i+1]) error(test[i], nlz10a(test[i]));}
TimestampEnd = std::clock();
printf("nlz10a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz10a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
TimestampBeg = std::clock();
for (std::size_t k = 0; k < Count; ++k)
@ -431,10 +431,10 @@ int main()
if (nlz10b(test[i]) != test[i+1]) error(test[i], nlz10b(test[i]));}
TimestampEnd = std::clock();
printf("nlz10b: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
std::printf("nlz10b: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
if (errors == 0)
printf("Passed all %d cases.\n", static_cast<int>(sizeof(test)/8));
std::printf("Passed all %d cases.\n", static_cast<int>(sizeof(test)/8));
# endif//NDEBUG
}

2
test/core/core_func_matrix.cpp
Unescape View File

@ -297,7 +297,7 @@ int test_inverse_perf(std::size_t Count, std::size_t Instance, char const * Mess
//glm::uint Ulp = 0;
//Ulp = glm::max(glm::float_distance(*Dst, *Src), Ulp);
printf("inverse<%s>(%f): %lu\n", Message, static_cast<double>(Diff), EndTime - StartTime);
std::printf("inverse<%s>(%f): %lu\n", Message, static_cast<double>(Diff), EndTime - StartTime);
return 0;
}

4
test/core/core_type_vec4.cpp
Unescape View File

@ -799,7 +799,7 @@ int main()
glm::ivec4 const g2 = *reinterpret_cast<glm::ivec4 const* const>(&f2);
printf("GNI\n");
std::printf("GNI\n");
}
{
@ -819,7 +819,7 @@ int main()
glm::uvec4 const g2 = *reinterpret_cast<glm::uvec4 const* const>(&f2);
printf("GNI\n");
std::printf("GNI\n");
}
*/

10
test/gtc/gtc_bitfield.cpp
Unescape View File

@ -103,11 +103,11 @@ namespace mask
std::clock_t TimeZero = Timestamp5 - Timestamp4;
std::clock_t TimeHalf = Timestamp6 - Timestamp5;
printf("mask[mix]: %d\n", static_cast<unsigned int>(TimeMix));
printf("mask[loop]: %d\n", static_cast<unsigned int>(TimeLoop));
printf("mask[default]: %d\n", static_cast<unsigned int>(TimeDefault));
printf("mask[zero]: %d\n", static_cast<unsigned int>(TimeZero));
printf("mask[half]: %d\n", static_cast<unsigned int>(TimeHalf));
std::printf("mask[mix]: %d\n", static_cast<unsigned int>(TimeMix));
std::printf("mask[loop]: %d\n", static_cast<unsigned int>(TimeLoop));
std::printf("mask[default]: %d\n", static_cast<unsigned int>(TimeDefault));
std::printf("mask[zero]: %d\n", static_cast<unsigned int>(TimeZero));
std::printf("mask[half]: %d\n", static_cast<unsigned int>(TimeHalf));
return TimeDefault < TimeLoop ? 0 : 1;
}

14
test/gtc/gtc_integer.cpp
Unescape View File

@ -68,7 +68,7 @@ namespace log2_
std::clock_t End = clock();
printf("glm::log2<int>: %d clocks\n", static_cast<int>(End - Begin));
std::printf("glm::log2<int>: %d clocks\n", static_cast<int>(End - Begin));
}
{
@ -82,7 +82,7 @@ namespace log2_
std::clock_t End = clock();
printf("glm::log2<ivec4>: %d clocks\n", static_cast<int>(End - Begin));
std::printf("glm::log2<ivec4>: %d clocks\n", static_cast<int>(End - Begin));
}
# if GLM_HAS_BITSCAN_WINDOWS
@ -104,7 +104,7 @@ namespace log2_
std::clock_t End = clock();
printf("glm::log2<ivec4> inlined: %d clocks\n", static_cast<int>(End - Begin));
std::printf("glm::log2<ivec4> inlined: %d clocks\n", static_cast<int>(End - Begin));
}
@ -124,7 +124,7 @@ namespace log2_
std::clock_t End = clock();
printf("glm::log2<ivec4> inlined no cast: %d clocks\n", static_cast<int>(End - Begin));
std::printf("glm::log2<ivec4> inlined no cast: %d clocks\n", static_cast<int>(End - Begin));
}
@ -144,7 +144,7 @@ namespace log2_
std::clock_t End = clock();
printf("glm::log2<ivec4> reinterpret: %d clocks\n", static_cast<int>(End - Begin));
std::printf("glm::log2<ivec4> reinterpret: %d clocks\n", static_cast<int>(End - Begin));
}
# endif//GLM_HAS_BITSCAN_WINDOWS
@ -159,7 +159,7 @@ namespace log2_
std::clock_t End = clock();
printf("glm::log2<float>: %d clocks\n", static_cast<int>(End - Begin));
std::printf("glm::log2<float>: %d clocks\n", static_cast<int>(End - Begin));
}
{
@ -173,7 +173,7 @@ namespace log2_
std::clock_t End = clock();
printf("glm::log2<vec4>: %d clocks\n", static_cast<int>(End - Begin));
std::printf("glm::log2<vec4>: %d clocks\n", static_cast<int>(End - Begin));
}
return Error;

26
test/gtc/gtc_packing.cpp
Unescape View File

@ -15,46 +15,46 @@ void print_bits(float const& s)
uif.f = s;
printf("f32: ");
std::printf("f32: ");
for(std::size_t j = sizeof(s) * 8; j > 0; --j)
{
if(j == 23 || j == 31)
printf(" ");
printf("%d", (uif.i & (1 << (j - 1))) ? 1 : 0);
std::printf(" ");
std::printf("%d", (uif.i & (1 << (j - 1))) ? 1 : 0);
}
}
void print_10bits(glm::uint const& s)
{
printf("10b: ");
std::printf("10b: ");
for(std::size_t j = 10; j > 0; --j)
{
if(j == 5)
printf(" ");
printf("%d", (s & (1 << (j - 1))) ? 1 : 0);
std::printf(" ");
std::printf("%d", (s & (1 << (j - 1))) ? 1 : 0);
}
}
void print_11bits(glm::uint const& s)
{
printf("11b: ");
std::printf("11b: ");
for(std::size_t j = 11; j > 0; --j)
{
if(j == 6)
printf(" ");
printf("%d", (s & (1 << (j - 1))) ? 1 : 0);
std::printf(" ");
std::printf("%d", (s & (1 << (j - 1))) ? 1 : 0);
}
}
void print_value(float const& s)
{
printf("%2.5f, ", static_cast<double>(s));
std::printf("%2.5f, ", static_cast<double>(s));
print_bits(s);
printf(", ");
std::printf(", ");
// print_11bits(detail::floatTo11bit(s));
// printf(", ");
// std::printf(", ");
// print_10bits(detail::floatTo10bit(s));
printf("\n");
std::printf("\n");
}
int test_Half1x16()

4
test/gtx/gtx_integer.cpp
Unescape View File

@ -33,10 +33,10 @@ int test_log2()
Error += glm::abs(double(A) - B) <= 24 ? 0 : 1;
assert(!Error);
printf("Log2(%d) error A=%d, B=%d\n", 1 << i, A, B);
std::printf("Log2(%d) error A=%d, B=%d\n", 1 << i, A, B);
}
printf("log2 error=%d\n", Error);
std::printf("log2 error=%d\n", Error);
return Error;
}

18
test/gtx/gtx_type_aligned.cpp
Unescape View File

@ -17,7 +17,7 @@ int test_decl()
glm::vec4 B;
};
printf("vec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
std::printf("vec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
Error += sizeof(S1) >= sizeof(S2) ? 0 : 1;
}
@ -35,7 +35,7 @@ int test_decl()
glm::aligned_vec3 B;
};
printf("vec3 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
std::printf("vec3 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
Error += sizeof(S1) <= sizeof(S2) ? 0 : 1;
}
@ -53,7 +53,7 @@ int test_decl()
glm::vec4 B;
};
printf("vec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
std::printf("vec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
Error += sizeof(S1) >= sizeof(S2) ? 0 : 1;
}
@ -71,7 +71,7 @@ int test_decl()
glm::dvec4 B;
};
printf("dvec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
std::printf("dvec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
Error += sizeof(S1) >= sizeof(S2) ? 0 : 1;
}
@ -82,11 +82,11 @@ int test_decl()
template<typename genType>
void print(genType const& Mat0)
{
printf("mat4(\n");
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast<double>(Mat0[0][0]), static_cast<double>(Mat0[0][1]), static_cast<double>(Mat0[0][2]), static_cast<double>(Mat0[0][3]));
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast<double>(Mat0[1][0]), static_cast<double>(Mat0[1][1]), static_cast<double>(Mat0[1][2]), static_cast<double>(Mat0[1][3]));
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast<double>(Mat0[2][0]), static_cast<double>(Mat0[2][1]), static_cast<double>(Mat0[2][2]), static_cast<double>(Mat0[2][3]));
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f))\n\n", static_cast<double>(Mat0[3][0]), static_cast<double>(Mat0[3][1]), static_cast<double>(Mat0[3][2]), static_cast<double>(Mat0[3][3]));
std::printf("mat4(\n");
std::printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast<double>(Mat0[0][0]), static_cast<double>(Mat0[0][1]), static_cast<double>(Mat0[0][2]), static_cast<double>(Mat0[0][3]));
std::printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast<double>(Mat0[1][0]), static_cast<double>(Mat0[1][1]), static_cast<double>(Mat0[1][2]), static_cast<double>(Mat0[1][3]));
std::printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast<double>(Mat0[2][0]), static_cast<double>(Mat0[2][1]), static_cast<double>(Mat0[2][2]), static_cast<double>(Mat0[2][3]));
std::printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f))\n\n", static_cast<double>(Mat0[3][0]), static_cast<double>(Mat0[3][1]), static_cast<double>(Mat0[3][2]), static_cast<double>(Mat0[3][3]));
}
int perf_mul()

24
test/perf/perf_matrix_div.cpp
Unescape View File

@ -46,10 +46,10 @@ static int comp_mat2_div_mat2(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.03, 0.05);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_div_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_div_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_div_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_div_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -73,10 +73,10 @@ static int comp_mat3_div_mat3(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_div_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_div_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_div_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_div_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -100,10 +100,10 @@ static int comp_mat4_div_mat4(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.05, 0.04, 0.02, 0.08, 0.05, 0.01, 0.08, 0.03, 0.05, 0.06, 0.02, 0.03, 0.07, 0.05);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_div_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_div_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_div_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_div_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -122,22 +122,22 @@ int main()
int Error = 0;
printf("mat2 / mat2:\n");
std::printf("mat2 / mat2:\n");
Error += comp_mat2_div_mat2<glm::mat2, glm::aligned_mat2>(Samples);
printf("dmat2 / dmat2:\n");
std::printf("dmat2 / dmat2:\n");
Error += comp_mat2_div_mat2<glm::dmat2, glm::aligned_dmat2>(Samples);
printf("mat3 / mat3:\n");
std::printf("mat3 / mat3:\n");
Error += comp_mat3_div_mat3<glm::mat3, glm::aligned_mat3>(Samples);
printf("dmat3 / dmat3:\n");
std::printf("dmat3 / dmat3:\n");
Error += comp_mat3_div_mat3<glm::dmat3, glm::aligned_dmat3>(Samples);
printf("mat4 / mat4:\n");
std::printf("mat4 / mat4:\n");
Error += comp_mat4_div_mat4<glm::mat4, glm::aligned_mat4>(Samples);
printf("dmat4 / dmat4:\n");
std::printf("dmat4 / dmat4:\n");
Error += comp_mat4_div_mat4<glm::dmat4, glm::aligned_dmat4>(Samples);
return Error;

24
test/perf/perf_matrix_inverse.cpp
Unescape View File

@ -45,10 +45,10 @@ static int comp_mat2_inverse(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.03, 0.05);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_inverse<packedMatType>(SISD, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_inverse<packedMatType>(SISD, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_inverse<alignedMatType>(SIMD, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_inverse<alignedMatType>(SIMD, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -71,10 +71,10 @@ static int comp_mat3_inverse(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_inverse<packedMatType>(SISD, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_inverse<packedMatType>(SISD, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_inverse<alignedMatType>(SIMD, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_inverse<alignedMatType>(SIMD, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -97,10 +97,10 @@ static int comp_mat4_inverse(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.05, 0.04, 0.02, 0.08, 0.05, 0.01, 0.08, 0.03, 0.05, 0.06, 0.02, 0.03, 0.07, 0.05);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_inverse<packedMatType>(SISD, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_inverse<packedMatType>(SISD, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_inverse<alignedMatType>(SIMD, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_inverse<alignedMatType>(SIMD, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -119,22 +119,22 @@ int main()
int Error = 0;
printf("glm::inverse(mat2):\n");
std::printf("glm::inverse(mat2):\n");
Error += comp_mat2_inverse<glm::mat2, glm::aligned_mat2>(Samples);
printf("glm::inverse(dmat2):\n");
std::printf("glm::inverse(dmat2):\n");
Error += comp_mat2_inverse<glm::dmat2, glm::aligned_dmat2>(Samples);
printf("glm::inverse(mat3):\n");
std::printf("glm::inverse(mat3):\n");
Error += comp_mat3_inverse<glm::mat3, glm::aligned_mat3>(Samples);
printf("glm::inverse(dmat3):\n");
std::printf("glm::inverse(dmat3):\n");
Error += comp_mat3_inverse<glm::dmat3, glm::aligned_dmat3>(Samples);
printf("glm::inverse(mat4):\n");
std::printf("glm::inverse(mat4):\n");
Error += comp_mat4_inverse<glm::mat4, glm::aligned_mat4>(Samples);
printf("glm::inverse(dmat4):\n");
std::printf("glm::inverse(dmat4):\n");
Error += comp_mat4_inverse<glm::dmat4, glm::aligned_dmat4>(Samples);
return Error;

24
test/perf/perf_matrix_mul.cpp
Unescape View File

@ -50,10 +50,10 @@ static int comp_mat2_mul_mat2(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.03, 0.05);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_mul_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_mul_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_mul_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_mul_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -76,10 +76,10 @@ static int comp_mat3_mul_mat3(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_mul_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_mul_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_mul_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_mul_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -102,10 +102,10 @@ static int comp_mat4_mul_mat4(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_mul_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_mul_mat<packedMatType>(SISD, Transform, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_mul_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_mul_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -123,22 +123,22 @@ int main()
int Error = 0;
printf("mat2 * mat2:\n");
std::printf("mat2 * mat2:\n");
Error += comp_mat2_mul_mat2<glm::mat2, glm::aligned_mat2>(Samples);
printf("dmat2 * dmat2:\n");
std::printf("dmat2 * dmat2:\n");
Error += comp_mat2_mul_mat2<glm::dmat2, glm::aligned_dmat2>(Samples);
printf("mat3 * mat3:\n");
std::printf("mat3 * mat3:\n");
Error += comp_mat3_mul_mat3<glm::mat3, glm::aligned_mat3>(Samples);
printf("dmat3 * dmat3:\n");
std::printf("dmat3 * dmat3:\n");
Error += comp_mat3_mul_mat3<glm::dmat3, glm::aligned_dmat3>(Samples);
printf("mat4 * mat4:\n");
std::printf("mat4 * mat4:\n");
Error += comp_mat4_mul_mat4<glm::mat4, glm::aligned_mat4>(Samples);
printf("dmat4 * dmat4:\n");
std::printf("dmat4 * dmat4:\n");
Error += comp_mat4_mul_mat4<glm::dmat4, glm::aligned_dmat4>(Samples);
return Error;

24
test/perf/perf_matrix_mul_vector.cpp
Unescape View File

@ -50,10 +50,10 @@ static int comp_mat2_mul_vec2(std::size_t Samples)
packedVecType const Scale(0.01, 0.02);
std::vector<packedVecType> SISD;
printf("- SISD: %d us\n", launch_mat_mul_vec<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_mul_vec<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::vector<alignedVecType> SIMD;
printf("- SIMD: %d us\n", launch_mat_mul_vec<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_mul_vec<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -76,10 +76,10 @@ static int comp_mat3_mul_vec3(std::size_t Samples)
packedVecType const Scale(0.01, 0.02, 0.05);
std::vector<packedVecType> SISD;
printf("- SISD: %d us\n", launch_mat_mul_vec<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_mul_vec<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::vector<alignedVecType> SIMD;
printf("- SIMD: %d us\n", launch_mat_mul_vec<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_mul_vec<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -102,10 +102,10 @@ static int comp_mat4_mul_vec4(std::size_t Samples)
packedVecType const Scale(0.01, 0.02, 0.03, 0.05);
std::vector<packedVecType> SISD;
printf("- SISD: %d us\n", launch_mat_mul_vec<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_mul_vec<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::vector<alignedVecType> SIMD;
printf("- SIMD: %d us\n", launch_mat_mul_vec<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_mul_vec<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -123,22 +123,22 @@ int main()
int Error = 0;
printf("mat2 * vec2:\n");
std::printf("mat2 * vec2:\n");
Error += comp_mat2_mul_vec2<glm::mat2, glm::vec2, glm::aligned_mat2, glm::aligned_vec2>(Samples);
printf("dmat2 * dvec2:\n");
std::printf("dmat2 * dvec2:\n");
Error += comp_mat2_mul_vec2<glm::dmat2, glm::dvec2,glm::aligned_dmat2, glm::aligned_dvec2>(Samples);
printf("mat3 * vec3:\n");
std::printf("mat3 * vec3:\n");
Error += comp_mat3_mul_vec3<glm::mat3, glm::vec3, glm::aligned_mat3, glm::aligned_vec3>(Samples);
printf("dmat3 * dvec3:\n");
std::printf("dmat3 * dvec3:\n");
Error += comp_mat3_mul_vec3<glm::dmat3, glm::dvec3, glm::aligned_dmat3, glm::aligned_dvec3>(Samples);
printf("mat4 * vec4:\n");
std::printf("mat4 * vec4:\n");
Error += comp_mat4_mul_vec4<glm::mat4, glm::vec4, glm::aligned_mat4, glm::aligned_vec4>(Samples);
printf("dmat4 * dvec4:\n");
std::printf("dmat4 * dvec4:\n");
Error += comp_mat4_mul_vec4<glm::dmat4, glm::dvec4, glm::aligned_dmat4, glm::aligned_dvec4>(Samples);
return Error;

24
test/perf/perf_matrix_transpose.cpp
Unescape View File

@ -45,10 +45,10 @@ static int comp_mat2_transpose(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.03, 0.05);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_transpose<packedMatType>(SISD, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_transpose<packedMatType>(SISD, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_transpose<alignedMatType>(SIMD, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_transpose<alignedMatType>(SIMD, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -71,10 +71,10 @@ static int comp_mat3_transpose(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_transpose<packedMatType>(SISD, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_transpose<packedMatType>(SISD, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_transpose<alignedMatType>(SIMD, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_transpose<alignedMatType>(SIMD, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -97,10 +97,10 @@ static int comp_mat4_transpose(std::size_t Samples)
packedMatType const Scale(0.01, 0.02, 0.05, 0.04, 0.02, 0.08, 0.05, 0.01, 0.08, 0.03, 0.05, 0.06, 0.02, 0.03, 0.07, 0.05);
std::vector<packedMatType> SISD;
printf("- SISD: %d us\n", launch_mat_transpose<packedMatType>(SISD, Scale, Samples));
std::printf("- SISD: %d us\n", launch_mat_transpose<packedMatType>(SISD, Scale, Samples));
std::vector<alignedMatType> SIMD;
printf("- SIMD: %d us\n", launch_mat_transpose<alignedMatType>(SIMD, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_mat_transpose<alignedMatType>(SIMD, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -119,22 +119,22 @@ int main()
int Error = 0;
printf("glm::transpose(mat2):\n");
std::printf("glm::transpose(mat2):\n");
Error += comp_mat2_transpose<glm::mat2, glm::aligned_mat2>(Samples);
printf("glm::transpose(dmat2):\n");
std::printf("glm::transpose(dmat2):\n");
Error += comp_mat2_transpose<glm::dmat2, glm::aligned_dmat2>(Samples);
printf("glm::transpose(mat3):\n");
std::printf("glm::transpose(mat3):\n");
Error += comp_mat3_transpose<glm::mat3, glm::aligned_mat3>(Samples);
printf("glm::transpose(dmat3):\n");
std::printf("glm::transpose(dmat3):\n");
Error += comp_mat3_transpose<glm::dmat3, glm::aligned_dmat3>(Samples);
printf("glm::transpose(mat4):\n");
std::printf("glm::transpose(mat4):\n");
Error += comp_mat4_transpose<glm::mat4, glm::aligned_mat4>(Samples);
printf("glm::transpose(dmat4):\n");
std::printf("glm::transpose(dmat4):\n");
Error += comp_mat4_transpose<glm::dmat4, glm::aligned_dmat4>(Samples);
return Error;

24
test/perf/perf_vector_mul_matrix.cpp
Unescape View File

@ -50,10 +50,10 @@ static int comp_vec2_mul_mat2(std::size_t Samples)
packedVecType const Scale(0.01, 0.02);
std::vector<packedVecType> SISD;
printf("- SISD: %d us\n", launch_vec_mul_mat<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_vec_mul_mat<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::vector<alignedVecType> SIMD;
printf("- SIMD: %d us\n", launch_vec_mul_mat<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_vec_mul_mat<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -76,10 +76,10 @@ static int comp_vec3_mul_mat3(std::size_t Samples)
packedVecType const Scale(0.01, 0.02, 0.05);
std::vector<packedVecType> SISD;
printf("- SISD: %d us\n", launch_vec_mul_mat<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_vec_mul_mat<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::vector<alignedVecType> SIMD;
printf("- SIMD: %d us\n", launch_vec_mul_mat<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_vec_mul_mat<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -102,10 +102,10 @@ static int comp_vec4_mul_mat4(std::size_t Samples)
packedVecType const Scale(0.01, 0.02, 0.03, 0.05);
std::vector<packedVecType> SISD;
printf("- SISD: %d us\n", launch_vec_mul_mat<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::printf("- SISD: %d us\n", launch_vec_mul_mat<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
std::vector<alignedVecType> SIMD;
printf("- SIMD: %d us\n", launch_vec_mul_mat<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
std::printf("- SIMD: %d us\n", launch_vec_mul_mat<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
for(std::size_t i = 0; i < Samples; ++i)
{
@ -123,22 +123,22 @@ int main()
int Error = 0;
printf("vec2 * mat2:\n");
std::printf("vec2 * mat2:\n");
Error += comp_vec2_mul_mat2<glm::mat2, glm::vec2, glm::aligned_mat2, glm::aligned_vec2>(Samples);
printf("dvec2 * dmat2:\n");
std::printf("dvec2 * dmat2:\n");
Error += comp_vec2_mul_mat2<glm::dmat2, glm::dvec2,glm::aligned_dmat2, glm::aligned_dvec2>(Samples);
printf("vec3 * mat3:\n");
std::printf("vec3 * mat3:\n");
Error += comp_vec3_mul_mat3<glm::mat3, glm::vec3, glm::aligned_mat3, glm::aligned_vec3>(Samples);
printf("dvec3 * dmat3:\n");
std::printf("dvec3 * dmat3:\n");
Error += comp_vec3_mul_mat3<glm::dmat3, glm::dvec3, glm::aligned_dmat3, glm::aligned_dvec3>(Samples);
printf("vec4 * mat4:\n");
std::printf("vec4 * mat4:\n");
Error += comp_vec4_mul_mat4<glm::mat4, glm::vec4, glm::aligned_mat4, glm::aligned_vec4>(Samples);
printf("dvec4 * dmat4:\n");
std::printf("dvec4 * dmat4:\n");
Error += comp_vec4_mul_mat4<glm::dmat4, glm::dvec4, glm::aligned_dmat4, glm::aligned_dvec4>(Samples);
return Error;

Write Preview
Loading…
Cancel
Save