Core/Utilities/MathHelpersTests.cpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/data/test_case.hpp>
0010 #include <boost/test/unit_test.hpp>
0011
0012 #include "Acts/Utilities/ArrayHelpers.hpp"
0013 #include "Acts/Utilities/MathHelpers.hpp"
0014 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0015
0016 #include <cmath>
0017
0018 namespace bdata = boost::unit_test::data;
0019
0020 const auto expDist = bdata::random(
0021     (bdata::engine = std::mt19937{}, bdata::seed = 0,
0022      bdata::distribution = std::uniform_real_distribution<double>(-4, 4)));
0023
0024 namespace ActsTetsts {
0025
0026 BOOST_AUTO_TEST_SUITE(UtilitiesSuite)
0027
0028 BOOST_DATA_TEST_CASE(fastHypot, expDist ^ expDist ^ bdata::xrange(100), xExp,
0029                      yExp, i) {
0030   static_cast<void>(i);
0031
0032   const double x = std::pow(10, xExp);
0033   const double y = std::pow(10, yExp);
0034
0035   const float fastFloat =
0036       Acts::fastHypot(static_cast<float>(x), static_cast<float>(y));
0037   const double fastDouble = Acts::fastHypot(x, y);
0038
0039   const float stdFloat =
0040       std::hypot(static_cast<float>(x), static_cast<float>(y));
0041   const double stdDouble = std::hypot(x, y);
0042
0043   CHECK_CLOSE_REL(stdFloat, fastFloat, 1e-6);
0044   CHECK_CLOSE_REL(stdDouble, fastDouble, 1e-6);
0045 }
0046
0047 BOOST_AUTO_TEST_CASE(Factorial) {
0048   static_assert(Acts::factorial(0u) == 1u);
0049   static_assert(Acts::factorial(1u) == 1u);
0050   static_assert(Acts::factorial(2u) == 2u);
0051
0052   for (std::size_t k = 3; k <= 20; ++k) {
0053     BOOST_CHECK_EQUAL(Acts::factorial(k), k * Acts::factorial(k - 1u));
0054     for (std::size_t j = 1; j <= k; ++j) {
0055       BOOST_CHECK_EQUAL(Acts::product(j, k),
0056                         Acts::factorial(k) / Acts::factorial(j - 1));
0057     }
0058   }
0059 }
0060
0061 BOOST_AUTO_TEST_CASE(PowerTests) {
0062   for (unsigned p = 0; p <= 15; ++p) {
0063     BOOST_CHECK_EQUAL(std::pow(2., p), Acts::pow(2., p));
0064     BOOST_CHECK_EQUAL(std::pow(0.5, p), Acts::pow(0.5, p));
0065     for (std::size_t k = 1; k <= 15; ++k) {
0066       BOOST_CHECK_EQUAL(std::pow(k, p), Acts::pow(k, p));
0067     }
0068   }
0069   for (int p = 0; p <= 15; ++p) {
0070     BOOST_CHECK_EQUAL(std::pow(2., p), Acts::pow(2., p));
0071     BOOST_CHECK_EQUAL(std::pow(2., -p), Acts::pow(2., -p));
0072     BOOST_CHECK_EQUAL(std::pow(0.5, p), Acts::pow(0.5, p));
0073
0074     BOOST_CHECK_EQUAL(std::pow(0.5, -p), Acts::pow(0.5, -p));
0075   }
0076 }
0077
0078 BOOST_AUTO_TEST_CASE(SumOfIntegers) {
0079   std::array<unsigned, 100> numberSeq{Acts::filledArray<unsigned, 100>(1)};
0080   std::iota(numberSeq.begin(), numberSeq.end(), 1);
0081   for (unsigned i = 1; i <= numberSeq.size(); ++i) {
0082     const unsigned sum =
0083         std::accumulate(numberSeq.begin(), numberSeq.begin() + i, 0);
0084     BOOST_CHECK_EQUAL(sum, Acts::sumUpToN(i));
0085   }
0086 }
0087
0088 BOOST_AUTO_TEST_CASE(BinomialTests) {
0089   BOOST_CHECK_EQUAL(Acts::binomial(1u, 1u), 1u);
0090   for (unsigned n = 2; n <= 10; ++n) {
0091     /// Check that the binomial of (n 1 is always n)
0092     BOOST_CHECK_EQUAL(Acts::binomial(n, 1u), n);
0093     for (unsigned k = 1; k <= n - 1u; ++k) {
0094       /// Use recursive formula
0095       ///  n      n -1       n -1
0096       ///     =          +
0097       ///  k      k -1        k
0098       std::cout << "n: " << n << ", k: " << k
0099                 << ", binom(n,k): " << Acts::binomial(n, k)
0100                 << ", binom(n-1, k-1): " << Acts::binomial(n - 1, k - 1)
0101                 << ", binom(n-1,k): " << Acts::binomial(n - 1, k) << std::endl;
0102       BOOST_CHECK_EQUAL(Acts::binomial(n, k), Acts::binomial(n - 1, k - 1) +
0103                                                   Acts::binomial(n - 1, k));
0104       BOOST_CHECK_EQUAL(Acts::binomial(n, k), Acts::binomial(n, n - k));
0105     }
0106   }
0107 }
0108
0109 BOOST_AUTO_TEST_CASE(CopySign) {
0110   BOOST_CHECK_EQUAL(Acts::copySign(5, -10), -5);
0111   BOOST_CHECK_EQUAL(Acts::copySign(5, 0), 5);
0112   BOOST_CHECK_EQUAL(Acts::copySign(5, 55), 5);
0113
0114   static_assert(Acts::copySign(5, -10) == -5);
0115   static_assert(Acts::copySign(5, 0) == 5);
0116   static_assert(Acts::copySign(5, 55) == 5);
0117
0118   BOOST_CHECK_EQUAL(Acts::copySign(5, -std::numeric_limits<double>::infinity()),
0119                     -5);
0120   BOOST_CHECK_EQUAL(Acts::copySign(5, std::numeric_limits<double>::infinity()),
0121                     5);
0122
0123   static_assert(Acts::copySign(5., -std::numeric_limits<double>::infinity()) ==
0124                 -5.);
0125   static_assert(Acts::copySign(5., 0) == 5);
0126   static_assert(Acts::copySign(5., std::numeric_limits<double>::infinity()) ==
0127                 5.);
0128
0129   BOOST_CHECK_EQUAL(Acts::copySign(5., -10.), -5.);
0130   BOOST_CHECK_EQUAL(Acts::copySign(5., 0.), 5.);
0131   BOOST_CHECK_EQUAL(Acts::copySign(5., 55.), 5.);
0132
0133   enum class CopyEnum : int { b = 1, a = -1, c = 0 };
0134   BOOST_CHECK_EQUAL(Acts::copySign(5, CopyEnum::a), -5);
0135   BOOST_CHECK_EQUAL(Acts::copySign(5, CopyEnum::b), 5);
0136   BOOST_CHECK_EQUAL(Acts::copySign(5, CopyEnum::c), 5);
0137
0138   const Acts::Vector3 v{Acts::Vector3::UnitZ()};
0139   CHECK_CLOSE_ABS(Acts::copySign(v, -1).dot(v), -1., 1.e-7);
0140   CHECK_CLOSE_ABS(Acts::copySign(v, 1).dot(v), 1., 1.e-7);
0141 }
0142
0143 BOOST_AUTO_TEST_SUITE_END()
0144
0145 }  // namespace ActsTetsts