Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision 1e6e08def6857d020506ed387a2bc1a3571988f3)
+++ src/libcfa/stdlib	(revision e672372dcffd6ac8335882a71d5b294e036bda92)
@@ -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: //
Index: src/libcfa/stdlib.c
===================================================================
--- src/libcfa/stdlib.c	(revision 1e6e08def6857d020506ed387a2bc1a3571988f3)
+++ src/libcfa/stdlib.c	(revision e672372dcffd6ac8335882a71d5b294e036bda92)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Oct 30 22:43:02 2017
-// Update Count     : 297
+// Last Modified On : Sun Dec 24 13:00:15 2017
+// Update Count     : 344
 //
 
@@ -19,9 +19,9 @@
 
 #define _XOPEN_SOURCE 600								// posix_memalign, *rand48
-#include <stdlib.h>										// malloc, free, calloc, realloc, memalign, posix_memalign, bsearch
 #include <string.h>										// memcpy, memset
 #include <malloc.h>										// malloc_usable_size
 #include <math.h>										// fabsf, fabs, fabsl
 #include <complex.h>									// _Complex_I
+#include <assert.h>
 
 // resize, non-array types
@@ -93,123 +93,12 @@
 //---------------------------------------
 
-int ato( const char * ptr ) {
-	int i;
-	if ( sscanf( ptr, "%d", &i ) == EOF ) {}
-	return i;
-} // ato
-
-unsigned int ato( const char * ptr ) {
-	unsigned int ui;
-	if ( sscanf( ptr, "%u", &ui ) == EOF ) {}
-	return ui;
-} // ato
-
-long int ato( const char * ptr ) {
-	long int li;
-	if ( sscanf( ptr, "%ld", &li ) == EOF ) {}
-	return li;
-} // ato
-
-unsigned long int ato( const char * ptr ) {
-	unsigned long int uli;
-	if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}
-	return uli;
-} // ato
-
-long long int ato( const char * ptr ) {
-	long long int lli;
-	if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}
-	return lli;
-} // ato
-
-unsigned long long int ato( const char * ptr ) {
-	unsigned long long int ulli;
-	if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}
-	return ulli;
-} // ato
-
-
-float ato( const char * ptr ) {
-	float f;
-	if ( sscanf( ptr, "%f", &f ) == EOF ) {}
-	return f;
-} // ato
-
-double ato( const char * ptr ) {
-	double d;
-	if ( sscanf( ptr, "%lf", &d ) == EOF ) {}
-	return d;
-} // ato
-
-long double ato( const char * ptr ) {
-	long double ld;
-	if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}
-	return ld;
-} // ato
-
-
-float _Complex ato( const char * ptr ) {
-	float re, im;
-	if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}
-	return re + im * _Complex_I;
-} // ato
-
-double _Complex ato( const char * ptr ) {
-	double re, im;
-	if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {}
-	return re + im * _Complex_I;
-} // ato
-
-long double _Complex ato( const char * ptr ) {
-	long double re, im;
-	if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}
-	return re + im * _Complex_I;
-} // ato
-
-
-int strto( const char * sptr, char ** eptr, int base ) {
-	return (int)strtol( sptr, eptr, base );
-} // strto
-
-unsigned int strto( const char * sptr, char ** eptr, int base ) {
-	return (unsigned int)strtoul( sptr, eptr, base );
-} // strto
-
-long int strto( const char * sptr, char ** eptr, int base ) {
-	return strtol( sptr, eptr, base );
-} // strto
-
-unsigned long int strto( const char * sptr, char ** eptr, int base ) {
-	return strtoul( sptr, eptr, base );
-} // strto
-
-long long int strto( const char * sptr, char ** eptr, int base ) {
-	return strtoll( sptr, eptr, base );
-} // strto
-
-unsigned long long int strto( const char * sptr, char ** eptr, int base ) {
-	return strtoull( sptr, eptr, base );
-} // strto
-
-
-float strto( const char * sptr, char ** eptr ) {
-	return strtof( sptr, eptr );
-} // strto
-
-double strto( const char * sptr, char ** eptr ) {
-	return strtod( sptr, eptr );
-} // strto
-
-long double strto( const char * sptr, char ** eptr ) {
-	return strtold( sptr, eptr );
-} // strto
-
-
 float _Complex strto( const char * sptr, char ** eptr ) {
 	float re, im;
-	re = strtof( sptr, eptr );
-	if ( sptr == *eptr ) return 0.0;
-	im = strtof( sptr, eptr );
-	if ( sptr == *eptr ) return 0.0;
+	char * eeptr;
+	re = strtof( sptr, &eeptr );
+	if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
+	im = strtof( eeptr, &eeptr );
+	if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
+	if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
 	return re + im * _Complex_I;
 } // strto
@@ -217,8 +106,10 @@
 double _Complex strto( const char * sptr, char ** eptr ) {
 	double re, im;
-	re = strtod( sptr, eptr );
-	if ( sptr == *eptr ) return 0.0;
-	im = strtod( sptr, eptr );
-	if ( sptr == *eptr ) return 0.0;
+	char * eeptr;
+	re = strtod( sptr, &eeptr );
+	if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
+	im = strtod( eeptr, &eeptr );
+	if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
+	if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
 	return re + im * _Complex_I;
 } // strto
@@ -226,8 +117,10 @@
 long double _Complex strto( const char * sptr, char ** eptr ) {
 	long double re, im;
-	re = strtold( sptr, eptr );
-	if ( sptr == *eptr ) return 0.0;
-	im = strtold( sptr, eptr );
-	if ( sptr == *eptr ) return 0.0;
+	char * eeptr;
+	re = strtold( sptr, &eeptr );
+	if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
+	im = strtold( eeptr, &eeptr );
+	if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
+	if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
 	return re + im * _Complex_I;
 } // strto
@@ -243,5 +136,5 @@
 forall( otype T | { int ?<?( T, T ); } )
 unsigned int bsearch( T key, const T * arr, size_t dim ) {
-	T *result = bsearch( key, arr, dim );
+	T * result = bsearch( key, arr, dim );
 	return result ? result - arr : dim;					// pointer subtraction includes sizeof(T)
 } // bsearch
@@ -263,56 +156,26 @@
 //---------------------------------------
 
-unsigned char abs( signed char v ) { return abs( (int)v ); }
-unsigned long int abs( long int v ) { return labs( v ); }
-unsigned long long int abs( long long int v ) { return llabs( v ); }
-float abs( float x ) { return fabsf( x ); }
-double abs( double x ) { return fabs( x ); }
-long double abs( long double x ) { return fabsl( x ); }
-float abs( float _Complex x ) { return cabsf( x ); }
-double abs( double _Complex x ) { return cabs( x ); }
-long double abs( long double _Complex x ) { return cabsl( x ); }
-
-//---------------------------------------
-
-void random_seed( long int s ) { srand48( s ); }
-char random( void ) { return mrand48(); }
-char random( char l, char u ) { return lrand48() % (u - l) + l; }
-int random( void ) { return mrand48(); }
-unsigned int random( void ) { return lrand48(); }
-unsigned int random( unsigned int u ) { return lrand48() % u; }
-unsigned int random( unsigned int l, unsigned int u ) { return lrand48() % (u - l) + l; }
-//long int random( void ) { return mrand48(); }
+void random_seed( long int s ) { srand48( s ); srandom( s ); } // call srandom to harmonize with C-lib random
+char random( void ) { return (unsigned long int)random(); }
+char random( char u ) { return random( (unsigned long int)u ); }
+char random( char l, char u ) { return random( (unsigned long int)l, (unsigned long int)u ); }
+int random( void ) { return (long int)random(); }
+int random( int u ) { return random( (long int)u ); }
+int random( int l, int u ) { return random( (long int)l, (long int)u ); }
+unsigned int random( void ) { return (unsigned long int)random(); }
+unsigned int random( unsigned int u ) { return random( (unsigned long int)u ); }
+unsigned int random( unsigned int l, unsigned int u ) { return random( (unsigned long int)l, (unsigned long int)u ); }
+//extern "C" { long int random() { return mrand48(); } }
+long int random( long int u ) { if ( u < 0 ) return random( u, 0 ); else return random( 0, u ); }
+long int random( long int l, long int u ) { assert( l < u ); return lrand48() % (u - l) + l; }
 unsigned long int random( void ) { return lrand48(); }
 unsigned long int random( unsigned long int u ) { return lrand48() % u; }
-unsigned long int random( unsigned long int l, unsigned long int u ) { return lrand48() % (u - l) + l; }
-float random( void ) { return (float)drand48(); }		// otherwise float uses lrand48
+unsigned long int random( unsigned long int l, unsigned long int u ) { assert( l < u ); return lrand48() % (u - l) + l; }
+float random( void ) { return (float)drand48(); }		// cast otherwise float uses lrand48
 double random( void ) { return drand48(); }
 float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
 double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
-long double _Complex random( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
+long double _Complex random( void ) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
 
-//---------------------------------------
-
-forall( otype T | { int ?<?( T, T ); } )
-T min( T t1, T t2 ) {
-	return t1 < t2 ? t1 : t2;
-} // min
-
-forall( otype T | { int ?>?( T, T ); } )
-T max( T t1, T t2 ) {
-	return t1 > t2 ? t1 : t2;
-} // max
-
-forall( otype T | { T min( T, T ); T max( T, T ); } )
-T clamp( T value, T min_val, T max_val ) {
-	return max( min_val, min( value, max_val ) );
-} // clamp
-
-forall( otype T )
-void swap( T & t1, T & t2 ) {
-	T temp = t1;
-	t1 = t2;
-	t2 = temp;
-} // swap
 
 // Local Variables: //