source: libcfa/src/stdlib.cfa @ ae1d151

ADTast-experimentalpthread-emulation
Last change on this file since ae1d151 was f6a4917, checked in by Peter A. Buhr <pabuhr@…>, 2 years ago

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