Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision cdbfab0d9666b55e218af2f33951428230e8b826)
+++ src/libcfa/stdlib	(revision d9ff69a257799a84e1981ca54516cbb2515e27cd)
@@ -10,9 +10,12 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Oct 31 13:47:24 2017
-// Update Count     : 245
+// Last Modified On : Sat Dec 23 18:21:42 2017
+// Update Count     : 267
 //
 
 #pragma once
+
+//#define _XOPEN_SOURCE 600								// posix_memalign, *rand48
+#include <stdlib.h>										// strto*, *abs
 
 //---------------------------------------
@@ -77,5 +80,5 @@
 	//printf( "X8\n" );
 	T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );	// C malloc
-    return (T *)memset( ptr, (int)fill, sizeof(T) );			// initial with fill value
+    return (T *)memset( ptr, (int)fill, sizeof(T) );	// initial with fill value
 } // alloc
 
@@ -150,29 +153,33 @@
 //---------------------------------------
 
-int ato( const char * ptr );
-unsigned int ato( const char * ptr );
-long int ato( const char * ptr );
-unsigned long int ato( const char * ptr );
-long long int ato( const char * ptr );
-unsigned long long int ato( const char * ptr );
-float ato( const char * ptr );
-double ato( const char * ptr );
-long double ato( const char * ptr );
-float _Complex ato( const char * ptr );
-double _Complex ato( const char * ptr );
-long double _Complex ato( const char * ptr );
-
-int strto( const char * sptr, char ** eptr, int base );
-unsigned int strto( const char * sptr, char ** eptr, int base );
-long int strto( const char * sptr, char ** eptr, int base );
-unsigned long int strto( const char * sptr, char ** eptr, int base );
-long long int strto( const char * sptr, char ** eptr, int base );
-unsigned long long int strto( const char * sptr, char ** eptr, int base );
-float strto( const char * sptr, char ** eptr );
-double strto( const char * sptr, char ** eptr );
-long double strto( const char * sptr, char ** eptr );
+static inline int strto( const char * sptr, char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
+static inline unsigned int strto( const char * sptr, char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
+static inline long int strto( const char * sptr, char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
+static inline unsigned long int strto( const char * sptr, char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
+static inline long long int strto( const char * sptr, char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
+static inline unsigned long long int strto( const char * sptr, char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
+
+static inline float strto( const char * sptr, char ** eptr ) { return strtof( sptr, eptr ); }
+static inline double strto( const char * sptr, char ** eptr ) { return strtod( sptr, eptr ); }
+static inline long double strto( const char * sptr, char ** eptr ) { return strtold( sptr, eptr ); }
+
 float _Complex strto( const char * sptr, char ** eptr );
 double _Complex strto( const char * sptr, char ** eptr );
 long double _Complex strto( const char * sptr, char ** eptr );
+
+static inline int ato( const char * sptr ) {return (int)strtol( sptr, 0, 10 ); }
+static inline unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0, 10 ); }
+static inline long int ato( const char * sptr ) { return strtol( sptr, 0, 10 ); }
+static inline unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0, 10 ); }
+static inline long long int ato( const char * sptr ) { return strtoll( sptr, 0, 10 ); }
+static inline unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0, 10 ); }
+
+static inline float ato( const char * sptr ) { return strtof( sptr, 0 ); }
+static inline double ato( const char * sptr ) { return strtod( sptr, 0 ); }
+static inline long double ato( const char * sptr ) { return strtold( sptr, 0 ); }
+
+static inline float _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
+static inline double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
+static inline long double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
 
 //---------------------------------------
@@ -198,14 +205,27 @@
 //---------------------------------------
 
-unsigned char abs( signed char );
+static inline unsigned char abs( signed char v ) { return abs( (int)v ); }
 extern "C" { int abs( int ); }							// use default C routine for int
-unsigned long int abs( long int );
-unsigned long long int abs( long long int );
-float abs( float );
-double abs( double );
-long double abs( long double );
-float abs( float _Complex );
-double abs( double _Complex );
-long double abs( long double _Complex );
+static inline unsigned long int abs( long int v ) { return labs( v ); }
+static inline unsigned long long int abs( long long int v ) { return llabs( v ); }
+
+extern "C" {
+double fabs( double );
+float fabsf( float );
+long double fabsl( long double );
+} // extern "C"
+static inline float abs( float x ) { return fabsf( x ); }
+static inline double abs( double x ) { return fabs( x ); }
+static inline long double abs( long double x ) { return fabsl( x ); }
+
+extern "C" {
+double cabs( double _Complex );
+float cabsf( float _Complex );
+long double cabsl( long double _Complex );
+} // extern "C"
+static inline float abs( float _Complex x ) { return cabsf( x ); }
+static inline double abs( double _Complex x ) { return cabs( x ); }
+static inline long double abs( long double _Complex x ) { return cabsl( x ); }
+
 forall( otype T | { void ?{}( T &, zero_t ); int ?<?( T, T ); T -?( T ); } )
 T abs( T );
@@ -215,10 +235,15 @@
 void random_seed( long int s );
 char random( void );
+char random( char u );
 char random( char l, char u );
 int random( void );
+int random( int u );
+int random( int l, int u );
 unsigned int random( void );
 unsigned int random( unsigned int u );
 unsigned int random( unsigned int l, unsigned int u );
-//long int random( void );
+extern "C" { long int random( void ); }
+long int random( long int u );
+long int random( long int l, long int u );
 unsigned long int random( void );
 unsigned long int random( unsigned long int u );
@@ -233,14 +258,14 @@
 
 forall( otype T | { int ?<?( T, T ); } )
-T min( T t1, T t2 );
+static inline T min( T t1, T t2 ) { return t1 < t2 ? t1 : t2; }
 
 forall( otype T | { int ?>?( T, T ); } )
-T max( T t1, T t2 );
+static inline T max( T t1, T t2 ) { return t1 > t2 ? t1 : t2; }
 
 forall( otype T | { T min( T, T ); T max( T, T ); } )
-T clamp( T value, T min_val, T max_val );
+static inline T clamp( T value, T min_val, T max_val ) { return max( min_val, min( value, max_val ) ); }
 
 forall( otype T )
-void swap( T & t1, T & t2 );
+static inline void swap( T & v1, T & v2 ) { T temp = v1; v1 = v2; v2 = temp; }
 
 // Local Variables: //