1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
// (C) Copyright Matt Borland 2021.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <cmath>
#include <cfloat>
#include <cstdint>
#include <limits>
#include <utility>
#include <type_traits>
#include <boost/math/ccmath/modf.hpp>
#include <boost/math/ccmath/isnan.hpp>
#include <boost/math/ccmath/isinf.hpp>
#ifdef BOOST_HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
template <typename T>
inline constexpr T floating_point_value(const T val)
{
T i = 0;
const T ans = boost::math::ccmath::modf(val, &i);
return ans;
}
template <typename T>
inline constexpr T integral_value(const T val)
{
T i = 0;
boost::math::ccmath::modf(val, &i);
return i;
}
template <typename T>
inline constexpr std::pair<T, T> pair_value(const T val)
{
T i = 0;
T ans = boost::math::ccmath::modf(val, &i);
return std::make_pair(i, ans);
}
template <typename T>
constexpr void test()
{
if constexpr (std::numeric_limits<T>::has_quiet_NaN)
{
constexpr std::pair<T, T> NaN_val = pair_value(std::numeric_limits<T>::quiet_NaN());
static_assert(boost::math::ccmath::isnan(NaN_val.first));
static_assert(boost::math::ccmath::isnan(NaN_val.second));
}
// if x is +-0, +-0 is returned and +-0 is stored in *iptr
static_assert(floating_point_value(T(0)) == 0);
static_assert(floating_point_value(-T(0)) == -0);
static_assert(integral_value(T(0)) == 0);
static_assert(integral_value(-T(0)) == -0);
// if x is +- inf, +-0 is returned and +-inf is stored in *iptr
static_assert(floating_point_value(std::numeric_limits<T>::infinity()) == 0);
static_assert(floating_point_value(-std::numeric_limits<T>::infinity()) == -0);
static_assert(integral_value(std::numeric_limits<T>::infinity()) == std::numeric_limits<T>::infinity());
static_assert(integral_value(-std::numeric_limits<T>::infinity()) == -std::numeric_limits<T>::infinity());
// The returned value is exact, the current rounding mode is ignored
// The return value and *iptr each have the same type and sign as x
static_assert(integral_value(T(123.45)) == 123);
static_assert(integral_value(T(-234.56)) == -234);
static_assert(floating_point_value(T(1.0/2)) == T(1.0/2));
static_assert(floating_point_value(T(-1.0/3)) == T(-1.0/3));
}
#if !defined(BOOST_MATH_NO_CONSTEXPR_DETECTION) && !defined(BOOST_MATH_USING_BUILTIN_CONSTANT_P)
int main()
{
test<float>();
test<double>();
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
test<long double>();
#endif
#ifdef BOOST_HAS_FLOAT128
test<boost::multiprecision::float128>();
#endif
return 0;
}
#else
int main()
{
return 0;
}
#endif
|
