blob: 65cb53589e0174de84ebe8eaefde10cef4886fcc (
plain)
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
|
/* GTK - The GIMP Toolkit
* Copyright (C) 2011 Chun-wei Fan <fanc999@yahoo.com.tw>
*
* Author: Chun-wei Fan <fanc999@yahoo.com.tw>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <math.h>
#include <float.h>
/* Workaround for round() for non-GCC/non-C99 compilers */
#ifndef HAVE_ROUND
static inline double
round (double x)
{
if (x >= 0)
return floor (x + 0.5);
else
return ceil (x - 0.5);
}
#endif
/* Workaround for rint() for non-GCC/non-C99 compilers */
#ifndef HAVE_RINT
static inline double
rint (double x)
{
if (ceil (x + 0.5) == floor (x + 0.5))
{
int a;
a = (int) ceil (x);
if (a % 2 == 0)
return ceil (x);
else
return floor (x);
}
else
{
if (x >= 0)
return floor (x + 0.5);
else
return ceil (x - 0.5);
}
}
#endif
#ifndef HAVE_NEARBYINT
/* Workaround for nearbyint() for non-GCC/non-C99 compilers */
/* This is quite similar to rint() in most respects */
static inline double
nearbyint (double x)
{
return floor (x + 0.5);
}
#endif
#ifndef HAVE_DECL_ISINF
/* Unfortunately MSVC does not have finite()
* but it does have _finite() which is the same
* as finite() except when x is a NaN
*/
static inline gboolean
isinf (double x)
{
return (!_finite (x) && !_isnan (x));
}
#endif
#ifndef HAVE_DECL_ISNAN
/* it seems of the supported compilers only
* MSVC does not have isnan(), but it does
* have _isnan() which does the same as isnan()
*/
static inline gboolean
isnan (double x)
{
return _isnan (x);
}
#endif
#ifndef HAVE_DECL_ISNANF
#if defined (__GNUC__)
/* gcc has an intern function that it warns about when
* using -Wshadow but no header properly declares it,
* so we do it instead.
*/
extern int isnanf (float x);
#else
static inline int
isnanf (float x)
{
/* Either use the C99 type infering macro, or the fallback from above.
* MSVC has _isnanf, but only on x64
*/
return isnan (x);
}
#endif
#endif
#ifndef INFINITY
/* define INFINITY for compilers that lack support for it */
# ifdef HUGE_VALF
# define INFINITY HUGE_VALF
# else
# define INFINITY (float)HUGE_VAL
# endif
#endif
#ifndef HAVE_LOG2
/* Use a simple implementation for log2() for compilers that lack it */
static inline double
log2 (double x)
{
return log (x) / log (2.0);
}
#endif
#ifndef HAVE_EXP2
/* Use a simple implementation for exp2() for compilers that lack it */
static inline double
exp2 (double x)
{
return pow (2.0, x);
}
#endif
|
