ctldef.c

Go to the documentation of this file.

#include <time.h>
#include "ctl/ctldef.h"

#ifndef CTL_UNIT

ppC(bool _ctl_dummy_true(void) { return true; })
ppC(bool _ctl_dummy_false(void) { return false; })


size_t int32_NumPlaces( int32 val )
{
    size_t ret = 0;
    if( val < 0 )
    {
        val = -val;
        ret = 1;
        if( val < 0 )   /* int32 min */
            return 11;
    }
    return ret + uint32_NumPlaces( val );
}
size_t uint32_NumPlaces( uint32 val )
{
    if( val >= 100000u )
    {
        if( val >= 100000000u )
        {
            if( val >= 1000000000u )
            {
                return 10;
            }
            return 9;
        }
        else if( val >= 1000000u )
        {
            if( val >= 10000000u )
                return 8;
            return 7;
        }
        return 6;
    }
    else if( val >= 1000u )
    {
        if( val >= 10000u )
            return 5;
        return 4;
    }
    else if( val >= 10u )
    {
        if( val >= 100u )
            return 3;
        return 2;
    }
    return 1;
}

size_t int64_NumPlaces( int64 val )
{
    size_t ret = 0;
    if( val < 0 )
    {
        val = -val;
        ret = 1;
        if( val < 0 )
            return 20;
    }
    return ret + uint64_NumPlaces( val );
}

size_t uint64_NumPlaces( uint64 val )
{
    /*18,446,744,073,709,551,616 */
    if( val > uint64const(billion(1,000,000,000)) )
    {
        if( val >= uint64const(quadrillion(1,000,000,000,000,000)) )
        {
            if( val >= uint64const(quintillion(1,000,000,000,000,000,000)) )
            {
                if( val >= uint64const(quintillion(10,000,000,000,000,000,000)) )
                    return 20;
                /* else uint64const(quintillion(1,000,000,000,000,000,000)) */
                return 19;
            }
            else /* if( val >= uint64const(quadrillion(1,000,000,000,000,000)) ) */
            {
                if( val >= uint64const(quadrillion(100,000,000,000,000,000)) )
                    return 18;
                if( val >= uint64const(quadrillion(10,000,000,000,000,000)) )
                    return 17;
                /* else uint64const(quadrillion(1,000,000,000,000,000)) */
                return 16;
            }
        }
        else if( val >= uint64const(trillion(1,000,000,000,000)) )
        {
            if( val >= uint64const(trillion(100,000,000,000,000)) )
                return 15;
            if( val >= uint64const(trillion(10,000,000,000,000)) )
                return 14;
            /* else uint64const(trillion(1,000,000,000,000)) */
            return 13;
        }
        else /* if( val >= uint64const(billion(1,000,000,000)) ) */
        {
            if( val >= uint64const(billion(100,000,000,000)) )
                return 12;
            if( val >= uint64const(billion(10,000,000,000)) )
                return 11;
            /* else uint64const(billion(1,000,000,000)) */
            return 10;
        }
    }
    return uint32_NumPlaces( (uint32)val );

}

size_t uint32_XNumPlaces( uint32 val )
{
    size_t ret = 1;
    if( val >= 0xffff0000 )
    {
        ret += 4;
        val >>= 16;
    }
    if( val >= 0xff00 )
    {
        ret += 2;
        val >>= 8;
    }
    if( val >= 0xf0 )
    {
        ret++;
    }
    return ret;
}
size_t uint64_XNumPlaces( uint64 val )
{
    if( val > 0xffffffff )
    {
        val >>= 32;
        return 32+uint32_XNumPlaces( (uint32)val );
    }
    return uint32_XNumPlaces( (uint32)val );
}


#else /* CTL_UNIT */
#include "unit/unit.h"


void Test_UnitShifts(void)
{
    /* Validate some of our former assumptions */
#define Test_Sizeof(type,size)              { int ppConcat(val_,type) = (int)sizeof(type); Test_Error( ppConcat(val_,type) == size ); }
#define Test_Constant(type,val,shouldbe)    { type ppConcat(val_,type) = (val); Test_Error( ppConcat(val_,type) == (shouldbe) ); }
    Test_Sizeof( int8, 1 );
    Test_Sizeof( uint8, 1 );
    Test_Sizeof( int16, 2 );
    Test_Sizeof( uint16, 2 );
    Test_Sizeof( int32, 4 );
    Test_Sizeof( uint32, 4 );
    Test_Sizeof( int64, 8 );
    Test_Sizeof( uint64, 8 );
    Test_Sizeof( float32, 4 );
    Test_Sizeof( float64, 8 );

    {
        const uint16 c16_msb = ppBits16_msb( 1,0,0,1, 1,0,1,0, 1,0,1,1, 1,1,0,0 );
        const uint16 c16_lsb = ppBits16_lsb( 1,0,0,1, 1,0,1,0, 1,0,1,1, 1,1,0,0 );
        Test_Error( c16_msb == 0x9abc );
        Test_Error( c16_lsb == 0x3d59 );
        Test_Constant(uint32, ppBits32_msb( 1,0,0,0, 1,0,0,1, 1,0,1,0, 1,0,1,1, 1,1,0,0, 1,1,0,1, 1,1,1,0, 1,1,1,1 ), 0x89abcdefu );
        Test_Constant(uint32, ppBits32_lsb( 1,0,0,0, 1,0,0,1, 1,0,1,0, 1,0,1,1, 1,1,0,0, 1,1,0,1, 1,1,1,0, 1,1,1,1 ), 0xf7b3d591u );
    }
    {
        const uint32 val = 1 ppOps( * 10, 3 );
        Test_Error( val == 1000 );
        Test_Error( ppExponent( 10, 4 ) == 10000 );
        Test_Error( ppExponent( 2, 8 ) == 256 );
        Test_Error( ppExponent( 3, 3 ) == 27 );
        Test_Error( ppExponent( 10, 0 ) == 1 );
    }

    {
        int curr;
        curr = 0;
        for( curr = 0; curr < 1000; ++curr )
        {
            int tally = 0;
            ppDuff( 4, curr, tally++ );
            Test_Error( tally == curr );

            tally = 0;
            ppDuff( 8, curr, tally++ );
            Test_Error( tally == curr );

            tally = 0;
            ppDuff( 32, curr, tally++ );
            Test_Error( tally == curr );

            tally = 0;
            ppDuff( 64, curr, tally++ );
            Test_Error( tally == curr );

            tally = 0;
            ppDuff( 128, curr, tally++ );
            Test_Error( tally == curr );

            tally = 0;
            ppDuff( 256, curr, tally++ );
            Test_Error( tally == curr );
        }
    }
    /* Test permutations */
    {
        int tally;
        int p1,p2,p3,p4,p5;
        p1=p2=p3=p4=p5=tally = 0;

#define BeginCheck()\
        {\
            tally=0;\
            /*printf("\n");*/\
        }
#define DoCheck()\
        {\
            tally++;\
            /*printf( "%d %d %d %d %d\n", p1,p2,p3,p4,p5 );*/\
        }
        BeginCheck();
        exponents_2( p1,p2, 0,4 )
            DoCheck();
        Test_Error( tally == exponents_2_calc(0,4) );
        BeginCheck();
        arrangements_2( p1,p2, 0,4 )
            DoCheck();
        Test_Error( tally == arrangements_2_calc(0,4) );
        BeginCheck();
        combinations_2( p1,p2, 0,4 )
            DoCheck();
        Test_Error( tally == combinations_2_calc(0,4) );

        BeginCheck()
        exponents_3( p1,p2,p3, 0,5 )
            DoCheck();
        Test_Error( tally == exponents_3_calc(0,5) );
        BeginCheck();
        arrangements_3( p1,p2,p3,0,5 )
            DoCheck();
        Test_Error( tally == arrangements_3_calc(0,5) );
        BeginCheck();
        combinations_3( p1,p2,p3, 0,5 )
            DoCheck();
        Test_Error( tally == combinations_3_calc(0,5) );

        BeginCheck()
        exponents_4( p1,p2,p3,p4, 0,6 )
            DoCheck();
        Test_Error( tally == exponents_4_calc(0,6) );
        BeginCheck();
        arrangements_4( p1,p2,p3,p4, 0,6 )
            DoCheck();
        Test_Error( tally == arrangements_4_calc(0,6) );
        BeginCheck();
        combinations_4( p1,p2,p3,p4, 0,6 )
            DoCheck();
        Test_Error( tally == combinations_4_calc(0,6) );
    
        BeginCheck()
        exponents_5( p1,p2,p3,p4,p5, 0,7 )
            DoCheck();
        Test_Error( tally == exponents_5_calc(0,7) );
        BeginCheck();
        arrangements_5( p1,p2,p3,p4,p5, 0,7 )
            DoCheck();
        Test_Error( tally == arrangements_5_calc(0,7) );
        BeginCheck();
        combinations_5( p1,p2,p3,p4,p5, 0,7 )
            DoCheck();
        Test_Error( tally == combinations_5_calc(0,7) );
    }
};

void Test_ppRand(void)
{
    ppRandSeed_T seed = 1;
    int remain = 10000;
    while( remain-- )
    {
#if 1
        ppRandSeed_T val = ppRand(seed);
        Test_Error( val >= 0 /*&& val <= int32_max*/ );
#else
        double val = ppfRand(seed);
        Test_Error( val >= 0.0 && val <= 1.0 );
#endif
    }
    Test_Error( 1043618065 == seed );
}


#endif /* CTL_UNIT */