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