X-Git-Url: https://pd.if.org/git/?p=pdclib;a=blobdiff_plain;f=includes%2Fmath.h;h=f737c215d8975285bd19e76d6c062981f613fe86;hp=813f3c94d1e99a2403eeb519deb5b813eb1494df;hb=ad2651a3d8a2e2ae70a5ad882518ef346ab1bc7b;hpb=1e221deb9ee725a14b3656f94e2763f8faeb18dc

diff --git a/includes/math.h b/includes/math.h
index 813f3c9..f737c21 100644
--- a/includes/math.h
+++ b/includes/math.h
@@ -40,27 +40,27 @@
 // --------------------------------------------------------------------------
 // TYPEDEFS
 
-typedef f-type double_t; // TODO
-typedef f-type float_t;  // TODO
+typedef double_t; // TODO
+typedef float_t;  // TODO
 
 // --------------------------------------------------------------------------
 // MACROS
 
 #ifndef __cplusplus
 
-#define signbit(x)           // TODO
-#define fpclassify(x)        // TODO
-#define isfinite(x)          // TODO
-#define isinf(x)             // TODO
-#define isnan(x)             // TODO
-#define isnormal(x)          // TODO
+#define signbit( x )           // TODO
+#define fpclassify( x )        // TODO
+#define isfinite( x )          // TODO
+#define isinf( x )             // TODO
+#define isnan( x )             // TODO
+#define isnormal( x )          // TODO
 
-#define isgreater(x, y)      // TODO
-#define isgreaterequal(x, y) // TODO
-#define isless(x, y)         // TODO
-#define islessequal(x, y)    // TODO
-#define islessgreater(x, y)  // TODO
-#define isunordered(x, y)    // TODO
+#define isgreater( x, y )      // TODO
+#define isgreaterequal( x, y ) // TODO
+#define isless( x, y )         // TODO
+#define islessequal( x, y )    // TODO
+#define islessgreater( x, y )  // TODO
+#define isunordered( x, y )    // TODO
 
 #else // __cplusplus
 
@@ -107,504 +107,508 @@ bool isunordered( long double x, long double y );
 // --------------------------------------------------------------------------
 // FUNCTIONS - C++
 
+#ifdef __cplusplus
+
 // These functions return the magnitude of their parameter.
-double      abs(double      x);
-float       abs(float       x);
-long double abs(long double x);
-float       fabs(float       x);
-long double fabs(long double x);
+double      abs( double      x );
+float       abs( float       x );
+long double abs( long double x );
+float       fabs( float       x );
+long double fabs( long double x );
 
 // These functions return the sine of their parameter.
-float       sin(float       x);
-long double sin(long double x);
+float       sin( float       x );
+long double sin( long double x );
 
 // These functions return the hyperbolic sine of their parameter.
-float       sinh(float       x);
-long double sinh(long double x);
+float       sinh( float       x );
+long double sinh( long double x );
 
 // These functions return the arcsine of their parameter.
-float       asin(float       x);
-long double asin(long double x);
+float       asin( float       x );
+long double asin( long double x );
 
 // These functions return the hyperbolic arcsine of their parameter.
-float       asinh(float       x);
-long double asinh(long double x);
+float       asinh( float       x );
+long double asinh( long double x );
 
 // These functions return the cosine of their parameter.
-float       cos(float       x);
-long double cos(long double x);
+float       cos( float       x );
+long double cos( long double x );
 
 // These functions return the hyperbolic cosine of their parameter.
-float       cosh(float       x);
-long double cosh(long double x);
+float       cosh( float       x );
+long double cosh( long double x );
 
 // These functions return the arccosine of their parameter.
-float       acos(float       x);
-long double acos(long double x);
+float       acos( float       x );
+long double acos( long double x );
 
 // These functions return the hyperbolic arccosine of their parameter.
-float       acosh(float       x);
-long double acosh(long double x);
+float       acosh( float       x );
+long double acosh( long double x );
 
 // These functions return the tangent of their parameter.
-float       tan(float       x);
-long double tan(long double x);
+float       tan( float       x );
+long double tan( long double x );
 
 // These functions return the hyperbolic tangent of their parameter.
-float       tanh(float       x);
-long double tanh(long double x);
+float       tanh( float       x );
+long double tanh( long double x );
 
 // These functions return the arctangent of their parameter.
-float       atan(float       x);
-long double atan(long double x);
+float       atan( float       x );
+long double atan( long double x );
 
 // These functions return the hyperbolic arctangent of their parameter.
-float       atanh(float       x);
-long double atanh(long double x);
+float       atanh( float       x );
+long double atanh( long double x );
 
 // TODO
-float       atan2(float       y, float       x);
-long double atan2(long double y, long double x);
+float       atan2( float       x, float       y );
+long double atan2( long double x, long double y );
 
-// These functions return sqrt(x^2 + y^2).
-float       hypot(float       x, float       y);
-long double hypot(long double x, long double y);
+// These functions return sqrt( x^2 + y^2 ).
+float       hypot( float       x, float       y );
+long double hypot( long double x, long double y );
 
 // These functions return their parameter x, raised to the power y.
-float       pow(float       x, float       y);
-long double pow(long double x, long double y);
-double      pow(double      x, int         y);
-float       pow(float       x, int         y);
-long double pow(long double x, int         y);
+float       pow( float       x, float       y );
+long double pow( long double x, long double y );
+double      pow( double      x, int         y );
+float       pow( float       x, int         y );
+long double pow( long double x, int         y );
 
 // These functions return the square root of their parameter.
-float       sqrt(float       x);
-long double sqrt(long double x);
+float       sqrt( float       x );
+long double sqrt( long double x );
 
 // TODO
-float       cbrt(float       x);
-long double cbrt(long double x);
+float       cbrt( float       x );
+long double cbrt( long double x );
 
 // TODO
-float       exp(float       x);
-long double exp(long double x);
+float       exp( float       x );
+long double exp( long double x );
 
 // TODO
-float       exp2(float       x);
-long double exp2(long double x);
+float       exp2( float       x );
+long double exp2( long double x );
 
 // TODO
-float       expm1(float       x);
-long double expm1(long double x);
+float       expm1( float       x );
+long double expm1( long double x );
 
 // TODO
-float       frexp(float       x, int * exponent);
-long double frexp(long double x, int * exponent);
+float       frexp( float       x, int * exponent );
+long double frexp( long double x, int * exponent );
 
 // TODO
-float       ldexp(float       x, int exponent);
-long double ldexp(long double x, int exponent);
+float       ldexp( float       x, int exponent );
+long double ldexp( long double x, int exponent );
 
 // These functions return the natural logarithm of their parameter.
-float       log(float       x);
-long double log(long double x);
+float       log( float       x );
+long double log( long double x );
 
-// These functions return the logarithm (base 10) of their parameter.
-float       log10(float       x);
-long double log10(long double x);
+// These functions return the logarithm (base 10 ) of their parameter.
+float       log10( float       x );
+long double log10( long double x );
 
-// These functions return the logarithm (base 2) of their parameter.
-float       log2(float       x);
-long double log2(long double x);
+// These functions return the logarithm (base 2 ) of their parameter.
+float       log2( float       x );
+long double log2( long double x );
 
 // TODO
-float       logb(float       x);
-long double logb(long double x);
+float       logb( float       x );
+long double logb( long double x );
 
 // TODO
-int ilogb(float       x);
-int ilogb(long double x);
+int ilogb( float       x );
+int ilogb( long double x );
 
 // TODO
-float       log1p(float       x);
-long double log1p(long double x);
+float       log1p( float       x );
+long double log1p( long double x );
 
 // These functions return the smallest integer no larger than their parameter
-float       ceil(float       x);
-long double ceil(long double x);
+float       ceil( float       x );
+long double ceil( long double x );
 
 // These functions return the biggest integer no larger than their parameter.
-float       floor(float       x);
-long double floor(long double x);
+float       floor( float       x );
+long double floor( long double x );
 
 // TODO
-float       fmod(float       x, float       y);
-long double fmod(long double x, long double y);
+float       fmod( float       x, float       y );
+long double fmod( long double x, long double y );
 
 // TODO
-float       modf(float       x, float *       integer);
-long double modf(long double x, long double * integer);
+float       modf( float       x, float *       integer );
+long double modf( long double x, long double * integer );
 
 // These functions return their parameter x, with the sign of parameter y.
-float       copysign(float       x, float       y);
-long double copysign(long double x, long double y);
+float       copysign( float       x, float       y );
+long double copysign( long double x, long double y );
 
 // TODO
-float       erf(float       x);
-long double erf(long double x);
+float       erf( float       x );
+long double erf( long double x );
 
 // TODO
-float       erfc(float       x);
-long double erfc(long double x);
+float       erfc( float       x );
+long double erfc( long double x );
 
 // TODO
-float       fdim(float       x, float       y);
-long double fdim(long double x, long double y);
+float       fdim( float       x, float       y );
+long double fdim( long double x, long double y );
 
 // TODO
-float       fma(float       x, float       y, float       z);
-long double fma(long double x, long double y, long double z);
+float       fma( float       x, float       y, float       z );
+long double fma( long double x, long double y, long double z );
 
 // These functions return the larger of their parameters.
-float       fmax(float       x, float       y);
-long double fmax(long double x, long double y);
+float       fmax( float       x, float       y );
+long double fmax( long double x, long double y );
 
 // These functions return the smaller of their parameters.
-float       fmin(float       x, float       y);
-long double fmin(long double x, long double y);
+float       fmin( float       x, float       y );
+long double fmin( long double x, long double y );
 
 // TODO
-long long llrint(float x);
-long long llrint(long double x);
-long lrint(float       x);
-long lrint(long double x);
-float       rint(float       x);
-long double rint(long double x);
+long long llrint( float x );
+long long llrint( long double x );
+long lrint( float       x );
+long lrint( long double x );
+float       rint( float       x );
+long double rint( long double x );
 
 // TODO
-long long llround(float       x);
-long long llround(long double x);
-long lround(float       x);
-long lround(long double x);
-float       round(float       x);
-long double round(long double x);
+long long llround( float       x );
+long long llround( long double x );
+long lround( float       x );
+long lround( long double x );
+float       round( float       x );
+long double round( long double x );
 
 // TODO
-float       trunc(float       x);
-long double trunc(long double x);
+float       trunc( float       x );
+long double trunc( long double x );
 
 // TODO
-float       nearbyint(float       x);
-long double nearbyint(long double x);
+float       nearbyint( float       x );
+long double nearbyint( long double x );
 
 // TODO
-float       nextafter(float       x, float       y);
-long double nextafter(long double x, long double y);
+float       nextafter( float       x, float       y );
+long double nextafter( long double x, long double y );
 
 // TODO
-float       nexttoward(float       x, long double y);
-long double nexttoward(long double x, long double y);
+float       nexttoward( float       x, long double y );
+long double nexttoward( long double x, long double y );
 
 // TODO
-float       remainder(float       x, float       y);
-long double remainder(long double x, long double y);
+float       remainder( float       x, float       y );
+long double remainder( long double x, long double y );
 
 // TODO
-float       remquo(float       x, float       y, int * quotient);
-long double remquo(long double x, long double y, int * quotient);
+float       remquo( float       x, float       y, int * quotient );
+long double remquo( long double x, long double y, int * quotient );
 
 // TODO
-float       scalbn(float       x, int ex);
-long double scalbn(long double x, int ex);
+float       scalbn( float       x, int ex );
+long double scalbn( long double x, int ex );
 
 // TODO
-float       scalbln(float       x, long ex);
-long double scalbln(long double x, long ex);
+float       scalbln( float       x, long ex );
+long double scalbln( long double x, long ex );
 
 // TODO
-float       lgamma(float       x);
-long double lgamma(long double x);
+float       lgamma( float       x );
+long double lgamma( long double x );
 
 // TODO
-float       tgamma(float       x);
-long double tgamma(long double x);
+float       tgamma( float       x );
+long double tgamma( long double x );
+
+#endif // __cplusplus
 
 // ----------------------------------------------------------------------------
 // FUNCTIONS - Standard C
 
 // These functions return the magnitude of its parameter.
-double      fabs(double       x);
-float       fabsf(float       x);
-long double fabsl(long double x);
+double      fabs( double       x );
+float       fabsf( float       x );
+long double fabsl( long double x );
 
 // These functions return the sine of its parameter.
-double      sin(double       x);
-float       sinf(float       x);
-long double sinl(long double x);
+double      sin( double       x );
+float       sinf( float       x );
+long double sinl( long double x );
 
 // These functions return the hyperbolic cosine of its parameter.
-double      sinh(double       x);
-float       sinhf(float       x);
-long double sinhl(long double x);
+double      sinh( double       x );
+float       sinhf( float       x );
+long double sinhl( long double x );
 
 // These functions return the arcsine of its parameter.
-double      asin(double       x);
-float       asinf(float       x);
-long double asinl(long double x);
+double      asin( double       x );
+float       asinf( float       x );
+long double asinl( long double x );
 
 // These functions return the hyperbolic arcsine of their parameter.
-double      asinh(double       x);
-float       asinhf(float       x);
-long double asinhl(long double x);
+double      asinh( double       x );
+float       asinhf( float       x );
+long double asinhl( long double x );
 
 // These functions return the cosine of its parameter.
-double      cos(double       x);
-float       cosf(float       x);
-long double cosl(long double x);
+double      cos( double       x );
+float       cosf( float       x );
+long double cosl( long double x );
 
 // These functions return the hyperbolic cosine of its parameter.
-double      cosh(double       x);
-float       coshf(float       x);
-long double coshl(long double x);
+double      cosh( double       x );
+float       coshf( float       x );
+long double coshl( long double x );
 
 // These functions return the arccosine of its parameter.
-double      acos(double       x);
-float       acosf(float       x);
-long double acosl(long double x);
+double      acos( double       x );
+float       acosf( float       x );
+long double acosl( long double x );
 
 // These functions return the hyperbolic arccosine of their parameter.
-double      acosh(double       x);
-float       acoshf(float       x);
-long double acoshl(long double x);
+double      acosh( double       x );
+float       acoshf( float       x );
+long double acoshl( long double x );
 
 // These functions return the tangent of its parameter.
-double      tan(double       x);
-float       tanf(float       x);
-long double tanl(long double x);
+double      tan( double       x );
+float       tanf( float       x );
+long double tanl( long double x );
 
 // These functions return the hyperbolic tangent of its parameter.
-double      tanh(double       x);
-float       tanhf(float       x);
-long double tanhl(long double x);
+double      tanh( double       x );
+float       tanhf( float       x );
+long double tanhl( long double x );
 
 // These functions return the arctangent of its parameter.
-double      atan(double       x);
-float       atanf(float       x);
-long double atanl(long double x);
+double      atan( double       x );
+float       atanf( float       x );
+long double atanl( long double x );
 
 // These functions return the hyperbolic arctangent of their parameter.
-double      atanh(double       x);
-float       atanhf(float       x);
-long double atanhl(long double x);
+double      atanh( double       x );
+float       atanhf( float       x );
+long double atanhl( long double x );
 
 // TODO
-double      atan2(double       y, double      x);
-float       atan2f(float       y, float       x);
-long double atan2l(long double y, long double x);
+double      atan2( double       y, double      x );
+float       atan2f( float       y, float       x );
+long double atan2l( long double y, long double x );
 
-// These functions return sqrt(x^2 + y^2).
-double      hypot(double       x, double      y);
-float       hypotf(float       x, float       y);
-long double hypotl(long double x, long double y);
+// These functions return sqrt(x^2 + y^2 ).
+double      hypot( double       x, double      y );
+float       hypotf( float       x, float       y );
+long double hypotl( long double x, long double y );
 
 // These functions return its parameter x, raised to the power y.
-double      pow(double       x, double      y);
-float       powf(float       x, float       y);
-long double powl(long double x, long double y);
+double      pow( double       x, double      y );
+float       powf( float       x, float       y );
+long double powl( long double x, long double y );
 
 // These functions return the square root of its parameter.
-double      sqrt(double       x);
-float       sqrtf(float       x);
-long double sqrtl(long double x);
+double      sqrt( double       x );
+float       sqrtf( float       x );
+long double sqrtl( long double x );
 
 // TODO
-double      cbrt(double       x);
-float       cbrtf(float       x);
-long double cbrtl(long double x);
+double      cbrt( double       x );
+float       cbrtf( float       x );
+long double cbrtl( long double x );
 
 // TODO
-double      exp(double       x);
-float       expf(float       x);
-long double expl(long double x);
+double      exp( double       x );
+float       expf( float       x );
+long double expl( long double x );
 
 // TODO
-double      exp2(double       x);
-float       exp2f(float       x);
-long double exp2l(long double x);
+double      exp2( double       x );
+float       exp2f( float       x );
+long double exp2l( long double x );
 
 // TODO
-double      expm1(double       x);
-float       expm1f(float       x);
-long double expm1l(long double x);
+double      expm1( double       x );
+float       expm1f( float       x );
+long double expm1l( long double x );
 
 // TODO
-double      frexp(double       x, int * exp);
-float       frexpf(float       x, int * exp);
-long double frexpl(long double x, int * exp);
+double      frexp( double       x, int * exp );
+float       frexpf( float       x, int * exp );
+long double frexpl( long double x, int * exp );
 
 // TODO
-double      ldexp(double       x, int exp);
-float       ldexpf(float       x, int exp);
-long double ldexpl(long double x, int exp);
+double      ldexp( double       x, int exp );
+float       ldexpf( float       x, int exp );
+long double ldexpl( long double x, int exp );
 
 // These functions return the natural logarithm of its parameter.
-double      log(double       x);
-float       logf(float       x);
-long double logl(long double x);
+double      log( double       x );
+float       logf( float       x );
+long double logl( long double x );
 
-// These functions return the logarithm (base 10) of its parameter.
-double      log10(double       x);
-float       log10f(float       x);
-long double log10l(long double x);
+// These functions return the logarithm (base 10 ) of its parameter.
+double      log10( double       x );
+float       log10f( float       x );
+long double log10l( long double x );
 
-// These functions return the logarithm (base 2) of their parameter.
-double      log2(double       x);
-float       log2f(float       x);
-long double log2l(long double x);
+// These functions return the logarithm (base 2 ) of their parameter.
+double      log2( double       x );
+float       log2f( float       x );
+long double log2l( long double x );
 
 // TODO
-double      logb(double       x);
-float       logbf(float       x);
-long double logbl(long double x);
+double      logb( double       x );
+float       logbf( float       x );
+long double logbl( long double x );
 
 // TODO
-int ilogb(double       x);
-int ilogbf(float       x);
-int ilogbl(long double x);
+int ilogb( double       x );
+int ilogbf( float       x );
+int ilogbl( long double x );
 
 // TODO
-double      log1p(double       x);
-float       log1pf(float       x);
-long double log1pl(long double x);
+double      log1p( double       x );
+float       log1pf( float       x );
+long double log1pl( long double x );
 
 // These functions return the smallest integer no smaller than value.
-double      ceil(double       x);
-float       ceilf(float       x);
-long double ceill(long double x);
+double      ceil( double       x );
+float       ceilf( float       x );
+long double ceill( long double x );
 
 // These functions return the largest integer no larger than its parameter.
-double      floor(double       x);
-float       floorf(float       x);
-long double floorl(long double x);
+double      floor( double       x );
+float       floorf( float       x );
+long double floorl( long double x );
 
 // TODO
-double      fmod(double       x, double      y);
-float       fmodf(float       x, float       y);
-long double fmodl(long double x, long double y);
+double      fmod( double       x, double      y );
+float       fmodf( float       x, float       y );
+long double fmodl( long double x, long double y );
 
 // TODO
-double      modf(double       x, double *      integer);
-float       modff(float       x, float *       integer);
-long double modfl(long double x, long double * integer);
+double      modf( double       x, double *      integer );
+float       modff( float       x, float *       integer );
+long double modfl( long double x, long double * integer );
 
 // These functions return their parameter x, with the sign of parameter y.
-double      copysign(double       x, double      y);
-float       copysignf(float       x, float       y);
-long double copysignl(long double x, long double y);
+double      copysign( double       x, double      y );
+float       copysignf( float       x, float       y );
+long double copysignl( long double x, long double y );
 
 // TODO
-double      erf(double       x);
-float       erff(float       x);
-long double erfl(long double x);
+double      erf( double       x );
+float       erff( float       x );
+long double erfl( long double x );
 
 // TODO
-double      erfc(double       x);
-float       erfcf(float       x);
-long double erfcl(long double x);
+double      erfc( double       x );
+float       erfcf( float       x );
+long double erfcl( long double x );
 
 // TODO
-double      fdim(double       x, double      y);
-float       fdimf(float       x, float       y);
-long double fdiml(long double x, long double y);
+double      fdim( double       x, double      y );
+float       fdimf( float       x, float       y );
+long double fdiml( long double x, long double y );
 
 // TODO
-double      fma(double       x, double      y, double      z);
-float       fmaf(float       x, float       y, float       z);
-long double fmal(long double x, long double y, long double z);
+double      fma( double       x, double      y, double      z );
+float       fmaf( float       x, float       y, float       z );
+long double fmal( long double x, long double y, long double z );
 
 // These functions return the larger of their parameters.
-double      fmax(double       x, double      y);
-float       fmaxf(float       x, float       y);
-long double fmaxl(long double x, long double y);
+double      fmax( double       x, double      y );
+float       fmaxf( float       x, float       y );
+long double fmaxl( long double x, long double y );
 
 // These functions return the smaller of their parameters.
-double      fmin(double       x, double      y);
-float       fminf(float       x, float       y);
-long double fminl(long double x, long double y);
+double      fmin( double       x, double      y );
+float       fminf( float       x, float       y );
+long double fminl( long double x, long double y );
 
 // TODO
-long long llrint(double       x);
-long long llrintf(float       x);
-long long llrintl(long double x);
-long lrint(double       x);
-long lrintf(float       x);
-long lrintl(long double x);
-double      rint(double       x);
-float       rintf(float       x);
-long double rintl(long double x);
+long long llrint( double       x );
+long long llrintf( float       x );
+long long llrintl( long double x );
+long lrint( double       x );
+long lrintf( float       x );
+long lrintl( long double x );
+double      rint( double       x );
+float       rintf( float       x );
+long double rintl( long double x );
 
 // TODO
-long long llround(double       x);
-long long llroundf(float       x);
-long long llroundl(long double x);
-long lround(double       x);
-long lroundf(float       x);
-long lroundl(long double x);
-double      round(double       x);
-float       roundf(float       x);
-long double roundl(long double x);
+long long llround( double       x );
+long long llroundf( float       x );
+long long llroundl( long double x );
+long lround( double       x );
+long lroundf( float       x );
+long lroundl( long double x );
+double      round( double       x );
+float       roundf( float       x );
+long double roundl( long double x );
 
 // TODO
-double      trunc(double       x);
-float       truncf(float       x);
-long double truncl(long double x);
+double      trunc( double       x );
+float       truncf( float       x );
+long double truncl( long double x );
 
-double      nearbyint(double       x);
-float       nearbyintf(float       x);
-long double nearbyintl(long double x);
+double      nearbyint( double       x );
+float       nearbyintf( float       x );
+long double nearbyintl( long double x );
 
-double      nextafter(double       x, double      y);
-float       nextafterf(float       x, float       y);
-long double nextafterl(long double x, long double y);
+double      nextafter( double       x, double      y );
+float       nextafterf( float       x, float       y );
+long double nextafterl( long double x, long double y );
 
 // TODO
-double      nexttoward(double       x, long double y);
-float       nexttowardf(float       x, long double y);
-long double nexttowardl(long double x, long double y);
+double      nexttoward( double       x, long double y );
+float       nexttowardf( float       x, long double y );
+long double nexttowardl( long double x, long double y );
 
 // TODO
-double      remainder(double       x, double      y);
-float       remainderf(float       x, float       y);
-long double remainderl(long double x, long double y);
+double      remainder( double       x, double      y );
+float       remainderf( float       x, float       y );
+long double remainderl( long double x, long double y );
 
 // TODO
-double      remquo(double       x, double      y, int * pquo);
-float       remquof(float       x, float       y, int * pquo);
-long double remquol(long double x, long double y, int * pquo);
+double      remquo( double       x, double      y, int * pquo );
+float       remquof( float       x, float       y, int * pquo );
+long double remquol( long double x, long double y, int * pquo );
 
 // TODO
-double      scalbn(double       x, int ex);
-float       scalbnf(float       x, int ex);
-long double scalbnl(long double x, int ex);
+double      scalbn( double       x, int ex );
+float       scalbnf( float       x, int ex );
+long double scalbnl( long double x, int ex );
 
 // TODO
-double      scalbln(double       x, long ex);
-float       scalblnf(float       x, long ex);
-long double scalblnl(long double x, long ex);
+double      scalbln( double       x, long ex );
+float       scalblnf( float       x, long ex );
+long double scalblnl( long double x, long ex );
 
 // TODO
-double      lgamma(double       x);
-float       lgammaf(float       x);
-long double lgammal(long double x);
+double      lgamma( double       x );
+float       lgammaf( float       x );
+long double lgammal( long double x );
 
 // TODO
-double      tgamma(double       x);
-float       tgammaf(float       x);
-long double tgammal(long double x);
+double      tgamma( double       x );
+float       tgammaf( float       x );
+long double tgammal( long double x );
 
 // TODO
-double      nan(const char  *str);
-float       nanf(const char *str);
-long double nanl(const char *str);
+double      nan( const char  *str );
+float       nanf( const char *str );
+long double nanl( const char *str );
 
 #endif // __MATH_H