1 /* $NetBSD: testCases.c,v 1.4 2002/02/21 07:38:16 itojun Exp $ */ 2 3 /* This is a derivative work. */ 4 5 /*- 6 * Copyright (c) 2001 The NetBSD Foundation, Inc. 7 * All rights reserved. 8 * 9 * This code is derived from software contributed to The NetBSD Foundation 10 * by Ross Harvey. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 3. All advertising materials mentioning features or use of this software 21 * must display the following acknowledgement: 22 * This product includes software developed by the NetBSD 23 * Foundation, Inc. and its contributors. 24 * 4. Neither the name of The NetBSD Foundation nor the names of its 25 * contributors may be used to endorse or promote products derived 26 * from this software without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 29 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 30 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 31 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 32 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 33 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 34 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 35 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 36 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 37 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 38 * POSSIBILITY OF SUCH DAMAGE. 39 */ 40 41 /* 42 =============================================================================== 43 44 This C source file is part of TestFloat, Release 2a, a package of programs 45 for testing the correctness of floating-point arithmetic complying to the 46 IEC/IEEE Standard for Floating-Point. 47 48 Written by John R. Hauser. More information is available through the Web 49 page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. 50 51 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort 52 has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT 53 TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO 54 PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY 55 AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. 56 57 Derivative works are acceptable, even for commercial purposes, so long as 58 (1) they include prominent notice that the work is derivative, and (2) they 59 include prominent notice akin to these four paragraphs for those parts of 60 this code that are retained. 61 62 =============================================================================== 63 */ 64 65 #include <stdlib.h> 66 67 #include "milieu.h" 68 #include "fail.h" 69 #include "softfloat.h" 70 #include "testCases.h" 71 #include "random.h" 72 73 typedef struct { 74 int16 expNum, term1Num, term2Num; 75 flag done; 76 } sequenceT; 77 78 enum { 79 int32NumP1 = 124 80 }; 81 82 static const uint32 int32P1[ int32NumP1 ] = { 83 0x00000000, 84 0x00000001, 85 0x00000002, 86 0x00000004, 87 0x00000008, 88 0x00000010, 89 0x00000020, 90 0x00000040, 91 0x00000080, 92 0x00000100, 93 0x00000200, 94 0x00000400, 95 0x00000800, 96 0x00001000, 97 0x00002000, 98 0x00004000, 99 0x00008000, 100 0x00010000, 101 0x00020000, 102 0x00040000, 103 0x00080000, 104 0x00100000, 105 0x00200000, 106 0x00400000, 107 0x00800000, 108 0x01000000, 109 0x02000000, 110 0x04000000, 111 0x08000000, 112 0x10000000, 113 0x20000000, 114 0x40000000, 115 0x80000000, 116 0xC0000000, 117 0xE0000000, 118 0xF0000000, 119 0xF8000000, 120 0xFC000000, 121 0xFE000000, 122 0xFF000000, 123 0xFF800000, 124 0xFFC00000, 125 0xFFE00000, 126 0xFFF00000, 127 0xFFF80000, 128 0xFFFC0000, 129 0xFFFE0000, 130 0xFFFF0000, 131 0xFFFF8000, 132 0xFFFFC000, 133 0xFFFFE000, 134 0xFFFFF000, 135 0xFFFFF800, 136 0xFFFFFC00, 137 0xFFFFFE00, 138 0xFFFFFF00, 139 0xFFFFFF80, 140 0xFFFFFFC0, 141 0xFFFFFFE0, 142 0xFFFFFFF0, 143 0xFFFFFFF8, 144 0xFFFFFFFC, 145 0xFFFFFFFE, 146 0xFFFFFFFF, 147 0xFFFFFFFD, 148 0xFFFFFFFB, 149 0xFFFFFFF7, 150 0xFFFFFFEF, 151 0xFFFFFFDF, 152 0xFFFFFFBF, 153 0xFFFFFF7F, 154 0xFFFFFEFF, 155 0xFFFFFDFF, 156 0xFFFFFBFF, 157 0xFFFFF7FF, 158 0xFFFFEFFF, 159 0xFFFFDFFF, 160 0xFFFFBFFF, 161 0xFFFF7FFF, 162 0xFFFEFFFF, 163 0xFFFDFFFF, 164 0xFFFBFFFF, 165 0xFFF7FFFF, 166 0xFFEFFFFF, 167 0xFFDFFFFF, 168 0xFFBFFFFF, 169 0xFF7FFFFF, 170 0xFEFFFFFF, 171 0xFDFFFFFF, 172 0xFBFFFFFF, 173 0xF7FFFFFF, 174 0xEFFFFFFF, 175 0xDFFFFFFF, 176 0xBFFFFFFF, 177 0x7FFFFFFF, 178 0x3FFFFFFF, 179 0x1FFFFFFF, 180 0x0FFFFFFF, 181 0x07FFFFFF, 182 0x03FFFFFF, 183 0x01FFFFFF, 184 0x00FFFFFF, 185 0x007FFFFF, 186 0x003FFFFF, 187 0x001FFFFF, 188 0x000FFFFF, 189 0x0007FFFF, 190 0x0003FFFF, 191 0x0001FFFF, 192 0x0000FFFF, 193 0x00007FFF, 194 0x00003FFF, 195 0x00001FFF, 196 0x00000FFF, 197 0x000007FF, 198 0x000003FF, 199 0x000001FF, 200 0x000000FF, 201 0x0000007F, 202 0x0000003F, 203 0x0000001F, 204 0x0000000F, 205 0x00000007, 206 0x00000003 207 }; 208 209 static int32 int32NextP1( sequenceT *sequencePtr ) 210 { 211 uint8 termNum; 212 int32 z; 213 214 termNum = sequencePtr->term1Num; 215 z = int32P1[ termNum ]; 216 ++termNum; 217 if ( int32NumP1 <= termNum ) { 218 termNum = 0; 219 sequencePtr->done = TRUE; 220 } 221 sequencePtr->term1Num = termNum; 222 return (sbits32) z; 223 224 } 225 226 static const int32 int32NumP2 = ( int32NumP1 * int32NumP1 + int32NumP1 ) / 2; 227 228 static int32 int32NextP2( sequenceT *sequencePtr ) 229 { 230 uint8 term1Num, term2Num; 231 int32 z; 232 233 term2Num = sequencePtr->term2Num; 234 term1Num = sequencePtr->term1Num; 235 z = int32P1[ term1Num ] + int32P1[ term2Num ]; 236 ++term2Num; 237 if ( int32NumP1 <= term2Num ) { 238 ++term1Num; 239 if ( int32NumP1 <= term1Num ) { 240 term1Num = 0; 241 sequencePtr->done = TRUE; 242 } 243 term2Num = term1Num; 244 sequencePtr->term1Num = term1Num; 245 } 246 sequencePtr->term2Num = term2Num; 247 return (sbits32) z; 248 249 } 250 251 static int32 int32RandomP3( void ) 252 { 253 254 return 255 (sbits32) ( 256 int32P1[ randomUint8() % int32NumP1 ] 257 + int32P1[ randomUint8() % int32NumP1 ] 258 + int32P1[ randomUint8() % int32NumP1 ] 259 ); 260 261 } 262 263 enum { 264 int32NumPInfWeightMasks = 29 265 }; 266 267 static const uint32 int32PInfWeightMasks[ int32NumPInfWeightMasks ] = { 268 0xFFFFFFFF, 269 0x7FFFFFFF, 270 0x3FFFFFFF, 271 0x1FFFFFFF, 272 0x0FFFFFFF, 273 0x07FFFFFF, 274 0x03FFFFFF, 275 0x01FFFFFF, 276 0x00FFFFFF, 277 0x007FFFFF, 278 0x003FFFFF, 279 0x001FFFFF, 280 0x000FFFFF, 281 0x0007FFFF, 282 0x0003FFFF, 283 0x0001FFFF, 284 0x0000FFFF, 285 0x00007FFF, 286 0x00003FFF, 287 0x00001FFF, 288 0x00000FFF, 289 0x000007FF, 290 0x000003FF, 291 0x000001FF, 292 0x000000FF, 293 0x0000007F, 294 0x0000003F, 295 0x0000001F, 296 0x0000000F 297 }; 298 299 static const uint32 int32PInfWeightOffsets[ int32NumPInfWeightMasks ] = { 300 0x00000000, 301 0xC0000000, 302 0xE0000000, 303 0xF0000000, 304 0xF8000000, 305 0xFC000000, 306 0xFE000000, 307 0xFF000000, 308 0xFF800000, 309 0xFFC00000, 310 0xFFE00000, 311 0xFFF00000, 312 0xFFF80000, 313 0xFFFC0000, 314 0xFFFE0000, 315 0xFFFF0000, 316 0xFFFF8000, 317 0xFFFFC000, 318 0xFFFFE000, 319 0xFFFFF000, 320 0xFFFFF800, 321 0xFFFFFC00, 322 0xFFFFFE00, 323 0xFFFFFF00, 324 0xFFFFFF80, 325 0xFFFFFFC0, 326 0xFFFFFFE0, 327 0xFFFFFFF0, 328 0xFFFFFFF8 329 }; 330 331 static int32 int32RandomPInf( void ) 332 { 333 int8 weightMaskNum; 334 335 weightMaskNum = randomUint8() % int32NumPInfWeightMasks; 336 return 337 (sbits32) ( 338 ( randomUint32() & int32PInfWeightMasks[ weightMaskNum ] ) 339 + int32PInfWeightOffsets[ weightMaskNum ] 340 ); 341 342 } 343 344 #ifdef BITS64 345 346 enum { 347 int64NumP1 = 252 348 }; 349 350 static const uint64 int64P1[ int64NumP1 ] = { 351 LIT64( 0x0000000000000000 ), 352 LIT64( 0x0000000000000001 ), 353 LIT64( 0x0000000000000002 ), 354 LIT64( 0x0000000000000004 ), 355 LIT64( 0x0000000000000008 ), 356 LIT64( 0x0000000000000010 ), 357 LIT64( 0x0000000000000020 ), 358 LIT64( 0x0000000000000040 ), 359 LIT64( 0x0000000000000080 ), 360 LIT64( 0x0000000000000100 ), 361 LIT64( 0x0000000000000200 ), 362 LIT64( 0x0000000000000400 ), 363 LIT64( 0x0000000000000800 ), 364 LIT64( 0x0000000000001000 ), 365 LIT64( 0x0000000000002000 ), 366 LIT64( 0x0000000000004000 ), 367 LIT64( 0x0000000000008000 ), 368 LIT64( 0x0000000000010000 ), 369 LIT64( 0x0000000000020000 ), 370 LIT64( 0x0000000000040000 ), 371 LIT64( 0x0000000000080000 ), 372 LIT64( 0x0000000000100000 ), 373 LIT64( 0x0000000000200000 ), 374 LIT64( 0x0000000000400000 ), 375 LIT64( 0x0000000000800000 ), 376 LIT64( 0x0000000001000000 ), 377 LIT64( 0x0000000002000000 ), 378 LIT64( 0x0000000004000000 ), 379 LIT64( 0x0000000008000000 ), 380 LIT64( 0x0000000010000000 ), 381 LIT64( 0x0000000020000000 ), 382 LIT64( 0x0000000040000000 ), 383 LIT64( 0x0000000080000000 ), 384 LIT64( 0x0000000100000000 ), 385 LIT64( 0x0000000200000000 ), 386 LIT64( 0x0000000400000000 ), 387 LIT64( 0x0000000800000000 ), 388 LIT64( 0x0000001000000000 ), 389 LIT64( 0x0000002000000000 ), 390 LIT64( 0x0000004000000000 ), 391 LIT64( 0x0000008000000000 ), 392 LIT64( 0x0000010000000000 ), 393 LIT64( 0x0000020000000000 ), 394 LIT64( 0x0000040000000000 ), 395 LIT64( 0x0000080000000000 ), 396 LIT64( 0x0000100000000000 ), 397 LIT64( 0x0000200000000000 ), 398 LIT64( 0x0000400000000000 ), 399 LIT64( 0x0000800000000000 ), 400 LIT64( 0x0001000000000000 ), 401 LIT64( 0x0002000000000000 ), 402 LIT64( 0x0004000000000000 ), 403 LIT64( 0x0008000000000000 ), 404 LIT64( 0x0010000000000000 ), 405 LIT64( 0x0020000000000000 ), 406 LIT64( 0x0040000000000000 ), 407 LIT64( 0x0080000000000000 ), 408 LIT64( 0x0100000000000000 ), 409 LIT64( 0x0200000000000000 ), 410 LIT64( 0x0400000000000000 ), 411 LIT64( 0x0800000000000000 ), 412 LIT64( 0x1000000000000000 ), 413 LIT64( 0x2000000000000000 ), 414 LIT64( 0x4000000000000000 ), 415 LIT64( 0x8000000000000000 ), 416 LIT64( 0xC000000000000000 ), 417 LIT64( 0xE000000000000000 ), 418 LIT64( 0xF000000000000000 ), 419 LIT64( 0xF800000000000000 ), 420 LIT64( 0xFC00000000000000 ), 421 LIT64( 0xFE00000000000000 ), 422 LIT64( 0xFF00000000000000 ), 423 LIT64( 0xFF80000000000000 ), 424 LIT64( 0xFFC0000000000000 ), 425 LIT64( 0xFFE0000000000000 ), 426 LIT64( 0xFFF0000000000000 ), 427 LIT64( 0xFFF8000000000000 ), 428 LIT64( 0xFFFC000000000000 ), 429 LIT64( 0xFFFE000000000000 ), 430 LIT64( 0xFFFF000000000000 ), 431 LIT64( 0xFFFF800000000000 ), 432 LIT64( 0xFFFFC00000000000 ), 433 LIT64( 0xFFFFE00000000000 ), 434 LIT64( 0xFFFFF00000000000 ), 435 LIT64( 0xFFFFF80000000000 ), 436 LIT64( 0xFFFFFC0000000000 ), 437 LIT64( 0xFFFFFE0000000000 ), 438 LIT64( 0xFFFFFF0000000000 ), 439 LIT64( 0xFFFFFF8000000000 ), 440 LIT64( 0xFFFFFFC000000000 ), 441 LIT64( 0xFFFFFFE000000000 ), 442 LIT64( 0xFFFFFFF000000000 ), 443 LIT64( 0xFFFFFFF800000000 ), 444 LIT64( 0xFFFFFFFC00000000 ), 445 LIT64( 0xFFFFFFFE00000000 ), 446 LIT64( 0xFFFFFFFF00000000 ), 447 LIT64( 0xFFFFFFFF80000000 ), 448 LIT64( 0xFFFFFFFFC0000000 ), 449 LIT64( 0xFFFFFFFFE0000000 ), 450 LIT64( 0xFFFFFFFFF0000000 ), 451 LIT64( 0xFFFFFFFFF8000000 ), 452 LIT64( 0xFFFFFFFFFC000000 ), 453 LIT64( 0xFFFFFFFFFE000000 ), 454 LIT64( 0xFFFFFFFFFF000000 ), 455 LIT64( 0xFFFFFFFFFF800000 ), 456 LIT64( 0xFFFFFFFFFFC00000 ), 457 LIT64( 0xFFFFFFFFFFE00000 ), 458 LIT64( 0xFFFFFFFFFFF00000 ), 459 LIT64( 0xFFFFFFFFFFF80000 ), 460 LIT64( 0xFFFFFFFFFFFC0000 ), 461 LIT64( 0xFFFFFFFFFFFE0000 ), 462 LIT64( 0xFFFFFFFFFFFF0000 ), 463 LIT64( 0xFFFFFFFFFFFF8000 ), 464 LIT64( 0xFFFFFFFFFFFFC000 ), 465 LIT64( 0xFFFFFFFFFFFFE000 ), 466 LIT64( 0xFFFFFFFFFFFFF000 ), 467 LIT64( 0xFFFFFFFFFFFFF800 ), 468 LIT64( 0xFFFFFFFFFFFFFC00 ), 469 LIT64( 0xFFFFFFFFFFFFFE00 ), 470 LIT64( 0xFFFFFFFFFFFFFF00 ), 471 LIT64( 0xFFFFFFFFFFFFFF80 ), 472 LIT64( 0xFFFFFFFFFFFFFFC0 ), 473 LIT64( 0xFFFFFFFFFFFFFFE0 ), 474 LIT64( 0xFFFFFFFFFFFFFFF0 ), 475 LIT64( 0xFFFFFFFFFFFFFFF8 ), 476 LIT64( 0xFFFFFFFFFFFFFFFC ), 477 LIT64( 0xFFFFFFFFFFFFFFFE ), 478 LIT64( 0xFFFFFFFFFFFFFFFF ), 479 LIT64( 0xFFFFFFFFFFFFFFFD ), 480 LIT64( 0xFFFFFFFFFFFFFFFB ), 481 LIT64( 0xFFFFFFFFFFFFFFF7 ), 482 LIT64( 0xFFFFFFFFFFFFFFEF ), 483 LIT64( 0xFFFFFFFFFFFFFFDF ), 484 LIT64( 0xFFFFFFFFFFFFFFBF ), 485 LIT64( 0xFFFFFFFFFFFFFF7F ), 486 LIT64( 0xFFFFFFFFFFFFFEFF ), 487 LIT64( 0xFFFFFFFFFFFFFDFF ), 488 LIT64( 0xFFFFFFFFFFFFFBFF ), 489 LIT64( 0xFFFFFFFFFFFFF7FF ), 490 LIT64( 0xFFFFFFFFFFFFEFFF ), 491 LIT64( 0xFFFFFFFFFFFFDFFF ), 492 LIT64( 0xFFFFFFFFFFFFBFFF ), 493 LIT64( 0xFFFFFFFFFFFF7FFF ), 494 LIT64( 0xFFFFFFFFFFFEFFFF ), 495 LIT64( 0xFFFFFFFFFFFDFFFF ), 496 LIT64( 0xFFFFFFFFFFFBFFFF ), 497 LIT64( 0xFFFFFFFFFFF7FFFF ), 498 LIT64( 0xFFFFFFFFFFEFFFFF ), 499 LIT64( 0xFFFFFFFFFFDFFFFF ), 500 LIT64( 0xFFFFFFFFFFBFFFFF ), 501 LIT64( 0xFFFFFFFFFF7FFFFF ), 502 LIT64( 0xFFFFFFFFFEFFFFFF ), 503 LIT64( 0xFFFFFFFFFDFFFFFF ), 504 LIT64( 0xFFFFFFFFFBFFFFFF ), 505 LIT64( 0xFFFFFFFFF7FFFFFF ), 506 LIT64( 0xFFFFFFFFEFFFFFFF ), 507 LIT64( 0xFFFFFFFFDFFFFFFF ), 508 LIT64( 0xFFFFFFFFBFFFFFFF ), 509 LIT64( 0xFFFFFFFF7FFFFFFF ), 510 LIT64( 0xFFFFFFFEFFFFFFFF ), 511 LIT64( 0xFFFFFFFDFFFFFFFF ), 512 LIT64( 0xFFFFFFFBFFFFFFFF ), 513 LIT64( 0xFFFFFFF7FFFFFFFF ), 514 LIT64( 0xFFFFFFEFFFFFFFFF ), 515 LIT64( 0xFFFFFFDFFFFFFFFF ), 516 LIT64( 0xFFFFFFBFFFFFFFFF ), 517 LIT64( 0xFFFFFF7FFFFFFFFF ), 518 LIT64( 0xFFFFFEFFFFFFFFFF ), 519 LIT64( 0xFFFFFDFFFFFFFFFF ), 520 LIT64( 0xFFFFFBFFFFFFFFFF ), 521 LIT64( 0xFFFFF7FFFFFFFFFF ), 522 LIT64( 0xFFFFEFFFFFFFFFFF ), 523 LIT64( 0xFFFFDFFFFFFFFFFF ), 524 LIT64( 0xFFFFBFFFFFFFFFFF ), 525 LIT64( 0xFFFF7FFFFFFFFFFF ), 526 LIT64( 0xFFFEFFFFFFFFFFFF ), 527 LIT64( 0xFFFDFFFFFFFFFFFF ), 528 LIT64( 0xFFFBFFFFFFFFFFFF ), 529 LIT64( 0xFFF7FFFFFFFFFFFF ), 530 LIT64( 0xFFEFFFFFFFFFFFFF ), 531 LIT64( 0xFFDFFFFFFFFFFFFF ), 532 LIT64( 0xFFBFFFFFFFFFFFFF ), 533 LIT64( 0xFF7FFFFFFFFFFFFF ), 534 LIT64( 0xFEFFFFFFFFFFFFFF ), 535 LIT64( 0xFDFFFFFFFFFFFFFF ), 536 LIT64( 0xFBFFFFFFFFFFFFFF ), 537 LIT64( 0xF7FFFFFFFFFFFFFF ), 538 LIT64( 0xEFFFFFFFFFFFFFFF ), 539 LIT64( 0xDFFFFFFFFFFFFFFF ), 540 LIT64( 0xBFFFFFFFFFFFFFFF ), 541 LIT64( 0x7FFFFFFFFFFFFFFF ), 542 LIT64( 0x3FFFFFFFFFFFFFFF ), 543 LIT64( 0x1FFFFFFFFFFFFFFF ), 544 LIT64( 0x0FFFFFFFFFFFFFFF ), 545 LIT64( 0x07FFFFFFFFFFFFFF ), 546 LIT64( 0x03FFFFFFFFFFFFFF ), 547 LIT64( 0x01FFFFFFFFFFFFFF ), 548 LIT64( 0x00FFFFFFFFFFFFFF ), 549 LIT64( 0x007FFFFFFFFFFFFF ), 550 LIT64( 0x003FFFFFFFFFFFFF ), 551 LIT64( 0x001FFFFFFFFFFFFF ), 552 LIT64( 0x000FFFFFFFFFFFFF ), 553 LIT64( 0x0007FFFFFFFFFFFF ), 554 LIT64( 0x0003FFFFFFFFFFFF ), 555 LIT64( 0x0001FFFFFFFFFFFF ), 556 LIT64( 0x0000FFFFFFFFFFFF ), 557 LIT64( 0x00007FFFFFFFFFFF ), 558 LIT64( 0x00003FFFFFFFFFFF ), 559 LIT64( 0x00001FFFFFFFFFFF ), 560 LIT64( 0x00000FFFFFFFFFFF ), 561 LIT64( 0x000007FFFFFFFFFF ), 562 LIT64( 0x000003FFFFFFFFFF ), 563 LIT64( 0x000001FFFFFFFFFF ), 564 LIT64( 0x000000FFFFFFFFFF ), 565 LIT64( 0x0000007FFFFFFFFF ), 566 LIT64( 0x0000003FFFFFFFFF ), 567 LIT64( 0x0000001FFFFFFFFF ), 568 LIT64( 0x0000000FFFFFFFFF ), 569 LIT64( 0x00000007FFFFFFFF ), 570 LIT64( 0x00000003FFFFFFFF ), 571 LIT64( 0x00000001FFFFFFFF ), 572 LIT64( 0x00000000FFFFFFFF ), 573 LIT64( 0x000000007FFFFFFF ), 574 LIT64( 0x000000003FFFFFFF ), 575 LIT64( 0x000000001FFFFFFF ), 576 LIT64( 0x000000000FFFFFFF ), 577 LIT64( 0x0000000007FFFFFF ), 578 LIT64( 0x0000000003FFFFFF ), 579 LIT64( 0x0000000001FFFFFF ), 580 LIT64( 0x0000000000FFFFFF ), 581 LIT64( 0x00000000007FFFFF ), 582 LIT64( 0x00000000003FFFFF ), 583 LIT64( 0x00000000001FFFFF ), 584 LIT64( 0x00000000000FFFFF ), 585 LIT64( 0x000000000007FFFF ), 586 LIT64( 0x000000000003FFFF ), 587 LIT64( 0x000000000001FFFF ), 588 LIT64( 0x000000000000FFFF ), 589 LIT64( 0x0000000000007FFF ), 590 LIT64( 0x0000000000003FFF ), 591 LIT64( 0x0000000000001FFF ), 592 LIT64( 0x0000000000000FFF ), 593 LIT64( 0x00000000000007FF ), 594 LIT64( 0x00000000000003FF ), 595 LIT64( 0x00000000000001FF ), 596 LIT64( 0x00000000000000FF ), 597 LIT64( 0x000000000000007F ), 598 LIT64( 0x000000000000003F ), 599 LIT64( 0x000000000000001F ), 600 LIT64( 0x000000000000000F ), 601 LIT64( 0x0000000000000007 ), 602 LIT64( 0x0000000000000003 ) 603 }; 604 605 static int64 int64NextP1( sequenceT *sequencePtr ) 606 { 607 uint8 termNum; 608 int64 z; 609 610 termNum = sequencePtr->term1Num; 611 z = int64P1[ termNum ]; 612 ++termNum; 613 if ( int64NumP1 <= termNum ) { 614 termNum = 0; 615 sequencePtr->done = TRUE; 616 } 617 sequencePtr->term1Num = termNum; 618 return (sbits64) z; 619 620 } 621 622 static const int64 int64NumP2 = ( int64NumP1 * int64NumP1 + int64NumP1 ) / 2; 623 624 static int64 int64NextP2( sequenceT *sequencePtr ) 625 { 626 uint8 term1Num, term2Num; 627 int64 z; 628 629 term2Num = sequencePtr->term2Num; 630 term1Num = sequencePtr->term1Num; 631 z = int64P1[ term1Num ] + int64P1[ term2Num ]; 632 ++term2Num; 633 if ( int64NumP1 <= term2Num ) { 634 ++term1Num; 635 if ( int64NumP1 <= term1Num ) { 636 term1Num = 0; 637 sequencePtr->done = TRUE; 638 } 639 term2Num = term1Num; 640 sequencePtr->term1Num = term1Num; 641 } 642 sequencePtr->term2Num = term2Num; 643 return (sbits64) z; 644 645 } 646 647 static int64 int64RandomP3( void ) 648 { 649 650 return 651 (sbits64) ( 652 int64P1[ randomUint8() % int64NumP1 ] 653 + int64P1[ randomUint8() % int64NumP1 ] 654 + int64P1[ randomUint8() % int64NumP1 ] 655 ); 656 657 } 658 659 enum { 660 int64NumPInfWeightMasks = 61 661 }; 662 663 static const uint64 int64PInfWeightMasks[ int64NumPInfWeightMasks ] = { 664 LIT64( 0xFFFFFFFFFFFFFFFF ), 665 LIT64( 0x7FFFFFFFFFFFFFFF ), 666 LIT64( 0x3FFFFFFFFFFFFFFF ), 667 LIT64( 0x1FFFFFFFFFFFFFFF ), 668 LIT64( 0x0FFFFFFFFFFFFFFF ), 669 LIT64( 0x07FFFFFFFFFFFFFF ), 670 LIT64( 0x03FFFFFFFFFFFFFF ), 671 LIT64( 0x01FFFFFFFFFFFFFF ), 672 LIT64( 0x00FFFFFFFFFFFFFF ), 673 LIT64( 0x007FFFFFFFFFFFFF ), 674 LIT64( 0x003FFFFFFFFFFFFF ), 675 LIT64( 0x001FFFFFFFFFFFFF ), 676 LIT64( 0x000FFFFFFFFFFFFF ), 677 LIT64( 0x0007FFFFFFFFFFFF ), 678 LIT64( 0x0003FFFFFFFFFFFF ), 679 LIT64( 0x0001FFFFFFFFFFFF ), 680 LIT64( 0x0000FFFFFFFFFFFF ), 681 LIT64( 0x00007FFFFFFFFFFF ), 682 LIT64( 0x00003FFFFFFFFFFF ), 683 LIT64( 0x00001FFFFFFFFFFF ), 684 LIT64( 0x00000FFFFFFFFFFF ), 685 LIT64( 0x000007FFFFFFFFFF ), 686 LIT64( 0x000003FFFFFFFFFF ), 687 LIT64( 0x000001FFFFFFFFFF ), 688 LIT64( 0x000000FFFFFFFFFF ), 689 LIT64( 0x0000007FFFFFFFFF ), 690 LIT64( 0x0000003FFFFFFFFF ), 691 LIT64( 0x0000001FFFFFFFFF ), 692 LIT64( 0x0000000FFFFFFFFF ), 693 LIT64( 0x00000007FFFFFFFF ), 694 LIT64( 0x00000003FFFFFFFF ), 695 LIT64( 0x00000001FFFFFFFF ), 696 LIT64( 0x00000000FFFFFFFF ), 697 LIT64( 0x000000007FFFFFFF ), 698 LIT64( 0x000000003FFFFFFF ), 699 LIT64( 0x000000001FFFFFFF ), 700 LIT64( 0x000000000FFFFFFF ), 701 LIT64( 0x0000000007FFFFFF ), 702 LIT64( 0x0000000003FFFFFF ), 703 LIT64( 0x0000000001FFFFFF ), 704 LIT64( 0x0000000000FFFFFF ), 705 LIT64( 0x00000000007FFFFF ), 706 LIT64( 0x00000000003FFFFF ), 707 LIT64( 0x00000000001FFFFF ), 708 LIT64( 0x00000000000FFFFF ), 709 LIT64( 0x000000000007FFFF ), 710 LIT64( 0x000000000003FFFF ), 711 LIT64( 0x000000000001FFFF ), 712 LIT64( 0x000000000000FFFF ), 713 LIT64( 0x0000000000007FFF ), 714 LIT64( 0x0000000000003FFF ), 715 LIT64( 0x0000000000001FFF ), 716 LIT64( 0x0000000000000FFF ), 717 LIT64( 0x00000000000007FF ), 718 LIT64( 0x00000000000003FF ), 719 LIT64( 0x00000000000001FF ), 720 LIT64( 0x00000000000000FF ), 721 LIT64( 0x000000000000007F ), 722 LIT64( 0x000000000000003F ), 723 LIT64( 0x000000000000001F ), 724 LIT64( 0x000000000000000F ) 725 }; 726 727 static const uint64 int64PInfWeightOffsets[ int64NumPInfWeightMasks ] = { 728 LIT64( 0x0000000000000000 ), 729 LIT64( 0xC000000000000000 ), 730 LIT64( 0xE000000000000000 ), 731 LIT64( 0xF000000000000000 ), 732 LIT64( 0xF800000000000000 ), 733 LIT64( 0xFC00000000000000 ), 734 LIT64( 0xFE00000000000000 ), 735 LIT64( 0xFF00000000000000 ), 736 LIT64( 0xFF80000000000000 ), 737 LIT64( 0xFFC0000000000000 ), 738 LIT64( 0xFFE0000000000000 ), 739 LIT64( 0xFFF0000000000000 ), 740 LIT64( 0xFFF8000000000000 ), 741 LIT64( 0xFFFC000000000000 ), 742 LIT64( 0xFFFE000000000000 ), 743 LIT64( 0xFFFF000000000000 ), 744 LIT64( 0xFFFF800000000000 ), 745 LIT64( 0xFFFFC00000000000 ), 746 LIT64( 0xFFFFE00000000000 ), 747 LIT64( 0xFFFFF00000000000 ), 748 LIT64( 0xFFFFF80000000000 ), 749 LIT64( 0xFFFFFC0000000000 ), 750 LIT64( 0xFFFFFE0000000000 ), 751 LIT64( 0xFFFFFF0000000000 ), 752 LIT64( 0xFFFFFF8000000000 ), 753 LIT64( 0xFFFFFFC000000000 ), 754 LIT64( 0xFFFFFFE000000000 ), 755 LIT64( 0xFFFFFFF000000000 ), 756 LIT64( 0xFFFFFFF800000000 ), 757 LIT64( 0xFFFFFFFC00000000 ), 758 LIT64( 0xFFFFFFFE00000000 ), 759 LIT64( 0xFFFFFFFF00000000 ), 760 LIT64( 0xFFFFFFFF80000000 ), 761 LIT64( 0xFFFFFFFFC0000000 ), 762 LIT64( 0xFFFFFFFFE0000000 ), 763 LIT64( 0xFFFFFFFFF0000000 ), 764 LIT64( 0xFFFFFFFFF8000000 ), 765 LIT64( 0xFFFFFFFFFC000000 ), 766 LIT64( 0xFFFFFFFFFE000000 ), 767 LIT64( 0xFFFFFFFFFF000000 ), 768 LIT64( 0xFFFFFFFFFF800000 ), 769 LIT64( 0xFFFFFFFFFFC00000 ), 770 LIT64( 0xFFFFFFFFFFE00000 ), 771 LIT64( 0xFFFFFFFFFFF00000 ), 772 LIT64( 0xFFFFFFFFFFF80000 ), 773 LIT64( 0xFFFFFFFFFFFC0000 ), 774 LIT64( 0xFFFFFFFFFFFE0000 ), 775 LIT64( 0xFFFFFFFFFFFF0000 ), 776 LIT64( 0xFFFFFFFFFFFF8000 ), 777 LIT64( 0xFFFFFFFFFFFFC000 ), 778 LIT64( 0xFFFFFFFFFFFFE000 ), 779 LIT64( 0xFFFFFFFFFFFFF000 ), 780 LIT64( 0xFFFFFFFFFFFFF800 ), 781 LIT64( 0xFFFFFFFFFFFFFC00 ), 782 LIT64( 0xFFFFFFFFFFFFFE00 ), 783 LIT64( 0xFFFFFFFFFFFFFF00 ), 784 LIT64( 0xFFFFFFFFFFFFFF80 ), 785 LIT64( 0xFFFFFFFFFFFFFFC0 ), 786 LIT64( 0xFFFFFFFFFFFFFFE0 ), 787 LIT64( 0xFFFFFFFFFFFFFFF0 ), 788 LIT64( 0xFFFFFFFFFFFFFFF8 ) 789 }; 790 791 static int64 int64RandomPInf( void ) 792 { 793 int8 weightMaskNum; 794 795 weightMaskNum = randomUint8() % int64NumPInfWeightMasks; 796 return 797 (sbits64) ( 798 ( randomUint64() & int64PInfWeightMasks[ weightMaskNum ] ) 799 + int64PInfWeightOffsets[ weightMaskNum ] 800 ); 801 802 } 803 804 #endif 805 806 enum { 807 float32NumQIn = 22, 808 float32NumQOut = 50, 809 float32NumP1 = 4, 810 float32NumP2 = 88 811 }; 812 813 static const uint32 float32QIn[ float32NumQIn ] = { 814 0x00000000, /* positive, subnormal */ 815 0x00800000, /* positive, -126 */ 816 0x33800000, /* positive, -24 */ 817 0x3E800000, /* positive, -2 */ 818 0x3F000000, /* positive, -1 */ 819 0x3F800000, /* positive, 0 */ 820 0x40000000, /* positive, 1 */ 821 0x40800000, /* positive, 2 */ 822 0x4B800000, /* positive, 24 */ 823 0x7F000000, /* positive, 127 */ 824 0x7F800000, /* positive, infinity or NaN */ 825 0x80000000, /* negative, subnormal */ 826 0x80800000, /* negative, -126 */ 827 0xB3800000, /* negative, -24 */ 828 0xBE800000, /* negative, -2 */ 829 0xBF000000, /* negative, -1 */ 830 0xBF800000, /* negative, 0 */ 831 0xC0000000, /* negative, 1 */ 832 0xC0800000, /* negative, 2 */ 833 0xCB800000, /* negative, 24 */ 834 0xFE800000, /* negative, 126 */ 835 0xFF800000 /* negative, infinity or NaN */ 836 }; 837 838 static const uint32 float32QOut[ float32NumQOut ] = { 839 0x00000000, /* positive, subnormal */ 840 0x00800000, /* positive, -126 */ 841 0x01000000, /* positive, -125 */ 842 0x33800000, /* positive, -24 */ 843 0x3D800000, /* positive, -4 */ 844 0x3E000000, /* positive, -3 */ 845 0x3E800000, /* positive, -2 */ 846 0x3F000000, /* positive, -1 */ 847 0x3F800000, /* positive, 0 */ 848 0x40000000, /* positive, 1 */ 849 0x40800000, /* positive, 2 */ 850 0x41000000, /* positive, 3 */ 851 0x41800000, /* positive, 4 */ 852 0x4B800000, /* positive, 24 */ 853 0x4E000000, /* positive, 29 */ 854 0x4E800000, /* positive, 30 */ 855 0x4F000000, /* positive, 31 */ 856 0x4F800000, /* positive, 32 */ 857 0x5E000000, /* positive, 61 */ 858 0x5E800000, /* positive, 62 */ 859 0x5F000000, /* positive, 63 */ 860 0x5F800000, /* positive, 64 */ 861 0x7E800000, /* positive, 126 */ 862 0x7F000000, /* positive, 127 */ 863 0x7F800000, /* positive, infinity or NaN */ 864 0x80000000, /* negative, subnormal */ 865 0x80800000, /* negative, -126 */ 866 0x81000000, /* negative, -125 */ 867 0xB3800000, /* negative, -24 */ 868 0xBD800000, /* negative, -4 */ 869 0xBE000000, /* negative, -3 */ 870 0xBE800000, /* negative, -2 */ 871 0xBF000000, /* negative, -1 */ 872 0xBF800000, /* negative, 0 */ 873 0xC0000000, /* negative, 1 */ 874 0xC0800000, /* negative, 2 */ 875 0xC1000000, /* negative, 3 */ 876 0xC1800000, /* negative, 4 */ 877 0xCB800000, /* negative, 24 */ 878 0xCE000000, /* negative, 29 */ 879 0xCE800000, /* negative, 30 */ 880 0xCF000000, /* negative, 31 */ 881 0xCF800000, /* negative, 32 */ 882 0xDE000000, /* negative, 61 */ 883 0xDE800000, /* negative, 62 */ 884 0xDF000000, /* negative, 63 */ 885 0xDF800000, /* negative, 64 */ 886 0xFE800000, /* negative, 126 */ 887 0xFF000000, /* negative, 127 */ 888 0xFF800000 /* negative, infinity or NaN */ 889 }; 890 891 static const uint32 float32P1[ float32NumP1 ] = { 892 0x00000000, 893 0x00000001, 894 0x007FFFFF, 895 0x007FFFFE 896 }; 897 898 static const uint32 float32P2[ float32NumP2 ] = { 899 0x00000000, 900 0x00000001, 901 0x00000002, 902 0x00000004, 903 0x00000008, 904 0x00000010, 905 0x00000020, 906 0x00000040, 907 0x00000080, 908 0x00000100, 909 0x00000200, 910 0x00000400, 911 0x00000800, 912 0x00001000, 913 0x00002000, 914 0x00004000, 915 0x00008000, 916 0x00010000, 917 0x00020000, 918 0x00040000, 919 0x00080000, 920 0x00100000, 921 0x00200000, 922 0x00400000, 923 0x00600000, 924 0x00700000, 925 0x00780000, 926 0x007C0000, 927 0x007E0000, 928 0x007F0000, 929 0x007F8000, 930 0x007FC000, 931 0x007FE000, 932 0x007FF000, 933 0x007FF800, 934 0x007FFC00, 935 0x007FFE00, 936 0x007FFF00, 937 0x007FFF80, 938 0x007FFFC0, 939 0x007FFFE0, 940 0x007FFFF0, 941 0x007FFFF8, 942 0x007FFFFC, 943 0x007FFFFE, 944 0x007FFFFF, 945 0x007FFFFD, 946 0x007FFFFB, 947 0x007FFFF7, 948 0x007FFFEF, 949 0x007FFFDF, 950 0x007FFFBF, 951 0x007FFF7F, 952 0x007FFEFF, 953 0x007FFDFF, 954 0x007FFBFF, 955 0x007FF7FF, 956 0x007FEFFF, 957 0x007FDFFF, 958 0x007FBFFF, 959 0x007F7FFF, 960 0x007EFFFF, 961 0x007DFFFF, 962 0x007BFFFF, 963 0x0077FFFF, 964 0x006FFFFF, 965 0x005FFFFF, 966 0x003FFFFF, 967 0x001FFFFF, 968 0x000FFFFF, 969 0x0007FFFF, 970 0x0003FFFF, 971 0x0001FFFF, 972 0x0000FFFF, 973 0x00007FFF, 974 0x00003FFF, 975 0x00001FFF, 976 0x00000FFF, 977 0x000007FF, 978 0x000003FF, 979 0x000001FF, 980 0x000000FF, 981 0x0000007F, 982 0x0000003F, 983 0x0000001F, 984 0x0000000F, 985 0x00000007, 986 0x00000003 987 }; 988 989 static const uint32 float32NumQInP1 = float32NumQIn * float32NumP1; 990 static const uint32 float32NumQOutP1 = float32NumQOut * float32NumP1; 991 992 static float32 float32NextQInP1( sequenceT *sequencePtr ) 993 { 994 uint8 expNum, sigNum; 995 float32 z; 996 997 sigNum = sequencePtr->term1Num; 998 expNum = sequencePtr->expNum; 999 z = float32QIn[ expNum ] | float32P1[ sigNum ]; 1000 ++sigNum; 1001 if ( float32NumP1 <= sigNum ) { 1002 sigNum = 0; 1003 ++expNum; 1004 if ( float32NumQIn <= expNum ) { 1005 expNum = 0; 1006 sequencePtr->done = TRUE; 1007 } 1008 sequencePtr->expNum = expNum; 1009 } 1010 sequencePtr->term1Num = sigNum; 1011 return z; 1012 1013 } 1014 1015 static float32 float32NextQOutP1( sequenceT *sequencePtr ) 1016 { 1017 uint8 expNum, sigNum; 1018 float32 z; 1019 1020 sigNum = sequencePtr->term1Num; 1021 expNum = sequencePtr->expNum; 1022 z = float32QOut[ expNum ] | float32P1[ sigNum ]; 1023 ++sigNum; 1024 if ( float32NumP1 <= sigNum ) { 1025 sigNum = 0; 1026 ++expNum; 1027 if ( float32NumQOut <= expNum ) { 1028 expNum = 0; 1029 sequencePtr->done = TRUE; 1030 } 1031 sequencePtr->expNum = expNum; 1032 } 1033 sequencePtr->term1Num = sigNum; 1034 return z; 1035 1036 } 1037 1038 static const uint32 float32NumQInP2 = float32NumQIn * float32NumP2; 1039 static const uint32 float32NumQOutP2 = float32NumQOut * float32NumP2; 1040 1041 static float32 float32NextQInP2( sequenceT *sequencePtr ) 1042 { 1043 uint8 expNum, sigNum; 1044 float32 z; 1045 1046 sigNum = sequencePtr->term1Num; 1047 expNum = sequencePtr->expNum; 1048 z = float32QIn[ expNum ] | float32P2[ sigNum ]; 1049 ++sigNum; 1050 if ( float32NumP2 <= sigNum ) { 1051 sigNum = 0; 1052 ++expNum; 1053 if ( float32NumQIn <= expNum ) { 1054 expNum = 0; 1055 sequencePtr->done = TRUE; 1056 } 1057 sequencePtr->expNum = expNum; 1058 } 1059 sequencePtr->term1Num = sigNum; 1060 return z; 1061 1062 } 1063 1064 static float32 float32NextQOutP2( sequenceT *sequencePtr ) 1065 { 1066 uint8 expNum, sigNum; 1067 float32 z; 1068 1069 sigNum = sequencePtr->term1Num; 1070 expNum = sequencePtr->expNum; 1071 z = float32QOut[ expNum ] | float32P2[ sigNum ]; 1072 ++sigNum; 1073 if ( float32NumP2 <= sigNum ) { 1074 sigNum = 0; 1075 ++expNum; 1076 if ( float32NumQOut <= expNum ) { 1077 expNum = 0; 1078 sequencePtr->done = TRUE; 1079 } 1080 sequencePtr->expNum = expNum; 1081 } 1082 sequencePtr->term1Num = sigNum; 1083 return z; 1084 1085 } 1086 1087 static float32 float32RandomQOutP3( void ) 1088 { 1089 1090 return 1091 float32QOut[ randomUint8() % float32NumQOut ] 1092 | ( ( float32P2[ randomUint8() % float32NumP2 ] 1093 + float32P2[ randomUint8() % float32NumP2 ] ) 1094 & 0x007FFFFF ); 1095 1096 } 1097 1098 static float32 float32RandomQOutPInf( void ) 1099 { 1100 1101 return 1102 float32QOut[ randomUint8() % float32NumQOut ] 1103 | ( randomUint32() & 0x007FFFFF ); 1104 1105 } 1106 1107 enum { 1108 float32NumQInfWeightMasks = 7 1109 }; 1110 1111 static const uint32 float32QInfWeightMasks[ float32NumQInfWeightMasks ] = { 1112 0x7F800000, 1113 0x7F800000, 1114 0x3F800000, 1115 0x1F800000, 1116 0x0F800000, 1117 0x07800000, 1118 0x03800000 1119 }; 1120 1121 static const uint32 float32QInfWeightOffsets[ float32NumQInfWeightMasks ] = { 1122 0x00000000, 1123 0x00000000, 1124 0x20000000, 1125 0x30000000, 1126 0x38000000, 1127 0x3C000000, 1128 0x3E000000 1129 }; 1130 1131 static float32 float32RandomQInfP3( void ) 1132 { 1133 int8 weightMaskNum; 1134 1135 weightMaskNum = randomUint8() % float32NumQInfWeightMasks; 1136 return 1137 ( ( (uint32) ( randomUint8() & 1 ) )<<31 ) 1138 | ( ( ( ( (uint32) ( randomUint16() & 0x1FF ) )<<23 ) 1139 & float32QInfWeightMasks[ weightMaskNum ] ) 1140 + float32QInfWeightOffsets[ weightMaskNum ] 1141 ) 1142 | ( ( float32P2[ randomUint8() % float32NumP2 ] 1143 + float32P2[ randomUint8() % float32NumP2 ] ) 1144 & 0x007FFFFF ); 1145 1146 } 1147 1148 static float32 float32RandomQInfPInf( void ) 1149 { 1150 int8 weightMaskNum; 1151 1152 weightMaskNum = randomUint8() % float32NumQInfWeightMasks; 1153 return 1154 ( ( (uint32) ( randomUint8() & 1 ) )<<31 ) 1155 | ( ( ( ( (uint32) ( randomUint16() & 0x1FF ) )<<23 ) 1156 & float32QInfWeightMasks[ weightMaskNum ] ) 1157 + float32QInfWeightOffsets[ weightMaskNum ] 1158 ) 1159 | ( randomUint32() & 0x007FFFFF ); 1160 1161 } 1162 1163 static float32 float32Random( void ) 1164 { 1165 1166 switch ( randomUint8() & 7 ) { 1167 case 0: 1168 case 1: 1169 case 2: 1170 return float32RandomQOutP3(); 1171 case 3: 1172 return float32RandomQOutPInf(); 1173 case 4: 1174 case 5: 1175 case 6: 1176 return float32RandomQInfP3(); 1177 case 7: 1178 return float32RandomQInfPInf(); 1179 } 1180 abort(); 1181 return 0; 1182 } 1183 1184 #ifdef BITS64 1185 #define SETFLOAT64( z, zHigh, zLow ) z = ( ( (float64) zHigh )<<32 ) | zLow 1186 #else 1187 #define SETFLOAT64( z, zHigh, zLow ) z.low = zLow; z.high = zHigh 1188 #endif 1189 1190 enum { 1191 float64NumQIn = 22, 1192 float64NumQOut = 64, 1193 float64NumP1 = 4, 1194 float64NumP2 = 204 1195 }; 1196 1197 static const uint32 float64QIn[ float64NumQIn ] = { 1198 0x00000000, /* positive, subnormal */ 1199 0x00100000, /* positive, -1022 */ 1200 0x3CA00000, /* positive, -53 */ 1201 0x3FD00000, /* positive, -2 */ 1202 0x3FE00000, /* positive, -1 */ 1203 0x3FF00000, /* positive, 0 */ 1204 0x40000000, /* positive, 1 */ 1205 0x40100000, /* positive, 2 */ 1206 0x43400000, /* positive, 53 */ 1207 0x7FE00000, /* positive, 1023 */ 1208 0x7FF00000, /* positive, infinity or NaN */ 1209 0x80000000, /* negative, subnormal */ 1210 0x80100000, /* negative, -1022 */ 1211 0xBCA00000, /* negative, -53 */ 1212 0xBFD00000, /* negative, -2 */ 1213 0xBFE00000, /* negative, -1 */ 1214 0xBFF00000, /* negative, 0 */ 1215 0xC0000000, /* negative, 1 */ 1216 0xC0100000, /* negative, 2 */ 1217 0xC3400000, /* negative, 53 */ 1218 0xFFE00000, /* negative, 1023 */ 1219 0xFFF00000 /* negative, infinity or NaN */ 1220 }; 1221 1222 static const uint32 float64QOut[ float64NumQOut ] = { 1223 0x00000000, /* positive, subnormal */ 1224 0x00100000, /* positive, -1022 */ 1225 0x00200000, /* positive, -1021 */ 1226 0x37E00000, /* positive, -129 */ 1227 0x37F00000, /* positive, -128 */ 1228 0x38000000, /* positive, -127 */ 1229 0x38100000, /* positive, -126 */ 1230 0x3CA00000, /* positive, -53 */ 1231 0x3FB00000, /* positive, -4 */ 1232 0x3FC00000, /* positive, -3 */ 1233 0x3FD00000, /* positive, -2 */ 1234 0x3FE00000, /* positive, -1 */ 1235 0x3FF00000, /* positive, 0 */ 1236 0x40000000, /* positive, 1 */ 1237 0x40100000, /* positive, 2 */ 1238 0x40200000, /* positive, 3 */ 1239 0x40300000, /* positive, 4 */ 1240 0x41C00000, /* positive, 29 */ 1241 0x41D00000, /* positive, 30 */ 1242 0x41E00000, /* positive, 31 */ 1243 0x41F00000, /* positive, 32 */ 1244 0x43400000, /* positive, 53 */ 1245 0x43C00000, /* positive, 61 */ 1246 0x43D00000, /* positive, 62 */ 1247 0x43E00000, /* positive, 63 */ 1248 0x43F00000, /* positive, 64 */ 1249 0x47E00000, /* positive, 127 */ 1250 0x47F00000, /* positive, 128 */ 1251 0x48000000, /* positive, 129 */ 1252 0x7FD00000, /* positive, 1022 */ 1253 0x7FE00000, /* positive, 1023 */ 1254 0x7FF00000, /* positive, infinity or NaN */ 1255 0x80000000, /* negative, subnormal */ 1256 0x80100000, /* negative, -1022 */ 1257 0x80200000, /* negative, -1021 */ 1258 0xB7E00000, /* negative, -129 */ 1259 0xB7F00000, /* negative, -128 */ 1260 0xB8000000, /* negative, -127 */ 1261 0xB8100000, /* negative, -126 */ 1262 0xBCA00000, /* negative, -53 */ 1263 0xBFB00000, /* negative, -4 */ 1264 0xBFC00000, /* negative, -3 */ 1265 0xBFD00000, /* negative, -2 */ 1266 0xBFE00000, /* negative, -1 */ 1267 0xBFF00000, /* negative, 0 */ 1268 0xC0000000, /* negative, 1 */ 1269 0xC0100000, /* negative, 2 */ 1270 0xC0200000, /* negative, 3 */ 1271 0xC0300000, /* negative, 4 */ 1272 0xC1C00000, /* negative, 29 */ 1273 0xC1D00000, /* negative, 30 */ 1274 0xC1E00000, /* negative, 31 */ 1275 0xC1F00000, /* negative, 32 */ 1276 0xC3400000, /* negative, 53 */ 1277 0xC3C00000, /* negative, 61 */ 1278 0xC3D00000, /* negative, 62 */ 1279 0xC3E00000, /* negative, 63 */ 1280 0xC3F00000, /* negative, 64 */ 1281 0xC7E00000, /* negative, 127 */ 1282 0xC7F00000, /* negative, 128 */ 1283 0xC8000000, /* negative, 129 */ 1284 0xFFD00000, /* negative, 1022 */ 1285 0xFFE00000, /* negative, 1023 */ 1286 0xFFF00000 /* negative, infinity or NaN */ 1287 }; 1288 1289 static const struct { bits32 high, low; } float64P1[ float64NumP1 ] = { 1290 { 0x00000000, 0x00000000 }, 1291 { 0x00000000, 0x00000001 }, 1292 { 0x000FFFFF, 0xFFFFFFFF }, 1293 { 0x000FFFFF, 0xFFFFFFFE } 1294 }; 1295 1296 static const struct { bits32 high, low; } float64P2[ float64NumP2 ] = { 1297 { 0x00000000, 0x00000000 }, 1298 { 0x00000000, 0x00000001 }, 1299 { 0x00000000, 0x00000002 }, 1300 { 0x00000000, 0x00000004 }, 1301 { 0x00000000, 0x00000008 }, 1302 { 0x00000000, 0x00000010 }, 1303 { 0x00000000, 0x00000020 }, 1304 { 0x00000000, 0x00000040 }, 1305 { 0x00000000, 0x00000080 }, 1306 { 0x00000000, 0x00000100 }, 1307 { 0x00000000, 0x00000200 }, 1308 { 0x00000000, 0x00000400 }, 1309 { 0x00000000, 0x00000800 }, 1310 { 0x00000000, 0x00001000 }, 1311 { 0x00000000, 0x00002000 }, 1312 { 0x00000000, 0x00004000 }, 1313 { 0x00000000, 0x00008000 }, 1314 { 0x00000000, 0x00010000 }, 1315 { 0x00000000, 0x00020000 }, 1316 { 0x00000000, 0x00040000 }, 1317 { 0x00000000, 0x00080000 }, 1318 { 0x00000000, 0x00100000 }, 1319 { 0x00000000, 0x00200000 }, 1320 { 0x00000000, 0x00400000 }, 1321 { 0x00000000, 0x00800000 }, 1322 { 0x00000000, 0x01000000 }, 1323 { 0x00000000, 0x02000000 }, 1324 { 0x00000000, 0x04000000 }, 1325 { 0x00000000, 0x08000000 }, 1326 { 0x00000000, 0x10000000 }, 1327 { 0x00000000, 0x20000000 }, 1328 { 0x00000000, 0x40000000 }, 1329 { 0x00000000, 0x80000000 }, 1330 { 0x00000001, 0x00000000 }, 1331 { 0x00000002, 0x00000000 }, 1332 { 0x00000004, 0x00000000 }, 1333 { 0x00000008, 0x00000000 }, 1334 { 0x00000010, 0x00000000 }, 1335 { 0x00000020, 0x00000000 }, 1336 { 0x00000040, 0x00000000 }, 1337 { 0x00000080, 0x00000000 }, 1338 { 0x00000100, 0x00000000 }, 1339 { 0x00000200, 0x00000000 }, 1340 { 0x00000400, 0x00000000 }, 1341 { 0x00000800, 0x00000000 }, 1342 { 0x00001000, 0x00000000 }, 1343 { 0x00002000, 0x00000000 }, 1344 { 0x00004000, 0x00000000 }, 1345 { 0x00008000, 0x00000000 }, 1346 { 0x00010000, 0x00000000 }, 1347 { 0x00020000, 0x00000000 }, 1348 { 0x00040000, 0x00000000 }, 1349 { 0x00080000, 0x00000000 }, 1350 { 0x000C0000, 0x00000000 }, 1351 { 0x000E0000, 0x00000000 }, 1352 { 0x000F0000, 0x00000000 }, 1353 { 0x000F8000, 0x00000000 }, 1354 { 0x000FC000, 0x00000000 }, 1355 { 0x000FE000, 0x00000000 }, 1356 { 0x000FF000, 0x00000000 }, 1357 { 0x000FF800, 0x00000000 }, 1358 { 0x000FFC00, 0x00000000 }, 1359 { 0x000FFE00, 0x00000000 }, 1360 { 0x000FFF00, 0x00000000 }, 1361 { 0x000FFF80, 0x00000000 }, 1362 { 0x000FFFC0, 0x00000000 }, 1363 { 0x000FFFE0, 0x00000000 }, 1364 { 0x000FFFF0, 0x00000000 }, 1365 { 0x000FFFF8, 0x00000000 }, 1366 { 0x000FFFFC, 0x00000000 }, 1367 { 0x000FFFFE, 0x00000000 }, 1368 { 0x000FFFFF, 0x00000000 }, 1369 { 0x000FFFFF, 0x80000000 }, 1370 { 0x000FFFFF, 0xC0000000 }, 1371 { 0x000FFFFF, 0xE0000000 }, 1372 { 0x000FFFFF, 0xF0000000 }, 1373 { 0x000FFFFF, 0xF8000000 }, 1374 { 0x000FFFFF, 0xFC000000 }, 1375 { 0x000FFFFF, 0xFE000000 }, 1376 { 0x000FFFFF, 0xFF000000 }, 1377 { 0x000FFFFF, 0xFF800000 }, 1378 { 0x000FFFFF, 0xFFC00000 }, 1379 { 0x000FFFFF, 0xFFE00000 }, 1380 { 0x000FFFFF, 0xFFF00000 }, 1381 { 0x000FFFFF, 0xFFF80000 }, 1382 { 0x000FFFFF, 0xFFFC0000 }, 1383 { 0x000FFFFF, 0xFFFE0000 }, 1384 { 0x000FFFFF, 0xFFFF0000 }, 1385 { 0x000FFFFF, 0xFFFF8000 }, 1386 { 0x000FFFFF, 0xFFFFC000 }, 1387 { 0x000FFFFF, 0xFFFFE000 }, 1388 { 0x000FFFFF, 0xFFFFF000 }, 1389 { 0x000FFFFF, 0xFFFFF800 }, 1390 { 0x000FFFFF, 0xFFFFFC00 }, 1391 { 0x000FFFFF, 0xFFFFFE00 }, 1392 { 0x000FFFFF, 0xFFFFFF00 }, 1393 { 0x000FFFFF, 0xFFFFFF80 }, 1394 { 0x000FFFFF, 0xFFFFFFC0 }, 1395 { 0x000FFFFF, 0xFFFFFFE0 }, 1396 { 0x000FFFFF, 0xFFFFFFF0 }, 1397 { 0x000FFFFF, 0xFFFFFFF8 }, 1398 { 0x000FFFFF, 0xFFFFFFFC }, 1399 { 0x000FFFFF, 0xFFFFFFFE }, 1400 { 0x000FFFFF, 0xFFFFFFFF }, 1401 { 0x000FFFFF, 0xFFFFFFFD }, 1402 { 0x000FFFFF, 0xFFFFFFFB }, 1403 { 0x000FFFFF, 0xFFFFFFF7 }, 1404 { 0x000FFFFF, 0xFFFFFFEF }, 1405 { 0x000FFFFF, 0xFFFFFFDF }, 1406 { 0x000FFFFF, 0xFFFFFFBF }, 1407 { 0x000FFFFF, 0xFFFFFF7F }, 1408 { 0x000FFFFF, 0xFFFFFEFF }, 1409 { 0x000FFFFF, 0xFFFFFDFF }, 1410 { 0x000FFFFF, 0xFFFFFBFF }, 1411 { 0x000FFFFF, 0xFFFFF7FF }, 1412 { 0x000FFFFF, 0xFFFFEFFF }, 1413 { 0x000FFFFF, 0xFFFFDFFF }, 1414 { 0x000FFFFF, 0xFFFFBFFF }, 1415 { 0x000FFFFF, 0xFFFF7FFF }, 1416 { 0x000FFFFF, 0xFFFEFFFF }, 1417 { 0x000FFFFF, 0xFFFDFFFF }, 1418 { 0x000FFFFF, 0xFFFBFFFF }, 1419 { 0x000FFFFF, 0xFFF7FFFF }, 1420 { 0x000FFFFF, 0xFFEFFFFF }, 1421 { 0x000FFFFF, 0xFFDFFFFF }, 1422 { 0x000FFFFF, 0xFFBFFFFF }, 1423 { 0x000FFFFF, 0xFF7FFFFF }, 1424 { 0x000FFFFF, 0xFEFFFFFF }, 1425 { 0x000FFFFF, 0xFDFFFFFF }, 1426 { 0x000FFFFF, 0xFBFFFFFF }, 1427 { 0x000FFFFF, 0xF7FFFFFF }, 1428 { 0x000FFFFF, 0xEFFFFFFF }, 1429 { 0x000FFFFF, 0xDFFFFFFF }, 1430 { 0x000FFFFF, 0xBFFFFFFF }, 1431 { 0x000FFFFF, 0x7FFFFFFF }, 1432 { 0x000FFFFE, 0xFFFFFFFF }, 1433 { 0x000FFFFD, 0xFFFFFFFF }, 1434 { 0x000FFFFB, 0xFFFFFFFF }, 1435 { 0x000FFFF7, 0xFFFFFFFF }, 1436 { 0x000FFFEF, 0xFFFFFFFF }, 1437 { 0x000FFFDF, 0xFFFFFFFF }, 1438 { 0x000FFFBF, 0xFFFFFFFF }, 1439 { 0x000FFF7F, 0xFFFFFFFF }, 1440 { 0x000FFEFF, 0xFFFFFFFF }, 1441 { 0x000FFDFF, 0xFFFFFFFF }, 1442 { 0x000FFBFF, 0xFFFFFFFF }, 1443 { 0x000FF7FF, 0xFFFFFFFF }, 1444 { 0x000FEFFF, 0xFFFFFFFF }, 1445 { 0x000FDFFF, 0xFFFFFFFF }, 1446 { 0x000FBFFF, 0xFFFFFFFF }, 1447 { 0x000F7FFF, 0xFFFFFFFF }, 1448 { 0x000EFFFF, 0xFFFFFFFF }, 1449 { 0x000DFFFF, 0xFFFFFFFF }, 1450 { 0x000BFFFF, 0xFFFFFFFF }, 1451 { 0x0007FFFF, 0xFFFFFFFF }, 1452 { 0x0003FFFF, 0xFFFFFFFF }, 1453 { 0x0001FFFF, 0xFFFFFFFF }, 1454 { 0x0000FFFF, 0xFFFFFFFF }, 1455 { 0x00007FFF, 0xFFFFFFFF }, 1456 { 0x00003FFF, 0xFFFFFFFF }, 1457 { 0x00001FFF, 0xFFFFFFFF }, 1458 { 0x00000FFF, 0xFFFFFFFF }, 1459 { 0x000007FF, 0xFFFFFFFF }, 1460 { 0x000003FF, 0xFFFFFFFF }, 1461 { 0x000001FF, 0xFFFFFFFF }, 1462 { 0x000000FF, 0xFFFFFFFF }, 1463 { 0x0000007F, 0xFFFFFFFF }, 1464 { 0x0000003F, 0xFFFFFFFF }, 1465 { 0x0000001F, 0xFFFFFFFF }, 1466 { 0x0000000F, 0xFFFFFFFF }, 1467 { 0x00000007, 0xFFFFFFFF }, 1468 { 0x00000003, 0xFFFFFFFF }, 1469 { 0x00000001, 0xFFFFFFFF }, 1470 { 0x00000000, 0xFFFFFFFF }, 1471 { 0x00000000, 0x7FFFFFFF }, 1472 { 0x00000000, 0x3FFFFFFF }, 1473 { 0x00000000, 0x1FFFFFFF }, 1474 { 0x00000000, 0x0FFFFFFF }, 1475 { 0x00000000, 0x07FFFFFF }, 1476 { 0x00000000, 0x03FFFFFF }, 1477 { 0x00000000, 0x01FFFFFF }, 1478 { 0x00000000, 0x00FFFFFF }, 1479 { 0x00000000, 0x007FFFFF }, 1480 { 0x00000000, 0x003FFFFF }, 1481 { 0x00000000, 0x001FFFFF }, 1482 { 0x00000000, 0x000FFFFF }, 1483 { 0x00000000, 0x0007FFFF }, 1484 { 0x00000000, 0x0003FFFF }, 1485 { 0x00000000, 0x0001FFFF }, 1486 { 0x00000000, 0x0000FFFF }, 1487 { 0x00000000, 0x00007FFF }, 1488 { 0x00000000, 0x00003FFF }, 1489 { 0x00000000, 0x00001FFF }, 1490 { 0x00000000, 0x00000FFF }, 1491 { 0x00000000, 0x000007FF }, 1492 { 0x00000000, 0x000003FF }, 1493 { 0x00000000, 0x000001FF }, 1494 { 0x00000000, 0x000000FF }, 1495 { 0x00000000, 0x0000007F }, 1496 { 0x00000000, 0x0000003F }, 1497 { 0x00000000, 0x0000001F }, 1498 { 0x00000000, 0x0000000F }, 1499 { 0x00000000, 0x00000007 }, 1500 { 0x00000000, 0x00000003 } 1501 }; 1502 1503 static const uint32 float64NumQInP1 = float64NumQIn * float64NumP1; 1504 static const uint32 float64NumQOutP1 = float64NumQOut * float64NumP1; 1505 1506 static float64 float64NextQInP1( sequenceT *sequencePtr ) 1507 { 1508 uint8 expNum, sigNum; 1509 float64 z; 1510 1511 sigNum = sequencePtr->term1Num; 1512 expNum = sequencePtr->expNum; 1513 SETFLOAT64( 1514 z, 1515 float64QIn[ expNum ] | float64P1[ sigNum ].high, 1516 float64P1[ sigNum ].low 1517 ); 1518 ++sigNum; 1519 if ( float64NumP1 <= sigNum ) { 1520 sigNum = 0; 1521 ++expNum; 1522 if ( float64NumQIn <= expNum ) { 1523 expNum = 0; 1524 sequencePtr->done = TRUE; 1525 } 1526 sequencePtr->expNum = expNum; 1527 } 1528 sequencePtr->term1Num = sigNum; 1529 return z; 1530 1531 } 1532 1533 static float64 float64NextQOutP1( sequenceT *sequencePtr ) 1534 { 1535 uint8 expNum, sigNum; 1536 float64 z; 1537 1538 sigNum = sequencePtr->term1Num; 1539 expNum = sequencePtr->expNum; 1540 SETFLOAT64( 1541 z, 1542 float64QOut[ expNum ] | float64P1[ sigNum ].high, 1543 float64P1[ sigNum ].low 1544 ); 1545 ++sigNum; 1546 if ( float64NumP1 <= sigNum ) { 1547 sigNum = 0; 1548 ++expNum; 1549 if ( float64NumQOut <= expNum ) { 1550 expNum = 0; 1551 sequencePtr->done = TRUE; 1552 } 1553 sequencePtr->expNum = expNum; 1554 } 1555 sequencePtr->term1Num = sigNum; 1556 return z; 1557 1558 } 1559 1560 static const uint32 float64NumQInP2 = float64NumQIn * float64NumP2; 1561 static const uint32 float64NumQOutP2 = float64NumQOut * float64NumP2; 1562 1563 static float64 float64NextQInP2( sequenceT *sequencePtr ) 1564 { 1565 uint8 expNum, sigNum; 1566 float64 z; 1567 1568 sigNum = sequencePtr->term1Num; 1569 expNum = sequencePtr->expNum; 1570 SETFLOAT64( 1571 z, 1572 float64QIn[ expNum ] | float64P2[ sigNum ].high, 1573 float64P2[ sigNum ].low 1574 ); 1575 ++sigNum; 1576 if ( float64NumP2 <= sigNum ) { 1577 sigNum = 0; 1578 ++expNum; 1579 if ( float64NumQIn <= expNum ) { 1580 expNum = 0; 1581 sequencePtr->done = TRUE; 1582 } 1583 sequencePtr->expNum = expNum; 1584 } 1585 sequencePtr->term1Num = sigNum; 1586 return z; 1587 1588 } 1589 1590 static float64 float64NextQOutP2( sequenceT *sequencePtr ) 1591 { 1592 uint8 expNum, sigNum; 1593 float64 z; 1594 1595 sigNum = sequencePtr->term1Num; 1596 expNum = sequencePtr->expNum; 1597 SETFLOAT64( 1598 z, 1599 float64QOut[ expNum ] | float64P2[ sigNum ].high, 1600 float64P2[ sigNum ].low 1601 ); 1602 ++sigNum; 1603 if ( float64NumP2 <= sigNum ) { 1604 sigNum = 0; 1605 ++expNum; 1606 if ( float64NumQOut <= expNum ) { 1607 expNum = 0; 1608 sequencePtr->done = TRUE; 1609 } 1610 sequencePtr->expNum = expNum; 1611 } 1612 sequencePtr->term1Num = sigNum; 1613 return z; 1614 1615 } 1616 1617 static float64 float64RandomQOutP3( void ) 1618 { 1619 int8 sigNum1, sigNum2; 1620 uint32 sig1Low, sig2Low, zLow; 1621 float64 z; 1622 1623 sigNum1 = randomUint8() % float64NumP2; 1624 sigNum2 = randomUint8() % float64NumP2; 1625 sig1Low = float64P2[ sigNum1 ].low; 1626 sig2Low = float64P2[ sigNum2 ].low; 1627 zLow = sig1Low + sig2Low; 1628 SETFLOAT64( 1629 z, 1630 float64QOut[ randomUint8() % float64NumQOut ] 1631 | ( ( float64P2[ sigNum1 ].high 1632 + float64P2[ sigNum2 ].high 1633 + ( zLow < sig1Low ) 1634 ) 1635 & 0x000FFFFF 1636 ), 1637 zLow 1638 ); 1639 return z; 1640 1641 } 1642 1643 static float64 float64RandomQOutPInf( void ) 1644 { 1645 float64 z; 1646 1647 SETFLOAT64( 1648 z, 1649 float64QOut[ randomUint8() % float64NumQOut ] 1650 | ( randomUint32() & 0x000FFFFF ), 1651 randomUint32() 1652 ); 1653 return z; 1654 1655 } 1656 1657 enum { 1658 float64NumQInfWeightMasks = 10 1659 }; 1660 1661 static const uint32 float64QInfWeightMasks[ float64NumQInfWeightMasks ] = { 1662 0x7FF00000, 1663 0x7FF00000, 1664 0x3FF00000, 1665 0x1FF00000, 1666 0x0FF00000, 1667 0x07F00000, 1668 0x03F00000, 1669 0x01F00000, 1670 0x00F00000, 1671 0x00700000 1672 }; 1673 1674 static const uint32 float64QInfWeightOffsets[ float64NumQInfWeightMasks ] = { 1675 0x00000000, 1676 0x00000000, 1677 0x20000000, 1678 0x30000000, 1679 0x38000000, 1680 0x3C000000, 1681 0x3E000000, 1682 0x3F000000, 1683 0x3F800000, 1684 0x3FC00000 1685 }; 1686 1687 static float64 float64RandomQInfP3( void ) 1688 { 1689 int8 sigNum1, sigNum2; 1690 uint32 sig1Low, sig2Low, zLow; 1691 int8 weightMaskNum; 1692 float64 z; 1693 1694 sigNum1 = randomUint8() % float64NumP2; 1695 sigNum2 = randomUint8() % float64NumP2; 1696 sig1Low = float64P2[ sigNum1 ].low; 1697 sig2Low = float64P2[ sigNum2 ].low; 1698 zLow = sig1Low + sig2Low; 1699 weightMaskNum = randomUint8() % float64NumQInfWeightMasks; 1700 SETFLOAT64( 1701 z, 1702 ( ( (uint32) ( randomUint8() & 1 ) )<<31 ) 1703 | ( ( ( ( (uint32) ( randomUint16() & 0xFFF ) )<<20 ) 1704 & float64QInfWeightMasks[ weightMaskNum ] ) 1705 + float64QInfWeightOffsets[ weightMaskNum ] 1706 ) 1707 | ( ( float64P2[ sigNum1 ].high 1708 + float64P2[ sigNum2 ].high 1709 + ( zLow < sig1Low ) 1710 ) 1711 & 0x000FFFFF 1712 ), 1713 zLow 1714 ); 1715 return z; 1716 1717 } 1718 1719 static float64 float64RandomQInfPInf( void ) 1720 { 1721 int8 weightMaskNum; 1722 float64 z; 1723 1724 weightMaskNum = randomUint8() % float64NumQInfWeightMasks; 1725 SETFLOAT64( 1726 z, 1727 ( ( (uint32) ( randomUint8() & 1 ) )<<31 ) 1728 | ( ( ( ( (uint32) ( randomUint16() & 0xFFF ) )<<20 ) 1729 & float64QInfWeightMasks[ weightMaskNum ] ) 1730 + float64QInfWeightOffsets[ weightMaskNum ] 1731 ) 1732 | ( randomUint32() & 0x000FFFFF ), 1733 randomUint32() 1734 ); 1735 return z; 1736 1737 } 1738 1739 static float64 float64Random( void ) 1740 { 1741 1742 switch ( randomUint8() & 7 ) { 1743 case 0: 1744 case 1: 1745 case 2: 1746 return float64RandomQOutP3(); 1747 case 3: 1748 return float64RandomQOutPInf(); 1749 case 4: 1750 case 5: 1751 case 6: 1752 return float64RandomQInfP3(); 1753 case 7: 1754 return float64RandomQInfPInf(); 1755 } 1756 abort(); 1757 return 0; 1758 } 1759 1760 #ifdef FLOATX80 1761 1762 enum { 1763 floatx80NumQIn = 22, 1764 floatx80NumQOut = 76, 1765 floatx80NumP1 = 4, 1766 floatx80NumP2 = 248 1767 }; 1768 1769 static const uint16 floatx80QIn[ floatx80NumQIn ] = { 1770 0x0000, /* positive, subnormal */ 1771 0x0001, /* positive, -16382 */ 1772 0x3FBF, /* positive, -64 */ 1773 0x3FFD, /* positive, -2 */ 1774 0x3FFE, /* positive, -1 */ 1775 0x3FFF, /* positive, 0 */ 1776 0x4000, /* positive, 1 */ 1777 0x4001, /* positive, 2 */ 1778 0x403F, /* positive, 64 */ 1779 0x7FFE, /* positive, 16383 */ 1780 0x7FFF, /* positive, infinity or NaN */ 1781 0x8000, /* negative, subnormal */ 1782 0x8001, /* negative, -16382 */ 1783 0xBFBF, /* negative, -64 */ 1784 0xBFFD, /* negative, -2 */ 1785 0xBFFE, /* negative, -1 */ 1786 0xBFFF, /* negative, 0 */ 1787 0xC000, /* negative, 1 */ 1788 0xC001, /* negative, 2 */ 1789 0xC03F, /* negative, 64 */ 1790 0xFFFE, /* negative, 16383 */ 1791 0xFFFF /* negative, infinity or NaN */ 1792 }; 1793 1794 static const uint16 floatx80QOut[ floatx80NumQOut ] = { 1795 0x0000, /* positive, subnormal */ 1796 0x0001, /* positive, -16382 */ 1797 0x0002, /* positive, -16381 */ 1798 0x3BFE, /* positive, -1025 */ 1799 0x3BFF, /* positive, -1024 */ 1800 0x3C00, /* positive, -1023 */ 1801 0x3C01, /* positive, -1022 */ 1802 0x3F7E, /* positive, -129 */ 1803 0x3F7F, /* positive, -128 */ 1804 0x3F80, /* positive, -127 */ 1805 0x3F81, /* positive, -126 */ 1806 0x3FBF, /* positive, -64 */ 1807 0x3FFB, /* positive, -4 */ 1808 0x3FFC, /* positive, -3 */ 1809 0x3FFD, /* positive, -2 */ 1810 0x3FFE, /* positive, -1 */ 1811 0x3FFF, /* positive, 0 */ 1812 0x4000, /* positive, 1 */ 1813 0x4001, /* positive, 2 */ 1814 0x4002, /* positive, 3 */ 1815 0x4003, /* positive, 4 */ 1816 0x401C, /* positive, 29 */ 1817 0x401D, /* positive, 30 */ 1818 0x401E, /* positive, 31 */ 1819 0x401F, /* positive, 32 */ 1820 0x403C, /* positive, 61 */ 1821 0x403D, /* positive, 62 */ 1822 0x403E, /* positive, 63 */ 1823 0x403F, /* positive, 64 */ 1824 0x407E, /* positive, 127 */ 1825 0x407F, /* positive, 128 */ 1826 0x4080, /* positive, 129 */ 1827 0x43FE, /* positive, 1023 */ 1828 0x43FF, /* positive, 1024 */ 1829 0x4400, /* positive, 1025 */ 1830 0x7FFD, /* positive, 16382 */ 1831 0x7FFE, /* positive, 16383 */ 1832 0x7FFF, /* positive, infinity or NaN */ 1833 0x8000, /* negative, subnormal */ 1834 0x8001, /* negative, -16382 */ 1835 0x8002, /* negative, -16381 */ 1836 0xBBFE, /* negative, -1025 */ 1837 0xBBFF, /* negative, -1024 */ 1838 0xBC00, /* negative, -1023 */ 1839 0xBC01, /* negative, -1022 */ 1840 0xBF7E, /* negative, -129 */ 1841 0xBF7F, /* negative, -128 */ 1842 0xBF80, /* negative, -127 */ 1843 0xBF81, /* negative, -126 */ 1844 0xBFBF, /* negative, -64 */ 1845 0xBFFB, /* negative, -4 */ 1846 0xBFFC, /* negative, -3 */ 1847 0xBFFD, /* negative, -2 */ 1848 0xBFFE, /* negative, -1 */ 1849 0xBFFF, /* negative, 0 */ 1850 0xC000, /* negative, 1 */ 1851 0xC001, /* negative, 2 */ 1852 0xC002, /* negative, 3 */ 1853 0xC003, /* negative, 4 */ 1854 0xC01C, /* negative, 29 */ 1855 0xC01D, /* negative, 30 */ 1856 0xC01E, /* negative, 31 */ 1857 0xC01F, /* negative, 32 */ 1858 0xC03C, /* negative, 61 */ 1859 0xC03D, /* negative, 62 */ 1860 0xC03E, /* negative, 63 */ 1861 0xC03F, /* negative, 64 */ 1862 0xC07E, /* negative, 127 */ 1863 0xC07F, /* negative, 128 */ 1864 0xC080, /* negative, 129 */ 1865 0xC3FE, /* negative, 1023 */ 1866 0xC3FF, /* negative, 1024 */ 1867 0xC400, /* negative, 1025 */ 1868 0xFFFD, /* negative, 16382 */ 1869 0xFFFE, /* negative, 16383 */ 1870 0xFFFF /* negative, infinity or NaN */ 1871 }; 1872 1873 static const bits64 floatx80P1[ floatx80NumP1 ] = { 1874 LIT64( 0x0000000000000000 ), 1875 LIT64( 0x0000000000000001 ), 1876 LIT64( 0x7FFFFFFFFFFFFFFF ), 1877 LIT64( 0x7FFFFFFFFFFFFFFE ) 1878 }; 1879 1880 static const bits64 floatx80P2[ floatx80NumP2 ] = { 1881 LIT64( 0x0000000000000000 ), 1882 LIT64( 0x0000000000000001 ), 1883 LIT64( 0x0000000000000002 ), 1884 LIT64( 0x0000000000000004 ), 1885 LIT64( 0x0000000000000008 ), 1886 LIT64( 0x0000000000000010 ), 1887 LIT64( 0x0000000000000020 ), 1888 LIT64( 0x0000000000000040 ), 1889 LIT64( 0x0000000000000080 ), 1890 LIT64( 0x0000000000000100 ), 1891 LIT64( 0x0000000000000200 ), 1892 LIT64( 0x0000000000000400 ), 1893 LIT64( 0x0000000000000800 ), 1894 LIT64( 0x0000000000001000 ), 1895 LIT64( 0x0000000000002000 ), 1896 LIT64( 0x0000000000004000 ), 1897 LIT64( 0x0000000000008000 ), 1898 LIT64( 0x0000000000010000 ), 1899 LIT64( 0x0000000000020000 ), 1900 LIT64( 0x0000000000040000 ), 1901 LIT64( 0x0000000000080000 ), 1902 LIT64( 0x0000000000100000 ), 1903 LIT64( 0x0000000000200000 ), 1904 LIT64( 0x0000000000400000 ), 1905 LIT64( 0x0000000000800000 ), 1906 LIT64( 0x0000000001000000 ), 1907 LIT64( 0x0000000002000000 ), 1908 LIT64( 0x0000000004000000 ), 1909 LIT64( 0x0000000008000000 ), 1910 LIT64( 0x0000000010000000 ), 1911 LIT64( 0x0000000020000000 ), 1912 LIT64( 0x0000000040000000 ), 1913 LIT64( 0x0000000080000000 ), 1914 LIT64( 0x0000000100000000 ), 1915 LIT64( 0x0000000200000000 ), 1916 LIT64( 0x0000000400000000 ), 1917 LIT64( 0x0000000800000000 ), 1918 LIT64( 0x0000001000000000 ), 1919 LIT64( 0x0000002000000000 ), 1920 LIT64( 0x0000004000000000 ), 1921 LIT64( 0x0000008000000000 ), 1922 LIT64( 0x0000010000000000 ), 1923 LIT64( 0x0000020000000000 ), 1924 LIT64( 0x0000040000000000 ), 1925 LIT64( 0x0000080000000000 ), 1926 LIT64( 0x0000100000000000 ), 1927 LIT64( 0x0000200000000000 ), 1928 LIT64( 0x0000400000000000 ), 1929 LIT64( 0x0000800000000000 ), 1930 LIT64( 0x0001000000000000 ), 1931 LIT64( 0x0002000000000000 ), 1932 LIT64( 0x0004000000000000 ), 1933 LIT64( 0x0008000000000000 ), 1934 LIT64( 0x0010000000000000 ), 1935 LIT64( 0x0020000000000000 ), 1936 LIT64( 0x0040000000000000 ), 1937 LIT64( 0x0080000000000000 ), 1938 LIT64( 0x0100000000000000 ), 1939 LIT64( 0x0200000000000000 ), 1940 LIT64( 0x0400000000000000 ), 1941 LIT64( 0x0800000000000000 ), 1942 LIT64( 0x1000000000000000 ), 1943 LIT64( 0x2000000000000000 ), 1944 LIT64( 0x4000000000000000 ), 1945 LIT64( 0x6000000000000000 ), 1946 LIT64( 0x7000000000000000 ), 1947 LIT64( 0x7800000000000000 ), 1948 LIT64( 0x7C00000000000000 ), 1949 LIT64( 0x7E00000000000000 ), 1950 LIT64( 0x7F00000000000000 ), 1951 LIT64( 0x7F80000000000000 ), 1952 LIT64( 0x7FC0000000000000 ), 1953 LIT64( 0x7FE0000000000000 ), 1954 LIT64( 0x7FF0000000000000 ), 1955 LIT64( 0x7FF8000000000000 ), 1956 LIT64( 0x7FFC000000000000 ), 1957 LIT64( 0x7FFE000000000000 ), 1958 LIT64( 0x7FFF000000000000 ), 1959 LIT64( 0x7FFF800000000000 ), 1960 LIT64( 0x7FFFC00000000000 ), 1961 LIT64( 0x7FFFE00000000000 ), 1962 LIT64( 0x7FFFF00000000000 ), 1963 LIT64( 0x7FFFF80000000000 ), 1964 LIT64( 0x7FFFFC0000000000 ), 1965 LIT64( 0x7FFFFE0000000000 ), 1966 LIT64( 0x7FFFFF0000000000 ), 1967 LIT64( 0x7FFFFF8000000000 ), 1968 LIT64( 0x7FFFFFC000000000 ), 1969 LIT64( 0x7FFFFFE000000000 ), 1970 LIT64( 0x7FFFFFF000000000 ), 1971 LIT64( 0x7FFFFFF800000000 ), 1972 LIT64( 0x7FFFFFFC00000000 ), 1973 LIT64( 0x7FFFFFFE00000000 ), 1974 LIT64( 0x7FFFFFFF00000000 ), 1975 LIT64( 0x7FFFFFFF80000000 ), 1976 LIT64( 0x7FFFFFFFC0000000 ), 1977 LIT64( 0x7FFFFFFFE0000000 ), 1978 LIT64( 0x7FFFFFFFF0000000 ), 1979 LIT64( 0x7FFFFFFFF8000000 ), 1980 LIT64( 0x7FFFFFFFFC000000 ), 1981 LIT64( 0x7FFFFFFFFE000000 ), 1982 LIT64( 0x7FFFFFFFFF000000 ), 1983 LIT64( 0x7FFFFFFFFF800000 ), 1984 LIT64( 0x7FFFFFFFFFC00000 ), 1985 LIT64( 0x7FFFFFFFFFE00000 ), 1986 LIT64( 0x7FFFFFFFFFF00000 ), 1987 LIT64( 0x7FFFFFFFFFF80000 ), 1988 LIT64( 0x7FFFFFFFFFFC0000 ), 1989 LIT64( 0x7FFFFFFFFFFE0000 ), 1990 LIT64( 0x7FFFFFFFFFFF0000 ), 1991 LIT64( 0x7FFFFFFFFFFF8000 ), 1992 LIT64( 0x7FFFFFFFFFFFC000 ), 1993 LIT64( 0x7FFFFFFFFFFFE000 ), 1994 LIT64( 0x7FFFFFFFFFFFF000 ), 1995 LIT64( 0x7FFFFFFFFFFFF800 ), 1996 LIT64( 0x7FFFFFFFFFFFFC00 ), 1997 LIT64( 0x7FFFFFFFFFFFFE00 ), 1998 LIT64( 0x7FFFFFFFFFFFFF00 ), 1999 LIT64( 0x7FFFFFFFFFFFFF80 ), 2000 LIT64( 0x7FFFFFFFFFFFFFC0 ), 2001 LIT64( 0x7FFFFFFFFFFFFFE0 ), 2002 LIT64( 0x7FFFFFFFFFFFFFF0 ), 2003 LIT64( 0x7FFFFFFFFFFFFFF8 ), 2004 LIT64( 0x7FFFFFFFFFFFFFFC ), 2005 LIT64( 0x7FFFFFFFFFFFFFFE ), 2006 LIT64( 0x7FFFFFFFFFFFFFFF ), 2007 LIT64( 0x7FFFFFFFFFFFFFFD ), 2008 LIT64( 0x7FFFFFFFFFFFFFFB ), 2009 LIT64( 0x7FFFFFFFFFFFFFF7 ), 2010 LIT64( 0x7FFFFFFFFFFFFFEF ), 2011 LIT64( 0x7FFFFFFFFFFFFFDF ), 2012 LIT64( 0x7FFFFFFFFFFFFFBF ), 2013 LIT64( 0x7FFFFFFFFFFFFF7F ), 2014 LIT64( 0x7FFFFFFFFFFFFEFF ), 2015 LIT64( 0x7FFFFFFFFFFFFDFF ), 2016 LIT64( 0x7FFFFFFFFFFFFBFF ), 2017 LIT64( 0x7FFFFFFFFFFFF7FF ), 2018 LIT64( 0x7FFFFFFFFFFFEFFF ), 2019 LIT64( 0x7FFFFFFFFFFFDFFF ), 2020 LIT64( 0x7FFFFFFFFFFFBFFF ), 2021 LIT64( 0x7FFFFFFFFFFF7FFF ), 2022 LIT64( 0x7FFFFFFFFFFEFFFF ), 2023 LIT64( 0x7FFFFFFFFFFDFFFF ), 2024 LIT64( 0x7FFFFFFFFFFBFFFF ), 2025 LIT64( 0x7FFFFFFFFFF7FFFF ), 2026 LIT64( 0x7FFFFFFFFFEFFFFF ), 2027 LIT64( 0x7FFFFFFFFFDFFFFF ), 2028 LIT64( 0x7FFFFFFFFFBFFFFF ), 2029 LIT64( 0x7FFFFFFFFF7FFFFF ), 2030 LIT64( 0x7FFFFFFFFEFFFFFF ), 2031 LIT64( 0x7FFFFFFFFDFFFFFF ), 2032 LIT64( 0x7FFFFFFFFBFFFFFF ), 2033 LIT64( 0x7FFFFFFFF7FFFFFF ), 2034 LIT64( 0x7FFFFFFFEFFFFFFF ), 2035 LIT64( 0x7FFFFFFFDFFFFFFF ), 2036 LIT64( 0x7FFFFFFFBFFFFFFF ), 2037 LIT64( 0x7FFFFFFF7FFFFFFF ), 2038 LIT64( 0x7FFFFFFEFFFFFFFF ), 2039 LIT64( 0x7FFFFFFDFFFFFFFF ), 2040 LIT64( 0x7FFFFFFBFFFFFFFF ), 2041 LIT64( 0x7FFFFFF7FFFFFFFF ), 2042 LIT64( 0x7FFFFFEFFFFFFFFF ), 2043 LIT64( 0x7FFFFFDFFFFFFFFF ), 2044 LIT64( 0x7FFFFFBFFFFFFFFF ), 2045 LIT64( 0x7FFFFF7FFFFFFFFF ), 2046 LIT64( 0x7FFFFEFFFFFFFFFF ), 2047 LIT64( 0x7FFFFDFFFFFFFFFF ), 2048 LIT64( 0x7FFFFBFFFFFFFFFF ), 2049 LIT64( 0x7FFFF7FFFFFFFFFF ), 2050 LIT64( 0x7FFFEFFFFFFFFFFF ), 2051 LIT64( 0x7FFFDFFFFFFFFFFF ), 2052 LIT64( 0x7FFFBFFFFFFFFFFF ), 2053 LIT64( 0x7FFF7FFFFFFFFFFF ), 2054 LIT64( 0x7FFEFFFFFFFFFFFF ), 2055 LIT64( 0x7FFDFFFFFFFFFFFF ), 2056 LIT64( 0x7FFBFFFFFFFFFFFF ), 2057 LIT64( 0x7FF7FFFFFFFFFFFF ), 2058 LIT64( 0x7FEFFFFFFFFFFFFF ), 2059 LIT64( 0x7FDFFFFFFFFFFFFF ), 2060 LIT64( 0x7FBFFFFFFFFFFFFF ), 2061 LIT64( 0x7F7FFFFFFFFFFFFF ), 2062 LIT64( 0x7EFFFFFFFFFFFFFF ), 2063 LIT64( 0x7DFFFFFFFFFFFFFF ), 2064 LIT64( 0x7BFFFFFFFFFFFFFF ), 2065 LIT64( 0x77FFFFFFFFFFFFFF ), 2066 LIT64( 0x6FFFFFFFFFFFFFFF ), 2067 LIT64( 0x5FFFFFFFFFFFFFFF ), 2068 LIT64( 0x3FFFFFFFFFFFFFFF ), 2069 LIT64( 0x1FFFFFFFFFFFFFFF ), 2070 LIT64( 0x0FFFFFFFFFFFFFFF ), 2071 LIT64( 0x07FFFFFFFFFFFFFF ), 2072 LIT64( 0x03FFFFFFFFFFFFFF ), 2073 LIT64( 0x01FFFFFFFFFFFFFF ), 2074 LIT64( 0x00FFFFFFFFFFFFFF ), 2075 LIT64( 0x007FFFFFFFFFFFFF ), 2076 LIT64( 0x003FFFFFFFFFFFFF ), 2077 LIT64( 0x001FFFFFFFFFFFFF ), 2078 LIT64( 0x000FFFFFFFFFFFFF ), 2079 LIT64( 0x0007FFFFFFFFFFFF ), 2080 LIT64( 0x0003FFFFFFFFFFFF ), 2081 LIT64( 0x0001FFFFFFFFFFFF ), 2082 LIT64( 0x0000FFFFFFFFFFFF ), 2083 LIT64( 0x00007FFFFFFFFFFF ), 2084 LIT64( 0x00003FFFFFFFFFFF ), 2085 LIT64( 0x00001FFFFFFFFFFF ), 2086 LIT64( 0x00000FFFFFFFFFFF ), 2087 LIT64( 0x000007FFFFFFFFFF ), 2088 LIT64( 0x000003FFFFFFFFFF ), 2089 LIT64( 0x000001FFFFFFFFFF ), 2090 LIT64( 0x000000FFFFFFFFFF ), 2091 LIT64( 0x0000007FFFFFFFFF ), 2092 LIT64( 0x0000003FFFFFFFFF ), 2093 LIT64( 0x0000001FFFFFFFFF ), 2094 LIT64( 0x0000000FFFFFFFFF ), 2095 LIT64( 0x00000007FFFFFFFF ), 2096 LIT64( 0x00000003FFFFFFFF ), 2097 LIT64( 0x00000001FFFFFFFF ), 2098 LIT64( 0x00000000FFFFFFFF ), 2099 LIT64( 0x000000007FFFFFFF ), 2100 LIT64( 0x000000003FFFFFFF ), 2101 LIT64( 0x000000001FFFFFFF ), 2102 LIT64( 0x000000000FFFFFFF ), 2103 LIT64( 0x0000000007FFFFFF ), 2104 LIT64( 0x0000000003FFFFFF ), 2105 LIT64( 0x0000000001FFFFFF ), 2106 LIT64( 0x0000000000FFFFFF ), 2107 LIT64( 0x00000000007FFFFF ), 2108 LIT64( 0x00000000003FFFFF ), 2109 LIT64( 0x00000000001FFFFF ), 2110 LIT64( 0x00000000000FFFFF ), 2111 LIT64( 0x000000000007FFFF ), 2112 LIT64( 0x000000000003FFFF ), 2113 LIT64( 0x000000000001FFFF ), 2114 LIT64( 0x000000000000FFFF ), 2115 LIT64( 0x0000000000007FFF ), 2116 LIT64( 0x0000000000003FFF ), 2117 LIT64( 0x0000000000001FFF ), 2118 LIT64( 0x0000000000000FFF ), 2119 LIT64( 0x00000000000007FF ), 2120 LIT64( 0x00000000000003FF ), 2121 LIT64( 0x00000000000001FF ), 2122 LIT64( 0x00000000000000FF ), 2123 LIT64( 0x000000000000007F ), 2124 LIT64( 0x000000000000003F ), 2125 LIT64( 0x000000000000001F ), 2126 LIT64( 0x000000000000000F ), 2127 LIT64( 0x0000000000000007 ), 2128 LIT64( 0x0000000000000003 ) 2129 }; 2130 2131 static const uint32 floatx80NumQInP1 = floatx80NumQIn * floatx80NumP1; 2132 static const uint32 floatx80NumQOutP1 = floatx80NumQOut * floatx80NumP1; 2133 2134 static floatx80 floatx80NextQInP1( sequenceT *sequencePtr ) 2135 { 2136 int16 expNum, sigNum; 2137 floatx80 z; 2138 2139 sigNum = sequencePtr->term1Num; 2140 expNum = sequencePtr->expNum; 2141 z.low = floatx80P1[ sigNum ]; 2142 z.high = floatx80QIn[ expNum ]; 2143 if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 ); 2144 ++sigNum; 2145 if ( floatx80NumP1 <= sigNum ) { 2146 sigNum = 0; 2147 ++expNum; 2148 if ( floatx80NumQIn <= expNum ) { 2149 expNum = 0; 2150 sequencePtr->done = TRUE; 2151 } 2152 sequencePtr->expNum = expNum; 2153 } 2154 sequencePtr->term1Num = sigNum; 2155 return z; 2156 2157 } 2158 2159 static floatx80 floatx80NextQOutP1( sequenceT *sequencePtr ) 2160 { 2161 int16 expNum, sigNum; 2162 floatx80 z; 2163 2164 sigNum = sequencePtr->term1Num; 2165 expNum = sequencePtr->expNum; 2166 z.low = floatx80P1[ sigNum ]; 2167 z.high = floatx80QOut[ expNum ]; 2168 if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 ); 2169 ++sigNum; 2170 if ( floatx80NumP1 <= sigNum ) { 2171 sigNum = 0; 2172 ++expNum; 2173 if ( floatx80NumQOut <= expNum ) { 2174 expNum = 0; 2175 sequencePtr->done = TRUE; 2176 } 2177 sequencePtr->expNum = expNum; 2178 } 2179 sequencePtr->term1Num = sigNum; 2180 return z; 2181 2182 } 2183 2184 static const uint32 floatx80NumQInP2 = floatx80NumQIn * floatx80NumP2; 2185 static const uint32 floatx80NumQOutP2 = floatx80NumQOut * floatx80NumP2; 2186 2187 static floatx80 floatx80NextQInP2( sequenceT *sequencePtr ) 2188 { 2189 int16 expNum, sigNum; 2190 floatx80 z; 2191 2192 sigNum = sequencePtr->term1Num; 2193 expNum = sequencePtr->expNum; 2194 z.low = floatx80P2[ sigNum ]; 2195 z.high = floatx80QIn[ expNum ]; 2196 if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 ); 2197 ++sigNum; 2198 if ( floatx80NumP2 <= sigNum ) { 2199 sigNum = 0; 2200 ++expNum; 2201 if ( floatx80NumQIn <= expNum ) { 2202 expNum = 0; 2203 sequencePtr->done = TRUE; 2204 } 2205 sequencePtr->expNum = expNum; 2206 } 2207 sequencePtr->term1Num = sigNum; 2208 return z; 2209 2210 } 2211 2212 static floatx80 floatx80NextQOutP2( sequenceT *sequencePtr ) 2213 { 2214 int16 expNum, sigNum; 2215 floatx80 z; 2216 2217 sigNum = sequencePtr->term1Num; 2218 expNum = sequencePtr->expNum; 2219 z.low = floatx80P2[ sigNum ]; 2220 z.high = floatx80QOut[ expNum ]; 2221 if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 ); 2222 ++sigNum; 2223 if ( floatx80NumP2 <= sigNum ) { 2224 sigNum = 0; 2225 ++expNum; 2226 if ( floatx80NumQOut <= expNum ) { 2227 expNum = 0; 2228 sequencePtr->done = TRUE; 2229 } 2230 sequencePtr->expNum = expNum; 2231 } 2232 sequencePtr->term1Num = sigNum; 2233 return z; 2234 2235 } 2236 2237 static floatx80 floatx80RandomQOutP3( void ) 2238 { 2239 floatx80 z; 2240 2241 z.low = 2242 ( floatx80P2[ randomUint8() % floatx80NumP2 ] 2243 + floatx80P2[ randomUint8() % floatx80NumP2 ] ) 2244 & LIT64( 0x7FFFFFFFFFFFFFFF ); 2245 z.high = floatx80QOut[ randomUint8() % floatx80NumQOut ]; 2246 if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 ); 2247 return z; 2248 2249 } 2250 2251 static floatx80 floatx80RandomQOutPInf( void ) 2252 { 2253 floatx80 z; 2254 2255 z.low = randomUint64() & LIT64( 0x7FFFFFFFFFFFFFFF ); 2256 z.high = floatx80QOut[ randomUint8() % floatx80NumQOut ]; 2257 if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 ); 2258 return z; 2259 2260 } 2261 2262 enum { 2263 floatx80NumQInfWeightMasks = 14 2264 }; 2265 2266 static const uint16 floatx80QInfWeightMasks[ floatx80NumQInfWeightMasks ] = { 2267 0x7FFF, 2268 0x7FFF, 2269 0x3FFF, 2270 0x1FFF, 2271 0x07FF, 2272 0x07FF, 2273 0x03FF, 2274 0x01FF, 2275 0x00FF, 2276 0x007F, 2277 0x003F, 2278 0x001F, 2279 0x000F, 2280 0x0007 2281 }; 2282 2283 static const uint16 floatx80QInfWeightOffsets[ floatx80NumQInfWeightMasks ] = { 2284 0x0000, 2285 0x0000, 2286 0x2000, 2287 0x3000, 2288 0x3800, 2289 0x3C00, 2290 0x3E00, 2291 0x3F00, 2292 0x3F80, 2293 0x3FC0, 2294 0x3FE0, 2295 0x3FF0, 2296 0x3FF8, 2297 0x3FFC 2298 }; 2299 2300 static floatx80 floatx80RandomQInfP3( void ) 2301 { 2302 int8 weightMaskNum; 2303 floatx80 z; 2304 2305 z.low = 2306 ( floatx80P2[ randomUint8() % floatx80NumP2 ] 2307 + floatx80P2[ randomUint8() % floatx80NumP2 ] ) 2308 & LIT64( 0x7FFFFFFFFFFFFFFF ); 2309 weightMaskNum = randomUint8() % floatx80NumQInfWeightMasks; 2310 z.high = 2311 randomUint16() & (floatx80QInfWeightMasks[ weightMaskNum ] 2312 + floatx80QInfWeightOffsets[ weightMaskNum ]); 2313 if ( z.high ) z.low |= LIT64( 0x8000000000000000 ); 2314 z.high |= ( (uint16) ( randomUint8() & 1 ) )<<15; 2315 return z; 2316 2317 } 2318 2319 static floatx80 floatx80RandomQInfPInf( void ) 2320 { 2321 int8 weightMaskNum; 2322 floatx80 z; 2323 2324 z.low = randomUint64() & LIT64( 0x7FFFFFFFFFFFFFFF ); 2325 weightMaskNum = randomUint8() % floatx80NumQInfWeightMasks; 2326 z.high = 2327 randomUint16() & (floatx80QInfWeightMasks[ weightMaskNum ] 2328 + floatx80QInfWeightOffsets[ weightMaskNum ]); 2329 if ( z.high ) z.low |= LIT64( 0x8000000000000000 ); 2330 z.high |= ( (uint16) ( randomUint8() & 1 ) )<<15; 2331 return z; 2332 2333 } 2334 2335 static floatx80 floatx80Random( void ) 2336 { 2337 2338 switch ( randomUint8() & 7 ) { 2339 case 0: 2340 case 1: 2341 case 2: 2342 return floatx80RandomQOutP3(); 2343 case 3: 2344 return floatx80RandomQOutPInf(); 2345 case 4: 2346 case 5: 2347 case 6: 2348 return floatx80RandomQInfP3(); 2349 case 7: 2350 break; 2351 } 2352 return floatx80RandomQInfPInf(); 2353 } 2354 2355 #endif 2356 2357 #ifdef FLOAT128 2358 2359 enum { 2360 float128NumQIn = 22, 2361 float128NumQOut = 78, 2362 float128NumP1 = 4, 2363 float128NumP2 = 443 2364 }; 2365 2366 static const uint64 float128QIn[ float128NumQIn ] = { 2367 LIT64( 0x0000000000000000 ), /* positive, subnormal */ 2368 LIT64( 0x0001000000000000 ), /* positive, -16382 */ 2369 LIT64( 0x3F8E000000000000 ), /* positive, -113 */ 2370 LIT64( 0x3FFD000000000000 ), /* positive, -2 */ 2371 LIT64( 0x3FFE000000000000 ), /* positive, -1 */ 2372 LIT64( 0x3FFF000000000000 ), /* positive, 0 */ 2373 LIT64( 0x4000000000000000 ), /* positive, 1 */ 2374 LIT64( 0x4001000000000000 ), /* positive, 2 */ 2375 LIT64( 0x4070000000000000 ), /* positive, 113 */ 2376 LIT64( 0x7FFE000000000000 ), /* positive, 16383 */ 2377 LIT64( 0x7FFF000000000000 ), /* positive, infinity or NaN */ 2378 LIT64( 0x8000000000000000 ), /* negative, subnormal */ 2379 LIT64( 0x8001000000000000 ), /* negative, -16382 */ 2380 LIT64( 0xBF8E000000000000 ), /* negative, -113 */ 2381 LIT64( 0xBFFD000000000000 ), /* negative, -2 */ 2382 LIT64( 0xBFFE000000000000 ), /* negative, -1 */ 2383 LIT64( 0xBFFF000000000000 ), /* negative, 0 */ 2384 LIT64( 0xC000000000000000 ), /* negative, 1 */ 2385 LIT64( 0xC001000000000000 ), /* negative, 2 */ 2386 LIT64( 0xC070000000000000 ), /* negative, 113 */ 2387 LIT64( 0xFFFE000000000000 ), /* negative, 16383 */ 2388 LIT64( 0xFFFF000000000000 ) /* negative, infinity or NaN */ 2389 }; 2390 2391 static const uint64 float128QOut[ float128NumQOut ] = { 2392 LIT64( 0x0000000000000000 ), /* positive, subnormal */ 2393 LIT64( 0x0001000000000000 ), /* positive, -16382 */ 2394 LIT64( 0x0002000000000000 ), /* positive, -16381 */ 2395 LIT64( 0x3BFE000000000000 ), /* positive, -1025 */ 2396 LIT64( 0x3BFF000000000000 ), /* positive, -1024 */ 2397 LIT64( 0x3C00000000000000 ), /* positive, -1023 */ 2398 LIT64( 0x3C01000000000000 ), /* positive, -1022 */ 2399 LIT64( 0x3F7E000000000000 ), /* positive, -129 */ 2400 LIT64( 0x3F7F000000000000 ), /* positive, -128 */ 2401 LIT64( 0x3F80000000000000 ), /* positive, -127 */ 2402 LIT64( 0x3F81000000000000 ), /* positive, -126 */ 2403 LIT64( 0x3F8E000000000000 ), /* positive, -113 */ 2404 LIT64( 0x3FFB000000000000 ), /* positive, -4 */ 2405 LIT64( 0x3FFC000000000000 ), /* positive, -3 */ 2406 LIT64( 0x3FFD000000000000 ), /* positive, -2 */ 2407 LIT64( 0x3FFE000000000000 ), /* positive, -1 */ 2408 LIT64( 0x3FFF000000000000 ), /* positive, 0 */ 2409 LIT64( 0x4000000000000000 ), /* positive, 1 */ 2410 LIT64( 0x4001000000000000 ), /* positive, 2 */ 2411 LIT64( 0x4002000000000000 ), /* positive, 3 */ 2412 LIT64( 0x4003000000000000 ), /* positive, 4 */ 2413 LIT64( 0x401C000000000000 ), /* positive, 29 */ 2414 LIT64( 0x401D000000000000 ), /* positive, 30 */ 2415 LIT64( 0x401E000000000000 ), /* positive, 31 */ 2416 LIT64( 0x401F000000000000 ), /* positive, 32 */ 2417 LIT64( 0x403C000000000000 ), /* positive, 61 */ 2418 LIT64( 0x403D000000000000 ), /* positive, 62 */ 2419 LIT64( 0x403E000000000000 ), /* positive, 63 */ 2420 LIT64( 0x403F000000000000 ), /* positive, 64 */ 2421 LIT64( 0x4070000000000000 ), /* positive, 113 */ 2422 LIT64( 0x407E000000000000 ), /* positive, 127 */ 2423 LIT64( 0x407F000000000000 ), /* positive, 128 */ 2424 LIT64( 0x4080000000000000 ), /* positive, 129 */ 2425 LIT64( 0x43FE000000000000 ), /* positive, 1023 */ 2426 LIT64( 0x43FF000000000000 ), /* positive, 1024 */ 2427 LIT64( 0x4400000000000000 ), /* positive, 1025 */ 2428 LIT64( 0x7FFD000000000000 ), /* positive, 16382 */ 2429 LIT64( 0x7FFE000000000000 ), /* positive, 16383 */ 2430 LIT64( 0x7FFF000000000000 ), /* positive, infinity or NaN */ 2431 LIT64( 0x8000000000000000 ), /* negative, subnormal */ 2432 LIT64( 0x8001000000000000 ), /* negative, -16382 */ 2433 LIT64( 0x8002000000000000 ), /* negative, -16381 */ 2434 LIT64( 0xBBFE000000000000 ), /* negative, -1025 */ 2435 LIT64( 0xBBFF000000000000 ), /* negative, -1024 */ 2436 LIT64( 0xBC00000000000000 ), /* negative, -1023 */ 2437 LIT64( 0xBC01000000000000 ), /* negative, -1022 */ 2438 LIT64( 0xBF7E000000000000 ), /* negative, -129 */ 2439 LIT64( 0xBF7F000000000000 ), /* negative, -128 */ 2440 LIT64( 0xBF80000000000000 ), /* negative, -127 */ 2441 LIT64( 0xBF81000000000000 ), /* negative, -126 */ 2442 LIT64( 0xBF8E000000000000 ), /* negative, -113 */ 2443 LIT64( 0xBFFB000000000000 ), /* negative, -4 */ 2444 LIT64( 0xBFFC000000000000 ), /* negative, -3 */ 2445 LIT64( 0xBFFD000000000000 ), /* negative, -2 */ 2446 LIT64( 0xBFFE000000000000 ), /* negative, -1 */ 2447 LIT64( 0xBFFF000000000000 ), /* negative, 0 */ 2448 LIT64( 0xC000000000000000 ), /* negative, 1 */ 2449 LIT64( 0xC001000000000000 ), /* negative, 2 */ 2450 LIT64( 0xC002000000000000 ), /* negative, 3 */ 2451 LIT64( 0xC003000000000000 ), /* negative, 4 */ 2452 LIT64( 0xC01C000000000000 ), /* negative, 29 */ 2453 LIT64( 0xC01D000000000000 ), /* negative, 30 */ 2454 LIT64( 0xC01E000000000000 ), /* negative, 31 */ 2455 LIT64( 0xC01F000000000000 ), /* negative, 32 */ 2456 LIT64( 0xC03C000000000000 ), /* negative, 61 */ 2457 LIT64( 0xC03D000000000000 ), /* negative, 62 */ 2458 LIT64( 0xC03E000000000000 ), /* negative, 63 */ 2459 LIT64( 0xC03F000000000000 ), /* negative, 64 */ 2460 LIT64( 0xC070000000000000 ), /* negative, 113 */ 2461 LIT64( 0xC07E000000000000 ), /* negative, 127 */ 2462 LIT64( 0xC07F000000000000 ), /* negative, 128 */ 2463 LIT64( 0xC080000000000000 ), /* negative, 129 */ 2464 LIT64( 0xC3FE000000000000 ), /* negative, 1023 */ 2465 LIT64( 0xC3FF000000000000 ), /* negative, 1024 */ 2466 LIT64( 0xC400000000000000 ), /* negative, 1025 */ 2467 LIT64( 0xFFFD000000000000 ), /* negative, 16382 */ 2468 LIT64( 0xFFFE000000000000 ), /* negative, 16383 */ 2469 LIT64( 0xFFFF000000000000 ) /* negative, infinity or NaN */ 2470 }; 2471 2472 static const struct { bits64 high, low; } float128P1[ float128NumP1 ] = { 2473 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000000 ) }, 2474 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000001 ) }, 2475 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2476 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFE ) } 2477 }; 2478 2479 static const struct { bits64 high, low; } float128P2[ float128NumP2 ] = { 2480 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000000 ) }, 2481 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000001 ) }, 2482 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000002 ) }, 2483 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000004 ) }, 2484 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000008 ) }, 2485 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000010 ) }, 2486 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000020 ) }, 2487 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000040 ) }, 2488 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000080 ) }, 2489 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000100 ) }, 2490 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000200 ) }, 2491 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000400 ) }, 2492 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000800 ) }, 2493 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000001000 ) }, 2494 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000002000 ) }, 2495 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000004000 ) }, 2496 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000008000 ) }, 2497 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000010000 ) }, 2498 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000020000 ) }, 2499 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000040000 ) }, 2500 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000080000 ) }, 2501 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000100000 ) }, 2502 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000200000 ) }, 2503 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000400000 ) }, 2504 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000800000 ) }, 2505 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000001000000 ) }, 2506 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000002000000 ) }, 2507 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000004000000 ) }, 2508 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000008000000 ) }, 2509 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000010000000 ) }, 2510 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000020000000 ) }, 2511 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000040000000 ) }, 2512 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000080000000 ) }, 2513 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000100000000 ) }, 2514 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000200000000 ) }, 2515 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000400000000 ) }, 2516 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000800000000 ) }, 2517 { LIT64( 0x0000000000000000 ), LIT64( 0x0000001000000000 ) }, 2518 { LIT64( 0x0000000000000000 ), LIT64( 0x0000002000000000 ) }, 2519 { LIT64( 0x0000000000000000 ), LIT64( 0x0000004000000000 ) }, 2520 { LIT64( 0x0000000000000000 ), LIT64( 0x0000008000000000 ) }, 2521 { LIT64( 0x0000000000000000 ), LIT64( 0x0000010000000000 ) }, 2522 { LIT64( 0x0000000000000000 ), LIT64( 0x0000020000000000 ) }, 2523 { LIT64( 0x0000000000000000 ), LIT64( 0x0000040000000000 ) }, 2524 { LIT64( 0x0000000000000000 ), LIT64( 0x0000080000000000 ) }, 2525 { LIT64( 0x0000000000000000 ), LIT64( 0x0000100000000000 ) }, 2526 { LIT64( 0x0000000000000000 ), LIT64( 0x0000200000000000 ) }, 2527 { LIT64( 0x0000000000000000 ), LIT64( 0x0000400000000000 ) }, 2528 { LIT64( 0x0000000000000000 ), LIT64( 0x0000800000000000 ) }, 2529 { LIT64( 0x0000000000000000 ), LIT64( 0x0001000000000000 ) }, 2530 { LIT64( 0x0000000000000000 ), LIT64( 0x0002000000000000 ) }, 2531 { LIT64( 0x0000000000000000 ), LIT64( 0x0004000000000000 ) }, 2532 { LIT64( 0x0000000000000000 ), LIT64( 0x0008000000000000 ) }, 2533 { LIT64( 0x0000000000000000 ), LIT64( 0x0010000000000000 ) }, 2534 { LIT64( 0x0000000000000000 ), LIT64( 0x0020000000000000 ) }, 2535 { LIT64( 0x0000000000000000 ), LIT64( 0x0040000000000000 ) }, 2536 { LIT64( 0x0000000000000000 ), LIT64( 0x0080000000000000 ) }, 2537 { LIT64( 0x0000000000000000 ), LIT64( 0x0100000000000000 ) }, 2538 { LIT64( 0x0000000000000000 ), LIT64( 0x0200000000000000 ) }, 2539 { LIT64( 0x0000000000000000 ), LIT64( 0x0400000000000000 ) }, 2540 { LIT64( 0x0000000000000000 ), LIT64( 0x0800000000000000 ) }, 2541 { LIT64( 0x0000000000000000 ), LIT64( 0x1000000000000000 ) }, 2542 { LIT64( 0x0000000000000000 ), LIT64( 0x2000000000000000 ) }, 2543 { LIT64( 0x0000000000000000 ), LIT64( 0x4000000000000000 ) }, 2544 { LIT64( 0x0000000000000000 ), LIT64( 0x8000000000000000 ) }, 2545 { LIT64( 0x0000000000000001 ), LIT64( 0x0000000000000000 ) }, 2546 { LIT64( 0x0000000000000002 ), LIT64( 0x0000000000000000 ) }, 2547 { LIT64( 0x0000000000000004 ), LIT64( 0x0000000000000000 ) }, 2548 { LIT64( 0x0000000000000008 ), LIT64( 0x0000000000000000 ) }, 2549 { LIT64( 0x0000000000000010 ), LIT64( 0x0000000000000000 ) }, 2550 { LIT64( 0x0000000000000020 ), LIT64( 0x0000000000000000 ) }, 2551 { LIT64( 0x0000000000000040 ), LIT64( 0x0000000000000000 ) }, 2552 { LIT64( 0x0000000000000080 ), LIT64( 0x0000000000000000 ) }, 2553 { LIT64( 0x0000000000000100 ), LIT64( 0x0000000000000000 ) }, 2554 { LIT64( 0x0000000000000200 ), LIT64( 0x0000000000000000 ) }, 2555 { LIT64( 0x0000000000000400 ), LIT64( 0x0000000000000000 ) }, 2556 { LIT64( 0x0000000000000800 ), LIT64( 0x0000000000000000 ) }, 2557 { LIT64( 0x0000000000001000 ), LIT64( 0x0000000000000000 ) }, 2558 { LIT64( 0x0000000000002000 ), LIT64( 0x0000000000000000 ) }, 2559 { LIT64( 0x0000000000004000 ), LIT64( 0x0000000000000000 ) }, 2560 { LIT64( 0x0000000000008000 ), LIT64( 0x0000000000000000 ) }, 2561 { LIT64( 0x0000000000010000 ), LIT64( 0x0000000000000000 ) }, 2562 { LIT64( 0x0000000000020000 ), LIT64( 0x0000000000000000 ) }, 2563 { LIT64( 0x0000000000040000 ), LIT64( 0x0000000000000000 ) }, 2564 { LIT64( 0x0000000000080000 ), LIT64( 0x0000000000000000 ) }, 2565 { LIT64( 0x0000000000100000 ), LIT64( 0x0000000000000000 ) }, 2566 { LIT64( 0x0000000000200000 ), LIT64( 0x0000000000000000 ) }, 2567 { LIT64( 0x0000000000400000 ), LIT64( 0x0000000000000000 ) }, 2568 { LIT64( 0x0000000000800000 ), LIT64( 0x0000000000000000 ) }, 2569 { LIT64( 0x0000000001000000 ), LIT64( 0x0000000000000000 ) }, 2570 { LIT64( 0x0000000002000000 ), LIT64( 0x0000000000000000 ) }, 2571 { LIT64( 0x0000000004000000 ), LIT64( 0x0000000000000000 ) }, 2572 { LIT64( 0x0000000008000000 ), LIT64( 0x0000000000000000 ) }, 2573 { LIT64( 0x0000000010000000 ), LIT64( 0x0000000000000000 ) }, 2574 { LIT64( 0x0000000020000000 ), LIT64( 0x0000000000000000 ) }, 2575 { LIT64( 0x0000000040000000 ), LIT64( 0x0000000000000000 ) }, 2576 { LIT64( 0x0000000080000000 ), LIT64( 0x0000000000000000 ) }, 2577 { LIT64( 0x0000000100000000 ), LIT64( 0x0000000000000000 ) }, 2578 { LIT64( 0x0000000200000000 ), LIT64( 0x0000000000000000 ) }, 2579 { LIT64( 0x0000000400000000 ), LIT64( 0x0000000000000000 ) }, 2580 { LIT64( 0x0000000800000000 ), LIT64( 0x0000000000000000 ) }, 2581 { LIT64( 0x0000001000000000 ), LIT64( 0x0000000000000000 ) }, 2582 { LIT64( 0x0000002000000000 ), LIT64( 0x0000000000000000 ) }, 2583 { LIT64( 0x0000004000000000 ), LIT64( 0x0000000000000000 ) }, 2584 { LIT64( 0x0000008000000000 ), LIT64( 0x0000000000000000 ) }, 2585 { LIT64( 0x0000010000000000 ), LIT64( 0x0000000000000000 ) }, 2586 { LIT64( 0x0000020000000000 ), LIT64( 0x0000000000000000 ) }, 2587 { LIT64( 0x0000040000000000 ), LIT64( 0x0000000000000000 ) }, 2588 { LIT64( 0x0000080000000000 ), LIT64( 0x0000000000000000 ) }, 2589 { LIT64( 0x0000100000000000 ), LIT64( 0x0000000000000000 ) }, 2590 { LIT64( 0x0000200000000000 ), LIT64( 0x0000000000000000 ) }, 2591 { LIT64( 0x0000400000000000 ), LIT64( 0x0000000000000000 ) }, 2592 { LIT64( 0x0000800000000000 ), LIT64( 0x0000000000000000 ) }, 2593 { LIT64( 0x0000C00000000000 ), LIT64( 0x0000000000000000 ) }, 2594 { LIT64( 0x0000E00000000000 ), LIT64( 0x0000000000000000 ) }, 2595 { LIT64( 0x0000F00000000000 ), LIT64( 0x0000000000000000 ) }, 2596 { LIT64( 0x0000F80000000000 ), LIT64( 0x0000000000000000 ) }, 2597 { LIT64( 0x0000FC0000000000 ), LIT64( 0x0000000000000000 ) }, 2598 { LIT64( 0x0000FE0000000000 ), LIT64( 0x0000000000000000 ) }, 2599 { LIT64( 0x0000FF0000000000 ), LIT64( 0x0000000000000000 ) }, 2600 { LIT64( 0x0000FF8000000000 ), LIT64( 0x0000000000000000 ) }, 2601 { LIT64( 0x0000FFC000000000 ), LIT64( 0x0000000000000000 ) }, 2602 { LIT64( 0x0000FFE000000000 ), LIT64( 0x0000000000000000 ) }, 2603 { LIT64( 0x0000FFF000000000 ), LIT64( 0x0000000000000000 ) }, 2604 { LIT64( 0x0000FFF800000000 ), LIT64( 0x0000000000000000 ) }, 2605 { LIT64( 0x0000FFFC00000000 ), LIT64( 0x0000000000000000 ) }, 2606 { LIT64( 0x0000FFFE00000000 ), LIT64( 0x0000000000000000 ) }, 2607 { LIT64( 0x0000FFFF00000000 ), LIT64( 0x0000000000000000 ) }, 2608 { LIT64( 0x0000FFFF80000000 ), LIT64( 0x0000000000000000 ) }, 2609 { LIT64( 0x0000FFFFC0000000 ), LIT64( 0x0000000000000000 ) }, 2610 { LIT64( 0x0000FFFFE0000000 ), LIT64( 0x0000000000000000 ) }, 2611 { LIT64( 0x0000FFFFF0000000 ), LIT64( 0x0000000000000000 ) }, 2612 { LIT64( 0x0000FFFFF8000000 ), LIT64( 0x0000000000000000 ) }, 2613 { LIT64( 0x0000FFFFFC000000 ), LIT64( 0x0000000000000000 ) }, 2614 { LIT64( 0x0000FFFFFE000000 ), LIT64( 0x0000000000000000 ) }, 2615 { LIT64( 0x0000FFFFFF000000 ), LIT64( 0x0000000000000000 ) }, 2616 { LIT64( 0x0000FFFFFF800000 ), LIT64( 0x0000000000000000 ) }, 2617 { LIT64( 0x0000FFFFFFC00000 ), LIT64( 0x0000000000000000 ) }, 2618 { LIT64( 0x0000FFFFFFE00000 ), LIT64( 0x0000000000000000 ) }, 2619 { LIT64( 0x0000FFFFFFF00000 ), LIT64( 0x0000000000000000 ) }, 2620 { LIT64( 0x0000FFFFFFF80000 ), LIT64( 0x0000000000000000 ) }, 2621 { LIT64( 0x0000FFFFFFFC0000 ), LIT64( 0x0000000000000000 ) }, 2622 { LIT64( 0x0000FFFFFFFE0000 ), LIT64( 0x0000000000000000 ) }, 2623 { LIT64( 0x0000FFFFFFFF0000 ), LIT64( 0x0000000000000000 ) }, 2624 { LIT64( 0x0000FFFFFFFF8000 ), LIT64( 0x0000000000000000 ) }, 2625 { LIT64( 0x0000FFFFFFFFC000 ), LIT64( 0x0000000000000000 ) }, 2626 { LIT64( 0x0000FFFFFFFFE000 ), LIT64( 0x0000000000000000 ) }, 2627 { LIT64( 0x0000FFFFFFFFF000 ), LIT64( 0x0000000000000000 ) }, 2628 { LIT64( 0x0000FFFFFFFFF800 ), LIT64( 0x0000000000000000 ) }, 2629 { LIT64( 0x0000FFFFFFFFFC00 ), LIT64( 0x0000000000000000 ) }, 2630 { LIT64( 0x0000FFFFFFFFFE00 ), LIT64( 0x0000000000000000 ) }, 2631 { LIT64( 0x0000FFFFFFFFFF00 ), LIT64( 0x0000000000000000 ) }, 2632 { LIT64( 0x0000FFFFFFFFFF80 ), LIT64( 0x0000000000000000 ) }, 2633 { LIT64( 0x0000FFFFFFFFFFC0 ), LIT64( 0x0000000000000000 ) }, 2634 { LIT64( 0x0000FFFFFFFFFFE0 ), LIT64( 0x0000000000000000 ) }, 2635 { LIT64( 0x0000FFFFFFFFFFF0 ), LIT64( 0x0000000000000000 ) }, 2636 { LIT64( 0x0000FFFFFFFFFFF8 ), LIT64( 0x0000000000000000 ) }, 2637 { LIT64( 0x0000FFFFFFFFFFFC ), LIT64( 0x0000000000000000 ) }, 2638 { LIT64( 0x0000FFFFFFFFFFFE ), LIT64( 0x0000000000000000 ) }, 2639 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0x0000000000000000 ) }, 2640 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0x8000000000000000 ) }, 2641 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xC000000000000000 ) }, 2642 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xE000000000000000 ) }, 2643 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xF000000000000000 ) }, 2644 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xF800000000000000 ) }, 2645 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFC00000000000000 ) }, 2646 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFE00000000000000 ) }, 2647 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFF00000000000000 ) }, 2648 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFF80000000000000 ) }, 2649 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFC0000000000000 ) }, 2650 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFE0000000000000 ) }, 2651 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFF0000000000000 ) }, 2652 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFF8000000000000 ) }, 2653 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFC000000000000 ) }, 2654 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFE000000000000 ) }, 2655 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFF000000000000 ) }, 2656 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFF800000000000 ) }, 2657 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFC00000000000 ) }, 2658 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFE00000000000 ) }, 2659 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFF00000000000 ) }, 2660 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFF80000000000 ) }, 2661 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFC0000000000 ) }, 2662 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFE0000000000 ) }, 2663 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFF0000000000 ) }, 2664 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFF8000000000 ) }, 2665 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFC000000000 ) }, 2666 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFE000000000 ) }, 2667 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFF000000000 ) }, 2668 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFF800000000 ) }, 2669 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFC00000000 ) }, 2670 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFE00000000 ) }, 2671 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFF00000000 ) }, 2672 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFF80000000 ) }, 2673 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFC0000000 ) }, 2674 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFE0000000 ) }, 2675 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFF0000000 ) }, 2676 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFF8000000 ) }, 2677 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFC000000 ) }, 2678 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFE000000 ) }, 2679 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFF000000 ) }, 2680 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFF800000 ) }, 2681 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFC00000 ) }, 2682 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFE00000 ) }, 2683 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFF00000 ) }, 2684 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFF80000 ) }, 2685 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFC0000 ) }, 2686 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFE0000 ) }, 2687 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFF0000 ) }, 2688 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFF8000 ) }, 2689 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFC000 ) }, 2690 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFE000 ) }, 2691 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFF000 ) }, 2692 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFF800 ) }, 2693 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFC00 ) }, 2694 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFE00 ) }, 2695 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFF00 ) }, 2696 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFF80 ) }, 2697 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFC0 ) }, 2698 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFE0 ) }, 2699 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFF0 ) }, 2700 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFF8 ) }, 2701 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFC ) }, 2702 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFE ) }, 2703 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2704 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFD ) }, 2705 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFB ) }, 2706 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFF7 ) }, 2707 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFEF ) }, 2708 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFDF ) }, 2709 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFBF ) }, 2710 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFF7F ) }, 2711 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFEFF ) }, 2712 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFDFF ) }, 2713 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFBFF ) }, 2714 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFF7FF ) }, 2715 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFEFFF ) }, 2716 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFDFFF ) }, 2717 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFBFFF ) }, 2718 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFF7FFF ) }, 2719 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFEFFFF ) }, 2720 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFDFFFF ) }, 2721 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFBFFFF ) }, 2722 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFF7FFFF ) }, 2723 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFEFFFFF ) }, 2724 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFDFFFFF ) }, 2725 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFBFFFFF ) }, 2726 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFF7FFFFF ) }, 2727 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFEFFFFFF ) }, 2728 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFDFFFFFF ) }, 2729 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFBFFFFFF ) }, 2730 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFF7FFFFFF ) }, 2731 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFEFFFFFFF ) }, 2732 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFDFFFFFFF ) }, 2733 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFBFFFFFFF ) }, 2734 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFF7FFFFFFF ) }, 2735 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFEFFFFFFFF ) }, 2736 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFDFFFFFFFF ) }, 2737 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFBFFFFFFFF ) }, 2738 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFF7FFFFFFFF ) }, 2739 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFEFFFFFFFFF ) }, 2740 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFDFFFFFFFFF ) }, 2741 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFBFFFFFFFFF ) }, 2742 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFF7FFFFFFFFF ) }, 2743 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFEFFFFFFFFFF ) }, 2744 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFDFFFFFFFFFF ) }, 2745 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFBFFFFFFFFFF ) }, 2746 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFF7FFFFFFFFFF ) }, 2747 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFEFFFFFFFFFFF ) }, 2748 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFDFFFFFFFFFFF ) }, 2749 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFBFFFFFFFFFFF ) }, 2750 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFF7FFFFFFFFFFF ) }, 2751 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFEFFFFFFFFFFFF ) }, 2752 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFDFFFFFFFFFFFF ) }, 2753 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFBFFFFFFFFFFFF ) }, 2754 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFF7FFFFFFFFFFFF ) }, 2755 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFEFFFFFFFFFFFFF ) }, 2756 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFDFFFFFFFFFFFFF ) }, 2757 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFBFFFFFFFFFFFFF ) }, 2758 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFF7FFFFFFFFFFFFF ) }, 2759 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFEFFFFFFFFFFFFFF ) }, 2760 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFDFFFFFFFFFFFFFF ) }, 2761 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFBFFFFFFFFFFFFFF ) }, 2762 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xF7FFFFFFFFFFFFFF ) }, 2763 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xEFFFFFFFFFFFFFFF ) }, 2764 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xDFFFFFFFFFFFFFFF ) }, 2765 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xBFFFFFFFFFFFFFFF ) }, 2766 { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0x7FFFFFFFFFFFFFFF ) }, 2767 { LIT64( 0x0000FFFFFFFFFFFD ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2768 { LIT64( 0x0000FFFFFFFFFFFB ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2769 { LIT64( 0x0000FFFFFFFFFFF7 ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2770 { LIT64( 0x0000FFFFFFFFFFEF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2771 { LIT64( 0x0000FFFFFFFFFFDF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2772 { LIT64( 0x0000FFFFFFFFFFBF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2773 { LIT64( 0x0000FFFFFFFFFF7F ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2774 { LIT64( 0x0000FFFFFFFFFEFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2775 { LIT64( 0x0000FFFFFFFFFDFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2776 { LIT64( 0x0000FFFFFFFFFBFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2777 { LIT64( 0x0000FFFFFFFFF7FF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2778 { LIT64( 0x0000FFFFFFFFEFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2779 { LIT64( 0x0000FFFFFFFFDFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2780 { LIT64( 0x0000FFFFFFFFBFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2781 { LIT64( 0x0000FFFFFFFF7FFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2782 { LIT64( 0x0000FFFFFFFEFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2783 { LIT64( 0x0000FFFFFFFDFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2784 { LIT64( 0x0000FFFFFFFBFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2785 { LIT64( 0x0000FFFFFFF7FFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2786 { LIT64( 0x0000FFFFFFEFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2787 { LIT64( 0x0000FFFFFFDFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2788 { LIT64( 0x0000FFFFFFBFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2789 { LIT64( 0x0000FFFFFF7FFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2790 { LIT64( 0x0000FFFFFEFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2791 { LIT64( 0x0000FFFFFDFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2792 { LIT64( 0x0000FFFFFBFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2793 { LIT64( 0x0000FFFFF7FFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2794 { LIT64( 0x0000FFFFEFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2795 { LIT64( 0x0000FFFFDFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2796 { LIT64( 0x0000FFFFBFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2797 { LIT64( 0x0000FFFF7FFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2798 { LIT64( 0x0000FFFEFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2799 { LIT64( 0x0000FFFDFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2800 { LIT64( 0x0000FFFBFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2801 { LIT64( 0x0000FFF7FFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2802 { LIT64( 0x0000FFEFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2803 { LIT64( 0x0000FFDFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2804 { LIT64( 0x0000FFBFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2805 { LIT64( 0x0000FF7FFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2806 { LIT64( 0x0000FEFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2807 { LIT64( 0x0000FDFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2808 { LIT64( 0x0000FBFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2809 { LIT64( 0x0000F7FFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2810 { LIT64( 0x0000EFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2811 { LIT64( 0x0000DFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2812 { LIT64( 0x0000BFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2813 { LIT64( 0x00007FFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2814 { LIT64( 0x00003FFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2815 { LIT64( 0x00001FFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2816 { LIT64( 0x00000FFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2817 { LIT64( 0x000007FFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2818 { LIT64( 0x000003FFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2819 { LIT64( 0x000001FFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2820 { LIT64( 0x000000FFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2821 { LIT64( 0x0000007FFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2822 { LIT64( 0x0000003FFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2823 { LIT64( 0x0000001FFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2824 { LIT64( 0x0000000FFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2825 { LIT64( 0x00000007FFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2826 { LIT64( 0x00000003FFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2827 { LIT64( 0x00000001FFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2828 { LIT64( 0x00000000FFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2829 { LIT64( 0x000000007FFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2830 { LIT64( 0x000000003FFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2831 { LIT64( 0x000000001FFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2832 { LIT64( 0x000000000FFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2833 { LIT64( 0x0000000007FFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2834 { LIT64( 0x0000000003FFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2835 { LIT64( 0x0000000001FFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2836 { LIT64( 0x0000000000FFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2837 { LIT64( 0x00000000007FFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2838 { LIT64( 0x00000000003FFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2839 { LIT64( 0x00000000001FFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2840 { LIT64( 0x00000000000FFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2841 { LIT64( 0x000000000007FFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2842 { LIT64( 0x000000000003FFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2843 { LIT64( 0x000000000001FFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2844 { LIT64( 0x000000000000FFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2845 { LIT64( 0x0000000000007FFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2846 { LIT64( 0x0000000000003FFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2847 { LIT64( 0x0000000000001FFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2848 { LIT64( 0x0000000000000FFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2849 { LIT64( 0x00000000000007FF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2850 { LIT64( 0x00000000000003FF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2851 { LIT64( 0x00000000000001FF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2852 { LIT64( 0x00000000000000FF ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2853 { LIT64( 0x000000000000007F ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2854 { LIT64( 0x000000000000003F ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2855 { LIT64( 0x000000000000001F ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2856 { LIT64( 0x000000000000000F ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2857 { LIT64( 0x0000000000000007 ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2858 { LIT64( 0x0000000000000003 ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2859 { LIT64( 0x0000000000000001 ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2860 { LIT64( 0x0000000000000000 ), LIT64( 0xFFFFFFFFFFFFFFFF ) }, 2861 { LIT64( 0x0000000000000000 ), LIT64( 0x7FFFFFFFFFFFFFFF ) }, 2862 { LIT64( 0x0000000000000000 ), LIT64( 0x3FFFFFFFFFFFFFFF ) }, 2863 { LIT64( 0x0000000000000000 ), LIT64( 0x1FFFFFFFFFFFFFFF ) }, 2864 { LIT64( 0x0000000000000000 ), LIT64( 0x0FFFFFFFFFFFFFFF ) }, 2865 { LIT64( 0x0000000000000000 ), LIT64( 0x07FFFFFFFFFFFFFF ) }, 2866 { LIT64( 0x0000000000000000 ), LIT64( 0x03FFFFFFFFFFFFFF ) }, 2867 { LIT64( 0x0000000000000000 ), LIT64( 0x01FFFFFFFFFFFFFF ) }, 2868 { LIT64( 0x0000000000000000 ), LIT64( 0x00FFFFFFFFFFFFFF ) }, 2869 { LIT64( 0x0000000000000000 ), LIT64( 0x007FFFFFFFFFFFFF ) }, 2870 { LIT64( 0x0000000000000000 ), LIT64( 0x003FFFFFFFFFFFFF ) }, 2871 { LIT64( 0x0000000000000000 ), LIT64( 0x001FFFFFFFFFFFFF ) }, 2872 { LIT64( 0x0000000000000000 ), LIT64( 0x000FFFFFFFFFFFFF ) }, 2873 { LIT64( 0x0000000000000000 ), LIT64( 0x0007FFFFFFFFFFFF ) }, 2874 { LIT64( 0x0000000000000000 ), LIT64( 0x0003FFFFFFFFFFFF ) }, 2875 { LIT64( 0x0000000000000000 ), LIT64( 0x0001FFFFFFFFFFFF ) }, 2876 { LIT64( 0x0000000000000000 ), LIT64( 0x0000FFFFFFFFFFFF ) }, 2877 { LIT64( 0x0000000000000000 ), LIT64( 0x00007FFFFFFFFFFF ) }, 2878 { LIT64( 0x0000000000000000 ), LIT64( 0x00003FFFFFFFFFFF ) }, 2879 { LIT64( 0x0000000000000000 ), LIT64( 0x00001FFFFFFFFFFF ) }, 2880 { LIT64( 0x0000000000000000 ), LIT64( 0x00000FFFFFFFFFFF ) }, 2881 { LIT64( 0x0000000000000000 ), LIT64( 0x000007FFFFFFFFFF ) }, 2882 { LIT64( 0x0000000000000000 ), LIT64( 0x000003FFFFFFFFFF ) }, 2883 { LIT64( 0x0000000000000000 ), LIT64( 0x000001FFFFFFFFFF ) }, 2884 { LIT64( 0x0000000000000000 ), LIT64( 0x000000FFFFFFFFFF ) }, 2885 { LIT64( 0x0000000000000000 ), LIT64( 0x0000007FFFFFFFFF ) }, 2886 { LIT64( 0x0000000000000000 ), LIT64( 0x0000003FFFFFFFFF ) }, 2887 { LIT64( 0x0000000000000000 ), LIT64( 0x0000001FFFFFFFFF ) }, 2888 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000FFFFFFFFF ) }, 2889 { LIT64( 0x0000000000000000 ), LIT64( 0x00000007FFFFFFFF ) }, 2890 { LIT64( 0x0000000000000000 ), LIT64( 0x00000003FFFFFFFF ) }, 2891 { LIT64( 0x0000000000000000 ), LIT64( 0x00000001FFFFFFFF ) }, 2892 { LIT64( 0x0000000000000000 ), LIT64( 0x00000000FFFFFFFF ) }, 2893 { LIT64( 0x0000000000000000 ), LIT64( 0x000000007FFFFFFF ) }, 2894 { LIT64( 0x0000000000000000 ), LIT64( 0x000000003FFFFFFF ) }, 2895 { LIT64( 0x0000000000000000 ), LIT64( 0x000000001FFFFFFF ) }, 2896 { LIT64( 0x0000000000000000 ), LIT64( 0x000000000FFFFFFF ) }, 2897 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000007FFFFFF ) }, 2898 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000003FFFFFF ) }, 2899 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000001FFFFFF ) }, 2900 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000FFFFFF ) }, 2901 { LIT64( 0x0000000000000000 ), LIT64( 0x00000000007FFFFF ) }, 2902 { LIT64( 0x0000000000000000 ), LIT64( 0x00000000003FFFFF ) }, 2903 { LIT64( 0x0000000000000000 ), LIT64( 0x00000000001FFFFF ) }, 2904 { LIT64( 0x0000000000000000 ), LIT64( 0x00000000000FFFFF ) }, 2905 { LIT64( 0x0000000000000000 ), LIT64( 0x000000000007FFFF ) }, 2906 { LIT64( 0x0000000000000000 ), LIT64( 0x000000000003FFFF ) }, 2907 { LIT64( 0x0000000000000000 ), LIT64( 0x000000000001FFFF ) }, 2908 { LIT64( 0x0000000000000000 ), LIT64( 0x000000000000FFFF ) }, 2909 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000007FFF ) }, 2910 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000003FFF ) }, 2911 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000001FFF ) }, 2912 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000FFF ) }, 2913 { LIT64( 0x0000000000000000 ), LIT64( 0x00000000000007FF ) }, 2914 { LIT64( 0x0000000000000000 ), LIT64( 0x00000000000003FF ) }, 2915 { LIT64( 0x0000000000000000 ), LIT64( 0x00000000000001FF ) }, 2916 { LIT64( 0x0000000000000000 ), LIT64( 0x00000000000000FF ) }, 2917 { LIT64( 0x0000000000000000 ), LIT64( 0x000000000000007F ) }, 2918 { LIT64( 0x0000000000000000 ), LIT64( 0x000000000000003F ) }, 2919 { LIT64( 0x0000000000000000 ), LIT64( 0x000000000000001F ) }, 2920 { LIT64( 0x0000000000000000 ), LIT64( 0x000000000000000F ) }, 2921 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000007 ) }, 2922 { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000003 ) } 2923 }; 2924 2925 static const uint32 float128NumQInP1 = float128NumQIn * float128NumP1; 2926 static const uint32 float128NumQOutP1 = float128NumQOut * float128NumP1; 2927 2928 static float128 float128NextQInP1( sequenceT *sequencePtr ) 2929 { 2930 int16 expNum, sigNum; 2931 float128 z; 2932 2933 sigNum = sequencePtr->term1Num; 2934 expNum = sequencePtr->expNum; 2935 z.low = float128P1[ sigNum ].low; 2936 z.high = float128QIn[ expNum ] | float128P1[ sigNum ].high; 2937 ++sigNum; 2938 if ( float128NumP1 <= sigNum ) { 2939 sigNum = 0; 2940 ++expNum; 2941 if ( float128NumQIn <= expNum ) { 2942 expNum = 0; 2943 sequencePtr->done = TRUE; 2944 } 2945 sequencePtr->expNum = expNum; 2946 } 2947 sequencePtr->term1Num = sigNum; 2948 return z; 2949 2950 } 2951 2952 static float128 float128NextQOutP1( sequenceT *sequencePtr ) 2953 { 2954 int16 expNum, sigNum; 2955 float128 z; 2956 2957 sigNum = sequencePtr->term1Num; 2958 expNum = sequencePtr->expNum; 2959 z.low = float128P1[ sigNum ].low; 2960 z.high = float128QOut[ expNum ] | float128P1[ sigNum ].high; 2961 ++sigNum; 2962 if ( float128NumP1 <= sigNum ) { 2963 sigNum = 0; 2964 ++expNum; 2965 if ( float128NumQOut <= expNum ) { 2966 expNum = 0; 2967 sequencePtr->done = TRUE; 2968 } 2969 sequencePtr->expNum = expNum; 2970 } 2971 sequencePtr->term1Num = sigNum; 2972 return z; 2973 2974 } 2975 2976 static const uint32 float128NumQInP2 = float128NumQIn * float128NumP2; 2977 static const uint32 float128NumQOutP2 = float128NumQOut * float128NumP2; 2978 2979 static float128 float128NextQInP2( sequenceT *sequencePtr ) 2980 { 2981 int16 expNum, sigNum; 2982 float128 z; 2983 2984 sigNum = sequencePtr->term1Num; 2985 expNum = sequencePtr->expNum; 2986 z.low = float128P2[ sigNum ].low; 2987 z.high = float128QIn[ expNum ] | float128P2[ sigNum ].high; 2988 ++sigNum; 2989 if ( float128NumP2 <= sigNum ) { 2990 sigNum = 0; 2991 ++expNum; 2992 if ( float128NumQIn <= expNum ) { 2993 expNum = 0; 2994 sequencePtr->done = TRUE; 2995 } 2996 sequencePtr->expNum = expNum; 2997 } 2998 sequencePtr->term1Num = sigNum; 2999 return z; 3000 3001 } 3002 3003 static float128 float128NextQOutP2( sequenceT *sequencePtr ) 3004 { 3005 int16 expNum, sigNum; 3006 float128 z; 3007 3008 sigNum = sequencePtr->term1Num; 3009 expNum = sequencePtr->expNum; 3010 z.low = float128P2[ sigNum ].low; 3011 z.high = float128QOut[ expNum ] | float128P2[ sigNum ].high; 3012 ++sigNum; 3013 if ( float128NumP2 <= sigNum ) { 3014 sigNum = 0; 3015 ++expNum; 3016 if ( float128NumQOut <= expNum ) { 3017 expNum = 0; 3018 sequencePtr->done = TRUE; 3019 } 3020 sequencePtr->expNum = expNum; 3021 } 3022 sequencePtr->term1Num = sigNum; 3023 return z; 3024 3025 } 3026 3027 static float128 float128RandomQOutP3( void ) 3028 { 3029 int16 sigNum1, sigNum2; 3030 uint64 sig1Low, sig2Low; 3031 float128 z; 3032 3033 sigNum1 = randomUint8() % float128NumP2; 3034 sigNum2 = randomUint8() % float128NumP2; 3035 sig1Low = float128P2[ sigNum1 ].low; 3036 sig2Low = float128P2[ sigNum2 ].low; 3037 z.low = sig1Low + sig2Low; 3038 z.high = 3039 float128QOut[ randomUint8() % float128NumQOut ] 3040 | ( ( float128P2[ sigNum1 ].high 3041 + float128P2[ sigNum2 ].high 3042 + ( z.low < sig1Low ) 3043 ) 3044 & LIT64( 0x0000FFFFFFFFFFFF ) 3045 ); 3046 return z; 3047 3048 } 3049 3050 static float128 float128RandomQOutPInf( void ) 3051 { 3052 float128 z; 3053 3054 z.low = randomUint64(); 3055 z.high = 3056 float128QOut[ randomUint8() % float128NumQOut ] 3057 | ( randomUint64() & LIT64( 0x0000FFFFFFFFFFFF ) ); 3058 return z; 3059 3060 } 3061 3062 enum { 3063 float128NumQInfWeightMasks = 14 3064 }; 3065 3066 static const uint64 float128QInfWeightMasks[ float128NumQInfWeightMasks ] = { 3067 LIT64( 0x7FFF000000000000 ), 3068 LIT64( 0x7FFF000000000000 ), 3069 LIT64( 0x3FFF000000000000 ), 3070 LIT64( 0x1FFF000000000000 ), 3071 LIT64( 0x07FF000000000000 ), 3072 LIT64( 0x07FF000000000000 ), 3073 LIT64( 0x03FF000000000000 ), 3074 LIT64( 0x01FF000000000000 ), 3075 LIT64( 0x00FF000000000000 ), 3076 LIT64( 0x007F000000000000 ), 3077 LIT64( 0x003F000000000000 ), 3078 LIT64( 0x001F000000000000 ), 3079 LIT64( 0x000F000000000000 ), 3080 LIT64( 0x0007000000000000 ) 3081 }; 3082 3083 static const uint64 float128QInfWeightOffsets[ float128NumQInfWeightMasks ] = { 3084 LIT64( 0x0000000000000000 ), 3085 LIT64( 0x0000000000000000 ), 3086 LIT64( 0x2000000000000000 ), 3087 LIT64( 0x3000000000000000 ), 3088 LIT64( 0x3800000000000000 ), 3089 LIT64( 0x3C00000000000000 ), 3090 LIT64( 0x3E00000000000000 ), 3091 LIT64( 0x3F00000000000000 ), 3092 LIT64( 0x3F80000000000000 ), 3093 LIT64( 0x3FC0000000000000 ), 3094 LIT64( 0x3FE0000000000000 ), 3095 LIT64( 0x3FF0000000000000 ), 3096 LIT64( 0x3FF8000000000000 ), 3097 LIT64( 0x3FFC000000000000 ) 3098 }; 3099 3100 static float128 float128RandomQInfP3( void ) 3101 { 3102 int16 sigNum1, sigNum2; 3103 uint64 sig1Low, sig2Low; 3104 int8 weightMaskNum; 3105 float128 z; 3106 3107 sigNum1 = randomUint8() % float128NumP2; 3108 sigNum2 = randomUint8() % float128NumP2; 3109 sig1Low = float128P2[ sigNum1 ].low; 3110 sig2Low = float128P2[ sigNum2 ].low; 3111 z.low = sig1Low + sig2Low; 3112 weightMaskNum = randomUint8() % float128NumQInfWeightMasks; 3113 z.high = 3114 ( ( (uint64) ( randomUint8() & 1 ) )<<63 ) 3115 | ( ( ( ( (uint64) randomUint16() )<<48 ) 3116 & float128QInfWeightMasks[ weightMaskNum ] ) 3117 + float128QInfWeightOffsets[ weightMaskNum ] 3118 ) 3119 | ( ( float128P2[ sigNum1 ].high 3120 + float128P2[ sigNum2 ].high 3121 + ( z.low < sig1Low ) 3122 ) 3123 & LIT64( 0x0000FFFFFFFFFFFF ) 3124 ); 3125 return z; 3126 3127 } 3128 3129 static float128 float128RandomQInfPInf( void ) 3130 { 3131 int8 weightMaskNum; 3132 float128 z; 3133 3134 weightMaskNum = randomUint8() % float128NumQInfWeightMasks; 3135 z.low = randomUint64(); 3136 z.high = 3137 ( ( (uint64) ( randomUint8() & 1 ) )<<63 ) 3138 | ( ( ( ( (uint64) randomUint16() )<<48 ) 3139 & float128QInfWeightMasks[ weightMaskNum ] ) 3140 + float128QInfWeightOffsets[ weightMaskNum ] 3141 ) 3142 | ( randomUint64() & LIT64( 0x0000FFFFFFFFFFFF ) ); 3143 return z; 3144 3145 } 3146 3147 static float128 float128Random( void ) 3148 { 3149 3150 switch ( randomUint8() & 7 ) { 3151 case 0: 3152 case 1: 3153 case 2: 3154 return float128RandomQOutP3(); 3155 case 3: 3156 return float128RandomQOutPInf(); 3157 case 4: 3158 case 5: 3159 case 6: 3160 return float128RandomQInfP3(); 3161 case 7: 3162 return float128RandomQInfPInf(); 3163 } 3164 3165 } 3166 3167 #endif 3168 3169 static int8 level = 0; 3170 3171 void testCases_setLevel( int8 levelIn ) 3172 { 3173 3174 if ( ( levelIn < 1 ) || ( 2 < levelIn ) ) { 3175 fail( "Invalid testing level: %d", levelIn ); 3176 } 3177 level = levelIn; 3178 3179 } 3180 3181 static int8 sequenceType; 3182 static sequenceT sequenceA, sequenceB; 3183 static int8 subcase; 3184 3185 uint32 testCases_total; 3186 flag testCases_done; 3187 3188 static float32 current_a_float32; 3189 static float32 current_b_float32; 3190 static float64 current_a_float64; 3191 static float64 current_b_float64; 3192 #ifdef FLOATX80 3193 static floatx80 current_a_floatx80; 3194 static floatx80 current_b_floatx80; 3195 #endif 3196 #ifdef FLOAT128 3197 static float128 current_a_float128; 3198 static float128 current_b_float128; 3199 #endif 3200 3201 void testCases_initSequence( int8 sequenceTypeIn ) 3202 { 3203 3204 sequenceType = sequenceTypeIn; 3205 sequenceA.term2Num = 0; 3206 sequenceA.term1Num = 0; 3207 sequenceA.expNum = 0; 3208 sequenceA.done = FALSE; 3209 sequenceB.term2Num = 0; 3210 sequenceB.term1Num = 0; 3211 sequenceB.expNum = 0; 3212 sequenceB.done = FALSE; 3213 subcase = 0; 3214 switch ( level ) { 3215 case 1: 3216 switch ( sequenceTypeIn ) { 3217 case testCases_sequence_a_int32: 3218 testCases_total = 3 * int32NumP1; 3219 break; 3220 #ifdef BITS64 3221 case testCases_sequence_a_int64: 3222 testCases_total = 3 * int64NumP1; 3223 break; 3224 #endif 3225 case testCases_sequence_a_float32: 3226 testCases_total = 3 * float32NumQOutP1; 3227 break; 3228 case testCases_sequence_ab_float32: 3229 testCases_total = 6 * float32NumQInP1 * float32NumQInP1; 3230 current_a_float32 = float32NextQInP1( &sequenceA ); 3231 break; 3232 case testCases_sequence_a_float64: 3233 testCases_total = 3 * float64NumQOutP1; 3234 break; 3235 case testCases_sequence_ab_float64: 3236 testCases_total = 6 * float64NumQInP1 * float64NumQInP1; 3237 current_a_float64 = float64NextQInP1( &sequenceA ); 3238 break; 3239 #ifdef FLOATX80 3240 case testCases_sequence_a_floatx80: 3241 testCases_total = 3 * floatx80NumQOutP1; 3242 break; 3243 case testCases_sequence_ab_floatx80: 3244 testCases_total = 6 * floatx80NumQInP1 * floatx80NumQInP1; 3245 current_a_floatx80 = floatx80NextQInP1( &sequenceA ); 3246 break; 3247 #endif 3248 #ifdef FLOAT128 3249 case testCases_sequence_a_float128: 3250 testCases_total = 3 * float128NumQOutP1; 3251 break; 3252 case testCases_sequence_ab_float128: 3253 testCases_total = 6 * float128NumQInP1 * float128NumQInP1; 3254 current_a_float128 = float128NextQInP1( &sequenceA ); 3255 break; 3256 #endif 3257 } 3258 break; 3259 case 2: 3260 switch ( sequenceTypeIn ) { 3261 case testCases_sequence_a_int32: 3262 testCases_total = 2 * int32NumP2; 3263 break; 3264 #ifdef BITS64 3265 case testCases_sequence_a_int64: 3266 testCases_total = 2 * int64NumP2; 3267 break; 3268 #endif 3269 case testCases_sequence_a_float32: 3270 testCases_total = 2 * float32NumQOutP2; 3271 break; 3272 case testCases_sequence_ab_float32: 3273 testCases_total = 2 * float32NumQInP2 * float32NumQInP2; 3274 current_a_float32 = float32NextQInP2( &sequenceA ); 3275 break; 3276 case testCases_sequence_a_float64: 3277 testCases_total = 2 * float64NumQOutP2; 3278 break; 3279 case testCases_sequence_ab_float64: 3280 testCases_total = 2 * float64NumQInP2 * float64NumQInP2; 3281 current_a_float64 = float64NextQInP2( &sequenceA ); 3282 break; 3283 #ifdef FLOATX80 3284 case testCases_sequence_a_floatx80: 3285 testCases_total = 2 * floatx80NumQOutP2; 3286 break; 3287 case testCases_sequence_ab_floatx80: 3288 testCases_total = 2 * floatx80NumQInP2 * floatx80NumQInP2; 3289 current_a_floatx80 = floatx80NextQInP2( &sequenceA ); 3290 break; 3291 #endif 3292 #ifdef FLOAT128 3293 case testCases_sequence_a_float128: 3294 testCases_total = 2 * float128NumQOutP2; 3295 break; 3296 case testCases_sequence_ab_float128: 3297 testCases_total = 2 * float128NumQInP2 * float128NumQInP2; 3298 current_a_float128 = float128NextQInP2( &sequenceA ); 3299 break; 3300 #endif 3301 } 3302 break; 3303 } 3304 testCases_done = FALSE; 3305 3306 } 3307 3308 int32 testCases_a_int32; 3309 #ifdef BITS64 3310 int64 testCases_a_int64; 3311 #endif 3312 float32 testCases_a_float32; 3313 float32 testCases_b_float32; 3314 float64 testCases_a_float64; 3315 float64 testCases_b_float64; 3316 #ifdef FLOATX80 3317 floatx80 testCases_a_floatx80; 3318 floatx80 testCases_b_floatx80; 3319 #endif 3320 #ifdef FLOAT128 3321 float128 testCases_a_float128; 3322 float128 testCases_b_float128; 3323 #endif 3324 3325 void testCases_next( void ) 3326 { 3327 3328 switch ( level ) { 3329 case 1: 3330 switch ( sequenceType ) { 3331 case testCases_sequence_a_int32: 3332 switch ( subcase ) { 3333 case 0: 3334 testCases_a_int32 = int32RandomP3(); 3335 break; 3336 case 1: 3337 testCases_a_int32 = int32RandomPInf(); 3338 break; 3339 case 2: 3340 testCases_a_int32 = int32NextP1( &sequenceA ); 3341 testCases_done = sequenceA.done; 3342 subcase = -1; 3343 break; 3344 } 3345 ++subcase; 3346 break; 3347 #ifdef BITS64 3348 case testCases_sequence_a_int64: 3349 switch ( subcase ) { 3350 case 0: 3351 testCases_a_int64 = int64RandomP3(); 3352 break; 3353 case 1: 3354 testCases_a_int64 = int64RandomPInf(); 3355 break; 3356 case 2: 3357 testCases_a_int64 = int64NextP1( &sequenceA ); 3358 testCases_done = sequenceA.done; 3359 subcase = -1; 3360 break; 3361 } 3362 ++subcase; 3363 break; 3364 #endif 3365 case testCases_sequence_a_float32: 3366 switch ( subcase ) { 3367 case 0: 3368 case 1: 3369 testCases_a_float32 = float32Random(); 3370 break; 3371 case 2: 3372 testCases_a_float32 = float32NextQOutP1( &sequenceA ); 3373 testCases_done = sequenceA.done; 3374 subcase = -1; 3375 break; 3376 } 3377 ++subcase; 3378 break; 3379 case testCases_sequence_ab_float32: 3380 switch ( subcase ) { 3381 case 0: 3382 if ( sequenceB.done ) { 3383 sequenceB.done = FALSE; 3384 current_a_float32 = float32NextQInP1( &sequenceA ); 3385 } 3386 current_b_float32 = float32NextQInP1( &sequenceB ); 3387 case 2: 3388 case 4: 3389 testCases_a_float32 = float32Random(); 3390 testCases_b_float32 = float32Random(); 3391 break; 3392 case 1: 3393 testCases_a_float32 = current_a_float32; 3394 testCases_b_float32 = float32Random(); 3395 break; 3396 case 3: 3397 testCases_a_float32 = float32Random(); 3398 testCases_b_float32 = current_b_float32; 3399 break; 3400 case 5: 3401 testCases_a_float32 = current_a_float32; 3402 testCases_b_float32 = current_b_float32; 3403 testCases_done = sequenceA.done & sequenceB.done; 3404 subcase = -1; 3405 break; 3406 } 3407 ++subcase; 3408 break; 3409 case testCases_sequence_a_float64: 3410 switch ( subcase ) { 3411 case 0: 3412 case 1: 3413 testCases_a_float64 = float64Random(); 3414 break; 3415 case 2: 3416 testCases_a_float64 = float64NextQOutP1( &sequenceA ); 3417 testCases_done = sequenceA.done; 3418 subcase = -1; 3419 break; 3420 } 3421 ++subcase; 3422 break; 3423 case testCases_sequence_ab_float64: 3424 switch ( subcase ) { 3425 case 0: 3426 if ( sequenceB.done ) { 3427 sequenceB.done = FALSE; 3428 current_a_float64 = float64NextQInP1( &sequenceA ); 3429 } 3430 current_b_float64 = float64NextQInP1( &sequenceB ); 3431 case 2: 3432 case 4: 3433 testCases_a_float64 = float64Random(); 3434 testCases_b_float64 = float64Random(); 3435 break; 3436 case 1: 3437 testCases_a_float64 = current_a_float64; 3438 testCases_b_float64 = float64Random(); 3439 break; 3440 case 3: 3441 testCases_a_float64 = float64Random(); 3442 testCases_b_float64 = current_b_float64; 3443 break; 3444 case 5: 3445 testCases_a_float64 = current_a_float64; 3446 testCases_b_float64 = current_b_float64; 3447 testCases_done = sequenceA.done & sequenceB.done; 3448 subcase = -1; 3449 break; 3450 } 3451 ++subcase; 3452 break; 3453 #ifdef FLOATX80 3454 case testCases_sequence_a_floatx80: 3455 switch ( subcase ) { 3456 case 0: 3457 case 1: 3458 testCases_a_floatx80 = floatx80Random(); 3459 break; 3460 case 2: 3461 testCases_a_floatx80 = floatx80NextQOutP1( &sequenceA ); 3462 testCases_done = sequenceA.done; 3463 subcase = -1; 3464 break; 3465 } 3466 ++subcase; 3467 break; 3468 case testCases_sequence_ab_floatx80: 3469 switch ( subcase ) { 3470 case 0: 3471 if ( sequenceB.done ) { 3472 sequenceB.done = FALSE; 3473 current_a_floatx80 = floatx80NextQInP1( &sequenceA ); 3474 } 3475 current_b_floatx80 = floatx80NextQInP1( &sequenceB ); 3476 case 2: 3477 case 4: 3478 testCases_a_floatx80 = floatx80Random(); 3479 testCases_b_floatx80 = floatx80Random(); 3480 break; 3481 case 1: 3482 testCases_a_floatx80 = current_a_floatx80; 3483 testCases_b_floatx80 = floatx80Random(); 3484 break; 3485 case 3: 3486 testCases_a_floatx80 = floatx80Random(); 3487 testCases_b_floatx80 = current_b_floatx80; 3488 break; 3489 case 5: 3490 testCases_a_floatx80 = current_a_floatx80; 3491 testCases_b_floatx80 = current_b_floatx80; 3492 testCases_done = sequenceA.done & sequenceB.done; 3493 subcase = -1; 3494 break; 3495 } 3496 ++subcase; 3497 break; 3498 #endif 3499 #ifdef FLOAT128 3500 case testCases_sequence_a_float128: 3501 switch ( subcase ) { 3502 case 0: 3503 case 1: 3504 testCases_a_float128 = float128Random(); 3505 break; 3506 case 2: 3507 testCases_a_float128 = float128NextQOutP1( &sequenceA ); 3508 testCases_done = sequenceA.done; 3509 subcase = -1; 3510 break; 3511 } 3512 ++subcase; 3513 break; 3514 case testCases_sequence_ab_float128: 3515 switch ( subcase ) { 3516 case 0: 3517 if ( sequenceB.done ) { 3518 sequenceB.done = FALSE; 3519 current_a_float128 = float128NextQInP1( &sequenceA ); 3520 } 3521 current_b_float128 = float128NextQInP1( &sequenceB ); 3522 case 2: 3523 case 4: 3524 testCases_a_float128 = float128Random(); 3525 testCases_b_float128 = float128Random(); 3526 break; 3527 case 1: 3528 testCases_a_float128 = current_a_float128; 3529 testCases_b_float128 = float128Random(); 3530 break; 3531 case 3: 3532 testCases_a_float128 = float128Random(); 3533 testCases_b_float128 = current_b_float128; 3534 break; 3535 case 5: 3536 testCases_a_float128 = current_a_float128; 3537 testCases_b_float128 = current_b_float128; 3538 testCases_done = sequenceA.done & sequenceB.done; 3539 subcase = -1; 3540 break; 3541 } 3542 ++subcase; 3543 break; 3544 #endif 3545 } 3546 break; 3547 case 2: 3548 switch ( sequenceType ) { 3549 case testCases_sequence_a_int32: 3550 switch ( subcase ) { 3551 case 0: 3552 testCases_a_int32 = int32RandomP3(); 3553 break; 3554 case 2: 3555 testCases_a_int32 = int32RandomPInf(); 3556 break; 3557 case 3: 3558 subcase = -1; 3559 case 1: 3560 testCases_a_int32 = int32NextP2( &sequenceA ); 3561 testCases_done = sequenceA.done; 3562 break; 3563 } 3564 ++subcase; 3565 break; 3566 #ifdef BITS64 3567 case testCases_sequence_a_int64: 3568 switch ( subcase ) { 3569 case 0: 3570 testCases_a_int64 = int64RandomP3(); 3571 break; 3572 case 2: 3573 testCases_a_int64 = int64RandomPInf(); 3574 break; 3575 case 3: 3576 subcase = -1; 3577 case 1: 3578 testCases_a_int64 = int64NextP2( &sequenceA ); 3579 testCases_done = sequenceA.done; 3580 break; 3581 } 3582 ++subcase; 3583 break; 3584 #endif 3585 case testCases_sequence_a_float32: 3586 switch ( subcase ) { 3587 case 0: 3588 testCases_a_float32 = float32Random(); 3589 break; 3590 case 1: 3591 testCases_a_float32 = float32NextQOutP2( &sequenceA ); 3592 testCases_done = sequenceA.done; 3593 subcase = -1; 3594 break; 3595 } 3596 ++subcase; 3597 break; 3598 case testCases_sequence_ab_float32: 3599 switch ( subcase ) { 3600 case 0: 3601 testCases_a_float32 = float32Random(); 3602 testCases_b_float32 = float32Random(); 3603 break; 3604 case 1: 3605 if ( sequenceB.done ) { 3606 sequenceB.done = FALSE; 3607 current_a_float32 = float32NextQInP2( &sequenceA ); 3608 } 3609 testCases_a_float32 = current_a_float32; 3610 testCases_b_float32 = float32NextQInP2( &sequenceB ); 3611 testCases_done = sequenceA.done & sequenceB.done; 3612 subcase = -1; 3613 break; 3614 } 3615 ++subcase; 3616 break; 3617 case testCases_sequence_a_float64: 3618 switch ( subcase ) { 3619 case 0: 3620 testCases_a_float64 = float64Random(); 3621 break; 3622 case 1: 3623 testCases_a_float64 = float64NextQOutP2( &sequenceA ); 3624 testCases_done = sequenceA.done; 3625 subcase = -1; 3626 break; 3627 } 3628 ++subcase; 3629 break; 3630 case testCases_sequence_ab_float64: 3631 switch ( subcase ) { 3632 case 0: 3633 testCases_a_float64 = float64Random(); 3634 testCases_b_float64 = float64Random(); 3635 break; 3636 case 1: 3637 if ( sequenceB.done ) { 3638 sequenceB.done = FALSE; 3639 current_a_float64 = float64NextQInP2( &sequenceA ); 3640 } 3641 testCases_a_float64 = current_a_float64; 3642 testCases_b_float64 = float64NextQInP2( &sequenceB ); 3643 testCases_done = sequenceA.done & sequenceB.done; 3644 subcase = -1; 3645 break; 3646 } 3647 ++subcase; 3648 break; 3649 #ifdef FLOATX80 3650 case testCases_sequence_a_floatx80: 3651 switch ( subcase ) { 3652 case 0: 3653 testCases_a_floatx80 = floatx80Random(); 3654 break; 3655 case 1: 3656 testCases_a_floatx80 = floatx80NextQOutP2( &sequenceA ); 3657 testCases_done = sequenceA.done; 3658 subcase = -1; 3659 break; 3660 } 3661 ++subcase; 3662 break; 3663 case testCases_sequence_ab_floatx80: 3664 switch ( subcase ) { 3665 case 0: 3666 testCases_a_floatx80 = floatx80Random(); 3667 testCases_b_floatx80 = floatx80Random(); 3668 break; 3669 case 1: 3670 if ( sequenceB.done ) { 3671 sequenceB.done = FALSE; 3672 current_a_floatx80 = floatx80NextQInP2( &sequenceA ); 3673 } 3674 testCases_a_floatx80 = current_a_floatx80; 3675 testCases_b_floatx80 = floatx80NextQInP2( &sequenceB ); 3676 testCases_done = sequenceA.done & sequenceB.done; 3677 subcase = -1; 3678 break; 3679 } 3680 ++subcase; 3681 break; 3682 #endif 3683 #ifdef FLOAT128 3684 case testCases_sequence_a_float128: 3685 switch ( subcase ) { 3686 case 0: 3687 testCases_a_float128 = float128Random(); 3688 break; 3689 case 1: 3690 testCases_a_float128 = float128NextQOutP2( &sequenceA ); 3691 testCases_done = sequenceA.done; 3692 subcase = -1; 3693 break; 3694 } 3695 ++subcase; 3696 break; 3697 case testCases_sequence_ab_float128: 3698 switch ( subcase ) { 3699 case 0: 3700 testCases_a_float128 = float128Random(); 3701 testCases_b_float128 = float128Random(); 3702 break; 3703 case 1: 3704 if ( sequenceB.done ) { 3705 sequenceB.done = FALSE; 3706 current_a_float128 = float128NextQInP2( &sequenceA ); 3707 } 3708 testCases_a_float128 = current_a_float128; 3709 testCases_b_float128 = float128NextQInP2( &sequenceB ); 3710 testCases_done = sequenceA.done & sequenceB.done; 3711 subcase = -1; 3712 break; 3713 } 3714 ++subcase; 3715 break; 3716 #endif 3717 } 3718 break; 3719 } 3720 3721 } 3722 3723