c99-compat.c

   1 /*
   2  * Simple implementations of some C99 library functions.
   3  * Note that the goal of altfloat is not to create a C99 math library: these
   4  * functions are intended to just be "good enough" on platforms where they are
   5  * missing.  They likely do not fully conform to applicable standards.
   6  *
   7  * Copyright (C) 2010 Nick Bowler.
   8  *
   9  * License BSD2:  2-clause BSD license.  See LICENSE for full terms.
  10  * This is free software: you are free to change and redistribute it.
  11  * There is NO WARRANTY, to the extent permitted by law.
  12  */
  13 #include <config.h>
  14 #include <limits.h>
  15 #include <math.h>
  16
  17 #if NEED_LIBM_NAN
  18 double nan(const char *tagp)
  19 {
  20         return NAN;
  21 }
  22 #endif
  23
  24 #if NEED_LIBM_LOG2
  25 double log2(double x)
  26 {
  27         return log(x) / log(2);
  28 }
  29 #endif
  30
  31 #if NEED_LIBM_EXP2
  32 double exp2(double x)
  33 {
  34         return pow(2, x);
  35 }
  36 #endif
  37
  38 #if NEED_LIBM_FMA
  39 double fma(double x, double y, double z)
  40 {
  41         return (long double) x*y + z;
  42 }
  43 #endif
  44
  45 #if NEED_LIBM_REMQUO
  46 double remquo(double x, double y, int *quo)
  47 {
  48         unsigned tmp = fabs(nearbyint(x/y));
  49         int sign     = signbit(x/y) ? -1 : 1;
  50
  51         *quo = sign * (int)(tmp % (INT_MAX + 1u));
  52         return remainder(x, y);
  53 }
  54 #endif
  55
  56 /*
  57  * Float-valued functions implemented in terms of double-valued functions.
  58  */
  59 #if NEED_LIBM_ACOSF
  60 float acosf(float x)
  61 {
  62         return acos(x);
  63 }
  64 #endif
  65
  66 #if NEED_LIBM_ASINF
  67 float asinf(float x)
  68 {
  69         return asin(x);
  70 }
  71 #endif
  72
  73 #if NEED_LIBM_ATANF
  74 float atanf(float x)
  75 {
  76         return atan(x);
  77 }
  78 #endif
  79
  80 #if NEED_LIBM_ATAN2F
  81 float atan2f(float x, float y)
  82 {
  83         return atan2(x, y);
  84 }
  85 #endif
  86
  87 #if NEED_LIBM_COSF
  88 float cosf(float x)
  89 {
  90         return cos(x);
  91 }
  92 #endif
  93
  94 #if NEED_LIBM_SINF
  95 float sinf(float x)
  96 {
  97         return sin(x);
  98 }
  99 #endif
 100
 101 #if NEED_LIBM_TANF
 102 float tanf(float x)
 103 {
 104         return tan(x);
 105 }
 106 #endif
 107
 108 #if NEED_LIBM_ACOSHF
 109 float acoshf(float x)
 110 {
 111         return acosh(x);
 112 }
 113 #endif
 114
 115 #if NEED_LIBM_ASINHF
 116 float asinhf(float x)
 117 {
 118         return asinh(x);
 119 }
 120 #endif
 121
 122 #if NEED_LIBM_ATANHF
 123 float atanhf(float x)
 124 {
 125         return atanh(x);
 126 }
 127 #endif
 128
 129 #if NEED_LIBM_COSHF
 130 float coshf(float x)
 131 {
 132         return cosh(x);
 133 }
 134 #endif
 135
 136 #if NEED_LIBM_SINHF
 137 float sinhf(float x)
 138 {
 139         return sinh(x);
 140 }
 141 #endif
 142
 143 #if NEED_LIBM_TANHF
 144 float tanhf(float x)
 145 {
 146         return tanh(x);
 147 }
 148 #endif
 149
 150 #if NEED_LIBM_EXPF
 151 float expf(float x)
 152 {
 153         return exp(x);
 154 }
 155 #endif
 156
 157 #if NEED_LIBM_EXP2F
 158 float exp2f(float x)
 159 {
 160         return exp2(x);
 161 }
 162 #endif
 163
 164 #if NEED_LIBM_EXPM1F
 165 float expm1f(float x)
 166 {
 167         return expm1(x);
 168 }
 169 #endif
 170
 171 #if NEED_LIBM_FREXPF
 172 float frexpf(float x, int *exp)
 173 {
 174         return frexp(x, exp);
 175 }
 176 #endif
 177
 178 #if NEED_LIBM_ILOGBF
 179 int ilogbf(float x)
 180 {
 181         return ilogb(x);
 182 }
 183 #endif
 184
 185 #if NEED_LIBM_LDEXPF
 186 float ldexpf(float x, int exp)
 187 {
 188         return ldexp(x, exp);
 189 }
 190 #endif
 191
 192 #if NEED_LIBM_LOGF
 193 float logf(float x)
 194 {
 195         return log(x);
 196 }
 197 #endif
 198
 199 #if NEED_LIBM_LOG10F
 200 float log10f(float x)
 201 {
 202         return log10(x);
 203 }
 204 #endif
 205
 206 #if NEED_LIBM_LOG1PF
 207 float log1pf(float x)
 208 {
 209         return log1p(x);
 210 }
 211 #endif
 212
 213 #if NEED_LIBM_LOG2F
 214 float log2f(float x)
 215 {
 216         return log2(x);
 217 }
 218 #endif
 219
 220 #if NEED_LIBM_LOGBF
 221 float logbf(float x)
 222 {
 223         return logb(x);
 224 }
 225 #endif
 226
 227 #if NEED_LIBM_MODFF
 228 float modff(float x, float *iptr)
 229 {
 230         double tmp, ret;
 231
 232         ret = modf(x, &tmp);
 233         *iptr = tmp;
 234         return ret;
 235 }
 236 #endif
 237
 238 #if NEED_LIBM_SCALBNF
 239 float scalbnf(float x, int exp)
 240 {
 241         return scalbn(x, exp);
 242 }
 243 #endif
 244
 245 #if NEED_LIBM_SCALBLNF
 246 float scalblnf(float x, long exp)
 247 {
 248         return scalbln(x, exp);
 249 }
 250 #endif
 251
 252 #if NEED_LIBM_CBRTF
 253 float cbrtf(float x)
 254 {
 255         return cbrt(x);
 256 }
 257 #endif
 258
 259 #if NEED_LIBM_FABSF
 260 float fabsf(float x)
 261 {
 262         return fabs(x);
 263 }
 264 #endif
 265
 266 #if NEED_LIBM_HYPOTF
 267 float hypotf(float x, float y)
 268 {
 269         return hypot(x, y);
 270 }
 271 #endif
 272
 273 #if NEED_LIBM_POWF
 274 float powf(float x, float y)
 275 {
 276         return pow(x, y);
 277 }
 278 #endif
 279
 280 #if NEED_LIBM_SQRTF
 281 float sqrtf(float x)
 282 {
 283         return sqrt(x);
 284 }
 285 #endif
 286
 287 #if NEED_LIBM_FMODF
 288 float fmodf(float x, float y)
 289 {
 290         return fmod(x, y);
 291 }
 292 #endif
 293
 294 #if NEED_LIBM_REMAINDERF
 295 float remainderf(float x, float y)
 296 {
 297         return remainder(x, y);
 298 }
 299 #endif
 300
 301 #if NEED_LIBM_REMQUOF
 302 float remquof(float x, float y, int *quo)
 303 {
 304         return remquo(x, y, quo);
 305 }
 306 #endif
 307
 308 #if NEED_LIBM_COPYSIGNF
 309 float copysignf(float x, float y)
 310 {
 311         return copysign(x, y);
 312 }
 313 #endif
 314
 315 #if NEED_LIBM_NANF
 316 float nanf(const char *tagp)
 317 {
 318         return nan(tagp);
 319 }
 320 #endif
 321
 322 #if NEED_LIBM_ERFF
 323 float erff(float x)
 324 {
 325         return erf(x);
 326 }
 327 #endif
 328
 329 #if NEED_LIBM_ERFCF
 330 float erfcf(float x)
 331 {
 332         return erfc(x);
 333 }
 334 #endif
 335
 336 #if NEED_LIBM_LGAMMAF
 337 float lgammaf(float x)
 338 {
 339         return lgamma(x);
 340 }
 341 #endif
 342
 343 #if NEED_LIBM_TGAMMAF
 344 float tgammaf(float x)
 345 {
 346         return tgamma(x);
 347 }
 348 #endif
 349
 350 #if NEED_LIBM_CEILF
 351 float ceilf(float x)
 352 {
 353         return ceil(x);
 354 }
 355 #endif
 356
 357 #if NEED_LIBM_FLOORF
 358 float floorf(float x)
 359 {
 360         return floor(x);
 361 }
 362 #endif
 363
 364 #if NEED_LIBM_NEARBYINTF
 365 float nearbyintf(float x)
 366 {
 367         return nearbyint(x);
 368 }
 369 #endif
 370
 371 #if NEED_LIBM_RINTF
 372 float rintf(float x)
 373 {
 374         return rint(x);
 375 }
 376 #endif
 377
 378 #if NEED_LIBM_LRINTF
 379 long lrintf(float x)
 380 {
 381         return lrint(x);
 382 }
 383 #endif
 384
 385 #if NEED_LIBM_LLRINTF
 386 long long llrintf(float x)
 387 {
 388         return llrint(x);
 389 }
 390 #endif
 391
 392 #if NEED_LIBM_ROUNDF
 393 float roundf(float x)
 394 {
 395         return round(x);
 396 }
 397 #endif
 398
 399 #if NEED_LIBM_LROUNDF
 400 long lroundf(float x)
 401 {
 402         return lround(x);
 403 }
 404 #endif
 405
 406 #if NEED_LIBM_LLRINTF
 407 long long llroundf(float x)
 408 {
 409         return llround(x);
 410 }
 411 #endif
 412
 413 #if NEED_LIBM_TRUNCF
 414 float truncf(float x)
 415 {
 416         return trunc(x);
 417 }
 418 #endif
 419
 420 #if NEED_LIBM_FDIMF
 421 float fdimf(float x, float y)
 422 {
 423         return fdim(x, y);
 424 }
 425 #endif
 426
 427 #if NEED_LIBM_FMAXF
 428 float fmaxf(float x, float y)
 429 {
 430         return fmax(x, y);
 431 }
 432 #endif
 433
 434 #if NEED_LIBM_FMINF
 435 float fminf(float x, float y)
 436 {
 437         return fmin(x, y);
 438 }
 439 #endif
 440
 441 #if NEED_LIBM_FMAF
 442 float fmaf(float x, float y, float z)
 443 {
 444         return fma(x, y, z);
 445 }
 446 #endif