Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/stdlib.c

    r54aba8d r70e4895d  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jan  2 12:20:32 2018
    13 // Update Count     : 441
     12// Last Modified On : Mon Oct 30 22:43:02 2017
     13// Update Count     : 297
    1414//
    1515
    … …  
    1919
    2020#define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
     21#include <stdlib.h>                                                                             // malloc, free, calloc, realloc, memalign, posix_memalign, bsearch
    2122#include <string.h>                                                                             // memcpy, memset
    2223#include <malloc.h>                                                                             // malloc_usable_size
    2324#include <math.h>                                                                               // fabsf, fabs, fabsl
    2425#include <complex.h>                                                                    // _Complex_I
    25 #include <assert.h>
    2626
    2727// resize, non-array types
    … …  
    9393//---------------------------------------
    9494
     95int ato( const char * ptr ) {
     96        int i;
     97        if ( sscanf( ptr, "%d", &i ) == EOF ) {}
     98        return i;
     99} // ato
     100
     101unsigned int ato( const char * ptr ) {
     102        unsigned int ui;
     103        if ( sscanf( ptr, "%u", &ui ) == EOF ) {}
     104        return ui;
     105} // ato
     106
     107long int ato( const char * ptr ) {
     108        long int li;
     109        if ( sscanf( ptr, "%ld", &li ) == EOF ) {}
     110        return li;
     111} // ato
     112
     113unsigned long int ato( const char * ptr ) {
     114        unsigned long int uli;
     115        if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}
     116        return uli;
     117} // ato
     118
     119long long int ato( const char * ptr ) {
     120        long long int lli;
     121        if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}
     122        return lli;
     123} // ato
     124
     125unsigned long long int ato( const char * ptr ) {
     126        unsigned long long int ulli;
     127        if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}
     128        return ulli;
     129} // ato
     130
     131
     132float ato( const char * ptr ) {
     133        float f;
     134        if ( sscanf( ptr, "%f", &f ) == EOF ) {}
     135        return f;
     136} // ato
     137
     138double ato( const char * ptr ) {
     139        double d;
     140        if ( sscanf( ptr, "%lf", &d ) == EOF ) {}
     141        return d;
     142} // ato
     143
     144long double ato( const char * ptr ) {
     145        long double ld;
     146        if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}
     147        return ld;
     148} // ato
     149
     150
     151float _Complex ato( const char * ptr ) {
     152        float re, im;
     153        if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}
     154        return re + im * _Complex_I;
     155} // ato
     156
     157double _Complex ato( const char * ptr ) {
     158        double re, im;
     159        if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {}
     160        return re + im * _Complex_I;
     161} // ato
     162
     163long double _Complex ato( const char * ptr ) {
     164        long double re, im;
     165        if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}
     166        return re + im * _Complex_I;
     167} // ato
     168
     169
     170int strto( const char * sptr, char ** eptr, int base ) {
     171        return (int)strtol( sptr, eptr, base );
     172} // strto
     173
     174unsigned int strto( const char * sptr, char ** eptr, int base ) {
     175        return (unsigned int)strtoul( sptr, eptr, base );
     176} // strto
     177
     178long int strto( const char * sptr, char ** eptr, int base ) {
     179        return strtol( sptr, eptr, base );
     180} // strto
     181
     182unsigned long int strto( const char * sptr, char ** eptr, int base ) {
     183        return strtoul( sptr, eptr, base );
     184} // strto
     185
     186long long int strto( const char * sptr, char ** eptr, int base ) {
     187        return strtoll( sptr, eptr, base );
     188} // strto
     189
     190unsigned long long int strto( const char * sptr, char ** eptr, int base ) {
     191        return strtoull( sptr, eptr, base );
     192} // strto
     193
     194
     195float strto( const char * sptr, char ** eptr ) {
     196        return strtof( sptr, eptr );
     197} // strto
     198
     199double strto( const char * sptr, char ** eptr ) {
     200        return strtod( sptr, eptr );
     201} // strto
     202
     203long double strto( const char * sptr, char ** eptr ) {
     204        return strtold( sptr, eptr );
     205} // strto
     206
     207
    95208float _Complex strto( const char * sptr, char ** eptr ) {
    96209        float re, im;
    97         char * eeptr;
    98         re = strtof( sptr, &eeptr );
    99         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
    100         im = strtof( eeptr, &eeptr );
    101         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
    102         if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
     210        re = strtof( sptr, eptr );
     211        if ( sptr == *eptr ) return 0.0;
     212        im = strtof( sptr, eptr );
     213        if ( sptr == *eptr ) return 0.0;
    103214        return re + im * _Complex_I;
    104215} // strto
    … …  
    106217double _Complex strto( const char * sptr, char ** eptr ) {
    107218        double re, im;
    108         char * eeptr;
    109         re = strtod( sptr, &eeptr );
    110         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
    111         im = strtod( eeptr, &eeptr );
    112         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
    113         if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
     219        re = strtod( sptr, eptr );
     220        if ( sptr == *eptr ) return 0.0;
     221        im = strtod( sptr, eptr );
     222        if ( sptr == *eptr ) return 0.0;
    114223        return re + im * _Complex_I;
    115224} // strto
    … …  
    117226long double _Complex strto( const char * sptr, char ** eptr ) {
    118227        long double re, im;
    119         char * eeptr;
    120         re = strtold( sptr, &eeptr );
    121         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
    122         im = strtold( eeptr, &eeptr );
    123         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
    124         if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
    125         return re + im * _Complex_I;
    126 } // strto
    127 
    128 //---------------------------------------
    129 
    130 forall( otype E | { int ?<?( E, E ); } )
    131 E * bsearch( E key, const E * vals, size_t dim ) {
    132         int cmp( const void * t1, const void * t2 ) {
    133                 return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
    134         } // cmp
    135         return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
     228        re = strtold( sptr, eptr );
     229        if ( sptr == *eptr ) return 0.0;
     230        im = strtold( sptr, eptr );
     231        if ( sptr == *eptr ) return 0.0;
     232        return re + im * _Complex_I;
     233} // strto
     234
     235//---------------------------------------
     236
     237forall( otype T | { int ?<?( T, T ); } )
     238T * bsearch( T key, const T * arr, size_t dim ) {
     239        int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
     240        return (T *)bsearch( &key, arr, dim, sizeof(T), comp );
    136241} // bsearch
    137242
    138 forall( otype E | { int ?<?( E, E ); } )
    139 size_t bsearch( E key, const E * vals, size_t dim ) {
    140         E * result = bsearch( key, vals, dim );
    141         return result ? result - vals : dim;                            // pointer subtraction includes sizeof(E)
     243forall( otype T | { int ?<?( T, T ); } )
     244unsigned int bsearch( T key, const T * arr, size_t dim ) {
     245        T *result = bsearch( key, arr, dim );
     246        return result ? result - arr : dim;                                     // pointer subtraction includes sizeof(T)
    142247} // bsearch
    143248
    144 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    145 E * bsearch( K key, const E * vals, size_t dim ) {
    146         int cmp( const void * t1, const void * t2 ) {
    147                 return *(K *)t1 < getKey( *(E *)t2 ) ? -1 : getKey( *(E *)t2 ) < *(K *)t1 ? 1 : 0;
    148         } // cmp
    149         return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
    150 } // bsearch
    151 
    152 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    153 size_t bsearch( K key, const E * vals, size_t dim ) {
    154         E * result = bsearch( key, vals, dim );
    155         return result ? result - vals : dim;                            // pointer subtraction includes sizeof(E)
    156 } // bsearch
    157 
    158 
    159 forall( otype E | { int ?<?( E, E ); } )
    160 size_t bsearchl( E key, const E * vals, size_t dim ) {
    161         size_t l = 0, m, h = dim;
    162         while ( l < h ) {
    163                 m = (l + h) / 2;
    164                 if ( (E &)(vals[m]) < key ) {                                   // cast away const
    165                         l = m + 1;
    166                 } else {
    167                         h = m;
    168                 } // if
    169         } // while
    170         return l;
    171 } // bsearchl
    172 
    173 forall( otype E | { int ?<?( E, E ); } )
    174 E * bsearchl( E key, const E * vals, size_t dim ) {
    175         size_t posn = bsearchl( key, vals, dim );
    176         return (E *)(&vals[posn]);                                                      // cast away const
    177 } // bsearchl
    178 
    179 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    180 size_t bsearchl( K key, const E * vals, size_t dim ) {
    181         size_t l = 0, m, h = dim;
    182         while ( l < h ) {
    183                 m = (l + h) / 2;
    184                 if ( getKey( vals[m] ) < key ) {
    185                         l = m + 1;
    186                 } else {
    187                         h = m;
    188                 } // if
    189         } // while
    190         return l;
    191 } // bsearchl
    192 
    193 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    194 E * bsearchl( K key, const E * vals, size_t dim ) {
    195         size_t posn = bsearchl( key, vals, dim );
    196         return (E *)(&vals[posn]);                                                      // cast away const
    197 } // bsearchl
    198 
    199 
    200 forall( otype E | { int ?<?( E, E ); } )
    201 size_t bsearchu( E key, const E * vals, size_t dim ) {
    202         size_t l = 0, m, h = dim;
    203         while ( l < h ) {
    204                 m = (l + h) / 2;
    205                 if ( ! ( key < (E &)(vals[m]) ) ) {                             // cast away const
    206                         l = m + 1;
    207                 } else {
    208                         h = m;
    209                 } // if
    210         } // while
    211         return l;
    212 } // bsearchu
    213 
    214 forall( otype E | { int ?<?( E, E ); } )
    215 E * bsearchu( E key, const E * vals, size_t dim ) {
    216         size_t posn = bsearchu( key, vals, dim );
    217         return (E *)(&vals[posn]);
    218 } // bsearchu
    219 
    220 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    221 size_t bsearchu( K key, const E * vals, size_t dim ) {
    222         size_t l = 0, m, h = dim;
    223         while ( l < h ) {
    224                 m = (l + h) / 2;
    225                 if ( ! ( key < getKey( vals[m] ) ) ) {
    226                         l = m + 1;
    227                 } else {
    228                         h = m;
    229                 } // if
    230         } // while
    231         return l;
    232 } // bsearchu
    233 
    234 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
    235 E * bsearchu( K key, const E * vals, size_t dim ) {
    236         size_t posn = bsearchu( key, vals, dim );
    237         return (E *)(&vals[posn]);
    238 } // bsearchu
    239 
    240 
    241 forall( otype E | { int ?<?( E, E ); } )
    242 void qsort( E * vals, size_t dim ) {
    243         int cmp( const void * t1, const void * t2 ) {
    244                 return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
    245         } // cmp
    246         qsort( vals, dim, sizeof(E), cmp );
     249forall( otype T | { int ?<?( T, T ); } )
     250void qsort( const T * arr, size_t dim ) {
     251        int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
     252        qsort( arr, dim, sizeof(T), comp );
    247253} // qsort
    248254
    … …  
    257263//---------------------------------------
    258264
    259 extern "C" { void srandom( unsigned int seed ) { srand48( seed ); } } // override C version
    260 char random( void ) { return (unsigned long int)random(); }
    261 char random( char u ) { return random( (unsigned long int)u ); }
    262 char random( char l, char u ) { return random( (unsigned long int)l, (unsigned long int)u ); }
    263 int random( void ) { return (long int)random(); }
    264 int random( int u ) { return random( (long int)u ); }
    265 int random( int l, int u ) { return random( (long int)l, (long int)u ); }
    266 unsigned int random( void ) { return (unsigned long int)random(); }
    267 unsigned int random( unsigned int u ) { return random( (unsigned long int)u ); }
    268 unsigned int random( unsigned int l, unsigned int u ) { return random( (unsigned long int)l, (unsigned long int)u ); }
    269 extern "C" { long int random( void ) { return mrand48(); } } // override C version
    270 long int random( long int u ) { if ( u < 0 ) return random( u, 0 ); else return random( 0, u ); }
    271 long int random( long int l, long int u ) { assert( l < u ); return lrand48() % (u - l) + l; }
     265unsigned char abs( signed char v ) { return abs( (int)v ); }
     266unsigned long int abs( long int v ) { return labs( v ); }
     267unsigned long long int abs( long long int v ) { return llabs( v ); }
     268float abs( float x ) { return fabsf( x ); }
     269double abs( double x ) { return fabs( x ); }
     270long double abs( long double x ) { return fabsl( x ); }
     271float abs( float _Complex x ) { return cabsf( x ); }
     272double abs( double _Complex x ) { return cabs( x ); }
     273long double abs( long double _Complex x ) { return cabsl( x ); }
     274
     275//---------------------------------------
     276
     277void random_seed( long int s ) { srand48( s ); }
     278char random( void ) { return mrand48(); }
     279char random( char l, char u ) { return lrand48() % (u - l) + l; }
     280int random( void ) { return mrand48(); }
     281unsigned int random( void ) { return lrand48(); }
     282unsigned int random( unsigned int u ) { return lrand48() % u; }
     283unsigned int random( unsigned int l, unsigned int u ) { return lrand48() % (u - l) + l; }
     284//long int random( void ) { return mrand48(); }
    272285unsigned long int random( void ) { return lrand48(); }
    273286unsigned long int random( unsigned long int u ) { return lrand48() % u; }
    274 unsigned long int random( unsigned long int l, unsigned long int u ) { assert( l < u ); return lrand48() % (u - l) + l; }
    275 float random( void ) { return (float)drand48(); }               // cast otherwise float uses lrand48
     287unsigned long int random( unsigned long int l, unsigned long int u ) { return lrand48() % (u - l) + l; }
     288float random( void ) { return (float)drand48(); }               // otherwise float uses lrand48
    276289double random( void ) { return drand48(); }
    277290float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
    278291double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
    279 long double _Complex random( void ) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
    280 
     292long double _Complex random( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
     293
     294//---------------------------------------
     295
     296forall( otype T | { int ?<?( T, T ); } )
     297T min( T t1, T t2 ) {
     298        return t1 < t2 ? t1 : t2;
     299} // min
     300
     301forall( otype T | { int ?>?( T, T ); } )
     302T max( T t1, T t2 ) {
     303        return t1 > t2 ? t1 : t2;
     304} // max
     305
     306forall( otype T | { T min( T, T ); T max( T, T ); } )
     307T clamp( T value, T min_val, T max_val ) {
     308        return max( min_val, min( value, max_val ) );
     309} // clamp
     310
     311forall( otype T )
     312void swap( T & t1, T & t2 ) {
     313        T temp = t1;
     314        t1 = t2;
     315        t2 = temp;
     316} // swap
    281317
    282318// Local Variables: //
Note: See TracChangeset for help on using the changeset viewer.