lolengine
/
lol
spogulis no https://github.com/lolengine/lol
1
0
Atdalīts 0
Kods Problēmas 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
520 Revīzijas
5 Atzari
18 MiB
Koks: 56511457d2
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '56511457d2'
${ noResults }
lol/test/unit/trig.cpp

trig.cpp 4.3 KiB
Neapstrādāts Parastais skats Vēsture

test: new test for trigonometric functions.
pirms 13 gadiem
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
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.
pirms 13 gadiem
test: new test for trigonometric functions.
pirms 13 gadiem
​
​
​
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.
pirms 13 gadiem
test: new test for trigonometric functions.
pirms 13 gadiem
test: give more explicit names to unit test cases.
pirms 13 gadiem
test: new test for trigonometric functions.
pirms 13 gadiem
​
​
test: do the trigonometry tests on doubles instead of floats.
pirms 13 gadiem
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
test: new test for trigonometric functions.
pirms 13 gadiem
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
​
​
test: new test for trigonometric functions.
pirms 13 gadiem
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.
pirms 13 gadiem
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.
pirms 13 gadiem
test: new test for trigonometric functions.
pirms 13 gadiem
​
​
​
test: do the trigonometry tests on doubles instead of floats.
pirms 13 gadiem
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
test: new test for trigonometric functions.
pirms 13 gadiem
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
​
​
test: new test for trigonometric functions.
pirms 13 gadiem
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.
pirms 13 gadiem
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.
pirms 13 gadiem
test: new test for trigonometric functions.
pirms 13 gadiem
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.
pirms 13 gadiem
core: implement accelerated cos().
pirms 13 gadiem
test: give more explicit names to unit test cases.
pirms 13 gadiem
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.
pirms 13 gadiem
core: implement accelerated cos().
pirms 13 gadiem
​
​
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
core: implement accelerated cos().
pirms 13 gadiem
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
​
​
core: implement accelerated cos().
pirms 13 gadiem
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.
pirms 13 gadiem
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.
pirms 13 gadiem
core: implement accelerated cos().
pirms 13 gadiem
​
​
​
​
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
core: implement accelerated cos().
pirms 13 gadiem
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
​
​
core: implement accelerated cos().
pirms 13 gadiem
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.
pirms 13 gadiem
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.
pirms 13 gadiem
core: implement accelerated cos().
pirms 13 gadiem
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.
pirms 13 gadiem
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
test: give more explicit names to unit test cases.
pirms 13 gadiem
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.
pirms 13 gadiem
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
​
​
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
​
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
​
​
​
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
​
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.
pirms 13 gadiem
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.
pirms 13 gadiem
​
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
​
​
​
​
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
​
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
​
​
​
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
​
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.
pirms 13 gadiem
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.
pirms 13 gadiem
​
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
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.
pirms 13 gadiem
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
test: give more explicit names to unit test cases.
pirms 13 gadiem
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.
pirms 13 gadiem
core: improve tan() accuracy by tweaking higher order Taylor coefficients.
pirms 13 gadiem
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
core: improve tan() accuracy by tweaking higher order Taylor coefficients.
pirms 13 gadiem
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
​
​
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
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.
pirms 13 gadiem
core: improve tan() accuracy by tweaking higher order Taylor coefficients.
pirms 13 gadiem
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.
pirms 13 gadiem
core: improve tan() accuracy by tweaking higher order Taylor coefficients.
pirms 13 gadiem
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.
pirms 13 gadiem
core: improve tan() accuracy by tweaking higher order Taylor coefficients.
pirms 13 gadiem
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.
pirms 13 gadiem
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
​
​
​
​
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
test: add a few Visual Studio 2010 project files and fix testsuite code so that it builds properly.
pirms 13 gadiem
​
​
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
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.
pirms 13 gadiem
core: improve tan() accuracy by tweaking higher order Taylor coefficients.
pirms 13 gadiem
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.
pirms 13 gadiem
core: improve tan() accuracy by tweaking higher order Taylor coefficients.
pirms 13 gadiem
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.
pirms 13 gadiem
core: improve tan() accuracy by tweaking higher order Taylor coefficients.
pirms 13 gadiem
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.
pirms 13 gadiem
core: implement accelerated lol_sincos() and lol_tan().
pirms 13 gadiem
test: new test for trigonometric functions.
pirms 13 gadiem
​
​
​
​
 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161 
  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://sam.zoy.org/projects/COPYING.WTFPL for more details.

  9. //

  10. 

  11. #if defined HAVE_CONFIG_H

  12. #   include "config.h"

  13. #endif

  14. 

  15. #include <cmath>

  16. 

  17. #include "core.h"

  18. #include "lol/unit.h"

  19. 

  20. namespace lol

  21. {

  22. 

  23. LOLUNIT_FIXTURE(TrigTest)

  24. {

  25.     LOLUNIT_TEST(Sin)

  26.     {

  27.         for (int i = -10000; i < 10000; i++)

  28.         {

  29.             double f = (double)i * (1.0 / 1000.0);

  30. #if defined __GNUC__

  31.             double a = __builtin_sin(f);

  32. #else

  33.             double a = sin(f);

  34. #endif

  35.             double b = lol_sin(f);

  36.             LOLUNIT_SET_CONTEXT(f);

  37.             LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);

  38.         }

  39. 

  40.         for (int i = -10000; i < 10000; i++)

  41.         {

  42.             double f = (double)i * (1.0 / 100000.0);

  43. #if defined __GNUC__

  44.             double a = __builtin_sin(f);

  45. #else

  46.             double a = sin(f);

  47. #endif

  48.             double b = lol_sin(f);

  49.             LOLUNIT_SET_CONTEXT(f);

  50.             LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);

  51.         }

  52.     }

  53. 

  54.     LOLUNIT_TEST(Cos)

  55.     {

  56.         for (int i = -10000; i < 10000; i++)

  57.         {

  58.             double f = (double)i * (1.0 / 1000.0);

  59. #if defined __GNUC__

  60.             double a = __builtin_cos(f);

  61. #else

  62.             double a = cos(f);

  63. #endif

  64.             double b = lol_cos(f);

  65.             LOLUNIT_SET_CONTEXT(f);

  66.             LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);

  67.         }

  68. 

  69.         for (int i = -10000; i < 10000; i++)

  70.         {

  71.             double f = (double)i * (1.0 / 100000.0);

  72. #if defined __GNUC__

  73.             double a = __builtin_cos(f);

  74. #else

  75.             double a = cos(f);

  76. #endif

  77.             double b = lol_cos(f);

  78.             LOLUNIT_SET_CONTEXT(f);

  79.             LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);

  80.         }

  81.     }

  82. 

  83.     LOLUNIT_TEST(SinCos)

  84.     {

  85.         for (int i = -10000; i < 10000; i++)

  86.         {

  87.             double f = (double)i * (1.0 / 1000.0);

  88. #if defined __GNUC__

  89.             double a1 = __builtin_sin(f);

  90.             double a2 = __builtin_cos(f);

  91. #else

  92.             double a1 = sin(f);

  93.             double a2 = cos(f);

  94. #endif

  95.             double b1, b2;

  96.             lol_sincos(f, &b1, &b2);

  97.             LOLUNIT_SET_CONTEXT(f);

  98.             LOLUNIT_ASSERT_DOUBLES_EQUAL(a1, b1, fabs(f) * 1e-11);

  99.             LOLUNIT_ASSERT_DOUBLES_EQUAL(a2, b2, fabs(f) * 1e-11);

  100.         }

  101. 

  102.         for (int i = -10000; i < 10000; i++)

  103.         {

  104.             double f = (double)i * (1.0 / 100000.0);

  105. #if defined __GNUC__

  106.             double a1 = __builtin_sin(f);

  107.             double a2 = __builtin_cos(f);

  108. #else

  109.             double a1 = sin(f);

  110.             double a2 = cos(f);

  111. #endif

  112.             double b1, b2;

  113.             lol_sincos(f, &b1, &b2);

  114.             LOLUNIT_SET_CONTEXT(f);

  115.             LOLUNIT_ASSERT_DOUBLES_EQUAL(a1, b1, fabs(f) * 1e-11);

  116.             LOLUNIT_ASSERT_DOUBLES_EQUAL(a2, b2, fabs(f) * 1e-11);

  117.         }

  118.     }

  119. 

  120.     LOLUNIT_TEST(Tan)

  121.     {

  122.         for (int i = -100000; i < 100000; i++)

  123.         {

  124.             double f = (double)i * (1.0 / 10000.0);

  125. #if defined __GNUC__

  126.             double a = __builtin_tan(f);

  127. #else

  128.             double a = tan(f);

  129. #endif

  130.             double b = lol_tan(f);

  131.             LOLUNIT_SET_CONTEXT(f);

  132.             if (fabs(a) > 1e4)

  133.                 LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(a) * fabs(a) * 1e-11);

  134.             else if (fabs(a) > 1.0)

  135.                 LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(a) * 1e-11);

  136.             else

  137.                 LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);

  138.         }

  139. 

  140.         for (int i = -10000; i < 10000; i++)

  141.         {

  142.             double f = (double)i * (1.0 / 100000.0);

  143. #if defined __GNUC__

  144.             double a = __builtin_tan(f);

  145. #else

  146.             double a = tan(f);

  147. #endif

  148.             double b = lol_tan(f);

  149.             LOLUNIT_SET_CONTEXT(f);

  150.             if (fabs(a) > 1e4)

  151.                 LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(a) * fabs(a) * 1e-11);

  152.             else if (fabs(a) > 1.0)

  153.                 LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(a) * 1e-11);

  154.             else

  155.                 LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);

  156.         }

  157.     }

  158. };

  159. 

  160. } /* namespace lol */

  161.