diff options
Diffstat (limited to 'gcc-4.9/libgcc/config/libbid/bid128_compare.c')
| -rw-r--r-- | gcc-4.9/libgcc/config/libbid/bid128_compare.c | 4346 |
1 files changed, 4346 insertions, 0 deletions
diff --git a/gcc-4.9/libgcc/config/libbid/bid128_compare.c b/gcc-4.9/libgcc/config/libbid/bid128_compare.c new file mode 100644 index 000000000..49ef7c05e --- /dev/null +++ b/gcc-4.9/libgcc/config/libbid/bid128_compare.c @@ -0,0 +1,4346 @@ +/* Copyright (C) 2007-2014 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_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_equal, x, y) + + int res; + int exp_x, exp_y, exp_t; + UINT128 sig_x, sig_y, sig_t; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 0 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 0; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equivalent. +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 1; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + if ((y.w[1] & MASK_INF) == MASK_INF) { + res = (((x.w[1] ^ y.w[1]) & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } else { + res = 0; + BID_RETURN (res); + } +} +if ((y.w[1] & MASK_INF) == MASK_INF) { + res = 0; + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + +if (x_is_zero && y_is_zero) { + res = 1; + BID_RETURN (res); +} else if ((x_is_zero && !y_is_zero) || (!x_is_zero && y_is_zero)) { + res = 0; + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ => not equal : return 0 +if ((x.w[1] ^ y.w[1]) & MASK_SIGN) { + res = 0; + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) +if (exp_x > exp_y) { // to simplify the loop below, + SWAP (exp_x, exp_y, exp_t); // put the larger exp in y, + SWAP (sig_x.w[1], sig_y.w[1], sig_t.w[1]); // and the smaller exp in x + SWAP (sig_x.w[0], sig_y.w[0], sig_t.w[0]); // and the smaller exp in x +} + + +if (exp_y - exp_x > 33) { + res = 0; + BID_RETURN (res); +} // difference cannot be greater than 10^33 + +if (exp_y - exp_x > 19) { + // recalculate y's significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, + ten2k128[exp_y - exp_x - 20]); + { + res = ((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])); + BID_RETURN (res); + } + +} + //else{ + // recalculate y's significand upwards +__mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_y - exp_x], sig_y); +{ + res = ((sig_n_prime192.w[2] == 0) + && (sig_n_prime192.w[1] == sig_x.w[1]) + && (sig_n_prime192.w[0] == sig_x.w[0])); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_greater, x, + y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, rather than + // equal : return 0 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 0; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 0; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x is neg infinity, there is no way it is greater than y, return 0 + if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) { + res = 0; + BID_RETURN (res); + } + // x is pos infinity, it is greater, unless y is positive infinity => + // return y!=pos_infinity + else { + res = (((y.w[1] & MASK_INF) != MASK_INF) + || ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 0; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +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); + } +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ + ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + res = ((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[1] == sig_x.w[1] && + sig_n_prime256.w[0] > sig_x.w[0]))) ^ + ((x.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 0; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] != 0 + || (sig_n_prime192.w[1] > sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, + bid128_quiet_greater_equal, x, + y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 1 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 0; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 1; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) } + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) + // x is -inf, so it is less than y unless y is -inf + { + res = (((y.w[1] & MASK_INF) == MASK_INF) + && (y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } else + // x is pos_inf, no way for it to be less than y + { + res = 1; + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 1; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison of the + // significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +if (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[0] <= sig_y.w[0] + && exp_x < exp_y) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 1; + BID_RETURN (res); + } // if equal, return 1 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 1; + BID_RETURN (res); + } // if equal, return 1 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 1; + BID_RETURN (res); + } // if equal, return 1 + { + res = ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] < + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 1; + BID_RETURN (res); +} // if equal, return 1 +{ + res = (sig_n_prime192.w[2] == 0 + && (sig_n_prime192.w[1] < sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] < + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, + bid128_quiet_greater_unordered, + x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than + // equal : return 1 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 1; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 0; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x is neg infinity, there is no way it is greater than y, return 0 + if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) { + res = 0; + BID_RETURN (res); + } + // x is pos infinity, it is greater, unless y is positive infinity => + // return y!=pos_infinity + else { + res = (((y.w[1] & MASK_INF) != MASK_INF) + || ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 0; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison of the + // significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +if (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[0] <= sig_y.w[0] + && exp_x < exp_y) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + res = ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] < + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 0; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] == 0 + && (sig_n_prime192.w[1] < sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] < + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_less, x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 0 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 0; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal. +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 0; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) } + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) + // x is -inf, so it is less than y unless y is -inf + { + res = (((y.w[1] & MASK_INF) != MASK_INF) + || (y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } else + // x is pos_inf, no way for it to be less than y + { + res = 0; + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 0; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison of the + // significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) != + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +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); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 0; + BID_RETURN (res); + } // if equal, return 1 + { + res = ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] > + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 0; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] != 0 + || (sig_n_prime192.w[1] > sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_less_equal, + x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 0 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 0; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 1; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x is neg infinity, there is no way it is greater than y, return 1 + if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) { + res = 1; + BID_RETURN (res); + } + // x is pos infinity, it is greater, unless y is positive infinity => + // return y!=pos_infinity + else { + res = (((y.w[1] & MASK_INF) == MASK_INF) + && ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 1; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison of the + // significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) || (sig_x.w[1] == sig_y.w[1] && + sig_x.w[0] >= + sig_y.w[0])) ^ ((x. + w[1] & + MASK_SIGN) != + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +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); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 1; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 1; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 1; + BID_RETURN (res); + } // if equal, return 0 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] > + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 1; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] != 0 + || (sig_n_prime192.w[1] > sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, + bid128_quiet_less_unordered, + x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 1; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal. +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 0; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) } + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) + // x is -inf, so it is less than y unless y is -inf + { + res = (((y.w[1] & MASK_INF) != MASK_INF) + || (y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } else + // x is pos_inf, no way for it to be less than y + { + res = 0; + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 0; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) != + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +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); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 0; + BID_RETURN (res); + } // if equal, return 1 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] > + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 0; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] != 0 + || (sig_n_prime192.w[1] > sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_not_equal, + x, y) + + int res; + int exp_x, exp_y, exp_t; + UINT128 sig_x, sig_y, sig_t; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 0 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 1; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equivalent. +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 0; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + if ((y.w[1] & MASK_INF) == MASK_INF) { + res = (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } else { + res = 1; + BID_RETURN (res); + } +} +if ((y.w[1] & MASK_INF) == MASK_INF) { + res = 1; + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + +if (x_is_zero && y_is_zero) { + res = 0; + BID_RETURN (res); +} else if ((x_is_zero && !y_is_zero) || (!x_is_zero && y_is_zero)) { + res = 1; + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ => not equal : return 0 +if ((x.w[1] ^ y.w[1]) & MASK_SIGN) { + res = 1; + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) +if (exp_x > exp_y) { // to simplify the loop below, + SWAP (exp_x, exp_y, exp_t); // put the larger exp in y, + SWAP (sig_x.w[1], sig_y.w[1], sig_t.w[1]); // and the smaller exp in x + SWAP (sig_x.w[0], sig_y.w[0], sig_t.w[0]); // and the smaller exp in x +} + + +if (exp_y - exp_x > 33) { + res = 1; + BID_RETURN (res); +} // difference cannot be greater than 10^33 + +if (exp_y - exp_x > 19) { + // recalculate y's significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, + ten2k128[exp_y - exp_x - 20]); + { + res = ((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])); + BID_RETURN (res); + } + +} + //else{ + // recalculate y's significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[exp_y - exp_x], sig_y); +{ + res = ((sig_n_prime192.w[2] != 0) + || (sig_n_prime192.w[1] != sig_x.w[1]) + || (sig_n_prime192.w[0] != sig_x.w[0])); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_not_greater, + x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 0 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 1; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 1; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x is neg infinity, there is no way it is greater than y, return 1 + if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) { + res = 1; + BID_RETURN (res); + } + // x is pos infinity, it is greater, unless y is positive infinity => return y!=pos_infinity + else { + res = (((y.w[1] & MASK_INF) == MASK_INF) + && ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 1; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) != + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +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); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 1; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 1; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 1; + BID_RETURN (res); + } // if equal, return 0 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] > + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 1; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] != 0 + || (sig_n_prime192.w[1] > sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_not_less, x, + y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 1 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 1; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 1; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) } + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) + // x is -inf, so it is less than y unless y is -inf + { + res = (((y.w[1] & MASK_INF) == MASK_INF) + && (y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } else + // x is pos_inf, no way for it to be less than y + { + res = 1; + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 1; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +if (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[0] <= sig_y.w[0] + && exp_x < exp_y) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 1; + BID_RETURN (res); + } // if equal, return 1 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 1; + BID_RETURN (res); + } // if equal, return 1 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 1; + BID_RETURN (res); + } // if equal, return 1 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] < + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 1; + BID_RETURN (res); +} // if equal, return 1 +{ + res = (sig_n_prime192.w[2] == 0 + && (sig_n_prime192.w[1] < sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] < + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_ordered, x, + y) + + int res; + + // NaN (CASE1) + // if either number is NAN, the comparison is ordered : return 1 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 0; + BID_RETURN (res); +} +} +{ + res = 1; + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_unordered, + x, y) + + int res; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered : return 1 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +if ((x.w[1] & MASK_SNAN) == MASK_SNAN + || (y.w[1] & MASK_SNAN) == MASK_SNAN) { + *pfpsf |= INVALID_EXCEPTION; +} +{ + res = 1; + BID_RETURN (res); +} +} +{ + res = 0; + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_signaling_greater, + x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 0 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +*pfpsf |= INVALID_EXCEPTION; +{ + res = 0; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 0; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x is neg infinity, there is no way it is greater than y, return 0 + if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) { + res = 0; + BID_RETURN (res); + } + // x is pos infinity, it is greater, unless y is positive infinity => return y!=pos_infinity + else { + res = (((y.w[1] & MASK_INF) != MASK_INF) + || ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 0; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +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); + } +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] > + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 0; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] != 0 + || (sig_n_prime192.w[1] > sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, + bid128_signaling_greater_equal, + x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 1 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +*pfpsf |= INVALID_EXCEPTION; +{ + res = 0; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 1; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) } + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) + // x is -inf, so it is less than y unless y is -inf + { + res = (((y.w[1] & MASK_INF) == MASK_INF) + && (y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } else + // x is pos_inf, no way for it to be less than y + { + res = 1; + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 1; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +if (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[0] <= sig_y.w[0] + && exp_x < exp_y) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 1; + BID_RETURN (res); + } // if equal, return 1 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 1; + BID_RETURN (res); + } // if equal, return 1 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 1; + BID_RETURN (res); + } // if equal, return 1 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] < + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 1; + BID_RETURN (res); +} // if equal, return 1 +{ + res = (sig_n_prime192.w[2] == 0 + && (sig_n_prime192.w[1] < sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] < + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, + bid128_signaling_greater_unordered, + x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 1 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +*pfpsf |= INVALID_EXCEPTION; +{ + res = 1; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 0; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x is neg infinity, there is no way it is greater than y, return 0 + if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) { + res = 0; + BID_RETURN (res); + } + // x is pos infinity, it is greater, unless y is positive infinity => return y!=pos_infinity + else { + res = (((y.w[1] & MASK_INF) != MASK_INF) + || ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 0; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +if (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[0] <= sig_y.w[0] + && exp_x < exp_y) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] < + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 0; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] == 0 + && (sig_n_prime192.w[1] < sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] < + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_signaling_less, x, + y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 0 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +*pfpsf |= INVALID_EXCEPTION; +{ + res = 0; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal. +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 0; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) } + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) + // x is -inf, so it is less than y unless y is -inf + { + res = (((y.w[1] & MASK_INF) != MASK_INF) + || (y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } else + // x is pos_inf, no way for it to be less than y + { + res = 0; + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 0; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) != + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +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); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, |x| < |y|, return 1 if positive +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 0; + BID_RETURN (res); + } // if equal, return 1 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] > + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 0; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] != 0 + || (sig_n_prime192.w[1] > sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, + bid128_signaling_less_equal, + x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 0 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +*pfpsf |= INVALID_EXCEPTION; +{ + res = 0; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 1; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x is neg infinity, there is no way it is greater than y, return 1 + if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) { + res = 1; + BID_RETURN (res); + } + // x is pos infinity, it is greater, unless y is positive infinity => return y!=pos_infinity + else { + res = (((y.w[1] & MASK_INF) == MASK_INF) + && ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 1; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) != + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +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); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 1; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 1; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 1; + BID_RETURN (res); + } // if equal, return 0 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] > + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 1; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] != 0 + || (sig_n_prime192.w[1] > sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, + bid128_signaling_less_unordered, + x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +*pfpsf |= INVALID_EXCEPTION; +{ + res = 1; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal. +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 0; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) } + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) + // x is -inf, so it is less than y unless y is -inf + { + res = (((y.w[1] & MASK_INF) != MASK_INF) + || (y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } else + // x is pos_inf, no way for it to be less than y + { + res = 0; + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 0; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) != + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +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); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 0; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 0; + BID_RETURN (res); + } // if equal, return 1 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] > + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger (converse if negative) +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 = 0; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] != 0 + || (sig_n_prime192.w[1] > sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, + bid128_signaling_not_greater, + x, y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 0 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +*pfpsf |= INVALID_EXCEPTION; +{ + res = 1; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 1; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x is neg infinity, there is no way it is greater than y, return 1 + if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) { + res = 1; + BID_RETURN (res); + } + // x is pos infinity, it is greater, unless y is positive infinity => return y!=pos_infinity + else { + res = (((y.w[1] & MASK_INF) == MASK_INF) + && ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 1; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) != + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +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); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 1; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 1; + BID_RETURN (res); + } // if equal, return 0 + { + 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])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 1; + BID_RETURN (res); + } // if equal, return 0 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] > + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger + // (converse if negative) +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 = 1; + BID_RETURN (res); +} // if equal, return 0 +{ + res = (sig_n_prime192.w[2] != 0 + || (sig_n_prime192.w[1] > sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] > + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} + +BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, + bid128_signaling_not_less, x, + y) + + int res; + int exp_x, exp_y; + int diff; + UINT128 sig_x, sig_y; + UINT192 sig_n_prime192; + UINT256 sig_n_prime256; + char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y; + + // NaN (CASE1) + // if either number is NAN, the comparison is unordered, + // rather than equal : return 1 +if (((x.w[1] & MASK_NAN) == MASK_NAN) + || ((y.w[1] & MASK_NAN) == MASK_NAN)) { +*pfpsf |= INVALID_EXCEPTION; +{ + res = 1; + BID_RETURN (res); +} +} + // SIMPLE (CASE2) + // if all the bits are the same, these numbers are equal (not Greater). +if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) { + res = 1; + BID_RETURN (res); +} + // INFINITY (CASE3) +if ((x.w[1] & MASK_INF) == MASK_INF) { + // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) } + if ((x.w[1] & MASK_SIGN) == MASK_SIGN) + // x is -inf, so it is less than y unless y is -inf + { + res = (((y.w[1] & MASK_INF) == MASK_INF) + && (y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); + } else + // x is pos_inf, no way for it to be less than y + { + res = 1; + BID_RETURN (res); + } +} else if ((y.w[1] & MASK_INF) == MASK_INF) { + // x is finite, so if y is positive infinity, then x is less, return 0 + // if y is negative infinity, then x is greater, return 1 + { + 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)) + non_canon_x = 1; +else + non_canon_x = 0; + + // 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)) + non_canon_y = 1; +else + non_canon_y = 0; + + // ZERO (CASE4) + // some properties: + // (+ZERO == -ZERO) => therefore ignore the sign + // (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore + // ignore the exponent field + // (Any non-canonical # is considered 0) +if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) { + x_is_zero = 1; +} +if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) { + y_is_zero = 1; +} + // if both numbers are zero, neither is greater => return NOTGREATERTHAN +if (x_is_zero && y_is_zero) { + res = 1; + BID_RETURN (res); +} + // is x is zero, it is greater if Y is negative +else if (x_is_zero) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // is y is zero, X is greater if it is positive +else if (y_is_zero) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); +} + // OPPOSITE SIGN (CASE5) + // now, if the sign bits differ, x is greater if y is negative +if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) { + res = ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + // REDUNDANT REPRESENTATIONS (CASE6) + + // if exponents are the same, then we have a simple comparison + // of the significands +if (exp_y == exp_x) { + res = (((sig_x.w[1] > sig_y.w[1]) + || (sig_x.w[1] == sig_y.w[1] + && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) == + MASK_SIGN)); + BID_RETURN (res); +} + // if both components are either bigger or smaller, + // it is clear what needs to be done +if (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[0] <= sig_y.w[0] + && exp_x < exp_y) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +diff = exp_x - exp_y; + + // if |exp_x - exp_y| < 33, it comes down to the compensated significand +if (diff > 0) { // to simplify the loop below, + + // if exp_x is 33 greater than exp_y, no need for compensation + if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) != MASK_SIGN); + BID_RETURN (res); + } // difference cannot be greater than 10^33 + + if (diff > 19) { //128 by 128 bit multiply -> 256 bits + __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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])) { + res = 1; + BID_RETURN (res); + } // if equal, return 1 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } + } + //else { //128 by 64 bit multiply -> 192 bits + __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x); + + // if postitive, 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 = 1; + BID_RETURN (res); + } // if equal, return 1 + { + 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])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + +diff = exp_y - exp_x; + + // if exp_x is 33 less than exp_y, no need for compensation +if (diff > 33) { + res = ((x.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} + +if (diff > 19) { //128 by 128 bit multiply -> 256 bits + // adjust the y significand upwards + __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]); + + + // if postitive, return whichever significand is larger + // (converse if negative) + 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 = 1; + BID_RETURN (res); + } // if equal, return 1 + { + res = + ((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[1] == sig_x.w[1] + && sig_n_prime256.w[0] < + sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN)); + BID_RETURN (res); + } +} + //else { //128 by 64 bit multiply -> 192 bits + // adjust the y significand upwards +__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y); + + // if postitive, return whichever significand is larger (converse if negative) +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 = 1; + BID_RETURN (res); +} // if equal, return 1 +{ + res = (sig_n_prime192.w[2] == 0 + && (sig_n_prime192.w[1] < sig_x.w[1] + || (sig_n_prime192.w[1] == sig_x.w[1] + && sig_n_prime192.w[0] < + sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN); + BID_RETURN (res); +} +} |