scfx_rep.cc revision 13197:aeba6988033f
1/***************************************************************************** 2 3 Licensed to Accellera Systems Initiative Inc. (Accellera) under one or 4 more contributor license agreements. See the NOTICE file distributed 5 with this work for additional information regarding copyright ownership. 6 Accellera licenses this file to you under the Apache License, Version 2.0 7 (the "License"); you may not use this file except in compliance with the 8 License. You may obtain a copy of the License at 9 10 http://www.apache.org/licenses/LICENSE-2.0 11 12 Unless required by applicable law or agreed to in writing, software 13 distributed under the License is distributed on an "AS IS" BASIS, 14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 15 implied. See the License for the specific language governing 16 permissions and limitations under the License. 17 18 *****************************************************************************/ 19 20/***************************************************************************** 21 22 scfx_rep.cpp - 23 24 Original Author: Robert Graulich, Synopsys, Inc. 25 Martin Janssen, Synopsys, Inc. 26 27 *****************************************************************************/ 28 29/***************************************************************************** 30 31 MODIFICATION LOG - modifiers, enter your name, affiliation, date and 32 changes you are making here. 33 34 Name, Affiliation, Date: 35 Description of Modification: 36 37 *****************************************************************************/ 38 39 40// $Log: scfx_rep.cpp,v $ 41// Revision 1.4 2011/08/24 22:05:43 acg 42// Torsten Maehne: initialization changes to remove warnings. 43// 44// Revision 1.3 2011/08/15 16:43:24 acg 45// Torsten Maehne: changes to remove unused argument warnings. 46// 47// Revision 1.2 2009/02/28 00:26:20 acg 48// Andy Goodrich: bug fixes. 49// 50// Revision 1.2 2008/11/06 17:22:47 acg 51// Andy Goodrich: bug fixes for 2.2.1. 52// 53// Revision 1.1.1.1 2006/12/15 20:31:36 acg 54// SystemC 2.2 55// 56// Revision 1.3 2006/01/13 18:53:58 acg 57// Andy Goodrich: added $Log command so that CVS comments are reproduced in 58// the source. 59// 60 61#include <cctype> 62#include <cmath> 63#include <cstdio> 64#include <cstdlib> 65 66#include "base/compiler.hh" 67#include "systemc/ext/dt/bit/sc_bv_base.hh" 68#include "systemc/ext/dt/bit/sc_lv_base.hh" 69#include "systemc/ext/dt/fx/scfx_ieee.hh" 70#include "systemc/ext/dt/fx/scfx_pow10.hh" 71#include "systemc/ext/dt/fx/scfx_rep.hh" 72#include "systemc/ext/dt/fx/scfx_utils.hh" 73#include "systemc/ext/utils/endian.hh" 74 75namespace sc_dt 76{ 77 78// ---------------------------------------------------------------------------- 79// some utilities 80// ---------------------------------------------------------------------------- 81 82static scfx_pow10 pow10_fx; 83 84static const int mantissa0_size = SCFX_IEEE_DOUBLE_M_SIZE - bits_in_int; 85 86static inline int 87n_word(int x) 88{ 89 return (x + bits_in_word - 1) / bits_in_word; 90} 91 92 93// ---------------------------------------------------------------------------- 94// CONSTRUCTORS 95// ---------------------------------------------------------------------------- 96 97scfx_rep::scfx_rep() : 98 m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 99 m_r_flag(false) 100{ 101 set_zero(); 102} 103 104scfx_rep::scfx_rep(int a) : m_mant(min_mant), m_wp(), m_sign(), m_state(), 105 m_msw(), m_lsw(), m_r_flag(false) 106{ 107 if (a != 0) { 108 m_mant.clear(); 109 m_wp = m_msw = m_lsw = 2; 110 m_state = normal; 111 if (a > 0) { 112 m_mant[2] = a; 113 m_sign = 1; 114 } else { 115 m_mant[2] = -a; 116 m_sign = -1; 117 } 118 } else { 119 set_zero(); 120 } 121} 122 123scfx_rep::scfx_rep(unsigned int a) : m_mant(min_mant), m_wp(), m_sign(), 124 m_state(), m_msw(), m_lsw(), m_r_flag(false) 125{ 126 if (a != 0) { 127 m_mant.clear(); 128 m_wp = m_msw = m_lsw = 2; 129 m_state = normal; 130 m_mant[2] = a; 131 m_sign = 1; 132 } else { 133 set_zero(); 134 } 135} 136 137scfx_rep::scfx_rep(long a) : 138 m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 139 m_r_flag(false) 140{ 141 if (a != 0) { 142 m_mant.clear(); 143 m_state = normal; 144 if (a > 0) { 145 m_sign = 1; 146 } else { 147 a = -a; 148 m_sign = -1; 149 } 150# if SC_LONG_64 151 m_wp = 1; 152 m_mant[1] = static_cast<word>(a); 153 m_mant[2] = static_cast<word>(a >> bits_in_word); 154 find_sw(); 155# else 156 m_wp = 2; 157 m_msw = 2; 158 m_lsw = 2; 159 m_mant[2] = a; 160# endif 161 } else { 162 set_zero(); 163 } 164} 165 166scfx_rep::scfx_rep(unsigned long a) : 167 m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 168 m_r_flag(false) 169{ 170 if (a != 0) { 171 m_mant.clear(); 172 m_wp = m_msw = m_lsw = 2; 173 m_state = normal; 174# if SC_LONG_64 175 m_wp = 1; 176 m_mant[1] = static_cast<word>(a); 177 m_mant[2] = static_cast<word>(a >> bits_in_word); 178 find_sw(); 179# else 180 m_wp = 2; 181 m_msw = 2; 182 m_lsw = 2; 183 m_mant[2] = a; 184# endif 185 m_sign = 1; 186 } 187 else 188 set_zero(); 189} 190 191scfx_rep::scfx_rep(double a) : 192 m_mant(min_mant), m_wp(0), m_sign(), m_state(normal), m_msw(0), 193 m_lsw(0), m_r_flag(false) 194{ 195 m_mant.clear(); 196 197 scfx_ieee_double id(a); 198 199 m_sign = id.negative() ? -1 : 1; 200 201 if (id.is_nan()) { 202 m_state = not_a_number; 203 } else if (id.is_inf()) { 204 m_state = infinity; 205 } else if (id.is_subnormal()) { 206 m_mant[0] = id.mantissa1(); 207 m_mant[1] = id.mantissa0(); 208 normalize(id.exponent() + 1 - SCFX_IEEE_DOUBLE_M_SIZE); 209 } else if (id.is_normal()) { 210 m_mant[0] = id.mantissa1(); 211 m_mant[1] = id.mantissa0() | (1 << mantissa0_size); 212 normalize(id.exponent() - SCFX_IEEE_DOUBLE_M_SIZE); 213 } 214} 215 216scfx_rep::scfx_rep(int64 a) : 217 m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 218 m_r_flag(false) 219{ 220 if (a != 0) { 221 m_mant.clear(); 222 m_wp = 1; 223 m_state = normal; 224 if (a > 0) { 225 m_mant[1] = static_cast<word>(a); 226 m_mant[2] = static_cast<word>(a >> bits_in_word); 227 m_sign = 1; 228 } else { 229 m_mant[1] = static_cast<word>(-a); 230 m_mant[2] = static_cast<word>((-a) >> bits_in_word); 231 m_sign = -1; 232 } 233 find_sw(); 234 } else { 235 set_zero(); 236 } 237} 238 239scfx_rep::scfx_rep(uint64 a) : 240 m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 241 m_r_flag(false) 242{ 243 if (a != 0) { 244 m_mant.clear(); 245 m_wp = 1; 246 m_state = normal; 247 m_mant[1] = static_cast<word>(a); 248 m_mant[2] = static_cast<word>(a >> bits_in_word); 249 m_sign = 1; 250 find_sw(); 251 } else { 252 set_zero(); 253 } 254} 255 256scfx_rep::scfx_rep(const sc_signed &a) : 257 m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 258 m_r_flag(false) 259{ 260 if (a.iszero()) { 261 set_zero(); 262 } else { 263 int words = n_word(a.length()); 264 if (words > size()) 265 resize_to(words); 266 m_mant.clear(); 267 m_wp = 0; 268 m_state = normal; 269 if (a.sign()) { 270 sc_signed a2 = -a; 271 for (int i = 0; i < a2.length(); ++i) { 272 if (a2[i]) { 273 scfx_index x = calc_indices(i); 274 m_mant[x.wi()] |= 1 << x.bi(); 275 } 276 } 277 m_sign = -1; 278 } else { 279 for (int i = 0; i < a.length(); ++i) { 280 if (a[i]) { 281 scfx_index x = calc_indices(i); 282 m_mant[x.wi()] |= 1 << x.bi(); 283 } 284 } 285 m_sign = 1; 286 } 287 find_sw(); 288 } 289} 290 291scfx_rep::scfx_rep(const sc_unsigned &a) : 292 m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 293 m_r_flag(false) 294{ 295 if (a.iszero()) { 296 set_zero(); 297 } else { 298 int words = n_word(a.length()); 299 if (words > size()) 300 resize_to(words); 301 m_mant.clear(); 302 m_wp = 0; 303 m_state = normal; 304 for (int i = 0; i < a.length(); ++i) { 305 if (a[i]) { 306 scfx_index x = calc_indices(i); 307 m_mant[x.wi()] |= 1 << x.bi(); 308 } 309 } 310 m_sign = 1; 311 find_sw(); 312 } 313} 314 315// copy constructor 316scfx_rep::scfx_rep(const scfx_rep &a) : 317 m_mant(a.m_mant), m_wp(a.m_wp), m_sign(a.m_sign), m_state(a.m_state), 318 m_msw(a.m_msw), m_lsw(a.m_lsw), m_r_flag(false) 319{} 320 321 322// ---------------------------------------------------------------------------- 323// OPERATORS : new, delete 324// 325// Memory management for class scfx_rep. 326// ---------------------------------------------------------------------------- 327 328union scfx_rep_node 329{ 330 char data[sizeof(scfx_rep)]; 331 scfx_rep_node *next; 332}; 333 334static scfx_rep_node *list = 0; 335 336void * 337scfx_rep::operator new(std::size_t size) 338{ 339 const int ALLOC_SIZE = 1024; 340 341 if (size != sizeof(scfx_rep)) 342 return ::operator new(size); 343 344 if (!list) { 345 list = new scfx_rep_node[ALLOC_SIZE]; 346 for (int i = 0; i < ALLOC_SIZE - 1; i++) 347 list[i].next = list + i + 1; 348 list[ALLOC_SIZE - 1].next = 0; 349 } 350 351 scfx_rep *ptr = reinterpret_cast<scfx_rep *>(list->data); 352 list = list->next; 353 354 return ptr; 355} 356 357void 358scfx_rep::operator delete(void *ptr, std::size_t size) 359{ 360 if (size != sizeof(scfx_rep)) { 361 ::operator delete(ptr); 362 return; 363 } 364 365 scfx_rep_node *node = static_cast<scfx_rep_node *>(ptr); 366 node->next = list; 367 list = node; 368} 369 370 371// ---------------------------------------------------------------------------- 372// METHOD : from_string 373// 374// Convert from character string to sc_fxrep. 375// ---------------------------------------------------------------------------- 376 377#define SCFX_FAIL_IF_(cnd) \ 378{ \ 379 if ((cnd)) { \ 380 m_state = not_a_number; \ 381 m_mant.clear(); /* to avoid Purify UMRs during assignment */ \ 382 return; \ 383 } \ 384} 385 386void 387scfx_rep::from_string(const char *s, int cte_wl) 388{ 389 SCFX_FAIL_IF_(s == 0 || *s == 0); 390 391 scfx_string s2; 392 s2 += s; 393 s2 += '\0'; 394 395 bool sign_char; 396 m_sign = scfx_parse_sign(s, sign_char); 397 398 sc_numrep numrep = scfx_parse_prefix(s); 399 400 int base = 0; 401 402 switch (numrep) { 403 case SC_DEC: 404 { 405 base = 10; 406 if (scfx_is_nan(s)) { // special case: NaN 407 m_state = not_a_number; 408 m_mant.clear(); /* to avoid Purify UMRs during assignment */ 409 return; 410 } 411 if (scfx_is_inf(s)) { // special case: Infinity 412 m_state = infinity; 413 m_mant.clear(); /* to avoid Purify UMRs during assignment */ 414 return; 415 } 416 break; 417 } 418 case SC_BIN: 419 case SC_BIN_US: 420 { 421 SCFX_FAIL_IF_(sign_char); 422 base = 2; 423 break; 424 } 425 426 case SC_BIN_SM: 427 { 428 base = 2; 429 break; 430 } 431 case SC_OCT: 432 case SC_OCT_US: 433 { 434 SCFX_FAIL_IF_(sign_char); 435 base = 8; 436 break; 437 } 438 case SC_OCT_SM: 439 { 440 base = 8; 441 break; 442 } 443 case SC_HEX: 444 case SC_HEX_US: 445 { 446 SCFX_FAIL_IF_(sign_char); 447 base = 16; 448 break; 449 } 450 case SC_HEX_SM: 451 { 452 base = 16; 453 break; 454 } 455 case SC_CSD: 456 { 457 SCFX_FAIL_IF_(sign_char); 458 base = 2; 459 scfx_csd2tc(s2); 460 s = (const char *)s2 + 4; 461 numrep = SC_BIN; 462 break; 463 } 464 default: 465 ; 466 } 467 468 // 469 // find end of mantissa and count the digits and points 470 // 471 472 const char *end = s; 473 bool based_point = false; 474 int int_digits = 0; 475 int frac_digits = 0; 476 477 while (*end) { 478 if (scfx_exp_start(end)) 479 break; 480 481 if (*end == '.') { 482 SCFX_FAIL_IF_(based_point); 483 based_point = true; 484 } else { 485 SCFX_FAIL_IF_(!scfx_is_digit(*end, numrep)); 486 if (based_point) 487 frac_digits++; 488 else 489 int_digits++; 490 } 491 492 ++end; 493 } 494 495 SCFX_FAIL_IF_(int_digits == 0 && frac_digits == 0); 496 497 // [ exponent ] 498 int exponent = 0; 499 500 if (*end) { 501 for (const char *e = end + 2; *e; ++e) 502 SCFX_FAIL_IF_(!scfx_is_digit(*e, SC_DEC)); 503 exponent = std::atoi(end + 1); 504 } 505 506 // 507 // check if the mantissa is negative 508 // 509 bool mant_is_neg = false; 510 switch (numrep) { 511 case SC_BIN: 512 case SC_OCT: 513 case SC_HEX: 514 { 515 const char *p = s; 516 if (*p == '.') 517 ++p; 518 519 mant_is_neg = (scfx_to_digit(* p, numrep) >= (base >> 1)); 520 break; 521 } 522 default: 523 ; 524 } 525 526 // 527 // convert the mantissa 528 // 529 530 switch (base) { 531 case 2: 532 { 533 int bit_offset = exponent % bits_in_word; 534 int word_offset = exponent / bits_in_word; 535 536 int_digits += bit_offset; 537 frac_digits -= bit_offset; 538 539 int words = n_word(int_digits) + n_word(frac_digits); 540 if (words > size()) 541 resize_to(words); 542 m_mant.clear(); 543 544 int j = n_word(frac_digits) * bits_in_word + int_digits - 1; 545 546 for (; s < end; s++) { 547 switch (*s) { 548 case '1': 549 set_bin(j); 550 M5_FALLTHROUGH; 551 case '0': 552 j--; 553 M5_FALLTHROUGH; 554 case '.': 555 break; 556 default: 557 SCFX_FAIL_IF_(true); // should not happen 558 } 559 } 560 561 m_wp = n_word(frac_digits) - word_offset; 562 break; 563 } 564 case 8: 565 { 566 exponent *= 3; 567 int_digits *= 3; 568 frac_digits *= 3; 569 570 int bit_offset = exponent % bits_in_word; 571 int word_offset = exponent / bits_in_word; 572 573 int_digits += bit_offset; 574 frac_digits -= bit_offset; 575 576 int words = n_word(int_digits) + n_word(frac_digits); 577 if (words > size()) 578 resize_to(words); 579 m_mant.clear(); 580 581 int j = n_word(frac_digits) * bits_in_word + int_digits - 3; 582 583 for (; s < end; s++) { 584 switch (*s) { 585 case '7': case '6': case '5': case '4': 586 case '3': case '2': case '1': 587 set_oct(j, *s - '0'); 588 M5_FALLTHROUGH; 589 case '0': 590 j -= 3; 591 M5_FALLTHROUGH; 592 case '.': 593 break; 594 default: 595 SCFX_FAIL_IF_(true); // should not happen 596 } 597 } 598 599 m_wp = n_word(frac_digits) - word_offset; 600 break; 601 } 602 case 10: 603 { 604 word carry, temp; 605 int length = int_digits + frac_digits; 606 resize_to(sc_max(min_mant, n_word(4 * length))); 607 608 m_mant.clear(); 609 m_msw = m_lsw = 0; 610 611 for (; s < end; s++) { 612 switch (*s) { 613 case '9': case '8': case '7': case '6': case '5': 614 case '4': case '3': case '2': case '1': case '0': 615 multiply_by_ten(); 616 carry = *s - '0'; 617 for (int i = 0; carry && i < m_mant.size(); i++) { 618 temp = m_mant[i]; 619 temp += carry; 620 carry = temp < m_mant[i]; 621 m_mant[i] = temp; 622 } 623 case '.': 624 break; 625 default: 626 SCFX_FAIL_IF_(true); // should not happen 627 } 628 } 629 630 m_wp = 0; 631 find_sw(); 632 633 int denominator = frac_digits - exponent; 634 635 if (denominator) { 636 scfx_rep frac_num = pow10_fx(denominator); 637 scfx_rep *temp_num = 638 div_scfx_rep(const_cast<const scfx_rep &>(*this), 639 frac_num, cte_wl); 640 *this = *temp_num; 641 delete temp_num; 642 } 643 644 break; 645 } 646 case 16: 647 { 648 exponent *= 4; 649 int_digits *= 4; 650 frac_digits *= 4; 651 652 int bit_offset = exponent % bits_in_word; 653 int word_offset = exponent / bits_in_word; 654 655 int_digits += bit_offset; 656 frac_digits -= bit_offset; 657 658 int words = n_word(int_digits) + n_word(frac_digits); 659 if (words > size()) 660 resize_to(words); 661 m_mant.clear(); 662 663 int j = n_word(frac_digits) * bits_in_word + int_digits - 4; 664 665 for (; s < end; s ++) { 666 switch (*s) { 667 case 'f': case 'e': case 'd': case 'c': case 'b': case 'a': 668 set_hex(j, *s - 'a' + 10); 669 j -= 4; 670 break; 671 case 'F': case 'E': case 'D': case 'C': case 'B': case 'A': 672 set_hex(j, *s - 'A' + 10); 673 j -= 4; 674 break; 675 case '9': case '8': case '7': case '6': case '5': 676 case '4': case '3': case '2': case '1': 677 set_hex(j, *s - '0'); 678 M5_FALLTHROUGH; 679 case '0': 680 j -= 4; 681 M5_FALLTHROUGH; 682 case '.': 683 break; 684 default: 685 SCFX_FAIL_IF_(true); // should not happen 686 } 687 } 688 689 m_wp = n_word(frac_digits) - word_offset; 690 break; 691 } 692 } 693 694 m_state = normal; 695 find_sw(); 696 697 // 698 // two's complement of mantissa if it is negative 699 // 700 if (mant_is_neg) { 701 m_mant[m_msw] |= ~0U << scfx_find_msb(m_mant[m_msw]); 702 for (int i = m_msw + 1; i < m_mant.size(); ++i) 703 m_mant[i] = static_cast<word>(-1); 704 complement(m_mant, m_mant, m_mant.size()); 705 inc(m_mant); 706 m_sign *= -1; 707 find_sw(); 708 } 709} 710 711#undef SCFX_FAIL_IF_ 712 713// ---------------------------------------------------------------------------- 714// METHOD : to_double 715// 716// Convert from scfx_rep to double. 717// ---------------------------------------------------------------------------- 718 719double 720scfx_rep::to_double() const 721{ 722 scfx_ieee_double id; 723 724 // handle special cases 725 if (is_nan()) { 726 id.set_nan(); 727 return id; 728 } 729 730 if (is_inf()) { 731 id.set_inf(); 732 id.negative(m_sign < 0); 733 return id; 734 } 735 736 if (is_zero()) { 737 id = 0.; 738 id.negative(m_sign < 0); 739 return id; 740 } 741 742 int msb = scfx_find_msb(m_mant[m_msw]); 743 744 int exp = (m_msw - m_wp) * bits_in_word + msb; 745 746 if (exp > SCFX_IEEE_DOUBLE_E_MAX) { 747 id.set_inf(); 748 id.negative(m_sign < 0); 749 return id; 750 } 751 752 if (exp < SCFX_IEEE_DOUBLE_E_MIN - 753 static_cast<int>(SCFX_IEEE_DOUBLE_M_SIZE)) 754 { 755 id = 0.; 756 return id; 757 } 758 759 int shift = mantissa0_size - msb; 760 761 unsigned int m0; 762 unsigned int m1 = 0; 763 unsigned int guard = 0; 764 765 if (shift == 0) { 766 m0 = m_mant[m_msw] & ~(1 << mantissa0_size); 767 if (m_msw > m_lsw) { 768 m1 = m_mant[m_msw - 1]; 769 if (m_msw - 1 > m_lsw) 770 guard = m_mant[m_msw - 2] >> (bits_in_word - 1); 771 } 772 } else if (shift < 0) { 773 m0 = (m_mant[m_msw] >> -shift) & ~(1 << mantissa0_size); 774 m1 = m_mant[m_msw] << (bits_in_word + shift); 775 if (m_msw > m_lsw) { 776 m1 |= m_mant[m_msw - 1] >> -shift; 777 guard = (m_mant[m_msw - 1] >> (-shift - 1)) & 1; 778 } 779 } else { 780 m0 = (m_mant[m_msw] << shift) & ~(1 << mantissa0_size); 781 if (m_msw > m_lsw) { 782 m0 |= m_mant[m_msw - 1] >> (bits_in_word - shift); 783 m1 = m_mant[m_msw - 1] << shift; 784 if (m_msw - 1 > m_lsw) { 785 m1 |= m_mant[m_msw - 2] >> (bits_in_word - shift); 786 guard = (m_mant[m_msw - 2] >> (bits_in_word - shift - 1)) & 1; 787 } 788 } 789 } 790 791 if (exp < SCFX_IEEE_DOUBLE_E_MIN) { 792 m0 |= (1 << mantissa0_size); 793 794 int subnormal_shift = SCFX_IEEE_DOUBLE_E_MIN - exp; 795 796 if (subnormal_shift < bits_in_word) { 797 m1 = m1 >> subnormal_shift | 798 m0 << (bits_in_word - subnormal_shift); 799 m0 = m0 >> subnormal_shift; 800 } else { 801 m1 = m0 >> (subnormal_shift - bits_in_word); 802 m0 = 0; 803 } 804 805 guard = 0; 806 807 exp = SCFX_IEEE_DOUBLE_E_MIN - 1; 808 } 809 810 id.mantissa0(m0); 811 id.mantissa1(m1); 812 id.exponent(exp); 813 id.negative(m_sign < 0); 814 815 double result = id; 816 817 if (guard != 0) 818 result += m_sign * scfx_pow2(exp - SCFX_IEEE_DOUBLE_M_SIZE); 819 820 return result; 821} 822 823 824// ---------------------------------------------------------------------------- 825// METHOD : to_uint64 826// 827// Convert from scfx_rep to uint64. 828// Truncates towards 0 _then_ wraps; infinities and NaN go to zero. 829// ---------------------------------------------------------------------------- 830 831uint64 832scfx_rep::to_uint64() const 833{ 834 if (!is_normal() || is_zero()) { 835 return 0; 836 } 837 838 uint64 result = 0; 839 int shift = 0; 840 int idx = m_wp; 841 842 // Ignore bits off the top; they modulo out. 843 // Ignore bits off the bottom; we're truncating. 844 while (shift < 64 && m_msw >= idx && idx >= m_lsw) { 845 result += static_cast<uint64>(m_mant[idx]) << shift; 846 shift += bits_in_word; 847 idx += 1; 848 } 849 850 return m_sign > 0 ? result : -result; 851} 852 853 854// ---------------------------------------------------------------------------- 855// METHOD : to_string 856// 857// Convert from scfx_rep to character string. 858// ---------------------------------------------------------------------------- 859 860void 861print_dec(scfx_string &s, const scfx_rep &num, int w_prefix, sc_fmt fmt) 862{ 863 if (num.is_neg()) 864 s += '-'; 865 866 if (w_prefix == 1) { 867 scfx_print_prefix(s, SC_DEC); 868 } 869 870 if (num.is_zero()) { 871 s += '0'; 872 return; 873 } 874 875 // split 'num' into its integer and fractional part 876 scfx_rep int_part = num; 877 scfx_rep frac_part = num; 878 879 int i; 880 881 for (i = int_part.m_lsw; i <= int_part.m_msw && i < int_part.m_wp; i++) 882 int_part.m_mant[i] = 0; 883 int_part.find_sw(); 884 if (int_part.m_wp < int_part.m_lsw) 885 int_part.resize_to(int_part.size() - int_part.m_wp, -1); 886 887 for (i = frac_part.m_msw; 888 i >= frac_part.m_lsw && i >= frac_part.m_wp; i--) 889 frac_part.m_mant[i] = 0; 890 frac_part.find_sw(); 891 if (frac_part.m_msw == frac_part.size() - 1) 892 frac_part.resize_to(frac_part.size() + 1, 1); 893 894 // print integer part 895 int int_digits = 0; 896 int int_zeros = 0; 897 898 if (!int_part.is_zero()) { 899 double int_wl = (int_part.m_msw - int_part.m_wp) * bits_in_word + 900 scfx_find_msb(int_part.m_mant[int_part.m_msw]) + 1; 901 int_digits = (int)std::ceil(int_wl * std::log10(2.)); 902 903 int len = s.length(); 904 s.append(int_digits); 905 906 bool zero_digits = (frac_part.is_zero() && fmt != SC_F); 907 908 for (i = int_digits + len - 1; i >= len; i--) { 909 unsigned int remainder = int_part.divide_by_ten(); 910 s[i] = static_cast<char>('0' + remainder); 911 912 if (zero_digits) { 913 if (remainder == 0) 914 int_zeros++; 915 else 916 zero_digits = false; 917 } 918 } 919 920 // discard trailing zeros from int_part 921 s.discard(int_zeros); 922 923 if (s[len] == '0') { 924 // int_digits was overestimated by one 925 s.remove(len); 926 --int_digits; 927 } 928 } 929 930 // print fractional part 931 int frac_digits = 0; 932 int frac_zeros = 0; 933 934 if (!frac_part.is_zero()) { 935 s += '.'; 936 937 bool zero_digits = (int_digits == 0 && fmt != SC_F); 938 939 double frac_wl = (frac_part.m_wp - frac_part.m_msw) * bits_in_word - 940 scfx_find_msb(frac_part.m_mant[frac_part.m_msw]) - 1; 941 frac_zeros = (int)std::floor(frac_wl * std::log10(2.)); 942 943 scfx_rep temp; 944 sc_dt::multiply(temp, frac_part, pow10_fx(frac_zeros)); 945 frac_part = temp; 946 if (frac_part.m_msw == frac_part.size() - 1) 947 frac_part.resize_to(frac_part.size() + 1, 1); 948 949 frac_digits = frac_zeros; 950 if (!zero_digits) { 951 for (i = 0; i < frac_zeros; i++) 952 s += '0'; 953 frac_zeros = 0; 954 } 955 956 while (!frac_part.is_zero()) { 957 frac_part.multiply_by_ten(); 958 int n = frac_part.m_mant[frac_part.m_msw + 1]; 959 960 if (zero_digits) { 961 if (n == 0) 962 frac_zeros++; 963 else 964 zero_digits = false; 965 } 966 967 if (! zero_digits) 968 s += static_cast<char>('0' + n); 969 970 frac_part.m_mant[frac_part.m_msw + 1] = 0; 971 frac_digits++; 972 } 973 } 974 975 // print exponent 976 if (fmt != SC_F) { 977 if (frac_digits == 0) 978 scfx_print_exp(s, int_zeros); 979 else if (int_digits == 0) 980 scfx_print_exp(s, -frac_zeros); 981 } 982} 983 984void 985print_other(scfx_string &s, const scfx_rep &a, sc_numrep numrep, int w_prefix, 986 sc_fmt fmt, const scfx_params *params) 987{ 988 scfx_rep b = a; 989 990 sc_numrep numrep2 = numrep; 991 992 bool numrep_is_sm = (numrep == SC_BIN_SM || 993 numrep == SC_OCT_SM || 994 numrep == SC_HEX_SM); 995 996 if (numrep_is_sm) { 997 if (b.is_neg()) { 998 s += '-'; 999 b = *neg_scfx_rep(a); 1000 } 1001 switch (numrep) { 1002 case SC_BIN_SM: 1003 numrep2 = SC_BIN_US; 1004 break; 1005 case SC_OCT_SM: 1006 numrep2 = SC_OCT_US; 1007 break; 1008 case SC_HEX_SM: 1009 numrep2 = SC_HEX_US; 1010 break; 1011 default: 1012 ; 1013 } 1014 } 1015 1016 if (w_prefix != 0) { 1017 scfx_print_prefix(s, numrep); 1018 } 1019 1020 numrep = numrep2; 1021 1022 int msb, lsb; 1023 1024 if (params != 0) { 1025 msb = params->iwl() - 1; 1026 lsb = params->iwl() - params->wl(); 1027 1028 if (params->enc() == SC_TC_ && 1029 (numrep == SC_BIN_US || 1030 numrep == SC_OCT_US || 1031 numrep == SC_HEX_US) && 1032 !numrep_is_sm && 1033 params->wl() > 1) { 1034 --msb; 1035 } else if (params->enc() == SC_US_ && 1036 (numrep == SC_BIN || 1037 numrep == SC_OCT || 1038 numrep == SC_HEX || 1039 numrep == SC_CSD)) { 1040 ++msb; 1041 } 1042 } else { 1043 if (b.is_zero()) { 1044 msb = 0; 1045 lsb = 0; 1046 } else { 1047 msb = (b.m_msw - b.m_wp) * bits_in_word 1048 + scfx_find_msb(b.m_mant[ b.m_msw ]) + 1; 1049 while (b.get_bit(msb) == b.get_bit(msb - 1)) 1050 --msb; 1051 1052 if (numrep == SC_BIN_US || 1053 numrep == SC_OCT_US || 1054 numrep == SC_HEX_US) { 1055 --msb; 1056 } 1057 1058 lsb = (b.m_lsw - b.m_wp) * bits_in_word + 1059 scfx_find_lsb(b.m_mant[b.m_lsw]); 1060 1061 } 1062 } 1063 1064 int step; 1065 1066 switch (numrep) { 1067 case SC_BIN: 1068 case SC_BIN_US: 1069 case SC_CSD: 1070 step = 1; 1071 break; 1072 case SC_OCT: 1073 case SC_OCT_US: 1074 step = 3; 1075 break; 1076 case SC_HEX: 1077 case SC_HEX_US: 1078 step = 4; 1079 break; 1080 default: 1081 SC_REPORT_FATAL("assertion failed", "unexpected sc_numrep"); 1082 sc_core::sc_abort(); 1083 } 1084 1085 msb = (int)std::ceil(double(msb + 1) / step) * step - 1; 1086 1087 lsb = (int)std::floor(double(lsb) / step) * step; 1088 1089 if (msb < 0) { 1090 s += '.'; 1091 if (fmt == SC_F) { 1092 int sign = (b.is_neg()) ? (1 << step) - 1 : 0; 1093 for (int i = (msb + 1) / step; i < 0; i++) { 1094 if (sign < 10) 1095 s += static_cast<char>(sign + '0'); 1096 else 1097 s += static_cast<char>(sign + 'a' - 10); 1098 } 1099 } 1100 } 1101 1102 int i = msb; 1103 while (i >= lsb) { 1104 int value = 0; 1105 for (int j = step - 1; j >= 0; --j) { 1106 value += static_cast<int>(b.get_bit(i)) << j; 1107 --i; 1108 } 1109 if (value < 10) 1110 s += static_cast<char>(value + '0'); 1111 else 1112 s += static_cast<char>(value + 'a' - 10); 1113 if (i == -1) 1114 s += '.'; 1115 } 1116 1117 if (lsb > 0 && fmt == SC_F) { 1118 for (int i = lsb / step; i > 0; i--) 1119 s += '0'; 1120 } 1121 1122 if (s[s.length() - 1] == '.') 1123 s.discard(1); 1124 1125 if (fmt != SC_F) { 1126 if (msb < 0) 1127 scfx_print_exp(s, (msb + 1) / step); 1128 else if (lsb > 0) 1129 scfx_print_exp(s, lsb / step); 1130 } 1131 1132 if (numrep == SC_CSD) 1133 scfx_tc2csd(s, w_prefix); 1134} 1135 1136const char * 1137scfx_rep::to_string(sc_numrep numrep, int w_prefix, 1138 sc_fmt fmt, const scfx_params *params) const 1139{ 1140 static scfx_string s; 1141 1142 s.clear(); 1143 1144 if (is_nan()) { 1145 scfx_print_nan(s); 1146 } else if (is_inf()) { 1147 scfx_print_inf(s, is_neg()); 1148 } else if (is_neg() && !is_zero() && 1149 (numrep == SC_BIN_US || 1150 numrep == SC_OCT_US || 1151 numrep == SC_HEX_US)) { 1152 s += "negative"; 1153 } else if (numrep == SC_DEC || numrep == SC_NOBASE) { 1154 sc_dt::print_dec(s, *this, w_prefix, fmt); 1155 } else { 1156 sc_dt::print_other(s, *this, numrep, w_prefix, fmt, params); 1157 } 1158 1159 return s; 1160} 1161 1162 1163// ---------------------------------------------------------------------------- 1164// ADD 1165// 1166// add two mantissas of the same size 1167// result has the same size 1168// returns carry of operation 1169// ---------------------------------------------------------------------------- 1170 1171static inline int 1172add_mants(int size, scfx_mant &result, const scfx_mant &a, const scfx_mant &b) 1173{ 1174 unsigned int carry = 0; 1175 1176 int index = 0; 1177 1178 do { 1179 word x = a[index]; 1180 word y = b[index]; 1181 1182 y += carry; 1183 carry = y < carry; 1184 y += x; 1185 carry += y < x; 1186 result[index] = y; 1187 } while (++index < size); 1188 1189 return (carry ? 1 : 0); 1190} 1191 1192static inline int 1193sub_mants(int size, scfx_mant &result, const scfx_mant &a, const scfx_mant &b) 1194{ 1195 unsigned carry = 0; 1196 1197 int index = 0; 1198 1199 do { 1200 word x = a[index]; 1201 word y = b[index]; 1202 1203 y += carry; 1204 carry = y < carry; 1205 y = x - y; 1206 carry += y > x; 1207 result[index] = y; 1208 } while (++index < size); 1209 1210 return (carry ? 1 : 0); 1211} 1212 1213scfx_rep * 1214add_scfx_rep(const scfx_rep &lhs, const scfx_rep &rhs, int max_wl) 1215{ 1216 scfx_rep &result = *new scfx_rep; 1217 1218 // 1219 // check for special cases 1220 // 1221 if (lhs.is_nan() || rhs.is_nan() || 1222 (lhs.is_inf() && rhs.is_inf() && lhs.m_sign != rhs.m_sign)) { 1223 result.set_nan(); 1224 return &result; 1225 } 1226 1227 if (lhs.is_inf()) { 1228 result.set_inf(lhs.m_sign); 1229 return &result; 1230 } 1231 1232 if (rhs.is_inf()) { 1233 result.set_inf(rhs.m_sign); 1234 return &result; 1235 } 1236 1237 // 1238 // align operands if needed 1239 // 1240 scfx_mant_ref lhs_mant; 1241 scfx_mant_ref rhs_mant; 1242 1243 int len_mant = lhs.size(); 1244 int new_wp = lhs.m_wp; 1245 1246 align(lhs, rhs, new_wp, len_mant, lhs_mant, rhs_mant); 1247 1248 // 1249 // size the result mantissa 1250 // 1251 result.resize_to(len_mant); 1252 result.m_wp = new_wp; 1253 1254 // 1255 // do it 1256 // 1257 if (lhs.m_sign == rhs.m_sign) { 1258 add_mants(len_mant, result.m_mant, lhs_mant, rhs_mant); 1259 result.m_sign = lhs.m_sign; 1260 } else { 1261 int cmp = compare_abs(lhs, rhs); 1262 1263 if (cmp == 1) { 1264 sub_mants(len_mant, result.m_mant, lhs_mant, rhs_mant); 1265 result.m_sign = lhs.m_sign; 1266 } else if (cmp == -1) { 1267 sub_mants(len_mant, result.m_mant, rhs_mant, lhs_mant); 1268 result.m_sign = rhs.m_sign; 1269 } else { 1270 result.m_mant.clear(); 1271 result.m_sign = 1; 1272 } 1273 } 1274 1275 result.find_sw(); 1276 result.round(max_wl); 1277 1278 return &result; 1279} 1280 1281 1282// ---------------------------------------------------------------------------- 1283// SUB 1284// 1285// sub two word's of the same size 1286// result has the same size 1287// returns carry of operation 1288// ---------------------------------------------------------------------------- 1289 1290static inline int 1291sub_with_index(scfx_mant &a, int a_msw, int /*a_lsw*/, 1292 const scfx_mant &b, int b_msw, int b_lsw) 1293{ 1294 unsigned carry = 0; 1295 1296 int size = b_msw - b_lsw; 1297 int a_index = a_msw - size; 1298 int b_index = b_msw - size; 1299 1300 do { 1301 word x = a[a_index]; 1302 word y = b[b_index]; 1303 1304 y += carry; 1305 carry = y < carry; 1306 y = x - y; 1307 carry += y > x; 1308 a[a_index] = y; 1309 1310 a_index++; 1311 b_index++; 1312 } while (size--); 1313 1314 if (carry) { 1315 // special case: a[a_msw + 1] == 1 1316 a[a_msw + 1] = 0; 1317 } 1318 1319 return (carry ? 1 : 0); 1320} 1321 1322scfx_rep * 1323sub_scfx_rep(const scfx_rep &lhs, const scfx_rep &rhs, int max_wl) 1324{ 1325 scfx_rep &result = *new scfx_rep; 1326 1327 // 1328 // check for special cases 1329 // 1330 if (lhs.is_nan() || rhs.is_nan() || 1331 (lhs.is_inf() && rhs.is_inf() && lhs.m_sign == rhs.m_sign)) { 1332 result.set_nan(); 1333 return &result; 1334 } 1335 1336 if (lhs.is_inf()) { 1337 result.set_inf(lhs.m_sign); 1338 return &result; 1339 } 1340 1341 if (rhs.is_inf()) { 1342 result.set_inf(-1 * rhs.m_sign); 1343 return &result; 1344 } 1345 1346 // 1347 // align operands if needed 1348 // 1349 scfx_mant_ref lhs_mant; 1350 scfx_mant_ref rhs_mant; 1351 1352 int len_mant = lhs.size(); 1353 int new_wp = lhs.m_wp; 1354 1355 align(lhs, rhs, new_wp, len_mant, lhs_mant, rhs_mant); 1356 1357 // 1358 // size the result mantissa 1359 // 1360 result.resize_to(len_mant); 1361 result.m_wp = new_wp; 1362 1363 // 1364 // do it 1365 // 1366 if (lhs.m_sign != rhs.m_sign) { 1367 add_mants(len_mant, result.m_mant, lhs_mant, rhs_mant); 1368 result.m_sign = lhs.m_sign; 1369 } else { 1370 int cmp = compare_abs(lhs, rhs); 1371 1372 if (cmp == 1) { 1373 sub_mants(len_mant, result.m_mant, lhs_mant, rhs_mant); 1374 result.m_sign = lhs.m_sign; 1375 } else if (cmp == -1) { 1376 sub_mants(len_mant, result.m_mant, rhs_mant, lhs_mant); 1377 result.m_sign = -rhs.m_sign; 1378 } else { 1379 result.m_mant.clear(); 1380 result.m_sign = 1; 1381 } 1382 } 1383 1384 result.find_sw(); 1385 result.round(max_wl); 1386 1387 return &result; 1388} 1389 1390 1391// ---------------------------------------------------------------------------- 1392// MUL 1393// ---------------------------------------------------------------------------- 1394 1395union word_short 1396{ 1397 word l; 1398 struct 1399 { 1400#if defined(SC_BOOST_BIG_ENDIAN) 1401 half_word u; 1402 half_word l; 1403#elif defined(SC_BOOST_LITTLE_ENDIAN) 1404 half_word l; 1405 half_word u; 1406#endif 1407 } s; 1408}; 1409 1410#if defined(SC_BOOST_BIG_ENDIAN) 1411static const int half_word_incr = -1; 1412#elif defined(SC_BOOST_LITTLE_ENDIAN) 1413static const int half_word_incr = 1; 1414#endif 1415 1416void 1417multiply(scfx_rep &result, const scfx_rep &lhs, const scfx_rep &rhs, 1418 int max_wl) 1419{ 1420 // 1421 // check for special cases 1422 // 1423 if (lhs.is_nan() || rhs.is_nan() || 1424 (lhs.is_inf() && rhs.is_zero()) || 1425 (lhs.is_zero() && rhs.is_inf())) { 1426 result.set_nan(); 1427 return; 1428 } 1429 1430 if (lhs.is_inf() || rhs.is_inf()) { 1431 result.set_inf(lhs.m_sign * rhs.m_sign); 1432 return; 1433 } 1434 1435 if (lhs.is_zero() || rhs.is_zero()) { 1436 result.set_zero(lhs.m_sign * rhs.m_sign); 1437 return; 1438 } 1439 1440 // 1441 // do it 1442 // 1443 int len_lhs = lhs.m_msw - lhs.m_lsw + 1; 1444 int len_rhs = rhs.m_msw - rhs.m_lsw + 1; 1445 1446 int new_size = sc_max(min_mant, len_lhs + len_rhs); 1447 int new_wp = (lhs.m_wp - lhs.m_lsw) + (rhs.m_wp - rhs.m_lsw); 1448 int new_sign = lhs.m_sign * rhs.m_sign; 1449 1450 result.resize_to(new_size); 1451 result.m_mant.clear(); 1452 result.m_wp = new_wp; 1453 result.m_sign = new_sign; 1454 result.m_state = scfx_rep::normal; 1455 1456 half_word *s1 = lhs.m_mant.half_addr(lhs.m_lsw); 1457 half_word *s2 = rhs.m_mant.half_addr(rhs.m_lsw); 1458 1459 half_word *t = result.m_mant.half_addr(); 1460 1461 len_lhs <<= 1; 1462 len_rhs <<= 1; 1463 1464 int i1, i2; 1465 1466 for (i1 = 0; i1 * half_word_incr < len_lhs; i1 += half_word_incr) { 1467 word_short ls; 1468 ls.l = 0; 1469 1470 half_word v1 = s1[i1]; 1471 1472 for (i2 = 0; i2 * half_word_incr < len_rhs; i2 += half_word_incr) { 1473 ls.l += v1 * s2[i2]; 1474 ls.s.l = ls.s.u + ((t[i2] += ls.s.l) < ls.s.l); 1475 ls.s.u = 0; 1476 } 1477 1478 t[i2] = ls.s.l; 1479 t += half_word_incr; 1480 } 1481 1482 result.find_sw(); 1483 result.round(max_wl); 1484} 1485 1486 1487// ---------------------------------------------------------------------------- 1488// DIV 1489// ---------------------------------------------------------------------------- 1490 1491scfx_rep * 1492div_scfx_rep(const scfx_rep &lhs, const scfx_rep &rhs, int div_wl) 1493{ 1494 scfx_rep &result = *new scfx_rep; 1495 1496 // 1497 // check for special cases 1498 // 1499 if (lhs.is_nan() || rhs.is_nan() || (lhs.is_inf() && rhs.is_inf()) || 1500 (lhs.is_zero() && rhs.is_zero())) { 1501 result.set_nan(); 1502 return &result; 1503 } 1504 1505 if (lhs.is_inf() || rhs.is_zero()) { 1506 result.set_inf(lhs.m_sign * rhs.m_sign); 1507 return &result; 1508 } 1509 1510 if (lhs.is_zero() || rhs.is_inf()) { 1511 result.set_zero(lhs.m_sign * rhs.m_sign); 1512 return &result; 1513 } 1514 1515 // 1516 // do it 1517 // 1518 1519 // compute one bit more for rounding 1520 div_wl++; 1521 1522 result.resize_to(sc_max(n_word(div_wl) + 1, min_mant)); 1523 result.m_mant.clear(); 1524 result.m_sign = lhs.m_sign * rhs.m_sign; 1525 1526 int msb_lhs = scfx_find_msb(lhs.m_mant[lhs.m_msw]) + 1527 (lhs.m_msw - lhs.m_wp) * bits_in_word; 1528 int msb_rhs = scfx_find_msb(rhs.m_mant[rhs.m_msw]) + 1529 (rhs.m_msw - rhs.m_wp) * bits_in_word; 1530 1531 int msb_res = msb_lhs - msb_rhs; 1532 int to_shift = -msb_res % bits_in_word; 1533 int result_index; 1534 1535 int c = (msb_res % bits_in_word >= 0) ? 1 : 0; 1536 1537 result_index = (result.size() - c) * bits_in_word + msb_res % bits_in_word; 1538 result.m_wp = (result.size() - c) - msb_res / bits_in_word; 1539 1540 scfx_rep remainder = lhs; 1541 1542 // align msb from remainder to msb from rhs 1543 remainder.lshift(to_shift); 1544 1545 // make sure msw(remainder) < size - 1 1546 if (remainder.m_msw == remainder.size() - 1) 1547 remainder.resize_to(remainder.size() + 1, 1); 1548 1549 // make sure msw(remainder) >= msw(rhs)! 1550 int msw_diff = rhs.m_msw - remainder.m_msw; 1551 if (msw_diff > 0) 1552 remainder.resize_to(remainder.size() + msw_diff, -1); 1553 1554 int counter; 1555 1556 for (counter = div_wl; counter && !remainder.is_zero(); counter--) { 1557 if (compare_msw_ff(rhs, remainder) <= 0) { 1558 result.set_bin(result_index); 1559 sub_with_index(remainder.m_mant, remainder.m_msw, remainder.m_lsw, 1560 rhs.m_mant, rhs.m_msw, rhs.m_lsw); 1561 } 1562 result_index--; 1563 remainder.shift_left(1); 1564 remainder.m_lsw = remainder.find_lsw(); 1565 } 1566 1567 // perform convergent rounding, if needed 1568 if (counter == 0) { 1569 int index = result_index + 1 - result.m_wp * bits_in_word; 1570 1571 scfx_index x = result.calc_indices(index); 1572 scfx_index x1 = result.calc_indices(index + 1); 1573 1574 if (result.o_bit_at(x) && result.o_bit_at(x1)) 1575 result.q_incr(x); 1576 1577 result.m_r_flag = true; 1578 } 1579 1580 result.find_sw(); 1581 1582 return &result; 1583} 1584 1585// ---------------------------------------------------------------------------- 1586// destructive shift mantissa to the left 1587// ---------------------------------------------------------------------------- 1588 1589void 1590scfx_rep::lshift(int n) 1591{ 1592 if (n == 0) 1593 return; 1594 1595 if (n < 0) { 1596 rshift(-n); 1597 return; 1598 } 1599 1600 if (is_normal()) { 1601 int shift_bits = n % bits_in_word; 1602 int shift_words = n / bits_in_word; 1603 1604 // resize if needed 1605 if (m_msw == size() - 1 && 1606 scfx_find_msb(m_mant[m_msw]) >= bits_in_word - shift_bits) 1607 resize_to(size() + 1, 1); 1608 1609 // do it 1610 m_wp -= shift_words; 1611 shift_left(shift_bits); 1612 find_sw(); 1613 } 1614} 1615 1616// ---------------------------------------------------------------------------- 1617// destructive shift mantissa to the right 1618// ---------------------------------------------------------------------------- 1619 1620void 1621scfx_rep::rshift(int n) 1622{ 1623 if (n == 0) 1624 return; 1625 1626 if (n < 0) { 1627 lshift(-n); 1628 return; 1629 } 1630 1631 if (is_normal()) { 1632 int shift_bits = n % bits_in_word; 1633 int shift_words = n / bits_in_word; 1634 1635 // resize if needed 1636 if (m_lsw == 0 && scfx_find_lsb(m_mant[m_lsw]) < shift_bits) 1637 resize_to(size() + 1, -1); 1638 1639 // do it 1640 m_wp += shift_words; 1641 shift_right(shift_bits); 1642 find_sw(); 1643 } 1644} 1645 1646 1647// ---------------------------------------------------------------------------- 1648// FRIEND FUNCTION : compare_abs 1649// 1650// Compares the absolute values of two scfx_reps, excluding the special cases. 1651// ---------------------------------------------------------------------------- 1652 1653int 1654compare_abs(const scfx_rep &a, const scfx_rep &b) 1655{ 1656 // check for zero 1657 word a_word = a.m_mant[a.m_msw]; 1658 word b_word = b.m_mant[b.m_msw]; 1659 1660 if (a_word == 0 || b_word == 0) { 1661 if (a_word != 0) 1662 return 1; 1663 if (b_word != 0) 1664 return -1; 1665 return 0; 1666 } 1667 1668 // compare msw index 1669 int a_msw = a.m_msw - a.m_wp; 1670 int b_msw = b.m_msw - b.m_wp; 1671 1672 if (a_msw > b_msw) 1673 return 1; 1674 1675 if (a_msw < b_msw) 1676 return -1; 1677 1678 // compare content 1679 int a_i = a.m_msw; 1680 int b_i = b.m_msw; 1681 1682 while (a_i >= a.m_lsw && b_i >= b.m_lsw) { 1683 a_word = a.m_mant[a_i]; 1684 b_word = b.m_mant[b_i]; 1685 if (a_word > b_word) 1686 return 1; 1687 if (a_word < b_word) 1688 return -1; 1689 --a_i; 1690 --b_i; 1691 } 1692 1693 bool a_zero = true; 1694 while (a_i >= a.m_lsw) { 1695 a_zero = a_zero && (a.m_mant[a_i] == 0); 1696 --a_i; 1697 } 1698 1699 bool b_zero = true; 1700 while (b_i >= b.m_lsw) { 1701 b_zero = b_zero && (b.m_mant[b_i] == 0); 1702 --b_i; 1703 } 1704 1705 // assertion: a_zero || b_zero 1706 1707 if (!a_zero && b_zero) 1708 return 1; 1709 1710 if (a_zero && !b_zero) 1711 return -1; 1712 1713 return 0; 1714} 1715 1716// ---------------------------------------------------------------------------- 1717// FRIEND FUNCTION : cmp_scfx_rep 1718// 1719// Compares the values of two scfx_reps, including the special cases. 1720// ---------------------------------------------------------------------------- 1721 1722int 1723cmp_scfx_rep(const scfx_rep &a, const scfx_rep &b) 1724{ 1725 // handle special cases 1726 1727 if (a.is_nan() || b.is_nan()) { 1728 return 2; 1729 } 1730 1731 if (a.is_inf() || b.is_inf()) { 1732 if (a.is_inf()) { 1733 if (!a.is_neg()) { 1734 if (b.is_inf() && !b.is_neg()) { 1735 return 0; 1736 } else { 1737 return 1; 1738 } 1739 } else { 1740 if (b.is_inf() && b.is_neg()) { 1741 return 0; 1742 } else { 1743 return -1; 1744 } 1745 } 1746 } 1747 if (b.is_inf()) { 1748 if (!b.is_neg()) { 1749 return -1; 1750 } else { 1751 return 1; 1752 } 1753 } 1754 } 1755 1756 if (a.is_zero() && b.is_zero()) { 1757 return 0; 1758 } 1759 1760 // compare sign 1761 if (a.m_sign != b.m_sign) { 1762 return a.m_sign; 1763 } 1764 1765 return (a.m_sign * compare_abs(a, b)); 1766} 1767 1768 1769// ---------------------------------------------------------------------------- 1770// PRIVATE METHOD : quantization 1771// 1772// Performs destructive quantization. 1773// ---------------------------------------------------------------------------- 1774 1775void 1776scfx_rep::quantization(const scfx_params ¶ms, bool &q_flag) 1777{ 1778 scfx_index x = calc_indices(params.iwl() - params.wl()); 1779 1780 if (x.wi() < 0) 1781 return; 1782 1783 if (x.wi() >= size()) 1784 resize_to(x.wi() + 1, 1); 1785 1786 bool qb = q_bit(x); 1787 bool qz = q_zero(x); 1788 1789 q_flag = (qb || ! qz); 1790 1791 if (q_flag) { 1792 switch (params.q_mode()) { 1793 case SC_TRN: // truncation 1794 { 1795 if (is_neg()) 1796 q_incr(x); 1797 break; 1798 } 1799 case SC_RND: // rounding to plus infinity 1800 { 1801 if (!is_neg()) { 1802 if (qb) 1803 q_incr(x); 1804 } else { 1805 if (qb && !qz) 1806 q_incr(x); 1807 } 1808 break; 1809 } 1810 case SC_TRN_ZERO: // truncation to zero 1811 { 1812 break; 1813 } 1814 case SC_RND_INF: // rounding to infinity 1815 { 1816 if (qb) 1817 q_incr(x); 1818 break; 1819 } 1820 case SC_RND_CONV: // convergent rounding 1821 { 1822 if ((qb && !qz) || (qb && qz && q_odd(x))) 1823 q_incr(x); 1824 break; 1825 } 1826 case SC_RND_ZERO: // rounding to zero 1827 { 1828 if (qb && !qz) 1829 q_incr(x); 1830 break; 1831 } 1832 case SC_RND_MIN_INF: // rounding to minus infinity 1833 { 1834 if (!is_neg()) { 1835 if (qb && !qz) 1836 q_incr(x); 1837 } else { 1838 if (qb) 1839 q_incr(x); 1840 } 1841 break; 1842 } 1843 default: 1844 ; 1845 } 1846 q_clear(x); 1847 1848 find_sw(); 1849 } 1850} 1851 1852 1853// ---------------------------------------------------------------------------- 1854// PRIVATE METHOD : overflow 1855// 1856// Performs destructive overflow handling. 1857// ---------------------------------------------------------------------------- 1858 1859void 1860scfx_rep::overflow(const scfx_params ¶ms, bool &o_flag) 1861{ 1862 scfx_index x = calc_indices(params.iwl() - 1); 1863 1864 if (x.wi() >= size()) 1865 resize_to(x.wi() + 1, 1); 1866 1867 if (x.wi() < 0) { 1868 resize_to(size() - x.wi(), -1); 1869 x.wi(0); 1870 } 1871 1872 bool zero_left = o_zero_left(x); 1873 bool bit_at = o_bit_at(x); 1874 bool zero_right = o_zero_right(x); 1875 1876 bool under = false; 1877 bool over = false; 1878 1879 sc_enc enc = params.enc(); 1880 1881 if (enc == SC_TC_) { 1882 if (is_neg()) { 1883 if (params.o_mode() == SC_SAT_SYM) 1884 under = (!zero_left || bit_at); 1885 else 1886 under = (!zero_left || (zero_left && bit_at && ! zero_right)); 1887 } else { 1888 over = (! zero_left || bit_at); 1889 } 1890 } else { 1891 if (is_neg()) 1892 under = (!is_zero()); 1893 else 1894 over = (!zero_left); 1895 } 1896 1897 o_flag = (under || over); 1898 1899 if (o_flag) { 1900 scfx_index x2 = calc_indices(params.iwl() - params.wl()); 1901 1902 if (x2.wi() < 0) { 1903 resize_to(size() - x2.wi(), -1); 1904 x.wi(x.wi() - x2.wi()); 1905 x2.wi(0); 1906 } 1907 1908 switch (params.o_mode()) { 1909 case SC_WRAP: // wrap-around 1910 { 1911 int n_bits = params.n_bits(); 1912 1913 if (n_bits == 0) { 1914 // wrap-around all 'wl' bits 1915 toggle_tc(); 1916 o_extend(x, enc); 1917 toggle_tc(); 1918 } else if (n_bits < params.wl()) { 1919 scfx_index x3 = calc_indices(params.iwl() - 1 - n_bits); 1920 1921 // wrap-around least significant 'wl - n_bits' bits; 1922 // saturate most significant 'n_bits' bits 1923 toggle_tc(); 1924 o_set(x, x3, enc, under); 1925 o_extend(x, enc); 1926 toggle_tc(); 1927 } else { 1928 // saturate all 'wl' bits 1929 if (under) 1930 o_set_low(x, enc); 1931 else 1932 o_set_high(x, x2, enc); 1933 } 1934 break; 1935 } 1936 case SC_SAT: // saturation 1937 { 1938 if (under) 1939 o_set_low(x, enc); 1940 else 1941 o_set_high(x, x2, enc); 1942 break; 1943 } 1944 case SC_SAT_SYM: // symmetrical saturation 1945 { 1946 if (under) { 1947 if (enc == SC_TC_) 1948 o_set_high(x, x2, SC_TC_, -1); 1949 else 1950 o_set_low(x, SC_US_); 1951 } else { 1952 o_set_high(x, x2, enc); 1953 } 1954 break; 1955 } 1956 case SC_SAT_ZERO: // saturation to zero 1957 { 1958 set_zero(); 1959 break; 1960 } 1961 case SC_WRAP_SM: // sign magnitude wrap-around 1962 { 1963 SC_ERROR_IF_(enc == SC_US_, 1964 "SC_WRAP_SM not defined for unsigned numbers"); 1965 1966 int n_bits = params.n_bits(); 1967 1968 if (n_bits == 0) { 1969 scfx_index x4 = calc_indices(params.iwl()); 1970 1971 if (x4.wi() >= size()) 1972 resize_to(x4.wi() + 1, 1); 1973 1974 toggle_tc(); 1975 if (o_bit_at(x4) != o_bit_at(x)) 1976 o_invert(x2); 1977 o_extend(x, SC_TC_); 1978 toggle_tc(); 1979 } else if (n_bits == 1) { 1980 toggle_tc(); 1981 if (is_neg() != o_bit_at(x)) 1982 o_invert(x2); 1983 o_extend(x, SC_TC_); 1984 toggle_tc(); 1985 } else if (n_bits < params.wl()) { 1986 scfx_index x3 = calc_indices(params.iwl() - 1 - n_bits); 1987 scfx_index x4 = calc_indices(params.iwl() - n_bits); 1988 1989 // wrap-around least significant 'wl - n_bits' bits; 1990 // saturate most significant 'n_bits' bits 1991 toggle_tc(); 1992 if (is_neg() == o_bit_at(x4)) 1993 o_invert(x2); 1994 o_set(x, x3, SC_TC_, under); 1995 o_extend(x, SC_TC_); 1996 toggle_tc(); 1997 } else { 1998 if (under) 1999 o_set_low(x, SC_TC_); 2000 else 2001 o_set_high(x, x2, SC_TC_); 2002 } 2003 break; 2004 } 2005 default: 2006 ; 2007 } 2008 2009 find_sw(); 2010 } 2011} 2012 2013 2014// ---------------------------------------------------------------------------- 2015// PUBLIC METHOD : cast 2016// 2017// Performs a destructive cast operation on a scfx_rep. 2018// ---------------------------------------------------------------------------- 2019 2020void 2021scfx_rep::cast(const scfx_params ¶ms, bool &q_flag, bool &o_flag) 2022{ 2023 q_flag = false; 2024 o_flag = false; 2025 2026 // check for special cases 2027 if (is_zero()) { 2028 if (is_neg()) 2029 m_sign = 1; 2030 return; 2031 } 2032 2033 // perform casting 2034 quantization(params, q_flag); 2035 overflow(params, o_flag); 2036 2037 // check for special case: -0 2038 if (is_zero() && is_neg()) 2039 m_sign = 1; 2040} 2041 2042 2043// ---------------------------------------------------------------------------- 2044// make sure, the two mantissas are aligned 2045// ---------------------------------------------------------------------------- 2046 2047void 2048align(const scfx_rep &lhs, const scfx_rep &rhs, int &new_wp, 2049 int &len_mant, scfx_mant_ref &lhs_mant, scfx_mant_ref &rhs_mant) 2050{ 2051 bool need_lhs = true; 2052 bool need_rhs = true; 2053 2054 if (lhs.m_wp != rhs.m_wp || lhs.size() != rhs.size()) { 2055 int lower_bound_lhs = lhs.m_lsw - lhs.m_wp; 2056 int upper_bound_lhs = lhs.m_msw - lhs.m_wp; 2057 int lower_bound_rhs = rhs.m_lsw - rhs.m_wp; 2058 int upper_bound_rhs = rhs.m_msw - rhs.m_wp; 2059 2060 int lower_bound = sc_min(lower_bound_lhs, lower_bound_rhs); 2061 int upper_bound = sc_max(upper_bound_lhs, upper_bound_rhs); 2062 2063 new_wp = -lower_bound; 2064 len_mant = sc_max(min_mant, upper_bound - lower_bound + 1); 2065 2066 if (new_wp != lhs.m_wp || len_mant != lhs.size()) { 2067 lhs_mant = lhs.resize(len_mant, new_wp); 2068 need_lhs = false; 2069 } 2070 2071 if (new_wp != rhs.m_wp || len_mant != rhs.size()) { 2072 rhs_mant = rhs.resize(len_mant, new_wp); 2073 need_rhs = false; 2074 } 2075 } 2076 2077 if (need_lhs) { 2078 lhs_mant = lhs.m_mant; 2079 } 2080 2081 if (need_rhs) { 2082 rhs_mant = rhs.m_mant; 2083 } 2084} 2085 2086 2087// ---------------------------------------------------------------------------- 2088// compare two mantissas 2089// ---------------------------------------------------------------------------- 2090 2091int 2092compare_msw_ff(const scfx_rep &lhs, const scfx_rep &rhs) 2093{ 2094 // special case: rhs.m_mant[rhs.m_msw + 1] == 1 2095 if (rhs.m_msw < rhs.size() - 1 && rhs.m_mant[rhs.m_msw + 1 ] != 0) { 2096 return -1; 2097 } 2098 2099 int lhs_size = lhs.m_msw - lhs.m_lsw + 1; 2100 int rhs_size = rhs.m_msw - rhs.m_lsw + 1; 2101 2102 int size = sc_min(lhs_size, rhs_size); 2103 2104 int lhs_index = lhs.m_msw; 2105 int rhs_index = rhs.m_msw; 2106 2107 int i; 2108 2109 for (i = 0; 2110 i < size && lhs.m_mant[lhs_index] == rhs.m_mant[rhs_index]; 2111 i++) { 2112 lhs_index--; 2113 rhs_index--; 2114 } 2115 2116 if (i == size) { 2117 if (lhs_size == rhs_size) { 2118 return 0; 2119 } 2120 2121 if (lhs_size < rhs_size) { 2122 return -1; 2123 } else { 2124 return 1; 2125 } 2126 } 2127 2128 if (lhs.m_mant[lhs_index] < rhs.m_mant[rhs_index]) { 2129 return -1; 2130 } else { 2131 return 1; 2132 } 2133} 2134 2135 2136// ---------------------------------------------------------------------------- 2137// divide the mantissa by ten 2138// ---------------------------------------------------------------------------- 2139 2140unsigned int 2141scfx_rep::divide_by_ten() 2142{ 2143#if defined(SC_BOOST_BIG_ENDIAN) 2144 half_word *hw = (half_word *)&m_mant[m_msw]; 2145#elif defined(SC_BOOST_LITTLE_ENDIAN) 2146 half_word *hw = ((half_word *)&m_mant[m_msw]) + 1; 2147#endif 2148 2149 unsigned int remainder = 0; 2150 2151 word_short ls; 2152 ls.l = 0; 2153 2154#if defined(SC_BOOST_BIG_ENDIAN) 2155 for (int i = 0, end = (m_msw - m_wp + 1) * 2; i < end; i++) { 2156#elif defined(SC_BOOST_LITTLE_ENDIAN) 2157 for (int i = 0, end = -(m_msw - m_wp + 1) * 2; i > end; i--) { 2158#endif 2159 ls.s.u = static_cast<half_word>(remainder); 2160 ls.s.l = hw[i]; 2161 remainder = ls.l % 10; 2162 ls.l /= 10; 2163 hw[i] = ls.s.l; 2164 } 2165 2166 return remainder; 2167} 2168 2169 2170// ---------------------------------------------------------------------------- 2171// multiply the mantissa by ten 2172// ---------------------------------------------------------------------------- 2173 2174void 2175scfx_rep::multiply_by_ten() 2176{ 2177 int size = m_mant.size() + 1; 2178 2179 scfx_mant mant8(size); 2180 scfx_mant mant2(size); 2181 2182 size--; 2183 2184 mant8[size] = (m_mant[size - 1] >> (bits_in_word - 3)); 2185 mant2[size] = (m_mant[size - 1] >> (bits_in_word - 1)); 2186 2187 while (--size) { 2188 mant8[size] = (m_mant[size] << 3) | 2189 (m_mant[size - 1] >> (bits_in_word - 3)); 2190 mant2[size] = (m_mant[size] << 1) | 2191 (m_mant[size - 1] >> (bits_in_word - 1)); 2192 } 2193 2194 mant8[0] = (m_mant[0] << 3); 2195 mant2[0] = (m_mant[0] << 1); 2196 2197 add_mants(m_mant.size(), m_mant, mant8, mant2); 2198} 2199 2200 2201// ---------------------------------------------------------------------------- 2202// normalize 2203// ---------------------------------------------------------------------------- 2204 2205void 2206scfx_rep::normalize(int exponent) 2207{ 2208 int shift = exponent % bits_in_word; 2209 if (shift < 0) { 2210 shift += bits_in_word; 2211 } 2212 2213 if (shift) { 2214 shift_left(shift); 2215 } 2216 2217 find_sw(); 2218 2219 m_wp = (shift - exponent) / bits_in_word; 2220} 2221 2222 2223// ---------------------------------------------------------------------------- 2224// return a new mantissa that is aligned and resized 2225// ---------------------------------------------------------------------------- 2226 2227scfx_mant * 2228scfx_rep::resize(int new_size, int new_wp) const 2229{ 2230 scfx_mant *result = new scfx_mant(new_size); 2231 2232 result->clear(); 2233 2234 int shift = new_wp - m_wp; 2235 2236 for (int j = m_lsw; j <= m_msw; j++) { 2237 (*result)[j + shift] = m_mant[j]; 2238 } 2239 2240 return result; 2241} 2242 2243 2244// ---------------------------------------------------------------------------- 2245// set a single bit 2246// ---------------------------------------------------------------------------- 2247 2248void 2249scfx_rep::set_bin(int i) 2250{ 2251 m_mant[i >> 5] |= 1 << (i & 31); 2252} 2253 2254 2255// ---------------------------------------------------------------------------- 2256// set three bits 2257// ---------------------------------------------------------------------------- 2258 2259void 2260scfx_rep::set_oct(int i, int n) 2261{ 2262 if (n & 1) { 2263 m_mant[i >> 5] |= 1 << (i & 31); 2264 } 2265 i++; 2266 if (n & 2) { 2267 m_mant[i >> 5] |= 1 << (i & 31); 2268 } 2269 i++; 2270 if (n & 4) { 2271 m_mant[i >> 5] |= 1 << (i & 31); 2272 } 2273} 2274 2275 2276// ---------------------------------------------------------------------------- 2277// set four bits 2278// ---------------------------------------------------------------------------- 2279 2280void 2281scfx_rep::set_hex(int i, int n) 2282{ 2283 if (n & 1) { 2284 m_mant[i >> 5] |= 1 << (i & 31); 2285 } 2286 i++; 2287 if (n & 2) { 2288 m_mant[i >> 5] |= 1 << (i & 31); 2289 } 2290 i++; 2291 if (n & 4) { 2292 m_mant[i >> 5] |= 1 << (i & 31); 2293 } 2294 i++; 2295 if (n & 8) { 2296 m_mant[i >> 5] |= 1 << (i & 31); 2297 } 2298} 2299 2300 2301// ---------------------------------------------------------------------------- 2302// PRIVATE METHOD : shift_left 2303// 2304// Shifts a scfx_rep to the left by a MAXIMUM of bits_in_word - 1 bits. 2305// ---------------------------------------------------------------------------- 2306 2307void 2308scfx_rep::shift_left(int n) 2309{ 2310 if (n != 0) { 2311 int shift_left = n; 2312 int shift_right = bits_in_word - n; 2313 2314 SC_ASSERT_(!(m_mant[size() - 1] >> shift_right), 2315 "shift_left overflow"); 2316 2317 for (int i = size() - 1; i > 0; i--) { 2318 m_mant[i] = (m_mant[i] << shift_left) | 2319 (m_mant[i - 1] >> shift_right); 2320 } 2321 m_mant[0] <<= shift_left; 2322 } 2323} 2324 2325 2326// ---------------------------------------------------------------------------- 2327// PRIVATE METHOD : shift_right 2328// 2329// Shifts a scfx_rep to the right by a MAXIMUM of bits_in_word - 1 bits. 2330// ---------------------------------------------------------------------------- 2331 2332void 2333scfx_rep::shift_right(int n) 2334{ 2335 if (n != 0) { 2336 int shift_left = bits_in_word - n; 2337 int shift_right = n; 2338 2339 SC_ASSERT_(!(m_mant[0] << shift_left), "shift_right overflow"); 2340 2341 for (int i = 0; i < size() - 1; i++) { 2342 m_mant[i] = (m_mant[i] >> shift_right) | 2343 (m_mant[i + 1] << shift_left); 2344 } 2345 m_mant[size() - 1] >>= shift_right; 2346 } 2347} 2348 2349 2350// ---------------------------------------------------------------------------- 2351// METHOD : get_bit 2352// 2353// Tests a bit, in two's complement. 2354// ---------------------------------------------------------------------------- 2355 2356bool 2357scfx_rep::get_bit(int i) const 2358{ 2359 if (!is_normal()) 2360 return false; 2361 2362 scfx_index x = calc_indices(i); 2363 2364 if (x.wi() >= size()) 2365 return is_neg(); 2366 2367 if (x.wi() < 0) 2368 return false; 2369 2370 const_cast<scfx_rep*>(this)->toggle_tc(); 2371 2372 bool result = (m_mant[x.wi()] & (1 << x.bi())) != 0; 2373 2374 const_cast<scfx_rep *>(this)->toggle_tc(); 2375 2376 return result; 2377} 2378 2379 2380// ---------------------------------------------------------------------------- 2381// METHOD : set 2382// 2383// Sets a bit, in two's complement, between iwl-1 and -fwl. 2384// ---------------------------------------------------------------------------- 2385 2386bool 2387scfx_rep::set(int i, const scfx_params ¶ms) 2388{ 2389 if (!is_normal()) 2390 return false; 2391 2392 scfx_index x = calc_indices(i); 2393 2394 if (x.wi() >= size()) { 2395 if (is_neg()) 2396 return true; 2397 else 2398 resize_to(x.wi() + 1, 1); 2399 } else if (x.wi() < 0) { 2400 resize_to(size() - x.wi(), -1); 2401 x.wi(0); 2402 } 2403 2404 toggle_tc(); 2405 2406 m_mant[x.wi()] |= 1 << x.bi(); 2407 2408 if (i == params.iwl() - 1) 2409 o_extend(x, params.enc()); // sign extension 2410 2411 toggle_tc(); 2412 2413 find_sw(); 2414 2415 return true; 2416} 2417 2418 2419// ---------------------------------------------------------------------------- 2420// METHOD : clear 2421// 2422// Clears a bit, in two's complement, between iwl-1 and -fwl. 2423// ---------------------------------------------------------------------------- 2424 2425bool 2426scfx_rep::clear(int i, const scfx_params ¶ms) 2427{ 2428 if (!is_normal()) 2429 return false; 2430 2431 scfx_index x = calc_indices(i); 2432 2433 if (x.wi() >= size()) { 2434 if (!is_neg()) 2435 return true; 2436 else 2437 resize_to(x.wi() + 1, 1); 2438 } else if (x.wi() < 0) { 2439 return true; 2440 } 2441 2442 toggle_tc(); 2443 2444 m_mant[x.wi()] &= ~(1 << x.bi()); 2445 2446 if (i == params.iwl() - 1) 2447 o_extend(x, params.enc()); // sign extension 2448 2449 toggle_tc(); 2450 2451 find_sw(); 2452 2453 return true; 2454} 2455 2456 2457// ---------------------------------------------------------------------------- 2458// METHOD : get_slice 2459// ---------------------------------------------------------------------------- 2460 2461bool 2462scfx_rep::get_slice(int i, int j, const scfx_params &, sc_bv_base &bv) const 2463{ 2464 if (is_nan() || is_inf()) 2465 return false; 2466 2467 // get the bits 2468 2469 int l = j; 2470 for (int k = 0; k < bv.length(); ++k) { 2471 bv[k] = get_bit(l); 2472 2473 if (i >= j) 2474 ++l; 2475 else 2476 --l; 2477 } 2478 2479 return true; 2480} 2481 2482bool 2483scfx_rep::set_slice(int i, int j, const scfx_params ¶ms, 2484 const sc_bv_base &bv) 2485{ 2486 if (is_nan() || is_inf()) 2487 return false; 2488 2489 // set the bits 2490 int l = j; 2491 for (int k = 0; k < bv.length(); ++k) { 2492 if (bv[k].to_bool()) 2493 set(l, params); 2494 else 2495 clear(l, params); 2496 2497 if (i >= j) 2498 ++l; 2499 else 2500 --l; 2501 } 2502 2503 return true; 2504} 2505 2506 2507// ---------------------------------------------------------------------------- 2508// METHOD : print 2509// ---------------------------------------------------------------------------- 2510 2511void 2512scfx_rep::print(::std::ostream &os) const 2513{ 2514 os << to_string(SC_DEC, -1, SC_E); 2515} 2516 2517 2518// ---------------------------------------------------------------------------- 2519// METHOD : dump 2520// ---------------------------------------------------------------------------- 2521 2522void 2523scfx_rep::dump(::std::ostream &os) const 2524{ 2525 os << "scfx_rep" << ::std::endl; 2526 os << "(" << ::std::endl; 2527 2528 os << "mant =" << ::std::endl; 2529 for (int i = size() - 1; i >= 0; i--) { 2530 char buf[BUFSIZ]; 2531 std::sprintf(buf, " %d: %10u (%8x)", i, 2532 (int)m_mant[i], (int)m_mant[i]); 2533 os << buf << ::std::endl; 2534 } 2535 2536 os << "wp = " << m_wp << ::std::endl; 2537 os << "sign = " << m_sign << ::std::endl; 2538 2539 os << "state = "; 2540 switch (m_state) { 2541 case normal: 2542 os << "normal"; 2543 break; 2544 case infinity: 2545 os << "infinity"; 2546 break; 2547 case not_a_number: 2548 os << "not_a_number"; 2549 break; 2550 default: 2551 os << "unknown"; 2552 } 2553 os << ::std::endl; 2554 2555 os << "msw = " << m_msw << ::std::endl; 2556 os << "lsw = " << m_lsw << ::std::endl; 2557 2558 os << ")" << ::std::endl; 2559} 2560 2561 2562// ---------------------------------------------------------------------------- 2563// METHOD : get_type 2564// ---------------------------------------------------------------------------- 2565 2566void 2567scfx_rep::get_type(int &wl, int &iwl, sc_enc &enc) const 2568{ 2569 if (is_nan() || is_inf()) { 2570 wl = 0; 2571 iwl = 0; 2572 enc = SC_TC_; 2573 return; 2574 } 2575 2576 if (is_zero()) { 2577 wl = 1; 2578 iwl = 1; 2579 enc = SC_US_; 2580 return; 2581 } 2582 2583 int msb = (m_msw - m_wp) * bits_in_word + 2584 scfx_find_msb(m_mant[ m_msw ]) + 1; 2585 while (get_bit(msb) == get_bit(msb - 1)) { 2586 --msb; 2587 } 2588 2589 int lsb = (m_lsw - m_wp) * bits_in_word + 2590 scfx_find_lsb(m_mant[m_lsw]); 2591 2592 if (is_neg()) { 2593 wl = msb - lsb + 1; 2594 iwl = msb + 1; 2595 enc = SC_TC_; 2596 } else { 2597 wl = msb - lsb; 2598 iwl = msb; 2599 enc = SC_US_; 2600 } 2601} 2602 2603 2604// ---------------------------------------------------------------------------- 2605// PRIVATE METHOD : round 2606// 2607// Performs convergent rounding (rounding to even) as in floating-point. 2608// ---------------------------------------------------------------------------- 2609 2610void 2611scfx_rep::round(int wl) 2612{ 2613 // check for special cases 2614 2615 if (is_nan() || is_inf() || is_zero()) 2616 return; 2617 2618 // estimate effective wordlength and compare 2619 int wl_effective; 2620 wl_effective = (m_msw - m_lsw + 1) * bits_in_word; 2621 if (wl_effective <= wl) 2622 return; 2623 2624 // calculate effective wordlength and compare 2625 int msb = scfx_find_msb(m_mant[m_msw]); 2626 int lsb = scfx_find_lsb(m_mant[m_lsw]); 2627 wl_effective = (m_msw * bits_in_word + msb) - 2628 (m_lsw * bits_in_word + lsb) + 1; 2629 if (wl_effective <= wl) 2630 return; 2631 2632 // perform rounding 2633 int wi = m_msw - (wl - 1) / bits_in_word; 2634 int bi = msb - (wl - 1) % bits_in_word; 2635 if (bi < 0) { 2636 --wi; 2637 bi += bits_in_word; 2638 } 2639 2640 scfx_index x(wi, bi); 2641 2642 if ((q_bit(x) && ! q_zero(x)) || (q_bit(x) && q_zero(x) && q_odd(x))) { 2643 q_incr(x); 2644 } 2645 q_clear(x); 2646 2647 find_sw(); 2648 2649 m_r_flag = true; 2650} 2651 2652} // namespace sc_dt 2653