source: libcfa/src/stdlib.cfa@ 3ad5c50

//
// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// stdlib.c --
//
// Author           : Peter A. Buhr
// Created On       : Thu Jan 28 17:10:29 2016
// Last Modified By : Peter A. Buhr
// Last Modified On : Fri Mar 15 18:47:28 2024
// Update Count     : 685
//

#include "stdlib.hfa"
#include "bits/random.hfa"
#include "concurrency/invoke.h"                                                 // random_state

//---------------------------------------

#include <string.h>                                                                             // memcpy, memset
//#include <math.h>                                                                             // fabsf, fabs, fabsl
#include <complex.h>                                                                    // _Complex_I
#include <assert.h>
#include <ctype.h>

#pragma GCC visibility push(default)

//---------------------------------------

// Cforall allocation/deallocation and constructor/destructor, array types

forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } )
T * anew( size_t dim, TT p ) {
        T * arr = alloc( dim );
        for ( i; dim ) {
                (arr[i]){ p };                                                                  // run constructor
        } // for
        return arr;
} // anew

forall( T & | sized(T) | { void ^?{}( T & ); } )
void adelete( T arr[] ) {
        if ( arr ) {                                                                            // ignore null
                size_t dim = malloc_size( arr ) / sizeof( T );
                for ( i; 0 -~= dim - 1 ) {                                              // reverse allocation order, must be unsigned
                        ^(arr[i]){};                                                            // run destructor
                } // for
                free( arr );
        } // if
} // adelete

forall( T & | sized(T) | { void ^?{}( T & ); }, TT... | { void adelete( TT ); } )
void adelete( T arr[], TT rest ) {
        if ( arr ) {                                                                            // ignore null
                size_t dim = malloc_size( arr ) / sizeof( T );
                for ( i; 0 -~= dim - 1 ) {                                              // reverse allocation order, must be unsigned
                        ^(arr[i]){};                                                            // run destructor
                } // for
                free( arr );
        } // if
        adelete( rest );
} // adelete

//---------------------------------------

// Cannot overload with singular (isspace) counterparts because they are macros.

bool isalnums( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! isalnum( *s ) ) return false;
                s += 1;
        } // for
} // isalnums

bool isalphas( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! isalpha( *s ) ) return false;
                s += 1;
        } // for
} // isblanks

bool iscntrls( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! iscntrl( *s ) ) return false;
                s += 1;
        } // for
} // iscntrls

bool isdigits( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! isdigit( *s ) ) return false;
                s += 1;
        } // for
} // isdigits

bool isgraphs( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! isgraph( *s ) ) return false;
                s += 1;
        } // for
} // isgraphs

bool islowers( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! islower( *s ) ) return false;
                s += 1;
        } // for
} // islowers

bool isprints( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! isprint( *s ) ) return false;
                s += 1;
        } // for
} // isprints

bool ispuncts( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! ispunct( *s ) ) return false;
                s += 1;
        } // for
} // ispuncts

bool isspaces( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! isspace( *s ) ) return false;
                s += 1;
        } // for
} // isspaces

bool isblanks( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! isblank( *s ) ) return false;
                s += 1;
        } // for
} // isblanks

bool isuppers( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! isupper( *s ) ) return false;
                s += 1;
        } // for
} // isuppers

bool isxdigits( const char s[] ) {
        for () {
                if ( *s == '\0' ) return true;
                if ( ! isxdigit( *s ) ) return false;
                s += 1;
        } // for
} // isxdigits

//---------------------------------------

float _Complex strto( const char sptr[], char * eptr[] ) {
        float re, im;
        char * eeptr;
        errno = 0;                                                                                      // reset
        re = strtof( sptr, &eeptr );
        if ( sptr != eeptr ) {
                im = strtof( eeptr, &eeptr );
                if ( sptr != eeptr ) {
                        if ( *eeptr == 'i' ) {
                                if ( eptr != 0p ) *eptr = eeptr + 1;
                                return re + im * _Complex_I;
                        } // if
                } // if
        } // if
        if ( eptr != 0p ) *eptr = eeptr;                                        // error case
        return 0.0f + 0.0f * _Complex_I;
} // strto

double _Complex strto( const char sptr[], char * eptr[] ) {
        double re, im;
        char * eeptr;
        re = strtod( sptr, &eeptr );
        if ( sptr != eeptr ) {
                im = strtod( eeptr, &eeptr );
                if ( sptr != eeptr ) {
                        if ( *eeptr == 'i' ) {
                                if ( eptr != 0p ) *eptr = eeptr + 1;
                                return re + im * _Complex_I;
                        } // if
                } // if
        } // if
        if ( eptr != 0p ) *eptr = eeptr;                                        // error case
        return 0.0 + 0.0 * _Complex_I;
} // strto

long double _Complex strto( const char sptr[], char * eptr[] ) {
        long double re, im;
        char * eeptr;
        re = strtold( sptr, &eeptr );
        if ( sptr != eeptr ) {
                im = strtold( eeptr, &eeptr );
                if ( sptr != eeptr ) {
                        if ( *eeptr == 'i' ) {
                                if ( eptr != 0p ) *eptr = eeptr + 1;
                                return re + im * _Complex_I;
                        } // if
                } // if
        } // if
        if ( eptr != 0p ) *eptr = eeptr;                                        // error case
        return 0.0L + 0.0L * _Complex_I;
} // strto

forall( T | { T strto( const char sptr[], char * eptr[], int ); } )
T convert( const char sptr[] ) {                                                // integral
        char * eptr;
        errno = 0;                                                                                      // reset
        T val = strto( sptr, &eptr, 10 );                                       // attempt conversion
        if ( errno == ERANGE ) throw ExceptionInst( out_of_range );
        if ( eptr == sptr ||                                                            // conversion failed, no characters generated
                 eptr[0] != '\0' && ! isspaces( eptr ) ) throw ExceptionInst( invalid_argument ); // not at end of blank str ?
        return val;
} // convert

forall( T | { T strto( const char sptr[], char * eptr[] ); } )
T convert( const char sptr[] ) {                                                // floating-point
        char * eptr;
        errno = 0;                                                                                      // reset
        T val = strto( sptr, &eptr );                                           // attempt conversion
        if ( errno == ERANGE ) throw ExceptionInst( out_of_range );
        if ( eptr == sptr ||                                                            // conversion failed, no characters generated
                 eptr[0] != '\0' && ! isspaces( eptr ) ) throw ExceptionInst( invalid_argument ); // not at end of blank str ?
        return val;
} // convert

//---------------------------------------

forall( E | { int ?<?( E, E ); } ) {
        E * bsearch( E key, const E * vals, size_t dim ) {
                int cmp( const void * t1, const void * t2 ) {
                        return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
                } // cmp
                return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
        } // bsearch

        size_t bsearch( E key, const E * vals, size_t dim ) {
                E * result = bsearch( key, vals, dim );
                return result ? result - vals : dim;                    // pointer subtraction includes sizeof(E)
        } // bsearch

        size_t bsearchl( E key, const E * vals, size_t dim ) {
                size_t l = 0, m, h = dim;
                while ( l < h ) {
                        m = (l + h) / 2;
                        if ( (E &)(vals[m]) < key ) {                           // cast away const
                                l = m + 1;
                        } else {
                                h = m;
                        } // if
                } // while
                return l;
        } // bsearchl

        E * bsearchl( E key, const E * vals, size_t dim ) {
                size_t posn = bsearchl( key, vals, dim );
                return (E *)(&vals[posn]);                                              // cast away const
        } // bsearchl

        size_t bsearchu( E key, const E * vals, size_t dim ) {
                size_t l = 0, m, h = dim;
                while ( l < h ) {
                        m = (l + h) / 2;
                        if ( ! ( key < (E &)(vals[m]) ) ) {                     // cast away const
                                l = m + 1;
                        } else {
                                h = m;
                        } // if
                } // while
                return l;
        } // bsearchu

        E * bsearchu( E key, const E * vals, size_t dim ) {
                size_t posn = bsearchu( key, vals, dim );
                return (E *)(&vals[posn]);
        } // bsearchu


        void qsort( E * vals, size_t dim ) {
                int cmp( const void * t1, const void * t2 ) {
                        return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
                } // cmp
                qsort( vals, dim, sizeof(E), cmp );
        } // qsort
} // distribution


forall( K, E | { int ?<?( K, K ); K getKey( const E & ); } ) {
        E * bsearch( K key, const E * vals, size_t dim ) {
                int cmp( const void * t1, const void * t2 ) {
                        return *(K *)t1 < getKey( *(E *)t2 ) ? -1 : getKey( *(E *)t2 ) < *(K *)t1 ? 1 : 0;
                } // cmp
                return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
        } // bsearch

        size_t bsearch( K key, const E * vals, size_t dim ) {
                E * result = bsearch( key, vals, dim );
                return result ? result - vals : dim;                    // pointer subtraction includes sizeof(E)
        } // bsearch

        size_t bsearchl( K key, const E * vals, size_t dim ) {
                size_t l = 0, m, h = dim;
                while ( l < h ) {
                        m = (l + h) / 2;
                        if ( getKey( vals[m] ) < key ) {
                                l = m + 1;
                        } else {
                                h = m;
                        } // if
                } // while
                return l;
        } // bsearchl

        E * bsearchl( K key, const E * vals, size_t dim ) {
                size_t posn = bsearchl( key, vals, dim );
                return (E *)(&vals[posn]);                                              // cast away const
        } // bsearchl

        size_t bsearchu( K key, const E * vals, size_t dim ) {
                size_t l = 0, m, h = dim;
                while ( l < h ) {
                        m = (l + h) / 2;
                        if ( ! ( key < getKey( vals[m] ) ) ) {
                                l = m + 1;
                        } else {
                                h = m;
                        } // if
                } // while
                return l;
        } // bsearchu

        E * bsearchu( K key, const E * vals, size_t dim ) {
                size_t posn = bsearchu( key, vals, dim );
                return (E *)(&vals[posn]);
        } // bsearchu
} // distribution

//---------------------------------------

extern "C" {                                                                                    // override C version
        void srandom( unsigned int seed ) { srand48( (long int)seed ); }
        long int random( void ) { return mrand48(); }           // GENERATES POSITIVE AND NEGATIVE VALUES
} // extern "C"

float random( void ) { return (float)drand48(); }               // cast otherwise float uses lrand48
double random( void ) { return drand48(); }
float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
long double _Complex random( void ) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }

//---------------------------------------

// would be cool to make hidden but it's needed for libcfathread
__attribute__((visibility("default"))) size_t __global_random_seed; // sequential/concurrent
__attribute__((visibility("hidden"))) PRNG_STATE_T __global_random_state; // sequential only

void set_seed( size_t seed ) {
        __global_random_seed = seed;
        PRNG_SET_SEED( __global_random_state, seed );
} // set_seed

size_t get_seed() { return __global_random_seed; }
size_t prng( void ) { return PRNG_NAME( __global_random_state ); } // [0,UINT_MAX]

//---------------------------------------

bool threading_enabled( void ) __attribute__(( weak )) { return false; }

// Local Variables: //
// tab-width: 4 //
// End: //