SystemC: sysc/datatypes/fx/sc_fixed.h Source File

00001 /*****************************************************************************
00002 
00003   The following code is derived, directly or indirectly, from the SystemC
00004   source code Copyright (c) 1996-2014 by all Contributors.
00005   All Rights reserved.
00006 
00007   The contents of this file are subject to the restrictions and limitations
00008   set forth in the SystemC Open Source License (the "License");
00009   You may not use this file except in compliance with such restrictions and
00010   limitations. You may obtain instructions on how to receive a copy of the
00011   License at http://www.accellera.org/. Software distributed by Contributors
00012   under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
00013   ANY KIND, either express or implied. See the License for the specific
00014   language governing rights and limitations under the License.
00015 
00016  *****************************************************************************/
00017 
00018 /*****************************************************************************
00019 
00020   sc_fixed.h - 
00021 
00022   Original Author: Martin Janssen, Synopsys, Inc.
00023 
00024  *****************************************************************************/
00025 
00026 /*****************************************************************************
00027 
00028   MODIFICATION LOG - modifiers, enter your name, affiliation, date and
00029   changes you are making here.
00030 
00031       Name, Affiliation, Date:
00032   Description of Modification:
00033 
00034  *****************************************************************************/
00035 
00036 // $Log: sc_fixed.h,v $
00037 // Revision 1.2  2011/01/19 18:57:40  acg
00038 //  Andy Goodrich: changes for IEEE_1666_2011.
00039 //
00040 // Revision 1.1.1.1  2006/12/15 20:20:04  acg
00041 // SystemC 2.3
00042 //
00043 // Revision 1.3  2006/01/13 18:53:57  acg
00044 // Andy Goodrich: added $Log command so that CVS comments are reproduced in
00045 // the source.
00046 //
00047 
00048 #ifndef SC_FIXED_H
00049 #define SC_FIXED_H
00050 
00051 
00052 #include "sysc/datatypes/fx/sc_fix.h"
00053 
00054 
00055 namespace sc_dt
00056 {
00057 
00058 // classes defined in this module
00059 template <int W, int I, sc_q_mode Q, sc_o_mode O, int N> class sc_fixed;
00060 template <int W, int I, sc_q_mode Q, sc_o_mode O, int N> class sc_fixed_fast;
00061 
00062 
00063 // ----------------------------------------------------------------------------
00064 //  TEMPLATE CLASS : sc_fixed
00065 //
00066 //  "Constrained" signed fixed-point class; arbitrary precision.
00067 // ----------------------------------------------------------------------------
00068 
00069 template <int W, int I,
00070           sc_q_mode Q = SC_DEFAULT_Q_MODE_,
00071           sc_o_mode O = SC_DEFAULT_O_MODE_, int N = SC_DEFAULT_N_BITS_>
00072 class sc_fixed : public sc_fix
00073 {
00074 
00075 public:
00076 
00077     // constructors
00078 
00079     explicit sc_fixed( sc_fxnum_observer* = 0 );
00080     explicit sc_fixed( const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
00081 
00082 #define DECL_CTORS_T_A(tp)                                                    \
00083              sc_fixed( tp, sc_fxnum_observer* = 0 );                          \
00084              sc_fixed( tp, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
00085 
00086 #define DECL_CTORS_T_B(tp)                                                    \
00087     explicit sc_fixed( tp, sc_fxnum_observer* = 0 );                          \
00088              sc_fixed( tp, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
00089 
00090     DECL_CTORS_T_A(int)
00091     DECL_CTORS_T_A(unsigned int)
00092     DECL_CTORS_T_A(long)
00093     DECL_CTORS_T_A(unsigned long)
00094     DECL_CTORS_T_A(float)
00095     DECL_CTORS_T_A(double)
00096     DECL_CTORS_T_A(const char*)
00097     DECL_CTORS_T_A(const sc_fxval&)
00098     DECL_CTORS_T_A(const sc_fxval_fast&)
00099     DECL_CTORS_T_A(const sc_fxnum&)
00100     DECL_CTORS_T_A(const sc_fxnum_fast&)
00101 #ifndef SC_FX_EXCLUDE_OTHER
00102     DECL_CTORS_T_B(int64)
00103     DECL_CTORS_T_B(uint64)
00104     DECL_CTORS_T_B(const sc_int_base&)
00105     DECL_CTORS_T_B(const sc_uint_base&)
00106     DECL_CTORS_T_B(const sc_signed&)
00107     DECL_CTORS_T_B(const sc_unsigned&)
00108 #endif
00109 
00110 #undef DECL_CTORS_T_A
00111 #undef DECL_CTORS_T_B
00112 
00113     // copy constructor
00114 
00115     sc_fixed( const sc_fixed<W,I,Q,O,N>& );
00116 
00117 
00118     // assignment operators
00119 
00120     sc_fixed& operator = ( const sc_fixed<W,I,Q,O,N>& );
00121 
00122 #define DECL_ASN_OP_T(op,tp)                                                  \
00123     sc_fixed& operator op ( tp );
00124 
00125 #ifndef SC_FX_EXCLUDE_OTHER
00126 #define DECL_ASN_OP_OTHER(op)                                                 \
00127     DECL_ASN_OP_T(op,int64)                                                   \
00128     DECL_ASN_OP_T(op,uint64)                                                  \
00129     DECL_ASN_OP_T(op,const sc_int_base&)                                      \
00130     DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
00131     DECL_ASN_OP_T(op,const sc_signed&)                                        \
00132     DECL_ASN_OP_T(op,const sc_unsigned&)
00133 #else
00134 #define DECL_ASN_OP_OTHER(op)
00135 #endif
00136 
00137 #define DECL_ASN_OP(op)                                                       \
00138     DECL_ASN_OP_T(op,int)                                                     \
00139     DECL_ASN_OP_T(op,unsigned int)                                            \
00140     DECL_ASN_OP_T(op,long)                                                    \
00141     DECL_ASN_OP_T(op,unsigned long)                                           \
00142     DECL_ASN_OP_T(op,float)                                                  \
00143     DECL_ASN_OP_T(op,double)                                                  \
00144     DECL_ASN_OP_T(op,const char*)                                             \
00145     DECL_ASN_OP_T(op,const sc_fxval&)                                         \
00146     DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
00147     DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
00148     DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
00149     DECL_ASN_OP_OTHER(op)
00150 
00151     DECL_ASN_OP(=)
00152 
00153     DECL_ASN_OP(*=)
00154     DECL_ASN_OP(/=)
00155     DECL_ASN_OP(+=)
00156     DECL_ASN_OP(-=)
00157 
00158     DECL_ASN_OP_T(<<=,int)
00159     DECL_ASN_OP_T(>>=,int)
00160 
00161     DECL_ASN_OP_T(&=,const sc_fix&)
00162     DECL_ASN_OP_T(&=,const sc_fix_fast&)
00163     DECL_ASN_OP_T(|=,const sc_fix&)
00164     DECL_ASN_OP_T(|=,const sc_fix_fast&)
00165     DECL_ASN_OP_T(^=,const sc_fix&)
00166     DECL_ASN_OP_T(^=,const sc_fix_fast&)
00167 
00168 #undef DECL_ASN_OP_T
00169 #undef DECL_ASN_OP_OTHER
00170 #undef DECL_ASN_OP
00171 
00172 
00173     // auto-increment and auto-decrement
00174 
00175     const sc_fxval operator ++ ( int );
00176     const sc_fxval operator -- ( int );
00177 
00178     sc_fixed& operator ++ ();
00179     sc_fixed& operator -- ();
00180 
00181 };
00182 
00183 
00184 // ----------------------------------------------------------------------------
00185 //  TEMPLATE CLASS : sc_fixed_fast
00186 //
00187 //  "Constrained" signed fixed-point class; limited precision.
00188 // ----------------------------------------------------------------------------
00189 
00190 template <int W, int I,
00191           sc_q_mode Q = SC_DEFAULT_Q_MODE_,
00192           sc_o_mode O = SC_DEFAULT_O_MODE_, int N = SC_DEFAULT_N_BITS_>
00193 class sc_fixed_fast : public sc_fix_fast
00194 {
00195 
00196 public:
00197 
00198     // constructors
00199 
00200     explicit sc_fixed_fast( sc_fxnum_fast_observer* = 0 );
00201     explicit sc_fixed_fast( const sc_fxcast_switch&,
00202                             sc_fxnum_fast_observer* = 0 );
00203 
00204 #define DECL_CTORS_T_A(tp)                                                    \
00205              sc_fixed_fast( tp, sc_fxnum_fast_observer* = 0 );                \
00206              sc_fixed_fast( tp, const sc_fxcast_switch&,                      \
00207                             sc_fxnum_fast_observer* = 0 );
00208 
00209 #define DECL_CTORS_T_B(tp)                                                    \
00210     explicit sc_fixed_fast( tp, sc_fxnum_fast_observer* = 0 );                \
00211              sc_fixed_fast( tp, const sc_fxcast_switch&,                      \
00212                             sc_fxnum_fast_observer* = 0 );
00213 
00214     DECL_CTORS_T_A(int)
00215     DECL_CTORS_T_A(unsigned int)
00216     DECL_CTORS_T_A(long)
00217     DECL_CTORS_T_A(unsigned long)
00218     DECL_CTORS_T_A(float)
00219     DECL_CTORS_T_A(double)
00220     DECL_CTORS_T_A(const char*)
00221     DECL_CTORS_T_A(const sc_fxval&)
00222     DECL_CTORS_T_A(const sc_fxval_fast&)
00223     DECL_CTORS_T_A(const sc_fxnum&)
00224     DECL_CTORS_T_A(const sc_fxnum_fast&)
00225 #ifndef SC_FX_EXCLUDE_OTHER
00226     DECL_CTORS_T_B(int64)
00227     DECL_CTORS_T_B(uint64)
00228     DECL_CTORS_T_B(const sc_int_base&)
00229     DECL_CTORS_T_B(const sc_uint_base&)
00230     DECL_CTORS_T_B(const sc_signed&)
00231     DECL_CTORS_T_B(const sc_unsigned&)
00232 #endif
00233 
00234 #undef DECL_CTORS_T_A
00235 #undef DECL_CTORS_T_B
00236 
00237     // copy constructor
00238 
00239     sc_fixed_fast( const sc_fixed_fast<W,I,Q,O,N>& );
00240 
00241 
00242     // assignment operators
00243 
00244     sc_fixed_fast& operator = ( const sc_fixed_fast<W,I,Q,O,N>& );
00245 
00246 #define DECL_ASN_OP_T(op,tp)                                                  \
00247     sc_fixed_fast& operator op ( tp );
00248 
00249 #ifndef SC_FX_EXCLUDE_OTHER
00250 #define DECL_ASN_OP_OTHER(op)                                                 \
00251     DECL_ASN_OP_T(op,int64)                                                   \
00252     DECL_ASN_OP_T(op,uint64)                                                  \
00253     DECL_ASN_OP_T(op,const sc_int_base&)                                      \
00254     DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
00255     DECL_ASN_OP_T(op,const sc_signed&)                                        \
00256     DECL_ASN_OP_T(op,const sc_unsigned&)
00257 #else
00258 #define DECL_ASN_OP_OTHER(op)
00259 #endif
00260 
00261 #define DECL_ASN_OP(op)                                                       \
00262     DECL_ASN_OP_T(op,int)                                                     \
00263     DECL_ASN_OP_T(op,unsigned int)                                            \
00264     DECL_ASN_OP_T(op,long)                                                    \
00265     DECL_ASN_OP_T(op,unsigned long)                                           \
00266     DECL_ASN_OP_T(op,float)                                                  \
00267     DECL_ASN_OP_T(op,double)                                                  \
00268     DECL_ASN_OP_T(op,const char*)                                             \
00269     DECL_ASN_OP_T(op,const sc_fxval&)                                         \
00270     DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
00271     DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
00272     DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
00273     DECL_ASN_OP_OTHER(op)
00274 
00275     DECL_ASN_OP(=)
00276 
00277     DECL_ASN_OP(*=)
00278     DECL_ASN_OP(/=)
00279     DECL_ASN_OP(+=)
00280     DECL_ASN_OP(-=)
00281 
00282     DECL_ASN_OP_T(<<=,int)
00283     DECL_ASN_OP_T(>>=,int)
00284 
00285     DECL_ASN_OP_T(&=,const sc_fix&)
00286     DECL_ASN_OP_T(&=,const sc_fix_fast&)
00287     DECL_ASN_OP_T(|=,const sc_fix&)
00288     DECL_ASN_OP_T(|=,const sc_fix_fast&)
00289     DECL_ASN_OP_T(^=,const sc_fix&)
00290     DECL_ASN_OP_T(^=,const sc_fix_fast&)
00291 
00292 #undef DECL_ASN_OP_T
00293 #undef DECL_ASN_OP_OTHER
00294 #undef DECL_ASN_OP
00295 
00296 
00297     // auto-increment and auto-decrement
00298 
00299     const sc_fxval_fast operator ++ ( int );
00300     const sc_fxval_fast operator -- ( int );
00301 
00302     sc_fixed_fast& operator ++ ();
00303     sc_fixed_fast& operator -- ();
00304 
00305 };
00306 
00307 
00308 // IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
00309 
00310 // ----------------------------------------------------------------------------
00311 //  TEMPLATE CLASS : sc_fixed
00312 //
00313 //  "Constrained" signed fixed-point class; arbitrary precision.
00314 // ----------------------------------------------------------------------------
00315 
00316 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00317 inline
00318 sc_fixed<W,I,Q,O,N>::sc_fixed( sc_fxnum_observer* observer_ )
00319 : sc_fix( W, I, Q, O, N, observer_ )
00320 {}
00321 
00322 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00323 inline
00324 sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxcast_switch& cast_sw,
00325                                sc_fxnum_observer* observer_ )
00326 : sc_fix( W, I, Q, O, N, cast_sw, observer_ )
00327 {}
00328 
00329 #define DEFN_CTORS_T(tp)                                                      \
00330 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
00331 inline                                                                        \
00332 sc_fixed<W,I,Q,O,N>::sc_fixed( tp a,                                          \
00333                                sc_fxnum_observer* observer_ )                 \
00334 : sc_fix( a, W, I, Q, O, N, observer_ )                                       \
00335 {}                                                                            \
00336                                                                               \
00337 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
00338 inline                                                                        \
00339 sc_fixed<W,I,Q,O,N>::sc_fixed( tp a,                                          \
00340                                const sc_fxcast_switch& cast_sw,               \
00341                                sc_fxnum_observer* observer_ )                 \
00342 : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ )                              \
00343 {}
00344 
00345 DEFN_CTORS_T(int)
00346 DEFN_CTORS_T(unsigned int)
00347 DEFN_CTORS_T(long)
00348 DEFN_CTORS_T(unsigned long)
00349 DEFN_CTORS_T(float)
00350 DEFN_CTORS_T(double)
00351 DEFN_CTORS_T(const char*)
00352 DEFN_CTORS_T(const sc_fxval&)
00353 DEFN_CTORS_T(const sc_fxval_fast&)
00354 DEFN_CTORS_T(const sc_fxnum&)
00355 DEFN_CTORS_T(const sc_fxnum_fast&)
00356 #ifndef SC_FX_EXCLUDE_OTHER
00357 DEFN_CTORS_T(int64)
00358 DEFN_CTORS_T(uint64)
00359 DEFN_CTORS_T(const sc_int_base&)
00360 DEFN_CTORS_T(const sc_uint_base&)
00361 DEFN_CTORS_T(const sc_signed&)
00362 DEFN_CTORS_T(const sc_unsigned&)
00363 #endif
00364 
00365 #undef DEFN_CTORS_T
00366 
00367 // copy constructor
00368 
00369 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00370 inline
00371 sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fixed<W,I,Q,O,N>& a )
00372 : sc_fix( a, W, I, Q, O, N )
00373 {}
00374 
00375 
00376 // assignment operators
00377 
00378 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00379 inline
00380 sc_fixed<W,I,Q,O,N>&
00381 sc_fixed<W,I,Q,O,N>::operator = ( const sc_fixed<W,I,Q,O,N>& a )
00382 {
00383     sc_fix::operator = ( a );
00384     return *this;
00385 }
00386 
00387 #define DEFN_ASN_OP_T(op,tp)                                                  \
00388 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
00389 inline                                                                        \
00390 sc_fixed<W,I,Q,O,N>&                                                          \
00391 sc_fixed<W,I,Q,O,N>::operator op ( tp a )                                     \
00392 {                                                                             \
00393     sc_fix::operator op ( a );                                                \
00394     return *this;                                                             \
00395 }
00396 
00397 #ifndef SC_FX_EXCLUDE_OTHER
00398 #define DEFN_ASN_OP_OTHER(op)                                                 \
00399 DEFN_ASN_OP_T(op,int64)                                                       \
00400 DEFN_ASN_OP_T(op,uint64)                                                      \
00401 DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
00402 DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
00403 DEFN_ASN_OP_T(op,const sc_signed&)                                            \
00404 DEFN_ASN_OP_T(op,const sc_unsigned&)
00405 #else
00406 #define DEFN_ASN_OP_OTHER(op)
00407 #endif
00408 
00409 #define DEFN_ASN_OP(op)                                                       \
00410 DEFN_ASN_OP_T(op,int)                                                         \
00411 DEFN_ASN_OP_T(op,unsigned int)                                                \
00412 DEFN_ASN_OP_T(op,long)                                                        \
00413 DEFN_ASN_OP_T(op,unsigned long)                                               \
00414 DEFN_ASN_OP_T(op,float)                                                      \
00415 DEFN_ASN_OP_T(op,double)                                                      \
00416 DEFN_ASN_OP_T(op,const char*)                                                 \
00417 DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
00418 DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
00419 DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
00420 DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
00421 DEFN_ASN_OP_OTHER(op)
00422 
00423 DEFN_ASN_OP(=)
00424 
00425 DEFN_ASN_OP(*=)
00426 DEFN_ASN_OP(/=)
00427 DEFN_ASN_OP(+=)
00428 DEFN_ASN_OP(-=)
00429 
00430 DEFN_ASN_OP_T(<<=,int)
00431 DEFN_ASN_OP_T(>>=,int)
00432 
00433 DEFN_ASN_OP_T(&=,const sc_fix&)
00434 DEFN_ASN_OP_T(&=,const sc_fix_fast&)
00435 DEFN_ASN_OP_T(|=,const sc_fix&)
00436 DEFN_ASN_OP_T(|=,const sc_fix_fast&)
00437 DEFN_ASN_OP_T(^=,const sc_fix&)
00438 DEFN_ASN_OP_T(^=,const sc_fix_fast&)
00439 
00440 #undef DEFN_ASN_OP_T
00441 #undef DEFN_ASN_OP_OTHER
00442 #undef DEFN_ASN_OP
00443 
00444 
00445 // auto-increment and auto-decrement
00446 
00447 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00448 inline
00449 const sc_fxval
00450 sc_fixed<W,I,Q,O,N>::operator ++ ( int )
00451 {
00452     return sc_fxval( sc_fix::operator ++ ( 0 ) );
00453 }
00454 
00455 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00456 inline
00457 const sc_fxval
00458 sc_fixed<W,I,Q,O,N>::operator -- ( int )
00459 {
00460     return sc_fxval( sc_fix::operator -- ( 0 ) );
00461 }
00462 
00463 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00464 inline
00465 sc_fixed<W,I,Q,O,N>&
00466 sc_fixed<W,I,Q,O,N>::operator ++ ()
00467 {
00468     sc_fix::operator ++ ();
00469     return *this;
00470 }
00471 
00472 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00473 inline
00474 sc_fixed<W,I,Q,O,N>&
00475 sc_fixed<W,I,Q,O,N>::operator -- ()
00476 {
00477     sc_fix::operator -- ();
00478     return *this;
00479 }
00480 
00481 
00482 // ----------------------------------------------------------------------------
00483 //  TEMPLATE CLASS : sc_fixed_fast
00484 //
00485 //  "Constrained" signed fixed-point class; limited precision.
00486 // ----------------------------------------------------------------------------
00487 
00488 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00489 inline
00490 sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( sc_fxnum_fast_observer* observer_ )
00491 : sc_fix_fast( W, I, Q, O, N, observer_ )
00492 {}
00493 
00494 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00495 inline
00496 sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxcast_switch& cast_sw,
00497                                          sc_fxnum_fast_observer* observer_ )
00498 : sc_fix_fast( W, I, Q, O, N, cast_sw, observer_ )
00499 {}
00500 
00501 #define DEFN_CTORS_T(tp)                                                      \
00502 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
00503 inline                                                                        \
00504 sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( tp a,                                \
00505                                          sc_fxnum_fast_observer* observer_ )  \
00506 : sc_fix_fast( a, W, I, Q, O, N, observer_ )                                  \
00507 {}                                                                            \
00508                                                                               \
00509 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
00510 inline                                                                        \
00511 sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( tp a,                                \
00512                                          const sc_fxcast_switch& cast_sw,     \
00513                                          sc_fxnum_fast_observer* observer_ )  \
00514 : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ )                         \
00515 {}
00516 
00517 DEFN_CTORS_T(int)
00518 DEFN_CTORS_T(unsigned int)
00519 DEFN_CTORS_T(long)
00520 DEFN_CTORS_T(unsigned long)
00521 DEFN_CTORS_T(float)
00522 DEFN_CTORS_T(double)
00523 DEFN_CTORS_T(const char*)
00524 DEFN_CTORS_T(const sc_fxval&)
00525 DEFN_CTORS_T(const sc_fxval_fast&)
00526 DEFN_CTORS_T(const sc_fxnum&)
00527 DEFN_CTORS_T(const sc_fxnum_fast&)
00528 #ifndef SC_FX_EXCLUDE_OTHER
00529 DEFN_CTORS_T(int64)
00530 DEFN_CTORS_T(uint64)
00531 DEFN_CTORS_T(const sc_int_base&)
00532 DEFN_CTORS_T(const sc_uint_base&)
00533 DEFN_CTORS_T(const sc_signed&)
00534 DEFN_CTORS_T(const sc_unsigned&)
00535 #endif
00536 
00537 #undef DEFN_CTORS_T
00538 
00539 // copy constructor
00540 
00541 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00542 inline
00543 sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fixed_fast<W,I,Q,O,N>& a )
00544 : sc_fix_fast( a, W, I, Q, O, N )
00545 {}
00546 
00547 
00548 // assignment operators
00549 
00550 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00551 inline
00552 sc_fixed_fast<W,I,Q,O,N>&
00553 sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_fixed_fast<W,I,Q,O,N>& a )
00554 {
00555     sc_fix_fast::operator = ( a );
00556     return *this;
00557 }
00558 
00559 #define DEFN_ASN_OP_T(op,tp)                                                  \
00560 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
00561 inline                                                                        \
00562 sc_fixed_fast<W,I,Q,O,N>&                                                     \
00563 sc_fixed_fast<W,I,Q,O,N>::operator op ( tp a )                                \
00564 {                                                                             \
00565     sc_fix_fast::operator op ( a );                                           \
00566     return *this;                                                             \
00567 }
00568 
00569 #ifndef SC_FX_EXCLUDE_OTHER
00570 #define DEFN_ASN_OP_OTHER(op)                                                 \
00571 DEFN_ASN_OP_T(op,int64)                                                       \
00572 DEFN_ASN_OP_T(op,uint64)                                                      \
00573 DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
00574 DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
00575 DEFN_ASN_OP_T(op,const sc_signed&)                                            \
00576 DEFN_ASN_OP_T(op,const sc_unsigned&)
00577 #else
00578 #define DEFN_ASN_OP_OTHER(op)
00579 #endif
00580 
00581 #define DEFN_ASN_OP(op)                                                       \
00582 DEFN_ASN_OP_T(op,int)                                                         \
00583 DEFN_ASN_OP_T(op,unsigned int)                                                \
00584 DEFN_ASN_OP_T(op,long)                                                        \
00585 DEFN_ASN_OP_T(op,unsigned long)                                               \
00586 DEFN_ASN_OP_T(op,float)                                                      \
00587 DEFN_ASN_OP_T(op,double)                                                      \
00588 DEFN_ASN_OP_T(op,const char*)                                                 \
00589 DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
00590 DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
00591 DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
00592 DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
00593 DEFN_ASN_OP_OTHER(op)
00594 
00595 DEFN_ASN_OP(=)
00596 
00597 DEFN_ASN_OP(*=)
00598 DEFN_ASN_OP(/=)
00599 DEFN_ASN_OP(+=)
00600 DEFN_ASN_OP(-=)
00601 
00602 DEFN_ASN_OP_T(<<=,int)
00603 DEFN_ASN_OP_T(>>=,int)
00604 
00605 DEFN_ASN_OP_T(&=,const sc_fix&)
00606 DEFN_ASN_OP_T(&=,const sc_fix_fast&)
00607 DEFN_ASN_OP_T(|=,const sc_fix&)
00608 DEFN_ASN_OP_T(|=,const sc_fix_fast&)
00609 DEFN_ASN_OP_T(^=,const sc_fix&)
00610 DEFN_ASN_OP_T(^=,const sc_fix_fast&)
00611 
00612 #undef DEFN_ASN_OP_T
00613 #undef DEFN_ASN_OP_OTHER
00614 #undef DEFN_ASN_OP
00615 
00616 
00617 // auto-increment and auto-decrement
00618 
00619 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00620 inline
00621 const sc_fxval_fast
00622 sc_fixed_fast<W,I,Q,O,N>::operator ++ ( int )
00623 {
00624     return sc_fxval_fast( sc_fix_fast::operator ++ ( 0 ) );
00625 }
00626 
00627 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00628 inline
00629 const sc_fxval_fast
00630 sc_fixed_fast<W,I,Q,O,N>::operator -- ( int )
00631 {
00632     return sc_fxval_fast( sc_fix_fast::operator -- ( 0 ) );
00633 }
00634 
00635 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00636 inline
00637 sc_fixed_fast<W,I,Q,O,N>&
00638 sc_fixed_fast<W,I,Q,O,N>::operator ++ ()
00639 {
00640     sc_fix_fast::operator ++ ();
00641     return *this;
00642 }
00643 
00644 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
00645 inline
00646 sc_fixed_fast<W,I,Q,O,N>&
00647 sc_fixed_fast<W,I,Q,O,N>::operator -- ()
00648 {
00649     sc_fix_fast::operator -- ();
00650     return *this;
00651 }
00652 
00653 } // namespace sc_dt
00654 
00655 
00656 #endif
00657 
00658 // Taf!