source: src/libcfa/stdlib.c @ 9c47a47

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 9c47a47 was 9c47a47, checked in by Peter A. Buhr <pabuhr@…>, 5 years ago

extend stdlib bsearch

  • Property mode set to 100644
File size: 7.9 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// algorithm.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 Dec 28 18:43:16 2017
13// Update Count     : 378
14//
15
16#include "stdlib"
17
18//---------------------------------------
19
20#define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
21#include <string.h>                                                                             // memcpy, memset
22#include <malloc.h>                                                                             // malloc_usable_size
23#include <math.h>                                                                               // fabsf, fabs, fabsl
24#include <complex.h>                                                                    // _Complex_I
25#include <assert.h>
26
27// resize, non-array types
28forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) {
29        size_t olen = malloc_usable_size( ptr );                        // current allocation
30    char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
31        size_t nlen = malloc_usable_size( nptr );                       // new allocation
32        if ( nlen > olen ) {                                                            // larger ?
33                memset( nptr + olen, (int)fill, nlen - olen );  // initialize added storage
34        } //
35    return (T *)nptr;
36} // alloc
37
38// allocation/deallocation and constructor/destructor, non-array types
39forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
40T * new( Params p ) {
41        return &(*malloc()){ p };                                                               // run constructor
42} // new
43
44forall( dtype T | sized(T) | { void ^?{}( T & ); } )
45void delete( T * ptr ) {
46        if ( ptr ) {                                                                            // ignore null
47                ^(*ptr){};                                                                                      // run destructor
48                free( ptr );
49        } // if
50} // delete
51
52forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } )
53void delete( T * ptr, Params rest ) {
54        if ( ptr ) {                                                                            // ignore null
55                ^(*ptr){};                                                                                      // run destructor
56                free( ptr );
57        } // if
58        delete( rest );
59} // delete
60
61
62// allocation/deallocation and constructor/destructor, array types
63forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
64T * anew( size_t dim, Params p ) {
65        T *arr = alloc( dim );
66        for ( unsigned int i = 0; i < dim; i += 1 ) {
67                (arr[i]){ p };                                                                  // run constructor
68        } // for
69        return arr;
70} // anew
71
72forall( dtype T | sized(T) | { void ^?{}( T & ); } )
73void adelete( size_t dim, T arr[] ) {
74        if ( arr ) {                                                                            // ignore null
75                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
76                        ^(arr[i]){};                                                            // run destructor
77                } // for
78                free( arr );
79        } // if
80} // adelete
81
82forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
83void adelete( size_t dim, T arr[], Params rest ) {
84        if ( arr ) {                                                                            // ignore null
85                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
86                        ^(arr[i]){};                                                            // run destructor
87                } // for
88                free( arr );
89        } // if
90        adelete( rest );
91} // adelete
92
93//---------------------------------------
94
95float _Complex strto( const char * sptr, char ** eptr ) {
96        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; }
103        return re + im * _Complex_I;
104} // strto
105
106double _Complex strto( const char * sptr, char ** eptr ) {
107        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; }
114        return re + im * _Complex_I;
115} // strto
116
117long double _Complex strto( const char * sptr, char ** eptr ) {
118        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
130forall( otype E | { int ?<?( E, E ); } )
131E * bsearch( E key, const E * arr, size_t dim ) {
132        int comp( const void * t1, const void * t2 ) { return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0; }
133        return (E *)bsearch( &key, arr, dim, sizeof(E), comp );
134} // bsearch
135
136forall( otype E | { int ?<?( E, E ); } )
137unsigned int bsearch( E key, const E * arr, size_t dim ) {
138        E * result = bsearch( key, arr, dim );
139        return result ? result - arr : dim;                                     // pointer subtraction includes sizeof(E)
140} // bsearch
141
142forall( otype K, otype E | { int ?<?( K, K ); K getKey( E & ); } )
143E * bsearch( K key, const E * arr, size_t dim ) {
144        int comp( const void * t1, const void * t2 ) { return *(K *)t1 < getKey( *(E *)t2 ) ? -1 : getKey( *(E *)t2 ) < *(K *)t1 ? 1 : 0; }
145        return (E *)bsearch( &key, arr, dim, sizeof(E), comp );
146} // bsearch
147
148forall( otype K, otype E | { int ?<?( K, K ); K getKey( E & ); } )
149unsigned int bsearch( K key, const E * arr, size_t dim ) {
150        E * result = bsearch( key, arr, dim );
151        return result ? result - arr : dim;                                     // pointer subtraction includes sizeof(E)
152} // bsearch
153
154forall( otype E | { int ?<?( E, E ); } )
155void qsort( E * arr, size_t dim ) {
156        int comp( const void * t1, const void * t2 ) { return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0; }
157        qsort( arr, dim, sizeof(E), comp );
158} // qsort
159
160//---------------------------------------
161
162[ int, int ] div( int num, int denom ) { div_t qr = div( num, denom ); return [ qr.quot, qr.rem ]; }
163[ long int, long int ] div( long int num, long int denom ) { ldiv_t qr = ldiv( num, denom ); return [ qr.quot, qr.rem ]; }
164[ long long int, long long int ] div( long long int num, long long int denom ) { lldiv_t qr = lldiv( num, denom ); return [ qr.quot, qr.rem ]; }
165forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
166[ T, T ] div( T num, T denom ) { return [ num / denom, num % denom ]; }
167
168//---------------------------------------
169
170void random_seed( long int s ) { srand48( s ); srandom( s ); } // call srandom to harmonize with C-lib random
171char random( void ) { return (unsigned long int)random(); }
172char random( char u ) { return random( (unsigned long int)u ); }
173char random( char l, char u ) { return random( (unsigned long int)l, (unsigned long int)u ); }
174int random( void ) { return (long int)random(); }
175int random( int u ) { return random( (long int)u ); }
176int random( int l, int u ) { return random( (long int)l, (long int)u ); }
177unsigned int random( void ) { return (unsigned long int)random(); }
178unsigned int random( unsigned int u ) { return random( (unsigned long int)u ); }
179unsigned int random( unsigned int l, unsigned int u ) { return random( (unsigned long int)l, (unsigned long int)u ); }
180//extern "C" { long int random() { return mrand48(); } }
181long int random( long int u ) { if ( u < 0 ) return random( u, 0 ); else return random( 0, u ); }
182long int random( long int l, long int u ) { assert( l < u ); return lrand48() % (u - l) + l; }
183unsigned long int random( void ) { return lrand48(); }
184unsigned long int random( unsigned long int u ) { return lrand48() % u; }
185unsigned long int random( unsigned long int l, unsigned long int u ) { assert( l < u ); return lrand48() % (u - l) + l; }
186float random( void ) { return (float)drand48(); }               // cast otherwise float uses lrand48
187double random( void ) { return drand48(); }
188float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
189double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
190long double _Complex random( void ) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
191
192
193// Local Variables: //
194// tab-width: 4 //
195// End: //
Note: See TracBrowser for help on using the repository browser.