svn commit: trunk/uClibc++/include
gkajmowi at uclibc.org
gkajmowi at uclibc.org
Sun Mar 26 04:00:22 UTC 2006
Author: gkajmowi
Date: 2006-03-25 20:00:20 -0800 (Sat, 25 Mar 2006)
New Revision: 14659
Log:
Convert to my own implementation of <cmath>, based on spec.
Modified:
trunk/uClibc++/include/cmath
Changeset:
Modified: trunk/uClibc++/include/cmath
===================================================================
--- trunk/uClibc++/include/cmath 2006-03-26 02:56:15 UTC (rev 14658)
+++ trunk/uClibc++/include/cmath 2006-03-26 04:00:20 UTC (rev 14659)
@@ -1,552 +1,205 @@
-// -*- C++ -*- C forwarding header.
+/* Copyright (C) 2006 Garrett A. Kajmowicz
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
-// Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 2, or (at your option)
-// any later version.
+ This file is part of the uClibc++ Library.
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
-// You should have received a copy of the GNU General Public License along
-// with this library; see the file COPYING. If not, write to the Free
-// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
-// USA.
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
-// As a special exception, you may use this file as part of a free software
-// library without restriction. Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License. This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
-//
-// ISO C++ 14882: 26.5 C library
-//
-
-/** @file cmath
- * This is a Standard C++ Library file. You should @c #include this file
- * in your programs, rather than any of the "*.h" implementation files.
- *
- * This is the C++ version of the Standard C Library header @c math.h,
- * and its contents are (mostly) the same as that header, but are all
- * contained in the namespace @c std.
- */
-
-#ifndef _CPP_CMATH
-#define _CPP_CMATH 1
-
-#pragma GCC system_header
-
#include <math.h>
-// Get rid of those macros defined in <math.h> in lieu of real functions.
-#undef abs
-#undef div
-#undef acos
-#undef asin
-#undef atan
-#undef atan2
-#undef ceil
-#undef cos
-#undef cosh
-#undef exp
-#undef fabs
-#undef floor
-#undef fmod
-#undef frexp
-#undef ldexp
-#undef log
-#undef log10
-#undef modf
-#undef pow
-#undef sin
-#undef sinh
-#undef sqrt
-#undef tan
-#undef tanh
+#ifndef __STD_HEADER_CMATH
+#define __STD_HEADER_CMATH 1
-// ...and in the darkness bind them...
-namespace __gnu_cxx
-{
- namespace __c99_binding
- {
-#if _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_CHECK || \
- _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC || \
- _GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_CHECK || \
- _GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC
- extern "C" float (acosf)(float);
- extern "C" float (asinf)(float);
- extern "C" float (atanf)(float);
- extern "C" float (atan2f)(float, float);
- extern "C" float (ceilf)(float);
- extern "C" float (coshf)(float);
- extern "C" float (expf)(float);
- extern "C" float (floorf)(float);
- extern "C" float (fmodf)(float, float);
- extern "C" float (frexpf)(float, int*);
- extern "C" float (ldexpf)(float, int);
- extern "C" float (logf)(float);
- extern "C" float (log10f)(float);
- extern "C" float (modff)(float, float*);
- extern "C" float (powf)(float, float);
- extern "C" float (sinhf)(float);
- extern "C" float (tanf)(float);
- extern "C" float (tanhf)(float);
-#endif
-#if !_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC && !_GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC
- using ::acosf;
- using ::asinf;
- using ::atanf;
- using ::atan2f;
- using ::ceilf;
- using ::coshf;
- using ::expf;
- using ::floorf;
- using ::fmodf;
- using ::frexpf;
- using ::ldexpf;
- using ::logf;
- using ::log10f;
- using ::modff;
- using ::powf;
- using ::sinhf;
- using ::tanf;
- using ::tanhf;
-#endif /* _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC */
- }
-}
+namespace std{
+ using ::acos;
+ using ::asin;
+ using ::atan;
+ using ::atan2;
+ using ::ceil;
+ using ::cos;
+ using ::cosh;
+ using ::exp;
+ using ::fabs;
+ using ::floor;
+ using ::fmod;
+ using ::frexp;
+ using ::ldexp;
+ using ::log;
+ using ::log10;
+ using ::modf;
+ using ::pow;
+ using ::sin;
+ using ::sinh;
+ using ::sqrt;
+ using ::tan;
+ using ::tanh;
-namespace std
-{
- // Forward declaration of a helper function. This really should be
- // an `exported' forward declaration.
- template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
+ inline float abs (float x){
+ return fabsf(x);
+ }
+ inline float acos (float x){
+ return acosf(x);
+ }
+ inline float asin (float x){
+ return asinf(x);
+ }
+ inline float atan (float x){
+ return atanf(x);
+ }
+ inline float atan2(float y, float x){
+ return atan2f(y, x);
+ }
+ inline float ceil (float x){
+ return ceilf(x);
+ }
+ inline float cos (float x){
+ return cosf(x);
+ }
+ inline float cosh (float x){
+ return coshf(x);
+ }
+ inline float exp (float x){
+ return expf(x);
+ }
+ inline float fabs (float x){
+ return fabsf(x);
+ }
+ inline float floor(float x){
+ return floorf(x);
+ }
+ inline float fmod (float x, float y){
+ return fmodf(x, y);
+ }
+ inline float frexp(float x, int* exp){
+ return frexpf(x, exp);
+ }
+ inline float ldexp(float x, int exp){
+ return ldexpf(x, exp);
+ }
+ inline float log (float x){
+ return logf(x);
+ }
+ inline float log10(float x){
+ return log10f(x);
+ }
+ inline float modf (float x, float* inptr){
+ return modff(x, inptr);
+ }
+ inline float pow (float x, float y){
+ return powf(x, y);
+ }
+ inline float pow (float x, int y){
+ return pow((double)x, (double)y);
+ }
+ inline float sin (float x){
+ return sinf(x);
+ }
+ inline float sinh (float x){
+ return sinhf(x);
+ }
+ inline float sqrt (float x){
+ return sqrtf(x);
+ }
+ inline float tan (float x){
+ return tanf(x);
+ }
+ inline float tanh (float x){
+ return tanhf(x);
+ }
+ inline double abs(double x){
+ return fabs(x);
+ }
+ inline double pow(double x, int y){
+ return pow((double)x, (double)y);
+ }
- inline double
- abs(double __x)
- { return __builtin_fabs(__x); }
-
- inline float
- abs(float __x)
- { return __builtin_fabsf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- abs(long double __x)
- { return __builtin_fabsl(__x); }
- #endif
-
- inline float
- acos(float __x) { return __gnu_cxx::__c99_binding::acosf(__x); }
-
- using ::acos;
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- acos(long double __x) { return ::acosl(__x); }
- #endif
-
- using ::asin;
-
- inline float
- asin(float __x) { return __gnu_cxx::__c99_binding::asinf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- asin(long double __x) { return ::asinl(__x); }
- #endif
-
- using ::atan;
-
- inline float
- atan(float __x) { return __gnu_cxx::__c99_binding::atanf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- atan(long double __x) { return ::atanl(__x); }
- #endif
-
- using ::atan2;
-
- inline float
- atan2(float __y, float __x) { return __gnu_cxx::__c99_binding::atan2f(__y, __x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- atan2(long double __y, long double __x) { return ::atan2l(__y, __x); }
- #endif
-
- using ::ceil;
-
- inline float
- ceil(float __x) { return __gnu_cxx::__c99_binding::ceilf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- ceil(long double __x) { return ::ceill(__x); }
- #endif
-
- using ::cos;
-
- inline float
- cos(float __x)
- { return __builtin_cosf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- cos(long double __x)
- { return __builtin_cosl(__x); }
- #endif
-
- using ::cosh;
-
- inline float
- cosh(float __x) { return __gnu_cxx::__c99_binding::coshf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- cosh(long double __x) { return ::coshl(__x); }
- #endif
-
- using ::exp;
-
- inline float
- exp(float __x) { return __gnu_cxx::__c99_binding::expf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- exp(long double __x) { return ::expl(__x); }
- #endif
-
- using ::fabs;
-
- inline float
- fabs(float __x)
- { return __builtin_fabsf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- fabs(long double __x)
- { return __builtin_fabsl(__x); }
- #endif
-
- using ::floor;
-
- inline float
- floor(float __x) { return __gnu_cxx::__c99_binding::floorf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- floor(long double __x) { return ::floorl(__x); }
- #endif
-
- using ::fmod;
-
- inline float
- fmod(float __x, float __y) { return __gnu_cxx::__c99_binding::fmodf(__x, __y); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- fmod(long double __x, long double __y) { return ::fmodl(__x, __y); }
- #endif
-
- using ::frexp;
-
- inline float
- frexp(float __x, int* __exp) { return __gnu_cxx::__c99_binding::frexpf(__x, __exp); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); }
- #endif
-
- using ::ldexp;
-
- inline float
- ldexp(float __x, int __exp) { return __gnu_cxx::__c99_binding::ldexpf(__x, __exp); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); }
- #endif
-
- using ::log;
-
- inline float
- log(float __x) { return __gnu_cxx::__c99_binding::logf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- log(long double __x) { return ::logl(__x); }
- #endif
-
- using ::log10;
-
- inline float
- log10(float __x) { return __gnu_cxx::__c99_binding::log10f(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- log10(long double __x) { return ::log10l(__x); }
- #endif
-
- using ::modf;
-
- inline float
- modf(float __x, float* __iptr) { return __gnu_cxx::__c99_binding::modff(__x, __iptr); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
- #endif
-
- template<typename _Tp>
- inline _Tp
- __pow_helper(_Tp __x, int __n)
- {
- return __n < 0
- ? _Tp(1)/__cmath_power(__x, -__n)
- : __cmath_power(__x, __n);
- }
-
- using ::pow;
-
- inline float
- pow(float __x, float __y) { return __gnu_cxx::__c99_binding::powf(__x, __y); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- pow(long double __x, long double __y) { return ::powl(__x, __y); }
- #endif
-
- inline double
- pow(double __x, int __i)
- { return __pow_helper(__x, __i); }
-
- inline float
- pow(float __x, int __n)
- { return __pow_helper(__x, __n); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- pow(long double __x, int __n)
- { return __pow_helper(__x, __n); }
- #endif
-
- using ::sin;
-
- inline float
- sin(float __x)
- { return __builtin_sinf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- sin(long double __x)
- { return __builtin_sinl(__x); }
- #endif
-
- using ::sinh;
-
- inline float
- sinh(float __x) { return __gnu_cxx::__c99_binding::sinhf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- sinh(long double __x) { return ::sinhl(__x); }
- #endif
-
- using ::sqrt;
-
- inline float
- sqrt(float __x)
- { return __builtin_sqrtf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- sqrt(long double __x)
- { return __builtin_sqrtl(__x); }
- #endif
-
- using ::tan;
-
- inline float
- tan(float __x) { return __gnu_cxx::__c99_binding::tanf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- tan(long double __x) { return ::tanl(__x); }
- #endif
-
- using ::tanh;
-
- inline float
- tanh(float __x) { return __gnu_cxx::__c99_binding::tanhf(__x); }
-
- #ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
- inline long double
- tanh(long double __x) { return ::tanhl(__x); }
- #endif
-}
-
-
-#if _GLIBCPP_USE_C99 || _GLIBCXX_USE_C99
-#if !_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
-// These are possible macros imported from C99-land. For strict
-// conformance, remove possible C99-injected names from the global
-// namespace, and sequester them in the __gnu_cxx extension namespace.
-namespace __gnu_cxx
-{
- template<typename _Tp>
- int
- __capture_fpclassify(_Tp __f) { return fpclassify(__f); }
-
- template<typename _Tp>
- int
- __capture_isfinite(_Tp __f) { return isfinite(__f); }
-
- template<typename _Tp>
- int
- __capture_isinf(_Tp __f) { return isinf(__f); }
-
- template<typename _Tp>
- int
- __capture_isnan(_Tp __f) { return isnan(__f); }
-
- template<typename _Tp>
- int
- __capture_isnormal(_Tp __f) { return isnormal(__f); }
-
- template<typename _Tp>
- int
- __capture_signbit(_Tp __f) { return signbit(__f); }
-
- template<typename _Tp>
- int
- __capture_isgreater(_Tp __f1, _Tp __f2)
- { return isgreater(__f1, __f2); }
-
- template<typename _Tp>
- int
- __capture_isgreaterequal(_Tp __f1, _Tp __f2)
- { return isgreaterequal(__f1, __f2); }
-
- template<typename _Tp>
- int
- __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
-
- template<typename _Tp>
- int
- __capture_islessequal(_Tp __f1, _Tp __f2)
- { return islessequal(__f1, __f2); }
-
- template<typename _Tp>
- int
- __capture_islessgreater(_Tp __f1, _Tp __f2)
- { return islessgreater(__f1, __f2); }
-
- template<typename _Tp>
- int
- __capture_isunordered(_Tp __f1, _Tp __f2)
- { return isunordered(__f1, __f2); }
-}
-#endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */
-#endif
-
-#undef fpclassify
-#undef isfinite
-#undef isinf
-#undef isnan
-#undef isnormal
-#undef signbit
-#undef isgreater
-#undef isgreaterequal
-#undef isless
-#undef islessequal
-#undef islessgreater
-#undef isunordered
-
-#if _GLIBCPP_USE_C99 || _GLIBCXX_USE_C99
-#if !_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
-namespace __gnu_cxx
-{
- template<typename _Tp>
- int
- fpclassify(_Tp __f) { return __capture_fpclassify(__f); }
-
- template<typename _Tp>
- int
- isfinite(_Tp __f) { return __capture_isfinite(__f); }
-
- template<typename _Tp>
- int
- isinf(_Tp __f) { return __capture_isinf(__f); }
-
- template<typename _Tp>
- int
- isnan(_Tp __f) { return __capture_isnan(__f); }
-
- template<typename _Tp>
- int
- isnormal(_Tp __f) { return __capture_isnormal(__f); }
-
- template<typename _Tp>
- int
- signbit(_Tp __f) { return __capture_signbit(__f); }
-
- template<typename _Tp>
- int
- isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
-
- template<typename _Tp>
- int
- isgreaterequal(_Tp __f1, _Tp __f2)
- { return __capture_isgreaterequal(__f1, __f2); }
-
- template<typename _Tp>
- int
- isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
-
- template<typename _Tp>
- int
- islessequal(_Tp __f1, _Tp __f2)
- { return __capture_islessequal(__f1, __f2); }
-
- template<typename _Tp>
- int
- islessgreater(_Tp __f1, _Tp __f2)
- { return __capture_islessgreater(__f1, __f2); }
-
- template<typename _Tp>
- int
- isunordered(_Tp __f1, _Tp __f2)
- { return __capture_isunordered(__f1, __f2); }
+#ifdef __UCLIBCXX_HAS_LONG_DOUBLE__
+ inline long double abs (long double x){
+ return fabsl(x);
+ }
+ inline long double acos (long double x){
+ return acosl(x);
+ }
+ inline long double asin (long double x){
+ return asinl(x);
+ }
+ inline long double atan (long double x){
+ return atanl(x);
+ }
+ inline long double atan2(long double y, long double x){
+ return atan2l(y, x);
+ }
+ inline long double ceil (long double x){
+ return ceill(x);
+ }
+ inline long double cos (long double x){
+ return cosl(x);
+ }
+ inline long double cosh (long double x){
+ return coshl(x);
+ }
+ inline long double exp (long double x){
+ return expl(x);
+ }
+ inline long double fabs (long double x){
+ return fabsl(x);
+ }
+ inline long double floor(long double x){
+ return floorl(x);
+ }
+ inline long double frexp(long double x, int* exp){
+ return frexpl(x, exp);
+ }
+ inline long double fmod (long double x, long double y){
+ return fmodl(x, y);
+ }
+ inline long double ldexp(long double x, int y){
+ return ldexpl(x, y);
+ }
+ inline long double log (long double x){
+ return logl(x);
+ }
+ inline long double log10(long double x){
+ return log10l(x);
+ }
+ inline long double modf (long double x, long double* iptr){
+ return modfl(x, iptr);
+ }
+ inline long double pow (long double x, long double y){
+ return powl(x, y);
+ }
+ inline long double pow (long double x, int y){
+ return powl(x, (long double)y );
+ }
+ inline long double sin (long double x){
+ return sinl(x);
+ }
+ inline long double sinh (long double x){
+ return sinhl(x);
+ }
+ inline long double sqrt (long double x){
+ return sqrtl(x);
+ }
+ inline long double tan (long double x){
+ return tanl(x);
+ }
+ inline long double tanh (long double x){
+ return tanhl(x);
+ }
+#endif // __UCLIBCXX_HAS_LONG_DOUBLE__
}
-namespace std
-{
- using __gnu_cxx::fpclassify;
- using __gnu_cxx::isfinite;
- using __gnu_cxx::isinf;
- using __gnu_cxx::isnan;
- using __gnu_cxx::isnormal;
- using __gnu_cxx::signbit;
- using __gnu_cxx::isgreater;
- using __gnu_cxx::isgreaterequal;
- using __gnu_cxx::isless;
- using __gnu_cxx::islessequal;
- using __gnu_cxx::islessgreater;
- using __gnu_cxx::isunordered;
-}
-#endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */
-#endif
-
-#endif
+#endif //__STD_HEADER_CMATH
+
More information about the uClibc-cvs
mailing list