From fb21a4dfe2c81640379f64855509fb7613530887 Mon Sep 17 00:00:00 2001 From: Enrico Zini Date: Wed, 9 Sep 2015 22:43:35 +0200 Subject: Removed wrongly added coverage report --- rep/usr/include/c++/4.3/cmath.gcov.html | 710 -------------------------------- 1 file changed, 710 deletions(-) delete mode 100644 rep/usr/include/c++/4.3/cmath.gcov.html (limited to 'rep/usr/include/c++/4.3/cmath.gcov.html') diff --git a/rep/usr/include/c++/4.3/cmath.gcov.html b/rep/usr/include/c++/4.3/cmath.gcov.html deleted file mode 100644 index cd12c31..0000000 --- a/rep/usr/include/c++/4.3/cmath.gcov.html +++ /dev/null @@ -1,710 +0,0 @@ - - - - - - - LCOV - lcov.info - /usr/include/c++/4.3/cmath - - - - - - - - - - - - - -
LTP GCOV extension - code coverage report
- - - - - - - - - - - - - - - - - - - - - - - -
Current view:directory - usr/include/c++/4.3 - cmath
Test:lcov.info
Date:2008-08-14Instrumented lines:2
Code covered:100.0 %Executed lines:2
-
- - - - - - - - - 

-       1                 : // -*- C++ -*- C forwarding header.
-       2                 : 
-       3                 : // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-       4                 : // 2006, 2007
-       5                 : // Free Software Foundation, Inc.
-       6                 : //
-       7                 : // This file is part of the GNU ISO C++ Library.  This library is free
-       8                 : // software; you can redistribute it and/or modify it under the
-       9                 : // terms of the GNU General Public License as published by the
-      10                 : // Free Software Foundation; either version 2, or (at your option)
-      11                 : // any later version.
-      12                 : 
-      13                 : // This library is distributed in the hope that it will be useful,
-      14                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
-      15                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-      16                 : // GNU General Public License for more details.
-      17                 : 
-      18                 : // You should have received a copy of the GNU General Public License
-      19                 : // along with this library; see the file COPYING.  If not, write to
-      20                 : // the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-      21                 : // Boston, MA 02110-1301, USA.
-      22                 : 
-      23                 : // As a special exception, you may use this file as part of a free software
-      24                 : // library without restriction.  Specifically, if other files instantiate
-      25                 : // templates or use macros or inline functions from this file, or you compile
-      26                 : // this file and link it with other files to produce an executable, this
-      27                 : // file does not by itself cause the resulting executable to be covered by
-      28                 : // the GNU General Public License.  This exception does not however
-      29                 : // invalidate any other reasons why the executable file might be covered by
-      30                 : // the GNU General Public License.
-      31                 : 
-      32                 : /** @file include/cmath
-      33                 :  *  This is a Standard C++ Library file.  You should @c #include this file
-      34                 :  *  in your programs, rather than any of the "*.h" implementation files.
-      35                 :  *
-      36                 :  *  This is the C++ version of the Standard C Library header @c math.h,
-      37                 :  *  and its contents are (mostly) the same as that header, but are all
-      38                 :  *  contained in the namespace @c std (except for names which are defined
-      39                 :  *  as macros in C).
-      40                 :  */
-      41                 : 
-      42                 : //
-      43                 : // ISO C++ 14882: 26.5  C library
-      44                 : //
-      45                 : 
-      46                 : #pragma GCC system_header
-      47                 : 
-      48                 : #include <bits/c++config.h>
-      49                 : #include <bits/cpp_type_traits.h>
-      50                 : #include <ext/type_traits.h>
-      51                 : #include_next <math.h>
-      52                 : 
-      53                 : #ifndef _GLIBCXX_CMATH
-      54                 : #define _GLIBCXX_CMATH 1
-      55                 : 
-      56                 : // Get rid of those macros defined in <math.h> in lieu of real functions.
-      57                 : #undef abs
-      58                 : #undef div
-      59                 : #undef acos
-      60                 : #undef asin
-      61                 : #undef atan
-      62                 : #undef atan2
-      63                 : #undef ceil
-      64                 : #undef cos
-      65                 : #undef cosh
-      66                 : #undef exp
-      67                 : #undef fabs
-      68                 : #undef floor
-      69                 : #undef fmod
-      70                 : #undef frexp
-      71                 : #undef ldexp
-      72                 : #undef log
-      73                 : #undef log10
-      74                 : #undef modf
-      75                 : #undef pow
-      76                 : #undef sin
-      77                 : #undef sinh
-      78                 : #undef sqrt
-      79                 : #undef tan
-      80                 : #undef tanh
-      81                 : 
-      82                 : _GLIBCXX_BEGIN_NAMESPACE(std)
-      83                 : 
-      84                 :   // Forward declaration of a helper function.  This really should be
-      85                 :   // an `exported' forward declaration.
-      86                 :   template<typename _Tp>
-      87                 :     _Tp __cmath_power(_Tp, unsigned int);
-      88                 : 
-      89                 :   template<typename _Tp>
-      90                 :     inline _Tp
-      91                 :     __pow_helper(_Tp __x, int __n)
-      92                 :     {
-      93                 :       return __n < 0
-      94                 :         ? _Tp(1)/__cmath_power(__x, -__n)
-      95                 :         : __cmath_power(__x, __n);
-      96                 :     }
-      97                 : 
-      98                 :   inline double
-      99                 :   abs(double __x)
-     100                 :   { return __builtin_fabs(__x); }
-     101                 : 
-     102                 :   inline float
-     103                 :   abs(float __x)
-     104                 :   { return __builtin_fabsf(__x); }
-     105                 : 
-     106                 :   inline long double
-     107                 :   abs(long double __x)
-     108                 :   { return __builtin_fabsl(__x); }
-     109                 : 
-     110                 :   using ::acos;
-     111                 : 
-     112                 :   inline float
-     113                 :   acos(float __x)
-     114                 :   { return __builtin_acosf(__x); }
-     115                 : 
-     116                 :   inline long double
-     117                 :   acos(long double __x)
-     118                 :   { return __builtin_acosl(__x); }
-     119                 : 
-     120                 :   template<typename _Tp>
-     121                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     122                 :                                            double>::__type
-     123                 :     acos(_Tp __x)
-     124                 :     { return __builtin_acos(__x); }
-     125                 : 
-     126                 :   using ::asin;
-     127                 : 
-     128                 :   inline float
-     129                 :   asin(float __x)
-     130                 :   { return __builtin_asinf(__x); }
-     131                 : 
-     132                 :   inline long double
-     133                 :   asin(long double __x)
-     134                 :   { return __builtin_asinl(__x); }
-     135                 : 
-     136                 :   template<typename _Tp>
-     137                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-     138                 :                                            double>::__type
-     139                 :     asin(_Tp __x)
-     140                 :     { return __builtin_asin(__x); }
-     141                 : 
-     142                 :   using ::atan;
-     143                 : 
-     144                 :   inline float
-     145                 :   atan(float __x)
-     146                 :   { return __builtin_atanf(__x); }
-     147                 : 
-     148                 :   inline long double
-     149                 :   atan(long double __x)
-     150                 :   { return __builtin_atanl(__x); }
-     151                 : 
-     152                 :   template<typename _Tp>
-     153                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     154                 :                                            double>::__type
-     155                 :     atan(_Tp __x)
-     156                 :     { return __builtin_atan(__x); }
-     157                 : 
-     158                 :   using ::atan2;
-     159                 : 
-     160                 :   inline float
-     161                 :   atan2(float __y, float __x)
-     162                 :   { return __builtin_atan2f(__y, __x); }
-     163                 : 
-     164                 :   inline long double
-     165                 :   atan2(long double __y, long double __x)
-     166                 :   { return __builtin_atan2l(__y, __x); }
-     167                 : 
-     168                 :   template<typename _Tp, typename _Up>
-     169                 :     inline
-     170                 :     typename __gnu_cxx::__promote_2<
-     171                 :     typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
-     172                 :                                     && __is_arithmetic<_Up>::__value,
-     173                 :                                     _Tp>::__type, _Up>::__type
-     174                 :     atan2(_Tp __y, _Up __x)
-     175                 :     {
-     176                 :       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-     177                 :       return atan2(__type(__y), __type(__x));
-     178                 :     }
-     179                 : 
-     180                 :   using ::ceil;
-     181                 : 
-     182                 :   inline float
-     183                 :   ceil(float __x)
-     184                 :   { return __builtin_ceilf(__x); }
-     185                 : 
-     186                 :   inline long double
-     187                 :   ceil(long double __x)
-     188                 :   { return __builtin_ceill(__x); }
-     189                 : 
-     190                 :   template<typename _Tp>
-     191                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     192                 :                                            double>::__type
-     193                 :     ceil(_Tp __x)
-     194                 :     { return __builtin_ceil(__x); }
-     195                 : 
-     196                 :   using ::cos;
-     197                 : 
-     198                 :   inline float
-     199                 :   cos(float __x)
-     200                 :   { return __builtin_cosf(__x); }
-     201                 : 
-     202                 :   inline long double
-     203                 :   cos(long double __x)
-     204                 :   { return __builtin_cosl(__x); }
-     205                 : 
-     206                 :   template<typename _Tp>
-     207                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     208                 :                                            double>::__type
-     209                 :     cos(_Tp __x)
-     210                 :     { return __builtin_cos(__x); }
-     211                 : 
-     212                 :   using ::cosh;
-     213                 : 
-     214                 :   inline float
-     215                 :   cosh(float __x)
-     216                 :   { return __builtin_coshf(__x); }
-     217                 : 
-     218                 :   inline long double
-     219                 :   cosh(long double __x)
-     220                 :   { return __builtin_coshl(__x); }
-     221                 : 
-     222                 :   template<typename _Tp>
-     223                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     224                 :                                            double>::__type
-     225                 :     cosh(_Tp __x)
-     226                 :     { return __builtin_cosh(__x); }
-     227                 : 
-     228                 :   using ::exp;
-     229                 : 
-     230                 :   inline float
-     231                 :   exp(float __x)
-     232                 :   { return __builtin_expf(__x); }
-     233                 : 
-     234                 :   inline long double
-     235                 :   exp(long double __x)
-     236                 :   { return __builtin_expl(__x); }
-     237                 : 
-     238                 :   template<typename _Tp>
-     239                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     240                 :                                            double>::__type
-     241                 :     exp(_Tp __x)
-     242                 :     { return __builtin_exp(__x); }
-     243                 : 
-     244                 :   using ::fabs;
-     245                 : 
-     246                 :   inline float
-     247                 :   fabs(float __x)
-     248                 :   { return __builtin_fabsf(__x); }
-     249                 : 
-     250                 :   inline long double
-     251                 :   fabs(long double __x)
-     252                 :   { return __builtin_fabsl(__x); }
-     253                 : 
-     254                 :   template<typename _Tp>
-     255                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     256                 :                                            double>::__type
-     257                 :     fabs(_Tp __x)
-     258                 :     { return __builtin_fabs(__x); }
-     259                 : 
-     260                 :   using ::floor;
-     261                 : 
-     262                 :   inline float
-     263                 :   floor(float __x)
-     264                 :   { return __builtin_floorf(__x); }
-     265                 : 
-     266                 :   inline long double
-     267                 :   floor(long double __x)
-     268                 :   { return __builtin_floorl(__x); }
-     269                 : 
-     270                 :   template<typename _Tp>
-     271                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     272                 :                                            double>::__type
-     273                 :     floor(_Tp __x)
-     274                 :     { return __builtin_floor(__x); }
-     275                 : 
-     276                 :   using ::fmod;
-     277                 : 
-     278                 :   inline float
-     279                 :   fmod(float __x, float __y)
-     280                 :   { return __builtin_fmodf(__x, __y); }
-     281                 : 
-     282                 :   inline long double
-     283                 :   fmod(long double __x, long double __y)
-     284                 :   { return __builtin_fmodl(__x, __y); }
-     285                 : 
-     286                 :   using ::frexp;
-     287                 : 
-     288                 :   inline float
-     289                 :   frexp(float __x, int* __exp)
-     290                 :   { return __builtin_frexpf(__x, __exp); }
-     291                 : 
-     292                 :   inline long double
-     293                 :   frexp(long double __x, int* __exp)
-     294                 :   { return __builtin_frexpl(__x, __exp); }
-     295                 : 
-     296                 :   template<typename _Tp>
-     297                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     298                 :                                            double>::__type
-     299                 :     frexp(_Tp __x, int* __exp)
-     300                 :     { return __builtin_frexp(__x, __exp); }
-     301                 : 
-     302                 :   using ::ldexp;
-     303                 : 
-     304                 :   inline float
-     305                 :   ldexp(float __x, int __exp)
-     306                 :   { return __builtin_ldexpf(__x, __exp); }
-     307                 : 
-     308                 :   inline long double
-     309                 :   ldexp(long double __x, int __exp)
-     310                 :   { return __builtin_ldexpl(__x, __exp); }
-     311                 : 
-     312                 :   template<typename _Tp>
-     313                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     314                 :                                            double>::__type
-     315                 :   ldexp(_Tp __x, int __exp)
-     316                 :   { return __builtin_ldexp(__x, __exp); }
-     317                 : 
-     318                 :   using ::log;
-     319                 : 
-     320                 :   inline float
-     321               1 :   log(float __x)
-     322               1 :   { return __builtin_logf(__x); }
-     323                 : 
-     324                 :   inline long double
-     325                 :   log(long double __x)
-     326                 :   { return __builtin_logl(__x); }
-     327                 : 
-     328                 :   template<typename _Tp>
-     329                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     330                 :                                            double>::__type
-     331                 :     log(_Tp __x)
-     332                 :     { return __builtin_log(__x); }
-     333                 : 
-     334                 :   using ::log10;
-     335                 : 
-     336                 :   inline float
-     337                 :   log10(float __x)
-     338                 :   { return __builtin_log10f(__x); }
-     339                 : 
-     340                 :   inline long double
-     341                 :   log10(long double __x)
-     342                 :   { return __builtin_log10l(__x); }
-     343                 : 
-     344                 :   template<typename _Tp>
-     345                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     346                 :                                            double>::__type
-     347                 :     log10(_Tp __x)
-     348                 :     { return __builtin_log10(__x); }
-     349                 : 
-     350                 :   using ::modf;
-     351                 : 
-     352                 :   inline float
-     353                 :   modf(float __x, float* __iptr)
-     354                 :   { return __builtin_modff(__x, __iptr); }
-     355                 : 
-     356                 :   inline long double
-     357                 :   modf(long double __x, long double* __iptr)
-     358                 :   { return __builtin_modfl(__x, __iptr); }
-     359                 : 
-     360                 :   using ::pow;
-     361                 : 
-     362                 :   inline float
-     363                 :   pow(float __x, float __y)
-     364                 :   { return __builtin_powf(__x, __y); }
-     365                 : 
-     366                 :   inline long double
-     367                 :   pow(long double __x, long double __y)
-     368                 :   { return __builtin_powl(__x, __y); }
-     369                 : 
-     370                 :   // DR 550.
-     371                 :   inline double
-     372                 :   pow(double __x, int __i)
-     373                 :   { return __builtin_powi(__x, __i); }
-     374                 : 
-     375                 :   inline float
-     376                 :   pow(float __x, int __n)
-     377                 :   { return __builtin_powif(__x, __n); }
-     378                 : 
-     379                 :   inline long double
-     380                 :   pow(long double __x, int __n)
-     381                 :   { return __builtin_powil(__x, __n); }
-     382                 : 
-     383                 :   template<typename _Tp, typename _Up>
-     384                 :     inline
-     385                 :     typename __gnu_cxx::__promote_2<
-     386                 :     typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
-     387                 :                                     && __is_arithmetic<_Up>::__value,
-     388                 :                                     _Tp>::__type, _Up>::__type
-     389                 :     pow(_Tp __x, _Up __y)
-     390                 :     {
-     391                 :       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-     392                 :       return pow(__type(__x), __type(__y));
-     393                 :     }
-     394                 : 
-     395                 :   using ::sin;
-     396                 : 
-     397                 :   inline float
-     398                 :   sin(float __x)
-     399                 :   { return __builtin_sinf(__x); }
-     400                 : 
-     401                 :   inline long double
-     402                 :   sin(long double __x)
-     403                 :   { return __builtin_sinl(__x); }
-     404                 : 
-     405                 :   template<typename _Tp>
-     406                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     407                 :                                            double>::__type
-     408                 :     sin(_Tp __x)
-     409                 :     { return __builtin_sin(__x); }
-     410                 : 
-     411                 :   using ::sinh;
-     412                 : 
-     413                 :   inline float
-     414                 :   sinh(float __x)
-     415                 :   { return __builtin_sinhf(__x); }
-     416                 : 
-     417                 :   inline long double
-     418                 :   sinh(long double __x)
-     419                 :   { return __builtin_sinhl(__x); }
-     420                 : 
-     421                 :   template<typename _Tp>
-     422                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     423                 :                                            double>::__type
-     424                 :     sinh(_Tp __x)
-     425                 :     { return __builtin_sinh(__x); }
-     426                 : 
-     427                 :   using ::sqrt;
-     428                 : 
-     429                 :   inline float
-     430                 :   sqrt(float __x)
-     431                 :   { return __builtin_sqrtf(__x); }
-     432                 : 
-     433                 :   inline long double
-     434                 :   sqrt(long double __x)
-     435                 :   { return __builtin_sqrtl(__x); }
-     436                 : 
-     437                 :   template<typename _Tp>
-     438                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     439                 :                                            double>::__type
-     440                 :     sqrt(_Tp __x)
-     441                 :     { return __builtin_sqrt(__x); }
-     442                 : 
-     443                 :   using ::tan;
-     444                 : 
-     445                 :   inline float
-     446                 :   tan(float __x)
-     447                 :   { return __builtin_tanf(__x); }
-     448                 : 
-     449                 :   inline long double
-     450                 :   tan(long double __x)
-     451                 :   { return __builtin_tanl(__x); }
-     452                 : 
-     453                 :   template<typename _Tp>
-     454                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     455                 :                                            double>::__type
-     456                 :     tan(_Tp __x)
-     457                 :     { return __builtin_tan(__x); }
-     458                 : 
-     459                 :   using ::tanh;
-     460                 : 
-     461                 :   inline float
-     462                 :   tanh(float __x)
-     463                 :   { return __builtin_tanhf(__x); }
-     464                 : 
-     465                 :   inline long double
-     466                 :   tanh(long double __x)
-     467                 :   { return __builtin_tanhl(__x); }
-     468                 : 
-     469                 :   template<typename _Tp>
-     470                 :     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
-     471                 :                                            double>::__type
-     472                 :     tanh(_Tp __x)
-     473                 :     { return __builtin_tanh(__x); }
-     474                 : 
-     475                 : _GLIBCXX_END_NAMESPACE
-     476                 : 
-     477                 : #if _GLIBCXX_USE_C99_MATH
-     478                 : #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
-     479                 : // These are possible macros imported from C99-land. For strict
-     480                 : // conformance, remove possible C99-injected names from the global
-     481                 : // namespace, and sequester them in the __gnu_cxx extension namespace.
-     482                 : 
-     483                 : _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
-     484                 : 
-     485                 :   template<typename _Tp>
-     486                 :     inline int
-     487                 :     __capture_fpclassify(_Tp __f) { return fpclassify(__f); }
-     488                 : 
-     489                 : _GLIBCXX_END_NAMESPACE
-     490                 : 
-     491                 : // Only undefine the C99 FP macros, if actually captured for namespace movement
-     492                 : #undef fpclassify
-     493                 : #undef isfinite
-     494                 : #undef isinf
-     495                 : #undef isnan
-     496                 : #undef isnormal
-     497                 : #undef signbit
-     498                 : #undef isgreater
-     499                 : #undef isgreaterequal
-     500                 : #undef isless
-     501                 : #undef islessequal
-     502                 : #undef islessgreater
-     503                 : #undef isunordered
-     504                 : 
-     505                 : _GLIBCXX_BEGIN_NAMESPACE(std)
-     506                 : 
-     507                 :   template<typename _Tp>
-     508                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     509                 :                                            int>::__type
-     510                 :     fpclassify(_Tp __f)
-     511                 :     {
-     512                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     513                 :       return ::__gnu_cxx::__capture_fpclassify(__type(__f));
-     514                 :     }
-     515                 : 
-     516                 :   template<typename _Tp>
-     517                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     518                 :                                            int>::__type
-     519                 :     isfinite(_Tp __f)
-     520                 :     {
-     521                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     522                 :       return __builtin_isfinite(__type(__f));
-     523                 :     }
-     524                 : 
-     525                 :   template<typename _Tp>
-     526                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     527                 :                                            int>::__type
-     528                 :     isinf(_Tp __f)
-     529                 :     {
-     530                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     531                 :       return __builtin_isinf(__type(__f));
-     532                 :     }
-     533                 : 
-     534                 :   template<typename _Tp>
-     535                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     536                 :                                            int>::__type
-     537                 :     isnan(_Tp __f)
-     538                 :     {
-     539                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     540                 :       return __builtin_isnan(__type(__f));
-     541                 :     }
-     542                 : 
-     543                 :   template<typename _Tp>
-     544                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     545                 :                                            int>::__type
-     546                 :     isnormal(_Tp __f)
-     547                 :     {
-     548                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     549                 :       return __builtin_isnormal(__type(__f));
-     550                 :     }
-     551                 : 
-     552                 :   template<typename _Tp>
-     553                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     554                 :                                            int>::__type
-     555                 :     signbit(_Tp __f)
-     556                 :     {
-     557                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     558                 :       return __builtin_signbit(__type(__f));
-     559                 :     }
-     560                 : 
-     561                 :   template<typename _Tp>
-     562                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     563                 :                                            int>::__type
-     564                 :     isgreater(_Tp __f1, _Tp __f2)
-     565                 :     {
-     566                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     567                 :       return __builtin_isgreater(__type(__f1), __type(__f2));
-     568                 :     }
-     569                 : 
-     570                 :   template<typename _Tp>
-     571                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     572                 :                                            int>::__type
-     573                 :     isgreaterequal(_Tp __f1, _Tp __f2)
-     574                 :     {
-     575                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     576                 :       return __builtin_isgreaterequal(__type(__f1), __type(__f2));
-     577                 :     }
-     578                 : 
-     579                 :   template<typename _Tp>
-     580                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     581                 :                                            int>::__type
-     582                 :     isless(_Tp __f1, _Tp __f2)
-     583                 :     {
-     584                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     585                 :       return __builtin_isless(__type(__f1), __type(__f2));
-     586                 :     }
-     587                 : 
-     588                 :   template<typename _Tp>
-     589                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     590                 :                                            int>::__type
-     591                 :     islessequal(_Tp __f1, _Tp __f2)
-     592                 :     {
-     593                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     594                 :       return __builtin_islessequal(__type(__f1), __type(__f2));
-     595                 :     }
-     596                 : 
-     597                 :   template<typename _Tp>
-     598                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     599                 :                                            int>::__type
-     600                 :     islessgreater(_Tp __f1, _Tp __f2)
-     601                 :     {
-     602                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     603                 :       return __builtin_islessgreater(__type(__f1), __type(__f2));
-     604                 :     }
-     605                 : 
-     606                 :   template<typename _Tp>
-     607                 :     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-     608                 :                                            int>::__type
-     609                 :     isunordered(_Tp __f1, _Tp __f2)
-     610                 :     {
-     611                 :       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-     612                 :       return __builtin_isunordered(__type(__f1), __type(__f2));
-     613                 :     }
-     614                 : 
-     615                 : _GLIBCXX_END_NAMESPACE
-     616                 : 
-     617                 : #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
-     618                 : #endif
-     619                 : 
-     620                 : #ifndef _GLIBCXX_EXPORT_TEMPLATE
-     621                 : # include <bits/cmath.tcc>
-     622                 : #endif
-     623                 : 
-     624                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
-     625                 : #  if defined(_GLIBCXX_INCLUDE_AS_TR1)
-     626                 : #    error C++0x header cannot be included from TR1 header
-     627                 : #  endif
-     628                 : #  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
-     629                 : #    include <tr1_impl/cmath>
-     630                 : #  else
-     631                 : #    define _GLIBCXX_INCLUDE_AS_CXX0X
-     632                 : #    define _GLIBCXX_BEGIN_NAMESPACE_TR1
-     633                 : #    define _GLIBCXX_END_NAMESPACE_TR1
-     634                 : #    define _GLIBCXX_TR1
-     635                 : #    include <tr1_impl/cmath>
-     636                 : #    undef _GLIBCXX_TR1
-     637                 : #    undef _GLIBCXX_END_NAMESPACE_TR1
-     638                 : #    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
-     639                 : #    undef _GLIBCXX_INCLUDE_AS_CXX0X
-     640                 : #  endif
-     641                 : #endif
-     642                 : 
-     643                 : #endif
-
-
-
- - - - -
Generated by: LTP GCOV extension version 1.6
-
- - - -- cgit v1.2.3