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