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>
make_rvalue_copy(const T a)21 T make_rvalue_copy(const T a)
22 {
23 return a;
24 }
25
main()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 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
44 {
45 // test assignment from rvalue:
46 mpfi_float b(2);
47 BOOST_CHECK_EQUAL(b.precision(), 20);
48 b = make_rvalue_copy(a);
49 BOOST_CHECK_EQUAL(b.precision(), a.precision());
50 }
51 #endif
52 mpfi_float::default_precision(20);
53 {
54 // test construct from lvalue:
55 mpfi_float b(a);
56 BOOST_CHECK_EQUAL(b.precision(), 100);
57 }
58 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
59 {
60 // test construct from rvalue:
61 mpfi_float b(make_rvalue_copy(a));
62 BOOST_CHECK_EQUAL(b.precision(), 100);
63 }
64 #endif
65 {
66 mpfi_float f150(2, 2, 150);
67 BOOST_CHECK_EQUAL(f150.precision(), 150);
68 }
69 {
70 mpfi_float f150("1.2", "1.2", 150);
71 BOOST_CHECK_EQUAL(f150.precision(), 150);
72 }
73 //
74 // From https://github.com/boostorg/multiprecision/issues/65
75 //
76 {
77 mpfi_float a(2);
78 a.precision(100);
79 BOOST_CHECK_EQUAL(a, 2);
80 BOOST_CHECK_EQUAL(a.precision(), 100);
81 }
82
83 //
84 // string_view with explicit precision:
85 //
86 #ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
87 {
88 std::string s("222");
89 std::string_view v(s.c_str(), 1);
90 mpfi_float f(v, v, 100);
91 BOOST_CHECK_EQUAL(f, 2);
92 BOOST_CHECK_EQUAL(f.precision(), 100);
93 }
94 #endif
95 // Swap:
96 {
97 mpfi_float x(2, 2, 100); // 100 digits precision.
98 mpfi_float y(3, 3, 50); // 50 digits precision.
99 swap(x, y);
100 BOOST_CHECK_EQUAL(x, 3);
101 BOOST_CHECK_EQUAL(y, 2);
102 BOOST_CHECK_EQUAL(x.precision(), 50);
103 BOOST_CHECK_EQUAL(y.precision(), 100);
104 x.swap(y);
105 BOOST_CHECK_EQUAL(x, 2);
106 BOOST_CHECK_EQUAL(y, 3);
107 BOOST_CHECK_EQUAL(x.precision(), 100);
108 BOOST_CHECK_EQUAL(y.precision(), 50);
109 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
110 x = std::move(mpfi_float(y));
111 BOOST_CHECK_EQUAL(x, y);
112 BOOST_CHECK_EQUAL(x.precision(), y.precision());
113 #endif
114 }
115 {
116 mpfi_float c(4), d(8), e(9), f;
117 f = (c + d) * d / e;
118 mpfi_float g((c + d) * d / e);
119 }
120 {
121 mpfi_float::default_precision(100);
122 mpfi_float f1;
123 f1 = 3;
124 BOOST_CHECK_EQUAL(f1.precision(), 100);
125 f1 = 3.5;
126 BOOST_CHECK_EQUAL(f1.precision(), 100);
127 mpfi_float f2(3.5);
128 BOOST_CHECK_EQUAL(f2.precision(), 100);
129 mpfi_float f3("5.1");
130 BOOST_CHECK_EQUAL(f3.precision(), 100);
131
132 mpfi_float::default_precision(50);
133 mpfi_float f4(f3, 50);
134 BOOST_CHECK_EQUAL(f4.precision(), 50);
135 f4.assign(f1, f4.precision());
136 BOOST_CHECK_EQUAL(f4.precision(), 50);
137 }
138 {
139 //
140 // Check additional non-member functions,
141 // see https://github.com/boostorg/multiprecision/issues/91
142 //
143 mpfi_float::default_precision(100);
144 mpfi_float f1;
145 f1 = 3;
146 BOOST_CHECK_EQUAL(f1.precision(), 100);
147 mpfi_float::default_precision(20);
148 BOOST_CHECK_EQUAL(lower(f1).precision(), 100);
149 BOOST_CHECK_EQUAL(upper(f1).precision(), 100);
150 BOOST_CHECK_EQUAL(median(f1).precision(), 100);
151 BOOST_CHECK_EQUAL(width(f1).precision(), 100);
152 BOOST_CHECK_EQUAL(intersect(f1, f1).precision(), 100);
153 BOOST_CHECK_EQUAL(hull(f1, f1).precision(), 100);
154
155 BOOST_CHECK_EQUAL(asinh(f1).precision(), 100);
156 BOOST_CHECK_EQUAL(acosh(f1).precision(), 100);
157 BOOST_CHECK_EQUAL(atanh(f1).precision(), 100);
158 BOOST_CHECK_EQUAL(log1p(f1).precision(), 100);
159 BOOST_CHECK_EQUAL(expm1(f1).precision(), 100);
160 BOOST_CHECK_EQUAL(cbrt(f1).precision(), 100);
161 }
162
163 return boost::report_errors();
164 }
165