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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
/* Round to integer generic implementation.
Copyright (C) 2019-2024 Free Software Foundation, Inc.
This file is part of the GNU C Library
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If
not, see <https://www.gnu.org/licenses/>. */
#ifndef _ROUND_TO_INTEGER_H
#define _ROUND_TO_INTEGER_H
#include <fenv_private.h>
enum round_mode
{
CEIL,
FLOOR,
ROUND,
TRUNC,
NEARBYINT,
RINT
};
static inline fenv_t
set_fenv_mode (enum round_mode mode)
{
fenv_t fe = 0;
if (mode != RINT)
/* Save current FPU rounding mode and inexact state. */
fe = fegetenv_register ();
switch (mode)
{
case CEIL:
__fesetround_inline_disable_inexact (FE_UPWARD);
break;
case FLOOR:
__fesetround_inline_disable_inexact (FE_DOWNWARD);
break;
case TRUNC:
case ROUND:
__fesetround_inline_disable_inexact (FE_TOWARDZERO);
break;
case NEARBYINT:
/* Disable FE_INEXACT exception */
reset_fpscr_bit (FPSCR_XE);
break;
case RINT:
break;
}
return fe;
}
static inline void
reset_fenv_mode (fenv_t fe, enum round_mode mode)
{
switch (mode)
{
default:
__builtin_mtfsf (0xff, fe);
break;
case RINT:
break;
}
}
static inline float
round_to_integer_float (enum round_mode mode, float x)
{
/* Ensure sNaN input is converted to qNaN. */
if (__glibc_unlikely (isnan (x)))
return x + x;
if (fabs (x) > 0x1p+23)
return x;
float r = x;
fenv_t fe = set_fenv_mode (mode);
if (x > 0.0)
{
/* IEEE 1003.1 round function. IEEE specifies "round to the nearest
integer value, rounding halfway cases away from zero, regardless of
the current rounding mode." However PowerPC Architecture defines
"Round to Nearest" as "Choose the best approximation. In case of a
tie, choose the one that is even (least significant bit o).".
So we can't use the PowerPC "Round to Nearest" mode. Instead we set
"Round toward Zero" mode and round by adding +-0.5 before rounding
to the integer value. */
if (mode == ROUND)
r += 0.5f;
r += 0x1p+23;
r -= 0x1p+23;
r = fabs (r);
}
else if (x < 0.0)
{
if (mode == ROUND)
r -= 0.5f;
r -= 0x1p+23;
r += 0x1p+23;
r = -fabs (r);
}
reset_fenv_mode (fe, mode);
return r;
}
static inline double
round_to_integer_double (enum round_mode mode, double x)
{
/* Ensure sNaN input is converted to qNaN. */
if (__glibc_unlikely (isnan (x)))
return x + x;
if (fabs (x) > 0x1p+52)
return x;
double r = x;
/* Save current FPU rounding mode and inexact state. */
fenv_t fe = set_fenv_mode (mode);
if (x > 0.0)
{
if (mode == ROUND)
r += 0.5;
r += 0x1p+52;
r -= 0x1p+52;
r = fabs (r);
}
else if (x < 0.0)
{
if (mode == ROUND)
r -= 0.5;
r -= 0x1p+52;
r += 0x1p+52;
r = -fabs (r);
}
reset_fenv_mode (fe, mode);
return r;
}
#endif
|
