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 );
};
|