ceph/src/boost/libs/multiprecision/test/test_mpfi_precisions.cpp

   1 ///////////////////////////////////////////////////////////////
   2 //  Copyright Christopher Kormanyos 2002 - 2011.
   3 //  Copyright 2011 John Maddock. Distributed under the Boost
   4 //  Software License, Version 1.0. (See accompanying file
   5 //  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
   6 //
   7 // This work is based on an earlier work:
   8 // "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
   9 // in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
  10
  11 #ifdef _MSC_VER
  12 #define _SCL_SECURE_NO_WARNINGS
  13 #endif
  14
  15 #include <boost/detail/lightweight_test.hpp>
  16 #include "test.hpp"
  17
  18 #include <boost/multiprecision/mpfi.hpp>
  19
  20 template <class T>
  21 T make_rvalue_copy(const T a)
  22 {
  23    return a;
  24 }
  25
  26 int main()
  27 {
  28    using namespace boost::multiprecision;
  29    //
  30    // Test change of default precision:
  31    //
  32    mpfi_float::default_precision(100);
  33    mpfi_float a("0.1");
  34    BOOST_CHECK_EQUAL(a.precision(), 100);
  35    mpfi_float::default_precision(20);
  36    {
  37       // test assignment from lvalue:
  38       mpfi_float b(2);
  39       BOOST_CHECK_EQUAL(b.precision(), 20);
  40       b = a;
  41       BOOST_CHECK_EQUAL(b.precision(), a.precision());
  42    }
  43    {
  44       // test assignment from rvalue:
  45       mpfi_float b(2);
  46       BOOST_CHECK_EQUAL(b.precision(), 20);
  47       b = make_rvalue_copy(a);
  48       BOOST_CHECK_EQUAL(b.precision(), a.precision());
  49    }
  50    mpfi_float::default_precision(20);
  51    {
  52       // test construct from lvalue:
  53       mpfi_float b(a);
  54       BOOST_CHECK_EQUAL(b.precision(), 100);
  55    }
  56    {
  57       // test construct from rvalue:
  58       mpfi_float b(make_rvalue_copy(a));
  59       BOOST_CHECK_EQUAL(b.precision(), 100);
  60    }
  61    {
  62       mpfi_float f150(2, 2, 150);
  63       BOOST_CHECK_EQUAL(f150.precision(), 150);
  64    }
  65    {
  66       mpfi_float f150("1.2", "1.2", 150);
  67       BOOST_CHECK_EQUAL(f150.precision(), 150);
  68    }
  69    //
  70    // From https://github.com/boostorg/multiprecision/issues/65
  71    //
  72    {
  73       mpfi_float a(2);
  74       a.precision(100);
  75       BOOST_CHECK_EQUAL(a, 2);
  76       BOOST_CHECK_EQUAL(a.precision(), 100);
  77    }
  78
  79    //
  80    // string_view with explicit precision:
  81    //
  82 #ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
  83    {
  84       std::string      s("222");
  85       std::string_view v(s.c_str(), 1);
  86       mpfi_float       f(v, v, 100);
  87       BOOST_CHECK_EQUAL(f, 2);
  88       BOOST_CHECK_EQUAL(f.precision(), 100);
  89    }
  90 #endif
  91    // Swap:
  92    {
  93       mpfi_float x(2, 2, 100); // 100 digits precision.
  94       mpfi_float y(3, 3, 50);  // 50 digits precision.
  95       swap(x, y);
  96       BOOST_CHECK_EQUAL(x, 3);
  97       BOOST_CHECK_EQUAL(y, 2);
  98       BOOST_CHECK_EQUAL(x.precision(), 50);
  99       BOOST_CHECK_EQUAL(y.precision(), 100);
 100       x.swap(y);
 101       BOOST_CHECK_EQUAL(x, 2);
 102       BOOST_CHECK_EQUAL(y, 3);
 103       BOOST_CHECK_EQUAL(x.precision(), 100);
 104       BOOST_CHECK_EQUAL(y.precision(), 50);
 105       x = std::move(mpfi_float(y));
 106       BOOST_CHECK_EQUAL(x, y);
 107       BOOST_CHECK_EQUAL(x.precision(), y.precision());
 108    }
 109    {
 110       mpfi_float c(4), d(8), e(9), f;
 111       f = (c + d) * d / e;
 112       mpfi_float g((c + d) * d / e);
 113    }
 114    {
 115       mpfi_float::default_precision(100);
 116       mpfi_float f1;
 117       f1 = 3;
 118       BOOST_CHECK_EQUAL(f1.precision(), 100);
 119       f1 = 3.5;
 120       BOOST_CHECK_EQUAL(f1.precision(), 100);
 121       mpfi_float f2(3.5);
 122       BOOST_CHECK_EQUAL(f2.precision(), 100);
 123       mpfi_float f3("5.1");
 124       BOOST_CHECK_EQUAL(f3.precision(), 100);
 125
 126       mpfi_float::default_precision(50);
 127       mpfi_float f4(f3, 50);
 128       BOOST_CHECK_EQUAL(f4.precision(), 50);
 129       f4.assign(f1, f4.precision());
 130       BOOST_CHECK_EQUAL(f4.precision(), 50);
 131    }
 132    {
 133       //
 134       // Check additional non-member functions,
 135       // see https://github.com/boostorg/multiprecision/issues/91
 136       //
 137       mpfi_float::default_precision(100);
 138       mpfi_float f1;
 139       f1 = 3;
 140       BOOST_CHECK_EQUAL(f1.precision(), 100);
 141       mpfi_float::default_precision(20);
 142       BOOST_CHECK_EQUAL(lower(f1).precision(), 100);
 143       BOOST_CHECK_EQUAL(upper(f1).precision(), 100);
 144       BOOST_CHECK_EQUAL(median(f1).precision(), 100);
 145       BOOST_CHECK_EQUAL(width(f1).precision(), 100);
 146       BOOST_CHECK_EQUAL(intersect(f1, f1).precision(), 100);
 147       BOOST_CHECK_EQUAL(hull(f1, f1).precision(), 100);
 148
 149       BOOST_CHECK_EQUAL(asinh(f1).precision(), 100);
 150       BOOST_CHECK_EQUAL(acosh(f1).precision(), 100);
 151       BOOST_CHECK_EQUAL(atanh(f1).precision(), 100);
 152       BOOST_CHECK_EQUAL(log1p(f1).precision(), 100);
 153       BOOST_CHECK_EQUAL(expm1(f1).precision(), 100);
 154       BOOST_CHECK_EQUAL(cbrt(f1).precision(), 100);
 155    }
 156
 157    return boost::report_errors();
 158 }