home *** CD-ROM | disk | FTP | other *** search
/ Dream 57 / Amiga_Dream_57.iso / Amiga / Jeux / Reflexion / Crafty-15.19.lha / crafty-15.19 / src / ulonglong.h < prev    next >
C/C++ Source or Header  |  1998-10-01  |  6KB  |  171 lines
  1. /* Experimental class for compiling Crafty without the long long support */
  2. /* The idea was to allow compilation with SAS/C and also to see if
  3.  * if the log2N algorithm would make Crafty play faster
  4.  */
  5. /* Author: Dominique Lorre */
  6.  
  7. class ULONGLONG
  8. {
  9. public:
  10.     unsigned long hi ;
  11.     unsigned long lo ;
  12.     ULONGLONG() { hi = lo = 0 ; }
  13.     ULONGLONG(int n) { hi = 0 ; lo = n ; }
  14.     ULONGLONG(unsigned long h, unsigned long l) : hi(h), lo(l) {}
  15.     ULONGLONG operator<<(int n)
  16.     {ULONGLONG r = *this ;
  17.     unsigned long mask ;
  18.         if (n > 31) {
  19.             r.hi = r.lo ;
  20.             r.lo = 0 ;
  21.             r.hi <<= (n - 32) ;
  22.         }
  23.         else {
  24.             r.hi <<= n ;
  25.             mask = r.lo >> (32 - n );
  26.             r.lo <<= n ;
  27.             r.hi |= mask ;
  28.         }
  29.         return r ;
  30.     }
  31.     ULONGLONG operator>>(int n)
  32.     {ULONGLONG r = *this ;
  33.     unsigned long mask ;
  34.         if (n > 31) {
  35.             r.lo = r.hi ;
  36.             r.hi = 0 ;
  37.             r.lo >>= (n - 32) ;
  38.         }
  39.         else {
  40.             r.lo >>= n ;
  41.             mask = r.hi << (32 - n );
  42.             r.hi >>= n ;
  43.             r.lo |= mask ;
  44.         }
  45.         return r ;
  46.     }
  47.     friend ULONGLONG operator- (ULONGLONG a) {return ULONGLONG(-a.hi, -a.lo) ; }
  48.     friend ULONGLONG operator- (ULONGLONG a, ULONGLONG b)
  49.     {
  50.         if (b > a)
  51.             return ULONGLONG(0) ; // underflow
  52.         else {
  53.             if (b.lo <= a.lo)   // a.hi >= b.hi
  54.                 return (ULONGLONG(a.hi-b.hi, a.lo-b.lo)) ; // a>b => a.hi >= b.hi
  55.             else  // a.hi > b.hi
  56.                 return (ULONGLONG(a.hi-b.hi-1, (0xFFFFFFFF - b.lo) + a.lo + 1)) ;
  57.  
  58.         }
  59.     }
  60.     friend ULONGLONG operator- (ULONGLONG a, int b)
  61.     {
  62.         return a - ULONGLONG(b) ;
  63.     }
  64.  
  65.     friend ULONGLONG operator+ (ULONGLONG a, ULONGLONG b)
  66.     {
  67.         if ((a.lo & 0x80000000) || (b.lo & 0x80000000)) {
  68.         unsigned long hisum, losum ;
  69.             hisum = a.hi+b.hi ;
  70.             losum = a.lo+b.lo ;
  71.             if (a.lo & 0x80000000 && b.lo & 0x80000000) { // simple case
  72.                 return ULONGLONG(hisum+1, losum) ;
  73.             }
  74.             else  if (losum & 0x80000000) {á// no carry
  75.                 return ULONGLONG(hisum, losum) ;
  76.             }
  77.             else {
  78.                 return ULONGLONG(hisum+1, losum) ;
  79.             }
  80.     }
  81.     else
  82.         return ULONGLONG(a.hi+b.hi, a.lo+b.lo) ;
  83.     }
  84.     friend ULONGLONG operator+ (ULONGLONG a, int b)
  85.     {
  86.         return a+ULONGLONG(b) ;
  87.     }
  88.  
  89.     /* log2 N algorithm */
  90.  
  91.     friend ULONGLONG operator* (ULONGLONG a, ULONGLONG b)
  92.     {
  93.     ULONGLONG r = ULONGLONG(0,0) ;
  94.  
  95.         if (a == 0 || b == 0)
  96.             return ULONGLONG(0) ;
  97.         else {
  98.             while (b != 0) {
  99.                 if (b.lo & 1) {
  100.                     r = r + a ;
  101.                 }
  102.                 b = b >> 1 ;
  103.                 if (b != 0) a = a << 1 ;
  104.             }
  105.         }
  106.         return r ;
  107.     }
  108.     friend ULONGLONG operator* (ULONGLONG a, int b)
  109.     {
  110.         return a * ULONGLONG(b) ;
  111.     }
  112.  
  113.     /* This algorithm is slow but I do not remember the faster one */
  114.  
  115.     friend ULONGLONG operator/ (ULONGLONG a, ULONGLONG b)
  116.     {
  117.     ULONGLONG r = ULONGLONG(0,0) ;
  118.  
  119.         if (b == 0) return ULONGLONG(1 / 0) ;  // divide error
  120.         while (a >= b) {
  121.             a = a-b ;
  122.             r++ ;
  123.        }
  124.         return r ;
  125.     }
  126.     friend ULONGLONG operator/ (ULONGLONG a, int b)
  127.     {
  128.         return a / ULONGLONG(b) ;
  129.     }
  130.  
  131.     friend ULONGLONG operator& (ULONGLONG a, ULONGLONG b) {return ULONGLONG(a.hi&b.hi,a.lo&b.lo) ; }
  132.     friend ULONGLONG operator& (ULONGLONG a, int n) {return ULONGLONG(0,a.lo&n) ; }
  133.  
  134.     friend ULONGLONG operator| (ULONGLONG a, ULONGLONG b) { return ULONGLONG(a.hi|b.hi, a.lo|b.lo) ;}
  135.  
  136.     friend ULONGLONG operator^ (ULONGLONG a, ULONGLONG b) { return ULONGLONG(a.hi^b.hi, a.lo^b.lo) ; }
  137.  
  138.     friend ULONGLONG operator~(ULONGLONG a) {return ULONGLONG(~a.hi,~a.lo) ;}
  139.  
  140.     void operator=(int n) { hi = 0 ; lo = n ; }
  141.  
  142.     friend int operator==(ULONGLONG a, int n) { return ((!a.hi) && (a.lo == n))  ; }
  143.     friend int operator==(ULONGLONG a, ULONGLONG b) { return ((a.hi == b.hi)  && (a.lo == b.lo))  ; }
  144.     friend int operator>(ULONGLONG a, ULONGLONG b) { return ((a.hi > b.hi)  || ((a.hi == b.hi) && (a.lo > b.lo)))  ; }
  145.     friend int operator>=(ULONGLONG a, ULONGLONG b) { return ((a.hi > b.hi)  || ((a.hi == b.hi) && (a.lo >= b.lo)))  ; }
  146.     friend int operator<(ULONGLONG a, ULONGLONG b) { return ((a.hi < b.hi)  || ((a.hi == b.hi) && (a.lo < b.lo)))  ; }
  147.  
  148.     friend int operator!=(ULONGLONG a, int n) { return (a.hi || a.lo != n)  ; }
  149.  
  150.     friend int operator!(ULONGLONG a) { return !(a.lo || a.hi) ; }
  151.  
  152.     friend int operator && (int n, ULONGLONG a) { return (n && (a.hi || a.lo)) ; }
  153.     friend int operator && (ULONGLONG a, int n) { return (n && (a.hi || a.lo)) ; }
  154.     friend int operator && (ULONGLONG a, ULONGLONG b) { return ((a.hi || a.lo) && (b.hi || b.lo)) ; }
  155.     friend int operator || (int n, ULONGLONG a) { return (n || (a.hi || a.lo)) ; }
  156.     friend int operator || (ULONGLONG a, ULONGLONG b) { return (b.hi || b.lo || (a.hi || a.lo)) ; }
  157.  
  158.     ULONGLONG operator++() { if (lo < 0xFFFFFFFF) lo++ ; else {hi++ ; lo = 0 ; } return *this ;  }
  159.     ULONGLONG operator++(int) { ULONGLONG r = *this ; if (lo < 0xFFFFFFFF) lo++ ; else {hi++ ; lo = 0 ; } return r ;  }
  160.  
  161.     ULONGLONG operator--() { if (lo > 0) lo-- ; else {hi-- ; lo = 0xFFFFFFFF ; } return *this ;  }
  162.     ULONGLONG operator--(int) { ULONGLONG r = *this ; if (lo > 0) lo-- ; else {hi-- ; lo = 0xFFFFFFFF ; } return r ;  }
  163.  
  164.     void operator &=(ULONGLONG a) {lo &= a.lo ; hi &= a.hi ;}
  165.     void operator &=(int n) { lo &= n ; }
  166.  
  167.     void operator |=(ULONGLONG a) { hi |= a.hi ; lo |= a.lo ; }
  168.     void operator |=(int n) { lo |= n ; }
  169.     friend int cvint(ULONGLONG a) { return a.lo ; }
  170. }  ;
  171.