ctldef.h

Go to the documentation of this file.
00001 #ifndef CTLDEF_H
00002 #define CTLDEF_H
00003 
00013 #include <stdlib.h>
00014 #include <stddef.h>
00015 #include <string.h>
00016 #define _USE_MATH_DEFINES /* VC doesn't define standard things without this */
00017 #include <math.h>
00018 #include <setjmp.h>
00019 
00020 #ifndef PP_H
00021 #include "ctl/pp.h"
00022 #endif
00023 #ifndef DEBUG_H
00024 #include "ctl/debug.h"
00025 #endif
00026 #ifndef ITERATE_H
00027 #include "ctl/iterate.h"
00028 #endif
00029 
00030 
00036 #ifdef __GNUC__
00037 
00040 #ifndef __cplusplus
00041 typedef enum { false, true }    bool;       
00042 #endif
00043 typedef signed char             int8;
00044 typedef unsigned char           uint8;
00045 typedef signed short            int16;
00046 typedef unsigned short          uint16;
00047 typedef signed long             int32;
00048 typedef unsigned long           uint32;
00049 typedef float                   float32;
00050 typedef double                  float64;
00051 typedef signed long long        int64;
00052 typedef unsigned long long      uint64;
00053 #define __int64const(v)         v##ll
00054 #define int64const(v)           __int64const(v)
00055 #define __uint64const(v)        v##ull
00056 #define uint64const(v)          __uint64const(v)
00057 #ifdef WIN32 /*MINGW*/
00058 /* Under mingw, apparently the Win32 SDK differs, and '%ll' works under Vista 
00059  * and not under XP.  So we have to use a special hack for the format specs */
00060 #define LLD(tchar)              szconst(tchar,"I64d")
00061 #define LLU(tchar)              szconst(tchar,"I64u")
00062 #define LLX(tchar)              szconst(tchar,"I64x")
00063 #else
00064 #define LLD(tchar)              szconst(tchar,"lld")
00065 #define LLU(tchar)              szconst(tchar,"llu")
00066 #define LLX(tchar)              szconst(tchar,"llx")
00067 #endif
00068 
00069 #define intentional_assignment(a)   (a)
00070 #define unused(a)                   __attribute__((unused)) a
00071 #endif /* __GNUC__ */
00072 
00073 #ifdef _MSC_VER /* Just assume it's MSVC - TODO: revisit */
00074 
00077 #ifndef __cplusplus
00078 typedef enum { false, true }    bool;       
00079 #endif
00080 typedef signed char             int8;
00081 typedef unsigned char           uint8;
00082 typedef signed short            int16;
00083 typedef unsigned short          uint16;
00084 typedef signed long             int32;
00085 typedef unsigned long           uint32;
00086 typedef float                   float32;
00087 typedef double                  float64;
00088 typedef __int64                 int64;
00089 typedef unsigned __int64        uint64;
00090 #define __int64const(v)         v##i64
00091 #define int64const(v)           __int64const(v)
00092 #define __uint64const(v)        v##ui64
00093 #define uint64const(v)          __uint64const(v)
00094 #define LLD(tchar)              szconst(tchar,"I64d")
00095 #define LLU(tchar)              szconst(tchar,"I64u")
00096 #define LLX(tchar)              szconst(tchar,"I64x")
00097 #define __attribute__( p )          /* GCC uses this to get rid of warnings; define it so MSVC doesn't spew. */
00098 #pragma warning( disable : 4100 )   /* "unreferenced formal parameter"  Visual studio.net warns on this, then errors when you strip the name for the typical fix */
00099 #pragma warning( disable : 4127 )   /* conditional expression is constant */
00100 #pragma warning( disable : 4204 )   /* "nonstandard extension used : non-constant aggregate initializer" - well, I use it, and it's handy.  Generally declarative macros ending with '_auto' use it.  If your compiler doesn't support this, don't use those macros; there's always a seperate init. */
00101 #pragma warning( disable : 4221 )   /* "nonstandard extension used : 'var' : cannot be initialized using address of automatic variable 'var'"  Basically the same as 4204, above.  */
00102 #pragma warning( disable : 4786 )   /* 'identifier' : identifier was truncated to 'number' characters in the debug information (if you use stl with VC6 or earlier, you get bombarded by these) */
00103 #pragma warning( disable : 4514 )   /* unreferenced inline function has been removed (DUH!) */
00104 #pragma warning( disable : 4710 )   /* function 'function-name' not inlined */
00105 #pragma warning( disable : 4702 )   /* unreachable code (Basically hits all over the place in stl... and in a few of my templates in ways that are hard to reconcile.) */
00106 #pragma warning( disable : 4132 )   /* 'identifier' : const object should be initialized  - Bug in VC: A static is forward declared with 'static'.  VC complains that arrays forward declared 'static' are not initialized. */
00107 #pragma warning( disable : 4996 )   /* This function or variable may be unsafe. Consider using strncpy_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. */
00108 
00109 #define intentional_assignment(a)   (0 != (a))
00110 #define unused(a)                   a
00111 #endif /* _MSC_VER */
00112 
00113 
00114 /*
00115  * Platform dependency: Sometimes modulus behavior can't be trusted, so 
00116  * assuming that the preprocessor works the same as the compiler... 
00117  */
00118 #if ((-1%2)<0)
00119 
00120 #define abs_mod(type,v,d)           type_abs(type,(v)%(d))
00121 
00122 #define sign_mod(type,v,d)          ((v)%(d))
00123 #else
00124 #define abs_mod(type,v,d)           ((v)%(d))
00125 #define sign_mod(type,v,d)          type_set_sign(type,abs_mod(type,(v),(d)),(v))
00126 #endif
00127 
00131 ppC_CPP(bool _dummy_true(void);,inline bool _dummy_true(void) {return true;})
00132 ppC_CPP(bool _dummy_false(void);,inline bool _dummy_false(void) {return false;})
00133 #define invariant_true _dummy_true()
00134 #define invariant_false _dummy_false()
00135 
00147 #ifndef float64_compare_epsilon
00148 
00149 #define float64_compare_epsilon 0.000001
00150 #endif
00151 #ifndef float32_compare_epsilon
00152 
00153 #define float32_compare_epsilon 0.000001f
00154 #endif
00155 
00161 #define NumPlaces( type, val )              ppConcat(type,_NumPlaces)( (type)val )
00162 
00168 #define NumXPlaces( type, val )             ppConcat(type,_XNumPlaces)( (type)val )
00169 
00174 #define type_min(type)              ppConcat(type,_min)
00175 
00180 #define type_max(type)              ppConcat(type,_max)
00181 
00186 #define type_epsilon(type)              ppConcat(type,_epsilon)
00187 
00192 #define type_bits(type)                 ppConcat(type,_bits)
00193 
00198 #define type_issigned(type)             ppConcat(type,_issigned)
00199 
00204 #define type_isunsigned(type)           (!ppConcat(type,_issigned))
00205 
00210 #define type_isscalar(type)             ppConcat(type,_isscalar)
00211 
00217 #define if_signed(type,eval)            ppConcat(type(eval),_ifsigned)
00218 
00224 #define if_unsigned(type,eval)          ppConcat(type(eval),_ifunsigned)
00225 
00230 #define type_isfloat(type)              ppConcat(type,_isfloat)
00231 
00237 #define if_float(type,eval)             ppConcat(type,_iffloat)(eval)
00238 
00244 #define if_int(type,eval)               ppConcat(type,_ifint)(eval)
00245 
00250 #define type_signedtype(type)           ppConcat(type,_signedtype)
00251 
00256 #define type_unsignedtype(type)         ppConcat(type,_unsignedtype)
00257 
00265 #define type_printf(tchar,type)         ppConcat(type,_fmt)(tchar)
00266 
00271 #define typecast_printf(type)           ppConcat(type,_castfmt)
00272 
00273 
00281 #define type_xprintf(tchar,type)        ppConcat(type,_xfmt)(tchar)
00282 
00288 #define type_get_sign(type,value)       ppConcat(type,_sign)(value)
00289 
00296 #define type_set_sign(type,value,sign)  ppConcat(type,_setsign)(value,sign)
00297 
00303 #define type_abs(type,v)                ppConcat(type,_abs)(v)
00304 
00310 #define type_rand(type)                 ppConcat(type,_rand)()
00311 
00312 /* datagen.h operations  */
00313 #define bool_init( p )                  {(*p) = false;}
00314 #define bool_destroy( p )
00315 #define bool_copy( d, s )               (*(d) = *(s))
00316 #define bool_copy_t( d, stype, s )      ((d) = (bool)(0 != (s)))
00317 #define bool_move( d, s )               (*(d) = *(s))
00318 #define bool_swap( p1, p2 )             { bool tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00319 #define bool_valid( p )                 (*(p)==true || *(p)==false)
00320 #define bool_size( p )                  sizeof(p)
00321 #define bool_isscalar                   true
00322 /* scalar queries for templates */
00323 #define bool_min                        false
00324 #define bool_max                        true
00325 #define bool_epsilon                    true
00326 #define bool_bits                       1
00327 #define bool_issigned                   false
00328 #define bool_ifsigned(eval)             
00329 #define bool_ifunsigned(eval)           eval
00330 #define bool_isfloat                    false
00331 #define bool_iffloat(eval)
00332 #define bool_ifint(eval)                eval
00333 #define bool_signedtype                 int
00334 #define bool_unsignedtype               unsigned
00335 #define bool_sign(val)                  1
00336 #define bool_setsign(val)               (val)
00337 #define bool_abs(v)                     (v)
00338 #define bool_rand()                     (0 != (rand()&1))
00339 #define bool_NumPlaces(val)             1
00340 #define bool_XNumPlaces(val)            1
00341 #define bool_fmt(tchar)                 szconst(tchar,"d")
00342 #define bool_castfmt                    (int)
00343 #define bool_xfmt(tchar)                szconst(tchar,"x")
00344 
00345 
00346 /* datagen.h operations  */
00347 #define int8_init( p )                  {(*p) = 0;}
00348 #define int8_destroy( p )
00349 #define int8_copy( d, s )               (*(d) = (int8)*(s))
00350 #define int8_copy_t( d, stype, s )      ((d) = (int8)(s))
00351 #define int8_move( d, s )               (*(d) = (int8)*(s))
00352 #define int8_swap( p1, p2 )             { int8 tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00353 #define int8_valid( p )                 true
00354 #define int8_size( p )                  sizeof(p)
00355 #define int8_isscalar                   true
00356 /* scalar queries for templates */
00357 #define int8_min                        (int8)-128
00358 #define int8_max                        (int8)127
00359 #define int8_epsilon                    (int8)1
00360 #define int8_bits                       8
00361 #define int8_issigned                   true
00362 #define int8_ifsigned(eval)             eval
00363 #define int8_ifunsigned(eval)
00364 #define int8_isfloat                    false
00365 #define int8_iffloat(eval)
00366 #define int8_ifint(eval)                eval
00367 #define int8_signedtype                 int8
00368 #define int8_unsignedtype               uint8
00369 #define int8_sign(val)                  ((val)<0?-1:1)
00370 #define int8_setsign(val)               ((sign)<0?(val)=-abs(val):abs(val))
00371 #define int8_abs(v)                     (int8)abs(v)
00372 #define int8_rand()                     randnegate((int8)rand())
00373 #define int8_NumPlaces(val)             int32_NumPlaces((int32)(val))
00374 #define int8_XNumPlaces(val)            uint32_XNumPlaces((uint32)(val))
00375 #define int8_fmt(tchar)                 szconst(tchar,"d")
00376 #define int8_castfmt                    (int)
00377 #define int8_xfmt(tchar)                szconst(tchar,"x")
00378 
00379 /* datagen.h operations  */
00380 #define uint8_init( p )                 {(*p) = 0;}
00381 #define uint8_destroy( p )
00382 #define uint8_copy( d, s )              (*(d) = (uint8)*(s))
00383 #define uint8_copy_t( d, stype, s )     ((d) = (uint8)(s))
00384 #define uint8_move( d, s )              (*(d) = (uint8)*(s))
00385 #define uint8_swap( p1, p2 )            { uint8 tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00386 #define uint8_valid( p )                true
00387 #define uint8_size( p )                 sizeof(p)
00388 #define uint8_isscalar                  true
00389 /* scalar queries for templates */
00390 #define uint8_min                       (uint8)0
00391 #define uint8_max                       (uint8)255u
00392 #define uint8_epsilon                   (uint8)1
00393 #define uint8_bits                      8
00394 #define uint8_issigned                  false
00395 #define uint8_ifsigned(eval)            
00396 #define uint8_ifunsigned(eval)          eval
00397 #define uint8_isfloat                   false
00398 #define uint8_iffloat(eval)
00399 #define uint8_ifint(eval)               eval
00400 #define uint8_signedtype                int8
00401 #define uint8_unsignedtype              uint8
00402 #define uint8_sign(val)                 1
00403 #define uint8_setsign(val)              (val)
00404 #define uint8_abs(v)                    (v)
00405 #define uint8_rand()                    ((uint8)rand())
00406 #define uint8_NumPlaces(val)            uint32_NumPlaces((uint32)(val))
00407 #define uint8_XNumPlaces(val)           uint32_XNumPlaces((uint32)(val))
00408 #define uint8_fmt(tchar)                szconst(tchar,"u")
00409 #define uint8_castfmt                   (unsigned)
00410 #define uint8_xfmt(tchar)               szconst(tchar,"x")
00411 
00412 /* datagen.h operations  */
00413 #define int16_init( p )                 {(*p) = 0;}
00414 #define int16_destroy( p )
00415 #define int16_copy( d, s )              (*(d) = (int16)*(s))
00416 #define int16_copy_t( d, stype, s )     ((d) = (int16)(s))
00417 #define int16_move( d, s )              (*(d) = (int16)*(s))
00418 #define int16_swap( p1, p2 )            { int16 tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00419 #define int16_valid( p )                true
00420 #define int16_size( p )                 sizeof(p)
00421 #define int16_isscalar                  true
00422 /* scalar queries for templates */
00423 #define int16_min                       (int16)-32768
00424 #define int16_max                       (uint16)32767
00425 #define int16_epsilon                   (uint16)1
00426 #define int16_bits                      16
00427 #define int16_issigned                  true
00428 #define int16_ifsigned(eval)            eval
00429 #define int16_ifunsigned(eval)
00430 #define int16_isfloat                   false
00431 #define int16_iffloat(eval)
00432 #define int16_ifint(eval)               eval
00433 #define int16_signedtype                int16
00434 #define int16_unsignedtype              uint16
00435 #define int16_sign(val)                 ((val)<0?-1:1)
00436 #define int16_setsign(val)              ((sign)<0?(val)=-abs(val):abs(val))
00437 #define int16_abs(v)                    (int16)abs(v)
00438 #define int16_rand()                    randnegate((int16)rand()) 
00439 #define int16_NumPlaces(val)            int32_NumPlaces((int32)(val))
00440 #define int16_XNumPlaces(val)           uint32_XNumPlaces((uint32)(val))
00441 #define int16_fmt(tchar)                szconst(tchar,"hd")
00442 #define int16_castfmt                   (int16)
00443 #define int16_xfmt(tchar)               szconst(tchar,"hx")
00444 
00445 /* datagen.h operations  */
00446 #define uint16_init( p )                {(*p) = 0;}
00447 #define uint16_destroy( p )
00448 #define uint16_copy( d, s )             (*(d) = (uint16)*(s))
00449 #define uint16_copy_t( d, stype, s )    ((d) = (uint16)(s))
00450 #define uint16_move( d, s )             (*(d) = (uint16)*(s))
00451 #define uint16_swap( p1, p2 )           { uint16 tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00452 #define uint16_valid( p )               true
00453 #define uint16_size( p )                sizeof(p)
00454 #define uint16_isscalar                 true
00455 /* scalar queries for templates */
00456 #define uint16_min                      (uint16)0
00457 #define uint16_max                      (uint16)65535u
00458 #define uint16_epsilon                  (uint16)1
00459 #define uint16_bits                     16
00460 #define uint16_issigned                 false
00461 #define uint16_ifsigned(eval)           
00462 #define uint16_ifunsigned(eval)         eval
00463 #define uint16_isfloat                  false
00464 #define uint16_iffloat(eval)
00465 #define uint16_ifint(eval)              eval
00466 #define uint16_signedtype               int16
00467 #define uint16_unsignedtype             uint16
00468 #define uint16_sign(val)                1
00469 #define uint16_setsign(val)             (val)
00470 #define uint16_abs(v)                   (v)
00471 #define uint16_rand()                   ((uint16)rand())
00472 #define uint16_NumPlaces(val)           uint32_NumPlaces((uint32)(val))
00473 #define uint16_XNumPlaces(val)          uint32_XNumPlaces((uint32)(val))
00474 #define uint16_fmt(tchar)               szconst(tchar,"hu")
00475 #define uint16_castfmt                  (uint16)
00476 #define uint16_xfmt(tchar)              szconst(tchar,"hx")
00477 
00478 /* datagen.h operations  */
00479 #define int32_init( p )                 {(*p) = 0;}
00480 #define int32_destroy( p )
00481 #define int32_copy( d, s )              (*(d) = (int32)*(s))
00482 #define int32_copy_t( d, stype, s )     ((d) = (int32)(s))
00483 #define int32_move( d, s )              (*(d) = (int32)*(s))
00484 #define int32_swap( p1, p2 )            { int32 tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00485 #define int32_valid( p )                true
00486 #define int32_size( p )                 sizeof(p)
00487 #define int32_isscalar                  true
00488 /* scalar queries for templates */
00489 #define int32_min                       (int32)-2147483647 - 1
00490 #define int32_max                       (int32)2147483647
00491 #define int32_epsilon                   (int32)1
00492 #define int32_bits                      32
00493 #define int32_issigned                  true
00494 #define int32_ifsigned(eval)            eval
00495 #define int32_ifunsigned(eval)
00496 #define int32_isfloat                   false
00497 #define int32_iffloat(eval)
00498 #define int32_ifint(eval)               eval
00499 #define int32_signedtype                int32
00500 #define int32_unsignedtype              uint32
00501 #define int32_sign(val)                 ((val)<0?-1:1)
00502 #define int32_setsign(val)              ((sign)<0?(val)=-abs(val):abs(val))
00503 #define int32_abs(v)                    abs(v)
00504 #define int32_rand()                    randnegate( rand() ^ ((int32)rand()<<16) )
00505 size_t int32_NumPlaces( int32 val );
00506 #define int32_XNumPlaces(val)           uint32_XNumPlaces((uint32)(val))
00507 #define int32_fmt(tchar)                szconst(tchar,"d")
00508 #define int32_castfmt                   (int)
00509 #define int32_xfmt(tchar)               szconst(tchar,"x")
00510 
00511 /* datagen.h operations  */
00512 #define uint32_init( p )                {(*p) = 0;}
00513 #define uint32_destroy( p )
00514 #define uint32_copy( d, s )             (*(d) = (uint32)*(s))
00515 #define uint32_copy_t( d, stype, s )    ((d) = (uint32)(s))
00516 #define uint32_move( d, s )             (*(d) = (uint32)*(s))
00517 #define uint32_swap( p1, p2 )           { uint32 tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00518 #define uint32_valid( p )               true
00519 #define uint32_size( p )                sizeof(p)
00520 #define uint32_isscalar                 true
00521 /* scalar queries for templates */
00522 #define uint32_min                      (uint32)0
00523 #define uint32_max                      (uint32)4294967295u
00524 #define uint32_epsilon                  (uint32)1
00525 #define uint32_bits                     32
00526 #define uint32_issigned                 false
00527 #define uint32_ifsigned(eval)           
00528 #define uint32_ifunsigned(eval)         eval
00529 #define uint32_isfloat                  false
00530 #define uint32_iffloat(eval)
00531 #define uint32_ifint(eval)              eval
00532 #define uint32_signedtype               int32
00533 #define uint32_unsignedtype             uint32
00534 #define uint32_sign(val)                1
00535 #define uint32_setsign(val)             (val)
00536 #define uint32_abs(v)                   (v)
00537 #define uint32_rand()                   ( rand() ^ ((uint32)rand()<<16) )
00538 size_t uint32_NumPlaces( uint32 val );
00539 size_t uint32_XNumPlaces( uint32 val );
00540 #define uint32_fmt(tchar)               szconst(tchar,"u")
00541 #define uint32_castfmt                  (unsigned)
00542 #define uint32_xfmt(tchar)              szconst(tchar,"x")
00543 
00544 /* datagen.h operations  */
00545 #define int64_init( p )                 {(*p) = 0;}
00546 #define int64_destroy( p )
00547 #define int64_copy( d, s )              (*(d) = (int64)*(s))
00548 #define int64_copy_t( d, stype, s )     ((d) = (int64)(s))
00549 #define int64_move( d, s )              (*(d) = (int64)*(s))
00550 #define int64_swap( p1, p2 )            { int64 tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00551 #define int64_valid( p )                true
00552 #define int64_size( p )                 sizeof(p)
00553 #define int64_isscalar                  true
00554 /* scalar queries for templates */
00555 #define int64_min                       int64const(-9223372036854775807)-1
00556 #define int64_max                       int64const(9223372036854775807)
00557 #define int64_epsilon                   (int64)1
00558 #define int64_bits                      64
00559 #define int64_issigned                  true
00560 #define int64_ifsigned(eval)            
00561 #define int64_ifunsigned(eval)          eval
00562 #define int64_isfloat                   false
00563 #define int64_iffloat(eval)
00564 #define int64_ifint(eval)               eval
00565 #define int64_signedtype                int64
00566 #define int64_unsignedtype              uint64
00567 #define int64_sign(val)                 ((val)<0?-1:1)
00568 #define int64_setsign(val)              ((sign)<0?(val)=-abs(val):abs(val))
00569 #define int64_abs(v)                    ((v)<0?-(v):(v))
00570 #define int64_rand()                    randnegate( rand() ^ ((int64)rand()<<16) ^ ((int64)rand()<<32) ^ ((int64)rand()<<48) )
00571 size_t int64_NumPlaces( int64 val );
00572 #define int64_XNumPlaces(val)           uint64_XNumPlaces((uint64)(val))
00573 #define int64_fmt(tchar)                LLD(tchar)
00574 #define int64_castfmt                   (int64)
00575 #define int64_xfmt(tchar)               LLX(tchar)
00576 
00577 /* datagen.h operations  */
00578 #define uint64_init( p )                {(*p) = 0;}
00579 #define uint64_destroy( p )
00580 #define uint64_copy( d, s )             (*(d) = (uint64)*(s))
00581 #define uint64_copy_t( d, stype, s )    ((d) = (uint64)(s))
00582 #define uint64_move( d, s )             (*(d) = (uint64)*(s))
00583 #define uint64_swap( p1, p2 )           { uint64 tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00584 #define uint64_valid( p )               true
00585 #define uint64_size( p )                sizeof(p)
00586 #define uint64_isscalar                 true
00587 /* scalar queries for templates */
00588 #define uint64_min                      uint64const(0)
00589 #define uint64_max                      uint64const(18446744073709551615)
00590 #define uint64_epsilon                  (uint64)1
00591 #define uint64_bits                     64
00592 #define uint64_issigned                 false
00593 #define uint64_ifsigned(eval)           eval
00594 #define uint64_ifunsigned(eval)
00595 #define uint64_isfloat                  false
00596 #define uint64_iffloat(eval)
00597 #define uint64_ifint(eval)              eval
00598 #define uint64_signedtype               int64
00599 #define uint64_unsignedtype             uint64
00600 #define uint64_sign(val)                1
00601 #define uint64_setsign(val)             (val)
00602 #define uint64_abs(v)                   (v)
00603 #define uint64_rand()                   ( rand() ^ ((uint64)rand()<<16) ^ ((uint64)rand()<<32) ^ ((uint64)rand()<<48) )
00604 size_t uint64_NumPlaces( uint64 val );
00605 size_t uint64_XNumPlaces( uint64 val );
00606 #define uint64_fmt(tchar)               LLU(tchar)
00607 #define uint64_castfmt                  (uint64)
00608 #define uint64_xfmt(tchar)              LLX(tchar)
00609 
00610 /* datagen.h operations  */
00611 #define float32_init( p )               {(*p) = 0.0f;}
00612 #define float32_destroy( p )
00613 #define float32_copy( d, s )            (*(d) = (float32)*(s))
00614 #define float32_copy_t( d, stype, s )   ((d) = (float32)(s))
00615 #define float32_move( d, s )            (*(d) = (float32)*(s))
00616 #define float32_swap( p1, p2 )          { float32 tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00617 #define float32_valid( p )              true
00618 #define float32_size( p )               sizeof(p)
00619 #define float32_isscalar                true
00620 /* scalar queries for templates */
00621 #define float32_min                     -3.402823466e+38f
00622 #define float32_max                     3.402823466e+38f
00623 #define float32_epsilon                 1.192092896e-7f
00624 #define float32_bits                    32
00625 #define float32_issigned                true
00626 #define float32_ifsigned(eval)          eval
00627 #define float32_ifunsigned(eval)
00628 #define float32_isfloat                 true
00629 #define float32_iffloat(eval)           eval
00630 #define float32_ifint(eval)
00631 #define float32_signedtype              float32
00632 #define float32_unsignedtype            float32
00633 #define float32_sign(val)               ((val)<0.0f?-1:1)
00634 #define float32_setsign(val)            ((sign)<0?(val)=-(float)fabs(val):(float)fabs(val))
00635 #define float32_abs(v)                  (float)fabs(v) /* fabsf(v) doesn't turn up in VC CRT */
00636 #define float32_rand()                  ( (float32)int32_rand() + ((float32)int32_rand()*(1.0f/uint32_max)) )
00637 size_t float32_NumPlaces( float32 val );
00638 #define float32_XNumPlaces(val)         uint32_XNumPlaces((uint32)(val))
00639 #define float32_fmt(tchar)              szconst(tchar,"f")
00640 #define float32_castfmt                 (double)
00641 #define float32_xfmt(tchar)             szconst(tchar,"e")
00642 
00643 /* datagen.h operations  */
00644 #define float64_init( p )               {(*p) = 0.0;}
00645 #define float64_destroy( p )
00646 #define float64_copy( d, s )            (*(d) = (float64)*(s))
00647 #define float64_copy_t( d, stype, s )   ((d) = (float64)(s))
00648 #define float64_move( d, s )            float64_copy( d, s )
00649 #define float64_swap( p1, p2 )          { float64 tmp = *(p1); *(p1) = *(p2); *(p2) = tmp; }
00650 #define float64_valid( p )              true
00651 #define float64_size( p )               sizeof(p)
00652 #define float64_isscalar                true
00653 /* scalar queries for templates */
00654 #define float64_min                     -1.7976931348623158e+308
00655 #define float64_max                     1.7976931348623158e+308
00656 #define float64_epsilon                 2.2204460492503131e-16
00657 #define float64_bits                    64
00658 #define float64_issigned                true
00659 #define float64_ifsigned(eval)          eval
00660 #define float64_ifunsigned(eval)
00661 #define float64_isfloat                 true
00662 #define float64_iffloat(eval)           eval
00663 #define float64_ifint(eval)
00664 #define float64_signedtype              float64
00665 #define float64_unsignedtype            float64
00666 #define float64_sign(val)               ((val)<0.0?-1:1)
00667 #define float64_setsign(val)            ((sign)<0?(val)=-fabs(val):fabs(val))
00668 #define float64_abs(v)                  fabs(v)
00669 #define float64_rand()                  ( (float64)int64_rand() + ((float64)int64_rand()*(1.0/uint64_max)) )
00670 size_t float64_NumPlaces( float64 val );
00671 #define float64_XNumPlaces(val)         uint64_XNumPlaces((uint64)(val))
00672 #define float64_fmt(tchar)              szconst(tchar,"f")
00673 #define float64_castfmt                 (double)
00674 #define float64_xfmt(tchar)             szconst(tchar,"e")
00675 
00676 #ifndef max
00677 #define max(a,b) ((a)>(b)?(a):(b))
00678 #endif
00679 #ifndef min
00680 #define min(a,b) ((a)<(b)?(a):(b))
00681 #endif
00682 
00686 #define DEF_ENUMTYPES(def,param) \
00687     def(bool,param)\
00688     def(int8,param)\
00689     def(uint8,param)\
00690     def(int16,param)\
00691     def(uint16,param)\
00692     def(int32,param)\
00693     def(uint32,param)\
00694     def(int64,param)\
00695     def(uint64,param)\
00696     def(float32,param)\
00697     def(float64,param)\
00698 
00699 
00704 #define DEF_ENUMTYPES_INNER(def,param) \
00705     def(bool,param)\
00706     def(int8,param)\
00707     def(uint8,param)\
00708     def(int16,param)\
00709     def(uint16,param)\
00710     def(int32,param)\
00711     def(uint32,param)\
00712     def(int64,param)\
00713     def(uint64,param)\
00714     def(float32,param)\
00715     def(float64,param)\
00716 
00717 
00721 typedef union ctl_scalar_union
00722 {
00723 #define X_UNION(type,unused) type ppConcat(m,type);
00724     DEF_ENUMTYPES(X_UNION,unused)
00725 #undef X_UNION
00726 } ctl_scalar_union;
00727 
00728 #ifndef min
00729 
00733 #define min(a,b) ((a)<(b)?(a):(b))
00734 #endif
00735 
00736 #ifndef max
00737 
00741 #define max(a,b) ((a)>(b)?(a):(b))
00742 #endif
00743 
00744 #ifndef roundup
00745 
00752 #define roundup_signed(val,mod) (((val)+((val)<0?-(mod)+1:(mod)-1))/(mod)*(mod))
00753 #define roundup(val,mod)        ( ((val)+(mod)-1)/(mod)*(mod))
00754 #endif
00755 
00756 #ifndef rounddown
00757 
00764 #define rounddown(val,mod)  ((val)/(mod)*(mod))
00765 #endif
00766 
00774 #define nextround(val,mod)  (rounddown(val,(mod))+(mod))
00775 
00782 #define ispow2(val)         (0 == ((val)-1) & (val))
00783 
00791 #define incwrap(val,limit)  (++(val) > (limit) ? ((val) = 0) : (val))
00792 
00800 #define decwrap(val,limit)  (--(val) < (0) ? ((val) = (limit)) : (val))
00801 
00810 #define valid(val,lmin,lmax)    ((val)>=(lmin)&&(val)<=lmax)
00811 
00820 #define limit(val,lmin,lmax)    ((val)<(lmin)?(lmin):((val)>(lmax)?(lmax):(val)))
00821 
00830 #define wrap(val,lmin,lmax)     ( (val)=( (val)<(lmin) ? ( 1+(lmax) - (((lmin)-(val))%(1+(lmax)-(lmin))) ) : ((val)%(1+(lmax)-(lmin))) ) )
00831 
00836 #define further(val,distance)   ((val)<0?(val)-(distance):(val)+(distance))
00837 
00844 #define rand_count(type,count)      (type_rand(type)%(count))
00845 
00854 #define rand_between(type,low,high) ( (low) + rand_count(type_unsignedtype(type),1+(high)-(low)) )
00855 
00859 #define rand32()                ((float32)type_rand(uint32)*(1.0f/type_max(uint32)))
00860 
00864 #define rand64()                ((float32)type_rand(uint64)*(1.0f/type_max(uint64)))
00865 
00870 #define randnegate(val)         ( rand()&1 ? (val) : -(val) )
00871 
00872 /*
00873  * These are purely to make integer constant numbers more comfortable for entering and reading.
00874  * Instead of typing 9223372036854775808, you may type quintillion(9,223,372,036,854,775,808)
00875  */
00876 
00880 #define quintillion(QQQ,qqq,TTT,bbb,mmm,ttt,hhh)            QQQ##qqq##TTT##bbb##mmm##ttt##hhh
00881 
00885 #define quadrillion(qqq,TTT,bbb,mmm,ttt,hhh)                qqq##TTT##bbb##mmm##ttt##hhh
00886 
00890 #define trillion(TTT,bbb,mmm,ttt,hhh)                       TTT##bbb##mmm##ttt##hhh
00891 
00895 #define billion(bbb,mmm,ttt,hhh)                            bbb##mmm##ttt##hhh
00896 
00900 #define million(mmm,ttt,hhh)                                mmm##ttt##hhh
00901 
00905 #define thousand(ttt,hhh)                                   ttt##hhh
00906 
00910 #define ppBits8_msb( b7,b6,b5,b4, b3,b2,b1,b0 ) ( (unsigned)(b0)|(unsigned)((b1)<<1)|(unsigned)((b2)<<2)|(unsigned)((b3)<<3) | (unsigned)((b4)<<4)|(unsigned)((b5)<<5)|(unsigned)((b6)<<6)|(unsigned)((b7)<<7) )
00911 
00915 #define ppBits8_lsb( b0,b1,b2,b3, b4,b5,b6,b7 ) ( (unsigned)(b0)|(unsigned)((b1)<<1)|(unsigned)((b2)<<2)|(unsigned)((b3)<<3) | (unsigned)((b4)<<4)|(unsigned)((b5)<<5)|(unsigned)((b6)<<6)|(unsigned)((b7)<<7) )
00916 
00920 #define ppBits16_msb( bf,be,bd,bc, bb,ba,b9,b8, b7,b6,b5,b4, b3,b2,b1,b0 ) \
00921     (ppBits8_msb( b7,b6,b5,b4, b3,b2,b1,b0 ) | \
00922     (ppBits8_msb( bf,be,bd,bc, bb,ba,b9,b8 )<<8) )
00923 
00927 #define ppBits16_lsb( b0,b1,b2,b3, b4,b5,b6,b7, b8,b9,ba,bb, bc,bd,be,bf ) \
00928     (ppBits8_lsb( b0,b1,b2,b3, b4,b5,b6,b7 ) | \
00929     (ppBits8_lsb( b8,b9,ba,bb, bc,bd,be,bf )<<8) )
00930 
00934 #define ppBits32_msb( bv,bu,bt,bs, br,bq,bp,bo, bn,bm,bl,bk, bj,bi,bh,bg, bf,be,bd,bc, bb,ba,b9,b8, b7,b6,b5,b4, b3,b2,b1,b0 ) \
00935     (ppBits16_msb( bf,be,bd,bc, bb,ba,b9,b8, b7,b6,b5,b4, b3,b2,b1,b0 ) | \
00936     (ppBits16_msb( bv,bu,bt,bs, br,bq,bp,bo, bn,bm,bl,bk, bj,bi,bh,bg )<<16) )
00937 
00941 #define ppBits32_lsb( b0,b1,b2,b3, b4,b5,b6,b7, b8,b9,ba,bb, bc,bd,be,bf, bg,bh,bi,bj, bk,bl,bm,bn, bo,bp,bq,br, bs,bt,bu,bv ) \
00942     (ppBits16_lsb( b0,b1,b2,b3, b4,b5,b6,b7, b8,b9,ba,bb, bc,bd,be,bf ) | \
00943     (ppBits16_lsb( bg,bh,bi,bj, bk,bl,bm,bn, bo,bp,bq,br, bs,bt,bu,bv )<<16) )
00944 
00945 /*
00946  * \brief Quicky "Minimum Standard" pseudo-random number generator 
00947  * \param seed ppRandSeed_T declared somewhere for this sequence of values
00948  * \return random value between 0 and 0x7fffffff
00949  * "Random Number Generators: Good Ones Are Hard to Find" - Stephen K. Park & Keith W. Miller
00950  * Originally worked out by D.H. Lehmer in 1951
00951  * Initially seeded with 1, the 10,000th invokation should yield 1043618065
00952  * Used for seeded half-assed cryptography that nobody will care about
00953  * The other two are variations that work 'better' according to several articles
00954  *
00955  * The group that's selected was the faster one on my recent Intel machine.
00956  * Tinker with Test_ppRand() change the #if and run the unit to check on yours.  
00957  * The difference was about 35ms vs 45ms for a million runs, so not dramatic.
00958  * The floating point version could come in handy on a system without 64 bit ints
00959  * or a language without them, such as Flash
00960  */
00961 #if 1
00962 #define ppRand(seed)    ((seed) = ((seed) * int64const(16807)) % 2147483647)
00963 #define ppRand2(seed)   ((seed) = ((seed) * int64const(48271)) % 2147483647)
00964 #define ppRand3(seed)   ((seed) = ((seed) * int64const(69621)) % 2147483647)
00965 typedef int32       ppRandSeed_T; 
00966 #define ppRand_MAX      2147483647
00967 #else
00968 #define ppRand(seed)    ((seed) = fmod((seed) * 16807.0, 2147483647.0))
00969 #define ppRand2(seed)   ((seed) = fmod((seed) * 48271.0, 2147483647.0))
00970 #define ppRand3(seed)   ((seed) = fmod((seed) * 69621.0, 2147483647.0))
00971 typedef float64     ppRandSeed_T;
00972 #define ppRand_MAX      2147483647.0
00973 #endif
00974 /* 
00975  * Quicky pseudo-random number floating point generator variant
00976  * \param seed Last value returned
00977  * \return random value between 0.0 and 1.0
00978  * Visits values between 0 and 1 with 31 bit precision; not full double precision
00979  */
00980 #define ppfRand(seed)   (((seed)=ppRand(seed)) * (1/ppRand_MAX) ) 
00981 #define ppfRand2(seed)  (((seed)=ppRand(seed)) * (1/ppRand_MAX) )
00982 #define ppfRand3(seed)  (((seed)=ppRand(seed)) * (1/ppRand_MAX) )
00983 
00984 
00985 #ifndef CTLNEW_H    /* Allocation helpers */
00986 #include "ctl/ctlnew.h"
00987 #endif
00988 #ifndef ARRAY_H     /* Fixed array definitions */
00989 #include "ctl/array.h"
00990 #endif
00991 #ifndef CTLSTRING_H /* Various magical string bits */
00992 #include "ctl/ctlstring.h"
00993 #endif
00994 
00995 #endif /* CTLDEF_H */

Generated on Fri Jan 2 15:28:34 2009 for Squat by  doxygen 1.5.6