lolengine
/
lol
镜像来自 https://github.com/lolengine/lol
1
0
複製 0
程式碼 問題 0 版本發佈 0 Wiki 活動
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2591 提交
5 分支
1.3 GiB
 
 
 
目錄樹: d64b117b8d
分支列表 標籤
${ item.name }
建立分支 ${ searchTerm }
從 'd64b117b8d'
${ noResults }
lol/src/t/math/real.cpp

360 line
11 KiB
原始文件 Blame 歷史記錄 

  1. //

  2. //  Lol Engine — Unit tests

  3. //

  4. //  Copyright © 2010—2014 Sam Hocevar <sam@hocevar.net>

  5. //

  6. //  This program is free software. It comes without any warranty, to

  7. //  the extent permitted by applicable law. You can redistribute it

  8. //  and/or modify it under the terms of the Do What the Fuck You Want

  9. //  to Public License, Version 2, as published by the WTFPL Task Force.

  10. //  See http://www.wtfpl.net/ for more details.

  11. //

  12. 

  13. #include <lol/engine-internal.h>

  14. 

  15. #include <cmath>

  16. 

  17. #include <lolunit.h>

  18. 

  19. namespace lol

  20. {

  21. 

  22. lolunit_declare_fixture(RealTest)

  23. {

  24.     lolunit_declare_test(Constants)

  25.     {

  26.         double a0 = real::R_0();

  27.         double a1 = real::R_1();

  28.         double a2 = real::R_2();

  29.         double a10 = real::R_10();

  30. 

  31.         lolunit_assert_equal(a0, 0.0);

  32.         lolunit_assert_equal(a1, 1.0);

  33.         lolunit_assert_equal(a2, 2.0);

  34.         lolunit_assert_equal(a10, 10.0);

  35. 

  36.         double b1 = log(real::R_E());

  37.         double b2 = log2(real::R_2());

  38.         lolunit_assert_equal(b1, 1.0);

  39.         lolunit_assert_equal(b2, 1.0);

  40. 

  41.         double c1 = exp(re(real::R_LOG2E()));

  42.         double c2 = log(exp2(real::R_LOG2E()));

  43.         lolunit_assert_equal(c1, 2.0);

  44.         lolunit_assert_equal(c2, 1.0);

  45. 

  46.         double d1 = exp(re(real::R_LOG10E()));

  47.         lolunit_assert_equal(d1, 10.0);

  48. 

  49.         double e1 = exp(real::R_LN2());

  50.         lolunit_assert_equal(e1, 2.0);

  51. 

  52.         double f1 = exp(real::R_LN10());

  53.         lolunit_assert_equal(f1, 10.0);

  54. 

  55.         double g1 = sin(real::R_PI());

  56.         double g2 = cos(real::R_PI());

  57.         lolunit_assert_doubles_equal(g1, 0.0, 1e-100);

  58.         lolunit_assert_equal(g2, -1.0);

  59. 

  60.         double h1 = sin(real::R_PI_2());

  61.         double h2 = cos(real::R_PI_2());

  62.         lolunit_assert_equal(h1, 1.0);

  63.         lolunit_assert_doubles_equal(h2, 0.0, 1e-100);

  64. 

  65.         double i1 = sin(real::R_PI_4()) * sin(real::R_PI_4());

  66.         double i2 = cos(real::R_PI_4()) * cos(real::R_PI_4());

  67.         lolunit_assert_equal(i1, 0.5);

  68.         lolunit_assert_equal(i2, 0.5);

  69.     }

  70. 

  71.     lolunit_declare_test(FloatToReal)

  72.     {

  73.         float a1 = real(0.0f);

  74.         float a2 = real(-0.0f);

  75.         float a3 = real(1.0f);

  76.         float a4 = real(-1.0f);

  77.         float a5 = real(1.5f);

  78.         float a6 = real(12345678.0f);

  79. 

  80.         lolunit_assert_equal(a1, 0.0f);

  81.         lolunit_assert_equal(a2, -0.0f);

  82.         lolunit_assert_equal(a3, 1.0f);

  83.         lolunit_assert_equal(a4, -1.0f);

  84.         lolunit_assert_equal(a5, 1.5f);

  85.         lolunit_assert_equal(a6, 12345678.0f);

  86.     }

  87. 

  88.     lolunit_declare_test(DoubleToReal)

  89.     {

  90.         double a1 = real(0.0);

  91.         double a2 = real(-0.0);

  92.         double a3 = real(1.0);

  93.         double a4 = real(-1.0);

  94.         double a5 = real(1.5);

  95.         double a6 = real(1234567876543210.0);

  96. 

  97.         lolunit_assert_doubles_equal(a1, 0.0, 0.0);

  98.         lolunit_assert_doubles_equal(a2, -0.0, 0.0);

  99.         lolunit_assert_doubles_equal(a3, 1.0, 0.0);

  100.         lolunit_assert_doubles_equal(a4, -1.0, 0.0);

  101.         lolunit_assert_doubles_equal(a5, 1.5, 0.0);

  102.         lolunit_assert_doubles_equal(a6, 1234567876543210.0, 0.0);

  103.     }

  104. 

  105.     lolunit_declare_test(Init)

  106.     {

  107.         real r;

  108.         float f1 = (float)r;

  109. 

  110.         lolunit_assert_equal(f1, 0.0f);

  111. 

  112.         rcmplx q;

  113.         float f2 = (float)q.x;

  114.         float f3 = (float)q.y;

  115. 

  116.         lolunit_assert_equal(f2, 0.0f);

  117.         lolunit_assert_equal(f3, 0.0f);

  118.     }

  119. 

  120.     lolunit_declare_test(StringToReal)

  121.     {

  122.         float a1 = real("0");

  123.         float a2 = real("1");

  124.         float a3 = real("-1");

  125.         /* 2^-128 * 2^128 */

  126.         float a4 = real("0.0000000000000000000000000000000000000029387358770"

  127.                         "557187699218413430556141945466638919302188037718792"

  128.                         "6569604314863681793212890625")

  129.                  * real("340282366920938463463374607431768211456");

  130. 

  131.         lolunit_assert_equal(a1, 0.0f);

  132.         lolunit_assert_equal(a2, 1.0f);

  133.         lolunit_assert_equal(a3, -1.0f);

  134.         lolunit_assert_equal(a4, 1.0f);

  135.     }

  136. 

  137.     lolunit_declare_test(UnaryMinus)

  138.     {

  139.         float a1 = - real(1.0f);

  140.         float a2 = - real(-1.0f);

  141.         float a3 = - real(0.0f);

  142.         float a4 = - real(-0.0f);

  143. 

  144.         lolunit_assert_equal(a1, -1.0f);

  145.         lolunit_assert_equal(a2, 1.0f);

  146.         lolunit_assert_equal(a3, -0.0f);

  147.         lolunit_assert_equal(a4, 0.0f);

  148.     }

  149. 

  150.     lolunit_declare_test(Comparison)

  151.     {

  152.         lolunit_assert(real(1.0f) > real(0.5f));

  153.         lolunit_assert(real(1.0f) >= real(0.5f));

  154.         lolunit_assert(real(1.0f) >= real(1.0f));

  155. 

  156.         lolunit_assert(real(-1.0f) < real(-0.5f));

  157.         lolunit_assert(real(-1.0f) <= real(-0.5f));

  158.         lolunit_assert(real(-1.0f) <= real(-1.0f));

  159. 

  160.         lolunit_assert(real(-1.0f) < real(0.5f));

  161.         lolunit_assert(real(-0.5f) < real(1.0f));

  162.         lolunit_assert(real(-1.0f) <= real(0.5f));

  163.         lolunit_assert(real(-0.5f) <= real(1.0f));

  164. 

  165.         lolunit_assert(real(1.0f) > real(-0.5f));

  166.         lolunit_assert(real(0.5f) > real(-1.0f));

  167.         lolunit_assert(real(1.0f) >= real(-0.5f));

  168.         lolunit_assert(real(0.5f) >= real(-1.0f));

  169.     }

  170. 

  171.     lolunit_declare_test(Addition)

  172.     {

  173.         float a1 = real(1.0f) + real(0.0f);

  174.         float a2 = real(0.0f) + real(1.0f);

  175.         float a3 = real(1.0f) + real(1.0f);

  176.         float a4 = real(-1.0f) + real(-1.0f);

  177.         float a5 = real(1.0f) + real(0.125f);

  178.         double a6 = real(3.13609818956293918)

  179.                   + real(0.00005972154828114);

  180.         float a7 = real(1.0f) + real(-0.125f);

  181.         double a8 = real(0.10000000002) + real(-2.0e-11);

  182. 

  183.         lolunit_assert_equal(a1, 1.0f);

  184.         lolunit_assert_equal(a2, 1.0f);

  185.         lolunit_assert_equal(a3, 2.0f);

  186.         lolunit_assert_equal(a4, -2.0f);

  187.         lolunit_assert_equal(a5, 1.125f);

  188.         lolunit_assert_doubles_equal(a6, 3.1361579, 0.000001);

  189.         lolunit_assert_equal(a7, 0.875f);

  190.         lolunit_assert_doubles_equal(a8, 0.1, 1.0e-13);

  191.     }

  192. 

  193.     lolunit_declare_test(Subtraction)

  194.     {

  195.         float a1 = real(1.0f) + real(1e20f) - real(1e20f);

  196. 

  197.         lolunit_assert_equal(a1, 1.0f);

  198.     }

  199. 

  200.     lolunit_declare_test(Multiplication)

  201.     {

  202.         real x(1.25f);

  203.         real y(1.5f);

  204.         real z(1.99999f);

  205.         real w(-1.5f);

  206. 

  207.         float m1 = x * x;

  208.         float m2 = y * y;

  209.         float m3 = z * z;

  210.         float m4 = w * w;

  211. 

  212.         lolunit_assert_equal(m1, 1.25f * 1.25f);

  213.         lolunit_assert_equal(m2, 1.5f * 1.5f);

  214.         lolunit_assert_equal(m3, 1.99999f * 1.99999f);

  215.         lolunit_assert_equal(m4, -1.5f * -1.5f);

  216.     }

  217. 

  218.     lolunit_declare_test(ExactDivision)

  219.     {

  220.         float m1 = real::R_1() / real::R_1();

  221.         float m2 = real::R_2() / real::R_1();

  222.         float m3 = real::R_1() / real::R_2();

  223.         float m4 = real::R_2() / real::R_2();

  224.         float m5 = real::R_1() / -real::R_2();

  225. 

  226.         lolunit_assert_equal(m1, 1.0f);

  227.         lolunit_assert_equal(m2, 2.0f);

  228.         lolunit_assert_equal(m3, 0.5f);

  229.         lolunit_assert_equal(m4, 1.0f);

  230.         lolunit_assert_equal(m5, -0.5f);

  231.     }

  232. 

  233.     lolunit_declare_test(InexactDivision)

  234.     {

  235.         /* 1 / 3 * 3 should be close to 1... check that it does not differ

  236.          * by more than 2^-k where k is the number of bits in the mantissa. */

  237.         real a = real::R_1() / real::R_3() * real::R_3();

  238.         real b = ldexp(real::R_1() - a, real::BIGITS * real::BIGIT_BITS);

  239. 

  240.         lolunit_assert_lequal((double)fabs(b), 1.0);

  241.     }

  242. 

  243.     lolunit_declare_test(LoadExp)

  244.     {

  245.         real a1(1.5);

  246.         real a2(-1.5);

  247.         real a3(0.0);

  248. 

  249.         lolunit_assert_equal((double)ldexp(a1, 7), 192.0);

  250.         lolunit_assert_equal((double)ldexp(a1, -7), 0.01171875);

  251. 

  252.         lolunit_assert_equal((double)ldexp(a2, 7), -192.0);

  253.         lolunit_assert_equal((double)ldexp(a2, -7), -0.01171875);

  254. 

  255.         lolunit_assert_equal((double)ldexp(a3, 7), 0.0);

  256.         lolunit_assert_equal((double)ldexp(a3, -7), 0.0);

  257.     }

  258. 

  259.     lolunit_declare_test(Ulp)

  260.     {

  261.         real a1 = real::R_PI();

  262. 

  263.         lolunit_assert_not_equal((double)(a1 + ulp(a1) - a1), 0.0);

  264.         lolunit_assert_equal((double)(a1 + ulp(a1) / 2 - a1), 0.0);

  265.     }

  266. 

  267.     lolunit_declare_test(Bool)

  268.     {

  269.         real a = 0.0;

  270.         lolunit_assert(!a);

  271. 

  272.         a = -0.0;

  273.         lolunit_assert(!a);

  274. 

  275.         a = 1234.0;

  276.         lolunit_assert(a);

  277.         lolunit_assert(!!a);

  278. 

  279.         a = -1234.0;

  280.         lolunit_assert(a);

  281.         lolunit_assert(!!a);

  282.     }

  283. 

  284.     lolunit_declare_test(AsinAcos)

  285.     {

  286.         double tests[] =

  287.         {

  288.             -1024.0, -1023.0, -513.0, -512.0, -511.0, -1.0, -0.0,

  289.             0.0, 1.0, 511.0, 512.0, 513.0, 1023.0, 1024.0

  290.         };

  291. 

  292.         for (double test : tests)

  293.         {

  294.             double a = test / 1024;

  295.             double b = sin(asin((real)a));

  296.             double c = cos(acos((real)a));

  297. 

  298.             lolunit_set_context(a);

  299.             lolunit_assert_doubles_equal(b, a, 1e-100);

  300.             lolunit_assert_doubles_equal(c, a, 1e-100);

  301.         }

  302.     }

  303. 

  304.     lolunit_declare_test(FloorCeilEtc)

  305.     {

  306.         double tests[] =

  307.         {

  308.             -2.0,  -2.0, -2.0,  -2.0,

  309.             -1.5,  -2.0, -1.0,  -2.0,

  310.             -1.0,  -1.0, -1.0,  -1.0,

  311.             -0.0,  -0.0, -0.0,  -0.0,

  312.              0.0,   0.0,  0.0,   0.0,

  313.              0.25,  0.0,  1.0,   0.0,

  314.              0.375, 0.0,  1.0,   0.0,

  315.              0.5,   0.0,  1.0,   1.0,

  316.              1.0,   1.0,  1.0,   1.0,

  317.              1.5,   1.0,  2.0,   2.0,

  318.              2.0,   2.0,  2.0,   2.0,

  319.              2.5,   2.0,  3.0,   3.0,

  320.              3.0,   3.0,  3.0,   3.0,

  321.             8192.0,     8192.0, 8192.0, 8192.0,

  322.             8192.03125, 8192.0, 8193.0, 8192.0,

  323.             8192.5,     8192.0, 8193.0, 8193.0,

  324.             8193.0,     8193.0, 8193.0, 8193.0,

  325.             549755813888.0,     549755813888.0, 549755813888.0, 549755813888.0,

  326.             549755813888.03125, 549755813888.0, 549755813889.0, 549755813888.0,

  327.             549755813888.5,     549755813888.0, 549755813889.0, 549755813889.0,

  328.             549755813889.0,     549755813889.0, 549755813889.0, 549755813889.0,

  329.         };

  330. 

  331.         for (unsigned int n = 0; n < sizeof(tests) / sizeof(*tests); n += 4)

  332.         {

  333.             double a0 = floor((real)tests[n]);

  334.             double b0 = tests[n + 1];

  335.             double a1 = ceil((real)tests[n]);

  336.             double b1 = tests[n + 2];

  337.             double a2 = round((real)tests[n]);

  338.             double b2 = tests[n + 3];

  339. 

  340.             lolunit_assert_equal(b0, a0);

  341.             lolunit_assert_equal(b1, a1);

  342.             lolunit_assert_equal(b2, a2);

  343.         }

  344.     }

  345. 

  346.     lolunit_declare_test(Pow)

  347.     {

  348.         double a1 = pow(-real::R_2(), real::R_2());

  349.         double b1 = 4.0;

  350.         lolunit_assert_doubles_equal(a1, b1, 1.0e-13);

  351. 

  352.         double a2 = pow(-real::R_2(), real::R_3());

  353.         double b2 = -8.0;

  354.         lolunit_assert_doubles_equal(a2, b2, 1.0e-13);

  355.     }

  356. };

  357. 

  358. } /* namespace lol */