StdLib/Include/math.h

   1 /** @file
   2   Floating-point Math functions and macros.
   3
   4   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials are licensed and made available under
   6   the terms and conditions of the BSD License that accompanies this distribution.
   7   The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13  * ====================================================
  14  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
  15  *
  16  * Developed at SunPro, a Sun Microsystems, Inc. business.
  17  * Permission to use, copy, modify, and distribute this
  18  * software is freely granted, provided that this notice
  19  * is preserved.
  20  * ====================================================
  21
  22     NetBSD: math.h,v 1.44 2006/03/25 16:41:11 xtraeme Exp
  23     dlibm.h 5.1 93/09/24
  24 **/
  25 #ifndef _MATH_H_
  26 #define _MATH_H_
  27
  28 #include  <sys/EfiCdefs.h>
  29 #include  <sys/featuretest.h>
  30
  31 /** @{
  32     @brief    These are forward references to unions and macros used internaly
  33               by the implementation of the math functions and macros.
  34 **/
  35 union __float_u {
  36   unsigned char __dummy[sizeof(float)];
  37   float __val;
  38 };
  39
  40 union __double_u {
  41   unsigned char __dummy[sizeof(double)];
  42   double __val;
  43 };
  44
  45 union __long_double_u {
  46   unsigned char __dummy[sizeof(long double)];
  47   long double __val;
  48 };
  49
  50 #include <machine/math.h>   /* may use __float_u, __double_u, or __long_double_u */
  51
  52 #ifdef __HAVE_LONG_DOUBLE
  53 #define __fpmacro_unary_floating(__name, __arg0)      \
  54   /* LINTED */              \
  55   ((sizeof (__arg0) == sizeof (float))        \
  56   ? __ ## __name ## f (__arg0)        \
  57   : (sizeof (__arg0) == sizeof (double))        \
  58   ? __ ## __name ## d (__arg0)        \
  59   : __ ## __name ## l (__arg0))
  60 #else
  61 #define __fpmacro_unary_floating(__name, __arg0)      \
  62   /* LINTED */              \
  63   ((sizeof (__arg0) == sizeof (float))        \
  64   ? __ ## __name ## f (__arg0)        \
  65   : __ ## __name ## d (__arg0))
  66 #endif /* __HAVE_LONG_DOUBLE */
  67
  68 extern const union __double_u       __infinity;
  69 extern const union __float_u        __infinityf;
  70 extern const union __long_double_u  __infinityl;
  71
  72 /* C99 7.12.3.1 int fpclassify(real-floating x) */
  73 #define fpclassify(__x) __fpmacro_unary_floating(fpclassify, __x)
  74
  75 /* C99 7.12.3.3 int isinf(real-floating x) */
  76 #ifdef __isinf
  77   #define isinf(__x)  __isinf(__x)
  78 #else
  79   #define isinf(__x)  __fpmacro_unary_floating(isinf, __x)
  80 #endif
  81
  82 /* C99 7.12.3.4 int isnan(real-floating x) */
  83 #ifdef __isnan
  84   #define isnan(__x)  __isnan(__x)
  85 #else
  86   #define isnan(__x)  __fpmacro_unary_floating(isnan, __x)
  87 #endif
  88 /*@)*/
  89
  90 /*#############################################################
  91  * ISO C95
  92  */
  93
  94 /**@{
  95     Double, float, and long double versions, respectively, of HUGE_VAL.
  96 */
  97 #define HUGE_VAL  __infinity.__val
  98 #define HUGE_VALF __infinityf.__val
  99 #define HUGE_VALL __infinityl.__val
 100 /*@)*/
 101
 102 __BEGIN_DECLS
 103 /*
 104  * ANSI/POSIX
 105  */
 106 /** Compute the principal value of the arc cosine of Arg.
 107
 108     @param[in]    Arg   The value to compute the arc cosine of.
 109
 110     @return   The computed value of the arc cosine of Arg in the interval [0,pi] radians.
 111               If Arg is not in the interval [-1,+1], errno is set to EDOM.
 112 **/
 113 double  acos(double Arg);
 114
 115 /** Compute the principal value of the arc sine of Arg.
 116
 117     @param[in]    Arg   The value to compute the arc sine of.
 118
 119     @return   The computed value of the arc sine of Arg in the interval [-pi/2,+pi/2] radians.
 120               If Arg is not in the interval [-1,+1], errno is set to EDOM.
 121 **/
 122 double  asin(double Arg);
 123
 124 /** Compute the principal value of the arc tangent of Arg.
 125
 126     @param[in]    Arg   The value to compute the arc tangent of.
 127
 128     @return   The computed value of the arc tangent of Arg in the interval [-pi/2,+pi/2] radians.
 129 **/
 130 double  atan(double Arg);
 131
 132 /** Compute the value of the arc tangent of (Num / Denom).
 133     The sign of both arguments is used to determine the quadrant of the return value.
 134
 135     @param[in]    Num   The numerator of the value to compute the arc tangent of.
 136     @param[in]    Denom The denominator of the value to compute the arc tangent of.
 137
 138     @return   The computed value of the arc tangent of (Num / Denom) in the interval [-pi,+pi] radians.
 139 **/
 140 double  atan2(double Num, double Denom);
 141
 142 /** Compute the value of the cosine of Arg, measured in radians.
 143
 144     @param[in]    Arg   The value to compute the cosine of.
 145
 146     @return   The computed value of the cosine of Arg.
 147 **/
 148 double  cos(double Arg);
 149
 150 /** Compute the value of the sine of Arg.
 151
 152     @param[in]    Arg   The value to compute the sine of.
 153
 154     @return   The computed value of the sine of Arg.
 155 **/
 156 double  sin(double Arg);
 157
 158 /** Compute the value of the tangent of Arg.
 159
 160     @param[in]    Arg   The value to compute the tangent of.
 161
 162     @return   The computed value of the tangent of Arg.
 163 **/
 164 double  tan(double Arg);
 165
 166
 167 /** Compute the value of the hyperbolic cosine of Arg.
 168
 169     @param[in]    Arg   The value to compute the hyperbolic cosine of.
 170
 171     @return   The computed value of the hyperbolic cosine of Arg.
 172               If the magnitude of Arg is too large, errno is set to ERANGE.
 173 **/
 174 double  cosh(double Arg);
 175
 176 /** Compute the value of the hyperbolic sine of Arg.
 177
 178     @param[in]    Arg   The value to compute the hyperbolic sine of.
 179
 180     @return   The computed value of the hyperbolic sine of Arg.
 181               If the magnitude of Arg is too large, errno is set to ERANGE.
 182 **/
 183 double  sinh(double Arg);
 184
 185 /** Compute the value of the hyperbolic tangent of Arg.
 186
 187     @param[in]    Arg   The value to compute the hyperbolic tangent of.
 188
 189     @return   The computed value of the hyperbolic tangent of Arg.
 190 **/
 191 double  tanh(double Arg);
 192
 193
 194 /** Compute the base-e exponential of Arg.
 195
 196     @param[in]    Arg   The value to compute the base-e exponential of.
 197
 198     @return   The computed value of e**Arg.
 199               If the magnitude of Arg is too large, errno is set to ERANGE.
 200 **/
 201 double  exp(double Arg);
 202
 203 /** Break a floating-point number into a normalized fraction and an integral power of 2.
 204
 205     @param[in]    Value   The floating-point value to be broken down.
 206     @param[out]   Exp     A pointer to an integer object to receive the integral power of 2 exponent.
 207
 208     @return   The frexp function returns a value R, such that Value == R**Exp.
 209               If Value is zero, both parts of the result are zero.
 210 **/
 211 double  frexp(double Value, int *Exp);
 212
 213 /** Multiply a floating-point number, Value, by an integral power of 2, Exp.
 214
 215     @param[in]    Value   The floating-point value to be multiplied.
 216     @param[out]   Exp     The integral power of 2 to multiply Value by.
 217
 218     @return   The ldexp function returns a value R, such that R = Value x 2**Exp.
 219               If a range error occurs, errno will be set to ERANGE.
 220 **/
 221 double  ldexp(double Value, int Exp);
 222
 223 /** Compute the natural logarithm of Arg.
 224
 225     @param[in]    Arg   The value to compute the natural logarithm of.
 226
 227     @return   The log function returns log base-e of Arg. If Arg is negative, errno is set to EDOM.
 228               Otherwise, errno will be set to ERANGE if a range error occurs.
 229 **/
 230 double  log(double Arg);
 231
 232 /** Compute the common (base-10) logarithm of Arg.
 233
 234     @param[in]    Arg   The value to compute the common logarithm of.
 235
 236     @return   The log10 function returns log base-10 of Arg. If Arg is negative, errno is set to EDOM.
 237               Otherwise, errno will be set to ERANGE if Arg is 0.
 238 **/
 239 double  log10(double Arg);
 240
 241 /** Compute the base-2 logarithm of Arg.
 242
 243     @param[in]    Arg   The value to compute the base-2 logarithm of.
 244
 245     @return   The log function returns log base-2 of Arg. If Arg is negative, errno is set to EDOM.
 246               Otherwise, errno will be set to ERANGE if Arg is 0.
 247 **/
 248 double  log2(double Arg);
 249
 250 /** Break Value into integral and fractional parts, each of which has the same type and sign
 251     as Value.  Store the integral part in the object pointed to by Integ and return the
 252     fractional part.
 253
 254     @param[in]    Value   The value to compute the arc cosine of.
 255     @param[out]   Integ   Pointer to where the integral component is to be stored.
 256
 257     @return   The fractional part of Value is returned directly while the integral part is
 258               returned in the location pointed to by Integ.
 259 **/
 260 double  modf(double Value, double *Integ);
 261
 262 /** Compute Value raised to the power Exp.
 263
 264     @param[in]    Value   The value to be raised.
 265     @param[in]    Exp     The power Value is to be raised to.
 266
 267     @return   The pow function returns Value**Exp.  If an error occurs, errno will be set as follows:
 268                 - EDOM: Value is finite and negative and Exp is finite and not an integer.
 269                 - EDOM: Both Value and Exp are zero.
 270                 - EDOM: Value is zero and Exp is less than zero.
 271 **/
 272 double  pow(double Value, double Exp);
 273
 274 /** Compute the non-negative square root of Arg.
 275
 276     @param[in]    Arg   The value to compute the square root of.
 277
 278     @return   The square root of Arg.  If Arg is less than zero, errno is set to EDOM.
 279 **/
 280 double  sqrt(double Arg);
 281
 282
 283 /** Compute the smallest integer value not less than Arg.
 284
 285     @param[in]    Arg   The value to compute the ceiling of.
 286
 287     @return   The ceiling of Arg expressed as a floating-point number.
 288 **/
 289 double  ceil(double Arg);
 290
 291 /** Compute the absolute value of Arg.
 292
 293     @param[in]    Arg   The value to compute the absolute value of.
 294
 295     @return   The absolute value of Arg.
 296 **/
 297 double  fabs(double Arg);
 298
 299 /** Compute the largest integer value not greater than Arg.
 300
 301     @param[in]    Arg   The value to compute the floor of.
 302
 303     @return   The largest integer value not greater than Arg, expressed as a floating-point number.
 304 **/
 305 double  floor(double);
 306
 307 /** Compute the floating-point remainder of A1 / A2.
 308
 309     @param[in]    A1    The dividend.
 310     @param[in]    A2    The divisor.
 311
 312     @return   The remainder of A1 / A2 with the same sign as A1.  If A2 is zero, the fmod function
 313               returns 0.
 314 **/
 315 double  fmod(double A1, double A2);
 316
 317
 318 int finite(double);
 319 double  expm1(double);
 320
 321 /**@{
 322     C99, Posix, or NetBSD functions that are not part of the C95 specification.
 323 **/
 324 /*
 325  * Functions callable from C, intended to support IEEE arithmetic.
 326  */
 327 double  copysign(double, double);
 328 double  scalbn(double, int);
 329
 330 /*
 331  * Library implementation
 332  */
 333 int __fpclassifyf(float);
 334 int __fpclassifyd(double);
 335 int __isinff(float);
 336 int __isinfd(double);
 337 int __isnanf(float);
 338 int __isnand(double);
 339
 340 #ifdef __HAVE_LONG_DOUBLE
 341   int __fpclassifyl(long double);
 342   int __isinfl(long double);
 343   int __isnanl(long double);
 344 #endif  /* __HAVE_LONG_DOUBLE */
 345 /*@}*/
 346
 347 __END_DECLS
 348
 349 /**@{
 350     Extensions provided by NetBSD but not required by the C95 standard.
 351 **/
 352 extern int signgam;
 353
 354 enum fdversion {fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix};
 355
 356 #define _LIB_VERSION_TYPE enum fdversion
 357 #define _LIB_VERSION _fdlib_version
 358
 359 /** If global variable _LIB_VERSION is not desirable, one may
 360  * change the following to be a constant by:
 361  *  #define _LIB_VERSION_TYPE const enum version
 362  * In that case, after one initializes the value _LIB_VERSION (see
 363  * s_lib_version.c) during compile time, it cannot be modified
 364  * in the middle of a program
 365  */
 366 extern  _LIB_VERSION_TYPE  _LIB_VERSION;
 367
 368 #define _IEEE_  fdlibm_ieee
 369 #define _SVID_  fdlibm_svid
 370 #define _XOPEN_ fdlibm_xopen
 371 #define _POSIX_ fdlibm_posix
 372
 373 #ifndef __cplusplus
 374 struct exception {
 375   int type;
 376   char *name;
 377   double arg1;
 378   double arg2;
 379   double retval;
 380 };
 381 #endif
 382
 383 #define HUGE    MAXFLOAT
 384
 385 /** set X_TLOSS = pi*2**52 **/
 386 #define X_TLOSS   1.41484755040568800000e+16
 387
 388 #define DOMAIN    1
 389 #define SING      2
 390 #define OVERFLOW  3
 391 #define UNDERFLOW 4
 392 #define TLOSS     5
 393 #define PLOSS     6
 394 /*@}*/
 395
 396 /* 7.12#4 INFINITY */
 397 #ifdef __INFINITY
 398 #define INFINITY  __INFINITY  /**< float constant which overflows */
 399 #else
 400 #define INFINITY  HUGE_VALF   /**< positive infinity */
 401 #endif /* __INFINITY */
 402
 403 /* 7.12#5 NAN: a quiet NaN, if supported */
 404 #ifdef __HAVE_NANF
 405 extern const union __float_u __nanf;
 406 #define NAN   __nanf.__val
 407 #endif /* __HAVE_NANF */
 408
 409 /**@{
 410     C99 7.12#6 Number classification macros represent mutually exclusive kinds of floating-point
 411     values.
 412 **/
 413 #define FP_INFINITE   0x00
 414 #define FP_NAN        0x01
 415 #define FP_NORMAL     0x02
 416 #define FP_SUBNORMAL  0x03
 417 #define FP_ZERO       0x04
 418 /* NetBSD extensions */
 419 #define _FP_LOMD      0x80    /**< range for machine-specific classes */
 420 #define _FP_HIMD      0xff
 421 /*@)*/
 422
 423 /**@{
 424  * Constants ala XOPEN/SVID.
 425  */
 426 #define M_E         2.7182818284590452354   /**< e */
 427 #define M_LOG2E     1.4426950408889634074   /**< log 2e */
 428 #define M_LOG10E    0.43429448190325182765  /**< log 10e */
 429 #define M_LN2       0.69314718055994530942  /**< log e2 */
 430 #define M_LN10      2.30258509299404568402  /**< log e10 */
 431 #define M_PI        3.14159265358979323846  /**< pi */
 432 #define M_PI_2      1.57079632679489661923  /**< pi/2 */
 433 #define M_PI_4      0.78539816339744830962  /**< pi/4 */
 434 #define M_1_PI      0.31830988618379067154  /**< 1/pi */
 435 #define M_2_PI      0.63661977236758134308  /**< 2/pi */
 436 #define M_2_SQRTPI  1.12837916709551257390  /**< 2/sqrt(pi) */
 437 #define M_SQRT2     1.41421356237309504880  /**< sqrt(2) */
 438 #define M_SQRT1_2   0.70710678118654752440  /**< 1/sqrt(2) */
 439 #define MAXFLOAT  ((float)3.40282346638528860e+38)
 440 /*@}*/
 441
 442 #endif /* _MATH_H_ */