OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [libbid/] [bid128_compare.c] - Blame information for rev 734

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 734 jeremybenn
/* Copyright (C) 2007, 2009  Free Software Foundation, Inc.
2
 
3
This file is part of GCC.
4
 
5
GCC is free software; you can redistribute it and/or modify it under
6
the terms of the GNU General Public License as published by the Free
7
Software Foundation; either version 3, or (at your option) any later
8
version.
9
 
10
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11
WARRANTY; without even the implied warranty of MERCHANTABILITY or
12
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
13
for more details.
14
 
15
Under Section 7 of GPL version 3, you are granted additional
16
permissions described in the GCC Runtime Library Exception, version
17
3.1, as published by the Free Software Foundation.
18
 
19
You should have received a copy of the GNU General Public License and
20
a copy of the GCC Runtime Library Exception along with this program;
21
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
22
<http://www.gnu.org/licenses/>.  */
23
 
24
#include "bid_internal.h"
25
 
26
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_equal, x, y)
27
 
28
     int res;
29
     int exp_x, exp_y, exp_t;
30
     UINT128 sig_x, sig_y, sig_t;
31
     UINT192 sig_n_prime192;
32
     UINT256 sig_n_prime256;
33
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
34
 
35
  // NaN (CASE1)
36
  // if either number is NAN, the comparison is unordered, 
37
  // rather than equal : return 0
38
if (((x.w[1] & MASK_NAN) == MASK_NAN)
39
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
40
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
41
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
42
  *pfpsf |= INVALID_EXCEPTION;
43
}
44
{
45
  res = 0;
46
  BID_RETURN (res);
47
}
48
}
49
  // SIMPLE (CASE2)
50
  // if all the bits are the same, these numbers are equivalent.
51
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
52
  res = 1;
53
  BID_RETURN (res);
54
}
55
  // INFINITY (CASE3)
56
if ((x.w[1] & MASK_INF) == MASK_INF) {
57
  if ((y.w[1] & MASK_INF) == MASK_INF) {
58
    res = (((x.w[1] ^ y.w[1]) & MASK_SIGN) != MASK_SIGN);
59
    BID_RETURN (res);
60
  } else {
61
    res = 0;
62
    BID_RETURN (res);
63
  }
64
}
65
if ((y.w[1] & MASK_INF) == MASK_INF) {
66
  res = 0;
67
  BID_RETURN (res);
68
}
69
  // CONVERT X
70
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
71
sig_x.w[0] = x.w[0];
72
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
73
 
74
  // CHECK IF X IS CANONICAL
75
  // 9999999999999999999999999999999999(decimal) = 
76
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
77
  // [0, 10^34) is the 754r supported canonical range.  
78
  //   If the value exceeds that, it is interpreted as 0.
79
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
80
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
81
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
82
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
83
  non_canon_x = 1;
84
else
85
  non_canon_x = 0;
86
 
87
  // CONVERT Y
88
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
89
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
90
sig_y.w[0] = y.w[0];
91
 
92
  // CHECK IF Y IS CANONICAL
93
  // 9999999999999999999999999999999999(decimal) = 
94
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
95
  // [0, 10^34) is the 754r supported canonical range.  
96
  // If the value exceeds that, it is interpreted as 0.
97
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
98
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
99
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
100
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
101
  non_canon_y = 1;
102
else
103
  non_canon_y = 0;
104
 
105
  // some properties:
106
  //    (+ZERO == -ZERO) => therefore ignore the sign
107
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
108
  //    ignore the exponent field
109
  //    (Any non-canonical # is considered 0)
110
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
111
  x_is_zero = 1;
112
}
113
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
114
  y_is_zero = 1;
115
}
116
 
117
if (x_is_zero && y_is_zero) {
118
  res = 1;
119
  BID_RETURN (res);
120
} else if ((x_is_zero && !y_is_zero) || (!x_is_zero && y_is_zero)) {
121
  res = 0;
122
  BID_RETURN (res);
123
}
124
  // OPPOSITE SIGN (CASE5)
125
  // now, if the sign bits differ => not equal : return 0
126
if ((x.w[1] ^ y.w[1]) & MASK_SIGN) {
127
  res = 0;
128
  BID_RETURN (res);
129
}
130
  // REDUNDANT REPRESENTATIONS (CASE6)
131
if (exp_x > exp_y) {    // to simplify the loop below,
132
  SWAP (exp_x, exp_y, exp_t);   // put the larger exp in y,
133
  SWAP (sig_x.w[1], sig_y.w[1], sig_t.w[1]);    // and the smaller exp in x
134
  SWAP (sig_x.w[0], sig_y.w[0], sig_t.w[0]);       // and the smaller exp in x
135
}
136
 
137
 
138
if (exp_y - exp_x > 33) {
139
  res = 0;
140
  BID_RETURN (res);
141
}       // difference cannot be greater than 10^33
142
 
143
if (exp_y - exp_x > 19) {
144
  // recalculate y's significand upwards
145
  __mul_128x128_to_256 (sig_n_prime256, sig_y,
146
                        ten2k128[exp_y - exp_x - 20]);
147
  {
148
    res = ((sig_n_prime256.w[3] == 0) && (sig_n_prime256.w[2] == 0)
149
           && (sig_n_prime256.w[1] == sig_x.w[1])
150
           && (sig_n_prime256.w[0] == sig_x.w[0]));
151
    BID_RETURN (res);
152
  }
153
 
154
}
155
  //else{
156
  // recalculate y's significand upwards
157
__mul_64x128_to_192 (sig_n_prime192, ten2k64[exp_y - exp_x], sig_y);
158
{
159
  res = ((sig_n_prime192.w[2] == 0)
160
         && (sig_n_prime192.w[1] == sig_x.w[1])
161
         && (sig_n_prime192.w[0] == sig_x.w[0]));
162
  BID_RETURN (res);
163
}
164
}
165
 
166
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_greater, x,
167
                                          y)
168
 
169
     int res;
170
     int exp_x, exp_y;
171
     int diff;
172
     UINT128 sig_x, sig_y;
173
     UINT192 sig_n_prime192;
174
     UINT256 sig_n_prime256;
175
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
176
 
177
  // NaN (CASE1)
178
  // if either number is NAN, the comparison is unordered, rather than 
179
  // equal : return 0
180
if (((x.w[1] & MASK_NAN) == MASK_NAN)
181
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
182
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
183
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
184
  *pfpsf |= INVALID_EXCEPTION;
185
}
186
{
187
  res = 0;
188
  BID_RETURN (res);
189
}
190
}
191
  // SIMPLE (CASE2)
192
  // if all the bits are the same, these numbers are equal (not Greater).
193
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
194
  res = 0;
195
  BID_RETURN (res);
196
}
197
  // INFINITY (CASE3)
198
if ((x.w[1] & MASK_INF) == MASK_INF) {
199
  // if x is neg infinity, there is no way it is greater than y, return 0
200
  if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) {
201
    res = 0;
202
    BID_RETURN (res);
203
  }
204
  // x is pos infinity, it is greater, unless y is positive infinity => 
205
  // return y!=pos_infinity
206
  else {
207
    res = (((y.w[1] & MASK_INF) != MASK_INF)
208
           || ((y.w[1] & MASK_SIGN) == MASK_SIGN));
209
    BID_RETURN (res);
210
  }
211
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
212
  // x is finite, so if y is positive infinity, then x is less, return 0
213
  //                 if y is negative infinity, then x is greater, return 1
214
  {
215
    res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
216
    BID_RETURN (res);
217
  }
218
}
219
  // CONVERT X
220
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
221
sig_x.w[0] = x.w[0];
222
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
223
 
224
  // CHECK IF X IS CANONICAL
225
  // 9999999999999999999999999999999999(decimal) = 
226
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
227
  // [0, 10^34) is the 754r supported canonical range.  
228
  //    If the value exceeds that, it is interpreted as 0.
229
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
230
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
231
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
232
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
233
  non_canon_x = 1;
234
else
235
  non_canon_x = 0;
236
 
237
  // CONVERT Y
238
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
239
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
240
sig_y.w[0] = y.w[0];
241
 
242
  // CHECK IF Y IS CANONICAL
243
  // 9999999999999999999999999999999999(decimal) = 
244
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
245
  // [0, 10^34) is the 754r supported canonical range.  
246
  //    If the value exceeds that, it is interpreted as 0.
247
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
248
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
249
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
250
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
251
  non_canon_y = 1;
252
else
253
  non_canon_y = 0;
254
 
255
  // ZERO (CASE4)
256
  // some properties:
257
  //    (+ZERO == -ZERO) => therefore ignore the sign
258
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
259
  //    ignore the exponent field
260
  //    (Any non-canonical # is considered 0)
261
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
262
  x_is_zero = 1;
263
}
264
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
265
  y_is_zero = 1;
266
}
267
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
268
if (x_is_zero && y_is_zero) {
269
  res = 0;
270
  BID_RETURN (res);
271
}
272
  // is x is zero, it is greater if Y is negative
273
else if (x_is_zero) {
274
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
275
  BID_RETURN (res);
276
}
277
  // is y is zero, X is greater if it is positive
278
else if (y_is_zero) {
279
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
280
  BID_RETURN (res);
281
}
282
  // OPPOSITE SIGN (CASE5)
283
  // now, if the sign bits differ, x is greater if y is negative
284
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
285
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
286
  BID_RETURN (res);
287
}
288
  // REDUNDANT REPRESENTATIONS (CASE6)
289
  // if exponents are the same, then we have a simple comparison 
290
  // of the significands
291
if (exp_y == exp_x) {
292
  res = (((sig_x.w[1] > sig_y.w[1])
293
          || (sig_x.w[1] == sig_y.w[1]
294
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) ==
295
                                               MASK_SIGN));
296
  BID_RETURN (res);
297
}
298
  // if both components are either bigger or smaller, 
299
  // it is clear what needs to be done
300
if ((sig_x.w[1] > sig_y.w[1]
301
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
302
    && exp_x >= exp_y) {
303
  {
304
    res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
305
    BID_RETURN (res);
306
  }
307
}
308
if ((sig_x.w[1] < sig_y.w[1]
309
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
310
    && exp_x <= exp_y) {
311
  {
312
    res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
313
    BID_RETURN (res);
314
  }
315
}
316
 
317
diff = exp_x - exp_y;
318
 
319
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
320
if (diff > 0) {  // to simplify the loop below,
321
 
322
  // if exp_x is 33 greater than exp_y, no need for compensation
323
  if (diff > 33) {
324
    res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
325
    BID_RETURN (res);
326
  }     // difference cannot be greater than 10^33
327
 
328
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
329
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
330
 
331
    // if postitive, return whichever significand is larger 
332
    // (converse if negative)
333
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
334
        && sig_n_prime256.w[1] == sig_y.w[1]
335
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
336
      res = 0;
337
      BID_RETURN (res);
338
    }   // if equal, return 0
339
    {
340
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
341
              || (sig_n_prime256.w[1] > sig_y.w[1])
342
              || (sig_n_prime256.w[1] == sig_y.w[1]
343
                  && sig_n_prime256.w[0] >
344
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
345
      BID_RETURN (res);
346
    }
347
  }
348
  //else { //128 by 64 bit multiply -> 192 bits
349
  __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
350
 
351
  // if postitive, return whichever significand is larger 
352
  // (converse if negative)
353
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
354
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
355
    res = 0;
356
    BID_RETURN (res);
357
  }     // if equal, return 0
358
  {
359
    res = (((sig_n_prime192.w[2] > 0) ||
360
            (sig_n_prime192.w[1] > sig_y.w[1]) ||
361
            (sig_n_prime192.w[1] == sig_y.w[1] &&
362
             sig_n_prime192.w[0] > sig_y.w[0])) ^
363
           ((y.w[1] & MASK_SIGN) == MASK_SIGN));
364
    BID_RETURN (res);
365
  }
366
}
367
 
368
diff = exp_y - exp_x;
369
 
370
  // if exp_x is 33 less than exp_y, no need for compensation
371
if (diff > 33) {
372
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
373
  BID_RETURN (res);
374
}
375
 
376
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
377
  // adjust the y significand upwards
378
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
379
 
380
  // if postitive, return whichever significand is larger 
381
  // (converse if negative)
382
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
383
      && sig_n_prime256.w[1] == sig_x.w[1]
384
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
385
    res = 0;
386
    BID_RETURN (res);
387
  }     // if equal, return 0
388
  {
389
    res = ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0 ||
390
            (sig_n_prime256.w[1] > sig_x.w[1] ||
391
             (sig_n_prime256.w[1] == sig_x.w[1] &&
392
              sig_n_prime256.w[0] > sig_x.w[0]))) ^
393
           ((x.w[1] & MASK_SIGN) != MASK_SIGN));
394
    BID_RETURN (res);
395
  }
396
}
397
  //else { //128 by 64 bit multiply -> 192 bits
398
  // adjust the y significand upwards
399
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
400
 
401
  // if postitive, return whichever significand is larger 
402
  // (converse if negative)
403
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
404
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
405
  res = 0;
406
  BID_RETURN (res);
407
}       // if equal, return 0
408
{
409
  res = (sig_n_prime192.w[2] != 0
410
         || (sig_n_prime192.w[1] > sig_x.w[1]
411
             || (sig_n_prime192.w[1] == sig_x.w[1]
412
                 && sig_n_prime192.w[0] >
413
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN);
414
  BID_RETURN (res);
415
}
416
}
417
 
418
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int,
419
                                          bid128_quiet_greater_equal, x,
420
                                          y)
421
 
422
     int res;
423
     int exp_x, exp_y;
424
     int diff;
425
     UINT128 sig_x, sig_y;
426
     UINT192 sig_n_prime192;
427
     UINT256 sig_n_prime256;
428
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
429
 
430
  // NaN (CASE1)
431
  // if either number is NAN, the comparison is unordered, 
432
  // rather than equal : return 1
433
if (((x.w[1] & MASK_NAN) == MASK_NAN)
434
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
435
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
436
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
437
  *pfpsf |= INVALID_EXCEPTION;
438
}
439
{
440
  res = 0;
441
  BID_RETURN (res);
442
}
443
}
444
  // SIMPLE (CASE2)
445
  // if all the bits are the same, these numbers are equal (not Greater).
446
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
447
  res = 1;
448
  BID_RETURN (res);
449
}
450
  // INFINITY (CASE3)
451
if ((x.w[1] & MASK_INF) == MASK_INF) {
452
  // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
453
  if ((x.w[1] & MASK_SIGN) == MASK_SIGN)
454
    // x is -inf, so it is less than y unless y is -inf
455
  {
456
    res = (((y.w[1] & MASK_INF) == MASK_INF)
457
           && (y.w[1] & MASK_SIGN) == MASK_SIGN);
458
    BID_RETURN (res);
459
  } else
460
    // x is pos_inf, no way for it to be less than y
461
  {
462
    res = 1;
463
    BID_RETURN (res);
464
  }
465
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
466
  // x is finite, so if y is positive infinity, then x is less, return 0
467
  //                 if y is negative infinity, then x is greater, return 1
468
  {
469
    res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
470
    BID_RETURN (res);
471
  }
472
}
473
  // CONVERT X
474
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
475
sig_x.w[0] = x.w[0];
476
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
477
 
478
  // CHECK IF X IS CANONICAL
479
  // 9999999999999999999999999999999999(decimal) = 
480
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
481
  // [0, 10^34) is the 754r supported canonical range.  
482
  //    If the value exceeds that, it is interpreted as 0.
483
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
484
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
485
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
486
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
487
  non_canon_x = 1;
488
else
489
  non_canon_x = 0;
490
 
491
  // CONVERT Y
492
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
493
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
494
sig_y.w[0] = y.w[0];
495
 
496
  // CHECK IF Y IS CANONICAL
497
  // 9999999999999999999999999999999999(decimal) = 
498
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
499
  // [0, 10^34) is the 754r supported canonical range.  
500
  //    If the value exceeds that, it is interpreted as 0.
501
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
502
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
503
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
504
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
505
  non_canon_y = 1;
506
else
507
  non_canon_y = 0;
508
 
509
  // ZERO (CASE4)
510
  // some properties:
511
  //    (+ZERO == -ZERO) => therefore ignore the sign
512
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
513
  //    ignore the exponent field
514
  //    (Any non-canonical # is considered 0)
515
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
516
  x_is_zero = 1;
517
}
518
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
519
  y_is_zero = 1;
520
}
521
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
522
if (x_is_zero && y_is_zero) {
523
  res = 1;
524
  BID_RETURN (res);
525
}
526
  // is x is zero, it is greater if Y is negative
527
else if (x_is_zero) {
528
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
529
  BID_RETURN (res);
530
}
531
  // is y is zero, X is greater if it is positive
532
else if (y_is_zero) {
533
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
534
  BID_RETURN (res);
535
}
536
  // OPPOSITE SIGN (CASE5)
537
  // now, if the sign bits differ, x is greater if y is negative
538
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
539
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
540
  BID_RETURN (res);
541
}
542
  // REDUNDANT REPRESENTATIONS (CASE6)
543
  // if exponents are the same, then we have a simple comparison of the 
544
  // significands
545
if (exp_y == exp_x) {
546
  res = (((sig_x.w[1] > sig_y.w[1])
547
          || (sig_x.w[1] == sig_y.w[1]
548
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) ==
549
                                               MASK_SIGN));
550
  BID_RETURN (res);
551
}
552
  // if both components are either bigger or smaller, 
553
  // it is clear what needs to be done
554
if (sig_x.w[1] >= sig_y.w[1] && sig_x.w[0] >= sig_y.w[0]
555
    && exp_x > exp_y) {
556
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
557
  BID_RETURN (res);
558
}
559
if (sig_x.w[1] <= sig_y.w[1] && sig_x.w[0] <= sig_y.w[0]
560
    && exp_x < exp_y) {
561
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
562
  BID_RETURN (res);
563
}
564
 
565
diff = exp_x - exp_y;
566
 
567
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
568
if (diff > 0) {  // to simplify the loop below,
569
 
570
  // if exp_x is 33 greater than exp_y, no need for compensation
571
  if (diff > 33) {
572
    res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
573
    BID_RETURN (res);
574
  }     // difference cannot be greater than 10^33
575
 
576
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
577
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
578
 
579
 
580
    // if postitive, return whichever significand is larger 
581
    // (converse if negative)
582
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
583
        && sig_n_prime256.w[1] == sig_y.w[1]
584
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
585
      res = 1;
586
      BID_RETURN (res);
587
    }   // if equal, return 1
588
    {
589
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
590
              || (sig_n_prime256.w[1] > sig_y.w[1])
591
              || (sig_n_prime256.w[1] == sig_y.w[1]
592
                  && sig_n_prime256.w[0] >
593
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
594
      BID_RETURN (res);
595
    }
596
  }
597
  //else { //128 by 64 bit multiply -> 192 bits
598
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
599
 
600
  // if postitive, return whichever significand is larger 
601
  // (converse if negative)
602
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
603
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
604
    res = 1;
605
    BID_RETURN (res);
606
  }     // if equal, return 1
607
  {
608
    res = (((sig_n_prime192.w[2] > 0)
609
            || (sig_n_prime192.w[1] > sig_y.w[1])
610
            || (sig_n_prime192.w[1] == sig_y.w[1]
611
                && sig_n_prime192.w[0] >
612
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
613
    BID_RETURN (res);
614
  }
615
}
616
 
617
diff = exp_y - exp_x;
618
 
619
  // if exp_x is 33 less than exp_y, no need for compensation
620
if (diff > 33) {
621
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
622
  BID_RETURN (res);
623
}
624
 
625
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
626
  // adjust the y significand upwards
627
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
628
 
629
 
630
  // if postitive, return whichever significand is larger 
631
  // (converse if negative)
632
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
633
      && sig_n_prime256.w[1] == sig_x.w[1]
634
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
635
    res = 1;
636
    BID_RETURN (res);
637
  }     // if equal, return 1
638
  {
639
    res = ((sig_n_prime256.w[3] == 0 && sig_n_prime256.w[2] == 0
640
            && (sig_n_prime256.w[1] < sig_x.w[1]
641
                || (sig_n_prime256.w[1] == sig_x.w[1]
642
                    && sig_n_prime256.w[0] <
643
                    sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) ==
644
                                     MASK_SIGN));
645
    BID_RETURN (res);
646
  }
647
}
648
  //else { //128 by 64 bit multiply -> 192 bits
649
  // adjust the y significand upwards
650
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
651
 
652
  // if postitive, return whichever significand is larger 
653
  // (converse if negative)
654
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
655
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
656
  res = 1;
657
  BID_RETURN (res);
658
}       // if equal, return 1
659
{
660
  res = (sig_n_prime192.w[2] == 0
661
         && (sig_n_prime192.w[1] < sig_x.w[1]
662
             || (sig_n_prime192.w[1] == sig_x.w[1]
663
                 && sig_n_prime192.w[0] <
664
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
665
  BID_RETURN (res);
666
}
667
}
668
 
669
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int,
670
                                          bid128_quiet_greater_unordered,
671
                                          x, y)
672
 
673
     int res;
674
     int exp_x, exp_y;
675
     int diff;
676
     UINT128 sig_x, sig_y;
677
     UINT192 sig_n_prime192;
678
     UINT256 sig_n_prime256;
679
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
680
 
681
  // NaN (CASE1)
682
  // if either number is NAN, the comparison is unordered, 
683
  // rather than 
684
  // equal : return 1
685
if (((x.w[1] & MASK_NAN) == MASK_NAN)
686
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
687
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
688
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
689
  *pfpsf |= INVALID_EXCEPTION;
690
}
691
{
692
  res = 1;
693
  BID_RETURN (res);
694
}
695
}
696
  // SIMPLE (CASE2)
697
  // if all the bits are the same, these numbers are equal (not Greater).
698
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
699
  res = 0;
700
  BID_RETURN (res);
701
}
702
  // INFINITY (CASE3)
703
if ((x.w[1] & MASK_INF) == MASK_INF) {
704
  // if x is neg infinity, there is no way it is greater than y, return 0
705
  if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) {
706
    res = 0;
707
    BID_RETURN (res);
708
  }
709
  // x is pos infinity, it is greater, unless y is positive infinity => 
710
  // return y!=pos_infinity
711
  else {
712
    res = (((y.w[1] & MASK_INF) != MASK_INF)
713
           || ((y.w[1] & MASK_SIGN) == MASK_SIGN));
714
    BID_RETURN (res);
715
  }
716
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
717
  // x is finite, so if y is positive infinity, then x is less, return 0
718
  //                 if y is negative infinity, then x is greater, return 1
719
  {
720
    res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
721
    BID_RETURN (res);
722
  }
723
}
724
  // CONVERT X
725
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
726
sig_x.w[0] = x.w[0];
727
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
728
 
729
  // CHECK IF X IS CANONICAL
730
  // 9999999999999999999999999999999999(decimal) = 
731
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
732
  // [0, 10^34) is the 754r supported canonical range.  
733
  //    If the value exceeds that, it is interpreted as 0.
734
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
735
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
736
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
737
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
738
  non_canon_x = 1;
739
else
740
  non_canon_x = 0;
741
 
742
  // CONVERT Y
743
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
744
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
745
sig_y.w[0] = y.w[0];
746
 
747
  // CHECK IF Y IS CANONICAL
748
  // 9999999999999999999999999999999999(decimal) = 
749
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
750
  // [0, 10^34) is the 754r supported canonical range.  
751
  //    If the value exceeds that, it is interpreted as 0.
752
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
753
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
754
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
755
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
756
  non_canon_y = 1;
757
else
758
  non_canon_y = 0;
759
 
760
  // ZERO (CASE4)
761
  // some properties:
762
  //    (+ZERO == -ZERO) => therefore ignore the sign
763
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
764
  //    ignore the exponent field
765
  //    (Any non-canonical # is considered 0)
766
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
767
  x_is_zero = 1;
768
}
769
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
770
  y_is_zero = 1;
771
}
772
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
773
if (x_is_zero && y_is_zero) {
774
  res = 0;
775
  BID_RETURN (res);
776
}
777
  // is x is zero, it is greater if Y is negative
778
else if (x_is_zero) {
779
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
780
  BID_RETURN (res);
781
}
782
  // is y is zero, X is greater if it is positive
783
else if (y_is_zero) {
784
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
785
  BID_RETURN (res);
786
}
787
  // OPPOSITE SIGN (CASE5)
788
  // now, if the sign bits differ, x is greater if y is negative
789
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
790
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
791
  BID_RETURN (res);
792
}
793
  // REDUNDANT REPRESENTATIONS (CASE6)
794
  // if exponents are the same, then we have a simple comparison of the 
795
  // significands
796
if (exp_y == exp_x) {
797
  res = (((sig_x.w[1] > sig_y.w[1])
798
          || (sig_x.w[1] == sig_y.w[1]
799
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) ==
800
                                               MASK_SIGN));
801
  BID_RETURN (res);
802
}
803
  // if both components are either bigger or smaller, 
804
  // it is clear what needs to be done
805
if (sig_x.w[1] >= sig_y.w[1] && sig_x.w[0] >= sig_y.w[0]
806
    && exp_x > exp_y) {
807
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
808
  BID_RETURN (res);
809
}
810
if (sig_x.w[1] <= sig_y.w[1] && sig_x.w[0] <= sig_y.w[0]
811
    && exp_x < exp_y) {
812
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
813
  BID_RETURN (res);
814
}
815
 
816
diff = exp_x - exp_y;
817
 
818
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
819
if (diff > 0) {  // to simplify the loop below,
820
 
821
  // if exp_x is 33 greater than exp_y, no need for compensation
822
  if (diff > 33) {
823
    res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
824
    BID_RETURN (res);
825
  }     // difference cannot be greater than 10^33
826
 
827
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
828
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
829
 
830
 
831
    // if postitive, return whichever significand is larger 
832
    // (converse if negative)
833
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
834
        && sig_n_prime256.w[1] == sig_y.w[1]
835
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
836
      res = 0;
837
      BID_RETURN (res);
838
    }   // if equal, return 0
839
    {
840
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
841
              || (sig_n_prime256.w[1] > sig_y.w[1])
842
              || (sig_n_prime256.w[1] == sig_y.w[1]
843
                  && sig_n_prime256.w[0] >
844
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
845
      BID_RETURN (res);
846
    }
847
  }
848
  //else { //128 by 64 bit multiply -> 192 bits
849
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
850
 
851
  // if postitive, return whichever significand is larger 
852
  // (converse if negative)
853
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
854
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
855
    res = 0;
856
    BID_RETURN (res);
857
  }     // if equal, return 0
858
  {
859
    res = (((sig_n_prime192.w[2] > 0)
860
            || (sig_n_prime192.w[1] > sig_y.w[1])
861
            || (sig_n_prime192.w[1] == sig_y.w[1]
862
                && sig_n_prime192.w[0] >
863
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
864
    BID_RETURN (res);
865
  }
866
}
867
 
868
diff = exp_y - exp_x;
869
 
870
  // if exp_x is 33 less than exp_y, no need for compensation
871
if (diff > 33) {
872
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
873
  BID_RETURN (res);
874
}
875
 
876
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
877
  // adjust the y significand upwards
878
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
879
 
880
 
881
  // if postitive, return whichever significand is larger 
882
  // (converse if negative)
883
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
884
      && sig_n_prime256.w[1] == sig_x.w[1]
885
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
886
    res = 0;
887
    BID_RETURN (res);
888
  }     // if equal, return 0
889
  {
890
    res = ((sig_n_prime256.w[3] == 0 && sig_n_prime256.w[2] == 0
891
            && (sig_n_prime256.w[1] < sig_x.w[1]
892
                || (sig_n_prime256.w[1] == sig_x.w[1]
893
                    && sig_n_prime256.w[0] <
894
                    sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) ==
895
                                     MASK_SIGN));
896
    BID_RETURN (res);
897
  }
898
}
899
  //else { //128 by 64 bit multiply -> 192 bits
900
  // adjust the y significand upwards
901
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
902
 
903
  // if postitive, return whichever significand is larger 
904
  // (converse if negative)
905
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
906
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
907
  res = 0;
908
  BID_RETURN (res);
909
}       // if equal, return 0
910
{
911
  res = (sig_n_prime192.w[2] == 0
912
         && (sig_n_prime192.w[1] < sig_x.w[1]
913
             || (sig_n_prime192.w[1] == sig_x.w[1]
914
                 && sig_n_prime192.w[0] <
915
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
916
  BID_RETURN (res);
917
}
918
}
919
 
920
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_less, x, y)
921
 
922
     int res;
923
     int exp_x, exp_y;
924
     int diff;
925
     UINT128 sig_x, sig_y;
926
     UINT192 sig_n_prime192;
927
     UINT256 sig_n_prime256;
928
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
929
 
930
  // NaN (CASE1)
931
  // if either number is NAN, the comparison is unordered, 
932
  // rather than equal : return 0
933
if (((x.w[1] & MASK_NAN) == MASK_NAN)
934
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
935
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
936
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
937
  *pfpsf |= INVALID_EXCEPTION;
938
}
939
{
940
  res = 0;
941
  BID_RETURN (res);
942
}
943
}
944
  // SIMPLE (CASE2)
945
  // if all the bits are the same, these numbers are equal.
946
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
947
  res = 0;
948
  BID_RETURN (res);
949
}
950
  // INFINITY (CASE3)
951
if ((x.w[1] & MASK_INF) == MASK_INF) {
952
  // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
953
  if ((x.w[1] & MASK_SIGN) == MASK_SIGN)
954
    // x is -inf, so it is less than y unless y is -inf
955
  {
956
    res = (((y.w[1] & MASK_INF) != MASK_INF)
957
           || (y.w[1] & MASK_SIGN) != MASK_SIGN);
958
    BID_RETURN (res);
959
  } else
960
    // x is pos_inf, no way for it to be less than y
961
  {
962
    res = 0;
963
    BID_RETURN (res);
964
  }
965
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
966
  // x is finite, so if y is positive infinity, then x is less, return 0
967
  //                 if y is negative infinity, then x is greater, return 1
968
  {
969
    res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
970
    BID_RETURN (res);
971
  }
972
}
973
  // CONVERT X
974
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
975
sig_x.w[0] = x.w[0];
976
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
977
 
978
  // CHECK IF X IS CANONICAL
979
  // 9999999999999999999999999999999999(decimal) = 
980
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
981
  // [0, 10^34) is the 754r supported canonical range.  
982
  //    If the value exceeds that, it is interpreted as 0.
983
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
984
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
985
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
986
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
987
  non_canon_x = 1;
988
else
989
  non_canon_x = 0;
990
 
991
  // CONVERT Y
992
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
993
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
994
sig_y.w[0] = y.w[0];
995
 
996
  // CHECK IF Y IS CANONICAL
997
  // 9999999999999999999999999999999999(decimal) = 
998
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
999
  // [0, 10^34) is the 754r supported canonical range.  
1000
  //    If the value exceeds that, it is interpreted as 0.
1001
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
1002
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
1003
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
1004
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
1005
  non_canon_y = 1;
1006
else
1007
  non_canon_y = 0;
1008
 
1009
  // ZERO (CASE4)
1010
  // some properties:
1011
  //    (+ZERO == -ZERO) => therefore ignore the sign
1012
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
1013
  //    ignore the exponent field
1014
  //    (Any non-canonical # is considered 0)
1015
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
1016
  x_is_zero = 1;
1017
}
1018
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
1019
  y_is_zero = 1;
1020
}
1021
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
1022
if (x_is_zero && y_is_zero) {
1023
  res = 0;
1024
  BID_RETURN (res);
1025
}
1026
  // is x is zero, it is greater if Y is negative
1027
else if (x_is_zero) {
1028
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1029
  BID_RETURN (res);
1030
}
1031
  // is y is zero, X is greater if it is positive
1032
else if (y_is_zero) {
1033
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1034
  BID_RETURN (res);
1035
}
1036
  // OPPOSITE SIGN (CASE5)
1037
  // now, if the sign bits differ, x is greater if y is negative
1038
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
1039
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1040
  BID_RETURN (res);
1041
}
1042
  // REDUNDANT REPRESENTATIONS (CASE6)
1043
  // if exponents are the same, then we have a simple comparison of the 
1044
  // significands
1045
if (exp_y == exp_x) {
1046
  res = (((sig_x.w[1] > sig_y.w[1])
1047
          || (sig_x.w[1] == sig_y.w[1]
1048
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) !=
1049
                                               MASK_SIGN));
1050
  BID_RETURN (res);
1051
}
1052
  // if both components are either bigger or smaller, 
1053
  // it is clear what needs to be done
1054
if ((sig_x.w[1] > sig_y.w[1]
1055
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
1056
    && exp_x >= exp_y) {
1057
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1058
  BID_RETURN (res);
1059
}
1060
if ((sig_x.w[1] < sig_y.w[1]
1061
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
1062
    && exp_x <= exp_y) {
1063
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
1064
  BID_RETURN (res);
1065
}
1066
 
1067
diff = exp_x - exp_y;
1068
 
1069
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
1070
if (diff > 0) {  // to simplify the loop below,
1071
 
1072
  // if exp_x is 33 greater than exp_y, no need for compensation
1073
  if (diff > 33) {
1074
    res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1075
    BID_RETURN (res);
1076
  }     // difference cannot be greater than 10^33
1077
 
1078
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
1079
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
1080
 
1081
 
1082
    // if postitive, return whichever significand is larger 
1083
    // (converse if negative)
1084
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
1085
        && sig_n_prime256.w[1] == sig_y.w[1]
1086
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
1087
      res = 0;
1088
      BID_RETURN (res);
1089
    }   // if equal, return 0
1090
    {
1091
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
1092
              || (sig_n_prime256.w[1] > sig_y.w[1])
1093
              || (sig_n_prime256.w[1] == sig_y.w[1]
1094
                  && sig_n_prime256.w[0] >
1095
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
1096
      BID_RETURN (res);
1097
    }
1098
  }
1099
  //else { //128 by 64 bit multiply -> 192 bits
1100
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
1101
 
1102
  // if postitive, return whichever significand is larger 
1103
  // (converse if negative)
1104
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
1105
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
1106
    res = 0;
1107
    BID_RETURN (res);
1108
  }     // if equal, return 0
1109
  {
1110
    res = (((sig_n_prime192.w[2] > 0)
1111
            || (sig_n_prime192.w[1] > sig_y.w[1])
1112
            || (sig_n_prime192.w[1] == sig_y.w[1]
1113
                && sig_n_prime192.w[0] >
1114
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
1115
    BID_RETURN (res);
1116
  }
1117
}
1118
 
1119
diff = exp_y - exp_x;
1120
 
1121
  // if exp_x is 33 less than exp_y, no need for compensation
1122
if (diff > 33) {
1123
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
1124
  BID_RETURN (res);
1125
}
1126
 
1127
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
1128
  // adjust the y significand upwards
1129
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
1130
 
1131
  // if postitive, return whichever significand is larger 
1132
  // (converse if negative)
1133
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
1134
      && sig_n_prime256.w[1] == sig_x.w[1]
1135
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
1136
    res = 0;
1137
    BID_RETURN (res);
1138
  }     // if equal, return 1
1139
  {
1140
    res = ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
1141
            || (sig_n_prime256.w[1] > sig_x.w[1]
1142
                || (sig_n_prime256.w[1] == sig_x.w[1]
1143
                    && sig_n_prime256.w[0] >
1144
                    sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) ==
1145
                                     MASK_SIGN));
1146
    BID_RETURN (res);
1147
  }
1148
}
1149
  //else { //128 by 64 bit multiply -> 192 bits
1150
  // adjust the y significand upwards
1151
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
1152
 
1153
  // if postitive, return whichever significand is larger 
1154
  // (converse if negative)
1155
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
1156
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
1157
  res = 0;
1158
  BID_RETURN (res);
1159
}       // if equal, return 0
1160
{
1161
  res = (sig_n_prime192.w[2] != 0
1162
         || (sig_n_prime192.w[1] > sig_x.w[1]
1163
             || (sig_n_prime192.w[1] == sig_x.w[1]
1164
                 && sig_n_prime192.w[0] >
1165
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
1166
  BID_RETURN (res);
1167
}
1168
}
1169
 
1170
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_less_equal,
1171
                                          x, y)
1172
 
1173
     int res;
1174
     int exp_x, exp_y;
1175
     int diff;
1176
     UINT128 sig_x, sig_y;
1177
     UINT192 sig_n_prime192;
1178
     UINT256 sig_n_prime256;
1179
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
1180
 
1181
  // NaN (CASE1)
1182
  // if either number is NAN, the comparison is unordered, 
1183
  // rather than equal : return 0
1184
if (((x.w[1] & MASK_NAN) == MASK_NAN)
1185
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
1186
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
1187
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
1188
  *pfpsf |= INVALID_EXCEPTION;
1189
}
1190
{
1191
  res = 0;
1192
  BID_RETURN (res);
1193
}
1194
}
1195
  // SIMPLE (CASE2)
1196
  // if all the bits are the same, these numbers are equal (not Greater).
1197
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
1198
  res = 1;
1199
  BID_RETURN (res);
1200
}
1201
  // INFINITY (CASE3)
1202
if ((x.w[1] & MASK_INF) == MASK_INF) {
1203
  // if x is neg infinity, there is no way it is greater than y, return 1
1204
  if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) {
1205
    res = 1;
1206
    BID_RETURN (res);
1207
  }
1208
  // x is pos infinity, it is greater, unless y is positive infinity => 
1209
  // return y!=pos_infinity
1210
  else {
1211
    res = (((y.w[1] & MASK_INF) == MASK_INF)
1212
           && ((y.w[1] & MASK_SIGN) != MASK_SIGN));
1213
    BID_RETURN (res);
1214
  }
1215
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
1216
  // x is finite, so if y is positive infinity, then x is less, return 0
1217
  //                 if y is negative infinity, then x is greater, return 1
1218
  {
1219
    res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1220
    BID_RETURN (res);
1221
  }
1222
}
1223
  // CONVERT X
1224
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
1225
sig_x.w[0] = x.w[0];
1226
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
1227
 
1228
  // CHECK IF X IS CANONICAL
1229
  // 9999999999999999999999999999999999(decimal) = 
1230
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
1231
  // [0, 10^34) is the 754r supported canonical range.  
1232
  //    If the value exceeds that, it is interpreted as 0.
1233
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
1234
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
1235
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
1236
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
1237
  non_canon_x = 1;
1238
else
1239
  non_canon_x = 0;
1240
 
1241
  // CONVERT Y
1242
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
1243
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
1244
sig_y.w[0] = y.w[0];
1245
 
1246
  // CHECK IF Y IS CANONICAL
1247
  // 9999999999999999999999999999999999(decimal) = 
1248
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
1249
  // [0, 10^34) is the 754r supported canonical range.  
1250
  //    If the value exceeds that, it is interpreted as 0.
1251
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
1252
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
1253
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
1254
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
1255
  non_canon_y = 1;
1256
else
1257
  non_canon_y = 0;
1258
 
1259
  // ZERO (CASE4)
1260
  // some properties:
1261
  //    (+ZERO == -ZERO) => therefore ignore the sign
1262
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
1263
  //    ignore the exponent field
1264
  //    (Any non-canonical # is considered 0)
1265
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
1266
  x_is_zero = 1;
1267
}
1268
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
1269
  y_is_zero = 1;
1270
}
1271
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
1272
if (x_is_zero && y_is_zero) {
1273
  res = 1;
1274
  BID_RETURN (res);
1275
}
1276
  // is x is zero, it is greater if Y is negative
1277
else if (x_is_zero) {
1278
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1279
  BID_RETURN (res);
1280
}
1281
  // is y is zero, X is greater if it is positive
1282
else if (y_is_zero) {
1283
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1284
  BID_RETURN (res);
1285
}
1286
  // OPPOSITE SIGN (CASE5)
1287
  // now, if the sign bits differ, x is greater if y is negative
1288
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
1289
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1290
  BID_RETURN (res);
1291
}
1292
  // REDUNDANT REPRESENTATIONS (CASE6)
1293
  // if exponents are the same, then we have a simple comparison of the 
1294
  // significands
1295
if (exp_y == exp_x) {
1296
  res = (((sig_x.w[1] > sig_y.w[1]) || (sig_x.w[1] == sig_y.w[1] &&
1297
                                        sig_x.w[0] >=
1298
                                        sig_y.w[0])) ^ ((x.
1299
                                                         w[1] &
1300
                                                         MASK_SIGN) !=
1301
                                                        MASK_SIGN));
1302
  BID_RETURN (res);
1303
}
1304
  // if both components are either bigger or smaller, 
1305
  // it is clear what needs to be done
1306
if ((sig_x.w[1] > sig_y.w[1]
1307
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
1308
    && exp_x >= exp_y) {
1309
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1310
  BID_RETURN (res);
1311
}
1312
if ((sig_x.w[1] < sig_y.w[1]
1313
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
1314
    && exp_x <= exp_y) {
1315
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
1316
  BID_RETURN (res);
1317
}
1318
 
1319
diff = exp_x - exp_y;
1320
 
1321
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
1322
if (diff > 0) {  // to simplify the loop below,
1323
 
1324
  // if exp_x is 33 greater than exp_y, no need for compensation
1325
  if (diff > 33) {
1326
    res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1327
    BID_RETURN (res);
1328
  }     // difference cannot be greater than 10^33
1329
 
1330
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
1331
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
1332
 
1333
 
1334
    // if postitive, return whichever significand is larger 
1335
    // (converse if negative)
1336
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
1337
        && sig_n_prime256.w[1] == sig_y.w[1]
1338
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
1339
      res = 1;
1340
      BID_RETURN (res);
1341
    }   // if equal, return 0
1342
    {
1343
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
1344
              || (sig_n_prime256.w[1] > sig_y.w[1])
1345
              || (sig_n_prime256.w[1] == sig_y.w[1]
1346
                  && sig_n_prime256.w[0] >
1347
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
1348
      BID_RETURN (res);
1349
    }
1350
  }
1351
  //else { //128 by 64 bit multiply -> 192 bits
1352
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
1353
 
1354
  // if postitive, return whichever significand is larger 
1355
  // (converse if negative)
1356
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
1357
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
1358
    res = 1;
1359
    BID_RETURN (res);
1360
  }     // if equal, return 0
1361
  {
1362
    res = (((sig_n_prime192.w[2] > 0)
1363
            || (sig_n_prime192.w[1] > sig_y.w[1])
1364
            || (sig_n_prime192.w[1] == sig_y.w[1]
1365
                && sig_n_prime192.w[0] >
1366
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
1367
    BID_RETURN (res);
1368
  }
1369
}
1370
 
1371
diff = exp_y - exp_x;
1372
 
1373
  // if exp_x is 33 less than exp_y, no need for compensation
1374
if (diff > 33) {
1375
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
1376
  BID_RETURN (res);
1377
}
1378
 
1379
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
1380
  // adjust the y significand upwards
1381
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
1382
 
1383
 
1384
  // if postitive, return whichever significand is larger 
1385
  // (converse if negative)
1386
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
1387
      && sig_n_prime256.w[1] == sig_x.w[1]
1388
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
1389
    res = 1;
1390
    BID_RETURN (res);
1391
  }     // if equal, return 0
1392
  {
1393
    res =
1394
      ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
1395
        || (sig_n_prime256.w[1] > sig_x.w[1]
1396
            || (sig_n_prime256.w[1] == sig_x.w[1]
1397
                && sig_n_prime256.w[0] >
1398
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
1399
    BID_RETURN (res);
1400
  }
1401
}
1402
  //else { //128 by 64 bit multiply -> 192 bits
1403
  // adjust the y significand upwards
1404
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
1405
 
1406
  // if postitive, return whichever significand is larger 
1407
      // (converse if negative)
1408
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
1409
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
1410
  res = 1;
1411
  BID_RETURN (res);
1412
}       // if equal, return 0
1413
{
1414
  res = (sig_n_prime192.w[2] != 0
1415
         || (sig_n_prime192.w[1] > sig_x.w[1]
1416
             || (sig_n_prime192.w[1] == sig_x.w[1]
1417
                 && sig_n_prime192.w[0] >
1418
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
1419
  BID_RETURN (res);
1420
}
1421
}
1422
 
1423
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int,
1424
                                          bid128_quiet_less_unordered,
1425
                                          x, y)
1426
 
1427
     int res;
1428
     int exp_x, exp_y;
1429
     int diff;
1430
     UINT128 sig_x, sig_y;
1431
     UINT192 sig_n_prime192;
1432
     UINT256 sig_n_prime256;
1433
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
1434
 
1435
  // NaN (CASE1)
1436
  // if either number is NAN, the comparison is unordered
1437
if (((x.w[1] & MASK_NAN) == MASK_NAN)
1438
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
1439
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
1440
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
1441
  *pfpsf |= INVALID_EXCEPTION;
1442
}
1443
{
1444
  res = 1;
1445
  BID_RETURN (res);
1446
}
1447
}
1448
  // SIMPLE (CASE2)
1449
  // if all the bits are the same, these numbers are equal.
1450
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
1451
  res = 0;
1452
  BID_RETURN (res);
1453
}
1454
  // INFINITY (CASE3)
1455
if ((x.w[1] & MASK_INF) == MASK_INF) {
1456
  // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
1457
  if ((x.w[1] & MASK_SIGN) == MASK_SIGN)
1458
    // x is -inf, so it is less than y unless y is -inf
1459
  {
1460
    res = (((y.w[1] & MASK_INF) != MASK_INF)
1461
           || (y.w[1] & MASK_SIGN) != MASK_SIGN);
1462
    BID_RETURN (res);
1463
  } else
1464
    // x is pos_inf, no way for it to be less than y
1465
  {
1466
    res = 0;
1467
    BID_RETURN (res);
1468
  }
1469
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
1470
  // x is finite, so if y is positive infinity, then x is less, return 0
1471
  //                 if y is negative infinity, then x is greater, return 1
1472
  {
1473
    res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1474
    BID_RETURN (res);
1475
  }
1476
}
1477
  // CONVERT X
1478
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
1479
sig_x.w[0] = x.w[0];
1480
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
1481
 
1482
  // CHECK IF X IS CANONICAL
1483
  // 9999999999999999999999999999999999(decimal) = 
1484
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
1485
  // [0, 10^34) is the 754r supported canonical range.  
1486
  //    If the value exceeds that, it is interpreted as 0.
1487
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
1488
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
1489
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
1490
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
1491
  non_canon_x = 1;
1492
else
1493
  non_canon_x = 0;
1494
 
1495
  // CONVERT Y
1496
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
1497
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
1498
sig_y.w[0] = y.w[0];
1499
 
1500
  // CHECK IF Y IS CANONICAL
1501
  // 9999999999999999999999999999999999(decimal) = 
1502
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
1503
  // [0, 10^34) is the 754r supported canonical range.  
1504
  //    If the value exceeds that, it is interpreted as 0.
1505
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
1506
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
1507
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
1508
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
1509
  non_canon_y = 1;
1510
else
1511
  non_canon_y = 0;
1512
 
1513
  // ZERO (CASE4)
1514
  // some properties:
1515
  //    (+ZERO == -ZERO) => therefore ignore the sign
1516
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
1517
  //    ignore the exponent field
1518
  //    (Any non-canonical # is considered 0)
1519
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
1520
  x_is_zero = 1;
1521
}
1522
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
1523
  y_is_zero = 1;
1524
}
1525
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
1526
if (x_is_zero && y_is_zero) {
1527
  res = 0;
1528
  BID_RETURN (res);
1529
}
1530
  // is x is zero, it is greater if Y is negative
1531
else if (x_is_zero) {
1532
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1533
  BID_RETURN (res);
1534
}
1535
  // is y is zero, X is greater if it is positive
1536
else if (y_is_zero) {
1537
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1538
  BID_RETURN (res);
1539
}
1540
  // OPPOSITE SIGN (CASE5)
1541
  // now, if the sign bits differ, x is greater if y is negative
1542
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
1543
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1544
  BID_RETURN (res);
1545
}
1546
  // REDUNDANT REPRESENTATIONS (CASE6)
1547
  // if exponents are the same, then we have a simple comparison 
1548
  // of the significands
1549
if (exp_y == exp_x) {
1550
  res = (((sig_x.w[1] > sig_y.w[1])
1551
          || (sig_x.w[1] == sig_y.w[1]
1552
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) !=
1553
                                               MASK_SIGN));
1554
  BID_RETURN (res);
1555
}
1556
  // if both components are either bigger or smaller, 
1557
  // it is clear what needs to be done
1558
if ((sig_x.w[1] > sig_y.w[1]
1559
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
1560
    && exp_x >= exp_y) {
1561
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1562
  BID_RETURN (res);
1563
}
1564
if ((sig_x.w[1] < sig_y.w[1]
1565
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
1566
    && exp_x <= exp_y) {
1567
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
1568
  BID_RETURN (res);
1569
}
1570
 
1571
diff = exp_x - exp_y;
1572
 
1573
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
1574
if (diff > 0) {  // to simplify the loop below,
1575
 
1576
  // if exp_x is 33 greater than exp_y, no need for compensation
1577
  if (diff > 33) {
1578
    res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1579
    BID_RETURN (res);
1580
  }     // difference cannot be greater than 10^33
1581
 
1582
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
1583
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
1584
 
1585
 
1586
    // if postitive, return whichever significand is larger 
1587
    // (converse if negative)
1588
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
1589
        && sig_n_prime256.w[1] == sig_y.w[1]
1590
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
1591
      res = 0;
1592
      BID_RETURN (res);
1593
    }   // if equal, return 0
1594
    {
1595
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
1596
              || (sig_n_prime256.w[1] > sig_y.w[1])
1597
              || (sig_n_prime256.w[1] == sig_y.w[1]
1598
                  && sig_n_prime256.w[0] >
1599
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
1600
      BID_RETURN (res);
1601
    }
1602
  }
1603
  //else { //128 by 64 bit multiply -> 192 bits
1604
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
1605
 
1606
  // if postitive, return whichever significand is larger 
1607
  // (converse if negative)
1608
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
1609
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
1610
    res = 0;
1611
    BID_RETURN (res);
1612
  }     // if equal, return 0
1613
  {
1614
    res = (((sig_n_prime192.w[2] > 0)
1615
            || (sig_n_prime192.w[1] > sig_y.w[1])
1616
            || (sig_n_prime192.w[1] == sig_y.w[1]
1617
                && sig_n_prime192.w[0] >
1618
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
1619
    BID_RETURN (res);
1620
  }
1621
}
1622
 
1623
diff = exp_y - exp_x;
1624
 
1625
  // if exp_x is 33 less than exp_y, no need for compensation
1626
if (diff > 33) {
1627
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
1628
  BID_RETURN (res);
1629
}
1630
 
1631
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
1632
  // adjust the y significand upwards
1633
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
1634
 
1635
 
1636
  // if postitive, return whichever significand is larger 
1637
  // (converse if negative)
1638
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
1639
      && sig_n_prime256.w[1] == sig_x.w[1]
1640
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
1641
    res = 0;
1642
    BID_RETURN (res);
1643
  }     // if equal, return 1
1644
  {
1645
    res =
1646
      ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
1647
        || (sig_n_prime256.w[1] > sig_x.w[1]
1648
            || (sig_n_prime256.w[1] == sig_x.w[1]
1649
                && sig_n_prime256.w[0] >
1650
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
1651
    BID_RETURN (res);
1652
  }
1653
}
1654
  //else { //128 by 64 bit multiply -> 192 bits
1655
  // adjust the y significand upwards
1656
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
1657
 
1658
  // if postitive, return whichever significand is larger 
1659
  // (converse if negative)
1660
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
1661
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
1662
  res = 0;
1663
  BID_RETURN (res);
1664
}       // if equal, return 0
1665
{
1666
  res = (sig_n_prime192.w[2] != 0
1667
         || (sig_n_prime192.w[1] > sig_x.w[1]
1668
             || (sig_n_prime192.w[1] == sig_x.w[1]
1669
                 && sig_n_prime192.w[0] >
1670
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
1671
  BID_RETURN (res);
1672
}
1673
}
1674
 
1675
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_not_equal,
1676
                                          x, y)
1677
 
1678
     int res;
1679
     int exp_x, exp_y, exp_t;
1680
     UINT128 sig_x, sig_y, sig_t;
1681
     UINT192 sig_n_prime192;
1682
     UINT256 sig_n_prime256;
1683
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
1684
 
1685
  // NaN (CASE1)
1686
  // if either number is NAN, the comparison is unordered, 
1687
  // rather than equal : return 0
1688
if (((x.w[1] & MASK_NAN) == MASK_NAN)
1689
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
1690
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
1691
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
1692
  *pfpsf |= INVALID_EXCEPTION;
1693
}
1694
{
1695
  res = 1;
1696
  BID_RETURN (res);
1697
}
1698
}
1699
  // SIMPLE (CASE2)
1700
  // if all the bits are the same, these numbers are equivalent.
1701
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
1702
  res = 0;
1703
  BID_RETURN (res);
1704
}
1705
  // INFINITY (CASE3)
1706
if ((x.w[1] & MASK_INF) == MASK_INF) {
1707
  if ((y.w[1] & MASK_INF) == MASK_INF) {
1708
    res = (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN);
1709
    BID_RETURN (res);
1710
  } else {
1711
    res = 1;
1712
    BID_RETURN (res);
1713
  }
1714
}
1715
if ((y.w[1] & MASK_INF) == MASK_INF) {
1716
  res = 1;
1717
  BID_RETURN (res);
1718
}
1719
  // CONVERT X
1720
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
1721
sig_x.w[0] = x.w[0];
1722
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
1723
 
1724
  // CHECK IF X IS CANONICAL
1725
  // 9999999999999999999999999999999999(decimal) = 
1726
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
1727
  // [0, 10^34) is the 754r supported canonical range.  
1728
  //    If the value exceeds that, it is interpreted as 0.
1729
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
1730
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
1731
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
1732
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
1733
  non_canon_x = 1;
1734
else
1735
  non_canon_x = 0;
1736
 
1737
  // CONVERT Y
1738
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
1739
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
1740
sig_y.w[0] = y.w[0];
1741
 
1742
  // CHECK IF Y IS CANONICAL
1743
  // 9999999999999999999999999999999999(decimal) = 
1744
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
1745
  // [0, 10^34) is the 754r supported canonical range.  
1746
  //    If the value exceeds that, it is interpreted as 0.
1747
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
1748
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
1749
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
1750
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
1751
  non_canon_y = 1;
1752
else
1753
  non_canon_y = 0;
1754
 
1755
  // some properties:
1756
  //    (+ZERO == -ZERO) => therefore ignore the sign
1757
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
1758
  //    ignore the exponent field
1759
  //    (Any non-canonical # is considered 0)
1760
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
1761
  x_is_zero = 1;
1762
}
1763
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
1764
  y_is_zero = 1;
1765
}
1766
 
1767
if (x_is_zero && y_is_zero) {
1768
  res = 0;
1769
  BID_RETURN (res);
1770
} else if ((x_is_zero && !y_is_zero) || (!x_is_zero && y_is_zero)) {
1771
  res = 1;
1772
  BID_RETURN (res);
1773
}
1774
  // OPPOSITE SIGN (CASE5)
1775
  // now, if the sign bits differ => not equal : return 0
1776
if ((x.w[1] ^ y.w[1]) & MASK_SIGN) {
1777
  res = 1;
1778
  BID_RETURN (res);
1779
}
1780
  // REDUNDANT REPRESENTATIONS (CASE6)
1781
if (exp_x > exp_y) {    // to simplify the loop below,
1782
  SWAP (exp_x, exp_y, exp_t);   // put the larger exp in y,
1783
  SWAP (sig_x.w[1], sig_y.w[1], sig_t.w[1]);    // and the smaller exp in x
1784
  SWAP (sig_x.w[0], sig_y.w[0], sig_t.w[0]);       // and the smaller exp in x
1785
}
1786
 
1787
 
1788
if (exp_y - exp_x > 33) {
1789
  res = 1;
1790
  BID_RETURN (res);
1791
}       // difference cannot be greater than 10^33
1792
 
1793
if (exp_y - exp_x > 19) {
1794
  // recalculate y's significand upwards
1795
  __mul_128x128_to_256 (sig_n_prime256, sig_y,
1796
                        ten2k128[exp_y - exp_x - 20]);
1797
  {
1798
    res = ((sig_n_prime256.w[3] != 0) || (sig_n_prime256.w[2] != 0)
1799
           || (sig_n_prime256.w[1] != sig_x.w[1])
1800
           || (sig_n_prime256.w[0] != sig_x.w[0]));
1801
    BID_RETURN (res);
1802
  }
1803
 
1804
}
1805
  //else{
1806
  // recalculate y's significand upwards
1807
__mul_64x128_to192 (sig_n_prime192, ten2k64[exp_y - exp_x], sig_y);
1808
{
1809
  res = ((sig_n_prime192.w[2] != 0)
1810
         || (sig_n_prime192.w[1] != sig_x.w[1])
1811
         || (sig_n_prime192.w[0] != sig_x.w[0]));
1812
  BID_RETURN (res);
1813
}
1814
}
1815
 
1816
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_not_greater,
1817
                                          x, y)
1818
 
1819
     int res;
1820
     int exp_x, exp_y;
1821
     int diff;
1822
     UINT128 sig_x, sig_y;
1823
     UINT192 sig_n_prime192;
1824
     UINT256 sig_n_prime256;
1825
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
1826
 
1827
  // NaN (CASE1)
1828
  // if either number is NAN, the comparison is unordered, 
1829
  // rather than equal : return 0
1830
if (((x.w[1] & MASK_NAN) == MASK_NAN)
1831
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
1832
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
1833
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
1834
  *pfpsf |= INVALID_EXCEPTION;
1835
}
1836
{
1837
  res = 1;
1838
  BID_RETURN (res);
1839
}
1840
}
1841
  // SIMPLE (CASE2)
1842
  // if all the bits are the same, these numbers are equal (not Greater).
1843
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
1844
  res = 1;
1845
  BID_RETURN (res);
1846
}
1847
  // INFINITY (CASE3)
1848
if ((x.w[1] & MASK_INF) == MASK_INF) {
1849
  // if x is neg infinity, there is no way it is greater than y, return 1
1850
  if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) {
1851
    res = 1;
1852
    BID_RETURN (res);
1853
  }
1854
  // x is pos infinity, it is greater, unless y is positive infinity => return y!=pos_infinity
1855
  else {
1856
    res = (((y.w[1] & MASK_INF) == MASK_INF)
1857
           && ((y.w[1] & MASK_SIGN) != MASK_SIGN));
1858
    BID_RETURN (res);
1859
  }
1860
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
1861
  // x is finite, so if y is positive infinity, then x is less, return 0
1862
  //                 if y is negative infinity, then x is greater, return 1
1863
  {
1864
    res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1865
    BID_RETURN (res);
1866
  }
1867
}
1868
  // CONVERT X
1869
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
1870
sig_x.w[0] = x.w[0];
1871
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
1872
 
1873
  // CHECK IF X IS CANONICAL
1874
  // 9999999999999999999999999999999999(decimal) = 
1875
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
1876
  // [0, 10^34) is the 754r supported canonical range.  
1877
  //    If the value exceeds that, it is interpreted as 0.
1878
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
1879
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
1880
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
1881
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
1882
  non_canon_x = 1;
1883
else
1884
  non_canon_x = 0;
1885
 
1886
  // CONVERT Y
1887
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
1888
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
1889
sig_y.w[0] = y.w[0];
1890
 
1891
  // CHECK IF Y IS CANONICAL
1892
  // 9999999999999999999999999999999999(decimal) = 
1893
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
1894
  // [0, 10^34) is the 754r supported canonical range.  
1895
  //    If the value exceeds that, it is interpreted as 0.
1896
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
1897
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
1898
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
1899
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
1900
  non_canon_y = 1;
1901
else
1902
  non_canon_y = 0;
1903
 
1904
  // ZERO (CASE4)
1905
  // some properties:
1906
  //    (+ZERO == -ZERO) => therefore ignore the sign
1907
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
1908
  //    ignore the exponent field
1909
  //    (Any non-canonical # is considered 0)
1910
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
1911
  x_is_zero = 1;
1912
}
1913
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
1914
  y_is_zero = 1;
1915
}
1916
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
1917
if (x_is_zero && y_is_zero) {
1918
  res = 1;
1919
  BID_RETURN (res);
1920
}
1921
  // is x is zero, it is greater if Y is negative
1922
else if (x_is_zero) {
1923
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1924
  BID_RETURN (res);
1925
}
1926
  // is y is zero, X is greater if it is positive
1927
else if (y_is_zero) {
1928
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1929
  BID_RETURN (res);
1930
}
1931
  // OPPOSITE SIGN (CASE5)
1932
  // now, if the sign bits differ, x is greater if y is negative
1933
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
1934
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
1935
  BID_RETURN (res);
1936
}
1937
  // REDUNDANT REPRESENTATIONS (CASE6)
1938
  // if exponents are the same, then we have a simple comparison 
1939
  // of the significands
1940
if (exp_y == exp_x) {
1941
  res = (((sig_x.w[1] > sig_y.w[1])
1942
          || (sig_x.w[1] == sig_y.w[1]
1943
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) !=
1944
                                               MASK_SIGN));
1945
  BID_RETURN (res);
1946
}
1947
  // if both components are either bigger or smaller, 
1948
  // it is clear what needs to be done
1949
if ((sig_x.w[1] > sig_y.w[1]
1950
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
1951
    && exp_x >= exp_y) {
1952
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1953
  BID_RETURN (res);
1954
}
1955
if ((sig_x.w[1] < sig_y.w[1]
1956
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
1957
    && exp_x <= exp_y) {
1958
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
1959
  BID_RETURN (res);
1960
}
1961
 
1962
diff = exp_x - exp_y;
1963
 
1964
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
1965
if (diff > 0) {  // to simplify the loop below,
1966
 
1967
  // if exp_x is 33 greater than exp_y, no need for compensation
1968
  if (diff > 33) {
1969
    res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
1970
    BID_RETURN (res);
1971
  }     // difference cannot be greater than 10^33
1972
 
1973
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
1974
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
1975
 
1976
 
1977
    // if postitive, return whichever significand is larger 
1978
    // (converse if negative)
1979
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
1980
        && sig_n_prime256.w[1] == sig_y.w[1]
1981
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
1982
      res = 1;
1983
      BID_RETURN (res);
1984
    }   // if equal, return 0
1985
    {
1986
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
1987
              || (sig_n_prime256.w[1] > sig_y.w[1])
1988
              || (sig_n_prime256.w[1] == sig_y.w[1]
1989
                  && sig_n_prime256.w[0] >
1990
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
1991
      BID_RETURN (res);
1992
    }
1993
  }
1994
  //else { //128 by 64 bit multiply -> 192 bits
1995
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
1996
 
1997
  // if postitive, return whichever significand is larger 
1998
  // (converse if negative)
1999
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
2000
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
2001
    res = 1;
2002
    BID_RETURN (res);
2003
  }     // if equal, return 0
2004
  {
2005
    res = (((sig_n_prime192.w[2] > 0)
2006
            || (sig_n_prime192.w[1] > sig_y.w[1])
2007
            || (sig_n_prime192.w[1] == sig_y.w[1]
2008
                && sig_n_prime192.w[0] >
2009
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
2010
    BID_RETURN (res);
2011
  }
2012
}
2013
 
2014
diff = exp_y - exp_x;
2015
 
2016
  // if exp_x is 33 less than exp_y, no need for compensation
2017
if (diff > 33) {
2018
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2019
  BID_RETURN (res);
2020
}
2021
 
2022
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
2023
  // adjust the y significand upwards
2024
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
2025
 
2026
 
2027
  // if postitive, return whichever significand is larger 
2028
  // (converse if negative)
2029
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
2030
      && sig_n_prime256.w[1] == sig_x.w[1]
2031
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
2032
    res = 1;
2033
    BID_RETURN (res);
2034
  }     // if equal, return 0
2035
  {
2036
    res =
2037
      ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
2038
        || (sig_n_prime256.w[1] > sig_x.w[1]
2039
            || (sig_n_prime256.w[1] == sig_x.w[1]
2040
                && sig_n_prime256.w[0] >
2041
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
2042
    BID_RETURN (res);
2043
  }
2044
}
2045
  //else { //128 by 64 bit multiply -> 192 bits
2046
  // adjust the y significand upwards
2047
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
2048
 
2049
  // if postitive, return whichever significand is larger 
2050
  // (converse if negative)
2051
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
2052
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
2053
  res = 1;
2054
  BID_RETURN (res);
2055
}       // if equal, return 0
2056
{
2057
  res = (sig_n_prime192.w[2] != 0
2058
         || (sig_n_prime192.w[1] > sig_x.w[1]
2059
             || (sig_n_prime192.w[1] == sig_x.w[1]
2060
                 && sig_n_prime192.w[0] >
2061
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2062
  BID_RETURN (res);
2063
}
2064
}
2065
 
2066
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_not_less, x,
2067
                                          y)
2068
 
2069
     int res;
2070
     int exp_x, exp_y;
2071
     int diff;
2072
     UINT128 sig_x, sig_y;
2073
     UINT192 sig_n_prime192;
2074
     UINT256 sig_n_prime256;
2075
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
2076
 
2077
  // NaN (CASE1)
2078
  // if either number is NAN, the comparison is unordered, 
2079
  // rather than equal : return 1
2080
if (((x.w[1] & MASK_NAN) == MASK_NAN)
2081
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
2082
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
2083
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
2084
  *pfpsf |= INVALID_EXCEPTION;
2085
}
2086
{
2087
  res = 1;
2088
  BID_RETURN (res);
2089
}
2090
}
2091
  // SIMPLE (CASE2)
2092
  // if all the bits are the same, these numbers are equal (not Greater).
2093
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
2094
  res = 1;
2095
  BID_RETURN (res);
2096
}
2097
  // INFINITY (CASE3)
2098
if ((x.w[1] & MASK_INF) == MASK_INF) {
2099
  // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
2100
  if ((x.w[1] & MASK_SIGN) == MASK_SIGN)
2101
    // x is -inf, so it is less than y unless y is -inf
2102
  {
2103
    res = (((y.w[1] & MASK_INF) == MASK_INF)
2104
           && (y.w[1] & MASK_SIGN) == MASK_SIGN);
2105
    BID_RETURN (res);
2106
  } else
2107
    // x is pos_inf, no way for it to be less than y
2108
  {
2109
    res = 1;
2110
    BID_RETURN (res);
2111
  }
2112
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
2113
  // x is finite, so if y is positive infinity, then x is less, return 0
2114
  //                 if y is negative infinity, then x is greater, return 1
2115
  {
2116
    res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2117
    BID_RETURN (res);
2118
  }
2119
}
2120
  // CONVERT X
2121
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
2122
sig_x.w[0] = x.w[0];
2123
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
2124
 
2125
  // CHECK IF X IS CANONICAL
2126
  // 9999999999999999999999999999999999(decimal) = 
2127
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
2128
  // [0, 10^34) is the 754r supported canonical range.  
2129
  //     If the value exceeds that, it is interpreted as 0.
2130
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
2131
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
2132
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
2133
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
2134
  non_canon_x = 1;
2135
else
2136
  non_canon_x = 0;
2137
 
2138
  // CONVERT Y
2139
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
2140
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
2141
sig_y.w[0] = y.w[0];
2142
 
2143
  // CHECK IF Y IS CANONICAL
2144
  // 9999999999999999999999999999999999(decimal) = 
2145
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
2146
  // [0, 10^34) is the 754r supported canonical range.  
2147
  //     If the value exceeds that, it is interpreted as 0.
2148
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
2149
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
2150
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
2151
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
2152
  non_canon_y = 1;
2153
else
2154
  non_canon_y = 0;
2155
 
2156
  // ZERO (CASE4)
2157
  // some properties:
2158
  //    (+ZERO == -ZERO) => therefore ignore the sign
2159
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
2160
  //    ignore the exponent field
2161
  //    (Any non-canonical # is considered 0)
2162
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
2163
  x_is_zero = 1;
2164
}
2165
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
2166
  y_is_zero = 1;
2167
}
2168
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
2169
if (x_is_zero && y_is_zero) {
2170
  res = 1;
2171
  BID_RETURN (res);
2172
}
2173
  // is x is zero, it is greater if Y is negative
2174
else if (x_is_zero) {
2175
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2176
  BID_RETURN (res);
2177
}
2178
  // is y is zero, X is greater if it is positive
2179
else if (y_is_zero) {
2180
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2181
  BID_RETURN (res);
2182
}
2183
  // OPPOSITE SIGN (CASE5)
2184
  // now, if the sign bits differ, x is greater if y is negative
2185
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
2186
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2187
  BID_RETURN (res);
2188
}
2189
  // REDUNDANT REPRESENTATIONS (CASE6)
2190
 
2191
  // if exponents are the same, then we have a simple comparison 
2192
  // of the significands
2193
if (exp_y == exp_x) {
2194
  res = (((sig_x.w[1] > sig_y.w[1])
2195
          || (sig_x.w[1] == sig_y.w[1]
2196
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) ==
2197
                                               MASK_SIGN));
2198
  BID_RETURN (res);
2199
}
2200
  // if both components are either bigger or smaller, 
2201
  // it is clear what needs to be done
2202
if (sig_x.w[1] >= sig_y.w[1] && sig_x.w[0] >= sig_y.w[0]
2203
    && exp_x > exp_y) {
2204
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2205
  BID_RETURN (res);
2206
}
2207
if (sig_x.w[1] <= sig_y.w[1] && sig_x.w[0] <= sig_y.w[0]
2208
    && exp_x < exp_y) {
2209
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
2210
  BID_RETURN (res);
2211
}
2212
 
2213
diff = exp_x - exp_y;
2214
 
2215
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
2216
if (diff > 0) {  // to simplify the loop below,
2217
 
2218
  // if exp_x is 33 greater than exp_y, no need for compensation
2219
  if (diff > 33) {
2220
    res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2221
    BID_RETURN (res);
2222
  }     // difference cannot be greater than 10^33
2223
 
2224
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
2225
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
2226
 
2227
 
2228
    // if postitive, return whichever significand is larger 
2229
    // (converse if negative)
2230
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
2231
        && sig_n_prime256.w[1] == sig_y.w[1]
2232
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
2233
      res = 1;
2234
      BID_RETURN (res);
2235
    }   // if equal, return 1
2236
    {
2237
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
2238
              || (sig_n_prime256.w[1] > sig_y.w[1])
2239
              || (sig_n_prime256.w[1] == sig_y.w[1]
2240
                  && sig_n_prime256.w[0] >
2241
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
2242
      BID_RETURN (res);
2243
    }
2244
  }
2245
  //else { //128 by 64 bit multiply -> 192 bits
2246
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
2247
 
2248
  // if postitive, return whichever significand is larger 
2249
  // (converse if negative)
2250
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
2251
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
2252
    res = 1;
2253
    BID_RETURN (res);
2254
  }     // if equal, return 1
2255
  {
2256
    res = (((sig_n_prime192.w[2] > 0)
2257
            || (sig_n_prime192.w[1] > sig_y.w[1])
2258
            || (sig_n_prime192.w[1] == sig_y.w[1]
2259
                && sig_n_prime192.w[0] >
2260
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
2261
    BID_RETURN (res);
2262
  }
2263
}
2264
 
2265
diff = exp_y - exp_x;
2266
 
2267
  // if exp_x is 33 less than exp_y, no need for compensation
2268
if (diff > 33) {
2269
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
2270
  BID_RETURN (res);
2271
}
2272
 
2273
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
2274
  // adjust the y significand upwards
2275
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
2276
 
2277
 
2278
  // if postitive, return whichever significand is larger 
2279
  // (converse if negative)
2280
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
2281
      && sig_n_prime256.w[1] == sig_x.w[1]
2282
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
2283
    res = 1;
2284
    BID_RETURN (res);
2285
  }     // if equal, return 1
2286
  {
2287
    res =
2288
      ((sig_n_prime256.w[3] == 0 && sig_n_prime256.w[2] == 0
2289
        && (sig_n_prime256.w[1] < sig_x.w[1]
2290
            || (sig_n_prime256.w[1] == sig_x.w[1]
2291
                && sig_n_prime256.w[0] <
2292
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
2293
    BID_RETURN (res);
2294
  }
2295
}
2296
  //else { //128 by 64 bit multiply -> 192 bits
2297
  // adjust the y significand upwards
2298
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
2299
 
2300
  // if postitive, return whichever significand is larger 
2301
  // (converse if negative)
2302
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
2303
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
2304
  res = 1;
2305
  BID_RETURN (res);
2306
}       // if equal, return 1
2307
{
2308
  res = (sig_n_prime192.w[2] == 0
2309
         && (sig_n_prime192.w[1] < sig_x.w[1]
2310
             || (sig_n_prime192.w[1] == sig_x.w[1]
2311
                 && sig_n_prime192.w[0] <
2312
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2313
  BID_RETURN (res);
2314
}
2315
}
2316
 
2317
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_ordered, x,
2318
                                          y)
2319
 
2320
     int res;
2321
 
2322
  // NaN (CASE1)
2323
  // if either number is NAN, the comparison is ordered : return 1
2324
if (((x.w[1] & MASK_NAN) == MASK_NAN)
2325
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
2326
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
2327
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
2328
  *pfpsf |= INVALID_EXCEPTION;
2329
}
2330
{
2331
  res = 0;
2332
  BID_RETURN (res);
2333
}
2334
}
2335
{
2336
  res = 1;
2337
  BID_RETURN (res);
2338
}
2339
}
2340
 
2341
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_quiet_unordered,
2342
                                          x, y)
2343
 
2344
     int res;
2345
 
2346
  // NaN (CASE1)
2347
  // if either number is NAN, the comparison is unordered : return 1
2348
if (((x.w[1] & MASK_NAN) == MASK_NAN)
2349
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
2350
if ((x.w[1] & MASK_SNAN) == MASK_SNAN
2351
    || (y.w[1] & MASK_SNAN) == MASK_SNAN) {
2352
  *pfpsf |= INVALID_EXCEPTION;
2353
}
2354
{
2355
  res = 1;
2356
  BID_RETURN (res);
2357
}
2358
}
2359
{
2360
  res = 0;
2361
  BID_RETURN (res);
2362
}
2363
}
2364
 
2365
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_signaling_greater,
2366
                                          x, y)
2367
 
2368
     int res;
2369
     int exp_x, exp_y;
2370
     int diff;
2371
     UINT128 sig_x, sig_y;
2372
     UINT192 sig_n_prime192;
2373
     UINT256 sig_n_prime256;
2374
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
2375
 
2376
  // NaN (CASE1)
2377
  // if either number is NAN, the comparison is unordered, 
2378
  // rather than equal : return 0
2379
if (((x.w[1] & MASK_NAN) == MASK_NAN)
2380
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
2381
*pfpsf |= INVALID_EXCEPTION;
2382
{
2383
  res = 0;
2384
  BID_RETURN (res);
2385
}
2386
}
2387
  // SIMPLE (CASE2)
2388
  // if all the bits are the same, these numbers are equal (not Greater).
2389
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
2390
  res = 0;
2391
  BID_RETURN (res);
2392
}
2393
  // INFINITY (CASE3)
2394
if ((x.w[1] & MASK_INF) == MASK_INF) {
2395
  // if x is neg infinity, there is no way it is greater than y, return 0
2396
  if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) {
2397
    res = 0;
2398
    BID_RETURN (res);
2399
  }
2400
  // x is pos infinity, it is greater, unless y is positive infinity => return y!=pos_infinity
2401
  else {
2402
    res = (((y.w[1] & MASK_INF) != MASK_INF)
2403
           || ((y.w[1] & MASK_SIGN) == MASK_SIGN));
2404
    BID_RETURN (res);
2405
  }
2406
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
2407
  // x is finite, so if y is positive infinity, then x is less, return 0
2408
  //                 if y is negative infinity, then x is greater, return 1
2409
  {
2410
    res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2411
    BID_RETURN (res);
2412
  }
2413
}
2414
  // CONVERT X
2415
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
2416
sig_x.w[0] = x.w[0];
2417
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
2418
 
2419
  // CHECK IF X IS CANONICAL
2420
  // 9999999999999999999999999999999999(decimal) = 
2421
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
2422
  // [0, 10^34) is the 754r supported canonical range.  
2423
  //     If the value exceeds that, it is interpreted as 0.
2424
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
2425
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
2426
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
2427
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
2428
  non_canon_x = 1;
2429
else
2430
  non_canon_x = 0;
2431
 
2432
  // CONVERT Y
2433
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
2434
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
2435
sig_y.w[0] = y.w[0];
2436
 
2437
  // CHECK IF Y IS CANONICAL
2438
  // 9999999999999999999999999999999999(decimal) = 
2439
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
2440
  // [0, 10^34) is the 754r supported canonical range.  
2441
  //     If the value exceeds that, it is interpreted as 0.
2442
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
2443
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
2444
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
2445
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
2446
  non_canon_y = 1;
2447
else
2448
  non_canon_y = 0;
2449
 
2450
  // ZERO (CASE4)
2451
  // some properties:
2452
  //    (+ZERO == -ZERO) => therefore ignore the sign
2453
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
2454
  //    ignore the exponent field
2455
  //    (Any non-canonical # is considered 0)
2456
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
2457
  x_is_zero = 1;
2458
}
2459
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
2460
  y_is_zero = 1;
2461
}
2462
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
2463
if (x_is_zero && y_is_zero) {
2464
  res = 0;
2465
  BID_RETURN (res);
2466
}
2467
  // is x is zero, it is greater if Y is negative
2468
else if (x_is_zero) {
2469
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2470
  BID_RETURN (res);
2471
}
2472
  // is y is zero, X is greater if it is positive
2473
else if (y_is_zero) {
2474
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2475
  BID_RETURN (res);
2476
}
2477
  // OPPOSITE SIGN (CASE5)
2478
  // now, if the sign bits differ, x is greater if y is negative
2479
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
2480
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2481
  BID_RETURN (res);
2482
}
2483
  // REDUNDANT REPRESENTATIONS (CASE6)
2484
  // if exponents are the same, then we have a simple comparison 
2485
  // of the significands
2486
if (exp_y == exp_x) {
2487
  res = (((sig_x.w[1] > sig_y.w[1])
2488
          || (sig_x.w[1] == sig_y.w[1]
2489
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) ==
2490
                                               MASK_SIGN));
2491
  BID_RETURN (res);
2492
}
2493
  // if both components are either bigger or smaller, 
2494
  // it is clear what needs to be done
2495
if ((sig_x.w[1] > sig_y.w[1]
2496
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
2497
    && exp_x >= exp_y) {
2498
  {
2499
    res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2500
    BID_RETURN (res);
2501
  }
2502
}
2503
if ((sig_x.w[1] < sig_y.w[1]
2504
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
2505
    && exp_x <= exp_y) {
2506
  {
2507
    res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
2508
    BID_RETURN (res);
2509
  }
2510
}
2511
 
2512
diff = exp_x - exp_y;
2513
 
2514
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
2515
if (diff > 0) {  // to simplify the loop below,
2516
 
2517
  // if exp_x is 33 greater than exp_y, no need for compensation
2518
  if (diff > 33) {
2519
    res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2520
    BID_RETURN (res);
2521
  }     // difference cannot be greater than 10^33
2522
 
2523
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
2524
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
2525
 
2526
    // if postitive, return whichever significand is larger 
2527
    // (converse if negative)
2528
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
2529
        && sig_n_prime256.w[1] == sig_y.w[1]
2530
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
2531
      res = 0;
2532
      BID_RETURN (res);
2533
    }   // if equal, return 0
2534
    {
2535
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
2536
              || (sig_n_prime256.w[1] > sig_y.w[1])
2537
              || (sig_n_prime256.w[1] == sig_y.w[1]
2538
                  && sig_n_prime256.w[0] >
2539
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
2540
      BID_RETURN (res);
2541
    }
2542
  }
2543
  //else { //128 by 64 bit multiply -> 192 bits
2544
  __mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
2545
 
2546
  // if postitive, return whichever significand is larger 
2547
  // (converse if negative)
2548
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
2549
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
2550
    res = 0;
2551
    BID_RETURN (res);
2552
  }     // if equal, return 0
2553
  {
2554
    res = (((sig_n_prime192.w[2] > 0)
2555
            || (sig_n_prime192.w[1] > sig_y.w[1])
2556
            || (sig_n_prime192.w[1] == sig_y.w[1]
2557
                && sig_n_prime192.w[0] >
2558
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
2559
    BID_RETURN (res);
2560
  }
2561
}
2562
 
2563
diff = exp_y - exp_x;
2564
 
2565
  // if exp_x is 33 less than exp_y, no need for compensation
2566
if (diff > 33) {
2567
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
2568
  BID_RETURN (res);
2569
}
2570
 
2571
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
2572
  // adjust the y significand upwards
2573
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
2574
 
2575
  // if postitive, return whichever significand is larger 
2576
  // (converse if negative)
2577
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
2578
      && sig_n_prime256.w[1] == sig_x.w[1]
2579
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
2580
    res = 0;
2581
    BID_RETURN (res);
2582
  }     // if equal, return 0
2583
  {
2584
    res =
2585
      ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
2586
        || (sig_n_prime256.w[1] > sig_x.w[1]
2587
            || (sig_n_prime256.w[1] == sig_x.w[1]
2588
                && sig_n_prime256.w[0] >
2589
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) != MASK_SIGN));
2590
    BID_RETURN (res);
2591
  }
2592
}
2593
  //else { //128 by 64 bit multiply -> 192 bits
2594
  // adjust the y significand upwards
2595
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
2596
 
2597
  // if postitive, return whichever significand is larger 
2598
  // (converse if negative)
2599
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
2600
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
2601
  res = 0;
2602
  BID_RETURN (res);
2603
}       // if equal, return 0
2604
{
2605
  res = (sig_n_prime192.w[2] != 0
2606
         || (sig_n_prime192.w[1] > sig_x.w[1]
2607
             || (sig_n_prime192.w[1] == sig_x.w[1]
2608
                 && sig_n_prime192.w[0] >
2609
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN);
2610
  BID_RETURN (res);
2611
}
2612
}
2613
 
2614
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int,
2615
                                          bid128_signaling_greater_equal,
2616
                                          x, y)
2617
 
2618
     int res;
2619
     int exp_x, exp_y;
2620
     int diff;
2621
     UINT128 sig_x, sig_y;
2622
     UINT192 sig_n_prime192;
2623
     UINT256 sig_n_prime256;
2624
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
2625
 
2626
  // NaN (CASE1)
2627
  // if either number is NAN, the comparison is unordered, 
2628
  // rather than equal : return 1
2629
if (((x.w[1] & MASK_NAN) == MASK_NAN)
2630
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
2631
*pfpsf |= INVALID_EXCEPTION;
2632
{
2633
  res = 0;
2634
  BID_RETURN (res);
2635
}
2636
}
2637
  // SIMPLE (CASE2)
2638
  // if all the bits are the same, these numbers are equal (not Greater).
2639
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
2640
  res = 1;
2641
  BID_RETURN (res);
2642
}
2643
  // INFINITY (CASE3)
2644
if ((x.w[1] & MASK_INF) == MASK_INF) {
2645
  // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
2646
  if ((x.w[1] & MASK_SIGN) == MASK_SIGN)
2647
    // x is -inf, so it is less than y unless y is -inf
2648
  {
2649
    res = (((y.w[1] & MASK_INF) == MASK_INF)
2650
           && (y.w[1] & MASK_SIGN) == MASK_SIGN);
2651
    BID_RETURN (res);
2652
  } else
2653
    // x is pos_inf, no way for it to be less than y
2654
  {
2655
    res = 1;
2656
    BID_RETURN (res);
2657
  }
2658
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
2659
  // x is finite, so if y is positive infinity, then x is less, return 0
2660
  //                 if y is negative infinity, then x is greater, return 1
2661
  {
2662
    res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2663
    BID_RETURN (res);
2664
  }
2665
}
2666
  // CONVERT X
2667
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
2668
sig_x.w[0] = x.w[0];
2669
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
2670
 
2671
  // CHECK IF X IS CANONICAL
2672
  // 9999999999999999999999999999999999(decimal) = 
2673
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
2674
  // [0, 10^34) is the 754r supported canonical range.  
2675
  //     If the value exceeds that, it is interpreted as 0.
2676
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
2677
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
2678
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
2679
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
2680
  non_canon_x = 1;
2681
else
2682
  non_canon_x = 0;
2683
 
2684
  // CONVERT Y
2685
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
2686
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
2687
sig_y.w[0] = y.w[0];
2688
 
2689
  // CHECK IF Y IS CANONICAL
2690
  // 9999999999999999999999999999999999(decimal) = 
2691
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
2692
  // [0, 10^34) is the 754r supported canonical range.  
2693
  //     If the value exceeds that, it is interpreted as 0.
2694
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
2695
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
2696
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
2697
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
2698
  non_canon_y = 1;
2699
else
2700
  non_canon_y = 0;
2701
 
2702
  // ZERO (CASE4)
2703
  // some properties:
2704
  //    (+ZERO == -ZERO) => therefore ignore the sign
2705
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
2706
  //    ignore the exponent field
2707
  //    (Any non-canonical # is considered 0)
2708
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
2709
  x_is_zero = 1;
2710
}
2711
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
2712
  y_is_zero = 1;
2713
}
2714
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
2715
if (x_is_zero && y_is_zero) {
2716
  res = 1;
2717
  BID_RETURN (res);
2718
}
2719
  // is x is zero, it is greater if Y is negative
2720
else if (x_is_zero) {
2721
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2722
  BID_RETURN (res);
2723
}
2724
  // is y is zero, X is greater if it is positive
2725
else if (y_is_zero) {
2726
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2727
  BID_RETURN (res);
2728
}
2729
  // OPPOSITE SIGN (CASE5)
2730
  // now, if the sign bits differ, x is greater if y is negative
2731
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
2732
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2733
  BID_RETURN (res);
2734
}
2735
  // REDUNDANT REPRESENTATIONS (CASE6)
2736
  // if exponents are the same, then we have a simple comparison 
2737
  // of the significands
2738
if (exp_y == exp_x) {
2739
  res = (((sig_x.w[1] > sig_y.w[1])
2740
          || (sig_x.w[1] == sig_y.w[1]
2741
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) ==
2742
                                               MASK_SIGN));
2743
  BID_RETURN (res);
2744
}
2745
  // if both components are either bigger or smaller, 
2746
  // it is clear what needs to be done
2747
if (sig_x.w[1] >= sig_y.w[1] && sig_x.w[0] >= sig_y.w[0]
2748
    && exp_x > exp_y) {
2749
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2750
  BID_RETURN (res);
2751
}
2752
if (sig_x.w[1] <= sig_y.w[1] && sig_x.w[0] <= sig_y.w[0]
2753
    && exp_x < exp_y) {
2754
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
2755
  BID_RETURN (res);
2756
}
2757
 
2758
diff = exp_x - exp_y;
2759
 
2760
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
2761
if (diff > 0) {  // to simplify the loop below,
2762
 
2763
  // if exp_x is 33 greater than exp_y, no need for compensation
2764
  if (diff > 33) {
2765
    res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2766
    BID_RETURN (res);
2767
  }     // difference cannot be greater than 10^33
2768
 
2769
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
2770
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
2771
 
2772
 
2773
    // if postitive, return whichever significand is larger 
2774
    // (converse if negative)
2775
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
2776
        && sig_n_prime256.w[1] == sig_y.w[1]
2777
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
2778
      res = 1;
2779
      BID_RETURN (res);
2780
    }   // if equal, return 1
2781
    {
2782
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
2783
              || (sig_n_prime256.w[1] > sig_y.w[1])
2784
              || (sig_n_prime256.w[1] == sig_y.w[1]
2785
                  && sig_n_prime256.w[0] >
2786
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
2787
      BID_RETURN (res);
2788
    }
2789
  }
2790
  //else { //128 by 64 bit multiply -> 192 bits
2791
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
2792
 
2793
  // if postitive, return whichever significand is larger 
2794
  // (converse if negative)
2795
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
2796
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
2797
    res = 1;
2798
    BID_RETURN (res);
2799
  }     // if equal, return 1
2800
  {
2801
    res = (((sig_n_prime192.w[2] > 0)
2802
            || (sig_n_prime192.w[1] > sig_y.w[1])
2803
            || (sig_n_prime192.w[1] == sig_y.w[1]
2804
                && sig_n_prime192.w[0] >
2805
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
2806
    BID_RETURN (res);
2807
  }
2808
}
2809
 
2810
diff = exp_y - exp_x;
2811
 
2812
  // if exp_x is 33 less than exp_y, no need for compensation
2813
if (diff > 33) {
2814
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
2815
  BID_RETURN (res);
2816
}
2817
 
2818
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
2819
  // adjust the y significand upwards
2820
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
2821
 
2822
 
2823
  // if postitive, return whichever significand is larger 
2824
  // (converse if negative)
2825
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
2826
      && sig_n_prime256.w[1] == sig_x.w[1]
2827
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
2828
    res = 1;
2829
    BID_RETURN (res);
2830
  }     // if equal, return 1
2831
  {
2832
    res =
2833
      ((sig_n_prime256.w[3] == 0 && sig_n_prime256.w[2] == 0
2834
        && (sig_n_prime256.w[1] < sig_x.w[1]
2835
            || (sig_n_prime256.w[1] == sig_x.w[1]
2836
                && sig_n_prime256.w[0] <
2837
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
2838
    BID_RETURN (res);
2839
  }
2840
}
2841
  //else { //128 by 64 bit multiply -> 192 bits
2842
  // adjust the y significand upwards
2843
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
2844
 
2845
  // if postitive, return whichever significand is larger 
2846
  // (converse if negative)
2847
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
2848
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
2849
  res = 1;
2850
  BID_RETURN (res);
2851
}       // if equal, return 1
2852
{
2853
  res = (sig_n_prime192.w[2] == 0
2854
         && (sig_n_prime192.w[1] < sig_x.w[1]
2855
             || (sig_n_prime192.w[1] == sig_x.w[1]
2856
                 && sig_n_prime192.w[0] <
2857
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2858
  BID_RETURN (res);
2859
}
2860
}
2861
 
2862
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int,
2863
                                          bid128_signaling_greater_unordered,
2864
                                          x, y)
2865
 
2866
     int res;
2867
     int exp_x, exp_y;
2868
     int diff;
2869
     UINT128 sig_x, sig_y;
2870
     UINT192 sig_n_prime192;
2871
     UINT256 sig_n_prime256;
2872
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
2873
 
2874
  // NaN (CASE1)
2875
  // if either number is NAN, the comparison is unordered, 
2876
  // rather than equal : return 1
2877
if (((x.w[1] & MASK_NAN) == MASK_NAN)
2878
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
2879
*pfpsf |= INVALID_EXCEPTION;
2880
{
2881
  res = 1;
2882
  BID_RETURN (res);
2883
}
2884
}
2885
  // SIMPLE (CASE2)
2886
  // if all the bits are the same, these numbers are equal (not Greater).
2887
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
2888
  res = 0;
2889
  BID_RETURN (res);
2890
}
2891
  // INFINITY (CASE3)
2892
if ((x.w[1] & MASK_INF) == MASK_INF) {
2893
  // if x is neg infinity, there is no way it is greater than y, return 0
2894
  if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) {
2895
    res = 0;
2896
    BID_RETURN (res);
2897
  }
2898
  // x is pos infinity, it is greater, unless y is positive infinity => return y!=pos_infinity
2899
  else {
2900
    res = (((y.w[1] & MASK_INF) != MASK_INF)
2901
           || ((y.w[1] & MASK_SIGN) == MASK_SIGN));
2902
    BID_RETURN (res);
2903
  }
2904
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
2905
  // x is finite, so if y is positive infinity, then x is less, return 0
2906
  //                 if y is negative infinity, then x is greater, return 1
2907
  {
2908
    res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2909
    BID_RETURN (res);
2910
  }
2911
}
2912
  // CONVERT X
2913
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
2914
sig_x.w[0] = x.w[0];
2915
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
2916
 
2917
  // CHECK IF X IS CANONICAL
2918
  // 9999999999999999999999999999999999(decimal) = 
2919
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
2920
  // [0, 10^34) is the 754r supported canonical range.  
2921
  //     If the value exceeds that, it is interpreted as 0.
2922
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
2923
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
2924
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
2925
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
2926
  non_canon_x = 1;
2927
else
2928
  non_canon_x = 0;
2929
 
2930
  // CONVERT Y
2931
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
2932
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
2933
sig_y.w[0] = y.w[0];
2934
 
2935
  // CHECK IF Y IS CANONICAL
2936
  // 9999999999999999999999999999999999(decimal) = 
2937
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
2938
  // [0, 10^34) is the 754r supported canonical range.  
2939
  //     If the value exceeds that, it is interpreted as 0.
2940
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
2941
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
2942
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
2943
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
2944
  non_canon_y = 1;
2945
else
2946
  non_canon_y = 0;
2947
 
2948
  // ZERO (CASE4)
2949
  // some properties:
2950
  //    (+ZERO == -ZERO) => therefore ignore the sign
2951
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
2952
  //    ignore the exponent field
2953
  //    (Any non-canonical # is considered 0)
2954
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
2955
  x_is_zero = 1;
2956
}
2957
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
2958
  y_is_zero = 1;
2959
}
2960
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
2961
if (x_is_zero && y_is_zero) {
2962
  res = 0;
2963
  BID_RETURN (res);
2964
}
2965
  // is x is zero, it is greater if Y is negative
2966
else if (x_is_zero) {
2967
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2968
  BID_RETURN (res);
2969
}
2970
  // is y is zero, X is greater if it is positive
2971
else if (y_is_zero) {
2972
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2973
  BID_RETURN (res);
2974
}
2975
  // OPPOSITE SIGN (CASE5)
2976
  // now, if the sign bits differ, x is greater if y is negative
2977
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
2978
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
2979
  BID_RETURN (res);
2980
}
2981
  // REDUNDANT REPRESENTATIONS (CASE6)
2982
  // if exponents are the same, then we have a simple comparison 
2983
  // of the significands
2984
if (exp_y == exp_x) {
2985
  res = (((sig_x.w[1] > sig_y.w[1])
2986
          || (sig_x.w[1] == sig_y.w[1]
2987
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) ==
2988
                                               MASK_SIGN));
2989
  BID_RETURN (res);
2990
}
2991
  // if both components are either bigger or smaller, 
2992
  // it is clear what needs to be done
2993
if (sig_x.w[1] >= sig_y.w[1] && sig_x.w[0] >= sig_y.w[0]
2994
    && exp_x > exp_y) {
2995
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
2996
  BID_RETURN (res);
2997
}
2998
if (sig_x.w[1] <= sig_y.w[1] && sig_x.w[0] <= sig_y.w[0]
2999
    && exp_x < exp_y) {
3000
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3001
  BID_RETURN (res);
3002
}
3003
 
3004
diff = exp_x - exp_y;
3005
 
3006
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
3007
if (diff > 0) {  // to simplify the loop below,
3008
 
3009
  // if exp_x is 33 greater than exp_y, no need for compensation
3010
  if (diff > 33) {
3011
    res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
3012
    BID_RETURN (res);
3013
  }     // difference cannot be greater than 10^33
3014
 
3015
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
3016
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
3017
 
3018
 
3019
    // if postitive, return whichever significand is larger 
3020
    // (converse if negative)
3021
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
3022
        && sig_n_prime256.w[1] == sig_y.w[1]
3023
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
3024
      res = 0;
3025
      BID_RETURN (res);
3026
    }   // if equal, return 0
3027
    {
3028
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
3029
              || (sig_n_prime256.w[1] > sig_y.w[1])
3030
              || (sig_n_prime256.w[1] == sig_y.w[1]
3031
                  && sig_n_prime256.w[0] >
3032
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
3033
      BID_RETURN (res);
3034
    }
3035
  }
3036
  //else { //128 by 64 bit multiply -> 192 bits
3037
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
3038
 
3039
  // if postitive, return whichever significand is larger 
3040
  // (converse if negative)
3041
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
3042
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
3043
    res = 0;
3044
    BID_RETURN (res);
3045
  }     // if equal, return 0
3046
  {
3047
    res = (((sig_n_prime192.w[2] > 0)
3048
            || (sig_n_prime192.w[1] > sig_y.w[1])
3049
            || (sig_n_prime192.w[1] == sig_y.w[1]
3050
                && sig_n_prime192.w[0] >
3051
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
3052
    BID_RETURN (res);
3053
  }
3054
}
3055
 
3056
diff = exp_y - exp_x;
3057
 
3058
  // if exp_x is 33 less than exp_y, no need for compensation
3059
if (diff > 33) {
3060
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3061
  BID_RETURN (res);
3062
}
3063
 
3064
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
3065
  // adjust the y significand upwards
3066
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
3067
 
3068
 
3069
  // if postitive, return whichever significand is larger 
3070
  // (converse if negative)
3071
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
3072
      && sig_n_prime256.w[1] == sig_x.w[1]
3073
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
3074
    res = 0;
3075
    BID_RETURN (res);
3076
  }     // if equal, return 0
3077
  {
3078
    res =
3079
      ((sig_n_prime256.w[3] == 0 && sig_n_prime256.w[2] == 0
3080
        && (sig_n_prime256.w[1] < sig_x.w[1]
3081
            || (sig_n_prime256.w[1] == sig_x.w[1]
3082
                && sig_n_prime256.w[0] <
3083
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
3084
    BID_RETURN (res);
3085
  }
3086
}
3087
  //else { //128 by 64 bit multiply -> 192 bits
3088
  // adjust the y significand upwards
3089
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
3090
 
3091
  // if postitive, return whichever significand is larger 
3092
  // (converse if negative)
3093
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
3094
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
3095
  res = 0;
3096
  BID_RETURN (res);
3097
}       // if equal, return 0
3098
{
3099
  res = (sig_n_prime192.w[2] == 0
3100
         && (sig_n_prime192.w[1] < sig_x.w[1]
3101
             || (sig_n_prime192.w[1] == sig_x.w[1]
3102
                 && sig_n_prime192.w[0] <
3103
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
3104
  BID_RETURN (res);
3105
}
3106
}
3107
 
3108
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int, bid128_signaling_less, x,
3109
                                          y)
3110
 
3111
     int res;
3112
     int exp_x, exp_y;
3113
     int diff;
3114
     UINT128 sig_x, sig_y;
3115
     UINT192 sig_n_prime192;
3116
     UINT256 sig_n_prime256;
3117
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
3118
 
3119
  // NaN (CASE1)
3120
  // if either number is NAN, the comparison is unordered, 
3121
  // rather than equal : return 0
3122
if (((x.w[1] & MASK_NAN) == MASK_NAN)
3123
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
3124
*pfpsf |= INVALID_EXCEPTION;
3125
{
3126
  res = 0;
3127
  BID_RETURN (res);
3128
}
3129
}
3130
  // SIMPLE (CASE2)
3131
  // if all the bits are the same, these numbers are equal.
3132
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
3133
  res = 0;
3134
  BID_RETURN (res);
3135
}
3136
  // INFINITY (CASE3)
3137
if ((x.w[1] & MASK_INF) == MASK_INF) {
3138
  // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
3139
  if ((x.w[1] & MASK_SIGN) == MASK_SIGN)
3140
    // x is -inf, so it is less than y unless y is -inf
3141
  {
3142
    res = (((y.w[1] & MASK_INF) != MASK_INF)
3143
           || (y.w[1] & MASK_SIGN) != MASK_SIGN);
3144
    BID_RETURN (res);
3145
  } else
3146
    // x is pos_inf, no way for it to be less than y
3147
  {
3148
    res = 0;
3149
    BID_RETURN (res);
3150
  }
3151
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
3152
  // x is finite, so if y is positive infinity, then x is less, return 0
3153
  //                 if y is negative infinity, then x is greater, return 1
3154
  {
3155
    res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3156
    BID_RETURN (res);
3157
  }
3158
}
3159
  // CONVERT X
3160
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
3161
sig_x.w[0] = x.w[0];
3162
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
3163
 
3164
  // CHECK IF X IS CANONICAL
3165
  // 9999999999999999999999999999999999(decimal) = 
3166
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
3167
  // [0, 10^34) is the 754r supported canonical range.  
3168
  //     If the value exceeds that, it is interpreted as 0.
3169
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
3170
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
3171
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
3172
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
3173
  non_canon_x = 1;
3174
else
3175
  non_canon_x = 0;
3176
 
3177
  // CONVERT Y
3178
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
3179
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
3180
sig_y.w[0] = y.w[0];
3181
 
3182
  // CHECK IF Y IS CANONICAL
3183
  // 9999999999999999999999999999999999(decimal) = 
3184
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
3185
  // [0, 10^34) is the 754r supported canonical range.  
3186
  //     If the value exceeds that, it is interpreted as 0.
3187
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
3188
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
3189
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
3190
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
3191
  non_canon_y = 1;
3192
else
3193
  non_canon_y = 0;
3194
 
3195
  // ZERO (CASE4)
3196
  // some properties:
3197
  //    (+ZERO == -ZERO) => therefore ignore the sign
3198
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
3199
  //    ignore the exponent field
3200
  //    (Any non-canonical # is considered 0)
3201
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
3202
  x_is_zero = 1;
3203
}
3204
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
3205
  y_is_zero = 1;
3206
}
3207
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
3208
if (x_is_zero && y_is_zero) {
3209
  res = 0;
3210
  BID_RETURN (res);
3211
}
3212
  // is x is zero, it is greater if Y is negative
3213
else if (x_is_zero) {
3214
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3215
  BID_RETURN (res);
3216
}
3217
  // is y is zero, X is greater if it is positive
3218
else if (y_is_zero) {
3219
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3220
  BID_RETURN (res);
3221
}
3222
  // OPPOSITE SIGN (CASE5)
3223
  // now, if the sign bits differ, x is greater if y is negative
3224
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
3225
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3226
  BID_RETURN (res);
3227
}
3228
  // REDUNDANT REPRESENTATIONS (CASE6)
3229
  // if exponents are the same, then we have a simple comparison 
3230
  // of the significands
3231
if (exp_y == exp_x) {
3232
  res = (((sig_x.w[1] > sig_y.w[1])
3233
          || (sig_x.w[1] == sig_y.w[1]
3234
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) !=
3235
                                               MASK_SIGN));
3236
  BID_RETURN (res);
3237
}
3238
  // if both components are either bigger or smaller, 
3239
  // it is clear what needs to be done
3240
if ((sig_x.w[1] > sig_y.w[1]
3241
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
3242
    && exp_x >= exp_y) {
3243
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3244
  BID_RETURN (res);
3245
}
3246
if ((sig_x.w[1] < sig_y.w[1]
3247
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
3248
    && exp_x <= exp_y) {
3249
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
3250
  BID_RETURN (res);
3251
}
3252
 
3253
diff = exp_x - exp_y;
3254
 
3255
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
3256
if (diff > 0) {  // to simplify the loop below,
3257
 
3258
  // if exp_x is 33 greater than exp_y, no need for compensation
3259
  if (diff > 33) {
3260
    res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3261
    BID_RETURN (res);
3262
  }     // difference cannot be greater than 10^33
3263
 
3264
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
3265
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
3266
 
3267
 
3268
    // if postitive, return whichever significand is larger 
3269
    // (converse if negative)
3270
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
3271
        && sig_n_prime256.w[1] == sig_y.w[1]
3272
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
3273
      res = 0;
3274
      BID_RETURN (res);
3275
    }   // if equal, return 0
3276
    {
3277
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
3278
              || (sig_n_prime256.w[1] > sig_y.w[1])
3279
              || (sig_n_prime256.w[1] == sig_y.w[1]
3280
                  && sig_n_prime256.w[0] >
3281
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
3282
      BID_RETURN (res);
3283
    }
3284
  }
3285
  //else { //128 by 64 bit multiply -> 192 bits
3286
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
3287
 
3288
  // if postitive, return whichever significand is larger 
3289
  // (converse if negative)
3290
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
3291
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
3292
    res = 0;
3293
    BID_RETURN (res);
3294
  }     // if equal, return 0
3295
  {
3296
    res = (((sig_n_prime192.w[2] > 0)
3297
            || (sig_n_prime192.w[1] > sig_y.w[1])
3298
            || (sig_n_prime192.w[1] == sig_y.w[1]
3299
                && sig_n_prime192.w[0] >
3300
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
3301
    BID_RETURN (res);
3302
  }
3303
}
3304
 
3305
diff = exp_y - exp_x;
3306
 
3307
  // if exp_x is 33 less than exp_y, |x| < |y|, return 1 if positive
3308
if (diff > 33) {
3309
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
3310
  BID_RETURN (res);
3311
}
3312
 
3313
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
3314
  // adjust the y significand upwards
3315
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
3316
 
3317
 
3318
  // if postitive, return whichever significand is larger 
3319
  // (converse if negative)
3320
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
3321
      && sig_n_prime256.w[1] == sig_x.w[1]
3322
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
3323
    res = 0;
3324
    BID_RETURN (res);
3325
  }     // if equal, return 1
3326
  {
3327
    res =
3328
      ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
3329
        || (sig_n_prime256.w[1] > sig_x.w[1]
3330
            || (sig_n_prime256.w[1] == sig_x.w[1]
3331
                && sig_n_prime256.w[0] >
3332
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
3333
    BID_RETURN (res);
3334
  }
3335
}
3336
  //else { //128 by 64 bit multiply -> 192 bits
3337
  // adjust the y significand upwards
3338
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
3339
 
3340
  // if postitive, return whichever significand is larger 
3341
  // (converse if negative)
3342
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
3343
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
3344
  res = 0;
3345
  BID_RETURN (res);
3346
}       // if equal, return 0
3347
{
3348
  res = (sig_n_prime192.w[2] != 0
3349
         || (sig_n_prime192.w[1] > sig_x.w[1]
3350
             || (sig_n_prime192.w[1] == sig_x.w[1]
3351
                 && sig_n_prime192.w[0] >
3352
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
3353
  BID_RETURN (res);
3354
}
3355
}
3356
 
3357
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int,
3358
                                          bid128_signaling_less_equal,
3359
                                          x, y)
3360
 
3361
     int res;
3362
     int exp_x, exp_y;
3363
     int diff;
3364
     UINT128 sig_x, sig_y;
3365
     UINT192 sig_n_prime192;
3366
     UINT256 sig_n_prime256;
3367
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
3368
 
3369
  // NaN (CASE1)
3370
  // if either number is NAN, the comparison is unordered, 
3371
  // rather than equal : return 0
3372
if (((x.w[1] & MASK_NAN) == MASK_NAN)
3373
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
3374
*pfpsf |= INVALID_EXCEPTION;
3375
{
3376
  res = 0;
3377
  BID_RETURN (res);
3378
}
3379
}
3380
  // SIMPLE (CASE2)
3381
  // if all the bits are the same, these numbers are equal (not Greater).
3382
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
3383
  res = 1;
3384
  BID_RETURN (res);
3385
}
3386
  // INFINITY (CASE3)
3387
if ((x.w[1] & MASK_INF) == MASK_INF) {
3388
  // if x is neg infinity, there is no way it is greater than y, return 1
3389
  if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) {
3390
    res = 1;
3391
    BID_RETURN (res);
3392
  }
3393
  // x is pos infinity, it is greater, unless y is positive infinity => return y!=pos_infinity
3394
  else {
3395
    res = (((y.w[1] & MASK_INF) == MASK_INF)
3396
           && ((y.w[1] & MASK_SIGN) != MASK_SIGN));
3397
    BID_RETURN (res);
3398
  }
3399
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
3400
  // x is finite, so if y is positive infinity, then x is less, return 0
3401
  //                 if y is negative infinity, then x is greater, return 1
3402
  {
3403
    res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3404
    BID_RETURN (res);
3405
  }
3406
}
3407
  // CONVERT X
3408
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
3409
sig_x.w[0] = x.w[0];
3410
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
3411
 
3412
  // CHECK IF X IS CANONICAL
3413
  // 9999999999999999999999999999999999(decimal) = 
3414
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
3415
  // [0, 10^34) is the 754r supported canonical range.  
3416
  //     If the value exceeds that, it is interpreted as 0.
3417
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
3418
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
3419
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
3420
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
3421
  non_canon_x = 1;
3422
else
3423
  non_canon_x = 0;
3424
 
3425
  // CONVERT Y
3426
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
3427
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
3428
sig_y.w[0] = y.w[0];
3429
 
3430
  // CHECK IF Y IS CANONICAL
3431
  // 9999999999999999999999999999999999(decimal) = 
3432
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
3433
  // [0, 10^34) is the 754r supported canonical range.  
3434
  //     If the value exceeds that, it is interpreted as 0.
3435
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
3436
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
3437
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
3438
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
3439
  non_canon_y = 1;
3440
else
3441
  non_canon_y = 0;
3442
 
3443
  // ZERO (CASE4)
3444
  // some properties:
3445
  //    (+ZERO == -ZERO) => therefore ignore the sign
3446
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
3447
  //    ignore the exponent field
3448
  //    (Any non-canonical # is considered 0)
3449
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
3450
  x_is_zero = 1;
3451
}
3452
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
3453
  y_is_zero = 1;
3454
}
3455
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
3456
if (x_is_zero && y_is_zero) {
3457
  res = 1;
3458
  BID_RETURN (res);
3459
}
3460
  // is x is zero, it is greater if Y is negative
3461
else if (x_is_zero) {
3462
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3463
  BID_RETURN (res);
3464
}
3465
  // is y is zero, X is greater if it is positive
3466
else if (y_is_zero) {
3467
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3468
  BID_RETURN (res);
3469
}
3470
  // OPPOSITE SIGN (CASE5)
3471
  // now, if the sign bits differ, x is greater if y is negative
3472
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
3473
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3474
  BID_RETURN (res);
3475
}
3476
  // REDUNDANT REPRESENTATIONS (CASE6)
3477
  // if exponents are the same, then we have a simple comparison 
3478
  // of the significands
3479
if (exp_y == exp_x) {
3480
  res = (((sig_x.w[1] > sig_y.w[1])
3481
          || (sig_x.w[1] == sig_y.w[1]
3482
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) !=
3483
                                               MASK_SIGN));
3484
  BID_RETURN (res);
3485
}
3486
  // if both components are either bigger or smaller, 
3487
  // it is clear what needs to be done
3488
if ((sig_x.w[1] > sig_y.w[1]
3489
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
3490
    && exp_x >= exp_y) {
3491
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3492
  BID_RETURN (res);
3493
}
3494
if ((sig_x.w[1] < sig_y.w[1]
3495
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
3496
    && exp_x <= exp_y) {
3497
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
3498
  BID_RETURN (res);
3499
}
3500
 
3501
diff = exp_x - exp_y;
3502
 
3503
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
3504
if (diff > 0) {  // to simplify the loop below,
3505
 
3506
  // if exp_x is 33 greater than exp_y, no need for compensation
3507
  if (diff > 33) {
3508
    res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3509
    BID_RETURN (res);
3510
  }     // difference cannot be greater than 10^33
3511
 
3512
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
3513
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
3514
 
3515
 
3516
    // if postitive, return whichever significand is larger 
3517
    // (converse if negative)
3518
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
3519
        && sig_n_prime256.w[1] == sig_y.w[1]
3520
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
3521
      res = 1;
3522
      BID_RETURN (res);
3523
    }   // if equal, return 0
3524
    {
3525
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
3526
              || (sig_n_prime256.w[1] > sig_y.w[1])
3527
              || (sig_n_prime256.w[1] == sig_y.w[1]
3528
                  && sig_n_prime256.w[0] >
3529
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
3530
      BID_RETURN (res);
3531
    }
3532
  }
3533
  //else { //128 by 64 bit multiply -> 192 bits
3534
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
3535
 
3536
  // if postitive, return whichever significand is larger 
3537
  // (converse if negative)
3538
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
3539
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
3540
    res = 1;
3541
    BID_RETURN (res);
3542
  }     // if equal, return 0
3543
  {
3544
    res = (((sig_n_prime192.w[2] > 0)
3545
            || (sig_n_prime192.w[1] > sig_y.w[1])
3546
            || (sig_n_prime192.w[1] == sig_y.w[1]
3547
                && sig_n_prime192.w[0] >
3548
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
3549
    BID_RETURN (res);
3550
  }
3551
}
3552
 
3553
diff = exp_y - exp_x;
3554
 
3555
  // if exp_x is 33 less than exp_y, no need for compensation
3556
if (diff > 33) {
3557
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
3558
  BID_RETURN (res);
3559
}
3560
 
3561
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
3562
  // adjust the y significand upwards
3563
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
3564
 
3565
 
3566
  // if postitive, return whichever significand is larger 
3567
  // (converse if negative)
3568
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
3569
      && sig_n_prime256.w[1] == sig_x.w[1]
3570
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
3571
    res = 1;
3572
    BID_RETURN (res);
3573
  }     // if equal, return 0
3574
  {
3575
    res =
3576
      ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
3577
        || (sig_n_prime256.w[1] > sig_x.w[1]
3578
            || (sig_n_prime256.w[1] == sig_x.w[1]
3579
                && sig_n_prime256.w[0] >
3580
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
3581
    BID_RETURN (res);
3582
  }
3583
}
3584
  //else { //128 by 64 bit multiply -> 192 bits
3585
  // adjust the y significand upwards
3586
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
3587
 
3588
  // if postitive, return whichever significand is larger 
3589
  // (converse if negative)
3590
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
3591
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
3592
  res = 1;
3593
  BID_RETURN (res);
3594
}       // if equal, return 0
3595
{
3596
  res = (sig_n_prime192.w[2] != 0
3597
         || (sig_n_prime192.w[1] > sig_x.w[1]
3598
             || (sig_n_prime192.w[1] == sig_x.w[1]
3599
                 && sig_n_prime192.w[0] >
3600
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
3601
  BID_RETURN (res);
3602
}
3603
}
3604
 
3605
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int,
3606
                                          bid128_signaling_less_unordered,
3607
                                          x, y)
3608
 
3609
     int res;
3610
     int exp_x, exp_y;
3611
     int diff;
3612
     UINT128 sig_x, sig_y;
3613
     UINT192 sig_n_prime192;
3614
     UINT256 sig_n_prime256;
3615
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
3616
 
3617
  // NaN (CASE1)
3618
  // if either number is NAN, the comparison is unordered
3619
if (((x.w[1] & MASK_NAN) == MASK_NAN)
3620
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
3621
*pfpsf |= INVALID_EXCEPTION;
3622
{
3623
  res = 1;
3624
  BID_RETURN (res);
3625
}
3626
}
3627
  // SIMPLE (CASE2)
3628
  // if all the bits are the same, these numbers are equal.
3629
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
3630
  res = 0;
3631
  BID_RETURN (res);
3632
}
3633
  // INFINITY (CASE3)
3634
if ((x.w[1] & MASK_INF) == MASK_INF) {
3635
  // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
3636
  if ((x.w[1] & MASK_SIGN) == MASK_SIGN)
3637
    // x is -inf, so it is less than y unless y is -inf
3638
  {
3639
    res = (((y.w[1] & MASK_INF) != MASK_INF)
3640
           || (y.w[1] & MASK_SIGN) != MASK_SIGN);
3641
    BID_RETURN (res);
3642
  } else
3643
    // x is pos_inf, no way for it to be less than y
3644
  {
3645
    res = 0;
3646
    BID_RETURN (res);
3647
  }
3648
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
3649
  // x is finite, so if y is positive infinity, then x is less, return 0
3650
  //                 if y is negative infinity, then x is greater, return 1
3651
  {
3652
    res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3653
    BID_RETURN (res);
3654
  }
3655
}
3656
  // CONVERT X
3657
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
3658
sig_x.w[0] = x.w[0];
3659
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
3660
 
3661
  // CHECK IF X IS CANONICAL
3662
  // 9999999999999999999999999999999999(decimal) = 
3663
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
3664
  // [0, 10^34) is the 754r supported canonical range.  
3665
  //     If the value exceeds that, it is interpreted as 0.
3666
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
3667
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
3668
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
3669
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
3670
  non_canon_x = 1;
3671
else
3672
  non_canon_x = 0;
3673
 
3674
  // CONVERT Y
3675
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
3676
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
3677
sig_y.w[0] = y.w[0];
3678
 
3679
  // CHECK IF Y IS CANONICAL
3680
  // 9999999999999999999999999999999999(decimal) = 
3681
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
3682
  // [0, 10^34) is the 754r supported canonical range.  
3683
  //     If the value exceeds that, it is interpreted as 0.
3684
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
3685
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
3686
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
3687
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
3688
  non_canon_y = 1;
3689
else
3690
  non_canon_y = 0;
3691
 
3692
  // ZERO (CASE4)
3693
  // some properties:
3694
  //    (+ZERO == -ZERO) => therefore ignore the sign
3695
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
3696
  //    ignore the exponent field
3697
  //    (Any non-canonical # is considered 0)
3698
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
3699
  x_is_zero = 1;
3700
}
3701
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
3702
  y_is_zero = 1;
3703
}
3704
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
3705
if (x_is_zero && y_is_zero) {
3706
  res = 0;
3707
  BID_RETURN (res);
3708
}
3709
  // is x is zero, it is greater if Y is negative
3710
else if (x_is_zero) {
3711
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3712
  BID_RETURN (res);
3713
}
3714
  // is y is zero, X is greater if it is positive
3715
else if (y_is_zero) {
3716
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3717
  BID_RETURN (res);
3718
}
3719
  // OPPOSITE SIGN (CASE5)
3720
  // now, if the sign bits differ, x is greater if y is negative
3721
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
3722
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3723
  BID_RETURN (res);
3724
}
3725
  // REDUNDANT REPRESENTATIONS (CASE6)
3726
  // if exponents are the same, then we have a simple comparison 
3727
  // of the significands
3728
if (exp_y == exp_x) {
3729
  res = (((sig_x.w[1] > sig_y.w[1])
3730
          || (sig_x.w[1] == sig_y.w[1]
3731
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) !=
3732
                                               MASK_SIGN));
3733
  BID_RETURN (res);
3734
}
3735
  // if both components are either bigger or smaller, 
3736
  // it is clear what needs to be done
3737
if ((sig_x.w[1] > sig_y.w[1]
3738
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
3739
    && exp_x >= exp_y) {
3740
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3741
  BID_RETURN (res);
3742
}
3743
if ((sig_x.w[1] < sig_y.w[1]
3744
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
3745
    && exp_x <= exp_y) {
3746
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
3747
  BID_RETURN (res);
3748
}
3749
 
3750
diff = exp_x - exp_y;
3751
 
3752
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
3753
if (diff > 0) {  // to simplify the loop below,
3754
 
3755
  // if exp_x is 33 greater than exp_y, no need for compensation
3756
  if (diff > 33) {
3757
    res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3758
    BID_RETURN (res);
3759
  }     // difference cannot be greater than 10^33
3760
 
3761
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
3762
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
3763
 
3764
 
3765
    // if postitive, return whichever significand is larger 
3766
    // (converse if negative)
3767
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
3768
        && sig_n_prime256.w[1] == sig_y.w[1]
3769
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
3770
      res = 0;
3771
      BID_RETURN (res);
3772
    }   // if equal, return 0
3773
    {
3774
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
3775
              || (sig_n_prime256.w[1] > sig_y.w[1])
3776
              || (sig_n_prime256.w[1] == sig_y.w[1]
3777
                  && sig_n_prime256.w[0] >
3778
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
3779
      BID_RETURN (res);
3780
    }
3781
  }
3782
  //else { //128 by 64 bit multiply -> 192 bits
3783
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
3784
 
3785
  // if postitive, return whichever significand is larger 
3786
  // (converse if negative)
3787
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
3788
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
3789
    res = 0;
3790
    BID_RETURN (res);
3791
  }     // if equal, return 0
3792
  {
3793
    res = (((sig_n_prime192.w[2] > 0)
3794
            || (sig_n_prime192.w[1] > sig_y.w[1])
3795
            || (sig_n_prime192.w[1] == sig_y.w[1]
3796
                && sig_n_prime192.w[0] >
3797
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
3798
    BID_RETURN (res);
3799
  }
3800
}
3801
 
3802
diff = exp_y - exp_x;
3803
 
3804
  // if exp_x is 33 less than exp_y, no need for compensation
3805
if (diff > 33) {
3806
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
3807
  BID_RETURN (res);
3808
}
3809
 
3810
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
3811
  // adjust the y significand upwards
3812
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
3813
 
3814
 
3815
  // if postitive, return whichever significand is larger 
3816
  // (converse if negative)
3817
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
3818
      && sig_n_prime256.w[1] == sig_x.w[1]
3819
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
3820
    res = 0;
3821
    BID_RETURN (res);
3822
  }     // if equal, return 1
3823
  {
3824
    res =
3825
      ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
3826
        || (sig_n_prime256.w[1] > sig_x.w[1]
3827
            || (sig_n_prime256.w[1] == sig_x.w[1]
3828
                && sig_n_prime256.w[0] >
3829
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
3830
    BID_RETURN (res);
3831
  }
3832
}
3833
  //else { //128 by 64 bit multiply -> 192 bits
3834
  // adjust the y significand upwards
3835
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
3836
 
3837
  // if postitive, return whichever significand is larger (converse if negative)
3838
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
3839
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
3840
  res = 0;
3841
  BID_RETURN (res);
3842
}       // if equal, return 0
3843
{
3844
  res = (sig_n_prime192.w[2] != 0
3845
         || (sig_n_prime192.w[1] > sig_x.w[1]
3846
             || (sig_n_prime192.w[1] == sig_x.w[1]
3847
                 && sig_n_prime192.w[0] >
3848
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
3849
  BID_RETURN (res);
3850
}
3851
}
3852
 
3853
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int,
3854
                                          bid128_signaling_not_greater,
3855
                                          x, y)
3856
 
3857
     int res;
3858
     int exp_x, exp_y;
3859
     int diff;
3860
     UINT128 sig_x, sig_y;
3861
     UINT192 sig_n_prime192;
3862
     UINT256 sig_n_prime256;
3863
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
3864
 
3865
  // NaN (CASE1)
3866
  // if either number is NAN, the comparison is unordered, 
3867
  // rather than equal : return 0
3868
if (((x.w[1] & MASK_NAN) == MASK_NAN)
3869
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
3870
*pfpsf |= INVALID_EXCEPTION;
3871
{
3872
  res = 1;
3873
  BID_RETURN (res);
3874
}
3875
}
3876
  // SIMPLE (CASE2)
3877
  // if all the bits are the same, these numbers are equal (not Greater).
3878
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
3879
  res = 1;
3880
  BID_RETURN (res);
3881
}
3882
  // INFINITY (CASE3)
3883
if ((x.w[1] & MASK_INF) == MASK_INF) {
3884
  // if x is neg infinity, there is no way it is greater than y, return 1
3885
  if (((x.w[1] & MASK_SIGN) == MASK_SIGN)) {
3886
    res = 1;
3887
    BID_RETURN (res);
3888
  }
3889
  // x is pos infinity, it is greater, unless y is positive infinity => return y!=pos_infinity
3890
  else {
3891
    res = (((y.w[1] & MASK_INF) == MASK_INF)
3892
           && ((y.w[1] & MASK_SIGN) != MASK_SIGN));
3893
    BID_RETURN (res);
3894
  }
3895
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
3896
  // x is finite, so if y is positive infinity, then x is less, return 0
3897
  //                 if y is negative infinity, then x is greater, return 1
3898
  {
3899
    res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3900
    BID_RETURN (res);
3901
  }
3902
}
3903
  // CONVERT X
3904
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
3905
sig_x.w[0] = x.w[0];
3906
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
3907
 
3908
  // CHECK IF X IS CANONICAL
3909
  // 9999999999999999999999999999999999(decimal) = 
3910
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
3911
  // [0, 10^34) is the 754r supported canonical range.  
3912
  //     If the value exceeds that, it is interpreted as 0.
3913
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
3914
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
3915
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
3916
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
3917
  non_canon_x = 1;
3918
else
3919
  non_canon_x = 0;
3920
 
3921
  // CONVERT Y
3922
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
3923
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
3924
sig_y.w[0] = y.w[0];
3925
 
3926
  // CHECK IF Y IS CANONICAL
3927
  // 9999999999999999999999999999999999(decimal) = 
3928
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
3929
  // [0, 10^34) is the 754r supported canonical range.  
3930
  //     If the value exceeds that, it is interpreted as 0.
3931
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
3932
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
3933
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
3934
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
3935
  non_canon_y = 1;
3936
else
3937
  non_canon_y = 0;
3938
 
3939
  // ZERO (CASE4)
3940
  // some properties:
3941
  //    (+ZERO == -ZERO) => therefore ignore the sign
3942
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
3943
  //    ignore the exponent field
3944
  //    (Any non-canonical # is considered 0)
3945
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
3946
  x_is_zero = 1;
3947
}
3948
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
3949
  y_is_zero = 1;
3950
}
3951
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
3952
if (x_is_zero && y_is_zero) {
3953
  res = 1;
3954
  BID_RETURN (res);
3955
}
3956
  // is x is zero, it is greater if Y is negative
3957
else if (x_is_zero) {
3958
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3959
  BID_RETURN (res);
3960
}
3961
  // is y is zero, X is greater if it is positive
3962
else if (y_is_zero) {
3963
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3964
  BID_RETURN (res);
3965
}
3966
  // OPPOSITE SIGN (CASE5)
3967
  // now, if the sign bits differ, x is greater if y is negative
3968
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
3969
  res = ((y.w[1] & MASK_SIGN) != MASK_SIGN);
3970
  BID_RETURN (res);
3971
}
3972
  // REDUNDANT REPRESENTATIONS (CASE6)
3973
  // if exponents are the same, then we have a simple comparison 
3974
  // of the significands
3975
if (exp_y == exp_x) {
3976
  res = (((sig_x.w[1] > sig_y.w[1])
3977
          || (sig_x.w[1] == sig_y.w[1]
3978
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) !=
3979
                                               MASK_SIGN));
3980
  BID_RETURN (res);
3981
}
3982
  // if both components are either bigger or smaller, 
3983
  // it is clear what needs to be done
3984
if ((sig_x.w[1] > sig_y.w[1]
3985
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] > sig_y.w[0]))
3986
    && exp_x >= exp_y) {
3987
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
3988
  BID_RETURN (res);
3989
}
3990
if ((sig_x.w[1] < sig_y.w[1]
3991
     || (sig_x.w[1] == sig_y.w[1] && sig_x.w[0] < sig_y.w[0]))
3992
    && exp_x <= exp_y) {
3993
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
3994
  BID_RETURN (res);
3995
}
3996
 
3997
diff = exp_x - exp_y;
3998
 
3999
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
4000
if (diff > 0) {  // to simplify the loop below,
4001
 
4002
  // if exp_x is 33 greater than exp_y, no need for compensation
4003
  if (diff > 33) {
4004
    res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
4005
    BID_RETURN (res);
4006
  }     // difference cannot be greater than 10^33
4007
 
4008
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
4009
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
4010
 
4011
 
4012
    // if postitive, return whichever significand is larger 
4013
    // (converse if negative)
4014
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
4015
        && sig_n_prime256.w[1] == sig_y.w[1]
4016
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
4017
      res = 1;
4018
      BID_RETURN (res);
4019
    }   // if equal, return 0
4020
    {
4021
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
4022
              || (sig_n_prime256.w[1] > sig_y.w[1])
4023
              || (sig_n_prime256.w[1] == sig_y.w[1]
4024
                  && sig_n_prime256.w[0] >
4025
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
4026
      BID_RETURN (res);
4027
    }
4028
  }
4029
  //else { //128 by 64 bit multiply -> 192 bits
4030
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
4031
 
4032
  // if postitive, return whichever significand is larger 
4033
  // (converse if negative)
4034
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
4035
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
4036
    res = 1;
4037
    BID_RETURN (res);
4038
  }     // if equal, return 0
4039
  {
4040
    res = (((sig_n_prime192.w[2] > 0)
4041
            || (sig_n_prime192.w[1] > sig_y.w[1])
4042
            || (sig_n_prime192.w[1] == sig_y.w[1]
4043
                && sig_n_prime192.w[0] >
4044
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) != MASK_SIGN));
4045
    BID_RETURN (res);
4046
  }
4047
}
4048
 
4049
diff = exp_y - exp_x;
4050
 
4051
  // if exp_x is 33 less than exp_y, no need for compensation
4052
if (diff > 33) {
4053
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
4054
  BID_RETURN (res);
4055
}
4056
 
4057
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
4058
  // adjust the y significand upwards
4059
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
4060
 
4061
  // if postitive, return whichever significand is larger 
4062
  // (converse if negative)
4063
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
4064
      && sig_n_prime256.w[1] == sig_x.w[1]
4065
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
4066
    res = 1;
4067
    BID_RETURN (res);
4068
  }     // if equal, return 0
4069
  {
4070
    res =
4071
      ((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
4072
        || (sig_n_prime256.w[1] > sig_x.w[1]
4073
            || (sig_n_prime256.w[1] == sig_x.w[1]
4074
                && sig_n_prime256.w[0] >
4075
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
4076
    BID_RETURN (res);
4077
  }
4078
}
4079
  //else { //128 by 64 bit multiply -> 192 bits
4080
  // adjust the y significand upwards
4081
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
4082
 
4083
  // if postitive, return whichever significand is larger 
4084
  // (converse if negative)
4085
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
4086
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
4087
  res = 1;
4088
  BID_RETURN (res);
4089
}       // if equal, return 0
4090
{
4091
  res = (sig_n_prime192.w[2] != 0
4092
         || (sig_n_prime192.w[1] > sig_x.w[1]
4093
             || (sig_n_prime192.w[1] == sig_x.w[1]
4094
                 && sig_n_prime192.w[0] >
4095
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
4096
  BID_RETURN (res);
4097
}
4098
}
4099
 
4100
BID128_FUNCTION_ARG2_NORND_CUSTOMRESTYPE (int,
4101
                                          bid128_signaling_not_less, x,
4102
                                          y)
4103
 
4104
     int res;
4105
     int exp_x, exp_y;
4106
     int diff;
4107
     UINT128 sig_x, sig_y;
4108
     UINT192 sig_n_prime192;
4109
     UINT256 sig_n_prime256;
4110
     char x_is_zero = 0, y_is_zero = 0, non_canon_x, non_canon_y;
4111
 
4112
  // NaN (CASE1)
4113
  // if either number is NAN, the comparison is unordered, 
4114
  // rather than equal : return 1
4115
if (((x.w[1] & MASK_NAN) == MASK_NAN)
4116
    || ((y.w[1] & MASK_NAN) == MASK_NAN)) {
4117
*pfpsf |= INVALID_EXCEPTION;
4118
{
4119
  res = 1;
4120
  BID_RETURN (res);
4121
}
4122
}
4123
  // SIMPLE (CASE2)
4124
  // if all the bits are the same, these numbers are equal (not Greater).
4125
if (x.w[0] == y.w[0] && x.w[1] == y.w[1]) {
4126
  res = 1;
4127
  BID_RETURN (res);
4128
}
4129
  // INFINITY (CASE3)
4130
if ((x.w[1] & MASK_INF) == MASK_INF) {
4131
  // if x==neg_inf, { res = (y == neg_inf)?1:0; BID_RETURN (res) }
4132
  if ((x.w[1] & MASK_SIGN) == MASK_SIGN)
4133
    // x is -inf, so it is less than y unless y is -inf
4134
  {
4135
    res = (((y.w[1] & MASK_INF) == MASK_INF)
4136
           && (y.w[1] & MASK_SIGN) == MASK_SIGN);
4137
    BID_RETURN (res);
4138
  } else
4139
    // x is pos_inf, no way for it to be less than y
4140
  {
4141
    res = 1;
4142
    BID_RETURN (res);
4143
  }
4144
} else if ((y.w[1] & MASK_INF) == MASK_INF) {
4145
  // x is finite, so if y is positive infinity, then x is less, return 0
4146
  //                 if y is negative infinity, then x is greater, return 1
4147
  {
4148
    res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
4149
    BID_RETURN (res);
4150
  }
4151
}
4152
  // CONVERT X
4153
sig_x.w[1] = x.w[1] & 0x0001ffffffffffffull;
4154
sig_x.w[0] = x.w[0];
4155
exp_x = (x.w[1] >> 49) & 0x000000000003fffull;
4156
 
4157
  // CHECK IF X IS CANONICAL
4158
  // 9999999999999999999999999999999999(decimal) = 
4159
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
4160
  // [0, 10^34) is the 754r supported canonical range.  
4161
  //     If the value exceeds that, it is interpreted as 0.
4162
if ((sig_x.w[1] > 0x0001ed09bead87c0ull)
4163
    || ((sig_x.w[1] == 0x0001ed09bead87c0ull)
4164
        && (sig_x.w[0] > 0x378d8e63ffffffffull))
4165
    || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
4166
  non_canon_x = 1;
4167
else
4168
  non_canon_x = 0;
4169
 
4170
  // CONVERT Y
4171
exp_y = (y.w[1] >> 49) & 0x0000000000003fffull;
4172
sig_y.w[1] = y.w[1] & 0x0001ffffffffffffull;
4173
sig_y.w[0] = y.w[0];
4174
 
4175
  // CHECK IF Y IS CANONICAL
4176
  // 9999999999999999999999999999999999(decimal) = 
4177
  //   1ed09_bead87c0_378d8e63_ffffffff(hexadecimal)
4178
  // [0, 10^34) is the 754r supported canonical range.  
4179
  //     If the value exceeds that, it is interpreted as 0.
4180
if ((sig_y.w[1] > 0x0001ed09bead87c0ull)
4181
    || ((sig_y.w[1] == 0x0001ed09bead87c0ull)
4182
        && (sig_y.w[0] > 0x378d8e63ffffffffull))
4183
    || ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull))
4184
  non_canon_y = 1;
4185
else
4186
  non_canon_y = 0;
4187
 
4188
  // ZERO (CASE4)
4189
  // some properties:
4190
  //    (+ZERO == -ZERO) => therefore ignore the sign
4191
  //    (ZERO x 10^A == ZERO x 10^B) for any valid A, B => therefore 
4192
  //    ignore the exponent field
4193
  //    (Any non-canonical # is considered 0)
4194
if (non_canon_x || ((sig_x.w[1] == 0) && (sig_x.w[0] == 0))) {
4195
  x_is_zero = 1;
4196
}
4197
if (non_canon_y || ((sig_y.w[1] == 0) && (sig_y.w[0] == 0))) {
4198
  y_is_zero = 1;
4199
}
4200
  // if both numbers are zero, neither is greater => return NOTGREATERTHAN
4201
if (x_is_zero && y_is_zero) {
4202
  res = 1;
4203
  BID_RETURN (res);
4204
}
4205
  // is x is zero, it is greater if Y is negative
4206
else if (x_is_zero) {
4207
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
4208
  BID_RETURN (res);
4209
}
4210
  // is y is zero, X is greater if it is positive
4211
else if (y_is_zero) {
4212
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
4213
  BID_RETURN (res);
4214
}
4215
  // OPPOSITE SIGN (CASE5)
4216
  // now, if the sign bits differ, x is greater if y is negative
4217
if (((x.w[1] ^ y.w[1]) & MASK_SIGN) == MASK_SIGN) {
4218
  res = ((y.w[1] & MASK_SIGN) == MASK_SIGN);
4219
  BID_RETURN (res);
4220
}
4221
  // REDUNDANT REPRESENTATIONS (CASE6)
4222
 
4223
  // if exponents are the same, then we have a simple comparison 
4224
  // of the significands
4225
if (exp_y == exp_x) {
4226
  res = (((sig_x.w[1] > sig_y.w[1])
4227
          || (sig_x.w[1] == sig_y.w[1]
4228
              && sig_x.w[0] >= sig_y.w[0])) ^ ((x.w[1] & MASK_SIGN) ==
4229
                                               MASK_SIGN));
4230
  BID_RETURN (res);
4231
}
4232
  // if both components are either bigger or smaller, 
4233
  // it is clear what needs to be done
4234
if (sig_x.w[1] >= sig_y.w[1] && sig_x.w[0] >= sig_y.w[0]
4235
    && exp_x > exp_y) {
4236
  res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
4237
  BID_RETURN (res);
4238
}
4239
if (sig_x.w[1] <= sig_y.w[1] && sig_x.w[0] <= sig_y.w[0]
4240
    && exp_x < exp_y) {
4241
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
4242
  BID_RETURN (res);
4243
}
4244
 
4245
diff = exp_x - exp_y;
4246
 
4247
  // if |exp_x - exp_y| < 33, it comes down to the compensated significand
4248
if (diff > 0) {  // to simplify the loop below,
4249
 
4250
  // if exp_x is 33 greater than exp_y, no need for compensation
4251
  if (diff > 33) {
4252
    res = ((x.w[1] & MASK_SIGN) != MASK_SIGN);
4253
    BID_RETURN (res);
4254
  }     // difference cannot be greater than 10^33
4255
 
4256
  if (diff > 19) {      //128 by 128 bit multiply -> 256 bits
4257
    __mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
4258
 
4259
 
4260
    // if postitive, return whichever significand is larger 
4261
    // (converse if negative)
4262
    if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
4263
        && sig_n_prime256.w[1] == sig_y.w[1]
4264
        && (sig_n_prime256.w[0] == sig_y.w[0])) {
4265
      res = 1;
4266
      BID_RETURN (res);
4267
    }   // if equal, return 1
4268
    {
4269
      res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
4270
              || (sig_n_prime256.w[1] > sig_y.w[1])
4271
              || (sig_n_prime256.w[1] == sig_y.w[1]
4272
                  && sig_n_prime256.w[0] >
4273
                  sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
4274
      BID_RETURN (res);
4275
    }
4276
  }
4277
  //else { //128 by 64 bit multiply -> 192 bits
4278
  __mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
4279
 
4280
  // if postitive, return whichever significand is larger 
4281
  // (converse if negative)
4282
  if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
4283
      && (sig_n_prime192.w[0] == sig_y.w[0])) {
4284
    res = 1;
4285
    BID_RETURN (res);
4286
  }     // if equal, return 1
4287
  {
4288
    res = (((sig_n_prime192.w[2] > 0)
4289
            || (sig_n_prime192.w[1] > sig_y.w[1])
4290
            || (sig_n_prime192.w[1] == sig_y.w[1]
4291
                && sig_n_prime192.w[0] >
4292
                sig_y.w[0])) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN));
4293
    BID_RETURN (res);
4294
  }
4295
}
4296
 
4297
diff = exp_y - exp_x;
4298
 
4299
  // if exp_x is 33 less than exp_y, no need for compensation
4300
if (diff > 33) {
4301
  res = ((x.w[1] & MASK_SIGN) == MASK_SIGN);
4302
  BID_RETURN (res);
4303
}
4304
 
4305
if (diff > 19) {        //128 by 128 bit multiply -> 256 bits
4306
  // adjust the y significand upwards
4307
  __mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
4308
 
4309
 
4310
  // if postitive, return whichever significand is larger 
4311
  // (converse if negative)
4312
  if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
4313
      && sig_n_prime256.w[1] == sig_x.w[1]
4314
      && (sig_n_prime256.w[0] == sig_x.w[0])) {
4315
    res = 1;
4316
    BID_RETURN (res);
4317
  }     // if equal, return 1
4318
  {
4319
    res =
4320
      ((sig_n_prime256.w[3] == 0 && sig_n_prime256.w[2] == 0
4321
        && (sig_n_prime256.w[1] < sig_x.w[1]
4322
            || (sig_n_prime256.w[1] == sig_x.w[1]
4323
                && sig_n_prime256.w[0] <
4324
                sig_x.w[0]))) ^ ((x.w[1] & MASK_SIGN) == MASK_SIGN));
4325
    BID_RETURN (res);
4326
  }
4327
}
4328
  //else { //128 by 64 bit multiply -> 192 bits
4329
  // adjust the y significand upwards
4330
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
4331
 
4332
  // if postitive, return whichever significand is larger (converse if negative)
4333
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
4334
    && (sig_n_prime192.w[0] == sig_x.w[0])) {
4335
  res = 1;
4336
  BID_RETURN (res);
4337
}       // if equal, return 1
4338
{
4339
  res = (sig_n_prime192.w[2] == 0
4340
         && (sig_n_prime192.w[1] < sig_x.w[1]
4341
             || (sig_n_prime192.w[1] == sig_x.w[1]
4342
                 && sig_n_prime192.w[0] <
4343
                 sig_x.w[0]))) ^ ((y.w[1] & MASK_SIGN) == MASK_SIGN);
4344
  BID_RETURN (res);
4345
}
4346
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.