1 | /** @file
|
---|
2 | * IPRT / No-CRT - math.h.
|
---|
3 | */
|
---|
4 |
|
---|
5 | /*
|
---|
6 | * Copyright (C) 2006-2017 Oracle Corporation
|
---|
7 | *
|
---|
8 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
9 | * available from http://www.virtualbox.org. This file is free software;
|
---|
10 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
11 | * General Public License (GPL) as published by the Free Software
|
---|
12 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
13 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
14 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
15 | *
|
---|
16 | * The contents of this file may alternatively be used under the terms
|
---|
17 | * of the Common Development and Distribution License Version 1.0
|
---|
18 | * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
|
---|
19 | * VirtualBox OSE distribution, in which case the provisions of the
|
---|
20 | * CDDL are applicable instead of those of the GPL.
|
---|
21 | *
|
---|
22 | * You may elect to license modified versions of this file under the
|
---|
23 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
24 | * --------------------------------------------------------------------
|
---|
25 | *
|
---|
26 | * This code is based on:
|
---|
27 | *
|
---|
28 | * from: @(#)fdlibm.h 5.1 93/09/24
|
---|
29 | * $FreeBSD: src/lib/msun/src/math.h,v 1.61 2005/04/16 21:12:47 das Exp $
|
---|
30 | * FreeBSD HEAD 2005-06-xx
|
---|
31 | *
|
---|
32 | * ====================================================
|
---|
33 | * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
---|
34 | *
|
---|
35 | * Developed at SunPro, a Sun Microsystems, Inc. business.
|
---|
36 | * Permission to use, copy, modify, and distribute this
|
---|
37 | * software is freely granted, provided that this notice
|
---|
38 | * is preserved.
|
---|
39 | * ====================================================
|
---|
40 | */
|
---|
41 |
|
---|
42 | #ifndef ___iprt_nocrt_math_h
|
---|
43 | #define ___iprt_nocrt_math_h
|
---|
44 |
|
---|
45 | #if !defined(__GNUC__) /* && !defined(__YOUR_COMPILER__) */
|
---|
46 | # error "IPRT: Adjust this header for your compiler"
|
---|
47 | #endif
|
---|
48 |
|
---|
49 | #include <iprt/types.h>
|
---|
50 | /*#include <machine/_limits.h>*/
|
---|
51 |
|
---|
52 | /* from sys/cdefs.h */
|
---|
53 | #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
|
---|
54 | #define __GNUC_PREREQ__(ma, mi) \
|
---|
55 | (__GNUC__ > (ma) || __GNUC__ == (ma) && __GNUC_MINOR__ >= (mi))
|
---|
56 | #else
|
---|
57 | #define __GNUC_PREREQ__(ma, mi) 0
|
---|
58 | #endif
|
---|
59 | #undef __pure2 /* darwin: avoid conflict with system headers when doing syntax checking of the headers */
|
---|
60 | #define __pure2
|
---|
61 |
|
---|
62 |
|
---|
63 | /*
|
---|
64 | * ANSI/POSIX
|
---|
65 | */
|
---|
66 | extern const union __infinity_un {
|
---|
67 | unsigned char __uc[8];
|
---|
68 | double __ud;
|
---|
69 | } RT_NOCRT(__infinity);
|
---|
70 |
|
---|
71 | extern const union __nan_un {
|
---|
72 | unsigned char __uc[sizeof(float)];
|
---|
73 | float __uf;
|
---|
74 | } RT_NOCRT(__nan);
|
---|
75 |
|
---|
76 | #if __GNUC_PREREQ__(3, 3) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
|
---|
77 | #define __MATH_BUILTIN_CONSTANTS
|
---|
78 | #endif
|
---|
79 |
|
---|
80 | #if __GNUC_PREREQ__(3, 0) && !defined(__INTEL_COMPILER)
|
---|
81 | #define __MATH_BUILTIN_RELOPS
|
---|
82 | #endif
|
---|
83 |
|
---|
84 | #ifdef __MATH_BUILTIN_CONSTANTS
|
---|
85 | #define HUGE_VAL __builtin_huge_val()
|
---|
86 | #else
|
---|
87 | #define HUGE_VAL (RT_NOCRT(__infinity).__ud)
|
---|
88 | #endif
|
---|
89 |
|
---|
90 | #if 1/* __ISO_C_VISIBLE >= 1999*/
|
---|
91 | #define FP_ILOGB0 (-__INT_MAX)
|
---|
92 | #define FP_ILOGBNAN __INT_MAX
|
---|
93 |
|
---|
94 | #ifdef __MATH_BUILTIN_CONSTANTS
|
---|
95 | #define HUGE_VALF __builtin_huge_valf()
|
---|
96 | #define HUGE_VALL __builtin_huge_vall()
|
---|
97 | #define INFINITY __builtin_inf()
|
---|
98 | #define NAN __builtin_nan("")
|
---|
99 | #else
|
---|
100 | #define HUGE_VALF (float)HUGE_VAL
|
---|
101 | #define HUGE_VALL (long double)HUGE_VAL
|
---|
102 | #define INFINITY HUGE_VALF
|
---|
103 | #define NAN (__nan.__uf)
|
---|
104 | #endif /* __MATH_BUILTIN_CONSTANTS */
|
---|
105 |
|
---|
106 | #define MATH_ERRNO 1
|
---|
107 | #define MATH_ERREXCEPT 2
|
---|
108 | #define math_errhandling MATH_ERREXCEPT
|
---|
109 |
|
---|
110 | /* XXX We need a <machine/math.h>. */
|
---|
111 | #if defined(__ia64__) || defined(__sparc64__)
|
---|
112 | #define FP_FAST_FMA
|
---|
113 | #endif
|
---|
114 | #ifdef __ia64__
|
---|
115 | #define FP_FAST_FMAL
|
---|
116 | #endif
|
---|
117 | #define FP_FAST_FMAF
|
---|
118 |
|
---|
119 | /* Symbolic constants to classify floating point numbers. */
|
---|
120 | #define FP_INFINITE 0x01
|
---|
121 | #define FP_NAN 0x02
|
---|
122 | #define FP_NORMAL 0x04
|
---|
123 | #define FP_SUBNORMAL 0x08
|
---|
124 | #define FP_ZERO 0x10
|
---|
125 | #define fpclassify(x) \
|
---|
126 | ((sizeof (x) == sizeof (float)) ? RT_NOCRT(__fpclassifyf)(x) \
|
---|
127 | : (sizeof (x) == sizeof (double)) ? RT_NOCRT(__fpclassifyd)(x) \
|
---|
128 | : RT_NOCRT(__fpclassifyl)(x))
|
---|
129 |
|
---|
130 | #define isfinite(x) \
|
---|
131 | ((sizeof (x) == sizeof (float)) ? RT_NOCRT(__isfinitef)(x) \
|
---|
132 | : (sizeof (x) == sizeof (double)) ? RT_NOCRT(__isfinite)(x) \
|
---|
133 | : RT_NOCRT(__isfinitel)(x))
|
---|
134 | #define isinf(x) \
|
---|
135 | ((sizeof (x) == sizeof (float)) ? RT_NOCRT(__isinff)(x) \
|
---|
136 | : (sizeof (x) == sizeof (double)) ? isinf(x) \
|
---|
137 | : RT_NOCRT(__isinfl)(x))
|
---|
138 | #define isnan(x) \
|
---|
139 | ((sizeof (x) == sizeof (float)) ? isnanf(x) \
|
---|
140 | : (sizeof (x) == sizeof (double)) ? isnan(x) \
|
---|
141 | : RT_NOCRT(__isnanl)(x))
|
---|
142 | #define isnormal(x) \
|
---|
143 | ((sizeof (x) == sizeof (float)) ? RT_NOCRT(__isnormalf)(x) \
|
---|
144 | : (sizeof (x) == sizeof (double)) ? RT_NOCRT(__isnormal)(x) \
|
---|
145 | : RT_NOCRT(__isnormall)(x))
|
---|
146 |
|
---|
147 | #ifdef __MATH_BUILTIN_RELOPS
|
---|
148 | #define isgreater(x, y) __builtin_isgreater((x), (y))
|
---|
149 | #define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y))
|
---|
150 | #define isless(x, y) __builtin_isless((x), (y))
|
---|
151 | #define islessequal(x, y) __builtin_islessequal((x), (y))
|
---|
152 | #define islessgreater(x, y) __builtin_islessgreater((x), (y))
|
---|
153 | #define isunordered(x, y) __builtin_isunordered((x), (y))
|
---|
154 | #else
|
---|
155 | #define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y))
|
---|
156 | #define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y))
|
---|
157 | #define isless(x, y) (!isunordered((x), (y)) && (x) < (y))
|
---|
158 | #define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y))
|
---|
159 | #define islessgreater(x, y) (!isunordered((x), (y)) && \
|
---|
160 | ((x) > (y) || (y) > (x)))
|
---|
161 | #define isunordered(x, y) (isnan(x) || isnan(y))
|
---|
162 | #endif /* __MATH_BUILTIN_RELOPS */
|
---|
163 |
|
---|
164 | #define signbit(x) \
|
---|
165 | ((sizeof (x) == sizeof (float)) ? RT_NOCRT(__signbitf)(x) \
|
---|
166 | : (sizeof (x) == sizeof (double)) ? RT_NOCRT(__signbit)(x) \
|
---|
167 | : RT_NOCRT(__signbitl)(x))
|
---|
168 |
|
---|
169 | typedef double double_t;
|
---|
170 | typedef float float_t;
|
---|
171 | #endif /* __ISO_C_VISIBLE >= 1999 */
|
---|
172 |
|
---|
173 | /*
|
---|
174 | * XOPEN/SVID
|
---|
175 | */
|
---|
176 | #if 1/* __BSD_VISIBLE || __XSI_VISIBLE*/
|
---|
177 | #define M_E 2.7182818284590452354 /* e */
|
---|
178 | #define M_LOG2E 1.4426950408889634074 /* log 2e */
|
---|
179 | #define M_LOG10E 0.43429448190325182765 /* log 10e */
|
---|
180 | #define M_LN2 0.69314718055994530942 /* log e2 */
|
---|
181 | #define M_LN10 2.30258509299404568402 /* log e10 */
|
---|
182 | #define M_PI 3.14159265358979323846 /* pi */
|
---|
183 | #define M_PI_2 1.57079632679489661923 /* pi/2 */
|
---|
184 | #define M_PI_4 0.78539816339744830962 /* pi/4 */
|
---|
185 | #define M_1_PI 0.31830988618379067154 /* 1/pi */
|
---|
186 | #define M_2_PI 0.63661977236758134308 /* 2/pi */
|
---|
187 | #define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
|
---|
188 | #define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
|
---|
189 | #define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
|
---|
190 |
|
---|
191 | #define MAXFLOAT ((float)3.40282346638528860e+38)
|
---|
192 | extern int RT_NOCRT(signgam);
|
---|
193 | #endif /* __BSD_VISIBLE || __XSI_VISIBLE */
|
---|
194 |
|
---|
195 | #if 1/* __BSD_VISIBLE*/
|
---|
196 | #if 0
|
---|
197 | /* Old value from 4.4BSD-Lite math.h; this is probably better. */
|
---|
198 | #define HUGE HUGE_VAL
|
---|
199 | #else
|
---|
200 | #define HUGE MAXFLOAT
|
---|
201 | #endif
|
---|
202 | #endif /* __BSD_VISIBLE */
|
---|
203 |
|
---|
204 | /*
|
---|
205 | * Most of these functions depend on the rounding mode and have the side
|
---|
206 | * effect of raising floating-point exceptions, so they are not declared
|
---|
207 | * as __pure2. In C99, FENV_ACCESS affects the purity of these functions.
|
---|
208 | */
|
---|
209 | RT_C_DECLS_BEGIN
|
---|
210 | /*
|
---|
211 | * ANSI/POSIX
|
---|
212 | */
|
---|
213 | int RT_NOCRT(__fpclassifyd)(double) __pure2;
|
---|
214 | int RT_NOCRT(__fpclassifyf)(float) __pure2;
|
---|
215 | int RT_NOCRT(__fpclassifyl)(long double) __pure2;
|
---|
216 | int RT_NOCRT(__isfinitef)(float) __pure2;
|
---|
217 | int RT_NOCRT(__isfinite)(double) __pure2;
|
---|
218 | int RT_NOCRT(__isfinitel)(long double) __pure2;
|
---|
219 | int RT_NOCRT(__isinff)(float) __pure2;
|
---|
220 | int RT_NOCRT(__isinfl)(long double) __pure2;
|
---|
221 | int RT_NOCRT(__isnanl)(long double) __pure2;
|
---|
222 | int RT_NOCRT(__isnormalf)(float) __pure2;
|
---|
223 | int RT_NOCRT(__isnormal)(double) __pure2;
|
---|
224 | int RT_NOCRT(__isnormall)(long double) __pure2;
|
---|
225 | int RT_NOCRT(__signbit)(double) __pure2;
|
---|
226 | int RT_NOCRT(__signbitf)(float) __pure2;
|
---|
227 | int RT_NOCRT(__signbitl)(long double) __pure2;
|
---|
228 |
|
---|
229 | double RT_NOCRT(acos)(double);
|
---|
230 | double RT_NOCRT(asin)(double);
|
---|
231 | double RT_NOCRT(atan)(double);
|
---|
232 | double RT_NOCRT(atan2)(double, double);
|
---|
233 | double RT_NOCRT(cos)(double);
|
---|
234 | double RT_NOCRT(sin)(double);
|
---|
235 | double RT_NOCRT(tan)(double);
|
---|
236 |
|
---|
237 | double RT_NOCRT(cosh)(double);
|
---|
238 | double RT_NOCRT(sinh)(double);
|
---|
239 | double RT_NOCRT(tanh)(double);
|
---|
240 |
|
---|
241 | double RT_NOCRT(exp)(double);
|
---|
242 | double RT_NOCRT(frexp)(double, int *); /* fundamentally !__pure2 */
|
---|
243 | double RT_NOCRT(ldexp)(double, int);
|
---|
244 | double RT_NOCRT(log)(double);
|
---|
245 | double RT_NOCRT(log10)(double);
|
---|
246 | double RT_NOCRT(modf)(double, double *); /* fundamentally !__pure2 */
|
---|
247 |
|
---|
248 | double RT_NOCRT(pow)(double, double);
|
---|
249 | double RT_NOCRT(sqrt)(double);
|
---|
250 |
|
---|
251 | double RT_NOCRT(ceil)(double);
|
---|
252 | double RT_NOCRT(fabs)(double) __pure2;
|
---|
253 | double RT_NOCRT(floor)(double);
|
---|
254 | double RT_NOCRT(fmod)(double, double);
|
---|
255 |
|
---|
256 | /*
|
---|
257 | * These functions are not in C90.
|
---|
258 | */
|
---|
259 | #if 1 /*__BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE*/
|
---|
260 | double RT_NOCRT(acosh)(double);
|
---|
261 | double RT_NOCRT(asinh)(double);
|
---|
262 | double RT_NOCRT(atanh)(double);
|
---|
263 | double RT_NOCRT(cbrt)(double);
|
---|
264 | double RT_NOCRT(erf)(double);
|
---|
265 | double RT_NOCRT(erfc)(double);
|
---|
266 | double RT_NOCRT(exp2)(double);
|
---|
267 | double RT_NOCRT(expm1)(double);
|
---|
268 | double RT_NOCRT(fma)(double, double, double);
|
---|
269 | double RT_NOCRT(hypot)(double, double);
|
---|
270 | int RT_NOCRT(ilogb)(double) __pure2;
|
---|
271 | /*int isinf(double) __pure2;*/
|
---|
272 | /*int isnan(double) __pure2;*/
|
---|
273 | double RT_NOCRT(lgamma)(double);
|
---|
274 | long long RT_NOCRT(llrint)(double);
|
---|
275 | long long RT_NOCRT(llround)(double);
|
---|
276 | double RT_NOCRT(log1p)(double);
|
---|
277 | double RT_NOCRT(logb)(double);
|
---|
278 | long RT_NOCRT(lrint)(double);
|
---|
279 | long RT_NOCRT(lround)(double);
|
---|
280 | double RT_NOCRT(nextafter)(double, double);
|
---|
281 | double RT_NOCRT(remainder)(double, double);
|
---|
282 | double RT_NOCRT(remquo)(double, double, int *);
|
---|
283 | double RT_NOCRT(rint)(double);
|
---|
284 | #endif /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */
|
---|
285 |
|
---|
286 | #if 1/* __BSD_VISIBLE || __XSI_VISIBLE*/
|
---|
287 | double RT_NOCRT(j0)(double);
|
---|
288 | double RT_NOCRT(j1)(double);
|
---|
289 | double RT_NOCRT(jn)(int, double);
|
---|
290 | double RT_NOCRT(scalb)(double, double);
|
---|
291 | double RT_NOCRT(y0)(double);
|
---|
292 | double RT_NOCRT(y1)(double);
|
---|
293 | double RT_NOCRT(yn)(int, double);
|
---|
294 |
|
---|
295 | #if 1/* __XSI_VISIBLE <= 500 || __BSD_VISIBLE*/
|
---|
296 | double RT_NOCRT(gamma)(double);
|
---|
297 | #endif
|
---|
298 | #endif /* __BSD_VISIBLE || __XSI_VISIBLE */
|
---|
299 |
|
---|
300 | #if 1/* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999*/
|
---|
301 | double RT_NOCRT(copysign)(double, double) __pure2;
|
---|
302 | double RT_NOCRT(fdim)(double, double);
|
---|
303 | double RT_NOCRT(fmax)(double, double) __pure2;
|
---|
304 | double RT_NOCRT(fmin)(double, double) __pure2;
|
---|
305 | double RT_NOCRT(nearbyint)(double);
|
---|
306 | double RT_NOCRT(round)(double);
|
---|
307 | double RT_NOCRT(scalbln)(double, long);
|
---|
308 | double RT_NOCRT(scalbn)(double, int);
|
---|
309 | double RT_NOCRT(tgamma)(double);
|
---|
310 | double RT_NOCRT(trunc)(double);
|
---|
311 | #endif
|
---|
312 |
|
---|
313 | /*
|
---|
314 | * BSD math library entry points
|
---|
315 | */
|
---|
316 | #if 1/* __BSD_VISIBLE*/
|
---|
317 | double RT_NOCRT(drem)(double, double);
|
---|
318 | int RT_NOCRT(finite)(double) __pure2;
|
---|
319 | int RT_NOCRT(isnanf)(float) __pure2;
|
---|
320 |
|
---|
321 | /*
|
---|
322 | * Reentrant version of gamma & lgamma; passes signgam back by reference
|
---|
323 | * as the second argument; user must allocate space for signgam.
|
---|
324 | */
|
---|
325 | double RT_NOCRT(gamma_r)(double, int *);
|
---|
326 | double RT_NOCRT(lgamma_r)(double, int *);
|
---|
327 |
|
---|
328 | /*
|
---|
329 | * IEEE Test Vector
|
---|
330 | */
|
---|
331 | double RT_NOCRT(significand)(double);
|
---|
332 | #endif /* __BSD_VISIBLE */
|
---|
333 |
|
---|
334 | /* float versions of ANSI/POSIX functions */
|
---|
335 | #if 1/* __ISO_C_VISIBLE >= 1999*/
|
---|
336 | float RT_NOCRT(acosf)(float);
|
---|
337 | float RT_NOCRT(asinf)(float);
|
---|
338 | float RT_NOCRT(atanf)(float);
|
---|
339 | float RT_NOCRT(atan2f)(float, float);
|
---|
340 | float RT_NOCRT(cosf)(float);
|
---|
341 | float RT_NOCRT(sinf)(float);
|
---|
342 | float RT_NOCRT(tanf)(float);
|
---|
343 |
|
---|
344 | float RT_NOCRT(coshf)(float);
|
---|
345 | float RT_NOCRT(sinhf)(float);
|
---|
346 | float RT_NOCRT(tanhf)(float);
|
---|
347 |
|
---|
348 | float RT_NOCRT(exp2f)(float);
|
---|
349 | float RT_NOCRT(expf)(float);
|
---|
350 | float RT_NOCRT(expm1f)(float);
|
---|
351 | float RT_NOCRT(frexpf)(float, int *); /* fundamentally !__pure2 */
|
---|
352 | int RT_NOCRT(ilogbf)(float) __pure2;
|
---|
353 | float RT_NOCRT(ldexpf)(float, int);
|
---|
354 | float RT_NOCRT(log10f)(float);
|
---|
355 | float RT_NOCRT(log1pf)(float);
|
---|
356 | float RT_NOCRT(logf)(float);
|
---|
357 | float RT_NOCRT(modff)(float, float *); /* fundamentally !__pure2 */
|
---|
358 |
|
---|
359 | float RT_NOCRT(powf)(float, float);
|
---|
360 | float RT_NOCRT(sqrtf)(float);
|
---|
361 |
|
---|
362 | float RT_NOCRT(ceilf)(float);
|
---|
363 | float RT_NOCRT(fabsf)(float) __pure2;
|
---|
364 | float RT_NOCRT(floorf)(float);
|
---|
365 | float RT_NOCRT(fmodf)(float, float);
|
---|
366 | float RT_NOCRT(roundf)(float);
|
---|
367 |
|
---|
368 | float RT_NOCRT(erff)(float);
|
---|
369 | float RT_NOCRT(erfcf)(float);
|
---|
370 | float RT_NOCRT(hypotf)(float, float);
|
---|
371 | float RT_NOCRT(lgammaf)(float);
|
---|
372 |
|
---|
373 | float RT_NOCRT(acoshf)(float);
|
---|
374 | float RT_NOCRT(asinhf)(float);
|
---|
375 | float RT_NOCRT(atanhf)(float);
|
---|
376 | float RT_NOCRT(cbrtf)(float);
|
---|
377 | float RT_NOCRT(logbf)(float);
|
---|
378 | float RT_NOCRT(copysignf)(float, float) __pure2;
|
---|
379 | long long RT_NOCRT(llrintf)(float);
|
---|
380 | long long RT_NOCRT(llroundf)(float);
|
---|
381 | long RT_NOCRT(lrintf)(float);
|
---|
382 | long RT_NOCRT(lroundf)(float);
|
---|
383 | float RT_NOCRT(nearbyintf)(float);
|
---|
384 | float RT_NOCRT(nextafterf)(float, float);
|
---|
385 | float RT_NOCRT(remainderf)(float, float);
|
---|
386 | float RT_NOCRT(remquof)(float, float, int *);
|
---|
387 | float RT_NOCRT(rintf)(float);
|
---|
388 | float RT_NOCRT(scalblnf)(float, long);
|
---|
389 | float RT_NOCRT(scalbnf)(float, int);
|
---|
390 | float RT_NOCRT(truncf)(float);
|
---|
391 |
|
---|
392 | float RT_NOCRT(fdimf)(float, float);
|
---|
393 | float RT_NOCRT(fmaf)(float, float, float);
|
---|
394 | float RT_NOCRT(fmaxf)(float, float) __pure2;
|
---|
395 | float RT_NOCRT(fminf)(float, float) __pure2;
|
---|
396 | #endif
|
---|
397 |
|
---|
398 | /*
|
---|
399 | * float versions of BSD math library entry points
|
---|
400 | */
|
---|
401 | #if 1/* __BSD_VISIBLE*/
|
---|
402 | float RT_NOCRT(dremf)(float, float);
|
---|
403 | int RT_NOCRT(finitef)(float) __pure2;
|
---|
404 | float RT_NOCRT(gammaf)(float);
|
---|
405 | float RT_NOCRT(j0f)(float);
|
---|
406 | float RT_NOCRT(j1f)(float);
|
---|
407 | float RT_NOCRT(jnf)(int, float);
|
---|
408 | float RT_NOCRT(scalbf)(float, float);
|
---|
409 | float RT_NOCRT(y0f)(float);
|
---|
410 | float RT_NOCRT(y1f)(float);
|
---|
411 | float RT_NOCRT(ynf)(int, float);
|
---|
412 |
|
---|
413 | /*
|
---|
414 | * Float versions of reentrant version of gamma & lgamma; passes
|
---|
415 | * signgam back by reference as the second argument; user must
|
---|
416 | * allocate space for signgam.
|
---|
417 | */
|
---|
418 | float RT_NOCRT(gammaf_r)(float, int *);
|
---|
419 | float RT_NOCRT(lgammaf_r)(float, int *);
|
---|
420 |
|
---|
421 | /*
|
---|
422 | * float version of IEEE Test Vector
|
---|
423 | */
|
---|
424 | float RT_NOCRT(significandf)(float);
|
---|
425 | #endif /* __BSD_VISIBLE */
|
---|
426 |
|
---|
427 | /*
|
---|
428 | * long double versions of ISO/POSIX math functions
|
---|
429 | */
|
---|
430 | #if 1/* __ISO_C_VISIBLE >= 1999*/
|
---|
431 | #if 1 /* bird: we've got these */
|
---|
432 | long double RT_NOCRT(acoshl)(long double);
|
---|
433 | long double RT_NOCRT(acosl)(long double);
|
---|
434 | long double RT_NOCRT(asinhl)(long double);
|
---|
435 | long double RT_NOCRT(asinl)(long double);
|
---|
436 | long double RT_NOCRT(atan2l)(long double, long double);
|
---|
437 | long double RT_NOCRT(atanhl)(long double);
|
---|
438 | long double RT_NOCRT(atanl)(long double);
|
---|
439 | long double RT_NOCRT(cbrtl)(long double);
|
---|
440 | #endif
|
---|
441 | long double RT_NOCRT(ceill)(long double);
|
---|
442 | long double RT_NOCRT(copysignl)(long double, long double) __pure2;
|
---|
443 | #if 1 /* bird */
|
---|
444 | long double RT_NOCRT(coshl)(long double);
|
---|
445 | long double RT_NOCRT(cosl)(long double);
|
---|
446 | long double RT_NOCRT(erfcl)(long double);
|
---|
447 | long double RT_NOCRT(erfl)(long double);
|
---|
448 | long double RT_NOCRT(exp2l)(long double);
|
---|
449 | long double RT_NOCRT(expl)(long double);
|
---|
450 | long double RT_NOCRT(expm1l)(long double);
|
---|
451 | #endif
|
---|
452 | long double RT_NOCRT(fabsl)(long double) __pure2;
|
---|
453 | long double RT_NOCRT(fdiml)(long double, long double);
|
---|
454 | long double RT_NOCRT(floorl)(long double);
|
---|
455 | long double RT_NOCRT(fmal)(long double, long double, long double);
|
---|
456 | long double RT_NOCRT(fmaxl)(long double, long double) __pure2;
|
---|
457 | long double RT_NOCRT(fminl)(long double, long double) __pure2;
|
---|
458 | #if 1 /* bird */
|
---|
459 | long double RT_NOCRT(fmodl)(long double, long double);
|
---|
460 | #endif
|
---|
461 | long double RT_NOCRT(frexpl)(long double value, int *); /* fundamentally !__pure2 */
|
---|
462 | #if 1 /* bird */
|
---|
463 | long double RT_NOCRT(hypotl)(long double, long double);
|
---|
464 | #endif
|
---|
465 | int RT_NOCRT(ilogbl)(long double) __pure2;
|
---|
466 | long double RT_NOCRT(ldexpl)(long double, int);
|
---|
467 | #if 1 /* bird */
|
---|
468 | long double RT_NOCRT(lgammal)(long double);
|
---|
469 | long long RT_NOCRT(llrintl)(long double);
|
---|
470 | #endif
|
---|
471 | long long RT_NOCRT(llroundl)(long double);
|
---|
472 | #if 1 /* bird */
|
---|
473 | long double RT_NOCRT(log10l)(long double);
|
---|
474 | long double RT_NOCRT(log1pl)(long double);
|
---|
475 | long double RT_NOCRT(log2l)(long double);
|
---|
476 | long double RT_NOCRT(logbl)(long double);
|
---|
477 | long double RT_NOCRT(logl)(long double);
|
---|
478 | long RT_NOCRT(lrintl)(long double);
|
---|
479 | #endif
|
---|
480 | long RT_NOCRT(lroundl)(long double);
|
---|
481 | #if 1 /* bird */
|
---|
482 | long double RT_NOCRT(modfl)(long double, long double *); /* fundamentally !__pure2 */
|
---|
483 | long double RT_NOCRT(nanl)(const char *) __pure2;
|
---|
484 | long double RT_NOCRT(nearbyintl)(long double);
|
---|
485 | #endif
|
---|
486 | long double RT_NOCRT(nextafterl)(long double, long double);
|
---|
487 | double RT_NOCRT(nexttoward)(double, long double);
|
---|
488 | float RT_NOCRT(nexttowardf)(float, long double);
|
---|
489 | long double RT_NOCRT(nexttowardl)(long double, long double);
|
---|
490 | #if 1 /* bird */
|
---|
491 | long double RT_NOCRT(powl)(long double, long double);
|
---|
492 | long double RT_NOCRT(remainderl)(long double, long double);
|
---|
493 | long double RT_NOCRT(remquol)(long double, long double, int *);
|
---|
494 | long double RT_NOCRT(rintl)(long double);
|
---|
495 | #endif
|
---|
496 | long double RT_NOCRT(roundl)(long double);
|
---|
497 | long double RT_NOCRT(scalblnl)(long double, long);
|
---|
498 | long double RT_NOCRT(scalbnl)(long double, int);
|
---|
499 | #if 1 /* bird: we 've got most of these. */
|
---|
500 | long double RT_NOCRT(sinhl)(long double);
|
---|
501 | long double RT_NOCRT(sinl)(long double);
|
---|
502 | long double RT_NOCRT(sqrtl)(long double);
|
---|
503 | long double RT_NOCRT(tanhl)(long double);
|
---|
504 | long double RT_NOCRT(tanl)(long double);
|
---|
505 | long double RT_NOCRT(tgammal)(long double);
|
---|
506 | #endif
|
---|
507 | long double RT_NOCRT(truncl)(long double);
|
---|
508 |
|
---|
509 | /* bird: these were missing, gcc apparently inlines them. */
|
---|
510 | double RT_NOCRT(nan)(const char *);
|
---|
511 | float RT_NOCRT(nanf)(const char *);
|
---|
512 |
|
---|
513 | #endif /* __ISO_C_VISIBLE >= 1999 */
|
---|
514 |
|
---|
515 | #if 1/*def __USE_GNU*/
|
---|
516 | /*
|
---|
517 | * In GLIBC there are long variants of the XOPEN/SVID constant
|
---|
518 | * block some pages ago. We need this to get the math tests going.
|
---|
519 | */
|
---|
520 | #define M_El 2.7182818284590452353602874713526625L
|
---|
521 | #define M_LOG2El 1.4426950408889634073599246810018921L
|
---|
522 | #define M_LOG10El 0.4342944819032518276511289189166051L
|
---|
523 | #define M_LN2l 0.6931471805599453094172321214581766L
|
---|
524 | #define M_LN10l 2.3025850929940456840179914546843642L
|
---|
525 | #define M_PIl 3.1415926535897932384626433832795029L
|
---|
526 | #define M_PI_2l 1.5707963267948966192313216916397514L
|
---|
527 | #define M_PI_4l 0.7853981633974483096156608458198757L
|
---|
528 | #define M_1_PIl 0.3183098861837906715377675267450287L
|
---|
529 | #define M_2_PIl 0.6366197723675813430755350534900574L
|
---|
530 | #define M_2_SQRTPIl 1.1283791670955125738961589031215452L
|
---|
531 | #define M_SQRT2l 1.4142135623730950488016887242096981L
|
---|
532 | #define M_SQRT1_2l 0.7071067811865475244008443621048490L
|
---|
533 | #endif
|
---|
534 |
|
---|
535 | #if 1/*def __USE_GNU*/
|
---|
536 |
|
---|
537 | void RT_NOCRT(sincos)(double, double *, double *);
|
---|
538 | void RT_NOCRT(sincosf)(float, float *, float *);
|
---|
539 | void RT_NOCRT(sincosl)(long double, long double *, long double *);
|
---|
540 | float RT_NOCRT(exp10f)(float);
|
---|
541 | double RT_NOCRT(exp10)(double);
|
---|
542 | long double RT_NOCRT(exp10l)(long double);
|
---|
543 | float RT_NOCRT(log2f)(float);
|
---|
544 | double RT_NOCRT(log2)(double);
|
---|
545 | long double RT_NOCRT(log2l)(long double);
|
---|
546 | float RT_NOCRT(tgammaf)(float);
|
---|
547 | long double RT_NOCRT(significandl)(long double);
|
---|
548 | long double RT_NOCRT(j0l)(long double);
|
---|
549 | long double RT_NOCRT(j1l)(long double);
|
---|
550 | long double RT_NOCRT(jnl)(int, long double);
|
---|
551 | long double RT_NOCRT(scalbl)(long double, long double);
|
---|
552 | long double RT_NOCRT(y0l)(long double);
|
---|
553 | long double RT_NOCRT(y1l)(long double);
|
---|
554 | long double RT_NOCRT(ynl)(int, long double);
|
---|
555 | long double RT_NOCRT(lgammal_r)(long double,int *);
|
---|
556 | long double RT_NOCRT(gammal)(long double);
|
---|
557 | #endif
|
---|
558 | RT_C_DECLS_END
|
---|
559 |
|
---|
560 |
|
---|
561 |
|
---|
562 | #if !defined(RT_WITHOUT_NOCRT_WRAPPERS) && !defined(RT_WITHOUT_NOCRT_WRAPPER_ALIASES)
|
---|
563 | /* sed -e "/#/d" -e "/RT_NOCRT/!d" -e "s/^.*RT_NOCRT(\([a-z0-9_]*\)).*$/# define \1 RT_NOCRT(\1)/" */
|
---|
564 | # define __infinity RT_NOCRT(__infinity)
|
---|
565 | # define __nan RT_NOCRT(__nan)
|
---|
566 | # define __fpclassifyf RT_NOCRT(__fpclassifyf)
|
---|
567 | # define __fpclassifyd RT_NOCRT(__fpclassifyd)
|
---|
568 | # define __fpclassifyl RT_NOCRT(__fpclassifyl)
|
---|
569 | # define __isfinitef RT_NOCRT(__isfinitef)
|
---|
570 | # define __isfinite RT_NOCRT(__isfinite)
|
---|
571 | # define __isfinitel RT_NOCRT(__isfinitel)
|
---|
572 | # define __isinff RT_NOCRT(__isinff)
|
---|
573 | # define __isinfl RT_NOCRT(__isinfl)
|
---|
574 | # define __isnanl RT_NOCRT(__isnanl)
|
---|
575 | # define __isnormalf RT_NOCRT(__isnormalf)
|
---|
576 | # define __isnormal RT_NOCRT(__isnormal)
|
---|
577 | # define __isnormall RT_NOCRT(__isnormall)
|
---|
578 | # define __signbitf RT_NOCRT(__signbitf)
|
---|
579 | # define __signbit RT_NOCRT(__signbit)
|
---|
580 | # define __signbitl RT_NOCRT(__signbitl)
|
---|
581 | # define signgam RT_NOCRT(signgam)
|
---|
582 | # define __fpclassifyd RT_NOCRT(__fpclassifyd)
|
---|
583 | # define __fpclassifyf RT_NOCRT(__fpclassifyf)
|
---|
584 | # define __fpclassifyl RT_NOCRT(__fpclassifyl)
|
---|
585 | # define __isfinitef RT_NOCRT(__isfinitef)
|
---|
586 | # define __isfinite RT_NOCRT(__isfinite)
|
---|
587 | # define __isfinitel RT_NOCRT(__isfinitel)
|
---|
588 | # define __isinff RT_NOCRT(__isinff)
|
---|
589 | # define __isinfl RT_NOCRT(__isinfl)
|
---|
590 | # define __isnanl RT_NOCRT(__isnanl)
|
---|
591 | # define __isnormalf RT_NOCRT(__isnormalf)
|
---|
592 | # define __isnormal RT_NOCRT(__isnormal)
|
---|
593 | # define __isnormall RT_NOCRT(__isnormall)
|
---|
594 | # define __signbit RT_NOCRT(__signbit)
|
---|
595 | # define __signbitf RT_NOCRT(__signbitf)
|
---|
596 | # define __signbitl RT_NOCRT(__signbitl)
|
---|
597 | # define acos RT_NOCRT(acos)
|
---|
598 | # define asin RT_NOCRT(asin)
|
---|
599 | # define atan RT_NOCRT(atan)
|
---|
600 | # define atan2 RT_NOCRT(atan2)
|
---|
601 | # define cos RT_NOCRT(cos)
|
---|
602 | # define sin RT_NOCRT(sin)
|
---|
603 | # define tan RT_NOCRT(tan)
|
---|
604 | # define cosh RT_NOCRT(cosh)
|
---|
605 | # define sinh RT_NOCRT(sinh)
|
---|
606 | # define tanh RT_NOCRT(tanh)
|
---|
607 | # define exp RT_NOCRT(exp)
|
---|
608 | # define frexp RT_NOCRT(frexp)
|
---|
609 | # define ldexp RT_NOCRT(ldexp)
|
---|
610 | # define log RT_NOCRT(log)
|
---|
611 | # define log10 RT_NOCRT(log10)
|
---|
612 | # define modf RT_NOCRT(modf)
|
---|
613 | # define pow RT_NOCRT(pow)
|
---|
614 | # define sqrt RT_NOCRT(sqrt)
|
---|
615 | # define ceil RT_NOCRT(ceil)
|
---|
616 | # define fabs RT_NOCRT(fabs)
|
---|
617 | # define floor RT_NOCRT(floor)
|
---|
618 | # define fmod RT_NOCRT(fmod)
|
---|
619 | # define acosh RT_NOCRT(acosh)
|
---|
620 | # define asinh RT_NOCRT(asinh)
|
---|
621 | # define atanh RT_NOCRT(atanh)
|
---|
622 | # define cbrt RT_NOCRT(cbrt)
|
---|
623 | # define erf RT_NOCRT(erf)
|
---|
624 | # define erfc RT_NOCRT(erfc)
|
---|
625 | # define exp2 RT_NOCRT(exp2)
|
---|
626 | # define expm1 RT_NOCRT(expm1)
|
---|
627 | # define fma RT_NOCRT(fma)
|
---|
628 | # define hypot RT_NOCRT(hypot)
|
---|
629 | # define ilogb RT_NOCRT(ilogb)
|
---|
630 | # define lgamma RT_NOCRT(lgamma)
|
---|
631 | # define llrint RT_NOCRT(llrint)
|
---|
632 | # define llround RT_NOCRT(llround)
|
---|
633 | # define log1p RT_NOCRT(log1p)
|
---|
634 | # define logb RT_NOCRT(logb)
|
---|
635 | # define lrint RT_NOCRT(lrint)
|
---|
636 | # define lround RT_NOCRT(lround)
|
---|
637 | # define nextafter RT_NOCRT(nextafter)
|
---|
638 | # define remainder RT_NOCRT(remainder)
|
---|
639 | # define remquo RT_NOCRT(remquo)
|
---|
640 | # define rint RT_NOCRT(rint)
|
---|
641 | # define j0 RT_NOCRT(j0)
|
---|
642 | # define j1 RT_NOCRT(j1)
|
---|
643 | # define jn RT_NOCRT(jn)
|
---|
644 | # define scalb RT_NOCRT(scalb)
|
---|
645 | # define y0 RT_NOCRT(y0)
|
---|
646 | # define y1 RT_NOCRT(y1)
|
---|
647 | # define yn RT_NOCRT(yn)
|
---|
648 | # define gamma RT_NOCRT(gamma)
|
---|
649 | # define copysign RT_NOCRT(copysign)
|
---|
650 | # define fdim RT_NOCRT(fdim)
|
---|
651 | # define fmax RT_NOCRT(fmax)
|
---|
652 | # define fmin RT_NOCRT(fmin)
|
---|
653 | # define nearbyint RT_NOCRT(nearbyint)
|
---|
654 | # define round RT_NOCRT(round)
|
---|
655 | # define scalbln RT_NOCRT(scalbln)
|
---|
656 | # define scalbn RT_NOCRT(scalbn)
|
---|
657 | # define tgamma RT_NOCRT(tgamma)
|
---|
658 | # define trunc RT_NOCRT(trunc)
|
---|
659 | # define drem RT_NOCRT(drem)
|
---|
660 | # define finite RT_NOCRT(finite)
|
---|
661 | # define isnanf RT_NOCRT(isnanf)
|
---|
662 | # define gamma_r RT_NOCRT(gamma_r)
|
---|
663 | # define lgamma_r RT_NOCRT(lgamma_r)
|
---|
664 | # define significand RT_NOCRT(significand)
|
---|
665 | # define acosf RT_NOCRT(acosf)
|
---|
666 | # define asinf RT_NOCRT(asinf)
|
---|
667 | # define atanf RT_NOCRT(atanf)
|
---|
668 | # define atan2f RT_NOCRT(atan2f)
|
---|
669 | # define cosf RT_NOCRT(cosf)
|
---|
670 | # define sinf RT_NOCRT(sinf)
|
---|
671 | # define tanf RT_NOCRT(tanf)
|
---|
672 | # define coshf RT_NOCRT(coshf)
|
---|
673 | # define sinhf RT_NOCRT(sinhf)
|
---|
674 | # define tanhf RT_NOCRT(tanhf)
|
---|
675 | # define exp2f RT_NOCRT(exp2f)
|
---|
676 | # define expf RT_NOCRT(expf)
|
---|
677 | # define expm1f RT_NOCRT(expm1f)
|
---|
678 | # define frexpf RT_NOCRT(frexpf)
|
---|
679 | # define ilogbf RT_NOCRT(ilogbf)
|
---|
680 | # define ldexpf RT_NOCRT(ldexpf)
|
---|
681 | # define log10f RT_NOCRT(log10f)
|
---|
682 | # define log1pf RT_NOCRT(log1pf)
|
---|
683 | # define logf RT_NOCRT(logf)
|
---|
684 | # define modff RT_NOCRT(modff)
|
---|
685 | # define powf RT_NOCRT(powf)
|
---|
686 | # define sqrtf RT_NOCRT(sqrtf)
|
---|
687 | # define ceilf RT_NOCRT(ceilf)
|
---|
688 | # define fabsf RT_NOCRT(fabsf)
|
---|
689 | # define floorf RT_NOCRT(floorf)
|
---|
690 | # define fmodf RT_NOCRT(fmodf)
|
---|
691 | # define roundf RT_NOCRT(roundf)
|
---|
692 | # define erff RT_NOCRT(erff)
|
---|
693 | # define erfcf RT_NOCRT(erfcf)
|
---|
694 | # define hypotf RT_NOCRT(hypotf)
|
---|
695 | # define lgammaf RT_NOCRT(lgammaf)
|
---|
696 | # define acoshf RT_NOCRT(acoshf)
|
---|
697 | # define asinhf RT_NOCRT(asinhf)
|
---|
698 | # define atanhf RT_NOCRT(atanhf)
|
---|
699 | # define cbrtf RT_NOCRT(cbrtf)
|
---|
700 | # define logbf RT_NOCRT(logbf)
|
---|
701 | # define copysignf RT_NOCRT(copysignf)
|
---|
702 | # define llrintf RT_NOCRT(llrintf)
|
---|
703 | # define llroundf RT_NOCRT(llroundf)
|
---|
704 | # define lrintf RT_NOCRT(lrintf)
|
---|
705 | # define lroundf RT_NOCRT(lroundf)
|
---|
706 | # define nearbyintf RT_NOCRT(nearbyintf)
|
---|
707 | # define nextafterf RT_NOCRT(nextafterf)
|
---|
708 | # define remainderf RT_NOCRT(remainderf)
|
---|
709 | # define remquof RT_NOCRT(remquof)
|
---|
710 | # define rintf RT_NOCRT(rintf)
|
---|
711 | # define scalblnf RT_NOCRT(scalblnf)
|
---|
712 | # define scalbnf RT_NOCRT(scalbnf)
|
---|
713 | # define truncf RT_NOCRT(truncf)
|
---|
714 | # define fdimf RT_NOCRT(fdimf)
|
---|
715 | # define fmaf RT_NOCRT(fmaf)
|
---|
716 | # define fmaxf RT_NOCRT(fmaxf)
|
---|
717 | # define fminf RT_NOCRT(fminf)
|
---|
718 | # define dremf RT_NOCRT(dremf)
|
---|
719 | # define finitef RT_NOCRT(finitef)
|
---|
720 | # define gammaf RT_NOCRT(gammaf)
|
---|
721 | # define j0f RT_NOCRT(j0f)
|
---|
722 | # define j1f RT_NOCRT(j1f)
|
---|
723 | # define jnf RT_NOCRT(jnf)
|
---|
724 | # define scalbf RT_NOCRT(scalbf)
|
---|
725 | # define y0f RT_NOCRT(y0f)
|
---|
726 | # define y1f RT_NOCRT(y1f)
|
---|
727 | # define ynf RT_NOCRT(ynf)
|
---|
728 | # define gammaf_r RT_NOCRT(gammaf_r)
|
---|
729 | # define lgammaf_r RT_NOCRT(lgammaf_r)
|
---|
730 | # define significandf RT_NOCRT(significandf)
|
---|
731 | # define acoshl RT_NOCRT(acoshl)
|
---|
732 | # define acosl RT_NOCRT(acosl)
|
---|
733 | # define asinhl RT_NOCRT(asinhl)
|
---|
734 | # define asinl RT_NOCRT(asinl)
|
---|
735 | # define atan2l RT_NOCRT(atan2l)
|
---|
736 | # define atanhl RT_NOCRT(atanhl)
|
---|
737 | # define atanl RT_NOCRT(atanl)
|
---|
738 | # define cbrtl RT_NOCRT(cbrtl)
|
---|
739 | # define ceill RT_NOCRT(ceill)
|
---|
740 | # define copysignl RT_NOCRT(copysignl)
|
---|
741 | # define coshl RT_NOCRT(coshl)
|
---|
742 | # define cosl RT_NOCRT(cosl)
|
---|
743 | # define erfcl RT_NOCRT(erfcl)
|
---|
744 | # define erfl RT_NOCRT(erfl)
|
---|
745 | # define exp2l RT_NOCRT(exp2l)
|
---|
746 | # define expl RT_NOCRT(expl)
|
---|
747 | # define expm1l RT_NOCRT(expm1l)
|
---|
748 | # define fabsl RT_NOCRT(fabsl)
|
---|
749 | # define fdiml RT_NOCRT(fdiml)
|
---|
750 | # define floorl RT_NOCRT(floorl)
|
---|
751 | # define fmal RT_NOCRT(fmal)
|
---|
752 | # define fmaxl RT_NOCRT(fmaxl)
|
---|
753 | # define fminl RT_NOCRT(fminl)
|
---|
754 | # define fmodl RT_NOCRT(fmodl)
|
---|
755 | # define frexpl RT_NOCRT(frexpl)
|
---|
756 | # define hypotl RT_NOCRT(hypotl)
|
---|
757 | # define ilogbl RT_NOCRT(ilogbl)
|
---|
758 | # define ldexpl RT_NOCRT(ldexpl)
|
---|
759 | # define lgammal RT_NOCRT(lgammal)
|
---|
760 | # define llrintl RT_NOCRT(llrintl)
|
---|
761 | # define llroundl RT_NOCRT(llroundl)
|
---|
762 | # define log10l RT_NOCRT(log10l)
|
---|
763 | # define log1pl RT_NOCRT(log1pl)
|
---|
764 | # define log2l RT_NOCRT(log2l)
|
---|
765 | # define logbl RT_NOCRT(logbl)
|
---|
766 | # define logl RT_NOCRT(logl)
|
---|
767 | # define lrintl RT_NOCRT(lrintl)
|
---|
768 | # define lroundl RT_NOCRT(lroundl)
|
---|
769 | # define modfl RT_NOCRT(modfl)
|
---|
770 | # define nanl RT_NOCRT(nanl)
|
---|
771 | # define nearbyintl RT_NOCRT(nearbyintl)
|
---|
772 | # define nextafterl RT_NOCRT(nextafterl)
|
---|
773 | # define nexttoward RT_NOCRT(nexttoward)
|
---|
774 | # define nexttowardf RT_NOCRT(nexttowardf)
|
---|
775 | # define nexttowardl RT_NOCRT(nexttowardl)
|
---|
776 | # define powl RT_NOCRT(powl)
|
---|
777 | # define remainderl RT_NOCRT(remainderl)
|
---|
778 | # define remquol RT_NOCRT(remquol)
|
---|
779 | # define rintl RT_NOCRT(rintl)
|
---|
780 | # define roundl RT_NOCRT(roundl)
|
---|
781 | # define scalblnl RT_NOCRT(scalblnl)
|
---|
782 | # define scalbnl RT_NOCRT(scalbnl)
|
---|
783 | # define sinhl RT_NOCRT(sinhl)
|
---|
784 | # define sinl RT_NOCRT(sinl)
|
---|
785 | # define sqrtl RT_NOCRT(sqrtl)
|
---|
786 | # define tanhl RT_NOCRT(tanhl)
|
---|
787 | # define tanl RT_NOCRT(tanl)
|
---|
788 | # define tgammal RT_NOCRT(tgammal)
|
---|
789 | # define truncl RT_NOCRT(truncl)
|
---|
790 | # define nan RT_NOCRT(nan)
|
---|
791 | # define nanf RT_NOCRT(nanf)
|
---|
792 | # define sincos RT_NOCRT(sincos)
|
---|
793 | # define sincosf RT_NOCRT(sincosf)
|
---|
794 | # define sincosl RT_NOCRT(sincosl)
|
---|
795 | # define exp10f RT_NOCRT(exp10f)
|
---|
796 | # define exp10 RT_NOCRT(exp10)
|
---|
797 | # define exp10l RT_NOCRT(exp10l)
|
---|
798 | # define log2f RT_NOCRT(log2f)
|
---|
799 | # define log2 RT_NOCRT(log2)
|
---|
800 | # define log2l RT_NOCRT(log2l)
|
---|
801 | # define tgammaf RT_NOCRT(tgammaf)
|
---|
802 | # define significandl RT_NOCRT(significandl)
|
---|
803 | # define j0l RT_NOCRT(j0l)
|
---|
804 | # define j1l RT_NOCRT(j1l)
|
---|
805 | # define jnl RT_NOCRT(jnl)
|
---|
806 | # define scalbl RT_NOCRT(scalbl)
|
---|
807 | # define y0l RT_NOCRT(y0l)
|
---|
808 | # define y1l RT_NOCRT(y1l)
|
---|
809 | # define ynl RT_NOCRT(ynl)
|
---|
810 | # define lgammal_r RT_NOCRT(lgammal_r)
|
---|
811 | # define gammal RT_NOCRT(gammal)
|
---|
812 | #endif
|
---|
813 |
|
---|
814 | /*
|
---|
815 | * Include inlined implementations.
|
---|
816 | */
|
---|
817 | #ifdef RT_ARCH_AMD64
|
---|
818 | # include <iprt/nocrt/amd64/math.h>
|
---|
819 | #elif defined(RT_ARCH_X86)
|
---|
820 | # include <iprt/nocrt/x86/math.h>
|
---|
821 | #endif
|
---|
822 |
|
---|
823 | #endif
|
---|
824 |
|
---|