source: libcfa/src/stdlib.cfa @ 9319a23

ADTast-experimental
Last change on this file since 9319a23 was f8729be, checked in by Peter A. Buhr <pabuhr@…>, 21 months ago

remove unnecessary #define for _XOPEN_SOURCE 600
  • Property mode set to 100644
File size: 7.5 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// stdlib.c --
8//
9// Author           : Peter A. Buhr
10// Created On       : Thu Jan 28 17:10:29 2016
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Thu Feb 16 16:31:34 2023
13// Update Count     : 633
14//
15
16#include "stdlib.hfa"
17#include "bits/random.hfa"
18#include "concurrency/invoke.h"                                                 // random_state
19
20//---------------------------------------
21
22#include <string.h>                                                                             // memcpy, memset
23//#include <math.h>                                                                             // fabsf, fabs, fabsl
24#include <complex.h>                                                                    // _Complex_I
25#include <assert.h>
26
27#pragma GCC visibility push(default)
28
29//---------------------------------------
30
31// Cforall allocation/deallocation and constructor/destructor, array types
32
33forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } )
34T * anew( size_t dim, TT p ) {
35        T * arr = alloc( dim );
36        for ( i; dim ) {
37                (arr[i]){ p };                                                                  // run constructor
38        } // for
39        return arr;
40} // anew
41
42forall( T & | sized(T) | { void ^?{}( T & ); } )
43void adelete( T arr[] ) {
44        if ( arr ) {                                                                            // ignore null
45                size_t dim = malloc_size( arr ) / sizeof( T );
46                for ( i; 0 -~= dim - 1 ) {                                              // reverse allocation order, must be unsigned
47                        ^(arr[i]){};                                                            // run destructor
48                } // for
49                free( arr );
50        } // if
51} // adelete
52
53forall( T & | sized(T) | { void ^?{}( T & ); }, TT... | { void adelete( TT ); } )
54void adelete( T arr[], TT rest ) {
55        if ( arr ) {                                                                            // ignore null
56                size_t dim = malloc_size( arr ) / sizeof( T );
57                for ( i; 0 -~= dim - 1 ) {                                              // reverse allocation order, must be unsigned
58                        ^(arr[i]){};                                                            // run destructor
59                } // for
60                free( arr );
61        } // if
62        adelete( rest );
63} // adelete
64
65//---------------------------------------
66
67float _Complex strto( const char sptr[], char ** eptr ) {
68        float re, im;
69        char * eeptr;
70        re = strtof( sptr, &eeptr );
71        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
72        im = strtof( eeptr, &eeptr );
73        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
74        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
75        return re + im * _Complex_I;
76} // strto
77
78double _Complex strto( const char sptr[], char ** eptr ) {
79        double re, im;
80        char * eeptr;
81        re = strtod( sptr, &eeptr );
82        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
83        im = strtod( eeptr, &eeptr );
84        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
85        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
86        return re + im * _Complex_I;
87} // strto
88
89long double _Complex strto( const char sptr[], char ** eptr ) {
90        long double re, im;
91        char * eeptr;
92        re = strtold( sptr, &eeptr );
93        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
94        im = strtold( eeptr, &eeptr );
95        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
96        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
97        return re + im * _Complex_I;
98} // strto
99
100//---------------------------------------
101
102forall( E | { int ?<?( E, E ); } ) {
103        E * bsearch( E key, const E * vals, size_t dim ) {
104                int cmp( const void * t1, const void * t2 ) {
105                        return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
106                } // cmp
107                return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
108        } // bsearch
109
110        size_t bsearch( E key, const E * vals, size_t dim ) {
111                E * result = bsearch( key, vals, dim );
112                return result ? result - vals : dim;                    // pointer subtraction includes sizeof(E)
113        } // bsearch
114
115        size_t bsearchl( E key, const E * vals, size_t dim ) {
116                size_t l = 0, m, h = dim;
117                while ( l < h ) {
118                        m = (l + h) / 2;
119                        if ( (E &)(vals[m]) < key ) {                           // cast away const
120                                l = m + 1;
121                        } else {
122                                h = m;
123                        } // if
124                } // while
125                return l;
126        } // bsearchl
127
128        E * bsearchl( E key, const E * vals, size_t dim ) {
129                size_t posn = bsearchl( key, vals, dim );
130                return (E *)(&vals[posn]);                                              // cast away const
131        } // bsearchl
132
133        size_t bsearchu( E key, const E * vals, size_t dim ) {
134                size_t l = 0, m, h = dim;
135                while ( l < h ) {
136                        m = (l + h) / 2;
137                        if ( ! ( key < (E &)(vals[m]) ) ) {                     // cast away const
138                                l = m + 1;
139                        } else {
140                                h = m;
141                        } // if
142                } // while
143                return l;
144        } // bsearchu
145
146        E * bsearchu( E key, const E * vals, size_t dim ) {
147                size_t posn = bsearchu( key, vals, dim );
148                return (E *)(&vals[posn]);
149        } // bsearchu
150
151
152        void qsort( E * vals, size_t dim ) {
153                int cmp( const void * t1, const void * t2 ) {
154                        return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
155                } // cmp
156                qsort( vals, dim, sizeof(E), cmp );
157        } // qsort
158} // distribution
159
160
161forall( K, E | { int ?<?( K, K ); K getKey( const E & ); } ) {
162        E * bsearch( K key, const E * vals, size_t dim ) {
163                int cmp( const void * t1, const void * t2 ) {
164                        return *(K *)t1 < getKey( *(E *)t2 ) ? -1 : getKey( *(E *)t2 ) < *(K *)t1 ? 1 : 0;
165                } // cmp
166                return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
167        } // bsearch
168
169        size_t bsearch( K key, const E * vals, size_t dim ) {
170                E * result = bsearch( key, vals, dim );
171                return result ? result - vals : dim;                    // pointer subtraction includes sizeof(E)
172        } // bsearch
173
174        size_t bsearchl( K key, const E * vals, size_t dim ) {
175                size_t l = 0, m, h = dim;
176                while ( l < h ) {
177                        m = (l + h) / 2;
178                        if ( getKey( vals[m] ) < key ) {
179                                l = m + 1;
180                        } else {
181                                h = m;
182                        } // if
183                } // while
184                return l;
185        } // bsearchl
186
187        E * bsearchl( K key, const E * vals, size_t dim ) {
188                size_t posn = bsearchl( key, vals, dim );
189                return (E *)(&vals[posn]);                                              // cast away const
190        } // bsearchl
191
192        size_t bsearchu( K key, const E * vals, size_t dim ) {
193                size_t l = 0, m, h = dim;
194                while ( l < h ) {
195                        m = (l + h) / 2;
196                        if ( ! ( key < getKey( vals[m] ) ) ) {
197                                l = m + 1;
198                        } else {
199                                h = m;
200                        } // if
201                } // while
202                return l;
203        } // bsearchu
204
205        E * bsearchu( K key, const E * vals, size_t dim ) {
206                size_t posn = bsearchu( key, vals, dim );
207                return (E *)(&vals[posn]);
208        } // bsearchu
209} // distribution
210
211//---------------------------------------
212
213extern "C" {                                                                                    // override C version
214        void srandom( unsigned int seed ) { srand48( (long int)seed ); }
215        long int random( void ) { return mrand48(); }           // GENERATES POSITIVE AND NEGATIVE VALUES
216} // extern "C"
217
218float random( void ) { return (float)drand48(); }               // cast otherwise float uses lrand48
219double random( void ) { return drand48(); }
220float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
221double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
222long double _Complex random( void ) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
223
224//---------------------------------------
225
226// would be cool to make hidden but it's needed for libcfathread
227__attribute__((visibility("default"))) size_t __global_random_seed; // sequential/concurrent
228__attribute__((visibility("hidden"))) PRNG_STATE_T __global_random_state; // sequential only
229
230void set_seed( size_t seed ) {
231        __global_random_seed = seed;
232        PRNG_SET_SEED( __global_random_state, seed );
233} // set_seed
234
235size_t get_seed() { return __global_random_seed; }
236size_t prng( void ) { return PRNG_NAME( __global_random_state ); } // [0,UINT_MAX]
237
238//---------------------------------------
239
240bool threading_enabled( void ) __attribute__(( weak )) { return false; }
241
242// Local Variables: //
243// tab-width: 4 //
244// End: //
Note: See TracBrowser for help on using the repository browser.