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