Fleshing out the headers.

diff --git a/includes/assert.h b/includes/assert.h
index e4363f510f42ad4768d35ed28cd523452da61fa8..e03baaaae87c66a5adc653f084be53591eee99a1 100644 (file)
--- a/includes/assert.h
+++ b/includes/assert.h
@@ -22,16 +22,13 @@ void __assert( char const * const expression, // the tested expression
 // ----------------------------------------------------------------------------
 // DEFINES
 
 // ----------------------------------------------------------------------------
 // DEFINES
 

-// TODO: <void expression> is given as (void) 0, which might give a "C style
-// cast" warning under C++. Find a void expression that does not give warnings.
-

 // TODO: Check the macro for if-compatibility.
 
 #undef assert
 #if defined NDEBUG
 // TODO: Check the macro for if-compatibility.
 
 #undef assert
 #if defined NDEBUG

-#define assert( x ) <void expression>
+#define assert( x ) (void) 0

 #else
 #else

-#define assert( x ) ( x ) ? <void expression> \
+#define assert( x ) ( x ) ? (void) 0 \

                           :  __assert( #x, __FILE__, __func__, __LINE__ )
 #endif
 
                           :  __assert( #x, __FILE__, __func__, __LINE__ )
 #endif
 

diff --git a/includes/complex.h b/includes/complex.h
index 6abc92a39e7537d976e49dde76903b92ab597504..59cb5b2c45facaefb2be191f02523365b48af6e0 100644 (file)
--- a/includes/complex.h
+++ b/includes/complex.h
@@ -14,7 +14,22 @@
 // ----------------------------------------------------------------------------
 // DEFINES
 
 // ----------------------------------------------------------------------------
 // DEFINES
 

-// TODO: #defines for complex, _Complex_I, imaginary, _Imaginary_I, and I.
+#ifndef __cplusplus
+#define complex     _Complex
+#endif
+
+#define _Complex_I  (float _Complex){0, 1}
+#define imaginary   _Imaginary             // optional
+
+#ifdef imaginary
+#define _Imaginary_I ((float _Imaginary)1)
+#endif
+
+#ifdef imaginary
+#define I _Imaginary_I
+#else
+#define I _Complex_I
+#endif

 
 // ----------------------------------------------------------------------------
 // FUNCTIONS - C++
 
 // ----------------------------------------------------------------------------
 // FUNCTIONS - C++


@@ -22,27 +37,27 @@
 #ifdef __cplusplus
 
 // These functions return the absolute value (magnitude) of their parameter.
 #ifdef __cplusplus
 
 // These functions return the absolute value (magnitude) of their parameter.

-double               abs( double      _Complex   x );
-float                abs( float       _Complex   x );
-long double          abs( long double _Complex   x );
-double               fabs( double      _Complex  x );
-float                fabs( float       _Complex  x );
-long double          fabs( long double _Complex  x );
+double               abs( double      _Complex  x );
+float                abs( float       _Complex  x );
+long double          abs( long double _Complex  x );
+double               fabs( double      _Complex x );
+float                fabs( float       _Complex x );
+long double          fabs( long double _Complex x );

 
 // These functions return the sine of their parameter.
 
 // These functions return the sine of their parameter.

-double _Complex      sin( double _Complex        x );
-float _Complex       sin( float _Complex         x );
-long double _Complex sin( long double _Complex   x );
+double _Complex      sin( double _Complex      x );
+float _Complex       sin( float _Complex       x );
+long double _Complex sin( long double _Complex x );

 
 // These functions return the hyperbolic sine of their parameter.
 
 // These functions return the hyperbolic sine of their parameter.

-double _Complex      sinh( double _Complex       x );
-float _Complex       sinh( float _Complex        x );
-long double _Complex sinh( long double _Complex  x );
+double _Complex      sinh( double _Complex      x );
+float _Complex       sinh( float _Complex       x );
+long double _Complex sinh( long double _Complex x );

 
 // These functions return the arcsine of their parameter.
 
 // These functions return the arcsine of their parameter.

-double _Complex      asin( double _Complex       x );
-float _Complex       asin( float _Complex        x );
-long double _Complex asin( long double _Complex  x );
+double _Complex      asin( double _Complex      x );
+float _Complex       asin( float _Complex       x );
+long double _Complex asin( long double _Complex x );

 
 // These functions return the hyperbolic arcsine of their parameter.
 double _Complex      asinh( double _Complex      x );
 
 // These functions return the hyperbolic arcsine of their parameter.
 double _Complex      asinh( double _Complex      x );


@@ -50,19 +65,19 @@ float _Complex       asinh( float _Complex       x );
 long double _Complex asinh( long double _Complex x );
 
 // These functions return the cosine of their parameter.
 long double _Complex asinh( long double _Complex x );
 
 // These functions return the cosine of their parameter.

-double _Complex      cos( double _Complex        x );
-float _Complex       cos( float _Complex         x );
-long double _Complex cos( long double _Complex   x );
+double _Complex      cos( double _Complex      x );
+float _Complex       cos( float _Complex       x );
+long double _Complex cos( long double _Complex x );

 
 // These functions return the hyperbolic cosine of their parameter.
 
 // These functions return the hyperbolic cosine of their parameter.

-double _Complex      cosh( double _Complex       x );
-float _Complex       cosh( float _Complex        x );
-long double _Complex cosh( long double _Complex  x );
+double _Complex      cosh( double _Complex      x );
+float _Complex       cosh( float _Complex       x );
+long double _Complex cosh( long double _Complex x );

 
 // These functions return the arccosine of their parameter.
 
 // These functions return the arccosine of their parameter.

-double _Complex      acos( double      _Complex  x );
-float _Complex       acos( float       _Complex  x );
-long double _Complex acos( long double _Complex  x );
+double _Complex      acos( double      _Complex x );
+float _Complex       acos( float       _Complex x );
+long double _Complex acos( long double _Complex x );

 
 // These functions return the hyperbolic arccosine of their parameter.
 double _Complex      acosh( double      _Complex x );
 
 // These functions return the hyperbolic arccosine of their parameter.
 double _Complex      acosh( double      _Complex x );


@@ -70,19 +85,19 @@ float _Complex       acosh( float       _Complex x );
 long double _Complex acosh( long double _Complex x );
 
 // These functions return the tangent of their parameter.
 long double _Complex acosh( long double _Complex x );
 
 // These functions return the tangent of their parameter.

-double _Complex      tan( double _Complex        x );
-float _Complex       tan( float _Complex         x );
-long double _Complex tan( long double _Complex   x );
+double _Complex      tan( double _Complex      x );
+float _Complex       tan( float _Complex       x );
+long double _Complex tan( long double _Complex x );

 
 // These functions return the hyperbolic tangent of their parameter.
 
 // These functions return the hyperbolic tangent of their parameter.

-double _Complex      tanh( double _Complex       x );
-float _Complex       tanh( float _Complex        x );
-long double _Complex tanh( long double _Complex  x );
+double _Complex      tanh( double _Complex      x );
+float _Complex       tanh( float _Complex       x );
+long double _Complex tanh( long double _Complex x );

 
 // These functions return the arctangent of their parameter.
 
 // These functions return the arctangent of their parameter.

-double _Complex      atan( double _Complex       x );
-float _Complex       atan( float _Complex        x );
-long double _Complex atan( long double _Complex  x );
+double _Complex      atan( double _Complex      x );
+float _Complex       atan( float _Complex       x );
+long double _Complex atan( long double _Complex x );

 
 // These functions return the hyperbolic arctangent of their parameter.
 double _Complex      atanh( double _Complex      x );
 
 // These functions return the hyperbolic arctangent of their parameter.
 double _Complex      atanh( double _Complex      x );


@@ -103,39 +118,36 @@ long double          real( long double _Complex  x );
 float                creal( float _Complex       x );
 long double          creal( long double _Complex x );
 
 float                creal( float _Complex       x );
 long double          creal( long double _Complex x );
 

-// These functions return value^exponent.
-double _Complex      pow( double _Complex        value,
-                         double _Complex        exponent );
-float _Complex       pow( float _Complex         value,
-                         float _Complex         exponent );
-long double _Complex pow( long double _Complex   value,
-                         long double _Complex   exponent );
+// These functions return x^y.
+double _Complex      pow( double _Complex      x, double _Complex      y );
+float _Complex       pow( float _Complex       x, float _Complex       y );
+long double _Complex pow( long double _Complex x, long double _Complex y );

 
 // These functions return the square root of their parameter.
 
 // These functions return the square root of their parameter.

-double _Complex      sqrt( double _Complex       x );
-float _Complex       sqrt( float _Complex        x );
-long double _Complex sqrt( long double _Complex  x );
+double _Complex      sqrt( double _Complex      x );
+float _Complex       sqrt( float _Complex       x );
+long double _Complex sqrt( long double _Complex x );

 
 // These functions return the exponential of their parameter.
 
 // These functions return the exponential of their parameter.

-double _Complex      exp( double _Complex        x );
-float _Complex       exp( float _Complex         x );
-long double _Complex exp( long double _Complex   x );
+double _Complex      exp( double _Complex      x );
+float _Complex       exp( float _Complex       x );
+long double _Complex exp( long double _Complex x );

 
 // These functions return the logarithm of their parameter.
 
 // These functions return the logarithm of their parameter.

-double _Complex      log( double _Complex        x );
-float _Complex       log( float _Complex         x );
-long double _Complex log( long double _Complex   x );
+double _Complex      log( double _Complex      x );
+float _Complex       log( float _Complex       x );
+long double _Complex log( long double _Complex x );

 
 // These functions return the phase angle of their parameter.
 
 // These functions return the phase angle of their parameter.

-double               arg( double _Complex        x );
-float                arg( float _Complex         x );
-long double          arg( long double _Complex   x );
-float                carg( float _Complex        x );
-long double          carg( long double _Complex  x );
+double               arg( double _Complex       x );
+float                arg( float _Complex        x );
+long double          arg( long double _Complex  x );
+float                carg( float _Complex       x );
+long double          carg( long double _Complex x );

 
 // These functions return the conjugate of their parameter.
 
 // These functions return the conjugate of their parameter.

-float _Complex       conj( float _Complex        x );
-long double _Complex conj( long double _Complex  x );
+float _Complex       conj( float _Complex       x );
+long double _Complex conj( long double _Complex x );

 
 // These functions return the projection of their parameter.
 float _Complex       cproj( float _Complex       x );
 
 // These functions return the projection of their parameter.
 float _Complex       cproj( float _Complex       x );


@@ -147,24 +159,24 @@ long double _Complex cproj( long double _Complex x );
 // FUNCTIONS - Standard C
 
 // These functions return the absolute value (magnitude) of their parameter.
 // FUNCTIONS - Standard C
 
 // These functions return the absolute value (magnitude) of their parameter.

-double               cabs( double _Complex         x );
-float                cabsf( float _Complex         x );
-long double          cabsl( long double _Complex   x );
+double               cabs( double _Complex       x );
+float                cabsf( float _Complex       x );
+long double          cabsl( long double _Complex x );

 
 // These functions return the sine of their parameter.
 
 // These functions return the sine of their parameter.

-double _Complex      csin( double _Complex         x );
-float _Complex       csinf( float _Complex         x );
-long double _Complex csinl( long double _Complex   x );
+double _Complex      csin( double _Complex       x );
+float _Complex       csinf( float _Complex       x );
+long double _Complex csinl( long double _Complex x );

 
 // These functions return the hyperbolic sine of their parameter.
 
 // These functions return the hyperbolic sine of their parameter.

-double _Complex      csinh( double _Complex        x );
-float _Complex       csinhf( float _Complex        x );
-long double _Complex csinhl( long double _Complex  x );
+double _Complex      csinh( double _Complex       x );
+float _Complex       csinhf( float _Complex       x );
+long double _Complex csinhl( long double _Complex x );

 
 // These functions return the arcsine of their parameter.
 
 // These functions return the arcsine of their parameter.

-double _Complex      casin( double _Complex        x );
-float _Complex       casinf( float _Complex        x );
-long double _Complex casinl( long double _Complex  x );
+double _Complex      casin( double _Complex       x );
+float _Complex       casinf( float _Complex       x );
+long double _Complex casinl( long double _Complex x );

 
 // These functions return the hyperbolic arcsine of their parameter.
 double _Complex      casinh( double _Complex       x );
 
 // These functions return the hyperbolic arcsine of their parameter.
 double _Complex      casinh( double _Complex       x );


@@ -172,19 +184,19 @@ float _Complex       casinhf( float _Complex       x );
 long double _Complex casinhl( long double _Complex x );
 
 // These functions return the cosine of their parameter.
 long double _Complex casinhl( long double _Complex x );
 
 // These functions return the cosine of their parameter.

-double _Complex      ccos( double _Complex         x );
-float _Complex       ccosf( float _Complex         x );
-long double _Complex ccosl( long double _Complex   x );
+double _Complex      ccos( double _Complex       x );
+float _Complex       ccosf( float _Complex       x );
+long double _Complex ccosl( long double _Complex x );

 
 // These functions return the hyperbolic cosine of their parameter.
 
 // These functions return the hyperbolic cosine of their parameter.

-double _Complex      ccosh( double _Complex        x );
-float _Complex       ccoshf( float _Complex        x );
-long double _Complex ccoshl( long double _Complex  x );
+double _Complex      ccosh( double _Complex       x );
+float _Complex       ccoshf( float _Complex       x );
+long double _Complex ccoshl( long double _Complex x );

 
 // These functions return the arccosine of their parameter.
 
 // These functions return the arccosine of their parameter.

-double _Complex      cacos( double _Complex        x );
-float _Complex       cacosf( float _Complex        x );
-long double _Complex cacosl( long double _Complex  x );
+double _Complex      cacos( double _Complex       x );
+float _Complex       cacosf( float _Complex       x );
+long double _Complex cacosl( long double _Complex x );

 
 // These functions return the hyperbolic arccosine of their parameter.
 double _Complex      cacosh( double _Complex       x );
 
 // These functions return the hyperbolic arccosine of their parameter.
 double _Complex      cacosh( double _Complex       x );


@@ -192,19 +204,19 @@ float _Complex       cacoshf( float _Complex       x );
 long double _Complex cacoshl( long double _Complex x );
 
 // These functions return the tangent of their parameter.
 long double _Complex cacoshl( long double _Complex x );
 
 // These functions return the tangent of their parameter.

-double _Complex      ctan( double _Complex         x );
-float _Complex       ctanf( float _Complex         x );
-long double _Complex ctanl( long double _Complex   x );
+double _Complex      ctan( double _Complex       x );
+float _Complex       ctanf( float _Complex       x );
+long double _Complex ctanl( long double _Complex x );

 
 // These functions return the hyperbolic tangent of their parameter.
 
 // These functions return the hyperbolic tangent of their parameter.

-double _Complex      ctanh( double _Complex        x );
-float _Complex       ctanhf( float _Complex        x );
-long double _Complex ctanhl( long double _Complex  x );
+double _Complex      ctanh( double _Complex       x );
+float _Complex       ctanhf( float _Complex       x );
+long double _Complex ctanhl( long double _Complex x );

 
 // These functions return the arctangent of their parameter.
 
 // These functions return the arctangent of their parameter.

-double _Complex      catan( double _Complex        x );
-float _Complex       catanf( float _Complex        x );
-long double _Complex catanl( long double _Complex  x );
+double _Complex      catan( double _Complex       x );
+float _Complex       catanf( float _Complex       x );
+long double _Complex catanl( long double _Complex x );

 
 // These functions return the hyperbolic arctangent of their parameter.
 double _Complex      catanh( double _Complex       x );
 
 // These functions return the hyperbolic arctangent of their parameter.
 double _Complex      catanh( double _Complex       x );


@@ -212,51 +224,48 @@ float _Complex       catanhf( float _Complex       x );
 long double _Complex catanhl( long double _Complex x );
 
 // These functions return the imaginary part of their parameter.
 long double _Complex catanhl( long double _Complex x );
 
 // These functions return the imaginary part of their parameter.

-double               cimag( double _Complex        x );
-float                cimagf( float _Complex        x );
-long double          cimagl( long double _Complex  x );
+double               cimag( double _Complex       x );
+float                cimagf( float _Complex       x );
+long double          cimagl( long double _Complex x );

 
 // These functions return the real part of their parameter.
 
 // These functions return the real part of their parameter.

-double               creal( double _Complex        x );
-float                crealf( float _Complex        x );
-long double          creall( long double _Complex  x );
-
-// These functions return value^exponent.
-double _Complex      cpow( double _Complex         value,
-                          double _Complex         exponent );
-float _Complex       cpowf( float _Complex         value,
-                           float _Complex         exponent );
-long double _Complex cpowl( long double _Complex   value,
-                           long double _Complex   exponent );
+double               creal( double _Complex       x );
+float                crealf( float _Complex       x );
+long double          creall( long double _Complex x );
+
+// These functions return x^y.
+double _Complex      cpow( double _Complex       x, double _Complex      y );
+float _Complex       cpowf( float _Complex       x, float _Complex       y );
+long double _Complex cpowl( long double _Complex x, long double _Complex y );

 
 // These functions return the square root of their parameter.
 
 // These functions return the square root of their parameter.

-double _Complex      csqrt( double _Complex        x );
-float _Complex       csqrtf( float _Complex        x );
-long double _Complex csqrtl( long double _Complex  x );
+double _Complex      csqrt( double _Complex       x );
+float _Complex       csqrtf( float _Complex       x );
+long double _Complex csqrtl( long double _Complex x );

 
 // These functions return the exponential of their parameter.
 
 // These functions return the exponential of their parameter.

-double _Complex      cexp( double _Complex         x );
-float _Complex       cexpf( float _Complex         x );
-long double _Complex cexpl( long double _Complex   x );
+double _Complex      cexp( double _Complex       x );
+float _Complex       cexpf( float _Complex       x );
+long double _Complex cexpl( long double _Complex x );

 
 // These functions return the logarithm of their parameter.
 
 // These functions return the logarithm of their parameter.

-double _Complex      clog( double _Complex         x );
-float _Complex       clogf( float _Complex         x );
-long double _Complex clogl( long double _Complex   x );
+double _Complex      clog( double _Complex       x );
+float _Complex       clogf( float _Complex       x );
+long double _Complex clogl( long double _Complex x );

 
 // These functions return the phase angle of their value.
 
 // These functions return the phase angle of their value.

-double               carg( double _Complex         x );
-float                cargf( float _Complex         x );
-long double          cargl( long double _Complex   x );
+double               carg( double _Complex       x );
+float                cargf( float _Complex       x );
+long double          cargl( long double _Complex x );

 
 // These functions return the conjugate of their parameter.
 
 // These functions return the conjugate of their parameter.

-double _Complex      conj( double _Complex         x );
-float _Complex       conjf( float _Complex         x );
-long double _Complex conjl( long double _Complex   x );
+double _Complex      conj( double _Complex       x );
+float _Complex       conjf( float _Complex       x );
+long double _Complex conjl( long double _Complex x );

 
 // These functions return the projection of their parameter.
 
 // These functions return the projection of their parameter.

-double _Complex      cproj( double _Complex        x );
-float _Complex       cprojf( float _Complex        x );
-long double _Complex cprojl( long double _Complex  x );
+double _Complex      cproj( double _Complex       x );
+float _Complex       cprojf( float _Complex       x );
+long double _Complex cprojl( long double _Complex x );

 
 #endif // __COMPLEX_H
 
 #endif // __COMPLEX_H

diff --git a/includes/fenv.h b/includes/fenv.h
index 395e980cf38a6bfcbdceff0c0df6e1cb97766b46..09e770c61d0a942493138dde7a3aa91f53b5622c 100644 (file)
--- a/includes/fenv.h
+++ b/includes/fenv.h
@@ -10,6 +10,45 @@
 #ifndef __FENV_H
 #define __FENV_H __FENV_H
 
 #ifndef __FENV_H
 #define __FENV_H __FENV_H
 

-// TODO
+// ----------------------------------------------------------------------------
+// MACROS
+
+// Used
+#define FE_DIVBYZERO  // TODO
+#define FE_INEXACT    // TODO
+#define FE_INVALID    // TODO
+#define FE_OVERFLOW   // TODO
+#define FE_UNDERFLOW  // TODO
+#define FE_ALL_EXCEPT // TODO
+
+#define FE_DOWNWARD   // TODO
+#define FE_TONEAREST  // TODO
+#define FE_TOWARDZERO // TODO
+#define FE_UPWARD     // TODO
+
+#define FE_DFL_ENV    // TODO
+
+// ----------------------------------------------------------------------------
+// TYPEDEFS
+
+typedef fenv_t;    // TODO
+typedef fexcept_t; // TODO
+
+// ----------------------------------------------------------------------------
+// FUNCTIONS
+
+int feclearexcept( int exceptions );
+int fegetexceptflag( fexcept_t * flags, int exceptions );
+int feraiseexcept( int exceptions );
+int fesetexceptflag( const fexcept_t * flags, int exceptions );
+int fetestexcept( int exceptions );
+
+int fegetround( void );
+int fesetround( int mode );
+
+int fegetenv( fenv_t * environment );
+int feholdexcept( fenv_t * environment );
+int fesetenv( const fenv_t * environment );
+int feupdateenv( const fenv_t * environment );

 
 #endif // __FENV_H
 
 #endif // __FENV_H

diff --git a/includes/limits.h b/includes/limits.h
index 168b7b0c5ab9ee279662ef263d284a0f72b408fc..e8cc909c631706ded3efcb79e6b39cac99495489 100644 (file)
--- a/includes/limits.h
+++ b/includes/limits.h
@@ -10,6 +10,35 @@
 #ifndef __LIMITS_H
 #define __LIMITS_H __LIMITS_H
 
 #ifndef __LIMITS_H
 #define __LIMITS_H __LIMITS_H
 

-// TODO
+// Limits of type 'char'
+#define CHAR_BIT   // TODO
+#define CHAR_MAX   // TODO
+#define CHAR_MIN   // TODO
+#define SCHAR_MAX  // TODO
+#define SCHAR_MIN  // TODO
+#define UCHAR_MAX  // TODO
+
+// Multibyte characters
+#define MB_LEN_MAX // TODO
+
+// Limits of type 'short int'
+#define SHRT_MAX   // TODO
+#define SHRT_MIN   // TODO
+#define USHRT_MAX  // TODO
+
+// Limits of type 'int'
+#define INT_MAX    // TODO
+#define INT_MIN    // TODO
+#define UINT_MAX   // TODO
+
+// Limits of type 'long int'
+#define LONG_MAX   // TODO
+#define LONG_MIN   // TODO
+#define ULONG_MAX  // TODO
+
+// Limits of type 'long long int'
+#define LLONG_MAX  // TODO
+#define LLONG_MIN  // TODO
+#define ULLONG_MAX // TODO

 
 #endif // __LIMITS_H
 
 #endif // __LIMITS_H

diff --git a/includes/math.h b/includes/math.h
index 813f3c94d1e99a2403eeb519deb5b813eb1494df..f737c215d8975285bd19e76d6c062981f613fe86 100644 (file)
--- a/includes/math.h
+++ b/includes/math.h
@@ -40,27 +40,27 @@
 // --------------------------------------------------------------------------
 // TYPEDEFS
 
 // --------------------------------------------------------------------------
 // TYPEDEFS
 

-typedef f-type double_t; // TODO
-typedef f-type float_t;  // TODO
+typedef double_t; // TODO
+typedef float_t;  // TODO

 
 // --------------------------------------------------------------------------
 // MACROS
 
 #ifndef __cplusplus
 
 
 // --------------------------------------------------------------------------
 // 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
 
 
 #else // __cplusplus
 


@@ -107,504 +107,508 @@ bool isunordered( long double x, long double y );
 // --------------------------------------------------------------------------
 // FUNCTIONS - C++
 
 // --------------------------------------------------------------------------
 // FUNCTIONS - C++
 

+#ifdef __cplusplus
+

 // These functions return the magnitude of their parameter.
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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
 
 // 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.
 
 // 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.
 
 // 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
 
 // TODO

-float       cbrt(float       x);
-long double cbrt(long double x);
+float       cbrt( float       x );
+long double cbrt( long double x );

 
 // TODO
 
 // TODO

-float       exp(float       x);
-long double exp(long double x);
+float       exp( float       x );
+long double exp( long double x );

 
 // TODO
 
 // TODO

-float       exp2(float       x);
-long double exp2(long double x);
+float       exp2( float       x );
+long double exp2( long double x );

 
 // TODO
 
 // TODO

-float       expm1(float       x);
-long double expm1(long double x);
+float       expm1( float       x );
+long double expm1( long double x );

 
 // TODO
 
 // 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
 
 // 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.
 
 // 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
 
 // TODO

-float       logb(float       x);
-long double logb(long double x);
+float       logb( float       x );
+long double logb( long double x );

 
 // TODO
 
 // TODO

-int ilogb(float       x);
-int ilogb(long double x);
+int ilogb( float       x );
+int ilogb( long double x );

 
 // TODO
 
 // 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
 
 // 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.
 
 // 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
 
 // 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
 
 // 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.
 
 // 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
 
 // TODO

-float       erf(float       x);
-long double erf(long double x);
+float       erf( float       x );
+long double erf( long double x );

 
 // TODO
 
 // TODO

-float       erfc(float       x);
-long double erfc(long double x);
+float       erfc( float       x );
+long double erfc( long double x );

 
 // TODO
 
 // 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
 
 // 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.
 
 // 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.
 
 // 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
 
 // 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
 
 // 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
 
 // TODO

-float       trunc(float       x);
-long double trunc(long double x);
+float       trunc( float       x );
+long double trunc( long double x );

 
 // TODO
 
 // TODO

-float       nearbyint(float       x);
-long double nearbyint(long double x);
+float       nearbyint( float       x );
+long double nearbyint( long double x );

 
 // TODO
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // TODO

-float       lgamma(float       x);
-long double lgamma(long double x);
+float       lgamma( float       x );
+long double lgamma( long double x );

 
 // TODO
 
 // 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.
 
 // ----------------------------------------------------------------------------
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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.
 
 // 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
 
 // 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.
 
 // 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.
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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.
 
 // 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
 
 // 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
 
 // 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
 
 // 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.
 
 // 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.
 
 // 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
 
 // 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
 
 // 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.
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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.
 
 // 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.
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 // 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
 
 #endif // __MATH_H

diff --git a/includes/signal.h b/includes/signal.h
index 21f70e40e0a020d2254f2a7cbcaaa1a9b560efa0..36b073e012ebab90e6c012ff51f292541bb26b0d 100644 (file)
--- a/includes/signal.h
+++ b/includes/signal.h
@@ -10,6 +10,28 @@
 #ifndef __SIGNAL_H
 #define __SIGNAL_H __SIGNAL_H
 
 #ifndef __SIGNAL_H
 #define __SIGNAL_H __SIGNAL_H
 

-// TODO
+// ----------------------------------------------------------------------------
+// MACROS
+
+#define SIGABRT // TODO
+#define SIGFPE  // TODO
+#define SIGILL  // TODO
+#define SIGINT  // TODO
+#define SIGSEGV // TODO
+#define SIGTERM // TODO
+#define SIG_DFL // TODO
+#define SIG_ERR // TODO
+#define SIG_IGN // TODO
+
+// ----------------------------------------------------------------------------
+// TYPEDEFS
+
+typedef sig_atomic_t; // TODO
+
+// ----------------------------------------------------------------------------
+// FUNCTIONS
+
+int raise( int sig );                                        // TODO
+void ( * signal( int sig, void ( *func )( int ) ) ) ( int ); // TODO

 
 #endif // __SIGNAL_H
 
 #endif // __SIGNAL_H

diff --git a/includes/stdarg.h b/includes/stdarg.h
index ab5529aa2b3527d108f8caebf90cc2b86fca93f5..6afedec46d83f1702465a1bbb06584764f97129d 100644 (file)
--- a/includes/stdarg.h
+++ b/includes/stdarg.h
@@ -10,6 +10,17 @@
 #ifndef __STDARG_H
 #define __STDARG_H __STDARG_H
 
 #ifndef __STDARG_H
 #define __STDARG_H __STDARG_H
 

-// TODO
+// ----------------------------------------------------------------------------
+// TYPEDEFS
+
+typedef do-type va_list;
+
+// ----------------------------------------------------------------------------
+// MACROS
+
+#define va_arg( va_list ap, Ty )             // TODO
+#define va_copy( va_list dest, va_list src ) // TODO
+#define va_end( va_list ap )                 // TODO
+#define va_start( va_list ap, last-par )     // TODO

 
 #endif // __STDARG_H
 
 #endif // __STDARG_H

diff --git a/includes/stdbool.h b/includes/stdbool.h
index 734a52dd99733fde260901db7ad395f2306fd3bf..7f58ab7bb029ffe88f22a7547150c847572d2670 100644 (file)
--- a/includes/stdbool.h
+++ b/includes/stdbool.h
@@ -10,6 +10,22 @@
 #ifndef __STDBOOL_H
 #define __STDBOOL_H __STDBOOL_H
 
 #ifndef __STDBOOL_H
 #define __STDBOOL_H __STDBOOL_H
 

-// TODO
+// ----------------------------------------------------------------------------
+// MACROS
+
+#define __bool_true_false_are_defined 1
+
+#ifndef __cplusplus
+
+#define bool  _Bool
+#define false 0
+#define true  1
+
+// ----------------------------------------------------------------------------
+// TYPEDEFS
+
+typedef int bool;
+
+#endif // __cplusplus

 
 #endif // __STDBOOL_H
 
 #endif // __STDBOOL_H

diff --git a/includes/stddef.h b/includes/stddef.h
index 2147696986334d4dfa05274be8497f82eaece197..d72ca71cbad171877eb9e12db368e790d1afa6b4 100644 (file)
--- a/includes/stddef.h
+++ b/includes/stddef.h
@@ -10,6 +10,20 @@
 #ifndef __STDDEF_H
 #define __STDDEF_H __STDDEF_H
 
 #ifndef __STDDEF_H
 #define __STDDEF_H __STDDEF_H
 

-// TODO
+// ----------------------------------------------------------------------------
+// MACROS
+
+#define NULL  0
+#define offsetof( s-type, mbr ) // TODO
+
+// ----------------------------------------------------------------------------
+// TYPEDEFS
+
+typedef ptrdiff_t; // TODO
+typedef size_t;    // TODO
+
+#ifndef __cplusplus
+typedef wchar_t;
+#endif // __cplusplus

 
 #endif // __STDDEF_H
 
 #endif // __STDDEF_H