/**************************************************************************
*   Copyright 2000 Compaq Computer Corporation
*
*   COMPAQ Registered in U.S. Patent and Trademark Office.
*
*   Confidential computer software. Valid license from Compaq or authorized
*   sublicensor required for possession, use or copying. Consistent with
*   FAR 12.211 and 12.212, Commercial Computer Software, Computer Software
*   Documentation, and Technical Data for Commercial Items are licensed to
*   the U.S. Government under vendor's standard commercial license.
**************************************************************************/

#if !defined(_CMATH_)
#define _CMATH_

#if defined(__linux__)

#if defined(__PURE_CNAME)
typedef union 
  { unsigned char __HUGE_DIGITS[8]; double __HUGE_NUM;} __HUGE_UNION;
static __HUGE_UNION __HUGE = {0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x7f};
#define HUGE_VAL (__HUGE.__HUGE_NUM)
#endif

#else
#if defined(_IEEE_FP)
#       define HUGE_VAL 1.8e308
#else
#	define HUGE_VAL 1.797693134862315708e308
#endif
#endif   /* __linux__ */

extern "C" {
namespace std {

extern double acos( double );
extern double asin( double );
extern double atan( double );
extern double atan2( double, double );
extern double ceil( double );
extern double cos( double );
extern double cosh( double );
extern double exp( double );
extern double fabs( double );
extern double floor( double );
extern double fmod( double, double );
extern double frexp( double, int * );
extern double ldexp( double, int );
extern double log( double );
extern double log10( double );
extern double modf( double, double * );
extern double pow( double, double );
extern double sin( double );
extern double sinh( double );
extern double sqrt( double );
extern double tan( double );
extern double tanh( double );

//
//   Supporting Math Functions
//
//  We can't provide these in -std ms mode because if we do we will
//  get an compiler message that std::acosf and the acosf brought in
//  by <math.h> conflict.  We can provide them in __PURE_CNAME mode
//  since we never bring in <math.h> in that case.
//
#if (!defined(__STD_MS) && !defined(__MS)) || defined(__PURE_CNAME)
extern float acosf ( float );
extern float asinf ( float );
extern float atanf ( float );
extern float atan2f ( float, float );
extern float ceilf ( float );
extern float cosf ( float );
extern float coshf ( float );
extern float expf ( float );
extern float fabsf ( float );
extern float floorf ( float );
extern float fmodf ( float, float );
extern float frexpf ( float, int * );
extern float ldexpf ( float, int );
extern float logf ( float );
extern float log10f ( float );
extern float modff ( float, float * );
extern float powf ( float, float );
extern float sinf ( float );
extern float sinhf ( float );
extern float sqrtf ( float );
extern float tanf ( float );
extern float tanhf ( float );

#if __X_FLOAT      /* use real long double math functions */
extern long double acosl( long double );
extern long double asinl( long double );
extern long double atanl( long double );
extern long double atan2l( long double, long double );
extern long double ceill( long double );
extern long double cosl( long double );
extern long double coshl( long double );
extern long double expl( long double );
extern long double fabsl( long double );
extern long double floorl( long double );
extern long double fmodl( long double, long double );
extern long double frexpl( long double, int * );
extern long double ldexpl( long double, int );
extern long double logl( long double );
extern long double log10l( long double );
extern long double modfl( long double, long double * );
extern long double powl( long double, long double );
extern long double sinl( long double );
extern long double sinhl( long double );
extern long double sqrtl( long double );
extern long double tanl( long double );
extern long double tanhl( long double );
#endif  //
#endif  // !defined(__STD_MS) && !defined(__MS)
}   /* namespace std */
}   /* extern "C" */

// 
//  Overloads and Added Signatures Required by C++ Standard
//
//  Provide only if __PURE_CNAME is specified (for standards conformance)
//  or if the user directly asked us to. 
//
#if defined(__PURE_CNAME) || defined(__CNAME_OVERLOADS)
extern "C++" {
namespace std {

inline double abs(double _dbl)         { return fabs(_dbl); }
inline double pow(double _dbl, int _i) { return pow (_dbl, (double)_i); }

inline float abs  ( float _flt )               { return fabsf (_flt); }
inline float acos ( float _flt )               { return acosf (_flt); }
inline float asin ( float _flt )               { return asinf (_flt); }
inline float atan ( float _flt )               { return atanf (_flt); }
inline float atan2( float _flt1, float _flt2 ) { return atan2f(_flt1, _flt2); }
inline float ceil ( float _flt )               { return ceilf (_flt); }
inline float cos  ( float _flt )               { return cosf  (_flt); }
inline float cosh ( float _flt )               { return coshf (_flt); }
inline float exp  ( float _flt )               { return expf  (_flt); }
inline float fabs ( float _flt )               { return fabsf (_flt); }
inline float floor( float _flt )               { return floorf(_flt); }
inline float fmod ( float _flt1, float _flt2 ) { return fmodf (_flt1, _flt2); }
inline float frexp( float _flt,  int *_ip )    { return frexpf(_flt,  _ip); }
inline float ldexp( float _flt,  int _i )      { return ldexpf(_flt,  _i); }
inline float log  ( float _flt )               { return logf  (_flt); }
inline float log10( float _flt )               { return log10f(_flt); }
inline float modf ( float _flt,  float *_fp )  { return modff (_flt,  _fp); }
inline float pow  ( float _flt1, float _flt2 ) { return powf  (_flt1, _flt2); }
inline float pow  ( float _flt,  int _i )      { return powf  (_flt,  _i); }
inline float sin  ( float _flt )               { return sinf  (_flt); }
inline float sinh ( float _flt )               { return sinhf (_flt); }
inline float sqrt ( float _flt )               { return sqrtf (_flt); }
inline float tan  ( float _flt )               { return tanf  (_flt); }
inline float tanh ( float _flt )               { return tanhf (_flt); }

#if __X_FLOAT       /* use real long double math functions */
inline long double abs  ( long double _ldbl)  { return fabsl (_ldbl); }
inline long double acos ( long double _ldbl)  { return acosl (_ldbl); }
inline long double asin ( long double _ldbl)  { return asinl (_ldbl); }
inline long double atan ( long double _ldbl)  { return atanl (_ldbl); }
inline long double atan2( long double _ldbl1,
                          long double _ldbl2) { return atan2l(_ldbl1, _ldbl2); }
inline long double ceil ( long double _ldbl)  { return ceill (_ldbl); }
inline long double cos  ( long double _ldbl)  { return cosl  (_ldbl); }
inline long double cosh ( long double _ldbl)  { return coshl (_ldbl); }
inline long double exp  ( long double _ldbl)  { return expl  (_ldbl); }
inline long double fabs ( long double _ldbl)  { return fabsl (_ldbl); }
inline long double floor( long double _ldbl)  { return floorl(_ldbl); }
inline long double fmod ( long double _ldbl1,
                          long double _ldbl2) { return fmodl (_ldbl1, _ldbl2); }
inline long double frexp( long double _ldbl, 
                          int *_ip)           { return frexpl(_ldbl,  _ip); }
inline long double ldexp( long double _ldbl, 
                          int _i)             { return ldexpl(_ldbl,  _i); }
inline long double log  ( long double _ldbl)  { return logl  (_ldbl); }
inline long double log10( long double _ldbl)  { return log10l(_ldbl); }
inline long double modf ( long double _ldbl, 
                          long double *_ldp)  { return modfl (_ldbl,  _ldp); }
inline long double pow  ( long double _ldbl1,
                          long double _ldbl2) { return powl  (_ldbl1, _ldbl2); }
inline long double pow  ( long double _ldbl, 
                          int _i)             { return powl  (_ldbl,  (long double)_i); }
inline long double sin  ( long double _ldbl)  { return sinl  (_ldbl); }
inline long double sinh ( long double _ldbl)  { return sinhl (_ldbl); }
inline long double sqrt ( long double _ldbl)  { return sqrtl (_ldbl); }
inline long double tan  ( long double _ldbl)  { return tanl  (_ldbl); }
inline long double tanh ( long double _ldbl)  { return tanhl (_ldbl); }
#else
inline long double abs  ( long double _ldbl)  { return (long double) fabs((double)_ldbl); }
inline long double acos ( long double _ldbl)  { return (long double) acos ((double)_ldbl); }
inline long double asin ( long double _ldbl)  { return (long double) asin ((double)_ldbl); }
inline long double atan ( long double _ldbl)  { return (long double) atan ((double)_ldbl); }
inline long double atan2( long double _ldbl1, 
                          long double _ldbl2) { return (long double) atan2((double)_ldbl1,(double)_ldbl2); }
inline long double ceil ( long double _ldbl)  { return (long double) ceil ((double)_ldbl); }
inline long double cos  ( long double _ldbl)  { return (long double) cos  ((double)_ldbl); }
inline long double cosh ( long double _ldbl)  { return (long double) cosh ((double)_ldbl); }
inline long double exp  ( long double _ldbl)  { return (long double) exp  ((double)_ldbl); }
inline long double fabs ( long double _ldbl)  { return (long double) fabs ((double)_ldbl); }
inline long double floor( long double _ldbl)  { return (long double) floor((double)_ldbl); }
inline long double fmod ( long double _ldbl1, 
                          long double _ldbl2) { return (long double) fmod ((double)_ldbl1,(double)_ldbl2); }
inline long double frexp( long double _ldbl, 
                          int *_ip)           { return (long double) frexp((double)_ldbl,_ip); }
inline long double ldexp( long double _ldbl, 
                          int _i)             { return (long double) ldexp((double)_ldbl,_i); }
inline long double log  ( long double _ldbl)  { return (long double) log  ((double)_ldbl); }
inline long double log10( long double _ldbl)  { return (long double) log10((double)_ldbl); }
inline long double modf ( long double _ldbl, 
                          long double *_ldp)  { return (long double) modf ((double)_ldbl,(double*)_ldp); }
inline long double pow  ( long double _ldbl1, 
                          long double _ldbl2) { return (long double) pow  ((double)_ldbl1,(double)_ldbl2); }
inline long double pow  ( long double _ldbl, 
                          int _i)             { return (long double) pow  ((double)_ldbl,(double)_i); }
inline long double sin  ( long double _ldbl)  { return (long double) sin  ((double)_ldbl); }
inline long double sinh ( long double _ldbl)  { return (long double) sinh ((double)_ldbl); }
inline long double sqrt ( long double _ldbl)  { return (long double) sqrt ((double)_ldbl); }
inline long double tan  ( long double _ldbl)  { return (long double) tan  ((double)_ldbl); }
inline long double tanh ( long double _ldbl)  { return (long double) tanh ((double)_ldbl); }
#endif   /* __X_FLOAT */

}  /* namespace std */
}  /* extern "C++"  */
#endif

//
//  _FASTMATH implies that we can use intrinsic functions for the
//  following routines.
//
#ifdef _FASTMATH
#pragma __message __save
#pragma __message __disable errnointrinsic

#pragma intrinsic(acos)
#pragma intrinsic(asin)
#pragma intrinsic(atan)
#pragma intrinsic(atan2)
#pragma intrinsic(cos)
#pragma intrinsic(exp)
#pragma intrinsic(log)
#pragma intrinsic(log10)
#pragma intrinsic(pow)
#pragma intrinsic(sin)
#pragma intrinsic(sqrt)
#pragma intrinsic(tan)

#pragma intrinsic(acosf)
#pragma intrinsic(asinf)
#pragma intrinsic(atanf)
#pragma intrinsic(atan2f)
#pragma intrinsic(cosf)
#pragma intrinsic(expf)
#pragma intrinsic(logf)
#pragma intrinsic(log10f)
#pragma intrinsic(powf)
#pragma intrinsic(sinf)
#pragma intrinsic(sqrtf)
#pragma intrinsic(tanf)

#pragma __message __restore
#endif

#if !defined(__PURE_CNAME) && !defined(_MATH_H_) && !defined(_MATH_H)
#   include <math.h>
#endif

#endif   /* _CMATH_ */
