lolengine
/
lol
Mirror von https://github.com/lolengine/lol
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Aktivität
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
2239 Commits
5 Branches
18 MiB
Struktur: 2f056e0133
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „2f056e0133“
${ noResults }
lol/test/unit/half.cpp

half.cpp 8.2 KiB
Originalformat Normale Ansicht Verlauf

test: add first test routines for the half class.
vor 13 Jahren
​
​
​
​
​
​
build: fix the WTFPL site URL in all code comments.
vor 12 Jahren
test: add first test routines for the half class.
vor 13 Jahren
​
​
​
​
​
test: add a fallback for isnan() when not defined by the system includes.
vor 13 Jahren
​
base: strip core.h from its contents and put it in public/private headers.
vor 10 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
​
​
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
test: give more explicit names to unit test cases.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
test: improve the benchmark code to measure a lot more half precision number conversions.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
test: improve the benchmark code to measure a lot more half precision number conversions.
vor 13 Jahren
​
lolunit: add a LOLUNIT_SET_CONTEXT / LOLUNIT_UNSET_CONTEXT macro pair. This is useful when doing several asserts in one loop, for instance: there isn't always a way to deduce the loop index from the assert failure, so these macros allow the user to give more context information.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
​
​
test: give more explicit names to unit test cases.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
core: tune the half precision code so that the best variants are being used on the PS3 platform.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
lolunit: add a LOLUNIT_SET_CONTEXT / LOLUNIT_UNSET_CONTEXT macro pair. This is useful when doing several asserts in one loop, for instance: there isn't always a way to deduce the loop index from the assert failure, so these macros allow the user to give more context information.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
​
​
test: give more explicit names to unit test cases.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
test: improve the benchmark code to measure a lot more half precision number conversions.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
test: improve the benchmark code to measure a lot more half precision number conversions.
vor 13 Jahren
​
lolunit: add a LOLUNIT_SET_CONTEXT / LOLUNIT_UNSET_CONTEXT macro pair. This is useful when doing several asserts in one loop, for instance: there isn't always a way to deduce the loop index from the assert failure, so these macros allow the user to give more context information.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
​
​
test: give more explicit names to unit test cases.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
​
​
​
​
​
​
​
​
​
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
test: give more explicit names to unit test cases.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
​
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
test: give more explicit names to unit test cases.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
​
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
test: give more explicit names to unit test cases.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
​
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
test: give more explicit names to unit test cases.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
​
lolunit: add a LOLUNIT_SET_CONTEXT / LOLUNIT_UNSET_CONTEXT macro pair. This is useful when doing several asserts in one loop, for instance: there isn't always a way to deduce the loop index from the assert failure, so these macros allow the user to give more context information.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
core: rename half::isnan() etc. to half::is_nan() because "isnan" can be a C macro on some systems (Android NDK, PS3...).
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
core: rename half::isnan() etc. to half::is_nan() because "isnan" can be a C macro on some systems (Android NDK, PS3...).
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
​
​
test: give more explicit names to unit test cases.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
lolunit: add a LOLUNIT_SET_CONTEXT / LOLUNIT_UNSET_CONTEXT macro pair. This is useful when doing several asserts in one loop, for instance: there isn't always a way to deduce the loop index from the assert failure, so these macros allow the user to give more context information.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
​
​
​
test: remove isnan() unit tests because we can't rely on that function.
vor 11 Jahren
​
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
lolunit: add a LOLUNIT_SET_CONTEXT / LOLUNIT_UNSET_CONTEXT macro pair. This is useful when doing several asserts in one loop, for instance: there isn't always a way to deduce the loop index from the assert failure, so these macros allow the user to give more context information.
vor 13 Jahren
test: remove isnan() unit tests because we can't rely on that function.
vor 11 Jahren
test: add first test routines for the half class.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: give more explicit names to unit test cases.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
​
​
​
​
​
​
​
​
​
test: add first test routines for the half class.
vor 13 Jahren
​
test: give more explicit names to unit test cases.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
​
​
​
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: give more explicit names to unit test cases.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
​
​
​
​
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: replace CppUnit with our LolUnit test suite. CppUnit is really too large for our needs, would require to be precompiled for many platforms, in all combinations of debug and release modes, with additional variants for libstdc++ versions. We replace it with our own lightweight implementation, LolUnit. Good riddance.
vor 13 Jahren
core: implement new half / float operations and the associated tests.
vor 13 Jahren
​
test: add first test routines for the half class.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
​
test: augment the half precision numbers testsuite.
vor 13 Jahren
test: add first test routines for the half class.
vor 13 Jahren
test: augment the half precision numbers testsuite.
vor 13 Jahren
​
​
​
​
​
​
​
​
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
vor 13 Jahren
lolunit: add a LOLUNIT_SET_CONTEXT / LOLUNIT_UNSET_CONTEXT macro pair. This is useful when doing several asserts in one loop, for instance: there isn't always a way to deduce the loop index from the assert failure, so these macros allow the user to give more context information.
vor 13 Jahren
​
test: add first test routines for the half class.
vor 13 Jahren
​
​
​
 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291 
  1. //

  2. // Lol Engine

  3. //

  4. // Copyright: (c) 2010-2011 Sam Hocevar <sam@hocevar.net>

  5. //   This program is free software; you can redistribute it and/or

  6. //   modify it under the terms of the Do What The Fuck You Want To

  7. //   Public License, Version 2, as published by Sam Hocevar. See

  8. //   http://www.wtfpl.net/ for more details.

  9. //

  10. 

  11. #if defined HAVE_CONFIG_H

  12. #   include "config.h"

  13. #endif

  14. 

  15. #include <cmath>

  16. 

  17. #include <lol/main.h>

  18. #include "lol/unit.h"

  19. 

  20. namespace lol

  21. {

  22. 

  23. LOLUNIT_FIXTURE(HalfTest)

  24. {

  25.     LOLUNIT_TEST(FloatToHalf)

  26.     {

  27.         for (size_t i = 0; i < sizeof(pairs) / sizeof(*pairs); i++)

  28.         {

  29.             half a = (half)pairs[i].f;

  30.             uint16_t b = pairs[i].x;

  31.             LOLUNIT_SET_CONTEXT(i);

  32.             LOLUNIT_ASSERT_EQUAL(a.bits, b);

  33.         }

  34.     }

  35. 

  36.     LOLUNIT_TEST(FloatToHalfAccurate)

  37.     {

  38.         for (size_t i = 0; i < sizeof(pairs) / sizeof(*pairs); i++)

  39.         {

  40.             half a = half::makeaccurate(pairs[i].f);

  41.             uint16_t b = pairs[i].x;

  42.             LOLUNIT_SET_CONTEXT(i);

  43.             LOLUNIT_ASSERT_EQUAL(a.bits, b);

  44.         }

  45.     }

  46. 

  47.     LOLUNIT_TEST(BitsToHalf)

  48.     {

  49.         for (unsigned int i = 0; i < 0x10000; i++)

  50.         {

  51.             half a = half::makebits(i);

  52.             uint16_t b = i;

  53.             LOLUNIT_SET_CONTEXT(i);

  54.             LOLUNIT_ASSERT_EQUAL(a.bits, b);

  55.         }

  56.     }

  57. 

  58.     LOLUNIT_TEST(HalfIsNaN)

  59.     {

  60.         LOLUNIT_ASSERT(half::makebits(0x7c01).is_nan());

  61.         LOLUNIT_ASSERT(half::makebits(0xfc01).is_nan());

  62.         LOLUNIT_ASSERT(half::makebits(0x7e00).is_nan());

  63.         LOLUNIT_ASSERT(half::makebits(0xfe00).is_nan());

  64. 

  65.         LOLUNIT_ASSERT(!half::makebits(0x7c00).is_nan());

  66.         LOLUNIT_ASSERT(!half::makebits(0xfc00).is_nan());

  67. 

  68.         LOLUNIT_ASSERT(!half(0.0f).is_nan());

  69.         LOLUNIT_ASSERT(!half(-0.0f).is_nan());

  70.         LOLUNIT_ASSERT(!half(2.0f).is_nan());

  71.         LOLUNIT_ASSERT(!half(-2.0f).is_nan());

  72.     }

  73. 

  74.     LOLUNIT_TEST(HalfIsInf)

  75.     {

  76.         LOLUNIT_ASSERT(half(65536.0f).is_inf());

  77.         LOLUNIT_ASSERT(half(-65536.0f).is_inf());

  78. 

  79.         LOLUNIT_ASSERT(!half(0.0f).is_inf());

  80.         LOLUNIT_ASSERT(!half(-0.0f).is_inf());

  81.         LOLUNIT_ASSERT(!half(65535.0f).is_inf());

  82.         LOLUNIT_ASSERT(!half(-65535.0f).is_inf());

  83. 

  84.         LOLUNIT_ASSERT(half::makebits(0x7c00).is_inf());

  85.         LOLUNIT_ASSERT(half::makebits(0xfc00).is_inf());

  86. 

  87.         LOLUNIT_ASSERT(!half::makebits(0x7e00).is_inf());

  88.         LOLUNIT_ASSERT(!half::makebits(0xfe00).is_inf());

  89.     }

  90. 

  91.     LOLUNIT_TEST(HalfIsFinite)

  92.     {

  93.         LOLUNIT_ASSERT(half(0.0f).is_finite());

  94.         LOLUNIT_ASSERT(half(-0.0f).is_finite());

  95.         LOLUNIT_ASSERT(half(65535.0f).is_finite());

  96.         LOLUNIT_ASSERT(half(-65535.0f).is_finite());

  97. 

  98.         LOLUNIT_ASSERT(!half(65536.0f).is_finite());

  99.         LOLUNIT_ASSERT(!half(-65536.0f).is_finite());

  100. 

  101.         LOLUNIT_ASSERT(!half::makebits(0x7c00).is_finite());

  102.         LOLUNIT_ASSERT(!half::makebits(0xfc00).is_finite());

  103. 

  104.         LOLUNIT_ASSERT(!half::makebits(0x7e00).is_finite());

  105.         LOLUNIT_ASSERT(!half::makebits(0xfe00).is_finite());

  106.     }

  107. 

  108.     LOLUNIT_TEST(HalfIsNormal)

  109.     {

  110.         LOLUNIT_ASSERT(half(0.0f).is_normal());

  111.         LOLUNIT_ASSERT(half(-0.0f).is_normal());

  112.         LOLUNIT_ASSERT(half(65535.0f).is_normal());

  113.         LOLUNIT_ASSERT(half(-65535.0f).is_normal());

  114. 

  115.         LOLUNIT_ASSERT(!half(65536.0f).is_normal());

  116.         LOLUNIT_ASSERT(!half(-65536.0f).is_normal());

  117. 

  118.         LOLUNIT_ASSERT(!half::makebits(0x7c00).is_normal());

  119.         LOLUNIT_ASSERT(!half::makebits(0xfc00).is_normal());

  120. 

  121.         LOLUNIT_ASSERT(!half::makebits(0x7e00).is_normal());

  122.         LOLUNIT_ASSERT(!half::makebits(0xfe00).is_normal());

  123.     }

  124. 

  125.     LOLUNIT_TEST(HalfClassify)

  126.     {

  127.         for (uint32_t i = 0; i < 0x10000; i++)

  128.         {

  129.             LOLUNIT_SET_CONTEXT(i);

  130.             half h = half::makebits(i);

  131.             if (h.is_nan())

  132.             {

  133.                 LOLUNIT_ASSERT(!h.is_inf());

  134.                 LOLUNIT_ASSERT(!h.is_normal());

  135.                 LOLUNIT_ASSERT(!h.is_finite());

  136.             }

  137.             else if (h.is_inf())

  138.             {

  139.                 LOLUNIT_ASSERT(!h.is_normal());

  140.                 LOLUNIT_ASSERT(!h.is_finite());

  141.             }

  142.             else

  143.             {

  144.                 LOLUNIT_ASSERT(h.is_finite());

  145.             }

  146.         }

  147.     }

  148. 

  149.     LOLUNIT_TEST(HalfToFloat)

  150.     {

  151.         for (size_t i = 0; i < sizeof(pairs) / sizeof(*pairs); i++)

  152.         {

  153.             float a = (float)half::makebits(pairs[i].x);

  154.             float b = pairs[i].f;

  155.             LOLUNIT_SET_CONTEXT(i);

  156.             LOLUNIT_ASSERT_EQUAL(a, b);

  157.         }

  158. 

  159.         for (uint32_t i = 0; i < 0x10000; i++)

  160.         {

  161.             half h = half::makebits(i);

  162.             if (h.is_nan())

  163.                 continue;

  164. 

  165.             float f = (float)h;

  166.             half g = (half)f;

  167.             LOLUNIT_SET_CONTEXT(i);

  168.             LOLUNIT_ASSERT_EQUAL(g.bits, h.bits);

  169.         }

  170.     }

  171. 

  172.     LOLUNIT_TEST(HalfToInt)

  173.     {

  174.         LOLUNIT_ASSERT_EQUAL((int)(half)(0.0f), 0);

  175.         LOLUNIT_ASSERT_EQUAL((int)(half)(-0.0f), 0);

  176.         LOLUNIT_ASSERT_EQUAL((int)(half)(0.9f), 0);

  177.         LOLUNIT_ASSERT_EQUAL((int)(half)(-0.9f), 0);

  178.         LOLUNIT_ASSERT_EQUAL((int)(half)(1.0f), 1);

  179.         LOLUNIT_ASSERT_EQUAL((int)(half)(-1.0f), -1);

  180.         LOLUNIT_ASSERT_EQUAL((int)(half)(1.9f), 1);

  181.         LOLUNIT_ASSERT_EQUAL((int)(half)(-1.9f), -1);

  182.         LOLUNIT_ASSERT_EQUAL((int)(half)(65504.0f), 65504);

  183.         LOLUNIT_ASSERT_EQUAL((int)(half)(-65504.0f), -65504);

  184.     }

  185. 

  186.     LOLUNIT_TEST(FloatOpHalf)

  187.     {

  188.         half zero = 0;

  189.         half one = 1;

  190.         half two = 2;

  191. 

  192.         float a = zero + one;

  193.         LOLUNIT_ASSERT_EQUAL(1.0f, a);

  194.         a += zero;

  195.         LOLUNIT_ASSERT_EQUAL(1.0f, a);

  196.         a -= zero;

  197.         LOLUNIT_ASSERT_EQUAL(1.0f, a);

  198.         a *= one;

  199.         LOLUNIT_ASSERT_EQUAL(1.0f, a);

  200.         a /= one;

  201.         LOLUNIT_ASSERT_EQUAL(1.0f, a);

  202. 

  203.         float b = one + zero;

  204.         LOLUNIT_ASSERT_EQUAL(1.0f, b);

  205.         b += one;

  206.         LOLUNIT_ASSERT_EQUAL(2.0f, b);

  207.         b *= two;

  208.         LOLUNIT_ASSERT_EQUAL(4.0f, b);

  209.         b -= two;

  210.         LOLUNIT_ASSERT_EQUAL(2.0f, b);

  211.         b /= two;

  212.         LOLUNIT_ASSERT_EQUAL(1.0f, b);

  213. 

  214.         float c = one - zero;

  215.         LOLUNIT_ASSERT_EQUAL(1.0f, c);

  216. 

  217.         float d = two - one;

  218.         LOLUNIT_ASSERT_EQUAL(1.0f, d);

  219. 

  220.         float e = two + (-one);

  221.         LOLUNIT_ASSERT_EQUAL(1.0f, e);

  222. 

  223.         float f = (two * two) / (one + one);

  224.         LOLUNIT_ASSERT_EQUAL(2.0f, f);

  225.     }

  226. 

  227.     LOLUNIT_TEST(HalfOpFloat)

  228.     {

  229.         half zero = 0;

  230.         half one = 1;

  231.         half two = 2;

  232.         half four = 4;

  233. 

  234.         half a = one + 0.0f;

  235.         LOLUNIT_ASSERT_EQUAL(one.bits, a.bits);

  236.         a += 0.0f;

  237.         LOLUNIT_ASSERT_EQUAL(one.bits, a.bits);

  238.         a -= 0.0f;

  239.         LOLUNIT_ASSERT_EQUAL(one.bits, a.bits);

  240.         a *= 1.0f;

  241.         LOLUNIT_ASSERT_EQUAL(one.bits, a.bits);

  242.         a /= 1.0f;

  243.         LOLUNIT_ASSERT_EQUAL(one.bits, a.bits);

  244. 

  245.         half b = one + 0.0f;

  246.         LOLUNIT_ASSERT_EQUAL(one.bits, b.bits);

  247.         b += 1.0f;

  248.         LOLUNIT_ASSERT_EQUAL(two.bits, b.bits);

  249.         b *= 2.0f;

  250.         LOLUNIT_ASSERT_EQUAL(four.bits, b.bits);

  251.         b -= 2.0f;

  252.         LOLUNIT_ASSERT_EQUAL(two.bits, b.bits);

  253.         b /= 2.0f;

  254.         LOLUNIT_ASSERT_EQUAL(one.bits, b.bits);

  255. 

  256.         half c = 1.0f - zero;

  257.         LOLUNIT_ASSERT_EQUAL(one.bits, c.bits);

  258. 

  259.         half d = 2.0f - one;

  260.         LOLUNIT_ASSERT_EQUAL(one.bits, d.bits);

  261. 

  262.         half e = 2.0f + (-one);

  263.         LOLUNIT_ASSERT_EQUAL(one.bits, e.bits);

  264. 

  265.         half f = (2.0f * two) / (1.0f + one);

  266.         LOLUNIT_ASSERT_EQUAL(two.bits, f.bits);

  267.     }

  268. 

  269.     struct TestPair { float f; uint16_t x; };

  270. 

  271.     static TestPair const pairs[11];

  272. };

  273. 

  274. HalfTest::TestPair const HalfTest::pairs[] =

  275. {

  276.     /* All these values have exact half representations */

  277.     { 0.0f,      0x0000 },

  278.     { -0.0f,     0x8000 }, /* negative zero */

  279.     { 1.0f,      0x3c00 },

  280.     { -1.0f,     0xbc00 },

  281.     { 2.0f,      0x4000 },

  282.     { 0.5f,      0x3800 },

  283.     { 0.125f,    0x3000 },

  284.     { 15.9375f,  0x4bf8 },

  285.     { 31.0f / (1 << 14), 0x17c0 }, /* 0x1.fp-10 */

  286.     { 31.0f / (1 << 18), 0x07c0 }, /* 0x1.fp-14, normal float, denormal half */

  287.     { 31.0f / (1 << 19), 0x03e0 }, /* 0x1.fp-15, normal float, denormal half */

  288. };

  289. 

  290. } /* namespace lol */

  291.