URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [libbid/] [bid128_compare.c] - Rev 734
Compare with Previous | Blame | View Log
/* Copyright (C) 2007, 2009 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. */ #include "bid_internal.h" BID128_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); } }