00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045 #ifndef SC_FXVAL_H
00046 #define SC_FXVAL_H
00047
00048
00049 #include "sysc/datatypes/fx/scfx_rep.h"
00050 #ifndef SC_FX_EXCLUDE_OTHER
00051 #include "sysc/datatypes/int/sc_int_base.h"
00052 #include "sysc/datatypes/int/sc_uint_base.h"
00053 #include "sysc/datatypes/int/sc_signed.h"
00054 #include "sysc/datatypes/int/sc_unsigned.h"
00055 #endif
00056 #include "sysc/datatypes/fx/sc_fxval_observer.h"
00057
00058
00059 namespace sc_dt
00060 {
00061
00062
00063 class sc_fxval;
00064 class sc_fxval_fast;
00065
00066
00067 class sc_fxnum;
00068 class sc_fxnum_fast;
00069
00070
00071
00072
00073
00074
00075
00076
00077 class sc_fxval
00078 {
00079
00080 friend class sc_fxnum;
00081
00082 protected:
00083
00084 sc_fxval_observer* observer() const;
00085
00086 public:
00087
00088
00089 sc_fxval( scfx_rep* );
00090
00091
00092 explicit sc_fxval( sc_fxval_observer* = 0 );
00093 sc_fxval( int,
00094 sc_fxval_observer* = 0 );
00095 sc_fxval( unsigned int,
00096 sc_fxval_observer* = 0 );
00097 sc_fxval( long,
00098 sc_fxval_observer* = 0 );
00099 sc_fxval( unsigned long,
00100 sc_fxval_observer* = 0 );
00101 sc_fxval( double,
00102 sc_fxval_observer* = 0 );
00103 sc_fxval( const char*,
00104 sc_fxval_observer* = 0 );
00105 sc_fxval( const sc_fxval&,
00106 sc_fxval_observer* = 0 );
00107 sc_fxval( const sc_fxval_fast&,
00108 sc_fxval_observer* = 0 );
00109 sc_fxval( const sc_fxnum&,
00110 sc_fxval_observer* = 0 );
00111 sc_fxval( const sc_fxnum_fast&,
00112 sc_fxval_observer* = 0 );
00113 #ifndef SC_FX_EXCLUDE_OTHER
00114 explicit sc_fxval( int64,
00115 sc_fxval_observer* = 0 );
00116 explicit sc_fxval( uint64,
00117 sc_fxval_observer* = 0 );
00118 explicit sc_fxval( const sc_int_base&,
00119 sc_fxval_observer* = 0 );
00120 explicit sc_fxval( const sc_uint_base&,
00121 sc_fxval_observer* = 0 );
00122 explicit sc_fxval( const sc_signed&,
00123 sc_fxval_observer* = 0 );
00124 explicit sc_fxval( const sc_unsigned&,
00125 sc_fxval_observer* = 0 );
00126 #endif
00127
00128 ~sc_fxval();
00129
00130
00131
00132 const scfx_rep* get_rep() const;
00133 void set_rep( scfx_rep* );
00134
00135
00136
00137
00138 const sc_fxval operator - () const;
00139 const sc_fxval& operator + () const;
00140
00141
00142
00143
00144 friend void neg( sc_fxval&, const sc_fxval& );
00145
00146
00147
00148
00149 #define DECL_BIN_OP_T(op,tp) \
00150 friend const sc_fxval operator op ( const sc_fxval&, tp ); \
00151 friend const sc_fxval operator op ( tp, const sc_fxval& );
00152
00153 #ifndef SC_FX_EXCLUDE_OTHER
00154 #define DECL_BIN_OP_OTHER(op) \
00155 DECL_BIN_OP_T(op,int64) \
00156 DECL_BIN_OP_T(op,uint64) \
00157 DECL_BIN_OP_T(op,const sc_int_base&) \
00158 DECL_BIN_OP_T(op,const sc_uint_base&) \
00159 DECL_BIN_OP_T(op,const sc_signed&) \
00160 DECL_BIN_OP_T(op,const sc_unsigned&)
00161 #else
00162 #define DECL_BIN_OP_OTHER(op)
00163 #endif
00164
00165 #define DECL_BIN_OP(op,dummy) \
00166 friend const sc_fxval operator op ( const sc_fxval&, const sc_fxval& ); \
00167 DECL_BIN_OP_T(op,int) \
00168 DECL_BIN_OP_T(op,unsigned int) \
00169 DECL_BIN_OP_T(op,long) \
00170 DECL_BIN_OP_T(op,unsigned long) \
00171 DECL_BIN_OP_T(op,double) \
00172 DECL_BIN_OP_T(op,const char*) \
00173 DECL_BIN_OP_T(op,const sc_fxval_fast&) \
00174 DECL_BIN_OP_T(op,const sc_fxnum_fast&) \
00175 DECL_BIN_OP_OTHER(op)
00176
00177 DECL_BIN_OP(*,mult)
00178 DECL_BIN_OP(+,add)
00179 DECL_BIN_OP(-,sub)
00180
00181
00182
00183 friend const sc_fxval operator / ( const sc_fxval&, const sc_fxval& );
00184 DECL_BIN_OP_T(/,int)
00185 DECL_BIN_OP_T(/,unsigned int)
00186 DECL_BIN_OP_T(/,long)
00187 DECL_BIN_OP_T(/,unsigned long)
00188 DECL_BIN_OP_T(/,double)
00189 DECL_BIN_OP_T(/,const char*)
00190 DECL_BIN_OP_T(/,const sc_fxval_fast&)
00191 DECL_BIN_OP_T(/,const sc_fxnum_fast&)
00192
00193 #ifndef SC_FX_EXCLUDE_OTHER
00194 DECL_BIN_OP_T(/,int64) \
00195 DECL_BIN_OP_T(/,uint64) \
00196 DECL_BIN_OP_T(/,const sc_int_base&) \
00197 DECL_BIN_OP_T(/,const sc_uint_base&) \
00198 DECL_BIN_OP_T(/,const sc_signed&) \
00199 DECL_BIN_OP_T(/,const sc_unsigned&)
00200 #endif
00201
00202
00203 #undef DECL_BIN_OP_T
00204 #undef DECL_BIN_OP_OTHER
00205 #undef DECL_BIN_OP
00206
00207 friend const sc_fxval operator << ( const sc_fxval&, int );
00208 friend const sc_fxval operator >> ( const sc_fxval&, int );
00209
00210
00211
00212
00213 #define DECL_BIN_FNC_T(fnc,tp) \
00214 friend void fnc ( sc_fxval&, const sc_fxval&, tp ); \
00215 friend void fnc ( sc_fxval&, tp, const sc_fxval& );
00216
00217 #ifndef SC_FX_EXCLUDE_OTHER
00218 #define DECL_BIN_FNC_OTHER(fnc) \
00219 DECL_BIN_FNC_T(fnc,int64) \
00220 DECL_BIN_FNC_T(fnc,uint64) \
00221 DECL_BIN_FNC_T(fnc,const sc_int_base&) \
00222 DECL_BIN_FNC_T(fnc,const sc_uint_base&) \
00223 DECL_BIN_FNC_T(fnc,const sc_signed&) \
00224 DECL_BIN_FNC_T(fnc,const sc_unsigned&)
00225 #else
00226 #define DECL_BIN_FNC_OTHER(fnc)
00227 #endif
00228
00229 #define DECL_BIN_FNC(fnc) \
00230 friend void fnc ( sc_fxval&, const sc_fxval&, const sc_fxval& ); \
00231 DECL_BIN_FNC_T(fnc,int) \
00232 DECL_BIN_FNC_T(fnc,unsigned int) \
00233 DECL_BIN_FNC_T(fnc,long) \
00234 DECL_BIN_FNC_T(fnc,unsigned long) \
00235 DECL_BIN_FNC_T(fnc,double) \
00236 DECL_BIN_FNC_T(fnc,const char*) \
00237 DECL_BIN_FNC_T(fnc,const sc_fxval_fast&) \
00238 DECL_BIN_FNC_T(fnc,const sc_fxnum_fast&) \
00239 DECL_BIN_FNC_OTHER(fnc)
00240
00241 DECL_BIN_FNC(mult)
00242 DECL_BIN_FNC(div)
00243 DECL_BIN_FNC(add)
00244 DECL_BIN_FNC(sub)
00245
00246 #undef DECL_BIN_FNC_T
00247 #undef DECL_BIN_FNC_OTHER
00248 #undef DECL_BIN_FNC
00249
00250 friend void lshift( sc_fxval&, const sc_fxval&, int );
00251 friend void rshift( sc_fxval&, const sc_fxval&, int );
00252
00253
00254
00255
00256 #define DECL_REL_OP_T(op,tp) \
00257 friend bool operator op ( const sc_fxval&, tp ); \
00258 friend bool operator op ( tp, const sc_fxval& );
00259
00260 #ifndef SC_FX_EXCLUDE_OTHER
00261 #define DECL_REL_OP_OTHER(op) \
00262 DECL_REL_OP_T(op,int64) \
00263 DECL_REL_OP_T(op,uint64) \
00264 DECL_REL_OP_T(op,const sc_int_base&) \
00265 DECL_REL_OP_T(op,const sc_uint_base&) \
00266 DECL_REL_OP_T(op,const sc_signed&) \
00267 DECL_REL_OP_T(op,const sc_unsigned&)
00268 #else
00269 #define DECL_REL_OP_OTHER(op)
00270 #endif
00271
00272 #define DECL_REL_OP(op) \
00273 friend bool operator op ( const sc_fxval&, const sc_fxval& ); \
00274 DECL_REL_OP_T(op,int) \
00275 DECL_REL_OP_T(op,unsigned int) \
00276 DECL_REL_OP_T(op,long) \
00277 DECL_REL_OP_T(op,unsigned long) \
00278 DECL_REL_OP_T(op,double) \
00279 DECL_REL_OP_T(op,const char*) \
00280 DECL_REL_OP_T(op,const sc_fxval_fast&) \
00281 DECL_REL_OP_T(op,const sc_fxnum_fast&) \
00282 DECL_REL_OP_OTHER(op)
00283
00284 DECL_REL_OP(<)
00285 DECL_REL_OP(<=)
00286 DECL_REL_OP(>)
00287 DECL_REL_OP(>=)
00288 DECL_REL_OP(==)
00289 DECL_REL_OP(!=)
00290
00291 #undef DECL_REL_OP_T
00292 #undef DECL_REL_OP_OTHER
00293 #undef DECL_REL_OP
00294
00295
00296
00297
00298 #define DECL_ASN_OP_T(op,tp) \
00299 sc_fxval& operator op( tp );
00300
00301 #ifndef SC_FX_EXCLUDE_OTHER
00302 #define DECL_ASN_OP_OTHER(op) \
00303 DECL_ASN_OP_T(op,int64) \
00304 DECL_ASN_OP_T(op,uint64) \
00305 DECL_ASN_OP_T(op,const sc_int_base&) \
00306 DECL_ASN_OP_T(op,const sc_uint_base&) \
00307 DECL_ASN_OP_T(op,const sc_signed&) \
00308 DECL_ASN_OP_T(op,const sc_unsigned&)
00309 #else
00310 #define DECL_ASN_OP_OTHER(op)
00311 #endif
00312
00313 #define DECL_ASN_OP(op) \
00314 DECL_ASN_OP_T(op,int) \
00315 DECL_ASN_OP_T(op,unsigned int) \
00316 DECL_ASN_OP_T(op,long) \
00317 DECL_ASN_OP_T(op,unsigned long) \
00318 DECL_ASN_OP_T(op,double) \
00319 DECL_ASN_OP_T(op,const char*) \
00320 DECL_ASN_OP_T(op,const sc_fxval&) \
00321 DECL_ASN_OP_T(op,const sc_fxval_fast&) \
00322 DECL_ASN_OP_T(op,const sc_fxnum&) \
00323 DECL_ASN_OP_T(op,const sc_fxnum_fast&) \
00324 DECL_ASN_OP_OTHER(op)
00325
00326 DECL_ASN_OP(=)
00327
00328 DECL_ASN_OP(*=)
00329 DECL_ASN_OP(/=)
00330 DECL_ASN_OP(+=)
00331 DECL_ASN_OP(-=)
00332
00333 DECL_ASN_OP_T(<<=,int)
00334 DECL_ASN_OP_T(>>=,int)
00335
00336 #undef DECL_ASN_OP_T
00337 #undef DECL_ASN_OP_OTHER
00338 #undef DECL_ASN_OP
00339
00340
00341
00342
00343 const sc_fxval operator ++ ( int );
00344 const sc_fxval operator -- ( int );
00345
00346 sc_fxval& operator ++ ();
00347 sc_fxval& operator -- ();
00348
00349
00350
00351
00352 operator double() const;
00353
00354
00355
00356
00357 short to_short() const;
00358 unsigned short to_ushort() const;
00359 int to_int() const;
00360 unsigned int to_uint() const;
00361 long to_long() const;
00362 unsigned long to_ulong() const;
00363 int64 to_int64() const;
00364 uint64 to_uint64() const;
00365 float to_float() const;
00366 double to_double() const;
00367
00368
00369
00370
00371 const std::string to_string() const;
00372 const std::string to_string( sc_numrep ) const;
00373 const std::string to_string( sc_numrep, bool ) const;
00374 const std::string to_string( sc_fmt ) const;
00375 const std::string to_string( sc_numrep, sc_fmt ) const;
00376 const std::string to_string( sc_numrep, bool, sc_fmt ) const;
00377
00378 const std::string to_dec() const;
00379 const std::string to_bin() const;
00380 const std::string to_oct() const;
00381 const std::string to_hex() const;
00382
00383
00384
00385
00386 bool is_neg() const;
00387 bool is_zero() const;
00388 bool is_nan() const;
00389 bool is_inf() const;
00390 bool is_normal() const;
00391
00392 bool rounding_flag() const;
00393
00394
00395
00396
00397 void print( ::std::ostream& = ::std::cout ) const;
00398 void scan( ::std::istream& = ::std::cin );
00399 void dump( ::std::ostream& = ::std::cout ) const;
00400
00401
00402
00403 bool get_bit( int ) const;
00404
00405 protected:
00406
00407 sc_fxval_observer* lock_observer() const;
00408 void unlock_observer( sc_fxval_observer* ) const;
00409
00410
00411 void get_type( int&, int&, sc_enc& ) const;
00412
00413 const sc_fxval quantization( const scfx_params&, bool& ) const;
00414 const sc_fxval overflow( const scfx_params&, bool& ) const;
00415
00416 private:
00417
00418 scfx_rep* m_rep;
00419
00420 mutable sc_fxval_observer* m_observer;
00421
00422 };
00423
00424
00425
00426
00427
00428
00429
00430
00431 class sc_fxval_fast
00432 {
00433
00434 friend class sc_fxnum_fast;
00435
00436 protected:
00437
00438 sc_fxval_fast_observer* observer() const;
00439
00440 public:
00441
00442 explicit sc_fxval_fast( sc_fxval_fast_observer* = 0 );
00443 sc_fxval_fast( int,
00444 sc_fxval_fast_observer* = 0 );
00445 sc_fxval_fast( unsigned int,
00446 sc_fxval_fast_observer* = 0 );
00447 sc_fxval_fast( long,
00448 sc_fxval_fast_observer* = 0 );
00449 sc_fxval_fast( unsigned long,
00450 sc_fxval_fast_observer* = 0 );
00451 sc_fxval_fast( double,
00452 sc_fxval_fast_observer* = 0 );
00453 sc_fxval_fast( const char*,
00454 sc_fxval_fast_observer* = 0 );
00455 sc_fxval_fast( const sc_fxval&,
00456 sc_fxval_fast_observer* = 0 );
00457 sc_fxval_fast( const sc_fxval_fast&,
00458 sc_fxval_fast_observer* = 0 );
00459 sc_fxval_fast( const sc_fxnum&,
00460 sc_fxval_fast_observer* = 0 );
00461 sc_fxval_fast( const sc_fxnum_fast&,
00462 sc_fxval_fast_observer* = 0 );
00463 #ifndef SC_FX_EXCLUDE_OTHER
00464 explicit sc_fxval_fast( int64,
00465 sc_fxval_fast_observer* = 0 );
00466 explicit sc_fxval_fast( uint64,
00467 sc_fxval_fast_observer* = 0 );
00468 explicit sc_fxval_fast( const sc_int_base&,
00469 sc_fxval_fast_observer* = 0 );
00470 explicit sc_fxval_fast( const sc_uint_base&,
00471 sc_fxval_fast_observer* = 0 );
00472 explicit sc_fxval_fast( const sc_signed&,
00473 sc_fxval_fast_observer* = 0 );
00474 explicit sc_fxval_fast( const sc_unsigned&,
00475 sc_fxval_fast_observer* = 0 );
00476 #endif
00477
00478 ~sc_fxval_fast();
00479
00480
00481 double get_val() const;
00482 void set_val( double );
00483
00484
00485
00486
00487 const sc_fxval_fast operator - () const;
00488 const sc_fxval_fast& operator + () const;
00489
00490
00491
00492
00493 friend void neg( sc_fxval_fast&, const sc_fxval_fast& );
00494
00495
00496
00497
00498 #define DECL_BIN_OP_T(op,tp) \
00499 friend const sc_fxval_fast operator op ( const sc_fxval_fast&, tp ); \
00500 friend const sc_fxval_fast operator op ( tp, const sc_fxval_fast& );
00501
00502 #ifndef SC_FX_EXCLUDE_OTHER
00503 #define DECL_BIN_OP_OTHER(op) \
00504 DECL_BIN_OP_T(op,int64) \
00505 DECL_BIN_OP_T(op,uint64) \
00506 DECL_BIN_OP_T(op,const sc_int_base&) \
00507 DECL_BIN_OP_T(op,const sc_uint_base&) \
00508 DECL_BIN_OP_T(op,const sc_signed&) \
00509 DECL_BIN_OP_T(op,const sc_unsigned&)
00510 #else
00511 #define DECL_BIN_OP_OTHER(op)
00512 #endif
00513
00514 #define DECL_BIN_OP(op,dummy) \
00515 friend const sc_fxval_fast operator op ( const sc_fxval_fast&, \
00516 const sc_fxval_fast& ); \
00517 DECL_BIN_OP_T(op,int) \
00518 DECL_BIN_OP_T(op,unsigned int) \
00519 DECL_BIN_OP_T(op,long) \
00520 DECL_BIN_OP_T(op,unsigned long) \
00521 DECL_BIN_OP_T(op,double) \
00522 DECL_BIN_OP_T(op,const char*) \
00523 DECL_BIN_OP_OTHER(op)
00524
00525 DECL_BIN_OP(*,mult)
00526 DECL_BIN_OP(+,add)
00527 DECL_BIN_OP(-,sub)
00528
00529
00530 friend const sc_fxval_fast operator / ( const sc_fxval_fast&,
00531 const sc_fxval_fast& );
00532 DECL_BIN_OP_T(/,int)
00533 DECL_BIN_OP_T(/,unsigned int)
00534 DECL_BIN_OP_T(/,long)
00535 DECL_BIN_OP_T(/,unsigned long)
00536 DECL_BIN_OP_T(/,double)
00537 DECL_BIN_OP_T(/,const char*)
00538
00539 #ifndef SC_FX_EXCLUDE_OTHER
00540 DECL_BIN_OP_T(/,int64) \
00541 DECL_BIN_OP_T(/,uint64) \
00542 DECL_BIN_OP_T(/,const sc_int_base&) \
00543 DECL_BIN_OP_T(/,const sc_uint_base&) \
00544 DECL_BIN_OP_T(/,const sc_signed&) \
00545 DECL_BIN_OP_T(/,const sc_unsigned&)
00546 #endif
00547
00548 #undef DECL_BIN_OP_T
00549 #undef DECL_BIN_OP_OTHER
00550 #undef DECL_BIN_OP
00551
00552 friend const sc_fxval_fast operator << ( const sc_fxval_fast&, int );
00553 friend const sc_fxval_fast operator >> ( const sc_fxval_fast&, int );
00554
00555
00556
00557
00558 #define DECL_BIN_FNC_T(fnc,tp) \
00559 friend void fnc ( sc_fxval_fast&, const sc_fxval_fast&, tp ); \
00560 friend void fnc ( sc_fxval_fast&, tp, const sc_fxval_fast& );
00561
00562 #ifndef SC_FX_EXCLUDE_OTHER
00563 #define DECL_BIN_FNC_OTHER(fnc) \
00564 DECL_BIN_FNC_T(fnc,int64) \
00565 DECL_BIN_FNC_T(fnc,uint64) \
00566 DECL_BIN_FNC_T(fnc,const sc_int_base&) \
00567 DECL_BIN_FNC_T(fnc,const sc_uint_base&) \
00568 DECL_BIN_FNC_T(fnc,const sc_signed&) \
00569 DECL_BIN_FNC_T(fnc,const sc_unsigned&)
00570 #else
00571 #define DECL_BIN_FNC_OTHER(fnc)
00572 #endif
00573
00574 #define DECL_BIN_FNC(fnc) \
00575 friend void fnc ( sc_fxval_fast&, const sc_fxval_fast&, \
00576 const sc_fxval_fast& ); \
00577 DECL_BIN_FNC_T(fnc,int) \
00578 DECL_BIN_FNC_T(fnc,unsigned int) \
00579 DECL_BIN_FNC_T(fnc,long) \
00580 DECL_BIN_FNC_T(fnc,unsigned long) \
00581 DECL_BIN_FNC_T(fnc,double) \
00582 DECL_BIN_FNC_T(fnc,const char*) \
00583 DECL_BIN_FNC_T(fnc,const sc_fxval&) \
00584 DECL_BIN_FNC_T(fnc,const sc_fxnum&) \
00585 DECL_BIN_FNC_OTHER(fnc)
00586
00587 DECL_BIN_FNC(mult)
00588 DECL_BIN_FNC(div)
00589 DECL_BIN_FNC(add)
00590 DECL_BIN_FNC(sub)
00591
00592 #undef DECL_BIN_FNC_T
00593 #undef DECL_BIN_FNC_OTHER
00594 #undef DECL_BIN_FNC
00595
00596 friend void lshift( sc_fxval_fast&, const sc_fxval_fast&, int );
00597 friend void rshift( sc_fxval_fast&, const sc_fxval_fast&, int );
00598
00599
00600
00601
00602 #define DECL_REL_OP_T(op,tp) \
00603 friend bool operator op ( const sc_fxval_fast&, tp ); \
00604 friend bool operator op ( tp, const sc_fxval_fast& );
00605
00606 #ifndef SC_FX_EXCLUDE_OTHER
00607 #define DECL_REL_OP_OTHER(op) \
00608 DECL_REL_OP_T(op,int64) \
00609 DECL_REL_OP_T(op,uint64) \
00610 DECL_REL_OP_T(op,const sc_int_base&) \
00611 DECL_REL_OP_T(op,const sc_uint_base&) \
00612 DECL_REL_OP_T(op,const sc_signed&) \
00613 DECL_REL_OP_T(op,const sc_unsigned&)
00614 #else
00615 #define DECL_REL_OP_OTHER(op)
00616 #endif
00617
00618 #define DECL_REL_OP(op) \
00619 friend bool operator op ( const sc_fxval_fast&, const sc_fxval_fast& ); \
00620 DECL_REL_OP_T(op,int) \
00621 DECL_REL_OP_T(op,unsigned int) \
00622 DECL_REL_OP_T(op,long) \
00623 DECL_REL_OP_T(op,unsigned long) \
00624 DECL_REL_OP_T(op,double) \
00625 DECL_REL_OP_T(op,const char*) \
00626 DECL_REL_OP_OTHER(op)
00627
00628 DECL_REL_OP(<)
00629 DECL_REL_OP(<=)
00630 DECL_REL_OP(>)
00631 DECL_REL_OP(>=)
00632 DECL_REL_OP(==)
00633 DECL_REL_OP(!=)
00634
00635 #undef DECL_REL_OP_T
00636 #undef DECL_REL_OP_OTHER
00637 #undef DECL_REL_OP
00638
00639
00640
00641
00642 #define DECL_ASN_OP_T(op,tp) \
00643 sc_fxval_fast& operator op( tp );
00644
00645 #ifndef SC_FX_EXCLUDE_OTHER
00646 #define DECL_ASN_OP_OTHER(op) \
00647 DECL_ASN_OP_T(op,int64) \
00648 DECL_ASN_OP_T(op,uint64) \
00649 DECL_ASN_OP_T(op,const sc_int_base&) \
00650 DECL_ASN_OP_T(op,const sc_uint_base&) \
00651 DECL_ASN_OP_T(op,const sc_signed&) \
00652 DECL_ASN_OP_T(op,const sc_unsigned&)
00653 #else
00654 #define DECL_ASN_OP_OTHER(op)
00655 #endif
00656
00657 #define DECL_ASN_OP(op) \
00658 DECL_ASN_OP_T(op,int) \
00659 DECL_ASN_OP_T(op,unsigned int) \
00660 DECL_ASN_OP_T(op,long) \
00661 DECL_ASN_OP_T(op,unsigned long) \
00662 DECL_ASN_OP_T(op,double) \
00663 DECL_ASN_OP_T(op,const char*) \
00664 DECL_ASN_OP_T(op,const sc_fxval&) \
00665 DECL_ASN_OP_T(op,const sc_fxval_fast&) \
00666 DECL_ASN_OP_T(op,const sc_fxnum&) \
00667 DECL_ASN_OP_T(op,const sc_fxnum_fast&) \
00668 DECL_ASN_OP_OTHER(op)
00669
00670 DECL_ASN_OP(=)
00671
00672 DECL_ASN_OP(*=)
00673 DECL_ASN_OP(/=)
00674 DECL_ASN_OP(+=)
00675 DECL_ASN_OP(-=)
00676
00677 DECL_ASN_OP_T(<<=,int)
00678 DECL_ASN_OP_T(>>=,int)
00679
00680 #undef DECL_ASN_OP_T
00681 #undef DECL_ASN_OP_OTHER
00682 #undef DECL_ASN_OP
00683
00684
00685
00686
00687 const sc_fxval_fast operator ++ ( int );
00688 const sc_fxval_fast operator -- ( int );
00689
00690 sc_fxval_fast& operator ++ ();
00691 sc_fxval_fast& operator -- ();
00692
00693
00694
00695
00696 operator double() const;
00697
00698
00699
00700
00701 short to_short() const;
00702 unsigned short to_ushort() const;
00703 int to_int() const;
00704 unsigned int to_uint() const;
00705 long to_long() const;
00706 unsigned long to_ulong() const;
00707 int64 to_int64() const;
00708 uint64 to_uint64() const;
00709 float to_float() const;
00710 double to_double() const;
00711
00712
00713
00714
00715 const std::string to_string() const;
00716 const std::string to_string( sc_numrep ) const;
00717 const std::string to_string( sc_numrep, bool ) const;
00718 const std::string to_string( sc_fmt ) const;
00719 const std::string to_string( sc_numrep, sc_fmt ) const;
00720 const std::string to_string( sc_numrep, bool, sc_fmt ) const;
00721
00722 const std::string to_dec() const;
00723 const std::string to_bin() const;
00724 const std::string to_oct() const;
00725 const std::string to_hex() const;
00726
00727
00728
00729
00730 bool is_neg() const;
00731 bool is_zero() const;
00732 bool is_nan() const;
00733 bool is_inf() const;
00734 bool is_normal() const;
00735
00736 bool rounding_flag() const;
00737
00738
00739
00740
00741 void print( ::std::ostream& = ::std::cout ) const;
00742 void scan( ::std::istream& = ::std::cin );
00743 void dump( ::std::ostream& = ::std::cout ) const;
00744
00745
00746
00747 bool get_bit( int ) const;
00748
00749 protected:
00750
00751 sc_fxval_fast_observer* lock_observer() const;
00752 void unlock_observer( sc_fxval_fast_observer* ) const;
00753
00754
00755 static double from_string( const char* );
00756
00757 private:
00758
00759 double m_val;
00760
00761 mutable sc_fxval_fast_observer* m_observer;
00762
00763 };
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776 inline
00777 sc_fxval_observer*
00778 sc_fxval::observer() const
00779 {
00780 return m_observer;
00781 }
00782
00783
00784
00785 inline
00786 sc_fxval::sc_fxval( scfx_rep* a )
00787 : m_rep( a ),
00788 m_observer( 0 )
00789 {}
00790
00791
00792
00793
00794 inline
00795 sc_fxval::sc_fxval( sc_fxval_observer* observer_ )
00796 : m_rep( new scfx_rep ),
00797 m_observer( observer_ )
00798 {
00799 SC_FXVAL_OBSERVER_DEFAULT_
00800 SC_FXVAL_OBSERVER_CONSTRUCT_( *this )
00801 }
00802
00803 inline
00804 sc_fxval::sc_fxval( const sc_fxval& a,
00805 sc_fxval_observer* observer_ )
00806 : m_rep( new scfx_rep( *a.m_rep ) ),
00807 m_observer( observer_ )
00808 {
00809 SC_FXVAL_OBSERVER_DEFAULT_
00810 SC_FXVAL_OBSERVER_READ_( a )
00811 SC_FXVAL_OBSERVER_CONSTRUCT_( *this )
00812 SC_FXVAL_OBSERVER_WRITE_( *this )
00813 }
00814
00815 #define DEFN_CTOR_T(tp,arg) \
00816 inline \
00817 sc_fxval::sc_fxval( tp a, \
00818 sc_fxval_observer* observer_ ) \
00819 : m_rep( new scfx_rep( arg ) ), \
00820 m_observer( observer_ ) \
00821 { \
00822 SC_FXVAL_OBSERVER_DEFAULT_ \
00823 SC_FXVAL_OBSERVER_CONSTRUCT_( *this ) \
00824 SC_FXVAL_OBSERVER_WRITE_( *this ) \
00825 }
00826
00827 #define DEFN_CTOR_T_A(tp) DEFN_CTOR_T(tp,a)
00828 #define DEFN_CTOR_T_B(tp) DEFN_CTOR_T(tp,a.to_double())
00829 #define DEFN_CTOR_T_C(tp) DEFN_CTOR_T(tp,a.value())
00830
00831 DEFN_CTOR_T_A(int)
00832 DEFN_CTOR_T_A(unsigned int)
00833 DEFN_CTOR_T_A(long)
00834 DEFN_CTOR_T_A(unsigned long)
00835 DEFN_CTOR_T_A(double)
00836 DEFN_CTOR_T_A(const char*)
00837 DEFN_CTOR_T_B(const sc_fxval_fast&)
00838 #ifndef SC_FX_EXCLUDE_OTHER
00839 DEFN_CTOR_T_A(int64)
00840 DEFN_CTOR_T_A(uint64)
00841 DEFN_CTOR_T_C(const sc_int_base&)
00842 DEFN_CTOR_T_C(const sc_uint_base&)
00843 DEFN_CTOR_T_A(const sc_signed&)
00844 DEFN_CTOR_T_A(const sc_unsigned&)
00845 #endif
00846
00847 #undef DEFN_CTOR_T
00848 #undef DEFN_CTOR_T_A
00849 #undef DEFN_CTOR_T_B
00850 #undef DEFN_CTOR_T_C
00851
00852
00853 inline
00854 sc_fxval::~sc_fxval()
00855 {
00856 SC_FXVAL_OBSERVER_DESTRUCT_( *this )
00857 delete m_rep;
00858 }
00859
00860
00861
00862 inline
00863 const scfx_rep*
00864 sc_fxval::get_rep() const
00865 {
00866 SC_FXVAL_OBSERVER_READ_( *this )
00867 return m_rep;
00868 }
00869
00870
00871 inline
00872 void
00873 sc_fxval::set_rep( scfx_rep* rep_ )
00874 {
00875 delete m_rep;
00876 m_rep = rep_;
00877 SC_FXVAL_OBSERVER_WRITE_( *this )
00878 }
00879
00880
00881
00882
00883 inline
00884 const sc_fxval
00885 sc_fxval::operator - () const
00886 {
00887 SC_FXVAL_OBSERVER_READ_( *this )
00888 return sc_fxval( sc_dt::neg_scfx_rep( *m_rep ) );
00889 }
00890
00891 inline
00892 const sc_fxval&
00893 sc_fxval::operator + () const
00894 {
00895
00896 return *this;
00897 }
00898
00899
00900
00901
00902 inline
00903 void
00904 neg( sc_fxval& c, const sc_fxval& a )
00905 {
00906 SC_FXVAL_OBSERVER_READ_( a )
00907 delete c.m_rep;
00908 c.m_rep = sc_dt::neg_scfx_rep( *a.m_rep );
00909 SC_FXVAL_OBSERVER_WRITE_( c )
00910 }
00911
00912
00913
00914
00915 #define DEFN_BIN_OP_T(op,fnc,tp) \
00916 inline \
00917 const sc_fxval \
00918 operator op ( const sc_fxval& a, tp b ) \
00919 { \
00920 SC_FXVAL_OBSERVER_READ_( a ) \
00921 sc_fxval tmp( b ); \
00922 return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.m_rep ) ); \
00923 } \
00924 \
00925 inline \
00926 const sc_fxval \
00927 operator op ( tp a, const sc_fxval& b ) \
00928 { \
00929 SC_FXVAL_OBSERVER_READ_( b ) \
00930 sc_fxval tmp( a ); \
00931 return sc_fxval( sc_dt::fnc ## _scfx_rep( *tmp.m_rep, *b.m_rep ) ); \
00932 }
00933
00934 #ifndef SC_FX_EXCLUDE_OTHER
00935 #define DEFN_BIN_OP_OTHER(op,fnc) \
00936 DEFN_BIN_OP_T(op,fnc,int64) \
00937 DEFN_BIN_OP_T(op,fnc,uint64) \
00938 DEFN_BIN_OP_T(op,fnc,const sc_int_base&) \
00939 DEFN_BIN_OP_T(op,fnc,const sc_uint_base&) \
00940 DEFN_BIN_OP_T(op,fnc,const sc_signed&) \
00941 DEFN_BIN_OP_T(op,fnc,const sc_unsigned&)
00942 #else
00943 #define DEFN_BIN_OP_OTHER(op,fnc)
00944 #endif
00945
00946 #define DEFN_BIN_OP(op,fnc) \
00947 inline \
00948 const sc_fxval \
00949 operator op ( const sc_fxval& a, const sc_fxval& b ) \
00950 { \
00951 SC_FXVAL_OBSERVER_READ_( a ) \
00952 SC_FXVAL_OBSERVER_READ_( b ) \
00953 return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.m_rep ) ); \
00954 } \
00955 \
00956 DEFN_BIN_OP_T(op,fnc,int) \
00957 DEFN_BIN_OP_T(op,fnc,unsigned int) \
00958 DEFN_BIN_OP_T(op,fnc,long) \
00959 DEFN_BIN_OP_T(op,fnc,unsigned long) \
00960 DEFN_BIN_OP_T(op,fnc,double) \
00961 DEFN_BIN_OP_T(op,fnc,const char*) \
00962 DEFN_BIN_OP_T(op,fnc,const sc_fxval_fast&) \
00963 DEFN_BIN_OP_OTHER(op,fnc)
00964
00965 DEFN_BIN_OP(*,mult)
00966 DEFN_BIN_OP(+,add)
00967 DEFN_BIN_OP(-,sub)
00968
00969
00970 inline
00971 const sc_fxval
00972 operator / ( const sc_fxval& a, const sc_fxval& b )
00973 {
00974 SC_FXVAL_OBSERVER_READ_( a )
00975 SC_FXVAL_OBSERVER_READ_( b )
00976 return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ) );
00977 }
00978
00979 DEFN_BIN_OP_T(/,div,int)
00980 DEFN_BIN_OP_T(/,div,unsigned int)
00981 DEFN_BIN_OP_T(/,div,long)
00982 DEFN_BIN_OP_T(/,div,unsigned long)
00983 DEFN_BIN_OP_T(/,div,double)
00984 DEFN_BIN_OP_T(/,div,const char*)
00985 DEFN_BIN_OP_T(/,div,const sc_fxval_fast&)
00986
00987 #ifndef SC_FX_EXCLUDE_OTHER
00988 DEFN_BIN_OP_T(/,div,int64) \
00989 DEFN_BIN_OP_T(/,div,uint64) \
00990 DEFN_BIN_OP_T(/,div,const sc_int_base&) \
00991 DEFN_BIN_OP_T(/,div,const sc_uint_base&) \
00992 DEFN_BIN_OP_T(/,div,const sc_signed&) \
00993 DEFN_BIN_OP_T(/,div,const sc_unsigned&)
00994 #endif
00995
00996 #undef DEFN_BIN_OP_T
00997 #undef DEFN_BIN_OP_OTHER
00998 #undef DEFN_BIN_OP
00999
01000
01001 inline
01002 const sc_fxval
01003 operator << ( const sc_fxval& a, int b )
01004 {
01005 SC_FXVAL_OBSERVER_READ_( a )
01006 return sc_fxval( sc_dt::lsh_scfx_rep( *a.m_rep, b ) );
01007 }
01008
01009 inline
01010 const sc_fxval
01011 operator >> ( const sc_fxval& a, int b )
01012 {
01013 SC_FXVAL_OBSERVER_READ_( a )
01014 return sc_fxval( sc_dt::rsh_scfx_rep( *a.m_rep, b ) );
01015 }
01016
01017
01018
01019
01020 #define DEFN_BIN_FNC_T(fnc,tp) \
01021 inline \
01022 void \
01023 fnc ( sc_fxval& c, const sc_fxval& a, tp b ) \
01024 { \
01025 SC_FXVAL_OBSERVER_READ_( a ) \
01026 sc_fxval tmp( b ); \
01027 delete c.m_rep; \
01028 c.m_rep = sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.m_rep ); \
01029 SC_FXVAL_OBSERVER_WRITE_( c ) \
01030 } \
01031 \
01032 inline \
01033 void \
01034 fnc ( sc_fxval& c, tp a, const sc_fxval& b ) \
01035 { \
01036 SC_FXVAL_OBSERVER_READ_( b ) \
01037 sc_fxval tmp( a ); \
01038 delete c.m_rep; \
01039 c.m_rep = sc_dt::fnc ## _scfx_rep( *tmp.m_rep, *b.m_rep ); \
01040 SC_FXVAL_OBSERVER_WRITE_( c ) \
01041 }
01042
01043 #ifndef SC_FX_EXCLUDE_OTHER
01044 #define DEFN_BIN_FNC_OTHER(fnc) \
01045 DEFN_BIN_FNC_T(fnc,int64) \
01046 DEFN_BIN_FNC_T(fnc,uint64) \
01047 DEFN_BIN_FNC_T(fnc,const sc_int_base&) \
01048 DEFN_BIN_FNC_T(fnc,const sc_uint_base&) \
01049 DEFN_BIN_FNC_T(fnc,const sc_signed&) \
01050 DEFN_BIN_FNC_T(fnc,const sc_unsigned&)
01051 #else
01052 #define DEFN_BIN_FNC_OTHER(fnc)
01053 #endif
01054
01055 #define DEFN_BIN_FNC(fnc) \
01056 inline \
01057 void \
01058 fnc( sc_fxval& c, const sc_fxval& a, const sc_fxval& b ) \
01059 { \
01060 SC_FXVAL_OBSERVER_READ_( a ) \
01061 SC_FXVAL_OBSERVER_READ_( b ) \
01062 delete c.m_rep; \
01063 c.m_rep = sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.m_rep ); \
01064 SC_FXVAL_OBSERVER_WRITE_( c ) \
01065 } \
01066 \
01067 DEFN_BIN_FNC_T(fnc,int) \
01068 DEFN_BIN_FNC_T(fnc,unsigned int) \
01069 DEFN_BIN_FNC_T(fnc,long) \
01070 DEFN_BIN_FNC_T(fnc,unsigned long) \
01071 DEFN_BIN_FNC_T(fnc,double) \
01072 DEFN_BIN_FNC_T(fnc,const char*) \
01073 DEFN_BIN_FNC_T(fnc,const sc_fxval_fast&) \
01074 DEFN_BIN_FNC_OTHER(fnc)
01075
01076 DEFN_BIN_FNC(mult)
01077 DEFN_BIN_FNC(div)
01078 DEFN_BIN_FNC(add)
01079 DEFN_BIN_FNC(sub)
01080
01081 #undef DEFN_BIN_FNC_T
01082 #undef DEFN_BIN_FNC_OTHER
01083 #undef DEFN_BIN_FNC
01084
01085
01086 inline
01087 void
01088 lshift( sc_fxval& c, const sc_fxval& a, int b )
01089 {
01090 SC_FXVAL_OBSERVER_READ_( a )
01091 delete c.m_rep;
01092 c.m_rep = sc_dt::lsh_scfx_rep( *a.m_rep, b );
01093 SC_FXVAL_OBSERVER_WRITE_( c )
01094 }
01095
01096 inline
01097 void
01098 rshift( sc_fxval& c, const sc_fxval& a, int b )
01099 {
01100 SC_FXVAL_OBSERVER_READ_( a )
01101 delete c.m_rep;
01102 c.m_rep = sc_dt::rsh_scfx_rep( *a.m_rep, b );
01103 SC_FXVAL_OBSERVER_WRITE_( c )
01104 }
01105
01106
01107
01108
01109 #define DEFN_REL_OP_T(op,ret,tp) \
01110 inline \
01111 bool \
01112 operator op ( const sc_fxval& a, tp b ) \
01113 { \
01114 SC_FXVAL_OBSERVER_READ_( a ) \
01115 sc_fxval tmp( b ); \
01116 int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); \
01117 return ( ret ); \
01118 } \
01119 \
01120 inline \
01121 bool \
01122 operator op ( tp a, const sc_fxval& b ) \
01123 { \
01124 SC_FXVAL_OBSERVER_READ_( b ) \
01125 sc_fxval tmp( a ); \
01126 int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); \
01127 return ( ret ); \
01128 }
01129
01130 #ifndef SC_FX_EXCLUDE_OTHER
01131 #define DEFN_REL_OP_OTHER(op,ret) \
01132 DEFN_REL_OP_T(op,ret,int64) \
01133 DEFN_REL_OP_T(op,ret,uint64) \
01134 DEFN_REL_OP_T(op,ret,const sc_int_base&) \
01135 DEFN_REL_OP_T(op,ret,const sc_uint_base&) \
01136 DEFN_REL_OP_T(op,ret,const sc_signed&) \
01137 DEFN_REL_OP_T(op,ret,const sc_unsigned&)
01138 #else
01139 #define DEFN_REL_OP_OTHER(op,ret)
01140 #endif
01141
01142 #define DEFN_REL_OP(op,ret) \
01143 inline \
01144 bool \
01145 operator op ( const sc_fxval& a, const sc_fxval& b) \
01146 { \
01147 SC_FXVAL_OBSERVER_READ_( a ) \
01148 SC_FXVAL_OBSERVER_READ_( b ) \
01149 int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); \
01150 return ( ret ); \
01151 } \
01152 \
01153 DEFN_REL_OP_T(op,ret,int) \
01154 DEFN_REL_OP_T(op,ret,unsigned int) \
01155 DEFN_REL_OP_T(op,ret,long) \
01156 DEFN_REL_OP_T(op,ret,unsigned long) \
01157 DEFN_REL_OP_T(op,ret,double) \
01158 DEFN_REL_OP_T(op,ret,const char*) \
01159 DEFN_REL_OP_T(op,ret,const sc_fxval_fast&) \
01160 DEFN_REL_OP_OTHER(op,ret)
01161
01162 DEFN_REL_OP(<,result < 0)
01163 DEFN_REL_OP(<=,result <= 0)
01164 DEFN_REL_OP(>,result > 0 && result != 2)
01165 DEFN_REL_OP(>=,result >= 0 && result != 2)
01166 DEFN_REL_OP(==,result == 0)
01167 DEFN_REL_OP(!=,result != 0)
01168
01169 #undef DEFN_REL_OP_T
01170 #undef DEFN_REL_OP_OTHER
01171 #undef DEFN_REL_OP
01172
01173
01174
01175
01176 inline
01177 sc_fxval&
01178 sc_fxval::operator = ( const sc_fxval& a )
01179 {
01180 if( &a != this )
01181 {
01182 SC_FXVAL_OBSERVER_READ_( a )
01183 *m_rep = *a.m_rep;
01184 SC_FXVAL_OBSERVER_WRITE_( *this )
01185 }
01186 return *this;
01187 }
01188
01189 #define DEFN_ASN_OP_T(tp) \
01190 inline \
01191 sc_fxval& \
01192 sc_fxval::operator = ( tp b ) \
01193 { \
01194 sc_fxval tmp( b ); \
01195 *m_rep = *tmp.m_rep; \
01196 SC_FXVAL_OBSERVER_WRITE_( *this ) \
01197 return *this; \
01198 }
01199
01200 DEFN_ASN_OP_T(int)
01201 DEFN_ASN_OP_T(unsigned int)
01202 DEFN_ASN_OP_T(long)
01203 DEFN_ASN_OP_T(unsigned long)
01204 DEFN_ASN_OP_T(double)
01205 DEFN_ASN_OP_T(const char*)
01206 DEFN_ASN_OP_T(const sc_fxval_fast&)
01207 #ifndef SC_FX_EXCLUDE_OTHER
01208 DEFN_ASN_OP_T(int64)
01209 DEFN_ASN_OP_T(uint64)
01210 DEFN_ASN_OP_T(const sc_int_base&)
01211 DEFN_ASN_OP_T(const sc_uint_base&)
01212 DEFN_ASN_OP_T(const sc_signed&)
01213 DEFN_ASN_OP_T(const sc_unsigned&)
01214 #endif
01215
01216 #undef DEFN_ASN_OP_T
01217
01218
01219 #define DEFN_ASN_OP_T(op,fnc,tp) \
01220 inline \
01221 sc_fxval& \
01222 sc_fxval::operator op ( tp b ) \
01223 { \
01224 SC_FXVAL_OBSERVER_READ_( *this ) \
01225 sc_fxval tmp( b ); \
01226 scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *tmp.m_rep ); \
01227 delete m_rep; \
01228 m_rep = new_rep; \
01229 SC_FXVAL_OBSERVER_WRITE_( *this ) \
01230 return *this; \
01231 }
01232
01233 #ifndef SC_FX_EXCLUDE_OTHER
01234 #define DEFN_ASN_OP_OTHER(op,fnc) \
01235 DEFN_ASN_OP_T(op,fnc,int64) \
01236 DEFN_ASN_OP_T(op,fnc,uint64) \
01237 DEFN_ASN_OP_T(op,fnc,const sc_int_base&) \
01238 DEFN_ASN_OP_T(op,fnc,const sc_uint_base&) \
01239 DEFN_ASN_OP_T(op,fnc,const sc_signed&) \
01240 DEFN_ASN_OP_T(op,fnc,const sc_unsigned&)
01241 #else
01242 #define DEFN_ASN_OP_OTHER(op,fnc)
01243 #endif
01244
01245 #define DEFN_ASN_OP(op,fnc) \
01246 inline \
01247 sc_fxval& \
01248 sc_fxval::operator op ( const sc_fxval& b ) \
01249 { \
01250 SC_FXVAL_OBSERVER_READ_( *this ) \
01251 SC_FXVAL_OBSERVER_READ_( b ) \
01252 scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *b.m_rep ); \
01253 delete m_rep; \
01254 m_rep = new_rep; \
01255 SC_FXVAL_OBSERVER_WRITE_( *this ) \
01256 return *this; \
01257 } \
01258 \
01259 DEFN_ASN_OP_T(op,fnc,int) \
01260 DEFN_ASN_OP_T(op,fnc,unsigned int) \
01261 DEFN_ASN_OP_T(op,fnc,long) \
01262 DEFN_ASN_OP_T(op,fnc,unsigned long) \
01263 DEFN_ASN_OP_T(op,fnc,double) \
01264 DEFN_ASN_OP_T(op,fnc,const char*) \
01265 DEFN_ASN_OP_T(op,fnc,const sc_fxval_fast&) \
01266 DEFN_ASN_OP_OTHER(op,fnc)
01267
01268 DEFN_ASN_OP(*=,mult)
01269 DEFN_ASN_OP(/=,div)
01270 DEFN_ASN_OP(+=,add)
01271 DEFN_ASN_OP(-=,sub)
01272
01273 #undef DEFN_ASN_OP_T
01274 #undef DEFN_ASN_OP_OTHER
01275 #undef DEFN_ASN_OP
01276
01277
01278 inline
01279 sc_fxval&
01280 sc_fxval::operator <<= ( int b )
01281 {
01282 SC_FXVAL_OBSERVER_READ_( *this )
01283 m_rep->lshift( b );
01284 SC_FXVAL_OBSERVER_WRITE_( *this )
01285 return *this;
01286 }
01287
01288 inline
01289 sc_fxval&
01290 sc_fxval::operator >>= ( int b )
01291 {
01292 SC_FXVAL_OBSERVER_READ_( *this )
01293 m_rep->rshift( b );
01294 SC_FXVAL_OBSERVER_WRITE_( *this )
01295 return *this;
01296 }
01297
01298
01299
01300
01301 inline
01302 const sc_fxval
01303 sc_fxval::operator ++ ( int )
01304 {
01305 sc_fxval c = *this;
01306 (*this) += 1;
01307 return c;
01308 }
01309
01310 inline
01311 const sc_fxval
01312 sc_fxval::operator -- ( int )
01313 {
01314 sc_fxval c = *this;
01315 (*this) -= 1;
01316 return c;
01317 }
01318
01319 inline
01320 sc_fxval&
01321 sc_fxval::operator ++ ()
01322 {
01323 (*this) += 1;
01324 return *this;
01325 }
01326
01327 inline
01328 sc_fxval&
01329 sc_fxval::operator -- ()
01330 {
01331 (*this) -= 1;
01332 return *this;
01333 }
01334
01335
01336
01337
01338 inline
01339 sc_fxval::operator double() const
01340 {
01341 SC_FXVAL_OBSERVER_READ_( *this )
01342 return m_rep->to_double();
01343 }
01344
01345
01346
01347
01348 inline
01349 short
01350 sc_fxval::to_short() const
01351 {
01352 SC_FXVAL_OBSERVER_READ_( *this )
01353 return static_cast<short>( m_rep->to_double() );
01354 }
01355
01356 inline
01357 unsigned short
01358 sc_fxval::to_ushort() const
01359 {
01360 SC_FXVAL_OBSERVER_READ_( *this )
01361 return static_cast<unsigned short>( m_rep->to_double() );
01362 }
01363
01364 inline
01365 int
01366 sc_fxval::to_int() const
01367 {
01368 SC_FXVAL_OBSERVER_READ_( *this )
01369 return static_cast<int>( m_rep->to_double() );
01370 }
01371
01372 inline
01373 int64
01374 sc_fxval::to_int64() const
01375 {
01376 SC_FXVAL_OBSERVER_READ_( *this )
01377 return static_cast<int64>( m_rep->to_double() );
01378 }
01379
01380 inline
01381 uint64
01382 sc_fxval::to_uint64() const
01383 {
01384 SC_FXVAL_OBSERVER_READ_( *this )
01385 return static_cast<uint64>( m_rep->to_double() );
01386 }
01387
01388 inline
01389 long
01390 sc_fxval::to_long() const
01391 {
01392 SC_FXVAL_OBSERVER_READ_( *this )
01393 return static_cast<long>( m_rep->to_double() );
01394 }
01395
01396 inline
01397 unsigned int
01398 sc_fxval::to_uint() const
01399 {
01400 SC_FXVAL_OBSERVER_READ_( *this )
01401 return static_cast<unsigned int>( m_rep->to_double() );
01402 }
01403
01404 inline
01405 unsigned long
01406 sc_fxval::to_ulong() const
01407 {
01408 SC_FXVAL_OBSERVER_READ_( *this )
01409 return static_cast<unsigned long>( m_rep->to_double() );
01410 }
01411
01412 inline
01413 float
01414 sc_fxval::to_float() const
01415 {
01416 SC_FXVAL_OBSERVER_READ_( *this )
01417 return static_cast<float>( m_rep->to_double() );
01418 }
01419
01420 inline
01421 double
01422 sc_fxval::to_double() const
01423 {
01424 SC_FXVAL_OBSERVER_READ_( *this )
01425 return m_rep->to_double();
01426 }
01427
01428
01429
01430
01431 inline
01432 bool
01433 sc_fxval::is_neg() const
01434 {
01435 SC_FXVAL_OBSERVER_READ_( *this )
01436 return m_rep->is_neg();
01437 }
01438
01439 inline
01440 bool
01441 sc_fxval::is_zero() const
01442 {
01443 SC_FXVAL_OBSERVER_READ_( *this )
01444 return m_rep->is_zero();
01445 }
01446
01447 inline
01448 bool
01449 sc_fxval::is_nan() const
01450 {
01451 SC_FXVAL_OBSERVER_READ_( *this )
01452 return m_rep->is_nan();
01453 }
01454
01455 inline
01456 bool
01457 sc_fxval::is_inf() const
01458 {
01459 SC_FXVAL_OBSERVER_READ_( *this )
01460 return m_rep->is_inf();
01461 }
01462
01463 inline
01464 bool
01465 sc_fxval::is_normal() const
01466 {
01467 SC_FXVAL_OBSERVER_READ_( *this )
01468 return m_rep->is_normal();
01469 }
01470
01471
01472 inline
01473 bool
01474 sc_fxval::rounding_flag() const
01475 {
01476 return m_rep->rounding_flag();
01477 }
01478
01479
01480
01481 inline
01482 bool
01483 sc_fxval::get_bit( int i ) const
01484 {
01485 return m_rep->get_bit( i );
01486 }
01487
01488
01489
01490
01491 inline
01492 void
01493 sc_fxval::get_type( int& wl, int& iwl, sc_enc& enc ) const
01494 {
01495 m_rep->get_type( wl, iwl, enc );
01496 }
01497
01498
01499 inline
01500 const sc_fxval
01501 sc_fxval::quantization( const scfx_params& params, bool& q_flag ) const
01502 {
01503 return sc_fxval( sc_dt::quantization_scfx_rep( *m_rep, params, q_flag ) );
01504 }
01505
01506 inline
01507 const sc_fxval
01508 sc_fxval::overflow( const scfx_params& params, bool& o_flag ) const
01509 {
01510 return sc_fxval( sc_dt::overflow_scfx_rep( *m_rep, params, o_flag ) );
01511 }
01512
01513
01514 inline
01515 ::std::ostream&
01516 operator << ( ::std::ostream& os, const sc_fxval& a )
01517 {
01518 a.print( os );
01519 return os;
01520 }
01521
01522 inline
01523 ::std::istream&
01524 operator >> ( ::std::istream& is, sc_fxval& a )
01525 {
01526 a.scan( is );
01527 return is;
01528 }
01529
01530
01531
01532
01533
01534
01535
01536
01537
01538
01539 inline
01540 sc_fxval_fast_observer*
01541 sc_fxval_fast::observer() const
01542 {
01543 return m_observer;
01544 }
01545
01546
01547
01548
01549 inline
01550 sc_fxval_fast::sc_fxval_fast( sc_fxval_fast_observer* observer_ )
01551 : m_val( 0.0 ),
01552 m_observer( observer_ )
01553 {
01554 SC_FXVAL_FAST_OBSERVER_DEFAULT_
01555 SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this )
01556 }
01557
01558 inline
01559 sc_fxval_fast::sc_fxval_fast( const sc_fxval_fast& a,
01560 sc_fxval_fast_observer* observer_ )
01561 : m_val( a.m_val ),
01562 m_observer( observer_ )
01563 {
01564 SC_FXVAL_FAST_OBSERVER_DEFAULT_
01565 SC_FXVAL_FAST_OBSERVER_READ_( a )
01566 SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this )
01567 SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
01568 }
01569
01570 #define DEFN_CTOR_T(tp,arg) \
01571 inline \
01572 sc_fxval_fast::sc_fxval_fast( tp a, \
01573 sc_fxval_fast_observer* observer_ ) \
01574 : m_val( arg ), \
01575 m_observer( observer_ ) \
01576 { \
01577 SC_FXVAL_FAST_OBSERVER_DEFAULT_ \
01578 SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this ) \
01579 SC_FXVAL_FAST_OBSERVER_WRITE_( *this ) \
01580 }
01581
01582 #define DEFN_CTOR_T_A(tp) DEFN_CTOR_T(tp,static_cast<double>( a ))
01583 #define DEFN_CTOR_T_B(tp) DEFN_CTOR_T(tp,from_string( a ))
01584 #define DEFN_CTOR_T_C(tp) DEFN_CTOR_T(tp,a.to_double())
01585
01586 DEFN_CTOR_T_A(int)
01587 DEFN_CTOR_T_A(unsigned int)
01588 DEFN_CTOR_T_A(long)
01589 DEFN_CTOR_T_A(unsigned long)
01590 DEFN_CTOR_T_A(double)
01591 DEFN_CTOR_T_B(const char*)
01592 DEFN_CTOR_T_C(const sc_fxval&)
01593 #ifndef SC_FX_EXCLUDE_OTHER
01594 DEFN_CTOR_T_A(int64)
01595 DEFN_CTOR_T_A(uint64)
01596 DEFN_CTOR_T_C(const sc_int_base&)
01597 DEFN_CTOR_T_C(const sc_uint_base&)
01598 DEFN_CTOR_T_C(const sc_signed&)
01599 DEFN_CTOR_T_C(const sc_unsigned&)
01600 #endif
01601
01602 #undef DEFN_CTOR_T
01603 #undef DEFN_CTOR_T_A
01604 #undef DEFN_CTOR_T_B
01605 #undef DEFN_CTOR_T_C
01606 #undef DEFN_CTOR_T_D
01607 #undef DEFN_CTOR_T_E
01608
01609
01610 inline
01611 sc_fxval_fast::~sc_fxval_fast()
01612 {
01613 SC_FXVAL_FAST_OBSERVER_DESTRUCT_( *this )
01614 }
01615
01616
01617
01618 inline
01619 double
01620 sc_fxval_fast::get_val() const
01621 {
01622 SC_FXVAL_FAST_OBSERVER_READ_( *this )
01623 return m_val;
01624 }
01625
01626
01627 inline
01628 void
01629 sc_fxval_fast::set_val( double val_ )
01630 {
01631 m_val = val_;
01632 SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
01633 }
01634
01635
01636
01637
01638 inline
01639 const sc_fxval_fast
01640 sc_fxval_fast::operator - () const
01641 {
01642 SC_FXVAL_FAST_OBSERVER_READ_( *this )
01643 return sc_fxval_fast( - m_val );
01644 }
01645
01646 inline
01647 const sc_fxval_fast&
01648 sc_fxval_fast::operator + () const
01649 {
01650
01651 return *this;
01652 }
01653
01654
01655
01656
01657 inline
01658 void
01659 neg( sc_fxval_fast& c, const sc_fxval_fast& a )
01660 {
01661 SC_FXVAL_FAST_OBSERVER_READ_( a )
01662 c.m_val = - a.m_val;
01663 SC_FXVAL_FAST_OBSERVER_WRITE_( c )
01664 }
01665
01666
01667
01668
01669 #define DEFN_BIN_OP_T(op,tp) \
01670 inline \
01671 const sc_fxval_fast \
01672 operator op ( const sc_fxval_fast& a, tp b ) \
01673 { \
01674 SC_FXVAL_FAST_OBSERVER_READ_( a ) \
01675 sc_fxval_fast tmp( b ); \
01676 return sc_fxval_fast( a.m_val op tmp.m_val ); \
01677 } \
01678 \
01679 inline \
01680 const sc_fxval_fast \
01681 operator op ( tp a, const sc_fxval_fast& b ) \
01682 { \
01683 SC_FXVAL_FAST_OBSERVER_READ_( b ) \
01684 sc_fxval_fast tmp( a ); \
01685 return sc_fxval_fast( tmp.m_val op b.m_val ); \
01686 }
01687
01688 #ifndef SC_FX_EXCLUDE_OTHER
01689 #define DEFN_BIN_OP_OTHER(op) \
01690 DEFN_BIN_OP_T(op,int64) \
01691 DEFN_BIN_OP_T(op,uint64) \
01692 DEFN_BIN_OP_T(op,const sc_int_base&) \
01693 DEFN_BIN_OP_T(op,const sc_uint_base&) \
01694 DEFN_BIN_OP_T(op,const sc_signed&) \
01695 DEFN_BIN_OP_T(op,const sc_unsigned&)
01696 #else
01697 #define DEFN_BIN_OP_OTHER(op)
01698 #endif
01699
01700 #define DEFN_BIN_OP(op,dummy) \
01701 inline \
01702 const sc_fxval_fast \
01703 operator op ( const sc_fxval_fast& a, const sc_fxval_fast& b ) \
01704 { \
01705 SC_FXVAL_FAST_OBSERVER_READ_( a ) \
01706 SC_FXVAL_FAST_OBSERVER_READ_( b ) \
01707 return sc_fxval_fast( a.m_val op b.m_val ); \
01708 } \
01709 \
01710 DEFN_BIN_OP_T(op,int) \
01711 DEFN_BIN_OP_T(op,unsigned int) \
01712 DEFN_BIN_OP_T(op,long) \
01713 DEFN_BIN_OP_T(op,unsigned long) \
01714 DEFN_BIN_OP_T(op,double) \
01715 DEFN_BIN_OP_T(op,const char*) \
01716 DEFN_BIN_OP_OTHER(op)
01717
01718 DEFN_BIN_OP(*,mult)
01719 DEFN_BIN_OP(+,add)
01720 DEFN_BIN_OP(-,sub)
01721
01722 inline
01723 const sc_fxval_fast
01724 operator / ( const sc_fxval_fast& a, const sc_fxval_fast& b )
01725 {
01726 SC_FXVAL_FAST_OBSERVER_READ_( a )
01727 SC_FXVAL_FAST_OBSERVER_READ_( b )
01728 return sc_fxval_fast( a.m_val / b.m_val );
01729 }
01730
01731 DEFN_BIN_OP_T(/,int)
01732 DEFN_BIN_OP_T(/,unsigned int)
01733 DEFN_BIN_OP_T(/,long)
01734 DEFN_BIN_OP_T(/,unsigned long)
01735 DEFN_BIN_OP_T(/,double)
01736 DEFN_BIN_OP_T(/,const char*)
01737
01738 #ifndef SC_FX_EXCLUDE_OTHER
01739 DEFN_BIN_OP_T(/,int64)
01740 DEFN_BIN_OP_T(/,uint64)
01741 DEFN_BIN_OP_T(/,const sc_int_base&)
01742 DEFN_BIN_OP_T(/,const sc_uint_base&)
01743 DEFN_BIN_OP_T(/,const sc_signed&)
01744 DEFN_BIN_OP_T(/,const sc_unsigned&)
01745 #endif
01746
01747
01748 #undef DEFN_BIN_OP_T
01749 #undef DEFN_BIN_OP_OTHER
01750 #undef DEFN_BIN_OP
01751
01752
01753 inline
01754 const sc_fxval_fast
01755 operator << ( const sc_fxval_fast& a, int b )
01756 {
01757 SC_FXVAL_FAST_OBSERVER_READ_( a )
01758 return sc_fxval_fast( a.m_val * scfx_pow2( b ) );
01759 }
01760
01761 inline
01762 const sc_fxval_fast
01763 operator >> ( const sc_fxval_fast& a, int b )
01764 {
01765 SC_FXVAL_FAST_OBSERVER_READ_( a )
01766 return sc_fxval_fast( a.m_val * scfx_pow2( -b ) );
01767 }
01768
01769
01770
01771
01772 #define DEFN_BIN_FNC_T(fnc,op,tp) \
01773 inline \
01774 void \
01775 fnc ( sc_fxval_fast& c, const sc_fxval_fast& a, tp b ) \
01776 { \
01777 SC_FXVAL_FAST_OBSERVER_READ_( a ) \
01778 sc_fxval_fast tmp( b ); \
01779 c.m_val = a.m_val op tmp.m_val; \
01780 SC_FXVAL_FAST_OBSERVER_WRITE_( c ) \
01781 } \
01782 \
01783 inline \
01784 void \
01785 fnc ( sc_fxval_fast& c, tp a, const sc_fxval_fast& b ) \
01786 { \
01787 SC_FXVAL_FAST_OBSERVER_READ_( b ) \
01788 sc_fxval_fast tmp( a ); \
01789 c.m_val = tmp.m_val op b.m_val; \
01790 SC_FXVAL_FAST_OBSERVER_WRITE_( c ) \
01791 }
01792
01793 #ifndef SC_FX_EXCLUDE_OTHER
01794 #define DEFN_BIN_FNC_OTHER(fnc,op) \
01795 DEFN_BIN_FNC_T(fnc,op,int64) \
01796 DEFN_BIN_FNC_T(fnc,op,uint64) \
01797 DEFN_BIN_FNC_T(fnc,op,const sc_int_base&) \
01798 DEFN_BIN_FNC_T(fnc,op,const sc_uint_base&) \
01799 DEFN_BIN_FNC_T(fnc,op,const sc_signed&) \
01800 DEFN_BIN_FNC_T(fnc,op,const sc_unsigned&)
01801 #else
01802 #define DEFN_BIN_FNC_OTHER(fnc,op)
01803 #endif
01804
01805 #define DEFN_BIN_FNC(fnc,op) \
01806 inline \
01807 void \
01808 fnc ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval_fast& b ) \
01809 { \
01810 SC_FXVAL_FAST_OBSERVER_READ_( a ) \
01811 SC_FXVAL_FAST_OBSERVER_READ_( b ) \
01812 c.m_val = a.m_val op b.m_val; \
01813 SC_FXVAL_FAST_OBSERVER_WRITE_( c ) \
01814 } \
01815 \
01816 DEFN_BIN_FNC_T(fnc,op,int) \
01817 DEFN_BIN_FNC_T(fnc,op,unsigned int) \
01818 DEFN_BIN_FNC_T(fnc,op,long) \
01819 DEFN_BIN_FNC_T(fnc,op,unsigned long) \
01820 DEFN_BIN_FNC_T(fnc,op,double) \
01821 DEFN_BIN_FNC_T(fnc,op,const char*) \
01822 DEFN_BIN_FNC_OTHER(fnc,op)
01823
01824 DEFN_BIN_FNC(mult,*)
01825 DEFN_BIN_FNC(div,/)
01826 DEFN_BIN_FNC(add,+)
01827 DEFN_BIN_FNC(sub,-)
01828
01829 #undef DEFN_BIN_FNC_T
01830 #undef DEFN_BIN_FNC_OTHER
01831 #undef DEFN_BIN_FNC
01832
01833
01834 inline
01835 void
01836 lshift( sc_fxval_fast& c, const sc_fxval_fast& a, int b )
01837 {
01838 SC_FXVAL_FAST_OBSERVER_READ_( a )
01839 c.m_val = a.m_val * scfx_pow2( b );
01840 SC_FXVAL_FAST_OBSERVER_WRITE_( c )
01841 }
01842
01843 inline
01844 void
01845 rshift( sc_fxval_fast& c, const sc_fxval_fast& a, int b )
01846 {
01847 SC_FXVAL_FAST_OBSERVER_READ_( a )
01848 c.m_val = a.m_val * scfx_pow2( -b );
01849 SC_FXVAL_FAST_OBSERVER_WRITE_( c )
01850 }
01851
01852
01853
01854
01855 #define DEFN_REL_OP_T(op,tp) \
01856 inline \
01857 bool \
01858 operator op ( const sc_fxval_fast& a, tp b ) \
01859 { \
01860 SC_FXVAL_FAST_OBSERVER_READ_( a ) \
01861 sc_fxval_fast tmp( b ); \
01862 return ( a.m_val op tmp.m_val ); \
01863 } \
01864 \
01865 inline \
01866 bool \
01867 operator op ( tp a, const sc_fxval_fast& b ) \
01868 { \
01869 SC_FXVAL_FAST_OBSERVER_READ_( b ) \
01870 sc_fxval_fast tmp( a ); \
01871 return ( tmp.m_val op b.m_val ); \
01872 }
01873
01874 #ifndef SC_FX_EXCLUDE_OTHER
01875 #define DEFN_REL_OP_OTHER(op) \
01876 DEFN_REL_OP_T(op,int64) \
01877 DEFN_REL_OP_T(op,uint64) \
01878 DEFN_REL_OP_T(op,const sc_int_base&) \
01879 DEFN_REL_OP_T(op,const sc_uint_base&) \
01880 DEFN_REL_OP_T(op,const sc_signed&) \
01881 DEFN_REL_OP_T(op,const sc_unsigned&)
01882 #else
01883 #define DEFN_REL_OP_OTHER(op)
01884 #endif
01885
01886 #define DEFN_REL_OP(op) \
01887 inline \
01888 bool \
01889 operator op ( const sc_fxval_fast& a, const sc_fxval_fast& b ) \
01890 { \
01891 SC_FXVAL_FAST_OBSERVER_READ_( a ) \
01892 SC_FXVAL_FAST_OBSERVER_READ_( b ) \
01893 return ( a.m_val op b.m_val ); \
01894 } \
01895 \
01896 DEFN_REL_OP_T(op,int) \
01897 DEFN_REL_OP_T(op,unsigned int) \
01898 DEFN_REL_OP_T(op,long) \
01899 DEFN_REL_OP_T(op,unsigned long) \
01900 DEFN_REL_OP_T(op,double) \
01901 DEFN_REL_OP_T(op,const char*) \
01902 DEFN_REL_OP_OTHER(op)
01903
01904 DEFN_REL_OP(<)
01905 DEFN_REL_OP(<=)
01906 DEFN_REL_OP(>)
01907 DEFN_REL_OP(>=)
01908 DEFN_REL_OP(==)
01909 DEFN_REL_OP(!=)
01910
01911 #undef DEFN_REL_OP_T
01912 #undef DEFN_REL_OP_OTHER
01913 #undef DEFN_REL_OP
01914
01915
01916
01917
01918 inline
01919 sc_fxval_fast&
01920 sc_fxval_fast::operator = ( const sc_fxval_fast& a )
01921 {
01922 if( &a != this )
01923 {
01924 SC_FXVAL_FAST_OBSERVER_READ_( a )
01925 m_val = a.m_val;
01926 SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
01927 }
01928 return *this;
01929 }
01930
01931 #define DEFN_ASN_OP_T(tp) \
01932 inline \
01933 sc_fxval_fast& \
01934 sc_fxval_fast::operator = ( tp a ) \
01935 { \
01936 sc_fxval_fast tmp( a ); \
01937 m_val = tmp.m_val; \
01938 SC_FXVAL_FAST_OBSERVER_WRITE_( *this ) \
01939 return *this; \
01940 }
01941
01942 DEFN_ASN_OP_T(int)
01943 DEFN_ASN_OP_T(unsigned int)
01944 DEFN_ASN_OP_T(long)
01945 DEFN_ASN_OP_T(unsigned long)
01946 DEFN_ASN_OP_T(double)
01947 DEFN_ASN_OP_T(const char*)
01948 DEFN_ASN_OP_T(const sc_fxval&)
01949 #ifndef SC_FX_EXCLUDE_OTHER
01950 DEFN_ASN_OP_T(int64)
01951 DEFN_ASN_OP_T(uint64)
01952 DEFN_ASN_OP_T(const sc_int_base&)
01953 DEFN_ASN_OP_T(const sc_uint_base&)
01954 DEFN_ASN_OP_T(const sc_signed&)
01955 DEFN_ASN_OP_T(const sc_unsigned&)
01956 #endif
01957
01958 #undef DEFN_ASN_OP_T
01959
01960
01961 #define DEFN_ASN_OP_T(op,tp) \
01962 inline \
01963 sc_fxval_fast& \
01964 sc_fxval_fast::operator op ( tp b ) \
01965 { \
01966 SC_FXVAL_FAST_OBSERVER_READ_( *this ) \
01967 sc_fxval_fast tmp( b ); \
01968 m_val op tmp.m_val; \
01969 SC_FXVAL_FAST_OBSERVER_WRITE_( *this ) \
01970 return *this; \
01971 }
01972
01973 #ifndef SC_FX_EXCLUDE_OTHER
01974 #define DEFN_ASN_OP_OTHER(op) \
01975 DEFN_ASN_OP_T(op,int64) \
01976 DEFN_ASN_OP_T(op,uint64) \
01977 DEFN_ASN_OP_T(op,const sc_int_base&) \
01978 DEFN_ASN_OP_T(op,const sc_uint_base&) \
01979 DEFN_ASN_OP_T(op,const sc_signed&) \
01980 DEFN_ASN_OP_T(op,const sc_unsigned&)
01981 #else
01982 #define DEFN_ASN_OP_OTHER(op)
01983 #endif
01984
01985 #define DEFN_ASN_OP(op) \
01986 inline \
01987 sc_fxval_fast& \
01988 sc_fxval_fast::operator op ( const sc_fxval_fast& b ) \
01989 { \
01990 SC_FXVAL_FAST_OBSERVER_READ_( *this ) \
01991 SC_FXVAL_FAST_OBSERVER_READ_( b ) \
01992 m_val op b.m_val; \
01993 SC_FXVAL_FAST_OBSERVER_WRITE_( *this ) \
01994 return *this; \
01995 } \
01996 \
01997 DEFN_ASN_OP_T(op,int) \
01998 DEFN_ASN_OP_T(op,unsigned int) \
01999 DEFN_ASN_OP_T(op,long) \
02000 DEFN_ASN_OP_T(op,unsigned long) \
02001 DEFN_ASN_OP_T(op,double) \
02002 DEFN_ASN_OP_T(op,const char*) \
02003 DEFN_ASN_OP_T(op,const sc_fxval&) \
02004 DEFN_ASN_OP_OTHER(op)
02005
02006 DEFN_ASN_OP(*=)
02007 DEFN_ASN_OP(/=)
02008 DEFN_ASN_OP(+=)
02009 DEFN_ASN_OP(-=)
02010
02011 #undef DEFN_ASN_OP_T
02012 #undef DEFN_ASN_OP_OTHER
02013 #undef DEFN_ASN_OP
02014
02015
02016 inline
02017 sc_fxval_fast&
02018 sc_fxval_fast::operator <<= ( int b )
02019 {
02020 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02021 m_val *= scfx_pow2( b );
02022 SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
02023 return *this;
02024 }
02025
02026 inline
02027 sc_fxval_fast&
02028 sc_fxval_fast::operator >>= ( int b )
02029 {
02030 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02031 m_val *= scfx_pow2( -b );
02032 SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
02033 return *this;
02034 }
02035
02036
02037
02038
02039 inline
02040 const sc_fxval_fast
02041 sc_fxval_fast::operator ++ ( int )
02042 {
02043 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02044 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02045 double c = m_val;
02046 m_val = m_val + 1;
02047 SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
02048 return sc_fxval_fast( c );
02049 }
02050
02051 inline
02052 const sc_fxval_fast
02053 sc_fxval_fast::operator -- ( int )
02054 {
02055 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02056 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02057 double c = m_val;
02058 m_val = m_val - 1;
02059 SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
02060 return sc_fxval_fast( c );
02061 }
02062
02063 inline
02064 sc_fxval_fast&
02065 sc_fxval_fast::operator ++ ()
02066 {
02067 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02068 m_val = m_val + 1;
02069 SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
02070 return *this;
02071 }
02072
02073 inline
02074 sc_fxval_fast&
02075 sc_fxval_fast::operator -- ()
02076 {
02077 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02078 m_val = m_val - 1;
02079 SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
02080 return *this;
02081 }
02082
02083
02084
02085
02086 inline
02087 sc_fxval_fast::operator double() const
02088 {
02089 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02090 return m_val;
02091 }
02092
02093
02094
02095
02096 inline
02097 short
02098 sc_fxval_fast::to_short() const
02099 {
02100 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02101 return static_cast<short>( m_val );
02102 }
02103
02104 inline
02105 unsigned short
02106 sc_fxval_fast::to_ushort() const
02107 {
02108 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02109 return static_cast<unsigned short>( m_val );
02110 }
02111
02112 inline
02113 int64
02114 sc_fxval_fast::to_int64() const
02115 {
02116 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02117 return static_cast<int64>( m_val );
02118 }
02119
02120 inline
02121 int
02122 sc_fxval_fast::to_int() const
02123 {
02124 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02125 return static_cast<int>( m_val );
02126 }
02127
02128 inline
02129 unsigned int
02130 sc_fxval_fast::to_uint() const
02131 {
02132 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02133 return static_cast<unsigned int>( m_val );
02134 }
02135
02136 inline
02137 uint64
02138 sc_fxval_fast::to_uint64() const
02139 {
02140 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02141 return static_cast<uint64>( m_val );
02142 }
02143
02144 inline
02145 long
02146 sc_fxval_fast::to_long() const
02147 {
02148 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02149 return static_cast<long>( m_val );
02150 }
02151
02152 inline
02153 unsigned long
02154 sc_fxval_fast::to_ulong() const
02155 {
02156 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02157 return static_cast<unsigned long>( m_val );
02158 }
02159
02160 inline
02161 float
02162 sc_fxval_fast::to_float() const
02163 {
02164 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02165 return static_cast<float>( m_val );
02166 }
02167
02168 inline
02169 double
02170 sc_fxval_fast::to_double() const
02171 {
02172 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02173 return m_val;
02174 }
02175
02176
02177
02178
02179 inline
02180 bool
02181 sc_fxval_fast::is_neg() const
02182 {
02183 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02184 scfx_ieee_double id( m_val );
02185 return ( id.negative() != 0 );
02186 }
02187
02188 inline
02189 bool
02190 sc_fxval_fast::is_zero() const
02191 {
02192 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02193 scfx_ieee_double id( m_val );
02194 return id.is_zero();
02195 }
02196
02197 inline
02198 bool
02199 sc_fxval_fast::is_nan() const
02200 {
02201 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02202 scfx_ieee_double id( m_val );
02203 return id.is_nan();
02204 }
02205
02206 inline
02207 bool
02208 sc_fxval_fast::is_inf() const
02209 {
02210 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02211 scfx_ieee_double id( m_val );
02212 return id.is_inf();
02213 }
02214
02215 inline
02216 bool
02217 sc_fxval_fast::is_normal() const
02218 {
02219 SC_FXVAL_FAST_OBSERVER_READ_( *this )
02220 scfx_ieee_double id( m_val );
02221 return ( id.is_normal() || id.is_subnormal() || id.is_zero() );
02222 }
02223
02224
02225 inline
02226 bool
02227 sc_fxval_fast::rounding_flag() const
02228 {
02229
02230 return false;
02231 }
02232
02233
02234 inline
02235 ::std::ostream&
02236 operator << ( ::std::ostream& os, const sc_fxval_fast& a )
02237 {
02238 a.print( os );
02239 return os;
02240 }
02241
02242 inline
02243 ::std::istream&
02244 operator >> ( ::std::istream& is, sc_fxval_fast& a )
02245 {
02246 a.scan( is );
02247 return is;
02248 }
02249
02250 }
02251
02252
02253 #endif
02254
02255
