lolengine
/
lol
mirror of https://github.com/lolengine/lol
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
2600 Commits
5 Branches
1.3 GiB
 
 
 
Tree: a327a68478
lol/src/t/math/polynomial.cpp

339 lines
9.3 KiB
Raw Blame History 

  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 <lolunit.h>

  16. 

  17. namespace lol

  18. {

  19. 

  20. lolunit_declare_fixture(PolynomialTest)

  21. {

  22.     lolunit_declare_test(Declaration)

  23.     {

  24.         polynomial<float> p;

  25.         polynomial<real> q;

  26.     }

  27. 

  28.     lolunit_declare_test(Init)

  29.     {

  30.         polynomial<float> p { };

  31.         lolunit_assert_equal(p[0], 0.f);

  32.         lolunit_assert_equal(p[1], 0.f);

  33.         lolunit_assert_equal(p[2], 0.f);

  34.         lolunit_assert_equal(p.degree(), -1);

  35. 

  36.         polynomial<float> q { 1.f };

  37.         lolunit_assert_equal(q[0], 1.f);

  38.         lolunit_assert_equal(q[1], 0.f);

  39.         lolunit_assert_equal(q[2], 0.f);

  40.         lolunit_assert_equal(q.degree(), 0);

  41. 

  42.         polynomial<float> r { 1.f, 2.f };

  43.         lolunit_assert_equal(r[0], 1.f);

  44.         lolunit_assert_equal(r[1], 2.f);

  45.         lolunit_assert_equal(r[2], 0.f);

  46.         lolunit_assert_equal(r.degree(), 1);

  47. 

  48.         polynomial<float> s { 0.f };

  49.         lolunit_assert_equal(s[0], 0.f);

  50.         lolunit_assert_equal(s[1], 0.f);

  51.         lolunit_assert_equal(s[2], 0.f);

  52.         lolunit_assert_equal(s.degree(), -1);

  53.     }

  54. 

  55.     lolunit_declare_test(Derive)

  56.     {

  57.         polynomial<float> p {};

  58.         p = p.derive();

  59.         lolunit_assert_equal(p.degree(), -1);

  60. 

  61.         polynomial<float> q { 1.f };

  62.         q = q.derive();

  63.         lolunit_assert_equal(q.degree(), -1);

  64. 

  65.         polynomial<float> r { 1.f, 2.f };

  66.         r = r.derive();

  67.         lolunit_assert_equal(r.degree(), 0);

  68.         lolunit_assert_equal(r[0], 2.f);

  69. 

  70.         polynomial<float> s { 1.f, 2.f, 3.f, 4.f };

  71.         s = s.derive();

  72.         lolunit_assert_equal(s.degree(), 2);

  73.         lolunit_assert_equal(s[0], 2.f);

  74.         lolunit_assert_equal(s[1], 6.f);

  75.         lolunit_assert_equal(s[2], 12.f);

  76.     }

  77. 

  78.     lolunit_declare_test(Eval)

  79.     {

  80.         /* Special null polynomial */

  81.         polynomial<float> p;

  82. 

  83.         float a = p.eval(42.f);

  84.         lolunit_assert_equal(a, 0.f);

  85.     }

  86. 

  87.     lolunit_declare_test(Eval0)

  88.     {

  89.         /* Constant polynomial p(x) = 1 */

  90.         polynomial<float> p { 1.f };

  91. 

  92.         float a = p.eval(42.f);

  93.         lolunit_assert_equal(a, 1.f);

  94.     }

  95. 

  96.     lolunit_declare_test(Eval1)

  97.     {

  98.         /* p(x) = 1 + 2x */

  99.         polynomial<float> p { 1.f, 2.f };

  100. 

  101.         float a = p.eval(0.f);

  102.         lolunit_assert_equal(a, 1.f);

  103. 

  104.         float b = p.eval(1.f);

  105.         lolunit_assert_equal(b, 3.f);

  106. 

  107.         float c = p.eval(2.f);

  108.         lolunit_assert_equal(c, 5.f);

  109.     }

  110. 

  111.     lolunit_declare_test(Eval2)

  112.     {

  113.         /* p(x) = 1 + 2x + 3x² */

  114.         polynomial<float> p { 1.f, 2.f, 3.f };

  115. 

  116.         float a = p.eval(0.f);

  117.         lolunit_assert_equal(a, 1.f);

  118. 

  119.         float b = p.eval(1.f);

  120.         lolunit_assert_equal(b, 6.f);

  121. 

  122.         float c = p.eval(2.f);

  123.         lolunit_assert_equal(c, 17.f);

  124.     }

  125. 

  126.     lolunit_declare_test(UnaryPlusMinus)

  127.     {

  128.         /* p(x) = 1 + 2x + 3x² */

  129.         polynomial<float> p { 1.f, 2.f, 3.f };

  130.         polynomial<float> q = +p;

  131.         polynomial<float> r = -p;

  132. 

  133.         lolunit_assert_equal(q[0], 1.f);

  134.         lolunit_assert_equal(q[1], 2.f);

  135.         lolunit_assert_equal(q[2], 3.f);

  136. 

  137.         lolunit_assert_equal(r[0], -1.f);

  138.         lolunit_assert_equal(r[1], -2.f);

  139.         lolunit_assert_equal(r[2], -3.f);

  140.     }

  141. 

  142.     lolunit_declare_test(Addition)

  143.     {

  144.         /* p(x) = 1 + 2x + 3x² */

  145.         /* q(x) = 4 + 5x */

  146.         polynomial<float> p { 1.f, 2.f, 3.f };

  147.         polynomial<float> q { 4.f, 5.f };

  148. 

  149.         /* r(x) = 5 + 7x + 3x² */

  150.         polynomial<float> r = p + q;

  151.         lolunit_assert_equal(r.degree(), 2);

  152.         lolunit_assert_equal(r[0], 5.f);

  153.         lolunit_assert_equal(r[1], 7.f);

  154.         lolunit_assert_equal(r[2], 3.f);

  155.     }

  156. 

  157.     lolunit_declare_test(Subtraction)

  158.     {

  159.         /* p(x) = 1 + 2x + 3x² */

  160.         /* q(x) = 4 + 5x */

  161.         polynomial<float> p { 1.f, 2.f, 3.f };

  162.         polynomial<float> q { 4.f, 5.f };

  163. 

  164.         /* r(x) = -3 + -3x + 3x² */

  165.         polynomial<float> r = p - q;

  166.         lolunit_assert_equal(r.degree(), 2);

  167.         lolunit_assert_equal(r[0], -3.f);

  168.         lolunit_assert_equal(r[1], -3.f);

  169.         lolunit_assert_equal(r[2], 3.f);

  170.     }

  171. 

  172.     lolunit_declare_test(Multiplication)

  173.     {

  174.         /* p(x) = 1 + 2x + 3x² */

  175.         /* q(x) = 4 + 5x */

  176.         polynomial<float> p { 1.f, 2.f, 3.f };

  177.         polynomial<float> q { 4.f, 5.f };

  178. 

  179.         /* r(x) = 4 + 13x + 22x² + 15x³ */

  180.         polynomial<float> r = p * q;

  181.         lolunit_assert_equal(r.degree(), 3);

  182.         lolunit_assert_equal(r[0], 4.f);

  183.         lolunit_assert_equal(r[1], 13.f);

  184.         lolunit_assert_equal(r[2], 22.f);

  185.         lolunit_assert_equal(r[3], 15.f);

  186.     }

  187. 

  188.     lolunit_declare_test(Division)

  189.     {

  190.         /* p(x) = -4 - 2x² + x³ */

  191.         /* q(x) = -3 + x */

  192.         polynomial<float> p { -4.f, 0.f, -2.f, 1.f };

  193.         polynomial<float> q { -3.f, 1.f };

  194. 

  195.         /* p(x) = r(x) q(x) + s(x)

  196.          * r(x) = 3 + x + x²

  197.          * s(x) = 5 */

  198.         auto r = p / q;

  199.         lolunit_assert_equal(r.m1.degree(), 2);

  200.         lolunit_assert_doubles_equal(r.m1[0], 3.f, 1e-5f);

  201.         lolunit_assert_doubles_equal(r.m1[1], 1.f, 1e-5f);

  202.         lolunit_assert_doubles_equal(r.m1[2], 1.f, 1e-5f);

  203.         lolunit_assert_equal(r.m2.degree(), 0);

  204.         lolunit_assert_doubles_equal(r.m2[0], 5.f, 1e-5f);

  205.     }

  206. 

  207.     lolunit_declare_test(Composition1)

  208.     {

  209.         /* p(x) = 1 + x² */

  210.         polynomial<float> p({ 1, 0, 1 });

  211. 

  212.         /* q(x) = (p o p)(x) = 2 + 2x² + x⁴ */

  213.         polynomial<float> q = p.eval(p);

  214.         lolunit_assert_equal(q.degree(), 4);

  215.         lolunit_assert_equal(q[0], 2.f);

  216.         lolunit_assert_equal(q[1], 0.f);

  217.         lolunit_assert_equal(q[2], 2.f);

  218.         lolunit_assert_equal(q[3], 0.f);

  219.         lolunit_assert_equal(q[4], 1.f);

  220.     }

  221. 

  222.     lolunit_declare_test(Composition2)

  223.     {

  224.         /* p(x) = 1 + x */

  225.         polynomial<float> p({ 1, 1 });

  226. 

  227.         /* q(x) = 1 + x + x² */

  228.         polynomial<float> q({ 1, 1, 1 });

  229. 

  230.         /* r(x) = (q o p)(x) = 3 + 3x + x² */

  231.         polynomial<float> r = q.eval(p);

  232.         lolunit_assert_equal(r.degree(), 2);

  233.         lolunit_assert_equal(r[0], 3.f);

  234.         lolunit_assert_equal(r[1], 3.f);

  235.         lolunit_assert_equal(r[2], 1.f);

  236.     }

  237. 

  238.     lolunit_declare_test(RootsDegree0)

  239.     {

  240.         /* p(x) = 42 */

  241.         polynomial<float> p { 42.f };

  242.         auto roots = p.roots();

  243. 

  244.         lolunit_assert_equal(roots.count(), 0);

  245.     }

  246. 

  247.     lolunit_declare_test(RootsDegree1)

  248.     {

  249.         /* p(x) = -6 + 2x */

  250.         polynomial<float> p { -6.f, 2.f };

  251.         auto roots = p.roots();

  252. 

  253.         lolunit_assert_equal(roots.count(), 1);

  254.         lolunit_assert_equal(roots[0], 3.f);

  255.     }

  256. 

  257.     lolunit_declare_test(RootsDegree2)

  258.     {

  259.         /* p(x) = 81 - 18x + x² */

  260.         polynomial<float> p { 81.f, -18.f, 1.f };

  261.         auto roots1 = p.roots();

  262. 

  263.         lolunit_assert_equal(roots1.count(), 1);

  264.         lolunit_assert_equal(roots1[0], 9.f);

  265. 

  266.         /* p(x) = 42 - 20x + 2x² */

  267.         polynomial<float> q { 42.f, -20.f, 2.f };

  268.         auto roots2 = q.roots();

  269. 

  270.         lolunit_assert_equal(roots2.count(), 2);

  271.         lolunit_assert_equal(roots2[0], 3.f);

  272.         lolunit_assert_equal(roots2[1], 7.f);

  273.     }

  274. 

  275. #ifdef ENABLE_3SOLVE

  276.     lolunit_declare_test(RootsDegree3TripleSolution)

  277.     {

  278.         polynomial<float> p { 1.f, 3.f, 3.f, 1.f };

  279.         auto roots1 = p.roots();

  280. 

  281.         lolunit_assert_equal(roots1.count(), 3);

  282.     }

  283. 

  284.     lolunit_declare_test(RootsDegree3DoubleSolution)

  285.     {

  286.         polynomial<float> p { 2.f, 5.f, 4.f, 1.f };

  287.         auto roots1 = p.roots();

  288. 

  289.         lolunit_assert_equal(roots1.count(), 3);

  290.     }

  291. 

  292.     lolunit_declare_test(RootsDegree3SingleSolutions)

  293.     {

  294.         polynomial<float> p { 6.f, 11.f, 6.f, 1.f };

  295.         auto roots1 = p.roots();

  296. 

  297.         lolunit_assert_equal(roots1.count(), 3);

  298.     }

  299. #endif

  300. 

  301.     lolunit_declare_test(Chebyshev)

  302.     {

  303.         polynomial<float> t0 = polynomial<float>::chebyshev(0);

  304.         polynomial<float> t1 = polynomial<float>::chebyshev(1);

  305.         polynomial<float> t2 = polynomial<float>::chebyshev(2);

  306.         polynomial<float> t3 = polynomial<float>::chebyshev(3);

  307.         polynomial<float> t4 = polynomial<float>::chebyshev(4);

  308. 

  309.         /* Taken from the sequence at http://oeis.org/A028297 */

  310.         lolunit_assert_equal(t0.degree(), 0);

  311.         lolunit_assert_equal(t0[0], 1.f);

  312. 

  313.         lolunit_assert_equal(t1.degree(), 1);

  314.         lolunit_assert_equal(t1[0], 0.f);

  315.         lolunit_assert_equal(t1[1], 1.f);

  316. 

  317.         lolunit_assert_equal(t2.degree(), 2);

  318.         lolunit_assert_equal(t2[0], -1.f);

  319.         lolunit_assert_equal(t2[1], 0.f);

  320.         lolunit_assert_equal(t2[2], 2.f);

  321. 

  322.         lolunit_assert_equal(t3.degree(), 3);

  323.         lolunit_assert_equal(t3[0], 0.f);

  324.         lolunit_assert_equal(t3[1], -3.f);

  325.         lolunit_assert_equal(t3[2], 0.f);

  326.         lolunit_assert_equal(t3[3], 4.f);

  327. 

  328.         lolunit_assert_equal(t4.degree(), 4);

  329.         lolunit_assert_equal(t4[0], 1.f);

  330.         lolunit_assert_equal(t4[1], 0.f);

  331.         lolunit_assert_equal(t4[2], -8.f);

  332.         lolunit_assert_equal(t4[3], 0.f);

  333.         lolunit_assert_equal(t4[4], 8.f);

  334.     }

  335. };

  336. 

  337. } /* namespace lol */