Changeset f3458a8 for src/libcfa
- Timestamp:
- Jan 2, 2018, 10:39:57 AM (6 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- 8aa474a
- Parents:
- f64d9bc (diff), 93cdd5c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Location:
- src/libcfa
- Files:
-
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
src/libcfa/iostream
rf64d9bc rf3458a8 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Dec 6 23:03:30201713 // Update Count : 14 412 // Last Modified On : Thu Dec 21 13:55:41 2017 13 // Update Count : 145 14 14 // 15 15 … … 55 55 56 56 // implement writable for intrinsic types 57 58 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, _Bool ); 57 59 58 60 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, char ); -
src/libcfa/iostream.c
rf64d9bc rf3458a8 10 10 // Created On : Wed May 27 17:56:53 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Dec 6 23:03:43201713 // Update Count : 42 612 // Last Modified On : Thu Dec 21 13:55:09 2017 13 // Update Count : 427 14 14 // 15 15 … … 23 23 #include <complex.h> // creal, cimag 24 24 } 25 26 forall( dtype ostype | ostream( ostype ) ) 27 ostype & ?|?( ostype & os, _Bool b ) { 28 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); 29 fmt( os, "%s", b ? "true" : "false" ); 30 return os; 31 } // ?|? 25 32 26 33 forall( dtype ostype | ostream( ostype ) ) -
src/libcfa/stdlib
rf64d9bc rf3458a8 10 10 // Created On : Thu Jan 28 17:12:35 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Oct 31 13:47:24 201713 // Update Count : 2 4512 // Last Modified On : Mon Jan 1 17:35:43 2018 13 // Update Count : 291 14 14 // 15 15 16 16 #pragma once 17 18 //#define _XOPEN_SOURCE 600 // posix_memalign, *rand48 19 #include <stdlib.h> // strto*, *abs 17 20 18 21 //--------------------------------------- … … 77 80 //printf( "X8\n" ); 78 81 T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc 79 return (T *)memset( ptr, (int)fill, sizeof(T) ); 82 return (T *)memset( ptr, (int)fill, sizeof(T) ); // initial with fill value 80 83 } // alloc 81 84 … … 150 153 //--------------------------------------- 151 154 152 int ato( const char * ptr ); 153 unsigned int ato( const char * ptr ); 154 long int ato( const char * ptr ); 155 unsigned long int ato( const char * ptr ); 156 long long int ato( const char * ptr ); 157 unsigned long long int ato( const char * ptr ); 158 float ato( const char * ptr ); 159 double ato( const char * ptr ); 160 long double ato( const char * ptr ); 161 float _Complex ato( const char * ptr ); 162 double _Complex ato( const char * ptr ); 163 long double _Complex ato( const char * ptr ); 164 165 int strto( const char * sptr, char ** eptr, int base ); 166 unsigned int strto( const char * sptr, char ** eptr, int base ); 167 long int strto( const char * sptr, char ** eptr, int base ); 168 unsigned long int strto( const char * sptr, char ** eptr, int base ); 169 long long int strto( const char * sptr, char ** eptr, int base ); 170 unsigned long long int strto( const char * sptr, char ** eptr, int base ); 171 float strto( const char * sptr, char ** eptr ); 172 double strto( const char * sptr, char ** eptr ); 173 long double strto( const char * sptr, char ** eptr ); 155 static inline int strto( const char * sptr, char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); } 156 static inline unsigned int strto( const char * sptr, char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); } 157 static inline long int strto( const char * sptr, char ** eptr, int base ) { return strtol( sptr, eptr, base ); } 158 static inline unsigned long int strto( const char * sptr, char ** eptr, int base ) { return strtoul( sptr, eptr, base ); } 159 static inline long long int strto( const char * sptr, char ** eptr, int base ) { return strtoll( sptr, eptr, base ); } 160 static inline unsigned long long int strto( const char * sptr, char ** eptr, int base ) { return strtoull( sptr, eptr, base ); } 161 162 static inline float strto( const char * sptr, char ** eptr ) { return strtof( sptr, eptr ); } 163 static inline double strto( const char * sptr, char ** eptr ) { return strtod( sptr, eptr ); } 164 static inline long double strto( const char * sptr, char ** eptr ) { return strtold( sptr, eptr ); } 165 174 166 float _Complex strto( const char * sptr, char ** eptr ); 175 167 double _Complex strto( const char * sptr, char ** eptr ); 176 168 long double _Complex strto( const char * sptr, char ** eptr ); 177 169 178 //--------------------------------------- 179 180 forall( otype T | { int ?<?( T, T ); } ) 181 T * bsearch( T key, const T * arr, size_t dim ); 182 183 forall( otype T | { int ?<?( T, T ); } ) 184 unsigned int bsearch( T key, const T * arr, size_t dim ); 185 186 187 forall( otype T | { int ?<?( T, T ); } ) 188 void qsort( const T * arr, size_t dim ); 170 static inline int ato( const char * sptr ) {return (int)strtol( sptr, 0, 10 ); } 171 static inline unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0, 10 ); } 172 static inline long int ato( const char * sptr ) { return strtol( sptr, 0, 10 ); } 173 static inline unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0, 10 ); } 174 static inline long long int ato( const char * sptr ) { return strtoll( sptr, 0, 10 ); } 175 static inline unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0, 10 ); } 176 177 static inline float ato( const char * sptr ) { return strtof( sptr, 0 ); } 178 static inline double ato( const char * sptr ) { return strtod( sptr, 0 ); } 179 static inline long double ato( const char * sptr ) { return strtold( sptr, 0 ); } 180 181 static inline float _Complex ato( const char * sptr ) { return strto( sptr, NULL ); } 182 static inline double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); } 183 static inline long double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); } 184 185 //--------------------------------------- 186 187 forall( otype E | { int ?<?( E, E ); } ) 188 E * bsearch( E key, const E * vals, size_t dim ); 189 190 forall( otype E | { int ?<?( E, E ); } ) 191 size_t bsearch( E key, const E * vals, size_t dim ); 192 193 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) 194 E * bsearch( K key, const E * vals, size_t dim ); 195 196 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) 197 size_t bsearch( K key, const E * vals, size_t dim ); 198 199 200 forall( otype E | { int ?<?( E, E ); } ) 201 E * bsearchl( E key, const E * vals, size_t dim ); 202 203 forall( otype E | { int ?<?( E, E ); } ) 204 size_t bsearchl( E key, const E * vals, size_t dim ); 205 206 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) 207 E * bsearchl( K key, const E * vals, size_t dim ); 208 209 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) 210 size_t bsearchl( K key, const E * vals, size_t dim ); 211 212 213 forall( otype E | { int ?<?( E, E ); } ) 214 E * bsearchu( E key, const E * vals, size_t dim ); 215 216 forall( otype E | { int ?<?( E, E ); } ) 217 size_t bsearchu( E key, const E * vals, size_t dim ); 218 219 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) 220 E * bsearchu( K key, const E * vals, size_t dim ); 221 222 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) 223 size_t bsearchu( K key, const E * vals, size_t dim ); 224 225 226 forall( otype E | { int ?<?( E, E ); } ) 227 void qsort( E * vals, size_t dim ); 189 228 190 229 //--------------------------------------- … … 198 237 //--------------------------------------- 199 238 200 unsigned char abs( signed char ); 239 static inline unsigned char abs( signed char v ) { return abs( (int)v ); } 201 240 extern "C" { int abs( int ); } // use default C routine for int 202 unsigned long int abs( long int ); 203 unsigned long long int abs( long long int ); 204 float abs( float ); 205 double abs( double ); 206 long double abs( long double ); 207 float abs( float _Complex ); 208 double abs( double _Complex ); 209 long double abs( long double _Complex ); 241 static inline unsigned long int abs( long int v ) { return labs( v ); } 242 static inline unsigned long long int abs( long long int v ) { return llabs( v ); } 243 244 extern "C" { 245 double fabs( double ); 246 float fabsf( float ); 247 long double fabsl( long double ); 248 } // extern "C" 249 static inline float abs( float x ) { return fabsf( x ); } 250 static inline double abs( double x ) { return fabs( x ); } 251 static inline long double abs( long double x ) { return fabsl( x ); } 252 253 extern "C" { 254 double cabs( double _Complex ); 255 float cabsf( float _Complex ); 256 long double cabsl( long double _Complex ); 257 } // extern "C" 258 static inline float abs( float _Complex x ) { return cabsf( x ); } 259 static inline double abs( double _Complex x ) { return cabs( x ); } 260 static inline long double abs( long double _Complex x ) { return cabsl( x ); } 261 210 262 forall( otype T | { void ?{}( T &, zero_t ); int ?<?( T, T ); T -?( T ); } ) 211 263 T abs( T ); … … 215 267 void random_seed( long int s ); 216 268 char random( void ); 269 char random( char u ); 217 270 char random( char l, char u ); 218 271 int random( void ); 272 int random( int u ); 273 int random( int l, int u ); 219 274 unsigned int random( void ); 220 275 unsigned int random( unsigned int u ); 221 276 unsigned int random( unsigned int l, unsigned int u ); 222 //long int random( void ); 277 extern "C" { long int random( void ); } 278 long int random( long int u ); 279 long int random( long int l, long int u ); 223 280 unsigned long int random( void ); 224 281 unsigned long int random( unsigned long int u ); … … 233 290 234 291 forall( otype T | { int ?<?( T, T ); } ) 235 T min( T t1, T t2 ); 292 static inline T min( T t1, T t2 ) { return t1 < t2 ? t1 : t2; } 236 293 237 294 forall( otype T | { int ?>?( T, T ); } ) 238 T max( T t1, T t2 ); 295 static inline T max( T t1, T t2 ) { return t1 > t2 ? t1 : t2; } 239 296 240 297 forall( otype T | { T min( T, T ); T max( T, T ); } ) 241 T clamp( T value, T min_val, T max_val ); 298 static inline T clamp( T value, T min_val, T max_val ) { return max( min_val, min( value, max_val ) ); } 242 299 243 300 forall( otype T ) 244 void swap( T & t1, T & t2 ); 301 static inline void swap( T & v1, T & v2 ) { T temp = v1; v1 = v2; v2 = temp; } 245 302 246 303 // Local Variables: // -
src/libcfa/stdlib.c
rf64d9bc rf3458a8 10 10 // Created On : Thu Jan 28 17:10:29 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Oct 30 22:43:02 201713 // Update Count : 29712 // Last Modified On : Mon Jan 1 19:03:16 2018 13 // Update Count : 437 14 14 // 15 15 … … 19 19 20 20 #define _XOPEN_SOURCE 600 // posix_memalign, *rand48 21 #include <stdlib.h> // malloc, free, calloc, realloc, memalign, posix_memalign, bsearch22 21 #include <string.h> // memcpy, memset 23 22 #include <malloc.h> // malloc_usable_size 24 23 #include <math.h> // fabsf, fabs, fabsl 25 24 #include <complex.h> // _Complex_I 25 #include <assert.h> 26 26 27 27 // resize, non-array types … … 93 93 //--------------------------------------- 94 94 95 int ato( const char * ptr ) {96 int i;97 if ( sscanf( ptr, "%d", &i ) == EOF ) {}98 return i;99 } // ato100 101 unsigned int ato( const char * ptr ) {102 unsigned int ui;103 if ( sscanf( ptr, "%u", &ui ) == EOF ) {}104 return ui;105 } // ato106 107 long int ato( const char * ptr ) {108 long int li;109 if ( sscanf( ptr, "%ld", &li ) == EOF ) {}110 return li;111 } // ato112 113 unsigned long int ato( const char * ptr ) {114 unsigned long int uli;115 if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}116 return uli;117 } // ato118 119 long long int ato( const char * ptr ) {120 long long int lli;121 if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}122 return lli;123 } // ato124 125 unsigned long long int ato( const char * ptr ) {126 unsigned long long int ulli;127 if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}128 return ulli;129 } // ato130 131 132 float ato( const char * ptr ) {133 float f;134 if ( sscanf( ptr, "%f", &f ) == EOF ) {}135 return f;136 } // ato137 138 double ato( const char * ptr ) {139 double d;140 if ( sscanf( ptr, "%lf", &d ) == EOF ) {}141 return d;142 } // ato143 144 long double ato( const char * ptr ) {145 long double ld;146 if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}147 return ld;148 } // ato149 150 151 float _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 } // ato156 157 double _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 } // ato162 163 long 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 } // ato168 169 170 int strto( const char * sptr, char ** eptr, int base ) {171 return (int)strtol( sptr, eptr, base );172 } // strto173 174 unsigned int strto( const char * sptr, char ** eptr, int base ) {175 return (unsigned int)strtoul( sptr, eptr, base );176 } // strto177 178 long int strto( const char * sptr, char ** eptr, int base ) {179 return strtol( sptr, eptr, base );180 } // strto181 182 unsigned long int strto( const char * sptr, char ** eptr, int base ) {183 return strtoul( sptr, eptr, base );184 } // strto185 186 long long int strto( const char * sptr, char ** eptr, int base ) {187 return strtoll( sptr, eptr, base );188 } // strto189 190 unsigned long long int strto( const char * sptr, char ** eptr, int base ) {191 return strtoull( sptr, eptr, base );192 } // strto193 194 195 float strto( const char * sptr, char ** eptr ) {196 return strtof( sptr, eptr );197 } // strto198 199 double strto( const char * sptr, char ** eptr ) {200 return strtod( sptr, eptr );201 } // strto202 203 long double strto( const char * sptr, char ** eptr ) {204 return strtold( sptr, eptr );205 } // strto206 207 208 95 float _Complex strto( const char * sptr, char ** eptr ) { 209 96 float re, im; 210 re = strtof( sptr, eptr ); 211 if ( sptr == *eptr ) return 0.0; 212 im = strtof( sptr, eptr ); 213 if ( sptr == *eptr ) return 0.0; 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; } 214 103 return re + im * _Complex_I; 215 104 } // strto … … 217 106 double _Complex strto( const char * sptr, char ** eptr ) { 218 107 double re, im; 219 re = strtod( sptr, eptr ); 220 if ( sptr == *eptr ) return 0.0; 221 im = strtod( sptr, eptr ); 222 if ( sptr == *eptr ) return 0.0; 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; } 223 114 return re + im * _Complex_I; 224 115 } // strto … … 226 117 long double _Complex strto( const char * sptr, char ** eptr ) { 227 118 long double re, im; 228 re = strtold( sptr, eptr ); 229 if ( sptr == *eptr ) return 0.0; 230 im = strtold( sptr, eptr ); 231 if ( sptr == *eptr ) return 0.0; 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; } 232 125 return re + im * _Complex_I; 233 126 } // strto … … 235 128 //--------------------------------------- 236 129 237 forall( otype T | { int ?<?( T, T ); } ) 238 T * 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 ); 241 } // bsearch 242 243 forall( otype T | { int ?<?( T, T ); } ) 244 unsigned 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) 247 } // bsearch 248 249 forall( otype T | { int ?<?( T, T ); } ) 250 void 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 ); 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 ); 136 } // bsearch 137 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) 142 } // bsearch 143 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 ); 253 247 } // qsort 254 248 … … 263 257 //--------------------------------------- 264 258 265 unsigned char abs( signed char v ) { return abs( (int)v ); } 266 unsigned long int abs( long int v ) { return labs( v ); } 267 unsigned long long int abs( long long int v ) { return llabs( v ); } 268 float abs( float x ) { return fabsf( x ); } 269 double abs( double x ) { return fabs( x ); } 270 long double abs( long double x ) { return fabsl( x ); } 271 float abs( float _Complex x ) { return cabsf( x ); } 272 double abs( double _Complex x ) { return cabs( x ); } 273 long double abs( long double _Complex x ) { return cabsl( x ); } 274 275 //--------------------------------------- 276 277 void random_seed( long int s ) { srand48( s ); } 278 char random( void ) { return mrand48(); } 279 char random( char l, char u ) { return lrand48() % (u - l) + l; } 280 int random( void ) { return mrand48(); } 281 unsigned int random( void ) { return lrand48(); } 282 unsigned int random( unsigned int u ) { return lrand48() % u; } 283 unsigned int random( unsigned int l, unsigned int u ) { return lrand48() % (u - l) + l; } 284 //long int random( void ) { return mrand48(); } 259 void random_seed( long int s ) { srand48( s ); srandom( s ); } // call srandom to harmonize with C-lib random 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() { return mrand48(); } } 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; } 285 272 unsigned long int random( void ) { return lrand48(); } 286 273 unsigned long int random( unsigned long int u ) { return lrand48() % u; } 287 unsigned long int random( unsigned long int l, unsigned long int u ) { return lrand48() % (u - l) + l; }288 float random( void ) { return (float)drand48(); } // otherwise float uses lrand48274 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 289 276 double random( void ) { return drand48(); } 290 277 float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); } 291 278 double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); } 292 long double _Complex random( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); } 293 294 //--------------------------------------- 295 296 forall( otype T | { int ?<?( T, T ); } ) 297 T min( T t1, T t2 ) { 298 return t1 < t2 ? t1 : t2; 299 } // min 300 301 forall( otype T | { int ?>?( T, T ); } ) 302 T max( T t1, T t2 ) { 303 return t1 > t2 ? t1 : t2; 304 } // max 305 306 forall( otype T | { T min( T, T ); T max( T, T ); } ) 307 T clamp( T value, T min_val, T max_val ) { 308 return max( min_val, min( value, max_val ) ); 309 } // clamp 310 311 forall( otype T ) 312 void swap( T & t1, T & t2 ) { 313 T temp = t1; 314 t1 = t2; 315 t2 = temp; 316 } // swap 279 long double _Complex random( void ) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); } 280 317 281 318 282 // Local Variables: //
Note: See TracChangeset
for help on using the changeset viewer.