math.h

利用單晶片LPC2104去接收GPS DATA NMEA

__inline double j1(double __x) { return _FPMANGLE(j1)(__x); }
    /*
     * Bessel function of the first kind, order 1. Returns ERANGE
     * if |x| > 2^52 (total loss of significance).
     */
extern double _FPMANGLE(jn) (int /*n*/, double /*x*/);
__inline double jn(int __n, double __x) { return _FPMANGLE(jn)(__n, __x); }
    /*
     * Bessel function of the first kind, order n. Returns ERANGE
     * if |x| > 2^52 (total loss of significance).
     */
extern double _FPMANGLE(lgamma) (double /*x*/);
__inline double lgamma(double __x) { return _FPMANGLE(lgamma)(__x); }
    /*
     * The log of the absolute value of the gamma function of x. The sign
     * of the gamma function of x is returned in the global `signgam'.
     */
extern double _FPMANGLE(lgamma_r) (double /*x*/, int * /*signgam*/);
__inline double lgamma_r(double __x, int *__p) { return _FPMANGLE(lgamma_r)(__x,__p); }
    /*
     * The log of the absolute value of the gamma function of x. The sign
     * of the gamma function of x is returned in the second argument.
     */
extern double _FPMANGLE(log1p) (double /*x*/);
__inline double log1p(double __x) { return _FPMANGLE(log1p)(__x); }
    /*
     * log(1+x). (More accurate than just coding log(1+x), for small x.)
     */
extern double _FPMANGLE(logb) (double /*x*/);
__inline double logb(double __x) { return _FPMANGLE(logb)(__x); }
    /*
     * Like ilogb but returns a double.
     */
extern double _FPMANGLE(nextafter) (double /*x*/, double /*y*/);
__inline double nextafter(double __x, double __y) { return _FPMANGLE(nextafter)(__x,__y); }
    /*
     * Returns the next representable number after x, in the
     * direction toward y.
     */
extern double _FPMANGLE(remainder) (double /*x*/, double /*y*/);
__inline double remainder(double __x, double __y) { return _FPMANGLE(remainder)(__x,__y); }
    /*
     * Returns the remainder of x by y, in the IEEE 754 sense.
     */
extern double _FPMANGLE(rint) (double /*x*/);
__inline double rint(double __x) { return _FPMANGLE(rint)(__x); }
    /*
     * Rounds x to an integer, in the IEEE 754 sense.
     */
extern double _FPMANGLE(scalb) (double /*x*/, double /*n*/);
__inline double scalb(double __x, double __n) { return _FPMANGLE(scalb)(__x,__n); }
    /*
     * Compute x times 2^n quickly. Undefined if n is not an integer.
     */
extern double _FPMANGLE(scalbn) (double /*x*/, int /*n*/);
__inline double scalbn(double __x, int __n) { return _FPMANGLE(scalbn)(__x,__n); }
    /*
     * Compute x times 2^n quickly.
     */
extern double _FPMANGLE(significand) (double /*x*/);
__inline double significand(double __x) { return _FPMANGLE(significand)(__x); }
    /*
     * Return the fraction part of x, in the range 1.0 to 2.0
     * (including 1.0, excluding 2.0).
     */
extern double _FPMANGLE(y0) (double /*x*/);
__inline double y0(double __x) { return _FPMANGLE(y0)(__x); }
    /*
     * Bessel function of the second kind, order 0. Returns ERANGE
     * if x > 2^52 (total loss of significance).
     */
extern double _FPMANGLE(y1) (double /*x*/);
__inline double y1(double __x) { return _FPMANGLE(y1)(__x); }
    /*
     * Bessel function of the second kind, order 1. Returns ERANGE
     * if x > 2^52 (total loss of significance).
     */
extern double _FPMANGLE(yn) (int /*n*/, double /*x*/);
__inline double yn(int __n, double __x) { return _FPMANGLE(yn)(__n, __x); }
    /*
     * Bessel function of the second kind, order n. Returns ERANGE
     * if x > 2^52 (total loss of significance).
     */
#endif

#ifdef __cplusplus
  extern float __mathlib_tofloat(double); /* internal; used below */
  extern "C++" {
    inline double abs(double __x) 
        { return fabs(__x); }
    inline float abs(float __x)
        { return (_fabsf)(__x); }
    inline float acos(float __x) // acosf
                { return (float)(acos((double) __x)); }
    inline float asin(float __x) // asinf
                { return (float)(asin((double) __x)); }
    inline float atan(float __x) // atanf
                { return (float)(atan((double) __x)); }
    inline float atan2(float __y, float __x)  // atan2f
                { return (float)(atan2((double) __y, (double) __x)); }
    inline float ceil(float __x) // ceilf
                { return (float)(ceil((double) __x)); }
    inline float cos(float __x) // cosf
                { return (float)(cos((double) __x)); }
    inline float cosh(float __x) // coshf
                { return __mathlib_tofloat(cosh((double) __x)); }
    inline float exp(float __x) // expf
                { return __mathlib_tofloat(exp((double) __x)); }
    inline float (fabs)(float __x) // fabsf
                { return (float)(fabs((double) __x)); }
    inline float floor(float __x) // floorf
                { return (float)(floor((double) __x)); }
    inline float fmod(float __x, float __y) //fmodf
                { return (float)(fmod((double) __x, (double) __y)); }
    inline float frexp(float __x, int* __exp) // frexpf
        { return (float)(frexp((double) __x, __exp)); }
    inline float ldexp(float __x, int __exp) // ldexpf
        { return __mathlib_tofloat(ldexp((double) __x, __exp));} 
    inline float log(float __x) // logf
                { return (float)(log((double) __x)); }
    inline float log10(float __x) // log10f
                { return (float)(log10((double) __x)); }
    inline float modf(float __x, float* __iptr) // modff
        { double __d; float __ret;
          __ret = (float)(modf((double) __x, &__d));
          *__iptr = (float)(__d); return __ret; }
    inline float pow(float __x, float __y) // powf
                { return __mathlib_tofloat(pow((double) __x, (double) __y)); }
    inline float pow (float __x, int __y)
                { return __mathlib_tofloat(pow((double) __x, (double) __y)); }
    inline float sin(float __x) //sinf
                { return (float)(sin((double) __x)); }
    inline float sinh(float __x)  //sinhf
                { return __mathlib_tofloat(sinh((double) __x)); }
    inline float sqrt(float __x) // sqrtf
                { return (float)(sqrt((double) __x)); }
    inline float _sqrt(float __x) // _sqrtf
                { return _sqrtf(__x); }
    inline float tan(float __x) // tanf
                { return __mathlib_tofloat(tan((double) __x)); }
    inline float tanh(float __x) // tanhf
                { return (float)(tanh((double) __x)); }

    inline double pow(double __x, int __y) 
                { return pow(__x, (double) __y); }

    inline long double abs(long double __x) // fabsl
                { return (long double)abs((double) __x); }
    inline long double acos(long double __x) // acosl
                { return (long double)acos((double) __x); }
    inline long double asin(long double __x) // asinl
                { return (long double)asin((double) __x); }
    inline long double atan(long double __x) // atanl
                { return (long double)atan((double) __x); }
    inline long double atan2(long double __y, long double __x)  //atan2l
                { return (long double)atan2((double) __y, (double) __x); }
    inline long double ceil(long double __x) // ceill
                { return (long double)ceil((double) __x); }
    inline long double cos(long double __x) // cosl
                { return (long double)cos((double) __x); }
    inline long double cosh(long double __x) // coshl
                { return (long double)cosh((double) __x); }
    inline long double exp(long double __x) // expl
                { return (long double)exp((double) __x); }
    inline long double (fabs)(long double __x) // fabsl
                { return (long double)fabs((double) __x); }
    inline long double floor(long double __x) // floorl
                { return (long double)floor((double) __x); }
    inline long double fmod(long double __x, long double __y) // fmodl
                { return (long double)fmod((double) __x, (double) __y); }
    inline long double frexp(long double __x, int* __p) // frexpl
                { return (long double)frexp((double) __x, __p); }
    inline long double ldexp(long double __x, int __exp) // ldexpl
                { return (long double)ldexp((double) __x, __exp); }
    inline long double log(long double __x)  // logl
                { return (long double)log((double) __x); }
    inline long double log10(long double __x)  // log10l
                { return (long double)log10((double) __x); }
    inline long double modf(long double __x, long double* __p) //modfl
                { return (long double)modf((double) __x, (double *) __p); }
    inline long double pow(long double __x, long double __y) // powl
                { return (long double)pow((double) __x, (double) __y); }
    inline long double pow (long double __x, int __y) 
                { return (long double)pow((double) __x, __y); }
    inline long double sin(long double __x) //sinl
                { return (long double)sin((double) __x); }
    inline long double sinh(long double __x) // sinhl
                { return (long double)sinh((double) __x); }
    inline long double sqrt(long double __x) // sqrtl
                { return (long double)sqrt((double) __x); }
    inline long double _sqrt(long double __x) // _sqrtl
                { return (long double)_sqrt((double) __x); }
    inline long double tan(long double __x) // tanl
                { return (long double)tan((double) __x); }
    inline long double tanh(long double __x) // tanhl
                { return (long double)tanh((double) __x); }
  }
#endif


    #ifdef __cplusplus
      }  /* extern "C" */
    #endif

    #ifdef __EDG_RUNTIME_USES_NAMESPACES
      }  /* namespace std */
    #endif
  #endif /* __MATH_DECLS */

  #ifdef __EDG_RUNTIME_USES_NAMESPACES
    #ifndef __MATH_NO_EXPORTS
      using std::__mathlib_tofloat;
      using std::__use_accurate_range_reduction;
      using std::abs;
      using std::acos;
      using std::asin;
      using std::atan2;
      using std::atan;
      using std::ceil;
      using std::cos;
      using std::cosh;
      using std::exp;
      using std::fabs;
      using std::floor;
      using std::fmod;
      using std::frexp;
      using std::ldexp;
      using std::log10;
      using std::log;
      using std::modf;
      using std::pow ;
      using std::pow;
      using std::sin;
      using std::sinh;
      using std::sqrt;
      using std::tan;
      using std::tanh;
      using std::_fabsf;
      #ifndef __STRICT_ANSI__
      using std::acosh;
      using std::asinh;
      using std::atanh;
      using std::cbrt;
      using std::copysign;
      using std::erf;
      using std::erfc;
      using std::expm1;
      using std::finite;
      using std::gamma;
      using std::gamma_r;
      using std::hypot;
      using std::ilogb;
      using std::isnan;
      using std::j0;
      using std::j1;
      using std::jn;
      using std::lgamma;
      using std::lgamma_r;
      using std::log1p;
      using std::logb;
      using std::nextafter;
      using std::remainder;
      using std::rint;
      using std::scalb;
      using std::scalbn;
      using std::significand;
      using std::y0;
      using std::y1;
      using std::yn;
      #endif

    #endif 
  #endif 

#endif 

/* end of math.h */