sc_fixed.h

system C源码 一种替代verilog的语言

sc_fixed<W,I,Q,O,N>::sc_fixed( tp a,                                          \
			       sc_fxnum_observer* observer_ )                 \
: sc_fix( a, W, I, Q, O, N, observer_ )                                       \
{}                                                                            \
                                                                              \
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
inline                                                                        \
sc_fixed<W,I,Q,O,N>::sc_fixed( tp a,                                          \
			       const sc_fxcast_switch& cast_sw,               \
			       sc_fxnum_observer* observer_ )                 \
: sc_fix( a, W, I, Q, O, N, cast_sw, observer_ )                              \
{}

DEFN_CTORS_T(int)
DEFN_CTORS_T(unsigned int)
DEFN_CTORS_T(long)
DEFN_CTORS_T(unsigned long)
DEFN_CTORS_T(double)
DEFN_CTORS_T(const char*)
DEFN_CTORS_T(const sc_fxval&)
DEFN_CTORS_T(const sc_fxval_fast&)
DEFN_CTORS_T(const sc_fxnum&)
DEFN_CTORS_T(const sc_fxnum_fast&)
#ifndef SC_FX_EXCLUDE_OTHER
DEFN_CTORS_T(int64)
DEFN_CTORS_T(uint64)
DEFN_CTORS_T(const sc_int_base&)
DEFN_CTORS_T(const sc_uint_base&)
DEFN_CTORS_T(const sc_signed&)
DEFN_CTORS_T(const sc_unsigned&)
#endif

#undef DEFN_CTORS_T

// copy constructor

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fixed<W,I,Q,O,N>& a )
: sc_fix( a, W, I, Q, O, N )
{}


// assignment operators

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed<W,I,Q,O,N>&
sc_fixed<W,I,Q,O,N>::operator = ( const sc_fixed<W,I,Q,O,N>& a )
{
    sc_fix::operator = ( a );
    return *this;
}

#define DEFN_ASN_OP_T(op,tp)                                                  \
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
inline                                                                        \
sc_fixed<W,I,Q,O,N>&                                                          \
sc_fixed<W,I,Q,O,N>::operator op ( tp a )                                     \
{                                                                             \
    sc_fix::operator op ( a );                                                \
    return *this;                                                             \
}

#ifndef SC_FX_EXCLUDE_OTHER
#define DEFN_ASN_OP_OTHER(op)                                                 \
DEFN_ASN_OP_T(op,int64)                                                       \
DEFN_ASN_OP_T(op,uint64)                                                      \
DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
DEFN_ASN_OP_T(op,const sc_signed&)                                            \
DEFN_ASN_OP_T(op,const sc_unsigned&)
#else
#define DEFN_ASN_OP_OTHER(op)
#endif

#define DEFN_ASN_OP(op)                                                       \
DEFN_ASN_OP_T(op,int)                                                         \
DEFN_ASN_OP_T(op,unsigned int)                                                \
DEFN_ASN_OP_T(op,long)                                                        \
DEFN_ASN_OP_T(op,unsigned long)                                               \
DEFN_ASN_OP_T(op,double)                                                      \
DEFN_ASN_OP_T(op,const char*)                                                 \
DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
DEFN_ASN_OP_OTHER(op)

DEFN_ASN_OP(=)

DEFN_ASN_OP(*=)
DEFN_ASN_OP(/=)
DEFN_ASN_OP(+=)
DEFN_ASN_OP(-=)

DEFN_ASN_OP_T(<<=,int)
DEFN_ASN_OP_T(>>=,int)

DEFN_ASN_OP_T(&=,const sc_fix&)
DEFN_ASN_OP_T(&=,const sc_fix_fast&)
DEFN_ASN_OP_T(|=,const sc_fix&)
DEFN_ASN_OP_T(|=,const sc_fix_fast&)
DEFN_ASN_OP_T(^=,const sc_fix&)
DEFN_ASN_OP_T(^=,const sc_fix_fast&)

#undef DEFN_ASN_OP_T
#undef DEFN_ASN_OP_OTHER
#undef DEFN_ASN_OP


// auto-increment and auto-decrement

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
const sc_fxval
sc_fixed<W,I,Q,O,N>::operator ++ ( int )
{
    return sc_fxval( sc_fix::operator ++ ( 0 ) );
}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
const sc_fxval
sc_fixed<W,I,Q,O,N>::operator -- ( int )
{
    return sc_fxval( sc_fix::operator -- ( 0 ) );
}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed<W,I,Q,O,N>&
sc_fixed<W,I,Q,O,N>::operator ++ ()
{
    sc_fix::operator ++ ();
    return *this;
}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed<W,I,Q,O,N>&
sc_fixed<W,I,Q,O,N>::operator -- ()
{
    sc_fix::operator -- ();
    return *this;
}


// ----------------------------------------------------------------------------
//  TEMPLATE CLASS : sc_fixed_fast
//
//  "Constrained" signed fixed-point class; limited precision.
// ----------------------------------------------------------------------------

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( sc_fxnum_fast_observer* observer_ )
: sc_fix_fast( W, I, Q, O, N, observer_ )
{}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxcast_switch& cast_sw,
					 sc_fxnum_fast_observer* observer_ )
: sc_fix_fast( W, I, Q, O, N, cast_sw, observer_ )
{}

#define DEFN_CTORS_T(tp)                                                      \
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
inline                                                                        \
sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( tp a,                                \
					 sc_fxnum_fast_observer* observer_ )  \
: sc_fix_fast( a, W, I, Q, O, N, observer_ )                                  \
{}                                                                            \
                                                                              \
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
inline                                                                        \
sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( tp a,                                \
					 const sc_fxcast_switch& cast_sw,     \
					 sc_fxnum_fast_observer* observer_ )  \
: sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ )                         \
{}

DEFN_CTORS_T(int)
DEFN_CTORS_T(unsigned int)
DEFN_CTORS_T(long)
DEFN_CTORS_T(unsigned long)
DEFN_CTORS_T(double)
DEFN_CTORS_T(const char*)
DEFN_CTORS_T(const sc_fxval&)
DEFN_CTORS_T(const sc_fxval_fast&)
DEFN_CTORS_T(const sc_fxnum&)
DEFN_CTORS_T(const sc_fxnum_fast&)
#ifndef SC_FX_EXCLUDE_OTHER
DEFN_CTORS_T(int64)
DEFN_CTORS_T(uint64)
DEFN_CTORS_T(const sc_int_base&)
DEFN_CTORS_T(const sc_uint_base&)
DEFN_CTORS_T(const sc_signed&)
DEFN_CTORS_T(const sc_unsigned&)
#endif

#undef DEFN_CTORS_T

// copy constructor

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fixed_fast<W,I,Q,O,N>& a )
: sc_fix_fast( a, W, I, Q, O, N )
{}


// assignment operators

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed_fast<W,I,Q,O,N>&
sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_fixed_fast<W,I,Q,O,N>& a )
{
    sc_fix_fast::operator = ( a );
    return *this;
}

#define DEFN_ASN_OP_T(op,tp)                                                  \
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
inline                                                                        \
sc_fixed_fast<W,I,Q,O,N>&                                                     \
sc_fixed_fast<W,I,Q,O,N>::operator op ( tp a )                                \
{                                                                             \
    sc_fix_fast::operator op ( a );                                           \
    return *this;                                                             \
}

#ifndef SC_FX_EXCLUDE_OTHER
#define DEFN_ASN_OP_OTHER(op)                                                 \
DEFN_ASN_OP_T(op,int64)                                                       \
DEFN_ASN_OP_T(op,uint64)                                                      \
DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
DEFN_ASN_OP_T(op,const sc_signed&)                                            \
DEFN_ASN_OP_T(op,const sc_unsigned&)
#else
#define DEFN_ASN_OP_OTHER(op)
#endif

#define DEFN_ASN_OP(op)                                                       \
DEFN_ASN_OP_T(op,int)                                                         \
DEFN_ASN_OP_T(op,unsigned int)                                                \
DEFN_ASN_OP_T(op,long)                                                        \
DEFN_ASN_OP_T(op,unsigned long)                                               \
DEFN_ASN_OP_T(op,double)                                                      \
DEFN_ASN_OP_T(op,const char*)                                                 \
DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
DEFN_ASN_OP_OTHER(op)

DEFN_ASN_OP(=)

DEFN_ASN_OP(*=)
DEFN_ASN_OP(/=)
DEFN_ASN_OP(+=)
DEFN_ASN_OP(-=)

DEFN_ASN_OP_T(<<=,int)
DEFN_ASN_OP_T(>>=,int)

DEFN_ASN_OP_T(&=,const sc_fix&)
DEFN_ASN_OP_T(&=,const sc_fix_fast&)
DEFN_ASN_OP_T(|=,const sc_fix&)
DEFN_ASN_OP_T(|=,const sc_fix_fast&)
DEFN_ASN_OP_T(^=,const sc_fix&)
DEFN_ASN_OP_T(^=,const sc_fix_fast&)

#undef DEFN_ASN_OP_T
#undef DEFN_ASN_OP_OTHER
#undef DEFN_ASN_OP


// auto-increment and auto-decrement

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
const sc_fxval_fast
sc_fixed_fast<W,I,Q,O,N>::operator ++ ( int )
{
    return sc_fxval_fast( sc_fix_fast::operator ++ ( 0 ) );
}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
const sc_fxval_fast
sc_fixed_fast<W,I,Q,O,N>::operator -- ( int )
{
    return sc_fxval_fast( sc_fix_fast::operator -- ( 0 ) );
}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed_fast<W,I,Q,O,N>&
sc_fixed_fast<W,I,Q,O,N>::operator ++ ()
{
    sc_fix_fast::operator ++ ();
    return *this;
}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed_fast<W,I,Q,O,N>&
sc_fixed_fast<W,I,Q,O,N>::operator -- ()
{
    sc_fix_fast::operator -- ();
    return *this;
}

} // namespace sc_dt


#endif

// Taf!