139 sc_core::sc_abort(); // can't recover from here 140} 141 142 143// ---------------------------------------------------------------------------- 144 145// ---------------------------------------------------------------------------- 146// SECTION: Public members. 147// ---------------------------------------------------------------------------- 148 149// Most public members are included from sc_nbcommon.inc. However, some 150// concatenation support appears here to optimize between the signed and 151// unsigned cases. 152 153// Insert this object's value at the specified place in a vector of biguint 154// style values. 155 156bool 157sc_signed::concat_get_ctrl(sc_digit *dst_p, int low_i) const 158{ 159 int dst_i; // Index to next word to set in dst_p. 160 int end_i; // Index of high order word to set. 161 int left_shift; // Amount to shift value left. 162 sc_digit mask; // Mask for partial word sets. 163 164 // CALCULATE METRICS FOR DATA MOVEMENT: 165 dst_i = low_i / BITS_PER_DIGIT; 166 end_i = (low_i + nbits - 1) / BITS_PER_DIGIT; 167 left_shift = low_i % BITS_PER_DIGIT; 168 169 // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 170 mask = ~(~0U << left_shift); 171 dst_p[dst_i] = (dst_p[dst_i] & ~mask); 172 dst_i++; 173 174 for (; dst_i <= end_i; dst_i++) 175 dst_p[dst_i] = 0; 176 177 return false; 178} 179 180bool 181sc_signed::concat_get_data(sc_digit *dst_p, int low_i) const 182{ 183 sc_digit carry; // Carry bit for complements. 184 int dst_i; // Index to next word to set in dst_p. 185 int end_i; // Index of high order word to set. 186 int high_i; // Index w/in word of high order bit. 187 int left_shift; // Amount to shift value left. 188 sc_digit left_word; // High word component for set. 189 sc_digit mask; // Mask for partial word sets. 190 bool result; // True if inserted non-zero data. 191 int right_shift; // Amount to shift value right. 192 sc_digit right_word; // Low word component for set. 193 int src_i; // Index to next word to get from digit. 194 195 // CALCULATE METRICS FOR DATA MOVEMENT: 196 dst_i = low_i / BITS_PER_DIGIT; 197 high_i = low_i + nbits - 1; 198 end_i = high_i / BITS_PER_DIGIT; 199 left_shift = low_i % BITS_PER_DIGIT; 200 201 switch (sgn) { 202 // POSITIVE SOURCE VALUE: 203 case SC_POS: 204 result = true; 205 206 // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 207 if (dst_i == end_i) { 208 mask = ~(~0U << left_shift); 209 dst_p[dst_i] = ((dst_p[dst_i] & mask) | 210 (digit[0] << left_shift)) & DIGIT_MASK; 211 212 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED: 213 } else if (left_shift == 0) { 214 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) { 215 dst_p[dst_i] = digit[src_i]; 216 } 217 high_i = high_i % BITS_PER_DIGIT; 218 mask = ~(~1U << high_i) & DIGIT_MASK; 219 dst_p[dst_i] = digit[src_i] & mask; 220 221 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED: 222 } else { 223 high_i = high_i % BITS_PER_DIGIT; 224 right_shift = BITS_PER_DIGIT - left_shift; 225 mask = ~(~0U << left_shift); 226 right_word = digit[0]; 227 dst_p[dst_i] = (dst_p[dst_i] & mask) | 228 ((right_word << left_shift) & DIGIT_MASK); 229 for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) { 230 left_word = digit[src_i]; 231 dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) | 232 (right_word >> right_shift); 233 right_word = left_word; 234 } 235 left_word = (src_i < ndigits) ? digit[src_i] : 0; 236 mask = ~(~1U << high_i) & DIGIT_MASK; 237 dst_p[dst_i] = ((left_word << left_shift) | 238 (right_word >> right_shift)) & mask; 239 } 240 break; 241 242 // SOURCE VALUE IS NEGATIVE: 243 case SC_NEG: 244 // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 245 result = true; 246 if (dst_i == end_i) { 247 mask = ~(~0U << nbits); 248 right_word = ((digit[0] ^ DIGIT_MASK) + 1) & mask; 249 mask = ~(~0U << left_shift); 250 dst_p[dst_i] = ((dst_p[dst_i] & mask) | 251 (right_word << left_shift)) & DIGIT_MASK; 252 253 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED: 254 } else if (left_shift == 0) { 255 carry = 1; 256 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) { 257 right_word = (digit[src_i] ^ DIGIT_MASK) + carry; 258 dst_p[dst_i] = right_word & DIGIT_MASK; 259 carry = right_word >> BITS_PER_DIGIT; 260 } 261 high_i = high_i % BITS_PER_DIGIT; 262 mask = (~(~1U << high_i)) & DIGIT_MASK; 263 right_word = (src_i < ndigits) ? 264 (digit[src_i] ^ DIGIT_MASK) + carry : DIGIT_MASK + carry; 265 dst_p[dst_i] = right_word & mask; 266 267 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED: 268 } else { 269 high_i = high_i % BITS_PER_DIGIT; 270 right_shift = BITS_PER_DIGIT - left_shift; 271 mask = ~(~0U << left_shift); 272 carry = 1; 273 right_word = (digit[0] ^ DIGIT_MASK) + carry; 274 dst_p[dst_i] = (dst_p[dst_i] & mask) | 275 ((right_word << left_shift) & DIGIT_MASK); 276 carry = right_word >> BITS_PER_DIGIT; 277 right_word &= DIGIT_MASK; 278 for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) { 279 left_word = (digit[src_i] ^ DIGIT_MASK) + carry; 280 dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) | 281 (right_word >> right_shift); 282 carry = left_word >> BITS_PER_DIGIT; 283 right_word = left_word & DIGIT_MASK; 284 } 285 left_word = (src_i < ndigits) ? 286 (digit[src_i] ^ DIGIT_MASK) + carry : carry; 287 mask = ~(~1U << high_i) & DIGIT_MASK; 288 dst_p[dst_i] = ((left_word << left_shift) | 289 (right_word >> right_shift)) & mask; 290 } 291 break; 292 293 // VALUE IS ZERO: 294 default: 295 result = false; 296 // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 297 if (dst_i == end_i) { 298 mask = ~(~0U << nbits) << left_shift; 299 dst_p[dst_i] = dst_p[dst_i] & ~mask; 300 301 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED: 302 } else if (left_shift == 0) { 303 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) { 304 dst_p[dst_i] = 0; 305 } 306 dst_p[dst_i] = 0; 307 308 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED: 309 } else { 310 mask = ~(~0U << left_shift); 311 dst_p[dst_i] = (dst_p[dst_i] & mask); 312 for (dst_i++; dst_i <= end_i; dst_i++) { 313 dst_p[dst_i] = 0; 314 } 315 } 316 break; 317 } 318 return result; 319} 320 321// Return this object instance's bits as a uint64 without sign extension. 322 323uint64 324sc_signed::concat_get_uint64() const 325{ 326 uint64 result; 327 switch (sgn) { 328 case SC_POS: 329 result = 0; 330 if (ndigits > 2) 331 result = digit[2]; 332 if (ndigits > 1) 333 result = (result << BITS_PER_DIGIT) | digit[1]; 334 result = (result << BITS_PER_DIGIT) | digit[0]; 335 break; 336 case SC_NEG: 337 result = 0; 338 if (ndigits > 2) 339 result = digit[2]; 340 if (ndigits > 1) 341 result = (result << BITS_PER_DIGIT) | digit[1]; 342 result = (result << BITS_PER_DIGIT) | digit[0]; 343 result = -result; 344 if (nbits < 64) { 345 uint64 mask = ~0; 346 result = result & ~(mask << nbits); 347 } 348 break; 349 default: 350 result = 0; 351 break; 352 } 353 return result; 354} 355 356// #### OPTIMIZE 357void 358sc_signed::concat_set(int64 src, int low_i) 359{ 360 *this = (low_i < 64) ? src >> low_i : src >> 63; 361} 362 363void 364sc_signed::concat_set(const sc_signed &src, int low_i) 365{ 366 if (low_i < src.length()) 367 *this = src >> low_i; 368 else 369 *this = (src<0) ? (int_type)-1 : 0; 370} 371 372void 373sc_signed::concat_set(const sc_unsigned &src, int low_i) 374{ 375 if (low_i < src.length()) 376 *this = src >> low_i; 377 else 378 *this = 0; 379} 380 381void 382sc_signed::concat_set(uint64 src, int low_i) 383{ 384 *this = (low_i < 64) ? src >> low_i : 0; 385} 386 387// ---------------------------------------------------------------------------- 388// SECTION: Public members - Reduction methods. 389// ---------------------------------------------------------------------------- 390 391bool 392sc_signed::and_reduce() const 393{ 394 sc_digit current; // Current digit examining. 395 int i; // Index of digit examining. 396 397 if (sgn == SC_NEG) { 398 current = (1 << BITS_PER_DIGIT); 399 for (i = 0; i < ndigits-1; i++) { 400 current = (current >> BITS_PER_DIGIT) + (digit[i]^DIGIT_MASK); 401 if ((current & DIGIT_MASK) != DIGIT_MASK) return false; 402 } 403 current = (current >> BITS_PER_DIGIT) + (digit[i]^DIGIT_MASK); 404 if ((current & ~(~0U << (nbits % BITS_PER_DIGIT))) == 405 static_cast<sc_digit>(~(~0U << (nbits % BITS_PER_DIGIT)))) { 406 return true; 407 } 408 } 409 return false; 410} 411 412bool 413sc_signed::or_reduce() const 414{ 415 return sgn == SC_ZERO ? false : true; 416} 417 418bool 419sc_signed::xor_reduce() const 420{ 421 int i; // Digit examining. 422 int odd; // Flag for odd number of digits. 423 424 odd = 0; 425 for (i = 0; i < nbits; i++) 426 if (test(i)) 427 odd = ~odd; 428 return odd ? true : false; 429} 430 431 432 433// ---------------------------------------------------------------------------- 434// SECTION: Public members - Assignment operators. 435// ---------------------------------------------------------------------------- 436 437// assignment operators 438 439const sc_signed & 440sc_signed::operator = (const char *a) 441{ 442 if (a == 0) { 443 SC_REPORT_ERROR("conversion failed", 444 "character string is zero"); 445 } else if (*a == 0) { 446 SC_REPORT_ERROR("conversion failed", 447 "character string is empty"); 448 } else try { 449 int len = length(); 450 sc_fix aa(a, len, len, SC_TRN, SC_WRAP, 0, SC_ON); 451 return this->operator = (aa); 452 } catch(const sc_core::sc_report &) { 453 std::stringstream msg; 454 msg << "character string '" << a << "' is not valid"; 455 SC_REPORT_ERROR("conversion failed", msg.str().c_str()); 456 } 457 return *this; 458} 459 460const sc_signed & 461sc_signed::operator=(int64 v) 462{ 463 sgn = get_sign(v); 464 // v >= 0 now. 465 if (sgn == SC_ZERO) { 466 vec_zero(ndigits, digit); 467 } else { 468 from_uint(ndigits, digit, (uint64)v); 469 if (nbits <= (int)BITS_PER_INT64) 470 convert_SM_to_2C_to_SM(); 471 } 472 return *this; 473} 474 475const sc_signed & 476sc_signed::operator=(uint64 v) 477{ 478 sgn = get_sign(v); 479 if (sgn == SC_ZERO) { 480 vec_zero(ndigits, digit); 481 } else { 482 from_uint(ndigits, digit, v); 483 if (nbits <= (int)BITS_PER_INT64) 484 convert_SM_to_2C_to_SM(); 485 } 486 return *this; 487} 488 489const sc_signed & 490sc_signed::operator=(long v) 491{ 492 sgn = get_sign(v); 493 // v >= 0 now. 494 if (sgn == SC_ZERO) { 495 vec_zero(ndigits, digit); 496 } else { 497 from_uint(ndigits, digit, (unsigned long)v); 498 if (nbits <= (int)BITS_PER_LONG) 499 convert_SM_to_2C_to_SM(); 500 } 501 return *this; 502} 503 504const sc_signed & 505sc_signed::operator=(unsigned long v) 506{ 507 sgn = get_sign(v); 508 if (sgn == SC_ZERO) { 509 vec_zero(ndigits, digit); 510 } else { 511 from_uint(ndigits, digit, v); 512 if (nbits <= (int)BITS_PER_LONG) 513 convert_SM_to_2C_to_SM(); 514 } 515 return *this; 516} 517 518const sc_signed & 519sc_signed::operator=(double v) 520{ 521 is_bad_double(v); 522 if (v < 0) { 523 v = -v; 524 sgn = SC_NEG; 525 } else { 526 sgn = SC_POS; 527 } 528 529 int i = 0; 530 while (std::floor(v) && (i < ndigits)) { 531 digit[i++] = ((sc_digit)std::floor(remainder(v, DIGIT_RADIX))) & 532 DIGIT_MASK; 533 v /= DIGIT_RADIX; 534 } 535 vec_zero(i, ndigits, digit); 536 convert_SM_to_2C_to_SM(); 537 return *this; 538} 539 540 541// ---------------------------------------------------------------------------- 542 543const sc_signed & 544sc_signed::operator = (const sc_bv_base &v) 545{ 546 int minlen = sc_min(nbits, v.length()); 547 int i = 0; 548 for (; i < minlen; ++i) { 549 safe_set(i, v.get_bit(i), digit); 550 } 551 for (; i < nbits; ++i) { 552 safe_set(i, 0, digit); // zero-extend 553 } 554 convert_2C_to_SM(); 555 return *this; 556} 557 558const sc_signed & 559sc_signed::operator = (const sc_lv_base &v) 560{ 561 int minlen = sc_min(nbits, v.length()); 562 int i = 0; 563 for (; i < minlen; ++i) { 564 safe_set(i, sc_logic(v.get_bit(i)).to_bool(), digit); 565 } 566 for (; i < nbits; ++i) { 567 safe_set(i, 0, digit); // zero-extend 568 } 569 convert_2C_to_SM(); 570 return *this; 571} 572 573 574// explicit conversion to character string 575const std::string 576sc_signed::to_string(sc_numrep numrep) const 577{ 578 int len = length(); 579 sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON); 580 return aa.to_string(numrep); 581} 582 583const std::string 584sc_signed::to_string(sc_numrep numrep, bool w_prefix) const 585{ 586 int len = length(); 587 sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON); 588 return aa.to_string(numrep, w_prefix); 589} 590 591 592// ---------------------------------------------------------------------------- 593// SECTION: Interfacing with sc_int_base 594// ---------------------------------------------------------------------------- 595 596const sc_signed & 597sc_signed::operator = (const sc_int_base &v) 598{ 599 return operator = ((int64)v); 600} 601 602 603sc_signed 604operator + (const sc_unsigned &u, const sc_int_base &v) 605{ 606 return operator + (u, static_cast<int64>(v)); 607} 608 609sc_signed 610operator + (const sc_int_base &u, const sc_unsigned &v) 611{ 612 return operator + (static_cast<int64>(u), v); 613} 614 615sc_signed 616operator + (const sc_signed &u, const sc_int_base &v) 617{ 618 return operator + (u, (int64)v); 619} 620 621sc_signed 622operator + (const sc_int_base &u, const sc_signed &v) 623{ 624 return operator + ((int64)u, v); 625} 626 627const sc_signed & 628sc_signed::operator += (const sc_int_base &v) 629{ 630 return operator += ((int64)v); 631} 632 633 634sc_signed 635operator - (const sc_unsigned &u, const sc_int_base &v) 636{ 637 return operator - (u, (int64)v); 638} 639 640sc_signed 641operator - (const sc_int_base &u, const sc_unsigned &v) 642{ 643 return operator - ((int64)u, v); 644} 645 646sc_signed 647operator - (const sc_signed &u, const sc_int_base &v) 648{ 649 return operator - (u, (int64)v); 650} 651 652sc_signed 653operator - (const sc_int_base &u, const sc_signed &v) 654{ 655 return operator - ((int64)u, v); 656} 657 658const sc_signed & 659sc_signed::operator -= (const sc_int_base &v) 660{ 661 return operator -= ((int64)v); 662} 663 664 665sc_signed 666operator * (const sc_unsigned &u, const sc_int_base &v) 667{ 668 return operator * (u, static_cast<int64>(v)); 669} 670 671sc_signed 672operator * (const sc_int_base &u, const sc_unsigned &v) 673{ 674 return operator * (static_cast<int64>(u), v); 675} 676 677sc_signed 678operator * (const sc_signed &u, const sc_int_base &v) 679{ 680 return operator * (u, (int64)v); 681} 682 683sc_signed 684operator * (const sc_int_base &u, const sc_signed &v) 685{ 686 return operator * ((int64)u, v); 687} 688 689const sc_signed & 690sc_signed::operator *= (const sc_int_base &v) 691{ 692 return operator *= ((int64)v); 693} 694 695 696sc_signed 697operator / (const sc_unsigned &u, const sc_int_base &v) 698{ 699 return operator / (u, static_cast<int64>(v)); 700} 701 702sc_signed 703operator / (const sc_int_base &u, const sc_unsigned &v) 704{ 705 return operator / (static_cast<int64>(u), v); 706} 707 708sc_signed 709operator / (const sc_signed &u, const sc_int_base &v) 710{ 711 return operator / (u, (int64)v); 712} 713 714sc_signed 715operator / (const sc_int_base &u, const sc_signed &v) 716{ 717 return operator / ((int64)u, v); 718} 719 720const sc_signed & 721sc_signed::operator /= (const sc_int_base &v) 722{ 723 return operator /= ((int64)v); 724} 725 726 727sc_signed 728operator % (const sc_unsigned &u, const sc_int_base &v) 729{ 730 return operator % (u, static_cast<int64>(v)); 731} 732 733sc_signed 734operator % (const sc_int_base &u, const sc_unsigned &v) 735{ 736 return operator % (static_cast<int64>(u), v); 737} 738 739sc_signed 740operator % (const sc_signed &u, const sc_int_base &v) 741{ 742 return operator % (u, (int64)v); 743} 744 745sc_signed 746operator % (const sc_int_base &u, const sc_signed &v) 747{ 748 return operator % ((int64)u, v); 749} 750 751const sc_signed & 752sc_signed::operator %= (const sc_int_base &v) 753{ 754 return operator %= ((int64)v); 755} 756 757 758sc_signed 759operator & (const sc_unsigned &u, const sc_int_base &v) 760{ 761 return operator & (u, static_cast<int64>(v)); 762} 763 764sc_signed 765operator & (const sc_int_base &u, const sc_unsigned &v) 766{ 767 return operator & (static_cast<int64>(u), v); 768} 769 770sc_signed 771operator & (const sc_signed &u, const sc_int_base &v) 772{ 773 return operator & (u, (int64)v); 774} 775 776sc_signed 777operator & (const sc_int_base &u, const sc_signed &v) 778{ 779 return operator & ((int64)u, v); 780} 781 782const sc_signed & 783sc_signed::operator &= (const sc_int_base &v) 784{ 785 return operator &= ((int64)v); 786} 787 788 789sc_signed 790operator | (const sc_unsigned &u, const sc_int_base &v) 791{ 792 return operator | (u, static_cast<int64>(v)); 793} 794 795sc_signed 796operator | (const sc_int_base &u, const sc_unsigned &v) 797{ 798 return operator | (static_cast<int64>(u), v); 799} 800 801sc_signed 802operator | (const sc_signed& u, const sc_int_base &v) 803{ 804 return operator|(u, (int64)v); 805} 806 807sc_signed 808operator | (const sc_int_base &u, const sc_signed &v) 809{ 810 return operator | ((int64)u, v); 811} 812 813const sc_signed & 814sc_signed::operator |= (const sc_int_base &v) 815{ 816 return operator |= ((int64)v); 817} 818 819 820sc_signed 821operator ^ (const sc_unsigned &u, const sc_int_base &v) 822{ 823 return operator ^ (u, static_cast<int64>(v)); 824} 825 826sc_signed 827operator ^ (const sc_int_base &u, const sc_unsigned &v) 828{ 829 return operator ^ (static_cast<int64>(u), v); 830} 831 832sc_signed 833operator ^ (const sc_signed &u, const sc_int_base &v) 834{ 835 return operator ^ (u, (int64)v); 836} 837 838sc_signed 839operator ^ (const sc_int_base &u, const sc_signed &v) 840{ 841 return operator ^ ((int64)u, v); 842} 843 844const sc_signed & 845sc_signed::operator ^= (const sc_int_base &v) 846{ 847 return operator ^= ((int64)v); 848} 849 850 851sc_signed 852operator << (const sc_signed &u, const sc_int_base &v) 853{ 854 return operator << (u, (int64)v); 855} 856 857const sc_signed & 858sc_signed::operator <<= (const sc_int_base &v) 859{ 860 return operator <<= ((int64)v); 861} 862 863 864sc_signed 865operator >> (const sc_signed &u, const sc_int_base &v) 866{ 867 return operator >> (u, (int64)v); 868} 869 870const sc_signed & 871sc_signed::operator >>= (const sc_int_base &v) 872{ 873 return operator >>= ((int64)v); 874} 875 876 877bool 878operator == (const sc_signed &u, const sc_int_base &v) 879{ 880 return operator == (u, (int64)v); 881} 882 883bool 884operator == (const sc_int_base &u, const sc_signed &v) 885{ 886 return operator == ((int64)u, v); 887} 888 889 890bool 891operator != (const sc_signed &u, const sc_int_base &v) 892{ 893 return operator != (u, (int64)v); 894} 895 896bool 897operator != (const sc_int_base &u, const sc_signed &v) 898{ 899 return operator != ((int64)u, v); 900} 901 902 903bool 904operator < (const sc_signed &u, const sc_int_base &v) 905{ 906 return operator < (u, (int64)v); 907} 908 909bool 910operator < (const sc_int_base &u, const sc_signed &v) 911{ 912 return operator < ((int64)u, v); 913} 914 915 916bool 917operator <= (const sc_signed &u, const sc_int_base &v) 918{ 919 return operator <= (u, (int64)v); 920} 921 922bool 923operator <= (const sc_int_base &u, const sc_signed &v) 924{ 925 return operator <= ((int64)u, v); 926} 927 928 929bool 930operator > (const sc_signed &u, const sc_int_base &v) 931{ 932 return operator > (u, (int64)v); 933} 934 935bool 936operator > (const sc_int_base &u, const sc_signed &v) 937{ 938 return operator > ((int64)u, v); 939} 940 941 942bool 943operator >= (const sc_signed &u, const sc_int_base &v) 944{ 945 return operator >= (u, (int64)v); 946} 947 948bool 949operator >= (const sc_int_base &u, const sc_signed &v) 950{ 951 return operator >= ((int64)u, v); 952} 953 954 955// ---------------------------------------------------------------------------- 956// SECTION: Interfacing with sc_uint_base 957// ---------------------------------------------------------------------------- 958 959const sc_signed & 960sc_signed::operator = (const sc_uint_base &v) 961{ 962 return operator = ((uint64)v); 963} 964 965 966sc_signed 967operator + (const sc_signed &u, const sc_uint_base &v) 968{ 969 return operator + (u, (uint64)v); 970} 971 972sc_signed 973operator + (const sc_uint_base &u, const sc_signed &v) 974{ 975 return operator + ((uint64)u, v); 976} 977 978const sc_signed & 979sc_signed::operator += (const sc_uint_base &v) 980{ 981 return operator += ((uint64)v); 982} 983 984 985sc_signed 986operator - (const sc_unsigned &u, const sc_uint_base &v) 987{ 988 return operator - (u, (uint64)v); 989} 990 991sc_signed 992operator - (const sc_uint_base &u, const sc_unsigned &v) 993{ 994 return operator - ((uint64)u, v); 995} 996 997sc_signed 998operator - (const sc_signed &u, const sc_uint_base &v) 999{ 1000 return operator - (u, (uint64)v); 1001} 1002 1003sc_signed 1004operator - (const sc_uint_base &u, const sc_signed &v) 1005{ 1006 return operator - ((uint64)u, v); 1007} 1008 1009const sc_signed & 1010sc_signed::operator -= (const sc_uint_base &v) 1011{ 1012 return operator -= ((uint64)v); 1013} 1014 1015 1016sc_signed 1017operator * (const sc_signed &u, const sc_uint_base &v) 1018{ 1019 return operator * (u, (uint64)v); 1020} 1021 1022sc_signed 1023operator * (const sc_uint_base &u, const sc_signed &v) 1024{ 1025 return operator * ((uint64)u, v); 1026} 1027 1028const sc_signed & 1029sc_signed::operator *= (const sc_uint_base &v) 1030{ 1031 return operator *= ((uint64)v); 1032} 1033 1034 1035sc_signed 1036operator / (const sc_signed &u, const sc_uint_base &v) 1037{ 1038 return operator / (u, (uint64)v); 1039} 1040 1041sc_signed 1042operator / (const sc_uint_base &u, const sc_signed &v) 1043{ 1044 return operator / ((uint64)u, v); 1045} 1046 1047const sc_signed & 1048sc_signed::operator /= (const sc_uint_base &v) 1049{ 1050 return operator /= ((uint64)v); 1051} 1052 1053 1054sc_signed 1055operator % (const sc_signed &u, const sc_uint_base &v) 1056{ 1057 return operator % (u, (uint64)v); 1058} 1059 1060sc_signed 1061operator % (const sc_uint_base &u, const sc_signed &v) 1062{ 1063 return operator % ((uint64)u, v); 1064} 1065 1066const sc_signed& 1067sc_signed::operator %= (const sc_uint_base &v) 1068{ 1069 return operator %= ((uint64)v); 1070} 1071 1072 1073sc_signed 1074operator & (const sc_signed &u, const sc_uint_base &v) 1075{ 1076 return operator & (u, (uint64)v); 1077} 1078 1079sc_signed 1080operator & (const sc_uint_base &u, const sc_signed &v) 1081{ 1082 return operator & ((uint64)u, v); 1083} 1084 1085const sc_signed & 1086sc_signed::operator &= (const sc_uint_base &v) 1087{ 1088 return operator &= ((uint64)v); 1089} 1090 1091 1092sc_signed 1093operator | (const sc_signed &u, const sc_uint_base &v) 1094{ 1095 return operator | (u, (uint64)v); 1096} 1097 1098sc_signed 1099operator | (const sc_uint_base &u, const sc_signed &v) 1100{ 1101 return operator | ((uint64)u, v); 1102} 1103 1104const sc_signed & 1105sc_signed::operator |= (const sc_uint_base &v) 1106{ 1107 return operator |= ((uint64)v); 1108} 1109 1110 1111sc_signed 1112operator ^ (const sc_signed &u, const sc_uint_base &v) 1113{ 1114 return operator ^ (u, (uint64)v); 1115} 1116 1117sc_signed 1118operator ^ (const sc_uint_base &u, const sc_signed &v) 1119{ 1120 return operator ^ ((uint64)u, v); 1121} 1122 1123const sc_signed & 1124sc_signed::operator ^= (const sc_uint_base &v) 1125{ 1126 return operator ^= ((uint64)v); 1127} 1128 1129 1130sc_signed 1131operator << (const sc_signed &u, const sc_uint_base &v) 1132{ 1133 return operator << (u, (uint64)v); 1134} 1135 1136const sc_signed & 1137sc_signed::operator <<= (const sc_uint_base &v) 1138{ 1139 return operator <<= ((uint64)v); 1140} 1141 1142 1143sc_signed 1144operator >> (const sc_signed& u, const sc_uint_base& v) 1145{ 1146 return operator >> (u, (uint64)v); 1147} 1148 1149const sc_signed & 1150sc_signed::operator >>= (const sc_uint_base& v) 1151{ 1152 return operator >>= ((uint64)v); 1153} 1154 1155 1156bool 1157operator == (const sc_signed &u, const sc_uint_base &v) 1158{ 1159 return operator == (u, (uint64)v); 1160} 1161 1162bool 1163operator == (const sc_uint_base &u, const sc_signed &v) 1164{ 1165 return operator == ((uint64)u, v); 1166} 1167 1168 1169bool 1170operator != (const sc_signed &u, const sc_uint_base &v) 1171{ 1172 return operator != (u, (uint64)v); 1173} 1174 1175bool 1176operator != (const sc_uint_base &u, const sc_signed &v) 1177{ 1178 return operator != ((uint64)u, v); 1179} 1180 1181 1182bool 1183operator < (const sc_signed &u, const sc_uint_base &v) 1184{ 1185 return operator < (u, (uint64)v); 1186} 1187 1188bool 1189operator < (const sc_uint_base &u, const sc_signed &v) 1190{ 1191 return operator < ((uint64)u, v); 1192} 1193 1194 1195bool 1196operator <= (const sc_signed &u, const sc_uint_base &v) 1197{ 1198 return operator <= (u, (uint64)v); 1199} 1200 1201bool 1202operator <= (const sc_uint_base &u, const sc_signed &v) 1203{ 1204 return operator <= ((uint64)u, v); 1205} 1206 1207 1208bool 1209operator > (const sc_signed &u, const sc_uint_base &v) 1210{ 1211 return operator > (u, (uint64)v); 1212} 1213 1214bool 1215operator > (const sc_uint_base &u, const sc_signed &v) 1216{ 1217 return operator > ((uint64)u, v); 1218} 1219 1220 1221bool 1222operator >= (const sc_signed &u, const sc_uint_base &v) 1223{ 1224 return operator >= (u, (uint64)v); 1225} 1226 1227bool 1228operator >= (const sc_uint_base &u, const sc_signed &v) 1229{ 1230 return operator >= ((uint64)u, v); 1231} 1232 1233 1234// ---------------------------------------------------------------------------- 1235// SECTION: Input and output operators 1236// ---------------------------------------------------------------------------- 1237 1238// Operators in this section are included from sc_nbcommon.cpp. 1239 1240 1241// ---------------------------------------------------------------------------- 1242// SECTION: Operator macros. 1243// ---------------------------------------------------------------------------- 1244 1245#define CONVERT_LONG(u) \ 1246small_type u ## s = get_sign(u); \ 1247sc_digit u ## d[DIGITS_PER_ULONG]; \ 1248from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u); 1249 1250#define CONVERT_LONG_2(u) \ 1251sc_digit u ## d[DIGITS_PER_ULONG]; \ 1252from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u); 1253 1254#define CONVERT_INT(u) \ 1255small_type u ## s = get_sign(u); \ 1256sc_digit u ## d[DIGITS_PER_UINT]; \ 1257from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u); 1258 1259#define CONVERT_INT_2(u) \ 1260sc_digit u ## d[DIGITS_PER_UINT]; \ 1261from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u); 1262 1263#define CONVERT_INT64(u) \ 1264small_type u ## s = get_sign(u); \ 1265sc_digit u ## d[DIGITS_PER_UINT64]; \ 1266from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u); 1267 1268#define CONVERT_INT64_2(u) \ 1269sc_digit u ## d[DIGITS_PER_UINT64]; \ 1270from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u); 1271 1272 1273// ---------------------------------------------------------------------------- 1274// SECTION: PLUS operators: +, +=, ++ 1275// ---------------------------------------------------------------------------- 1276 1277// Cases to consider when computing u + v: 1278// 1. 0 + v = v 1279// 2. u + 0 = u 1280// 3. if sgn(u) == sgn(v) 1281// 3.1 u + v = +(u + v) = sgn(u) * (u + v) 1282// 3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v) 1283// 4. if sgn(u) != sgn(v) 1284// 4.1 u + (-v) = u - v = sgn(u) * (u - v) 1285// 4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v) 1286// 1287// Specialization of above cases for computing ++u or u++: 1288// 1. 0 + 1 = 1 1289// 3. u + 1 = u + 1 = sgn(u) * (u + 1) 1290// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1) 1291 1292sc_signed 1293operator + (const sc_unsigned &u, const sc_signed &v) 1294{ 1295 if (u.sgn == SC_ZERO) // case 1 1296 return sc_signed(v); 1297 1298 if (v.sgn == SC_ZERO) // case 2 1299 return sc_signed(u); 1300 1301 // cases 3 and 4 1302 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1303 v.sgn, v.nbits, v.ndigits, v.digit); 1304} 1305 1306 1307sc_signed 1308operator + (const sc_signed &u, const sc_unsigned &v) 1309{ 1310 if (u.sgn == SC_ZERO) // case 1 1311 return sc_signed(v); 1312 1313 if (v.sgn == SC_ZERO) // case 2 1314 return sc_signed(u); 1315 1316 // cases 3 and 4 1317 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1318 v.sgn, v.nbits, v.ndigits, v.digit); 1319} 1320 1321 1322sc_signed 1323operator + (const sc_signed &u, const sc_signed &v) 1324{ 1325 if (u.sgn == SC_ZERO) // case 1 1326 return sc_signed(v); 1327 1328 if (v.sgn == SC_ZERO) // case 2 1329 return sc_signed(u); 1330 1331 // cases 3 and 4 1332 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1333 v.sgn, v.nbits, v.ndigits, v.digit); 1334} 1335 1336 1337sc_signed 1338operator + (const sc_signed &u, int64 v) 1339{ 1340 if (v == 0) // case 2 1341 return sc_signed(u); 1342 1343 CONVERT_INT64(v); 1344 1345 if (u.sgn == SC_ZERO) // case 1 1346 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1347 1348 // cases 3 and 4 1349 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1350 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1351} 1352 1353 1354sc_signed 1355operator + (int64 u, const sc_signed &v) 1356{ 1357 if (u == 0) // case 1 1358 return sc_signed(v); 1359 1360 CONVERT_INT64(u); 1361 1362 if (v.sgn == SC_ZERO) // case 2 1363 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1364 1365 // cases 3 and 4 1366 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1367 v.sgn, v.nbits, v.ndigits, v.digit); 1368} 1369 1370 1371sc_signed 1372operator + (const sc_unsigned &u, int64 v) 1373{ 1374 if (v == 0) // case 2 1375 return sc_signed(u); 1376 1377 CONVERT_INT64(v); 1378 1379 if (u.sgn == SC_ZERO) // case 1 1380 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1381 1382 // cases 3 and 4 1383 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1384 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1385} 1386 1387 1388sc_signed 1389operator + (int64 u, const sc_unsigned &v) 1390{ 1391 if (u == 0) // case 1 1392 return sc_signed(v); 1393 1394 CONVERT_INT64(u); 1395 1396 if (v.sgn == SC_ZERO) // case 2 1397 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1398 1399 // cases 3 and 4 1400 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1401 v.sgn, v.nbits, v.ndigits, v.digit); 1402} 1403 1404 1405sc_signed 1406operator + (const sc_signed &u, uint64 v) 1407{ 1408 if (v == 0) // case 2 1409 return sc_signed(u); 1410 1411 CONVERT_INT64(v); 1412 1413 if (u.sgn == SC_ZERO) // case 1 1414 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1415 1416 // cases 3 and 4 1417 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1418 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1419} 1420 1421 1422sc_signed 1423operator + (uint64 u, const sc_signed &v) 1424{ 1425 if (u == 0) // case 1 1426 return sc_signed(v); 1427 1428 CONVERT_INT64(u); 1429 1430 if (v.sgn == SC_ZERO) // case 2 1431 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1432 1433 // cases 3 and 4 1434 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1435 v.sgn, v.nbits, v.ndigits, v.digit); 1436} 1437 1438 1439sc_signed 1440operator + (const sc_signed &u, long v) 1441{ 1442 if (v == 0) // case 2 1443 return sc_signed(u); 1444 1445 CONVERT_LONG(v); 1446 1447 if (u.sgn == SC_ZERO) // case 1 1448 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1449 1450 // cases 3 and 4 1451 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1452 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1453} 1454 1455 1456sc_signed 1457operator + (long u, const sc_signed &v) 1458{ 1459 if (u == 0) // case 1 1460 return sc_signed(v); 1461 1462 CONVERT_LONG(u); 1463 1464 if (v.sgn == SC_ZERO) // case 2 1465 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1466 1467 // cases 3 and 4 1468 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1469 v.sgn, v.nbits, v.ndigits, v.digit); 1470} 1471 1472 1473sc_signed 1474operator + (const sc_unsigned &u, long v) 1475{ 1476 if (v == 0) // case 2 1477 return sc_signed(u); 1478 1479 CONVERT_LONG(v); 1480 1481 if (u.sgn == SC_ZERO) // case 1 1482 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1483 1484 // cases 3 and 4 1485 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1486 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1487} 1488 1489 1490sc_signed 1491operator + (long u, const sc_unsigned &v) 1492{ 1493 if (u == 0) // case 1 1494 return sc_signed(v); 1495 1496 CONVERT_LONG(u); 1497 1498 if (v.sgn == SC_ZERO) // case 2 1499 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1500 1501 // cases 3 and 4 1502 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1503 v.sgn, v.nbits, v.ndigits, v.digit); 1504} 1505 1506 1507sc_signed 1508operator + (const sc_signed &u, unsigned long v) 1509{ 1510 if (v == 0) // case 2 1511 return sc_signed(u); 1512 1513 CONVERT_LONG(v); 1514 1515 if (u.sgn == SC_ZERO) // case 1 1516 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1517 1518 // cases 3 and 4 1519 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1520 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1521} 1522 1523 1524sc_signed 1525operator + (unsigned long u, const sc_signed &v) 1526{ 1527 if (u == 0) // case 1 1528 return sc_signed(v); 1529 1530 CONVERT_LONG(u); 1531 1532 if (v.sgn == SC_ZERO) // case 2 1533 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1534 1535 // cases 3 and 4 1536 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1537 v.sgn, v.nbits, v.ndigits, v.digit); 1538} 1539 1540// The rest of the operators in this section are included from 1541// sc_nbcommon.cpp. 1542 1543// ---------------------------------------------------------------------------- 1544// SECTION: MINUS operators: -, -=, -- 1545// ---------------------------------------------------------------------------- 1546 1547// Cases to consider when computing u + v: 1548// 1. u - 0 = u 1549// 2. 0 - v = -v 1550// 3. if sgn(u) != sgn(v) 1551// 3.1 u - (-v) = u + v = sgn(u) * (u + v) 1552// 3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v) 1553// 4. if sgn(u) == sgn(v) 1554// 4.1 u - v = +(u - v) = sgn(u) * (u - v) 1555// 4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v) 1556// 1557// Specialization of above cases for computing --u or u--: 1558// 1. 0 - 1 = -1 1559// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1) 1560// 4. u - 1 = u - 1 = sgn(u) * (u - 1) 1561 1562sc_signed 1563operator - (const sc_unsigned &u, const sc_unsigned &v) 1564{ 1565 if (v.sgn == SC_ZERO) // case 1 1566 return sc_signed(u); 1567 1568 if (u.sgn == SC_ZERO) // case 2 1569 return sc_signed(v, -v.sgn); 1570 1571 // cases 3 and 4 1572 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1573 -v.sgn, v.nbits, v.ndigits, v.digit); 1574} 1575 1576 1577sc_signed 1578operator - (const sc_unsigned &u, const sc_signed &v) 1579{ 1580 if (v.sgn == SC_ZERO) // case 1 1581 return sc_signed(u); 1582 1583 if (u.sgn == SC_ZERO) // case 2 1584 return sc_signed(v, -v.sgn); 1585 1586 // cases 3 and 4 1587 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1588 -v.sgn, v.nbits, v.ndigits, v.digit); 1589} 1590 1591 1592sc_signed 1593operator - (const sc_signed &u, const sc_unsigned &v) 1594{ 1595 if (v.sgn == SC_ZERO) // case 1 1596 return sc_signed(u); 1597 1598 if (u.sgn == SC_ZERO) // case 2 1599 return sc_signed(v, -v.sgn); 1600 1601 // cases 3 and 4 1602 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1603 -v.sgn, v.nbits, v.ndigits, v.digit); 1604} 1605 1606 1607sc_signed 1608operator - (const sc_signed &u, const sc_signed &v) 1609{ 1610 if (v.sgn == SC_ZERO) // case 1 1611 return sc_signed(u); 1612 1613 if (u.sgn == SC_ZERO) // case 2 1614 return sc_signed(v, -v.sgn); 1615 1616 // cases 3 and 4 1617 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1618 -v.sgn, v.nbits, v.ndigits, v.digit); 1619} 1620 1621 1622sc_signed 1623operator - (const sc_signed &u, int64 v) 1624{ 1625 if (v == 0) // case 1 1626 return sc_signed(u); 1627 1628 CONVERT_INT64(v); 1629 1630 if (u.sgn == SC_ZERO) // case 2 1631 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1632 1633 // cases 3 and 4 1634 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1635 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1636} 1637 1638 1639sc_signed 1640operator - (int64 u, const sc_signed &v) 1641{ 1642 if (u == 0) // case 1 1643 return sc_signed(v, -v.sgn); 1644 1645 CONVERT_INT64(u); 1646 1647 if (v.sgn == SC_ZERO) // case 2 1648 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1649 1650 // cases 3 and 4 1651 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1652 -v.sgn, v.nbits, v.ndigits, v.digit); 1653} 1654 1655 1656sc_signed 1657operator - (const sc_unsigned &u, int64 v) 1658{ 1659 if (v == 0) // case 1 1660 return sc_signed(u); 1661 1662 CONVERT_INT64(v); 1663 1664 if (u.sgn == SC_ZERO) // case 2 1665 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1666 1667 // cases 3 and 4 1668 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1669 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1670} 1671 1672 1673sc_signed 1674operator - (int64 u, const sc_unsigned &v) 1675{ 1676 if (u == 0) // case 1 1677 return sc_signed(v, -v.sgn); 1678 1679 CONVERT_INT64(u); 1680 1681 if (v.sgn == SC_ZERO) // case 2 1682 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1683 1684 // cases 3 and 4 1685 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1686 -v.sgn, v.nbits, v.ndigits, v.digit); 1687} 1688 1689 1690sc_signed 1691operator - (const sc_signed &u, uint64 v) 1692{ 1693 if (v == 0) // case 1 1694 return sc_signed(u); 1695 1696 CONVERT_INT64(v); 1697 1698 if (u.sgn == SC_ZERO) // case 2 1699 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1700 1701 // cases 3 and 4 1702 1703 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1704 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1705} 1706 1707 1708sc_signed 1709operator - (uint64 u, const sc_signed &v) 1710{ 1711 if (u == 0) // case 1 1712 return sc_signed(v, -v.sgn); 1713 1714 CONVERT_INT64(u); 1715 1716 if (v.sgn == SC_ZERO) // case 2 1717 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1718 1719 // cases 3 and 4 1720 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1721 -v.sgn, v.nbits, v.ndigits, v.digit); 1722} 1723 1724 1725sc_signed 1726operator - (const sc_unsigned &u, uint64 v) 1727{ 1728 if (v == 0) // case 1 1729 return sc_signed(u); 1730 1731 CONVERT_INT64(v); 1732 1733 if (u.sgn == SC_ZERO) // case 2 1734 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1735 1736 // cases 3 and 4 1737 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1738 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1739} 1740 1741 1742sc_signed 1743operator - (uint64 u, const sc_unsigned &v) 1744{ 1745 if (u == 0) // case 1 1746 return sc_signed(v, -v.sgn); 1747 1748 CONVERT_INT64(u); 1749 1750 if (v.sgn == SC_ZERO) // case 2 1751 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1752 1753 // cases 3 and 4 1754 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1755 -v.sgn, v.nbits, v.ndigits, v.digit); 1756} 1757 1758 1759sc_signed 1760operator - (const sc_signed &u, long v) 1761{ 1762 if (v == 0) // case 1 1763 return sc_signed(u); 1764 1765 CONVERT_LONG(v); 1766 1767 if (u.sgn == SC_ZERO) // case 2 1768 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1769 1770 // cases 3 and 4 1771 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1772 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1773} 1774 1775 1776sc_signed 1777operator - (long u, const sc_signed &v) 1778{ 1779 if (u == 0) // case 1 1780 return sc_signed(v, -v.sgn); 1781 1782 CONVERT_LONG(u); 1783 1784 if (v.sgn == SC_ZERO) // case 2 1785 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1786 1787 // cases 3 and 4 1788 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1789 -v.sgn, v.nbits, v.ndigits, v.digit); 1790} 1791 1792 1793sc_signed 1794operator - (const sc_unsigned &u, long v) 1795{ 1796 if (v == 0) // case 1 1797 return sc_signed(u); 1798 1799 CONVERT_LONG(v); 1800 1801 if (u.sgn == SC_ZERO) // case 2 1802 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1803 1804 // cases 3 and 4 1805 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1806 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1807} 1808 1809 1810sc_signed 1811operator - (long u, const sc_unsigned &v) 1812{ 1813 if (u == 0) // case 1 1814 return sc_signed(v, -v.sgn); 1815 1816 CONVERT_LONG(u); 1817 1818 if (v.sgn == SC_ZERO) // case 2 1819 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1820 1821 // cases 3 and 4 1822 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1823 -v.sgn, v.nbits, v.ndigits, v.digit); 1824} 1825 1826 1827sc_signed 1828operator - (const sc_signed &u, unsigned long v) 1829{ 1830 if (v == 0) // case 1 1831 return sc_signed(u); 1832 1833 CONVERT_LONG(v); 1834 1835 if (u.sgn == SC_ZERO) // case 2 1836 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1837 1838 // cases 3 and 4 1839 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1840 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1841} 1842 1843 1844sc_signed 1845operator - (unsigned long u, const sc_signed &v) 1846{ 1847 if (u == 0) // case 1 1848 return sc_signed(v, -v.sgn); 1849 1850 CONVERT_LONG(u); 1851 1852 if (v.sgn == SC_ZERO) // case 2 1853 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1854 1855 // cases 3 and 4 1856 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1857 -v.sgn, v.nbits, v.ndigits, v.digit); 1858} 1859 1860 1861sc_signed 1862operator - (const sc_unsigned &u, unsigned long v) 1863{ 1864 if (v == 0) // case 1 1865 return sc_signed(u); 1866 1867 CONVERT_LONG(v); 1868 1869 if (u.sgn == SC_ZERO) // case 2 1870 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1871 1872 // cases 3 and 4 1873 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1874 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1875} 1876 1877 1878sc_signed 1879operator - (unsigned long u, const sc_unsigned &v) 1880{ 1881 if (u == 0) // case 1 1882 return sc_signed(v, -v.sgn); 1883 1884 CONVERT_LONG(u); 1885 1886 if (v.sgn == SC_ZERO) // case 2 1887 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1888 1889 // cases 3 and 4 1890 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1891 -v.sgn, v.nbits, v.ndigits, v.digit); 1892} 1893 1894// The rest of the operators in this section are included from 1895// sc_nbcommon.cpp. 1896 1897 1898// ---------------------------------------------------------------------------- 1899// SECTION: MULTIPLICATION operators: *, *= 1900// ---------------------------------------------------------------------------- 1901 1902// Cases to consider when computing u * v: 1903// 1. u * 0 = 0 * v = 0 1904// 2. 1 * v = v and -1 * v = -v 1905// 3. u * 1 = u and u * -1 = -u 1906// 4. u * v = u * v 1907 1908sc_signed 1909operator * (const sc_unsigned &u, const sc_signed &v) 1910{ 1911 small_type s = mul_signs(u.sgn, v.sgn); 1912 1913 if (s == SC_ZERO) // case 1 1914 return sc_signed(); 1915 1916 // cases 2-4 1917 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 1918 v.nbits, v.ndigits, v.digit); 1919} 1920 1921 1922sc_signed 1923operator * (const sc_signed &u, const sc_unsigned &v) 1924{ 1925 small_type s = mul_signs(u.sgn, v.sgn); 1926 1927 if (s == SC_ZERO) // case 1 1928 return sc_signed(); 1929 1930 // cases 2-4 1931 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 1932 v.nbits, v.ndigits, v.digit); 1933} 1934 1935 1936sc_signed 1937operator * (const sc_signed &u, const sc_signed &v) 1938{ 1939 small_type s = mul_signs(u.sgn, v.sgn); 1940 1941 if (s == SC_ZERO) // case 1 1942 return sc_signed(); 1943 1944 // cases 2-4 1945 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 1946 v.nbits, v.ndigits, v.digit); 1947} 1948 1949 1950sc_signed 1951operator * (const sc_signed &u, int64 v) 1952{ 1953 small_type s = mul_signs(u.sgn, get_sign(v)); 1954 1955 if (s == SC_ZERO) // case 1 1956 return sc_signed(); 1957 1958 CONVERT_INT64_2(v); 1959 1960 // cases 2-4 1961 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 1962 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1963} 1964 1965 1966sc_signed 1967operator * (int64 u, const sc_signed &v) 1968{ 1969 small_type s = mul_signs(v.sgn, get_sign(u)); 1970 1971 if (s == SC_ZERO) // case 1 1972 return sc_signed(); 1973 1974 CONVERT_INT64_2(u); 1975 1976 // cases 2-4 1977 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1978 v.nbits, v.ndigits, v.digit); 1979} 1980 1981 1982sc_signed 1983operator * (const sc_unsigned &u, int64 v) 1984{ 1985 small_type s = mul_signs(u.sgn, get_sign(v)); 1986 1987 if (s == SC_ZERO) // case 1 1988 return sc_signed(); 1989 1990 CONVERT_INT64_2(v); 1991 1992 // cases 2-4 1993 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 1994 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1995} 1996 1997 1998sc_signed 1999operator * (int64 u, const sc_unsigned &v) 2000{ 2001 small_type s = mul_signs(v.sgn, get_sign(u)); 2002 2003 if (s == SC_ZERO) // case 1 2004 return sc_signed(); 2005 2006 CONVERT_INT64_2(u); 2007 2008 // cases 2-4 2009 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2010 v.nbits, v.ndigits, v.digit); 2011} 2012 2013 2014sc_signed 2015operator * (const sc_signed &u, uint64 v) 2016{ 2017 small_type s = mul_signs(u.sgn, get_sign(v)); 2018 2019 if (s == SC_ZERO) // case 1 2020 return sc_signed(); 2021 2022 CONVERT_INT64_2(v); 2023 2024 // cases 2-4 2025 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 2026 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2027} 2028 2029 2030sc_signed 2031operator * (uint64 u, const sc_signed &v) 2032{ 2033 small_type s = mul_signs(v.sgn, get_sign(u)); 2034 2035 if (s == SC_ZERO) // case 1 2036 return sc_signed(); 2037 2038 CONVERT_INT64_2(u); 2039 2040 // cases 2-4 2041 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2042 v.nbits, v.ndigits, v.digit); 2043} 2044 2045 2046sc_signed 2047operator * (const sc_signed &u, long v) 2048{ 2049 small_type s = mul_signs(u.sgn, get_sign(v)); 2050 2051 if (s == SC_ZERO) // case 1 2052 return sc_signed(); 2053 2054 CONVERT_LONG_2(v); 2055 2056 // cases 2-4 2057 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 2058 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2059} 2060 2061 2062sc_signed 2063operator * (long u, const sc_signed &v) 2064{ 2065 small_type s = mul_signs(v.sgn, get_sign(u)); 2066 2067 if (s == SC_ZERO) // case 1 2068 return sc_signed(); 2069 2070 CONVERT_LONG_2(u); 2071 2072 // cases 2-4 2073 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2074 v.nbits, v.ndigits, v.digit); 2075} 2076 2077 2078sc_signed 2079operator * (const sc_unsigned &u, long v) 2080{ 2081 small_type s = mul_signs(u.sgn, get_sign(v)); 2082 2083 if (s == SC_ZERO) // case 1 2084 return sc_signed(); 2085 2086 CONVERT_LONG_2(v); 2087 2088 // cases 2-4 2089 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 2090 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2091} 2092 2093 2094sc_signed 2095operator * (long u, const sc_unsigned &v) 2096{ 2097 small_type s = mul_signs(v.sgn, get_sign(u)); 2098 2099 if (s == SC_ZERO) // case 1 2100 return sc_signed(); 2101 2102 CONVERT_LONG_2(u); 2103 2104 // cases 2-4 2105 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2106 v.nbits, v.ndigits, v.digit); 2107} 2108 2109 2110sc_signed 2111operator * (const sc_signed &u, unsigned long v) 2112{ 2113 small_type s = mul_signs(u.sgn, get_sign(v)); 2114 2115 if (s == SC_ZERO) // case 1 2116 return sc_signed(); 2117 2118 CONVERT_LONG_2(v); 2119 2120 // else cases 2-4 2121 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 2122 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2123} 2124 2125sc_signed 2126operator * (unsigned long u, const sc_signed &v) 2127{ 2128 small_type s = mul_signs(v.sgn, get_sign(u)); 2129 2130 if (s == SC_ZERO) // case 1 2131 return sc_signed(); 2132 2133 CONVERT_LONG_2(u); 2134 2135 // cases 2-4 2136 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2137 v.nbits, v.ndigits, v.digit); 2138} 2139 2140// The rest of the operators in this section are included from 2141// sc_nbcommon.cpp. 2142 2143 2144// ---------------------------------------------------------------------------- 2145// SECTION: DIVISION operators: /, /= 2146// ---------------------------------------------------------------------------- 2147 2148// Cases to consider when finding the quotient q = floor(u/v): 2149// Note that u = q * v + r for r < q. 2150// 1. 0 / 0 or u / 0 => error 2151// 2. 0 / v => 0 = 0 * v + 0 2152// 3. u / v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1 2153// 4. u / v & &u < v => u = 0 * v + u - u can be 1 or -1 2154// 5. u / v & &u > v => u = q * v + r - v can be 1 or -1 2155 2156sc_signed 2157operator / (const sc_unsigned &u, const sc_signed &v) 2158{ 2159 small_type s = mul_signs(u.sgn, v.sgn); 2160 2161 if (s == SC_ZERO) { 2162 div_by_zero(v.sgn); // case 1 2163 return sc_signed(); // case 2 2164 } 2165 2166 // other cases 2167 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2168 v.nbits, v.ndigits, v.digit); 2169} 2170 2171 2172sc_signed 2173operator / (const sc_signed &u, const sc_unsigned &v) 2174{ 2175 small_type s = mul_signs(u.sgn, v.sgn); 2176 2177 if (s == SC_ZERO) { 2178 div_by_zero(v.sgn); // case 1 2179 return sc_signed(); // case 2 2180 } 2181 2182 // other cases 2183 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2184 v.nbits, v.ndigits, v.digit); 2185} 2186 2187 2188sc_signed 2189operator / (const sc_signed &u, const sc_signed &v) 2190{ 2191 small_type s = mul_signs(u.sgn, v.sgn); 2192 2193 if (s == SC_ZERO) { 2194 div_by_zero(v.sgn); // case 1 2195 return sc_signed(); // case 2 2196 } 2197 2198 // other cases 2199 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2200 v.nbits, v.ndigits, v.digit); 2201} 2202 2203 2204sc_signed 2205operator / (const sc_signed &u, int64 v) 2206{ 2207 small_type s = mul_signs(u.sgn, get_sign(v)); 2208 2209 if (s == SC_ZERO) { 2210 div_by_zero(v); // case 1 2211 return sc_signed(); // case 2 2212 } 2213 2214 CONVERT_INT64_2(v); 2215 2216 // other cases 2217 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2218 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2219} 2220 2221 2222sc_signed 2223operator / (int64 u, const sc_signed &v) 2224{ 2225 small_type s = mul_signs(v.sgn, get_sign(u)); 2226 2227 if (s == SC_ZERO) { 2228 div_by_zero(v.sgn); // case 1 2229 return sc_signed(); // case 2 2230 } 2231 2232 CONVERT_INT64_2(u); 2233 2234 // other cases 2235 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2236 v.nbits, v.ndigits, v.digit); 2237} 2238 2239 2240sc_signed 2241operator / (const sc_unsigned &u, int64 v) 2242{ 2243 small_type s = mul_signs(u.sgn, get_sign(v)); 2244 2245 if (s == SC_ZERO) { 2246 div_by_zero(v); // case 1 2247 return sc_signed(); // case 2 2248 } 2249 2250 CONVERT_INT64_2(v); 2251 2252 // other cases 2253 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2254 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2255} 2256 2257 2258sc_signed 2259operator / (int64 u, const sc_unsigned &v) 2260{ 2261 small_type s = mul_signs(v.sgn, get_sign(u)); 2262 2263 if (s == SC_ZERO) { 2264 div_by_zero(v.sgn); // case 1 2265 return sc_signed(); // case 2 2266 } 2267 2268 CONVERT_INT64_2(u); 2269 2270 // other cases 2271 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2272 v.nbits, v.ndigits, v.digit); 2273} 2274 2275 2276sc_signed 2277operator / (const sc_signed &u, uint64 v) 2278{ 2279 small_type s = mul_signs(u.sgn, get_sign(v)); 2280 2281 if (s == SC_ZERO) { 2282 div_by_zero(v); // case 1 2283 return sc_signed(); // case 2 2284 } 2285 2286 CONVERT_INT64_2(v); 2287 2288 // other cases 2289 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2290 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2291} 2292 2293 2294sc_signed 2295operator / (uint64 u, const sc_signed &v) 2296{ 2297 small_type s = mul_signs(v.sgn, get_sign(u)); 2298 2299 if (s == SC_ZERO) { 2300 div_by_zero(v.sgn); // case 1 2301 return sc_signed(); // case 2 2302 2303 } 2304 2305 CONVERT_INT64_2(u); 2306 2307 // other cases 2308 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2309 v.nbits, v.ndigits, v.digit); 2310} 2311 2312 2313sc_signed 2314operator / (const sc_signed &u, long v) 2315{ 2316 small_type s = mul_signs(u.sgn, get_sign(v)); 2317 2318 if (s == SC_ZERO) { 2319 div_by_zero(v); // case 1 2320 return sc_signed(); // case 2 2321 } 2322 2323 CONVERT_LONG_2(v); 2324 2325 // other cases 2326 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2327 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2328} 2329 2330 2331sc_signed 2332operator / (long u, const sc_signed &v) 2333{ 2334 small_type s = mul_signs(v.sgn, get_sign(u)); 2335 2336 if (s == SC_ZERO) { 2337 div_by_zero(v.sgn); // case 1 2338 return sc_signed(); // case 2 2339 } 2340 2341 CONVERT_LONG_2(u); 2342 2343 // other cases 2344 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2345 v.nbits, v.ndigits, v.digit); 2346} 2347 2348 2349sc_signed 2350operator / (const sc_unsigned &u, long v) 2351{ 2352 small_type s = mul_signs(u.sgn, get_sign(v)); 2353 2354 if (s == SC_ZERO) { 2355 div_by_zero(v); // case 1 2356 return sc_signed(); // case 2 2357 } 2358 2359 CONVERT_LONG_2(v); 2360 2361 // other cases 2362 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2363 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2364} 2365 2366 2367sc_signed 2368operator / (long u, const sc_unsigned &v) 2369{ 2370 small_type s = mul_signs(v.sgn, get_sign(u)); 2371 2372 if (s == SC_ZERO) { 2373 div_by_zero(v.sgn); // case 1 2374 return sc_signed(); // case 2 2375 } 2376 2377 CONVERT_LONG_2(u); 2378 2379 // other cases 2380 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2381 v.nbits, v.ndigits, v.digit); 2382} 2383 2384 2385sc_signed 2386operator / (const sc_signed &u, unsigned long v) 2387{ 2388 small_type s = mul_signs(u.sgn, get_sign(v)); 2389 2390 if (s == SC_ZERO) { 2391 div_by_zero(v); // case 1 2392 return sc_signed(); // case 2 2393 } 2394 2395 CONVERT_LONG_2(v); 2396 2397 // other cases 2398 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2399 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2400} 2401 2402 2403sc_signed 2404operator / (unsigned long u, const sc_signed &v) 2405{ 2406 small_type s = mul_signs(v.sgn, get_sign(u)); 2407 2408 if (s == SC_ZERO) { 2409 div_by_zero(v.sgn); // case 1 2410 return sc_signed(); // case 2 2411 2412 } 2413 2414 CONVERT_LONG_2(u); 2415 2416 // other cases 2417 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2418 v.nbits, v.ndigits, v.digit); 2419} 2420 2421// The rest of the operators in this section are included from 2422// sc_nbcommon.cpp. 2423 2424 2425// ---------------------------------------------------------------------------- 2426// SECTION: MOD operators: %, %=. 2427// ---------------------------------------------------------------------------- 2428 2429// Cases to consider when finding the remainder r = u % v: 2430// Note that u = q * v + r for r < q. 2431// 1. 0 % 0 or u % 0 => error 2432// 2. 0 % v => 0 = 0 * v + 0 2433// 3. u % v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1 2434// 4. u % v & &u < v => u = 0 * v + u - u can be 1 or -1 2435// 5. u % v & &u > v => u = q * v + r - v can be 1 or -1 2436 2437sc_signed 2438operator % (const sc_unsigned &u, const sc_signed &v) 2439{ 2440 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { 2441 div_by_zero(v.sgn); // case 1 2442 return sc_signed(); // case 2 2443 } 2444 2445 // other cases 2446 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2447 v.nbits, v.ndigits, v.digit); 2448} 2449 2450 2451sc_signed 2452operator % (const sc_signed &u, const sc_unsigned &v) 2453{ 2454 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { 2455 div_by_zero(v.sgn); // case 1 2456 return sc_signed(); // case 2 2457 } 2458 2459 // other cases 2460 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2461 v.nbits, v.ndigits, v.digit); 2462} 2463 2464 2465sc_signed 2466operator % (const sc_signed &u, const sc_signed &v) 2467{ 2468 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { 2469 div_by_zero(v.sgn); // case 1 2470 return sc_signed(); // case 2 2471 } 2472 2473 // other cases 2474 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2475 v.nbits, v.ndigits, v.digit); 2476} 2477 2478 2479sc_signed 2480operator % (const sc_signed &u, int64 v) 2481{ 2482 small_type vs = get_sign(v); 2483 2484 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) { 2485 div_by_zero(v); // case 1 2486 return sc_signed(); // case 2 2487 } 2488 2489 CONVERT_INT64_2(v); 2490 2491 // other cases 2492 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2493 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2494} 2495 2496 2497sc_signed 2498operator % (int64 u, const sc_signed &v) 2499{ 2500 small_type us = get_sign(u); 2501 2502 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) { 2503 div_by_zero(v.sgn); // case 1 2504 return sc_signed(); // case 2 2505 } 2506 2507 CONVERT_INT64_2(u); 2508 2509 // other cases 2510 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2511 v.nbits, v.ndigits, v.digit); 2512} 2513 2514 2515sc_signed 2516operator % (const sc_unsigned &u, int64 v) 2517{ 2518 small_type vs = get_sign(v); 2519 2520 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) { 2521 div_by_zero(v); // case 1 2522 return sc_signed(); // case 2 2523 } 2524 2525 CONVERT_INT64_2(v); 2526 2527 // other cases 2528 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2529 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2530} 2531 2532 2533sc_signed 2534operator % (int64 u, const sc_unsigned &v) 2535{ 2536 small_type us = get_sign(u); 2537 2538 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) { 2539 div_by_zero(v.sgn); // case 1 2540 return sc_signed(); // case 2 2541 } 2542 2543 CONVERT_INT64_2(u); 2544 2545 // other cases 2546 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2547 v.nbits, v.ndigits, v.digit); 2548} 2549 2550 2551sc_signed 2552operator % (const sc_signed &u, uint64 v) 2553{ 2554 if ((u.sgn == SC_ZERO) || (v == 0)) { 2555 div_by_zero(v); // case 1 2556 return sc_signed(); // case 2 2557 } 2558 2559 CONVERT_INT64_2(v); 2560 2561 // other cases 2562 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2563 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2564} 2565 2566 2567sc_signed 2568operator % (uint64 u, const sc_signed &v) 2569{ 2570 if ((u == 0) || (v.sgn == SC_ZERO)) { 2571 div_by_zero(v.sgn); // case 1 2572 return sc_signed(); // case 2 2573 } 2574 2575 CONVERT_INT64(u); 2576 2577 // other cases 2578 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2579 v.nbits, v.ndigits, v.digit); 2580} 2581 2582 2583sc_signed 2584operator % (const sc_signed &u, long v) 2585{ 2586 small_type vs = get_sign(v); 2587 2588 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) { 2589 div_by_zero(v); // case 1 2590 return sc_signed(); // case 2 2591 } 2592 2593 CONVERT_LONG_2(v); 2594 2595 // other cases 2596 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2597 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2598} 2599 2600 2601sc_signed 2602operator % (long u, const sc_signed &v) 2603{ 2604 small_type us = get_sign(u); 2605 2606 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) { 2607 div_by_zero(v.sgn); // case 1 2608 return sc_signed(); // case 2 2609 } 2610 2611 CONVERT_LONG_2(u); 2612 2613 // other cases 2614 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2615 v.nbits, v.ndigits, v.digit); 2616} 2617 2618 2619sc_signed 2620operator % (const sc_unsigned &u, long v) 2621{ 2622 2623 small_type vs = get_sign(v); 2624 2625 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) { 2626 div_by_zero(v); // case 1 2627 return sc_signed(); // case 2 2628 } 2629 2630 CONVERT_LONG_2(v); 2631 2632 // other cases 2633 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2634 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2635} 2636 2637 2638sc_signed 2639operator % (long u, const sc_unsigned &v) 2640{ 2641 small_type us = get_sign(u); 2642 2643 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) { 2644 div_by_zero(v.sgn); // case 1 2645 return sc_signed(); // case 2 2646 } 2647 2648 CONVERT_LONG_2(u); 2649 2650 // other cases 2651 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2652 v.nbits, v.ndigits, v.digit); 2653} 2654 2655 2656sc_signed 2657operator % (const sc_signed &u, unsigned long v) 2658{ 2659 if ((u.sgn == SC_ZERO) || (v == 0)) { 2660 div_by_zero(v); // case 1 2661 return sc_signed(); // case 2 2662 } 2663 2664 CONVERT_LONG_2(v); 2665 2666 // other cases 2667 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2668 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2669} 2670 2671 2672sc_signed 2673operator % (unsigned long u, const sc_signed &v) 2674{ 2675 if ((u == 0) || (v.sgn == SC_ZERO)) { 2676 div_by_zero(v.sgn); // case 1 2677 return sc_signed(); // case 2 2678 } 2679 2680 CONVERT_LONG(u); 2681 2682 // other cases 2683 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2684 v.nbits, v.ndigits, v.digit); 2685} 2686 2687// The rest of the operators in this section are included from 2688// sc_nbcommon.cpp. 2689 2690 2691// ---------------------------------------------------------------------------- 2692// SECTION: Bitwise AND operators: &, &= 2693// ---------------------------------------------------------------------------- 2694 2695// Cases to consider when computing u &v: 2696// 1. u & 0 = 0 &v = 0 2697// 2. u &v => sgn = + 2698// 3. (-u) & (-v) => sgn = - 2699// 4. u & (-v) => sgn = + 2700// 5. (-u) &v => sgn = + 2701 2702sc_signed 2703operator & (const sc_unsigned &u, const sc_signed &v) 2704{ 2705 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1 2706 return sc_signed(); 2707 2708 // other cases 2709 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2710 v.sgn, v.nbits, v.ndigits, v.digit); 2711} 2712 2713 2714sc_signed 2715operator & (const sc_signed &u, const sc_unsigned &v) 2716{ 2717 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1 2718 return sc_signed(); 2719 2720 // other cases 2721 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2722 v.sgn, v.nbits, v.ndigits, v.digit); 2723} 2724 2725 2726sc_signed 2727operator & (const sc_signed &u, const sc_signed &v) 2728{ 2729 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1 2730 return sc_signed(); 2731 2732 // other cases 2733 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2734 v.sgn, v.nbits, v.ndigits, v.digit); 2735} 2736 2737 2738sc_signed 2739operator & (const sc_signed &u, int64 v) 2740{ 2741 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2742 return sc_signed(); 2743 2744 CONVERT_INT64(v); 2745 2746 // other cases 2747 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2748 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2749} 2750 2751 2752sc_signed 2753operator & (int64 u, const sc_signed &v) 2754{ 2755 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2756 return sc_signed(); 2757 2758 CONVERT_INT64(u); 2759 2760 // other cases 2761 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2762 v.sgn, v.nbits, v.ndigits, v.digit); 2763} 2764 2765 2766sc_signed 2767operator & (const sc_unsigned &u, int64 v) 2768{ 2769 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2770 return sc_signed(); 2771 2772 CONVERT_INT64(v); 2773 2774 // other cases 2775 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2776 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2777} 2778 2779 2780sc_signed 2781operator & (int64 u, const sc_unsigned &v) 2782{ 2783 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2784 return sc_signed(); 2785 2786 CONVERT_INT64(u); 2787 2788 // other cases 2789 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2790 v.sgn, v.nbits, v.ndigits, v.digit); 2791} 2792 2793 2794sc_signed 2795operator & (const sc_signed &u, uint64 v) 2796{ 2797 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2798 return sc_signed(); 2799 2800 CONVERT_INT64(v); 2801 2802 // other cases 2803 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2804 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2805} 2806 2807 2808sc_signed 2809operator & (uint64 u, const sc_signed &v) 2810{ 2811 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2812 return sc_signed(); 2813 2814 CONVERT_INT64(u); 2815 2816 // other cases 2817 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2818 v.sgn, v.nbits, v.ndigits, v.digit); 2819} 2820 2821 2822sc_signed 2823operator & (const sc_signed &u, long v) 2824{ 2825 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2826 return sc_signed(); 2827 2828 CONVERT_LONG(v); 2829 2830 // other cases 2831 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2832 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2833} 2834 2835 2836sc_signed 2837operator & (long u, const sc_signed &v) 2838{ 2839 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2840 return sc_signed(); 2841 2842 CONVERT_LONG(u); 2843 2844 // other cases 2845 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2846 v.sgn, v.nbits, v.ndigits, v.digit); 2847} 2848 2849 2850sc_signed 2851operator & (const sc_unsigned &u, long v) 2852{ 2853 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2854 return sc_signed(); 2855 2856 CONVERT_LONG(v); 2857 2858 // other cases 2859 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2860 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2861} 2862 2863 2864sc_signed 2865operator & (long u, const sc_unsigned &v) 2866{ 2867 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2868 return sc_signed(); 2869 2870 CONVERT_LONG(u); 2871 2872 // other cases 2873 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2874 v.sgn, v.nbits, v.ndigits, v.digit); 2875} 2876 2877 2878sc_signed 2879operator & (const sc_signed &u, unsigned long v) 2880{ 2881 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2882 return sc_signed(); 2883 2884 CONVERT_LONG(v); 2885 2886 // other cases 2887 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2888 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2889} 2890 2891 2892sc_signed 2893operator & (unsigned long u, const sc_signed &v) 2894{ 2895 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2896 return sc_signed(); 2897 2898 CONVERT_LONG(u); 2899 2900 // other cases 2901 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2902 v.sgn, v.nbits, v.ndigits, v.digit); 2903} 2904 2905// The rest of the operators in this section are included from 2906// sc_nbcommon.cpp. 2907 2908 2909// ---------------------------------------------------------------------------- 2910// SECTION: Bitwise OR operators: |, |= 2911// ---------------------------------------------------------------------------- 2912 2913// Cases to consider when computing u | v: 2914// 1. u | 0 = u 2915// 2. 0 | v = v 2916// 3. u | v => sgn = + 2917// 4. (-u) | (-v) => sgn = - 2918// 5. u | (-v) => sgn = - 2919// 6. (-u) | v => sgn = - 2920 2921sc_signed 2922operator | (const sc_unsigned &u, const sc_signed &v) 2923{ 2924 if (v.sgn == SC_ZERO) // case 1 2925 return sc_signed(u); 2926 2927 if (u.sgn == SC_ZERO) // case 2 2928 return sc_signed(v); 2929 2930 // other cases 2931 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2932 v.sgn, v.nbits, v.ndigits, v.digit); 2933} 2934 2935 2936sc_signed 2937operator | (const sc_signed &u, const sc_unsigned &v) 2938{ 2939 if (v.sgn == SC_ZERO) // case 1 2940 return sc_signed(u); 2941 2942 if (u.sgn == SC_ZERO) // case 2 2943 return sc_signed(v); 2944 2945 // other cases 2946 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2947 v.sgn, v.nbits, v.ndigits, v.digit); 2948} 2949 2950 2951sc_signed 2952operator | (const sc_signed &u, const sc_signed &v) 2953{ 2954 if (v.sgn == SC_ZERO) // case 1 2955 return sc_signed(u); 2956 2957 if (u.sgn == SC_ZERO) // case 2 2958 return sc_signed(v); 2959 2960 // other cases 2961 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2962 v.sgn, v.nbits, v.ndigits, v.digit); 2963} 2964 2965 2966sc_signed 2967operator | (const sc_signed &u, int64 v) 2968{ 2969 if (v == 0) // case 1 2970 return sc_signed(u); 2971 2972 CONVERT_INT64(v); 2973 2974 if (u.sgn == SC_ZERO) // case 2 2975 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 2976 2977 // other cases 2978 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2979 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2980} 2981 2982 2983sc_signed 2984operator | (int64 u, const sc_signed &v) 2985{ 2986 if (u == 0) 2987 return sc_signed(v); 2988 2989 CONVERT_INT64(u); 2990 2991 if (v.sgn == SC_ZERO) 2992 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 2993 2994 // other cases 2995 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2996 v.sgn, v.nbits, v.ndigits, v.digit); 2997} 2998 2999 3000sc_signed 3001operator | (const sc_unsigned &u, int64 v) 3002{ 3003 if (v == 0) // case 1 3004 return sc_signed(u); 3005 3006 CONVERT_INT64(v); 3007 3008 if (u.sgn == SC_ZERO) // case 2 3009 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 3010 3011 // other cases 3012 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3013 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 3014} 3015 3016 3017sc_signed 3018operator | (int64 u, const sc_unsigned &v) 3019{ 3020 if (u == 0) 3021 return sc_signed(v); 3022 3023 CONVERT_INT64(u); 3024 3025 if (v.sgn == SC_ZERO) 3026 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 3027 3028 // other cases 3029 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 3030 v.sgn, v.nbits, v.ndigits, v.digit); 3031} 3032 3033 3034sc_signed 3035operator | (const sc_signed &u, uint64 v) 3036{ 3037 if (v == 0) // case 1 3038 return sc_signed(u); 3039 3040 CONVERT_INT64(v); 3041 3042 if (u.sgn == SC_ZERO) // case 2 3043 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 3044 3045 // other cases 3046 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3047 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 3048} 3049 3050 3051sc_signed 3052operator | (uint64 u, const sc_signed &v) 3053{ 3054 if (u == 0) 3055 return sc_signed(v); 3056 3057 CONVERT_INT64(u); 3058 3059 if (v.sgn == SC_ZERO) 3060 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 3061 3062 // other cases 3063 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 3064 v.sgn, v.nbits, v.ndigits, v.digit); 3065} 3066 3067 3068sc_signed 3069operator | (const sc_signed &u, long v) 3070{ 3071 if (v == 0) // case 1 3072 return sc_signed(u); 3073 3074 CONVERT_LONG(v); 3075 3076 if (u.sgn == SC_ZERO) // case 2 3077 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3078 3079 // other cases 3080 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3081 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3082} 3083 3084 3085sc_signed 3086operator | (long u, const sc_signed &v) 3087{ 3088 if (u == 0) 3089 return sc_signed(v); 3090 3091 CONVERT_LONG(u); 3092 3093 if (v.sgn == SC_ZERO) 3094 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3095 3096 // other cases 3097 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3098 v.sgn, v.nbits, v.ndigits, v.digit); 3099} 3100 3101 3102sc_signed 3103operator | (const sc_unsigned &u, long v) 3104{ 3105 if (v == 0) // case 1 3106 return sc_signed(u); 3107 3108 CONVERT_LONG(v); 3109 3110 if (u.sgn == SC_ZERO) // case 2 3111 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3112 3113 // other cases 3114 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3115 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3116} 3117 3118 3119sc_signed 3120operator | (long u, const sc_unsigned &v) 3121{ 3122 if (u == 0) 3123 return sc_signed(v); 3124 3125 CONVERT_LONG(u); 3126 3127 if (v.sgn == SC_ZERO) 3128 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3129 3130 // other cases 3131 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3132 v.sgn, v.nbits, v.ndigits, v.digit); 3133} 3134 3135 3136sc_signed 3137operator | (const sc_signed &u, unsigned long v) 3138{ 3139 if (v == 0) // case 1 3140 return sc_signed(u); 3141 3142 CONVERT_LONG(v); 3143 3144 if (u.sgn == SC_ZERO) // case 2 3145 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3146 3147 // other cases 3148 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3149 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3150} 3151 3152 3153sc_signed 3154operator | (unsigned long u, const sc_signed &v) 3155{ 3156 if (u == 0) 3157 return sc_signed(v); 3158 3159 CONVERT_LONG(u); 3160 3161 if (v.sgn == SC_ZERO) 3162 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3163 3164 // other cases 3165 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3166 v.sgn, v.nbits, v.ndigits, v.digit); 3167} 3168 3169// The rest of the operators in this section are included from 3170// sc_nbcommon.cpp. 3171 3172 3173// ---------------------------------------------------------------------------- 3174// SECTION: Bitwise XOR operators: ^, ^= 3175// ---------------------------------------------------------------------------- 3176 3177// Cases to consider when computing u ^ v: 3178// Note that u ^ v = (~u &v) | (u & ~v). 3179// 1. u ^ 0 = u 3180// 2. 0 ^ v = v 3181// 3. u ^ v => sgn = + 3182// 4. (-u) ^ (-v) => sgn = - 3183// 5. u ^ (-v) => sgn = - 3184// 6. (-u) ^ v => sgn = + 3185 3186sc_signed 3187operator ^ (const sc_unsigned &u, const sc_signed &v) 3188{ 3189 3190 if (v.sgn == SC_ZERO) // case 1 3191 return sc_signed(u); 3192 3193 if (u.sgn == SC_ZERO) // case 2 3194 return sc_signed(v); 3195 3196 // other cases 3197 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3198 v.sgn, v.nbits, v.ndigits, v.digit); 3199 3200} 3201 3202 3203sc_signed 3204operator ^ (const sc_signed &u, const sc_unsigned &v) 3205{ 3206 if (v.sgn == SC_ZERO) // case 1 3207 return sc_signed(u); 3208 3209 if (u.sgn == SC_ZERO) // case 2 3210 return sc_signed(v); 3211 3212 // other cases 3213 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3214 v.sgn, v.nbits, v.ndigits, v.digit); 3215} 3216 3217 3218sc_signed 3219operator ^ (const sc_signed &u, const sc_signed &v) 3220{ 3221 if (v.sgn == SC_ZERO) // case 1 3222 return sc_signed(u); 3223 3224 if (u.sgn == SC_ZERO) // case 2 3225 return sc_signed(v); 3226 3227 // other cases 3228 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3229 v.sgn, v.nbits, v.ndigits, v.digit); 3230} 3231 3232 3233sc_signed 3234operator ^ (const sc_signed &u, int64 v) 3235{ 3236 if (v == 0) // case 1 3237 return sc_signed(u); 3238 3239 CONVERT_INT64(v); 3240 3241 if (u.sgn == SC_ZERO) // case 2 3242 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 3243 3244 // other cases 3245 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3246 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 3247} 3248 3249 3250sc_signed 3251operator ^ (int64 u, const sc_signed &v) 3252{ 3253 if (u == 0) 3254 return sc_signed(v); 3255 3256 CONVERT_INT64(u); 3257 3258 if (v.sgn == SC_ZERO) 3259 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 3260 3261 // other cases 3262 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 3263 v.sgn, v.nbits, v.ndigits, v.digit); 3264} 3265 3266 3267sc_signed 3268operator ^ (const sc_unsigned &u, int64 v) 3269{ 3270 if (v == 0) // case 1 3271 return sc_signed(u); 3272 3273 CONVERT_INT64(v); 3274 3275 if (u.sgn == SC_ZERO) // case 2 3276 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 3277 3278 // other cases 3279 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3280 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 3281} 3282 3283 3284sc_signed 3285operator ^ (int64 u, const sc_unsigned &v) 3286{ 3287 if (u == 0) 3288 return sc_signed(v); 3289 3290 CONVERT_INT64(u); 3291 3292 if (v.sgn == SC_ZERO) 3293 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 3294 3295 // other cases 3296 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 3297 v.sgn, v.nbits, v.ndigits, v.digit); 3298} 3299 3300 3301sc_signed 3302operator ^ (const sc_signed &u, uint64 v) 3303{ 3304 if (v == 0) // case 1 3305 return sc_signed(u); 3306 3307 CONVERT_INT64(v); 3308 3309 if (u.sgn == SC_ZERO) // case 2 3310 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 3311 3312 // other cases 3313 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3314 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 3315} 3316 3317sc_signed 3318operator ^ (uint64 u, const sc_signed &v) 3319{ 3320 if (u == 0) 3321 return sc_signed(v); 3322 3323 CONVERT_INT64(u); 3324 3325 if (v.sgn == SC_ZERO) 3326 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 3327 3328 // other cases 3329 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 3330 v.sgn, v.nbits, v.ndigits, v.digit); 3331} 3332 3333 3334sc_signed 3335operator ^ (const sc_signed &u, long v) 3336{ 3337 if (v == 0) // case 1 3338 return sc_signed(u); 3339 3340 CONVERT_LONG(v); 3341 3342 if (u.sgn == SC_ZERO) // case 2 3343 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3344 3345 // other cases 3346 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3347 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3348} 3349 3350 3351sc_signed 3352operator ^ (long u, const sc_signed &v) 3353{ 3354 if (u == 0) 3355 return sc_signed(v); 3356 3357 CONVERT_LONG(u); 3358 3359 if (v.sgn == SC_ZERO) 3360 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3361 3362 // other cases 3363 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3364 v.sgn, v.nbits, v.ndigits, v.digit); 3365} 3366 3367 3368sc_signed 3369operator ^ (const sc_unsigned &u, long v) 3370{ 3371 if (v == 0) // case 1 3372 return sc_signed(u); 3373 3374 CONVERT_LONG(v); 3375 3376 if (u.sgn == SC_ZERO) // case 2 3377 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3378 3379 // other cases 3380 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3381 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3382} 3383 3384 3385sc_signed 3386operator ^ (long u, const sc_unsigned &v) 3387{ 3388 if (u == 0) 3389 return sc_signed(v); 3390 3391 CONVERT_LONG(u); 3392 3393 if (v.sgn == SC_ZERO) 3394 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3395 3396 // other cases 3397 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3398 v.sgn, v.nbits, v.ndigits, v.digit); 3399} 3400 3401 3402sc_signed 3403operator ^ (const sc_signed &u, unsigned long v) 3404{ 3405 if (v == 0) // case 1 3406 return sc_signed(u); 3407 3408 CONVERT_LONG(v); 3409 3410 if (u.sgn == SC_ZERO) // case 2 3411 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3412 3413 // other cases 3414 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3415 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3416} 3417 3418sc_signed 3419operator ^ (unsigned long u, const sc_signed &v) 3420{ 3421 if (u == 0) 3422 return sc_signed(v); 3423 3424 CONVERT_LONG(u); 3425 3426 if (v.sgn == SC_ZERO) 3427 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3428 3429 // other cases 3430 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3431 v.sgn, v.nbits, v.ndigits, v.digit); 3432} 3433 3434// The rest of the operators in this section are included from 3435// sc_nbcommon.cpp. 3436 3437 3438// ---------------------------------------------------------------------------- 3439// SECTION: Bitwise NOT operator: ~ 3440// ---------------------------------------------------------------------------- 3441 3442// Operators in this section are included from sc_nbcommon.cpp. 3443 3444 3445// ---------------------------------------------------------------------------- 3446// SECTION: LEFT SHIFT operators: <<, <<= 3447// ---------------------------------------------------------------------------- 3448 3449sc_signed 3450operator << (const sc_signed &u, const sc_unsigned &v) 3451{ 3452 if (v.sgn == SC_ZERO) 3453 return sc_signed(u); 3454 3455 return operator << (u, v.to_ulong()); 3456} 3457 3458// The rest of the operators in this section are included from 3459// sc_nbcommon.cpp. 3460 3461 3462// ---------------------------------------------------------------------------- 3463// SECTION: RIGHT SHIFT operators: >>, >>= 3464// ---------------------------------------------------------------------------- 3465 3466sc_signed 3467operator >> (const sc_signed &u, const sc_unsigned &v) 3468{ 3469 if (v.sgn == SC_ZERO) 3470 return sc_signed(u); 3471 3472 return operator >> (u, v.to_ulong()); 3473} 3474 3475// The rest of the operators in this section are included from 3476// sc_nbcommon.cpp. 3477 3478 3479// ---------------------------------------------------------------------------- 3480// SECTION: Unary arithmetic operators. 3481// ---------------------------------------------------------------------------- 3482 3483sc_signed 3484operator + (const sc_signed &u) 3485{ 3486 return sc_signed(u); 3487} 3488 3489sc_signed 3490operator - (const sc_signed &u) 3491{ 3492 return sc_signed(u, -u.sgn); 3493} 3494 3495sc_signed 3496operator - (const sc_unsigned &u) 3497{ 3498 return sc_signed(u, -u.sgn); 3499} 3500 3501 3502// ---------------------------------------------------------------------------- 3503// SECTION: EQUAL operator: == 3504// ---------------------------------------------------------------------------- 3505 3506bool 3507operator == (const sc_signed &u, const sc_signed &v) 3508{ 3509 if (u.sgn != v.sgn) 3510 return false; 3511 3512 if (&u == &v) 3513 return true; 3514 3515 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) != 0) 3516 return false; 3517 3518 return true; 3519} 3520 3521 3522bool 3523operator == (const sc_signed &u, int64 v) 3524{ 3525 CONVERT_INT64(v); 3526 3527 if (u.sgn != vs) 3528 return false; 3529 3530 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0) 3531 return false; 3532 3533 return true; 3534} 3535 3536 3537bool 3538operator == (int64 u, const sc_signed &v) 3539{ 3540 CONVERT_INT64(u); 3541 3542 if (us != v.sgn) 3543 return false; 3544 3545 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0) 3546 return false; 3547 3548 return true; 3549} 3550 3551 3552bool 3553operator == (const sc_signed &u, uint64 v) 3554{ 3555 CONVERT_INT64(v); 3556 3557 if (u.sgn != vs) 3558 return false; 3559 3560 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0) 3561 return false; 3562 3563 return true; 3564} 3565 3566 3567bool 3568operator == (uint64 u, const sc_signed &v) 3569{ 3570 CONVERT_INT64(u); 3571 3572 if (us != v.sgn) 3573 return false; 3574 3575 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0) 3576 return false; 3577 3578 return true; 3579} 3580 3581 3582bool 3583operator == (const sc_signed &u, long v) 3584{ 3585 CONVERT_LONG(v); 3586 3587 if (u.sgn != vs) 3588 return false; 3589 3590 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0) 3591 return false; 3592 3593 return true; 3594} 3595 3596 3597bool 3598operator == (long u, const sc_signed &v) 3599{ 3600 CONVERT_LONG(u); 3601 3602 if (us != v.sgn) 3603 return false; 3604 3605 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0) 3606 return false; 3607 3608 return true; 3609} 3610 3611 3612bool 3613operator == (const sc_signed &u, unsigned long v) 3614{ 3615 CONVERT_LONG(v); 3616 3617 if (u.sgn != vs) 3618 return false; 3619 3620 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0) 3621 return false; 3622 3623 return true; 3624} 3625 3626 3627bool 3628operator == (unsigned long u, const sc_signed &v) 3629{ 3630 CONVERT_LONG(u); 3631 3632 if (us != v.sgn) 3633 return false; 3634 3635 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0) 3636 return false; 3637 3638 return true; 3639} 3640 3641 3642// ---------------------------------------------------------------------------- 3643// SECTION: NOT_EQUAL operator: != 3644// ---------------------------------------------------------------------------- 3645 3646// Operators in this section are included from sc_nbcommon.cpp. 3647 3648 3649// ---------------------------------------------------------------------------- 3650// SECTION: LESS THAN operator: < 3651// ---------------------------------------------------------------------------- 3652 3653bool 3654operator < (const sc_signed &u, const sc_signed &v) 3655{ 3656 if (u.sgn < v.sgn) 3657 return true; 3658 3659 if (u.sgn > v.sgn) 3660 return false; 3661 3662 // u.sgn == v.sgn 3663 3664 if (&u == &v) 3665 return false; 3666 3667 if (u.sgn == SC_POS) { 3668 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) < 0) 3669 return true; 3670 } else if (u.sgn == SC_NEG) { 3671 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) > 0) 3672 return true; 3673 } 3674 3675 return false; 3676} 3677 3678 3679bool 3680operator < (const sc_signed &u, int64 v) 3681{ 3682 CONVERT_INT64(v); 3683 3684 if (u.sgn < vs) 3685 return true; 3686 3687 if (u.sgn > vs) 3688 return false; 3689 3690 // u.sgn == vs 3691 3692 if (vs == SC_POS) { 3693 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0) 3694 return true; 3695 } else if (vs == SC_NEG) { 3696 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) > 0) 3697 return true; 3698 } 3699 3700 return false; 3701} 3702 3703 3704bool 3705operator < (int64 u, const sc_signed &v) 3706{ 3707 CONVERT_INT64(u); 3708 3709 if (us < v.sgn) 3710 return true; 3711 3712 if (us > v.sgn) 3713 return false; 3714 3715 // us == v.sgn 3716 3717 if (us == SC_POS) { 3718 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0) 3719 return true; 3720 } else if (us == SC_NEG) { 3721 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) > 0) 3722 return true; 3723 } 3724 3725 return false; 3726} 3727 3728 3729bool 3730operator < (const sc_signed &u, uint64 v) 3731{ 3732 CONVERT_INT64(v); 3733 3734 if (u.sgn < vs) 3735 return true; 3736 3737 if (u.sgn > vs) 3738 return false; 3739 3740 // u.sgn == vs 3741 3742 if (vs == SC_POS) { 3743 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0) 3744 return true; 3745 } 3746 3747 return false; 3748} 3749 3750 3751bool 3752operator < (uint64 u, const sc_signed &v) 3753{ 3754 CONVERT_INT64(u); 3755 3756 if (us < v.sgn) 3757 return true; 3758 3759 if (us > v.sgn) 3760 return false; 3761 3762 // us == v.sgn 3763 3764 if (us == SC_POS) { 3765 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0) 3766 return true; 3767 } 3768 3769 return false; 3770} 3771 3772 3773bool 3774operator < (const sc_signed &u, long v) 3775{ 3776 CONVERT_LONG(v); 3777 3778 if (u.sgn < vs) 3779 return true; 3780 3781 if (u.sgn > vs) 3782 return false; 3783 3784 // u.sgn == vs 3785 3786 if (vs == SC_POS) { 3787 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0) 3788 return true; 3789 3790 } else if (vs == SC_NEG) { 3791 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) > 0) 3792 return true; 3793 } 3794 3795 return false; 3796} 3797 3798 3799bool 3800operator < (long u, const sc_signed &v) 3801{ 3802 CONVERT_LONG(u); 3803 3804 if (us < v.sgn) 3805 return true; 3806 3807 if (us > v.sgn) 3808 return false; 3809 3810 // us == v.sgn 3811 3812 if (us == SC_POS) { 3813 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0) 3814 return true; 3815 } else if (us == SC_NEG) { 3816 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) > 0) 3817 return true; 3818 } 3819 3820 return false; 3821} 3822 3823 3824bool 3825operator < (const sc_signed &u, unsigned long v) 3826{ 3827 CONVERT_LONG(v); 3828 3829 if (u.sgn < vs) 3830 return true; 3831 3832 if (u.sgn > vs) 3833 return false; 3834 3835 // u.sgn == vs 3836 3837 if (vs == SC_POS) { 3838 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0) 3839 return true; 3840 } 3841 3842 return false; 3843} 3844 3845 3846bool 3847operator < (unsigned long u, const sc_signed &v) 3848{ 3849 CONVERT_LONG(u); 3850 3851 if (us < v.sgn) 3852 return true; 3853 3854 if (us > v.sgn) 3855 return false; 3856 3857 // us == v.sgn 3858 3859 if (us == SC_POS) { 3860 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0) 3861 return true; 3862 } 3863 3864 return false; 3865} 3866 3867 3868// --------------------------------------------------------------------------- 3869// SECTION: LESS THAN or EQUAL operator: <= 3870// --------------------------------------------------------------------------- 3871 3872// Operators in this section are included from sc_nbcommon.cpp. 3873 3874 3875// --------------------------------------------------------------------------- 3876// SECTION: GREATER THAN operator: > 3877// --------------------------------------------------------------------------- 3878 3879// Operators in this section are included from sc_nbcommon.cpp. 3880 3881 3882// --------------------------------------------------------------------------- 3883// SECTION: GREATER THAN or EQUAL operator: >= 3884// --------------------------------------------------------------------------- 3885 3886// Operators in this section are included from sc_nbcommon.cpp. 3887 3888 3889// --------------------------------------------------------------------------- 3890// SECTION: Public members - Other utils. 3891// --------------------------------------------------------------------------- 3892 3893bool 3894sc_signed::iszero() const 3895{ 3896 if (sgn == SC_ZERO) 3897 return true; 3898 else if (sgn != SC_NOSIGN) 3899 return false; 3900 else 3901 return check_for_zero(ndigits, digit); 3902} 3903 3904 3905bool 3906sc_signed::sign() const 3907{ 3908 if (sgn == SC_NEG) 3909 return 1; 3910 else if (sgn != SC_NOSIGN) 3911 return 0; 3912 else 3913 return ((digit[ndigits - 1] & one_and_zeros(bit_ord(nbits - 1))) != 0); 3914} 3915 3916// The rest of the utils in this section are included from sc_nbcommon.cpp. 3917 3918 3919// ---------------------------------------------------------------------------- 3920// SECTION: Private members. 3921// ---------------------------------------------------------------------------- 3922 3923// The private members in this section are included from sc_nbcommon.cpp. 3924 3925#define CLASS_TYPE sc_signed 3926#define CLASS_TYPE_STR "sc_signed" 3927 3928#define ADD_HELPER add_signed_friend 3929#define SUB_HELPER sub_signed_friend 3930#define MUL_HELPER mul_signed_friend 3931#define DIV_HELPER div_signed_friend 3932#define MOD_HELPER mod_signed_friend 3933#define AND_HELPER and_signed_friend 3934#define OR_HELPER or_signed_friend 3935#define XOR_HELPER xor_signed_friend 3936 3937#include "sc_nbfriends.inc" 3938 3939#undef SC_UNSIGNED 3940#define SC_SIGNED 3941#define IF_SC_SIGNED 1 // 1 = sc_signed 3942#define CLASS_TYPE_SUBREF sc_signed_subref_r 3943#define OTHER_CLASS_TYPE sc_unsigned 3944#define OTHER_CLASS_TYPE_SUBREF sc_unsigned_subref_r 3945 3946#define MUL_ON_HELPER mul_on_help_signed 3947#define DIV_ON_HELPER div_on_help_signed 3948#define MOD_ON_HELPER mod_on_help_signed 3949 3950#include "sc_nbcommon.inc" 3951 3952#undef MOD_ON_HELPER 3953#undef DIV_ON_HELPER 3954#undef MUL_ON_HELPER 3955 3956#undef OTHER_CLASS_TYPE_SUBREF 3957#undef OTHER_CLASS_TYPE 3958#undef CLASS_TYPE_SUBREF 3959#undef IF_SC_SIGNED 3960#undef SC_SIGNED 3961 3962#undef XOR_HELPER 3963#undef OR_HELPER 3964#undef AND_HELPER 3965#undef MOD_HELPER 3966#undef DIV_HELPER 3967#undef MUL_HELPER 3968#undef SUB_HELPER 3969#undef ADD_HELPER 3970 3971#undef CLASS_TYPE 3972#undef CLASS_TYPE_STR 3973 3974#include "sc_signed_bitref.inc" 3975#include "sc_signed_subref.inc" 3976 3977#undef CONVERT_LONG 3978#undef CONVERT_LONG_2 3979#undef CONVERT_INT64 3980#undef CONVERT_INT64_2 3981 3982} // namespace sc_dt
| 139 sc_core::sc_abort(); // can't recover from here 140} 141 142 143// ---------------------------------------------------------------------------- 144 145// ---------------------------------------------------------------------------- 146// SECTION: Public members. 147// ---------------------------------------------------------------------------- 148 149// Most public members are included from sc_nbcommon.inc. However, some 150// concatenation support appears here to optimize between the signed and 151// unsigned cases. 152 153// Insert this object's value at the specified place in a vector of biguint 154// style values. 155 156bool 157sc_signed::concat_get_ctrl(sc_digit *dst_p, int low_i) const 158{ 159 int dst_i; // Index to next word to set in dst_p. 160 int end_i; // Index of high order word to set. 161 int left_shift; // Amount to shift value left. 162 sc_digit mask; // Mask for partial word sets. 163 164 // CALCULATE METRICS FOR DATA MOVEMENT: 165 dst_i = low_i / BITS_PER_DIGIT; 166 end_i = (low_i + nbits - 1) / BITS_PER_DIGIT; 167 left_shift = low_i % BITS_PER_DIGIT; 168 169 // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 170 mask = ~(~0U << left_shift); 171 dst_p[dst_i] = (dst_p[dst_i] & ~mask); 172 dst_i++; 173 174 for (; dst_i <= end_i; dst_i++) 175 dst_p[dst_i] = 0; 176 177 return false; 178} 179 180bool 181sc_signed::concat_get_data(sc_digit *dst_p, int low_i) const 182{ 183 sc_digit carry; // Carry bit for complements. 184 int dst_i; // Index to next word to set in dst_p. 185 int end_i; // Index of high order word to set. 186 int high_i; // Index w/in word of high order bit. 187 int left_shift; // Amount to shift value left. 188 sc_digit left_word; // High word component for set. 189 sc_digit mask; // Mask for partial word sets. 190 bool result; // True if inserted non-zero data. 191 int right_shift; // Amount to shift value right. 192 sc_digit right_word; // Low word component for set. 193 int src_i; // Index to next word to get from digit. 194 195 // CALCULATE METRICS FOR DATA MOVEMENT: 196 dst_i = low_i / BITS_PER_DIGIT; 197 high_i = low_i + nbits - 1; 198 end_i = high_i / BITS_PER_DIGIT; 199 left_shift = low_i % BITS_PER_DIGIT; 200 201 switch (sgn) { 202 // POSITIVE SOURCE VALUE: 203 case SC_POS: 204 result = true; 205 206 // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 207 if (dst_i == end_i) { 208 mask = ~(~0U << left_shift); 209 dst_p[dst_i] = ((dst_p[dst_i] & mask) | 210 (digit[0] << left_shift)) & DIGIT_MASK; 211 212 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED: 213 } else if (left_shift == 0) { 214 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) { 215 dst_p[dst_i] = digit[src_i]; 216 } 217 high_i = high_i % BITS_PER_DIGIT; 218 mask = ~(~1U << high_i) & DIGIT_MASK; 219 dst_p[dst_i] = digit[src_i] & mask; 220 221 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED: 222 } else { 223 high_i = high_i % BITS_PER_DIGIT; 224 right_shift = BITS_PER_DIGIT - left_shift; 225 mask = ~(~0U << left_shift); 226 right_word = digit[0]; 227 dst_p[dst_i] = (dst_p[dst_i] & mask) | 228 ((right_word << left_shift) & DIGIT_MASK); 229 for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) { 230 left_word = digit[src_i]; 231 dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) | 232 (right_word >> right_shift); 233 right_word = left_word; 234 } 235 left_word = (src_i < ndigits) ? digit[src_i] : 0; 236 mask = ~(~1U << high_i) & DIGIT_MASK; 237 dst_p[dst_i] = ((left_word << left_shift) | 238 (right_word >> right_shift)) & mask; 239 } 240 break; 241 242 // SOURCE VALUE IS NEGATIVE: 243 case SC_NEG: 244 // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 245 result = true; 246 if (dst_i == end_i) { 247 mask = ~(~0U << nbits); 248 right_word = ((digit[0] ^ DIGIT_MASK) + 1) & mask; 249 mask = ~(~0U << left_shift); 250 dst_p[dst_i] = ((dst_p[dst_i] & mask) | 251 (right_word << left_shift)) & DIGIT_MASK; 252 253 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED: 254 } else if (left_shift == 0) { 255 carry = 1; 256 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) { 257 right_word = (digit[src_i] ^ DIGIT_MASK) + carry; 258 dst_p[dst_i] = right_word & DIGIT_MASK; 259 carry = right_word >> BITS_PER_DIGIT; 260 } 261 high_i = high_i % BITS_PER_DIGIT; 262 mask = (~(~1U << high_i)) & DIGIT_MASK; 263 right_word = (src_i < ndigits) ? 264 (digit[src_i] ^ DIGIT_MASK) + carry : DIGIT_MASK + carry; 265 dst_p[dst_i] = right_word & mask; 266 267 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED: 268 } else { 269 high_i = high_i % BITS_PER_DIGIT; 270 right_shift = BITS_PER_DIGIT - left_shift; 271 mask = ~(~0U << left_shift); 272 carry = 1; 273 right_word = (digit[0] ^ DIGIT_MASK) + carry; 274 dst_p[dst_i] = (dst_p[dst_i] & mask) | 275 ((right_word << left_shift) & DIGIT_MASK); 276 carry = right_word >> BITS_PER_DIGIT; 277 right_word &= DIGIT_MASK; 278 for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) { 279 left_word = (digit[src_i] ^ DIGIT_MASK) + carry; 280 dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) | 281 (right_word >> right_shift); 282 carry = left_word >> BITS_PER_DIGIT; 283 right_word = left_word & DIGIT_MASK; 284 } 285 left_word = (src_i < ndigits) ? 286 (digit[src_i] ^ DIGIT_MASK) + carry : carry; 287 mask = ~(~1U << high_i) & DIGIT_MASK; 288 dst_p[dst_i] = ((left_word << left_shift) | 289 (right_word >> right_shift)) & mask; 290 } 291 break; 292 293 // VALUE IS ZERO: 294 default: 295 result = false; 296 // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 297 if (dst_i == end_i) { 298 mask = ~(~0U << nbits) << left_shift; 299 dst_p[dst_i] = dst_p[dst_i] & ~mask; 300 301 // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED: 302 } else if (left_shift == 0) { 303 for (src_i = 0; dst_i < end_i; dst_i++, src_i++) { 304 dst_p[dst_i] = 0; 305 } 306 dst_p[dst_i] = 0; 307 308 // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED: 309 } else { 310 mask = ~(~0U << left_shift); 311 dst_p[dst_i] = (dst_p[dst_i] & mask); 312 for (dst_i++; dst_i <= end_i; dst_i++) { 313 dst_p[dst_i] = 0; 314 } 315 } 316 break; 317 } 318 return result; 319} 320 321// Return this object instance's bits as a uint64 without sign extension. 322 323uint64 324sc_signed::concat_get_uint64() const 325{ 326 uint64 result; 327 switch (sgn) { 328 case SC_POS: 329 result = 0; 330 if (ndigits > 2) 331 result = digit[2]; 332 if (ndigits > 1) 333 result = (result << BITS_PER_DIGIT) | digit[1]; 334 result = (result << BITS_PER_DIGIT) | digit[0]; 335 break; 336 case SC_NEG: 337 result = 0; 338 if (ndigits > 2) 339 result = digit[2]; 340 if (ndigits > 1) 341 result = (result << BITS_PER_DIGIT) | digit[1]; 342 result = (result << BITS_PER_DIGIT) | digit[0]; 343 result = -result; 344 if (nbits < 64) { 345 uint64 mask = ~0; 346 result = result & ~(mask << nbits); 347 } 348 break; 349 default: 350 result = 0; 351 break; 352 } 353 return result; 354} 355 356// #### OPTIMIZE 357void 358sc_signed::concat_set(int64 src, int low_i) 359{ 360 *this = (low_i < 64) ? src >> low_i : src >> 63; 361} 362 363void 364sc_signed::concat_set(const sc_signed &src, int low_i) 365{ 366 if (low_i < src.length()) 367 *this = src >> low_i; 368 else 369 *this = (src<0) ? (int_type)-1 : 0; 370} 371 372void 373sc_signed::concat_set(const sc_unsigned &src, int low_i) 374{ 375 if (low_i < src.length()) 376 *this = src >> low_i; 377 else 378 *this = 0; 379} 380 381void 382sc_signed::concat_set(uint64 src, int low_i) 383{ 384 *this = (low_i < 64) ? src >> low_i : 0; 385} 386 387// ---------------------------------------------------------------------------- 388// SECTION: Public members - Reduction methods. 389// ---------------------------------------------------------------------------- 390 391bool 392sc_signed::and_reduce() const 393{ 394 sc_digit current; // Current digit examining. 395 int i; // Index of digit examining. 396 397 if (sgn == SC_NEG) { 398 current = (1 << BITS_PER_DIGIT); 399 for (i = 0; i < ndigits-1; i++) { 400 current = (current >> BITS_PER_DIGIT) + (digit[i]^DIGIT_MASK); 401 if ((current & DIGIT_MASK) != DIGIT_MASK) return false; 402 } 403 current = (current >> BITS_PER_DIGIT) + (digit[i]^DIGIT_MASK); 404 if ((current & ~(~0U << (nbits % BITS_PER_DIGIT))) == 405 static_cast<sc_digit>(~(~0U << (nbits % BITS_PER_DIGIT)))) { 406 return true; 407 } 408 } 409 return false; 410} 411 412bool 413sc_signed::or_reduce() const 414{ 415 return sgn == SC_ZERO ? false : true; 416} 417 418bool 419sc_signed::xor_reduce() const 420{ 421 int i; // Digit examining. 422 int odd; // Flag for odd number of digits. 423 424 odd = 0; 425 for (i = 0; i < nbits; i++) 426 if (test(i)) 427 odd = ~odd; 428 return odd ? true : false; 429} 430 431 432 433// ---------------------------------------------------------------------------- 434// SECTION: Public members - Assignment operators. 435// ---------------------------------------------------------------------------- 436 437// assignment operators 438 439const sc_signed & 440sc_signed::operator = (const char *a) 441{ 442 if (a == 0) { 443 SC_REPORT_ERROR("conversion failed", 444 "character string is zero"); 445 } else if (*a == 0) { 446 SC_REPORT_ERROR("conversion failed", 447 "character string is empty"); 448 } else try { 449 int len = length(); 450 sc_fix aa(a, len, len, SC_TRN, SC_WRAP, 0, SC_ON); 451 return this->operator = (aa); 452 } catch(const sc_core::sc_report &) { 453 std::stringstream msg; 454 msg << "character string '" << a << "' is not valid"; 455 SC_REPORT_ERROR("conversion failed", msg.str().c_str()); 456 } 457 return *this; 458} 459 460const sc_signed & 461sc_signed::operator=(int64 v) 462{ 463 sgn = get_sign(v); 464 // v >= 0 now. 465 if (sgn == SC_ZERO) { 466 vec_zero(ndigits, digit); 467 } else { 468 from_uint(ndigits, digit, (uint64)v); 469 if (nbits <= (int)BITS_PER_INT64) 470 convert_SM_to_2C_to_SM(); 471 } 472 return *this; 473} 474 475const sc_signed & 476sc_signed::operator=(uint64 v) 477{ 478 sgn = get_sign(v); 479 if (sgn == SC_ZERO) { 480 vec_zero(ndigits, digit); 481 } else { 482 from_uint(ndigits, digit, v); 483 if (nbits <= (int)BITS_PER_INT64) 484 convert_SM_to_2C_to_SM(); 485 } 486 return *this; 487} 488 489const sc_signed & 490sc_signed::operator=(long v) 491{ 492 sgn = get_sign(v); 493 // v >= 0 now. 494 if (sgn == SC_ZERO) { 495 vec_zero(ndigits, digit); 496 } else { 497 from_uint(ndigits, digit, (unsigned long)v); 498 if (nbits <= (int)BITS_PER_LONG) 499 convert_SM_to_2C_to_SM(); 500 } 501 return *this; 502} 503 504const sc_signed & 505sc_signed::operator=(unsigned long v) 506{ 507 sgn = get_sign(v); 508 if (sgn == SC_ZERO) { 509 vec_zero(ndigits, digit); 510 } else { 511 from_uint(ndigits, digit, v); 512 if (nbits <= (int)BITS_PER_LONG) 513 convert_SM_to_2C_to_SM(); 514 } 515 return *this; 516} 517 518const sc_signed & 519sc_signed::operator=(double v) 520{ 521 is_bad_double(v); 522 if (v < 0) { 523 v = -v; 524 sgn = SC_NEG; 525 } else { 526 sgn = SC_POS; 527 } 528 529 int i = 0; 530 while (std::floor(v) && (i < ndigits)) { 531 digit[i++] = ((sc_digit)std::floor(remainder(v, DIGIT_RADIX))) & 532 DIGIT_MASK; 533 v /= DIGIT_RADIX; 534 } 535 vec_zero(i, ndigits, digit); 536 convert_SM_to_2C_to_SM(); 537 return *this; 538} 539 540 541// ---------------------------------------------------------------------------- 542 543const sc_signed & 544sc_signed::operator = (const sc_bv_base &v) 545{ 546 int minlen = sc_min(nbits, v.length()); 547 int i = 0; 548 for (; i < minlen; ++i) { 549 safe_set(i, v.get_bit(i), digit); 550 } 551 for (; i < nbits; ++i) { 552 safe_set(i, 0, digit); // zero-extend 553 } 554 convert_2C_to_SM(); 555 return *this; 556} 557 558const sc_signed & 559sc_signed::operator = (const sc_lv_base &v) 560{ 561 int minlen = sc_min(nbits, v.length()); 562 int i = 0; 563 for (; i < minlen; ++i) { 564 safe_set(i, sc_logic(v.get_bit(i)).to_bool(), digit); 565 } 566 for (; i < nbits; ++i) { 567 safe_set(i, 0, digit); // zero-extend 568 } 569 convert_2C_to_SM(); 570 return *this; 571} 572 573 574// explicit conversion to character string 575const std::string 576sc_signed::to_string(sc_numrep numrep) const 577{ 578 int len = length(); 579 sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON); 580 return aa.to_string(numrep); 581} 582 583const std::string 584sc_signed::to_string(sc_numrep numrep, bool w_prefix) const 585{ 586 int len = length(); 587 sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON); 588 return aa.to_string(numrep, w_prefix); 589} 590 591 592// ---------------------------------------------------------------------------- 593// SECTION: Interfacing with sc_int_base 594// ---------------------------------------------------------------------------- 595 596const sc_signed & 597sc_signed::operator = (const sc_int_base &v) 598{ 599 return operator = ((int64)v); 600} 601 602 603sc_signed 604operator + (const sc_unsigned &u, const sc_int_base &v) 605{ 606 return operator + (u, static_cast<int64>(v)); 607} 608 609sc_signed 610operator + (const sc_int_base &u, const sc_unsigned &v) 611{ 612 return operator + (static_cast<int64>(u), v); 613} 614 615sc_signed 616operator + (const sc_signed &u, const sc_int_base &v) 617{ 618 return operator + (u, (int64)v); 619} 620 621sc_signed 622operator + (const sc_int_base &u, const sc_signed &v) 623{ 624 return operator + ((int64)u, v); 625} 626 627const sc_signed & 628sc_signed::operator += (const sc_int_base &v) 629{ 630 return operator += ((int64)v); 631} 632 633 634sc_signed 635operator - (const sc_unsigned &u, const sc_int_base &v) 636{ 637 return operator - (u, (int64)v); 638} 639 640sc_signed 641operator - (const sc_int_base &u, const sc_unsigned &v) 642{ 643 return operator - ((int64)u, v); 644} 645 646sc_signed 647operator - (const sc_signed &u, const sc_int_base &v) 648{ 649 return operator - (u, (int64)v); 650} 651 652sc_signed 653operator - (const sc_int_base &u, const sc_signed &v) 654{ 655 return operator - ((int64)u, v); 656} 657 658const sc_signed & 659sc_signed::operator -= (const sc_int_base &v) 660{ 661 return operator -= ((int64)v); 662} 663 664 665sc_signed 666operator * (const sc_unsigned &u, const sc_int_base &v) 667{ 668 return operator * (u, static_cast<int64>(v)); 669} 670 671sc_signed 672operator * (const sc_int_base &u, const sc_unsigned &v) 673{ 674 return operator * (static_cast<int64>(u), v); 675} 676 677sc_signed 678operator * (const sc_signed &u, const sc_int_base &v) 679{ 680 return operator * (u, (int64)v); 681} 682 683sc_signed 684operator * (const sc_int_base &u, const sc_signed &v) 685{ 686 return operator * ((int64)u, v); 687} 688 689const sc_signed & 690sc_signed::operator *= (const sc_int_base &v) 691{ 692 return operator *= ((int64)v); 693} 694 695 696sc_signed 697operator / (const sc_unsigned &u, const sc_int_base &v) 698{ 699 return operator / (u, static_cast<int64>(v)); 700} 701 702sc_signed 703operator / (const sc_int_base &u, const sc_unsigned &v) 704{ 705 return operator / (static_cast<int64>(u), v); 706} 707 708sc_signed 709operator / (const sc_signed &u, const sc_int_base &v) 710{ 711 return operator / (u, (int64)v); 712} 713 714sc_signed 715operator / (const sc_int_base &u, const sc_signed &v) 716{ 717 return operator / ((int64)u, v); 718} 719 720const sc_signed & 721sc_signed::operator /= (const sc_int_base &v) 722{ 723 return operator /= ((int64)v); 724} 725 726 727sc_signed 728operator % (const sc_unsigned &u, const sc_int_base &v) 729{ 730 return operator % (u, static_cast<int64>(v)); 731} 732 733sc_signed 734operator % (const sc_int_base &u, const sc_unsigned &v) 735{ 736 return operator % (static_cast<int64>(u), v); 737} 738 739sc_signed 740operator % (const sc_signed &u, const sc_int_base &v) 741{ 742 return operator % (u, (int64)v); 743} 744 745sc_signed 746operator % (const sc_int_base &u, const sc_signed &v) 747{ 748 return operator % ((int64)u, v); 749} 750 751const sc_signed & 752sc_signed::operator %= (const sc_int_base &v) 753{ 754 return operator %= ((int64)v); 755} 756 757 758sc_signed 759operator & (const sc_unsigned &u, const sc_int_base &v) 760{ 761 return operator & (u, static_cast<int64>(v)); 762} 763 764sc_signed 765operator & (const sc_int_base &u, const sc_unsigned &v) 766{ 767 return operator & (static_cast<int64>(u), v); 768} 769 770sc_signed 771operator & (const sc_signed &u, const sc_int_base &v) 772{ 773 return operator & (u, (int64)v); 774} 775 776sc_signed 777operator & (const sc_int_base &u, const sc_signed &v) 778{ 779 return operator & ((int64)u, v); 780} 781 782const sc_signed & 783sc_signed::operator &= (const sc_int_base &v) 784{ 785 return operator &= ((int64)v); 786} 787 788 789sc_signed 790operator | (const sc_unsigned &u, const sc_int_base &v) 791{ 792 return operator | (u, static_cast<int64>(v)); 793} 794 795sc_signed 796operator | (const sc_int_base &u, const sc_unsigned &v) 797{ 798 return operator | (static_cast<int64>(u), v); 799} 800 801sc_signed 802operator | (const sc_signed& u, const sc_int_base &v) 803{ 804 return operator|(u, (int64)v); 805} 806 807sc_signed 808operator | (const sc_int_base &u, const sc_signed &v) 809{ 810 return operator | ((int64)u, v); 811} 812 813const sc_signed & 814sc_signed::operator |= (const sc_int_base &v) 815{ 816 return operator |= ((int64)v); 817} 818 819 820sc_signed 821operator ^ (const sc_unsigned &u, const sc_int_base &v) 822{ 823 return operator ^ (u, static_cast<int64>(v)); 824} 825 826sc_signed 827operator ^ (const sc_int_base &u, const sc_unsigned &v) 828{ 829 return operator ^ (static_cast<int64>(u), v); 830} 831 832sc_signed 833operator ^ (const sc_signed &u, const sc_int_base &v) 834{ 835 return operator ^ (u, (int64)v); 836} 837 838sc_signed 839operator ^ (const sc_int_base &u, const sc_signed &v) 840{ 841 return operator ^ ((int64)u, v); 842} 843 844const sc_signed & 845sc_signed::operator ^= (const sc_int_base &v) 846{ 847 return operator ^= ((int64)v); 848} 849 850 851sc_signed 852operator << (const sc_signed &u, const sc_int_base &v) 853{ 854 return operator << (u, (int64)v); 855} 856 857const sc_signed & 858sc_signed::operator <<= (const sc_int_base &v) 859{ 860 return operator <<= ((int64)v); 861} 862 863 864sc_signed 865operator >> (const sc_signed &u, const sc_int_base &v) 866{ 867 return operator >> (u, (int64)v); 868} 869 870const sc_signed & 871sc_signed::operator >>= (const sc_int_base &v) 872{ 873 return operator >>= ((int64)v); 874} 875 876 877bool 878operator == (const sc_signed &u, const sc_int_base &v) 879{ 880 return operator == (u, (int64)v); 881} 882 883bool 884operator == (const sc_int_base &u, const sc_signed &v) 885{ 886 return operator == ((int64)u, v); 887} 888 889 890bool 891operator != (const sc_signed &u, const sc_int_base &v) 892{ 893 return operator != (u, (int64)v); 894} 895 896bool 897operator != (const sc_int_base &u, const sc_signed &v) 898{ 899 return operator != ((int64)u, v); 900} 901 902 903bool 904operator < (const sc_signed &u, const sc_int_base &v) 905{ 906 return operator < (u, (int64)v); 907} 908 909bool 910operator < (const sc_int_base &u, const sc_signed &v) 911{ 912 return operator < ((int64)u, v); 913} 914 915 916bool 917operator <= (const sc_signed &u, const sc_int_base &v) 918{ 919 return operator <= (u, (int64)v); 920} 921 922bool 923operator <= (const sc_int_base &u, const sc_signed &v) 924{ 925 return operator <= ((int64)u, v); 926} 927 928 929bool 930operator > (const sc_signed &u, const sc_int_base &v) 931{ 932 return operator > (u, (int64)v); 933} 934 935bool 936operator > (const sc_int_base &u, const sc_signed &v) 937{ 938 return operator > ((int64)u, v); 939} 940 941 942bool 943operator >= (const sc_signed &u, const sc_int_base &v) 944{ 945 return operator >= (u, (int64)v); 946} 947 948bool 949operator >= (const sc_int_base &u, const sc_signed &v) 950{ 951 return operator >= ((int64)u, v); 952} 953 954 955// ---------------------------------------------------------------------------- 956// SECTION: Interfacing with sc_uint_base 957// ---------------------------------------------------------------------------- 958 959const sc_signed & 960sc_signed::operator = (const sc_uint_base &v) 961{ 962 return operator = ((uint64)v); 963} 964 965 966sc_signed 967operator + (const sc_signed &u, const sc_uint_base &v) 968{ 969 return operator + (u, (uint64)v); 970} 971 972sc_signed 973operator + (const sc_uint_base &u, const sc_signed &v) 974{ 975 return operator + ((uint64)u, v); 976} 977 978const sc_signed & 979sc_signed::operator += (const sc_uint_base &v) 980{ 981 return operator += ((uint64)v); 982} 983 984 985sc_signed 986operator - (const sc_unsigned &u, const sc_uint_base &v) 987{ 988 return operator - (u, (uint64)v); 989} 990 991sc_signed 992operator - (const sc_uint_base &u, const sc_unsigned &v) 993{ 994 return operator - ((uint64)u, v); 995} 996 997sc_signed 998operator - (const sc_signed &u, const sc_uint_base &v) 999{ 1000 return operator - (u, (uint64)v); 1001} 1002 1003sc_signed 1004operator - (const sc_uint_base &u, const sc_signed &v) 1005{ 1006 return operator - ((uint64)u, v); 1007} 1008 1009const sc_signed & 1010sc_signed::operator -= (const sc_uint_base &v) 1011{ 1012 return operator -= ((uint64)v); 1013} 1014 1015 1016sc_signed 1017operator * (const sc_signed &u, const sc_uint_base &v) 1018{ 1019 return operator * (u, (uint64)v); 1020} 1021 1022sc_signed 1023operator * (const sc_uint_base &u, const sc_signed &v) 1024{ 1025 return operator * ((uint64)u, v); 1026} 1027 1028const sc_signed & 1029sc_signed::operator *= (const sc_uint_base &v) 1030{ 1031 return operator *= ((uint64)v); 1032} 1033 1034 1035sc_signed 1036operator / (const sc_signed &u, const sc_uint_base &v) 1037{ 1038 return operator / (u, (uint64)v); 1039} 1040 1041sc_signed 1042operator / (const sc_uint_base &u, const sc_signed &v) 1043{ 1044 return operator / ((uint64)u, v); 1045} 1046 1047const sc_signed & 1048sc_signed::operator /= (const sc_uint_base &v) 1049{ 1050 return operator /= ((uint64)v); 1051} 1052 1053 1054sc_signed 1055operator % (const sc_signed &u, const sc_uint_base &v) 1056{ 1057 return operator % (u, (uint64)v); 1058} 1059 1060sc_signed 1061operator % (const sc_uint_base &u, const sc_signed &v) 1062{ 1063 return operator % ((uint64)u, v); 1064} 1065 1066const sc_signed& 1067sc_signed::operator %= (const sc_uint_base &v) 1068{ 1069 return operator %= ((uint64)v); 1070} 1071 1072 1073sc_signed 1074operator & (const sc_signed &u, const sc_uint_base &v) 1075{ 1076 return operator & (u, (uint64)v); 1077} 1078 1079sc_signed 1080operator & (const sc_uint_base &u, const sc_signed &v) 1081{ 1082 return operator & ((uint64)u, v); 1083} 1084 1085const sc_signed & 1086sc_signed::operator &= (const sc_uint_base &v) 1087{ 1088 return operator &= ((uint64)v); 1089} 1090 1091 1092sc_signed 1093operator | (const sc_signed &u, const sc_uint_base &v) 1094{ 1095 return operator | (u, (uint64)v); 1096} 1097 1098sc_signed 1099operator | (const sc_uint_base &u, const sc_signed &v) 1100{ 1101 return operator | ((uint64)u, v); 1102} 1103 1104const sc_signed & 1105sc_signed::operator |= (const sc_uint_base &v) 1106{ 1107 return operator |= ((uint64)v); 1108} 1109 1110 1111sc_signed 1112operator ^ (const sc_signed &u, const sc_uint_base &v) 1113{ 1114 return operator ^ (u, (uint64)v); 1115} 1116 1117sc_signed 1118operator ^ (const sc_uint_base &u, const sc_signed &v) 1119{ 1120 return operator ^ ((uint64)u, v); 1121} 1122 1123const sc_signed & 1124sc_signed::operator ^= (const sc_uint_base &v) 1125{ 1126 return operator ^= ((uint64)v); 1127} 1128 1129 1130sc_signed 1131operator << (const sc_signed &u, const sc_uint_base &v) 1132{ 1133 return operator << (u, (uint64)v); 1134} 1135 1136const sc_signed & 1137sc_signed::operator <<= (const sc_uint_base &v) 1138{ 1139 return operator <<= ((uint64)v); 1140} 1141 1142 1143sc_signed 1144operator >> (const sc_signed& u, const sc_uint_base& v) 1145{ 1146 return operator >> (u, (uint64)v); 1147} 1148 1149const sc_signed & 1150sc_signed::operator >>= (const sc_uint_base& v) 1151{ 1152 return operator >>= ((uint64)v); 1153} 1154 1155 1156bool 1157operator == (const sc_signed &u, const sc_uint_base &v) 1158{ 1159 return operator == (u, (uint64)v); 1160} 1161 1162bool 1163operator == (const sc_uint_base &u, const sc_signed &v) 1164{ 1165 return operator == ((uint64)u, v); 1166} 1167 1168 1169bool 1170operator != (const sc_signed &u, const sc_uint_base &v) 1171{ 1172 return operator != (u, (uint64)v); 1173} 1174 1175bool 1176operator != (const sc_uint_base &u, const sc_signed &v) 1177{ 1178 return operator != ((uint64)u, v); 1179} 1180 1181 1182bool 1183operator < (const sc_signed &u, const sc_uint_base &v) 1184{ 1185 return operator < (u, (uint64)v); 1186} 1187 1188bool 1189operator < (const sc_uint_base &u, const sc_signed &v) 1190{ 1191 return operator < ((uint64)u, v); 1192} 1193 1194 1195bool 1196operator <= (const sc_signed &u, const sc_uint_base &v) 1197{ 1198 return operator <= (u, (uint64)v); 1199} 1200 1201bool 1202operator <= (const sc_uint_base &u, const sc_signed &v) 1203{ 1204 return operator <= ((uint64)u, v); 1205} 1206 1207 1208bool 1209operator > (const sc_signed &u, const sc_uint_base &v) 1210{ 1211 return operator > (u, (uint64)v); 1212} 1213 1214bool 1215operator > (const sc_uint_base &u, const sc_signed &v) 1216{ 1217 return operator > ((uint64)u, v); 1218} 1219 1220 1221bool 1222operator >= (const sc_signed &u, const sc_uint_base &v) 1223{ 1224 return operator >= (u, (uint64)v); 1225} 1226 1227bool 1228operator >= (const sc_uint_base &u, const sc_signed &v) 1229{ 1230 return operator >= ((uint64)u, v); 1231} 1232 1233 1234// ---------------------------------------------------------------------------- 1235// SECTION: Input and output operators 1236// ---------------------------------------------------------------------------- 1237 1238// Operators in this section are included from sc_nbcommon.cpp. 1239 1240 1241// ---------------------------------------------------------------------------- 1242// SECTION: Operator macros. 1243// ---------------------------------------------------------------------------- 1244 1245#define CONVERT_LONG(u) \ 1246small_type u ## s = get_sign(u); \ 1247sc_digit u ## d[DIGITS_PER_ULONG]; \ 1248from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u); 1249 1250#define CONVERT_LONG_2(u) \ 1251sc_digit u ## d[DIGITS_PER_ULONG]; \ 1252from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u); 1253 1254#define CONVERT_INT(u) \ 1255small_type u ## s = get_sign(u); \ 1256sc_digit u ## d[DIGITS_PER_UINT]; \ 1257from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u); 1258 1259#define CONVERT_INT_2(u) \ 1260sc_digit u ## d[DIGITS_PER_UINT]; \ 1261from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u); 1262 1263#define CONVERT_INT64(u) \ 1264small_type u ## s = get_sign(u); \ 1265sc_digit u ## d[DIGITS_PER_UINT64]; \ 1266from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u); 1267 1268#define CONVERT_INT64_2(u) \ 1269sc_digit u ## d[DIGITS_PER_UINT64]; \ 1270from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u); 1271 1272 1273// ---------------------------------------------------------------------------- 1274// SECTION: PLUS operators: +, +=, ++ 1275// ---------------------------------------------------------------------------- 1276 1277// Cases to consider when computing u + v: 1278// 1. 0 + v = v 1279// 2. u + 0 = u 1280// 3. if sgn(u) == sgn(v) 1281// 3.1 u + v = +(u + v) = sgn(u) * (u + v) 1282// 3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v) 1283// 4. if sgn(u) != sgn(v) 1284// 4.1 u + (-v) = u - v = sgn(u) * (u - v) 1285// 4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v) 1286// 1287// Specialization of above cases for computing ++u or u++: 1288// 1. 0 + 1 = 1 1289// 3. u + 1 = u + 1 = sgn(u) * (u + 1) 1290// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1) 1291 1292sc_signed 1293operator + (const sc_unsigned &u, const sc_signed &v) 1294{ 1295 if (u.sgn == SC_ZERO) // case 1 1296 return sc_signed(v); 1297 1298 if (v.sgn == SC_ZERO) // case 2 1299 return sc_signed(u); 1300 1301 // cases 3 and 4 1302 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1303 v.sgn, v.nbits, v.ndigits, v.digit); 1304} 1305 1306 1307sc_signed 1308operator + (const sc_signed &u, const sc_unsigned &v) 1309{ 1310 if (u.sgn == SC_ZERO) // case 1 1311 return sc_signed(v); 1312 1313 if (v.sgn == SC_ZERO) // case 2 1314 return sc_signed(u); 1315 1316 // cases 3 and 4 1317 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1318 v.sgn, v.nbits, v.ndigits, v.digit); 1319} 1320 1321 1322sc_signed 1323operator + (const sc_signed &u, const sc_signed &v) 1324{ 1325 if (u.sgn == SC_ZERO) // case 1 1326 return sc_signed(v); 1327 1328 if (v.sgn == SC_ZERO) // case 2 1329 return sc_signed(u); 1330 1331 // cases 3 and 4 1332 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1333 v.sgn, v.nbits, v.ndigits, v.digit); 1334} 1335 1336 1337sc_signed 1338operator + (const sc_signed &u, int64 v) 1339{ 1340 if (v == 0) // case 2 1341 return sc_signed(u); 1342 1343 CONVERT_INT64(v); 1344 1345 if (u.sgn == SC_ZERO) // case 1 1346 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1347 1348 // cases 3 and 4 1349 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1350 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1351} 1352 1353 1354sc_signed 1355operator + (int64 u, const sc_signed &v) 1356{ 1357 if (u == 0) // case 1 1358 return sc_signed(v); 1359 1360 CONVERT_INT64(u); 1361 1362 if (v.sgn == SC_ZERO) // case 2 1363 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1364 1365 // cases 3 and 4 1366 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1367 v.sgn, v.nbits, v.ndigits, v.digit); 1368} 1369 1370 1371sc_signed 1372operator + (const sc_unsigned &u, int64 v) 1373{ 1374 if (v == 0) // case 2 1375 return sc_signed(u); 1376 1377 CONVERT_INT64(v); 1378 1379 if (u.sgn == SC_ZERO) // case 1 1380 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1381 1382 // cases 3 and 4 1383 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1384 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1385} 1386 1387 1388sc_signed 1389operator + (int64 u, const sc_unsigned &v) 1390{ 1391 if (u == 0) // case 1 1392 return sc_signed(v); 1393 1394 CONVERT_INT64(u); 1395 1396 if (v.sgn == SC_ZERO) // case 2 1397 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1398 1399 // cases 3 and 4 1400 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1401 v.sgn, v.nbits, v.ndigits, v.digit); 1402} 1403 1404 1405sc_signed 1406operator + (const sc_signed &u, uint64 v) 1407{ 1408 if (v == 0) // case 2 1409 return sc_signed(u); 1410 1411 CONVERT_INT64(v); 1412 1413 if (u.sgn == SC_ZERO) // case 1 1414 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1415 1416 // cases 3 and 4 1417 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1418 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1419} 1420 1421 1422sc_signed 1423operator + (uint64 u, const sc_signed &v) 1424{ 1425 if (u == 0) // case 1 1426 return sc_signed(v); 1427 1428 CONVERT_INT64(u); 1429 1430 if (v.sgn == SC_ZERO) // case 2 1431 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1432 1433 // cases 3 and 4 1434 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1435 v.sgn, v.nbits, v.ndigits, v.digit); 1436} 1437 1438 1439sc_signed 1440operator + (const sc_signed &u, long v) 1441{ 1442 if (v == 0) // case 2 1443 return sc_signed(u); 1444 1445 CONVERT_LONG(v); 1446 1447 if (u.sgn == SC_ZERO) // case 1 1448 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1449 1450 // cases 3 and 4 1451 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1452 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1453} 1454 1455 1456sc_signed 1457operator + (long u, const sc_signed &v) 1458{ 1459 if (u == 0) // case 1 1460 return sc_signed(v); 1461 1462 CONVERT_LONG(u); 1463 1464 if (v.sgn == SC_ZERO) // case 2 1465 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1466 1467 // cases 3 and 4 1468 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1469 v.sgn, v.nbits, v.ndigits, v.digit); 1470} 1471 1472 1473sc_signed 1474operator + (const sc_unsigned &u, long v) 1475{ 1476 if (v == 0) // case 2 1477 return sc_signed(u); 1478 1479 CONVERT_LONG(v); 1480 1481 if (u.sgn == SC_ZERO) // case 1 1482 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1483 1484 // cases 3 and 4 1485 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1486 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1487} 1488 1489 1490sc_signed 1491operator + (long u, const sc_unsigned &v) 1492{ 1493 if (u == 0) // case 1 1494 return sc_signed(v); 1495 1496 CONVERT_LONG(u); 1497 1498 if (v.sgn == SC_ZERO) // case 2 1499 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1500 1501 // cases 3 and 4 1502 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1503 v.sgn, v.nbits, v.ndigits, v.digit); 1504} 1505 1506 1507sc_signed 1508operator + (const sc_signed &u, unsigned long v) 1509{ 1510 if (v == 0) // case 2 1511 return sc_signed(u); 1512 1513 CONVERT_LONG(v); 1514 1515 if (u.sgn == SC_ZERO) // case 1 1516 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1517 1518 // cases 3 and 4 1519 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1520 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1521} 1522 1523 1524sc_signed 1525operator + (unsigned long u, const sc_signed &v) 1526{ 1527 if (u == 0) // case 1 1528 return sc_signed(v); 1529 1530 CONVERT_LONG(u); 1531 1532 if (v.sgn == SC_ZERO) // case 2 1533 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1534 1535 // cases 3 and 4 1536 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1537 v.sgn, v.nbits, v.ndigits, v.digit); 1538} 1539 1540// The rest of the operators in this section are included from 1541// sc_nbcommon.cpp. 1542 1543// ---------------------------------------------------------------------------- 1544// SECTION: MINUS operators: -, -=, -- 1545// ---------------------------------------------------------------------------- 1546 1547// Cases to consider when computing u + v: 1548// 1. u - 0 = u 1549// 2. 0 - v = -v 1550// 3. if sgn(u) != sgn(v) 1551// 3.1 u - (-v) = u + v = sgn(u) * (u + v) 1552// 3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v) 1553// 4. if sgn(u) == sgn(v) 1554// 4.1 u - v = +(u - v) = sgn(u) * (u - v) 1555// 4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v) 1556// 1557// Specialization of above cases for computing --u or u--: 1558// 1. 0 - 1 = -1 1559// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1) 1560// 4. u - 1 = u - 1 = sgn(u) * (u - 1) 1561 1562sc_signed 1563operator - (const sc_unsigned &u, const sc_unsigned &v) 1564{ 1565 if (v.sgn == SC_ZERO) // case 1 1566 return sc_signed(u); 1567 1568 if (u.sgn == SC_ZERO) // case 2 1569 return sc_signed(v, -v.sgn); 1570 1571 // cases 3 and 4 1572 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1573 -v.sgn, v.nbits, v.ndigits, v.digit); 1574} 1575 1576 1577sc_signed 1578operator - (const sc_unsigned &u, const sc_signed &v) 1579{ 1580 if (v.sgn == SC_ZERO) // case 1 1581 return sc_signed(u); 1582 1583 if (u.sgn == SC_ZERO) // case 2 1584 return sc_signed(v, -v.sgn); 1585 1586 // cases 3 and 4 1587 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1588 -v.sgn, v.nbits, v.ndigits, v.digit); 1589} 1590 1591 1592sc_signed 1593operator - (const sc_signed &u, const sc_unsigned &v) 1594{ 1595 if (v.sgn == SC_ZERO) // case 1 1596 return sc_signed(u); 1597 1598 if (u.sgn == SC_ZERO) // case 2 1599 return sc_signed(v, -v.sgn); 1600 1601 // cases 3 and 4 1602 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1603 -v.sgn, v.nbits, v.ndigits, v.digit); 1604} 1605 1606 1607sc_signed 1608operator - (const sc_signed &u, const sc_signed &v) 1609{ 1610 if (v.sgn == SC_ZERO) // case 1 1611 return sc_signed(u); 1612 1613 if (u.sgn == SC_ZERO) // case 2 1614 return sc_signed(v, -v.sgn); 1615 1616 // cases 3 and 4 1617 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1618 -v.sgn, v.nbits, v.ndigits, v.digit); 1619} 1620 1621 1622sc_signed 1623operator - (const sc_signed &u, int64 v) 1624{ 1625 if (v == 0) // case 1 1626 return sc_signed(u); 1627 1628 CONVERT_INT64(v); 1629 1630 if (u.sgn == SC_ZERO) // case 2 1631 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1632 1633 // cases 3 and 4 1634 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1635 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1636} 1637 1638 1639sc_signed 1640operator - (int64 u, const sc_signed &v) 1641{ 1642 if (u == 0) // case 1 1643 return sc_signed(v, -v.sgn); 1644 1645 CONVERT_INT64(u); 1646 1647 if (v.sgn == SC_ZERO) // case 2 1648 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1649 1650 // cases 3 and 4 1651 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1652 -v.sgn, v.nbits, v.ndigits, v.digit); 1653} 1654 1655 1656sc_signed 1657operator - (const sc_unsigned &u, int64 v) 1658{ 1659 if (v == 0) // case 1 1660 return sc_signed(u); 1661 1662 CONVERT_INT64(v); 1663 1664 if (u.sgn == SC_ZERO) // case 2 1665 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1666 1667 // cases 3 and 4 1668 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1669 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1670} 1671 1672 1673sc_signed 1674operator - (int64 u, const sc_unsigned &v) 1675{ 1676 if (u == 0) // case 1 1677 return sc_signed(v, -v.sgn); 1678 1679 CONVERT_INT64(u); 1680 1681 if (v.sgn == SC_ZERO) // case 2 1682 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1683 1684 // cases 3 and 4 1685 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1686 -v.sgn, v.nbits, v.ndigits, v.digit); 1687} 1688 1689 1690sc_signed 1691operator - (const sc_signed &u, uint64 v) 1692{ 1693 if (v == 0) // case 1 1694 return sc_signed(u); 1695 1696 CONVERT_INT64(v); 1697 1698 if (u.sgn == SC_ZERO) // case 2 1699 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1700 1701 // cases 3 and 4 1702 1703 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1704 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1705} 1706 1707 1708sc_signed 1709operator - (uint64 u, const sc_signed &v) 1710{ 1711 if (u == 0) // case 1 1712 return sc_signed(v, -v.sgn); 1713 1714 CONVERT_INT64(u); 1715 1716 if (v.sgn == SC_ZERO) // case 2 1717 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1718 1719 // cases 3 and 4 1720 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1721 -v.sgn, v.nbits, v.ndigits, v.digit); 1722} 1723 1724 1725sc_signed 1726operator - (const sc_unsigned &u, uint64 v) 1727{ 1728 if (v == 0) // case 1 1729 return sc_signed(u); 1730 1731 CONVERT_INT64(v); 1732 1733 if (u.sgn == SC_ZERO) // case 2 1734 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 1735 1736 // cases 3 and 4 1737 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1738 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1739} 1740 1741 1742sc_signed 1743operator - (uint64 u, const sc_unsigned &v) 1744{ 1745 if (u == 0) // case 1 1746 return sc_signed(v, -v.sgn); 1747 1748 CONVERT_INT64(u); 1749 1750 if (v.sgn == SC_ZERO) // case 2 1751 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 1752 1753 // cases 3 and 4 1754 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1755 -v.sgn, v.nbits, v.ndigits, v.digit); 1756} 1757 1758 1759sc_signed 1760operator - (const sc_signed &u, long v) 1761{ 1762 if (v == 0) // case 1 1763 return sc_signed(u); 1764 1765 CONVERT_LONG(v); 1766 1767 if (u.sgn == SC_ZERO) // case 2 1768 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1769 1770 // cases 3 and 4 1771 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1772 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1773} 1774 1775 1776sc_signed 1777operator - (long u, const sc_signed &v) 1778{ 1779 if (u == 0) // case 1 1780 return sc_signed(v, -v.sgn); 1781 1782 CONVERT_LONG(u); 1783 1784 if (v.sgn == SC_ZERO) // case 2 1785 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1786 1787 // cases 3 and 4 1788 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1789 -v.sgn, v.nbits, v.ndigits, v.digit); 1790} 1791 1792 1793sc_signed 1794operator - (const sc_unsigned &u, long v) 1795{ 1796 if (v == 0) // case 1 1797 return sc_signed(u); 1798 1799 CONVERT_LONG(v); 1800 1801 if (u.sgn == SC_ZERO) // case 2 1802 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1803 1804 // cases 3 and 4 1805 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1806 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1807} 1808 1809 1810sc_signed 1811operator - (long u, const sc_unsigned &v) 1812{ 1813 if (u == 0) // case 1 1814 return sc_signed(v, -v.sgn); 1815 1816 CONVERT_LONG(u); 1817 1818 if (v.sgn == SC_ZERO) // case 2 1819 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1820 1821 // cases 3 and 4 1822 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1823 -v.sgn, v.nbits, v.ndigits, v.digit); 1824} 1825 1826 1827sc_signed 1828operator - (const sc_signed &u, unsigned long v) 1829{ 1830 if (v == 0) // case 1 1831 return sc_signed(u); 1832 1833 CONVERT_LONG(v); 1834 1835 if (u.sgn == SC_ZERO) // case 2 1836 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1837 1838 // cases 3 and 4 1839 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1840 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1841} 1842 1843 1844sc_signed 1845operator - (unsigned long u, const sc_signed &v) 1846{ 1847 if (u == 0) // case 1 1848 return sc_signed(v, -v.sgn); 1849 1850 CONVERT_LONG(u); 1851 1852 if (v.sgn == SC_ZERO) // case 2 1853 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1854 1855 // cases 3 and 4 1856 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1857 -v.sgn, v.nbits, v.ndigits, v.digit); 1858} 1859 1860 1861sc_signed 1862operator - (const sc_unsigned &u, unsigned long v) 1863{ 1864 if (v == 0) // case 1 1865 return sc_signed(u); 1866 1867 CONVERT_LONG(v); 1868 1869 if (u.sgn == SC_ZERO) // case 2 1870 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 1871 1872 // cases 3 and 4 1873 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 1874 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 1875} 1876 1877 1878sc_signed 1879operator - (unsigned long u, const sc_unsigned &v) 1880{ 1881 if (u == 0) // case 1 1882 return sc_signed(v, -v.sgn); 1883 1884 CONVERT_LONG(u); 1885 1886 if (v.sgn == SC_ZERO) // case 2 1887 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 1888 1889 // cases 3 and 4 1890 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 1891 -v.sgn, v.nbits, v.ndigits, v.digit); 1892} 1893 1894// The rest of the operators in this section are included from 1895// sc_nbcommon.cpp. 1896 1897 1898// ---------------------------------------------------------------------------- 1899// SECTION: MULTIPLICATION operators: *, *= 1900// ---------------------------------------------------------------------------- 1901 1902// Cases to consider when computing u * v: 1903// 1. u * 0 = 0 * v = 0 1904// 2. 1 * v = v and -1 * v = -v 1905// 3. u * 1 = u and u * -1 = -u 1906// 4. u * v = u * v 1907 1908sc_signed 1909operator * (const sc_unsigned &u, const sc_signed &v) 1910{ 1911 small_type s = mul_signs(u.sgn, v.sgn); 1912 1913 if (s == SC_ZERO) // case 1 1914 return sc_signed(); 1915 1916 // cases 2-4 1917 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 1918 v.nbits, v.ndigits, v.digit); 1919} 1920 1921 1922sc_signed 1923operator * (const sc_signed &u, const sc_unsigned &v) 1924{ 1925 small_type s = mul_signs(u.sgn, v.sgn); 1926 1927 if (s == SC_ZERO) // case 1 1928 return sc_signed(); 1929 1930 // cases 2-4 1931 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 1932 v.nbits, v.ndigits, v.digit); 1933} 1934 1935 1936sc_signed 1937operator * (const sc_signed &u, const sc_signed &v) 1938{ 1939 small_type s = mul_signs(u.sgn, v.sgn); 1940 1941 if (s == SC_ZERO) // case 1 1942 return sc_signed(); 1943 1944 // cases 2-4 1945 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 1946 v.nbits, v.ndigits, v.digit); 1947} 1948 1949 1950sc_signed 1951operator * (const sc_signed &u, int64 v) 1952{ 1953 small_type s = mul_signs(u.sgn, get_sign(v)); 1954 1955 if (s == SC_ZERO) // case 1 1956 return sc_signed(); 1957 1958 CONVERT_INT64_2(v); 1959 1960 // cases 2-4 1961 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 1962 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1963} 1964 1965 1966sc_signed 1967operator * (int64 u, const sc_signed &v) 1968{ 1969 small_type s = mul_signs(v.sgn, get_sign(u)); 1970 1971 if (s == SC_ZERO) // case 1 1972 return sc_signed(); 1973 1974 CONVERT_INT64_2(u); 1975 1976 // cases 2-4 1977 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 1978 v.nbits, v.ndigits, v.digit); 1979} 1980 1981 1982sc_signed 1983operator * (const sc_unsigned &u, int64 v) 1984{ 1985 small_type s = mul_signs(u.sgn, get_sign(v)); 1986 1987 if (s == SC_ZERO) // case 1 1988 return sc_signed(); 1989 1990 CONVERT_INT64_2(v); 1991 1992 // cases 2-4 1993 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 1994 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 1995} 1996 1997 1998sc_signed 1999operator * (int64 u, const sc_unsigned &v) 2000{ 2001 small_type s = mul_signs(v.sgn, get_sign(u)); 2002 2003 if (s == SC_ZERO) // case 1 2004 return sc_signed(); 2005 2006 CONVERT_INT64_2(u); 2007 2008 // cases 2-4 2009 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2010 v.nbits, v.ndigits, v.digit); 2011} 2012 2013 2014sc_signed 2015operator * (const sc_signed &u, uint64 v) 2016{ 2017 small_type s = mul_signs(u.sgn, get_sign(v)); 2018 2019 if (s == SC_ZERO) // case 1 2020 return sc_signed(); 2021 2022 CONVERT_INT64_2(v); 2023 2024 // cases 2-4 2025 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 2026 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2027} 2028 2029 2030sc_signed 2031operator * (uint64 u, const sc_signed &v) 2032{ 2033 small_type s = mul_signs(v.sgn, get_sign(u)); 2034 2035 if (s == SC_ZERO) // case 1 2036 return sc_signed(); 2037 2038 CONVERT_INT64_2(u); 2039 2040 // cases 2-4 2041 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2042 v.nbits, v.ndigits, v.digit); 2043} 2044 2045 2046sc_signed 2047operator * (const sc_signed &u, long v) 2048{ 2049 small_type s = mul_signs(u.sgn, get_sign(v)); 2050 2051 if (s == SC_ZERO) // case 1 2052 return sc_signed(); 2053 2054 CONVERT_LONG_2(v); 2055 2056 // cases 2-4 2057 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 2058 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2059} 2060 2061 2062sc_signed 2063operator * (long u, const sc_signed &v) 2064{ 2065 small_type s = mul_signs(v.sgn, get_sign(u)); 2066 2067 if (s == SC_ZERO) // case 1 2068 return sc_signed(); 2069 2070 CONVERT_LONG_2(u); 2071 2072 // cases 2-4 2073 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2074 v.nbits, v.ndigits, v.digit); 2075} 2076 2077 2078sc_signed 2079operator * (const sc_unsigned &u, long v) 2080{ 2081 small_type s = mul_signs(u.sgn, get_sign(v)); 2082 2083 if (s == SC_ZERO) // case 1 2084 return sc_signed(); 2085 2086 CONVERT_LONG_2(v); 2087 2088 // cases 2-4 2089 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 2090 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2091} 2092 2093 2094sc_signed 2095operator * (long u, const sc_unsigned &v) 2096{ 2097 small_type s = mul_signs(v.sgn, get_sign(u)); 2098 2099 if (s == SC_ZERO) // case 1 2100 return sc_signed(); 2101 2102 CONVERT_LONG_2(u); 2103 2104 // cases 2-4 2105 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2106 v.nbits, v.ndigits, v.digit); 2107} 2108 2109 2110sc_signed 2111operator * (const sc_signed &u, unsigned long v) 2112{ 2113 small_type s = mul_signs(u.sgn, get_sign(v)); 2114 2115 if (s == SC_ZERO) // case 1 2116 return sc_signed(); 2117 2118 CONVERT_LONG_2(v); 2119 2120 // else cases 2-4 2121 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 2122 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2123} 2124 2125sc_signed 2126operator * (unsigned long u, const sc_signed &v) 2127{ 2128 small_type s = mul_signs(v.sgn, get_sign(u)); 2129 2130 if (s == SC_ZERO) // case 1 2131 return sc_signed(); 2132 2133 CONVERT_LONG_2(u); 2134 2135 // cases 2-4 2136 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2137 v.nbits, v.ndigits, v.digit); 2138} 2139 2140// The rest of the operators in this section are included from 2141// sc_nbcommon.cpp. 2142 2143 2144// ---------------------------------------------------------------------------- 2145// SECTION: DIVISION operators: /, /= 2146// ---------------------------------------------------------------------------- 2147 2148// Cases to consider when finding the quotient q = floor(u/v): 2149// Note that u = q * v + r for r < q. 2150// 1. 0 / 0 or u / 0 => error 2151// 2. 0 / v => 0 = 0 * v + 0 2152// 3. u / v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1 2153// 4. u / v & &u < v => u = 0 * v + u - u can be 1 or -1 2154// 5. u / v & &u > v => u = q * v + r - v can be 1 or -1 2155 2156sc_signed 2157operator / (const sc_unsigned &u, const sc_signed &v) 2158{ 2159 small_type s = mul_signs(u.sgn, v.sgn); 2160 2161 if (s == SC_ZERO) { 2162 div_by_zero(v.sgn); // case 1 2163 return sc_signed(); // case 2 2164 } 2165 2166 // other cases 2167 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2168 v.nbits, v.ndigits, v.digit); 2169} 2170 2171 2172sc_signed 2173operator / (const sc_signed &u, const sc_unsigned &v) 2174{ 2175 small_type s = mul_signs(u.sgn, v.sgn); 2176 2177 if (s == SC_ZERO) { 2178 div_by_zero(v.sgn); // case 1 2179 return sc_signed(); // case 2 2180 } 2181 2182 // other cases 2183 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2184 v.nbits, v.ndigits, v.digit); 2185} 2186 2187 2188sc_signed 2189operator / (const sc_signed &u, const sc_signed &v) 2190{ 2191 small_type s = mul_signs(u.sgn, v.sgn); 2192 2193 if (s == SC_ZERO) { 2194 div_by_zero(v.sgn); // case 1 2195 return sc_signed(); // case 2 2196 } 2197 2198 // other cases 2199 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2200 v.nbits, v.ndigits, v.digit); 2201} 2202 2203 2204sc_signed 2205operator / (const sc_signed &u, int64 v) 2206{ 2207 small_type s = mul_signs(u.sgn, get_sign(v)); 2208 2209 if (s == SC_ZERO) { 2210 div_by_zero(v); // case 1 2211 return sc_signed(); // case 2 2212 } 2213 2214 CONVERT_INT64_2(v); 2215 2216 // other cases 2217 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2218 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2219} 2220 2221 2222sc_signed 2223operator / (int64 u, const sc_signed &v) 2224{ 2225 small_type s = mul_signs(v.sgn, get_sign(u)); 2226 2227 if (s == SC_ZERO) { 2228 div_by_zero(v.sgn); // case 1 2229 return sc_signed(); // case 2 2230 } 2231 2232 CONVERT_INT64_2(u); 2233 2234 // other cases 2235 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2236 v.nbits, v.ndigits, v.digit); 2237} 2238 2239 2240sc_signed 2241operator / (const sc_unsigned &u, int64 v) 2242{ 2243 small_type s = mul_signs(u.sgn, get_sign(v)); 2244 2245 if (s == SC_ZERO) { 2246 div_by_zero(v); // case 1 2247 return sc_signed(); // case 2 2248 } 2249 2250 CONVERT_INT64_2(v); 2251 2252 // other cases 2253 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2254 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2255} 2256 2257 2258sc_signed 2259operator / (int64 u, const sc_unsigned &v) 2260{ 2261 small_type s = mul_signs(v.sgn, get_sign(u)); 2262 2263 if (s == SC_ZERO) { 2264 div_by_zero(v.sgn); // case 1 2265 return sc_signed(); // case 2 2266 } 2267 2268 CONVERT_INT64_2(u); 2269 2270 // other cases 2271 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2272 v.nbits, v.ndigits, v.digit); 2273} 2274 2275 2276sc_signed 2277operator / (const sc_signed &u, uint64 v) 2278{ 2279 small_type s = mul_signs(u.sgn, get_sign(v)); 2280 2281 if (s == SC_ZERO) { 2282 div_by_zero(v); // case 1 2283 return sc_signed(); // case 2 2284 } 2285 2286 CONVERT_INT64_2(v); 2287 2288 // other cases 2289 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2290 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2291} 2292 2293 2294sc_signed 2295operator / (uint64 u, const sc_signed &v) 2296{ 2297 small_type s = mul_signs(v.sgn, get_sign(u)); 2298 2299 if (s == SC_ZERO) { 2300 div_by_zero(v.sgn); // case 1 2301 return sc_signed(); // case 2 2302 2303 } 2304 2305 CONVERT_INT64_2(u); 2306 2307 // other cases 2308 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2309 v.nbits, v.ndigits, v.digit); 2310} 2311 2312 2313sc_signed 2314operator / (const sc_signed &u, long v) 2315{ 2316 small_type s = mul_signs(u.sgn, get_sign(v)); 2317 2318 if (s == SC_ZERO) { 2319 div_by_zero(v); // case 1 2320 return sc_signed(); // case 2 2321 } 2322 2323 CONVERT_LONG_2(v); 2324 2325 // other cases 2326 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2327 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2328} 2329 2330 2331sc_signed 2332operator / (long u, const sc_signed &v) 2333{ 2334 small_type s = mul_signs(v.sgn, get_sign(u)); 2335 2336 if (s == SC_ZERO) { 2337 div_by_zero(v.sgn); // case 1 2338 return sc_signed(); // case 2 2339 } 2340 2341 CONVERT_LONG_2(u); 2342 2343 // other cases 2344 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2345 v.nbits, v.ndigits, v.digit); 2346} 2347 2348 2349sc_signed 2350operator / (const sc_unsigned &u, long v) 2351{ 2352 small_type s = mul_signs(u.sgn, get_sign(v)); 2353 2354 if (s == SC_ZERO) { 2355 div_by_zero(v); // case 1 2356 return sc_signed(); // case 2 2357 } 2358 2359 CONVERT_LONG_2(v); 2360 2361 // other cases 2362 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2363 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2364} 2365 2366 2367sc_signed 2368operator / (long u, const sc_unsigned &v) 2369{ 2370 small_type s = mul_signs(v.sgn, get_sign(u)); 2371 2372 if (s == SC_ZERO) { 2373 div_by_zero(v.sgn); // case 1 2374 return sc_signed(); // case 2 2375 } 2376 2377 CONVERT_LONG_2(u); 2378 2379 // other cases 2380 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2381 v.nbits, v.ndigits, v.digit); 2382} 2383 2384 2385sc_signed 2386operator / (const sc_signed &u, unsigned long v) 2387{ 2388 small_type s = mul_signs(u.sgn, get_sign(v)); 2389 2390 if (s == SC_ZERO) { 2391 div_by_zero(v); // case 1 2392 return sc_signed(); // case 2 2393 } 2394 2395 CONVERT_LONG_2(v); 2396 2397 // other cases 2398 return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 2399 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2400} 2401 2402 2403sc_signed 2404operator / (unsigned long u, const sc_signed &v) 2405{ 2406 small_type s = mul_signs(v.sgn, get_sign(u)); 2407 2408 if (s == SC_ZERO) { 2409 div_by_zero(v.sgn); // case 1 2410 return sc_signed(); // case 2 2411 2412 } 2413 2414 CONVERT_LONG_2(u); 2415 2416 // other cases 2417 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2418 v.nbits, v.ndigits, v.digit); 2419} 2420 2421// The rest of the operators in this section are included from 2422// sc_nbcommon.cpp. 2423 2424 2425// ---------------------------------------------------------------------------- 2426// SECTION: MOD operators: %, %=. 2427// ---------------------------------------------------------------------------- 2428 2429// Cases to consider when finding the remainder r = u % v: 2430// Note that u = q * v + r for r < q. 2431// 1. 0 % 0 or u % 0 => error 2432// 2. 0 % v => 0 = 0 * v + 0 2433// 3. u % v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1 2434// 4. u % v & &u < v => u = 0 * v + u - u can be 1 or -1 2435// 5. u % v & &u > v => u = q * v + r - v can be 1 or -1 2436 2437sc_signed 2438operator % (const sc_unsigned &u, const sc_signed &v) 2439{ 2440 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { 2441 div_by_zero(v.sgn); // case 1 2442 return sc_signed(); // case 2 2443 } 2444 2445 // other cases 2446 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2447 v.nbits, v.ndigits, v.digit); 2448} 2449 2450 2451sc_signed 2452operator % (const sc_signed &u, const sc_unsigned &v) 2453{ 2454 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { 2455 div_by_zero(v.sgn); // case 1 2456 return sc_signed(); // case 2 2457 } 2458 2459 // other cases 2460 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2461 v.nbits, v.ndigits, v.digit); 2462} 2463 2464 2465sc_signed 2466operator % (const sc_signed &u, const sc_signed &v) 2467{ 2468 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { 2469 div_by_zero(v.sgn); // case 1 2470 return sc_signed(); // case 2 2471 } 2472 2473 // other cases 2474 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2475 v.nbits, v.ndigits, v.digit); 2476} 2477 2478 2479sc_signed 2480operator % (const sc_signed &u, int64 v) 2481{ 2482 small_type vs = get_sign(v); 2483 2484 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) { 2485 div_by_zero(v); // case 1 2486 return sc_signed(); // case 2 2487 } 2488 2489 CONVERT_INT64_2(v); 2490 2491 // other cases 2492 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2493 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2494} 2495 2496 2497sc_signed 2498operator % (int64 u, const sc_signed &v) 2499{ 2500 small_type us = get_sign(u); 2501 2502 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) { 2503 div_by_zero(v.sgn); // case 1 2504 return sc_signed(); // case 2 2505 } 2506 2507 CONVERT_INT64_2(u); 2508 2509 // other cases 2510 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2511 v.nbits, v.ndigits, v.digit); 2512} 2513 2514 2515sc_signed 2516operator % (const sc_unsigned &u, int64 v) 2517{ 2518 small_type vs = get_sign(v); 2519 2520 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) { 2521 div_by_zero(v); // case 1 2522 return sc_signed(); // case 2 2523 } 2524 2525 CONVERT_INT64_2(v); 2526 2527 // other cases 2528 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2529 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2530} 2531 2532 2533sc_signed 2534operator % (int64 u, const sc_unsigned &v) 2535{ 2536 small_type us = get_sign(u); 2537 2538 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) { 2539 div_by_zero(v.sgn); // case 1 2540 return sc_signed(); // case 2 2541 } 2542 2543 CONVERT_INT64_2(u); 2544 2545 // other cases 2546 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2547 v.nbits, v.ndigits, v.digit); 2548} 2549 2550 2551sc_signed 2552operator % (const sc_signed &u, uint64 v) 2553{ 2554 if ((u.sgn == SC_ZERO) || (v == 0)) { 2555 div_by_zero(v); // case 1 2556 return sc_signed(); // case 2 2557 } 2558 2559 CONVERT_INT64_2(v); 2560 2561 // other cases 2562 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2563 BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2564} 2565 2566 2567sc_signed 2568operator % (uint64 u, const sc_signed &v) 2569{ 2570 if ((u == 0) || (v.sgn == SC_ZERO)) { 2571 div_by_zero(v.sgn); // case 1 2572 return sc_signed(); // case 2 2573 } 2574 2575 CONVERT_INT64(u); 2576 2577 // other cases 2578 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2579 v.nbits, v.ndigits, v.digit); 2580} 2581 2582 2583sc_signed 2584operator % (const sc_signed &u, long v) 2585{ 2586 small_type vs = get_sign(v); 2587 2588 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) { 2589 div_by_zero(v); // case 1 2590 return sc_signed(); // case 2 2591 } 2592 2593 CONVERT_LONG_2(v); 2594 2595 // other cases 2596 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2597 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2598} 2599 2600 2601sc_signed 2602operator % (long u, const sc_signed &v) 2603{ 2604 small_type us = get_sign(u); 2605 2606 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) { 2607 div_by_zero(v.sgn); // case 1 2608 return sc_signed(); // case 2 2609 } 2610 2611 CONVERT_LONG_2(u); 2612 2613 // other cases 2614 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2615 v.nbits, v.ndigits, v.digit); 2616} 2617 2618 2619sc_signed 2620operator % (const sc_unsigned &u, long v) 2621{ 2622 2623 small_type vs = get_sign(v); 2624 2625 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) { 2626 div_by_zero(v); // case 1 2627 return sc_signed(); // case 2 2628 } 2629 2630 CONVERT_LONG_2(v); 2631 2632 // other cases 2633 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2634 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2635} 2636 2637 2638sc_signed 2639operator % (long u, const sc_unsigned &v) 2640{ 2641 small_type us = get_sign(u); 2642 2643 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) { 2644 div_by_zero(v.sgn); // case 1 2645 return sc_signed(); // case 2 2646 } 2647 2648 CONVERT_LONG_2(u); 2649 2650 // other cases 2651 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2652 v.nbits, v.ndigits, v.digit); 2653} 2654 2655 2656sc_signed 2657operator % (const sc_signed &u, unsigned long v) 2658{ 2659 if ((u.sgn == SC_ZERO) || (v == 0)) { 2660 div_by_zero(v); // case 1 2661 return sc_signed(); // case 2 2662 } 2663 2664 CONVERT_LONG_2(v); 2665 2666 // other cases 2667 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2668 BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2669} 2670 2671 2672sc_signed 2673operator % (unsigned long u, const sc_signed &v) 2674{ 2675 if ((u == 0) || (v.sgn == SC_ZERO)) { 2676 div_by_zero(v.sgn); // case 1 2677 return sc_signed(); // case 2 2678 } 2679 2680 CONVERT_LONG(u); 2681 2682 // other cases 2683 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2684 v.nbits, v.ndigits, v.digit); 2685} 2686 2687// The rest of the operators in this section are included from 2688// sc_nbcommon.cpp. 2689 2690 2691// ---------------------------------------------------------------------------- 2692// SECTION: Bitwise AND operators: &, &= 2693// ---------------------------------------------------------------------------- 2694 2695// Cases to consider when computing u &v: 2696// 1. u & 0 = 0 &v = 0 2697// 2. u &v => sgn = + 2698// 3. (-u) & (-v) => sgn = - 2699// 4. u & (-v) => sgn = + 2700// 5. (-u) &v => sgn = + 2701 2702sc_signed 2703operator & (const sc_unsigned &u, const sc_signed &v) 2704{ 2705 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1 2706 return sc_signed(); 2707 2708 // other cases 2709 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2710 v.sgn, v.nbits, v.ndigits, v.digit); 2711} 2712 2713 2714sc_signed 2715operator & (const sc_signed &u, const sc_unsigned &v) 2716{ 2717 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1 2718 return sc_signed(); 2719 2720 // other cases 2721 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2722 v.sgn, v.nbits, v.ndigits, v.digit); 2723} 2724 2725 2726sc_signed 2727operator & (const sc_signed &u, const sc_signed &v) 2728{ 2729 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1 2730 return sc_signed(); 2731 2732 // other cases 2733 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2734 v.sgn, v.nbits, v.ndigits, v.digit); 2735} 2736 2737 2738sc_signed 2739operator & (const sc_signed &u, int64 v) 2740{ 2741 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2742 return sc_signed(); 2743 2744 CONVERT_INT64(v); 2745 2746 // other cases 2747 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2748 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2749} 2750 2751 2752sc_signed 2753operator & (int64 u, const sc_signed &v) 2754{ 2755 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2756 return sc_signed(); 2757 2758 CONVERT_INT64(u); 2759 2760 // other cases 2761 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2762 v.sgn, v.nbits, v.ndigits, v.digit); 2763} 2764 2765 2766sc_signed 2767operator & (const sc_unsigned &u, int64 v) 2768{ 2769 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2770 return sc_signed(); 2771 2772 CONVERT_INT64(v); 2773 2774 // other cases 2775 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2776 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2777} 2778 2779 2780sc_signed 2781operator & (int64 u, const sc_unsigned &v) 2782{ 2783 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2784 return sc_signed(); 2785 2786 CONVERT_INT64(u); 2787 2788 // other cases 2789 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2790 v.sgn, v.nbits, v.ndigits, v.digit); 2791} 2792 2793 2794sc_signed 2795operator & (const sc_signed &u, uint64 v) 2796{ 2797 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2798 return sc_signed(); 2799 2800 CONVERT_INT64(v); 2801 2802 // other cases 2803 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2804 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2805} 2806 2807 2808sc_signed 2809operator & (uint64 u, const sc_signed &v) 2810{ 2811 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2812 return sc_signed(); 2813 2814 CONVERT_INT64(u); 2815 2816 // other cases 2817 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2818 v.sgn, v.nbits, v.ndigits, v.digit); 2819} 2820 2821 2822sc_signed 2823operator & (const sc_signed &u, long v) 2824{ 2825 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2826 return sc_signed(); 2827 2828 CONVERT_LONG(v); 2829 2830 // other cases 2831 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2832 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2833} 2834 2835 2836sc_signed 2837operator & (long u, const sc_signed &v) 2838{ 2839 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2840 return sc_signed(); 2841 2842 CONVERT_LONG(u); 2843 2844 // other cases 2845 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2846 v.sgn, v.nbits, v.ndigits, v.digit); 2847} 2848 2849 2850sc_signed 2851operator & (const sc_unsigned &u, long v) 2852{ 2853 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2854 return sc_signed(); 2855 2856 CONVERT_LONG(v); 2857 2858 // other cases 2859 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2860 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2861} 2862 2863 2864sc_signed 2865operator & (long u, const sc_unsigned &v) 2866{ 2867 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2868 return sc_signed(); 2869 2870 CONVERT_LONG(u); 2871 2872 // other cases 2873 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2874 v.sgn, v.nbits, v.ndigits, v.digit); 2875} 2876 2877 2878sc_signed 2879operator & (const sc_signed &u, unsigned long v) 2880{ 2881 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1 2882 return sc_signed(); 2883 2884 CONVERT_LONG(v); 2885 2886 // other cases 2887 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2888 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 2889} 2890 2891 2892sc_signed 2893operator & (unsigned long u, const sc_signed &v) 2894{ 2895 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1 2896 return sc_signed(); 2897 2898 CONVERT_LONG(u); 2899 2900 // other cases 2901 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 2902 v.sgn, v.nbits, v.ndigits, v.digit); 2903} 2904 2905// The rest of the operators in this section are included from 2906// sc_nbcommon.cpp. 2907 2908 2909// ---------------------------------------------------------------------------- 2910// SECTION: Bitwise OR operators: |, |= 2911// ---------------------------------------------------------------------------- 2912 2913// Cases to consider when computing u | v: 2914// 1. u | 0 = u 2915// 2. 0 | v = v 2916// 3. u | v => sgn = + 2917// 4. (-u) | (-v) => sgn = - 2918// 5. u | (-v) => sgn = - 2919// 6. (-u) | v => sgn = - 2920 2921sc_signed 2922operator | (const sc_unsigned &u, const sc_signed &v) 2923{ 2924 if (v.sgn == SC_ZERO) // case 1 2925 return sc_signed(u); 2926 2927 if (u.sgn == SC_ZERO) // case 2 2928 return sc_signed(v); 2929 2930 // other cases 2931 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2932 v.sgn, v.nbits, v.ndigits, v.digit); 2933} 2934 2935 2936sc_signed 2937operator | (const sc_signed &u, const sc_unsigned &v) 2938{ 2939 if (v.sgn == SC_ZERO) // case 1 2940 return sc_signed(u); 2941 2942 if (u.sgn == SC_ZERO) // case 2 2943 return sc_signed(v); 2944 2945 // other cases 2946 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2947 v.sgn, v.nbits, v.ndigits, v.digit); 2948} 2949 2950 2951sc_signed 2952operator | (const sc_signed &u, const sc_signed &v) 2953{ 2954 if (v.sgn == SC_ZERO) // case 1 2955 return sc_signed(u); 2956 2957 if (u.sgn == SC_ZERO) // case 2 2958 return sc_signed(v); 2959 2960 // other cases 2961 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2962 v.sgn, v.nbits, v.ndigits, v.digit); 2963} 2964 2965 2966sc_signed 2967operator | (const sc_signed &u, int64 v) 2968{ 2969 if (v == 0) // case 1 2970 return sc_signed(u); 2971 2972 CONVERT_INT64(v); 2973 2974 if (u.sgn == SC_ZERO) // case 2 2975 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 2976 2977 // other cases 2978 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 2979 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 2980} 2981 2982 2983sc_signed 2984operator | (int64 u, const sc_signed &v) 2985{ 2986 if (u == 0) 2987 return sc_signed(v); 2988 2989 CONVERT_INT64(u); 2990 2991 if (v.sgn == SC_ZERO) 2992 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 2993 2994 // other cases 2995 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 2996 v.sgn, v.nbits, v.ndigits, v.digit); 2997} 2998 2999 3000sc_signed 3001operator | (const sc_unsigned &u, int64 v) 3002{ 3003 if (v == 0) // case 1 3004 return sc_signed(u); 3005 3006 CONVERT_INT64(v); 3007 3008 if (u.sgn == SC_ZERO) // case 2 3009 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 3010 3011 // other cases 3012 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3013 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 3014} 3015 3016 3017sc_signed 3018operator | (int64 u, const sc_unsigned &v) 3019{ 3020 if (u == 0) 3021 return sc_signed(v); 3022 3023 CONVERT_INT64(u); 3024 3025 if (v.sgn == SC_ZERO) 3026 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 3027 3028 // other cases 3029 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 3030 v.sgn, v.nbits, v.ndigits, v.digit); 3031} 3032 3033 3034sc_signed 3035operator | (const sc_signed &u, uint64 v) 3036{ 3037 if (v == 0) // case 1 3038 return sc_signed(u); 3039 3040 CONVERT_INT64(v); 3041 3042 if (u.sgn == SC_ZERO) // case 2 3043 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 3044 3045 // other cases 3046 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3047 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 3048} 3049 3050 3051sc_signed 3052operator | (uint64 u, const sc_signed &v) 3053{ 3054 if (u == 0) 3055 return sc_signed(v); 3056 3057 CONVERT_INT64(u); 3058 3059 if (v.sgn == SC_ZERO) 3060 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 3061 3062 // other cases 3063 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 3064 v.sgn, v.nbits, v.ndigits, v.digit); 3065} 3066 3067 3068sc_signed 3069operator | (const sc_signed &u, long v) 3070{ 3071 if (v == 0) // case 1 3072 return sc_signed(u); 3073 3074 CONVERT_LONG(v); 3075 3076 if (u.sgn == SC_ZERO) // case 2 3077 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3078 3079 // other cases 3080 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3081 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3082} 3083 3084 3085sc_signed 3086operator | (long u, const sc_signed &v) 3087{ 3088 if (u == 0) 3089 return sc_signed(v); 3090 3091 CONVERT_LONG(u); 3092 3093 if (v.sgn == SC_ZERO) 3094 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3095 3096 // other cases 3097 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3098 v.sgn, v.nbits, v.ndigits, v.digit); 3099} 3100 3101 3102sc_signed 3103operator | (const sc_unsigned &u, long v) 3104{ 3105 if (v == 0) // case 1 3106 return sc_signed(u); 3107 3108 CONVERT_LONG(v); 3109 3110 if (u.sgn == SC_ZERO) // case 2 3111 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3112 3113 // other cases 3114 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3115 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3116} 3117 3118 3119sc_signed 3120operator | (long u, const sc_unsigned &v) 3121{ 3122 if (u == 0) 3123 return sc_signed(v); 3124 3125 CONVERT_LONG(u); 3126 3127 if (v.sgn == SC_ZERO) 3128 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3129 3130 // other cases 3131 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3132 v.sgn, v.nbits, v.ndigits, v.digit); 3133} 3134 3135 3136sc_signed 3137operator | (const sc_signed &u, unsigned long v) 3138{ 3139 if (v == 0) // case 1 3140 return sc_signed(u); 3141 3142 CONVERT_LONG(v); 3143 3144 if (u.sgn == SC_ZERO) // case 2 3145 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3146 3147 // other cases 3148 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3149 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3150} 3151 3152 3153sc_signed 3154operator | (unsigned long u, const sc_signed &v) 3155{ 3156 if (u == 0) 3157 return sc_signed(v); 3158 3159 CONVERT_LONG(u); 3160 3161 if (v.sgn == SC_ZERO) 3162 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3163 3164 // other cases 3165 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3166 v.sgn, v.nbits, v.ndigits, v.digit); 3167} 3168 3169// The rest of the operators in this section are included from 3170// sc_nbcommon.cpp. 3171 3172 3173// ---------------------------------------------------------------------------- 3174// SECTION: Bitwise XOR operators: ^, ^= 3175// ---------------------------------------------------------------------------- 3176 3177// Cases to consider when computing u ^ v: 3178// Note that u ^ v = (~u &v) | (u & ~v). 3179// 1. u ^ 0 = u 3180// 2. 0 ^ v = v 3181// 3. u ^ v => sgn = + 3182// 4. (-u) ^ (-v) => sgn = - 3183// 5. u ^ (-v) => sgn = - 3184// 6. (-u) ^ v => sgn = + 3185 3186sc_signed 3187operator ^ (const sc_unsigned &u, const sc_signed &v) 3188{ 3189 3190 if (v.sgn == SC_ZERO) // case 1 3191 return sc_signed(u); 3192 3193 if (u.sgn == SC_ZERO) // case 2 3194 return sc_signed(v); 3195 3196 // other cases 3197 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3198 v.sgn, v.nbits, v.ndigits, v.digit); 3199 3200} 3201 3202 3203sc_signed 3204operator ^ (const sc_signed &u, const sc_unsigned &v) 3205{ 3206 if (v.sgn == SC_ZERO) // case 1 3207 return sc_signed(u); 3208 3209 if (u.sgn == SC_ZERO) // case 2 3210 return sc_signed(v); 3211 3212 // other cases 3213 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3214 v.sgn, v.nbits, v.ndigits, v.digit); 3215} 3216 3217 3218sc_signed 3219operator ^ (const sc_signed &u, const sc_signed &v) 3220{ 3221 if (v.sgn == SC_ZERO) // case 1 3222 return sc_signed(u); 3223 3224 if (u.sgn == SC_ZERO) // case 2 3225 return sc_signed(v); 3226 3227 // other cases 3228 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3229 v.sgn, v.nbits, v.ndigits, v.digit); 3230} 3231 3232 3233sc_signed 3234operator ^ (const sc_signed &u, int64 v) 3235{ 3236 if (v == 0) // case 1 3237 return sc_signed(u); 3238 3239 CONVERT_INT64(v); 3240 3241 if (u.sgn == SC_ZERO) // case 2 3242 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 3243 3244 // other cases 3245 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3246 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 3247} 3248 3249 3250sc_signed 3251operator ^ (int64 u, const sc_signed &v) 3252{ 3253 if (u == 0) 3254 return sc_signed(v); 3255 3256 CONVERT_INT64(u); 3257 3258 if (v.sgn == SC_ZERO) 3259 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 3260 3261 // other cases 3262 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 3263 v.sgn, v.nbits, v.ndigits, v.digit); 3264} 3265 3266 3267sc_signed 3268operator ^ (const sc_unsigned &u, int64 v) 3269{ 3270 if (v == 0) // case 1 3271 return sc_signed(u); 3272 3273 CONVERT_INT64(v); 3274 3275 if (u.sgn == SC_ZERO) // case 2 3276 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 3277 3278 // other cases 3279 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3280 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 3281} 3282 3283 3284sc_signed 3285operator ^ (int64 u, const sc_unsigned &v) 3286{ 3287 if (u == 0) 3288 return sc_signed(v); 3289 3290 CONVERT_INT64(u); 3291 3292 if (v.sgn == SC_ZERO) 3293 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 3294 3295 // other cases 3296 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 3297 v.sgn, v.nbits, v.ndigits, v.digit); 3298} 3299 3300 3301sc_signed 3302operator ^ (const sc_signed &u, uint64 v) 3303{ 3304 if (v == 0) // case 1 3305 return sc_signed(u); 3306 3307 CONVERT_INT64(v); 3308 3309 if (u.sgn == SC_ZERO) // case 2 3310 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false); 3311 3312 // other cases 3313 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3314 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd); 3315} 3316 3317sc_signed 3318operator ^ (uint64 u, const sc_signed &v) 3319{ 3320 if (u == 0) 3321 return sc_signed(v); 3322 3323 CONVERT_INT64(u); 3324 3325 if (v.sgn == SC_ZERO) 3326 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false); 3327 3328 // other cases 3329 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 3330 v.sgn, v.nbits, v.ndigits, v.digit); 3331} 3332 3333 3334sc_signed 3335operator ^ (const sc_signed &u, long v) 3336{ 3337 if (v == 0) // case 1 3338 return sc_signed(u); 3339 3340 CONVERT_LONG(v); 3341 3342 if (u.sgn == SC_ZERO) // case 2 3343 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3344 3345 // other cases 3346 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3347 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3348} 3349 3350 3351sc_signed 3352operator ^ (long u, const sc_signed &v) 3353{ 3354 if (u == 0) 3355 return sc_signed(v); 3356 3357 CONVERT_LONG(u); 3358 3359 if (v.sgn == SC_ZERO) 3360 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3361 3362 // other cases 3363 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3364 v.sgn, v.nbits, v.ndigits, v.digit); 3365} 3366 3367 3368sc_signed 3369operator ^ (const sc_unsigned &u, long v) 3370{ 3371 if (v == 0) // case 1 3372 return sc_signed(u); 3373 3374 CONVERT_LONG(v); 3375 3376 if (u.sgn == SC_ZERO) // case 2 3377 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3378 3379 // other cases 3380 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3381 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3382} 3383 3384 3385sc_signed 3386operator ^ (long u, const sc_unsigned &v) 3387{ 3388 if (u == 0) 3389 return sc_signed(v); 3390 3391 CONVERT_LONG(u); 3392 3393 if (v.sgn == SC_ZERO) 3394 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3395 3396 // other cases 3397 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3398 v.sgn, v.nbits, v.ndigits, v.digit); 3399} 3400 3401 3402sc_signed 3403operator ^ (const sc_signed &u, unsigned long v) 3404{ 3405 if (v == 0) // case 1 3406 return sc_signed(u); 3407 3408 CONVERT_LONG(v); 3409 3410 if (u.sgn == SC_ZERO) // case 2 3411 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false); 3412 3413 // other cases 3414 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit, 3415 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd); 3416} 3417 3418sc_signed 3419operator ^ (unsigned long u, const sc_signed &v) 3420{ 3421 if (u == 0) 3422 return sc_signed(v); 3423 3424 CONVERT_LONG(u); 3425 3426 if (v.sgn == SC_ZERO) 3427 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false); 3428 3429 // other cases 3430 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 3431 v.sgn, v.nbits, v.ndigits, v.digit); 3432} 3433 3434// The rest of the operators in this section are included from 3435// sc_nbcommon.cpp. 3436 3437 3438// ---------------------------------------------------------------------------- 3439// SECTION: Bitwise NOT operator: ~ 3440// ---------------------------------------------------------------------------- 3441 3442// Operators in this section are included from sc_nbcommon.cpp. 3443 3444 3445// ---------------------------------------------------------------------------- 3446// SECTION: LEFT SHIFT operators: <<, <<= 3447// ---------------------------------------------------------------------------- 3448 3449sc_signed 3450operator << (const sc_signed &u, const sc_unsigned &v) 3451{ 3452 if (v.sgn == SC_ZERO) 3453 return sc_signed(u); 3454 3455 return operator << (u, v.to_ulong()); 3456} 3457 3458// The rest of the operators in this section are included from 3459// sc_nbcommon.cpp. 3460 3461 3462// ---------------------------------------------------------------------------- 3463// SECTION: RIGHT SHIFT operators: >>, >>= 3464// ---------------------------------------------------------------------------- 3465 3466sc_signed 3467operator >> (const sc_signed &u, const sc_unsigned &v) 3468{ 3469 if (v.sgn == SC_ZERO) 3470 return sc_signed(u); 3471 3472 return operator >> (u, v.to_ulong()); 3473} 3474 3475// The rest of the operators in this section are included from 3476// sc_nbcommon.cpp. 3477 3478 3479// ---------------------------------------------------------------------------- 3480// SECTION: Unary arithmetic operators. 3481// ---------------------------------------------------------------------------- 3482 3483sc_signed 3484operator + (const sc_signed &u) 3485{ 3486 return sc_signed(u); 3487} 3488 3489sc_signed 3490operator - (const sc_signed &u) 3491{ 3492 return sc_signed(u, -u.sgn); 3493} 3494 3495sc_signed 3496operator - (const sc_unsigned &u) 3497{ 3498 return sc_signed(u, -u.sgn); 3499} 3500 3501 3502// ---------------------------------------------------------------------------- 3503// SECTION: EQUAL operator: == 3504// ---------------------------------------------------------------------------- 3505 3506bool 3507operator == (const sc_signed &u, const sc_signed &v) 3508{ 3509 if (u.sgn != v.sgn) 3510 return false; 3511 3512 if (&u == &v) 3513 return true; 3514 3515 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) != 0) 3516 return false; 3517 3518 return true; 3519} 3520 3521 3522bool 3523operator == (const sc_signed &u, int64 v) 3524{ 3525 CONVERT_INT64(v); 3526 3527 if (u.sgn != vs) 3528 return false; 3529 3530 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0) 3531 return false; 3532 3533 return true; 3534} 3535 3536 3537bool 3538operator == (int64 u, const sc_signed &v) 3539{ 3540 CONVERT_INT64(u); 3541 3542 if (us != v.sgn) 3543 return false; 3544 3545 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0) 3546 return false; 3547 3548 return true; 3549} 3550 3551 3552bool 3553operator == (const sc_signed &u, uint64 v) 3554{ 3555 CONVERT_INT64(v); 3556 3557 if (u.sgn != vs) 3558 return false; 3559 3560 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0) 3561 return false; 3562 3563 return true; 3564} 3565 3566 3567bool 3568operator == (uint64 u, const sc_signed &v) 3569{ 3570 CONVERT_INT64(u); 3571 3572 if (us != v.sgn) 3573 return false; 3574 3575 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0) 3576 return false; 3577 3578 return true; 3579} 3580 3581 3582bool 3583operator == (const sc_signed &u, long v) 3584{ 3585 CONVERT_LONG(v); 3586 3587 if (u.sgn != vs) 3588 return false; 3589 3590 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0) 3591 return false; 3592 3593 return true; 3594} 3595 3596 3597bool 3598operator == (long u, const sc_signed &v) 3599{ 3600 CONVERT_LONG(u); 3601 3602 if (us != v.sgn) 3603 return false; 3604 3605 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0) 3606 return false; 3607 3608 return true; 3609} 3610 3611 3612bool 3613operator == (const sc_signed &u, unsigned long v) 3614{ 3615 CONVERT_LONG(v); 3616 3617 if (u.sgn != vs) 3618 return false; 3619 3620 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0) 3621 return false; 3622 3623 return true; 3624} 3625 3626 3627bool 3628operator == (unsigned long u, const sc_signed &v) 3629{ 3630 CONVERT_LONG(u); 3631 3632 if (us != v.sgn) 3633 return false; 3634 3635 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0) 3636 return false; 3637 3638 return true; 3639} 3640 3641 3642// ---------------------------------------------------------------------------- 3643// SECTION: NOT_EQUAL operator: != 3644// ---------------------------------------------------------------------------- 3645 3646// Operators in this section are included from sc_nbcommon.cpp. 3647 3648 3649// ---------------------------------------------------------------------------- 3650// SECTION: LESS THAN operator: < 3651// ---------------------------------------------------------------------------- 3652 3653bool 3654operator < (const sc_signed &u, const sc_signed &v) 3655{ 3656 if (u.sgn < v.sgn) 3657 return true; 3658 3659 if (u.sgn > v.sgn) 3660 return false; 3661 3662 // u.sgn == v.sgn 3663 3664 if (&u == &v) 3665 return false; 3666 3667 if (u.sgn == SC_POS) { 3668 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) < 0) 3669 return true; 3670 } else if (u.sgn == SC_NEG) { 3671 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) > 0) 3672 return true; 3673 } 3674 3675 return false; 3676} 3677 3678 3679bool 3680operator < (const sc_signed &u, int64 v) 3681{ 3682 CONVERT_INT64(v); 3683 3684 if (u.sgn < vs) 3685 return true; 3686 3687 if (u.sgn > vs) 3688 return false; 3689 3690 // u.sgn == vs 3691 3692 if (vs == SC_POS) { 3693 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0) 3694 return true; 3695 } else if (vs == SC_NEG) { 3696 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) > 0) 3697 return true; 3698 } 3699 3700 return false; 3701} 3702 3703 3704bool 3705operator < (int64 u, const sc_signed &v) 3706{ 3707 CONVERT_INT64(u); 3708 3709 if (us < v.sgn) 3710 return true; 3711 3712 if (us > v.sgn) 3713 return false; 3714 3715 // us == v.sgn 3716 3717 if (us == SC_POS) { 3718 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0) 3719 return true; 3720 } else if (us == SC_NEG) { 3721 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) > 0) 3722 return true; 3723 } 3724 3725 return false; 3726} 3727 3728 3729bool 3730operator < (const sc_signed &u, uint64 v) 3731{ 3732 CONVERT_INT64(v); 3733 3734 if (u.sgn < vs) 3735 return true; 3736 3737 if (u.sgn > vs) 3738 return false; 3739 3740 // u.sgn == vs 3741 3742 if (vs == SC_POS) { 3743 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0) 3744 return true; 3745 } 3746 3747 return false; 3748} 3749 3750 3751bool 3752operator < (uint64 u, const sc_signed &v) 3753{ 3754 CONVERT_INT64(u); 3755 3756 if (us < v.sgn) 3757 return true; 3758 3759 if (us > v.sgn) 3760 return false; 3761 3762 // us == v.sgn 3763 3764 if (us == SC_POS) { 3765 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0) 3766 return true; 3767 } 3768 3769 return false; 3770} 3771 3772 3773bool 3774operator < (const sc_signed &u, long v) 3775{ 3776 CONVERT_LONG(v); 3777 3778 if (u.sgn < vs) 3779 return true; 3780 3781 if (u.sgn > vs) 3782 return false; 3783 3784 // u.sgn == vs 3785 3786 if (vs == SC_POS) { 3787 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0) 3788 return true; 3789 3790 } else if (vs == SC_NEG) { 3791 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) > 0) 3792 return true; 3793 } 3794 3795 return false; 3796} 3797 3798 3799bool 3800operator < (long u, const sc_signed &v) 3801{ 3802 CONVERT_LONG(u); 3803 3804 if (us < v.sgn) 3805 return true; 3806 3807 if (us > v.sgn) 3808 return false; 3809 3810 // us == v.sgn 3811 3812 if (us == SC_POS) { 3813 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0) 3814 return true; 3815 } else if (us == SC_NEG) { 3816 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) > 0) 3817 return true; 3818 } 3819 3820 return false; 3821} 3822 3823 3824bool 3825operator < (const sc_signed &u, unsigned long v) 3826{ 3827 CONVERT_LONG(v); 3828 3829 if (u.sgn < vs) 3830 return true; 3831 3832 if (u.sgn > vs) 3833 return false; 3834 3835 // u.sgn == vs 3836 3837 if (vs == SC_POS) { 3838 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0) 3839 return true; 3840 } 3841 3842 return false; 3843} 3844 3845 3846bool 3847operator < (unsigned long u, const sc_signed &v) 3848{ 3849 CONVERT_LONG(u); 3850 3851 if (us < v.sgn) 3852 return true; 3853 3854 if (us > v.sgn) 3855 return false; 3856 3857 // us == v.sgn 3858 3859 if (us == SC_POS) { 3860 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0) 3861 return true; 3862 } 3863 3864 return false; 3865} 3866 3867 3868// --------------------------------------------------------------------------- 3869// SECTION: LESS THAN or EQUAL operator: <= 3870// --------------------------------------------------------------------------- 3871 3872// Operators in this section are included from sc_nbcommon.cpp. 3873 3874 3875// --------------------------------------------------------------------------- 3876// SECTION: GREATER THAN operator: > 3877// --------------------------------------------------------------------------- 3878 3879// Operators in this section are included from sc_nbcommon.cpp. 3880 3881 3882// --------------------------------------------------------------------------- 3883// SECTION: GREATER THAN or EQUAL operator: >= 3884// --------------------------------------------------------------------------- 3885 3886// Operators in this section are included from sc_nbcommon.cpp. 3887 3888 3889// --------------------------------------------------------------------------- 3890// SECTION: Public members - Other utils. 3891// --------------------------------------------------------------------------- 3892 3893bool 3894sc_signed::iszero() const 3895{ 3896 if (sgn == SC_ZERO) 3897 return true; 3898 else if (sgn != SC_NOSIGN) 3899 return false; 3900 else 3901 return check_for_zero(ndigits, digit); 3902} 3903 3904 3905bool 3906sc_signed::sign() const 3907{ 3908 if (sgn == SC_NEG) 3909 return 1; 3910 else if (sgn != SC_NOSIGN) 3911 return 0; 3912 else 3913 return ((digit[ndigits - 1] & one_and_zeros(bit_ord(nbits - 1))) != 0); 3914} 3915 3916// The rest of the utils in this section are included from sc_nbcommon.cpp. 3917 3918 3919// ---------------------------------------------------------------------------- 3920// SECTION: Private members. 3921// ---------------------------------------------------------------------------- 3922 3923// The private members in this section are included from sc_nbcommon.cpp. 3924 3925#define CLASS_TYPE sc_signed 3926#define CLASS_TYPE_STR "sc_signed" 3927 3928#define ADD_HELPER add_signed_friend 3929#define SUB_HELPER sub_signed_friend 3930#define MUL_HELPER mul_signed_friend 3931#define DIV_HELPER div_signed_friend 3932#define MOD_HELPER mod_signed_friend 3933#define AND_HELPER and_signed_friend 3934#define OR_HELPER or_signed_friend 3935#define XOR_HELPER xor_signed_friend 3936 3937#include "sc_nbfriends.inc" 3938 3939#undef SC_UNSIGNED 3940#define SC_SIGNED 3941#define IF_SC_SIGNED 1 // 1 = sc_signed 3942#define CLASS_TYPE_SUBREF sc_signed_subref_r 3943#define OTHER_CLASS_TYPE sc_unsigned 3944#define OTHER_CLASS_TYPE_SUBREF sc_unsigned_subref_r 3945 3946#define MUL_ON_HELPER mul_on_help_signed 3947#define DIV_ON_HELPER div_on_help_signed 3948#define MOD_ON_HELPER mod_on_help_signed 3949 3950#include "sc_nbcommon.inc" 3951 3952#undef MOD_ON_HELPER 3953#undef DIV_ON_HELPER 3954#undef MUL_ON_HELPER 3955 3956#undef OTHER_CLASS_TYPE_SUBREF 3957#undef OTHER_CLASS_TYPE 3958#undef CLASS_TYPE_SUBREF 3959#undef IF_SC_SIGNED 3960#undef SC_SIGNED 3961 3962#undef XOR_HELPER 3963#undef OR_HELPER 3964#undef AND_HELPER 3965#undef MOD_HELPER 3966#undef DIV_HELPER 3967#undef MUL_HELPER 3968#undef SUB_HELPER 3969#undef ADD_HELPER 3970 3971#undef CLASS_TYPE 3972#undef CLASS_TYPE_STR 3973 3974#include "sc_signed_bitref.inc" 3975#include "sc_signed_subref.inc" 3976 3977#undef CONVERT_LONG 3978#undef CONVERT_LONG_2 3979#undef CONVERT_INT64 3980#undef CONVERT_INT64_2 3981 3982} // namespace sc_dt
|