www.pudn.com > system.rar > cmath

/****************************************************************************/ 
/*  cmath  v2.54                                                            */ 
/*  Copyright (c) 1999-2004  Texas Instruments Incorporated                 */ 
/****************************************************************************/ 
 
#ifndef __cmath__ 
#define __cmath__ 
 
#include  
 
#ifndef EDOM 
#define EDOM   1 
#endif 
 
#ifndef ERANGE 
#define ERANGE 2 
#endif 
 
#include  
#define HUGE_VAL DBL_MAX 
 
#include  
 
#ifndef __EXTERN 
#define __EXTERN 
#endif 
 
extern "C" namespace std 
{ 
   __EXTERN double sqrt (double x); 
   __EXTERN double exp  (double x); 
   __EXTERN double log  (double x); 
   __EXTERN double log10(double x); 
   __EXTERN double pow  (double x, double y); 
   __EXTERN double sin  (double x); 
   __EXTERN double cos  (double x); 
   __EXTERN double tan  (double x); 
   __EXTERN double asin (double x); 
   __EXTERN double acos (double x); 
   __EXTERN double atan (double x); 
   __EXTERN double atan2(double y, double x); 
   __EXTERN double sinh (double x); 
   __EXTERN double cosh (double x); 
   __EXTERN double tanh (double x); 
 
   __INLINE double ceil (double x); 
   __INLINE double floor(double x); 
 
#ifndef __TMS320C27XX__ 
   __EXTERN double fabs (double x); 
#endif 
 
   __EXTERN double ldexp(double x, int n); 
   __EXTERN double frexp(double x, int *exp); 
   __EXTERN double modf (double x, double *ip); 
   __EXTERN double fmod (double x, double y); 
 
   /* An inline version of fmod that works for limited domain only */ 
   /* See comments in implementation below */ 
   static inline double _FMOD(double x, double y); 
 
   /* these present in many linked images, so we'll tell you about them. */ 
   __EXTERN double _nround(double x); /* round-to-nearest */ 
   __EXTERN double _trunc(double x); /* truncate towards 0 */ 
} 
 
/* the ANSI-optional *f and *l routines */ 
#include  
#include  
 
#include  
 
#ifdef _TI_ENHANCED_MATH_H 
#if 0 
   /* ------------------------------------------------- */ 
   /* Routines below are an addition to ANSI math.h     */ 
   /* Some (noted with "9x" in comment) will become ANSI*/ 
   /* once C9x is approved.                             */ 
   /* ------------------------------------------------- */ 
#endif 
 
extern "C" namespace std 
{ 
   __EXTERN double rsqrt(double x); /*   == 1/sqrt(x) but *MUCH* faster      */ 
   __EXTERN double exp2 (double x); /*9x mathematically equiv to pow(2.0 ,x) */ 
   __EXTERN double exp10(double x); /*   mathematically equiv to pow(10.0,x) */ 
   __EXTERN double log2 (double x); /*9x mathematically equiv to log(x)/log(2.0)*/ 
 
   __EXTERN double powi(double x, int i); /* equiv to pow(x,(double)i) */ 
 
   __EXTERN double cot  (double x); 
   __EXTERN double acot (double x); 
   __EXTERN double acot2(double x, double y); 
 
   __EXTERN double coth (double x); 
 
   __EXTERN double asinh(double x); /* 9x */ 
   __EXTERN double acosh(double x); /* 9x */ 
   __EXTERN double atanh(double x); /* 9x */ 
   __EXTERN double acoth(double x); 
 
#define round(x) _nround(x) /* 9x round-to-nearest   */ 
#define trunc(x) _trunc(x) /* 9x truncate towards 0 */ 
 
} /* namespace */ 
 
#endif  /* _TI_ENHANCED_MATH_H */ 
 
 
#ifdef _INLINE 
/****************************************************************************/ 
/*  Inline versions of floor, ceil, fmod                                    */ 
/****************************************************************************/ 
 
static __inline double std::floor(double x)  
{ 
   double y;  
   return (std::modf(x, &y) < 0 ? y - 1 : y); 
} 
 
static __inline double std::ceil(double x) 
{ 
   double y;  
   return (std::modf(x, &y) > 0 ? y + 1 : y); 
} 
 
/*  
   The implementation below does not work correctly for all cases. 
   Consider the case of fmod(Big, 3), for any Big > 2**(MANT_DIG+2). 
   The correct result is one of 0,1, or 2. 
   But the implementation below will *always* return 0  
   because the quotient is only an approximation. 
*/ 
static __inline double _FMOD(double x, double y) 
{ 
   double d = std::fabs(x);  
   if (d - std::fabs(y) == d) return (0); 
   std::modf(x/y, &d);   
   return (x - d * y); 
} 
 
#endif 
 
#include  
 
#ifdef __embedded_cplusplus 
//---------------------------------------------------------------------------- 
// We cannot expect the embedded C++ user to use std namespace. So we include 
// the using directive when compiled under embedded C++. 
//---------------------------------------------------------------------------- 
using namespace std; 
#endif /* __embedded_cplusplus */ 
 
#endif /* __math__ */