activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r564048 - in /activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util: BigInt.cpp BigInt.h
Date Thu, 09 Aug 2007 00:00:04 GMT
Author: tabish
Date: Wed Aug  8 17:00:02 2007
New Revision: 564048

URL: http://svn.apache.org/viewvc?view=rev&rev=564048
Log:
http://issues.apache.org/activemq/browse/AMQCPP-103

Adding in more Types wrappers

Modified:
    activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util/BigInt.cpp
    activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util/BigInt.h

Modified: activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util/BigInt.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util/BigInt.cpp?view=diff&rev=564048&r1=564047&r2=564048
==============================================================================
--- activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util/BigInt.cpp (original)
+++ activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util/BigInt.cpp Wed Aug
 8 17:00:02 2007
@@ -24,3 +24,729 @@
 ////////////////////////////////////////////////////////////////////////////////
 BigInt::BigInt() {
 }
+
+////////////////////////////////////////////////////////////////////////////////
+void BigInt::multiplyHighPrecision( unsigned long long* arg1,
+                                    int length1,
+                                    unsigned long long* arg2,
+                                    int length2,
+                                    unsigned long long* result,
+                                    int length ) {
+
+    // assumes result is large enough to hold product
+    unsigned long long *temp;
+    unsigned int *resultIn32;
+    int count, index;
+
+    if( length1 < length2 ) {
+        temp = arg1;
+        arg1 = arg2;
+        arg2 = temp;
+        count = length1;
+        length1 = length2;
+        length2 = count;
+    }
+
+    memset( result, 0, sizeof(unsigned long long) * length );
+
+    // length1 > length2
+    resultIn32 = (unsigned int*)result;
+    index = -1;
+    for( count = 0; count < length2; ++count ) {
+//        simpleMultiplyAddHighPrecision( arg1, length1, LOW_IN_U64( arg2[count] ),
+//                                        resultIn32 + (++index));
+//        simpleMultiplyAddHighPrecision( arg1, length1,
+//                                        HIGH_IN_U64( arg2[count] ),
+//                                        resultIn32 + (++index) );
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+unsigned int BigInt::simpleAppendDecimalDigitHighPrecision(
+        unsigned long long* arg1, int length, unsigned long long digit ) {
+
+      /* assumes digit is less than 32 bits */
+      unsigned long long arg;
+      int index = 0;
+
+      digit <<= 32;
+      do
+        {
+          arg = LOW_IN_U64 (arg1[index]);
+          digit = HIGH_IN_U64 (digit) + TIMES_TEN (arg);
+          LOW_U32_FROM_PTR (arg1 + index) = LOW_U32_FROM_VAR (digit);
+
+          arg = HIGH_IN_U64 (arg1[index]);
+          digit = HIGH_IN_U64 (digit) + TIMES_TEN (arg);
+          HIGH_U32_FROM_PTR (arg1 + index) = LOW_U32_FROM_VAR (digit);
+        }
+      while (++index < length);
+
+      return HIGH_U32_FROM_VAR (digit);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+double BigInt::toDoubleHighPrecision( unsigned long long* arg, int length ) {
+
+      int highBit;
+      unsigned long long mantissa, test64;
+      unsigned int test;
+      double result;
+
+      while (length > 0 && arg[length - 1] == 0)
+        --length;
+
+      if (length == 0)
+        result = 0.0;
+      else if (length > 16)
+        {
+          DOUBLE_TO_LONGBITS (result) = EXPONENT_MASK;
+        }
+      else if (length == 1)
+        {
+          highBit = highestSetBit (arg);
+          if (highBit <= 53)
+            {
+              highBit = 53 - highBit;
+              mantissa = *arg << highBit;
+              DOUBLE_TO_LONGBITS (result) =
+                CREATE_DOUBLE_BITS (mantissa, -highBit);
+            }
+          else
+            {
+              highBit -= 53;
+              mantissa = *arg >> highBit;
+              DOUBLE_TO_LONGBITS (result) =
+                CREATE_DOUBLE_BITS (mantissa, highBit);
+
+              /* perform rounding, round to even in case of tie */
+              test = (LOW_U32_FROM_PTR (arg) << (11 - highBit)) & 0x7FF;
+              if (test > 0x400 || ((test == 0x400) && (mantissa & 1)))
+                DOUBLE_TO_LONGBITS (result) = DOUBLE_TO_LONGBITS (result) + 1;
+            }
+        }
+      else
+        {
+          highBit = highestSetBit (arg + (--length));
+          if (highBit <= 53)
+            {
+              highBit = 53 - highBit;
+              if (highBit > 0)
+                {
+                  mantissa =
+                    (arg[length] << highBit) | (arg[length - 1] >>
+                                                (64 - highBit));
+                }
+              else
+                {
+                  mantissa = arg[length];
+                }
+              DOUBLE_TO_LONGBITS (result) =
+                CREATE_DOUBLE_BITS (mantissa, length * 64 - highBit);
+
+              /* perform rounding, round to even in case of tie */
+              test64 = arg[--length] << highBit;
+              if (test64 > SIGN_MASK || ((test64 == SIGN_MASK) && (mantissa &
1)))
+                DOUBLE_TO_LONGBITS (result) = DOUBLE_TO_LONGBITS (result) + 1;
+              else if (test64 == SIGN_MASK)
+                {
+                  while (--length >= 0)
+                    {
+                      if (arg[length] != 0)
+                        {
+                          DOUBLE_TO_LONGBITS (result) =
+                            DOUBLE_TO_LONGBITS (result) + 1;
+                          break;
+                        }
+                    }
+                }
+            }
+          else
+            {
+              highBit -= 53;
+              mantissa = arg[length] >> highBit;
+              DOUBLE_TO_LONGBITS (result) =
+                CREATE_DOUBLE_BITS (mantissa, length * 64 + highBit);
+
+              /* perform rounding, round to even in case of tie */
+              test = (LOW_U32_FROM_PTR (arg + length) << (11 - highBit)) & 0x7FF;
+              if (test > 0x400 || ((test == 0x400) && (mantissa & 1)))
+                DOUBLE_TO_LONGBITS (result) = DOUBLE_TO_LONGBITS (result) + 1;
+              else if (test == 0x400)
+                {
+                  do
+                    {
+                      if (arg[--length] != 0)
+                        {
+                          DOUBLE_TO_LONGBITS (result) =
+                            DOUBLE_TO_LONGBITS (result) + 1;
+                          break;
+                        }
+                    }
+                  while (length > 0);
+                }
+            }
+        }
+
+      return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::tenToTheEHighPrecision( unsigned long long * result,
+                                    int length, int e ) {
+
+    // size test
+    if( length < ((e / 19) + 1) ) {
+        return 0;
+    }
+
+    memset( result, 0, length * sizeof(unsigned long long) );
+    *result = 1;
+
+    if( e == 0 ) {
+        return 1;
+    }
+
+    length = 1;
+    length = timesTenToTheEHighPrecision( result, length, e );
+
+    return length;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+unsigned long long BigInt::doubleMantissa( double z ) {
+
+      unsigned long long m = DOUBLE_TO_LONGBITS (z);
+
+      if ((m & EXPONENT_MASK) != 0)
+        m = (m & MANTISSA_MASK) | NORMAL_MASK;
+      else
+        m = (m & MANTISSA_MASK);
+
+      return m;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::compareHighPrecision( unsigned long long* arg1,
+                                  int length1,
+                                  unsigned long long* arg2,
+                                  int length2 ) {
+
+    while( --length1 >= 0 && arg1[length1] == 0 );
+    while( --length2 >= 0 && arg2[length2] == 0 );
+
+    if( length1 > length2 ) {
+        return 1;
+    } else if( length1 < length2 ) {
+        return -1;
+    } else if( length1 > -1 ) {
+        do {
+            if( arg1[length1] > arg2[length1] ) {
+                return 1;
+            } else if( arg1[length1] < arg2[length1] ) {
+                return -1;
+            }
+        } while( --length1 >= 0 );
+    }
+
+    return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::highestSetBitHighPrecision( unsigned long long* arg, int length ) {
+
+    int highBit;
+
+    while( --length >= 0 ) {
+        highBit = highestSetBit( arg + length );
+        if( highBit ) {
+            return highBit + 64 * length;
+        }
+    }
+
+    return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BigInt::subtractHighPrecision( unsigned long long* arg1,
+                                    int length1,
+                                    unsigned long long* arg2,
+                                    int length2 ) {
+
+    // assumes arg1 > arg2
+
+    for( int index = 0; index < length1; ++index ) {
+        arg1[index] = ~arg1[index];
+    }
+
+    simpleAddHighPrecision( arg1, length1, 1 );
+
+    while( length2 > 0 && arg2[length2 - 1] == 0 ) {
+        --length2;
+    }
+
+    addHighPrecision( arg1, length1, arg2, length2 );
+
+    for( int index = 0; index < length1; ++index ) {
+        arg1[index] = ~arg1[index];
+    }
+
+    simpleAddHighPrecision( arg1, length1, 1 );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::doubleExponent( double z ) {
+
+      /* assumes positive double */
+      int k = HIGH_U32_FROM_VAR (z) >> 20;
+
+      if (k)
+        k -= E_OFFSET;
+      else
+        k = 1 - E_OFFSET;
+
+      return k;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+unsigned int BigInt::simpleMultiplyHighPrecision(
+    unsigned long long* arg1, int length, unsigned long long arg2 ) {
+
+    // assumes arg2 only holds 32 bits of information
+    unsigned long long product = 0;
+    int index = 0;
+
+//    do {
+//
+//        product =
+//            HIGH_IN_U64( product ) + arg2 * LOW_U32_FROM_PTR( arg1 + index );
+//
+//        LOW_U32_FROM_PTR( arg1 + index ) = LOW_U32_FROM_VAR( product );
+//
+//        product =
+//            HIGH_IN_U64(product) + arg2 * HIGH_U32_FROM_PTR( arg1 + index );
+//
+//        HIGH_U32_FROM_PTR( arg1 + index ) = LOW_U32_FROM_VAR( product );
+//
+//    } while( ++index < length );
+//
+//    return HIGH_U32_FROM_VAR( product );
+
+    return length;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::addHighPrecision( unsigned long long* arg1,
+                              int length1,
+                              unsigned long long* arg2,
+                              int length2 ) {
+
+    // addition is limited by length of arg1 as it this function is
+    // storing the result in arg1
+    //
+    // fix for cc (GCC) 3.2 20020903 (Red Hat Linux 8.0 3.2-7): code generated does not
+    // do the temp1 + temp2 + carry addition correct.  carry is 64 bit because gcc has
+    // subtle issues when you mix 64 / 32 bit maths.
+    unsigned long long temp1, temp2, temp3;     /* temporary variables to help the SH-4,
and gcc */
+    unsigned long long carry;
+    int index;
+
+    if( length1 == 0 || length2 == 0 ) {
+        return 0;
+    } else if( length1 < length2 ) {
+        length2 = length1;
+    }
+
+    carry = 0;
+    index = 0;
+
+    do {
+
+        temp1 = arg1[index];
+        temp2 = arg2[index];
+        temp3 = temp1 + temp2;
+        arg1[index] = temp3 + carry;
+
+        if( arg2[index] < arg1[index] ) {
+            carry = 0;
+        } else if( arg2[index] != arg1[index] ) {
+            carry = 1;
+        }
+
+    } while( ++index < length2 );
+
+    if( !carry ) {
+        return 0;
+    } else if( index == length1 ) {
+        return 1;
+    }
+
+    while( ++arg1[index] == 0 && ++index < length1 );
+
+    return (int)( index == length1 );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::lowestSetBit( unsigned long long* y ) {
+
+      unsigned int x;
+      int result;
+
+      if (*y == 0)
+        return 0;
+
+      if (*y & 0x00000000FFFFFFFFLL)
+        {
+          x = LOW_U32_FROM_PTR (y);
+          result = 0;
+        }
+      else
+        {
+          x = HIGH_U32_FROM_PTR (y);
+          result = 32;
+        }
+
+      if (!(x & 0xFFFF))
+        {
+          x = bitSection (x, 0xFFFF0000, 16);
+          result += 16;
+        }
+      if (!(x & 0xFF))
+        {
+          x = bitSection (x, 0xFF00, 8);
+          result += 8;
+        }
+      if (!(x & 0xF))
+        {
+          x = bitSection (x, 0xF0, 4);
+          result += 4;
+        }
+
+      if (x & 0x1)
+        return result + 1;
+      else if (x & 0x2)
+        return result + 2;
+      else if (x & 0x4)
+        return result + 3;
+      else
+        return result + 4;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::timesTenToTheEHighPrecision(
+    unsigned long long* result, int length, int e ) {
+
+    // assumes result can hold value
+    unsigned long long overflow;
+    int exp10 = e;
+
+    if( e == 0 ) {
+        return length;
+    }
+
+    // Replace the current implementaion which performs a
+    // "multiplication" by 10 e number of times with an actual
+    // mulitplication. 10e19 is the largest exponent to the power of ten
+    // that will fit in a 64-bit integer, and 10e9 is the largest exponent to
+    // the power of ten that will fit in a 64-bit integer. Not sure where the
+    // break-even point is between an actual multiplication and a
+    // simpleAappendDecimalDigit() so just pick 10e3 as that point for
+    // now.
+    while( exp10 >= 19 ) {
+        overflow = simpleMultiplyHighPrecision64( result, length, TEN_E19 );
+        if( overflow ) {
+            result[length++] = overflow;
+        }
+        exp10 -= 19;
+    }
+
+    while( exp10 >= 9 ) {
+        overflow = simpleMultiplyHighPrecision( result, length, TEN_E9 );
+        if( overflow ) {
+              result[length++] = overflow;
+        }
+        exp10 -= 9;
+    }
+
+    if( exp10 == 0 ) {
+        return length;
+    } else if( exp10 == 1 ) {
+        overflow = simpleAppendDecimalDigitHighPrecision( result, length, 0 );
+        if( overflow ) {
+            result[length++] = overflow;
+        }
+    } else if( exp10 == 2 ) {
+        overflow = simpleAppendDecimalDigitHighPrecision( result, length, 0 );
+        if( overflow ) {
+            result[length++] = overflow;
+        }
+        overflow = simpleAppendDecimalDigitHighPrecision( result, length, 0 );
+        if( overflow ) {
+            result[length++] = overflow;
+        }
+    } else if( exp10 == 3 ) {
+        overflow = simpleMultiplyHighPrecision( result, length, TEN_E3 );
+        if( overflow ) {
+            result[length++] = overflow;
+        }
+    } else if( exp10 == 4 ) {
+        overflow = simpleMultiplyHighPrecision( result, length, TEN_E4 );
+        if( overflow ) {
+            result[length++] = overflow;
+        }
+    } else if( exp10 == 5 ) {
+        overflow = simpleMultiplyHighPrecision( result, length, TEN_E5 );
+        if( overflow ) {
+            result[length++] = overflow;
+        }
+    } else if( exp10 == 6 ) {
+        overflow = simpleMultiplyHighPrecision( result, length, TEN_E6);
+        if( overflow ) {
+            result[length++] = overflow;
+        }
+    } else if( exp10 == 7 ) {
+        overflow = simpleMultiplyHighPrecision( result, length, TEN_E7 );
+        if( overflow ) {
+            result[length++] = overflow;
+        }
+    } else if( exp10 == 8 ) {
+        overflow = simpleMultiplyHighPrecision( result, length, TEN_E8 );
+        if( overflow ) {
+            result[length++] = overflow;
+        }
+    }
+
+    return length;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BigInt::simpleMultiplyAddHighPrecision(
+    unsigned long long* arg1, int length,
+    unsigned long long arg2, unsigned int* result ) {
+
+    // Assumes result can hold the product and arg2 only holds 32 bits
+    // of information
+    unsigned long long product = 0;
+    int index = 0;
+    int resultIndex = 0;
+
+//    do {
+//
+//        product =
+//            HIGH_IN_U64( product ) + result[at( resultIndex )] +
+//            arg2 * LOW_U32_FROM_PTR( arg1 + index );
+//        result[at( resultIndex )] = LOW_U32_FROM_VAR( product );
+//        ++resultIndex;
+//
+//        product =
+//            HIGH_IN_U64( product ) + result[at( resultIndex )] +
+//            arg2 * HIGH_U32_FROM_PTR( arg1 + index );
+//        result[at( resultIndex )] = LOW_U32_FROM_VAR( product );
+//        ++resultIndex;
+//
+//    } while( ++index < length );
+//
+//    result[at( resultIndex )] += HIGH_U32_FROM_VAR( product );
+//    if( result[at( resultIndex )] < HIGH_U32_FROM_VAR( product ) ) {
+//        // must be careful with ++ operator and macro expansion
+//        ++resultIndex;
+//        while( ++result[at( resultIndex )] == 0 ) {
+//            ++resultIndex;
+//        }
+//    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::highestSetBit(unsigned long long* y ) {
+
+    unsigned int x = 0;
+    int result = 0;
+
+    if( *y == 0 ) {
+        return 0;
+    }
+
+//    if( *y & 0xFFFFFFFF00000000LL ) {
+//        x = HIGH_U32_FROM_PTR(y);
+//        result = 32;
+//    } else {
+//        x = LOW_U32_FROM_PTR(y);
+//        result = 0;
+//    }
+
+//    if( x & 0xFFFF0000 )
+//    {
+//        x = bitSection( x, 0xFFFF0000, 16 );
+//        result += 16;
+//    }
+//
+//    if( x & 0xFF00 ) {
+//        x = bitSection( x, 0xFF00, 8 );
+//        result += 8;
+//    }
+//
+//    if( x & 0xF0 ) {
+//        x = bitSection( x, 0xF0, 4 );
+//        result += 4;
+//    }
+
+    if( x > 0x7 ) {
+        return result + 4;
+    } else if( x > 0x3 ) {
+        return result + 3;
+    } else if( x > 0x1 ) {
+        return result + 2;
+    } else {
+        return result + 1;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::lowestSetBitHighPrecision( unsigned long long* arg, int length ) {
+
+    int lowBit, index = -1;
+
+    while( ++index < length ) {
+        lowBit = lowestSetBit( arg + index );
+        if( lowBit ) {
+            return lowBit + 64 * index;
+        }
+    }
+
+    return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BigInt::simpleShiftLeftHighPrecision( unsigned long long* arg1,
+                                           int length, int arg2 ) {
+
+    // assumes length > 0
+    int index, offset = 0;
+
+    if( arg2 >= 64 ) {
+
+        offset = arg2 >> 6;
+        index = length;
+
+        while( --index - offset >= 0 ) {
+            arg1[index] = arg1[index - offset];
+        }
+
+        do {
+            arg1[index] = 0;
+        } while (--index >= 0);
+
+        arg2 &= 0x3F;
+    }
+
+    if( arg2 == 0 ) {
+        return;
+    }
+
+    while( --length > 0 ) {
+        arg1[length] = arg1[length] << arg2 | arg1[length - 1] >> (64 - arg2);
+    }
+
+    *arg1 <<= arg2;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+unsigned int BigInt::floatMantissa( float z ) {
+
+      unsigned int m = (unsigned int) FLOAT_TO_INTBITS (z);
+
+      if ((m & FLOAT_EXPONENT_MASK) != 0)
+        m = (m & FLOAT_MANTISSA_MASK) | FLOAT_NORMAL_MASK;
+      else
+        m = (m & FLOAT_MANTISSA_MASK);
+
+      return m;
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
+unsigned long long BigInt::simpleMultiplyHighPrecision64(
+    unsigned long long* arg1, int length, unsigned long long arg2 ) {
+
+      unsigned long long intermediate, *pArg1, carry1, carry2, prod1, prod2, sum;
+      int index;
+      unsigned int buf32;
+
+      index = 0;
+      intermediate = 0;
+      pArg1 = arg1 + index;
+      carry1 = carry2 = 0;
+
+      do
+        {
+          if ((*pArg1 != 0) || (intermediate != 0))
+            {
+              prod1 =
+                (unsigned long long) LOW_U32_FROM_VAR (arg2) * (unsigned long long) LOW_U32_FROM_PTR
(pArg1);
+              sum = intermediate + prod1;
+              if ((sum < prod1) || (sum < intermediate))
+                {
+                  carry1 = 1;
+                }
+              else
+                {
+                  carry1 = 0;
+                }
+              prod1 =
+                (unsigned long long) LOW_U32_FROM_VAR (arg2) * (unsigned long long) HIGH_U32_FROM_PTR
(pArg1);
+              prod2 =
+                (unsigned long long) HIGH_U32_FROM_VAR (arg2) * (unsigned long long) LOW_U32_FROM_PTR
(pArg1);
+              intermediate = carry2 + HIGH_IN_U64 (sum) + prod1 + prod2;
+              if ((intermediate < prod1) || (intermediate < prod2))
+                {
+                  carry2 = 1;
+                }
+              else
+                {
+                  carry2 = 0;
+                }
+              LOW_U32_FROM_PTR (pArg1) = LOW_U32_FROM_VAR (sum);
+              buf32 = HIGH_U32_FROM_PTR (pArg1);
+              HIGH_U32_FROM_PTR (pArg1) = LOW_U32_FROM_VAR (intermediate);
+              intermediate = carry1 + HIGH_IN_U64 (intermediate)
+                + (unsigned long long) HIGH_U32_FROM_VAR (arg2) * (unsigned long long) buf32;
+            }
+          pArg1++;
+        }
+      while (++index < length);
+      return intermediate;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::simpleAddHighPrecision( unsigned long long* arg1,
+                                    int length,
+                                    unsigned long long arg2 ) {
+
+    // assumes length > 0
+    int index = 1;
+
+    *arg1 += arg2;
+    if( arg2 <= *arg1 ) {
+        return 0;
+    } else if (length == 1) {
+        return 1;
+    }
+
+    while( ++arg1[index] == 0 && ++index < length );
+
+    return (int)( index == length );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BigInt::floatExponent( float z ) {
+
+      /* assumes positive float */
+      int k = FLOAT_TO_INTBITS (z) >> 23;
+      if (k)
+        k -= FLOAT_E_OFFSET;
+      else
+        k = 1 - FLOAT_E_OFFSET;
+
+      return k;
+
+}

Modified: activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util/BigInt.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util/BigInt.h?view=diff&rev=564048&r1=564047&r2=564048
==============================================================================
--- activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util/BigInt.h (original)
+++ activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/internal/util/BigInt.h Wed Aug  8
17:00:02 2007
@@ -43,6 +43,28 @@
             static const int LoWord = 0;
         #endif
 
+        static const long long TEN_E1 = 0xALL;
+        static const long long TEN_E2 = 0x64LL;
+        static const long long TEN_E3 = 0x3E8LL;
+        static const long long TEN_E4 = 0x2710LL;
+        static const long long TEN_E5 = 0x186A0LL;
+        static const long long TEN_E6 = 0xF4240LL;
+        static const long long TEN_E7 = 0x989680LL;
+        static const long long TEN_E8 = 0x5F5E100LL;
+        static const long long TEN_E9 = 0x3B9ACA00LL;
+        static const long long TEN_E19 = 0x8AC7230489E80000LL;
+
+        static const int E_OFFSET = 1075;
+
+        static const unsigned long long MANTISSA_MASK = 0x000FFFFFFFFFFFFFULL;
+        static const unsigned long long EXPONENT_MASK = 0x7FF0000000000000ULL;
+        static const unsigned long long NORMAL_MASK = 0x0010000000000000ULL;
+        static const unsigned long long SIGN_MASK = 0x8000000000000000ULL;
+        static const unsigned int FLOAT_MANTISSA_MASK = 0x007FFFFF;
+        static const unsigned int FLOAT_EXPONENT_MASK = 0x7F800000;
+        static const unsigned int FLOAT_NORMAL_MASK = 0x00800000;
+        static const unsigned int FLOAT_E_OFFSET = 150;
+
     public:
 
         BigInt();
@@ -71,25 +93,48 @@
                                          unsigned long long* arg2,
                                          int length2 );
 
-        static int highestSetBitHighPrecision(unsigned long long* arg, int length );
-        static void subtractHighPrecision(unsigned long long* arg1, int length1, unsigned
long long* arg2,
-                                    int length2);
-        static int doubleExponent(double z);
-        static unsigned int simpleMultiplyHighPrecision(unsigned long long* arg1, int length,
unsigned long long arg2 );
-        static int addHighPrecision(unsigned long long * arg1, int length1, unsigned long
long* arg2,
-                                int length2);
-        static void simpleMultiplyAddHighPrecisionBigEndianFix(unsigned long long* arg1,
int length,
-                                                         unsigned long long arg2, unsigned
int* result );
-        static int lowestSetBit(unsigned long long* y);
-        static int timesTenToTheEHighPrecision(unsigned long long * result, int length, jint
e );
-        static void simpleMultiplyAddHighPrecision(unsigned long long * arg1, int length,
unsigned long long arg2,
-                                             unsigned int * result);
-        static int highestSetBit(unsigned long long * y );
-        static int lowestSetBitHighPrecision(unsigned long long* arg, int length );
-        static void simpleShiftLeftHighPrecision(unsigned long long* arg1, int length, int
arg2 );
+        static int highestSetBitHighPrecision( unsigned long long* arg, int length );
+
+        static void subtractHighPrecision( unsigned long long* arg1,
+                                           int length1,
+                                           unsigned long long* arg2,
+                                           int length2 );
+
+        static int doubleExponent( double z );
+
+        static unsigned int simpleMultiplyHighPrecision(
+            unsigned long long* arg1, int length, unsigned long long arg2 );
+
+        static int addHighPrecision( unsigned long long* arg1,
+                                     int length1,
+                                     unsigned long long* arg2,
+                                     int length2 );
+
+        static int lowestSetBit( unsigned long long* y );
+
+        static int timesTenToTheEHighPrecision(
+            unsigned long long* result, int length, int e );
+
+        static void simpleMultiplyAddHighPrecision(
+            unsigned long long* arg1, int length,
+            unsigned long long arg2, unsigned int* result );
+
+        static int highestSetBit( unsigned long long* y );
+
+        static int lowestSetBitHighPrecision( unsigned long long* arg, int length );
+
+        static void simpleShiftLeftHighPrecision( unsigned long long* arg1,
+                                                  int length, int arg2 );
+
         static unsigned int floatMantissa( float z );
-        static unsigned long long simpleMultiplyHighPrecision64( unsigned long long* arg1,
int length, unsigned long long arg2 );
-        static int simpleAddHighPrecision( unsigned long long* arg1, int length, unsigned
long long arg2 );
+
+        static unsigned long long simpleMultiplyHighPrecision64(
+            unsigned long long* arg1, int length, unsigned long long arg2 );
+
+        static int simpleAddHighPrecision( unsigned long long* arg1,
+                                           int length,
+                                           unsigned long long arg2 );
+
         static int floatExponent( float z );
 
     };



Mime
View raw message