openlibm_math.h

Go to the documentation of this file.

/*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunPro, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice
 * is preserved.
 * ====================================================
 */
 
/*
 * from: @(#)fdlibm.h 5.1 93/09/24
 * $FreeBSD: src/lib/msun/src/openlibm.h,v 1.82 2011/11/12 19:55:48 theraven Exp $
 */
 
#ifndef OPENLIBM_MATH_H
#define OPENLIBM_MATH_H
 
 
//#include "Imt.Base.Core.Platform/Platform.h"
#include "../inc/openlibm_defs.h"
 
#ifdef USE_STL
#include <math.h> // redirect to STL
#endif
 
#if (defined(_WIN32) || defined (_MSC_VER)) && !defined(__WIN32__)
    #define __WIN32__
#endif
 
#ifndef __pure2
#define __pure2
#endif
 
/*
 * ANSI/POSIX
 */
 #ifndef _MSC_BUILD
 extern const union __infinity_un {
    unsigned char   __uc[8];
    double      __ud;
} __infinity;
 
extern const union __nan_un {
    unsigned char   __uc[sizeof(float)];
    float       __uf;
} __nan;
#else
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
typedef union {
    unsigned char   __uc[8];
    double      __ud;
}__infinity_un;
extern const __infinity_un __infinity;
typedef union {
    unsigned char   __uc[sizeof(float)];
    float       __uf;
}__nan_un;
extern const __nan_un __nan;
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // _MSC_BUILD
 
/* VBS
#if __GNUC_PREREQ__(3, 3) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
#define __MATH_BUILTIN_CONSTANTS
#endif
 
#if __GNUC_PREREQ__(3, 0) && !defined(__INTEL_COMPILER)
#define __MATH_BUILTIN_RELOPS
#endif
*/
//VBS begin
#if !defined(_MSC_BUILD) && !defined(__ARM_ARCH_ISA_THUMB)
#define __MATH_BUILTIN_CONSTANTS
#endif // _MSC_BUILD
#define __MATH_BUILTIN_RELOPS
#ifndef __ISO_C_VISIBLE
#define __ISO_C_VISIBLE 1999
#endif
//VBS end
#ifndef USE_STL
#ifndef HUGE_VAL
#ifdef __MATH_BUILTIN_CONSTANTS
#define HUGE_VAL    __builtin_huge_val()
#else
#define HUGE_VAL    (__infinity.__ud)
#endif
#endif
#endif /* USE_STL */
 
#if __ISO_C_VISIBLE >= 1999
#ifndef USE_STL
#define FP_ILOGB0   (-INT_MAX)
#define FP_ILOGBNAN INT_MAX
 
#ifdef __MATH_BUILTIN_CONSTANTS
#define HUGE_VALF   __builtin_huge_valf()
#define HUGE_VALL   __builtin_huge_vall()
#define INFINITY    __builtin_inff()
#define NAN     __builtin_nanf("")
#else
#define HUGE_VALF   (float)HUGE_VAL
#define HUGE_VALL   (long double)HUGE_VAL
#define INFINITY    HUGE_VALF
#define NAN     (__nan.__uf)
#endif /* __MATH_BUILTIN_CONSTANTS */
 
#define MATH_ERRNO  1
#define MATH_ERREXCEPT  2
#define math_errhandling    MATH_ERREXCEPT
#define FP_FAST_FMAF    1
#ifdef __ia64__
#define FP_FAST_FMA 1
#define FP_FAST_FMAL    1
#endif
 
/* Symbolic constants to classify floating point numbers. */
#define FP_INFINITE 0x01
#define FP_NAN      0x02
#define FP_NORMAL   0x04
#define FP_SUBNORMAL    0x08
#define FP_ZERO     0x10
#endif /* USE_STL */
 
#define c_fpclassify(x) \
    ((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) \
    : __fpclassifyd(x) )
 
#define c_isfinite(x)                   \
    ((sizeof (x) == sizeof (float)) ? __isfinitef(x)    \
    : __isfinite(x))
#define c_isinf(x)                  \
    ((sizeof (x) == sizeof (float)) ? __isinff(x)   \
    :  __isinf(x))
#define c_isnan(x)                  \
    ((sizeof (x) == sizeof (float)) ? __isnanf(x)   \
    : __isnan(x))
#define c_isnormal(x)                   \
    ((sizeof (x) == sizeof (float)) ? __isnormalf(x)    \
    : __isnormal(x))
 
#ifdef __MATH_BUILTIN_RELOPS
#define isgreater(x, y)     __builtin_isgreater((x), (y))
#define isgreaterequal(x, y)    __builtin_isgreaterequal((x), (y))
#define isless(x, y)        __builtin_isless((x), (y))
#define islessequal(x, y)   __builtin_islessequal((x), (y))
#define islessgreater(x, y) __builtin_islessgreater((x), (y))
#define isunordered(x, y)   __builtin_isunordered((x), (y))
#else
#define isgreater(x, y)     (!isunordered((x), (y)) && (x) > (y))
#define isgreaterequal(x, y)    (!isunordered((x), (y)) && (x) >= (y))
#define isless(x, y)        (!isunordered((x), (y)) && (x) < (y))
#define islessequal(x, y)   (!isunordered((x), (y)) && (x) <= (y))
#define islessgreater(x, y) (!isunordered((x), (y)) && \
                    ((x) > (y) || (y) > (x)))
#define isunordered(x, y)   (isnan(x) || isnan(y))
#endif /* __MATH_BUILTIN_RELOPS */
 
#define signbit(x)                  \
    ((sizeof (x) == sizeof (float)) ? __signbitf(x) \
    : __signbit(x))
 
//VBS
//typedef   __double_t  double_t;
//typedef   __float_t   float_t;
#endif /* __ISO_C_VISIBLE >= 1999 */
 
/*
 * XOPEN/SVID
 */
#if __BSD_VISIBLE || __XSI_VISIBLE
#define M_E     2.7182818284590452354   /* e */
#define M_LOG2E     1.4426950408889634074   /* log 2e */
#define M_LOG10E    0.43429448190325182765  /* log 10e */
#define M_LN2       0.69314718055994530942  /* log e2 */
#define M_LN10      2.30258509299404568402  /* log e10 */
#define M_PI        3.14159265358979323846  /* pi */
#define M_PI_2      1.57079632679489661923  /* pi/2 */
#define M_PI_4      0.78539816339744830962  /* pi/4 */
#define M_1_PI      0.31830988618379067154  /* 1/pi */
#define M_2_PI      0.63661977236758134308  /* 2/pi */
#define M_2_SQRTPI  1.12837916709551257390  /* 2/sqrt(pi) */
#define M_SQRT2     1.41421356237309504880  /* sqrt(2) */
#define M_SQRT1_2   0.70710678118654752440  /* 1/sqrt(2) */
 
#define MAXFLOAT    ((float)3.40282346638528860e+38)
 
#ifndef OPENLIBM_ONLY_THREAD_SAFE
 extern int signgam; // TODO
#endif
#endif /* __BSD_VISIBLE || __XSI_VISIBLE */
 
#if __BSD_VISIBLE
#if 0
/* Old value from 4.4BSD-Lite openlibm.h; this is probably better. */
#define HUGE        HUGE_VAL
#else
#define HUGE        MAXFLOAT
#endif
#endif /* __BSD_VISIBLE */
 
/*
 * Most of these functions depend on the ing mode and have the side
 * effect of raising floating-point exceptions, so they are not declared
 * as __pure2.  In C99, FENV_ACCESS affects the purity of these functions.
 */
 
#if defined(__cplusplus)
extern "C" {
#endif
/* Symbol present when OpenLibm is used. */
int isopenlibm(void);
 
/*
 * ANSI/POSIX
 */
 int    __fpclassifyd(double) __pure2;
 int    __fpclassifyf(float) __pure2;
 int    __isfinitef(float) __pure2;
 int    __isfinite(double) __pure2;
 int    __isinf(double) __pure2;
 int    __isinff(float) __pure2;
 int    __isnan(double) __pure2;
 int    __isnanf(float) __pure2;
 int    __isnormalf(float) __pure2;
 int    __isnormal(double) __pure2;
 int    __signbit(double) __pure2;
 int    __signbitf(float) __pure2;
 
double  c_acos(double);
double  c_asin(double);
double  c_atan(double);
double  c_atan2(double, double);
double  c_cos(double);
double  c_sin(double);
double  c_tan(double);
 
double  c_cosh(double);
double  c_sinh(double);
double  c_tanh(double);
 
double  c_exp(double);
double  c_frexp(double, int *); /* fundamentally !__pure2 */
double  c_ldexp(double, int);
double  c_log(double);
double  c_log10(double);
double  c_modf(double, double *);   /* fundamentally !__pure2 */
 
double  c_pow(double, double);
double  c_sqrt(double);
 
double  c_fabs(double) __pure2;
double  c_floor(double);
double  c_fmod(double, double);
 
/*
 * These functions are not in C90.
 */
#if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE
double  c_acosh(double);
double  c_asinh(double);
double  c_atanh(double);
double  c_erf(double);
double  c_erfc(double);
double  c_expm1(double);
double  c_hypot(double, double);
int c_ilogb(double) __pure2;
double  c_log1p(double);
double  c_log2(double);
double  c_logb(double);
double  c_nan(const char *) __pure2;
double  c_nextafter(double, double);
double  c_remainder(double, double);
double  c_remquo(double, double, int *);
double  c_rint(double);
#endif /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */
 
#if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999
double  c_copysign(double, double) __pure2;
double  c_fdim(double, double);
double  c_scalbln(double, long);
double  c_scalbn(double, int);
double  c_trunc(double);
#endif
 
/* float versions of ANSI/POSIX functions */
#if __ISO_C_VISIBLE >= 1999
 float  c_acosf(float);
 float  c_asinf(float);
 float  c_atanf(float);
 float  c_atan2f(float, float);
 float  c_cosf(float);
 float  c_sinf(float);
 float  c_tanf(float);
 
 float  c_coshf(float);
 float  c_sinhf(float);
 float  c_tanhf(float);
 
 float  c_expf(float);
 float  c_expm1f(float);
 float  c_frexpf(float, int *); /* fundamentally !__pure2 */
 int    c_ilogbf(float) __pure2;
 float  c_ldexpf(float, int);
 float  c_log10f(float);
 float  c_log1pf(float);
 float  c_log2f(float);
 float  c_logf(float);
 float  c_modff(float, float *);    /* fundamentally !__pure2 */
 
 float  c_powf(float, float);
 float  c_sqrtf(float);
 
 float  c_fabsf(float) __pure2;
 float  c_floorf(float);
 float  c_fmodf(float, float);
 
 float  c_erff(float);
 float  c_erfcf(float);
 float  c_hypotf(float, float);
 
 float  c_acoshf(float);
 float  c_asinhf(float);
 float  c_atanhf(float);
  float c_logbf(float);
 float  c_copysignf(float, float) __pure2;
 float  c_nanf(const char *) __pure2;
 float  c_nextafterf(float, float);
 float  c_remainderf(float, float);
 float  c_remquof(float, float, int *);
 float  c_rintf(float);
 float  c_scalblnf(float, long);
 float  c_scalbnf(float, int);
 float  c_truncf(float);
 
 float  c_fdimf(float, float);
 
#endif
 
#if defined(__cplusplus)
}
#endif
 
#endif /* !OPENLIBM_MATH_H */