1 #include <glm/ext/vector_integer.hpp>
2 #include <glm/ext/scalar_int_sized.hpp>
3 #include <glm/ext/scalar_uint_sized.hpp>
4 #include <vector>
5 #include <ctime>
6 #include <cstdio>
7
8 namespace isPowerOfTwo
9 {
10 template<typename genType>
11 struct type
12 {
13 genType Value;
14 bool Return;
15 };
16
17 template <glm::length_t L>
test_int16()18 int test_int16()
19 {
20 type<glm::int16> const Data[] =
21 {
22 { 0x0001, true },
23 { 0x0002, true },
24 { 0x0004, true },
25 { 0x0080, true },
26 { 0x0000, true },
27 { 0x0003, false }
28 };
29
30 int Error = 0;
31
32 for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::int16>); i < n; ++i)
33 {
34 glm::vec<L, bool> const Result = glm::isPowerOfTwo(glm::vec<L, glm::int16>(Data[i].Value));
35 Error += glm::vec<L, bool>(Data[i].Return) == Result ? 0 : 1;
36 }
37
38 return Error;
39 }
40
41 template <glm::length_t L>
test_uint16()42 int test_uint16()
43 {
44 type<glm::uint16> const Data[] =
45 {
46 { 0x0001, true },
47 { 0x0002, true },
48 { 0x0004, true },
49 { 0x0000, true },
50 { 0x0000, true },
51 { 0x0003, false }
52 };
53
54 int Error = 0;
55
56 for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint16>); i < n; ++i)
57 {
58 glm::vec<L, bool> const Result = glm::isPowerOfTwo(glm::vec<L, glm::uint16>(Data[i].Value));
59 Error += glm::vec<L, bool>(Data[i].Return) == Result ? 0 : 1;
60 }
61
62 return Error;
63 }
64
65 template <glm::length_t L>
test_int32()66 int test_int32()
67 {
68 type<int> const Data[] =
69 {
70 { 0x00000001, true },
71 { 0x00000002, true },
72 { 0x00000004, true },
73 { 0x0000000f, false },
74 { 0x00000000, true },
75 { 0x00000003, false }
76 };
77
78 int Error = 0;
79
80 for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i)
81 {
82 glm::vec<L, bool> const Result = glm::isPowerOfTwo(glm::vec<L, glm::int32>(Data[i].Value));
83 Error += glm::vec<L, bool>(Data[i].Return) == Result ? 0 : 1;
84 }
85
86 return Error;
87 }
88
89 template <glm::length_t L>
test_uint32()90 int test_uint32()
91 {
92 type<glm::uint> const Data[] =
93 {
94 { 0x00000001, true },
95 { 0x00000002, true },
96 { 0x00000004, true },
97 { 0x80000000, true },
98 { 0x00000000, true },
99 { 0x00000003, false }
100 };
101
102 int Error = 0;
103
104 for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint>); i < n; ++i)
105 {
106 glm::vec<L, bool> const Result = glm::isPowerOfTwo(glm::vec<L, glm::uint32>(Data[i].Value));
107 Error += glm::vec<L, bool>(Data[i].Return) == Result ? 0 : 1;
108 }
109
110 return Error;
111 }
112
test()113 int test()
114 {
115 int Error = 0;
116
117 Error += test_int16<1>();
118 Error += test_int16<2>();
119 Error += test_int16<3>();
120 Error += test_int16<4>();
121
122 Error += test_uint16<1>();
123 Error += test_uint16<2>();
124 Error += test_uint16<3>();
125 Error += test_uint16<4>();
126
127 Error += test_int32<1>();
128 Error += test_int32<2>();
129 Error += test_int32<3>();
130 Error += test_int32<4>();
131
132 Error += test_uint32<1>();
133 Error += test_uint32<2>();
134 Error += test_uint32<3>();
135 Error += test_uint32<4>();
136
137 return Error;
138 }
139 }//isPowerOfTwo
140
141 namespace prevPowerOfTwo
142 {
143 template <glm::length_t L, typename T>
run()144 int run()
145 {
146 int Error = 0;
147
148 glm::vec<L, T> const A = glm::prevPowerOfTwo(glm::vec<L, T>(7));
149 Error += A == glm::vec<L, T>(4) ? 0 : 1;
150
151 glm::vec<L, T> const B = glm::prevPowerOfTwo(glm::vec<L, T>(15));
152 Error += B == glm::vec<L, T>(8) ? 0 : 1;
153
154 glm::vec<L, T> const C = glm::prevPowerOfTwo(glm::vec<L, T>(31));
155 Error += C == glm::vec<L, T>(16) ? 0 : 1;
156
157 glm::vec<L, T> const D = glm::prevPowerOfTwo(glm::vec<L, T>(32));
158 Error += D == glm::vec<L, T>(32) ? 0 : 1;
159
160 return Error;
161 }
162
test()163 int test()
164 {
165 int Error = 0;
166
167 Error += run<1, glm::int8>();
168 Error += run<2, glm::int8>();
169 Error += run<3, glm::int8>();
170 Error += run<4, glm::int8>();
171
172 Error += run<1, glm::int16>();
173 Error += run<2, glm::int16>();
174 Error += run<3, glm::int16>();
175 Error += run<4, glm::int16>();
176
177 Error += run<1, glm::int32>();
178 Error += run<2, glm::int32>();
179 Error += run<3, glm::int32>();
180 Error += run<4, glm::int32>();
181
182 Error += run<1, glm::int64>();
183 Error += run<2, glm::int64>();
184 Error += run<3, glm::int64>();
185 Error += run<4, glm::int64>();
186
187 Error += run<1, glm::uint8>();
188 Error += run<2, glm::uint8>();
189 Error += run<3, glm::uint8>();
190 Error += run<4, glm::uint8>();
191
192 Error += run<1, glm::uint16>();
193 Error += run<2, glm::uint16>();
194 Error += run<3, glm::uint16>();
195 Error += run<4, glm::uint16>();
196
197 Error += run<1, glm::uint32>();
198 Error += run<2, glm::uint32>();
199 Error += run<3, glm::uint32>();
200 Error += run<4, glm::uint32>();
201
202 Error += run<1, glm::uint64>();
203 Error += run<2, glm::uint64>();
204 Error += run<3, glm::uint64>();
205 Error += run<4, glm::uint64>();
206
207 return Error;
208 }
209 }//namespace prevPowerOfTwo
210
211 namespace nextPowerOfTwo
212 {
213 template <glm::length_t L, typename T>
run()214 int run()
215 {
216 int Error = 0;
217
218 glm::vec<L, T> const A = glm::nextPowerOfTwo(glm::vec<L, T>(7));
219 Error += A == glm::vec<L, T>(8) ? 0 : 1;
220
221 glm::vec<L, T> const B = glm::nextPowerOfTwo(glm::vec<L, T>(15));
222 Error += B == glm::vec<L, T>(16) ? 0 : 1;
223
224 glm::vec<L, T> const C = glm::nextPowerOfTwo(glm::vec<L, T>(31));
225 Error += C == glm::vec<L, T>(32) ? 0 : 1;
226
227 glm::vec<L, T> const D = glm::nextPowerOfTwo(glm::vec<L, T>(32));
228 Error += D == glm::vec<L, T>(32) ? 0 : 1;
229
230 return Error;
231 }
232
test()233 int test()
234 {
235 int Error = 0;
236
237 Error += run<1, glm::int8>();
238 Error += run<2, glm::int8>();
239 Error += run<3, glm::int8>();
240 Error += run<4, glm::int8>();
241
242 Error += run<1, glm::int16>();
243 Error += run<2, glm::int16>();
244 Error += run<3, glm::int16>();
245 Error += run<4, glm::int16>();
246
247 Error += run<1, glm::int32>();
248 Error += run<2, glm::int32>();
249 Error += run<3, glm::int32>();
250 Error += run<4, glm::int32>();
251
252 Error += run<1, glm::int64>();
253 Error += run<2, glm::int64>();
254 Error += run<3, glm::int64>();
255 Error += run<4, glm::int64>();
256
257 Error += run<1, glm::uint8>();
258 Error += run<2, glm::uint8>();
259 Error += run<3, glm::uint8>();
260 Error += run<4, glm::uint8>();
261
262 Error += run<1, glm::uint16>();
263 Error += run<2, glm::uint16>();
264 Error += run<3, glm::uint16>();
265 Error += run<4, glm::uint16>();
266
267 Error += run<1, glm::uint32>();
268 Error += run<2, glm::uint32>();
269 Error += run<3, glm::uint32>();
270 Error += run<4, glm::uint32>();
271
272 Error += run<1, glm::uint64>();
273 Error += run<2, glm::uint64>();
274 Error += run<3, glm::uint64>();
275 Error += run<4, glm::uint64>();
276
277 return Error;
278 }
279 }//namespace nextPowerOfTwo
280
281 namespace prevMultiple
282 {
283 template<typename genIUType>
284 struct type
285 {
286 genIUType Source;
287 genIUType Multiple;
288 genIUType Return;
289 };
290
291 template <glm::length_t L, typename T>
run()292 int run()
293 {
294 type<T> const Data[] =
295 {
296 { 8, 3, 6 },
297 { 7, 7, 7 }
298 };
299
300 int Error = 0;
301
302 for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
303 {
304 glm::vec<L, T> const Result0 = glm::prevMultiple(glm::vec<L, T>(Data[i].Source), Data[i].Multiple);
305 Error += glm::vec<L, T>(Data[i].Return) == Result0 ? 0 : 1;
306
307 glm::vec<L, T> const Result1 = glm::prevMultiple(glm::vec<L, T>(Data[i].Source), glm::vec<L, T>(Data[i].Multiple));
308 Error += glm::vec<L, T>(Data[i].Return) == Result1 ? 0 : 1;
309 }
310
311 return Error;
312 }
313
test()314 int test()
315 {
316 int Error = 0;
317
318 Error += run<1, glm::int8>();
319 Error += run<2, glm::int8>();
320 Error += run<3, glm::int8>();
321 Error += run<4, glm::int8>();
322
323 Error += run<1, glm::int16>();
324 Error += run<2, glm::int16>();
325 Error += run<3, glm::int16>();
326 Error += run<4, glm::int16>();
327
328 Error += run<1, glm::int32>();
329 Error += run<2, glm::int32>();
330 Error += run<3, glm::int32>();
331 Error += run<4, glm::int32>();
332
333 Error += run<1, glm::int64>();
334 Error += run<2, glm::int64>();
335 Error += run<3, glm::int64>();
336 Error += run<4, glm::int64>();
337
338 Error += run<1, glm::uint8>();
339 Error += run<2, glm::uint8>();
340 Error += run<3, glm::uint8>();
341 Error += run<4, glm::uint8>();
342
343 Error += run<1, glm::uint16>();
344 Error += run<2, glm::uint16>();
345 Error += run<3, glm::uint16>();
346 Error += run<4, glm::uint16>();
347
348 Error += run<1, glm::uint32>();
349 Error += run<2, glm::uint32>();
350 Error += run<3, glm::uint32>();
351 Error += run<4, glm::uint32>();
352
353 Error += run<1, glm::uint64>();
354 Error += run<2, glm::uint64>();
355 Error += run<3, glm::uint64>();
356 Error += run<4, glm::uint64>();
357
358 return Error;
359 }
360 }//namespace prevMultiple
361
362 namespace nextMultiple
363 {
364 template<typename genIUType>
365 struct type
366 {
367 genIUType Source;
368 genIUType Multiple;
369 genIUType Return;
370 };
371
372 template <glm::length_t L, typename T>
run()373 int run()
374 {
375 type<T> const Data[] =
376 {
377 { 3, 4, 4 },
378 { 6, 3, 6 },
379 { 5, 3, 6 },
380 { 7, 7, 7 },
381 { 0, 1, 0 },
382 { 8, 3, 9 }
383 };
384
385 int Error = 0;
386
387 for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
388 {
389 glm::vec<L, T> const Result0 = glm::nextMultiple(glm::vec<L, T>(Data[i].Source), glm::vec<L, T>(Data[i].Multiple));
390 Error += glm::vec<L, T>(Data[i].Return) == Result0 ? 0 : 1;
391
392 glm::vec<L, T> const Result1 = glm::nextMultiple(glm::vec<L, T>(Data[i].Source), Data[i].Multiple);
393 Error += glm::vec<L, T>(Data[i].Return) == Result1 ? 0 : 1;
394 }
395
396 return Error;
397 }
398
test()399 int test()
400 {
401 int Error = 0;
402
403 Error += run<1, glm::int8>();
404 Error += run<2, glm::int8>();
405 Error += run<3, glm::int8>();
406 Error += run<4, glm::int8>();
407
408 Error += run<1, glm::int16>();
409 Error += run<2, glm::int16>();
410 Error += run<3, glm::int16>();
411 Error += run<4, glm::int16>();
412
413 Error += run<1, glm::int32>();
414 Error += run<2, glm::int32>();
415 Error += run<3, glm::int32>();
416 Error += run<4, glm::int32>();
417
418 Error += run<1, glm::int64>();
419 Error += run<2, glm::int64>();
420 Error += run<3, glm::int64>();
421 Error += run<4, glm::int64>();
422
423 Error += run<1, glm::uint8>();
424 Error += run<2, glm::uint8>();
425 Error += run<3, glm::uint8>();
426 Error += run<4, glm::uint8>();
427
428 Error += run<1, glm::uint16>();
429 Error += run<2, glm::uint16>();
430 Error += run<3, glm::uint16>();
431 Error += run<4, glm::uint16>();
432
433 Error += run<1, glm::uint32>();
434 Error += run<2, glm::uint32>();
435 Error += run<3, glm::uint32>();
436 Error += run<4, glm::uint32>();
437
438 Error += run<1, glm::uint64>();
439 Error += run<2, glm::uint64>();
440 Error += run<3, glm::uint64>();
441 Error += run<4, glm::uint64>();
442
443 return Error;
444 }
445 }//namespace nextMultiple
446
447 namespace findNSB
448 {
449 template<typename T>
450 struct type
451 {
452 T Source;
453 int SignificantBitCount;
454 int Return;
455 };
456
457 template <glm::length_t L, typename T>
run()458 int run()
459 {
460 type<T> const Data[] =
461 {
462 { 0x00, 1,-1 },
463 { 0x01, 2,-1 },
464 { 0x02, 2,-1 },
465 { 0x06, 3,-1 },
466 { 0x01, 1, 0 },
467 { 0x03, 1, 0 },
468 { 0x03, 2, 1 },
469 { 0x07, 2, 1 },
470 { 0x05, 2, 2 },
471 { 0x0D, 2, 2 }
472 };
473
474 int Error = 0;
475
476 for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
477 {
478 glm::vec<L, int> const Result0 = glm::findNSB<L, T, glm::defaultp>(glm::vec<L, T>(Data[i].Source), glm::vec<L, int>(Data[i].SignificantBitCount));
479 Error += glm::vec<L, int>(Data[i].Return) == Result0 ? 0 : 1;
480 assert(!Error);
481 }
482
483 return Error;
484 }
485
test()486 int test()
487 {
488 int Error = 0;
489
490 Error += run<1, glm::uint8>();
491 Error += run<2, glm::uint8>();
492 Error += run<3, glm::uint8>();
493 Error += run<4, glm::uint8>();
494
495 Error += run<1, glm::uint16>();
496 Error += run<2, glm::uint16>();
497 Error += run<3, glm::uint16>();
498 Error += run<4, glm::uint16>();
499
500 Error += run<1, glm::uint32>();
501 Error += run<2, glm::uint32>();
502 Error += run<3, glm::uint32>();
503 Error += run<4, glm::uint32>();
504
505 Error += run<1, glm::uint64>();
506 Error += run<2, glm::uint64>();
507 Error += run<3, glm::uint64>();
508 Error += run<4, glm::uint64>();
509
510 Error += run<1, glm::int8>();
511 Error += run<2, glm::int8>();
512 Error += run<3, glm::int8>();
513 Error += run<4, glm::int8>();
514
515 Error += run<1, glm::int16>();
516 Error += run<2, glm::int16>();
517 Error += run<3, glm::int16>();
518 Error += run<4, glm::int16>();
519
520 Error += run<1, glm::int32>();
521 Error += run<2, glm::int32>();
522 Error += run<3, glm::int32>();
523 Error += run<4, glm::int32>();
524
525 Error += run<1, glm::int64>();
526 Error += run<2, glm::int64>();
527 Error += run<3, glm::int64>();
528 Error += run<4, glm::int64>();
529
530
531 return Error;
532 }
533 }//namespace findNSB
534
main()535 int main()
536 {
537 int Error = 0;
538
539 Error += isPowerOfTwo::test();
540 Error += prevPowerOfTwo::test();
541 Error += nextPowerOfTwo::test();
542 Error += prevMultiple::test();
543 Error += nextMultiple::test();
544 Error += findNSB::test();
545
546 return Error;
547 }
548