Ignore:
Timestamp:
Jun 12, 2005, 7:33:38 AM (20 years ago)
Author:
bird
Message:

o The smallcnv stuff is gone, waste of space since we're not really into

static linking. Should've done this when switching to gdtoa.

o Ported the msun and some other math bits from current FreeBSD libc.

This mostly replaces the EMX math, except for some double long variants
and some EMX specific ones. This is a risky change, but it's needed
if we're gonna catch up on the C99 bits and make libstdc++ happy.
There are some new headers, complex.h and fenv.h being the importan ones.
float.h have gotten some updates while math.h is totally replaced.
More than 100 standard functions were added!
NOTE: msun is using MATH_ERREXCEPT (math_errhandling) and not

MATH_ERRNO for error reporting.

I really hope this is not gonna uncover more OS/2 387 mess.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/emx/include/math.h

    • Property cvs2svn:cvs-rev changed from 1.6 to 1.7
    r2012 r2013  
    1 /* math.h,v 1.5 2004/09/14 22:27:34 bird Exp */
     1/*
     2 * ====================================================
     3 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
     4 *
     5 * Developed at SunPro, a Sun Microsystems, Inc. business.
     6 * Permission to use, copy, modify, and distribute this
     7 * software is freely granted, provided that this notice
     8 * is preserved.
     9 * ====================================================
     10 */
     11
     12/*
     13 * from: @(#)fdlibm.h 5.1 93/09/24
     14 * $FreeBSD: src/lib/msun/src/math.h,v 1.61 2005/04/16 21:12:47 das Exp $
     15 */
     16
    217/** @file
    3  * EMX
    4  * @todo This needs C99 attention!
    5  */
    6 
    7 #ifndef _MATH_H
    8 #define _MATH_H
    9 
    10 #if defined (__cplusplus)
    11 extern "C" {
    12 #endif
    13 
    14 #define HUGE_VAL        1e9999
    15 
    16 double acos (double);
    17 double asin (double);
    18 double atan (double);
    19 double atan2 (double, double);
    20 double cbrt (double);
    21 double ceil (double);
    22 double cos (double);
    23 double cosh (double);
    24 double exp (double);
    25 double fabs (double);
    26 double floor (double);
    27 double fmod (double, double);
    28 double frexp (double, int *);
    29 double hypot (double, double);
    30 double ldexp (double, int);
    31 double log (double);
    32 double log10 (double);
    33 double modf (double, double *);
    34 double pow (double, double);
    35 double rint (double);
    36 double sin (double);
    37 double sinh (double);
    38 double sqrt (double);
    39 double tan (double);
    40 double tanh (double);
    41 double trunc (double);
    42 
    43 #if !defined (__NO_C9X)
    44 
    45 #define HUGE_VALF       1e9999F
    46 #define HUGE_VALL       1e9999L
    47 #define INFINITY        1e9999          /* TODO: float_t */
    48 #define NAN             (0.0/0.0)       /* TODO: Exceptions, float_t */
    49 
    50 #define DECIMAL_DIG     21
    51 
    52 #define FP_ZERO         0
    53 #define FP_SUBNORMAL    1
    54 #define FP_NORMAL       2
    55 #define FP_INFINITE     3
    56 #define FP_NAN          4
    57 
    58 #define fpclassify(x) \
    59     ((sizeof (x) == sizeof (float))  ? __fpclassifyf (x) \
    60    : (sizeof (x) == sizeof (double)) ? __fpclassify (x) \
    61    :                                   __fpclassifyl (x))
    62 
    63 #define signbit(x) \
    64     ((sizeof (x) == sizeof (float))  ? __signbitf (x) \
    65    : (sizeof (x) == sizeof (double)) ? __signbit (x) \
    66    :                                   __signbitl (x))
    67 
    68 #define isfinite(x) \
    69     ((sizeof (x) == sizeof (float))  ? __isfinitef (x) \
    70    : (sizeof (x) == sizeof (double)) ? __isfinite (x) \
    71    :                                   __isfinitel (x))
    72 
    73 #define isnormal(x) \
    74     ((sizeof (x) == sizeof (float))  ? __isnormalf (x) \
    75    : (sizeof (x) == sizeof (double)) ? __isnormal (x) \
    76    :                                   __isnormall (x))
    77 
    78 #define isnan(x) \
    79     ((sizeof (x) == sizeof (float))  ? __isnanf (x) \
    80    : (sizeof (x) == sizeof (double)) ? __isnan (x) \
    81    :                                   __isnanl (x))
    82 
    83 float copysignf (float, float);
    84 double copysign (double, double);
    85 long double copysignl (long double, long double);
    86 
    87 float nextafterf (float, float);
    88 double nextafter (double, double);
    89 long double nextafterl (long double, long double);
    90 
    91 long double acosl (long double);
    92 long double asinl (long double);
    93 long double atanl (long double);
    94 long double atan2l (long double, long double);
    95 long double cbrtl (long double);
    96 long double ceill (long double);
    97 long double cosl (long double);
    98 long double coshl (long double);
    99 long double expl (long double);
    100 long double fabsl (long double);
    101 long double floorl (long double);
    102 long double fmodl (long double, long double);
    103 long double frexpl (long double, int *);
    104 long double hypotl (long double, long double);
    105 long double ldexpl (long double, int);
    106 long double logl (long double);
    107 long double log10l (long double);
    108 long double modfl (long double, long double *);
    109 long double powl (long double, long double);
    110 long double rintl (long double);
    111 long double sinl (long double);
    112 long double sinhl (long double);
    113 long double sqrtl (long double);
    114 long double tanl (long double);
    115 long double tanhl (long double);
    116 long double truncl (long double);
    117 
    118 int __fpclassify (double);
    119 int __fpclassifyf (float);
    120 int __fpclassifyl (long double);
    121 
    122 int __signbit (double);
    123 int __signbitf (float);
    124 int __signbitl (long double);
    125 
    126 int __isfinite (double);
    127 int __isfinitef (float);
    128 int __isfinitel (long double);
    129 
    130 int __isnormal (double);
    131 int __isnormalf (float);
    132 int __isnormall (long double);
    133 
    134 int __isnan (double);
    135 int __isnanf (float);
    136 int __isnanl (long double);
    137 
    138 #endif
    139 
    140 #if !defined (__STRICT_ANSI__)
    141 
    142 #define HUGE    HUGE_VAL
    143 
    144 double atof (__const__ char *);
    145 
    146 #endif
    147 
    148 
    149 #if !defined (__STRICT_ANSI__) || defined (_WITH_UNDERSCORE)
    150 
    151 #define _HUGE_VALF      1e9999F
    152 #define _HUGE_VALL      1e9999L
    153 #define _INFINITY       1e9999          /* TODO: float_t */
    154 #define _NAN            (0.0/0.0)       /* TODO: Exceptions, float_t */
    155 
    156 #define _LHUGE_VAL      _HUGE_VALL
    157 #define _LHUGE          _HUGE_VALL
    158 
    159 
    160 float _copysignf (float, float);
    161 double _copysign (double, double);
    162 long double _copysignl (long double, long double);
    163 
    164 float _nextafterf (float, float);
    165 double _nextafter (double, double);
    166 long double _nextafterl (long double, long double);
    167 
    168 long double _acosl (long double);
    169 long double _asinl (long double);
    170 long double _atanl (long double);
    171 long double _atan2l (long double, long double);
    172 long double _atofl (__const__ char *);
    173 long double _cbrtl (long double);
    174 long double _ceill (long double);
    175 long double _cosl (long double);
    176 long double _coshl (long double);
    177 long double _hypotl (long double, long double);
    178 long double _expl (long double);
    179 long double _fabsl (long double);
    180 long double _floorl (long double);
    181 long double _fmodl (long double, long double);
    182 long double _frexpl (long double, int *);
    183 long double _ldexpl (long double, int);
    184 long double _logl (long double);
    185 long double _log10l (long double);
    186 long double _modfl (long double, long double *);
    187 long double _powl (long double, long double);
    188 long double _rintl (long double);
    189 long double _sinl (long double);
    190 long double _sinhl (long double);
    191 long double _sqrtl (long double);
    192 long double _tanl (long double);
    193 long double _tanhl (long double);
    194 long double _truncl (long double);
    195 
    196 #endif
    197 
    198 
    199 #if defined (__cplusplus)
    200 }
    201 #endif
    202 
    203 #endif /* not _MATH_H */
     18 * FreeBSD HEAD 2005-06-xx
     19 */
     20
     21#ifndef _MATH_H_
     22#define _MATH_H_
     23
     24#include <sys/cdefs.h>
     25#include <sys/_types.h>
     26#include <machine/_limits.h>
     27
     28/*
     29 * ANSI/POSIX
     30 */
     31extern const union __infinity_un {
     32        unsigned char   __uc[8];
     33        double          __ud;
     34} __infinity;
     35
     36extern const union __nan_un {
     37        unsigned char   __uc[sizeof(float)];
     38        float           __uf;
     39} __nan;
     40
     41#if __GNUC_PREREQ__(3, 3) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
     42#define __MATH_BUILTIN_CONSTANTS
     43#endif
     44
     45#if __GNUC_PREREQ__(3, 0) && !defined(__INTEL_COMPILER)
     46#define __MATH_BUILTIN_RELOPS
     47#endif
     48
     49#ifdef __MATH_BUILTIN_CONSTANTS
     50#define HUGE_VAL        __builtin_huge_val()
     51#else
     52#define HUGE_VAL        (__infinity.__ud)
     53#endif
     54
     55#if __ISO_C_VISIBLE >= 1999
     56#define FP_ILOGB0       (-__INT_MAX)
     57#define FP_ILOGBNAN     __INT_MAX
     58
     59#ifdef __MATH_BUILTIN_CONSTANTS
     60#define HUGE_VALF       __builtin_huge_valf()
     61#define HUGE_VALL       __builtin_huge_vall()
     62#define INFINITY        __builtin_inf()
     63#define NAN             __builtin_nan("")
     64#else
     65#define HUGE_VALF       (float)HUGE_VAL
     66#define HUGE_VALL       (long double)HUGE_VAL
     67#define INFINITY        HUGE_VALF
     68#define NAN             (__nan.__uf)
     69#endif /* __MATH_BUILTIN_CONSTANTS */
     70
     71#define MATH_ERRNO      1
     72#define MATH_ERREXCEPT  2
     73#define math_errhandling        MATH_ERREXCEPT
     74
     75/* XXX We need a <machine/math.h>. */
     76#if defined(__ia64__) || defined(__sparc64__)
     77#define FP_FAST_FMA
     78#endif
     79#ifdef __ia64__
     80#define FP_FAST_FMAL
     81#endif
     82#define FP_FAST_FMAF
     83
     84/* Symbolic constants to classify floating point numbers. */
     85#define FP_INFINITE     0x01
     86#define FP_NAN          0x02
     87#define FP_NORMAL       0x04
     88#define FP_SUBNORMAL    0x08
     89#define FP_ZERO         0x10
     90#define fpclassify(x) \
     91    ((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) \
     92    : (sizeof (x) == sizeof (double)) ? __fpclassifyd(x) \
     93    : __fpclassifyl(x))
     94
     95#define isfinite(x)                                     \
     96    ((sizeof (x) == sizeof (float)) ? __isfinitef(x)    \
     97    : (sizeof (x) == sizeof (double)) ? __isfinite(x)   \
     98    : __isfinitel(x))
     99#define isinf(x)                                        \
     100    ((sizeof (x) == sizeof (float)) ? __isinff(x)       \
     101    : (sizeof (x) == sizeof (double)) ? isinf(x)        \
     102    : __isinfl(x))
     103#define isnan(x)                                        \
     104    ((sizeof (x) == sizeof (float)) ? isnanf(x)         \
     105    : (sizeof (x) == sizeof (double)) ? isnan(x)        \
     106    : __isnanl(x))
     107#define isnormal(x)                                     \
     108    ((sizeof (x) == sizeof (float)) ? __isnormalf(x)    \
     109    : (sizeof (x) == sizeof (double)) ? __isnormal(x)   \
     110    : __isnormall(x))
     111
     112#ifdef __MATH_BUILTIN_RELOPS
     113#define isgreater(x, y)         __builtin_isgreater((x), (y))
     114#define isgreaterequal(x, y)    __builtin_isgreaterequal((x), (y))
     115#define isless(x, y)            __builtin_isless((x), (y))
     116#define islessequal(x, y)       __builtin_islessequal((x), (y))
     117#define islessgreater(x, y)     __builtin_islessgreater((x), (y))
     118#define isunordered(x, y)       __builtin_isunordered((x), (y))
     119#else
     120#define isgreater(x, y)         (!isunordered((x), (y)) && (x) > (y))
     121#define isgreaterequal(x, y)    (!isunordered((x), (y)) && (x) >= (y))
     122#define isless(x, y)            (!isunordered((x), (y)) && (x) < (y))
     123#define islessequal(x, y)       (!isunordered((x), (y)) && (x) <= (y))
     124#define islessgreater(x, y)     (!isunordered((x), (y)) && \
     125                                        ((x) > (y) || (y) > (x)))
     126#define isunordered(x, y)       (isnan(x) || isnan(y))
     127#endif /* __MATH_BUILTIN_RELOPS */
     128
     129#define signbit(x)                                      \
     130    ((sizeof (x) == sizeof (float)) ? __signbitf(x)     \
     131    : (sizeof (x) == sizeof (double)) ? __signbit(x)    \
     132    : __signbitl(x))
     133
     134typedef __double_t      double_t;
     135typedef __float_t       float_t;
     136#endif /* __ISO_C_VISIBLE >= 1999 */
     137
     138/*
     139 * XOPEN/SVID
     140 */
     141#if __BSD_VISIBLE || __XSI_VISIBLE
     142#define M_E             2.7182818284590452354   /* e */
     143#define M_LOG2E         1.4426950408889634074   /* log 2e */
     144#define M_LOG10E        0.43429448190325182765  /* log 10e */
     145#define M_LN2           0.69314718055994530942  /* log e2 */
     146#define M_LN10          2.30258509299404568402  /* log e10 */
     147#define M_PI            3.14159265358979323846  /* pi */
     148#define M_PI_2          1.57079632679489661923  /* pi/2 */
     149#define M_PI_4          0.78539816339744830962  /* pi/4 */
     150#define M_1_PI          0.31830988618379067154  /* 1/pi */
     151#define M_2_PI          0.63661977236758134308  /* 2/pi */
     152#define M_2_SQRTPI      1.12837916709551257390  /* 2/sqrt(pi) */
     153#define M_SQRT2         1.41421356237309504880  /* sqrt(2) */
     154#define M_SQRT1_2       0.70710678118654752440  /* 1/sqrt(2) */
     155
     156#define MAXFLOAT        ((float)3.40282346638528860e+38)
     157extern int signgam;
     158#endif /* __BSD_VISIBLE || __XSI_VISIBLE */
     159
     160#if __BSD_VISIBLE
     161#if 0
     162/* Old value from 4.4BSD-Lite math.h; this is probably better. */
     163#define HUGE            HUGE_VAL
     164#else
     165#define HUGE            MAXFLOAT
     166#endif
     167#endif /* __BSD_VISIBLE */
     168
     169/*
     170 * Most of these functions depend on the rounding mode and have the side
     171 * effect of raising floating-point exceptions, so they are not declared
     172 * as __pure2.  In C99, FENV_ACCESS affects the purity of these functions.
     173 */
     174__BEGIN_DECLS
     175/*
     176 * ANSI/POSIX
     177 */
     178int     __fpclassifyd(double) __pure2;
     179int     __fpclassifyf(float) __pure2;
     180int     __fpclassifyl(long double) __pure2;
     181int     __isfinitef(float) __pure2;
     182int     __isfinite(double) __pure2;
     183int     __isfinitel(long double) __pure2;
     184int     __isinff(float) __pure2;
     185int     __isinfl(long double) __pure2;
     186int     __isnanl(long double) __pure2;
     187int     __isnormalf(float) __pure2;
     188int     __isnormal(double) __pure2;
     189int     __isnormall(long double) __pure2;
     190int     __signbit(double) __pure2;
     191int     __signbitf(float) __pure2;
     192int     __signbitl(long double) __pure2;
     193
     194double  acos(double);
     195double  asin(double);
     196double  atan(double);
     197double  atan2(double, double);
     198double  cos(double);
     199double  sin(double);
     200double  tan(double);
     201
     202double  cosh(double);
     203double  sinh(double);
     204double  tanh(double);
     205
     206double  exp(double);
     207double  frexp(double, int *);   /* fundamentally !__pure2 */
     208double  ldexp(double, int);
     209double  log(double);
     210double  log10(double);
     211double  modf(double, double *); /* fundamentally !__pure2 */
     212
     213double  pow(double, double);
     214double  sqrt(double);
     215
     216double  ceil(double);
     217double  fabs(double) __pure2;
     218double  floor(double);
     219double  fmod(double, double);
     220
     221/*
     222 * These functions are not in C90.
     223 */
     224#if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE
     225double  acosh(double);
     226double  asinh(double);
     227double  atanh(double);
     228double  cbrt(double);
     229double  erf(double);
     230double  erfc(double);
     231double  exp2(double);
     232double  expm1(double);
     233double  fma(double, double, double);
     234double  hypot(double, double);
     235int     ilogb(double) __pure2;
     236int     (isinf)(double) __pure2;
     237int     (isnan)(double) __pure2;
     238double  lgamma(double);
     239long long llrint(double);
     240long long llround(double);
     241double  log1p(double);
     242double  logb(double);
     243long    lrint(double);
     244long    lround(double);
     245double  nextafter(double, double);
     246double  remainder(double, double);
     247double  remquo(double, double, int *);
     248double  rint(double);
     249#endif /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */
     250
     251#if __BSD_VISIBLE || __XSI_VISIBLE
     252double  j0(double);
     253double  j1(double);
     254double  jn(int, double);
     255double  scalb(double, double);
     256double  y0(double);
     257double  y1(double);
     258double  yn(int, double);
     259
     260#if __XSI_VISIBLE <= 500 || __BSD_VISIBLE
     261double  gamma(double);
     262#endif
     263#endif /* __BSD_VISIBLE || __XSI_VISIBLE */
     264
     265#if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999
     266double  copysign(double, double) __pure2;
     267double  fdim(double, double);
     268double  fmax(double, double) __pure2;
     269double  fmin(double, double) __pure2;
     270double  nearbyint(double);
     271double  round(double);
     272double  scalbln(double, long);
     273double  scalbn(double, int);
     274double  tgamma(double);
     275double  trunc(double);
     276#endif
     277
     278/*
     279 * BSD math library entry points
     280 */
     281#if __BSD_VISIBLE
     282double  drem(double, double);
     283int     finite(double) __pure2;
     284int     isnanf(float) __pure2;
     285
     286/*
     287 * Reentrant version of gamma & lgamma; passes signgam back by reference
     288 * as the second argument; user must allocate space for signgam.
     289 */
     290double  gamma_r(double, int *);
     291double  lgamma_r(double, int *);
     292
     293/*
     294 * IEEE Test Vector
     295 */
     296double  significand(double);
     297#endif /* __BSD_VISIBLE */
     298
     299/* float versions of ANSI/POSIX functions */
     300#if __ISO_C_VISIBLE >= 1999
     301float   acosf(float);
     302float   asinf(float);
     303float   atanf(float);
     304float   atan2f(float, float);
     305float   cosf(float);
     306float   sinf(float);
     307float   tanf(float);
     308
     309float   coshf(float);
     310float   sinhf(float);
     311float   tanhf(float);
     312
     313float   exp2f(float);
     314float   expf(float);
     315float   expm1f(float);
     316float   frexpf(float, int *);   /* fundamentally !__pure2 */
     317int     ilogbf(float) __pure2;
     318float   ldexpf(float, int);
     319float   log10f(float);
     320float   log1pf(float);
     321float   logf(float);
     322float   modff(float, float *);  /* fundamentally !__pure2 */
     323
     324float   powf(float, float);
     325float   sqrtf(float);
     326
     327float   ceilf(float);
     328float   fabsf(float) __pure2;
     329float   floorf(float);
     330float   fmodf(float, float);
     331float   roundf(float);
     332
     333float   erff(float);
     334float   erfcf(float);
     335float   hypotf(float, float);
     336float   lgammaf(float);
     337
     338float   acoshf(float);
     339float   asinhf(float);
     340float   atanhf(float);
     341float   cbrtf(float);
     342float   logbf(float);
     343float   copysignf(float, float) __pure2;
     344long long llrintf(float);
     345long long llroundf(float);
     346long    lrintf(float);
     347long    lroundf(float);
     348float   nearbyintf(float);
     349float   nextafterf(float, float);
     350float   remainderf(float, float);
     351float   remquof(float, float, int *);
     352float   rintf(float);
     353float   scalblnf(float, long);
     354float   scalbnf(float, int);
     355float   truncf(float);
     356
     357float   fdimf(float, float);
     358float   fmaf(float, float, float);
     359float   fmaxf(float, float) __pure2;
     360float   fminf(float, float) __pure2;
     361#endif
     362
     363/*
     364 * float versions of BSD math library entry points
     365 */
     366#if __BSD_VISIBLE
     367float   dremf(float, float);
     368int     finitef(float) __pure2;
     369float   gammaf(float);
     370float   j0f(float);
     371float   j1f(float);
     372float   jnf(int, float);
     373float   scalbf(float, float);
     374float   y0f(float);
     375float   y1f(float);
     376float   ynf(int, float);
     377
     378/*
     379 * Float versions of reentrant version of gamma & lgamma; passes
     380 * signgam back by reference as the second argument; user must
     381 * allocate space for signgam.
     382 */
     383float   gammaf_r(float, int *);
     384float   lgammaf_r(float, int *);
     385
     386/*
     387 * float version of IEEE Test Vector
     388 */
     389float   significandf(float);
     390#endif  /* __BSD_VISIBLE */
     391
     392/*
     393 * long double versions of ISO/POSIX math functions
     394 */
     395#if __ISO_C_VISIBLE >= 1999
     396#if 1  /* bird: we've got these */
     397long double     acoshl(long double);
     398long double     acosl(long double);
     399long double     asinhl(long double);
     400long double     asinl(long double);
     401long double     atan2l(long double, long double);
     402long double     atanhl(long double);
     403long double     atanl(long double);
     404long double     cbrtl(long double);
     405#endif
     406long double     ceill(long double);
     407long double     copysignl(long double, long double) __pure2;
     408#if 1 /* bird: we've got some of these */
     409long double     coshl(long double);
     410long double     cosl(long double);
     411/*long double   erfcl(long double);
     412long double     erfl(long double);
     413long double     exp2l(long double);*/
     414long double     expl(long double);
     415/*long double   expm1l(long double);*/
     416#endif
     417long double     fabsl(long double) __pure2;
     418long double     fdiml(long double, long double);
     419long double     floorl(long double);
     420long double     fmal(long double, long double, long double);
     421long double     fmaxl(long double, long double) __pure2;
     422long double     fminl(long double, long double) __pure2;
     423#if 1 /* bird: we've got this one */
     424long double     fmodl(long double, long double);
     425#endif
     426long double     frexpl(long double value, int *); /* fundamentally !__pure2 */
     427#if 1 /* bird: we've got this one */
     428long double     hypotl(long double, long double);
     429#endif
     430int             ilogbl(long double) __pure2;
     431long double     ldexpl(long double, int);
     432#if 0
     433long double     lgammal(long double);
     434long long       llrintl(long double);
     435#endif
     436long long       llroundl(long double);
     437#if 1 /* bird: we've got some of these */
     438long double     log10l(long double);
     439/*long double   log1pl(long double);
     440long double     log2l(long double);
     441long double     logbl(long double);*/
     442long double     logl(long double);
     443/*long          lrintl(long double);*/
     444#endif
     445long            lroundl(long double);
     446#if 1 /* bird: we've got some of these. */
     447long double     modfl(long double, long double *); /* fundamentally !__pure2 */
     448/*long double   nanl(const char *) __pure2;
     449long double     nearbyintl(long double);*/
     450#endif
     451long double     nextafterl(long double, long double);
     452double          nexttoward(double, long double);
     453float           nexttowardf(float, long double);
     454long double     nexttowardl(long double, long double);
     455#if 1 /* bird: we've got powl. */
     456long double     powl(long double, long double);
     457/*long double   remainderl(long double, long double);
     458long double     remquol(long double, long double, int *);*/
     459long double     rintl(long double);
     460#endif
     461long double     roundl(long double);
     462long double     scalblnl(long double, long);
     463long double     scalbnl(long double, int);
     464#if 1 /* birdL we 've got most of these. */
     465long double     sinhl(long double);
     466long double     sinl(long double);
     467long double     sqrtl(long double);
     468long double     tanhl(long double);
     469long double     tanl(long double);
     470/*long double   tgammal(long double); */
     471#endif
     472long double     truncl(long double);
     473
     474#endif /* __ISO_C_VISIBLE >= 1999 */
     475__END_DECLS
     476
     477#endif /* !_MATH_H_ */
Note: See TracChangeset for help on using the changeset viewer.