summaryrefslogtreecommitdiff
path: root/ext/systemc/src/sysc/datatypes/fx/sc_fxval.h
diff options
context:
space:
mode:
Diffstat (limited to 'ext/systemc/src/sysc/datatypes/fx/sc_fxval.h')
-rw-r--r--ext/systemc/src/sysc/datatypes/fx/sc_fxval.h2269
1 files changed, 2269 insertions, 0 deletions
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxval.h b/ext/systemc/src/sysc/datatypes/fx/sc_fxval.h
new file mode 100644
index 000000000..1f199875c
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxval.h
@@ -0,0 +1,2269 @@
+/*****************************************************************************
+
+ Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+ more contributor license agreements. See the NOTICE file distributed
+ with this work for additional information regarding copyright ownership.
+ Accellera licenses this file to you under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with the
+ License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied. See the License for the specific language governing
+ permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+ sc_fxval.h -
+
+ Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+ MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+ changes you are making here.
+
+ Name, Affiliation, Date:
+ Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_fxval.h,v $
+// Revision 1.3 2011/01/19 18:57:40 acg
+// Andy Goodrich: changes for IEEE_1666_2011.
+//
+// Revision 1.2 2010/12/07 20:09:08 acg
+// Andy Goodrich: Philipp Hartmann's constructor disambiguation fix
+//
+// Revision 1.1.1.1 2006/12/15 20:20:04 acg
+// SystemC 2.3
+//
+// Revision 1.3 2006/01/13 18:53:58 acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FXVAL_H
+#define SC_FXVAL_H
+
+
+#include "sysc/datatypes/fx/scfx_rep.h"
+#ifndef SC_FX_EXCLUDE_OTHER
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#endif
+#include "sysc/datatypes/fx/sc_fxval_observer.h"
+
+#ifdef SC_FXVAL_IMPLICIT_CONV
+# define SCFX_EXPLICIT_ // nothing
+#else
+# define SCFX_EXPLICIT_ explicit
+#endif
+#ifdef SC_FXVAL_IMPLICIT_OTHER
+# define SCFX_EXPLICIT_OTHER_
+#else
+# define SCFX_EXPLICIT_OTHER_ explicit
+#endif
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_fxval;
+class sc_fxval_fast;
+
+// forward class declarations
+class sc_fxnum;
+class sc_fxnum_fast;
+
+
+// ----------------------------------------------------------------------------
+// CLASS : sc_fxval
+//
+// Fixed-point value type; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+class sc_fxval
+{
+
+ friend class sc_fxnum;
+
+protected:
+
+ sc_fxval_observer* observer() const;
+
+public:
+
+ // internal use only;
+ explicit sc_fxval( scfx_rep* );
+
+
+ explicit sc_fxval( sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval( int, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval( unsigned int, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval( long, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval( unsigned long, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval( float, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval( double, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval( const char*, sc_fxval_observer* = 0 );
+ sc_fxval( const sc_fxval&, sc_fxval_observer* = 0 );
+ sc_fxval( const sc_fxval_fast&, sc_fxval_observer* = 0 );
+ sc_fxval( const sc_fxnum&, sc_fxval_observer* = 0 );
+ sc_fxval( const sc_fxnum_fast&, sc_fxval_observer* = 0 );
+#ifndef SC_FX_EXCLUDE_OTHER
+ SCFX_EXPLICIT_OTHER_ sc_fxval( int64, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_OTHER_ sc_fxval( uint64, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_OTHER_ sc_fxval( const sc_int_base&, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_OTHER_ sc_fxval( const sc_uint_base&, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_OTHER_ sc_fxval( const sc_signed&, sc_fxval_observer* = 0 );
+ SCFX_EXPLICIT_OTHER_ sc_fxval( const sc_unsigned&, sc_fxval_observer* = 0 );
+#endif
+
+ ~sc_fxval();
+
+
+ // internal use only;
+ const scfx_rep* get_rep() const;
+ void set_rep( scfx_rep* );
+
+
+ // unary operators
+
+ const sc_fxval operator - () const;
+ const sc_fxval& operator + () const;
+
+
+ // unary functions
+
+ friend void neg( sc_fxval&, const sc_fxval& );
+
+
+ // binary operators
+
+#define DECL_BIN_OP_T(op,tp) \
+ friend const sc_fxval operator op ( const sc_fxval&, tp ); \
+ friend const sc_fxval operator op ( tp, const sc_fxval& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_OP_OTHER(op) \
+ DECL_BIN_OP_T(op,int64) \
+ DECL_BIN_OP_T(op,uint64) \
+ DECL_BIN_OP_T(op,const sc_int_base&) \
+ DECL_BIN_OP_T(op,const sc_uint_base&) \
+ DECL_BIN_OP_T(op,const sc_signed&) \
+ DECL_BIN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_BIN_OP_OTHER(op)
+#endif
+
+#define DECL_BIN_OP(op,dummy) \
+ friend const sc_fxval operator op ( const sc_fxval&, const sc_fxval& ); \
+ DECL_BIN_OP_T(op,int) \
+ DECL_BIN_OP_T(op,unsigned int) \
+ DECL_BIN_OP_T(op,long) \
+ DECL_BIN_OP_T(op,unsigned long) \
+ DECL_BIN_OP_T(op,float) \
+ DECL_BIN_OP_T(op,double) \
+ DECL_BIN_OP_T(op,const char*) \
+ DECL_BIN_OP_T(op,const sc_fxval_fast&) \
+ DECL_BIN_OP_T(op,const sc_fxnum_fast&) \
+ DECL_BIN_OP_OTHER(op)
+
+ DECL_BIN_OP(*,mult)
+ DECL_BIN_OP(+,add)
+ DECL_BIN_OP(-,sub)
+// declaration below doesn't compile with BCB5 (E2206)
+// DECL_BIN_OP(/,div)
+// previous macro expanded
+ friend const sc_fxval operator / ( const sc_fxval&, const sc_fxval& );
+ DECL_BIN_OP_T(/,int)
+ DECL_BIN_OP_T(/,unsigned int)
+ DECL_BIN_OP_T(/,long)
+ DECL_BIN_OP_T(/,unsigned long)
+ DECL_BIN_OP_T(/,float)
+ DECL_BIN_OP_T(/,double)
+ DECL_BIN_OP_T(/,const char*)
+ DECL_BIN_OP_T(/,const sc_fxval_fast&)
+ DECL_BIN_OP_T(/,const sc_fxnum_fast&)
+// DECL_BIN_OP_OTHER(/)
+#ifndef SC_FX_EXCLUDE_OTHER
+ DECL_BIN_OP_T(/,int64) \
+ DECL_BIN_OP_T(/,uint64) \
+ DECL_BIN_OP_T(/,const sc_int_base&) \
+ DECL_BIN_OP_T(/,const sc_uint_base&) \
+ DECL_BIN_OP_T(/,const sc_signed&) \
+ DECL_BIN_OP_T(/,const sc_unsigned&)
+#endif
+
+
+#undef DECL_BIN_OP_T
+#undef DECL_BIN_OP_OTHER
+#undef DECL_BIN_OP
+
+ friend const sc_fxval operator << ( const sc_fxval&, int );
+ friend const sc_fxval operator >> ( const sc_fxval&, int );
+
+
+ // binary functions
+
+#define DECL_BIN_FNC_T(fnc,tp) \
+ friend void fnc ( sc_fxval&, const sc_fxval&, tp ); \
+ friend void fnc ( sc_fxval&, tp, const sc_fxval& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_FNC_OTHER(fnc) \
+ DECL_BIN_FNC_T(fnc,int64) \
+ DECL_BIN_FNC_T(fnc,uint64) \
+ DECL_BIN_FNC_T(fnc,const sc_int_base&) \
+ DECL_BIN_FNC_T(fnc,const sc_uint_base&) \
+ DECL_BIN_FNC_T(fnc,const sc_signed&) \
+ DECL_BIN_FNC_T(fnc,const sc_unsigned&)
+#else
+#define DECL_BIN_FNC_OTHER(fnc)
+#endif
+
+#define DECL_BIN_FNC(fnc) \
+ friend void fnc ( sc_fxval&, const sc_fxval&, const sc_fxval& ); \
+ DECL_BIN_FNC_T(fnc,int) \
+ DECL_BIN_FNC_T(fnc,unsigned int) \
+ DECL_BIN_FNC_T(fnc,long) \
+ DECL_BIN_FNC_T(fnc,unsigned long) \
+ DECL_BIN_FNC_T(fnc,float) \
+ DECL_BIN_FNC_T(fnc,double) \
+ DECL_BIN_FNC_T(fnc,const char*) \
+ DECL_BIN_FNC_T(fnc,const sc_fxval_fast&) \
+ DECL_BIN_FNC_T(fnc,const sc_fxnum_fast&) \
+ DECL_BIN_FNC_OTHER(fnc)
+
+ DECL_BIN_FNC(mult)
+ DECL_BIN_FNC(div)
+ DECL_BIN_FNC(add)
+ DECL_BIN_FNC(sub)
+
+#undef DECL_BIN_FNC_T
+#undef DECL_BIN_FNC_OTHER
+#undef DECL_BIN_FNC
+
+ friend void lshift( sc_fxval&, const sc_fxval&, int );
+ friend void rshift( sc_fxval&, const sc_fxval&, int );
+
+
+ // relational (including equality) operators
+
+#define DECL_REL_OP_T(op,tp) \
+ friend bool operator op ( const sc_fxval&, tp ); \
+ friend bool operator op ( tp, const sc_fxval& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_REL_OP_OTHER(op) \
+ DECL_REL_OP_T(op,int64) \
+ DECL_REL_OP_T(op,uint64) \
+ DECL_REL_OP_T(op,const sc_int_base&) \
+ DECL_REL_OP_T(op,const sc_uint_base&) \
+ DECL_REL_OP_T(op,const sc_signed&) \
+ DECL_REL_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_REL_OP_OTHER(op)
+#endif
+
+#define DECL_REL_OP(op) \
+ friend bool operator op ( const sc_fxval&, const sc_fxval& ); \
+ DECL_REL_OP_T(op,int) \
+ DECL_REL_OP_T(op,unsigned int) \
+ DECL_REL_OP_T(op,long) \
+ DECL_REL_OP_T(op,unsigned long) \
+ DECL_REL_OP_T(op,float) \
+ DECL_REL_OP_T(op,double) \
+ DECL_REL_OP_T(op,const char*) \
+ DECL_REL_OP_T(op,const sc_fxval_fast&) \
+ DECL_REL_OP_T(op,const sc_fxnum_fast&) \
+ DECL_REL_OP_OTHER(op)
+
+ DECL_REL_OP(<)
+ DECL_REL_OP(<=)
+ DECL_REL_OP(>)
+ DECL_REL_OP(>=)
+ DECL_REL_OP(==)
+ DECL_REL_OP(!=)
+
+#undef DECL_REL_OP_T
+#undef DECL_REL_OP_OTHER
+#undef DECL_REL_OP
+
+
+ // assignment operators
+
+#define DECL_ASN_OP_T(op,tp) \
+ sc_fxval& operator op( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op) \
+ DECL_ASN_OP_T(op,int64) \
+ DECL_ASN_OP_T(op,uint64) \
+ DECL_ASN_OP_T(op,const sc_int_base&) \
+ DECL_ASN_OP_T(op,const sc_uint_base&) \
+ DECL_ASN_OP_T(op,const sc_signed&) \
+ DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op) \
+ DECL_ASN_OP_T(op,int) \
+ DECL_ASN_OP_T(op,unsigned int) \
+ DECL_ASN_OP_T(op,long) \
+ DECL_ASN_OP_T(op,unsigned long) \
+ DECL_ASN_OP_T(op,float) \
+ DECL_ASN_OP_T(op,double) \
+ DECL_ASN_OP_T(op,const char*) \
+ DECL_ASN_OP_T(op,const sc_fxval&) \
+ DECL_ASN_OP_T(op,const sc_fxval_fast&) \
+ DECL_ASN_OP_T(op,const sc_fxnum&) \
+ DECL_ASN_OP_T(op,const sc_fxnum_fast&) \
+ DECL_ASN_OP_OTHER(op)
+
+ DECL_ASN_OP(=)
+
+ DECL_ASN_OP(*=)
+ DECL_ASN_OP(/=)
+ DECL_ASN_OP(+=)
+ DECL_ASN_OP(-=)
+
+ DECL_ASN_OP_T(<<=,int)
+ DECL_ASN_OP_T(>>=,int)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+ // auto-increment and auto-decrement
+
+ const sc_fxval operator ++ ( int );
+ const sc_fxval operator -- ( int );
+
+ sc_fxval& operator ++ ();
+ sc_fxval& operator -- ();
+
+
+ // implicit conversion
+
+ operator double() const; // necessary evil!
+
+
+ // explicit conversion to primitive types
+
+ short to_short() const;
+ unsigned short to_ushort() const;
+ int to_int() const;
+ unsigned int to_uint() const;
+ long to_long() const;
+ unsigned long to_ulong() const;
+ int64 to_int64() const;
+ uint64 to_uint64() const;
+ float to_float() const;
+ double to_double() const;
+
+
+ // explicit conversion to character string
+
+ const std::string to_string() const;
+ const std::string to_string( sc_numrep ) const;
+ const std::string to_string( sc_numrep, bool ) const;
+ const std::string to_string( sc_fmt ) const;
+ const std::string to_string( sc_numrep, sc_fmt ) const;
+ const std::string to_string( sc_numrep, bool, sc_fmt ) const;
+
+ const std::string to_dec() const;
+ const std::string to_bin() const;
+ const std::string to_oct() const;
+ const std::string to_hex() const;
+
+
+ // query value
+
+ bool is_neg() const;
+ bool is_zero() const;
+ bool is_nan() const;
+ bool is_inf() const;
+ bool is_normal() const;
+
+ bool rounding_flag() const;
+
+
+ // print or dump content
+
+ void print( ::std::ostream& = ::std::cout ) const;
+ void scan( ::std::istream& = ::std::cin );
+ void dump( ::std::ostream& = ::std::cout ) const;
+
+
+ // internal use only;
+ bool get_bit( int ) const;
+
+protected:
+
+ sc_fxval_observer* lock_observer() const;
+ void unlock_observer( sc_fxval_observer* ) const;
+
+
+ void get_type( int&, int&, sc_enc& ) const;
+
+ const sc_fxval quantization( const scfx_params&, bool& ) const;
+ const sc_fxval overflow( const scfx_params&, bool& ) const;
+
+private:
+
+ scfx_rep* m_rep;
+
+ mutable sc_fxval_observer* m_observer;
+
+};
+
+
+// ----------------------------------------------------------------------------
+// CLASS : sc_fxval_fast
+//
+// Fixed-point value type; limited precision.
+// ----------------------------------------------------------------------------
+
+class sc_fxval_fast
+{
+
+ friend class sc_fxnum_fast;
+
+protected:
+
+ sc_fxval_fast_observer* observer() const;
+
+public:
+
+ explicit sc_fxval_fast( sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval_fast( int, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval_fast( unsigned int, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval_fast( long, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval_fast( unsigned long, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval_fast( float, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval_fast( double, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_ sc_fxval_fast( const char*, sc_fxval_fast_observer* = 0 );
+ sc_fxval_fast( const sc_fxval&, sc_fxval_fast_observer* = 0 );
+ sc_fxval_fast( const sc_fxval_fast&, sc_fxval_fast_observer* = 0 );
+ sc_fxval_fast( const sc_fxnum&, sc_fxval_fast_observer* = 0 );
+ sc_fxval_fast( const sc_fxnum_fast&, sc_fxval_fast_observer* = 0 );
+#ifndef SC_FX_EXCLUDE_OTHER
+ SCFX_EXPLICIT_OTHER_ sc_fxval_fast( int64, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_OTHER_ sc_fxval_fast( uint64, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_OTHER_ sc_fxval_fast( const sc_int_base&, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_OTHER_ sc_fxval_fast( const sc_uint_base&, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_OTHER_ sc_fxval_fast( const sc_signed&, sc_fxval_fast_observer* = 0 );
+ SCFX_EXPLICIT_OTHER_ sc_fxval_fast( const sc_unsigned&, sc_fxval_fast_observer* = 0 );
+#endif
+
+ ~sc_fxval_fast();
+
+ // internal use only;
+ double get_val() const;
+ void set_val( double );
+
+
+ // unary operators
+
+ const sc_fxval_fast operator - () const;
+ const sc_fxval_fast& operator + () const;
+
+
+ // unary functions
+
+ friend void neg( sc_fxval_fast&, const sc_fxval_fast& );
+
+
+ // binary operators
+
+#define DECL_BIN_OP_T(op,tp) \
+ friend const sc_fxval_fast operator op ( const sc_fxval_fast&, tp ); \
+ friend const sc_fxval_fast operator op ( tp, const sc_fxval_fast& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_OP_OTHER(op) \
+ DECL_BIN_OP_T(op,int64) \
+ DECL_BIN_OP_T(op,uint64) \
+ DECL_BIN_OP_T(op,const sc_int_base&) \
+ DECL_BIN_OP_T(op,const sc_uint_base&) \
+ DECL_BIN_OP_T(op,const sc_signed&) \
+ DECL_BIN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_BIN_OP_OTHER(op)
+#endif
+
+#define DECL_BIN_OP(op,dummy) \
+ friend const sc_fxval_fast operator op ( const sc_fxval_fast&, \
+ const sc_fxval_fast& ); \
+ DECL_BIN_OP_T(op,int) \
+ DECL_BIN_OP_T(op,unsigned int) \
+ DECL_BIN_OP_T(op,long) \
+ DECL_BIN_OP_T(op,unsigned long) \
+ DECL_BIN_OP_T(op,float) \
+ DECL_BIN_OP_T(op,double) \
+ DECL_BIN_OP_T(op,const char*) \
+ DECL_BIN_OP_OTHER(op)
+
+ DECL_BIN_OP(*,mult)
+ DECL_BIN_OP(+,add)
+ DECL_BIN_OP(-,sub)
+// don't use macro
+// DECL_BIN_OP(/,div)
+ friend const sc_fxval_fast operator / ( const sc_fxval_fast&,
+ const sc_fxval_fast& );
+ DECL_BIN_OP_T(/,int)
+ DECL_BIN_OP_T(/,unsigned int)
+ DECL_BIN_OP_T(/,long)
+ DECL_BIN_OP_T(/,unsigned long)
+ DECL_BIN_OP_T(/,float)
+ DECL_BIN_OP_T(/,double)
+ DECL_BIN_OP_T(/,const char*)
+// DECL_BIN_OP_OTHER(/)
+#ifndef SC_FX_EXCLUDE_OTHER
+ DECL_BIN_OP_T(/,int64) \
+ DECL_BIN_OP_T(/,uint64) \
+ DECL_BIN_OP_T(/,const sc_int_base&) \
+ DECL_BIN_OP_T(/,const sc_uint_base&) \
+ DECL_BIN_OP_T(/,const sc_signed&) \
+ DECL_BIN_OP_T(/,const sc_unsigned&)
+#endif
+
+#undef DECL_BIN_OP_T
+#undef DECL_BIN_OP_OTHER
+#undef DECL_BIN_OP
+
+ friend const sc_fxval_fast operator << ( const sc_fxval_fast&, int );
+ friend const sc_fxval_fast operator >> ( const sc_fxval_fast&, int );
+
+
+ // binary functions
+
+#define DECL_BIN_FNC_T(fnc,tp) \
+ friend void fnc ( sc_fxval_fast&, const sc_fxval_fast&, tp ); \
+ friend void fnc ( sc_fxval_fast&, tp, const sc_fxval_fast& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_FNC_OTHER(fnc) \
+ DECL_BIN_FNC_T(fnc,int64) \
+ DECL_BIN_FNC_T(fnc,uint64) \
+ DECL_BIN_FNC_T(fnc,const sc_int_base&) \
+ DECL_BIN_FNC_T(fnc,const sc_uint_base&) \
+ DECL_BIN_FNC_T(fnc,const sc_signed&) \
+ DECL_BIN_FNC_T(fnc,const sc_unsigned&)
+#else
+#define DECL_BIN_FNC_OTHER(fnc)
+#endif
+
+#define DECL_BIN_FNC(fnc) \
+ friend void fnc ( sc_fxval_fast&, const sc_fxval_fast&, \
+ const sc_fxval_fast& ); \
+ DECL_BIN_FNC_T(fnc,int) \
+ DECL_BIN_FNC_T(fnc,unsigned int) \
+ DECL_BIN_FNC_T(fnc,long) \
+ DECL_BIN_FNC_T(fnc,unsigned long) \
+ DECL_BIN_FNC_T(fnc,float) \
+ DECL_BIN_FNC_T(fnc,double) \
+ DECL_BIN_FNC_T(fnc,const char*) \
+ DECL_BIN_FNC_T(fnc,const sc_fxval&) \
+ DECL_BIN_FNC_T(fnc,const sc_fxnum&) \
+ DECL_BIN_FNC_OTHER(fnc)
+
+ DECL_BIN_FNC(mult)
+ DECL_BIN_FNC(div)
+ DECL_BIN_FNC(add)
+ DECL_BIN_FNC(sub)
+
+#undef DECL_BIN_FNC_T
+#undef DECL_BIN_FNC_OTHER
+#undef DECL_BIN_FNC
+
+ friend void lshift( sc_fxval_fast&, const sc_fxval_fast&, int );
+ friend void rshift( sc_fxval_fast&, const sc_fxval_fast&, int );
+
+
+ // relational (including equality) operators
+
+#define DECL_REL_OP_T(op,tp) \
+ friend bool operator op ( const sc_fxval_fast&, tp ); \
+ friend bool operator op ( tp, const sc_fxval_fast& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_REL_OP_OTHER(op) \
+ DECL_REL_OP_T(op,int64) \
+ DECL_REL_OP_T(op,uint64) \
+ DECL_REL_OP_T(op,const sc_int_base&) \
+ DECL_REL_OP_T(op,const sc_uint_base&) \
+ DECL_REL_OP_T(op,const sc_signed&) \
+ DECL_REL_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_REL_OP_OTHER(op)
+#endif
+
+#define DECL_REL_OP(op) \
+ friend bool operator op ( const sc_fxval_fast&, const sc_fxval_fast& ); \
+ DECL_REL_OP_T(op,int) \
+ DECL_REL_OP_T(op,unsigned int) \
+ DECL_REL_OP_T(op,long) \
+ DECL_REL_OP_T(op,unsigned long) \
+ DECL_REL_OP_T(op,float) \
+ DECL_REL_OP_T(op,double) \
+ DECL_REL_OP_T(op,const char*) \
+ DECL_REL_OP_OTHER(op)
+
+ DECL_REL_OP(<)
+ DECL_REL_OP(<=)
+ DECL_REL_OP(>)
+ DECL_REL_OP(>=)
+ DECL_REL_OP(==)
+ DECL_REL_OP(!=)
+
+#undef DECL_REL_OP_T
+#undef DECL_REL_OP_OTHER
+#undef DECL_REL_OP
+
+
+ // assignment operators
+
+#define DECL_ASN_OP_T(op,tp) \
+ sc_fxval_fast& operator op( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op) \
+ DECL_ASN_OP_T(op,int64) \
+ DECL_ASN_OP_T(op,uint64) \
+ DECL_ASN_OP_T(op,const sc_int_base&) \
+ DECL_ASN_OP_T(op,const sc_uint_base&) \
+ DECL_ASN_OP_T(op,const sc_signed&) \
+ DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op) \
+ DECL_ASN_OP_T(op,int) \
+ DECL_ASN_OP_T(op,unsigned int) \
+ DECL_ASN_OP_T(op,long) \
+ DECL_ASN_OP_T(op,unsigned long) \
+ DECL_ASN_OP_T(op,float) \
+ DECL_ASN_OP_T(op,double) \
+ DECL_ASN_OP_T(op,const char*) \
+ DECL_ASN_OP_T(op,const sc_fxval&) \
+ DECL_ASN_OP_T(op,const sc_fxval_fast&) \
+ DECL_ASN_OP_T(op,const sc_fxnum&) \
+ DECL_ASN_OP_T(op,const sc_fxnum_fast&) \
+ DECL_ASN_OP_OTHER(op)
+
+ DECL_ASN_OP(=)
+
+ DECL_ASN_OP(*=)
+ DECL_ASN_OP(/=)
+ DECL_ASN_OP(+=)
+ DECL_ASN_OP(-=)
+
+ DECL_ASN_OP_T(<<=,int)
+ DECL_ASN_OP_T(>>=,int)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+ // auto-increment and auto-decrement
+
+ const sc_fxval_fast operator ++ ( int );
+ const sc_fxval_fast operator -- ( int );
+
+ sc_fxval_fast& operator ++ ();
+ sc_fxval_fast& operator -- ();
+
+
+ // implicit conversion
+
+ operator double() const; // necessary evil!
+
+
+ // explicit conversion to primitive types
+
+ short to_short() const;
+ unsigned short to_ushort() const;
+ int to_int() const;
+ unsigned int to_uint() const;
+ long to_long() const;
+ unsigned long to_ulong() const;
+ int64 to_int64() const;
+ uint64 to_uint64() const;
+ float to_float() const;
+ double to_double() const;
+
+
+ // explicit conversion to character string
+
+ const std::string to_string() const;
+ const std::string to_string( sc_numrep ) const;
+ const std::string to_string( sc_numrep, bool ) const;
+ const std::string to_string( sc_fmt ) const;
+ const std::string to_string( sc_numrep, sc_fmt ) const;
+ const std::string to_string( sc_numrep, bool, sc_fmt ) const;
+
+ const std::string to_dec() const;
+ const std::string to_bin() const;
+ const std::string to_oct() const;
+ const std::string to_hex() const;
+
+
+ // query value
+
+ bool is_neg() const;
+ bool is_zero() const;
+ bool is_nan() const;
+ bool is_inf() const;
+ bool is_normal() const;
+
+ bool rounding_flag() const;
+
+
+ // print or dump content
+
+ void print( ::std::ostream& = ::std::cout ) const;
+ void scan( ::std::istream& = ::std::cin );
+ void dump( ::std::ostream& = ::std::cout ) const;
+
+
+ // internal use only;
+ bool get_bit( int ) const;
+
+protected:
+
+ sc_fxval_fast_observer* lock_observer() const;
+ void unlock_observer( sc_fxval_fast_observer* ) const;
+
+
+ static double from_string( const char* );
+
+private:
+
+ double m_val;
+
+ mutable sc_fxval_fast_observer* m_observer;
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+// CLASS : sc_fxval
+//
+// Fixed-point value type; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+// protected method
+
+inline
+sc_fxval_observer*
+sc_fxval::observer() const
+{
+ return m_observer;
+}
+
+
+// internal use only;
+inline
+sc_fxval::sc_fxval( scfx_rep* a )
+: m_rep( a != 0 ? a : new scfx_rep ),
+ m_observer( 0 )
+{}
+
+
+// public constructors
+
+inline
+sc_fxval::sc_fxval( sc_fxval_observer* observer_ )
+: m_rep( new scfx_rep ),
+ m_observer( observer_ )
+{
+ SC_FXVAL_OBSERVER_DEFAULT_
+ SC_FXVAL_OBSERVER_CONSTRUCT_( *this )
+}
+
+inline
+sc_fxval::sc_fxval( const sc_fxval& a,
+ sc_fxval_observer* observer_ )
+: m_rep( new scfx_rep( *a.m_rep ) ),
+ m_observer( observer_ )
+{
+ SC_FXVAL_OBSERVER_DEFAULT_
+ SC_FXVAL_OBSERVER_READ_( a )
+ SC_FXVAL_OBSERVER_CONSTRUCT_( *this )
+ SC_FXVAL_OBSERVER_WRITE_( *this )
+}
+
+#define DEFN_CTOR_T(tp,arg) \
+inline \
+sc_fxval::sc_fxval( tp a, \
+ sc_fxval_observer* observer_ ) \
+: m_rep( new scfx_rep( arg ) ), \
+ m_observer( observer_ ) \
+{ \
+ SC_FXVAL_OBSERVER_DEFAULT_ \
+ SC_FXVAL_OBSERVER_CONSTRUCT_( *this ) \
+ SC_FXVAL_OBSERVER_WRITE_( *this ) \
+}
+
+#define DEFN_CTOR_T_A(tp) DEFN_CTOR_T(tp,a)
+#define DEFN_CTOR_T_B(tp) DEFN_CTOR_T(tp,a.to_double())
+#define DEFN_CTOR_T_C(tp) DEFN_CTOR_T(tp,a.value())
+
+DEFN_CTOR_T_A(int)
+DEFN_CTOR_T_A(unsigned int)
+DEFN_CTOR_T_A(long)
+DEFN_CTOR_T_A(unsigned long)
+DEFN_CTOR_T_A(float)
+DEFN_CTOR_T_A(double)
+DEFN_CTOR_T_A(const char*)
+DEFN_CTOR_T_B(const sc_fxval_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTOR_T_A(int64)
+DEFN_CTOR_T_A(uint64)
+DEFN_CTOR_T_C(const sc_int_base&)
+DEFN_CTOR_T_C(const sc_uint_base&)
+DEFN_CTOR_T_A(const sc_signed&)
+DEFN_CTOR_T_A(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTOR_T
+#undef DEFN_CTOR_T_A
+#undef DEFN_CTOR_T_B
+#undef DEFN_CTOR_T_C
+
+
+inline
+sc_fxval::~sc_fxval()
+{
+ SC_FXVAL_OBSERVER_DESTRUCT_( *this )
+ delete m_rep;
+}
+
+
+// internal use only;
+inline
+const scfx_rep*
+sc_fxval::get_rep() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return m_rep;
+}
+
+// internal use only;
+inline
+void
+sc_fxval::set_rep( scfx_rep* rep_ )
+{
+ delete m_rep;
+ m_rep = rep_;
+ SC_FXVAL_OBSERVER_WRITE_( *this )
+}
+
+
+// unary operators
+
+inline
+const sc_fxval
+sc_fxval::operator - () const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return sc_fxval( sc_dt::neg_scfx_rep( *m_rep ) );
+}
+
+inline
+const sc_fxval&
+sc_fxval::operator + () const
+{
+ // SC_FXVAL_OBSERVER_READ_( *this )
+ return *this;
+}
+
+
+// unary functions
+
+inline
+void
+neg( sc_fxval& c, const sc_fxval& a )
+{
+ SC_FXVAL_OBSERVER_READ_( a )
+ delete c.m_rep;
+ c.m_rep = sc_dt::neg_scfx_rep( *a.m_rep );
+ SC_FXVAL_OBSERVER_WRITE_( c )
+}
+
+
+// binary operators
+
+#define DEFN_BIN_OP_T(op,fnc,tp) \
+inline \
+const sc_fxval \
+operator op ( const sc_fxval& a, tp b ) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( a ) \
+ sc_fxval tmp( b ); \
+ return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.m_rep ) ); \
+} \
+ \
+inline \
+const sc_fxval \
+operator op ( tp a, const sc_fxval& b ) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( b ) \
+ sc_fxval tmp( a ); \
+ return sc_fxval( sc_dt::fnc ## _scfx_rep( *tmp.m_rep, *b.m_rep ) ); \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_OP_OTHER(op,fnc) \
+DEFN_BIN_OP_T(op,fnc,int64) \
+DEFN_BIN_OP_T(op,fnc,uint64) \
+DEFN_BIN_OP_T(op,fnc,const sc_int_base&) \
+DEFN_BIN_OP_T(op,fnc,const sc_uint_base&) \
+DEFN_BIN_OP_T(op,fnc,const sc_signed&) \
+DEFN_BIN_OP_T(op,fnc,const sc_unsigned&)
+#else
+#define DEFN_BIN_OP_OTHER(op,fnc)
+#endif
+
+#define DEFN_BIN_OP(op,fnc) \
+inline \
+const sc_fxval \
+operator op ( const sc_fxval& a, const sc_fxval& b ) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( a ) \
+ SC_FXVAL_OBSERVER_READ_( b ) \
+ return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.m_rep ) ); \
+} \
+ \
+DEFN_BIN_OP_T(op,fnc,int) \
+DEFN_BIN_OP_T(op,fnc,unsigned int) \
+DEFN_BIN_OP_T(op,fnc,long) \
+DEFN_BIN_OP_T(op,fnc,unsigned long) \
+DEFN_BIN_OP_T(op,fnc,float) \
+DEFN_BIN_OP_T(op,fnc,double) \
+DEFN_BIN_OP_T(op,fnc,const char*) \
+DEFN_BIN_OP_T(op,fnc,const sc_fxval_fast&) \
+DEFN_BIN_OP_OTHER(op,fnc)
+
+DEFN_BIN_OP(*,mult)
+DEFN_BIN_OP(+,add)
+DEFN_BIN_OP(-,sub)
+// don't use macro
+//DEFN_BIN_OP(/,div)
+inline
+const sc_fxval
+operator / ( const sc_fxval& a, const sc_fxval& b )
+{
+ SC_FXVAL_OBSERVER_READ_( a )
+ SC_FXVAL_OBSERVER_READ_( b )
+ return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ) );
+}
+
+DEFN_BIN_OP_T(/,div,int)
+DEFN_BIN_OP_T(/,div,unsigned int)
+DEFN_BIN_OP_T(/,div,long)
+DEFN_BIN_OP_T(/,div,unsigned long)
+DEFN_BIN_OP_T(/,div,float)
+DEFN_BIN_OP_T(/,div,double)
+DEFN_BIN_OP_T(/,div,const char*)
+DEFN_BIN_OP_T(/,div,const sc_fxval_fast&)
+//DEFN_BIN_OP_OTHER(/,div)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_BIN_OP_T(/,div,int64) \
+DEFN_BIN_OP_T(/,div,uint64) \
+DEFN_BIN_OP_T(/,div,const sc_int_base&) \
+DEFN_BIN_OP_T(/,div,const sc_uint_base&) \
+DEFN_BIN_OP_T(/,div,const sc_signed&) \
+DEFN_BIN_OP_T(/,div,const sc_unsigned&)
+#endif
+
+#undef DEFN_BIN_OP_T
+#undef DEFN_BIN_OP_OTHER
+#undef DEFN_BIN_OP
+
+
+inline
+const sc_fxval
+operator << ( const sc_fxval& a, int b )
+{
+ SC_FXVAL_OBSERVER_READ_( a )
+ return sc_fxval( sc_dt::lsh_scfx_rep( *a.m_rep, b ) );
+}
+
+inline
+const sc_fxval
+operator >> ( const sc_fxval& a, int b )
+{
+ SC_FXVAL_OBSERVER_READ_( a )
+ return sc_fxval( sc_dt::rsh_scfx_rep( *a.m_rep, b ) );
+}
+
+
+// binary functions
+
+#define DEFN_BIN_FNC_T(fnc,tp) \
+inline \
+void \
+fnc ( sc_fxval& c, const sc_fxval& a, tp b ) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( a ) \
+ sc_fxval tmp( b ); \
+ delete c.m_rep; \
+ c.m_rep = sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.m_rep ); \
+ SC_FXVAL_OBSERVER_WRITE_( c ) \
+} \
+ \
+inline \
+void \
+fnc ( sc_fxval& c, tp a, const sc_fxval& b ) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( b ) \
+ sc_fxval tmp( a ); \
+ delete c.m_rep; \
+ c.m_rep = sc_dt::fnc ## _scfx_rep( *tmp.m_rep, *b.m_rep ); \
+ SC_FXVAL_OBSERVER_WRITE_( c ) \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_FNC_OTHER(fnc) \
+DEFN_BIN_FNC_T(fnc,int64) \
+DEFN_BIN_FNC_T(fnc,uint64) \
+DEFN_BIN_FNC_T(fnc,const sc_int_base&) \
+DEFN_BIN_FNC_T(fnc,const sc_uint_base&) \
+DEFN_BIN_FNC_T(fnc,const sc_signed&) \
+DEFN_BIN_FNC_T(fnc,const sc_unsigned&)
+#else
+#define DEFN_BIN_FNC_OTHER(fnc)
+#endif
+
+#define DEFN_BIN_FNC(fnc) \
+inline \
+void \
+fnc( sc_fxval& c, const sc_fxval& a, const sc_fxval& b ) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( a ) \
+ SC_FXVAL_OBSERVER_READ_( b ) \
+ delete c.m_rep; \
+ c.m_rep = sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.m_rep ); \
+ SC_FXVAL_OBSERVER_WRITE_( c ) \
+} \
+ \
+DEFN_BIN_FNC_T(fnc,int) \
+DEFN_BIN_FNC_T(fnc,unsigned int) \
+DEFN_BIN_FNC_T(fnc,long) \
+DEFN_BIN_FNC_T(fnc,unsigned long) \
+DEFN_BIN_FNC_T(fnc,float) \
+DEFN_BIN_FNC_T(fnc,double) \
+DEFN_BIN_FNC_T(fnc,const char*) \
+DEFN_BIN_FNC_T(fnc,const sc_fxval_fast&) \
+DEFN_BIN_FNC_OTHER(fnc)
+
+DEFN_BIN_FNC(mult)
+DEFN_BIN_FNC(div)
+DEFN_BIN_FNC(add)
+DEFN_BIN_FNC(sub)
+
+#undef DEFN_BIN_FNC_T
+#undef DEFN_BIN_FNC_OTHER
+#undef DEFN_BIN_FNC
+
+
+inline
+void
+lshift( sc_fxval& c, const sc_fxval& a, int b )
+{
+ SC_FXVAL_OBSERVER_READ_( a )
+ delete c.m_rep;
+ c.m_rep = sc_dt::lsh_scfx_rep( *a.m_rep, b );
+ SC_FXVAL_OBSERVER_WRITE_( c )
+}
+
+inline
+void
+rshift( sc_fxval& c, const sc_fxval& a, int b )
+{
+ SC_FXVAL_OBSERVER_READ_( a )
+ delete c.m_rep;
+ c.m_rep = sc_dt::rsh_scfx_rep( *a.m_rep, b );
+ SC_FXVAL_OBSERVER_WRITE_( c )
+}
+
+
+// relational (including equality) operators
+
+#define DEFN_REL_OP_T(op,ret,tp) \
+inline \
+bool \
+operator op ( const sc_fxval& a, tp b ) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( a ) \
+ sc_fxval tmp( b ); \
+ int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); \
+ return ( ret ); \
+} \
+ \
+inline \
+bool \
+operator op ( tp a, const sc_fxval& b ) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( b ) \
+ sc_fxval tmp( a ); \
+ int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); \
+ return ( ret ); \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_REL_OP_OTHER(op,ret) \
+DEFN_REL_OP_T(op,ret,int64) \
+DEFN_REL_OP_T(op,ret,uint64) \
+DEFN_REL_OP_T(op,ret,const sc_int_base&) \
+DEFN_REL_OP_T(op,ret,const sc_uint_base&) \
+DEFN_REL_OP_T(op,ret,const sc_signed&) \
+DEFN_REL_OP_T(op,ret,const sc_unsigned&)
+#else
+#define DEFN_REL_OP_OTHER(op,ret)
+#endif
+
+#define DEFN_REL_OP(op,ret) \
+inline \
+bool \
+operator op ( const sc_fxval& a, const sc_fxval& b) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( a ) \
+ SC_FXVAL_OBSERVER_READ_( b ) \
+ int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); \
+ return ( ret ); \
+} \
+ \
+DEFN_REL_OP_T(op,ret,int) \
+DEFN_REL_OP_T(op,ret,unsigned int) \
+DEFN_REL_OP_T(op,ret,long) \
+DEFN_REL_OP_T(op,ret,unsigned long) \
+DEFN_REL_OP_T(op,ret,float) \
+DEFN_REL_OP_T(op,ret,double) \
+DEFN_REL_OP_T(op,ret,const char*) \
+DEFN_REL_OP_T(op,ret,const sc_fxval_fast&) \
+DEFN_REL_OP_OTHER(op,ret)
+
+DEFN_REL_OP(<,result < 0)
+DEFN_REL_OP(<=,result <= 0)
+DEFN_REL_OP(>,result > 0 && result != 2)
+DEFN_REL_OP(>=,result >= 0 && result != 2)
+DEFN_REL_OP(==,result == 0)
+DEFN_REL_OP(!=,result != 0)
+
+#undef DEFN_REL_OP_T
+#undef DEFN_REL_OP_OTHER
+#undef DEFN_REL_OP
+
+
+// assignment operators
+
+inline
+sc_fxval&
+sc_fxval::operator = ( const sc_fxval& a )
+{
+ if( &a != this )
+ {
+ SC_FXVAL_OBSERVER_READ_( a )
+ *m_rep = *a.m_rep;
+ SC_FXVAL_OBSERVER_WRITE_( *this )
+ }
+ return *this;
+}
+
+#define DEFN_ASN_OP_T(tp) \
+inline \
+sc_fxval& \
+sc_fxval::operator = ( tp b ) \
+{ \
+ sc_fxval tmp( b ); \
+ *m_rep = *tmp.m_rep; \
+ SC_FXVAL_OBSERVER_WRITE_( *this ) \
+ return *this; \
+}
+
+DEFN_ASN_OP_T(int)
+DEFN_ASN_OP_T(unsigned int)
+DEFN_ASN_OP_T(long)
+DEFN_ASN_OP_T(unsigned long)
+DEFN_ASN_OP_T(float)
+DEFN_ASN_OP_T(double)
+DEFN_ASN_OP_T(const char*)
+DEFN_ASN_OP_T(const sc_fxval_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_ASN_OP_T(int64)
+DEFN_ASN_OP_T(uint64)
+DEFN_ASN_OP_T(const sc_int_base&)
+DEFN_ASN_OP_T(const sc_uint_base&)
+DEFN_ASN_OP_T(const sc_signed&)
+DEFN_ASN_OP_T(const sc_unsigned&)
+#endif
+
+#undef DEFN_ASN_OP_T
+
+
+#define DEFN_ASN_OP_T(op,fnc,tp) \
+inline \
+sc_fxval& \
+sc_fxval::operator op ( tp b ) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( *this ) \
+ sc_fxval tmp( b ); \
+ scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *tmp.m_rep ); \
+ delete m_rep; \
+ m_rep = new_rep; \
+ SC_FXVAL_OBSERVER_WRITE_( *this ) \
+ return *this; \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op,fnc) \
+DEFN_ASN_OP_T(op,fnc,int64) \
+DEFN_ASN_OP_T(op,fnc,uint64) \
+DEFN_ASN_OP_T(op,fnc,const sc_int_base&) \
+DEFN_ASN_OP_T(op,fnc,const sc_uint_base&) \
+DEFN_ASN_OP_T(op,fnc,const sc_signed&) \
+DEFN_ASN_OP_T(op,fnc,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op,fnc)
+#endif
+
+#define DEFN_ASN_OP(op,fnc) \
+inline \
+sc_fxval& \
+sc_fxval::operator op ( const sc_fxval& b ) \
+{ \
+ SC_FXVAL_OBSERVER_READ_( *this ) \
+ SC_FXVAL_OBSERVER_READ_( b ) \
+ scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *b.m_rep ); \
+ delete m_rep; \
+ m_rep = new_rep; \
+ SC_FXVAL_OBSERVER_WRITE_( *this ) \
+ return *this; \
+} \
+ \
+DEFN_ASN_OP_T(op,fnc,int) \
+DEFN_ASN_OP_T(op,fnc,unsigned int) \
+DEFN_ASN_OP_T(op,fnc,long) \
+DEFN_ASN_OP_T(op,fnc,unsigned long) \
+DEFN_ASN_OP_T(op,fnc,float) \
+DEFN_ASN_OP_T(op,fnc,double) \
+DEFN_ASN_OP_T(op,fnc,const char*) \
+DEFN_ASN_OP_T(op,fnc,const sc_fxval_fast&) \
+DEFN_ASN_OP_OTHER(op,fnc)
+
+DEFN_ASN_OP(*=,mult)
+DEFN_ASN_OP(/=,div)
+DEFN_ASN_OP(+=,add)
+DEFN_ASN_OP(-=,sub)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+inline
+sc_fxval&
+sc_fxval::operator <<= ( int b )
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ m_rep->lshift( b );
+ SC_FXVAL_OBSERVER_WRITE_( *this )
+ return *this;
+}
+
+inline
+sc_fxval&
+sc_fxval::operator >>= ( int b )
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ m_rep->rshift( b );
+ SC_FXVAL_OBSERVER_WRITE_( *this )
+ return *this;
+}
+
+
+// auto-increment and auto-decrement
+
+inline
+const sc_fxval
+sc_fxval::operator ++ ( int )
+{
+ sc_fxval c = *this;
+ (*this) += 1;
+ return c;
+}
+
+inline
+const sc_fxval
+sc_fxval::operator -- ( int )
+{
+ sc_fxval c = *this;
+ (*this) -= 1;
+ return c;
+}
+
+inline
+sc_fxval&
+sc_fxval::operator ++ ()
+{
+ (*this) += 1;
+ return *this;
+}
+
+inline
+sc_fxval&
+sc_fxval::operator -- ()
+{
+ (*this) -= 1;
+ return *this;
+}
+
+
+// implicit conversion
+
+inline
+sc_fxval::operator double() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return m_rep->to_double();
+}
+
+
+// explicit conversion to primitive types
+
+inline
+short
+sc_fxval::to_short() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return static_cast<short>( m_rep->to_double() );
+}
+
+inline
+unsigned short
+sc_fxval::to_ushort() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return static_cast<unsigned short>( m_rep->to_double() );
+}
+
+inline
+int
+sc_fxval::to_int() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return static_cast<int>( m_rep->to_double() );
+}
+
+inline
+int64
+sc_fxval::to_int64() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return static_cast<int64>( m_rep->to_double() );
+}
+
+inline
+uint64
+sc_fxval::to_uint64() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return static_cast<uint64>( m_rep->to_double() );
+}
+
+inline
+long
+sc_fxval::to_long() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return static_cast<long>( m_rep->to_double() );
+}
+
+inline
+unsigned int
+sc_fxval::to_uint() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return static_cast<unsigned int>( m_rep->to_double() );
+}
+
+inline
+unsigned long
+sc_fxval::to_ulong() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return static_cast<unsigned long>( m_rep->to_double() );
+}
+
+inline
+float
+sc_fxval::to_float() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return static_cast<float>( m_rep->to_double() );
+}
+
+inline
+double
+sc_fxval::to_double() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return m_rep->to_double();
+}
+
+
+// query value
+
+inline
+bool
+sc_fxval::is_neg() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return m_rep->is_neg();
+}
+
+inline
+bool
+sc_fxval::is_zero() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return m_rep->is_zero();
+}
+
+inline
+bool
+sc_fxval::is_nan() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return m_rep->is_nan();
+}
+
+inline
+bool
+sc_fxval::is_inf() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return m_rep->is_inf();
+}
+
+inline
+bool
+sc_fxval::is_normal() const
+{
+ SC_FXVAL_OBSERVER_READ_( *this )
+ return m_rep->is_normal();
+}
+
+
+inline
+bool
+sc_fxval::rounding_flag() const
+{
+ return m_rep->rounding_flag();
+}
+
+
+// internal use only;
+inline
+bool
+sc_fxval::get_bit( int i ) const
+{
+ return m_rep->get_bit( i );
+}
+
+
+// protected methods and friend functions
+
+inline
+void
+sc_fxval::get_type( int& wl, int& iwl, sc_enc& enc ) const
+{
+ m_rep->get_type( wl, iwl, enc );
+}
+
+
+inline
+const sc_fxval
+sc_fxval::quantization( const scfx_params& params, bool& q_flag ) const
+{
+ return sc_fxval( sc_dt::quantization_scfx_rep( *m_rep, params, q_flag ) );
+}
+
+inline
+const sc_fxval
+sc_fxval::overflow( const scfx_params& params, bool& o_flag ) const
+{
+ return sc_fxval( sc_dt::overflow_scfx_rep( *m_rep, params, o_flag ) );
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxval& a )
+{
+ a.print( os );
+ return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_fxval& a )
+{
+ a.scan( is );
+ return is;
+}
+
+
+// ----------------------------------------------------------------------------
+// CLASS : sc_fxval_fast
+//
+// Fixed-point value type; limited precision.
+// ----------------------------------------------------------------------------
+
+// protected method
+
+inline
+sc_fxval_fast_observer*
+sc_fxval_fast::observer() const
+{
+ return m_observer;
+}
+
+
+// public constructors
+
+inline
+sc_fxval_fast::sc_fxval_fast( sc_fxval_fast_observer* observer_ )
+: m_val( 0.0 ),
+ m_observer( observer_ )
+{
+ SC_FXVAL_FAST_OBSERVER_DEFAULT_
+ SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this )
+}
+
+inline
+sc_fxval_fast::sc_fxval_fast( const sc_fxval_fast& a,
+ sc_fxval_fast_observer* observer_ )
+: m_val( a.m_val ),
+ m_observer( observer_ )
+{
+ SC_FXVAL_FAST_OBSERVER_DEFAULT_
+ SC_FXVAL_FAST_OBSERVER_READ_( a )
+ SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this )
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+}
+
+#define DEFN_CTOR_T(tp,arg) \
+inline \
+sc_fxval_fast::sc_fxval_fast( tp a, \
+ sc_fxval_fast_observer* observer_ ) \
+: m_val( arg ), \
+ m_observer( observer_ ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_DEFAULT_ \
+ SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this ) \
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this ) \
+}
+
+#define DEFN_CTOR_T_A(tp) DEFN_CTOR_T(tp,static_cast<double>( a ))
+#define DEFN_CTOR_T_B(tp) DEFN_CTOR_T(tp,from_string( a ))
+#define DEFN_CTOR_T_C(tp) DEFN_CTOR_T(tp,a.to_double())
+
+DEFN_CTOR_T_A(int)
+DEFN_CTOR_T_A(unsigned int)
+DEFN_CTOR_T_A(long)
+DEFN_CTOR_T_A(unsigned long)
+DEFN_CTOR_T_A(float)
+DEFN_CTOR_T_A(double)
+DEFN_CTOR_T_B(const char*)
+DEFN_CTOR_T_C(const sc_fxval&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTOR_T_A(int64)
+DEFN_CTOR_T_A(uint64)
+DEFN_CTOR_T_C(const sc_int_base&)
+DEFN_CTOR_T_C(const sc_uint_base&)
+DEFN_CTOR_T_C(const sc_signed&)
+DEFN_CTOR_T_C(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTOR_T
+#undef DEFN_CTOR_T_A
+#undef DEFN_CTOR_T_B
+#undef DEFN_CTOR_T_C
+#undef DEFN_CTOR_T_D
+#undef DEFN_CTOR_T_E
+
+
+inline
+sc_fxval_fast::~sc_fxval_fast()
+{
+ SC_FXVAL_FAST_OBSERVER_DESTRUCT_( *this )
+}
+
+
+// internal use only;
+inline
+double
+sc_fxval_fast::get_val() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return m_val;
+}
+
+// internal use only;
+inline
+void
+sc_fxval_fast::set_val( double val_ )
+{
+ m_val = val_;
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+}
+
+
+// unary operators
+
+inline
+const sc_fxval_fast
+sc_fxval_fast::operator - () const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return sc_fxval_fast( - m_val );
+}
+
+inline
+const sc_fxval_fast&
+sc_fxval_fast::operator + () const
+{
+ // SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return *this;
+}
+
+
+// unary functions
+
+inline
+void
+neg( sc_fxval_fast& c, const sc_fxval_fast& a )
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( a )
+ c.m_val = - a.m_val;
+ SC_FXVAL_FAST_OBSERVER_WRITE_( c )
+}
+
+
+// binary operators
+
+#define DEFN_BIN_OP_T(op,tp) \
+inline \
+const sc_fxval_fast \
+operator op ( const sc_fxval_fast& a, tp b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( a ) \
+ sc_fxval_fast tmp( b ); \
+ return sc_fxval_fast( a.m_val op tmp.m_val ); \
+} \
+ \
+inline \
+const sc_fxval_fast \
+operator op ( tp a, const sc_fxval_fast& b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( b ) \
+ sc_fxval_fast tmp( a ); \
+ return sc_fxval_fast( tmp.m_val op b.m_val ); \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_OP_OTHER(op) \
+DEFN_BIN_OP_T(op,int64) \
+DEFN_BIN_OP_T(op,uint64) \
+DEFN_BIN_OP_T(op,const sc_int_base&) \
+DEFN_BIN_OP_T(op,const sc_uint_base&) \
+DEFN_BIN_OP_T(op,const sc_signed&) \
+DEFN_BIN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_BIN_OP_OTHER(op)
+#endif
+
+#define DEFN_BIN_OP(op,dummy) \
+inline \
+const sc_fxval_fast \
+operator op ( const sc_fxval_fast& a, const sc_fxval_fast& b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( a ) \
+ SC_FXVAL_FAST_OBSERVER_READ_( b ) \
+ return sc_fxval_fast( a.m_val op b.m_val ); \
+} \
+ \
+DEFN_BIN_OP_T(op,int) \
+DEFN_BIN_OP_T(op,unsigned int) \
+DEFN_BIN_OP_T(op,long) \
+DEFN_BIN_OP_T(op,unsigned long) \
+DEFN_BIN_OP_T(op,float) \
+DEFN_BIN_OP_T(op,double) \
+DEFN_BIN_OP_T(op,const char*) \
+DEFN_BIN_OP_OTHER(op)
+
+DEFN_BIN_OP(*,mult)
+DEFN_BIN_OP(+,add)
+DEFN_BIN_OP(-,sub)
+//DEFN_BIN_OP(/,div)
+inline
+const sc_fxval_fast
+operator / ( const sc_fxval_fast& a, const sc_fxval_fast& b )
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( a )
+ SC_FXVAL_FAST_OBSERVER_READ_( b )
+ return sc_fxval_fast( a.m_val / b.m_val );
+}
+
+DEFN_BIN_OP_T(/,int)
+DEFN_BIN_OP_T(/,unsigned int)
+DEFN_BIN_OP_T(/,long)
+DEFN_BIN_OP_T(/,unsigned long)
+DEFN_BIN_OP_T(/,float)
+DEFN_BIN_OP_T(/,double)
+DEFN_BIN_OP_T(/,const char*)
+//DEFN_BIN_OP_OTHER(/)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_BIN_OP_T(/,int64)
+DEFN_BIN_OP_T(/,uint64)
+DEFN_BIN_OP_T(/,const sc_int_base&)
+DEFN_BIN_OP_T(/,const sc_uint_base&)
+DEFN_BIN_OP_T(/,const sc_signed&)
+DEFN_BIN_OP_T(/,const sc_unsigned&)
+#endif
+
+
+#undef DEFN_BIN_OP_T
+#undef DEFN_BIN_OP_OTHER
+#undef DEFN_BIN_OP
+
+
+inline
+const sc_fxval_fast
+operator << ( const sc_fxval_fast& a, int b )
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( a )
+ return sc_fxval_fast( a.m_val * scfx_pow2( b ) );
+}
+
+inline
+const sc_fxval_fast
+operator >> ( const sc_fxval_fast& a, int b )
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( a )
+ return sc_fxval_fast( a.m_val * scfx_pow2( -b ) );
+}
+
+
+// binary functions
+
+#define DEFN_BIN_FNC_T(fnc,op,tp) \
+inline \
+void \
+fnc ( sc_fxval_fast& c, const sc_fxval_fast& a, tp b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( a ) \
+ sc_fxval_fast tmp( b ); \
+ c.m_val = a.m_val op tmp.m_val; \
+ SC_FXVAL_FAST_OBSERVER_WRITE_( c ) \
+} \
+ \
+inline \
+void \
+fnc ( sc_fxval_fast& c, tp a, const sc_fxval_fast& b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( b ) \
+ sc_fxval_fast tmp( a ); \
+ c.m_val = tmp.m_val op b.m_val; \
+ SC_FXVAL_FAST_OBSERVER_WRITE_( c ) \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_FNC_OTHER(fnc,op) \
+DEFN_BIN_FNC_T(fnc,op,int64) \
+DEFN_BIN_FNC_T(fnc,op,uint64) \
+DEFN_BIN_FNC_T(fnc,op,const sc_int_base&) \
+DEFN_BIN_FNC_T(fnc,op,const sc_uint_base&) \
+DEFN_BIN_FNC_T(fnc,op,const sc_signed&) \
+DEFN_BIN_FNC_T(fnc,op,const sc_unsigned&)
+#else
+#define DEFN_BIN_FNC_OTHER(fnc,op)
+#endif
+
+#define DEFN_BIN_FNC(fnc,op) \
+inline \
+void \
+fnc ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval_fast& b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( a ) \
+ SC_FXVAL_FAST_OBSERVER_READ_( b ) \
+ c.m_val = a.m_val op b.m_val; \
+ SC_FXVAL_FAST_OBSERVER_WRITE_( c ) \
+} \
+ \
+DEFN_BIN_FNC_T(fnc,op,int) \
+DEFN_BIN_FNC_T(fnc,op,unsigned int) \
+DEFN_BIN_FNC_T(fnc,op,long) \
+DEFN_BIN_FNC_T(fnc,op,unsigned long) \
+DEFN_BIN_FNC_T(fnc,op,float) \
+DEFN_BIN_FNC_T(fnc,op,double) \
+DEFN_BIN_FNC_T(fnc,op,const char*) \
+DEFN_BIN_FNC_OTHER(fnc,op)
+
+DEFN_BIN_FNC(mult,*)
+DEFN_BIN_FNC(div,/)
+DEFN_BIN_FNC(add,+)
+DEFN_BIN_FNC(sub,-)
+
+#undef DEFN_BIN_FNC_T
+#undef DEFN_BIN_FNC_OTHER
+#undef DEFN_BIN_FNC
+
+
+inline
+void
+lshift( sc_fxval_fast& c, const sc_fxval_fast& a, int b )
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( a )
+ c.m_val = a.m_val * scfx_pow2( b );
+ SC_FXVAL_FAST_OBSERVER_WRITE_( c )
+}
+
+inline
+void
+rshift( sc_fxval_fast& c, const sc_fxval_fast& a, int b )
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( a )
+ c.m_val = a.m_val * scfx_pow2( -b );
+ SC_FXVAL_FAST_OBSERVER_WRITE_( c )
+}
+
+
+// relational (including equality) operators
+
+#define DEFN_REL_OP_T(op,tp) \
+inline \
+bool \
+operator op ( const sc_fxval_fast& a, tp b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( a ) \
+ sc_fxval_fast tmp( b ); \
+ return ( a.m_val op tmp.m_val ); \
+} \
+ \
+inline \
+bool \
+operator op ( tp a, const sc_fxval_fast& b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( b ) \
+ sc_fxval_fast tmp( a ); \
+ return ( tmp.m_val op b.m_val ); \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_REL_OP_OTHER(op) \
+DEFN_REL_OP_T(op,int64) \
+DEFN_REL_OP_T(op,uint64) \
+DEFN_REL_OP_T(op,const sc_int_base&) \
+DEFN_REL_OP_T(op,const sc_uint_base&) \
+DEFN_REL_OP_T(op,const sc_signed&) \
+DEFN_REL_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_REL_OP_OTHER(op)
+#endif
+
+#define DEFN_REL_OP(op) \
+inline \
+bool \
+operator op ( const sc_fxval_fast& a, const sc_fxval_fast& b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( a ) \
+ SC_FXVAL_FAST_OBSERVER_READ_( b ) \
+ return ( a.m_val op b.m_val ); \
+} \
+ \
+DEFN_REL_OP_T(op,int) \
+DEFN_REL_OP_T(op,unsigned int) \
+DEFN_REL_OP_T(op,long) \
+DEFN_REL_OP_T(op,unsigned long) \
+DEFN_REL_OP_T(op,float) \
+DEFN_REL_OP_T(op,double) \
+DEFN_REL_OP_T(op,const char*) \
+DEFN_REL_OP_OTHER(op)
+
+DEFN_REL_OP(<)
+DEFN_REL_OP(<=)
+DEFN_REL_OP(>)
+DEFN_REL_OP(>=)
+DEFN_REL_OP(==)
+DEFN_REL_OP(!=)
+
+#undef DEFN_REL_OP_T
+#undef DEFN_REL_OP_OTHER
+#undef DEFN_REL_OP
+
+
+// assignment operators
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator = ( const sc_fxval_fast& a )
+{
+ if( &a != this )
+ {
+ SC_FXVAL_FAST_OBSERVER_READ_( a )
+ m_val = a.m_val;
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+ }
+ return *this;
+}
+
+#define DEFN_ASN_OP_T(tp) \
+inline \
+sc_fxval_fast& \
+sc_fxval_fast::operator = ( tp a ) \
+{ \
+ sc_fxval_fast tmp( a ); \
+ m_val = tmp.m_val; \
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this ) \
+ return *this; \
+}
+
+DEFN_ASN_OP_T(int)
+DEFN_ASN_OP_T(unsigned int)
+DEFN_ASN_OP_T(long)
+DEFN_ASN_OP_T(unsigned long)
+DEFN_ASN_OP_T(float)
+DEFN_ASN_OP_T(double)
+DEFN_ASN_OP_T(const char*)
+DEFN_ASN_OP_T(const sc_fxval&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_ASN_OP_T(int64)
+DEFN_ASN_OP_T(uint64)
+DEFN_ASN_OP_T(const sc_int_base&)
+DEFN_ASN_OP_T(const sc_uint_base&)
+DEFN_ASN_OP_T(const sc_signed&)
+DEFN_ASN_OP_T(const sc_unsigned&)
+#endif
+
+#undef DEFN_ASN_OP_T
+
+
+#define DEFN_ASN_OP_T(op,tp) \
+inline \
+sc_fxval_fast& \
+sc_fxval_fast::operator op ( tp b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( *this ) \
+ sc_fxval_fast tmp( b ); \
+ m_val op tmp.m_val; \
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this ) \
+ 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) \
+inline \
+sc_fxval_fast& \
+sc_fxval_fast::operator op ( const sc_fxval_fast& b ) \
+{ \
+ SC_FXVAL_FAST_OBSERVER_READ_( *this ) \
+ SC_FXVAL_FAST_OBSERVER_READ_( b ) \
+ m_val op b.m_val; \
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this ) \
+ return *this; \
+} \
+ \
+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,float) \
+DEFN_ASN_OP_T(op,double) \
+DEFN_ASN_OP_T(op,const char*) \
+DEFN_ASN_OP_T(op,const sc_fxval&) \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator <<= ( int b )
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ m_val *= scfx_pow2( b );
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+ return *this;
+}
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator >>= ( int b )
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ m_val *= scfx_pow2( -b );
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+ return *this;
+}
+
+
+// auto-increment and auto-decrement
+
+inline
+const sc_fxval_fast
+sc_fxval_fast::operator ++ ( int )
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ double c = m_val;
+ m_val = m_val + 1;
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+ return sc_fxval_fast( c );
+}
+
+inline
+const sc_fxval_fast
+sc_fxval_fast::operator -- ( int )
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ double c = m_val;
+ m_val = m_val - 1;
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+ return sc_fxval_fast( c );
+}
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator ++ ()
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ m_val = m_val + 1;
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+ return *this;
+}
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator -- ()
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ m_val = m_val - 1;
+ SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+ return *this;
+}
+
+
+// implicit conversion
+
+inline
+sc_fxval_fast::operator double() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return m_val;
+}
+
+
+// explicit conversion to primitive types
+
+inline
+short
+sc_fxval_fast::to_short() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return static_cast<short>( m_val );
+}
+
+inline
+unsigned short
+sc_fxval_fast::to_ushort() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return static_cast<unsigned short>( m_val );
+}
+
+inline
+int64
+sc_fxval_fast::to_int64() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return static_cast<int64>( m_val );
+}
+
+inline
+int
+sc_fxval_fast::to_int() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return static_cast<int>( m_val );
+}
+
+inline
+unsigned int
+sc_fxval_fast::to_uint() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return static_cast<unsigned int>( m_val );
+}
+
+inline
+uint64
+sc_fxval_fast::to_uint64() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return static_cast<uint64>( m_val );
+}
+
+inline
+long
+sc_fxval_fast::to_long() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return static_cast<long>( m_val );
+}
+
+inline
+unsigned long
+sc_fxval_fast::to_ulong() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return static_cast<unsigned long>( m_val );
+}
+
+inline
+float
+sc_fxval_fast::to_float() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return static_cast<float>( m_val );
+}
+
+inline
+double
+sc_fxval_fast::to_double() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ return m_val;
+}
+
+
+// query value
+
+inline
+bool
+sc_fxval_fast::is_neg() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ scfx_ieee_double id( m_val );
+ return ( id.negative() != 0 );
+}
+
+inline
+bool
+sc_fxval_fast::is_zero() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ scfx_ieee_double id( m_val );
+ return id.is_zero();
+}
+
+inline
+bool
+sc_fxval_fast::is_nan() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ scfx_ieee_double id( m_val );
+ return id.is_nan();
+}
+
+inline
+bool
+sc_fxval_fast::is_inf() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ scfx_ieee_double id( m_val );
+ return id.is_inf();
+}
+
+inline
+bool
+sc_fxval_fast::is_normal() const
+{
+ SC_FXVAL_FAST_OBSERVER_READ_( *this )
+ scfx_ieee_double id( m_val );
+ return ( id.is_normal() || id.is_subnormal() || id.is_zero() );
+}
+
+
+inline
+bool
+sc_fxval_fast::rounding_flag() const
+{
+ // does not apply to sc_fxval_fast; included for API compatibility
+ return false;
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxval_fast& a )
+{
+ a.print( os );
+ return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_fxval_fast& a )
+{
+ a.scan( is );
+ return is;
+}
+
+} // namespace sc_dt
+
+#undef SCFX_EXPLICIT_
+#undef SCFX_EXPLICIT_OTHER_
+
+#endif
+
+// Taf!
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-09 17:37:00 +0000