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
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
00058
00059
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
00072
00073 #ifdef _MSC_VER
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 )
00098 #pragma warning( disable : 4100 )
00099 #pragma warning( disable : 4127 )
00100 #pragma warning( disable : 4204 )
00101 #pragma warning( disable : 4221 )
00102 #pragma warning( disable : 4786 )
00103 #pragma warning( disable : 4514 )
00104 #pragma warning( disable : 4710 )
00105 #pragma warning( disable : 4702 )
00106 #pragma warning( disable : 4132 )
00107 #pragma warning( disable : 4996 )
00108
00109 #define intentional_assignment(a) (0 != (a))
00110 #define unused(a) a
00111 #endif
00112
00113
00114
00115
00116
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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)
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
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
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
00874
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
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
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
00976
00977
00978
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
00986 #include "ctl/ctlnew.h"
00987 #endif
00988 #ifndef ARRAY_H
00989 #include "ctl/array.h"
00990 #endif
00991 #ifndef CTLSTRING_H
00992 #include "ctl/ctlstring.h"
00993 #endif
00994
00995 #endif