| /* Copyright (C) 2007, 2009 Free Software Foundation, Inc. |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 3, or (at your option) any later |
| version. |
| |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| for more details. |
| |
| Under Section 7 of GPL version 3, you are granted additional |
| permissions described in the GCC Runtime Library Exception, version |
| 3.1, as published by the Free Software Foundation. |
| |
| You should have received a copy of the GNU General Public License and |
| a copy of the GCC Runtime Library Exception along with this program; |
| see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include "bid_internal.h" |
| |
| /***************************************************************************** |
| * |
| * BID128 non-computational functions: |
| * - bid128_isSigned |
| * - bid128_isNormal |
| * - bid128_isSubnormal |
| * - bid128_isFinite |
| * - bid128_isZero |
| * - bid128_isInf |
| * - bid128_isSignaling |
| * - bid128_isCanonical |
| * - bid128_isNaN |
| * - bid128_copy |
| * - bid128_negate |
| * - bid128_abs |
| * - bid128_copySign |
| * - bid128_class |
| * - bid128_totalOrder |
| * - bid128_totalOrderMag |
| * - bid128_sameQuantum |
| * - bid128_radix |
| ****************************************************************************/ |
| |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_isSigned (int *pres, |
| UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_isSigned (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| |
| res = ((x.w[HIGH_128W] & MASK_SIGN) == MASK_SIGN); |
| BID_RETURN (res); |
| } |
| |
| // return 1 iff x is not zero, nor NaN nor subnormal nor infinity |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_isNormal (int *pres, |
| UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_isNormal (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| UINT64 x_exp, C1_hi, C1_lo; |
| BID_UI64DOUBLE tmp1; |
| int exp, q, x_nr_bits; |
| |
| BID_SWAP128 (x); |
| // test for special values - infinity or NaN |
| if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { |
| // x is special |
| res = 0; |
| BID_RETURN (res); |
| } |
| // unpack x |
| x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions |
| C1_hi = x.w[1] & MASK_COEFF; |
| C1_lo = x.w[0]; |
| // test for zero |
| if (C1_hi == 0 && C1_lo == 0) { |
| res = 0; |
| BID_RETURN (res); |
| } |
| // test for non-canonical values of the argument x |
| if ((((C1_hi > 0x0001ed09bead87c0ull) |
| || ((C1_hi == 0x0001ed09bead87c0ull) |
| && (C1_lo > 0x378d8e63ffffffffull))) |
| && ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) |
| || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { |
| res = 0; |
| BID_RETURN (res); |
| } |
| // x is subnormal or normal |
| // determine the number of digits q in the significand |
| // q = nr. of decimal digits in x |
| // determine first the nr. of bits in x |
| if (C1_hi == 0) { |
| if (C1_lo >= 0x0020000000000000ull) { // x >= 2^53 |
| // split the 64-bit value in two 32-bit halves to avoid rounding errors |
| if (C1_lo >= 0x0000000100000000ull) { // x >= 2^32 |
| tmp1.d = (double) (C1_lo >> 32); // exact conversion |
| x_nr_bits = |
| 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); |
| } else { // x < 2^32 |
| tmp1.d = (double) (C1_lo); // exact conversion |
| x_nr_bits = |
| 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); |
| } |
| } else { // if x < 2^53 |
| tmp1.d = (double) C1_lo; // exact conversion |
| x_nr_bits = |
| 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); |
| } |
| } else { // C1_hi != 0 => nr. bits = 64 + nr_bits (C1_hi) |
| tmp1.d = (double) C1_hi; // exact conversion |
| x_nr_bits = |
| 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); |
| } |
| q = nr_digits[x_nr_bits - 1].digits; |
| if (q == 0) { |
| q = nr_digits[x_nr_bits - 1].digits1; |
| if (C1_hi > nr_digits[x_nr_bits - 1].threshold_hi || |
| (C1_hi == nr_digits[x_nr_bits - 1].threshold_hi && |
| C1_lo >= nr_digits[x_nr_bits - 1].threshold_lo)) |
| q++; |
| } |
| exp = (int) (x_exp >> 49) - 6176; |
| // test for subnormal values of x |
| if (exp + q <= -6143) { |
| res = 0; |
| BID_RETURN (res); |
| } else { |
| res = 1; |
| BID_RETURN (res); |
| } |
| } |
| |
| // return 1 iff x is not zero, nor NaN nor normal nor infinity |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_isSubnormal (int *pres, |
| UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_isSubnormal (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| UINT64 x_exp, C1_hi, C1_lo; |
| BID_UI64DOUBLE tmp1; |
| int exp, q, x_nr_bits; |
| |
| BID_SWAP128 (x); |
| // test for special values - infinity or NaN |
| if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { |
| // x is special |
| res = 0; |
| BID_RETURN (res); |
| } |
| // unpack x |
| x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions |
| C1_hi = x.w[1] & MASK_COEFF; |
| C1_lo = x.w[0]; |
| // test for zero |
| if (C1_hi == 0 && C1_lo == 0) { |
| res = 0; |
| BID_RETURN (res); |
| } |
| // test for non-canonical values of the argument x |
| if ((((C1_hi > 0x0001ed09bead87c0ull) |
| || ((C1_hi == 0x0001ed09bead87c0ull) |
| && (C1_lo > 0x378d8e63ffffffffull))) |
| && ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) |
| || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { |
| res = 0; |
| BID_RETURN (res); |
| } |
| // x is subnormal or normal |
| // determine the number of digits q in the significand |
| // q = nr. of decimal digits in x |
| // determine first the nr. of bits in x |
| if (C1_hi == 0) { |
| if (C1_lo >= 0x0020000000000000ull) { // x >= 2^53 |
| // split the 64-bit value in two 32-bit halves to avoid rounding errors |
| if (C1_lo >= 0x0000000100000000ull) { // x >= 2^32 |
| tmp1.d = (double) (C1_lo >> 32); // exact conversion |
| x_nr_bits = |
| 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); |
| } else { // x < 2^32 |
| tmp1.d = (double) (C1_lo); // exact conversion |
| x_nr_bits = |
| 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); |
| } |
| } else { // if x < 2^53 |
| tmp1.d = (double) C1_lo; // exact conversion |
| x_nr_bits = |
| 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); |
| } |
| } else { // C1_hi != 0 => nr. bits = 64 + nr_bits (C1_hi) |
| tmp1.d = (double) C1_hi; // exact conversion |
| x_nr_bits = |
| 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); |
| } |
| q = nr_digits[x_nr_bits - 1].digits; |
| if (q == 0) { |
| q = nr_digits[x_nr_bits - 1].digits1; |
| if (C1_hi > nr_digits[x_nr_bits - 1].threshold_hi || |
| (C1_hi == nr_digits[x_nr_bits - 1].threshold_hi && |
| C1_lo >= nr_digits[x_nr_bits - 1].threshold_lo)) |
| q++; |
| } |
| exp = (int) (x_exp >> 49) - 6176; |
| // test for subnormal values of x |
| if (exp + q <= -6143) { |
| res = 1; |
| } else { |
| res = 0; |
| } |
| BID_RETURN (res); |
| } |
| |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_isFinite (int *pres, |
| UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_isFinite (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| res = ((x.w[HIGH_128W] & MASK_INF) != MASK_INF); |
| BID_RETURN (res); |
| } |
| |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_isZero (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_isZero (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| UINT128 sig_x; |
| |
| BID_SWAP128 (x); |
| if ((x.w[1] & MASK_INF) == MASK_INF) { |
| res = 0; |
| BID_RETURN (res); |
| } |
| sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull; |
| sig_x.w[0] = x.w[0]; |
| if ((sig_x.w[1] > 0x0001ed09bead87c0ull) || // significand is non-canonical |
| ((sig_x.w[1] == 0x0001ed09bead87c0ull) && (sig_x.w[0] > 0x378d8e63ffffffffull)) || // significand is non-canonical |
| ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull && (x.w[1] & MASK_INF) != MASK_INF) || // significand is non-canonical |
| (sig_x.w[1] == 0 && sig_x.w[0] == 0)) { // significand is 0 |
| res = 1; |
| BID_RETURN (res); |
| } |
| res = 0; |
| BID_RETURN (res); |
| } |
| |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_isInf (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_isInf (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| res = ((x.w[HIGH_128W] & MASK_INF) == MASK_INF) |
| && ((x.w[HIGH_128W] & MASK_NAN) != MASK_NAN); |
| BID_RETURN (res); |
| } |
| |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_isSignaling (int *pres, |
| UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_isSignaling (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| |
| res = ((x.w[HIGH_128W] & MASK_SNAN) == MASK_SNAN); |
| BID_RETURN (res); |
| } |
| |
| // return 1 iff x is a canonical number ,infinity, or NaN. |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_isCanonical (int *pres, |
| UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_isCanonical (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| UINT128 sig_x; |
| |
| BID_SWAP128 (x); |
| if ((x.w[1] & MASK_NAN) == MASK_NAN) { // NaN |
| if (x.w[1] & 0x01ffc00000000000ull) { |
| res = 0; |
| BID_RETURN (res); |
| } |
| sig_x.w[1] = x.w[1] & 0x00003fffffffffffull; // 46 bits |
| sig_x.w[0] = x.w[0]; // 64 bits |
| // payload must be < 10^33 = 0x0000314dc6448d93_38c15b0a00000000 |
| if (sig_x.w[1] < 0x0000314dc6448d93ull |
| || (sig_x.w[1] == 0x0000314dc6448d93ull |
| && sig_x.w[0] < 0x38c15b0a00000000ull)) { |
| res = 1; |
| } else { |
| res = 0; |
| } |
| BID_RETURN (res); |
| } else if ((x.w[1] & MASK_INF) == MASK_INF) { // infinity |
| if ((x.w[1] & 0x03ffffffffffffffull) || x.w[0]) { |
| res = 0; |
| } else { |
| res = 1; |
| } |
| BID_RETURN (res); |
| } |
| // not NaN or infinity; extract significand to ensure it is canonical |
| sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull; |
| sig_x.w[0] = x.w[0]; |
| // a canonical number has a coefficient < 10^34 |
| // (0x0001ed09_bead87c0_378d8e64_00000000) |
| if ((sig_x.w[1] > 0x0001ed09bead87c0ull) || // significand is non-canonical |
| ((sig_x.w[1] == 0x0001ed09bead87c0ull) && (sig_x.w[0] > 0x378d8e63ffffffffull)) || // significand is non-canonical |
| ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { |
| res = 0; |
| } else { |
| res = 1; |
| } |
| BID_RETURN (res); |
| } |
| |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_isNaN (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_isNaN (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| |
| res = ((x.w[HIGH_128W] & MASK_NAN) == MASK_NAN); |
| BID_RETURN (res); |
| } |
| |
| // copies a floating-point operand x to destination y, with no change |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_copy (UINT128 * pres, |
| UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| UINT128 |
| bid128_copy (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| UINT128 res; |
| |
| res = x; |
| BID_RETURN (res); |
| } |
| |
| // copies a floating-point operand x to destination y, reversing the sign |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_negate (UINT128 * pres, |
| UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| UINT128 |
| bid128_negate (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| UINT128 res; |
| |
| x.w[HIGH_128W] ^= MASK_SIGN; |
| res = x; |
| BID_RETURN (res); |
| } |
| |
| // copies a floating-point operand x to destination y, changing the sign to positive |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_abs (UINT128 * pres, |
| UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| UINT128 |
| bid128_abs (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| UINT128 res; |
| |
| x.w[HIGH_128W] &= ~MASK_SIGN; |
| res = x; |
| BID_RETURN (res); |
| } |
| |
| // copies operand x to destination in the same format as x, but with the sign of y |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_copySign (UINT128 * pres, UINT128 * px, |
| UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| UINT128 y = *py; |
| #else |
| UINT128 |
| bid128_copySign (UINT128 x, UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| UINT128 res; |
| |
| x.w[HIGH_128W] = |
| (x.w[HIGH_128W] & ~MASK_SIGN) | (y.w[HIGH_128W] & MASK_SIGN); |
| res = x; |
| BID_RETURN (res); |
| } |
| |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_class (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_class (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| UINT256 sig_x_prime256; |
| UINT192 sig_x_prime192; |
| UINT128 sig_x; |
| int exp_x; |
| |
| BID_SWAP128 (x); |
| if ((x.w[1] & MASK_NAN) == MASK_NAN) { |
| if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { |
| res = signalingNaN; |
| } else { |
| res = quietNaN; |
| } |
| BID_RETURN (res); |
| } |
| if ((x.w[1] & MASK_INF) == MASK_INF) { |
| if ((x.w[1] & MASK_SIGN) == MASK_SIGN) { |
| res = negativeInfinity; |
| } else { |
| res = positiveInfinity; |
| } |
| BID_RETURN (res); |
| } |
| // decode number into exponent and significand |
| sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull; |
| sig_x.w[0] = x.w[0]; |
| // check for zero or non-canonical |
| if ((sig_x.w[1] > 0x0001ed09bead87c0ull) |
| || ((sig_x.w[1] == 0x0001ed09bead87c0ull) |
| && (sig_x.w[0] > 0x378d8e63ffffffffull)) |
| || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) |
| || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { |
| if ((x.w[1] & MASK_SIGN) == MASK_SIGN) { |
| res = negativeZero; |
| } else { |
| res = positiveZero; |
| } |
| BID_RETURN (res); |
| } |
| exp_x = (x.w[1] >> 49) & 0x000000000003fffull; |
| // if exponent is less than -6176, the number may be subnormal |
| // (less than the smallest normal value) |
| // the smallest normal value is 1 x 10^-6143 = 10^33 x 10^-6176 |
| // if (exp_x - 6176 < -6143) |
| if (exp_x < 33) { // sig_x * 10^exp_x |
| if (exp_x > 19) { |
| __mul_128x128_to_256 (sig_x_prime256, sig_x, |
| ten2k128[exp_x - 20]); |
| // 10^33 = 0x0000314dc6448d93_38c15b0a00000000 |
| if ((sig_x_prime256.w[3] == 0) && (sig_x_prime256.w[2] == 0) |
| && ((sig_x_prime256.w[1] < 0x0000314dc6448d93ull) |
| || ((sig_x_prime256.w[1] == 0x0000314dc6448d93ull) |
| && (sig_x_prime256.w[0] < 0x38c15b0a00000000ull)))) { |
| res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? negativeSubnormal : |
| positiveSubnormal; |
| BID_RETURN (res); |
| } |
| } else { |
| __mul_64x128_to_192 (sig_x_prime192, ten2k64[exp_x], sig_x); |
| // 10^33 = 0x0000314dc6448d93_38c15b0a00000000 |
| if ((sig_x_prime192.w[2] == 0) |
| && ((sig_x_prime192.w[1] < 0x0000314dc6448d93ull) |
| || ((sig_x_prime192.w[1] == 0x0000314dc6448d93ull) |
| && (sig_x_prime192.w[0] < 0x38c15b0a00000000ull)))) { |
| res = ((x.w[1] & MASK_SIGN) == MASK_SIGN) ? negativeSubnormal : |
| positiveSubnormal; |
| BID_RETURN (res); |
| } |
| } |
| } |
| // otherwise, normal number, determine the sign |
| res = |
| ((x.w[1] & MASK_SIGN) == |
| MASK_SIGN) ? negativeNormal : positiveNormal; |
| BID_RETURN (res); |
| } |
| |
| // true if the exponents of x and y are the same, false otherwise. |
| // The special cases of sameQuantum(NaN, NaN) and sameQuantum(Inf, Inf) are true |
| // If exactly one operand is infinite or exactly one operand is NaN, then false |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_sameQuantum (int *pres, UINT128 * px, |
| UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| UINT128 y = *py; |
| #else |
| int |
| bid128_sameQuantum (UINT128 x, |
| UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| UINT64 x_exp, y_exp; |
| |
| BID_SWAP128 (x); |
| BID_SWAP128 (y); |
| // if both operands are NaN, return true |
| if ((x.w[1] & MASK_NAN) == MASK_NAN |
| || ((y.w[1] & MASK_NAN) == MASK_NAN)) { |
| res = ((x.w[1] & MASK_NAN) == MASK_NAN |
| && (y.w[1] & MASK_NAN) == MASK_NAN); |
| BID_RETURN (res); |
| } |
| // if both operands are INF, return true |
| if ((x.w[1] & MASK_INF) == MASK_INF |
| || (y.w[1] & MASK_INF) == MASK_INF) { |
| res = ((x.w[1] & MASK_INF) == MASK_INF) |
| && ((y.w[1] & MASK_INF) == MASK_INF); |
| BID_RETURN (res); |
| } |
| // decode exponents for both numbers, and return true if they match |
| if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11 |
| x_exp = (x.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits |
| } else { // G0_G1 != 11 |
| x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bits |
| } |
| if ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { // G0_G1=11 |
| y_exp = (y.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits |
| } else { // G0_G1 != 11 |
| y_exp = y.w[1] & MASK_EXP; // biased and shifted left 49 bits |
| } |
| res = (x_exp == y_exp); |
| BID_RETURN (res); |
| } |
| |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_totalOrder (int *pres, UINT128 * px, |
| UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| UINT128 y = *py; |
| #else |
| int |
| bid128_totalOrder (UINT128 x, |
| UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| int exp_x, exp_y; |
| UINT128 sig_x, sig_y, pyld_y, pyld_x; |
| UINT192 sig_n_prime192; |
| UINT256 sig_n_prime256; |
| char x_is_zero = 0, y_is_zero = 0; |
| |
| BID_SWAP128 (x); |
| BID_SWAP128 (y); |
| // NaN (CASE 1) |
| // if x and y are unordered numerically because either operand is NaN |
| // (1) totalOrder(-NaN, number) is true |
| // (2) totalOrder(number, +NaN) is true |
| // (3) if x and y are both NaN: |
| // i) negative sign bit < positive sign bit |
| // ii) signaling < quiet for +NaN, reverse for -NaN |
| // iii) lesser payload < greater payload for +NaN (reverse for -NaN) |
| // iv) else if bitwise identical (in canonical form), return 1 |
| if ((x.w[1] & MASK_NAN) == MASK_NAN) { |
| // if x is -NaN |
| if ((x.w[1] & MASK_SIGN) == MASK_SIGN) { |
| // return true, unless y is -NaN also |
| if ((y.w[1] & MASK_NAN) != MASK_NAN |
| || (y.w[1] & MASK_SIGN) != MASK_SIGN) { |
| res = 1; // y is a number, return 1 |
| BID_RETURN (res); |
| } else { // if y and x are both -NaN |
| pyld_x.w[1] = x.w[1] & 0x00003fffffffffffull; |
| pyld_x.w[0] = x.w[0]; |
| pyld_y.w[1] = y.w[1] & 0x00003fffffffffffull; |
| pyld_y.w[0] = y.w[0]; |
| if ((pyld_x.w[1] > 0x0000314dc6448d93ull) |
| || ((pyld_x.w[1] == 0x0000314dc6448d93ull) |
| && (pyld_x.w[0] > 0x38c15b09ffffffffull))) { |
| pyld_x.w[1] = 0; |
| pyld_x.w[0] = 0; |
| } |
| if ((pyld_y.w[1] > 0x0000314dc6448d93ull) |
| || ((pyld_y.w[1] == 0x0000314dc6448d93ull) |
| && (pyld_y.w[0] > 0x38c15b09ffffffffull))) { |
| pyld_y.w[1] = 0; |
| pyld_y.w[0] = 0; |
| } |
| // if x and y are both -SNaN or both -QNaN, we have to compare payloads |
| // this statement evaluates to true if both are SNaN or QNaN |
| if (! |
| (((y.w[1] & MASK_SNAN) == MASK_SNAN) ^ |
| ((x.w[1] & MASK_SNAN) == MASK_SNAN))) { |
| // it comes down to the payload. we want to return true if x has a |
| // larger payload, or if the payloads are equal (canonical forms |
| // are bitwise identical) |
| if ((pyld_x.w[1] > pyld_y.w[1]) || |
| ((pyld_x.w[1] == pyld_y.w[1]) |
| && (pyld_x.w[0] >= pyld_y.w[0]))) |
| res = 1; |
| else |
| res = 0; |
| BID_RETURN (res); |
| } else { |
| // either x = -SNaN and y = -QNaN or x = -QNaN and y = -SNaN |
| res = ((y.w[1] & MASK_SNAN) == MASK_SNAN); |
| // totalOrder (-QNaN, -SNaN) == 1 |
| BID_RETURN (res); |
| } |
| } |
| } else { // x is +NaN |
| // return false, unless y is +NaN also |
| if ((y.w[1] & MASK_NAN) != MASK_NAN |
| || (y.w[1] & MASK_SIGN) == MASK_SIGN) { |
| res = 0; // y is a number, return 1 |
| BID_RETURN (res); |
| } else { |
| // x and y are both +NaN; |
| pyld_x.w[1] = x.w[1] & 0x00003fffffffffffull; |
| pyld_x.w[0] = x.w[0]; |
| pyld_y.w[1] = y.w[1] & 0x00003fffffffffffull; |
| pyld_y.w[0] = y.w[0]; |
| if ((pyld_x.w[1] > 0x0000314dc6448d93ull) |
| || ((pyld_x.w[1] == 0x0000314dc6448d93ull) |
| && (pyld_x.w[0] > 0x38c15b09ffffffffull))) { |
| pyld_x.w[1] = 0; |
| pyld_x.w[0] = 0; |
| } |
| if ((pyld_y.w[1] > 0x0000314dc6448d93ull) |
| || ((pyld_y.w[1] == 0x0000314dc6448d93ull) |
| && (pyld_y.w[0] > 0x38c15b09ffffffffull))) { |
| pyld_y.w[1] = 0; |
| pyld_y.w[0] = 0; |
| } |
| // if x and y are both +SNaN or both +QNaN, we have to compare payloads |
| // this statement evaluates to true if both are SNaN or QNaN |
| if (! |
| (((y.w[1] & MASK_SNAN) == MASK_SNAN) ^ |
| ((x.w[1] & MASK_SNAN) == MASK_SNAN))) { |
| // it comes down to the payload. we want to return true if x has a |
| // smaller payload, or if the payloads are equal (canonical forms |
| // are bitwise identical) |
| if ((pyld_x.w[1] < pyld_y.w[1]) || |
| ((pyld_x.w[1] == pyld_y.w[1]) |
| && (pyld_x.w[0] <= pyld_y.w[0]))) |
| res = 1; |
| else |
| res = 0; |
| BID_RETURN (res); |
| } else { |
| // either x = SNaN and y = QNaN or x = QNaN and y = SNaN |
| res = ((x.w[1] & MASK_SNAN) == MASK_SNAN); |
| // totalOrder (-QNaN, -SNaN) == 1 |
| BID_RETURN (res); |
| } |
| } |
| } |
| } else if ((y.w[1] & MASK_NAN) == MASK_NAN) { |
| // x is certainly not NAN in this case. |
| // return true if y is positive |
| res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); |
| BID_RETURN (res); |
| } |
| // SIMPLE (CASE 2) |
| // if all the bits are the same, the numbers are equal. |
| if ((x.w[1] == y.w[1]) && (x.w[0] == y.w[0])) { |
| res = 1; |
| BID_RETURN (res); |
| } |
| // OPPOSITE SIGNS (CASE 3) |
| // if signs are opposite, return 1 if x is negative |
| // (if x < y, totalOrder is true) |
| if (((x.w[1] & MASK_SIGN) == MASK_SIGN) ^ ((y.w[1] & MASK_SIGN) == |
| MASK_SIGN)) { |
| res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); |
| BID_RETURN (res); |
| } |
| // INFINITY (CASE 4) |
| if ((x.w[1] & MASK_INF) == MASK_INF) { |
| // if x == neg_inf, return (y == neg_inf); |
| if ((x.w[1] & MASK_SIGN) == MASK_SIGN) { |
| res = 1; |
| BID_RETURN (res); |
| } else { |
| // x is positive infinity, only return1 if y is positive infinity as well |
| res = ((y.w[1] & MASK_INF) == MASK_INF); |
| BID_RETURN (res); |
| // && (y & MASK_SIGN) != MASK_SIGN); (we know y has same sign as x) |
| } |
| } else if ((y.w[1] & MASK_INF) == MASK_INF) { |
| // x is finite, so: |
| // if y is +inf, x<y |
| // if y is -inf, x>y |
| res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); |
| BID_RETURN (res); |
| } |
| // CONVERT x |
| sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull; |
| sig_x.w[0] = x.w[0]; |
| exp_x = (x.w[1] >> 49) & 0x000000000003fffull; |
| |
| // CHECK IF x IS CANONICAL |
| // 9999999999999999999999999999999999 (decimal) = |
| // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal) |
| // [0, 10^34) is the 754r supported canonical range. |
| // If the value exceeds that, it is interpreted as 0. |
| if ((((sig_x.w[1] > 0x0001ed09bead87c0ull) || |
| ((sig_x.w[1] == 0x0001ed09bead87c0ull) && |
| (sig_x.w[0] > 0x378d8e63ffffffffull))) && |
| ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) || |
| ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) || |
| ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { |
| x_is_zero = 1; |
| // check for the case where the exponent is shifted right by 2 bits! |
| if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { |
| exp_x = (x.w[1] >> 47) & 0x000000000003fffull; |
| } |
| } |
| // CONVERT y |
| exp_y = (y.w[1] >> 49) & 0x0000000000003fffull; |
| sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull; |
| sig_y.w[0] = y.w[0]; |
| |
| // CHECK IF y IS CANONICAL |
| // 9999999999999999999999999999999999(decimal) = |
| // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal) |
| // [0, 10^34) is the 754r supported canonical range. |
| // If the value exceeds that, it is interpreted as 0. |
| if ((((sig_y.w[1] > 0x0001ed09bead87c0ull) || |
| ((sig_y.w[1] == 0x0001ed09bead87c0ull) && |
| (sig_y.w[0] > 0x378d8e63ffffffffull))) && |
| ((y.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) || |
| ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) || |
| ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { |
| y_is_zero = 1; |
| // check for the case where the exponent is shifted right by 2 bits! |
| if ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { |
| exp_y = (y.w[1] >> 47) & 0x000000000003fffull; |
| } |
| } |
| // ZERO (CASE 5) |
| // if x and y represent the same entities, and both are negative |
| // return true iff exp_x <= exp_y |
| if (x_is_zero && y_is_zero) { |
| // we know that signs must be the same because we would have caught it |
| // in case3 if signs were different |
| // totalOrder(x,y) iff exp_x >= exp_y for negative numbers |
| // totalOrder(x,y) iff exp_x <= exp_y for positive numbers |
| if (exp_x == exp_y) { |
| res = 1; |
| BID_RETURN (res); |
| } |
| res = ((exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); |
| BID_RETURN (res); |
| } |
| // if x is zero and y isn't, clearly x has the smaller payload |
| if (x_is_zero) { |
| res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); |
| BID_RETURN (res); |
| } |
| // if y is zero, and x isn't, clearly y has the smaller payload |
| if (y_is_zero) { |
| res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); |
| BID_RETURN (res); |
| } |
| // REDUNDANT REPRESENTATIONS (CASE 6) |
| // if both components are either bigger or smaller |
| if (((sig_x.w[1] > sig_y.w[1]) |
| || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0])) |
| && exp_x >= exp_y) { |
| res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); |
| BID_RETURN (res); |
| } |
| if (((sig_x.w[1] < sig_y.w[1]) |
| || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0])) |
| && exp_x <= exp_y) { |
| res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); |
| BID_RETURN (res); |
| } |
| // if |exp_x - exp_y| < 33, it comes down to the compensated significand |
| if (exp_x > exp_y) { |
| // if exp_x is 33 greater than exp_y, it is definitely larger, |
| // so no need for compensation |
| if (exp_x - exp_y > 33) { |
| res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); |
| BID_RETURN (res); |
| // difference cannot be greater than 10^33 |
| } |
| // otherwise adjust the x significand upwards |
| if (exp_x - exp_y > 19) { |
| __mul_128x128_to_256 (sig_n_prime256, sig_x, |
| ten2k128[exp_x - exp_y - 20]); |
| // the compensated significands are equal (ie "x and y represent the same |
| // entities") return 1 if (negative && expx > expy) || |
| // (positive && expx < expy) |
| if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) |
| && (sig_n_prime256.w[1] == sig_y.w[1]) |
| && (sig_n_prime256.w[0] == sig_y.w[0])) { |
| // the case exp_x == exp_y cannot occur, because all bits must be |
| // the same - would have been caught if (x == y) |
| res = ((exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); |
| BID_RETURN (res); |
| } |
| // if positive, return 1 if adjusted x is smaller than y |
| res = (((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) |
| && ((sig_n_prime256.w[1] < sig_y.w[1]) |
| || (sig_n_prime256.w[1] == sig_y.w[1] |
| && sig_n_prime256.w[0] < |
| sig_y.w[0]))) ^ ((x.w[1] & MASK_SIGN) == |
| MASK_SIGN)); |
| BID_RETURN (res); |
| } |
| __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_x - exp_y], sig_x); |
| // if positive, return whichever significand is larger |
| // (converse if negative) |
| if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1] |
| && (sig_n_prime192.w[0] == sig_y.w[0])) { |
| res = ((exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); |
| BID_RETURN (res); |
| } |
| res = (((sig_n_prime192.w[2] == 0) |
| && ((sig_n_prime192.w[1] < sig_y.w[1]) |
| || (sig_n_prime192.w[1] == sig_y.w[1] |
| && sig_n_prime192.w[0] < |
| sig_y.w[0]))) ^ ((x.w[1] & MASK_SIGN) == |
| MASK_SIGN)); |
| BID_RETURN (res); |
| } |
| // if exp_x is 33 less than exp_y, it is definitely smaller, |
| // no need for compensation |
| if (exp_y - exp_x > 33) { |
| res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); |
| BID_RETURN (res); |
| } |
| if (exp_y - exp_x > 19) { |
| // adjust the y significand upwards |
| __mul_128x128_to_256 (sig_n_prime256, sig_y, |
| ten2k128[exp_y - exp_x - 20]); |
| // if x and y represent the same entities and both are negative |
| // return true iff exp_x <= exp_y |
| if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) |
| && (sig_n_prime256.w[1] == sig_x.w[1]) |
| && (sig_n_prime256.w[0] == sig_x.w[0])) { |
| res = (exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN); |
| BID_RETURN (res); |
| } |
| // values are not equal, for positive numbers return 1 if x is less than y |
| // and 0 otherwise |
| res = (((sig_n_prime256.w[3] != 0) || |
| // if upper128 bits of compensated y are non-zero, y is bigger |
| (sig_n_prime256.w[2] != 0) || |
| // if upper128 bits of compensated y are non-zero, y is bigger |
| (sig_n_prime256.w[1] > sig_x.w[1]) || |
| // if compensated y is bigger, y is bigger |
| (sig_n_prime256.w[1] == sig_x.w[1] |
| && sig_n_prime256.w[0] > |
| sig_x.w[0])) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); |
| BID_RETURN (res); |
| } |
| __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_y - exp_x], sig_y); |
| if ((sig_n_prime192.w[2] == 0) && (sig_n_prime192.w[1] == sig_x.w[1]) |
| && (sig_n_prime192.w[0] == sig_x.w[0])) { |
| res = (exp_x <= exp_y) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN); |
| BID_RETURN (res); |
| } |
| res = (((sig_n_prime192.w[2] != 0) || |
| // if upper128 bits of compensated y are non-zero, y is bigger |
| (sig_n_prime192.w[1] > sig_x.w[1]) || |
| // if compensated y is bigger, y is bigger |
| (sig_n_prime192.w[1] == sig_x.w[1] |
| && sig_n_prime192.w[0] > |
| sig_x.w[0])) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); |
| BID_RETURN (res); |
| } |
| |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_totalOrderMag (int *pres, UINT128 * px, |
| UINT128 * py _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| UINT128 y = *py; |
| #else |
| int |
| bid128_totalOrderMag (UINT128 x, |
| UINT128 y _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| int exp_x, exp_y; |
| UINT128 sig_x, sig_y, pyld_y, pyld_x; |
| UINT192 sig_n_prime192; |
| UINT256 sig_n_prime256; |
| char x_is_zero = 0, y_is_zero = 0; |
| |
| BID_SWAP128 (x); |
| BID_SWAP128 (y); |
| x.w[1] = x.w[1] & 0x7fffffffffffffffull; |
| y.w[1] = y.w[1] & 0x7fffffffffffffffull; |
| |
| // NaN (CASE 1) |
| // if x and y are unordered numerically because either operand is NaN |
| // (1) totalOrder(number, +NaN) is true |
| // (2) if x and y are both NaN: |
| // i) signaling < quiet for +NaN |
| // ii) lesser payload < greater payload for +NaN |
| // iii) else if bitwise identical (in canonical form), return 1 |
| if ((x.w[1] & MASK_NAN) == MASK_NAN) { |
| // x is +NaN |
| // return false, unless y is +NaN also |
| if ((y.w[1] & MASK_NAN) != MASK_NAN) { |
| res = 0; // y is a number, return 0 |
| BID_RETURN (res); |
| } else { |
| // x and y are both +NaN; |
| pyld_x.w[1] = x.w[1] & 0x00003fffffffffffull; |
| pyld_x.w[0] = x.w[0]; |
| pyld_y.w[1] = y.w[1] & 0x00003fffffffffffull; |
| pyld_y.w[0] = y.w[0]; |
| if ((pyld_x.w[1] > 0x0000314dc6448d93ull) |
| || ((pyld_x.w[1] == 0x0000314dc6448d93ull) |
| && (pyld_x.w[0] > 0x38c15b09ffffffffull))) { |
| pyld_x.w[1] = 0; |
| pyld_x.w[0] = 0; |
| } |
| if ((pyld_y.w[1] > 0x0000314dc6448d93ull) |
| || ((pyld_y.w[1] == 0x0000314dc6448d93ull) |
| && (pyld_y.w[0] > 0x38c15b09ffffffffull))) { |
| pyld_y.w[1] = 0; |
| pyld_y.w[0] = 0; |
| } |
| // if x and y are both +SNaN or both +QNaN, we have to compare payloads |
| // this statement evaluates to true if both are SNaN or QNaN |
| if (! |
| (((y.w[1] & MASK_SNAN) == MASK_SNAN) ^ |
| ((x.w[1] & MASK_SNAN) == MASK_SNAN))) { |
| // it comes down to the payload. we want to return true if x has a |
| // smaller payload, or if the payloads are equal (canonical forms |
| // are bitwise identical) |
| if ((pyld_x.w[1] < pyld_y.w[1]) || |
| ((pyld_x.w[1] == pyld_y.w[1]) |
| && (pyld_x.w[0] <= pyld_y.w[0]))) { |
| res = 1; |
| } else { |
| res = 0; |
| } |
| BID_RETURN (res); |
| } else { |
| // either x = SNaN and y = QNaN or x = QNaN and y = SNaN |
| res = ((x.w[1] & MASK_SNAN) == MASK_SNAN); |
| // totalOrder (-QNaN, -SNaN) == 1 |
| BID_RETURN (res); |
| } |
| } |
| } else if ((y.w[1] & MASK_NAN) == MASK_NAN) { |
| // x is certainly not NAN in this case. |
| // return true because y is positive |
| res = 1; |
| BID_RETURN (res); |
| } |
| // SIMPLE (CASE 2) |
| // if all the bits are the same, the numbers are equal. |
| if ((x.w[1] == y.w[1]) && (x.w[0] == y.w[0])) { |
| res = 1; |
| BID_RETURN (res); |
| } |
| // INFINITY (CASE 3) |
| if ((x.w[1] & MASK_INF) == MASK_INF) { |
| // x is positive infinity, only return 1 if y is positive infinity as well |
| res = ((y.w[1] & MASK_INF) == MASK_INF); |
| BID_RETURN (res); |
| // (we know y has same sign as x) |
| } else if ((y.w[1] & MASK_INF) == MASK_INF) { |
| // x is finite, so: |
| // since y is +inf, x<y |
| res = 1; |
| BID_RETURN (res); |
| } else { |
| ; // continue |
| } |
| |
| // CONVERT x |
| sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull; |
| sig_x.w[0] = x.w[0]; |
| exp_x = (x.w[1] >> 49) & 0x000000000003fffull; |
| |
| // CHECK IF x IS CANONICAL |
| // 9999999999999999999999999999999999 (decimal) = |
| // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal) |
| // [0, 10^34) is the 754r supported canonical range. |
| // If the value exceeds that, it is interpreted as 0. |
| if ((((sig_x.w[1] > 0x0001ed09bead87c0ull) || |
| ((sig_x.w[1] == 0x0001ed09bead87c0ull) && |
| (sig_x.w[0] > 0x378d8e63ffffffffull))) && |
| ((x.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) || |
| ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) || |
| ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { |
| x_is_zero = 1; |
| // check for the case where the exponent is shifted right by 2 bits! |
| if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { |
| exp_x = (x.w[1] >> 47) & 0x000000000003fffull; |
| } |
| } |
| // CONVERT y |
| exp_y = (y.w[1] >> 49) & 0x0000000000003fffull; |
| sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull; |
| sig_y.w[0] = y.w[0]; |
| |
| // CHECK IF y IS CANONICAL |
| // 9999999999999999999999999999999999(decimal) = |
| // 1ed09_bead87c0_378d8e63_ffffffff(hexadecimal) |
| // [0, 10^34) is the 754r supported canonical range. |
| // If the value exceeds that, it is interpreted as 0. |
| if ((((sig_y.w[1] > 0x0001ed09bead87c0ull) || |
| ((sig_y.w[1] == 0x0001ed09bead87c0ull) && |
| (sig_y.w[0] > 0x378d8e63ffffffffull))) && |
| ((y.w[1] & 0x6000000000000000ull) != 0x6000000000000000ull)) || |
| ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) || |
| ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { |
| y_is_zero = 1; |
| // check for the case where the exponent is shifted right by 2 bits! |
| if ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) { |
| exp_y = (y.w[1] >> 47) & 0x000000000003fffull; |
| } |
| } |
| // ZERO (CASE 4) |
| if (x_is_zero && y_is_zero) { |
| // we know that signs must be the same because we would have caught it |
| // in case3 if signs were different |
| // totalOrder(x,y) iff exp_x <= exp_y for positive numbers |
| if (exp_x == exp_y) { |
| res = 1; |
| BID_RETURN (res); |
| } |
| res = (exp_x <= exp_y); |
| BID_RETURN (res); |
| } |
| // if x is zero and y isn't, clearly x has the smaller payload |
| if (x_is_zero) { |
| res = 1; |
| BID_RETURN (res); |
| } |
| // if y is zero, and x isn't, clearly y has the smaller payload |
| if (y_is_zero) { |
| res = 0; |
| BID_RETURN (res); |
| } |
| // REDUNDANT REPRESENTATIONS (CASE 5) |
| // if both components are either bigger or smaller |
| if (((sig_x.w[1] > sig_y.w[1]) |
| || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0])) |
| && exp_x >= exp_y) { |
| res = 0; |
| BID_RETURN (res); |
| } |
| if (((sig_x.w[1] < sig_y.w[1]) |
| || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0])) |
| && exp_x <= exp_y) { |
| res = 1; |
| BID_RETURN (res); |
| } |
| // if |exp_x - exp_y| < 33, it comes down to the compensated significand |
| if (exp_x > exp_y) { |
| // if exp_x is 33 greater than exp_y, it is definitely larger, |
| // so no need for compensation |
| if (exp_x - exp_y > 33) { |
| res = 0; // difference cannot be greater than 10^33 |
| BID_RETURN (res); |
| } |
| // otherwise adjust the x significand upwards |
| if (exp_x - exp_y > 19) { |
| __mul_128x128_to_256 (sig_n_prime256, sig_x, |
| ten2k128[exp_x - exp_y - 20]); |
| // the compensated significands are equal (ie "x and y represent the same |
| // entities") return 1 if (negative && expx > expy) || |
| // (positive && expx < expy) |
| if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) |
| && (sig_n_prime256.w[1] == sig_y.w[1]) |
| && (sig_n_prime256.w[0] == sig_y.w[0])) { |
| // the case (exp_x == exp_y) cannot occur, because all bits must be |
| // the same - would have been caught if (x == y) |
| res = (exp_x <= exp_y); |
| BID_RETURN (res); |
| } |
| // since positive, return 1 if adjusted x is smaller than y |
| res = ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) |
| && ((sig_n_prime256.w[1] < sig_y.w[1]) |
| || (sig_n_prime256.w[1] == sig_y.w[1] |
| && sig_n_prime256.w[0] < sig_y.w[0]))); |
| BID_RETURN (res); |
| } |
| __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_x - exp_y], sig_x); |
| // if positive, return whichever significand is larger |
| // (converse if negative) |
| if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1] |
| && (sig_n_prime192.w[0] == sig_y.w[0])) { |
| res = (exp_x <= exp_y); |
| BID_RETURN (res); |
| } |
| res = ((sig_n_prime192.w[2] == 0) |
| && ((sig_n_prime192.w[1] < sig_y.w[1]) |
| || (sig_n_prime192.w[1] == sig_y.w[1] |
| && sig_n_prime192.w[0] < sig_y.w[0]))); |
| BID_RETURN (res); |
| } |
| // if exp_x is 33 less than exp_y, it is definitely smaller, |
| // no need for compensation |
| if (exp_y - exp_x > 33) { |
| res = 1; |
| BID_RETURN (res); |
| } |
| if (exp_y - exp_x > 19) { |
| // adjust the y significand upwards |
| __mul_128x128_to_256 (sig_n_prime256, sig_y, |
| ten2k128[exp_y - exp_x - 20]); |
| if ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0) |
| && (sig_n_prime256.w[1] == sig_x.w[1]) |
| && (sig_n_prime256.w[0] == sig_x.w[0])) { |
| res = (exp_x <= exp_y); |
| BID_RETURN (res); |
| } |
| // values are not equal, for positive numbers return 1 if x is less than y |
| // and 0 otherwise |
| res = ((sig_n_prime256.w[3] != 0) || |
| // if upper128 bits of compensated y are non-zero, y is bigger |
| (sig_n_prime256.w[2] != 0) || |
| // if upper128 bits of compensated y are non-zero, y is bigger |
| (sig_n_prime256.w[1] > sig_x.w[1]) || |
| // if compensated y is bigger, y is bigger |
| (sig_n_prime256.w[1] == sig_x.w[1] |
| && sig_n_prime256.w[0] > sig_x.w[0])); |
| BID_RETURN (res); |
| } |
| __mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_y - exp_x], sig_y); |
| if ((sig_n_prime192.w[2] == 0) && (sig_n_prime192.w[1] == sig_x.w[1]) |
| && (sig_n_prime192.w[0] == sig_x.w[0])) { |
| res = (exp_x <= exp_y); |
| BID_RETURN (res); |
| } |
| res = ((sig_n_prime192.w[2] != 0) || |
| // if upper128 bits of compensated y are non-zero, y is bigger |
| (sig_n_prime192.w[1] > sig_x.w[1]) || |
| // if compensated y is bigger, y is bigger |
| (sig_n_prime192.w[1] == sig_x.w[1] |
| && sig_n_prime192.w[0] > sig_x.w[0])); |
| BID_RETURN (res); |
| } |
| |
| #if DECIMAL_CALL_BY_REFERENCE |
| void |
| bid128_radix (int *pres, UINT128 * px _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| UINT128 x = *px; |
| #else |
| int |
| bid128_radix (UINT128 x _EXC_MASKS_PARAM _EXC_INFO_PARAM) { |
| #endif |
| int res; |
| if (x.w[LOW_128W]) // dummy test |
| res = 10; |
| else |
| res = 10; |
| BID_RETURN (res); |
| } |