ネームスペース sc_dt

構成
class	sc_bit
class	sc_bitref_r
class	sc_bitref
class	sc_subref_r
class	sc_subref
class	sc_concref_r
class	sc_concref
class	sc_bv
class	sc_bv_base
class	sc_logic
class	sc_lv
class	sc_lv_base
class	sc_proxy
class	sc_without_context
class	sc_global
class	sc_context
class	sc_fix
class	sc_fix_fast
class	sc_fixed
class	sc_fixed_fast
class	sc_fxcast_switch
class	sc_fxnum_bitref
class	sc_fxnum_fast_bitref
class	sc_fxnum_subref
class	sc_fxnum_fast_subref
class	sc_fxnum
class	sc_fxnum_fast
class	sc_fxnum_observer
class	sc_fxnum_fast_observer
class	sc_fxtype_params
class	sc_fxval
class	sc_fxval_fast
class	sc_fxval_observer
class	sc_fxval_fast_observer
class	sc_ufix
class	sc_ufix_fast
class	sc_ufixed
class	sc_ufixed_fast
union	ieee_double
class	scfx_ieee_double
union	ieee_float
class	scfx_ieee_float
class	word_list
class	scfx_mant
class	scfx_mant_ref
class	scfx_params
class	scfx_pow10
union	scfx_rep_node
union	word_short
class	scfx_index
class	scfx_rep
class	scfx_string
class	sc_bigint
class	sc_biguint
class	sc_int
class	sc_int_bitref_r
class	sc_int_bitref
class	sc_int_subref_r
class	sc_int_subref
class	sc_int_base
class	sc_length_param
class	sc_signed_bitref_r
class	sc_signed_bitref
class	sc_signed_subref_r
class	sc_signed_subref
class	sc_signed
class	sc_uint
class	sc_uint_bitref_r
class	sc_uint_bitref
class	sc_uint_subref_r
class	sc_uint_subref
class	sc_uint_base
class	sc_unsigned_bitref_r
class	sc_unsigned_bitref
class	sc_unsigned_subref_r
class	sc_unsigned_subref
class	sc_unsigned
class	sc_concatref
class	sc_concat_bool
class	sc_value_base
class	sc_generic_base
class	sc_string_rep
class	sc_string_old
型定義
typedef sc_context < sc_fxcast_switch >	sc_fxcast_context
typedef sc_context < sc_fxtype_params >	sc_fxtype_context
typedef unsigned int	word
typedef unsigned short	half_word
typedef sc_context < sc_length_param >	sc_length_context
typedef unsigned char	uchar
typedef int	small_type
typedef unsigned int	sc_digit
typedef long long	int64
typedef unsigned long long	uint64
typedef ::std::ios::fmtflags	fmtflags
typedef int64	int_type
typedef uint64	uint_type
typedef ::std::istream	systemc_istream
typedef ::std::ostream	systemc_ostream
列挙型
enum	sc_logic_value_t { Log_0 = 0, Log_1, Log_Z, Log_X }
enum	sc_context_begin { SC_NOW, SC_LATER }
enum	sc_enc { SC_TC_, SC_US_ }
enum	sc_q_mode {   SC_RND, SC_RND_ZERO, SC_RND_MIN_INF, SC_RND_INF,   SC_RND_CONV, SC_TRN, SC_TRN_ZERO }
enum	sc_o_mode {   SC_SAT, SC_SAT_ZERO, SC_SAT_SYM, SC_WRAP,   SC_WRAP_SM }
enum	sc_switch { SC_OFF, SC_ON }
enum	sc_fmt { SC_F, SC_E }
enum	sc_numrep {   SC_NOBASE = 0, SC_BIN = 2, SC_OCT = 8, SC_DEC = 10,   SC_HEX = 16, SC_BIN_US, SC_BIN_SM, SC_OCT_US,   SC_OCT_SM, SC_HEX_US, SC_HEX_SM, SC_CSD }
関数
void	sc_deprecated_sc_bit ()
bool	operator== (const sc_bit &a, const sc_bit &b)
bool	operator== (const sc_bit &a, int b)
bool	operator== (const sc_bit &a, bool b)
bool	operator== (const sc_bit &a, char b)
bool	operator== (int a, const sc_bit &b)
bool	operator== (bool a, const sc_bit &b)
bool	operator== (char a, const sc_bit &b)
bool	equal (const sc_bit &a, const sc_bit &b)
bool	equal (const sc_bit &a, int b)
bool	equal (const sc_bit &a, bool b)
bool	equal (const sc_bit &a, char b)
bool	equal (int a, const sc_bit &b)
bool	equal (bool a, const sc_bit &b)
bool	equal (char a, const sc_bit &b)
bool	operator!= (const sc_bit &a, const sc_bit &b)
bool	operator!= (const sc_bit &a, int b)
bool	operator!= (const sc_bit &a, bool b)
bool	operator!= (const sc_bit &a, char b)
bool	operator!= (int a, const sc_bit &b)
bool	operator!= (bool a, const sc_bit &b)
bool	operator!= (char a, const sc_bit &b)
bool	not_equal (const sc_bit &a, const sc_bit &b)
bool	not_equal (const sc_bit &a, int b)
bool	not_equal (const sc_bit &a, bool b)
bool	not_equal (const sc_bit &a, char b)
bool	not_equal (int a, const sc_bit &b)
bool	not_equal (bool a, const sc_bit &b)
bool	not_equal (char a, const sc_bit &b)
const sc_bit	operator~ (const sc_bit &a)
const sc_bit	b_not (const sc_bit &a)
void	b_not (sc_bit &r, const sc_bit &a)
const sc_bit	operator| (const sc_bit &a, const sc_bit &b)
const sc_bit	operator| (const sc_bit &a, int b)
const sc_bit	operator| (const sc_bit &a, bool b)
const sc_bit	operator| (const sc_bit &a, char b)
const sc_bit	operator| (int a, const sc_bit &b)
const sc_bit	operator| (bool a, const sc_bit &b)
const sc_bit	operator| (char a, const sc_bit &b)
const sc_bit	b_or (const sc_bit &a, const sc_bit &b)
const sc_bit	b_or (const sc_bit &a, int b)
const sc_bit	b_or (const sc_bit &a, bool b)
const sc_bit	b_or (const sc_bit &a, char b)
const sc_bit	b_or (int a, const sc_bit &b)
const sc_bit	b_or (bool a, const sc_bit &b)
const sc_bit	b_or (char a, const sc_bit &b)
void	b_or (sc_bit &r, const sc_bit &a, const sc_bit &b)
void	b_or (sc_bit &r, const sc_bit &a, int b)
void	b_or (sc_bit &r, const sc_bit &a, bool b)
void	b_or (sc_bit &r, const sc_bit &a, char b)
void	b_or (sc_bit &r, int a, const sc_bit &b)
void	b_or (sc_bit &r, bool a, const sc_bit &b)
void	b_or (sc_bit &r, char a, const sc_bit &b)
const sc_bit	operator & (const sc_bit &a, const sc_bit &b)
const sc_bit	operator & (const sc_bit &a, int b)
const sc_bit	operator & (const sc_bit &a, bool b)
const sc_bit	operator & (const sc_bit &a, char b)
const sc_bit	operator & (int a, const sc_bit &b)
const sc_bit	operator & (bool a, const sc_bit &b)
const sc_bit	operator & (char a, const sc_bit &b)
const sc_bit	b_and (const sc_bit &a, const sc_bit &b)
const sc_bit	b_and (const sc_bit &a, int b)
const sc_bit	b_and (const sc_bit &a, bool b)
const sc_bit	b_and (const sc_bit &a, char b)
const sc_bit	b_and (int a, const sc_bit &b)
const sc_bit	b_and (bool a, const sc_bit &b)
const sc_bit	b_and (char a, const sc_bit &b)
void	b_and (sc_bit &r, const sc_bit &a, const sc_bit &b)
void	b_and (sc_bit &r, const sc_bit &a, int b)
void	b_and (sc_bit &r, const sc_bit &a, bool b)
void	b_and (sc_bit &r, const sc_bit &a, char b)
void	b_and (sc_bit &r, int a, const sc_bit &b)
void	b_and (sc_bit &r, bool a, const sc_bit &b)
void	b_and (sc_bit &r, char a, const sc_bit &b)
const sc_bit	operator^ (const sc_bit &a, const sc_bit &b)
const sc_bit	operator^ (const sc_bit &a, int b)
const sc_bit	operator^ (const sc_bit &a, bool b)
const sc_bit	operator^ (const sc_bit &a, char b)
const sc_bit	operator^ (int a, const sc_bit &b)
const sc_bit	operator^ (bool a, const sc_bit &b)
const sc_bit	operator^ (char a, const sc_bit &b)
const sc_bit	b_xor (const sc_bit &a, const sc_bit &b)
const sc_bit	b_xor (const sc_bit &a, int b)
const sc_bit	b_xor (const sc_bit &a, bool b)
const sc_bit	b_xor (const sc_bit &a, char b)
const sc_bit	b_xor (int a, const sc_bit &b)
const sc_bit	b_xor (bool a, const sc_bit &b)
const sc_bit	b_xor (char a, const sc_bit &b)
void	b_xor (sc_bit &r, const sc_bit &a, const sc_bit &b)
void	b_xor (sc_bit &r, const sc_bit &a, int b)
void	b_xor (sc_bit &r, const sc_bit &a, bool b)
void	b_xor (sc_bit &r, const sc_bit &a, char b)
void	b_xor (sc_bit &r, int a, const sc_bit &b)
void	b_xor (sc_bit &r, bool a, const sc_bit &b)
void	b_xor (sc_bit &r, char a, const sc_bit &b)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_bit &a)
inline::std::istream &	operator>> (::std::istream &is, sc_bit &a)
template<class T1, class T2>
const sc_logic	operator & (const sc_bitref_r< T1 > &a, const sc_bitref_r< T2 > &b)
template<class T1, class T2>
const sc_logic	operator| (const sc_bitref_r< T1 > &a, const sc_bitref_r< T2 > &b)
template<class T1, class T2>
const sc_logic	operator^ (const sc_bitref_r< T1 > &a, const sc_bitref_r< T2 > &b)
template<class T1, class T2>
bool	operator== (const sc_bitref_r< T1 > &a, const sc_bitref_r< T2 > &b)
template<class T1, class T2>
bool	operator!= (const sc_bitref_r< T1 > &a, const sc_bitref_r< T2 > &b)
template<class T1, class T2>
sc_concref_r< sc_bitref_r< T1 > , sc_bitref_r< T2 > >	operator, (sc_bitref_r< T1 >, sc_bitref_r< T2 >)
template<class T1, class T2>
sc_concref_r< sc_bitref_r< T1 > , sc_subref_r< T2 > >	operator, (sc_bitref_r< T1 >, sc_subref_r< T2 >)
template<class T1, class T2, class T3>
sc_concref_r< sc_bitref_r< T1 > , sc_concref_r< T2, T3 > >	operator, (sc_bitref_r< T1 >, sc_concref_r< T2, T3 >)
template<class T1, class T2>
sc_concref_r< sc_bitref_r< T1 > , T2 >	operator, (sc_bitref_r< T1 >, const sc_proxy< T2 > &)
template<class T>
sc_concref_r< sc_bitref_r< T > , sc_lv_base >	operator, (sc_bitref_r< T >, const char *)
template<class T>
sc_concref_r< sc_lv_base, sc_bitref_r< T > >	operator, (const char *, sc_bitref_r< T >)
template<class T>
sc_concref_r< sc_bitref_r< T > , sc_lv_base >	operator, (sc_bitref_r< T >, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base, sc_bitref_r< T > >	operator, (const sc_logic &, sc_bitref_r< T >)
template<class T>
sc_concref_r< sc_bitref_r< T > , sc_lv_base >	operator, (sc_bitref_r< T >, bool)
template<class T>
sc_concref_r< sc_lv_base, sc_bitref_r< T > >	operator, (bool, sc_bitref_r< T >)
template<class T1, class T2>
sc_concref_r< sc_bitref_r< T1 > , sc_bitref_r< T2 > >	concat (sc_bitref_r< T1 >, sc_bitref_r< T2 >)
template<class T1, class T2>
sc_concref_r< sc_bitref_r< T1 > , sc_subref_r< T2 > >	concat (sc_bitref_r< T1 >, sc_subref_r< T2 >)
template<class T1, class T2, class T3>
sc_concref_r< sc_bitref_r< T1 > , sc_concref_r< T2, T3 > >	concat (sc_bitref_r< T1 >, sc_concref_r< T2, T3 >)
template<class T1, class T2>
sc_concref_r< sc_bitref_r< T1 > , T2 >	concat (sc_bitref_r< T1 >, const sc_proxy< T2 > &)
template<class T>
sc_concref_r< sc_bitref_r< T > , sc_lv_base >	concat (sc_bitref_r< T >, const char *)
template<class T>
sc_concref_r< sc_lv_base, sc_bitref_r< T > >	concat (const char *, sc_bitref_r< T >)
template<class T>
sc_concref_r< sc_bitref_r< T > , sc_lv_base >	concat (sc_bitref_r< T >, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base, sc_bitref_r< T > >	concat (const sc_logic &, sc_bitref_r< T >)
template<class T>
sc_concref_r< sc_bitref_r< T > , sc_lv_base >	concat (sc_bitref_r< T >, bool)
template<class T>
sc_concref_r< sc_lv_base, sc_bitref_r< T > >	concat (bool, sc_bitref_r< T >)
template<class T1, class T2>
sc_concref< sc_bitref< T1 > , sc_bitref< T2 > >	operator, (sc_bitref< T1 >, sc_bitref< T2 >)
template<class T1, class T2>
sc_concref< sc_bitref< T1 > , sc_subref< T2 > >	operator, (sc_bitref< T1 >, sc_subref< T2 >)
template<class T1, class T2, class T3>
sc_concref< sc_bitref< T1 > , sc_concref< T2, T3 > >	operator, (sc_bitref< T1 >, sc_concref< T2, T3 >)
template<class T1, class T2>
sc_concref< sc_bitref< T1 >, T2 >	operator, (sc_bitref< T1 >, sc_proxy< T2 > &)
template<class T1, class T2>
sc_concref< sc_bitref< T1 > , sc_bitref< T2 > >	concat (sc_bitref< T1 >, sc_bitref< T2 >)
template<class T1, class T2>
sc_concref< sc_bitref< T1 > , sc_subref< T2 > >	concat (sc_bitref< T1 >, sc_subref< T2 >)
template<class T1, class T2, class T3>
sc_concref< sc_bitref< T1 > , sc_concref< T2, T3 > >	concat (sc_bitref< T1 >, sc_concref< T2, T3 >)
template<class T1, class T2>
sc_concref< sc_bitref< T1 >, T2 >	concat (sc_bitref< T1 >, sc_proxy< T2 > &)
template<class T>
::std::istream &	operator>> (::std::istream &, sc_bitref< T >)
template<class T1, class T2>
sc_concref_r< sc_subref_r< T1 > , sc_bitref_r< T2 > >	operator, (sc_subref_r< T1 >, sc_bitref_r< T2 >)
template<class T1, class T2>
sc_concref_r< sc_subref_r< T1 > , sc_subref_r< T2 > >	operator, (sc_subref_r< T1 >, sc_subref_r< T2 >)
template<class T1, class T2, class T3>
sc_concref_r< sc_subref_r< T1 > , sc_concref_r< T2, T3 > >	operator, (sc_subref_r< T1 >, sc_concref_r< T2, T3 >)
template<class T1, class T2>
sc_concref_r< sc_subref_r< T1 > , T2 >	operator, (sc_subref_r< T1 >, const sc_proxy< T2 > &)
template<class T>
sc_concref_r< sc_subref_r< T > , sc_lv_base >	operator, (sc_subref_r< T >, const char *)
template<class T>
sc_concref_r< sc_lv_base, sc_subref_r< T > >	operator, (const char *, sc_subref_r< T >)
template<class T>
sc_concref_r< sc_subref_r< T > , sc_lv_base >	operator, (sc_subref_r< T >, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base, sc_subref_r< T > >	operator, (const sc_logic &, sc_subref_r< T >)
template<class T>
sc_concref_r< sc_subref_r< T > , sc_lv_base >	operator, (sc_subref_r< T >, bool)
template<class T>
sc_concref_r< sc_lv_base, sc_subref_r< T > >	operator, (bool, sc_subref_r< T >)
template<class T1, class T2>
sc_concref_r< sc_subref_r< T1 > , sc_bitref_r< T2 > >	concat (sc_subref_r< T1 >, sc_bitref_r< T2 >)
template<class T1, class T2>
sc_concref_r< sc_subref_r< T1 > , sc_subref_r< T2 > >	concat (sc_subref_r< T1 >, sc_subref_r< T2 >)
template<class T1, class T2, class T3>
sc_concref_r< sc_subref_r< T1 > , sc_concref_r< T2, T3 > >	concat (sc_subref_r< T1 >, sc_concref_r< T2, T3 >)
template<class T1, class T2>
sc_concref_r< sc_subref_r< T1 > , T2 >	concat (sc_subref_r< T1 >, const sc_proxy< T2 > &)
template<class T>
sc_concref_r< sc_subref_r< T > , sc_lv_base >	concat (sc_subref_r< T >, const char *)
template<class T>
sc_concref_r< sc_lv_base, sc_subref_r< T > >	concat (const char *, sc_subref_r< T >)
template<class T>
sc_concref_r< sc_subref_r< T > , sc_lv_base >	concat (sc_subref_r< T >, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base, sc_subref_r< T > >	concat (const sc_logic &, sc_subref_r< T >)
template<class T>
sc_concref_r< sc_subref_r< T > , sc_lv_base >	concat (sc_subref_r< T >, bool)
template<class T>
sc_concref_r< sc_lv_base, sc_subref_r< T > >	concat (bool, sc_subref_r< T >)
template<class T1, class T2>
sc_concref< sc_subref< T1 > , sc_bitref< T2 > >	operator, (sc_subref< T1 >, sc_bitref< T2 >)
template<class T1, class T2>
sc_concref< sc_subref< T1 > , sc_subref< T2 > >	operator, (sc_subref< T1 >, sc_subref< T2 >)
template<class T1, class T2, class T3>
sc_concref< sc_subref< T1 > , sc_concref< T2, T3 > >	operator, (sc_subref< T1 >, sc_concref< T2, T3 >)
template<class T1, class T2>
sc_concref< sc_subref< T1 >, T2 >	operator, (sc_subref< T1 >, sc_proxy< T2 > &)
template<class T1, class T2>
sc_concref< sc_subref< T1 > , sc_bitref< T2 > >	concat (sc_subref< T1 >, sc_bitref< T2 >)
template<class T1, class T2>
sc_concref< sc_subref< T1 > , sc_subref< T2 > >	concat (sc_subref< T1 >, sc_subref< T2 >)
template<class T1, class T2, class T3>
sc_concref< sc_subref< T1 > , sc_concref< T2, T3 > >	concat (sc_subref< T1 >, sc_concref< T2, T3 >)
template<class T1, class T2>
sc_concref< sc_subref< T1 >, T2 >	concat (sc_subref< T1 >, sc_proxy< T2 > &)
template<class T>
inline::std::istream &	operator>> (::std::istream &, sc_subref< T >)
template<class T1, class T2, class T3>
sc_concref_r< sc_concref_r< T1, T2 >, sc_bitref_r< T3 > >	operator, (sc_concref_r< T1, T2 >, sc_bitref_r< T3 >)
template<class T1, class T2, class T3>
sc_concref_r< sc_concref_r< T1, T2 >, sc_subref_r< T3 > >	operator, (sc_concref_r< T1, T2 >, sc_subref_r< T3 >)
template<class T1, class T2, class T3, class T4>
sc_concref_r< sc_concref_r< T1, T2 >, sc_concref_r< T3, T4 > >	operator, (sc_concref_r< T1, T2 >, sc_concref_r< T3, T4 >)
template<class T1, class T2, class T3>
sc_concref_r< sc_concref_r< T1, T2 >, T3 >	operator, (sc_concref_r< T1, T2 >, const sc_proxy< T3 > &)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base >	operator, (sc_concref_r< T1, T2 >, const char *)
template<class T1, class T2>
sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > >	operator, (const char *, sc_concref_r< T1, T2 >)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base >	operator, (sc_concref_r< T1, T2 >, const sc_logic &)
template<class T1, class T2>
sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > >	operator, (const sc_logic &, sc_concref_r< T1, T2 >)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base >	operator, (sc_concref_r< T1, T2 >, bool)
template<class T1, class T2>
sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > >	operator, (bool, sc_concref_r< T1, T2 >)
template<class T1, class T2, class T3>
sc_concref_r< sc_concref_r< T1, T2 >, sc_bitref_r< T3 > >	concat (sc_concref_r< T1, T2 >, sc_bitref_r< T3 >)
template<class T1, class T2, class T3>
sc_concref_r< sc_concref_r< T1, T2 >, sc_subref_r< T3 > >	concat (sc_concref_r< T1, T2 >, sc_subref_r< T3 >)
template<class T1, class T2, class T3, class T4>
sc_concref_r< sc_concref_r< T1, T2 >, sc_concref_r< T3, T4 > >	concat (sc_concref_r< T1, T2 >, sc_concref_r< T3, T4 >)
template<class T1, class T2, class T3>
sc_concref_r< sc_concref_r< T1, T2 >, T3 >	concat (sc_concref_r< T1, T2 >, const sc_proxy< T3 > &)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base >	concat (sc_concref_r< T1, T2 >, const char *)
template<class T1, class T2>
sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > >	concat (const char *, sc_concref_r< T1, T2 >)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base >	concat (sc_concref_r< T1, T2 >, const sc_logic &)
template<class T1, class T2>
sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > >	concat (const sc_logic &, sc_concref_r< T1, T2 >)
template<class T1, class T2>
sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base >	concat (sc_concref_r< T1, T2 >, bool)
template<class T1, class T2>
sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > >	concat (bool, sc_concref_r< T1, T2 >)
template<class T1, class T2, class T3>
sc_concref< sc_concref< T1, T2 > , sc_bitref< T3 > >	operator, (sc_concref< T1, T2 >, sc_bitref< T3 >)
template<class T1, class T2, class T3>
sc_concref< sc_concref< T1, T2 > , sc_subref< T3 > >	operator, (sc_concref< T1, T2 >, sc_subref< T3 >)
template<class T1, class T2, class T3, class T4>
sc_concref< sc_concref< T1, T2 > , sc_concref< T3, T4 > >	operator, (sc_concref< T1, T2 >, sc_concref< T3, T4 >)
template<class T1, class T2, class T3>
sc_concref< sc_concref< T1, T2 > , T3 >	operator, (sc_concref< T1, T2 >, sc_proxy< T3 > &)
template<class T1, class T2, class T3>
sc_concref< sc_concref< T1, T2 > , sc_bitref< T3 > >	concat (sc_concref< T1, T2 >, sc_bitref< T3 >)
template<class T1, class T2, class T3>
sc_concref< sc_concref< T1, T2 > , sc_subref< T3 > >	concat (sc_concref< T1, T2 >, sc_subref< T3 >)
template<class T1, class T2, class T3, class T4>
sc_concref< sc_concref< T1, T2 > , sc_concref< T3, T4 > >	concat (sc_concref< T1, T2 >, sc_concref< T3, T4 >)
template<class T1, class T2, class T3>
sc_concref< sc_concref< T1, T2 > , T3 >	concat (sc_concref< T1, T2 >, sc_proxy< T3 > &)
template<class T1, class T2>
inline::std::istream &	operator>> (::std::istream &, sc_concref< T1, T2 >)
template<class T1, class T2>
sc_concref_r< T1, sc_bitref_r < T2 > >	operator, (const sc_proxy< T1 > &, sc_bitref_r< T2 >)
template<class T1, class T2>
sc_concref_r< T1, sc_subref_r < T2 > >	operator, (const sc_proxy< T1 > &, sc_subref_r< T2 >)
template<class T1, class T2, class T3>
sc_concref_r< T1, sc_concref_r < T2, T3 > >	operator, (const sc_proxy< T1 > &, sc_concref_r< T2, T3 >)
template<class T1, class T2>
sc_concref_r< T1, T2 >	operator, (const sc_proxy< T1 > &, const sc_proxy< T2 > &)
template<class T>
sc_concref_r< T, sc_lv_base >	operator, (const sc_proxy< T > &, const char *)
template<class T>
sc_concref_r< sc_lv_base, T >	operator, (const char *, const sc_proxy< T > &)
template<class T>
sc_concref_r< T, sc_lv_base >	operator, (const sc_proxy< T > &, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base, T >	operator, (const sc_logic &, const sc_proxy< T > &)
template<class T>
sc_concref_r< T, sc_lv_base >	operator, (const sc_proxy< T > &, bool)
template<class T>
sc_concref_r< sc_lv_base, T >	operator, (bool, const sc_proxy< T > &)
template<class T1, class T2>
sc_concref_r< T1, sc_bitref_r < T2 > >	concat (const sc_proxy< T1 > &, sc_bitref_r< T2 >)
template<class T1, class T2>
sc_concref_r< T1, sc_subref_r < T2 > >	concat (const sc_proxy< T1 > &, sc_subref_r< T2 >)
template<class T1, class T2, class T3>
sc_concref_r< T1, sc_concref_r < T2, T3 > >	concat (const sc_proxy< T1 > &, sc_concref_r< T2, T3 >)
template<class T1, class T2>
sc_concref_r< T1, T2 >	concat (const sc_proxy< T1 > &, const sc_proxy< T2 > &)
template<class T>
sc_concref_r< T, sc_lv_base >	concat (const sc_proxy< T > &, const char *)
template<class T>
sc_concref_r< sc_lv_base, T >	concat (const char *, const sc_proxy< T > &)
template<class T>
sc_concref_r< T, sc_lv_base >	concat (const sc_proxy< T > &, const sc_logic &)
template<class T>
sc_concref_r< sc_lv_base, T >	concat (const sc_logic &, const sc_proxy< T > &)
template<class T>
sc_concref_r< T, sc_lv_base >	concat (const sc_proxy< T > &, bool)
template<class T>
sc_concref_r< sc_lv_base, T >	concat (bool, const sc_proxy< T > &)
template<class T1, class T2>
sc_concref< T1, sc_bitref< T2 > >	operator, (sc_proxy< T1 > &, sc_bitref< T2 >)
template<class T1, class T2>
sc_concref< T1, sc_subref< T2 > >	operator, (sc_proxy< T1 > &, sc_subref< T2 >)
template<class T1, class T2, class T3>
sc_concref< T1, sc_concref< T2, T3 > >	operator, (sc_proxy< T1 > &, sc_concref< T2, T3 >)
template<class T1, class T2>
sc_concref< T1, T2 >	operator, (sc_proxy< T1 > &, sc_proxy< T2 > &)
template<class T1, class T2>
sc_concref< T1, sc_bitref< T2 > >	concat (sc_proxy< T1 > &, sc_bitref< T2 >)
template<class T1, class T2>
sc_concref< T1, sc_subref< T2 > >	concat (sc_proxy< T1 > &, sc_subref< T2 >)
template<class T1, class T2, class T3>
sc_concref< T1, sc_concref< T2, T3 > >	concat (sc_proxy< T1 > &, sc_concref< T2, T3 >)
template<class T1, class T2>
sc_concref< T1, T2 >	concat (sc_proxy< T1 > &, sc_proxy< T2 > &)
template<class X>
inline::std::istream &	operator>> (::std::istream &is, sc_bitref< X > a)
template<class X>
inline::std::istream &	operator>> (::std::istream &is, sc_subref< X > a)
template<class X, class Y>
inline::std::istream &	operator>> (::std::istream &is, sc_concref< X, Y > a)
const std::string	convert_to_bin (const char *s)
const std::string	convert_to_fmt (const std::string &s, sc_numrep numrep, bool w_prefix)
const sc_logic	operator & (const sc_logic &a, const sc_logic &b)
const sc_logic	operator & (const sc_logic &a, sc_logic_value_t b)
const sc_logic	operator & (const sc_logic &a, bool b)
const sc_logic	operator & (const sc_logic &a, char b)
const sc_logic	operator & (const sc_logic &a, int b)
const sc_logic	operator & (sc_logic_value_t a, const sc_logic &b)
const sc_logic	operator & (bool a, const sc_logic &b)
const sc_logic	operator & (char a, const sc_logic &b)
const sc_logic	operator & (int a, const sc_logic &b)
const sc_logic	operator| (const sc_logic &a, const sc_logic &b)
const sc_logic	operator| (const sc_logic &a, sc_logic_value_t b)
const sc_logic	operator| (const sc_logic &a, bool b)
const sc_logic	operator| (const sc_logic &a, char b)
const sc_logic	operator| (const sc_logic &a, int b)
const sc_logic	operator| (sc_logic_value_t a, const sc_logic &b)
const sc_logic	operator| (bool a, const sc_logic &b)
const sc_logic	operator| (char a, const sc_logic &b)
const sc_logic	operator| (int a, const sc_logic &b)
const sc_logic	operator^ (const sc_logic &a, const sc_logic &b)
const sc_logic	operator^ (const sc_logic &a, sc_logic_value_t b)
const sc_logic	operator^ (const sc_logic &a, bool b)
const sc_logic	operator^ (const sc_logic &a, char b)
const sc_logic	operator^ (const sc_logic &a, int b)
const sc_logic	operator^ (sc_logic_value_t a, const sc_logic &b)
const sc_logic	operator^ (bool a, const sc_logic &b)
const sc_logic	operator^ (char a, const sc_logic &b)
const sc_logic	operator^ (int a, const sc_logic &b)
bool	operator== (const sc_logic &a, const sc_logic &b)
bool	operator== (const sc_logic &a, sc_logic_value_t b)
bool	operator== (const sc_logic &a, bool b)
bool	operator== (const sc_logic &a, char b)
bool	operator== (const sc_logic &a, int b)
bool	operator== (sc_logic_value_t a, const sc_logic &b)
bool	operator== (bool a, const sc_logic &b)
bool	operator== (char a, const sc_logic &b)
bool	operator== (int a, const sc_logic &b)
bool	operator!= (const sc_logic &a, const sc_logic &b)
bool	operator!= (const sc_logic &a, sc_logic_value_t b)
bool	operator!= (const sc_logic &a, bool b)
bool	operator!= (const sc_logic &a, char b)
bool	operator!= (const sc_logic &a, int b)
bool	operator!= (sc_logic_value_t a, const sc_logic &b)
bool	operator!= (bool a, const sc_logic &b)
bool	operator!= (char a, const sc_logic &b)
bool	operator!= (int a, const sc_logic &b)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_logic &a)
inline::std::istream &	operator>> (::std::istream &is, sc_logic &a)
template<class X, class Y>
X &	operator &= (sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
const sc_lv_base	operator & (const sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
X &	operator|= (sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
const sc_lv_base	operator| (const sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
X &	operator^= (sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
const sc_lv_base	operator^ (const sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X>
const sc_lv_base	lrotate (const sc_proxy< X > &x, int n)
template<class X>
const sc_lv_base	rrotate (const sc_proxy< X > &x, int n)
template<class X>
const sc_lv_base	reverse (const sc_proxy< X > &x)
template<class X, class Y>
bool	operator== (const sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
void	assign_p_ (sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class T>
void	assign_v_ (sc_proxy< X > &px, const T &a)
template<class X, class Y>
bool	operator!= (const sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X>
void	get_words_ (const X &x, int wi, sc_digit &x_dw, sc_digit &x_cw)
template<class X>
void	set_words_ (X &x, int wi, sc_digit x_dw, sc_digit x_cw)
template<class X>
void	extend_sign_w_ (X &x, int wi, bool sign)
template<class X>
void	assign_v_ (sc_proxy< X > &px, const sc_int_base &a)
template<class X>
void	assign_v_ (sc_proxy< X > &px, const sc_signed &a)
template<class X>
void	assign_v_ (sc_proxy< X > &px, const sc_uint_base &a)
template<class X>
void	assign_v_ (sc_proxy< X > &px, const sc_unsigned &a)
template<class X, class Y>
X &	b_and_assign_ (sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
X &	b_or_assign_ (sc_proxy< X > &px, const sc_proxy< Y > &py)
template<class X, class Y>
X &	b_xor_assign_ (sc_proxy< X > &a, const sc_proxy< Y > &b)
template<class X>
sc_logic_value_t	and_reduce (const sc_proxy< X > &a)
template<class X>
sc_logic_value_t	nand_reduce (const sc_proxy< X > &a)
template<class X>
sc_logic_value_t	or_reduce (const sc_proxy< X > &a)
template<class X>
sc_logic_value_t	nor_reduce (const sc_proxy< X > &a)
template<class X>
sc_logic_value_t	xor_reduce (const sc_proxy< X > &a)
template<class X>
sc_logic_value_t	xnor_reduce (const sc_proxy< X > &a)
template<class X>
inline::std::ostream &	operator<< (::std::ostream &os, const sc_proxy< X > &a)
template<class X>
inline::std::istream &	operator>> (::std::istream &is, sc_proxy< X > &a)
void	b_not (sc_fix &c, const sc_fix &a)
void	b_not (sc_fix_fast &c, const sc_fix_fast &a)
bool	operator== (const sc_fxcast_switch &a, const sc_fxcast_switch &b)
bool	operator!= (const sc_fxcast_switch &a, const sc_fxcast_switch &b)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_fxcast_switch &a)
const std::string	to_string (sc_enc enc)
const std::string	to_string (sc_q_mode q_mode)
const std::string	to_string (sc_o_mode o_mode)
const std::string	to_string (sc_switch sw)
const std::string	to_string (sc_fmt fmt)
inline::std::ostream &	operator<< (::std::ostream &os, sc_enc enc)
inline::std::ostream &	operator<< (::std::ostream &os, sc_q_mode q_mode)
inline::std::ostream &	operator<< (::std::ostream &os, sc_o_mode o_mode)
inline::std::ostream &	operator<< (::std::ostream &os, sc_switch sw)
inline::std::ostream &	operator<< (::std::ostream &os, sc_fmt fmt)
static void	quantization (double &c, const scfx_params &params, bool &q_flag)
static void	overflow (double &c, const scfx_params &params, bool &o_flag)
const char *	to_string (const scfx_ieee_double &, sc_numrep, int, sc_fmt, const scfx_params *=0)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_fxnum_bitref &a)
inline::std::istream &	operator>> (::std::istream &is, sc_fxnum_bitref &a)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_fxnum_fast_bitref &a)
inline::std::istream &	operator>> (::std::istream &is, sc_fxnum_fast_bitref &a)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_fxnum_subref &a)
inline::std::istream &	operator>> (::std::istream &is, sc_fxnum_subref &a)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_fxnum_fast_subref &a)
inline::std::istream &	operator>> (::std::istream &is, sc_fxnum_fast_subref &a)
void	neg (sc_fxval &c, const sc_fxnum &a)
void	neg (sc_fxnum &c, const sc_fxnum &a)
const sc_fxval	operator/ (const sc_fxnum &a, const sc_fxnum &b)
const sc_fxval	operator/ (const sc_fxnum &a, const sc_fxval &b)
const sc_fxval	operator/ (const sc_fxval &a, const sc_fxnum &b)
const sc_fxval	operator<< (const sc_fxnum &a, int b)
const sc_fxval	operator>> (const sc_fxnum &a, int b)
void	lshift (sc_fxval &c, const sc_fxnum &a, int b)
void	rshift (sc_fxval &c, const sc_fxnum &a, int b)
void	lshift (sc_fxnum &c, const sc_fxnum &a, int b)
void	rshift (sc_fxnum &c, const sc_fxnum &a, int b)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_fxnum &a)
inline::std::istream &	operator>> (::std::istream &is, sc_fxnum &a)
void	neg (sc_fxval_fast &c, const sc_fxnum_fast &a)
void	neg (sc_fxnum_fast &c, const sc_fxnum_fast &a)
const sc_fxval_fast	operator/ (const sc_fxnum_fast &a, const sc_fxnum_fast &b)
const sc_fxval_fast	operator/ (const sc_fxnum_fast &a, const sc_fxval_fast &b)
const sc_fxval_fast	operator/ (const sc_fxval_fast &a, const sc_fxnum_fast &b)
const sc_fxval_fast	operator<< (const sc_fxnum_fast &a, int b)
const sc_fxval_fast	operator>> (const sc_fxnum_fast &a, int b)
void	lshift (sc_fxval_fast &c, const sc_fxnum_fast &a, int b)
void	rshift (sc_fxval_fast &c, const sc_fxnum_fast &a, int b)
void	lshift (sc_fxnum_fast &c, const sc_fxnum_fast &a, int b)
void	rshift (sc_fxnum_fast &c, const sc_fxnum_fast &a, int b)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_fxnum_fast &a)
inline::std::istream &	operator>> (::std::istream &is, sc_fxnum_fast &a)
bool	operator== (const sc_fxtype_params &a, const sc_fxtype_params &b)
bool	operator!= (const sc_fxtype_params &a, const sc_fxtype_params &b)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_fxtype_params &a)
static void	print_dec (scfx_string &s, scfx_ieee_double id, int w_prefix, sc_fmt fmt)
static void	print_other (scfx_string &s, const scfx_ieee_double &id, sc_numrep numrep, int w_prefix, sc_fmt fmt, const scfx_params *params)
void	neg (sc_fxval &c, const sc_fxval &a)
const sc_fxval	operator/ (const sc_fxval &a, const sc_fxval &b)
	DEFN_BIN_OP_T (/, div, int64) DEFN_BIN_OP_T(/
uint64	DEFN_BIN_OP_T (/, div, const sc_int_base &) DEFN_BIN_OP_T(/
uint64 const sc_uint_base &	DEFN_BIN_OP_T (/, div, const sc_signed &) inline const sc_fxval operator<< (const sc_fxval &a
	m_observer (observer_)
void	neg (sc_fxval_fast &c, const sc_fxval_fast &a)
const sc_fxval_fast	operator/ (const sc_fxval_fast &a, const sc_fxval_fast &b)
const sc_fxval_fast	operator<< (const sc_fxval_fast &a, int b)
const sc_fxval_fast	operator>> (const sc_fxval_fast &a, int b)
void	lshift (sc_fxval_fast &c, const sc_fxval_fast &a, int b)
void	rshift (sc_fxval_fast &c, const sc_fxval_fast &a, int b)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_fxval_fast &a)
inline::std::istream &	operator>> (::std::istream &is, sc_fxval_fast &a)
void	b_not (sc_ufix &c, const sc_ufix &a)
void	b_not (sc_ufix_fast &c, const sc_ufix_fast &a)
double	scfx_pow2 (int exp)
double	uint64_to_double (uint64 a)
static int	next_pow2_index (std::size_t size)
void	complement (scfx_mant &target, const scfx_mant &source, int size)
void	inc (scfx_mant &mant)
void	sc_trace (sc_core::sc_trace_file *tf, const sc_fxval &object, const std::string &name)
void	sc_trace (sc_core::sc_trace_file *tf, const sc_fxval *object, const std::string &name)
void	sc_trace (sc_core::sc_trace_file *tf, const sc_fxval_fast &object, const std::string &name)
void	sc_trace (sc_core::sc_trace_file *tf, const sc_fxval_fast *object, const std::string &name)
void	sc_trace (sc_core::sc_trace_file *tf, const sc_fxnum &object, const std::string &name)
void	sc_trace (sc_core::sc_trace_file *tf, const sc_fxnum *object, const std::string &name)
void	sc_trace (sc_core::sc_trace_file *tf, const sc_fxnum_fast &object, const std::string &name)
void	sc_trace (sc_core::sc_trace_file *tf, const sc_fxnum_fast *object, const std::string &name)
static int	n_word (int x)
void	print_dec (scfx_string &s, const scfx_rep &num, int w_prefix, sc_fmt fmt)
void	print_other (scfx_string &s, const scfx_rep &a, sc_numrep numrep, int w_prefix, sc_fmt fmt, const scfx_params *params)
static int	add_mants (int size, scfx_mant &result, const scfx_mant &a, const scfx_mant &b)
static int	sub_mants (int size, scfx_mant &result, const scfx_mant &a, const scfx_mant &b)
scfx_rep *	add_scfx_rep (const scfx_rep &lhs, const scfx_rep &rhs, int max_wl)
static int	sub_with_index (scfx_mant &a, int a_msw, int a_lsw, const scfx_mant &b, int b_msw, int b_lsw)
scfx_rep *	sub_scfx_rep (const scfx_rep &lhs, const scfx_rep &rhs, int max_wl)
void	multiply (scfx_rep &result, const scfx_rep &lhs, const scfx_rep &rhs, int max_wl)
scfx_rep *	div_scfx_rep (const scfx_rep &lhs, const scfx_rep &rhs, int div_wl)
int	compare_abs (const scfx_rep &a, const scfx_rep &b)
int	cmp_scfx_rep (const scfx_rep &a, const scfx_rep &b)
void	align (const scfx_rep &lhs, const scfx_rep &rhs, int &new_wp, int &len_mant, scfx_mant_ref &lhs_mant, scfx_mant_ref &rhs_mant)
int	compare_msw_ff (const scfx_rep &lhs, const scfx_rep &rhs)
scfx_rep *	neg_scfx_rep (const scfx_rep &)
scfx_rep *	mult_scfx_rep (const scfx_rep &, const scfx_rep &, int)
scfx_rep *	lsh_scfx_rep (const scfx_rep &, int)
scfx_rep *	rsh_scfx_rep (const scfx_rep &, int)
scfx_rep *	quantization_scfx_rep (const scfx_rep &a, const scfx_params &params, bool &q_flag)
scfx_rep *	overflow_scfx_rep (const scfx_rep &a, const scfx_params &params, bool &o_flag)
void	scfx_tc2csd (scfx_string &s, int w_prefix)
void	scfx_csd2tc (scfx_string &csd)
int	scfx_find_msb (unsigned long x)
int	scfx_find_lsb (unsigned long x)
int	scfx_parse_sign (const char *&s, bool &sign_char)
sc_numrep	scfx_parse_prefix (const char *&s)
int	scfx_parse_base (const char *&s)
bool	scfx_is_equal (const char *a, const char *b)
bool	scfx_is_nan (const char *s)
bool	scfx_is_inf (const char *s)
bool	scfx_exp_start (const char *s)
bool	scfx_is_digit (char c, sc_numrep numrep)
int	scfx_to_digit (char c, sc_numrep numrep)
void	scfx_print_nan (scfx_string &s)
void	scfx_print_inf (scfx_string &s, bool negative)
void	scfx_print_prefix (scfx_string &s, sc_numrep numrep)
void	scfx_print_exp (scfx_string &s, int exp)
void	sc_int_concref_invalid_length (int length)
bool	operator== (const sc_int_base &a, const sc_int_base &b)
bool	operator!= (const sc_int_base &a, const sc_int_base &b)
bool	operator< (const sc_int_base &a, const sc_int_base &b)
bool	operator<= (const sc_int_base &a, const sc_int_base &b)
bool	operator> (const sc_int_base &a, const sc_int_base &b)
bool	operator>= (const sc_int_base &a, const sc_int_base &b)
inline::std::ostream &	operator<< (::std::ostream &, const sc_int_bitref_r &)
inline::std::istream &	operator>> (::std::istream &, sc_int_bitref &)
inline::std::ostream &	operator<< (::std::ostream &, const sc_int_subref_r &)
inline::std::istream &	operator>> (::std::istream &, sc_int_subref &)
inline::std::ostream &	operator<< (::std::ostream &, const sc_int_base &)
inline::std::istream &	operator>> (::std::istream &, sc_int_base &)
bool	and_reduce (const sc_int_subref_r &a)
bool	nand_reduce (const sc_int_subref_r &a)
bool	or_reduce (const sc_int_subref_r &a)
bool	nor_reduce (const sc_int_subref_r &a)
bool	xor_reduce (const sc_int_subref_r &a)
bool	xnor_reduce (const sc_int_subref_r &a)
bool	and_reduce (const sc_int_base &a)
bool	nand_reduce (const sc_int_base &a)
bool	or_reduce (const sc_int_base &a)
bool	nor_reduce (const sc_int_base &a)
bool	xor_reduce (const sc_int_base &a)
bool	xnor_reduce (const sc_int_base &a)
bool	operator== (const sc_length_param &, const sc_length_param &)
bool	operator!= (const sc_length_param &, const sc_length_param &)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_length_param &a)
void	add_on_help (small_type &us, int, int und, sc_digit *ud, small_type vs, int, int vnd, const sc_digit *vd)
void	mul_on_help_signed (small_type &us, int unb, int und, sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
void	mul_on_help_unsigned (small_type &us, int unb, int und, sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
void	div_on_help_signed (small_type &us, int unb, int und, sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
void	div_on_help_unsigned (small_type &us, int unb, int und, sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
void	mod_on_help_signed (small_type &us, int unb, int und, sc_digit *ud, int, int vnd, const sc_digit *vd)
void	mod_on_help_unsigned (small_type &us, int unb, int und, sc_digit *ud, int, int vnd, const sc_digit *vd)
void	and_on_help (small_type us, int, int und, sc_digit *ud, small_type vs, int, int vnd, const sc_digit *vd)
void	or_on_help (small_type us, int, int und, sc_digit *ud, small_type vs, int, int vnd, const sc_digit *vd)
void	xor_on_help (small_type us, int, int und, sc_digit *ud, small_type vs, int, int vnd, const sc_digit *vd)
small_type	fsm_move (char c, small_type &b, small_type &s, small_type &state)
const char *	get_base_and_sign (const char *v, small_type &b, small_type &s)
void	parse_binary_bits (const char *src_p, int dst_n, sc_digit *data_p, sc_digit *ctrl_p)
void	parse_hex_bits (const char *src_p, int dst_n, sc_digit *data_p, sc_digit *ctrl_p)
small_type	vec_from_str (int unb, int und, sc_digit *u, const char *v, sc_numrep base)
void	vec_add (int ulen, const sc_digit *u, int vlen, const sc_digit *v, sc_digit *w)
void	vec_add_on (int ulen, sc_digit *ubegin, int vlen, const sc_digit *v)
void	vec_add_on2 (int ulen, sc_digit *ubegin, int, const sc_digit *v)
void	vec_add_small (int ulen, const sc_digit *u, sc_digit v, sc_digit *w)
void	vec_add_small_on (int ulen, sc_digit *u, sc_digit v)
void	vec_sub (int ulen, const sc_digit *u, int vlen, const sc_digit *v, sc_digit *w)
void	vec_sub_on (int ulen, sc_digit *ubegin, int vlen, const sc_digit *v)
void	vec_sub_on2 (int ulen, sc_digit *ubegin, int vlen, const sc_digit *v)
void	vec_sub_small (int ulen, const sc_digit *u, sc_digit v, sc_digit *w)
void	vec_sub_small_on (int ulen, sc_digit *u, sc_digit v)
void	vec_mul (int ulen, const sc_digit *u, int vlen, const sc_digit *vbegin, sc_digit *wbegin)
void	vec_mul_small (int ulen, const sc_digit *u, sc_digit v, sc_digit *w)
void	vec_mul_small_on (int ulen, sc_digit *u, sc_digit v)
void	vec_div_large (int ulen, const sc_digit *u, int vlen, const sc_digit *v, sc_digit *w)
void	vec_div_small (int ulen, const sc_digit *u, sc_digit v, sc_digit *q)
void	vec_rem_large (int ulen, const sc_digit *u, int vlen, const sc_digit *v, sc_digit *w)
sc_digit	vec_rem_small (int ulen, const sc_digit *u, sc_digit v)
sc_digit	vec_rem_on_small (int ulen, sc_digit *u, sc_digit v)
int	vec_to_char (int ulen, const sc_digit *u, int vlen, uchar *v)
void	vec_from_char (int ulen, const uchar *u, int vlen, sc_digit *v)
void	vec_shift_left (int ulen, sc_digit *u, int nsl)
void	vec_shift_right (int ulen, sc_digit *u, int nsr, sc_digit fill)
void	vec_reverse (int unb, int und, sc_digit *ud, int l, int r)
void	is_valid_base (sc_numrep base)
sc_digit	low_half (sc_digit d)
sc_digit	high_half (sc_digit d)
sc_digit	high_half_masked (sc_digit d)
sc_digit	concat (sc_digit h, sc_digit l)
sc_digit	one_and_ones (int n)
sc_digit	one_and_zeros (int n)
int	digit_ord (int i)
int	bit_ord (int i)
int	vec_cmp (int ulen, const sc_digit *u, int vlen, const sc_digit *v)
int	vec_find_first_nonzero (int ulen, const sc_digit *u)
int	vec_skip_leading_zeros (int ulen, const sc_digit *u)
int	vec_skip_and_cmp (int ulen, const sc_digit *u, int vlen, const sc_digit *v)
void	vec_zero (int from, int ulen, sc_digit *u)
void	vec_zero (int ulen, sc_digit *u)
void	vec_copy (int n, sc_digit *u, const sc_digit *v)
void	vec_copy_and_zero (int ulen, sc_digit *u, int vlen, const sc_digit *v)
void	vec_complement (int ulen, sc_digit *u)
template<class Type>
void	from_uint (int ulen, sc_digit *u, Type v)
template<class Type>
small_type	get_sign (Type &u)
small_type	mul_signs (small_type us, small_type vs)
template<class Type>
void	div_by_zero (Type s)
small_type	check_for_zero (small_type s, int ulen, const sc_digit *u)
bool	check_for_zero (int ulen, const sc_digit *u)
small_type	make_zero (int nd, sc_digit *d)
void	trim (small_type added, int nb, int nd, sc_digit *d)
void	convert_SM_to_2C_trimmed (small_type added, small_type s, int nb, int nd, sc_digit *d)
void	convert_SM_to_2C (small_type s, int nd, sc_digit *d)
void	trim_signed (int nb, int nd, sc_digit *d)
small_type	convert_signed_2C_to_SM (int nb, int nd, sc_digit *d)
small_type	convert_signed_SM_to_2C_to_SM (small_type s, int nb, int nd, sc_digit *d)
void	convert_signed_SM_to_2C_trimmed (small_type s, int nb, int nd, sc_digit *d)
void	convert_signed_SM_to_2C (small_type s, int nd, sc_digit *d)
void	trim_unsigned (int nb, int nd, sc_digit *d)
small_type	convert_unsigned_2C_to_SM (int nb, int nd, sc_digit *d)
small_type	convert_unsigned_SM_to_2C_to_SM (small_type s, int nb, int nd, sc_digit *d)
void	convert_unsigned_SM_to_2C_trimmed (small_type s, int nb, int nd, sc_digit *d)
void	convert_unsigned_SM_to_2C (small_type s, int nd, sc_digit *d)
void	copy_digits_signed (small_type &us, int unb, int und, sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
void	copy_digits_unsigned (small_type &us, int unb, int und, sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
void	safe_set (int i, bool v, sc_digit *d)
void	is_bad_double (double v)
sc_signed	operator+ (const sc_unsigned &u, const sc_int_base &v)
sc_signed	operator+ (const sc_int_base &u, const sc_unsigned &v)
sc_signed	operator+ (const sc_signed &u, const sc_int_base &v)
sc_signed	operator+ (const sc_int_base &u, const sc_signed &v)
sc_signed	operator- (const sc_unsigned &u, const sc_int_base &v)
sc_signed	operator- (const sc_int_base &u, const sc_unsigned &v)
sc_signed	operator- (const sc_signed &u, const sc_int_base &v)
sc_signed	operator- (const sc_int_base &u, const sc_signed &v)
sc_signed	operator* (const sc_unsigned &u, const sc_int_base &v)
sc_signed	operator* (const sc_int_base &u, const sc_unsigned &v)
sc_signed	operator* (const sc_signed &u, const sc_int_base &v)
sc_signed	operator* (const sc_int_base &u, const sc_signed &v)
sc_signed	operator/ (const sc_unsigned &u, const sc_int_base &v)
sc_signed	operator/ (const sc_int_base &u, const sc_unsigned &v)
sc_signed	operator/ (const sc_signed &u, const sc_int_base &v)
sc_signed	operator/ (const sc_int_base &u, const sc_signed &v)
sc_signed	operator% (const sc_unsigned &u, const sc_int_base &v)
sc_signed	operator% (const sc_int_base &u, const sc_unsigned &v)
sc_signed	operator% (const sc_signed &u, const sc_int_base &v)
sc_signed	operator% (const sc_int_base &u, const sc_signed &v)
sc_signed	operator & (const sc_unsigned &u, const sc_int_base &v)
sc_signed	operator & (const sc_int_base &u, const sc_unsigned &v)
sc_signed	operator & (const sc_signed &u, const sc_int_base &v)
sc_signed	operator & (const sc_int_base &u, const sc_signed &v)
sc_signed	operator| (const sc_unsigned &u, const sc_int_base &v)
sc_signed	operator| (const sc_int_base &u, const sc_unsigned &v)
sc_signed	operator| (const sc_signed &u, const sc_int_base &v)
sc_signed	operator| (const sc_int_base &u, const sc_signed &v)
sc_signed	operator^ (const sc_unsigned &u, const sc_int_base &v)
sc_signed	operator^ (const sc_int_base &u, const sc_unsigned &v)
sc_signed	operator^ (const sc_signed &u, const sc_int_base &v)
sc_signed	operator^ (const sc_int_base &u, const sc_signed &v)
sc_signed	operator<< (const sc_signed &u, const sc_int_base &v)
sc_signed	operator>> (const sc_signed &u, const sc_int_base &v)
bool	operator== (const sc_signed &u, const sc_int_base &v)
bool	operator== (const sc_int_base &u, const sc_signed &v)
bool	operator!= (const sc_signed &u, const sc_int_base &v)
bool	operator!= (const sc_int_base &u, const sc_signed &v)
bool	operator< (const sc_signed &u, const sc_int_base &v)
bool	operator< (const sc_int_base &u, const sc_signed &v)
bool	operator<= (const sc_signed &u, const sc_int_base &v)
bool	operator<= (const sc_int_base &u, const sc_signed &v)
bool	operator> (const sc_signed &u, const sc_int_base &v)
bool	operator> (const sc_int_base &u, const sc_signed &v)
bool	operator>= (const sc_signed &u, const sc_int_base &v)
bool	operator>= (const sc_int_base &u, const sc_signed &v)
sc_signed	operator+ (const sc_signed &u, const sc_uint_base &v)
sc_signed	operator+ (const sc_uint_base &u, const sc_signed &v)
sc_signed	operator- (const sc_unsigned &u, const sc_uint_base &v)
sc_signed	operator- (const sc_uint_base &u, const sc_unsigned &v)
sc_signed	operator- (const sc_signed &u, const sc_uint_base &v)
sc_signed	operator- (const sc_uint_base &u, const sc_signed &v)
sc_signed	operator* (const sc_signed &u, const sc_uint_base &v)
sc_signed	operator* (const sc_uint_base &u, const sc_signed &v)
sc_signed	operator/ (const sc_signed &u, const sc_uint_base &v)
sc_signed	operator/ (const sc_uint_base &u, const sc_signed &v)
sc_signed	operator% (const sc_signed &u, const sc_uint_base &v)
sc_signed	operator% (const sc_uint_base &u, const sc_signed &v)
sc_signed	operator & (const sc_signed &u, const sc_uint_base &v)
sc_signed	operator & (const sc_uint_base &u, const sc_signed &v)
sc_signed	operator| (const sc_signed &u, const sc_uint_base &v)
sc_signed	operator| (const sc_uint_base &u, const sc_signed &v)
sc_signed	operator^ (const sc_signed &u, const sc_uint_base &v)
sc_signed	operator^ (const sc_uint_base &u, const sc_signed &v)
sc_signed	operator<< (const sc_signed &u, const sc_uint_base &v)
sc_signed	operator>> (const sc_signed &u, const sc_uint_base &v)
bool	operator== (const sc_signed &u, const sc_uint_base &v)
bool	operator== (const sc_uint_base &u, const sc_signed &v)
bool	operator!= (const sc_signed &u, const sc_uint_base &v)
bool	operator!= (const sc_uint_base &u, const sc_signed &v)
bool	operator< (const sc_signed &u, const sc_uint_base &v)
bool	operator< (const sc_uint_base &u, const sc_signed &v)
bool	operator<= (const sc_signed &u, const sc_uint_base &v)
bool	operator<= (const sc_uint_base &u, const sc_signed &v)
bool	operator> (const sc_signed &u, const sc_uint_base &v)
bool	operator> (const sc_uint_base &u, const sc_signed &v)
bool	operator>= (const sc_signed &u, const sc_uint_base &v)
bool	operator>= (const sc_uint_base &u, const sc_signed &v)
sc_signed	operator+ (const sc_unsigned &u, const sc_signed &v)
sc_signed	operator+ (const sc_signed &u, const sc_unsigned &v)
sc_signed	operator+ (const sc_signed &u, const sc_signed &v)
sc_signed	operator+ (const sc_signed &u, int64 v)
sc_signed	operator+ (int64 u, const sc_signed &v)
sc_signed	operator+ (const sc_unsigned &u, int64 v)
sc_signed	operator+ (int64 u, const sc_unsigned &v)
sc_signed	operator+ (const sc_signed &u, uint64 v)
sc_signed	operator+ (uint64 u, const sc_signed &v)
sc_signed	operator+ (const sc_signed &u, long v)
sc_signed	operator+ (long u, const sc_signed &v)
sc_signed	operator+ (const sc_unsigned &u, long v)
sc_signed	operator+ (long u, const sc_unsigned &v)
sc_signed	operator+ (const sc_signed &u, unsigned long v)
sc_signed	operator+ (unsigned long u, const sc_signed &v)
sc_signed	operator- (const sc_unsigned &u, const sc_unsigned &v)
sc_signed	operator- (const sc_unsigned &u, const sc_signed &v)
sc_signed	operator- (const sc_signed &u, const sc_unsigned &v)
sc_signed	operator- (const sc_signed &u, const sc_signed &v)
sc_signed	operator- (const sc_signed &u, int64 v)
sc_signed	operator- (int64 u, const sc_signed &v)
sc_signed	operator- (const sc_unsigned &u, int64 v)
sc_signed	operator- (int64 u, const sc_unsigned &v)
sc_signed	operator- (const sc_signed &u, uint64 v)
sc_signed	operator- (uint64 u, const sc_signed &v)
sc_signed	operator- (const sc_unsigned &u, uint64 v)
sc_signed	operator- (uint64 u, const sc_unsigned &v)
sc_signed	operator- (const sc_signed &u, long v)
sc_signed	operator- (long u, const sc_signed &v)
sc_signed	operator- (const sc_unsigned &u, long v)
sc_signed	operator- (long u, const sc_unsigned &v)
sc_signed	operator- (const sc_signed &u, unsigned long v)
sc_signed	operator- (unsigned long u, const sc_signed &v)
sc_signed	operator- (const sc_unsigned &u, unsigned long v)
sc_signed	operator- (unsigned long u, const sc_unsigned &v)
sc_signed	operator* (const sc_unsigned &u, const sc_signed &v)
sc_signed	operator* (const sc_signed &u, const sc_unsigned &v)
sc_signed	operator* (const sc_signed &u, const sc_signed &v)
sc_signed	operator* (const sc_signed &u, int64 v)
sc_signed	operator* (int64 u, const sc_signed &v)
sc_signed	operator* (const sc_unsigned &u, int64 v)
sc_signed	operator* (int64 u, const sc_unsigned &v)
sc_signed	operator* (const sc_signed &u, uint64 v)
sc_signed	operator* (uint64 u, const sc_signed &v)
sc_signed	operator* (const sc_signed &u, long v)
sc_signed	operator* (long u, const sc_signed &v)
sc_signed	operator* (const sc_unsigned &u, long v)
sc_signed	operator* (long u, const sc_unsigned &v)
sc_signed	operator* (const sc_signed &u, unsigned long v)
sc_signed	operator* (unsigned long u, const sc_signed &v)
sc_signed	operator/ (const sc_unsigned &u, const sc_signed &v)
sc_signed	operator/ (const sc_signed &u, const sc_unsigned &v)
sc_signed	operator/ (const sc_signed &u, const sc_signed &v)
sc_signed	operator/ (const sc_signed &u, int64 v)
sc_signed	operator/ (int64 u, const sc_signed &v)
sc_signed	operator/ (const sc_unsigned &u, int64 v)
sc_signed	operator/ (int64 u, const sc_unsigned &v)
sc_signed	operator/ (const sc_signed &u, uint64 v)
sc_signed	operator/ (uint64 u, const sc_signed &v)
sc_signed	operator/ (const sc_signed &u, long v)
sc_signed	operator/ (long u, const sc_signed &v)
sc_signed	operator/ (const sc_unsigned &u, long v)
sc_signed	operator/ (long u, const sc_unsigned &v)
sc_signed	operator/ (const sc_signed &u, unsigned long v)
sc_signed	operator/ (unsigned long u, const sc_signed &v)
sc_signed	operator% (const sc_unsigned &u, const sc_signed &v)
sc_signed	operator% (const sc_signed &u, const sc_unsigned &v)
sc_signed	operator% (const sc_signed &u, const sc_signed &v)
sc_signed	operator% (const sc_signed &u, int64 v)
sc_signed	operator% (int64 u, const sc_signed &v)
sc_signed	operator% (const sc_unsigned &u, int64 v)
sc_signed	operator% (int64 u, const sc_unsigned &v)
sc_signed	operator% (const sc_signed &u, uint64 v)
sc_signed	operator% (uint64 u, const sc_signed &v)
sc_signed	operator% (const sc_signed &u, long v)
sc_signed	operator% (long u, const sc_signed &v)
sc_signed	operator% (const sc_unsigned &u, long v)
sc_signed	operator% (long u, const sc_unsigned &v)
sc_signed	operator% (const sc_signed &u, unsigned long v)
sc_signed	operator% (unsigned long u, const sc_signed &v)
sc_signed	operator & (const sc_unsigned &u, const sc_signed &v)
sc_signed	operator & (const sc_signed &u, const sc_unsigned &v)
sc_signed	operator & (const sc_signed &u, const sc_signed &v)
sc_signed	operator & (const sc_signed &u, int64 v)
sc_signed	operator & (int64 u, const sc_signed &v)
sc_signed	operator & (const sc_unsigned &u, int64 v)
sc_signed	operator & (int64 u, const sc_unsigned &v)
sc_signed	operator & (const sc_signed &u, uint64 v)
sc_signed	operator & (uint64 u, const sc_signed &v)
sc_signed	operator & (const sc_signed &u, long v)
sc_signed	operator & (long u, const sc_signed &v)
sc_signed	operator & (const sc_unsigned &u, long v)
sc_signed	operator & (long u, const sc_unsigned &v)
sc_signed	operator & (const sc_signed &u, unsigned long v)
sc_signed	operator & (unsigned long u, const sc_signed &v)
sc_signed	operator| (const sc_unsigned &u, const sc_signed &v)
sc_signed	operator| (const sc_signed &u, const sc_unsigned &v)
sc_signed	operator| (const sc_signed &u, const sc_signed &v)
sc_signed	operator| (const sc_signed &u, int64 v)
sc_signed	operator| (int64 u, const sc_signed &v)
sc_signed	operator| (const sc_unsigned &u, int64 v)
sc_signed	operator| (int64 u, const sc_unsigned &v)
sc_signed	operator| (const sc_signed &u, uint64 v)
sc_signed	operator| (uint64 u, const sc_signed &v)
sc_signed	operator| (const sc_signed &u, long v)
sc_signed	operator| (long u, const sc_signed &v)
sc_signed	operator| (const sc_unsigned &u, long v)
sc_signed	operator| (long u, const sc_unsigned &v)
sc_signed	operator| (const sc_signed &u, unsigned long v)
sc_signed	operator| (unsigned long u, const sc_signed &v)
sc_signed	operator^ (const sc_unsigned &u, const sc_signed &v)
sc_signed	operator^ (const sc_signed &u, const sc_unsigned &v)
sc_signed	operator^ (const sc_signed &u, const sc_signed &v)
sc_signed	operator^ (const sc_signed &u, int64 v)
sc_signed	operator^ (int64 u, const sc_signed &v)
sc_signed	operator^ (const sc_unsigned &u, int64 v)
sc_signed	operator^ (int64 u, const sc_unsigned &v)
sc_signed	operator^ (const sc_signed &u, uint64 v)
sc_signed	operator^ (uint64 u, const sc_signed &v)
sc_signed	operator^ (const sc_signed &u, long v)
sc_signed	operator^ (long u, const sc_signed &v)
sc_signed	operator^ (const sc_unsigned &u, long v)
sc_signed	operator^ (long u, const sc_unsigned &v)
sc_signed	operator^ (const sc_signed &u, unsigned long v)
sc_signed	operator^ (unsigned long u, const sc_signed &v)
sc_signed	operator<< (const sc_signed &u, const sc_unsigned &v)
sc_signed	operator>> (const sc_signed &u, const sc_unsigned &v)
sc_signed	operator+ (const sc_signed &u)
sc_signed	operator- (const sc_signed &u)
sc_signed	operator- (const sc_unsigned &u)
bool	operator== (const sc_signed &u, const sc_signed &v)
bool	operator== (const sc_signed &u, int64 v)
bool	operator== (int64 u, const sc_signed &v)
bool	operator== (const sc_signed &u, uint64 v)
bool	operator== (uint64 u, const sc_signed &v)
bool	operator== (const sc_signed &u, long v)
bool	operator== (long u, const sc_signed &v)
bool	operator== (const sc_signed &u, unsigned long v)
bool	operator== (unsigned long u, const sc_signed &v)
bool	operator< (const sc_signed &u, const sc_signed &v)
bool	operator< (const sc_signed &u, int64 v)
bool	operator< (int64 u, const sc_signed &v)
bool	operator< (const sc_signed &u, uint64 v)
bool	operator< (uint64 u, const sc_signed &v)
bool	operator< (const sc_signed &u, long v)
bool	operator< (long u, const sc_signed &v)
bool	operator< (const sc_signed &u, unsigned long v)
bool	operator< (unsigned long u, const sc_signed &v)
CLASS_TYPE	ADD_HELPER (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
CLASS_TYPE	MUL_HELPER (small_type s, int unb, int und, const sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
CLASS_TYPE	DIV_HELPER (small_type s, int unb, int und, const sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
CLASS_TYPE	MOD_HELPER (small_type us, int unb, int und, const sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
CLASS_TYPE	AND_HELPER (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
CLASS_TYPE	OR_HELPER (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
CLASS_TYPE	XOR_HELPER (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
CLASS_TYPE	operator~ (const CLASS_TYPE &u)
CLASS_TYPE	operator<< (const CLASS_TYPE &u, const CLASS_TYPE &v)
CLASS_TYPE	operator<< (const CLASS_TYPE &u, int64 v)
CLASS_TYPE	operator<< (const CLASS_TYPE &u, uint64 v)
CLASS_TYPE	operator<< (const CLASS_TYPE &u, long v)
CLASS_TYPE	operator<< (const CLASS_TYPE &u, unsigned long v)
CLASS_TYPE	operator>> (const CLASS_TYPE &u, const CLASS_TYPE &v)
CLASS_TYPE	operator>> (const CLASS_TYPE &u, int64 v)
CLASS_TYPE	operator>> (const CLASS_TYPE &u, uint64 v)
CLASS_TYPE	operator>> (const CLASS_TYPE &u, long v)
CLASS_TYPE	operator>> (const CLASS_TYPE &u, unsigned long v)
bool	operator!= (const CLASS_TYPE &u, const CLASS_TYPE &v)
bool	operator!= (const CLASS_TYPE &u, int64 v)
bool	operator!= (int64 u, const CLASS_TYPE &v)
bool	operator!= (const CLASS_TYPE &u, uint64 v)
bool	operator!= (uint64 u, const CLASS_TYPE &v)
bool	operator!= (const CLASS_TYPE &u, long v)
bool	operator!= (long u, const CLASS_TYPE &v)
bool	operator!= (const CLASS_TYPE &u, unsigned long v)
bool	operator!= (unsigned long u, const CLASS_TYPE &v)
bool	operator<= (const CLASS_TYPE &u, const CLASS_TYPE &v)
bool	operator<= (const CLASS_TYPE &u, int64 v)
bool	operator<= (int64 u, const CLASS_TYPE &v)
bool	operator<= (const CLASS_TYPE &u, uint64 v)
bool	operator<= (uint64 u, const CLASS_TYPE &v)
bool	operator<= (const CLASS_TYPE &u, long v)
bool	operator<= (long u, const CLASS_TYPE &v)
bool	operator<= (const CLASS_TYPE &u, unsigned long v)
bool	operator<= (unsigned long u, const CLASS_TYPE &v)
bool	operator> (const CLASS_TYPE &u, const CLASS_TYPE &v)
bool	operator> (const CLASS_TYPE &u, int64 v)
bool	operator> (int64 u, const CLASS_TYPE &v)
bool	operator> (const CLASS_TYPE &u, uint64 v)
bool	operator> (uint64 u, const CLASS_TYPE &v)
bool	operator> (const CLASS_TYPE &u, long v)
bool	operator> (long u, const CLASS_TYPE &v)
bool	operator> (const CLASS_TYPE &u, unsigned long v)
bool	operator> (unsigned long u, const CLASS_TYPE &v)
bool	operator>= (const CLASS_TYPE &u, const CLASS_TYPE &v)
bool	operator>= (const CLASS_TYPE &u, int64 v)
bool	operator>= (int64 u, const CLASS_TYPE &v)
bool	operator>= (const CLASS_TYPE &u, uint64 v)
bool	operator>= (uint64 u, const CLASS_TYPE &v)
bool	operator>= (const CLASS_TYPE &u, long v)
bool	operator>= (long u, const CLASS_TYPE &v)
bool	operator>= (const CLASS_TYPE &u, unsigned long v)
bool	operator>= (unsigned long u, const CLASS_TYPE &v)
sc_signed	add_signed_friend (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
sc_signed	sub_signed_friend (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
sc_signed	mul_signed_friend (small_type s, int unb, int und, const sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
sc_signed	div_signed_friend (small_type s, int unb, int und, const sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
sc_signed	mod_signed_friend (small_type us, int unb, int und, const sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
sc_signed	and_signed_friend (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
sc_signed	or_signed_friend (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
sc_signed	xor_signed_friend (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
sc_signed	operator+ (const sc_unsigned &u, int v)
sc_signed	operator+ (int u, const sc_unsigned &v)
sc_signed	operator+ (const sc_signed &u, int v)
sc_signed	operator+ (const sc_signed &u, unsigned int v)
sc_signed	operator+ (int u, const sc_signed &v)
sc_signed	operator+ (unsigned int u, const sc_signed &v)
sc_signed	operator- (const sc_unsigned &u, int v)
sc_signed	operator- (const sc_unsigned &u, unsigned int v)
sc_signed	operator- (int u, const sc_unsigned &v)
sc_signed	operator- (unsigned int u, const sc_unsigned &v)
sc_signed	operator- (const sc_signed &u, int v)
sc_signed	operator- (const sc_signed &u, unsigned int v)
sc_signed	operator- (int u, const sc_signed &v)
sc_signed	operator- (unsigned int u, const sc_signed &v)
sc_signed	operator* (const sc_unsigned &u, int v)
sc_signed	operator* (int u, const sc_unsigned &v)
sc_signed	operator* (const sc_signed &u, int v)
sc_signed	operator* (const sc_signed &u, unsigned int v)
sc_signed	operator* (int u, const sc_signed &v)
sc_signed	operator* (unsigned int u, const sc_signed &v)
sc_signed	operator/ (const sc_unsigned &u, int v)
sc_signed	operator/ (int u, const sc_unsigned &v)
sc_signed	operator/ (const sc_signed &u, int v)
sc_signed	operator/ (const sc_signed &u, unsigned int v)
sc_signed	operator/ (int u, const sc_signed &v)
sc_signed	operator/ (unsigned int u, const sc_signed &v)
sc_signed	operator% (const sc_unsigned &u, int v)
sc_signed	operator% (int u, const sc_unsigned &v)
sc_signed	operator% (const sc_signed &u, int v)
sc_signed	operator% (const sc_signed &u, unsigned int v)
sc_signed	operator% (int u, const sc_signed &v)
sc_signed	operator% (unsigned int u, const sc_signed &v)
sc_signed	operator & (const sc_unsigned &u, int v)
sc_signed	operator & (int u, const sc_unsigned &v)
sc_signed	operator & (const sc_signed &u, int v)
sc_signed	operator & (const sc_signed &u, unsigned int v)
sc_signed	operator & (int u, const sc_signed &v)
sc_signed	operator & (unsigned int u, const sc_signed &v)
sc_signed	operator| (const sc_unsigned &u, int v)
sc_signed	operator| (int u, const sc_unsigned &v)
sc_signed	operator| (const sc_signed &u, int v)
sc_signed	operator| (const sc_signed &u, unsigned int v)
sc_signed	operator| (int u, const sc_signed &v)
sc_signed	operator| (unsigned int u, const sc_signed &v)
sc_signed	operator^ (const sc_unsigned &u, int v)
sc_signed	operator^ (int u, const sc_unsigned &v)
sc_signed	operator^ (const sc_signed &u, int v)
sc_signed	operator^ (const sc_signed &u, unsigned int v)
sc_signed	operator^ (int u, const sc_signed &v)
sc_signed	operator^ (unsigned int u, const sc_signed &v)
sc_unsigned	operator<< (const sc_unsigned &u, const sc_signed &v)
sc_signed	operator<< (const sc_signed &u, const sc_signed &v)
sc_signed	operator<< (const sc_signed &u, int64 v)
sc_signed	operator<< (const sc_signed &u, uint64 v)
sc_signed	operator<< (const sc_signed &u, long v)
sc_signed	operator<< (const sc_signed &u, unsigned long v)
sc_signed	operator<< (const sc_signed &u, int v)
sc_signed	operator<< (const sc_signed &u, unsigned int v)
sc_unsigned	operator>> (const sc_unsigned &u, const sc_signed &v)
sc_signed	operator>> (const sc_signed &u, const sc_signed &v)
sc_signed	operator>> (const sc_signed &u, int64 v)
sc_signed	operator>> (const sc_signed &u, uint64 v)
sc_signed	operator>> (const sc_signed &u, long v)
sc_signed	operator>> (const sc_signed &u, unsigned long v)
sc_signed	operator>> (const sc_signed &u, int v)
sc_signed	operator>> (const sc_signed &u, unsigned int v)
bool	operator== (const sc_unsigned &u, const sc_signed &v)
bool	operator== (const sc_signed &u, const sc_unsigned &v)
bool	operator== (const sc_signed &u, int v)
bool	operator== (const sc_signed &u, unsigned int v)
bool	operator== (int u, const sc_signed &v)
bool	operator== (unsigned int u, const sc_signed &v)
bool	operator!= (const sc_unsigned &u, const sc_signed &v)
bool	operator!= (const sc_signed &u, const sc_unsigned &v)
bool	operator!= (const sc_signed &u, const sc_signed &v)
bool	operator!= (const sc_signed &u, int64 v)
bool	operator!= (const sc_signed &u, uint64 v)
bool	operator!= (const sc_signed &u, long v)
bool	operator!= (const sc_signed &u, unsigned long v)
bool	operator!= (const sc_signed &u, int v)
bool	operator!= (const sc_signed &u, unsigned int v)
bool	operator!= (int64 u, const sc_signed &v)
bool	operator!= (uint64 u, const sc_signed &v)
bool	operator!= (long u, const sc_signed &v)
bool	operator!= (unsigned long u, const sc_signed &v)
bool	operator!= (int u, const sc_signed &v)
bool	operator!= (unsigned int u, const sc_signed &v)
bool	operator< (const sc_unsigned &u, const sc_signed &v)
bool	operator< (const sc_signed &u, const sc_unsigned &v)
bool	operator< (const sc_signed &u, int v)
bool	operator< (const sc_signed &u, unsigned int v)
bool	operator< (int u, const sc_signed &v)
bool	operator< (unsigned int u, const sc_signed &v)
bool	operator<= (const sc_unsigned &u, const sc_signed &v)
bool	operator<= (const sc_signed &u, const sc_unsigned &v)
bool	operator<= (const sc_signed &u, const sc_signed &v)
bool	operator<= (const sc_signed &u, int64 v)
bool	operator<= (const sc_signed &u, uint64 v)
bool	operator<= (const sc_signed &u, long v)
bool	operator<= (const sc_signed &u, unsigned long v)
bool	operator<= (const sc_signed &u, int v)
bool	operator<= (const sc_signed &u, unsigned int v)
bool	operator<= (int64 u, const sc_signed &v)
bool	operator<= (uint64 u, const sc_signed &v)
bool	operator<= (long u, const sc_signed &v)
bool	operator<= (unsigned long u, const sc_signed &v)
bool	operator<= (int u, const sc_signed &v)
bool	operator<= (unsigned int u, const sc_signed &v)
bool	operator> (const sc_unsigned &u, const sc_signed &v)
bool	operator> (const sc_signed &u, const sc_unsigned &v)
bool	operator> (const sc_signed &u, const sc_signed &v)
bool	operator> (const sc_signed &u, int64 v)
bool	operator> (const sc_signed &u, uint64 v)
bool	operator> (const sc_signed &u, long v)
bool	operator> (const sc_signed &u, unsigned long v)
bool	operator> (const sc_signed &u, int v)
bool	operator> (const sc_signed &u, unsigned int v)
bool	operator> (int64 u, const sc_signed &v)
bool	operator> (uint64 u, const sc_signed &v)
bool	operator> (long u, const sc_signed &v)
bool	operator> (unsigned long u, const sc_signed &v)
bool	operator> (int u, const sc_signed &v)
bool	operator> (unsigned int u, const sc_signed &v)
bool	operator>= (const sc_unsigned &u, const sc_signed &v)
bool	operator>= (const sc_signed &u, const sc_unsigned &v)
bool	operator>= (const sc_signed &u, const sc_signed &v)
bool	operator>= (const sc_signed &u, int64 v)
bool	operator>= (const sc_signed &u, uint64 v)
bool	operator>= (const sc_signed &u, long v)
bool	operator>= (const sc_signed &u, unsigned long v)
bool	operator>= (const sc_signed &u, int v)
bool	operator>= (const sc_signed &u, unsigned int v)
bool	operator>= (int64 u, const sc_signed &v)
bool	operator>= (uint64 u, const sc_signed &v)
bool	operator>= (long u, const sc_signed &v)
bool	operator>= (unsigned long u, const sc_signed &v)
bool	operator>= (int u, const sc_signed &v)
bool	operator>= (unsigned int u, const sc_signed &v)
sc_signed	operator~ (const sc_signed &u)
inline::std::ostream &	operator<< (::std::ostream &, const sc_signed_bitref_r &)
inline::std::istream &	operator>> (::std::istream &, sc_signed_bitref &)
inline::std::ostream &	operator<< (::std::ostream &, const sc_signed_subref_r &)
inline::std::istream &	operator>> (::std::istream &, sc_signed_subref &)
inline::std::ostream &	operator<< (::std::ostream &, const sc_signed &)
inline::std::istream &	operator>> (::std::istream &, sc_signed &)
void	sc_uint_concref_invalid_length (int length)
bool	operator== (const sc_uint_base &a, const sc_uint_base &b)
bool	operator!= (const sc_uint_base &a, const sc_uint_base &b)
bool	operator< (const sc_uint_base &a, const sc_uint_base &b)
bool	operator<= (const sc_uint_base &a, const sc_uint_base &b)
bool	operator> (const sc_uint_base &a, const sc_uint_base &b)
bool	operator>= (const sc_uint_base &a, const sc_uint_base &b)
inline::std::ostream &	operator<< (::std::ostream &, const sc_uint_bitref_r &)
inline::std::istream &	operator>> (::std::istream &, sc_uint_bitref &)
inline::std::ostream &	operator<< (::std::ostream &, const sc_uint_subref_r &)
inline::std::istream &	operator>> (::std::istream &, sc_uint_subref &)
inline::std::ostream &	operator<< (::std::ostream &, const sc_uint_base &)
inline::std::istream &	operator>> (::std::istream &, sc_uint_base &)
bool	and_reduce (const sc_uint_subref_r &a)
bool	nand_reduce (const sc_uint_subref_r &a)
bool	or_reduce (const sc_uint_subref_r &a)
bool	nor_reduce (const sc_uint_subref_r &a)
bool	xor_reduce (const sc_uint_subref_r &a)
bool	xnor_reduce (const sc_uint_subref_r &a)
bool	and_reduce (const sc_uint_base &a)
bool	nand_reduce (const sc_uint_base &a)
bool	or_reduce (const sc_uint_base &a)
bool	nor_reduce (const sc_uint_base &a)
bool	xor_reduce (const sc_uint_base &a)
bool	xnor_reduce (const sc_uint_base &a)
sc_unsigned	operator<< (const sc_unsigned &u, const sc_int_base &v)
sc_unsigned	operator>> (const sc_unsigned &u, const sc_int_base &v)
bool	operator== (const sc_unsigned &u, const sc_int_base &v)
bool	operator== (const sc_int_base &u, const sc_unsigned &v)
bool	operator!= (const sc_unsigned &u, const sc_int_base &v)
bool	operator!= (const sc_int_base &u, const sc_unsigned &v)
bool	operator< (const sc_unsigned &u, const sc_int_base &v)
bool	operator< (const sc_int_base &u, const sc_unsigned &v)
bool	operator<= (const sc_unsigned &u, const sc_int_base &v)
bool	operator<= (const sc_int_base &u, const sc_unsigned &v)
bool	operator> (const sc_unsigned &u, const sc_int_base &v)
bool	operator> (const sc_int_base &u, const sc_unsigned &v)
bool	operator>= (const sc_unsigned &u, const sc_int_base &v)
bool	operator>= (const sc_int_base &u, const sc_unsigned &v)
sc_unsigned	operator+ (const sc_unsigned &u, const sc_uint_base &v)
sc_unsigned	operator+ (const sc_uint_base &u, const sc_unsigned &v)
sc_unsigned	operator* (const sc_unsigned &u, const sc_uint_base &v)
sc_unsigned	operator* (const sc_uint_base &u, const sc_unsigned &v)
sc_unsigned	operator/ (const sc_unsigned &u, const sc_uint_base &v)
sc_unsigned	operator/ (const sc_uint_base &u, const sc_unsigned &v)
sc_unsigned	operator% (const sc_unsigned &u, const sc_uint_base &v)
sc_unsigned	operator% (const sc_uint_base &u, const sc_unsigned &v)
sc_unsigned	operator & (const sc_unsigned &u, const sc_uint_base &v)
sc_unsigned	operator & (const sc_uint_base &u, const sc_unsigned &v)
sc_unsigned	operator| (const sc_unsigned &u, const sc_uint_base &v)
sc_unsigned	operator| (const sc_uint_base &u, const sc_unsigned &v)
sc_unsigned	operator^ (const sc_unsigned &u, const sc_uint_base &v)
sc_unsigned	operator^ (const sc_uint_base &u, const sc_unsigned &v)
sc_unsigned	operator<< (const sc_unsigned &u, const sc_uint_base &v)
sc_unsigned	operator>> (const sc_unsigned &u, const sc_uint_base &v)
bool	operator== (const sc_unsigned &u, const sc_uint_base &v)
bool	operator== (const sc_uint_base &u, const sc_unsigned &v)
bool	operator!= (const sc_unsigned &u, const sc_uint_base &v)
bool	operator!= (const sc_uint_base &u, const sc_unsigned &v)
bool	operator< (const sc_unsigned &u, const sc_uint_base &v)
bool	operator< (const sc_uint_base &u, const sc_unsigned &v)
bool	operator<= (const sc_unsigned &u, const sc_uint_base &v)
bool	operator<= (const sc_uint_base &u, const sc_unsigned &v)
bool	operator> (const sc_unsigned &u, const sc_uint_base &v)
bool	operator> (const sc_uint_base &u, const sc_unsigned &v)
bool	operator>= (const sc_unsigned &u, const sc_uint_base &v)
bool	operator>= (const sc_uint_base &u, const sc_unsigned &v)
sc_unsigned	operator+ (const sc_unsigned &u, const sc_unsigned &v)
sc_unsigned	operator+ (const sc_unsigned &u, uint64 v)
sc_unsigned	operator+ (uint64 u, const sc_unsigned &v)
sc_unsigned	operator+ (const sc_unsigned &u, unsigned long v)
sc_unsigned	operator+ (unsigned long u, const sc_unsigned &v)
sc_unsigned	operator* (const sc_unsigned &u, const sc_unsigned &v)
sc_unsigned	operator* (const sc_unsigned &u, uint64 v)
sc_unsigned	operator* (uint64 u, const sc_unsigned &v)
sc_unsigned	operator* (const sc_unsigned &u, unsigned long v)
sc_unsigned	operator* (unsigned long u, const sc_unsigned &v)
sc_unsigned	operator/ (const sc_unsigned &u, const sc_unsigned &v)
sc_unsigned	operator/ (const sc_unsigned &u, uint64 v)
sc_unsigned	operator/ (uint64 u, const sc_unsigned &v)
sc_unsigned	operator/ (const sc_unsigned &u, unsigned long v)
sc_unsigned	operator/ (unsigned long u, const sc_unsigned &v)
sc_unsigned	operator% (const sc_unsigned &u, const sc_unsigned &v)
sc_unsigned	operator% (const sc_unsigned &u, uint64 v)
sc_unsigned	operator% (uint64 u, const sc_unsigned &v)
sc_unsigned	operator% (const sc_unsigned &u, unsigned long v)
sc_unsigned	operator% (unsigned long u, const sc_unsigned &v)
sc_unsigned	operator & (const sc_unsigned &u, const sc_unsigned &v)
sc_unsigned	operator & (const sc_unsigned &u, uint64 v)
sc_unsigned	operator & (uint64 u, const sc_unsigned &v)
sc_unsigned	operator & (const sc_unsigned &u, unsigned long v)
sc_unsigned	operator & (unsigned long u, const sc_unsigned &v)
sc_unsigned	operator| (const sc_unsigned &u, const sc_unsigned &v)
sc_unsigned	operator| (const sc_unsigned &u, uint64 v)
sc_unsigned	operator| (uint64 u, const sc_unsigned &v)
sc_unsigned	operator| (const sc_unsigned &u, unsigned long v)
sc_unsigned	operator| (unsigned long u, const sc_unsigned &v)
sc_unsigned	operator^ (const sc_unsigned &u, const sc_unsigned &v)
sc_unsigned	operator^ (const sc_unsigned &u, uint64 v)
sc_unsigned	operator^ (uint64 u, const sc_unsigned &v)
sc_unsigned	operator^ (const sc_unsigned &u, unsigned long v)
sc_unsigned	operator^ (unsigned long u, const sc_unsigned &v)
sc_unsigned	operator+ (const sc_unsigned &u)
bool	operator== (const sc_unsigned &u, const sc_unsigned &v)
bool	operator== (const sc_unsigned &u, int64 v)
bool	operator== (int64 u, const sc_unsigned &v)
bool	operator== (const sc_unsigned &u, uint64 v)
bool	operator== (uint64 u, const sc_unsigned &v)
bool	operator== (const sc_unsigned &u, long v)
bool	operator== (long u, const sc_unsigned &v)
bool	operator== (const sc_unsigned &u, unsigned long v)
bool	operator== (unsigned long u, const sc_unsigned &v)
bool	operator< (const sc_unsigned &u, const sc_unsigned &v)
bool	operator< (const sc_unsigned &u, int64 v)
bool	operator< (int64 u, const sc_unsigned &v)
bool	operator< (const sc_unsigned &u, uint64 v)
bool	operator< (uint64 u, const sc_unsigned &v)
bool	operator< (const sc_unsigned &u, long v)
bool	operator< (long u, const sc_unsigned &v)
bool	operator< (const sc_unsigned &u, unsigned long v)
bool	operator< (unsigned long u, const sc_unsigned &v)
int	compare_unsigned (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd, small_type if_u_signed, small_type if_v_signed)
sc_unsigned	add_unsigned_friend (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
sc_unsigned	sub_unsigned_friend (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
sc_unsigned	mul_unsigned_friend (small_type s, int unb, int und, const sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
sc_unsigned	div_unsigned_friend (small_type s, int unb, int und, const sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
sc_unsigned	mod_unsigned_friend (small_type us, int unb, int und, const sc_digit *ud, int vnb, int vnd, const sc_digit *vd)
sc_unsigned	and_unsigned_friend (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
sc_unsigned	or_unsigned_friend (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
sc_unsigned	xor_unsigned_friend (small_type us, int unb, int und, const sc_digit *ud, small_type vs, int vnb, int vnd, const sc_digit *vd)
sc_unsigned	operator+ (const sc_unsigned &u, unsigned int v)
sc_unsigned	operator+ (unsigned int u, const sc_unsigned &v)
sc_unsigned	operator* (const sc_unsigned &u, unsigned int v)
sc_unsigned	operator* (unsigned int u, const sc_unsigned &v)
sc_unsigned	operator/ (const sc_unsigned &u, unsigned int v)
sc_unsigned	operator/ (unsigned int u, const sc_unsigned &v)
sc_unsigned	operator% (const sc_unsigned &u, unsigned int v)
sc_unsigned	operator% (unsigned int u, const sc_unsigned &v)
sc_unsigned	operator & (const sc_unsigned &u, unsigned int v)
sc_unsigned	operator & (unsigned int u, const sc_unsigned &v)
sc_unsigned	operator| (const sc_unsigned &u, unsigned int v)
sc_unsigned	operator| (unsigned int u, const sc_unsigned &v)
sc_unsigned	operator^ (const sc_unsigned &u, unsigned int v)
sc_unsigned	operator^ (unsigned int u, const sc_unsigned &v)
sc_unsigned	operator<< (const sc_unsigned &u, const sc_unsigned &v)
sc_unsigned	operator<< (const sc_unsigned &u, int64 v)
sc_unsigned	operator<< (const sc_unsigned &u, uint64 v)
sc_unsigned	operator<< (const sc_unsigned &u, long v)
sc_unsigned	operator<< (const sc_unsigned &u, unsigned long v)
sc_unsigned	operator<< (const sc_unsigned &u, int v)
sc_unsigned	operator<< (const sc_unsigned &u, unsigned int v)
sc_unsigned	operator>> (const sc_unsigned &u, const sc_unsigned &v)
sc_unsigned	operator>> (const sc_unsigned &u, int64 v)
sc_unsigned	operator>> (const sc_unsigned &u, uint64 v)
sc_unsigned	operator>> (const sc_unsigned &u, long v)
sc_unsigned	operator>> (const sc_unsigned &u, unsigned long v)
sc_unsigned	operator>> (const sc_unsigned &u, int v)
sc_unsigned	operator>> (const sc_unsigned &u, unsigned int v)
bool	operator== (const sc_unsigned &u, int v)
bool	operator== (const sc_unsigned &u, unsigned int v)
bool	operator== (int u, const sc_unsigned &v)
bool	operator== (unsigned int u, const sc_unsigned &v)
bool	operator!= (const sc_unsigned &u, const sc_unsigned &v)
bool	operator!= (const sc_unsigned &u, int64 v)
bool	operator!= (const sc_unsigned &u, uint64 v)
bool	operator!= (const sc_unsigned &u, long v)
bool	operator!= (const sc_unsigned &u, unsigned long v)
bool	operator!= (const sc_unsigned &u, int v)
bool	operator!= (const sc_unsigned &u, unsigned int v)
bool	operator!= (int64 u, const sc_unsigned &v)
bool	operator!= (uint64 u, const sc_unsigned &v)
bool	operator!= (long u, const sc_unsigned &v)
bool	operator!= (unsigned long u, const sc_unsigned &v)
bool	operator!= (int u, const sc_unsigned &v)
bool	operator!= (unsigned int u, const sc_unsigned &v)
bool	operator< (const sc_unsigned &u, int v)
bool	operator< (const sc_unsigned &u, unsigned int v)
bool	operator< (int u, const sc_unsigned &v)
bool	operator< (unsigned int u, const sc_unsigned &v)
bool	operator<= (const sc_unsigned &u, const sc_unsigned &v)
bool	operator<= (const sc_unsigned &u, int64 v)
bool	operator<= (const sc_unsigned &u, uint64 v)
bool	operator<= (const sc_unsigned &u, long v)
bool	operator<= (const sc_unsigned &u, unsigned long v)
bool	operator<= (const sc_unsigned &u, int v)
bool	operator<= (const sc_unsigned &u, unsigned int v)
bool	operator<= (int64 u, const sc_unsigned &v)
bool	operator<= (uint64 u, const sc_unsigned &v)
bool	operator<= (long u, const sc_unsigned &v)
bool	operator<= (unsigned long u, const sc_unsigned &v)
bool	operator<= (int u, const sc_unsigned &v)
bool	operator<= (unsigned int u, const sc_unsigned &v)
bool	operator> (const sc_unsigned &u, const sc_unsigned &v)
bool	operator> (const sc_unsigned &u, int64 v)
bool	operator> (const sc_unsigned &u, uint64 v)
bool	operator> (const sc_unsigned &u, long v)
bool	operator> (const sc_unsigned &u, unsigned long v)
bool	operator> (const sc_unsigned &u, int v)
bool	operator> (const sc_unsigned &u, unsigned int v)
bool	operator> (int64 u, const sc_unsigned &v)
bool	operator> (uint64 u, const sc_unsigned &v)
bool	operator> (long u, const sc_unsigned &v)
bool	operator> (unsigned long u, const sc_unsigned &v)
bool	operator> (int u, const sc_unsigned &v)
bool	operator> (unsigned int u, const sc_unsigned &v)
bool	operator>= (const sc_unsigned &u, const sc_unsigned &v)
bool	operator>= (const sc_unsigned &u, int64 v)
bool	operator>= (const sc_unsigned &u, uint64 v)
bool	operator>= (const sc_unsigned &u, long v)
bool	operator>= (const sc_unsigned &u, unsigned long v)
bool	operator>= (const sc_unsigned &u, int v)
bool	operator>= (const sc_unsigned &u, unsigned int v)
bool	operator>= (int64 u, const sc_unsigned &v)
bool	operator>= (uint64 u, const sc_unsigned &v)
bool	operator>= (long u, const sc_unsigned &v)
bool	operator>= (unsigned long u, const sc_unsigned &v)
bool	operator>= (int u, const sc_unsigned &v)
bool	operator>= (unsigned int u, const sc_unsigned &v)
sc_unsigned	operator~ (const sc_unsigned &u)
inline::std::ostream &	operator<< (::std::ostream &, const sc_unsigned_bitref_r &)
inline::std::istream &	operator>> (::std::istream &, sc_unsigned_bitref &)
inline::std::ostream &	operator<< (::std::ostream &, const sc_unsigned_subref_r &)
inline::std::istream &	operator>> (::std::istream &, sc_unsigned_subref &)
inline::std::ostream &	operator<< (::std::ostream &, const sc_unsigned &)
inline::std::istream &	operator>> (::std::istream &, sc_unsigned &)
bool	and_reduce (const sc_concatref &a)
bool	nand_reduce (const sc_concatref &a)
bool	or_reduce (const sc_concatref &a)
bool	nor_reduce (const sc_concatref &a)
bool	xor_reduce (const sc_concatref &a)
bool	xnor_reduce (const sc_concatref &a)
const sc_unsigned	operator<< (const sc_concatref &target, uint64 shift)
const sc_unsigned	operator<< (const sc_concatref &target, int64 shift)
const sc_unsigned	operator<< (const sc_concatref &target, unsigned long shift)
const sc_unsigned	operator<< (const sc_concatref &target, unsigned int shift)
const sc_unsigned	operator<< (const sc_concatref &target, long shift)
const sc_unsigned	operator>> (const sc_concatref &target, uint64 shift)
const sc_unsigned	operator>> (const sc_concatref &target, int64 shift)
const sc_unsigned	operator>> (const sc_concatref &target, unsigned long shift)
const sc_unsigned	operator>> (const sc_concatref &target, unsigned int shift)
const sc_unsigned	operator>> (const sc_concatref &target, long shift)
inline::std::ostream &	operator<< (::std::ostream &os, const sc_concatref &v)
inline::std::istream &	operator>> (::std::istream &is, sc_concatref &a)
sc_dt::sc_concatref &	concat (sc_dt::sc_value_base &a, sc_dt::sc_value_base &b)
const sc_dt::sc_concatref &	concat (const sc_dt::sc_value_base &a, const sc_dt::sc_value_base &b)
const sc_dt::sc_concatref &	concat (const sc_dt::sc_value_base &a, bool b)
const sc_dt::sc_concatref &	concat (bool a, const sc_dt::sc_value_base &b)
sc_dt::sc_concatref &	operator, (sc_dt::sc_value_base &a, sc_dt::sc_value_base &b)
const sc_dt::sc_concatref &	operator, (const sc_dt::sc_value_base &a, const sc_dt::sc_value_base &b)
const sc_dt::sc_concatref &	operator, (const sc_dt::sc_value_base &a, bool b)
const sc_dt::sc_concatref &	operator, (bool a, const sc_dt::sc_value_base &b)
template<class T>
const T	sc_min (const T &a, const T &b)
template<class T>
const T	sc_max (const T &a, const T &b)
template<class T>
const T	sc_abs (const T &a)
int	sc_roundup (int n, int m)
const std::string	to_string (sc_numrep numrep)
sc_string_old	operator+ (const char *s, const sc_string_old &t)
::std::istream &	operator>> (::std::istream &is, sc_string_old &s)
sc_numrep	sc_io_base (systemc_ostream &stream_object, sc_numrep def_base)
bool	sc_io_show_base (systemc_ostream &stream_object)
systemc_ostream &	operator<< (systemc_ostream &os, sc_numrep numrep)
systemc_ostream &	operator<< (systemc_ostream &os, const sc_string_old &a)
変数
const sc_logic	sc_logic_0 (Log_0)
const sc_logic	sc_logic_1 (Log_1)
const sc_logic	sc_logic_Z (Log_Z)
const sc_logic	sc_logic_X (Log_X)
const sc_logic	SC_LOGIC_0 (Log_0)
const sc_logic	SC_LOGIC_1 (Log_1)
const sc_logic	SC_LOGIC_Z (Log_Z)
const sc_logic	SC_LOGIC_X (Log_X)
static const sc_digit	data_array []
static const sc_digit	ctrl_array []
const int	SC_DIGIT_SIZE = BITS_PER_BYTE * sizeof( sc_digit )
const sc_digit	SC_DIGIT_ZERO = (sc_digit)0
const sc_digit	SC_DIGIT_ONE = (sc_digit)1
const sc_digit	SC_DIGIT_TWO = (sc_digit)2
const int	SC_BUILTIN_WL_ = 32
const int	SC_BUILTIN_IWL_ = 32
const sc_q_mode	SC_BUILTIN_Q_MODE_ = SC_TRN
const sc_o_mode	SC_BUILTIN_O_MODE_ = SC_WRAP
const int	SC_BUILTIN_N_BITS_ = 0
const int	SC_DEFAULT_WL_ = SC_BUILTIN_WL_
const int	SC_DEFAULT_IWL_ = SC_BUILTIN_IWL_
const sc_q_mode	SC_DEFAULT_Q_MODE_ = SC_BUILTIN_Q_MODE_
const sc_o_mode	SC_DEFAULT_O_MODE_ = SC_BUILTIN_O_MODE_
const int	SC_DEFAULT_N_BITS_ = SC_BUILTIN_N_BITS_
const sc_switch	SC_BUILTIN_CAST_SWITCH_ = SC_ON
const sc_switch	SC_DEFAULT_CAST_SWITCH_ = SC_BUILTIN_CAST_SWITCH_
const int	SC_BUILTIN_DIV_WL_ = 64
const int	SC_BUILTIN_CTE_WL_ = 64
const int	SC_BUILTIN_MAX_WL_ = 1024
const int	SC_DEFAULT_DIV_WL_ = SC_BUILTIN_DIV_WL_
const int	SC_DEFAULT_CTE_WL_ = SC_BUILTIN_CTE_WL_
const int	SC_DEFAULT_MAX_WL_ = SC_BUILTIN_MAX_WL_
	div
const unsigned int	SCFX_IEEE_DOUBLE_BIAS = 1023U
const int	SCFX_IEEE_DOUBLE_E_MAX = 1023
const int	SCFX_IEEE_DOUBLE_E_MIN = -1022
const unsigned int	SCFX_IEEE_DOUBLE_M_SIZE = 52
const unsigned int	SCFX_IEEE_FLOAT_BIAS = 127U
const int	SCFX_IEEE_FLOAT_E_MAX = 127
const int	SCFX_IEEE_FLOAT_E_MIN = -126
const unsigned int	SCFX_IEEE_FLOAT_M_SIZE = 23
static word_list *	free_words [32] = { 0 }
const int	SCFX_POW10_TABLE_SIZE = 32
static scfx_pow10	pow10_fx
static const int	mantissa0_size = SCFX_IEEE_DOUBLE_M_SIZE - bits_in_int
static scfx_rep_node *	list = 0
const int	min_mant = 4
const int	bits_in_int = sizeof(int) * CHAR_BIT
const int	bits_in_word = sizeof(word) * CHAR_BIT
const uint_type	mask_int [SC_INTWIDTH][SC_INTWIDTH]
const uint64	UINT64_ZERO = 0ULL
const uint64	UINT64_ONE = 1ULL
const uint64	UINT64_32ONES = 0x00000000ffffffffULL
const small_type	NB_DEFAULT_BASE = SC_DEC
const uint64	UINT_ZERO = UINT64_ZERO
const uint64	UINT_ONE = UINT64_ONE

---

型定義

typedef ::std::ios::fmtflags sc_dt::fmtflags

sc_nbdefs.h の 176 行で定義されています。

typedef unsigned short sc_dt::half_word

scfx_mant.h の 64 行で定義されています。

typedef long long sc_dt::int64

sc_nbdefs.h の 137 行で定義されています。

typedef int64 sc_dt::int_type

sc_nbdefs.h の 187 行で定義されています。

typedef unsigned int sc_dt::sc_digit

sc_nbdefs.h の 132 行で定義されています。

typedef sc_context<sc_fxcast_switch> sc_dt::sc_fxcast_context

sc_fxcast_switch.h の 100 行で定義されています。

typedef sc_context<sc_fxtype_params> sc_dt::sc_fxtype_context

sc_fxtype_params.h の 123 行で定義されています。

typedef sc_context<sc_length_param> sc_dt::sc_length_context

sc_length_param.h の 107 行で定義されています。

typedef int sc_dt::small_type

sc_nbdefs.h の 77 行で定義されています。

typedef ::std::istream sc_dt::systemc_istream

sc_string.h の 98 行で定義されています。

typedef ::std::ostream sc_dt::systemc_ostream

sc_string.h の 99 行で定義されています。

typedef unsigned char sc_dt::uchar

sc_nbdefs.h の 73 行で定義されています。

typedef unsigned long long sc_dt::uint64

sc_nbdefs.h の 138 行で定義されています。

typedef uint64 sc_dt::uint_type

sc_nbdefs.h の 188 行で定義されています。

typedef unsigned int sc_dt::word

scfx_mant.h の 60 行で定義されています。

---

列挙型

enum sc_dt::sc_context_begin

列挙型の値:

SC_NOW
SC_LATER

sc_context.h の 118 行で定義されています。

{
    SC_NOW,
    SC_LATER
};

enum sc_dt::sc_enc

列挙型の値:

SC_TC_
SC_US_

sc_fxdefs.h の 64 行で定義されています。

{
    SC_TC_,     // two's complement
    SC_US_      // unsigned
};

enum sc_dt::sc_fmt

列挙型の値:

SC_F
SC_E

sc_fxdefs.h の 170 行で定義されています。

{
    SC_F,       // fixed
    SC_E        // scientific
};

enum sc_dt::sc_logic_value_t

列挙型の値:

Log_0
Log_1
Log_Z
Log_X

sc_logic.h の 71 行で定義されています。

{
    Log_0 = 0,
    Log_1,
    Log_Z,
    Log_X
};

enum sc_dt::sc_numrep

列挙型の値:

SC_NOBASE
SC_BIN
SC_OCT
SC_DEC
SC_HEX
SC_BIN_US
SC_BIN_SM
SC_OCT_US
SC_OCT_SM
SC_HEX_US
SC_HEX_SM
SC_CSD

sc_string.h の 79 行で定義されています。

{
    SC_NOBASE = 0,
    SC_BIN    = 2,
    SC_OCT    = 8,
    SC_DEC    = 10,
    SC_HEX    = 16,
    SC_BIN_US,
    SC_BIN_SM,
    SC_OCT_US,
    SC_OCT_SM,
    SC_HEX_US,
    SC_HEX_SM,
    SC_CSD
};

enum sc_dt::sc_o_mode

列挙型の値:

SC_SAT
SC_SAT_ZERO
SC_SAT_SYM
SC_WRAP
SC_WRAP_SM

sc_fxdefs.h の 117 行で定義されています。

{
    SC_SAT,             // saturation
    SC_SAT_ZERO,        // saturation to zero
    SC_SAT_SYM,         // symmetrical saturation
    SC_WRAP,            // wrap-around (*)
    SC_WRAP_SM          // sign magnitude wrap-around (*)
};

enum sc_dt::sc_q_mode

列挙型の値:

SC_RND
SC_RND_ZERO
SC_RND_MIN_INF
SC_RND_INF
SC_RND_CONV
SC_TRN
SC_TRN_ZERO

sc_fxdefs.h の 88 行で定義されています。

{
    SC_RND,             // rounding to plus infinity
    SC_RND_ZERO,        // rounding to zero
    SC_RND_MIN_INF,     // rounding to minus infinity
    SC_RND_INF,         // rounding to infinity
    SC_RND_CONV,        // convergent rounding
    SC_TRN,             // truncation
    SC_TRN_ZERO         // truncation to zero
};

enum sc_dt::sc_switch

列挙型の値:

SC_OFF
SC_ON

sc_fxdefs.h の 146 行で定義されています。

{
    SC_OFF,
    SC_ON
};

---

関数

CLASS_TYPE sc_dt::ADD_HELPER	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_signed.cpp の 4122 行で定義されています。

static int sc_dt::add_mants	(	int	size,
		scfx_mant &	result,
		const scfx_mant &	a,
		const scfx_mant &	b
	)			[inline, static]

scfx_rep.cpp の 1228 行で定義されています。

{
    unsigned int carry = 0;

    int index = 0;

    do
    {
        word x = a[index];
        word y = b[index];

        y += carry;
        carry = y < carry;
        y += x;
        carry += y < x;
        result[index] = y;
    }
    while( ++ index < size );

    return ( carry ? 1 : 0 );
}

void sc_dt::add_on_help	(	small_type &	us,
		int	,
		int	und,
		sc_digit *	ud,
		small_type	vs,
		int	,
		int	vnd,
		const sc_digit *	vd
	)

sc_nbexterns.cpp の 62 行で定義されています。

{

  vnd = vec_skip_leading_zeros(vnd, vd);

  if (us == vs) {  // case 3

    if (und >= vnd)
      vec_add_on(und, ud, vnd, vd);
    else
      vec_add_on2(und, ud, vnd, vd);

  }
  else {  // case 4

    // vec_cmp expects that und is the number of non-zero digits in ud.
    int new_und = vec_skip_leading_zeros(und, ud); 
    int cmp_res = vec_cmp(new_und, ud, vnd, vd);

    if (cmp_res == 0)  { // u == v
      us = SC_ZERO;
      vec_zero(und, ud);
      return;
    }

    if (cmp_res > 0) // u > v
      vec_sub_on(und, ud, vnd, vd);

    else { // u < v
      us = -us;
      vec_sub_on2(und, ud, vnd, vd);
    }

  }
}

scfx_rep * sc_dt::add_scfx_rep	(	const scfx_rep &	lhs,
		const scfx_rep &	rhs,
		int	max_wl
	)

scfx_rep.cpp の 1279 行で定義されています。

{
    scfx_rep& result = *new scfx_rep;

    //
    // check for special cases
    //

    if( lhs.is_nan() || rhs.is_nan()
    ||  ( lhs.is_inf() && rhs.is_inf() && lhs.m_sign != rhs.m_sign ) )
    {
        result.set_nan();
        return &result;
    }

    if( lhs.is_inf() )
    {
        result.set_inf( lhs.m_sign );
        return &result;
    }

    if( rhs.is_inf() )
    {
        result.set_inf( rhs.m_sign );
        return &result;
    }

    //
    // align operands if needed
    //

    scfx_mant_ref lhs_mant;
    scfx_mant_ref rhs_mant;

    int len_mant = lhs.size();
    int new_wp = lhs.m_wp;

    align( lhs, rhs, new_wp, len_mant, lhs_mant, rhs_mant );

    //
    // size the result mantissa
    //

    result.resize_to( len_mant );
    result.m_wp = new_wp;

    //
    // do it
    //

    if( lhs.m_sign == rhs.m_sign )
    {
        add_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
        result.m_sign = lhs.m_sign;
    }
    else
    {
        int cmp = compare_abs( lhs, rhs );

        if( cmp == 1 )
        {
            sub_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
            result.m_sign = lhs.m_sign;
        }
        else if ( cmp == -1 )
        {
            sub_mants( len_mant, result.m_mant, rhs_mant, lhs_mant );
            result.m_sign = rhs.m_sign;
        }
        else
        {
            result.m_mant.clear();
            result.m_sign = 1;
        }
    }

    result.find_sw();
    result.round( max_wl );

    return &result;
}

sc_signed sc_dt::add_signed_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_unsigned sc_dt::add_unsigned_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

void sc_dt::align	(	const scfx_rep &	lhs,
		const scfx_rep &	rhs,
		int &	new_wp,
		int &	len_mant,
		scfx_mant_ref &	lhs_mant,
		scfx_mant_ref &	rhs_mant
	)

scfx_rep.cpp の 2233 行で定義されています。

{
    bool need_lhs = true;
    bool need_rhs = true;

    if( lhs.m_wp != rhs.m_wp || lhs.size() != rhs.size() )
    {
        int lower_bound_lhs = lhs.m_lsw - lhs.m_wp;
        int upper_bound_lhs = lhs.m_msw - lhs.m_wp;
        int lower_bound_rhs = rhs.m_lsw - rhs.m_wp;
        int upper_bound_rhs = rhs.m_msw - rhs.m_wp;

        int lower_bound = sc_min( lower_bound_lhs, lower_bound_rhs );
        int upper_bound = sc_max( upper_bound_lhs, upper_bound_rhs );

        new_wp   = -lower_bound;
        len_mant = sc_max( min_mant, upper_bound - lower_bound + 1 );

        if( new_wp != lhs.m_wp || len_mant != lhs.size() )
        {
            lhs_mant = lhs.resize( len_mant, new_wp );
            need_lhs = false;
        }

        if( new_wp != rhs.m_wp || len_mant != rhs.size() )
        {
            rhs_mant = rhs.resize( len_mant, new_wp );
            need_rhs = false;
        }
    }

    if( need_lhs )
    {
        lhs_mant = lhs.m_mant;
    }

    if( need_rhs )
    {
        rhs_mant = rhs.m_mant;
    }
}

CLASS_TYPE sc_dt::AND_HELPER	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_signed.cpp の 4380 行で定義されています。

void sc_dt::and_on_help	(	small_type	us,
		int	,
		int	und,
		sc_digit *	ud,
		small_type	vs,
		int	,
		int	vnd,
		const sc_digit *	vd
	)

sc_nbexterns.cpp の 584 行で定義されています。

{

  register sc_digit *x = ud;
  register const sc_digit *y = vd;
  int xnd = und;
  int ynd = vnd;

  // Truncate y.
  if (xnd < ynd)
    ynd = xnd;

  const sc_digit *xend = (x + xnd);
  const sc_digit *yend = (y + ynd);

  // x is longer than y.

  small_type s = mul_signs(us, vs);

  if (s > 0) {

    if (us > 0) { // case 2

      while (y < yend)
        (*x++) &= (*y++);

      while (x < xend)
        (*x++) = 0;

    }
    else {  // case 3

      register sc_digit xcarry = 1;
      register sc_digit ycarry = 1;

      while (y < yend) {
        xcarry += (~(*x) & DIGIT_MASK);
        ycarry += (~(*y++) & DIGIT_MASK);
        (*x++) = (xcarry & ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        xcarry += (~(*x) & DIGIT_MASK);
        ycarry += DIGIT_MASK;
        (*x++) = (xcarry & ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }

    }
  }
  else {

    if (us > 0) { // case 4

      register sc_digit ycarry = 1;

      while (y < yend) {
        ycarry += (~(*y++) & DIGIT_MASK);
        (*x++) &= ycarry & DIGIT_MASK;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        ycarry += DIGIT_MASK;
        (*x++) &= ycarry & DIGIT_MASK;
        ycarry >>= BITS_PER_DIGIT;
      }

    }
    else {  // case 5

      register sc_digit xcarry = 1;

      while (y < yend) {
        xcarry += (~(*x) & DIGIT_MASK);
        (*x++) = (xcarry & (*y++)) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
      }

      while (x < xend)
        (*x++) = 0;

    }
  }
}

bool sc_dt::and_reduce

(

const sc_concatref &

a

)

[inline]

sc_concatref.h の 437 行で定義されています。

{
    return a.and_reduce();
}

bool sc_dt::and_reduce

(

const sc_uint_base &

a

)

[inline]

sc_uint_base.h の 1276 行で定義されています。

{
    return a.and_reduce();
}

bool sc_dt::and_reduce

(

const sc_uint_subref_r &

a

)

[inline]

sc_uint_base.h の 1093 行で定義されています。

{
    return a.and_reduce();
}

bool sc_dt::and_reduce

(

const sc_int_base &

a

)

[inline]

sc_int_base.h の 1305 行で定義されています。

{
    return a.and_reduce();
}

bool sc_dt::and_reduce

(

const sc_int_subref_r &

a

)

[inline]

sc_int_base.h の 1122 行で定義されています。

{
    return a.and_reduce();
}

template<class X>

sc_logic_value_t sc_dt::and_reduce

(

const sc_proxy< X > &

a

)

[inline]

sc_proxy.h の 1459 行で定義されています。

{
    return a.and_reduce();
}

sc_signed sc_dt::and_signed_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_unsigned sc_dt::and_unsigned_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

template<class X, class Y>

void sc_dt::assign_p_	(	sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_proxy.h の 669 行で定義されています。

{
    if( (void*) &px != (void*) &py ) {
        X& x = px.back_cast();
        const Y& y = py.back_cast();
        int sz = x.size();
        int min_sz = sc_min( sz, y.size() );
        int i = 0;
        for( ; i < min_sz; ++ i ) {
            set_words_( x, i, y.get_word( i ), y.get_cword( i ) );
        }
        // extend with zeros
        extend_sign_w_( x, i, false );
        x.clean_tail();
    }
}

template<class X>

void sc_dt::assign_v_	(	sc_proxy< X > &	px,
		const sc_unsigned &	a
	)			[inline]

sc_proxy.h の 769 行で定義されています。

{
    X& x = px.back_cast();
        int i;
    int len_x = x.length();
    int len_a = a.length();
    if ( len_a > len_x ) len_a = len_x;
    for( i = 0 ; i < len_a; ++ i ) {
        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
    }
    for( ; i < len_x; ++ i ) {
        x.set_bit( i, sc_logic_value_t( false ) );
    }
}

template<class X>

void sc_dt::assign_v_	(	sc_proxy< X > &	px,
		const sc_uint_base &	a
	)			[inline]

sc_proxy.h の 751 行で定義されています。

{
    X& x = px.back_cast();
        int i;
    int len_x = x.length();
    int len_a = a.length();
    if ( len_a > len_x ) len_a = len_x;
    for( i = 0 ; i < len_a; ++ i ) {
        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
    }
    for( ; i < len_x; ++ i ) {
        x.set_bit( i, sc_logic_value_t( false ) );
    }
}

template<class X>

void sc_dt::assign_v_	(	sc_proxy< X > &	px,
		const sc_signed &	a
	)			[inline]

sc_proxy.h の 732 行で定義されています。

{
    X& x = px.back_cast();
        int i;
    bool sign = a < 0;
    int len_x = x.length();
    int len_a = a.length();
    if ( len_a > len_x ) len_a = len_x;
    for( i = 0 ; i < len_a; ++ i ) {
        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
    }
    for( ; i < len_x; ++ i ) {
        x.set_bit( i, sc_logic_value_t( sign ) );
    }
}

template<class X>

void sc_dt::assign_v_	(	sc_proxy< X > &	px,
		const sc_int_base &	a
	)			[inline]

sc_proxy.h の 713 行で定義されています。

{
    X& x = px.back_cast();
        int i;
    bool sign = a < 0;
    int len_x = x.length();
    int len_a = a.length();
    if ( len_a > len_x ) len_a = len_x;
    for( i = 0 ; i < len_a; ++ i ) {
        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
    }
    for( ; i < len_x; ++ i ) {
        x.set_bit( i, sc_logic_value_t( sign ) );
    }
}

template<class X, class T>

void sc_dt::assign_v_	(	sc_proxy< X > &	px,
		const T &	a
	)			[inline]

sc_proxy.h の 695 行で定義されています。

{
    X& x = px.back_cast();
    int i;
    int len_x = x.length();
    int len_a = a.length();
    if ( len_a > len_x ) len_a = len_x;
    for( i = 0 ; i < len_a; ++ i ) {
        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
    }
    for( ; i < len_x; ++ i ) {
        x.set_bit( i, sc_logic_value_t( false ) );
    }
}

void sc_dt::b_and	(	sc_bit &	r,
		char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 666 行で定義されています。

        { r = ( a & b ); }

void sc_dt::b_and	(	sc_bit &	r,
		bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 663 行で定義されています。

        { r = ( a & b ); }

void sc_dt::b_and	(	sc_bit &	r,
		int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 660 行で定義されています。

        { r = ( a & b ); }

void sc_dt::b_and	(	sc_bit &	r,
		const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 657 行で定義されています。

        { r = ( a & b ); }

void sc_dt::b_and	(	sc_bit &	r,
		const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 654 行で定義されています。

        { r = ( a & b ); }

void sc_dt::b_and	(	sc_bit &	r,
		const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 651 行で定義されています。

        { r = ( a & b ); }

void sc_dt::b_and	(	sc_bit &	r,
		const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 648 行で定義されています。

        { r = ( a & b ); }

const sc_bit sc_dt::b_and	(	char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 643 行で定義されています。

        { return ( a & b ); }

const sc_bit sc_dt::b_and	(	bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 640 行で定義されています。

        { return ( a & b ); }

const sc_bit sc_dt::b_and	(	int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 637 行で定義されています。

        { return ( a & b ); }

const sc_bit sc_dt::b_and	(	const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 634 行で定義されています。

        { return ( a & b ); }

const sc_bit sc_dt::b_and	(	const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 631 行で定義されています。

        { return ( a & b ); }

const sc_bit sc_dt::b_and	(	const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 628 行で定義されています。

        { return ( a & b ); }

const sc_bit sc_dt::b_and	(	const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 625 行で定義されています。

        { return ( a & b ); }

template<class X, class Y>

X& sc_dt::b_and_assign_	(	sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_proxy.h の 992 行で定義されています。

{
    X& x = px.back_cast();
    const Y& y = py.back_cast();
    assert( x.length() == y.length() );
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
        sc_digit x_dw, x_cw, y_dw, y_cw;
        get_words_( x, i, x_dw, x_cw );
        get_words_( y, i, y_dw, y_cw );
        sc_digit cw = x_dw & y_cw | x_cw & y_dw | x_cw & y_cw;
        sc_digit dw = cw | x_dw & y_dw;
        set_words_( x, i, dw, cw );
    }
    // tail cleaning not needed
    return x;
}

void sc_dt::b_not	(	sc_ufix_fast &	c,
		const sc_ufix_fast &	a
	)			[inline]

sc_ufix.h の 1747 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    int iwl_c = c.iwl();
    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )
        c.set_bit( i, ! a.get_bit( i ) );
    c.cast();
    SC_FXNUM_FAST_OBSERVER_WRITE_( c )
}

void sc_dt::b_not	(	sc_ufix &	c,
		const sc_ufix &	a
	)			[inline]

sc_ufix.h の 1035 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    int iwl_c = c.iwl();
    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )
        c.set_bit( i, ! a.get_bit( i ) );
    c.cast();
    SC_FXNUM_OBSERVER_WRITE_( c )
}

void sc_dt::b_not	(	sc_fix_fast &	c,
		const sc_fix_fast &	a
	)			[inline]

sc_fix.h の 1744 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    int iwl_c = c.iwl();
    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )
        c.set_bit( i, ! a.get_bit( i ) );
    c.cast();
    SC_FXNUM_FAST_OBSERVER_WRITE_( c )
}

void sc_dt::b_not	(	sc_fix &	c,
		const sc_fix &	a
	)			[inline]

sc_fix.h の 1032 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    int iwl_c = c.iwl();
    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )
        c.set_bit( i, ! a.get_bit( i ) );
    c.cast();
    SC_FXNUM_OBSERVER_WRITE_( c )
}

void sc_dt::b_not	(	sc_bit &	r,
		const sc_bit &	a
	)			[inline]

sc_bit.h の 522 行で定義されています。

        { r = ( ~ a ); }

const sc_bit sc_dt::b_not

(

const sc_bit &

a

)

[inline]

sc_bit.h の 517 行で定義されています。

        { return ( ~ a ); }

void sc_dt::b_or	(	sc_bit &	r,
		char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 594 行で定義されています。

        { r = ( a | b ); }

void sc_dt::b_or	(	sc_bit &	r,
		bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 591 行で定義されています。

        { r = ( a | b ); }

void sc_dt::b_or	(	sc_bit &	r,
		int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 588 行で定義されています。

        { r = ( a | b ); }

void sc_dt::b_or	(	sc_bit &	r,
		const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 585 行で定義されています。

        { r = ( a | b ); }

void sc_dt::b_or	(	sc_bit &	r,
		const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 582 行で定義されています。

        { r = ( a | b ); }

void sc_dt::b_or	(	sc_bit &	r,
		const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 579 行で定義されています。

        { r = ( a | b ); }

void sc_dt::b_or	(	sc_bit &	r,
		const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 576 行で定義されています。

        { r = ( a | b ); }

const sc_bit sc_dt::b_or	(	char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 571 行で定義されています。

        { return ( a | b ); }

const sc_bit sc_dt::b_or	(	bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 568 行で定義されています。

        { return ( a | b ); }

const sc_bit sc_dt::b_or	(	int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 565 行で定義されています。

        { return ( a | b ); }

const sc_bit sc_dt::b_or	(	const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 562 行で定義されています。

        { return ( a | b ); }

const sc_bit sc_dt::b_or	(	const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 559 行で定義されています。

        { return ( a | b ); }

const sc_bit sc_dt::b_or	(	const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 556 行で定義されています。

        { return ( a | b ); }

const sc_bit sc_dt::b_or	(	const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 553 行で定義されています。

        { return ( a | b ); }

template<class X, class Y>

X& sc_dt::b_or_assign_	(	sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_proxy.h の 1016 行で定義されています。

{
    X& x = px.back_cast();
    const Y& y = py.back_cast();
    assert( x.length() == y.length() );
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
        sc_digit x_dw, x_cw, y_dw, y_cw;
        get_words_( x, i, x_dw, x_cw );
        get_words_( y, i, y_dw, y_cw );
        sc_digit cw = x_cw & y_cw | x_cw & ~y_dw | ~x_dw & y_cw;
        sc_digit dw = cw | x_dw | y_dw;
        set_words_( x, i, dw, cw );
    }
    // tail cleaning not needed
    return x;
}

void sc_dt::b_xor	(	sc_bit &	r,
		char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 738 行で定義されています。

        { r = ( a ^ b ); }

void sc_dt::b_xor	(	sc_bit &	r,
		bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 735 行で定義されています。

        { r = ( a ^ b ); }

void sc_dt::b_xor	(	sc_bit &	r,
		int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 732 行で定義されています。

        { r = ( a ^ b ); }

void sc_dt::b_xor	(	sc_bit &	r,
		const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 729 行で定義されています。

        { r = ( a ^ b ); }

void sc_dt::b_xor	(	sc_bit &	r,
		const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 726 行で定義されています。

        { r = ( a ^ b ); }

void sc_dt::b_xor	(	sc_bit &	r,
		const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 723 行で定義されています。

        { r = ( a ^ b ); }

void sc_dt::b_xor	(	sc_bit &	r,
		const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 720 行で定義されています。

        { r = ( a ^ b ); }

const sc_bit sc_dt::b_xor	(	char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 715 行で定義されています。

        { return ( a ^ b ); }

const sc_bit sc_dt::b_xor	(	bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 712 行で定義されています。

        { return ( a ^ b ); }

const sc_bit sc_dt::b_xor	(	int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 709 行で定義されています。

        { return ( a ^ b ); }

const sc_bit sc_dt::b_xor	(	const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 706 行で定義されています。

        { return ( a ^ b ); }

const sc_bit sc_dt::b_xor	(	const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 703 行で定義されています。

        { return ( a ^ b ); }

const sc_bit sc_dt::b_xor	(	const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 700 行で定義されています。

        { return ( a ^ b ); }

const sc_bit sc_dt::b_xor	(	const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 697 行で定義されています。

        { return ( a ^ b ); }

template<class X, class Y>

X& sc_dt::b_xor_assign_	(	sc_proxy< X > &	a,
		const sc_proxy< Y > &	b
	)			[inline]

sc_proxy.h の 1040 行で定義されています。

{
    X& x = a.back_cast();
    const Y& y = b.back_cast();
    assert( x.length() == y.length() );
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
        sc_digit x_dw, x_cw, y_dw, y_cw;
        get_words_( x, i, x_dw, x_cw );
        get_words_( y, i, y_dw, y_cw );
        sc_digit cw = x_cw | y_cw;
        sc_digit dw = cw | x_dw ^ y_dw;
        set_words_( x, i, dw, cw );
    }
    // tail cleaning not needed
    return x;
}

int sc_dt::bit_ord

(

int

i

)

[inline]

sc_nbutils.h の 344 行で定義されています。

{
  return (i % BITS_PER_DIGIT);
}

bool sc_dt::check_for_zero	(	int	ulen,
		const sc_digit *	u
	)			[inline]

sc_nbutils.h の 669 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  // assert(ulen >= 0);
  assert((ulen > 0) && (u != NULL));
#endif

  if (vec_find_first_nonzero(ulen, u) < 0)
    return true;

  return false;

}

small_type sc_dt::check_for_zero	(	small_type	s,
		int	ulen,
		const sc_digit *	u
	)			[inline]

sc_nbutils.h の 650 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  // assert(ulen >= 0);
  assert((ulen > 0) && (u != NULL));
#endif

  if (vec_find_first_nonzero(ulen, u) < 0)
    return SC_ZERO;  

  return s;

}

int sc_dt::cmp_scfx_rep	(	const scfx_rep &	a,
		const scfx_rep &	b
	)

scfx_rep.cpp の 1850 行で定義されています。

{
    // handle special cases

    if( a.is_nan() || b.is_nan() )
    {
#if 0
        if( a.is_nan() && b.is_nan() )
        {
            return 0;
        }
#endif
        return 2;
    }

    if( a.is_inf() || b.is_inf() )
    {
        if( a.is_inf() )
        {
            if( ! a.is_neg() )
            {
                if( b.is_inf() && ! b.is_neg() )
                {
                    return 0;
                }
                else
                {
                    return 1;
                }
            }
            else
            {
                if( b.is_inf() && b.is_neg() )
                {
                    return 0;
                }
                else
                {
                    return -1;
                }
            }
        }
        if( b.is_inf() )
        {
            if( ! b.is_neg() )
            {
                return -1;
            }
            else
            {
                return 1;
            }
        }
    }
  
    if( a.is_zero() && b.is_zero() )
    {
        return 0;
    }

    // compare sign

    if( a.m_sign != b.m_sign )
    {
        return a.m_sign;
    }

    return ( a.m_sign * compare_abs( a, b ) );
}

int sc_dt::compare_abs	(	const scfx_rep &	a,
		const scfx_rep &	b
	)

scfx_rep.cpp の 1773 行で定義されています。

{
    // check for zero

    word a_word = a.m_mant[a.m_msw];
    word b_word = b.m_mant[b.m_msw];
  
    if( a_word == 0 || b_word == 0 )
    {
        if( a_word != 0 )
            return 1;
        if( b_word != 0 )
            return -1;
        return 0;
    }

    // compare msw index

    int a_msw = a.m_msw - a.m_wp;
    int b_msw = b.m_msw - b.m_wp;

    if( a_msw > b_msw )
        return 1;

    if( a_msw < b_msw )
        return -1;

    // compare content

    int a_i = a.m_msw;
    int b_i = b.m_msw;

    while( a_i >= a.m_lsw && b_i >= b.m_lsw )
    {
        a_word = a.m_mant[a_i];
        b_word = b.m_mant[b_i];
        if( a_word > b_word )
            return 1;
        if( a_word < b_word )
            return -1;
        -- a_i;
        -- b_i;
    }

    bool a_zero = true;
    while( a_i >= a.m_lsw )
    {
        a_zero = a_zero && ( a.m_mant[a_i] == 0 );
        -- a_i;
    }
  
    bool b_zero = true;
    while( b_i >= b.m_lsw )
    {
        b_zero = b_zero && ( b.m_mant[b_i] == 0 );
        -- b_i;
    }

    // assertion: a_zero || b_zero == true

    if( ! a_zero && b_zero )
        return 1;

    if( a_zero && ! b_zero )
        return -1;

    return 0;
}

int sc_dt::compare_msw_ff	(	const scfx_rep &	lhs,
		const scfx_rep &	rhs
	)

scfx_rep.cpp の 2282 行で定義されています。

{
    // special case: rhs.m_mant[rhs.m_msw + 1] == 1
    if( rhs.m_msw < rhs.size() - 1 && rhs.m_mant[rhs.m_msw + 1 ] != 0 )
    {
        return -1;
    }

    int lhs_size = lhs.m_msw - lhs.m_lsw + 1;
    int rhs_size = rhs.m_msw - rhs.m_lsw + 1;

    int size = sc_min( lhs_size, rhs_size );

    int lhs_index = lhs.m_msw;
    int rhs_index = rhs.m_msw;

    int i;

    for( i = 0;
         i < size && lhs.m_mant[lhs_index] == rhs.m_mant[rhs_index];
         i ++ )
    {
        lhs_index --;
        rhs_index --;
    }

    if( i == size )
    {
        if( lhs_size == rhs_size )
        {
            return 0;
        }

        if( lhs_size < rhs_size )
        {
            return -1;
        }
        else
        {
            return 1;
        }
  }

  if( lhs.m_mant[lhs_index] < rhs.m_mant[rhs_index] )
  {
      return -1;
  } else {
      return 1;
  }
}

int sc_dt::compare_unsigned	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd,
		small_type	if_u_signed,
		small_type	if_v_signed
	)

sc_unsigned.cpp の 1975 行で定義されています。

{

  if (us == vs) {

    if (us == SC_ZERO)
      return 0;

    else {

      int cmp_res = vec_skip_and_cmp(und, ud, vnd, vd);

      if (us == SC_POS)
        return cmp_res;
      else
        return -cmp_res;

    }
  }
  else {

    if (us == SC_ZERO)
      return -vs;

    if (vs == SC_ZERO)
      return us;

    int cmp_res;

    int nd = (us == SC_NEG ? und : vnd);

#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS];
#else
    sc_digit *d = new sc_digit[nd];
#endif

    if (us == SC_NEG) {

      vec_copy(nd, d, ud);
      vec_complement(nd, d);
      trim(if_u_signed, unb, nd, d);
      cmp_res = vec_skip_and_cmp(nd, d, vnd, vd);

    }
    else {

      vec_copy(nd, d, vd);
      vec_complement(nd, d);
      trim(if_v_signed, vnb, nd, d);
      cmp_res = vec_skip_and_cmp(und, ud, nd, d);

    }

#ifndef SC_MAX_NBITS
    delete [] d;
#endif

    return cmp_res;

  }
}

void sc_dt::complement	(	scfx_mant &	target,
		const scfx_mant &	source,
		int	size
	)			[inline]

scfx_mant.h の 341 行で定義されています。

{
    for( int i = 0; i < size; i ++ )
    {
        target[i] = ~source[i];
    }
}

const sc_dt::sc_concatref& sc_dt::concat	(	bool	a,
		const sc_dt::sc_value_base &	b
	)			[inline]

sc_concatref.h の 745 行で定義されています。

{
    const sc_dt::sc_concat_bool* a_p;        // Proxy for boolean value.
    sc_dt::sc_concatref*         result_p;   // Proxy for the concatenation.

    a_p = sc_dt::sc_concat_bool::allocate(a);
    result_p = sc_dt::sc_concatref::m_pool.allocate();
    result_p->initialize( *a_p, b );
    return *result_p;
}

const sc_dt::sc_concatref& sc_dt::concat	(	const sc_dt::sc_value_base &	a,
		bool	b
	)			[inline]

sc_concatref.h の 732 行で定義されています。

{
    const sc_dt::sc_concat_bool* b_p;        // Proxy for boolean value.
    sc_dt::sc_concatref*         result_p;   // Proxy for the concatenation.

    b_p = sc_dt::sc_concat_bool::allocate(b);
    result_p = sc_dt::sc_concatref::m_pool.allocate();
    result_p->initialize( a, *b_p );
    return *result_p;
}

const sc_dt::sc_concatref& sc_dt::concat	(	const sc_dt::sc_value_base &	a,
		const sc_dt::sc_value_base &	b
	)			[inline]

sc_concatref.h の 720 行で定義されています。

{
    sc_dt::sc_concatref* result_p;     // Proxy for the concatenation.

    result_p = sc_dt::sc_concatref::m_pool.allocate();
    result_p->initialize( a, b );
    return *result_p;
}

sc_dt::sc_concatref& sc_dt::concat	(	sc_dt::sc_value_base &	a,
		sc_dt::sc_value_base &	b
	)			[inline]

sc_concatref.h の 708 行で定義されています。

{
    sc_dt::sc_concatref* result_p;     // Proxy for the concatenation.

    result_p = sc_dt::sc_concatref::m_pool.allocate();
    result_p->initialize( a, b );
    return *result_p;
}

sc_digit sc_dt::concat	(	sc_digit	h,
		sc_digit	l
	)			[inline]

sc_nbutils.h の 309 行で定義されています。

{
  return ((h << BITS_PER_HALF_DIGIT) | l);
}

template<class T1, class T2>

sc_concref< T1, T2 > sc_dt::concat	(	sc_proxy< T1 > &	a,
		sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 3854 行で定義されています。

{
    return sc_concref<T1,T2>(
        a.back_cast(), b.back_cast() );
}

template<class T1, class T2, class T3>

sc_concref< T1, sc_concref< T2, T3 > > sc_dt::concat	(	sc_proxy< T1 > &	a,
		sc_concref< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 3845 行で定義されています。

{
    return sc_concref<T1,sc_concref<T2,T3> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T1, class T2>

sc_concref< T1, sc_subref< T2 > > sc_dt::concat	(	sc_proxy< T1 > &	a,
		sc_subref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 3836 行で定義されています。

{
    return sc_concref<T1,sc_subref<T2> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T1, class T2>

sc_concref< T1, sc_bitref< T2 > > sc_dt::concat	(	sc_proxy< T1 > &	a,
		sc_bitref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 3827 行で定義されています。

{
    return sc_concref<T1,sc_bitref<T2> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T>

sc_concref_r< sc_lv_base, T > sc_dt::concat	(	bool	a,
		const sc_proxy< T > &	b
	)			[inline]

sc_lv_base.h の 1691 行で定義されています。

{
    return sc_concref_r<sc_lv_base,T>(
        *new sc_lv_base( sc_logic( a ), 1 ), b.back_cast(), 1 );
}

template<class T>

sc_concref_r< T, sc_lv_base > sc_dt::concat	(	const sc_proxy< T > &	a,
		bool	b
	)			[inline]

sc_lv_base.h の 1682 行で定義されています。

{
    return sc_concref_r<T,sc_lv_base>(
        a.back_cast(), *new sc_lv_base( sc_logic( b ), 1 ), 2 );
}

template<class T>

sc_concref_r< sc_lv_base, T > sc_dt::concat	(	const sc_logic &	a,
		const sc_proxy< T > &	b
	)			[inline]

sc_lv_base.h の 1673 行で定義されています。

{
    return sc_concref_r<sc_lv_base,T>(
        *new sc_lv_base( a, 1 ), b.back_cast(), 1 );
}

template<class T>

sc_concref_r< T, sc_lv_base > sc_dt::concat	(	const sc_proxy< T > &	a,
		const sc_logic &	b
	)			[inline]

sc_lv_base.h の 1664 行で定義されています。

{
    return sc_concref_r<T,sc_lv_base>(
        a.back_cast(), *new sc_lv_base( b, 1 ), 2 );
}

template<class T>

sc_concref_r< sc_lv_base, T > sc_dt::concat	(	const char *	a,
		const sc_proxy< T > &	b
	)			[inline]

sc_lv_base.h の 1655 行で定義されています。

{
    return sc_concref_r<sc_lv_base,T>(
        *new sc_lv_base( a ), b.back_cast(), 1 );
}

template<class T>

sc_concref_r< T, sc_lv_base > sc_dt::concat	(	const sc_proxy< T > &	a,
		const char *	b
	)			[inline]

sc_lv_base.h の 1646 行で定義されています。

{
    return sc_concref_r<T,sc_lv_base>(
        a.back_cast(), *new sc_lv_base( b ), 2 );
}

template<class T1, class T2>

sc_concref_r< T1, T2 > sc_dt::concat	(	const sc_proxy< T1 > &	a,
		const sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 3628 行で定義されています。

{
    return sc_concref_r<T1,T2>(
        a.back_cast(), b.back_cast() );
}

template<class T1, class T2, class T3>

sc_concref_r< T1, sc_concref_r< T2, T3 > > sc_dt::concat	(	const sc_proxy< T1 > &	a,
		sc_concref_r< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 3619 行で定義されています。

{
    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T1, class T2>

sc_concref_r< T1, sc_subref_r< T2 > > sc_dt::concat	(	const sc_proxy< T1 > &	a,
		sc_subref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 3610 行で定義されています。

{
    return sc_concref_r<T1,sc_subref_r<T2> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T1, class T2>

sc_concref_r< T1, sc_bitref_r< T2 > > sc_dt::concat	(	const sc_proxy< T1 > &	a,
		sc_bitref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 3601 行で定義されています。

{
    return sc_concref_r<T1,sc_bitref_r<T2> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T1, class T2, class T3>

sc_concref< sc_concref< T1, T2 >, T3 > sc_dt::concat	(	sc_concref< T1, T2 >	a,
		sc_proxy< T3 > &	b
	)			[inline]

sc_bit_proxies.h の 3535 行で定義されています。

{
    return sc_concref<sc_concref<T1,T2>,T3>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3, class T4>

sc_concref< sc_concref< T1, T2 >, sc_concref< T3, T4 > > sc_dt::concat	(	sc_concref< T1, T2 >	a,
		sc_concref< T3, T4 >	b
	)			[inline]

sc_bit_proxies.h の 3526 行で定義されています。

{
    return sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2, class T3>

sc_concref< sc_concref< T1, T2 >, sc_subref< T3 > > sc_dt::concat	(	sc_concref< T1, T2 >	a,
		sc_subref< T3 >	b
	)			[inline]

sc_bit_proxies.h の 3517 行で定義されています。

{
    return sc_concref<sc_concref<T1,T2>,sc_subref<T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2, class T3>

sc_concref< sc_concref< T1, T2 >, sc_bitref< T3 > > sc_dt::concat	(	sc_concref< T1, T2 >	a,
		sc_bitref< T3 >	b
	)			[inline]

sc_bit_proxies.h の 3508 行で定義されています。

{
    return sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > > sc_dt::concat	(	bool	a,
		sc_concref_r< T1, T2 >	b
	)			[inline]

sc_lv_base.h の 1458 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
        *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base > sc_dt::concat	(	sc_concref_r< T1, T2 >	a,
		bool	b
	)			[inline]

sc_lv_base.h の 1449 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > > sc_dt::concat	(	const sc_logic &	a,
		sc_concref_r< T1, T2 >	b
	)			[inline]

sc_lv_base.h の 1440 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
        *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base > sc_dt::concat	(	sc_concref_r< T1, T2 >	a,
		const sc_logic &	b
	)			[inline]

sc_lv_base.h の 1431 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > > sc_dt::concat	(	const char *	a,
		sc_concref_r< T1, T2 >	b
	)			[inline]

sc_lv_base.h の 1422 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
        *new sc_lv_base( a ), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base > sc_dt::concat	(	sc_concref_r< T1, T2 >	a,
		const char *	b
	)			[inline]

sc_lv_base.h の 1413 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b ), 3 );
}

template<class T1, class T2, class T3>

sc_concref_r< sc_concref_r< T1, T2 >, T3 > sc_dt::concat	(	sc_concref_r< T1, T2 >	a,
		const sc_proxy< T3 > &	b
	)			[inline]

sc_bit_proxies.h の 3290 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3, class T4>

sc_concref_r< sc_concref_r< T1, T2 >, sc_concref_r< T3, T4 > > sc_dt::concat	(	sc_concref_r< T1, T2 >	a,
		sc_concref_r< T3, T4 >	b
	)			[inline]

sc_bit_proxies.h の 3281 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2, class T3>

sc_concref_r< sc_concref_r< T1, T2 >, sc_subref_r< T3 > > sc_dt::concat	(	sc_concref_r< T1, T2 >	a,
		sc_subref_r< T3 >	b
	)			[inline]

sc_bit_proxies.h の 3272 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2, class T3>

sc_concref_r< sc_concref_r< T1, T2 >, sc_bitref_r< T3 > > sc_dt::concat	(	sc_concref_r< T1, T2 >	a,
		sc_bitref_r< T3 >	b
	)			[inline]

sc_bit_proxies.h の 3263 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_subref< T1 >, T2 > sc_dt::concat	(	sc_subref< T1 >	a,
		sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 2990 行で定義されています。

{
    return sc_concref<sc_subref<T1>,T2>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3>

sc_concref< sc_subref< T1 >, sc_concref< T2, T3 > > sc_dt::concat	(	sc_subref< T1 >	a,
		sc_concref< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 2981 行で定義されています。

{
    return sc_concref<sc_subref<T1>,sc_concref<T2,T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_subref< T1 >, sc_subref< T2 > > sc_dt::concat	(	sc_subref< T1 >	a,
		sc_subref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2972 行で定義されています。

{
    return sc_concref<sc_subref<T1>,sc_subref<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_subref< T1 >, sc_bitref< T2 > > sc_dt::concat	(	sc_subref< T1 >	a,
		sc_bitref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2963 行で定義されています。

{
    return sc_concref<sc_subref<T1>,sc_bitref<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_lv_base, sc_subref_r< T > > sc_dt::concat	(	bool	a,
		sc_subref_r< T >	b
	)			[inline]

sc_lv_base.h の 1181 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
        *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_subref_r< T >, sc_lv_base > sc_dt::concat	(	sc_subref_r< T >	a,
		bool	b
	)			[inline]

sc_lv_base.h の 1172 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template<class T>

sc_concref_r< sc_lv_base, sc_subref_r< T > > sc_dt::concat	(	const sc_logic &	a,
		sc_subref_r< T >	b
	)			[inline]

sc_lv_base.h の 1163 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
        *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_subref_r< T >, sc_lv_base > sc_dt::concat	(	sc_subref_r< T >	a,
		const sc_logic &	b
	)			[inline]

sc_lv_base.h の 1154 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template<class T>

sc_concref_r< sc_lv_base, sc_subref_r< T > > sc_dt::concat	(	const char *	a,
		sc_subref_r< T >	b
	)			[inline]

sc_lv_base.h の 1145 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
        *new sc_lv_base( a ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_subref_r< T >, sc_lv_base > sc_dt::concat	(	sc_subref_r< T >	a,
		const char *	b
	)			[inline]

sc_lv_base.h の 1136 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b ), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_subref_r< T1 >, T2 > sc_dt::concat	(	sc_subref_r< T1 >	a,
		const sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 2739 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T1>,T2>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3>

sc_concref_r< sc_subref_r< T1 >, sc_concref_r< T2, T3 > > sc_dt::concat	(	sc_subref_r< T1 >	a,
		sc_concref_r< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 2730 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_subref_r< T1 >, sc_subref_r< T2 > > sc_dt::concat	(	sc_subref_r< T1 >	a,
		sc_subref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2721 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_subref_r< T1 >, sc_bitref_r< T2 > > sc_dt::concat	(	sc_subref_r< T1 >	a,
		sc_bitref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2712 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_bitref< T1 >, T2 > sc_dt::concat	(	sc_bitref< T1 >	a,
		sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 2484 行で定義されています。

{
    return sc_concref<sc_bitref<T1>,T2>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3>

sc_concref< sc_bitref< T1 >, sc_concref< T2, T3 > > sc_dt::concat	(	sc_bitref< T1 >	a,
		sc_concref< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 2475 行で定義されています。

{
    return sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_bitref< T1 >, sc_subref< T2 > > sc_dt::concat	(	sc_bitref< T1 >	a,
		sc_subref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2466 行で定義されています。

{
    return sc_concref<sc_bitref<T1>,sc_subref<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_bitref< T1 >, sc_bitref< T2 > > sc_dt::concat	(	sc_bitref< T1 >	a,
		sc_bitref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2457 行で定義されています。

{
    return sc_concref<sc_bitref<T1>,sc_bitref<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_lv_base, sc_bitref_r< T > > sc_dt::concat	(	bool	a,
		sc_bitref_r< T >	b
	)			[inline]

sc_lv_base.h の 949 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
        *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_bitref_r< T >, sc_lv_base > sc_dt::concat	(	sc_bitref_r< T >	a,
		bool	b
	)			[inline]

sc_lv_base.h の 940 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ) );
}

template<class T>

sc_concref_r< sc_lv_base, sc_bitref_r< T > > sc_dt::concat	(	const sc_logic &	a,
		sc_bitref_r< T >	b
	)			[inline]

sc_lv_base.h の 931 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
        *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_bitref_r< T >, sc_lv_base > sc_dt::concat	(	sc_bitref_r< T >	a,
		const sc_logic &	b
	)			[inline]

sc_lv_base.h の 922 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b, 1 ) );
}

template<class T>

sc_concref_r< sc_lv_base, sc_bitref_r< T > > sc_dt::concat	(	const char *	a,
		sc_bitref_r< T >	b
	)			[inline]

sc_lv_base.h の 913 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
        *new sc_lv_base( a ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_bitref_r< T >, sc_lv_base > sc_dt::concat	(	sc_bitref_r< T >	a,
		const char *	b
	)			[inline]

sc_lv_base.h の 904 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b ), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_bitref_r< T1 >, T2 > sc_dt::concat	(	sc_bitref_r< T1 >	a,
		const sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 2081 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T1>,T2>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3>

sc_concref_r< sc_bitref_r< T1 >, sc_concref_r< T2, T3 > > sc_dt::concat	(	sc_bitref_r< T1 >	a,
		sc_concref_r< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 2072 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_bitref_r< T1 >, sc_subref_r< T2 > > sc_dt::concat	(	sc_bitref_r< T1 >	a,
		sc_subref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2063 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_bitref_r< T1 >, sc_bitref_r< T2 > > sc_dt::concat	(	sc_bitref_r< T1 >	a,
		sc_bitref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2054 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
        *a.clone(), *b.clone(), 3 );
}

small_type sc_dt::convert_signed_2C_to_SM	(	int	nb,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 759 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((nb > 0) && (nd > 0) && (d != NULL));
#endif

  small_type s;

  int xnb = bit_ord(nb - 1) + 1;

  // Test the sign bit.  
  if (d[nd - 1] & one_and_zeros(xnb - 1)) {
    s = SC_NEG;
    vec_complement(nd, d);
  }
  else
    s = SC_POS;

  // Trim the last digit.
  d[nd - 1] &= one_and_ones(xnb);

  // Check if the new number is zero.
  if (s == SC_POS)
    return check_for_zero(s, nd, d);

  return s;

}

void sc_dt::convert_signed_SM_to_2C	(	small_type	s,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 814 行で定義されています。

{
  convert_SM_to_2C(s, nd, d);
}

small_type sc_dt::convert_signed_SM_to_2C_to_SM	(	small_type	s,
		int	nb,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 795 行で定義されています。

{
  convert_SM_to_2C(s, nd, d);
  return convert_signed_2C_to_SM(nb, nd, d);
}

void sc_dt::convert_signed_SM_to_2C_trimmed	(	small_type	s,
		int	nb,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 805 行で定義されています。

{
  convert_SM_to_2C_trimmed(1, s, nb, nd, d);
}

void sc_dt::convert_SM_to_2C	(	small_type	s,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 730 行で定義されています。

{
  if (s == SC_NEG)
    vec_complement(nd, d);
}

void sc_dt::convert_SM_to_2C_trimmed	(	small_type	added,
		small_type	s,
		int	nb,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 717 行で定義されています。

{
  if (s == SC_NEG) {
    vec_complement(nd, d);
    trim(added, nb, nd, d);
  }
}

const std::string sc_dt::convert_to_bin

(

const char *

s

)

sc_bv_base.cpp の 302 行で定義されています。

{
    // Beware: logic character strings cannot start with '0x' or '0X',
    //         because this is seen as a hexadecimal encoding prefix!

    if( s == 0 ) {
        SC_REPORT_ERROR(sc_core::SC_ID_CANNOT_CONVERT_, 
            "character string is zero" );
    }
    if( *s == 0 ) {
        SC_REPORT_ERROR(sc_core::SC_ID_CANNOT_CONVERT_, 
            "character string is empty");
    }

    int n = strlen( s );
    int i = 0;
    if( s[0] == '-' || s[0] == '+' ) {
        ++ i;
    }
    if( n > (i + 2) && s[i] == '0' )
    {
        if (s[i+1] == 'b' || s[i+1] == 'B' )
        {
            if ( s[i+2] == '0' || s[i+2] == '1' )
            {
                std::string str( &s[2] );
                str += "F";
                return str;
            }
        }
        if ( s[i+1] == 'b' || s[i+1] == 'B' ||
             s[i+1] == 'c' || s[i+1] == 'C' ||
             s[i+1] == 'd' || s[i+1] == 'D' ||
             s[i+1] == 'o' || s[i+1] == 'O' ||
             s[i+1] == 'x' || s[i+1] == 'X') 
        {
            try {
                // worst case length = n * 4
                sc_fix a( s, n * 4, n * 4, SC_TRN, SC_WRAP, 0, SC_ON );
                std::string str = a.to_bin();
                str += "F"; // mark the string as formatted
                // get rid of prefix (0b) and redundant leading bits
                const char* p = str.c_str() + 2;
                while( p[1] && p[0] == p[1] ) {
                    ++ p;
                }
                return std::string( p );
            } catch( sc_core::sc_report ) {
                char msg[BUFSIZ];
                std::sprintf( msg, "character string '%s' is not valid", s );
                SC_REPORT_ERROR( sc_core::SC_ID_CANNOT_CONVERT_, msg );
                // never reached
                return std::string();
            }
        }

    }

    // bin by default

    std::string str( s );
    str += "U"; // mark the string as unformatted
    return str;
}

const std::string sc_dt::convert_to_fmt	(	const std::string &	s,
		sc_numrep	numrep,
		bool	w_prefix
	)

sc_bv_base.cpp の 370 行で定義されています。

{
    int n = s.length();
    std::string str("0bus");
    // str += "0bus";
    str += s;
    sc_ufix a( str.c_str(), n, n, SC_TRN, SC_WRAP, 0, SC_ON );
    return a.to_string( numrep, w_prefix );
}

small_type sc_dt::convert_unsigned_2C_to_SM	(	int	nb,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 842 行で定義されています。

{
  trim_unsigned(nb, nd, d);
  return check_for_zero(SC_POS, nd, d);
}

void sc_dt::convert_unsigned_SM_to_2C	(	small_type	s,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 873 行で定義されています。

{
  convert_SM_to_2C(s, nd, d);
}

small_type sc_dt::convert_unsigned_SM_to_2C_to_SM	(	small_type	s,
		int	nb,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 854 行で定義されています。

{
  convert_SM_to_2C(s, nd, d);
  return convert_unsigned_2C_to_SM(nb, nd, d);
}

void sc_dt::convert_unsigned_SM_to_2C_trimmed	(	small_type	s,
		int	nb,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 864 行で定義されています。

{
  convert_SM_to_2C_trimmed(0, s, nb, nd, d);
}

void sc_dt::copy_digits_signed	(	small_type &	us,
		int	unb,
		int	und,
		sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)			[inline]

sc_nbutils.h の 886 行で定義されています。

{

  if (und <= vnd) {

    vec_copy(und, ud, vd);

    if (unb <= vnb)
      us = convert_signed_SM_to_2C_to_SM(us, unb, und, ud);

  }
  else // und > vnd
    vec_copy_and_zero(und, ud, vnd, vd);

}

void sc_dt::copy_digits_unsigned	(	small_type &	us,
		int	unb,
		int	und,
		sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)			[inline]

sc_nbutils.h の 907 行で定義されています。

{

  if (und <= vnd)
    vec_copy(und, ud, vd);

  else // und > vnd
    vec_copy_and_zero(und, ud, vnd, vd);

  us = convert_unsigned_SM_to_2C_to_SM(us, unb, und, ud);

}

uint64 const sc_uint_base& sc_dt::DEFN_BIN_OP_T	(	/	,
		div	,
		const sc_signed &
	)			const

Type Constraints

uint64 sc_dt::DEFN_BIN_OP_T	(	/	,
		div	,
		const sc_int_base &
	)

Type Constraints

sc_dt::DEFN_BIN_OP_T	(	/	,
		div	,
		int64
	)

int sc_dt::digit_ord

(

int

i

)

[inline]

sc_nbutils.h の 336 行で定義されています。

{
  return (i / BITS_PER_DIGIT);
}

template<class Type>

void sc_dt::div_by_zero

(

Type

s

)

[inline]

sc_nbutils.h の 633 行で定義されています。

{
  if (s == 0) {
      SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_,
                       "div_by_zero<Type>( Type ) : division by zero" );
  }
}

CLASS_TYPE sc_dt::DIV_HELPER	(	small_type	s,
		int	unb,
		int	und,
		const sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_signed.cpp の 4259 行で定義されています。

void sc_dt::div_on_help_signed	(	small_type &	us,
		int	unb,
		int	und,
		sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_nbexterns.cpp の 279 行で定義されています。

{
#define CONVERT_SM_to_2C_to_SM convert_signed_SM_to_2C_to_SM
#define COPY_DIGITS copy_digits_signed

  {  // Body of div_on_help

    int old_und = und;
    
    und = vec_skip_leading_zeros(und, ud);
    vnd = vec_skip_leading_zeros(vnd, vd);
    
    int cmp_res = vec_cmp(und, ud, vnd, vd);
    
    if (cmp_res < 0) { // u < v => u / v = 0 - case 4
      us = SC_ZERO;
      vec_zero(old_und, ud);
      return;
    }
    
    sc_digit vd0 = (*vd);
    
    if ((cmp_res > 0) && (vnd == 1) && (vd0 == 1))  {
      us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
      return;
    }
    
    // One extra digit for d is allocated to simplify vec_div_*().
    int nd = sc_max(und, vnd) + 1;
    
#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS + 1];
#else
    sc_digit *d = new sc_digit[nd];
#endif
    
    vec_zero(nd, d);
    
    // u = v => u / v = 1 - case 3
    if (cmp_res == 0)
      d[0] = 1;
    
    else if ((vnd == 1) && (und == 1))
      d[0] = (*ud) / vd0;
    
    else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
      vec_div_small(und, ud, vd0, d);
    
    else
      vec_div_large(und, ud, vnd, vd, d);
    
    COPY_DIGITS(us, unb, old_und, ud, sc_max(unb, vnb), nd - 1, d);
    
#ifndef SC_MAX_NBITS
    delete [] d;
#endif
    
  }
  
#undef COPY_DIGITS
#undef CONVERT_SM_to_2C_to_SM

}

void sc_dt::div_on_help_unsigned	(	small_type &	us,
		int	unb,
		int	und,
		sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_nbexterns.cpp の 349 行で定義されています。

{
#define CONVERT_SM_to_2C_to_SM convert_unsigned_SM_to_2C_to_SM
#define COPY_DIGITS copy_digits_unsigned

  {  // Body of div_on_help

    int old_und = und;
    
    und = vec_skip_leading_zeros(und, ud);
    vnd = vec_skip_leading_zeros(vnd, vd);
    
    int cmp_res = vec_cmp(und, ud, vnd, vd);
    
    if (cmp_res < 0) { // u < v => u / v = 0 - case 4
      us = SC_ZERO;
      vec_zero(old_und, ud);
      return;
    }
    
    sc_digit vd0 = (*vd);
    
    if ((cmp_res > 0) && (vnd == 1) && (vd0 == 1))  {
      us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
      return;
    }
    
    // One extra digit for d is allocated to simplify vec_div_*().
    int nd = sc_max(und, vnd) + 1;
    
#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS + 1];
#else
    sc_digit *d = new sc_digit[nd];
#endif
    
    vec_zero(nd, d);
    
    // u = v => u / v = 1 - case 3
    if (cmp_res == 0)
      d[0] = 1;
    
    else if ((vnd == 1) && (und == 1))
      d[0] = (*ud) / vd0;
    
    else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
      vec_div_small(und, ud, vd0, d);
    
    else
      vec_div_large(und, ud, vnd, vd, d);
    
    COPY_DIGITS(us, unb, old_und, ud, sc_max(unb, vnb), nd - 1, d);
    
#ifndef SC_MAX_NBITS
    delete [] d;
#endif
    
  }
  
#undef COPY_DIGITS
#undef CONVERT_SM_to_2C_to_SM

}

scfx_rep * sc_dt::div_scfx_rep	(	const scfx_rep &	lhs,
		const scfx_rep &	rhs,
		int	div_wl
	)

scfx_rep.cpp の 1598 行で定義されています。

{
    scfx_rep& result = *new scfx_rep;

    //
    // check for special cases
    //

    if( lhs.is_nan() || rhs.is_nan() || lhs.is_inf() && rhs.is_inf() ||
        lhs.is_zero() && rhs.is_zero() )
    {
        result.set_nan();
        return &result;
    }

    if( lhs.is_inf() || rhs.is_zero() )
    {
        result.set_inf( lhs.m_sign * rhs.m_sign );
        return &result;
    }

    if( lhs.is_zero() || rhs.is_inf() )
    {
        result.set_zero( lhs.m_sign * rhs.m_sign );
        return &result;
    }

    //
    // do it
    //

    // compute one bit more for rounding
    div_wl ++;

    result.resize_to( sc_max( n_word( div_wl ) + 1, min_mant ) );
    result.m_mant.clear();
    result.m_sign = lhs.m_sign * rhs.m_sign;

    int msb_lhs = scfx_find_msb( lhs.m_mant[lhs.m_msw] )
                + ( lhs.m_msw - lhs.m_wp ) * bits_in_word;
    int msb_rhs = scfx_find_msb( rhs.m_mant[rhs.m_msw] )
                + ( rhs.m_msw - rhs.m_wp ) * bits_in_word;

    int msb_res = msb_lhs - msb_rhs;
    int to_shift = -msb_res % bits_in_word;
    int result_index;

    int c = ( msb_res % bits_in_word >= 0 ) ? 1 : 0;

    result_index = (result.size() - c) * bits_in_word + msb_res % bits_in_word;
    result.m_wp   = (result.size() - c) - msb_res / bits_in_word;

    scfx_rep remainder = lhs;

    // align msb from remainder to msb from rhs
    remainder.lshift( to_shift );

    // make sure msw( remainder ) < size - 1
    if( remainder.m_msw == remainder.size() - 1 )
        remainder.resize_to( remainder.size() + 1, 1 );

    // make sure msw( remainder ) >= msw( rhs )!
    int msw_diff = rhs.m_msw - remainder.m_msw;
    if (msw_diff > 0)
        remainder.resize_to( remainder.size() + msw_diff, -1 );

    int counter;

    for( counter = div_wl; counter && ! remainder.is_zero(); counter -- )
    {
        if( compare_msw_ff( rhs, remainder ) <= 0 )
        {
            result.set_bin( result_index );
            sub_with_index( remainder.m_mant, remainder.m_msw, remainder.m_lsw,
                            rhs.m_mant, rhs.m_msw, rhs.m_lsw );
        }
        result_index --;
        remainder.shift_left( 1 );
        remainder.m_lsw = remainder.find_lsw();
    }

    // perform convergent rounding, if needed
    if( counter == 0 )
    {
        int index = result_index + 1 - result.m_wp * bits_in_word;

        scfx_index x = result.calc_indices( index );
        scfx_index x1 = result.calc_indices( index + 1 );

        if( result.o_bit_at( x ) && result.o_bit_at( x1 ) )
            result.q_incr( x );

        result.m_r_flag = true;
    }

    result.find_sw();

    return &result;
}

sc_signed sc_dt::div_signed_friend	(	small_type	s,
		int	unb,
		int	und,
		const sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_unsigned sc_dt::div_unsigned_friend	(	small_type	s,
		int	unb,
		int	und,
		const sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

bool sc_dt::equal	(	char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 451 行で定義されています。

        { return ( a == b ); }

bool sc_dt::equal	(	bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 448 行で定義されています。

        { return ( a == b ); }

bool sc_dt::equal	(	int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 445 行で定義されています。

        { return ( a == b ); }

bool sc_dt::equal	(	const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 442 行で定義されています。

        { return ( a == b ); }

bool sc_dt::equal	(	const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 439 行で定義されています。

        { return ( a == b ); }

bool sc_dt::equal	(	const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 436 行で定義されています。

        { return ( a == b ); }

bool sc_dt::equal	(	const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 433 行で定義されています。

        { return ( a == b ); }

template<class X>

void sc_dt::extend_sign_w_	(	X &	x,
		int	wi,
		bool	sign
	)			[inline]

sc_proxy.h の 654 行で定義されています。

{
    int sz = x.size();
    unsigned int sgn = (sign ? ~SC_DIGIT_ZERO : SC_DIGIT_ZERO);
    for( int i = wi; i < sz; ++ i ) {
        set_words_( x, i, sgn, SC_DIGIT_ZERO );
    }
}

template<class Type>

void sc_dt::from_uint	(	int	ulen,
		sc_digit *	u,
		Type	v
	)			[inline]

sc_nbutils.h の 546 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  // assert((ulen <= 0) || (u != NULL));
  assert((ulen > 0) && (u != NULL));
  assert(v >= 0);
#endif

  register int i = 0;

  while (v && (i < ulen)) {
#ifndef WIN32
    u[i++] = static_cast<sc_digit>( v & DIGIT_MASK );
#else
    u[i++] = ((sc_digit) v) & DIGIT_MASK;
#endif
    v >>= BITS_PER_DIGIT;
  }

  vec_zero(i, ulen, u);

}

small_type sc_dt::fsm_move	(	char	c,
		small_type &	b,
		small_type &	s,
		small_type &	state
	)

sc_nbutils.cpp の 65 行で定義されています。

{

  // Possible regular expressions (REs):
  // Let N = any digit depending on the base.
  //    1. [0|1|..|9]N*
  //    2. [+|-][0|1|..|9]N*
  //    3. 0[b|B|d|D|o|O|x|X][0|1|..|F]N*
  //    4. [+|-]?0[b|B|d|D|o|O|x|X][0|1|..|F]N*
  //
  // The finite state machine (FMS) to parse these regular expressions
  // has 4 states, 0 to 3. 0 is the initial state and 3 is the final
  // state.
  //
  // Default sign = SC_POS, default base = NB_DEFAULT_BASE.

  switch (state) {

  case 0: // The initial state.
    switch (c) { 
    case '0': s = SC_POS; state = 1; return 0; // RE 1 or 3
    case '+': s = SC_POS; state = 2; return 1; // RE 2
    case '-': s = SC_NEG; state = 2; return 1; // RE 2
    default:  s = SC_POS; b = NB_DEFAULT_BASE; state = 3; return 0; // RE 1
    }
    // break; //unreachable code
  case 1: // 0...
    switch (c) {
    case 'x': case 'X': b = SC_HEX; state = 3; return 2; // RE 3 or 4
    case 'd': case 'D': b = SC_DEC; state = 3; return 2; // RE 3 or 4
    case 'o': case 'O': b = SC_OCT; state = 3; return 2; // RE 3 or 4
    case 'b': case 'B': b = SC_BIN; state = 3; return 2; // RE 3 or 4
    default:  b = NB_DEFAULT_BASE; state = 3; return 0; // RE 1
    }
    // break; //unreachable code
  case 2: // +... or -...
    switch (c) {
    case '0': state = 1; return 0; // RE 2 or 4
    default:  b = NB_DEFAULT_BASE; state = 3; return 0; // RE 2
    }
    // break; //unreachable code
  case 3: // The final state.
    break;

  default:
    // Any other state is not possible.
    assert((0 <= state) && (state <= 3));

  } // switch

  return 0;

}  

const char * sc_dt::get_base_and_sign	(	const char *	v,
		small_type &	b,
		small_type &	s
	)

sc_nbutils.cpp の 125 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert(v != NULL);
#endif

  const small_type STATE_START = 0;
  const small_type STATE_FINISH = 3;

  // Default sign = SC_POS, default base = 10.
  s = SC_POS;
  b = NB_DEFAULT_BASE;

  small_type state = STATE_START;
  small_type nskip = 0; // Skip that many chars.
  const char *u = v;

  while (*u) {
    if (isspace(*u))  // Skip white space.
      ++u;
    else {
      nskip += fsm_move(*u, b, s, state);
      if (state == STATE_FINISH)
        break;
      else
        ++u;
    }
  }

#ifdef DEBUG_SYSTEMC
  // Test to see if the above loop executed more than it should
  // have. The max number of skipped chars is equal to the length of
  // the longest format specifier, e.g., "-0x".
  assert(nskip <= 3);
#endif

  v += nskip;

  // Handles empty strings or strings without any digits after the
  // base or base and sign specifier.
  if (*v == '\0') { 
      char msg[BUFSIZ];
      std::sprintf( msg,
               "get_base_and_sign( const char* v, small_type&, small_type& ) : "
               "v = \"\" is not valid" );
      SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
  }

  return v;

}

template<class Type>

small_type sc_dt::get_sign

(

Type &

u

)

[inline]

sc_nbutils.h の 576 行で定義されています。

{
  if (u > 0)
    return SC_POS;

  else if (u == 0)
    return SC_ZERO;

  else {
    u = -u;
    return SC_NEG;
  }
}

template<class X>

void sc_dt::get_words_	(	const X &	x,
		int	wi,
		sc_digit &	x_dw,
		sc_digit &	x_cw
	)			[inline]

sc_proxy.h の 636 行で定義されています。

{
    x_dw = x.get_word( wi );
    x_cw = x.get_cword( wi );
}

sc_digit sc_dt::high_half

(

sc_digit

d

)

[inline]

sc_nbutils.h の 293 行で定義されています。

{
  return (d >> BITS_PER_HALF_DIGIT);
}

sc_digit sc_dt::high_half_masked

(

sc_digit

d

)

[inline]

sc_nbutils.h の 300 行で定義されています。

{
  return (high_half(d) & HALF_DIGIT_MASK);
}

void sc_dt::inc

(

scfx_mant &

mant

)

[inline]

scfx_mant.h の 356 行で定義されています。

{
    for( int i = 0; i < mant.size(); i ++ )
    {
        if( ++ mant[i] )
        {
            break;
        }
    }
}

void sc_dt::is_bad_double

(

double

v

)

[inline]

sc_nbutils.h の 954 行で定義されています。

{
// Windows throws exception.
#if !defined(WIN32) && !defined(i386) && !defined(__x86_64__) && !defined( __EDG__ )
#if defined( __hpux ) && defined( isfinite )
  // HP-UX 11.00 does not have finite anymore
  if( ! isfinite( v ) ) {
#else
  if (! finite(v)) {
#endif
      SC_REPORT_ERROR( sc_core::SC_ID_VALUE_NOT_VALID_,
                       "is_bad_double( double v ) : "
                       "v is not finite - NaN or Inf" );
  }
#endif
}

void sc_dt::is_valid_base

(

sc_numrep

base

)

[inline]

sc_nbutils.h の 68 行で定義されています。

{
  switch (base) {
    case SC_NOBASE: case SC_BIN: 
    case SC_OCT: case SC_DEC: 
    case SC_HEX: 
        break;
    case SC_BIN_US: case SC_BIN_SM: 
    case SC_OCT_US: case SC_OCT_SM:
    case SC_HEX_US: case SC_HEX_SM:
      SC_REPORT_ERROR( sc_core::SC_ID_NOT_IMPLEMENTED_,
                       "is_valid_base( sc_numrep base ) : "
                       "base ending in _US and _SM is not supported yet" );
    default:
      char msg[BUFSIZ];
      std::sprintf( msg, "is_valid_base( sc_numrep base ) : "
               "base = %s is not valid",
               to_string( base ).c_str() );
      SC_REPORT_ERROR( sc_core::SC_ID_VALUE_NOT_VALID_, msg );
  }
}

sc_digit sc_dt::low_half

(

sc_digit

d

)

[inline]

sc_nbutils.h の 281 行で定義されています。

{
  return (d & HALF_DIGIT_MASK);
}

template<class X>

const sc_lv_base sc_dt::lrotate	(	const sc_proxy< X > &	x,
		int	n
	)			[inline]

sc_lv_base.h の 726 行で定義されています。

{
    sc_lv_base a( x.back_cast() );
    return a.lrotate( n );
}

scfx_rep * sc_dt::lsh_scfx_rep	(	const scfx_rep &	a,
		int	b
	)			[inline]

scfx_rep.h の 377 行で定義されています。

{
    scfx_rep& c = *new scfx_rep( a );
    c.lshift( b );
    return &c;
}

void sc_dt::lshift	(	sc_fxval_fast &	c,
		const sc_fxval_fast &	a,
		int	b
	)			[inline]

sc_fxval.h の 1836 行で定義されています。

{
    SC_FXVAL_FAST_OBSERVER_READ_( a )
    c.m_val = a.m_val * scfx_pow2( b );
    SC_FXVAL_FAST_OBSERVER_WRITE_( c )
}

void sc_dt::lshift	(	sc_fxnum_fast &	c,
		const sc_fxnum_fast &	a,
		int	b
	)			[inline]

sc_fxnum.h の 4086 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    c.m_val = a.m_val * scfx_pow2( b );
    c.cast();
    SC_FXNUM_FAST_OBSERVER_WRITE_( c )
}

void sc_dt::lshift	(	sc_fxval_fast &	c,
		const sc_fxnum_fast &	a,
		int	b
	)			[inline]

sc_fxnum.h の 4070 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    c.set_val( a.m_val * scfx_pow2( b ) );
}

void sc_dt::lshift	(	sc_fxnum &	c,
		const sc_fxnum &	a,
		int	b
	)			[inline]

sc_fxnum.h の 2974 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    delete c.m_rep;
    c.m_rep = sc_dt::lsh_scfx_rep( *a.m_rep, b );
    c.cast();
    SC_FXNUM_OBSERVER_WRITE_( c )
}

void sc_dt::lshift	(	sc_fxval &	c,
		const sc_fxnum &	a,
		int	b
	)			[inline]

sc_fxnum.h の 2958 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    c.set_rep( sc_dt::lsh_scfx_rep( *a.m_rep, b ) );
}

sc_dt::m_observer

(

observer_

)

sc_fxval.h の 1552 行で定義されています。

{
    SC_FXVAL_FAST_OBSERVER_DEFAULT_
    SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this )
}

small_type sc_dt::make_zero	(	int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 686 行で定義されています。

{
  vec_zero(nd, d);
  return SC_ZERO;
}

CLASS_TYPE sc_dt::MOD_HELPER	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_signed.cpp の 4317 行で定義されています。

void sc_dt::mod_on_help_signed	(	small_type &	us,
		int	unb,
		int	und,
		sc_digit *	ud,
		int	,
		int	vnd,
		const sc_digit *	vd
	)

sc_nbexterns.cpp の 423 行で定義されています。

{

#define COPY_DIGITS copy_digits_signed

  { // Body of mod_on_help

    int old_und = und;
    
    und = vec_skip_leading_zeros(und, ud);
    vnd = vec_skip_leading_zeros(vnd, vd);
    
    int cmp_res = vec_cmp(und, ud, vnd, vd);
    
    // u < v => u % v = u - case 4
    if (cmp_res < 0) 
      return;
    
    // u = v => u % v = 0 - case 3
    if (cmp_res == 0) { 
      us = SC_ZERO;
      vec_zero(old_und, ud);
      return;
    }
    
    // else if u > v - case 5
    
    sc_digit vd0 = (*vd);
    
    if ((vnd == 1) && (vd0 == 1)) {
      us = SC_ZERO;
      vec_zero(old_und, ud);
      return;
    }
    
    // One extra digit for d is allocated to simplify vec_div_*().
    int nd = sc_max(und, vnd) + 1;
    
#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS + 1];
#else
    sc_digit *d = new sc_digit[nd];
#endif
    
    vec_zero(nd, d);
    
    if ((vnd == 1) && (und == 1))
      d[0] = (*ud) % vd0;
    
    if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
      d[0] = vec_rem_small(und, ud, vd0);
    
    else
      vec_rem_large(und, ud, vnd, vd, d);
    
    us = check_for_zero(us, nd - 1, d);
    
    if (us == SC_ZERO)
      vec_zero(old_und, ud);
    else
      COPY_DIGITS(us, unb, old_und, ud, sc_min(unb, vnd), nd - 1, d);
    
#ifndef SC_MAX_NBITS
    delete [] d;
#endif
    
  }
  
#undef COPY_DIGITS
  
}

void sc_dt::mod_on_help_unsigned	(	small_type &	us,
		int	unb,
		int	und,
		sc_digit *	ud,
		int	,
		int	vnd,
		const sc_digit *	vd
	)

sc_nbexterns.cpp の 501 行で定義されています。

{

#define COPY_DIGITS copy_digits_unsigned

  { // Body of mod_on_help

    int old_und = und;
    
    und = vec_skip_leading_zeros(und, ud);
    vnd = vec_skip_leading_zeros(vnd, vd);
    
    int cmp_res = vec_cmp(und, ud, vnd, vd);
    
    // u < v => u % v = u - case 4
    if (cmp_res < 0) 
      return;
    
    // u = v => u % v = 0 - case 3
    if (cmp_res == 0) { 
      us = SC_ZERO;
      vec_zero(old_und, ud);
      return;
    }
    
    // else if u > v - case 5
    
    sc_digit vd0 = (*vd);
    
    if ((vnd == 1) && (vd0 == 1)) {
      us = SC_ZERO;
      vec_zero(old_und, ud);
      return;
    }
    
    // One extra digit for d is allocated to simplify vec_div_*().
    int nd = sc_max(und, vnd) + 1;
    
#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS + 1];
#else
    sc_digit *d = new sc_digit[nd];
#endif
    
    vec_zero(nd, d);
    
    if ((vnd == 1) && (und == 1))
      d[0] = (*ud) % vd0;
    
    if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
      d[0] = vec_rem_small(und, ud, vd0);
    
    else
      vec_rem_large(und, ud, vnd, vd, d);
    
    us = check_for_zero(us, nd - 1, d);
    
    if (us == SC_ZERO)
      vec_zero(old_und, ud);
    else
      COPY_DIGITS(us, unb, old_und, ud, sc_min(unb, vnd), nd - 1, d);
    
#ifndef SC_MAX_NBITS
    delete [] d;
#endif
    
  }
  
#undef COPY_DIGITS
  
}

sc_signed sc_dt::mod_signed_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_unsigned sc_dt::mod_unsigned_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

CLASS_TYPE sc_dt::MUL_HELPER	(	small_type	s,
		int	unb,
		int	und,
		const sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_signed.cpp の 4201 行で定義されています。

void sc_dt::mul_on_help_signed	(	small_type &	us,
		int	unb,
		int	und,
		sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_nbexterns.cpp の 125 行で定義されています。

{
#define CONVERT_SM_to_2C_to_SM convert_signed_SM_to_2C_to_SM
#define COPY_DIGITS copy_digits_signed

  {  // Body of mul_on_help

    int old_und = und;

    und = vec_skip_leading_zeros(und, ud);
    vnd = vec_skip_leading_zeros(vnd, vd);
    
    sc_digit ud0 = (*ud);
    sc_digit vd0 = (*vd);
    
    if ((vnd == 1) && (vd0 == 1)) {
      us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
      return;
    }
    
    if ((und == 1) && (ud0 == 1)) {
      COPY_DIGITS(us, unb, old_und, ud, vnb, vnd, vd);
      return;
    }
    
    if ((und == 1) && (vnd == 1) && 
        (ud0 < HALF_DIGIT_RADIX) && (vd0 < HALF_DIGIT_RADIX)) {
      
      sc_digit d = ud0 * vd0;
      COPY_DIGITS(us, unb, old_und, ud, unb + vnb, 1, &d);
      return;
      
    }
    
    int nd = und + vnd;
    
#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS];
#else
    sc_digit *d = new sc_digit[nd];
#endif
  
    vec_zero(nd, d);
    
    if ((und == 1) && (ud0 < HALF_DIGIT_RADIX))
      vec_mul_small(vnd, vd, ud0, d);
    
    else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
      vec_mul_small(und, ud, vd0, d);
    
    else if (vnd < und)
      vec_mul(und, ud, vnd, vd, d);
    
    else
      vec_mul(vnd, vd, und, ud, d);
    
    COPY_DIGITS(us, unb, old_und, ud, unb + vnb, nd, d);
    
#ifndef SC_MAX_NBITS
    delete [] d;
#endif
    
  }

#undef COPY_DIGITS
#undef CONVERT_SM_to_2C_to_SM

}

void sc_dt::mul_on_help_unsigned	(	small_type &	us,
		int	unb,
		int	und,
		sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_nbexterns.cpp の 200 行で定義されています。

{
#define CONVERT_SM_to_2C_to_SM convert_unsigned_SM_to_2C_to_SM
#define COPY_DIGITS copy_digits_unsigned

  {  // Body of mul_on_help

    int old_und = und;

    und = vec_skip_leading_zeros(und, ud);
    vnd = vec_skip_leading_zeros(vnd, vd);
    
    sc_digit ud0 = (*ud);
    sc_digit vd0 = (*vd);
    
    if ((vnd == 1) && (vd0 == 1)) {
      us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
      return;
    }
    
    if ((und == 1) && (ud0 == 1)) {
      COPY_DIGITS(us, unb, old_und, ud, vnb, vnd, vd);
      return;
    }
    
    if ((und == 1) && (vnd == 1) && 
        (ud0 < HALF_DIGIT_RADIX) && (vd0 < HALF_DIGIT_RADIX)) {
      
      sc_digit d = ud0 * vd0;
      COPY_DIGITS(us, unb, old_und, ud, unb + vnb, 1, &d);
      return;
      
    }
    
    int nd = und + vnd;
    
#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS];
#else
    sc_digit *d = new sc_digit[nd];
#endif
  
    vec_zero(nd, d);
    
    if ((und == 1) && (ud0 < HALF_DIGIT_RADIX))
      vec_mul_small(vnd, vd, ud0, d);
    
    else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
      vec_mul_small(und, ud, vd0, d);
    
    else if (vnd < und)
      vec_mul(und, ud, vnd, vd, d);
    
    else
      vec_mul(vnd, vd, und, ud, d);
    
    COPY_DIGITS(us, unb, old_und, ud, unb + vnb, nd, d);
    
#ifndef SC_MAX_NBITS
    delete [] d;
#endif
    
  }

#undef COPY_DIGITS
#undef CONVERT_SM_to_2C_to_SM

}

sc_signed sc_dt::mul_signed_friend	(	small_type	s,
		int	unb,
		int	und,
		const sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

small_type sc_dt::mul_signs	(	small_type	us,
		small_type	vs
	)			[inline]

sc_nbutils.h の 597 行で定義されています。

{
  if ((us == SC_ZERO) || (vs == SC_ZERO))
    return SC_ZERO;

  if (us == vs)
    return SC_POS;

  return SC_NEG;
}

sc_unsigned sc_dt::mul_unsigned_friend	(	small_type	s,
		int	unb,
		int	und,
		const sc_digit *	ud,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

scfx_rep * sc_dt::mult_scfx_rep	(	const scfx_rep &	a,
		const scfx_rep &	b,
		int	max_wl = SC_DEFAULT_MAX_WL_
	)			[inline]

scfx_rep.h の 368 行で定義されています。

{
    scfx_rep& c = *new scfx_rep;
    sc_dt::multiply( c, a, b, max_wl );
    return &c;
}

void sc_dt::multiply	(	scfx_rep &	result,
		const scfx_rep &	lhs,
		const scfx_rep &	rhs,
		int	max_wl
	)

scfx_rep.cpp の 1517 行で定義されています。

{
    //
    // check for special cases
    //

    if( lhs.is_nan() || rhs.is_nan()
    ||  lhs.is_inf() && rhs.is_zero()
    ||  lhs.is_zero() && rhs.is_inf() )
    {
        result.set_nan();
        return;
    }

    if( lhs.is_inf() || rhs.is_inf() )
    {
        result.set_inf( lhs.m_sign * rhs.m_sign );
        return;
    }
    
    if( lhs.is_zero() || rhs.is_zero() ) {
        result.set_zero( lhs.m_sign * rhs.m_sign );
        return;
    }

    //
    // do it
    //

    int len_lhs = lhs.m_msw - lhs.m_lsw + 1;
    int len_rhs = rhs.m_msw - rhs.m_lsw + 1;

    int new_size = sc_max( min_mant, len_lhs + len_rhs );
    int new_wp   = ( lhs.m_wp - lhs.m_lsw ) + ( rhs.m_wp - rhs.m_lsw );
    int new_sign = lhs.m_sign * rhs.m_sign;

    result.resize_to( new_size );
    result.m_mant.clear();
    result.m_wp    = new_wp;
    result.m_sign  = new_sign;
    result.m_state = scfx_rep::normal;

    half_word *s1 = lhs.m_mant.half_addr( lhs.m_lsw );
    half_word *s2 = rhs.m_mant.half_addr( rhs.m_lsw );

    half_word *t = result.m_mant.half_addr();

    len_lhs <<= 1;
    len_rhs <<= 1;

    int i1, i2;

    for( i1 = 0; i1 * half_word_incr < len_lhs; i1 += half_word_incr )
    {
        register word_short ls;
        ls.l = 0;

        half_word v1 = s1[i1];

        for( i2  = 0; i2 * half_word_incr < len_rhs; i2 += half_word_incr )
        {
            ls.l  += v1 * s2[i2];
            ls.s.l = ls.s.u + ( ( t[i2] += ls.s.l ) < ls.s.l );
            ls.s.u = 0;
        }

        t[i2] = ls.s.l;
        t += half_word_incr;
    }

    result.find_sw();
    result.round( max_wl );
}

static int sc_dt::n_word

(

int

x

)

[inline, static]

scfx_rep.cpp の 73 行で定義されています。

{
    return ( x + bits_in_word - 1 ) / bits_in_word;
}

bool sc_dt::nand_reduce

(

const sc_concatref &

a

)

[inline]

sc_concatref.h の 444 行で定義されています。

{
    return a.nand_reduce();
}

bool sc_dt::nand_reduce

(

const sc_uint_base &

a

)

[inline]

sc_uint_base.h の 1283 行で定義されています。

{
    return a.nand_reduce();
}

bool sc_dt::nand_reduce

(

const sc_uint_subref_r &

a

)

[inline]

sc_uint_base.h の 1100 行で定義されています。

{
    return a.nand_reduce();
}

bool sc_dt::nand_reduce

(

const sc_int_base &

a

)

[inline]

sc_int_base.h の 1312 行で定義されています。

{
    return a.nand_reduce();
}

bool sc_dt::nand_reduce

(

const sc_int_subref_r &

a

)

[inline]

sc_int_base.h の 1129 行で定義されています。

{
    return a.nand_reduce();
}

template<class X>

sc_logic_value_t sc_dt::nand_reduce

(

const sc_proxy< X > &

a

)

[inline]

sc_proxy.h の 1467 行で定義されています。

{
    return a.nand_reduce();
}

void sc_dt::neg	(	sc_fxval_fast &	c,
		const sc_fxval_fast &	a
	)			[inline]

sc_fxval.h の 1659 行で定義されています。

{
    SC_FXVAL_FAST_OBSERVER_READ_( a )
    c.m_val = - a.m_val;
    SC_FXVAL_FAST_OBSERVER_WRITE_( c )
}

void sc_dt::neg	(	sc_fxval &	c,
		const sc_fxval &	a
	)			[inline]

sc_fxval.h の 904 行で定義されています。

{
    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 )
}

void sc_dt::neg	(	sc_fxnum_fast &	c,
		const sc_fxnum_fast &	a
	)			[inline]

sc_fxnum.h の 3793 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    c.m_val = - a.m_val;
    c.cast();
    SC_FXNUM_FAST_OBSERVER_WRITE_( c )
}

void sc_dt::neg	(	sc_fxval_fast &	c,
		const sc_fxnum_fast &	a
	)			[inline]

sc_fxnum.h の 3785 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    c.set_val( - a.m_val );
}

void sc_dt::neg	(	sc_fxnum &	c,
		const sc_fxnum &	a
	)			[inline]

sc_fxnum.h の 2670 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    delete c.m_rep;
    c.m_rep = sc_dt::neg_scfx_rep( *a.m_rep );
    c.cast();
    SC_FXNUM_OBSERVER_WRITE_( c )
}

void sc_dt::neg	(	sc_fxval &	c,
		const sc_fxnum &	a
	)			[inline]

sc_fxnum.h の 2662 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    c.set_rep( sc_dt::neg_scfx_rep( *a.m_rep ) );
}

scfx_rep * sc_dt::neg_scfx_rep

(

const scfx_rep &

a

)

[inline]

scfx_rep.h の 359 行で定義されています。

{
    scfx_rep& c = *new scfx_rep( a );
    c.m_sign = - c.m_sign;
    return &c;
}

static int sc_dt::next_pow2_index

(

std::size_t

size

)

[inline, static]

scfx_mant.cpp の 64 行で定義されています。

{
    int index = scfx_find_msb( size );
    // If this was a power of 2 we are one bucket too low.
    if( ~ (1 << index) & size ) index ++;
    // If this is a 64-bit machine and we are using 32-bit words go down
        // one slot size, as all the slots are 2x in size.
    if ( index != 0 && ( sizeof(word_list) != sizeof(word) ) ) 
        {
                index -= 1;
        }
    return index;
}

bool sc_dt::nor_reduce

(

const sc_concatref &

a

)

[inline]

sc_concatref.h の 458 行で定義されています。

{
    return a.nor_reduce();
}

bool sc_dt::nor_reduce

(

const sc_uint_base &

a

)

[inline]

sc_uint_base.h の 1297 行で定義されています。

{
    return a.nor_reduce();
}

bool sc_dt::nor_reduce

(

const sc_uint_subref_r &

a

)

[inline]

sc_uint_base.h の 1114 行で定義されています。

{
    return a.nor_reduce();
}

bool sc_dt::nor_reduce

(

const sc_int_base &

a

)

[inline]

sc_int_base.h の 1326 行で定義されています。

{
    return a.nor_reduce();
}

bool sc_dt::nor_reduce

(

const sc_int_subref_r &

a

)

[inline]

sc_int_base.h の 1143 行で定義されています。

{
    return a.nor_reduce();
}

template<class X>

sc_logic_value_t sc_dt::nor_reduce

(

const sc_proxy< X > &

a

)

[inline]

sc_proxy.h の 1483 行で定義されています。

{
    return a.nor_reduce();
}

bool sc_dt::not_equal	(	char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 497 行で定義されています。

        { return ( a != b ); }

bool sc_dt::not_equal	(	bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 494 行で定義されています。

        { return ( a != b ); }

bool sc_dt::not_equal	(	int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 491 行で定義されています。

        { return ( a != b ); }

bool sc_dt::not_equal	(	const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 488 行で定義されています。

        { return ( a != b ); }

bool sc_dt::not_equal	(	const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 485 行で定義されています。

        { return ( a != b ); }

bool sc_dt::not_equal	(	const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 482 行で定義されています。

        { return ( a != b ); }

bool sc_dt::not_equal	(	const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 479 行で定義されています。

        { return ( a != b ); }

sc_digit sc_dt::one_and_ones

(

int

n

)

[inline]

sc_nbutils.h の 317 行で定義されています。

{
  return (((sc_digit) 1 << n) - 1);
}

sc_digit sc_dt::one_and_zeros

(

int

n

)

[inline]

sc_nbutils.h の 325 行で定義されています。

{
  return ((sc_digit) 1 << n);
}

sc_unsigned sc_dt::operator &	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1500 行で定義されています。

    { return operator&((unsigned long) u,  v); }

sc_unsigned sc_dt::operator &	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1492 行で定義されています。

    { return operator&(u, (unsigned long) v); }

sc_unsigned sc_dt::operator &	(	unsigned long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1328 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
    return sc_unsigned();

  CONVERT_LONG(u);

  // other cases
  return and_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                             v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator &	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned.cpp の 1312 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
    return sc_unsigned();

  CONVERT_LONG(v);

  // other cases
  return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_unsigned sc_dt::operator &	(	uint64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1296 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
    return sc_unsigned();

  CONVERT_INT64(u);

  // other cases
  return and_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                             v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator &	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned.cpp の 1280 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
    return sc_unsigned();

  CONVERT_INT64(v);

  // other cases
  return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
  
}

sc_unsigned sc_dt::operator &	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1266 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
    return sc_unsigned();

  // other cases
  return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator &	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 677 行で定義されています。

{ return operator&((uint64) u, v); }

sc_unsigned sc_dt::operator &	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 674 行で定義されています。

{ return operator&(u, (uint64) v); }

sc_signed sc_dt::operator &	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1697 行で定義されています。

    { return operator&((unsigned long) u, v); }

sc_signed sc_dt::operator &	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1695 行で定義されています。

    { return operator&((long) u, v); }

sc_signed sc_dt::operator &	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1688 行で定義されています。

    { return operator&(u, (unsigned long) v); }

sc_signed sc_dt::operator &	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1686 行で定義されています。

    { return operator&(u, (long) v); }

sc_signed sc_dt::operator &	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_signed.h の 1678 行で定義されています。

    { return operator&((long) u, v); }

sc_signed sc_dt::operator &	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_signed.h の 1673 行で定義されています。

    { return operator&(u, (long) v); }

sc_signed sc_dt::operator &	(	unsigned long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2893 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
    return sc_signed();

  CONVERT_LONG(u);

  // other cases
  return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator &	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed.cpp の 2877 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
    return sc_signed();

  CONVERT_LONG(v);

  // other cases
  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator &	(	long	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2861 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
    return sc_signed();

  CONVERT_LONG(u);

  // other cases
  return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator &	(	const sc_unsigned &	u,
		long	v
	)

sc_signed.cpp の 2845 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
    return sc_signed();

  CONVERT_LONG(v);

  // other cases
  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator &	(	long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2829 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
    return sc_signed();

  CONVERT_LONG(u);

  // other cases
  return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator &	(	const sc_signed &	u,
		long	v
	)

sc_signed.cpp の 2813 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
    return sc_signed();

  CONVERT_LONG(v);

  // other cases
  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator &	(	uint64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2797 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
    return sc_signed();

  CONVERT_INT64(u);

  // other cases
  return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator &	(	const sc_signed &	u,
		uint64	v
	)

sc_signed.cpp の 2781 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
    return sc_signed();

  CONVERT_INT64(v);

  // other cases
  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
  
}

sc_signed sc_dt::operator &	(	int64	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2765 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
    return sc_signed();

  CONVERT_INT64(u);

  // other cases
  return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator &	(	const sc_unsigned &	u,
		int64	v
	)

sc_signed.cpp の 2749 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
    return sc_signed();

  CONVERT_INT64(v);

  // other cases
  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator &	(	int64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2733 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
    return sc_signed();

  CONVERT_INT64(u);

  // other cases
  return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator &	(	const sc_signed &	u,
		int64	v
	)

sc_signed.cpp の 2717 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
    return sc_signed();

  CONVERT_INT64(v);

  // other cases
  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator &	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2703 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
    return sc_signed();

  // other cases
  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator &	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2689 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
    return sc_signed();

  // other cases
  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator &	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2675 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
    return sc_signed();

  // other cases
  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator &	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 942 行で定義されています。

{ return operator&((uint64) u, v); }

sc_signed sc_dt::operator &	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 938 行で定義されています。

{ return operator&(u, (uint64) v); }

sc_signed sc_dt::operator &	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 733 行で定義されています。

{ return operator&((int64) u, v); }

sc_signed sc_dt::operator &	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 729 行で定義されています。

{ return operator&(u, (int64) v); }

sc_signed sc_dt::operator &	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 725 行で定義されています。

{ return operator & ( SCAST<int64>( u ), v ); }

sc_signed sc_dt::operator &	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 721 行で定義されています。

{ return operator & ( u, SCAST<int64>( v ) ); }

template<class X, class Y>

const sc_lv_base sc_dt::operator &	(	const sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_lv_base.h の 405 行で定義されています。

{
    sc_lv_base a( px.back_cast() );
    return ( a &= py.back_cast() );
}

const sc_logic sc_dt::operator &	(	int	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 402 行で定義されています。

        { return ( sc_logic( a ) & b ); }

const sc_logic sc_dt::operator &	(	char	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 399 行で定義されています。

        { return ( sc_logic( a ) & b ); }

const sc_logic sc_dt::operator &	(	bool	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 396 行で定義されています。

        { return ( sc_logic( a ) & b ); }

const sc_logic sc_dt::operator &	(	sc_logic_value_t	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 393 行で定義されています。

        { return ( sc_logic( a ) & b ); }

const sc_logic sc_dt::operator &	(	const sc_logic &	a,
		int	b
	)			[inline]

sc_logic.h の 390 行で定義されています。

        { return ( a & sc_logic( b ) ); }

const sc_logic sc_dt::operator &	(	const sc_logic &	a,
		char	b
	)			[inline]

sc_logic.h の 387 行で定義されています。

        { return ( a & sc_logic( b ) ); }

const sc_logic sc_dt::operator &	(	const sc_logic &	a,
		bool	b
	)			[inline]

sc_logic.h の 384 行で定義されています。

        { return ( a & sc_logic( b ) ); }

const sc_logic sc_dt::operator &	(	const sc_logic &	a,
		sc_logic_value_t	b
	)			[inline]

sc_logic.h の 381 行で定義されています。

        { return ( a & sc_logic( b ) ); }

const sc_logic sc_dt::operator &	(	const sc_logic &	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 378 行で定義されています。

        { return sc_logic( sc_logic::and_table[a.m_val][b.m_val] ); }

template<class T1, class T2>

const sc_logic sc_dt::operator &	(	const sc_bitref_r< T1 > &	a,
		const sc_bitref_r< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 1919 行で定義されています。

{
    return sc_logic( sc_logic::and_table[a.value()][b.value()] );
}

const sc_bit sc_dt::operator &	(	char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 620 行で定義されています。

        { return ( sc_bit( a ) & b ); }

const sc_bit sc_dt::operator &	(	bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 617 行で定義されています。

        { return ( sc_bit( a ) & b ); }

const sc_bit sc_dt::operator &	(	int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 614 行で定義されています。

        { return ( sc_bit( a ) & b ); }

const sc_bit sc_dt::operator &	(	const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 611 行で定義されています。

        { return ( a & sc_bit( b ) ); }

const sc_bit sc_dt::operator &	(	const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 608 行で定義されています。

        { return ( a & sc_bit( b ) ); }

const sc_bit sc_dt::operator &	(	const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 605 行で定義されています。

        { return ( a & sc_bit( b ) ); }

const sc_bit sc_dt::operator &	(	const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 602 行で定義されています。

        { return sc_bit( a.m_val && b.m_val ); }

template<class X, class Y>

X & sc_dt::operator &=	(	sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_lv_base.h の 368 行で定義されています。

{
    X& x = px.back_cast();
    sc_lv_base a( x.length() );
    a = py.back_cast();
    return b_and_assign_( x, a );
}

bool sc_dt::operator!=	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1721 行で定義されています。

    { return operator!=((unsigned long) u,  v); }

bool sc_dt::operator!=	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1719 行で定義されています。

    { return operator!=((long) u,  v); }

bool sc_dt::operator!=	(	unsigned long	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator!=	(	long	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator!=	(	uint64	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator!=	(	int64	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator!=	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1712 行で定義されています。

    { return operator!=(u, (unsigned long) v); }

bool sc_dt::operator!=	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_unsigned.h の 1710 行で定義されています。

    { return operator!=(u, (long) v); }

bool sc_dt::operator!=	(	const sc_unsigned &	u,
		unsigned long	v
	)

bool sc_dt::operator!=	(	const sc_unsigned &	u,
		long	v
	)

bool sc_dt::operator!=	(	const sc_unsigned &	u,
		uint64	v
	)

bool sc_dt::operator!=	(	const sc_unsigned &	u,
		int64	v
	)

bool sc_dt::operator!=	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator!=	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 728 行で定義されています。

{ return operator!=((uint64) u, v); }

bool sc_dt::operator!=	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 725 行で定義されています。

{ return operator!=(u, (uint64) v); }

bool sc_dt::operator!=	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 589 行で定義されています。

{ return operator!=((int64) u, v); }

bool sc_dt::operator!=	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_unsigned.cpp の 586 行で定義されています。

{ return operator!=(u, (int64) v); }

bool sc_dt::operator!=	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			[inline]

sc_uint_base.h の 692 行で定義されています。

        { return a.m_val != b.m_val; }

bool sc_dt::operator!=	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1949 行で定義されています。

    { return operator!=((unsigned long) u, v); }

bool sc_dt::operator!=	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1947 行で定義されています。

    { return operator!=((long) u, v); }

bool sc_dt::operator!=	(	unsigned long	u,
		const sc_signed &	v
	)

bool sc_dt::operator!=	(	long	u,
		const sc_signed &	v
	)

bool sc_dt::operator!=	(	uint64	u,
		const sc_signed &	v
	)

bool sc_dt::operator!=	(	int64	u,
		const sc_signed &	v
	)

bool sc_dt::operator!=	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1940 行で定義されています。

    { return operator!=(u, (unsigned long) v); }

bool sc_dt::operator!=	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1938 行で定義されています。

    { return operator!=(u, (long) v); }

bool sc_dt::operator!=	(	const sc_signed &	u,
		unsigned long	v
	)

bool sc_dt::operator!=	(	const sc_signed &	u,
		long	v
	)

bool sc_dt::operator!=	(	const sc_signed &	u,
		uint64	v
	)

bool sc_dt::operator!=	(	const sc_signed &	u,
		int64	v
	)

bool sc_dt::operator!=	(	const sc_signed &	u,
		const sc_signed &	v
	)

bool sc_dt::operator!=	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1761 行で定義されています。

{
  return (! operator==(u, v));
}

bool sc_dt::operator!=	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_unsigned.cpp の 1754 行で定義されています。

{
  return (! operator==(u, v));
}

bool sc_dt::operator!=	(	unsigned long	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6808 行で定義されています。

bool sc_dt::operator!=	(	const CLASS_TYPE &	u,
		unsigned long	v
	)

sc_signed.cpp の 6801 行で定義されています。

bool sc_dt::operator!=	(	long	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6794 行で定義されています。

bool sc_dt::operator!=	(	const CLASS_TYPE &	u,
		long	v
	)

sc_signed.cpp の 6787 行で定義されています。

bool sc_dt::operator!=	(	uint64	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6780 行で定義されています。

bool sc_dt::operator!=	(	const CLASS_TYPE &	u,
		uint64	v
	)

sc_signed.cpp の 6773 行で定義されています。

bool sc_dt::operator!=	(	int64	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6766 行で定義されています。

bool sc_dt::operator!=	(	const CLASS_TYPE &	u,
		int64	v
	)

sc_signed.cpp の 6759 行で定義されています。

bool sc_dt::operator!=	(	const CLASS_TYPE &	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6752 行で定義されています。

bool sc_dt::operator!=	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1008 行で定義されています。

{ return operator!=((uint64) u, v); }

bool sc_dt::operator!=	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 1004 行で定義されています。

{ return operator!=(u, (uint64) v); }

bool sc_dt::operator!=	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 815 行で定義されています。

{ return operator!=((int64) u, v); }

bool sc_dt::operator!=	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 811 行で定義されています。

{ return operator!=(u, (int64) v); }

bool sc_dt::operator!=	(	const sc_length_param &	a,
		const sc_length_param &	b
	)			[inline]

sc_length_param.h の 157 行で定義されています。

{
    return ( a.m_len != b.m_len );
}

bool sc_dt::operator!=	(	const sc_int_base &	a,
		const sc_int_base &	b
	)			[inline]

sc_int_base.h の 706 行で定義されています。

        { return a.m_val != b.m_val; }

bool sc_dt::operator!=	(	const sc_fxtype_params &	a,
		const sc_fxtype_params &	b
	)			[inline]

sc_fxtype_params.h の 233 行で定義されています。

{
    return ( a.m_wl     != b.m_wl     ||
             a.m_iwl    != b.m_iwl    ||
             a.m_q_mode != b.m_q_mode ||
             a.m_o_mode != b.m_o_mode ||
             a.m_n_bits != b.m_n_bits );
}

bool sc_dt::operator!=	(	const sc_fxcast_switch &	a,
		const sc_fxcast_switch &	b
	)			[inline]

sc_fxcast_switch.h の 149 行で定義されています。

{
    return ( a.m_sw != b.m_sw );
}

template<class X, class Y>

bool sc_dt::operator!=	(	const sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_proxy.h の 1260 行で定義されています。

{
    return !( px == py );
}

bool sc_dt::operator!=	(	int	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 520 行で定義されています。

        { return ( sc_logic( a ) != b ); }

bool sc_dt::operator!=	(	char	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 517 行で定義されています。

        { return ( sc_logic( a ) != b ); }

bool sc_dt::operator!=	(	bool	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 514 行で定義されています。

        { return ( sc_logic( a ) != b ); }

bool sc_dt::operator!=	(	sc_logic_value_t	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 511 行で定義されています。

        { return ( sc_logic( a ) != b ); }

bool sc_dt::operator!=	(	const sc_logic &	a,
		int	b
	)			[inline]

sc_logic.h の 508 行で定義されています。

        { return ( a != sc_logic( b ) ); }

bool sc_dt::operator!=	(	const sc_logic &	a,
		char	b
	)			[inline]

sc_logic.h の 505 行で定義されています。

        { return ( a != sc_logic( b ) ); }

bool sc_dt::operator!=	(	const sc_logic &	a,
		bool	b
	)			[inline]

sc_logic.h の 502 行で定義されています。

        { return ( a != sc_logic( b ) ); }

bool sc_dt::operator!=	(	const sc_logic &	a,
		sc_logic_value_t	b
	)			[inline]

sc_logic.h の 499 行で定義されています。

        { return ( a != sc_logic( b ) ); }

bool sc_dt::operator!=	(	const sc_logic &	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 496 行で定義されています。

        { return ( (int) a.m_val != b.m_val ); }

template<class T1, class T2>

bool sc_dt::operator!=	(	const sc_bitref_r< T1 > &	a,
		const sc_bitref_r< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 1960 行で定義されています。

{
    return ( (int) a.value() != b.value() );
}

bool sc_dt::operator!=	(	char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 474 行で定義されています。

        { return ( sc_bit( a ) != b ); }

bool sc_dt::operator!=	(	bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 471 行で定義されています。

        { return ( sc_bit( a ) != b ); }

bool sc_dt::operator!=	(	int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 468 行で定義されています。

        { return ( sc_bit( a ) != b ); }

bool sc_dt::operator!=	(	const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 465 行で定義されています。

        { return ( a != sc_bit( b ) ); }

bool sc_dt::operator!=	(	const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 462 行で定義されています。

        { return ( a != sc_bit( b ) ); }

bool sc_dt::operator!=	(	const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 459 行で定義されています。

        { return ( a != sc_bit( b ) ); }

bool sc_dt::operator!=	(	const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 456 行で定義されています。

        { return ( a.m_val != b.m_val ); }

sc_unsigned sc_dt::operator%	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1458 行で定義されています。

    { return operator%((unsigned long) u,  v); }

sc_unsigned sc_dt::operator%	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1450 行で定義されています。

    { return operator%(u, (unsigned long) v); }

sc_unsigned sc_dt::operator%	(	unsigned long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1234 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_unsigned();  // case 2
  }

  CONVERT_LONG(u);

  // other cases
  return mod_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                             v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator%	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned.cpp の 1216 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) {
    div_by_zero(v);  // case 1
    return sc_unsigned();  // case 2
  }

  CONVERT_LONG_2(v);

  // other cases
  return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_unsigned sc_dt::operator%	(	uint64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1198 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_unsigned();  // case 2
  }

  CONVERT_INT64(u);

  // other cases
  return mod_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                             v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator%	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned.cpp の 1180 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) {
    div_by_zero(v);  // case 1
    return sc_unsigned();  // case 2
  }

  CONVERT_INT64_2(v);

  // other cases
  return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_unsigned sc_dt::operator%	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1165 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_unsigned();  // case 2
  }

  // other cases
  return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             v.nbits, v.ndigits, v.digit);
}

sc_unsigned sc_dt::operator%	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 667 行で定義されています。

{ return operator%((uint64) u, v); }

sc_unsigned sc_dt::operator%	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 664 行で定義されています。

{ return operator%(u, (uint64) v); }

sc_signed sc_dt::operator%	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1641 行で定義されています。

    { return operator%((unsigned long) u, v); }

sc_signed sc_dt::operator%	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1639 行で定義されています。

    { return operator%((long) u, v); }

sc_signed sc_dt::operator%	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1632 行で定義されています。

    { return operator%(u, (unsigned long) v); }

sc_signed sc_dt::operator%	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1630 行で定義されています。

    { return operator%(u, (long) v); }

sc_signed sc_dt::operator%	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_signed.h の 1622 行で定義されています。

    { return operator%((long) u, v); }

sc_signed sc_dt::operator%	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_signed.h の 1617 行で定義されています。

    { return operator%(u, (long) v); }

sc_signed sc_dt::operator%	(	unsigned long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2643 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG(u);

  // other cases
  return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator%	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed.cpp の 2625 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG_2(v);

  // other cases
  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator%	(	long	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2605 行で定義されています。

{

  small_type us = get_sign(u);

  if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG_2(u);

  // other cases
  return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator%	(	const sc_unsigned &	u,
		long	v
	)

sc_signed.cpp の 2586 行で定義されています。

{

  small_type vs = get_sign(v);

  if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG_2(v);

  // other cases
  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
}

sc_signed sc_dt::operator%	(	long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2566 行で定義されています。

{

  small_type us = get_sign(u);

  if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG_2(u);

  // other cases
  return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator%	(	const sc_signed &	u,
		long	v
	)

sc_signed.cpp の 2547 行で定義されています。

{

  small_type vs = get_sign(v);

  if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG_2(v);

  // other cases
  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
}

sc_signed sc_dt::operator%	(	uint64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2529 行で定義されています。

{

  if ((u == 0) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64(u);

  // other cases
  return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator%	(	const sc_signed &	u,
		uint64	v
	)

sc_signed.cpp の 2511 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v == 0)) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64_2(v);

  // other cases
  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator%	(	int64	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2491 行で定義されています。

{

  small_type us = get_sign(u);

  if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64_2(u);

  // other cases
  return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator%	(	const sc_unsigned &	u,
		int64	v
	)

sc_signed.cpp の 2471 行で定義されています。

{

  small_type vs = get_sign(v);

  if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64_2(v);

  // other cases
  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator%	(	int64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2451 行で定義されています。

{

  small_type us = get_sign(u);

  if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64_2(u);

  // other cases
  return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator%	(	const sc_signed &	u,
		int64	v
	)

sc_signed.cpp の 2431 行で定義されています。

{

  small_type vs = get_sign(v);

  if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64_2(v);

  // other cases
  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator%	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2416 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  // other cases
  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.nbits, v.ndigits, v.digit);
}

sc_signed sc_dt::operator%	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2401 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  // other cases
  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.nbits, v.ndigits, v.digit);
}

sc_signed sc_dt::operator%	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2386 行で定義されています。

{

  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  // other cases
  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.nbits, v.ndigits, v.digit);
}

sc_signed sc_dt::operator%	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 929 行で定義されています。

{ return operator%((uint64) u, v); }

sc_signed sc_dt::operator%	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 925 行で定義されています。

{ return operator%(u, (uint64) v); }

sc_signed sc_dt::operator%	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 712 行で定義されています。

{ return operator%((int64) u, v); }

sc_signed sc_dt::operator%	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 708 行で定義されています。

{ return operator%(u, (int64) v); }

sc_signed sc_dt::operator%	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 704 行で定義されています。

{ return operator % ( SCAST<int64>( u ), v ); }

sc_signed sc_dt::operator%	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 700 行で定義されています。

{ return operator % ( u, SCAST<int64>( v ) ); }

sc_unsigned sc_dt::operator*	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1378 行で定義されています。

    { return operator*((unsigned long) u,  v); }

sc_unsigned sc_dt::operator*	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1370 行で定義されています。

    { return operator*(u, (unsigned long) v); }

sc_unsigned sc_dt::operator*	(	unsigned long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1017 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) // case 1
    return sc_unsigned();

  CONVERT_LONG_2(u);

  // cases 2-4
  return mul_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
                             v.nbits, v.ndigits, v.digit);
  
}

sc_unsigned sc_dt::operator*	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned.cpp の 1000 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) // case 1
    return sc_unsigned();

  CONVERT_LONG_2(v);

  // else cases 2-4
  return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
  
}

sc_unsigned sc_dt::operator*	(	uint64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 982 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) // case 1
    return sc_unsigned();

  CONVERT_INT64_2(u);

  // cases 2-4
  return mul_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
                             v.nbits, v.ndigits, v.digit);
  
}

sc_unsigned sc_dt::operator*	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned.cpp の 964 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) // case 1
    return sc_unsigned();

  CONVERT_INT64_2(v);

  // cases 2-4
  return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
  
}

sc_unsigned sc_dt::operator*	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 948 行で定義されています。

{
 
  small_type s = mul_signs(u.sgn, v.sgn);

  if (s == SC_ZERO) // case 1
    return sc_unsigned();

  // cases 2-4
  return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
                             v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator*	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 647 行で定義されています。

{ return operator*((uint64) u, v); }

sc_unsigned sc_dt::operator*	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 644 行で定義されています。

{ return operator*(u, (uint64) v); }

sc_signed sc_dt::operator*	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1533 行で定義されています。

    { return operator*((unsigned long) u, v); }

sc_signed sc_dt::operator*	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1531 行で定義されています。

    { return operator*((long) u, v); }

sc_signed sc_dt::operator*	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1524 行で定義されています。

    { return operator*(u, (unsigned long) v); }

sc_signed sc_dt::operator*	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1522 行で定義されています。

    { return operator*(u, (long) v); }

sc_signed sc_dt::operator*	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_signed.h の 1514 行で定義されています。

    { return operator*((long) u, v); }

sc_signed sc_dt::operator*	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_signed.h の 1509 行で定義されています。

    { return operator*(u, (long) v); }

sc_signed sc_dt::operator*	(	unsigned long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2042 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_LONG_2(u);

  // cases 2-4
  return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator*	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed.cpp の 2025 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_LONG_2(v);

  // else cases 2-4
  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
  
}

sc_signed sc_dt::operator*	(	long	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2007 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_LONG_2(u);

  // cases 2-4
  return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator*	(	const sc_unsigned &	u,
		long	v
	)

sc_signed.cpp の 1989 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_LONG_2(v);

  // cases 2-4
  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
  
}

sc_signed sc_dt::operator*	(	long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1971 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_LONG_2(u);

  // cases 2-4
  return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator*	(	const sc_signed &	u,
		long	v
	)

sc_signed.cpp の 1953 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_LONG_2(v);

  // cases 2-4
  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
  
}

sc_signed sc_dt::operator*	(	uint64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1935 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_INT64_2(u);

  // cases 2-4
  return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator*	(	const sc_signed &	u,
		uint64	v
	)

sc_signed.cpp の 1917 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_INT64_2(v);

  // cases 2-4
  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
  
}

sc_signed sc_dt::operator*	(	int64	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1899 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_INT64_2(u);

  // cases 2-4
  return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator*	(	const sc_unsigned &	u,
		int64	v
	)

sc_signed.cpp の 1881 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_INT64_2(v);

  // cases 2-4
  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
  
}

sc_signed sc_dt::operator*	(	int64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1863 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_INT64_2(u);

  // cases 2-4
  return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator*	(	const sc_signed &	u,
		int64	v
	)

sc_signed.cpp の 1845 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) // case 1
    return sc_signed();

  CONVERT_INT64_2(v);

  // cases 2-4
  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
  
}

sc_signed sc_dt::operator*	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1829 行で定義されています。

{
 
  small_type s = mul_signs(u.sgn, v.sgn);

  if (s == SC_ZERO) // case 1
    return sc_signed();

  // cases 2-4
  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator*	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1813 行で定義されています。

{
 
  small_type s = mul_signs(u.sgn, v.sgn);

  if (s == SC_ZERO) // case 1
    return sc_signed();

  // cases 2-4
  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator*	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1797 行で定義されています。

{
 
  small_type s = mul_signs(u.sgn, v.sgn);

  if (s == SC_ZERO) // case 1
    return sc_signed();

  // cases 2-4
  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator*	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 903 行で定義されています。

{ return operator*((uint64) u, v); }

sc_signed sc_dt::operator*	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 899 行で定義されています。

{ return operator*(u, (uint64) v); }

sc_signed sc_dt::operator*	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 670 行で定義されています。

{ return operator*((int64) u, v); }

sc_signed sc_dt::operator*	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 666 行で定義されています。

{ return operator*(u, (int64) v); }

sc_signed sc_dt::operator*	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 662 行で定義されています。

{ return operator * ( SCAST<int64>( u ), v ); }

sc_signed sc_dt::operator*	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 658 行で定義されています。

{ return operator * ( u, SCAST<int64>( v ) ); }

sc_string_old sc_dt::operator+	(	const char *	s,
		const sc_string_old &	t
	)

sc_string.cpp の 261 行で定義されています。

{
    int len = strlen(s);
    sc_string_rep* r = new sc_string_rep( len + t.length() + 1 );
    strcpy( r->str, s );
    strcpy( r->str + len, t );
    return sc_string_old(r);
}

sc_unsigned sc_dt::operator+	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1300 行で定義されています。

    { return operator+((unsigned long) u,  v); }

sc_unsigned sc_dt::operator+	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1292 行で定義されています。

    { return operator+(u, (unsigned long) v); }

sc_unsigned sc_dt::operator+

(

const sc_unsigned &

u

)

sc_unsigned.cpp の 1607 行で定義されています。

{
  return sc_unsigned(u);
}

sc_unsigned sc_dt::operator+	(	unsigned long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 894 行で定義されています。

{

  if (u == 0) // case 1
    return sc_unsigned(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)  // case 2
    return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // cases 3 and 4
  return add_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                             v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator+	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned.cpp の 875 行で定義されています。

{

  if (v == 0) // case 2
    return sc_unsigned(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 1
    return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // cases 3 and 4
  return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_unsigned sc_dt::operator+	(	uint64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 855 行で定義されています。

{

  if (u == 0) // case 1
    return sc_unsigned(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)  // case 2
    return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // cases 3 and 4

  return add_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                             v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator+	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned.cpp の 836 行で定義されています。

{

  if (v == 0)  // case 2
    return sc_unsigned(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 1
    return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // cases 3 and 4
  return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_unsigned sc_dt::operator+	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 819 行で定義されています。

{

  if (u.sgn == SC_ZERO) // case 1
    return sc_unsigned(v);

  if (v.sgn == SC_ZERO) // case 2
    return sc_unsigned(u);

  // cases 3 and 4
  return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             v.sgn, v.nbits, v.ndigits, v.digit);
  
}

sc_unsigned sc_dt::operator+	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 633 行で定義されています。

{ return operator+((uint64) u, v); }

sc_unsigned sc_dt::operator+	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 630 行で定義されています。

{ return operator+(u, (uint64) v); }

sc_signed sc_dt::operator+	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1414 行で定義されています。

    { return operator+((unsigned long) u, v); }

sc_signed sc_dt::operator+	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1412 行で定義されています。

    { return operator+((long) u, v); }

sc_signed sc_dt::operator+	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1405 行で定義されています。

    { return operator+(u, (unsigned long) v); }

sc_signed sc_dt::operator+	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1403 行で定義されています。

    { return operator+(u, (long) v); }

sc_signed sc_dt::operator+	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_signed.h の 1395 行で定義されています。

    { return operator+((long) u, v); }

sc_signed sc_dt::operator+	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_signed.h の 1390 行で定義されています。

    { return operator+(u, (long) v); }

sc_signed sc_dt::operator+

(

const sc_signed &

u

)

sc_signed.cpp の 3544 行で定義されています。

{
  return sc_signed(u);
}

sc_signed sc_dt::operator+	(	unsigned long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1370 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)  // case 2
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // cases 3 and 4
  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator+	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed.cpp の 1351 行で定義されています。

{

  if (v == 0) // case 2
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 1
    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator+	(	long	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1332 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)  // case 2
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // cases 3 and 4
  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator+	(	const sc_unsigned &	u,
		long	v
	)

sc_signed.cpp の 1313 行で定義されています。

{

  if (v == 0)  // case 2
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 1
    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator+	(	long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1294 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)  // case 2
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // cases 3 and 4
  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator+	(	const sc_signed &	u,
		long	v
	)

sc_signed.cpp の 1275 行で定義されています。

{

  if (v == 0)  // case 2
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 1
    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator+	(	uint64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1255 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)  // case 2
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // cases 3 and 4

  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator+	(	const sc_signed &	u,
		uint64	v
	)

sc_signed.cpp の 1236 行で定義されています。

{

  if (v == 0)  // case 2
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 1
    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator+	(	int64	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1216 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)  // case 2
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // cases 3 and 4

  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator+	(	const sc_unsigned &	u,
		int64	v
	)

sc_signed.cpp の 1197 行で定義されています。

{

  if (v == 0)  // case 2
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 1
    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator+	(	int64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1177 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)  // case 2
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // cases 3 and 4

  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator+	(	const sc_signed &	u,
		int64	v
	)

sc_signed.cpp の 1158 行で定義されています。

{

  if (v == 0)  // case 2
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 1
    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator+	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1141 行で定義されています。

{

  if (u.sgn == SC_ZERO) // case 1
    return sc_signed(v);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(u);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.sgn, v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator+	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1124 行で定義されています。

{

  if (u.sgn == SC_ZERO) // case 1
    return sc_signed(v);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(u);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator+	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1107 行で定義されています。

{

  if (u.sgn == SC_ZERO) // case 1
    return sc_signed(v);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(u);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator+	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 869 行で定義されています。

{ return operator+((uint64) u, v); }

sc_signed sc_dt::operator+	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 865 行で定義されています。

{ return operator+(u, (uint64) v); }

sc_signed sc_dt::operator+	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 628 行で定義されています。

{ return operator+((int64) u, v); }

sc_signed sc_dt::operator+	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 624 行で定義されています。

{ return operator+(u, (int64) v); }

sc_signed sc_dt::operator+	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 620 行で定義されています。

{ return operator + ( SCAST<int64>( u ), v ); }

sc_signed sc_dt::operator+	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 616 行で定義されています。

{ return operator + ( u, SCAST<int64>( v ) ); }

const sc_dt::sc_concatref& sc_dt::operator,	(	bool	a,
		const sc_dt::sc_value_base &	b
	)			[inline]

sc_concatref.h の 793 行で定義されています。

{
    const sc_dt::sc_concat_bool* a_p;      // Proxy for boolean value.
    sc_dt::sc_concatref*         result_p; // Proxy for the concatenation.

    a_p = sc_dt::sc_concat_bool::allocate(a);
    result_p = sc_dt::sc_concatref::m_pool.allocate();
    result_p->initialize( *a_p, b );
    return *result_p;
}

const sc_dt::sc_concatref& sc_dt::operator,	(	const sc_dt::sc_value_base &	a,
		bool	b
	)			[inline]

sc_concatref.h の 780 行で定義されています。

{
    const sc_dt::sc_concat_bool* b_p;      // Proxy for boolean value.
    sc_dt::sc_concatref*         result_p; // Proxy for the concatenation.

    b_p = sc_dt::sc_concat_bool::allocate(b);
    result_p = sc_dt::sc_concatref::m_pool.allocate();
    result_p->initialize( a, *b_p );
    return *result_p;
}

const sc_dt::sc_concatref& sc_dt::operator,	(	const sc_dt::sc_value_base &	a,
		const sc_dt::sc_value_base &	b
	)			[inline]

sc_concatref.h の 768 行で定義されています。

{
    sc_dt::sc_concatref* result_p;     // Proxy for the concatenation.

    result_p = sc_dt::sc_concatref::m_pool.allocate();
    result_p->initialize( a, b );
    return *result_p;
}

sc_dt::sc_concatref& sc_dt::operator,	(	sc_dt::sc_value_base &	a,
		sc_dt::sc_value_base &	b
	)			[inline]

sc_concatref.h の 756 行で定義されています。

{
    sc_dt::sc_concatref* result_p;     // Proxy for the concatenation.

    result_p = sc_dt::sc_concatref::m_pool.allocate();
    result_p->initialize( a, b );
    return *result_p;
}

template<class T1, class T2>

sc_concref< T1, T2 > sc_dt::operator,	(	sc_proxy< T1 > &	a,
		sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 3817 行で定義されています。

{
    return sc_concref<T1,T2>(
        a.back_cast(), b.back_cast() );
}

template<class T1, class T2, class T3>

sc_concref< T1, sc_concref< T2, T3 > > sc_dt::operator,	(	sc_proxy< T1 > &	a,
		sc_concref< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 3808 行で定義されています。

{
    return sc_concref<T1,sc_concref<T2,T3> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T1, class T2>

sc_concref< T1, sc_subref< T2 > > sc_dt::operator,	(	sc_proxy< T1 > &	a,
		sc_subref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 3799 行で定義されています。

{
    return sc_concref<T1,sc_subref<T2> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T1, class T2>

sc_concref< T1, sc_bitref< T2 > > sc_dt::operator,	(	sc_proxy< T1 > &	a,
		sc_bitref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 3790 行で定義されています。

{
    return sc_concref<T1,sc_bitref<T2> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T>

sc_concref_r< sc_lv_base, T > sc_dt::operator,	(	bool	a,
		const sc_proxy< T > &	b
	)			[inline]

sc_lv_base.h の 1636 行で定義されています。

{
    return sc_concref_r<sc_lv_base,T>(
        *new sc_lv_base( sc_logic( a ), 1 ), b.back_cast(), 1 );
}

template<class T>

sc_concref_r< T, sc_lv_base > sc_dt::operator,	(	const sc_proxy< T > &	a,
		bool	b
	)			[inline]

sc_lv_base.h の 1627 行で定義されています。

{
    return sc_concref_r<T,sc_lv_base>(
        a.back_cast(), *new sc_lv_base( sc_logic( b ), 1 ), 2 );
}

template<class T>

sc_concref_r< sc_lv_base, T > sc_dt::operator,	(	const sc_logic &	a,
		const sc_proxy< T > &	b
	)			[inline]

sc_lv_base.h の 1618 行で定義されています。

{
    return sc_concref_r<sc_lv_base,T>(
        *new sc_lv_base( a, 1 ), b.back_cast(), 1 );
}

template<class T>

sc_concref_r< T, sc_lv_base > sc_dt::operator,	(	const sc_proxy< T > &	a,
		const sc_logic &	b
	)			[inline]

sc_lv_base.h の 1609 行で定義されています。

{
    return sc_concref_r<T,sc_lv_base>(
        a.back_cast(), *new sc_lv_base( b, 1 ), 2 );
}

template<class T>

sc_concref_r< sc_lv_base, T > sc_dt::operator,	(	const char *	a,
		const sc_proxy< T > &	b
	)			[inline]

sc_lv_base.h の 1600 行で定義されています。

{
    return sc_concref_r<sc_lv_base,T>(
        *new sc_lv_base( a ), b.back_cast(), 1 );
}

template<class T>

sc_concref_r< T, sc_lv_base > sc_dt::operator,	(	const sc_proxy< T > &	a,
		const char *	b
	)			[inline]

sc_lv_base.h の 1591 行で定義されています。

{
    return sc_concref_r<T,sc_lv_base>(
        a.back_cast(), *new sc_lv_base( b ), 2 );
}

template<class T1, class T2>

sc_concref_r< T1, T2 > sc_dt::operator,	(	const sc_proxy< T1 > &	a,
		const sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 3591 行で定義されています。

{
    return sc_concref_r<T1,T2>(
        a.back_cast(), b.back_cast() );
}

template<class T1, class T2, class T3>

sc_concref_r< T1, sc_concref_r< T2, T3 > > sc_dt::operator,	(	const sc_proxy< T1 > &	a,
		sc_concref_r< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 3582 行で定義されています。

{
    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T1, class T2>

sc_concref_r< T1, sc_subref_r< T2 > > sc_dt::operator,	(	const sc_proxy< T1 > &	a,
		sc_subref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 3573 行で定義されています。

{
    return sc_concref_r<T1,sc_subref_r<T2> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T1, class T2>

sc_concref_r< T1, sc_bitref_r< T2 > > sc_dt::operator,	(	const sc_proxy< T1 > &	a,
		sc_bitref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 3564 行で定義されています。

{
    return sc_concref_r<T1,sc_bitref_r<T2> >(
        a.back_cast(), *b.clone(), 2 );
}

template<class T1, class T2, class T3>

sc_concref< sc_concref< T1, T2 >, T3 > sc_dt::operator,	(	sc_concref< T1, T2 >	a,
		sc_proxy< T3 > &	b
	)			[inline]

sc_bit_proxies.h の 3498 行で定義されています。

{
    return sc_concref<sc_concref<T1,T2>,T3>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3, class T4>

sc_concref< sc_concref< T1, T2 >, sc_concref< T3, T4 > > sc_dt::operator,	(	sc_concref< T1, T2 >	a,
		sc_concref< T3, T4 >	b
	)			[inline]

sc_bit_proxies.h の 3489 行で定義されています。

{
    return sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2, class T3>

sc_concref< sc_concref< T1, T2 >, sc_subref< T3 > > sc_dt::operator,	(	sc_concref< T1, T2 >	a,
		sc_subref< T3 >	b
	)			[inline]

sc_bit_proxies.h の 3480 行で定義されています。

{
    return sc_concref<sc_concref<T1,T2>,sc_subref<T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2, class T3>

sc_concref< sc_concref< T1, T2 >, sc_bitref< T3 > > sc_dt::operator,	(	sc_concref< T1, T2 >	a,
		sc_bitref< T3 >	b
	)			[inline]

sc_bit_proxies.h の 3471 行で定義されています。

{
    return sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > > sc_dt::operator,	(	bool	a,
		sc_concref_r< T1, T2 >	b
	)			[inline]

sc_lv_base.h の 1403 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
        *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base > sc_dt::operator,	(	sc_concref_r< T1, T2 >	a,
		bool	b
	)			[inline]

sc_lv_base.h の 1394 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > > sc_dt::operator,	(	const sc_logic &	a,
		sc_concref_r< T1, T2 >	b
	)			[inline]

sc_lv_base.h の 1385 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
        *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base > sc_dt::operator,	(	sc_concref_r< T1, T2 >	a,
		const sc_logic &	b
	)			[inline]

sc_lv_base.h の 1376 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_lv_base, sc_concref_r< T1, T2 > > sc_dt::operator,	(	const char *	a,
		sc_concref_r< T1, T2 >	b
	)			[inline]

sc_lv_base.h の 1367 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
        *new sc_lv_base( a ), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_concref_r< T1, T2 >, sc_lv_base > sc_dt::operator,	(	sc_concref_r< T1, T2 >	a,
		const char *	b
	)			[inline]

sc_lv_base.h の 1358 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b ), 3 );
}

template<class T1, class T2, class T3>

sc_concref_r< sc_concref_r< T1, T2 >, T3 > sc_dt::operator,	(	sc_concref_r< T1, T2 >	a,
		const sc_proxy< T3 > &	b
	)			[inline]

sc_bit_proxies.h の 3253 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3, class T4>

sc_concref_r< sc_concref_r< T1, T2 >, sc_concref_r< T3, T4 > > sc_dt::operator,	(	sc_concref_r< T1, T2 >	a,
		sc_concref_r< T3, T4 >	b
	)			[inline]

sc_bit_proxies.h の 3244 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2, class T3>

sc_concref_r< sc_concref_r< T1, T2 >, sc_subref_r< T3 > > sc_dt::operator,	(	sc_concref_r< T1, T2 >	a,
		sc_subref_r< T3 >	b
	)			[inline]

sc_bit_proxies.h の 3235 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2, class T3>

sc_concref_r< sc_concref_r< T1, T2 >, sc_bitref_r< T3 > > sc_dt::operator,	(	sc_concref_r< T1, T2 >	a,
		sc_bitref_r< T3 >	b
	)			[inline]

sc_bit_proxies.h の 3226 行で定義されています。

{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_subref< T1 >, T2 > sc_dt::operator,	(	sc_subref< T1 >	a,
		sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 2953 行で定義されています。

{
    return sc_concref<sc_subref<T1>,T2>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3>

sc_concref< sc_subref< T1 >, sc_concref< T2, T3 > > sc_dt::operator,	(	sc_subref< T1 >	a,
		sc_concref< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 2944 行で定義されています。

{
    return sc_concref<sc_subref<T1>,sc_concref<T2,T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_subref< T1 >, sc_subref< T2 > > sc_dt::operator,	(	sc_subref< T1 >	a,
		sc_subref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2935 行で定義されています。

{
    return sc_concref<sc_subref<T1>,sc_subref<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_subref< T1 >, sc_bitref< T2 > > sc_dt::operator,	(	sc_subref< T1 >	a,
		sc_bitref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2926 行で定義されています。

{
    return sc_concref<sc_subref<T1>,sc_bitref<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_lv_base, sc_subref_r< T > > sc_dt::operator,	(	bool	a,
		sc_subref_r< T >	b
	)			[inline]

sc_lv_base.h の 1126 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
        *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_subref_r< T >, sc_lv_base > sc_dt::operator,	(	sc_subref_r< T >	a,
		bool	b
	)			[inline]

sc_lv_base.h の 1117 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template<class T>

sc_concref_r< sc_lv_base, sc_subref_r< T > > sc_dt::operator,	(	const sc_logic &	a,
		sc_subref_r< T >	b
	)			[inline]

sc_lv_base.h の 1108 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
        *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_subref_r< T >, sc_lv_base > sc_dt::operator,	(	sc_subref_r< T >	a,
		const sc_logic &	b
	)			[inline]

sc_lv_base.h の 1099 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template<class T>

sc_concref_r< sc_lv_base, sc_subref_r< T > > sc_dt::operator,	(	const char *	a,
		sc_subref_r< T >	b
	)			[inline]

sc_lv_base.h の 1090 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
        *new sc_lv_base( a ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_subref_r< T >, sc_lv_base > sc_dt::operator,	(	sc_subref_r< T >	a,
		const char *	b
	)			[inline]

sc_lv_base.h の 1081 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b ), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_subref_r< T1 >, T2 > sc_dt::operator,	(	sc_subref_r< T1 >	a,
		const sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 2702 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T1>,T2>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3>

sc_concref_r< sc_subref_r< T1 >, sc_concref_r< T2, T3 > > sc_dt::operator,	(	sc_subref_r< T1 >	a,
		sc_concref_r< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 2693 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_subref_r< T1 >, sc_subref_r< T2 > > sc_dt::operator,	(	sc_subref_r< T1 >	a,
		sc_subref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2684 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_subref_r< T1 >, sc_bitref_r< T2 > > sc_dt::operator,	(	sc_subref_r< T1 >	a,
		sc_bitref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2675 行で定義されています。

{
    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_bitref< T1 >, T2 > sc_dt::operator,	(	sc_bitref< T1 >	a,
		sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 2447 行で定義されています。

{
    return sc_concref<sc_bitref<T1>,T2>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3>

sc_concref< sc_bitref< T1 >, sc_concref< T2, T3 > > sc_dt::operator,	(	sc_bitref< T1 >	a,
		sc_concref< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 2438 行で定義されています。

{
    return sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_bitref< T1 >, sc_subref< T2 > > sc_dt::operator,	(	sc_bitref< T1 >	a,
		sc_subref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2429 行で定義されています。

{
    return sc_concref<sc_bitref<T1>,sc_subref<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref< sc_bitref< T1 >, sc_bitref< T2 > > sc_dt::operator,	(	sc_bitref< T1 >	a,
		sc_bitref< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2420 行で定義されています。

{
    return sc_concref<sc_bitref<T1>,sc_bitref<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_lv_base, sc_bitref_r< T > > sc_dt::operator,	(	bool	a,
		sc_bitref_r< T >	b
	)			[inline]

sc_lv_base.h の 894 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
        *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_bitref_r< T >, sc_lv_base > sc_dt::operator,	(	sc_bitref_r< T >	a,
		bool	b
	)			[inline]

sc_lv_base.h の 885 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ) );
}

template<class T>

sc_concref_r< sc_lv_base, sc_bitref_r< T > > sc_dt::operator,	(	const sc_logic &	a,
		sc_bitref_r< T >	b
	)			[inline]

sc_lv_base.h の 876 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
        *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_bitref_r< T >, sc_lv_base > sc_dt::operator,	(	sc_bitref_r< T >	a,
		const sc_logic &	b
	)			[inline]

sc_lv_base.h の 867 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b, 1 ) );
}

template<class T>

sc_concref_r< sc_lv_base, sc_bitref_r< T > > sc_dt::operator,	(	const char *	a,
		sc_bitref_r< T >	b
	)			[inline]

sc_lv_base.h の 858 行で定義されています。

{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
        *new sc_lv_base( a ), *b.clone(), 3 );
}

template<class T>

sc_concref_r< sc_bitref_r< T >, sc_lv_base > sc_dt::operator,	(	sc_bitref_r< T >	a,
		const char *	b
	)			[inline]

sc_lv_base.h の 849 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
        *a.clone(), *new sc_lv_base( b ), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_bitref_r< T1 >, T2 > sc_dt::operator,	(	sc_bitref_r< T1 >	a,
		const sc_proxy< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 2044 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T1>,T2>(
        *a.clone(), b.back_cast(), 1 );
}

template<class T1, class T2, class T3>

sc_concref_r< sc_bitref_r< T1 >, sc_concref_r< T2, T3 > > sc_dt::operator,	(	sc_bitref_r< T1 >	a,
		sc_concref_r< T2, T3 >	b
	)			[inline]

sc_bit_proxies.h の 2035 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_bitref_r< T1 >, sc_subref_r< T2 > > sc_dt::operator,	(	sc_bitref_r< T1 >	a,
		sc_subref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2026 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
        *a.clone(), *b.clone(), 3 );
}

template<class T1, class T2>

sc_concref_r< sc_bitref_r< T1 >, sc_bitref_r< T2 > > sc_dt::operator,	(	sc_bitref_r< T1 >	a,
		sc_bitref_r< T2 >	b
	)			[inline]

sc_bit_proxies.h の 2017 行で定義されています。

{
    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
        *a.clone(), *b.clone(), 3 );
}

sc_signed sc_dt::operator-	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1477 行で定義されています。

    { return operator-((unsigned long) u, v); }

sc_signed sc_dt::operator-	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1475 行で定義されています。

    { return operator-((long) u, v); }

sc_signed sc_dt::operator-	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1468 行で定義されています。

    { return operator-(u, (unsigned long) v); }

sc_signed sc_dt::operator-	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1466 行で定義されています。

    { return operator-(u, (long) v); }

sc_signed sc_dt::operator-	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_signed.h の 1458 行で定義されています。

    { return operator-((unsigned long) u, v); }

sc_signed sc_dt::operator-	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_signed.h の 1456 行で定義されています。

    { return operator-((long) u, v); }

sc_signed sc_dt::operator-	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1449 行で定義されています。

    { return operator-(u, (unsigned long) v); }

sc_signed sc_dt::operator-	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_signed.h の 1447 行で定義されています。

    { return operator-(u, (long) v); }

sc_signed sc_dt::operator-

(

const sc_unsigned &

u

)

sc_signed.cpp の 3556 行で定義されています。

{
  return sc_signed(u, -u.sgn);
}

sc_signed sc_dt::operator-

(

const sc_signed &

u

)

sc_signed.cpp の 3550 行で定義されています。

{
  return sc_signed(u, -u.sgn);
}

sc_signed sc_dt::operator-	(	unsigned long	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1766 行で定義されています。

{
  if (u == 0) // case 1
    return sc_signed(v, -v.sgn);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // cases 3 and 4
  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_signed.cpp の 1747 行で定義されています。

{

  if (v == 0) // case 1
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator-	(	unsigned long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1729 行で定義されています。

{
  if (u == 0) // case 1
    return sc_signed(v, -v.sgn);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // cases 3 and 4
  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed.cpp の 1710 行で定義されています。

{

  if (v == 0) // case 1
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator-	(	long	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1691 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v, -v.sgn);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // cases 3 and 4
  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_unsigned &	u,
		long	v
	)

sc_signed.cpp の 1672 行で定義されています。

{

  if (v == 0) // case 1
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator-	(	long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1653 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v, -v.sgn);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // cases 3 and 4
  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_signed &	u,
		long	v
	)

sc_signed.cpp の 1634 行で定義されています。

{

  if (v == 0) // case 1
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator-	(	uint64	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1615 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v, -v.sgn);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // cases 3 and 4
  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_unsigned &	u,
		uint64	v
	)

sc_signed.cpp の 1595 行で定義されています。

{

  if (v == 0) // case 1
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // cases 3 and 4

  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator-	(	uint64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1576 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v, -v.sgn);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // cases 3 and 4
  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_signed &	u,
		uint64	v
	)

sc_signed.cpp の 1556 行で定義されています。

{

  if (v == 0) // case 1
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // cases 3 and 4

  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator-	(	int64	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1536 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v, -v.sgn);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // cases 3 and 4

  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_unsigned &	u,
		int64	v
	)

sc_signed.cpp の 1517 行で定義されています。

{

  if (v == 0) // case 1
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator-	(	int64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1497 行で定義されています。

{

  if (u == 0) // case 1
    return sc_signed(v, -v.sgn);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO) // case 2
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // cases 3 and 4

  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_signed &	u,
		int64	v
	)

sc_signed.cpp の 1478 行で定義されています。

{

  if (v == 0) // case 1
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator-	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1461 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_signed(u);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(v, -v.sgn);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1444 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_signed(u);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(v, -v.sgn);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1427 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_signed(u);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(v, -v.sgn);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 1410 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_signed(u);

  if (u.sgn == SC_ZERO) // case 2
    return sc_signed(v, -v.sgn);

  // cases 3 and 4
  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           -v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator-	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 890 行で定義されています。

{ return operator-((uint64) u, v); }

sc_signed sc_dt::operator-	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 886 行で定義されています。

{ return operator-(u, (uint64) v); }

sc_signed sc_dt::operator-	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 882 行で定義されています。

{ return operator-((uint64) u, v); }

sc_signed sc_dt::operator-	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 878 行で定義されています。

{ return operator-(u, (uint64) v); }

sc_signed sc_dt::operator-	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 649 行で定義されています。

{ return operator-((int64) u, v); }

sc_signed sc_dt::operator-	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 645 行で定義されています。

{ return operator-(u, (int64) v); }

sc_signed sc_dt::operator-	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 641 行で定義されています。

{ return operator-((int64) u, v); }

sc_signed sc_dt::operator-	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 637 行で定義されています。

{ return operator-(u, (int64) v); }

sc_unsigned sc_dt::operator/	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1418 行で定義されています。

    { return operator/((unsigned long) u,  v); }

sc_unsigned sc_dt::operator/	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1410 行で定義されています。

    { return operator/(u, (unsigned long) v); }

sc_unsigned sc_dt::operator/	(	unsigned long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1129 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) {
    div_by_zero(v.sgn);  // case 1
    return sc_unsigned();  // case 2

  }

  CONVERT_LONG_2(u);

  // other cases
  return div_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
                             v.nbits, v.ndigits, v.digit);
  
}

sc_unsigned sc_dt::operator/	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned.cpp の 1109 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) {
    div_by_zero(v);  // case 1
    return sc_unsigned();  // case 2
  }

  CONVERT_LONG_2(v);

  // other cases
  return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
  
}

sc_unsigned sc_dt::operator/	(	uint64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1088 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) {
    div_by_zero(v.sgn);  // case 1
    return sc_unsigned();  // case 2

  }

  CONVERT_INT64_2(u);

  // other cases
  return div_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
                             v.nbits, v.ndigits, v.digit);
  
}

sc_unsigned sc_dt::operator/	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned.cpp の 1068 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) {
    div_by_zero(v);  // case 1
    return sc_unsigned();  // case 2
  }

  CONVERT_INT64_2(v);

  // other cases
  return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
  
}

sc_unsigned sc_dt::operator/	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1050 行で定義されています。

{

  small_type s = mul_signs(u.sgn, v.sgn);

  if (s == SC_ZERO) {
    div_by_zero(v.sgn); // case 1
    return sc_unsigned();  // case 2
  }

  // other cases
  return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
                             v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator/	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 657 行で定義されています。

{ return operator/((uint64) u, v); }

sc_unsigned sc_dt::operator/	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 654 行で定義されています。

{ return operator/(u, (uint64) v); }

sc_signed sc_dt::operator/	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1587 行で定義されています。

    { return operator/((unsigned long) u, v); }

sc_signed sc_dt::operator/	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1585 行で定義されています。

    { return operator/((long) u, v); }

sc_signed sc_dt::operator/	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1578 行で定義されています。

    { return operator/(u, (unsigned long) v); }

sc_signed sc_dt::operator/	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1576 行で定義されています。

    { return operator/(u, (long) v); }

sc_signed sc_dt::operator/	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_signed.h の 1568 行で定義されています。

    { return operator/((long) u, v); }

sc_signed sc_dt::operator/	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_signed.h の 1563 行で定義されています。

    { return operator/(u, (long) v); }

sc_signed sc_dt::operator/	(	unsigned long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2350 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2

  }

  CONVERT_LONG_2(u);

  // other cases
  return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator/	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed.cpp の 2330 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG_2(v);

  // other cases
  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
  
}

sc_signed sc_dt::operator/	(	long	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2310 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG_2(u);

  // other cases
  return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator/	(	const sc_unsigned &	u,
		long	v
	)

sc_signed.cpp の 2290 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG_2(v);

  // other cases
  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
  
}

sc_signed sc_dt::operator/	(	long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2270 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG_2(u);

  // other cases
  return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator/	(	const sc_signed &	u,
		long	v
	)

sc_signed.cpp の 2250 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_LONG_2(v);

  // other cases
  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
  
}

sc_signed sc_dt::operator/	(	uint64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2229 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2

  }

  CONVERT_INT64_2(u);

  // other cases
  return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator/	(	const sc_signed &	u,
		uint64	v
	)

sc_signed.cpp の 2209 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64_2(v);

  // other cases
  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
  
}

sc_signed sc_dt::operator/	(	int64	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2189 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64_2(u);

  // other cases
  return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator/	(	const sc_unsigned &	u,
		int64	v
	)

sc_signed.cpp の 2169 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64_2(v);

  // other cases
  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
  
}

sc_signed sc_dt::operator/	(	int64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2149 行で定義されています。

{

  small_type s = mul_signs(v.sgn, get_sign(u));

  if (s == SC_ZERO) {
    div_by_zero(v.sgn);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64_2(u);

  // other cases
  return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
                           v.nbits, v.ndigits, v.digit);
  
}

sc_signed sc_dt::operator/	(	const sc_signed &	u,
		int64	v
	)

sc_signed.cpp の 2129 行で定義されています。

{

  small_type s = mul_signs(u.sgn, get_sign(v));

  if (s == SC_ZERO) {
    div_by_zero(v);  // case 1
    return sc_signed();  // case 2
  }

  CONVERT_INT64_2(v);

  // other cases
  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
  
}

sc_signed sc_dt::operator/	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2111 行で定義されています。

{

  small_type s = mul_signs(u.sgn, v.sgn);

  if (s == SC_ZERO) {
    div_by_zero(v.sgn); // case 1
    return sc_signed();  // case 2
  }

  // other cases
  return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator/	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2093 行で定義されています。

{

  small_type s = mul_signs(u.sgn, v.sgn);

  if (s == SC_ZERO) {
    div_by_zero(v.sgn); // case 1
    return sc_signed();  // case 2
  }

  // other cases
  return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator/	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2075 行で定義されています。

{

  small_type s = mul_signs(u.sgn, v.sgn);

  if (s == SC_ZERO) {
    div_by_zero(v.sgn); // case 1
    return sc_signed();  // case 2
  }

  // other cases
  return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
                           v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator/	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 916 行で定義されています。

{ return operator/((uint64) u, v); }

sc_signed sc_dt::operator/	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 912 行で定義されています。

{ return operator/(u, (uint64) v); }

sc_signed sc_dt::operator/	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 691 行で定義されています。

{ return operator/((int64) u, v); }

sc_signed sc_dt::operator/	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 687 行で定義されています。

{ return operator/(u, (int64) v); }

sc_signed sc_dt::operator/	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 683 行で定義されています。

{ return operator / ( SCAST<int64>( u ), v ); }

sc_signed sc_dt::operator/	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 679 行で定義されています。

{ return operator / ( u, SCAST<int64>( v ) ); }

const sc_fxval_fast sc_dt::operator/	(	const sc_fxval_fast &	a,
		const sc_fxval_fast &	b
	)			[inline]

sc_fxval.h の 1724 行で定義されています。

{
    SC_FXVAL_FAST_OBSERVER_READ_( a )
    SC_FXVAL_FAST_OBSERVER_READ_( b )
    return sc_fxval_fast( a.m_val / b.m_val );
}

const sc_fxval sc_dt::operator/	(	const sc_fxval &	a,
		const sc_fxval &	b
	)			[inline]

sc_fxval.h の 972 行で定義されています。

{
    SC_FXVAL_OBSERVER_READ_( a )
    SC_FXVAL_OBSERVER_READ_( b )
    return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ) );
}

const sc_fxval_fast sc_dt::operator/	(	const sc_fxval_fast &	a,
		const sc_fxnum_fast &	b
	)			[inline]

sc_fxnum.h の 3892 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( b )
    return sc_fxval_fast( a.get_val() / b.m_val );
}

const sc_fxval_fast sc_dt::operator/	(	const sc_fxnum_fast &	a,
		const sc_fxval_fast &	b
	)			[inline]

sc_fxnum.h の 3884 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    return sc_fxval_fast( a.m_val / b.get_val() );
}

const sc_fxval_fast sc_dt::operator/	(	const sc_fxnum_fast &	a,
		const sc_fxnum_fast &	b
	)			[inline]

sc_fxnum.h の 3875 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    SC_FXNUM_FAST_OBSERVER_READ_( b )
    return sc_fxval_fast( a.m_val / b.m_val );
}

const sc_fxval sc_dt::operator/	(	const sc_fxval &	a,
		const sc_fxnum &	b
	)			[inline]

sc_fxnum.h の 2773 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( b )
    return sc_fxval( sc_dt::div_scfx_rep( *a.get_rep(), *b.m_rep ) );
}

const sc_fxval sc_dt::operator/	(	const sc_fxnum &	a,
		const sc_fxval &	b
	)			[inline]

sc_fxnum.h の 2765 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.get_rep() ) );
}

const sc_fxval sc_dt::operator/	(	const sc_fxnum &	a,
		const sc_fxnum &	b
	)			[inline]

sc_fxnum.h の 2756 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    SC_FXNUM_OBSERVER_READ_( b )
    return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ) );
}

bool sc_dt::operator<	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1750 行で定義されています。

    { return operator<((unsigned long) u,  v); }

bool sc_dt::operator<	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1748 行で定義されています。

    { return operator<((long) u,  v); }

bool sc_dt::operator<	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1741 行で定義されています。

    { return operator<(u, (unsigned long) v); }

bool sc_dt::operator<	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_unsigned.h の 1739 行で定義されています。

    { return operator<(u, (long) v); }

bool sc_dt::operator<	(	unsigned long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1895 行で定義されています。

{
  CONVERT_LONG(u);
  if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                       v.sgn, v.nbits, v.ndigits, v.digit) < 0)
    return true;
  return false;    
}

bool sc_dt::operator<	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned.cpp の 1884 行で定義されています。

{
  CONVERT_LONG(v);
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0)
    return true;
  return false;
}

bool sc_dt::operator<	(	long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1871 行で定義されています。

{
  if (u < 0)
    return true;
  CONVERT_LONG(u);
  if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                       v.sgn, v.nbits, v.ndigits, v.digit) < 0)
    return true;
  return false;
}

bool sc_dt::operator<	(	const sc_unsigned &	u,
		long	v
	)

sc_unsigned.cpp の 1858 行で定義されています。

{
  if (v < 0)
    return false;
  CONVERT_LONG(v);
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0)
    return true;
  return false;
}

bool sc_dt::operator<	(	uint64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1847 行で定義されています。

{
  CONVERT_INT64(u);
  if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                       v.sgn, v.nbits, v.ndigits, v.digit) < 0)
    return true;
  return false;    
}

bool sc_dt::operator<	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned.cpp の 1836 行で定義されています。

{
  CONVERT_INT64(v);
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0)
    return true;
  return false;
}

bool sc_dt::operator<	(	int64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1823 行で定義されています。

{
  if (u < 0)
    return true;
  CONVERT_INT64(u);
  if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                       v.sgn, v.nbits, v.ndigits, v.digit) < 0)
    return true;
  return false;
}

bool sc_dt::operator<	(	const sc_unsigned &	u,
		int64	v
	)

sc_unsigned.cpp の 1810 行で定義されています。

{
  if (v < 0)
    return false;
  CONVERT_INT64(v);
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0)
    return true;
  return false;
}

bool sc_dt::operator<	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1774 行で定義されています。

{
  if (&u == &v)
    return false;
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       v.sgn, v.nbits, v.ndigits, v.digit) < 0)
    return true;
  return false;
}

bool sc_dt::operator<	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 735 行で定義されています。

{ return operator<((uint64) u, v); }

bool sc_dt::operator<	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 732 行で定義されています。

{ return operator<(u, (uint64) v); }

bool sc_dt::operator<	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 596 行で定義されています。

{ return operator<((int64) u, v); }

bool sc_dt::operator<	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_unsigned.cpp の 593 行で定義されています。

{ return operator<(u, (int64) v); }

bool sc_dt::operator<	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			[inline]

sc_uint_base.h の 695 行で定義されています。

        { return a.m_val < b.m_val; }

bool sc_dt::operator<	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1978 行で定義されています。

    { return operator<((unsigned long) u, v); }

bool sc_dt::operator<	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1976 行で定義されています。

    { return operator<((long) u, v); }

bool sc_dt::operator<	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1969 行で定義されています。

    { return operator<(u, (unsigned long) v); }

bool sc_dt::operator<	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1967 行で定義されています。

    { return operator<(u, (long) v); }

bool sc_dt::operator<	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1798 行で定義されています。

{
  if (u.sgn == SC_NEG)
    return true;
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       v.sgn, v.nbits, v.ndigits, v.digit, 1, 0) < 0)
    return true;
  return false;
}

bool sc_dt::operator<	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_unsigned.cpp の 1786 行で定義されています。

{
  if (v.sgn == SC_NEG)
    return false;
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       v.sgn, v.nbits, v.ndigits, v.digit, 0, 1) < 0)
    return true;
  return false;
}

bool sc_dt::operator<	(	unsigned long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3967 行で定義されています。

{
  CONVERT_LONG(u);

  if (us < v.sgn)
    return true;

  if (us > v.sgn)
    return false;

  // us == v.sgn

  if (us == SC_POS) {

    if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0)
      return true;

  }

  return false;    
}

bool sc_dt::operator<	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed.cpp の 3943 行で定義されています。

{
  CONVERT_LONG(v);

  if (u.sgn < vs)
    return true;

  if (u.sgn > vs)
    return false;

  // u.sgn == vs

  if (vs == SC_POS) {

    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0)
      return true;
    
  }

  return false;
}

bool sc_dt::operator<	(	long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3913 行で定義されています。

{
  CONVERT_LONG(u);

  if (us < v.sgn)
    return true;

  if (us > v.sgn)
    return false;

  // us == v.sgn

  if (us == SC_POS) {

    if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0)
      return true;

  }
  else if (us == SC_NEG) {

    if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) > 0)
      return true;

  }

  return false;
}

bool sc_dt::operator<	(	const sc_signed &	u,
		long	v
	)

sc_signed.cpp の 3881 行で定義されています。

{

  CONVERT_LONG(v);

  if (u.sgn < vs)
    return true;

  if (u.sgn > vs)
    return false;

  // u.sgn == vs

  if (vs == SC_POS) {

    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0)
      return true;

  }
  else if (vs == SC_NEG) {

    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) > 0)
      return true;

  }

  return false;

}

bool sc_dt::operator<	(	uint64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3855 行で定義されています。

{

  CONVERT_INT64(u);

  if (us < v.sgn)
    return true;

  if (us > v.sgn)
    return false;

  // us == v.sgn

  if (us == SC_POS) {

    if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0)
      return true;

  }

  return false;    

}

bool sc_dt::operator<	(	const sc_signed &	u,
		uint64	v
	)

sc_signed.cpp の 3829 行で定義されています。

{

  CONVERT_INT64(v);

  if (u.sgn < vs)
    return true;

  if (u.sgn > vs)
    return false;

  // u.sgn == vs

  if (vs == SC_POS) {

    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0)
      return true;
    
  }

  return false;

}

bool sc_dt::operator<	(	int64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3797 行で定義されています。

{

  CONVERT_INT64(u);

  if (us < v.sgn)
    return true;

  if (us > v.sgn)
    return false;

  // us == v.sgn

  if (us == SC_POS) {

    if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0)
      return true;

  }
  else if (us == SC_NEG) {

    if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) > 0)
      return true;

  }

  return false;

}

bool sc_dt::operator<	(	const sc_signed &	u,
		int64	v
	)

sc_signed.cpp の 3765 行で定義されています。

{

  CONVERT_INT64(v);

  if (u.sgn < vs)
    return true;

  if (u.sgn > vs)
    return false;

  // u.sgn == vs

  if (vs == SC_POS) {

    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0)
      return true;

  }
  else if (vs == SC_NEG) {

    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) > 0)
      return true;

  }

  return false;

}

bool sc_dt::operator<	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3732 行で定義されています。

{

  if (u.sgn < v.sgn)
    return true;

  if (u.sgn > v.sgn)
    return false;

  // u.sgn == v.sgn

  if (&u == &v)
    return false;

  if (u.sgn == SC_POS) {

    if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) < 0)
      return true;

  }
  else if (u.sgn == SC_NEG) {

    if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) > 0)
      return true;

  }

  return false;

}

bool sc_dt::operator<	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1017 行で定義されています。

{ return operator<((uint64) u, v); }

bool sc_dt::operator<	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 1013 行で定義されています。

{ return operator<(u, (uint64) v); }

bool sc_dt::operator<	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 824 行で定義されています。

{ return operator<((int64) u, v); }

bool sc_dt::operator<	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 820 行で定義されています。

{ return operator<(u, (int64) v); }

bool sc_dt::operator<	(	const sc_int_base &	a,
		const sc_int_base &	b
	)			[inline]

sc_int_base.h の 709 行で定義されています。

        { return a.m_val < b.m_val; }

systemc_ostream& sc_dt::operator<<	(	systemc_ostream &	os,
		const sc_string_old &	a
	)			[inline]

sc_string.h の 323 行で定義されています。

{
    a.print( os );
    return os;
}

systemc_ostream& sc_dt::operator<<	(	systemc_ostream &	os,
		sc_numrep	numrep
	)			[inline]

sc_string.h の 314 行で定義されています。

{
    os << to_string( numrep );
    return os;
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_concatref &	v
	)

sc_concatref.h の 544 行で定義されています。

{ 
    return os << v.value();
}

const sc_unsigned sc_dt::operator<<	(	const sc_concatref &	target,
		long	shift
	)			[inline]

sc_concatref.h の 507 行で定義されています。

{
    return target.value() << (int)shift;
}

const sc_unsigned sc_dt::operator<<	(	const sc_concatref &	target,
		unsigned int	shift
	)			[inline]

sc_concatref.h の 501 行で定義されています。

{
    return target.value() << (int)shift;
}

const sc_unsigned sc_dt::operator<<	(	const sc_concatref &	target,
		unsigned long	shift
	)			[inline]

sc_concatref.h の 495 行で定義されています。

{
    return target.value() << (int)shift;
}

const sc_unsigned sc_dt::operator<<	(	const sc_concatref &	target,
		int64	shift
	)			[inline]

sc_concatref.h の 490 行で定義されています。

{
    return target.value() << (int)shift;
}

const sc_unsigned sc_dt::operator<<	(	const sc_concatref &	target,
		uint64	shift
	)			[inline]

sc_concatref.h の 485 行で定義されています。

{
    return target.value() << (int)shift;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_unsigned &	a
	)			[inline]

sc_unsigned.h の 2157 行で定義されています。

{
    a.print( os );
    return os;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_unsigned_subref_r &	a
	)			[inline]

sc_unsigned.h の 2091 行で定義されています。

{
    a.print( os );
    return os;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_unsigned_bitref_r &	a
	)			[inline]

sc_unsigned.h の 2008 行で定義されています。

{
    a.print( os );
    return os;
}

sc_unsigned sc_dt::operator<<	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1615 行で定義されています。

    { return operator<<(u, (unsigned long) v); }

sc_unsigned sc_dt::operator<<	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_unsigned.h の 1613 行で定義されています。

    { return operator<<(u, (long) v); }

sc_unsigned sc_dt::operator<<	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned sc_dt::operator<<	(	const sc_unsigned &	u,
		long	v
	)

sc_unsigned sc_dt::operator<<	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned sc_dt::operator<<	(	const sc_unsigned &	u,
		int64	v
	)

sc_unsigned sc_dt::operator<<	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned sc_dt::operator<<	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 704 行で定義されています。

{ return operator<<(u, (uint64) v); }

sc_unsigned sc_dt::operator<<	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_unsigned.cpp の 565 行で定義されています。

{ return operator<<(u, (int64) v); }

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_uint_base &	a
	)			[inline]

sc_uint_base.h の 1320 行で定義されています。

{
    a.print( os );
    return os;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_uint_subref_r &	a
	)			[inline]

sc_uint_base.h の 1137 行で定義されています。

{
    a.print( os );
    return os;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_uint_bitref_r &	a
	)			[inline]

sc_uint_base.h の 886 行で定義されています。

{
    a.print( os );
    return os;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_signed &	a
	)			[inline]

sc_signed.h の 2351 行で定義されています。

{
    a.print( os );
    return os;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_signed_subref_r &	a
	)			[inline]

sc_signed.h の 2282 行で定義されています。

{
    a.print( os );
    return os;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_signed_bitref_r &	a
	)			[inline]

sc_signed.h の 2214 行で定義されています。

{
    a.print( os );
    return os;
}

sc_signed sc_dt::operator<<	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1842 行で定義されています。

    { return operator<<(u, (unsigned long) v); }

sc_signed sc_dt::operator<<	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1840 行で定義されています。

    { return operator<<(u, (long) v); }

sc_signed sc_dt::operator<<	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed sc_dt::operator<<	(	const sc_signed &	u,
		long	v
	)

sc_signed sc_dt::operator<<	(	const sc_signed &	u,
		uint64	v
	)

sc_signed sc_dt::operator<<	(	const sc_signed &	u,
		int64	v
	)

sc_signed sc_dt::operator<<	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_unsigned sc_dt::operator<<	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_unsigned.cpp の 1571 行で定義されています。

{
  if ((v.sgn == SC_ZERO) || (v.sgn == SC_NEG))
    return sc_unsigned(u);

  return operator<<(u, v.to_ulong());
}

CLASS_TYPE sc_dt::operator<<	(	const CLASS_TYPE &	u,
		unsigned long	v
	)

sc_signed.cpp の 6518 行で定義されています。

CLASS_TYPE sc_dt::operator<<	(	const CLASS_TYPE &	u,
		long	v
	)

sc_signed.cpp の 6509 行で定義されています。

CLASS_TYPE sc_dt::operator<<	(	const CLASS_TYPE &	u,
		uint64	v
	)

sc_signed.cpp の 6479 行で定義されています。

CLASS_TYPE sc_dt::operator<<	(	const CLASS_TYPE &	u,
		int64	v
	)

sc_signed.cpp の 6469 行で定義されています。

CLASS_TYPE sc_dt::operator<<	(	const CLASS_TYPE &	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6424 行で定義されています。

sc_signed sc_dt::operator<<	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 3508 行で定義されています。

{
  if (v.sgn == SC_ZERO)
    return sc_signed(u);

  return operator<<(u, v.to_ulong());
}

sc_signed sc_dt::operator<<	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 977 行で定義されています。

{ return operator<<(u, (uint64) v); }

sc_signed sc_dt::operator<<	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 784 行で定義されています。

{ return operator<<(u, (int64) v); }

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_length_param &	a
	)

sc_length_param.h の 181 行で定義されています。

{
    a.print( os );
    return os;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_int_base &	a
	)			[inline]

sc_int_base.h の 1349 行で定義されています。

{
    a.print( os );
    return os;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_int_subref_r &	a
	)			[inline]

sc_int_base.h の 1166 行で定義されています。

{
    a.print( os );
    return os;
}

std::ostream & sc_dt::operator<<	(	::std::ostream &	os,
		const sc_int_bitref_r &	a
	)			[inline]

sc_int_base.h の 906 行で定義されています。

{
    a.print( os );
    return os;
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_fxval_fast &	a
	)

sc_fxval.h の 2236 行で定義されています。

{
    a.print( os );
    return os;
}

const sc_fxval_fast sc_dt::operator<<	(	const sc_fxval_fast &	a,
		int	b
	)			[inline]

sc_fxval.h の 1755 行で定義されています。

{
    SC_FXVAL_FAST_OBSERVER_READ_( a )
    return sc_fxval_fast( a.m_val * scfx_pow2( b ) );
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_fxtype_params &	a
	)

sc_fxtype_params.h の 322 行で定義されています。

{
    a.print( os );
    return os;
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_fxnum_fast &	a
	)

sc_fxnum.h の 4710 行で定義されています。

{
    a.print( os );
    return os;
}

const sc_fxval_fast sc_dt::operator<<	(	const sc_fxnum_fast &	a,
		int	b
	)			[inline]

sc_fxnum.h の 3921 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    return sc_fxval_fast( a.m_val * scfx_pow2( b ) );
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_fxnum &	a
	)

sc_fxnum.h の 3631 行で定義されています。

{
    a.print( os );
    return os;
}

const sc_fxval sc_dt::operator<<	(	const sc_fxnum &	a,
		int	b
	)			[inline]

sc_fxnum.h の 2804 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    return sc_fxval( sc_dt::lsh_scfx_rep( *a.m_rep, b ) );
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_fxnum_fast_subref &	a
	)

sc_fxnum.h の 2514 行で定義されています。

{
    a.print( os );
    return os;
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_fxnum_subref &	a
	)

sc_fxnum.h の 2163 行で定義されています。

{
    a.print( os );
    return os;
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_fxnum_fast_bitref &	a
	)

sc_fxnum.h の 1813 行で定義されています。

{
    a.print( os );
    return os;
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_fxnum_bitref &	a
	)

sc_fxnum.h の 1591 行で定義されています。

{
    a.print( os );
    return os;
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		sc_fmt	fmt
	)

sc_fxdefs.h の 182 行で定義されています。

{
    return os << to_string( fmt );
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		sc_switch	sw
	)

sc_fxdefs.h の 158 行で定義されています。

{
    return os << to_string( sw );
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		sc_o_mode	o_mode
	)

sc_fxdefs.h の 134 行で定義されています。

{
    return os << to_string( o_mode );
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		sc_q_mode	q_mode
	)

sc_fxdefs.h の 105 行で定義されています。

{
    return os << to_string( q_mode );
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		sc_enc	enc
	)

sc_fxdefs.h の 76 行で定義されています。

{
    return os << to_string( enc );
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_fxcast_switch &	a
	)

sc_fxcast_switch.h の 157 行で定義されています。

{
    a.print( os );
    return os;
}

template<class X>

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_proxy< X > &	a
	)			[inline]

sc_proxy.h の 1510 行で定義されています。

{
    a.print( os );
    return os;
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_logic &	a
	)

sc_logic.h の 581 行で定義されています。

{
    a.print( os );
    return os;
}

inline ::std::ostream& sc_dt::operator<<	(	::std::ostream &	os,
		const sc_bit &	a
	)

sc_bit.h の 759 行で定義されています。

{
    a.print( os );
    return os;
}

bool sc_dt::operator<=	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1779 行で定義されています。

    { return operator<=((unsigned long) u,  v); }

bool sc_dt::operator<=	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1777 行で定義されています。

    { return operator<=((long) u,  v); }

bool sc_dt::operator<=	(	unsigned long	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator<=	(	long	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator<=	(	uint64	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator<=	(	int64	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator<=	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1770 行で定義されています。

    { return operator<=(u, (unsigned long) v); }

bool sc_dt::operator<=	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_unsigned.h の 1768 行で定義されています。

    { return operator<=(u, (long) v); }

bool sc_dt::operator<=	(	const sc_unsigned &	u,
		unsigned long	v
	)

bool sc_dt::operator<=	(	const sc_unsigned &	u,
		long	v
	)

bool sc_dt::operator<=	(	const sc_unsigned &	u,
		uint64	v
	)

bool sc_dt::operator<=	(	const sc_unsigned &	u,
		int64	v
	)

bool sc_dt::operator<=	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator<=	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 742 行で定義されています。

{ return operator<=((uint64) u, v); }

bool sc_dt::operator<=	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 739 行で定義されています。

{ return operator<=(u, (uint64) v); }

bool sc_dt::operator<=	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 603 行で定義されています。

{ return operator<=((int64) u, v); }

bool sc_dt::operator<=	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_unsigned.cpp の 600 行で定義されています。

{ return operator<=(u, (int64) v); }

bool sc_dt::operator<=	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			[inline]

sc_uint_base.h の 698 行で定義されています。

        { return a.m_val <= b.m_val; }

bool sc_dt::operator<=	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 2007 行で定義されています。

    { return operator<=((unsigned long) u, v); }

bool sc_dt::operator<=	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 2005 行で定義されています。

    { return operator<=((long) u, v); }

bool sc_dt::operator<=	(	unsigned long	u,
		const sc_signed &	v
	)

bool sc_dt::operator<=	(	long	u,
		const sc_signed &	v
	)

bool sc_dt::operator<=	(	uint64	u,
		const sc_signed &	v
	)

bool sc_dt::operator<=	(	int64	u,
		const sc_signed &	v
	)

bool sc_dt::operator<=	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1998 行で定義されています。

    { return operator<=(u, (unsigned long) v); }

bool sc_dt::operator<=	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1996 行で定義されています。

    { return operator<=(u, (long) v); }

bool sc_dt::operator<=	(	const sc_signed &	u,
		unsigned long	v
	)

bool sc_dt::operator<=	(	const sc_signed &	u,
		long	v
	)

bool sc_dt::operator<=	(	const sc_signed &	u,
		uint64	v
	)

bool sc_dt::operator<=	(	const sc_signed &	u,
		int64	v
	)

bool sc_dt::operator<=	(	const sc_signed &	u,
		const sc_signed &	v
	)

bool sc_dt::operator<=	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1917 行で定義されています。

{
  return (operator<(u, v) || operator==(u, v));
}

bool sc_dt::operator<=	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_unsigned.cpp の 1910 行で定義されています。

{
  return (operator<(u, v) || operator==(u, v));
}

bool sc_dt::operator<=	(	unsigned long	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6882 行で定義されています。

bool sc_dt::operator<=	(	const CLASS_TYPE &	u,
		unsigned long	v
	)

sc_signed.cpp の 6875 行で定義されています。

bool sc_dt::operator<=	(	long	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6868 行で定義されています。

bool sc_dt::operator<=	(	const CLASS_TYPE &	u,
		long	v
	)

sc_signed.cpp の 6861 行で定義されています。

bool sc_dt::operator<=	(	uint64	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6854 行で定義されています。

bool sc_dt::operator<=	(	const CLASS_TYPE &	u,
		uint64	v
	)

sc_signed.cpp の 6847 行で定義されています。

bool sc_dt::operator<=	(	int64	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6840 行で定義されています。

bool sc_dt::operator<=	(	const CLASS_TYPE &	u,
		int64	v
	)

sc_signed.cpp の 6833 行で定義されています。

bool sc_dt::operator<=	(	const CLASS_TYPE &	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6826 行で定義されています。

bool sc_dt::operator<=	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1026 行で定義されています。

{ return operator<=((uint64) u, v); }

bool sc_dt::operator<=	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 1022 行で定義されています。

{ return operator<=(u, (uint64) v); }

bool sc_dt::operator<=	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 833 行で定義されています。

{ return operator<=((int64) u, v); }

bool sc_dt::operator<=	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 829 行で定義されています。

{ return operator<=(u, (int64) v); }

bool sc_dt::operator<=	(	const sc_int_base &	a,
		const sc_int_base &	b
	)			[inline]

sc_int_base.h の 712 行で定義されています。

        { return a.m_val <= b.m_val; }

bool sc_dt::operator==	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1692 行で定義されています。

    { return operator==((unsigned long) u,  v); }

bool sc_dt::operator==	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1690 行で定義されています。

    { return operator==((long) u,  v); }

bool sc_dt::operator==	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1683 行で定義されています。

    { return operator==(u, (unsigned long) v); }

bool sc_dt::operator==	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_unsigned.h の 1681 行で定義されています。

    { return operator==(u, (long) v); }

bool sc_dt::operator==	(	unsigned long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1739 行で定義されています。

{
  CONVERT_LONG(u);
  if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                       v.sgn, v.nbits, v.ndigits, v.digit) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned.cpp の 1728 行で定義されています。

{
  CONVERT_LONG(v);
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1715 行で定義されています。

{
  if (u < 0)
    return false;
  CONVERT_LONG(u);
  if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                       v.sgn, v.nbits, v.ndigits, v.digit) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	const sc_unsigned &	u,
		long	v
	)

sc_unsigned.cpp の 1702 行で定義されています。

{
  if (v < 0)
    return false;
  CONVERT_LONG(v);
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	uint64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1691 行で定義されています。

{
  CONVERT_INT64(u);
  if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                       v.sgn, v.nbits, v.ndigits, v.digit) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned.cpp の 1680 行で定義されています。

{
  CONVERT_INT64(v);
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	int64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1667 行で定義されています。

{
  if (u < 0)
    return false;
  CONVERT_INT64(u);
  if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                       v.sgn, v.nbits, v.ndigits, v.digit) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	const sc_unsigned &	u,
		int64	v
	)

sc_unsigned.cpp の 1654 行で定義されています。

{
  if (v < 0)
    return false;
  CONVERT_INT64(v);
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1618 行で定義されています。

{
  if (&u == &v)
    return true;
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       v.sgn, v.nbits, v.ndigits, v.digit) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 721 行で定義されています。

{ return operator==((uint64) u, v); }

bool sc_dt::operator==	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 718 行で定義されています。

{ return operator==(u, (uint64) v); }

bool sc_dt::operator==	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 582 行で定義されています。

{ return operator==((int64) u, v); }

bool sc_dt::operator==	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_unsigned.cpp の 579 行で定義されています。

{ return operator==(u, (int64) v); }

bool sc_dt::operator==	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			[inline]

sc_uint_base.h の 689 行で定義されています。

        { return a.m_val == b.m_val; }

bool sc_dt::operator==	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1920 行で定義されています。

    { return operator==((unsigned long) u, v); }

bool sc_dt::operator==	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1918 行で定義されています。

    { return operator==((long) u, v); }

bool sc_dt::operator==	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1911 行で定義されています。

    { return operator==(u, (unsigned long) v); }

bool sc_dt::operator==	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1909 行で定義されています。

    { return operator==(u, (long) v); }

bool sc_dt::operator==	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1642 行で定義されています。

{
  if (u.sgn == SC_NEG)
    return false;
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       v.sgn, v.nbits, v.ndigits, v.digit, 1, 0) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_unsigned.cpp の 1630 行で定義されています。

{
  if (v.sgn == SC_NEG)
    return false;
  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
                       v.sgn, v.nbits, v.ndigits, v.digit, 0, 1) != 0)
    return false;
  return true;
}

bool sc_dt::operator==	(	unsigned long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3704 行で定義されています。

{

  CONVERT_LONG(u);

  if (us != v.sgn)
    return false;

  if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0)
    return false;

  return true;
  
}

bool sc_dt::operator==	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed.cpp の 3687 行で定義されています。

{

  CONVERT_LONG(v);

  if (u.sgn != vs)
    return false;

  if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0)
    return false;

  return true;
  
}

bool sc_dt::operator==	(	long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3670 行で定義されています。

{

  CONVERT_LONG(u);

  if (us != v.sgn)
    return false;

  if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0)
    return false;

  return true;
  
}

bool sc_dt::operator==	(	const sc_signed &	u,
		long	v
	)

sc_signed.cpp の 3653 行で定義されています。

{

  CONVERT_LONG(v);

  if (u.sgn != vs)
    return false;

  if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0)
    return false;

  return true;
  
}

bool sc_dt::operator==	(	uint64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3636 行で定義されています。

{

  CONVERT_INT64(u);

  if (us != v.sgn)
    return false;

  if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0)
    return false;

  return true;
  
}

bool sc_dt::operator==	(	const sc_signed &	u,
		uint64	v
	)

sc_signed.cpp の 3619 行で定義されています。

{

  CONVERT_INT64(v);

  if (u.sgn != vs)
    return false;

  if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0)
    return false;

  return true;
  
}

bool sc_dt::operator==	(	int64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3602 行で定義されています。

{

  CONVERT_INT64(u);

  if (us != v.sgn)
    return false;

  if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0)
    return false;

  return true;
  
}

bool sc_dt::operator==	(	const sc_signed &	u,
		int64	v
	)

sc_signed.cpp の 3585 行で定義されています。

{

  CONVERT_INT64(v);

  if (u.sgn != vs)
    return false;

  if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0)
    return false;

  return true;
  
}

bool sc_dt::operator==	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3567 行で定義されています。

{
 
  if (u.sgn != v.sgn)
    return false;

  if (&u == &v)
    return true;
  
  if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) != 0)
    return false;

  return true;

}

bool sc_dt::operator==	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 999 行で定義されています。

{ return operator==((uint64) u, v); }

bool sc_dt::operator==	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 995 行で定義されています。

{ return operator==(u, (uint64) v); }

bool sc_dt::operator==	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 806 行で定義されています。

{ return operator==((int64) u, v); }

bool sc_dt::operator==	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 802 行で定義されています。

{ return operator==(u, (int64) v); }

bool sc_dt::operator==	(	const sc_length_param &	a,
		const sc_length_param &	b
	)			[inline]

sc_length_param.h の 150 行で定義されています。

{
    return ( a.m_len == b.m_len );
}

bool sc_dt::operator==	(	const sc_int_base &	a,
		const sc_int_base &	b
	)			[inline]

sc_int_base.h の 703 行で定義されています。

        { return a.m_val == b.m_val; }

bool sc_dt::operator==	(	const sc_fxtype_params &	a,
		const sc_fxtype_params &	b
	)			[inline]

sc_fxtype_params.h の 222 行で定義されています。

{
    return ( a.m_wl     == b.m_wl     &&
             a.m_iwl    == b.m_iwl    &&
             a.m_q_mode == b.m_q_mode &&
             a.m_o_mode == b.m_o_mode &&
             a.m_n_bits == b.m_n_bits );
}

bool sc_dt::operator==	(	const sc_fxcast_switch &	a,
		const sc_fxcast_switch &	b
	)			[inline]

sc_fxcast_switch.h の 141 行で定義されています。

{
    return ( a.m_sw == b.m_sw );
}

template<class X, class Y>

bool sc_dt::operator==	(	const sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_lv_base.h の 789 行で定義されています。

{
    const X& x = px.back_cast();
    const Y& y = py.back_cast();
    int x_len = x.length();
    int y_len = y.length();
    if( x_len != y_len ) {
        return false;
    }
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
        if( x.get_word( i ) != y.get_word( i ) ||
            x.get_cword( i ) != y.get_cword( i ) ) {
            return false;
        }
    }
    return true;
}

bool sc_dt::operator==	(	int	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 492 行で定義されています。

        { return ( sc_logic( a ) == b ); }

bool sc_dt::operator==	(	char	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 489 行で定義されています。

        { return ( sc_logic( a ) == b ); }

bool sc_dt::operator==	(	bool	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 486 行で定義されています。

        { return ( sc_logic( a ) == b ); }

bool sc_dt::operator==	(	sc_logic_value_t	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 483 行で定義されています。

        { return ( sc_logic( a ) == b ); }

bool sc_dt::operator==	(	const sc_logic &	a,
		int	b
	)			[inline]

sc_logic.h の 480 行で定義されています。

        { return ( a == sc_logic( b ) ); }

bool sc_dt::operator==	(	const sc_logic &	a,
		char	b
	)			[inline]

sc_logic.h の 477 行で定義されています。

        { return ( a == sc_logic( b ) ); }

bool sc_dt::operator==	(	const sc_logic &	a,
		bool	b
	)			[inline]

sc_logic.h の 474 行で定義されています。

        { return ( a == sc_logic( b ) ); }

bool sc_dt::operator==	(	const sc_logic &	a,
		sc_logic_value_t	b
	)			[inline]

sc_logic.h の 471 行で定義されています。

        { return ( a == sc_logic( b ) ); }

bool sc_dt::operator==	(	const sc_logic &	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 468 行で定義されています。

        { return ( (int) a.m_val == b.m_val ); }

template<class T1, class T2>

bool sc_dt::operator==	(	const sc_bitref_r< T1 > &	a,
		const sc_bitref_r< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 1952 行で定義されています。

{
    return ( (int) a.value() == b.value() );
}

bool sc_dt::operator==	(	char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 428 行で定義されています。

        { return ( sc_bit( a ) == b ); }

bool sc_dt::operator==	(	bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 425 行で定義されています。

        { return ( sc_bit( a ) == b ); }

bool sc_dt::operator==	(	int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 422 行で定義されています。

        { return ( sc_bit( a ) == b ); }

bool sc_dt::operator==	(	const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 419 行で定義されています。

        { return ( a == sc_bit( b ) ); }

bool sc_dt::operator==	(	const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 416 行で定義されています。

        { return ( a == sc_bit( b ) ); }

bool sc_dt::operator==	(	const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 413 行で定義されています。

        { return ( a == sc_bit( b ) ); }

bool sc_dt::operator==	(	const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 410 行で定義されています。

        { return ( a.m_val == b.m_val ); }

bool sc_dt::operator>	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1808 行で定義されています。

    { return operator>((unsigned long) u,  v); }

bool sc_dt::operator>	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1806 行で定義されています。

    { return operator>((long) u,  v); }

bool sc_dt::operator>	(	unsigned long	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator>	(	long	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator>	(	uint64	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator>	(	int64	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator>	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1799 行で定義されています。

    { return operator>(u, (unsigned long) v); }

bool sc_dt::operator>	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_unsigned.h の 1797 行で定義されています。

    { return operator>(u, (long) v); }

bool sc_dt::operator>	(	const sc_unsigned &	u,
		unsigned long	v
	)

bool sc_dt::operator>	(	const sc_unsigned &	u,
		long	v
	)

bool sc_dt::operator>	(	const sc_unsigned &	u,
		uint64	v
	)

bool sc_dt::operator>	(	const sc_unsigned &	u,
		int64	v
	)

bool sc_dt::operator>	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator>	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 749 行で定義されています。

{ return operator>((uint64) u, v); }

bool sc_dt::operator>	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 746 行で定義されています。

{ return operator>(u, (uint64) v); }

bool sc_dt::operator>	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 610 行で定義されています。

{ return operator>((int64) u, v); }

bool sc_dt::operator>	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_unsigned.cpp の 607 行で定義されています。

{ return operator>(u, (int64) v); }

bool sc_dt::operator>	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			[inline]

sc_uint_base.h の 701 行で定義されています。

        { return a.m_val > b.m_val; }

bool sc_dt::operator>	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 2036 行で定義されています。

    { return operator>((unsigned long) u, v); }

bool sc_dt::operator>	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 2034 行で定義されています。

    { return operator>((long) u, v); }

bool sc_dt::operator>	(	unsigned long	u,
		const sc_signed &	v
	)

bool sc_dt::operator>	(	long	u,
		const sc_signed &	v
	)

bool sc_dt::operator>	(	uint64	u,
		const sc_signed &	v
	)

bool sc_dt::operator>	(	int64	u,
		const sc_signed &	v
	)

bool sc_dt::operator>	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 2027 行で定義されています。

    { return operator>(u, (unsigned long) v); }

bool sc_dt::operator>	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 2025 行で定義されています。

    { return operator>(u, (long) v); }

bool sc_dt::operator>	(	const sc_signed &	u,
		unsigned long	v
	)

bool sc_dt::operator>	(	const sc_signed &	u,
		long	v
	)

bool sc_dt::operator>	(	const sc_signed &	u,
		uint64	v
	)

bool sc_dt::operator>	(	const sc_signed &	u,
		int64	v
	)

bool sc_dt::operator>	(	const sc_signed &	u,
		const sc_signed &	v
	)

bool sc_dt::operator>	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1937 行で定義されています。

{
  return (! (operator<=(u, v)));
}

bool sc_dt::operator>	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_unsigned.cpp の 1930 行で定義されています。

{
  return (! (operator<=(u, v)));
}

bool sc_dt::operator>	(	unsigned long	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6949 行で定義されています。

bool sc_dt::operator>	(	const CLASS_TYPE &	u,
		unsigned long	v
	)

sc_signed.cpp の 6942 行で定義されています。

bool sc_dt::operator>	(	long	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6935 行で定義されています。

bool sc_dt::operator>	(	const CLASS_TYPE &	u,
		long	v
	)

sc_signed.cpp の 6928 行で定義されています。

bool sc_dt::operator>	(	uint64	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6921 行で定義されています。

bool sc_dt::operator>	(	const CLASS_TYPE &	u,
		uint64	v
	)

sc_signed.cpp の 6914 行で定義されています。

bool sc_dt::operator>	(	int64	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6907 行で定義されています。

bool sc_dt::operator>	(	const CLASS_TYPE &	u,
		int64	v
	)

sc_signed.cpp の 6900 行で定義されています。

bool sc_dt::operator>	(	const CLASS_TYPE &	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6893 行で定義されています。

bool sc_dt::operator>	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1035 行で定義されています。

{ return operator>((uint64) u, v); }

bool sc_dt::operator>	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 1031 行で定義されています。

{ return operator>(u, (uint64) v); }

bool sc_dt::operator>	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 842 行で定義されています。

{ return operator>((int64) u, v); }

bool sc_dt::operator>	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 838 行で定義されています。

{ return operator>(u, (int64) v); }

bool sc_dt::operator>	(	const sc_int_base &	a,
		const sc_int_base &	b
	)			[inline]

sc_int_base.h の 715 行で定義されています。

        { return a.m_val > b.m_val; }

bool sc_dt::operator>=	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1837 行で定義されています。

    { return operator>=((unsigned long) u,  v); }

bool sc_dt::operator>=	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1835 行で定義されています。

    { return operator>=((long) u,  v); }

bool sc_dt::operator>=	(	unsigned long	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator>=	(	long	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator>=	(	uint64	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator>=	(	int64	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator>=	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1828 行で定義されています。

    { return operator>=(u, (unsigned long) v); }

bool sc_dt::operator>=	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_unsigned.h の 1826 行で定義されています。

    { return operator>=(u, (long) v); }

bool sc_dt::operator>=	(	const sc_unsigned &	u,
		unsigned long	v
	)

bool sc_dt::operator>=	(	const sc_unsigned &	u,
		long	v
	)

bool sc_dt::operator>=	(	const sc_unsigned &	u,
		uint64	v
	)

bool sc_dt::operator>=	(	const sc_unsigned &	u,
		int64	v
	)

bool sc_dt::operator>=	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

bool sc_dt::operator>=	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 756 行で定義されています。

{ return operator>=((uint64) u, v); }

bool sc_dt::operator>=	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 753 行で定義されています。

{ return operator>=(u, (uint64) v); }

bool sc_dt::operator>=	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 617 行で定義されています。

{ return operator>=((int64) u, v); }

bool sc_dt::operator>=	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_unsigned.cpp の 614 行で定義されています。

{ return operator>=(u, (int64) v); }

bool sc_dt::operator>=	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			[inline]

sc_uint_base.h の 704 行で定義されています。

        { return a.m_val >= b.m_val; }

bool sc_dt::operator>=	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 2065 行で定義されています。

    { return operator>=((unsigned long) u, v); }

bool sc_dt::operator>=	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 2063 行で定義されています。

    { return operator>=((long) u, v); }

bool sc_dt::operator>=	(	unsigned long	u,
		const sc_signed &	v
	)

bool sc_dt::operator>=	(	long	u,
		const sc_signed &	v
	)

bool sc_dt::operator>=	(	uint64	u,
		const sc_signed &	v
	)

bool sc_dt::operator>=	(	int64	u,
		const sc_signed &	v
	)

bool sc_dt::operator>=	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 2056 行で定義されています。

    { return operator>=(u, (unsigned long) v); }

bool sc_dt::operator>=	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 2054 行で定義されています。

    { return operator>=(u, (long) v); }

bool sc_dt::operator>=	(	const sc_signed &	u,
		unsigned long	v
	)

bool sc_dt::operator>=	(	const sc_signed &	u,
		long	v
	)

bool sc_dt::operator>=	(	const sc_signed &	u,
		uint64	v
	)

bool sc_dt::operator>=	(	const sc_signed &	u,
		int64	v
	)

bool sc_dt::operator>=	(	const sc_signed &	u,
		const sc_signed &	v
	)

bool sc_dt::operator>=	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1957 行で定義されています。

{
  return (! (operator<(u, v)));
}

bool sc_dt::operator>=	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_unsigned.cpp の 1950 行で定義されています。

{
  return (! (operator<(u, v)));
}

bool sc_dt::operator>=	(	unsigned long	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 7016 行で定義されています。

bool sc_dt::operator>=	(	const CLASS_TYPE &	u,
		unsigned long	v
	)

sc_signed.cpp の 7009 行で定義されています。

bool sc_dt::operator>=	(	long	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 7002 行で定義されています。

bool sc_dt::operator>=	(	const CLASS_TYPE &	u,
		long	v
	)

sc_signed.cpp の 6995 行で定義されています。

bool sc_dt::operator>=	(	uint64	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6988 行で定義されています。

bool sc_dt::operator>=	(	const CLASS_TYPE &	u,
		uint64	v
	)

sc_signed.cpp の 6981 行で定義されています。

bool sc_dt::operator>=	(	int64	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6974 行で定義されています。

bool sc_dt::operator>=	(	const CLASS_TYPE &	u,
		int64	v
	)

sc_signed.cpp の 6967 行で定義されています。

bool sc_dt::operator>=	(	const CLASS_TYPE &	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6960 行で定義されています。

bool sc_dt::operator>=	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 1044 行で定義されています。

{ return operator>=((uint64) u, v); }

bool sc_dt::operator>=	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 1040 行で定義されています。

{ return operator>=(u, (uint64) v); }

bool sc_dt::operator>=	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 851 行で定義されています。

{ return operator>=((int64) u, v); }

bool sc_dt::operator>=	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 847 行で定義されています。

{ return operator>=(u, (int64) v); }

bool sc_dt::operator>=	(	const sc_int_base &	a,
		const sc_int_base &	b
	)			[inline]

sc_int_base.h の 718 行で定義されています。

        { return a.m_val >= b.m_val; }

::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_string_old &	s
	)

sc_string.cpp の 638 行で定義されています。

{
    if( s.rep->ref_count > 1 ) {
        -- s.rep->ref_count;
        s.rep = new sc_string_rep;
    }

    int i = 0;
    char* p = s.rep->str;
    char c;

    // skip white spaces
    while( is.get( c ) && isspace( c ) )
        ;

    for( ; is.good() && ! isspace( c ); is.get( c ) ) {
        if( i > s.rep->alloc - 2 ) {
            s.rep->str[i] = '\0';
            s.rep->resize( (int) (s.rep->alloc * 1.5) );
            p = s.rep->str + i;
        }
        *p ++ = c;
        i ++;
    }
    *p = '\0';

    return is;
}

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_concatref &	a
	)

sc_concatref.h の 551 行で定義されています。

{
    sc_unsigned temp(a.concat_length(0));   
    temp.scan( is );
    a = temp;
    return is;
}

const sc_unsigned sc_dt::operator>>	(	const sc_concatref &	target,
		long	shift
	)			[inline]

sc_concatref.h の 534 行で定義されています。

{
    return target.value() >> (int)shift;
}

const sc_unsigned sc_dt::operator>>	(	const sc_concatref &	target,
		unsigned int	shift
	)			[inline]

sc_concatref.h の 528 行で定義されています。

{
    return target.value() >> (int)shift;
}

const sc_unsigned sc_dt::operator>>	(	const sc_concatref &	target,
		unsigned long	shift
	)			[inline]

sc_concatref.h の 522 行で定義されています。

{
    return target.value() >> (int)shift;
}

const sc_unsigned sc_dt::operator>>	(	const sc_concatref &	target,
		int64	shift
	)			[inline]

sc_concatref.h の 517 行で定義されています。

{
    return target.value() >> (int)shift;
}

const sc_unsigned sc_dt::operator>>	(	const sc_concatref &	target,
		uint64	shift
	)			[inline]

sc_concatref.h の 512 行で定義されています。

{
    return target.value() >> (int)shift;
}

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_unsigned &	a
	)			[inline]

sc_unsigned.h の 2165 行で定義されています。

{
    a.scan( is );
    return is;
}

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_unsigned_subref &	a
	)			[inline]

sc_unsigned.h の 2117 行で定義されています。

{
    a.scan( is );
    return is;
}

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_unsigned_bitref &	a
	)			[inline]

sc_unsigned.h の 2032 行で定義されています。

{
    a.scan( is );
    return is;
}

sc_unsigned sc_dt::operator>>	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1646 行で定義されています。

    { return operator>>(u, (unsigned long) v); }

sc_unsigned sc_dt::operator>>	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_unsigned.h の 1644 行で定義されています。

    { return operator>>(u, (long) v); }

sc_unsigned sc_dt::operator>>	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned sc_dt::operator>>	(	const sc_unsigned &	u,
		long	v
	)

sc_unsigned sc_dt::operator>>	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned sc_dt::operator>>	(	const sc_unsigned &	u,
		int64	v
	)

sc_unsigned sc_dt::operator>>	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned sc_dt::operator>>	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 711 行で定義されています。

{ return operator>>(u, (uint64) v); }

sc_unsigned sc_dt::operator>>	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_unsigned.cpp の 572 行で定義されています。

{ return operator>>(u, (int64) v); }

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_uint_base &	a
	)			[inline]

sc_uint_base.h の 1328 行で定義されています。

{
    a.scan( is );
    return is;
}

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_uint_subref &	a
	)			[inline]

sc_uint_base.h の 1171 行で定義されています。

{
    a.scan( is );
    return is;
}

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_uint_bitref &	a
	)			[inline]

sc_uint_base.h の 960 行で定義されています。

{
    a.scan( is );
    return is;
}

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_signed &	a
	)			[inline]

sc_signed.h の 2359 行で定義されています。

{
    a.scan( is );
    return is;
}

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_signed_subref &	a
	)			[inline]

sc_signed.h の 2310 行で定義されています。

{
    a.scan( is );
    return is;
}

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_signed_bitref &	a
	)			[inline]

sc_signed.h の 2223 行で定義されています。

{
    a.scan( is );
    return is;
}

sc_signed sc_dt::operator>>	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1873 行で定義されています。

    { return operator>>(u, (unsigned long) v); }

sc_signed sc_dt::operator>>	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1871 行で定義されています。

    { return operator>>(u, (long) v); }

sc_signed sc_dt::operator>>	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed sc_dt::operator>>	(	const sc_signed &	u,
		long	v
	)

sc_signed sc_dt::operator>>	(	const sc_signed &	u,
		uint64	v
	)

sc_signed sc_dt::operator>>	(	const sc_signed &	u,
		int64	v
	)

sc_signed sc_dt::operator>>	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_unsigned sc_dt::operator>>	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_unsigned.cpp の 1588 行で定義されています。

{

  if ((v.sgn == SC_ZERO) || (v.sgn == SC_NEG))
    return sc_unsigned(u);

  return operator>>(u, v.to_long());

}

CLASS_TYPE sc_dt::operator>>	(	const CLASS_TYPE &	u,
		unsigned long	v
	)

sc_signed.cpp の 6676 行で定義されています。

CLASS_TYPE sc_dt::operator>>	(	const CLASS_TYPE &	u,
		long	v
	)

sc_signed.cpp の 6666 行で定義されています。

CLASS_TYPE sc_dt::operator>>	(	const CLASS_TYPE &	u,
		uint64	v
	)

sc_signed.cpp の 6637 行で定義されています。

CLASS_TYPE sc_dt::operator>>	(	const CLASS_TYPE &	u,
		int64	v
	)

sc_signed.cpp の 6627 行で定義されています。

CLASS_TYPE sc_dt::operator>>	(	const CLASS_TYPE &	u,
		const CLASS_TYPE &	v
	)

sc_signed.cpp の 6582 行で定義されています。

sc_signed sc_dt::operator>>	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 3525 行で定義されています。

{

  if (v.sgn == SC_ZERO)
    return sc_signed(u);

  return operator>>(u, v.to_ulong());

}

sc_signed sc_dt::operator>>	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 986 行で定義されています。

{ return operator>>(u, (uint64) v); }

sc_signed sc_dt::operator>>	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 793 行で定義されています。

{ return operator>>(u, (int64) v); }

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_int_base &	a
	)			[inline]

sc_int_base.h の 1357 行で定義されています。

{
    a.scan( is );
    return is;
}

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_int_subref &	a
	)			[inline]

sc_int_base.h の 1200 行で定義されています。

{
    a.scan( is );
    return is;
}

std::istream & sc_dt::operator>>	(	::std::istream &	is,
		sc_int_bitref &	a
	)			[inline]

sc_int_base.h の 986 行で定義されています。

{
    a.scan( is );
    return is;
}

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_fxval_fast &	a
	)

sc_fxval.h の 2244 行で定義されています。

{
    a.scan( is );
    return is;
}

const sc_fxval_fast sc_dt::operator>>	(	const sc_fxval_fast &	a,
		int	b
	)			[inline]

sc_fxval.h の 1763 行で定義されています。

{
    SC_FXVAL_FAST_OBSERVER_READ_( a )
    return sc_fxval_fast( a.m_val * scfx_pow2( -b ) );
}

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_fxnum_fast &	a
	)

sc_fxnum.h の 4718 行で定義されています。

{
    a.scan( is );
    return is;
}

const sc_fxval_fast sc_dt::operator>>	(	const sc_fxnum_fast &	a,
		int	b
	)			[inline]

sc_fxnum.h の 3929 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    return sc_fxval_fast( a.m_val * scfx_pow2( -b ) );
}

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_fxnum &	a
	)

sc_fxnum.h の 3639 行で定義されています。

{
    a.scan( is );
    return is;
}

const sc_fxval sc_dt::operator>>	(	const sc_fxnum &	a,
		int	b
	)			[inline]

sc_fxnum.h の 2812 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    return sc_fxval( sc_dt::rsh_scfx_rep( *a.m_rep, b ) );
}

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_fxnum_fast_subref &	a
	)

sc_fxnum.h の 2522 行で定義されています。

{
    a.scan( is );
    return is;
}

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_fxnum_subref &	a
	)

sc_fxnum.h の 2171 行で定義されています。

{
    a.scan( is );
    return is;
}

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_fxnum_fast_bitref &	a
	)

sc_fxnum.h の 1821 行で定義されています。

{
    a.scan( is );
    return is;
}

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_fxnum_bitref &	a
	)

sc_fxnum.h の 1599 行で定義されています。

{
    a.scan( is );
    return is;
}

template<class X>

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_proxy< X > &	a
	)			[inline]

sc_proxy.h の 1519 行で定義されています。

{
    a.scan( is );
    return is;
}

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_logic &	a
	)

sc_logic.h の 589 行で定義されています。

{
    a.scan( is );
    return is;
}

template<class X, class Y>

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_concref< X, Y >	a
	)			[inline]

sc_bit_proxies.h の 3545 行で定義されています。

{
    a.scan( is );
    return is;
}

template<class X>

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_subref< X >	a
	)			[inline]

sc_bit_proxies.h の 3000 行で定義されています。

{
    a.scan( is );
    return is;
}

template<class X>

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_bitref< X >	a
	)			[inline]

sc_bit_proxies.h の 2494 行で定義されています。

{
    a.scan( is );
    return is;
}

template<class T1, class T2>

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	,
		sc_concref< T1, T2 >
	)			[inline]

template<class T>

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	,
		sc_subref< T >
	)			[inline]

template<class T>

::std::istream& sc_dt::operator>>	(	::std::istream &	,
		sc_bitref< T >
	)			[inline]

inline ::std::istream& sc_dt::operator>>	(	::std::istream &	is,
		sc_bit &	a
	)

sc_bit.h の 767 行で定義されています。

{
    a.scan( is );
    return is;
}

sc_unsigned sc_dt::operator^	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1580 行で定義されています。

    { return operator^((unsigned long) u,  v); }

sc_unsigned sc_dt::operator^	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1572 行で定義されています。

    { return operator^(u, (unsigned long) v); }

sc_unsigned sc_dt::operator^	(	unsigned long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1539 行で定義されています。

{
  if (u == 0)
    return sc_unsigned(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)
    return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // other cases
  return xor_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                             v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator^	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned.cpp の 1521 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_unsigned(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // other cases
  return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_unsigned sc_dt::operator^	(	uint64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1503 行で定義されています。

{
  if (u == 0)
    return sc_unsigned(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)
    return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // other cases
  return xor_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                             v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator^	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned.cpp の 1485 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_unsigned(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // other cases
  return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_unsigned sc_dt::operator^	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1468 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_unsigned(u);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_unsigned(v);

  // other cases
  return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                             v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator^	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 697 行で定義されています。

{ return operator^((uint64) u, v); }

sc_unsigned sc_dt::operator^	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 694 行で定義されています。

{ return operator^(u, (uint64) v); }

sc_signed sc_dt::operator^	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1805 行で定義されています。

    { return operator^((unsigned long) u, v); }

sc_signed sc_dt::operator^	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1803 行で定義されています。

    { return operator^((long) u, v); }

sc_signed sc_dt::operator^	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1796 行で定義されています。

    { return operator^(u, (unsigned long) v); }

sc_signed sc_dt::operator^	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1794 行で定義されています。

    { return operator^(u, (long) v); }

sc_signed sc_dt::operator^	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_signed.h の 1786 行で定義されています。

    { return operator^((long) u, v); }

sc_signed sc_dt::operator^	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_signed.h の 1781 行で定義されています。

    { return operator^(u, (long) v); }

sc_signed sc_dt::operator^	(	unsigned long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3476 行で定義されています。

{
  if (u == 0)
    return sc_signed(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // other cases
  return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator^	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed.cpp の 3458 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // other cases
  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator^	(	long	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 3439 行で定義されています。

{

  if (u == 0)
    return sc_signed(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // other cases
  return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator^	(	const sc_unsigned &	u,
		long	v
	)

sc_signed.cpp の 3420 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // other cases
  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator^	(	long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3401 行で定義されています。

{

  if (u == 0)
    return sc_signed(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // other cases
  return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator^	(	const sc_signed &	u,
		long	v
	)

sc_signed.cpp の 3382 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // other cases
  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator^	(	uint64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3364 行で定義されています。

{
  if (u == 0)
    return sc_signed(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // other cases
  return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator^	(	const sc_signed &	u,
		uint64	v
	)

sc_signed.cpp の 3346 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // other cases
  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator^	(	int64	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 3327 行で定義されています。

{

  if (u == 0)
    return sc_signed(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // other cases
  return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator^	(	const sc_unsigned &	u,
		int64	v
	)

sc_signed.cpp の 3308 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // other cases
  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator^	(	int64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3289 行で定義されています。

{

  if (u == 0)
    return sc_signed(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // other cases
  return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator^	(	const sc_signed &	u,
		int64	v
	)

sc_signed.cpp の 3270 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // other cases
  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator^	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3253 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_signed(u);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(v);

  // other cases
  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator^	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 3236 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_signed(u);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(v);

  // other cases
  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator^	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3219 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_signed(u);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(v);

  // other cases
  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                           v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator^	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 968 行で定義されています。

{ return operator^((uint64) u, v); }

sc_signed sc_dt::operator^	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 964 行で定義されています。

{ return operator^(u, (uint64) v); }

sc_signed sc_dt::operator^	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 775 行で定義されています。

{ return operator^((int64) u, v); }

sc_signed sc_dt::operator^	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 771 行で定義されています。

{ return operator^(u, (int64) v); }

sc_signed sc_dt::operator^	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 767 行で定義されています。

{ return operator ^ ( SCAST<int64>( u ), v ); }

sc_signed sc_dt::operator^	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 763 行で定義されています。

{ return operator ^ ( u, SCAST<int64>( v ) ); }

template<class X, class Y>

const sc_lv_base sc_dt::operator^	(	const sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_lv_base.h の 609 行で定義されています。

{
    sc_lv_base a( px.back_cast() );
    return ( a ^= py.back_cast() );
}

const sc_logic sc_dt::operator^	(	int	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 462 行で定義されています。

        { return ( sc_logic( a ) ^ b ); }

const sc_logic sc_dt::operator^	(	char	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 459 行で定義されています。

        { return ( sc_logic( a ) ^ b ); }

const sc_logic sc_dt::operator^	(	bool	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 456 行で定義されています。

        { return ( sc_logic( a ) ^ b ); }

const sc_logic sc_dt::operator^	(	sc_logic_value_t	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 453 行で定義されています。

        { return ( sc_logic( a ) ^ b ); }

const sc_logic sc_dt::operator^	(	const sc_logic &	a,
		int	b
	)			[inline]

sc_logic.h の 450 行で定義されています。

        { return ( a ^ sc_logic( b ) ); }

const sc_logic sc_dt::operator^	(	const sc_logic &	a,
		char	b
	)			[inline]

sc_logic.h の 447 行で定義されています。

        { return ( a ^ sc_logic( b ) ); }

const sc_logic sc_dt::operator^	(	const sc_logic &	a,
		bool	b
	)			[inline]

sc_logic.h の 444 行で定義されています。

        { return ( a ^ sc_logic( b ) ); }

const sc_logic sc_dt::operator^	(	const sc_logic &	a,
		sc_logic_value_t	b
	)			[inline]

sc_logic.h の 441 行で定義されています。

        { return ( a ^ sc_logic( b ) ); }

const sc_logic sc_dt::operator^	(	const sc_logic &	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 438 行で定義されています。

        { return sc_logic( sc_logic::xor_table[a.m_val][b.m_val] ); }

template<class T1, class T2>

const sc_logic sc_dt::operator^	(	const sc_bitref_r< T1 > &	a,
		const sc_bitref_r< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 1941 行で定義されています。

{
    return sc_logic( sc_logic::xor_table[a.value()][b.value()] );
}

const sc_bit sc_dt::operator^	(	char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 692 行で定義されています。

        { return ( sc_bit( a ) ^ b ); }

const sc_bit sc_dt::operator^	(	bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 689 行で定義されています。

        { return ( sc_bit( a ) ^ b ); }

const sc_bit sc_dt::operator^	(	int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 686 行で定義されています。

        { return ( sc_bit( a ) ^ b ); }

const sc_bit sc_dt::operator^	(	const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 683 行で定義されています。

        { return ( a ^ sc_bit( b ) ); }

const sc_bit sc_dt::operator^	(	const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 680 行で定義されています。

        { return ( a ^ sc_bit( b ) ); }

const sc_bit sc_dt::operator^	(	const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 677 行で定義されています。

        { return ( a ^ sc_bit( b ) ); }

const sc_bit sc_dt::operator^	(	const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 674 行で定義されています。

        { return sc_bit( a.m_val != b.m_val ); }

template<class X, class Y>

X & sc_dt::operator^=	(	sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_lv_base.h の 572 行で定義されています。

{
    X& x = px.back_cast();
    sc_lv_base a( x.length() );
    a = py.back_cast();
    return b_xor_assign_( x, a );
}

sc_unsigned sc_dt::operator|	(	unsigned int	u,
		const sc_unsigned &	v
	)			[inline]

sc_unsigned.h の 1540 行で定義されています。

    { return operator|((unsigned long) u,  v); }

sc_unsigned sc_dt::operator|	(	const sc_unsigned &	u,
		unsigned int	v
	)			[inline]

sc_unsigned.h の 1532 行で定義されています。

    { return operator|(u, (unsigned long) v); }

sc_unsigned sc_dt::operator|	(	unsigned long	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1433 行で定義されています。

{

  if (u == 0)
    return sc_unsigned(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)
    return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // other cases
  return or_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                            v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator|	(	const sc_unsigned &	u,
		unsigned long	v
	)

sc_unsigned.cpp の 1414 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_unsigned(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // other cases
  return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                            vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_unsigned sc_dt::operator|	(	uint64	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1395 行で定義されています。

{

  if (u == 0)
    return sc_unsigned(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)
    return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // other cases
  return or_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                            v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator|	(	const sc_unsigned &	u,
		uint64	v
	)

sc_unsigned.cpp の 1376 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_unsigned(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // other cases
  return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                            vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_unsigned sc_dt::operator|	(	const sc_unsigned &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 1359 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_unsigned(u);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_unsigned(v);

  // other cases
  return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                            v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_unsigned sc_dt::operator|	(	const sc_uint_base &	u,
		const sc_unsigned &	v
	)

sc_unsigned.cpp の 687 行で定義されています。

{ return operator|((uint64) u, v); }

sc_unsigned sc_dt::operator|	(	const sc_unsigned &	u,
		const sc_uint_base &	v
	)

sc_unsigned.cpp の 684 行で定義されています。

{ return operator|(u, (uint64) v); }

sc_signed sc_dt::operator|	(	unsigned int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1751 行で定義されています。

    { return operator|((unsigned long) u, v); }

sc_signed sc_dt::operator|	(	int	u,
		const sc_signed &	v
	)			[inline]

sc_signed.h の 1749 行で定義されています。

    { return operator|((long) u, v); }

sc_signed sc_dt::operator|	(	const sc_signed &	u,
		unsigned int	v
	)			[inline]

sc_signed.h の 1742 行で定義されています。

    { return operator|(u, (unsigned long) v); }

sc_signed sc_dt::operator|	(	const sc_signed &	u,
		int	v
	)			[inline]

sc_signed.h の 1740 行で定義されています。

    { return operator|(u, (long) v); }

sc_signed sc_dt::operator|	(	int	u,
		const sc_unsigned &	v
	)			[inline]

sc_signed.h の 1732 行で定義されています。

    { return operator|((long) u, v); }

sc_signed sc_dt::operator|	(	const sc_unsigned &	u,
		int	v
	)			[inline]

sc_signed.h の 1727 行で定義されています。

    { return operator|(u, (long) v); }

sc_signed sc_dt::operator|	(	unsigned long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3184 行で定義されています。

{

  if (u == 0)
    return sc_signed(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // other cases
  return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                          v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator|	(	const sc_signed &	u,
		unsigned long	v
	)

sc_signed.cpp の 3165 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // other cases
  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                          vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator|	(	long	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 3146 行で定義されています。

{

  if (u == 0)
    return sc_signed(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // other cases
  return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                          v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator|	(	const sc_unsigned &	u,
		long	v
	)

sc_signed.cpp の 3127 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // other cases
  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                          vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator|	(	long	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3108 行で定義されています。

{

  if (u == 0)
    return sc_signed(v);

  CONVERT_LONG(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);

  // other cases
  return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
                          v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator|	(	const sc_signed &	u,
		long	v
	)

sc_signed.cpp の 3089 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_LONG(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);

  // other cases
  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                          vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

}

sc_signed sc_dt::operator|	(	uint64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 3070 行で定義されています。

{

  if (u == 0)
    return sc_signed(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // other cases
  return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                          v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator|	(	const sc_signed &	u,
		uint64	v
	)

sc_signed.cpp の 3051 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // other cases
  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                          vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator|	(	int64	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 3032 行で定義されています。

{

  if (u == 0)
    return sc_signed(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // other cases
  return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                          v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator|	(	const sc_unsigned &	u,
		int64	v
	)

sc_signed.cpp の 3013 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // other cases
  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                          vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator|	(	int64	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2994 行で定義されています。

{

  if (u == 0)
    return sc_signed(v);

  CONVERT_INT64(u);

  if (v.sgn == SC_ZERO)
    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);

  // other cases
  return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
                          v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator|	(	const sc_signed &	u,
		int64	v
	)

sc_signed.cpp の 2975 行で定義されています。

{

  if (v == 0)  // case 1
    return sc_signed(u);

  CONVERT_INT64(v);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);

  // other cases
  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                          vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

}

sc_signed sc_dt::operator|	(	const sc_signed &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2958 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_signed(u);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(v);

  // other cases
  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                          v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator|	(	const sc_signed &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 2941 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_signed(u);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(v);

  // other cases
  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                          v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator|	(	const sc_unsigned &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 2924 行で定義されています。

{

  if (v.sgn == SC_ZERO)  // case 1
    return sc_signed(u);

  if (u.sgn == SC_ZERO)  // case 2
    return sc_signed(v);

  // other cases
  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
                          v.sgn, v.nbits, v.ndigits, v.digit);

}

sc_signed sc_dt::operator|	(	const sc_uint_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 955 行で定義されています。

{ return operator|((uint64) u, v); }

sc_signed sc_dt::operator|	(	const sc_signed &	u,
		const sc_uint_base &	v
	)

sc_signed.cpp の 951 行で定義されています。

{ return operator|(u, (uint64) v); }

sc_signed sc_dt::operator|	(	const sc_int_base &	u,
		const sc_signed &	v
	)

sc_signed.cpp の 754 行で定義されています。

{ return operator|((int64) u, v); }

sc_signed sc_dt::operator|	(	const sc_signed &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 750 行で定義されています。

{ return operator|(u, (int64) v); }

sc_signed sc_dt::operator|	(	const sc_int_base &	u,
		const sc_unsigned &	v
	)

sc_signed.cpp の 746 行で定義されています。

{ return operator | ( SCAST<int64>( u ), v ); }

sc_signed sc_dt::operator|	(	const sc_unsigned &	u,
		const sc_int_base &	v
	)

sc_signed.cpp の 742 行で定義されています。

{ return operator | ( u, SCAST<int64>( v ) ); }

template<class X, class Y>

const sc_lv_base sc_dt::operator|	(	const sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_lv_base.h の 507 行で定義されています。

{
    sc_lv_base a( px.back_cast() );
    return ( a |= py.back_cast() );
}

const sc_logic sc_dt::operator|	(	int	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 432 行で定義されています。

        { return ( sc_logic( a ) | b ); }

const sc_logic sc_dt::operator|	(	char	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 429 行で定義されています。

        { return ( sc_logic( a ) | b ); }

const sc_logic sc_dt::operator|	(	bool	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 426 行で定義されています。

        { return ( sc_logic( a ) | b ); }

const sc_logic sc_dt::operator|	(	sc_logic_value_t	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 423 行で定義されています。

        { return ( sc_logic( a ) | b ); }

const sc_logic sc_dt::operator|	(	const sc_logic &	a,
		int	b
	)			[inline]

sc_logic.h の 420 行で定義されています。

        { return ( a | sc_logic( b ) ); }

const sc_logic sc_dt::operator|	(	const sc_logic &	a,
		char	b
	)			[inline]

sc_logic.h の 417 行で定義されています。

        { return ( a | sc_logic( b ) ); }

const sc_logic sc_dt::operator|	(	const sc_logic &	a,
		bool	b
	)			[inline]

sc_logic.h の 414 行で定義されています。

        { return ( a | sc_logic( b ) ); }

const sc_logic sc_dt::operator|	(	const sc_logic &	a,
		sc_logic_value_t	b
	)			[inline]

sc_logic.h の 411 行で定義されています。

        { return ( a | sc_logic( b ) ); }

const sc_logic sc_dt::operator|	(	const sc_logic &	a,
		const sc_logic &	b
	)			[inline]

sc_logic.h の 408 行で定義されています。

        { return sc_logic( sc_logic::or_table[a.m_val][b.m_val] ); }

template<class T1, class T2>

const sc_logic sc_dt::operator|	(	const sc_bitref_r< T1 > &	a,
		const sc_bitref_r< T2 > &	b
	)			[inline]

sc_bit_proxies.h の 1930 行で定義されています。

{
    return sc_logic( sc_logic::or_table[a.value()][b.value()] );
}

const sc_bit sc_dt::operator|	(	char	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 548 行で定義されています。

        { return ( sc_bit( a ) | b ); }

const sc_bit sc_dt::operator|	(	bool	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 545 行で定義されています。

        { return ( sc_bit( a ) | b ); }

const sc_bit sc_dt::operator|	(	int	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 542 行で定義されています。

        { return ( sc_bit( a ) | b ); }

const sc_bit sc_dt::operator|	(	const sc_bit &	a,
		char	b
	)			[inline]

sc_bit.h の 539 行で定義されています。

        { return ( a | sc_bit( b ) ); }

const sc_bit sc_dt::operator|	(	const sc_bit &	a,
		bool	b
	)			[inline]

sc_bit.h の 536 行で定義されています。

        { return ( a | sc_bit( b ) ); }

const sc_bit sc_dt::operator|	(	const sc_bit &	a,
		int	b
	)			[inline]

sc_bit.h の 533 行で定義されています。

        { return ( a | sc_bit( b ) ); }

const sc_bit sc_dt::operator|	(	const sc_bit &	a,
		const sc_bit &	b
	)			[inline]

sc_bit.h の 530 行で定義されています。

        { return sc_bit( a.m_val || b.m_val ); }

template<class X, class Y>

X & sc_dt::operator|=	(	sc_proxy< X > &	px,
		const sc_proxy< Y > &	py
	)			[inline]

sc_lv_base.h の 470 行で定義されています。

{
    X& x = px.back_cast();
    sc_lv_base a( x.length() );
    a = py.back_cast();
    return b_or_assign_( x, a );
}

sc_unsigned sc_dt::operator~

(

const sc_unsigned &

u

)

sc_signed sc_dt::operator~

(

const sc_signed &

u

)

CLASS_TYPE sc_dt::operator~

(

const CLASS_TYPE &

u

)

sc_signed.cpp の 6378 行で定義されています。

const sc_bit sc_dt::operator~

(

const sc_bit &

a

)

[inline]

sc_bit.h の 507 行で定義されています。

        { return sc_bit( ! a.m_val ); }

CLASS_TYPE sc_dt::OR_HELPER	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_signed.cpp の 4512 行で定義されています。

void sc_dt::or_on_help	(	small_type	us,
		int	,
		int	und,
		sc_digit *	ud,
		small_type	vs,
		int	,
		int	vnd,
		const sc_digit *	vd
	)

sc_nbexterns.cpp の 685 行で定義されています。

{
  
  register sc_digit *x = ud;
  register const sc_digit *y = vd;
  int xnd = und;
  int ynd = vnd;

  if (xnd < ynd)
    ynd = xnd;

  const sc_digit *xend = (x + xnd);
  const sc_digit *yend = (y + ynd);

  // x is longer than y.

  small_type s = mul_signs(us, vs);

  if (s > 0) {

    if (us > 0) { // case 3

      while (y < yend)
        (*x++) |= (*y++);

      // No change for the rest of x.

    }
    else {  // case 4

      register sc_digit xcarry = 1;
      register sc_digit ycarry = 1;

      while (y < yend) {
        xcarry += (~(*x) & DIGIT_MASK);
        ycarry += (~(*y++) & DIGIT_MASK);
        (*x++) = (xcarry | ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        xcarry += (~(*x) & DIGIT_MASK);
        ycarry += DIGIT_MASK;
        (*x++) = (xcarry | ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }
    }

  }
  else {

    if (us > 0) { // case 5

      register sc_digit ycarry = 1;

      while (y < yend) {
        ycarry += (~(*y++) & DIGIT_MASK);
        (*x) = ((*x) | ycarry) & DIGIT_MASK;
        x++;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        ycarry += DIGIT_MASK;
        (*x) = ((*x) | ycarry) & DIGIT_MASK;
        x++;
        ycarry >>= BITS_PER_DIGIT;
      }

    }
    else {  // case 6

      register sc_digit xcarry = 1;

      while (y < yend) {
        xcarry += (~(*x) & DIGIT_MASK);
        (*x++) = (xcarry | (*y++)) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        xcarry += (~(*x) & DIGIT_MASK);
        (*x++) = xcarry & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
      }
    }
  }
}

bool sc_dt::or_reduce

(

const sc_concatref &

a

)

[inline]

sc_concatref.h の 451 行で定義されています。

{
    return a.or_reduce();
}

bool sc_dt::or_reduce

(

const sc_uint_base &

a

)

[inline]

sc_uint_base.h の 1290 行で定義されています。

{
    return a.or_reduce();
}

bool sc_dt::or_reduce

(

const sc_uint_subref_r &

a

)

[inline]

sc_uint_base.h の 1107 行で定義されています。

{
    return a.or_reduce();
}

bool sc_dt::or_reduce

(

const sc_int_base &

a

)

[inline]

sc_int_base.h の 1319 行で定義されています。

{
    return a.or_reduce();
}

bool sc_dt::or_reduce

(

const sc_int_subref_r &

a

)

[inline]

sc_int_base.h の 1136 行で定義されています。

{
    return a.or_reduce();
}

template<class X>

sc_logic_value_t sc_dt::or_reduce

(

const sc_proxy< X > &

a

)

[inline]

sc_proxy.h の 1475 行で定義されています。

{
    return a.or_reduce();
}

sc_signed sc_dt::or_signed_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_unsigned sc_dt::or_unsigned_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

static void sc_dt::overflow	(	double &	c,
		const scfx_params &	params,
		bool &	o_flag
	)			[static]

sc_fxnum.cpp の 459 行で定義されています。

{
    int iwl = params.iwl();
    int fwl = params.wl() - iwl;
    double full_circle = scfx_pow2( iwl );
    double resolution = scfx_pow2( -fwl );
    double low, high;
    if( params.enc() == SC_TC_ )
    {
        high = full_circle / 2.0 - resolution;
        if( params.o_mode() == SC_SAT_SYM )
            low = - high;
        else
            low = - full_circle / 2.0;
    }
    else
    {
        low = 0.0;
        high = full_circle - resolution;
    }
    double val = c;
    sc_fxval_fast c2 = c;

    bool under = ( val < low );
    bool over = ( val > high );

    o_flag = ( under || over );

    if( o_flag )
    {
        switch( params.o_mode() )
        {
            case SC_WRAP:                       // wrap-around
            {
                int n_bits = params.n_bits();

                if( n_bits == 0 )
                {
                    // wrap-around all 'wl' bits
                    val -= floor( val / full_circle ) * full_circle;
                    if( val > high )
                        val -= full_circle;
                }
                else if( n_bits < params.wl() )
                {
                    double X = scfx_pow2( iwl - n_bits );

                    // wrap-around least significant 'wl - n_bits' bits
                    val -= floor( val / X ) * X;
                    if( val > ( X - resolution ) )
                        val -= X;
                    
                    // saturate most significant 'n_bits' bits
                    if( under )
                        val += low;
                    else
                    {
                        if( params.enc() == SC_TC_ )
                            val += full_circle / 2.0 - X;
                        else
                            val += full_circle - X;
                    }
                }
                else
                {
                    // saturate all 'wl' bits
                    if( under )
                        val = low;
                    else
                        val = high;
                }
                break;
            }
            case SC_SAT:                        // saturation
            case SC_SAT_SYM:                    // symmetrical saturation
            {
                if( under )
                    val = low;
                else
                    val = high;
                break;
            }
            case SC_SAT_ZERO:                   // saturation to zero
            {
                val = 0.0;
                break;
            }
            case SC_WRAP_SM:                    // sign magnitude wrap-around
            {
                SC_ERROR_IF_( params.enc() == SC_US_,
                              sc_core::SC_ID_WRAP_SM_NOT_DEFINED_ );
        
                int n_bits = params.n_bits();

                if( n_bits == 0 )
                {
                    // invert conditionally
                    if( c2.get_bit( iwl ) != c2.get_bit( iwl - 1 ) )
                        val = -val - resolution;

                    // wrap-around all 'wl' bits
                    val -= floor( val / full_circle ) * full_circle;
                    if( val > high )
                        val -= full_circle;
                }
                else if( n_bits == 1 )
                {
                    // invert conditionally
                    if( c2.is_neg() != c2.get_bit( iwl - 1 ) )
                        val = -val - resolution;

                    // wrap-around all 'wl' bits
                    val -= floor( val / full_circle ) * full_circle;
                    if( val > high )
                        val -= full_circle;
                }
                else if( n_bits < params.wl() )
                {
                    // invert conditionally
                    if( c2.is_neg() == c2.get_bit( iwl - n_bits ) )
                        val = -val - resolution;
                    
                    double X = scfx_pow2( iwl - n_bits );

                    // wrap-around least significant 'wl - n_bits' bits
                    val -= floor( val / X ) * X;
                    if( val > ( X - resolution ) )
                        val -= X;

                    // saturate most significant 'n_bits' bits
                    if( under )
                        val += low;
                    else
                        val += full_circle / 2.0 - X;
                } else {
                    // saturate all 'wl' bits
                    if( under )
                        val = low;
                    else
                        val = high;
                }
                break;
            }
            default:
                ;
        }

        c = val;
    }
}

scfx_rep* sc_dt::overflow_scfx_rep	(	const scfx_rep &	a,
		const scfx_params &	params,
		bool &	o_flag
	)			[inline]

scfx_rep.h の 457 行で定義されています。

{
    scfx_rep& c = *new scfx_rep( a );
    c.overflow( params, o_flag );
    return &c;
}

void sc_dt::parse_binary_bits	(	const char *	src_p,
		int	dst_n,
		sc_digit *	data_p,
		sc_digit *	ctrl_p
	)

sc_nbutils.cpp の 190 行で定義されています。

{
    int      bit_i;    // Number of bit now processing.
    sc_digit ctrl;     // Control word now assembling.
    sc_digit data;     // Data word now assembling.
    int      delta_n;  // src_n - dst_n*BITS_PER_DIGIT.
    int      src_i;    // Index in src_p now accessing (left to right).
    int      src_n;    // Length of source that is left in bits.
    int      word_i;   // Bit within word now accessing (left to right).

    // MAKE SURE WE HAVE A STRING TO PARSE:

    if( src_p == 0 ) {
        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
                         "character string is zero" );
    }
    if( *src_p == 0 ) {
        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
                         "character string is empty" );
    }


    // INDEX INTO THE SOURCE TO A DEPTH THAT WILL ACCOMODATE OUR SIZE:
    //
    // If the source is smaller than our value initialize our value to zero.

    src_n = strlen(src_p);
    delta_n = src_n - (dst_n*BITS_PER_DIGIT);
    if ( delta_n > 0 ) 
    {
        src_p = &src_p[delta_n];
        src_n -= delta_n;
    }
    else
    {
        for ( word_i = 0; word_i < dst_n; word_i++ ) data_p[word_i] = 0;
            if ( ctrl_p ) 
                for ( word_i = 0; word_i < dst_n; word_i++ ) ctrl_p[word_i] = 0;
    }


    // LOOP OVER THE SOURCE ASSEMBLING WORDS AND PLACING THEM IN OUR VALUE:
    //
    // We stride right to left through the source in BITS_PER_DIGIT chunks.
    // Each of those chunks is processed from left to right a bit at a time.
    // We process the high order word specially, since there are less bits.

    src_n = src_n - BITS_PER_DIGIT;
    for (word_i=0; word_i < dst_n; word_i++)
    {
        src_i = src_n;


        // PARTIAL LAST WORD TO ASSEMBLE:

        if ( src_i < 0 ) 
        {
            src_n += BITS_PER_DIGIT;
            src_i = 0;
            data = 0;
            ctrl = 0;
            for ( src_i = 0; src_i < src_n; src_i++ )
            {
                ctrl = ctrl << 1;
                data = data << 1;
                switch( src_p[src_i] )
                {
                  case 'X':
                  case 'x': ctrl = ctrl | 1; data = data | 1; break;
                  case '1': data = data | 1; break;
                  case 'Z':
                  case 'z': ctrl = ctrl | 1; break;
                  case '0':                  break;
                  default:
                    {
                        char msg[BUFSIZ];
                        std::sprintf( msg, "character string '%s' is not valid", 
                        src_p );
                        SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_, msg);
                    }
                    break;
                }
            }
            if ( ctrl_p ) ctrl_p[word_i] = ctrl;
            data_p[word_i] = data;
            break;
        }


        // FULL WORD TO BE ASSEMBLED:

        ctrl = 0;
        data = 0;
        for ( bit_i = 0; bit_i < BITS_PER_DIGIT; bit_i++ )
        {
            ctrl = ctrl << 1;
            data = data << 1;
            switch( src_p[src_i++] )
            {
              case 'X':
              case 'x': ctrl = ctrl | 1; data = data | 1; break;
              case '1': data = data | 1; break;
              case 'Z':
              case 'z': ctrl = ctrl | 1; break;
              case '0':                  break;
              default:
                {
                    char msg[BUFSIZ];
                    std::sprintf( msg, "character string '%s' is not valid", 
                    src_p );
                    SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
                }
                break;
            }
        }
        if ( ctrl_p ) ctrl_p[word_i] = ctrl;
        data_p[word_i] = data;
        src_n = src_n - BITS_PER_DIGIT;
    }
}

void sc_dt::parse_hex_bits	(	const char *	src_p,
		int	dst_n,
		sc_digit *	data_p,
		sc_digit *	ctrl_p
	)

sc_nbutils.cpp の 325 行で定義されています。

{
    sc_digit ctrl;     // Control word now assembling.
    sc_digit data;     // Data word now assembling.
    int      delta_n;  // src_n - dst_n*BITS_PER_DIGIT.
    int      digit_i;  // Number of digit now processing.
    int      src_i;    // Index in src_p now accessing (left to right).
    int      src_n;    // Length of source that is left in bits.
    int      word_i;   // Bit within word now accessing (left to right).

    // MAKE SURE WE HAVE A STRING TO PARSE:

    if( src_p == 0 ) {
        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
                         "character string is zero" );
    }
    if( *src_p == 0 ) {
        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
                         "character string is empty" );
    }


    // INDEX INTO THE SOURCE TO A DEPTH THAT WILL ACCOMODATE OUR SIZE:
    //
    // If the source is smaller than our value initialize our value to zero.

    src_n = strlen(src_p);
    delta_n = src_n - (dst_n*8);
    if ( delta_n > 0 ) 
    {
        src_p = &src_p[delta_n];
        src_n -= delta_n;
    }
    else
    {
        for ( word_i = 0; word_i < dst_n; word_i++ ) data_p[word_i] = 0;
                if ( ctrl_p ) 
                        for ( word_i = 0; word_i < dst_n; word_i++ ) ctrl_p[word_i] = 0;
    }


    // LOOP OVER THE SOURCE ASSEMBLING WORDS AND PLACING THEM IN OUR VALUE:
    //
    // We stride right to left through the source in BITS_PER_DIGIT chunks.
    // Each of those chunks is processed from left to right a bit at a time.
    // We process the high order word specially, since there are less bits.

    src_n = src_n - 8;
    for (word_i=0; word_i < dst_n; word_i++)
    {
        src_i = src_n;


        // PARTIAL LAST WORD TO ASSEMBLE:

        if ( src_i < 0 ) 
        {
            src_n += 8;
            src_i = 0;
            data = 0;
            ctrl = 0;
            for ( src_i = 0; src_i < src_n; src_i++ )
            {
                ctrl = ctrl << 4;
                data = data << 4;
                switch( src_p[src_i] )
                {
                  case 'X':
                  case 'x': ctrl = ctrl | 15; data = data | 15; break;
                  case 'F':
                  case 'f': data = data | 15; break;
                  case 'E':
                  case 'e': data = data | 14; break;
                  case 'D':
                  case 'd': data = data | 13; break;
                  case 'C':
                  case 'c': data = data | 12; break;
                  case 'B':
                  case 'b': data = data | 11; break;
                  case 'A':
                  case 'a': data = data | 10; break;
                  case '9': data = data |  9; break;
                  case '8': data = data |  8; break;
                  case '7': data = data |  7; break;
                  case '6': data = data |  6; break;
                  case '5': data = data |  5; break;
                  case '4': data = data |  4; break;
                  case '3': data = data |  3; break;
                  case '2': data = data |  2; break;
                  case '1': data = data |  1; break;
                  case '0':                  break;
                  case 'Z':
                  case 'z': ctrl = ctrl | 15; break;
                  default:
                    {
                        char msg[BUFSIZ];
                        std::sprintf( msg, "character string '%s' is not valid", 
                        src_p );
                        SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_, msg);
                    }
                    break;
                }
            }
            if ( ctrl_p ) ctrl_p[word_i] = ctrl;
            data_p[word_i] = data;
            break;
        }


        // FULL WORD TO BE ASSEMBLED:

        ctrl = 0;
        data = 0;
        for ( digit_i = 0; digit_i < 8; digit_i++ )
        {
            ctrl = ctrl << 4;
            data = data << 4;
            switch( src_p[src_i++] )
            {
              case 'X':
              case 'x': ctrl = ctrl | 15; data = data | 15; break;
              case 'F':
              case 'f': data = data | 15; break;
              case 'E':
              case 'e': data = data | 14; break;
              case 'D':
              case 'd': data = data | 13; break;
              case 'C':
              case 'c': data = data | 12; break;
              case 'B':
              case 'b': data = data | 11; break;
              case 'A':
              case 'a': data = data | 10; break;
              case '9': data = data |  9; break;
              case '8': data = data |  8; break;
              case '7': data = data |  7; break;
              case '6': data = data |  6; break;
              case '5': data = data |  5; break;
              case '4': data = data |  4; break;
              case '3': data = data |  3; break;
              case '2': data = data |  2; break;
              case '1': data = data |  1; break;
              case '0':                  break;
              case 'Z':
              case 'z': ctrl = ctrl | 15; break;
              default:
                {
                    char msg[BUFSIZ];
                    std::sprintf( msg, "character string '%s' is not valid", 
                    src_p );
                    SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
                }
                break;
            }
        }
        if ( ctrl_p ) ctrl_p[word_i] = ctrl;
        data_p[word_i] = data;
        src_n = src_n - BITS_PER_DIGIT;
    }
}

void sc_dt::print_dec	(	scfx_string &	s,
		const scfx_rep &	num,
		int	w_prefix,
		sc_fmt	fmt
	)

scfx_rep.cpp の 888 行で定義されています。

{
    if( num.is_neg() )
        s += '-';

    if( w_prefix == 1 ) {
        scfx_print_prefix( s, SC_DEC );
    }

    if( num.is_zero() )
    {
        s += '0';
        return;
    }

    // split 'num' into its integer and fractional part

    scfx_rep int_part  = num;
    scfx_rep frac_part = num;

    int i;
    
    for( i = int_part.m_lsw; i <= int_part.m_msw && i < int_part.m_wp; i ++ )
        int_part.m_mant[i] = 0;
    int_part.find_sw();
    if( int_part.m_wp < int_part.m_lsw )
        int_part.resize_to( int_part.size() - int_part.m_wp, -1 );
    
    for( i = frac_part.m_msw;
         i >= frac_part.m_lsw && i >= frac_part.m_wp;
         i -- )
        frac_part.m_mant[i] = 0;
    frac_part.find_sw();
    if( frac_part.m_msw == frac_part.size() - 1 )
        frac_part.resize_to( frac_part.size() + 1, 1 );

    // print integer part

    int int_digits = 0;
    int int_zeros  = 0;
    
    if( ! int_part.is_zero() )
    {
        double int_wl = ( int_part.m_msw - int_part.m_wp ) * bits_in_word
                      + scfx_find_msb( int_part.m_mant[int_part.m_msw] ) + 1;
        int_digits = (int) ceil( int_wl * log10( 2. ) );

        int len = s.length();
        s.append( int_digits );

        bool zero_digits = ( frac_part.is_zero() && fmt != SC_F );

        for( i = int_digits + len - 1; i >= len; i-- )
        {
            unsigned int remainder = int_part.divide_by_ten();
            s[i] = static_cast<char>( '0' + remainder );
            
            if( zero_digits )
            {
                if( remainder == 0 )
                    int_zeros ++;
                else
                    zero_digits = false;
            }
        }

        // discard trailing zeros from int_part
        s.discard( int_zeros );

        if( s[len] == '0' )
        {
            // int_digits was overestimated by one
            s.remove( len );
            -- int_digits;
        }
    }

    // print fractional part

    int frac_digits = 0;
    int frac_zeros  = 0;

    if( ! frac_part.is_zero() )
    {
        s += '.';

        bool zero_digits = ( int_digits == 0 && fmt != SC_F );

        double frac_wl = ( frac_part.m_wp - frac_part.m_msw ) * bits_in_word
                       - scfx_find_msb( frac_part.m_mant[frac_part.m_msw] )
                       - 1;
        frac_zeros = (int) floor( frac_wl * log10( 2. ) );

        scfx_rep temp;
        sc_dt::multiply( temp, frac_part, pow10_fx( frac_zeros ) );
        frac_part = temp;
        if( frac_part.m_msw == frac_part.size() - 1 )
            frac_part.resize_to( frac_part.size() + 1, 1 );
        
        frac_digits = frac_zeros;
        if( ! zero_digits )
        {
            for( i = 0; i < frac_zeros; i ++ )
                s += '0';
            frac_zeros = 0;
        }

        while( ! frac_part.is_zero() )
        {
            frac_part.multiply_by_ten();
            int n = frac_part.m_mant[frac_part.m_msw + 1];
        
            if( zero_digits )
            {
                if( n == 0 )
                    frac_zeros ++;
                else
                    zero_digits = false;
            }
        
            if( ! zero_digits )
                s += static_cast<char>( '0' + n );

            frac_part.m_mant[frac_part.m_msw + 1] = 0;
            frac_digits ++;
        }
    }

    // print exponent
    
    if( fmt != SC_F )
    {
        if( frac_digits == 0 )
            scfx_print_exp( s, int_zeros );
        else if( int_digits == 0 )
            scfx_print_exp( s, - frac_zeros );
    }
}

static void sc_dt::print_dec	(	scfx_string &	s,
		scfx_ieee_double	id,
		int	w_prefix,
		sc_fmt	fmt
	)			[static]

sc_fxval.cpp の 187 行で定義されています。

{
    if( id.negative() != 0 )
    {
        id.negative( 0 );
        s += '-';
    }

    if( w_prefix == 1 ) {
        scfx_print_prefix( s, SC_DEC );
    }

    if( id.is_zero() )
    {
        s += '0';
        return;
    }

    // split 'id' into its integer and fractional part

    double int_part;
    double frac_part = modf( static_cast<double>( id ), &int_part );

    int i;

    // print integer part

    int int_digits = 0;
    int int_zeros  = 0;
    
    if( int_part != 0.0 )
    {
        int_digits = (int) ceil( log10( int_part + 1.0 ) );

        int len = s.length();
        s.append( int_digits );

        bool zero_digits = ( frac_part == 0.0 && fmt != SC_F );

        for( i = int_digits + len - 1; i >= len; i-- )
        {
            unsigned int remainder = (unsigned int) fmod( int_part, 10.0 );
            s[i] = static_cast<char>( '0' + remainder );
            
            if( zero_digits )
            {
                if( remainder == 0 )
                    int_zeros ++;
                else
                    zero_digits = false;
            }

            int_part /= 10.0;
        }

        // discard trailing zeros from int_part
        s.discard( int_zeros );

        if( s[len] == '0' )
        {
            // int_digits was overestimated by one
            s.remove( len );
            -- int_digits;
        }
    }

    // print fractional part

    int frac_digits = 0;
    int frac_zeros  = 0;

    if( frac_part != 0.0 )
    {
        s += '.';

        bool zero_digits = ( int_digits == 0 && fmt != SC_F );

        frac_zeros = (int) floor( - log10( frac_part + DBL_EPSILON ) );

        frac_part *= pow( 10.0, frac_zeros );
        
        frac_digits = frac_zeros;
        if( ! zero_digits )
        {
            for( i = 0; i < frac_zeros; i ++ )
                s += '0';
            frac_zeros = 0;
        }

        while( frac_part != 0.0 )
        {
            frac_part *= 10.0;
            int n = static_cast<int>( frac_part );
        
            if( zero_digits )
            {
                if( n == 0 )
                    frac_zeros ++;
                else
                    zero_digits = false;
            }
        
            if( ! zero_digits )
                s += static_cast<char>( '0' + n );

            frac_part -= n;
            frac_digits ++;
        }
    }

    // print exponent
    
    if( fmt != SC_F )
    {
        if( frac_digits == 0 )
            scfx_print_exp( s, int_zeros );
        else if( int_digits == 0 )
            scfx_print_exp( s, - frac_zeros );
    }
}

void sc_dt::print_other	(	scfx_string &	s,
		const scfx_rep &	a,
		sc_numrep	numrep,
		int	w_prefix,
		sc_fmt	fmt,
		const scfx_params *	params
	)

scfx_rep.cpp の 1028 行で定義されています。

{
    scfx_rep b = a;

    sc_numrep numrep2 = numrep;

    bool numrep_is_sm = ( numrep == SC_BIN_SM ||
                          numrep == SC_OCT_SM ||
                          numrep == SC_HEX_SM );

    if( numrep_is_sm )
    {
        if( b.is_neg() )
        {
            s += '-';
            b = *neg_scfx_rep( a );
        }
        switch( numrep )
        {
            case SC_BIN_SM:
                numrep2 = SC_BIN_US;
                break;
            case SC_OCT_SM:
                numrep2 = SC_OCT_US;
                break;
            case SC_HEX_SM:
                numrep2 = SC_HEX_US;
                break;
            default:
                ;
        }
    }
    
    if( w_prefix != 0 ) {
        scfx_print_prefix( s, numrep );
    }

    numrep = numrep2;

    int msb, lsb;

    if( params != 0 )
    {
        msb = params->iwl() - 1;
        lsb = params->iwl() - params->wl();

        if( params->enc() == SC_TC_ &&
            ( numrep == SC_BIN_US ||
              numrep == SC_OCT_US ||
              numrep == SC_HEX_US ) &&
            ! numrep_is_sm &&
            params->wl() > 1 )
            -- msb;
        else if( params->enc() == SC_US_ &&
            ( numrep == SC_BIN ||
              numrep == SC_OCT ||
              numrep == SC_HEX ||
              numrep == SC_CSD ) )
            ++ msb;
    }
    else
    {
        if( b.is_zero() )
        {
            msb = 0;
            lsb = 0;
        }
        else
        {
            msb = ( b.m_msw - b.m_wp ) * bits_in_word
                + scfx_find_msb( b.m_mant[ b.m_msw ] ) + 1;
            while( b.get_bit( msb ) == b.get_bit( msb - 1 ) )
                -- msb;

            if( numrep == SC_BIN_US ||
                numrep == SC_OCT_US ||
                numrep == SC_HEX_US )
                -- msb;

            lsb = ( b.m_lsw - b.m_wp ) * bits_in_word
                + scfx_find_lsb( b.m_mant[ b.m_lsw ] );
        }
    }

    int step;

    switch( numrep )
    {
        case SC_BIN:
        case SC_BIN_US:
        case SC_CSD:
            step = 1;
           break;
        case SC_OCT:
        case SC_OCT_US:
            step = 3;
            break;
        case SC_HEX:
        case SC_HEX_US:
            step = 4;
            break;
        default:
            step = 0;
    }

    msb = (int) ceil( double( msb + 1 ) / step ) * step - 1;

    lsb = (int) floor( double( lsb ) / step ) * step;

    if( msb < 0 )
    {
        s += '.';
        if( fmt == SC_F )
        {
            int sign = ( b.is_neg() ) ? ( 1 << step ) - 1 : 0;
            for( int i = ( msb + 1 ) / step; i < 0; i ++ )
            {
                if( sign < 10 )
                    s += static_cast<char>( sign + '0' );
                else
                    s += static_cast<char>( sign + 'a' - 10 );
            }
        }
    }

    int i = msb;
    while( i >= lsb )
    {
        int value = 0;
        for( int j = step - 1; j >= 0; -- j )
        {
            value += static_cast<int>( b.get_bit( i ) ) << j;
            -- i;
        }
        if( value < 10 )
            s += static_cast<char>( value + '0' );
        else
            s += static_cast<char>( value + 'a' - 10 );
        if( i == -1 )
            s += '.';
    }

    if( lsb > 0 && fmt == SC_F )
    {
        for( int i = lsb / step; i > 0; i -- )
            s += '0';
    }

    if( s[s.length() - 1] == '.' )
        s.discard( 1 );

    if( fmt != SC_F )
    {
        if( msb < 0 )
            scfx_print_exp( s, ( msb + 1 ) / step );
        else if( lsb > 0 )
            scfx_print_exp( s, lsb / step );
    }

    if( numrep == SC_CSD )
        scfx_tc2csd( s, w_prefix );
}

static void sc_dt::print_other	(	scfx_string &	s,
		const scfx_ieee_double &	id,
		sc_numrep	numrep,
		int	w_prefix,
		sc_fmt	fmt,
		const scfx_params *	params
	)			[static]

sc_fxval.cpp の 311 行で定義されています。

{
    scfx_ieee_double id2 = id;

    sc_numrep numrep2 = numrep;

    bool numrep_is_sm = ( numrep == SC_BIN_SM ||
                          numrep == SC_OCT_SM ||
                          numrep == SC_HEX_SM );

    if( numrep_is_sm )
    {
        if( id2.negative() != 0 )
        {
            s += '-';
            id2.negative( 0 );
        }
        switch( numrep )
        {
            case SC_BIN_SM:
                numrep2 = SC_BIN_US;
                break;
            case SC_OCT_SM:
                numrep2 = SC_OCT_US;
                break;
            case SC_HEX_SM:
                numrep2 = SC_HEX_US;
                break;
            default:
                ;
        }
    }

    if( w_prefix != 0 ) {
        scfx_print_prefix( s, numrep );
    }

    numrep = numrep2;

    sc_fxval_fast a( id2 );

    int msb, lsb;

    if( params != 0 )
    {
        msb = params->iwl() - 1;
        lsb = params->iwl() - params->wl();

        if( params->enc() == SC_TC_ &&
            ( numrep == SC_BIN_US ||
              numrep == SC_OCT_US ||
              numrep == SC_HEX_US ) &&
            ! numrep_is_sm &&
            params->wl() > 1 )
            -- msb;
        else if( params->enc() == SC_US_ &&
            ( numrep == SC_BIN ||
              numrep == SC_OCT ||
              numrep == SC_HEX ||
              numrep == SC_CSD ) )
            ++ msb;
    }
    else
    {
        if( a.is_zero() )
        {
            msb = 0;
            lsb = 0;
        }
        else
        {
            msb = id2.exponent() + 1;
            while( a.get_bit( msb ) == a.get_bit( msb - 1 ) )
                -- msb;

            if( numrep == SC_BIN_US ||
                numrep == SC_OCT_US ||
                numrep == SC_HEX_US )
                -- msb;

            lsb = id2.exponent() - 52;
            while( ! a.get_bit( lsb ) )
                ++ lsb;
        }
    }

    int step;

    switch( numrep )
    {
        case SC_BIN:
        case SC_BIN_US:
        case SC_CSD:
            step = 1;
           break;
        case SC_OCT:
        case SC_OCT_US:
            step = 3;
            break;
        case SC_HEX:
        case SC_HEX_US:
            step = 4;
            break;
        default:
            step = 0;
    }

    msb = (int) ceil( double( msb + 1 ) / step ) * step - 1;

    lsb = (int) floor( double( lsb ) / step ) * step;

    if( msb < 0 )
    {
        s += '.';
        if( fmt == SC_F )
        {
            int sign = ( id2.negative() != 0 ) ? ( 1 << step ) - 1 : 0;
            for( int i = ( msb + 1 ) / step; i < 0; i ++ )
            {
                if( sign < 10 )
                    s += static_cast<char>( sign + '0' );
                else
                    s += static_cast<char>( sign + 'a' - 10 );
            }
        }
    }

    int i = msb;
    while( i >= lsb )
    {
        int value = 0;
        for( int j = step - 1; j >= 0; -- j )
        {
            value += static_cast<int>( a.get_bit( i ) ) << j;
            -- i;
        }
        if( value < 10 )
            s += static_cast<char>( value + '0' );
        else
            s += static_cast<char>( value + 'a' - 10 );
        if( i == -1 )
            s += '.';
    }

    if( lsb > 0 && fmt == SC_F )
    {
        for( int i = lsb / step; i > 0; i -- )
            s += '0';
    }

    if( s[s.length() - 1] == '.' )
        s.discard( 1 );

    if( fmt != SC_F )
    {
        if( msb < 0 )
            scfx_print_exp( s, ( msb + 1 ) / step );
        else if( lsb > 0 )
            scfx_print_exp( s, lsb / step );
    }

    if( numrep == SC_CSD )
        scfx_tc2csd( s, w_prefix );
}

static void sc_dt::quantization	(	double &	c,
		const scfx_params &	params,
		bool &	q_flag
	)			[static]

sc_fxnum.cpp の 380 行で定義されています。

{
    int fwl = params.wl() - params.iwl();
    double scale = scfx_pow2( fwl );
    double val = scale * c;
    double int_part;
    double frac_part = modf( val, &int_part );

    q_flag = ( frac_part != 0.0 );

    if( q_flag )
    {
        val = int_part;

        switch( params.q_mode() )
        {
            case SC_TRN:                        // truncation
            {
                if( c < 0.0 )
                    val -= 1.0;
                break;
            }
            case SC_RND:                        // rounding to plus infinity
            {
                if( frac_part >= 0.5 )
                    val += 1.0;
                else if( frac_part < -0.5 )
                    val -= 1.0;
                break;
            }
            case SC_TRN_ZERO:                   // truncation to zero
            {
                break;
            }
            case SC_RND_INF:                    // rounding to infinity
            {
                if( frac_part >= 0.5 )
                    val += 1.0;
                else if( frac_part <= -0.5 )
                    val -= 1.0;
                break;
            }
            case SC_RND_CONV:                   // convergent rounding
            {
                if( frac_part > 0.5 ||
                    frac_part == 0.5 && fmod( int_part, 2.0 ) != 0.0 )
                    val += 1.0;
                else if( frac_part < -0.5 ||
                         frac_part == -0.5 && fmod( int_part, 2.0 ) != 0.0 )
                    val -= 1.0;
                break;
            }
            case SC_RND_ZERO:                   // rounding to zero
            {
                if( frac_part > 0.5 )
                    val += 1.0;
                else if( frac_part < -0.5 )
                    val -= 1.0;
                break;
            }
            case SC_RND_MIN_INF:                // rounding to minus infinity
            {
                if( frac_part > 0.5 )
                    val += 1.0;
                else if( frac_part <= -0.5 )
                    val -= 1.0;
                break;
            }
            default:
                ;
        }
    }

    val /= scale;
    c = val;
}

scfx_rep* sc_dt::quantization_scfx_rep	(	const scfx_rep &	a,
		const scfx_params &	params,
		bool &	q_flag
	)			[inline]

scfx_rep.h の 446 行で定義されています。

{
    scfx_rep& c = *new scfx_rep( a );
    c.quantization( params, q_flag );
    return &c;
}

template<class X>

const sc_lv_base sc_dt::reverse

(

const sc_proxy< X > &

x

)

[inline]

sc_lv_base.h の 777 行で定義されています。

{
    sc_lv_base a( x.back_cast() );
    return a.reverse();
}

template<class X>

const sc_lv_base sc_dt::rrotate	(	const sc_proxy< X > &	x,
		int	n
	)			[inline]

sc_lv_base.h の 765 行で定義されています。

{
    sc_lv_base a( x.back_cast() );
    return a.rrotate( n );
}

scfx_rep * sc_dt::rsh_scfx_rep	(	const scfx_rep &	a,
		int	b
	)			[inline]

scfx_rep.h の 386 行で定義されています。

{
    scfx_rep& c = *new scfx_rep( a );
    c.rshift( b );
    return &c;
}

void sc_dt::rshift	(	sc_fxval_fast &	c,
		const sc_fxval_fast &	a,
		int	b
	)			[inline]

sc_fxval.h の 1845 行で定義されています。

{
    SC_FXVAL_FAST_OBSERVER_READ_( a )
    c.m_val = a.m_val * scfx_pow2( -b );
    SC_FXVAL_FAST_OBSERVER_WRITE_( c )
}

void sc_dt::rshift	(	sc_fxnum_fast &	c,
		const sc_fxnum_fast &	a,
		int	b
	)			[inline]

sc_fxnum.h の 4096 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    c.m_val = a.m_val * scfx_pow2( -b );
    c.cast();
    SC_FXNUM_FAST_OBSERVER_WRITE_( c )
}

void sc_dt::rshift	(	sc_fxval_fast &	c,
		const sc_fxnum_fast &	a,
		int	b
	)			[inline]

sc_fxnum.h の 4078 行で定義されています。

{
    SC_FXNUM_FAST_OBSERVER_READ_( a )
    c.set_val( a.m_val * scfx_pow2( -b ) );
}

void sc_dt::rshift	(	sc_fxnum &	c,
		const sc_fxnum &	a,
		int	b
	)			[inline]

sc_fxnum.h の 2985 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    delete c.m_rep;
    c.m_rep = sc_dt::rsh_scfx_rep( *a.m_rep, b );
    c.cast();
    SC_FXNUM_OBSERVER_WRITE_( c )
}

void sc_dt::rshift	(	sc_fxval &	c,
		const sc_fxnum &	a,
		int	b
	)			[inline]

sc_fxnum.h の 2966 行で定義されています。

{
    SC_FXNUM_OBSERVER_READ_( a )
    c.set_rep( sc_dt::rsh_scfx_rep( *a.m_rep, b ) );
}

void sc_dt::safe_set	(	int	i,
		bool	v,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 930 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((i >= 0) && (d != NULL));
#endif

  int bit_num = bit_ord(i);
  int digit_num = digit_ord(i);    
  
  if (v)
    d[digit_num] |= one_and_zeros(bit_num);      
  else
    d[digit_num] &= ~(one_and_zeros(bit_num));
  
}

template<class T>

const T sc_dt::sc_abs

(

const T &

a

)

[inline]

sc_macros.h の 69 行で定義されています。

{
    // return ( a >= 0 ? a : -a );
    // the code below is functionaly the same as the code above; the
    // difference is that the code below works for all arithmetic
    // SystemC datatypes.
    T z( a );
    z = 0;
    if( a >= z ) {
        return a;
    } else {
        T c( a );
        c = -a;
        return c;
    }
}

void sc_dt::sc_deprecated_sc_bit

(

)

sc_bit.cpp の 122 行で定義されています。

{
    static bool warn_sc_bit_deprecated=true;
    if ( warn_sc_bit_deprecated )
    {
        warn_sc_bit_deprecated=false;
        SC_REPORT_INFO(sc_core::SC_ID_IEEE_1666_DEPRECATION_,
            "sc_bit is deprecated, use bool instead");
    }
}

void sc_dt::sc_int_concref_invalid_length

(

int

length

)

sc_int_base.cpp の 67 行で定義されています。

{
    char msg[BUFSIZ];
    std::sprintf( msg,
             "sc_int_concref<T1,T2> initialization: length = %d "
             "violates 1 <= length <= %d",
             length, SC_INTWIDTH );
    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
}

sc_numrep sc_dt::sc_io_base	(	systemc_ostream &	stream_object,
		sc_numrep	def_base
	)			[inline]

sc_string.h の 132 行で定義されています。

    {
        return SC_DEC;
    }

bool sc_dt::sc_io_show_base

(

systemc_ostream &

stream_object

)

[inline]

sc_string.h の 137 行で定義されています。

    {
        return false;
    }

template<class T>

const T sc_dt::sc_max	(	const T &	a,
		const T &	b
	)			[inline]

sc_macros.h の 61 行で定義されています。

{
    return ( ( a >= b ) ? a : b );
}

template<class T>

const T sc_dt::sc_min	(	const T &	a,
		const T &	b
	)			[inline]

sc_macros.h の 53 行で定義されています。

{
    return ( ( a <= b ) ? a : b );
}

int sc_dt::sc_roundup	(	int	n,
		int	m
	)			[inline]

sc_string.cpp の 58 行で定義されています。

{
    return ((n - 1) / m + 1) * m;
}

void sc_dt::sc_trace	(	sc_core::sc_trace_file *	tf,
		const sc_fxnum_fast *	object,
		const std::string &	name
	)			[inline]

scfx_other_defs.h の 419 行で定義されています。

{
    if( tf )
        tf->trace( *object, name );
}

void sc_dt::sc_trace	(	sc_core::sc_trace_file *	tf,
		const sc_fxnum_fast &	object,
		const std::string &	name
	)			[inline]

scfx_other_defs.h の 410 行で定義されています。

{
    if( tf )
        tf->trace( object, name );
}

void sc_dt::sc_trace	(	sc_core::sc_trace_file *	tf,
		const sc_fxnum *	object,
		const std::string &	name
	)			[inline]

scfx_other_defs.h の 401 行で定義されています。

{
    if( tf )
        tf->trace( *object, name );
}

void sc_dt::sc_trace	(	sc_core::sc_trace_file *	tf,
		const sc_fxnum &	object,
		const std::string &	name
	)			[inline]

scfx_other_defs.h の 392 行で定義されています。

{
    if( tf )
        tf->trace( object, name );
}

void sc_dt::sc_trace	(	sc_core::sc_trace_file *	tf,
		const sc_fxval_fast *	object,
		const std::string &	name
	)			[inline]

scfx_other_defs.h の 383 行で定義されています。

{
    if( tf )
        tf->trace( *object, name );
}

void sc_dt::sc_trace	(	sc_core::sc_trace_file *	tf,
		const sc_fxval_fast &	object,
		const std::string &	name
	)			[inline]

scfx_other_defs.h の 374 行で定義されています。

{
    if( tf )
        tf->trace( object, name );
}

void sc_dt::sc_trace	(	sc_core::sc_trace_file *	tf,
		const sc_fxval *	object,
		const std::string &	name
	)			[inline]

scfx_other_defs.h の 365 行で定義されています。

{
    if( tf )
        tf->trace( *object, name );
}

void sc_dt::sc_trace	(	sc_core::sc_trace_file *	tf,
		const sc_fxval &	object,
		const std::string &	name
	)			[inline]

scfx_other_defs.h の 356 行で定義されています。

{
    if( tf )
        tf->trace( object, name );
}

void sc_dt::sc_uint_concref_invalid_length

(

int

length

)

sc_uint_base.cpp の 65 行で定義されています。

{
    char msg[BUFSIZ];
    std::sprintf( msg,
             "sc_uint_concref<T1,T2> initialization: length = %d "
             "violates 1 <= length <= %d",
             length, SC_INTWIDTH );
    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
}

void sc_dt::scfx_csd2tc

(

scfx_string &

csd

)

scfx_utils.cpp の 113 行で定義されています。

{
    SC_ASSERT_( csd[0] == '0' && csd[1] == 'c' &&
                csd[2] == 's' && csd[3] == 'd', "invalid prefix" );

    scfx_string s;

    // copy bits from 'csd' into 's'; skip prefix, point, and exponent
    int i = 0;
    s[i ++] = '0';
    int j = 4;
    while( csd[j] )
    {
        if( csd[j] == '-' || csd[j] == '0' || csd[j] == '1' )
            s[i ++] = csd[j];
        else if( csd[j] != '.' )
            break;
        ++ j;
    }
    s[i] = '\0';

    // convert 's' from csd to two's complement
    int len = i;
    i = 1;
    while( i < len )
    {
        while( i < len && s[i] != '-' )
            i ++;
        if( i < len )
        {
            j = i ++;
            s[j --] = '1';
            while( j >= 0 && s[j] == '0' )
                s[j --] = '1';
            if( j >= 0 )
                s[j] = '0';
        }
    }

    // copy bits from 's' back into 'csd'
    j = csd.length();
    csd[j + 1] = '\0';
    while( j > 4 )
    {
        csd[j] = csd[j - 1];
        -- j;
    }
        
    i = 0;
    j = 4;
    while( s[i] )
    {
        if( csd[j] == '.' )
            ++ j;
        csd[j ++] = s[i ++];
    }
}

bool sc_dt::scfx_exp_start

(

const char *

s

)

[inline]

scfx_utils.h の 258 行で定義されています。

{
    if( *s == 'e' || *s == 'E' )
    {
        ++ s;
        if( *s == '+' || *s == '-' )
            return true;
    }
    return false;
}

int sc_dt::scfx_find_lsb

(

unsigned long

x

)

[inline]

scfx_utils.h の 85 行で定義されています。

{
    int i;
#   if defined(SC_LONG_64)
        i = 63;
        LSB_STATEMENT( 32 );
#   else
        i = 31;
#   endif // defined(SC_LONG_64)
    LSB_STATEMENT( 16 );
    LSB_STATEMENT( 8 );
    LSB_STATEMENT( 4 );
    LSB_STATEMENT( 2 );
    LSB_STATEMENT( 1 );
    return i;
}

int sc_dt::scfx_find_msb

(

unsigned long

x

)

[inline]

scfx_utils.h の 65 行で定義されています。

{
    int i = 0;
#   if defined(SC_LONG_64)
        MSB_STATEMENT( 32 );
#   endif // defined(SC_LONG_64)
    MSB_STATEMENT( 16 );
    MSB_STATEMENT( 8 );
    MSB_STATEMENT( 4 );
    MSB_STATEMENT( 2 );
    MSB_STATEMENT( 1 );
    return i;
}

bool sc_dt::scfx_is_digit	(	char	c,
		sc_numrep	numrep
	)			[inline]

scfx_utils.h の 271 行で定義されています。

{
    bool is_digit;

    switch( numrep )
    {
        case SC_DEC:
        {
            switch( c )
            {
                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
                {
                    is_digit = true;
                    break;
                }
                default:
                    is_digit = false;
            }
            break;
        }
        case SC_BIN:
        case SC_BIN_US:
        case SC_BIN_SM:
        {
            switch( c )
            {
                case '0': case '1':
                {
                    is_digit = true;
                    break;
                }
                default:
                    is_digit = false;
            }
            break;
        }
        case SC_OCT:
        case SC_OCT_US:
        case SC_OCT_SM:
        {
            switch( c )
            {
                case '0': case '1': case '2': case '3':
                case '4': case '5': case '6': case '7':
                {
                    is_digit = true;
                    break;
                }
                default:
                    is_digit = false;
            }
            break;
        }
        case SC_HEX:
        case SC_HEX_US:
        case SC_HEX_SM:
        {
            switch( c )
            {
                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                {
                    is_digit = true;
                    break;
                }
                default:
                    is_digit = false;
            }
            break;
        }
        case SC_CSD:
        {
            switch( c )
            {
                case '0': case '1': case '-':
                {
                    is_digit = true;
                    break;
                }
                default:
                    is_digit = false;
            }
            break;
        }
        default:
            is_digit = false;
    }

    return is_digit;
}

bool sc_dt::scfx_is_equal	(	const char *	a,
		const char *	b
	)			[inline]

scfx_utils.h の 232 行で定義されています。

{
    while( *a != 0 && *b != 0 && *a == *b )
    {
        ++ a;
        ++ b;
    }
    return ( *a == 0 && *b == 0 );
}

bool sc_dt::scfx_is_inf

(

const char *

s

)

[inline]

scfx_utils.h の 251 行で定義されています。

{
    return ( scfx_is_equal( s, "Inf" ) || scfx_is_equal( s, "Infinity" ) );
}

bool sc_dt::scfx_is_nan

(

const char *

s

)

[inline]

scfx_utils.h の 244 行で定義されています。

{
    return scfx_is_equal( s, "NaN" );
}

int sc_dt::scfx_parse_base

(

const char *&

s

)

[inline]

scfx_utils.h の 206 行で定義されています。

{
    const char* s1 = s + 1;

    int base = 10;

    if( *s == '0' )
    {
        switch( *s1 )
        {
            case 'b':
            case 'B': base =  2; s += 2; break;
            case 'o':
            case 'O': base =  8; s += 2; break;
            case 'd':
            case 'D': base = 10; s += 2; break;
            case 'x':
            case 'X': base = 16; s += 2; break;
        }
    }

    return base;
}

sc_numrep sc_dt::scfx_parse_prefix

(

const char *&

s

)

[inline]

scfx_utils.h の 134 行で定義されています。

{
    if( s[0] == '0' ) {
        switch( s[1] ) {
        case 'b':
        case 'B':
        {
            if( s[2] == 'u' || s[2] == 'U' && s[3] == 's' || s[3] == 'S' ) {
                s += 4;
                return SC_BIN_US;
            }
            if( s[2] == 's' || s[2] == 'S' && s[3] == 'm' || s[3] == 'M' ) {
                s += 4;
                return SC_BIN_SM;
            }
            s += 2;
            return SC_BIN;
        }
        case 'o':
        case 'O':
        {
            if( s[2] == 'u' || s[2] == 'U' && s[3] == 's' || s[3] == 'S' ) {
                s += 4;
                return SC_OCT_US;
            }
            if( s[2] == 's' || s[2] == 'S' && s[3] == 'm' || s[3] == 'M' ) {
                s += 4;
                return SC_OCT_SM;
            }
            s += 2;
            return SC_OCT;
        }
        case 'x':
        case 'X':
        {
            if( s[2] == 'u' || s[2] == 'U' && s[3] == 's' || s[3] == 'S' ) {
                s += 4;
                return SC_HEX_US;
            }
            if( s[2] == 's' || s[2] == 'S' && s[3] == 'm' || s[3] == 'M' ) {
                s += 4;
                return SC_HEX_SM;
            }
            s += 2;
            return SC_HEX;
        }
        case 'd':
        case 'D':
        {
            s += 2;
            return SC_DEC;
        }
        case 'c':
        case 'C':
        {
            if( s[2] == 's' || s[2] == 'S' && s[3] == 'd' || s[3] == 'D' ) {
                s += 4;
                return SC_CSD;
            }
            break;
        }
        default:
            break;
        }
    }

    return SC_DEC;
}

int sc_dt::scfx_parse_sign	(	const char *&	s,
		bool &	sign_char
	)			[inline]

scfx_utils.h の 111 行で定義されています。

{
    int sign = 1;

    if( *s == '+' )
    {
        ++ s;
        sign_char = true;
    }
    else if( *s == '-' )
    {
        sign = -1;
        ++ s;
        sign_char = true;
    }
    else
        sign_char = false;

    return sign;
}

double sc_dt::scfx_pow2

(

int

exp

)

[inline]

scfx_ieee.h の 627 行で定義されています。

{
    scfx_ieee_double r;
    if( exp < SCFX_IEEE_DOUBLE_E_MIN )
    {
        r = 0.0;
        // handle subnormal case
        exp -= SCFX_IEEE_DOUBLE_E_MIN;
        if( ( exp += 20 ) >= 0 )
        {
            r.mantissa0( 1U << exp );
        }
        else if( ( exp += 32 ) >= 0 )
        {
            r.mantissa1( 1U << exp );
        }
    }
    else if( exp > SCFX_IEEE_DOUBLE_E_MAX )
    {
        r.set_inf();
    }
    else
    {
        r = 1.0;
        r.exponent( exp );
    }
    return r;
}

void sc_dt::scfx_print_exp	(	scfx_string &	s,
		int	exp
	)			[inline]

scfx_utils.h の 487 行で定義されています。

{
    if( exp != 0 )
    {
        s += 'e';
                
        if( exp < 0 )
        {
            exp = - exp;
            s += '-';
        }
        else
            s += '+';

        bool first = true;
        int scale = 1000000000;
        do
        {
            int digit = exp / scale;
            exp = exp % scale;
            if( digit != 0 || ! first )
            {
                s += static_cast<char>( digit + '0' );
                first = false;
            }
            scale /= 10;
        }
        while( scale > 0 );
    }
}

void sc_dt::scfx_print_inf	(	scfx_string &	s,
		bool	negative
	)			[inline]

scfx_utils.h の 433 行で定義されています。

{
    if( negative )
        s += "-Inf";
    else
        s += "Inf";
}

void sc_dt::scfx_print_nan

(

scfx_string &

s

)

[inline]

scfx_utils.h の 426 行で定義されています。

{
    s += "NaN";
}

void sc_dt::scfx_print_prefix	(	scfx_string &	s,
		sc_numrep	numrep
	)			[inline]

scfx_utils.h の 443 行で定義されています。

{
    switch( numrep )
    {
        case SC_DEC:
            s += "0d";
            break;
        case SC_BIN:
            s += "0b";
            break;
        case SC_BIN_US:
            s += "0bus";
            break;
        case SC_BIN_SM:
            s += "0bsm";
            break;
        case SC_OCT:
            s += "0o";
            break;
        case SC_OCT_US:
            s += "0ous";
            break;
        case SC_OCT_SM:
            s += "0osm";
            break;
        case SC_HEX:
            s += "0x";
            break;
        case SC_HEX_US:
            s += "0xus";
            break;
        case SC_HEX_SM:
            s += "0xsm";
            break;
        case SC_CSD:
            s += "0csd";
            break;
        default:
            s += "unknown";
    }
}

void sc_dt::scfx_tc2csd	(	scfx_string &	s,
		int	w_prefix
	)

scfx_utils.cpp の 53 行で定義されています。

{
    if( w_prefix != 0 ) {
        SC_ASSERT_( s[0] == '0' && s[1] == 'c' &&
                    s[2] == 's' && s[3] == 'd', "invalid prefix" );
    }

    scfx_string csd;

    // copy bits from 's' into 'csd'; skip prefix, point, and exponent
    int i = 0;
    int j = (w_prefix != 0 ? 4 : 0);
    while( s[j] )
    {
        if( s[j] == '0' || s[j] == '1' )
            csd[i ++] = s[j];
        else if( s[j] != '.' )
            break;
        ++ j;
    }
    csd[i] = '\0';

    // convert 'csd' from two's complement to csd
    -- i;
    while( i >= 0 )
    {
        if( csd[i] == '0' )
            -- i;
        else
        {
            if( i > 0 && csd[i - 1] == '0' )
                -- i;
            else if( i == 0 )
                csd[i --] = '-';
            else
            {   // i > 0 && csd[i - 1] == '1'
                csd[i --] = '-';
                while( i >= 0 && csd[i] == '1' )
                    csd[i --] = '0';
                if( i > 0 )
                    csd[i] = '1';
                else if( i == 0 )
                    csd[i --] = '1';
            }
        }
    }

    // copy bits from 'csd' back into 's'
    i = 0;
    j = (w_prefix != 0 ? 4 : 0);
    while( csd[i] )
    {
        if( s[j] == '.' )
            ++ j;
        s[j ++] = csd[i ++];
    }
}

int sc_dt::scfx_to_digit	(	char	c,
		sc_numrep	numrep
	)			[inline]

scfx_utils.h の 367 行で定義されています。

{
    int to_digit;
    
    switch( numrep )
    {
        case SC_DEC:
        case SC_BIN:
        case SC_BIN_US:
        case SC_BIN_SM:
        case SC_OCT:
        case SC_OCT_US:
        case SC_OCT_SM:
        {
            to_digit = c - '0';
            break;
        }
        case SC_HEX:
        case SC_HEX_US:
        case SC_HEX_SM:
        {
            switch( c )
            {
                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
                    to_digit = c - '0';
                    break;
                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                    to_digit = c - 'a' + 10;
                    break;
                case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                    to_digit = c - 'A' + 10;
                    break;
                default:
                    to_digit = -2;
            }
            break;
        }
        case SC_CSD:
        {
            if( c == '-' )
                to_digit = -1;
            else
                to_digit = c - '0';
        }
        default:
            to_digit = -2;
    };

    return to_digit;
}

template<class X>

void sc_dt::set_words_	(	X &	x,
		int	wi,
		sc_digit	x_dw,
		sc_digit	x_cw
	)			[inline]

sc_proxy.h の 645 行で定義されています。

{
    x.set_word( wi, x_dw );
    x.set_cword( wi, x_cw );
}

static int sc_dt::sub_mants	(	int	size,
		scfx_mant &	result,
		const scfx_mant &	a,
		const scfx_mant &	b
	)			[inline, static]

scfx_rep.cpp の 1254 行で定義されています。

{
    unsigned carry = 0;

    int index = 0;

    do
    {
        word x = a[index];
        word y = b[index];

        y += carry;
        carry = y < carry;
        y = x - y;
        carry += y > x;
        result[index] = y;
    }
    while( ++ index < size );

    return ( carry ? 1 : 0 );
}

scfx_rep * sc_dt::sub_scfx_rep	(	const scfx_rep &	lhs,
		const scfx_rep &	rhs,
		int	max_wl
	)

scfx_rep.cpp の 1408 行で定義されています。

{
    scfx_rep& result = *new scfx_rep;

    //
    // check for special cases
    //

    if( lhs.is_nan() || rhs.is_nan()
    ||  ( lhs.is_inf() && rhs.is_inf() && lhs.m_sign == rhs.m_sign ) )
    {
        result.set_nan();
        return &result;
    }

    if( lhs.is_inf() )
    {
        result.set_inf( lhs.m_sign );
        return &result;
    }

    if( rhs.is_inf() )
    {
        result.set_inf( -1 * rhs.m_sign );
        return &result;
    }

    //
    // align operands if needed
    //

    scfx_mant_ref lhs_mant;
    scfx_mant_ref rhs_mant;

    int len_mant = lhs.size();
    int new_wp = lhs.m_wp;

    align( lhs, rhs, new_wp, len_mant, lhs_mant, rhs_mant );

    //
    // size the result mantissa
    //

    result.resize_to( len_mant );
    result.m_wp = new_wp;

    //
    // do it
    //

    if( lhs.m_sign != rhs.m_sign )
    {
        add_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
        result.m_sign = lhs.m_sign;
    }
    else
    {
        int cmp = compare_abs( lhs, rhs );

        if( cmp == 1 )
        {
            sub_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
            result.m_sign = lhs.m_sign;
        }
        else if ( cmp == -1 )
        {
            sub_mants( len_mant, result.m_mant, rhs_mant, lhs_mant );
            result.m_sign = -rhs.m_sign;
        } else {
            result.m_mant.clear();
            result.m_sign = 1;
        }
    }

    result.find_sw();
    result.round( max_wl );

    return &result;
}

sc_signed sc_dt::sub_signed_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_unsigned sc_dt::sub_unsigned_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

static int sc_dt::sub_with_index	(	scfx_mant &	a,
		int	a_msw,
		int	a_lsw,
		const scfx_mant &	b,
		int	b_msw,
		int	b_lsw
	)			[inline, static]

scfx_rep.cpp の 1372 行で定義されています。

{
    unsigned carry = 0;

    int size    = b_msw - b_lsw;
    int a_index = a_msw - size;
    int b_index = b_msw - size;

    do
    {
        word x = a[a_index];
        word y = b[b_index];

        y += carry;
        carry = y < carry;
        y = x - y;
        carry += y > x;
        a[a_index] = y;

        a_index ++;
        b_index ++;
    }
    while( size -- );

    if( carry )
    {
        // special case: a[a_msw + 1 ] == 1
        a[a_msw + 1] = 0;
    }

    return ( carry ? 1 : 0 );
}

const std::string sc_dt::to_string

(

sc_numrep

numrep

)

sc_string.cpp の 71 行で定義されています。

{
    switch( numrep )
    {
        case SC_DEC:
            return std::string( "SC_DEC" );
        case SC_BIN:
            return std::string( "SC_BIN" );
        case SC_BIN_US:
            return std::string( "SC_BIN_US" );
        case SC_BIN_SM:
            return std::string( "SC_BIN_SM" );
        case SC_OCT:
            return std::string( "SC_OCT" );
        case SC_OCT_US:
            return std::string( "SC_OCT_US" );
        case SC_OCT_SM:
            return std::string( "SC_OCT_SM" );
        case SC_HEX:
            return std::string( "SC_HEX" );
        case SC_HEX_US:
            return std::string( "SC_HEX_US" );
        case SC_HEX_SM:
            return std::string( "SC_HEX_SM" );
        case SC_CSD:
            return std::string( "SC_CSD" );
        default:
            return std::string( "unknown" );
    }
}

const char * sc_dt::to_string	(	const scfx_ieee_double &	id,
		sc_numrep	numrep,
		int	w_prefix,
		sc_fmt	fmt,
		const scfx_params *	params = 0
	)

sc_fxval.cpp の 479 行で定義されています。

{
    static scfx_string s;

    s.clear();

    if( id.is_nan() )
        scfx_print_nan( s );
    else if( id.is_inf() )
        scfx_print_inf( s, static_cast<bool>( id.negative() ) );
    else if( id.negative() && ! id.is_zero() &&
             ( numrep == SC_BIN_US ||
               numrep == SC_OCT_US ||
               numrep == SC_HEX_US ) )
        s += "negative";
    else if( numrep == SC_DEC )
        sc_dt::print_dec( s, id, w_prefix, fmt );
    else
        sc_dt::print_other( s, id, numrep, w_prefix, fmt, params );

    return s;
}

const std::string sc_dt::to_string

(

sc_fmt

fmt

)

sc_fxdefs.cpp の 158 行で定義されています。

{
    switch( fmt ) {
        case SC_F:
            return std::string( "SC_F" );
        case SC_E:
            return std::string( "SC_E" );
        default:
            return std::string( "unknown" );
    }
}

const std::string sc_dt::to_string

(

sc_switch

sw

)

sc_fxdefs.cpp の 138 行で定義されています。

{
    switch( sw ) {
        case SC_OFF:
            return std::string( "SC_OFF" );
        case SC_ON:
            return std::string( "SC_ON" );
        default:
            return std::string( "unknown" );
    }
}

const std::string sc_dt::to_string

(

sc_o_mode

o_mode

)

sc_fxdefs.cpp の 111 行で定義されています。

{
    switch( o_mode )
    {
        case SC_SAT:
            return std::string( "SC_SAT" );
        case SC_SAT_ZERO:
            return std::string( "SC_SAT_ZERO" );
        case SC_SAT_SYM:
            return std::string( "SC_SAT_SYM" );
        case SC_WRAP:
            return std::string( "SC_WRAP" );
        case SC_WRAP_SM:
            return std::string( "SC_WRAP_SM" );
        default:
            return std::string( "unknown" );
    }
}

const std::string sc_dt::to_string

(

sc_q_mode

q_mode

)

sc_fxdefs.cpp の 80 行で定義されています。

{
    switch( q_mode )
    {
        case SC_RND:
            return std::string( "SC_RND" );
        case SC_RND_ZERO:
            return std::string( "SC_RND_ZERO" );
        case SC_RND_MIN_INF:
            return std::string( "SC_RND_MIN_INF" );
        case SC_RND_INF:
            return std::string( "SC_RND_INF" );
        case SC_RND_CONV:
            return std::string( "SC_RND_CONV" );
        case SC_TRN:
            return std::string( "SC_TRN" );
        case SC_TRN_ZERO:
            return std::string( "SC_TRN_ZERO" );
        default:
            return std::string( "unknown" );
    }
}

const std::string sc_dt::to_string

(

sc_enc

enc

)

sc_fxdefs.cpp の 59 行で定義されています。

{
    switch( enc )
    {
        case SC_TC_:
            return std::string( "SC_TC_" );
        case SC_US_:
            return std::string( "SC_US_" );
        default:
            return std::string( "unknown" );
    }
}

void sc_dt::trim	(	small_type	added,
		int	nb,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 704 行で定義されています。

{
#ifdef DEBUG_SYSTEMC
  assert((nb > 0) && (nd > 0) && (d != NULL));
#endif

  d[nd - 1] &= one_and_ones(bit_ord(nb - 1) + added);    
}

void sc_dt::trim_signed	(	int	nb,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 745 行で定義されています。

{
#ifdef DEBUG_SYSTEMC
  assert((nb > 0) && (nd > 0) && (d != NULL));
#endif

  d[nd - 1] &= one_and_ones(bit_ord(nb - 1) + 1);
}

void sc_dt::trim_unsigned	(	int	nb,
		int	nd,
		sc_digit *	d
	)			[inline]

sc_nbutils.h の 828 行で定義されています。

{
#ifdef DEBUG_SYSTEMC
  assert((nb > 0) && (nd > 0) && (d != NULL));
#endif

  d[nd - 1] &= one_and_ones(bit_ord(nb - 1));    
}

double sc_dt::uint64_to_double

(

uint64

a

)

[inline]

scfx_ieee.h の 666 行で定義されています。

{
#if defined( _MSC_VER )
    // conversion from uint64 to double not implemented; use int64
    double tmp = static_cast<double>( static_cast<int64>( a ) );
    return ( tmp >= 0 ) ? tmp : tmp + sc_dt::scfx_pow2( 64 );
#else
    return static_cast<double>( a );
#endif
}

void sc_dt::vec_add	(	int	ulen,
		const sc_digit *	u,
		int	vlen,
		const sc_digit *	v,
		sc_digit *	w
	)

sc_nbutils.cpp の 577 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((vlen > 0) && (v != NULL));
  assert(w != NULL);
  assert(ulen >= vlen);
#endif

  const sc_digit *uend = (u + ulen);
  const sc_digit *vend = (v + vlen);

  register sc_digit carry = 0;   // Also used as sum to save space.

  // Add along the shorter v.
  while (v < vend) {
    carry += (*u++) + (*v++);
    (*w++) = carry & DIGIT_MASK;
    carry >>= BITS_PER_DIGIT;
  }

  // Propagate the carry.
  while (carry && (u < uend)) {
    carry = (*u++) + 1;
    (*w++) = carry & DIGIT_MASK;
    carry >>= BITS_PER_DIGIT;
  }

  // Copy the rest of u to the result.
  while (u < uend)
    (*w++) = (*u++);

  // Propagate the carry if it is still 1.
  if (carry)
    (*w) = 1;

}

void sc_dt::vec_add_on	(	int	ulen,
		sc_digit *	ubegin,
		int	vlen,
		const sc_digit *	v
	)

sc_nbutils.cpp の 622 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (ubegin != NULL));
  assert((vlen > 0) && (v != NULL));
  assert(ulen >= vlen);
#endif

  register sc_digit *u = ubegin;
  const sc_digit *uend = (u + ulen);
  const sc_digit *vend = (v + vlen);

  register sc_digit carry = 0;   // Also used as sum to save space.

  // Add along the shorter v.
  while (v < vend) {
    carry += (*u) + (*v++);
    (*u++) = carry & DIGIT_MASK;
    carry >>= BITS_PER_DIGIT;
  }

  // Propagate the carry.
  while (carry && (u < uend)) {
    carry = (*u) + 1;
    (*u++) = carry & DIGIT_MASK;
    carry >>= BITS_PER_DIGIT;
  }

#ifdef DEBUG_SYSTEMC
  if( carry != 0 ) {
      SC_REPORT_WARNING( sc_core::SC_ID_WITHOUT_MESSAGE_,
                         "vec_add_on( int, sc_digit*, int, const "
                         "sc_digit* ) : "
                         "result of addition is wrapped around" );
  }
#endif

}

void sc_dt::vec_add_on2	(	int	ulen,
		sc_digit *	ubegin,
		int	,
		const sc_digit *	v
	)

sc_nbutils.cpp の 667 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (ubegin != NULL));
  assert((vlen > 0) && (v != NULL));
  assert(ulen < vlen);
#endif

  register sc_digit *u = ubegin;
  const sc_digit *uend = (u + ulen);

  register sc_digit carry = 0;   // Also used as sum to save space.

  // Add along the shorter u.
  while (u < uend) {
    carry += (*u) + (*v++);
    (*u++) = carry & DIGIT_MASK;
    carry >>= BITS_PER_DIGIT;
  }

#ifdef DEBUG_SYSTEMC
  if( carry != 0 ) {
      SC_REPORT_WARNING( sc_core::SC_ID_WITHOUT_MESSAGE_,
                         "vec_add_on2( int, sc_digit*, int, const "
                         "sc_digit* ) : "
                         "result of addition is wrapped around" );
  }
#endif
}

void sc_dt::vec_add_small	(	int	ulen,
		const sc_digit *	u,
		sc_digit	v,
		sc_digit *	w
	)

sc_nbutils.cpp の 706 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert(w != NULL);
#endif

  const sc_digit *uend = (u + ulen);

  // Add along the shorter v.
  register sc_digit carry = (*u++) + v;
  (*w++) = carry & DIGIT_MASK;
  carry >>= BITS_PER_DIGIT;

  // Propagate the carry.
  while (carry && (u < uend)) {
    carry = (*u++) + 1;
    (*w++) = carry & DIGIT_MASK;
    carry >>= BITS_PER_DIGIT;
  }

  // Copy the rest of u to the result.
  while (u < uend)
    (*w++) = (*u++);

  // Propagate the carry if it is still 1.
  if (carry)
    (*w) = 1;

}

void sc_dt::vec_add_small_on	(	int	ulen,
		sc_digit *	u,
		sc_digit	v
	)

sc_nbutils.cpp の 742 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
#endif

  register int i = 0;

  while (v && (i < ulen)) {
    v += u[i];
    u[i++] = v & DIGIT_MASK;
    v >>= BITS_PER_DIGIT;
  }

#ifdef DEBUG_SYSTEMC
  if( v != 0 ) {
      SC_REPORT_WARNING( sc_core::SC_ID_WITHOUT_MESSAGE_,
                         "vec_add_small_on( int, sc_digit*, unsigned "
                         "long ) : "
                         "result of addition is wrapped around" );
  }
#endif

}

int sc_dt::vec_cmp	(	int	ulen,
		const sc_digit *	u,
		int	vlen,
		const sc_digit *	v
	)			[inline]

sc_nbutils.h の 363 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  // assert((ulen <= 0) || (u != NULL));
  // assert((vlen <= 0) || (v != NULL));

  // ulen and vlen can be equal to 0 because vec_cmp can be called
  // after vec_skip_leading_zeros.
  assert((ulen >= 0) && (u != NULL));
  assert((vlen >= 0) && (v != NULL));
  // If ulen > 0, then the leading digit of u must be non-zero.
  assert((ulen <= 0) || (u[ulen - 1] != 0));
  assert((vlen <= 0) || (v[vlen - 1] != 0));
#endif

  if (ulen != vlen)
    return (ulen - vlen);

  // ulen == vlen >= 1
  while ((--ulen >= 0) && (u[ulen] == v[ulen]))
    ;

  if (ulen < 0)
    return 0;

#ifdef DEBUG_SYSTEMC
  // Test to see if the result is wrong due to the presence of
  // overflow bits.
  assert((u[ulen] & DIGIT_MASK) != (v[ulen] & DIGIT_MASK));
#endif

  return (int) (u[ulen] - v[ulen]);

}

void sc_dt::vec_complement	(	int	ulen,
		sc_digit *	u
	)			[inline]

sc_nbutils.h の 519 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
#endif

  register sc_digit carry = 1;

  for (register int i = 0; i < ulen; ++i) {
    carry += (~u[i] & DIGIT_MASK);
    u[i] = carry & DIGIT_MASK;
    carry >>= BITS_PER_DIGIT;
  }
  
}

void sc_dt::vec_copy	(	int	n,
		sc_digit *	u,
		const sc_digit *	v
	)			[inline]

sc_nbutils.h の 487 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((n > 0) && (u != NULL) && (v != NULL));
#endif

  for (register int i = 0; i < n; ++i)
    u[i] = v[i];
}

void sc_dt::vec_copy_and_zero	(	int	ulen,
		sc_digit *	u,
		int	vlen,
		const sc_digit *	v
	)			[inline]

sc_nbutils.h の 501 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((vlen > 0) && (v != NULL));
  assert(ulen >= vlen);
#endif

  vec_copy(vlen, u, v);
  vec_zero(vlen, ulen, u);

}

void sc_dt::vec_div_large	(	int	ulen,
		const sc_digit *	u,
		int	vlen,
		const sc_digit *	v,
		sc_digit *	w
	)

sc_nbutils.cpp の 1158 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((vlen > 0) && (v != NULL));
  assert(w != NULL);
  assert(BITS_PER_DIGIT >= 3 * BITS_PER_BYTE);
#endif

  // We will compute q = x / y where x = u and y = v. The reason for
  // using x and y is that x and y are BYTE_RADIX copies of u and v,
  // respectively. The use of BYTE_RADIX radix greatly simplifies the
  // complexity of the division operation. These copies are also
  // needed even when we use DIGIT_RADIX representation.

  int xlen = BYTES_PER_DIGIT * ulen + 1;
  int ylen = BYTES_PER_DIGIT * vlen;

#ifdef SC_MAX_NBITS
  uchar x[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
  uchar y[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
  uchar q[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
#else
  uchar *x = new uchar[xlen];
  uchar *y = new uchar[ylen];
  uchar *q = new uchar[xlen - ylen + 1];
#endif

  // q corresponds to w.

  // Set (uchar) x = (sc_digit) u.
  xlen = vec_to_char(ulen, u, xlen, x);

  // Skip all the leading zeros in x.
  while ((--xlen >= 0) && (! x[xlen]));
  xlen++;

  // Set (uchar) y = (sc_digit) v.
  ylen = vec_to_char(vlen, v, ylen, y);

  // Skip all the leading zeros in y.
  while ((--ylen >= 0) && (! y[ylen]));
  ylen++;

#ifdef DEBUG_SYSTEMC
  assert(xlen > 1);
  assert(ylen > 1);
#endif

  // At this point, all the leading zeros are eliminated from x and y.

  // Zero the last digit of x.
  x[xlen] = 0;

  // The first two digits of y.
  register sc_digit y2 = (y[ylen - 1] << BITS_PER_BYTE) + y[ylen - 2];

  const sc_digit DOUBLE_BITS_PER_BYTE = 2 * BITS_PER_BYTE;

  // Find each q[k].
  for (register int k = xlen - ylen; k >= 0; --k) {

    // qk is a guess for q[k] such that q[k] = qk or qk - 1.
    register sc_digit qk;

    // Find qk by just using 2 digits of y and 3 digits of x. The
    // following code assumes that sizeof(sc_digit) >= 3 BYTEs.
    int k2 = k + ylen;

    qk = ((x[k2] << DOUBLE_BITS_PER_BYTE) + 
          (x[k2 - 1] << BITS_PER_BYTE) + x[k2 - 2]) / y2;

    if (qk >= BYTE_RADIX)     // qk cannot be larger than the largest
      qk = BYTE_RADIX - 1;    // digit in BYTE_RADIX.

    // q[k] = qk or qk - 1. The following if-statement determines which:
    if (qk) {

      register uchar *xk = (x + k);  // A shortcut for x[k].

      // x = x - y * qk :
      register sc_digit carry = 0;

      for (register int i = 0; i < ylen; ++i) {
        carry += y[i] * qk;
        sc_digit diff = (xk[i] + BYTE_RADIX) - (carry & BYTE_MASK);
        xk[i] = (uchar)(diff & BYTE_MASK);
        carry = (carry >> BITS_PER_BYTE) + (1 - (diff >> BITS_PER_BYTE));
      }

      // If carry, qk may be one too large.
      if (carry) {

        // 2's complement the last digit.
        carry = (xk[ylen] + BYTE_RADIX) - carry;
        xk[ylen] = (uchar)(carry & BYTE_MASK);
        carry = 1 - (carry >> BITS_PER_BYTE);
        
        if (carry) {

          // qk was one too large, so decrement it.
          --qk;
        
          // Since qk was decreased by one, y must be added to x:
          // That is, x = x - y * (qk - 1) = x - y * qk + y = x_above + y.
          carry = 0;

          for (register int i = 0; i < ylen; ++i) {
            carry += xk[i] + y[i];
            xk[i] = (uchar)(carry & BYTE_MASK);
            carry >>= BITS_PER_BYTE;
          }

          if (carry)
            xk[ylen] = (uchar)((xk[ylen] + 1) & BYTE_MASK);

        }  // second if carry
      }  // first if carry
    }  // if qk

    q[k] = (uchar)qk;

  }  // for k

  // Set (sc_digit) w = (uchar) q.
  vec_from_char(xlen - ylen + 1, q, ulen, w);

#ifndef SC_MAX_NBITS
  delete [] x;
  delete [] y;
  delete [] q;
#endif

}

void sc_dt::vec_div_small	(	int	ulen,
		const sc_digit *	u,
		sc_digit	v,
		sc_digit *	q
	)

sc_nbutils.cpp の 1299 行で定義されています。

{

  // Given (u = u_1u_2...u_n)_b = (q = q_1q_2...q_n) * v + r, where b
  // is the base, and 0 <= r < v. Then, the algorithm is as follows:
  //
  // r = 0; 
  // for (j = 1; j <= n; j++) {
  //   q_j = (r * b + u_j) / v;
  //   r = (r * b + u_j) % v;
  // }
  // 
  // In our case, b = DIGIT_RADIX, and u = Ax + B and q = Cx + D where
  // x = HALF_DIGIT_RADIX. Note that r < v < x and b = x^2. Then, a
  // typical situation is as follows:
  //
  // ---- ----
  // 0    r
  //           ---- ----
  //           A    B
  //      ---- ---- ----
  //      r    A    B     = r * b + u
  //
  // Hence, C = (r|A) / v.
  //        D = (((r|A) % v)|B) / v
  //        r = (((r|A) % v)|B) % v

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert(q != NULL);
  assert((0 < v) && (v < HALF_DIGIT_RADIX));
#endif

#define q_h r

  register sc_digit r = 0;
  const sc_digit *ubegin = u;

  u += ulen;
  q += ulen;

  while (ubegin < u) {

    sc_digit u_AB = (*--u);       // A|B

#ifdef DEBUG_SYSTEMC
    // The overflow bits must be zero.
    assert(high_half(u_AB) == high_half_masked(u_AB));
#endif

    register sc_digit num = concat(r, high_half(u_AB));  // num = r|A
    q_h = num / v;                           // C
    num = concat((num % v), low_half(u_AB)); // num = (((r|A) % v)|B) 
    (*--q) = concat(q_h, num / v);           // q = C|D
    r = num % v;

  }

#undef q_h

}

int sc_dt::vec_find_first_nonzero	(	int	ulen,
		const sc_digit *	u
	)			[inline]

sc_nbutils.h の 406 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  // assert((ulen <= 0) || (u != NULL));
  assert((ulen > 0) && (u != NULL));
#endif

  while ((--ulen >= 0) && (! u[ulen]))
    ;

  return ulen;
  
}

void sc_dt::vec_from_char	(	int	ulen,
		const uchar *	u,
		int	vlen,
		sc_digit *	v
	)

sc_nbutils.cpp の 1615 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((vlen > 0) && (v != NULL));
  assert(sizeof(uchar) <= sizeof(sc_digit));
#endif

  sc_digit *vend = (v + vlen);

  const int nsr = BITS_PER_DIGIT - BITS_PER_BYTE;
  const sc_digit mask = one_and_ones(nsr);

  (*v) = (sc_digit) u[ulen - 1];

  for (register int i = ulen - 2; i >= 0; --i) {

    // Manual inlining of vec_shift_left().

    register sc_digit *viter = v;

    register sc_digit carry = 0;

    while (viter < vend) {
      register sc_digit vval = (*viter);
      (*viter++) = (((vval & mask) << BITS_PER_BYTE) | carry);
      carry = vval >> nsr;
    }

    if (viter < vend)
      (*viter) = carry;

    (*v) |= (sc_digit) u[i];

  }

}

small_type sc_dt::vec_from_str	(	int	unb,
		int	und,
		sc_digit *	u,
		const char *	v,
		sc_numrep	base
	)

sc_nbutils.cpp の 496 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((unb > 0) && (und > 0) && (u != NULL));
  assert(v != NULL);
#endif

  is_valid_base(base);

  small_type b, s;  // base and sign.

  v = get_base_and_sign(v, b, s);

  if (base != SC_NOBASE) {
    if (b == NB_DEFAULT_BASE)
      b = base;
    else {
        char msg[BUFSIZ];
        std::sprintf( msg,
                 "vec_from_str( int, int, sc_digit*, const char*, sc_numrep base ) : "
                 "base = %s does not match the default base",
                 to_string( base ).c_str() );
        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
    }
  }

  vec_zero(und, u);

  char c;
  
  for ( ; (c = *v); ++v) {

    if (isalnum(c)) {
      
      small_type val;  // Numeric value of a char.
    
      if (isalpha(c)) // Hex digit.
        val = toupper(c) - 'A' + 10;
      else
        val = c - '0';
      
      if (val >= b) {
          char msg[BUFSIZ];
          std::sprintf( msg,
                   "vec_from_str( int, int, sc_digit*, const char*, sc_numrep base ) : "
                   "'%c' is not a valid digit in base %d",
                   *v, b );
          SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
      }
      
      // digit = digit * b + val;
      vec_mul_small_on(und, u, b);
      
      if (val)
        vec_add_small_on(und, u, val);

    }
    else {
        char msg[BUFSIZ];
        std::sprintf( msg,
                 "vec_from_str( int, int, sc_digit*, const char*, sc_numrep base ) : "
                 "'%c' is not a valid digit in base %d",
                 *v, b );
        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
    }
  }

  return convert_signed_SM_to_2C_to_SM(s, unb, und, u);
}

void sc_dt::vec_mul	(	int	ulen,
		const sc_digit *	u,
		int	vlen,
		const sc_digit *	vbegin,
		sc_digit *	wbegin
	)

sc_nbutils.cpp の 948 行で定義されています。

{

  /* Consider u = Ax + B and v = Cx + D where x is equal to
     HALF_DIGIT_RADIX. In other words, A is the higher half of u and
     B is the lower half of u. The interpretation for v is
     similar. Then, we have the following picture:

              u_h     u_l
     u: -------- --------
               A        B

              v_h     v_l
     v: -------- --------
               C        D
 
     result (d):                     
     carry_before:                           -------- --------
                                              carry_h  carry_l
     result_before:        -------- -------- -------- --------
                               R1_h     R1_l     R0_h     R0_l
                                             -------- --------
                                                 BD_h     BD_l
                                    -------- --------
                                        AD_h     AD_l
                                    -------- --------
                                        BC_h     BC_l
                           -------- --------
                               AC_h     AC_l
     result_after:         -------- -------- -------- --------
                              R1_h'    R1_l'    R0_h'    R0_l'
 
     prod_l = R0_h|R0_l + B * D  + 0|carry_l
            = R0_h|R0_l + BD_h|BD_l + 0|carry_l
 
     prod_h = A * D + B * C + high_half(prod_l) + carry_h
            = AD_h|AD_l + BC_h|BC_l + high_half(prod_l) + 0|carry_h
 
     carry = A * C + high_half(prod_h)
           = AC_h|AC_l + high_half(prod_h)
 
     R0_l' = low_half(prod_l)
 
     R0_h' = low_half(prod_h)
 
     R0 = high_half(prod_h)|low_half(prod_l)
 
     where '|' is the concatenation operation and the suffixes 0 and 1
     show the iteration number, i.e., 0 is the current iteration and 1
     is the next iteration.
 
     NOTE: sc_max(prod_l, prod_h, carry) <= 2 * x^2 - 1, so any
     of these numbers can be stored in a digit.

     NOTE: low_half(u) returns the lower BITS_PER_HALF_DIGIT of u,
     whereas high_half(u) returns the rest of the bits, which may
     contain more bits than BITS_PER_HALF_DIGIT.  
  */

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((vlen > 0) && (vbegin != NULL));
  assert(wbegin != NULL);
#endif

#define prod_h carry

  const sc_digit *uend = (u + ulen);
  const sc_digit *vend = (vbegin + vlen);

  while (u < uend) {

    sc_digit u_h = (*u++);        // A|B
    sc_digit u_l = low_half(u_h); // B
    u_h = high_half(u_h);           // A

#ifdef DEBUG_SYSTEMC
    // The overflow bits must be zero.
    assert(u_h == (u_h & HALF_DIGIT_MASK));
#endif

    register sc_digit carry = 0;

    register sc_digit *w = (wbegin++);

    register const sc_digit *v = vbegin;

    while (v < vend) {

      sc_digit v_h = (*v++);         // C|D
      sc_digit v_l = low_half(v_h);  // D

      v_h = high_half(v_h);            // C

#ifdef DEBUG_SYSTEMC
      // The overflow bits must be zero.
      assert(v_h == (v_h & HALF_DIGIT_MASK));
#endif

      sc_digit prod_l = (*w) + u_l * v_l + low_half(carry);

      prod_h = u_h * v_l + u_l * v_h + high_half(prod_l) + high_half(carry);

      (*w++) = concat(low_half(prod_h), low_half(prod_l));

      carry = u_h * v_h + high_half(prod_h);

    }

    (*w) = carry;

  }

#undef prod_h

}

void sc_dt::vec_mul_small	(	int	ulen,
		const sc_digit *	u,
		sc_digit	v,
		sc_digit *	w
	)

sc_nbutils.cpp の 1070 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert(w != NULL);
  assert((0 < v) && (v < HALF_DIGIT_RADIX));
#endif

#define prod_h carry

  const sc_digit *uend = (u + ulen);

  register sc_digit carry = 0;

  while (u < uend) {

    sc_digit u_AB = (*u++);

#ifdef DEBUG_SYSTEMC
    // The overflow bits must be zero.
    assert(high_half(u_AB) == high_half_masked(u_AB));
#endif

    sc_digit prod_l = v * low_half(u_AB) + low_half(carry);

    prod_h = v * high_half(u_AB) + high_half(prod_l) + high_half(carry);

    (*w++) = concat(low_half(prod_h), low_half(prod_l));

    carry = high_half(prod_h);

  }

  (*w) = carry;

#undef prod_h

}

void sc_dt::vec_mul_small_on	(	int	ulen,
		sc_digit *	u,
		sc_digit	v
	)

sc_nbutils.cpp の 1114 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((0 < v) && (v < HALF_DIGIT_RADIX));
#endif

#define prod_h carry

  register sc_digit carry = 0;

  for (register int i = 0; i < ulen; ++i) {

#ifdef DEBUG_SYSTEMC
    // The overflow bits must be zero.
    assert(high_half(u[i]) == high_half_masked(u[i]));
#endif

    sc_digit prod_l = v * low_half(u[i]) + low_half(carry);

    prod_h = v * high_half(u[i]) + high_half(prod_l) + high_half(carry);

    u[i] = concat(low_half(prod_h), low_half(prod_l));

    carry = high_half(prod_h);

  }

#undef prod_h

#ifdef DEBUG_SYSTEMC
  if( carry != 0 ) {
      SC_REPORT_WARNING( sc_core::SC_ID_WITHOUT_MESSAGE_,
                         "vec_mul_small_on( int, sc_digit*, unsigned "
                         "long ) : "
                         "result of multiplication is wrapped around" );
  }
#endif
}

void sc_dt::vec_rem_large	(	int	ulen,
		const sc_digit *	u,
		int	vlen,
		const sc_digit *	v,
		sc_digit *	w
	)

sc_nbutils.cpp の 1365 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((vlen > 0) && (v != NULL));
  assert(w != NULL);
  assert(BITS_PER_DIGIT >= 3 * BITS_PER_BYTE);
#endif

  // This function is adapted from vec_div_large.

  int xlen = BYTES_PER_DIGIT * ulen + 1;
  int ylen = BYTES_PER_DIGIT * vlen;

#ifdef SC_MAX_NBITS
  uchar x[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
  uchar y[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
#else
  uchar *x = new uchar[xlen];
  uchar *y = new uchar[ylen];
#endif

  // r corresponds to w.

  // Set (uchar) x = (sc_digit) u.
  xlen = vec_to_char(ulen, u, xlen, x);

  // Skip all the leading zeros in x.
  while ((--xlen >= 0) && (! x[xlen]));
  xlen++;

  // Set (uchar) y = (sc_digit) v.
  ylen = vec_to_char(vlen, v, ylen, y);

  // Skip all the leading zeros in y.
  while ((--ylen >= 0) && (! y[ylen]));
  ylen++;

#ifdef DEBUG_SYSTEMC
  assert(xlen > 1);
  assert(ylen > 1);
#endif

  // At this point, all the leading zeros are eliminated from x and y.

  // Zero the last digit of x.
  x[xlen] = 0;

  // The first two digits of y.
  register sc_digit y2 = (y[ylen - 1] << BITS_PER_BYTE) + y[ylen - 2];

  const sc_digit DOUBLE_BITS_PER_BYTE = 2 * BITS_PER_BYTE;

  // Find each q[k].
  for (register int k = xlen - ylen; k >= 0; --k) {

    // qk is a guess for q[k] such that q[k] = qk or qk - 1.
    register sc_digit qk;

    // Find qk by just using 2 digits of y and 3 digits of x. The
    // following code assumes that sizeof(sc_digit) >= 3 BYTEs.
    int k2 = k + ylen;

    qk = ((x[k2] << DOUBLE_BITS_PER_BYTE) +
      (x[k2 - 1] << BITS_PER_BYTE) + x[k2 - 2]) / y2;

    if (qk >= BYTE_RADIX)     // qk cannot be larger than the largest
      qk = BYTE_RADIX - 1;    // digit in BYTE_RADIX.

    // q[k] = qk or qk - 1. The following if-statement determines which.
    if (qk) {

      register uchar *xk = (x + k);  // A shortcut for x[k].

      // x = x - y * qk;
      register sc_digit carry = 0;

      for (register int i = 0; i < ylen; ++i) {
        carry += y[i] * qk;
        sc_digit diff = (xk[i] + BYTE_RADIX) - (carry & BYTE_MASK);
        xk[i] = (uchar)(diff & BYTE_MASK);
        carry = (carry >> BITS_PER_BYTE) + (1 - (diff >> BITS_PER_BYTE));
      }

      if (carry) {

        // 2's complement the last digit.
        carry = (xk[ylen] + BYTE_RADIX) - carry;
        xk[ylen] = (uchar)(carry & BYTE_MASK);
        carry = 1 - (carry >> BITS_PER_BYTE);
        
        if (carry) {

          // qk was one too large, so decrement it.
          // --qk;
        
          // x = x - y * (qk - 1) = x - y * qk + y = x_above + y.
          carry = 0;

          for (register int i = 0; i < ylen; ++i) {
            carry += xk[i] + y[i];
            xk[i] = (uchar)(carry & BYTE_MASK);
            carry >>= BITS_PER_BYTE;
          }

          if (carry)
            xk[ylen] = (uchar)((xk[ylen] + 1) & BYTE_MASK);

        }  // second if carry
      } // first if carry
    }  // if qk
  }  // for k

  // Set (sc_digit) w = (uchar) x for the remainder.
  vec_from_char(ylen, x, ulen, w);

#ifndef SC_MAX_NBITS
  delete [] x;
  delete [] y;
#endif

}

sc_digit sc_dt::vec_rem_on_small	(	int	ulen,
		sc_digit *	u,
		sc_digit	v
	)

sc_nbutils.cpp の 1528 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert(v > 0);
#endif

#define q_h r

  register sc_digit r = 0;
  const sc_digit *ubegin = u;

  u += ulen;

  while (ubegin < u) {

    sc_digit u_AB = (*--u);       // A|B

#ifdef DEBUG_SYSTEMC
    // The overflow bits must be zero.
    assert(high_half(u_AB) == high_half_masked(u_AB));
#endif

    register sc_digit num = concat(r, high_half(u_AB));  // num = r|A
    q_h = num / v;                           // C
    num = concat((num % v), low_half(u_AB)); // num = (((r|A) % v)|B) 
    (*u) = concat(q_h, num / v);             // q = C|D
    r = num % v;

  }

#undef q_h

  return r;

}

sc_digit sc_dt::vec_rem_small	(	int	ulen,
		const sc_digit *	u,
		sc_digit	v
	)

sc_nbutils.cpp の 1495 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((0 < v) && (v < HALF_DIGIT_RADIX));
#endif

  // This function is adapted from vec_div_small().

  register sc_digit r = 0;
  const sc_digit *ubegin = u;

  u += ulen;

  while (ubegin < u) {
    register sc_digit u_AB = (*--u);  // A|B

#ifdef DEBUG_SYSTEMC
    // The overflow bits must be zero.
    assert(high_half(u_AB) == high_half_masked(u_AB));
#endif

    // r = (((r|A) % v)|B) % v
    r = (concat(((concat(r, high_half(u_AB))) % v), low_half(u_AB))) % v;
  }

  return r;

}

void sc_dt::vec_reverse	(	int	unb,
		int	und,
		sc_digit *	ud,
		int	l,
		int	r
	)

sc_nbutils.cpp の 1787 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((unb > 0) && (und > 0) && (ud != NULL));
  assert((0 <= r) && (r <= l) && (l < unb));
#endif

  if (l < r) {
      char msg[BUFSIZ];
      std::sprintf( msg, "vec_reverse( int, int, sc_digit*, int l, int r ) : "
               "l = %d < r = %d is not valid",
               l, r );
      SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
  }

  // Make sure that l and r are within bounds.
  r = sc_max(r, 0);
  l = sc_min(l, unb - 1);

  // Allocate memory for processing.
#ifdef SC_MAX_NBITS
  sc_digit d[MAX_NDIGITS];
#else
  sc_digit *d = new sc_digit[und];
#endif

  // d is a copy of ud.
  vec_copy(und, d, ud);

  // Based on the value of the ith in d, find the value of the jth bit
  // in ud.

  for (register int i = l, j = r; i >= r; --i, ++j) {

    if ((d[digit_ord(i)] & one_and_zeros(bit_ord(i))) != 0) // Test.
      ud[digit_ord(j)] |= one_and_zeros(bit_ord(j));     // Set.
    else  
      ud[digit_ord(j)] &= ~(one_and_zeros(bit_ord(j)));  // Clear.

  }

#ifndef SC_MAX_NBITS
  delete [] d;
#endif
    
}

void sc_dt::vec_shift_left	(	int	ulen,
		sc_digit *	u,
		int	nsl
	)

sc_nbutils.cpp の 1658 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
#endif

  if (nsl <= 0)
    return;

  // Shift left whole digits if nsl is large enough.
  if (nsl >= (int) BITS_PER_DIGIT) {

    int nd;

    if (nsl % BITS_PER_DIGIT == 0) {
      nd = nsl / BITS_PER_DIGIT;  // No need to use DIV_CEIL(nsl).
      nsl = 0;
    }
    else {
      nd = DIV_CEIL(nsl) - 1;
      nsl -= nd * BITS_PER_DIGIT;
    }

    if (nd) {

      // Shift left for nd digits.
      for (register int j = ulen - 1; j >= nd; --j)
        u[j] = u[j - nd];
      
      vec_zero( sc_min( nd, ulen ), u );
      
    }

    if (nsl == 0)
      return;

  }

  // Shift left if nsl < BITS_PER_DIGIT.
  register sc_digit *uiter = u;
  sc_digit *uend = uiter + ulen;

  int nsr = BITS_PER_DIGIT - nsl;
  sc_digit mask = one_and_ones(nsr);

  register sc_digit carry = 0;

  while (uiter < uend) {
    register sc_digit uval = (*uiter);
    (*uiter++) = (((uval & mask) << nsl) | carry);
    carry = uval >> nsr;
  }

  if (uiter < uend)
    (*uiter) = carry;

}

void sc_dt::vec_shift_right	(	int	ulen,
		sc_digit *	u,
		int	nsr,
		sc_digit	fill
	)

sc_nbutils.cpp の 1720 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
#endif

  // fill is usually either 0 or DIGIT_MASK; it can be any value.

  if (nsr <= 0)
    return;

  // Shift right whole digits if nsr is large enough.
  if (nsr >= (int) BITS_PER_DIGIT) {

    int nd;

    if (nsr % BITS_PER_DIGIT == 0) {
      nd = nsr / BITS_PER_DIGIT;
      nsr = 0;
    }
    else {
      nd = DIV_CEIL(nsr) - 1;
      nsr -= nd * BITS_PER_DIGIT;
    }
    
    if (nd) {

      // Shift right for nd digits.
      for (register int j = 0; j < (ulen - nd); ++j)
        u[j] = u[j + nd];

      if (fill) {
        for (register int j = ulen - sc_min( nd, ulen ); j < ulen; ++j)
          u[j] = fill;
      }
      else
        vec_zero(ulen - sc_min( nd, ulen ), ulen, u);
     
    }

    if (nsr == 0)
      return;

  }

  // Shift right if nsr < BITS_PER_DIGIT.
  sc_digit *ubegin = u;
  register sc_digit *uiter = (ubegin + ulen);

  int nsl = BITS_PER_DIGIT - nsr;
  sc_digit mask = one_and_ones(nsr);

  register sc_digit carry = (fill & mask) << nsl;

  while (ubegin < uiter) {
    register sc_digit uval = (*--uiter);
    (*uiter) = (uval >> nsr) | carry;
    carry = (uval & mask) << nsl;
  }

}

int sc_dt::vec_skip_and_cmp	(	int	ulen,
		const sc_digit *	u,
		int	vlen,
		const sc_digit *	v
	)			[inline]

sc_nbutils.h の 445 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((vlen > 0) && (v != NULL));
#endif

  ulen = vec_skip_leading_zeros(ulen, u);
  vlen = vec_skip_leading_zeros(vlen, v);
  // ulen and/or vlen can be equal to zero here.
  return vec_cmp(ulen, u, vlen, v);

}

int sc_dt::vec_skip_leading_zeros	(	int	ulen,
		const sc_digit *	u
	)			[inline]

sc_nbutils.h の 427 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  // assert((ulen <= 0) || (u != NULL));
  assert((ulen > 0) && (u != NULL));
#endif

  return (1 + vec_find_first_nonzero(ulen, u));

}

void sc_dt::vec_sub	(	int	ulen,
		const sc_digit *	u,
		int	vlen,
		const sc_digit *	v,
		sc_digit *	w
	)

sc_nbutils.cpp の 772 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((vlen > 0) && (v != NULL));
  assert(w != NULL);
  assert(ulen >= vlen);
#endif

  const sc_digit *uend = (u + ulen);
  const sc_digit *vend = (v + vlen);

  register sc_digit borrow = 0;   // Also used as diff to save space.

  // Subtract along the shorter v.
  while (v < vend) {
    borrow = ((*u++) + DIGIT_RADIX) - (*v++) - borrow;
    (*w++) = borrow & DIGIT_MASK;
    borrow = 1 - (borrow >> BITS_PER_DIGIT);
  }

  // Propagate the borrow.
  while (borrow && (u < uend)) {
    borrow = ((*u++) + DIGIT_RADIX) - 1;
    (*w++) = borrow & DIGIT_MASK;
    borrow = 1 - (borrow >> BITS_PER_DIGIT);
  }

#ifdef DEBUG_SYSTEMC
  assert(borrow == 0);
#endif

  // Copy the rest of u to the result.
  while (u < uend)
    (*w++) = (*u++);

}

void sc_dt::vec_sub_on	(	int	ulen,
		sc_digit *	ubegin,
		int	vlen,
		const sc_digit *	v
	)

sc_nbutils.cpp の 817 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (ubegin != NULL));
  assert((vlen > 0) && (v != NULL));
  assert(ulen >= vlen);
#endif

  register sc_digit *u = ubegin;
  const sc_digit *uend = (u + ulen);
  const sc_digit *vend = (v + vlen);

  register sc_digit borrow = 0;   // Also used as diff to save space.

  // Subtract along the shorter v.
  while (v < vend) {
    borrow = ((*u) + DIGIT_RADIX) - (*v++) - borrow;
    (*u++) = borrow & DIGIT_MASK;
    borrow = 1 - (borrow >> BITS_PER_DIGIT);
  }

  // Propagate the borrow.
  while (borrow && (u < uend)) {
    borrow = ((*u) + DIGIT_RADIX) - 1;
    (*u++) = borrow & DIGIT_MASK;
    borrow = 1 - (borrow >> BITS_PER_DIGIT);
  }

#ifdef DEBUG_SYSTEMC
  assert(borrow == 0);
#endif

}

void sc_dt::vec_sub_on2	(	int	ulen,
		sc_digit *	ubegin,
		int	vlen,
		const sc_digit *	v
	)

sc_nbutils.cpp の 857 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (ubegin != NULL));
  assert((vlen > 0) && (v != NULL));
#endif

  register sc_digit *u = ubegin;
  const sc_digit *uend = (u + sc_min(ulen, vlen));

  register sc_digit borrow = 0;   // Also used as diff to save space.

  // Subtract along the shorter u.
  while (u < uend) {
    borrow = ((*v++) + DIGIT_RADIX) - (*u) - borrow;
    (*u++) = borrow & DIGIT_MASK;
    borrow = 1 - (borrow >> BITS_PER_DIGIT);
  }

#ifdef DEBUG_SYSTEMC
  if( borrow != 0 ) {
      SC_REPORT_WARNING( sc_core::SC_ID_WITHOUT_MESSAGE_,
                         "vec_sub_on2( int, sc_digit*, int, const "
                         "sc_digit* ) : "
                         "result of subtraction is wrapped around" );
  }
#endif
}

void sc_dt::vec_sub_small	(	int	ulen,
		const sc_digit *	u,
		sc_digit	v,
		sc_digit *	w
	)

sc_nbutils.cpp の 890 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert(ulen > 0);
  assert(u != NULL);
#endif

  const sc_digit *uend = (u + ulen);

  // Add along the shorter v.
  register sc_digit borrow = ((*u++) + DIGIT_RADIX) - v;
  (*w++) = borrow & DIGIT_MASK;
  borrow = 1 - (borrow >> BITS_PER_DIGIT);

  // Propagate the borrow.
  while (borrow && (u < uend)) {
    borrow = ((*u++) + DIGIT_RADIX) - 1;
    (*w++) = borrow & DIGIT_MASK;
    borrow = 1 - (borrow >> BITS_PER_DIGIT);
  }

#ifdef DEBUG_SYSTEMC
  assert(borrow == 0);
#endif

  // Copy the rest of u to the result.
  while (u < uend)
    (*w++) = (*u++);

}

void sc_dt::vec_sub_small_on	(	int	ulen,
		sc_digit *	u,
		sc_digit	v
	)

sc_nbutils.cpp の 927 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
#endif

  for (register int i = 0; i < ulen; ++i) {
    v = (u[i] + DIGIT_RADIX) - v;    
    u[i] = v & DIGIT_MASK;
    v = 1 - (v >> BITS_PER_DIGIT);
  }

#ifdef DEBUG_SYSTEMC
  assert(v == 0);
#endif

}

int sc_dt::vec_to_char	(	int	ulen,
		const sc_digit *	u,
		int	vlen,
		uchar *	v
	)

sc_nbutils.cpp の 1568 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
  assert((vlen > 0) && (v != NULL));
#endif

  register int nbits = ulen * BITS_PER_DIGIT;

  register int right = 0;
  register int left = right + BITS_PER_BYTE - 1;

  vlen = 0;

  while (nbits > 0) {

    int left_digit = left / BITS_PER_DIGIT;
    int right_digit = right / BITS_PER_DIGIT;

    register int nsr = ((vlen << LOG2_BITS_PER_BYTE) % BITS_PER_DIGIT);

    int d = u[right_digit] >> nsr;

    if (left_digit != right_digit) {

      if (left_digit < ulen)
        d |= u[left_digit] << (BITS_PER_DIGIT - nsr);

    }

    v[vlen++] = (uchar)(d & BYTE_MASK);

    left += BITS_PER_BYTE;
    right += BITS_PER_BYTE;
    nbits -= BITS_PER_BYTE;

  }

  return vlen;

}

void sc_dt::vec_zero	(	int	ulen,
		sc_digit *	u
	)			[inline]

sc_nbutils.h の 479 行で定義されています。

{
  vec_zero(0, ulen, u);
}

void sc_dt::vec_zero	(	int	from,
		int	ulen,
		sc_digit *	u
	)			[inline]

sc_nbutils.h の 464 行で定義されています。

{

#ifdef DEBUG_SYSTEMC
  assert((ulen > 0) && (u != NULL));
#endif

  for(int i = from; i < ulen; i++)
    u[i] = 0;

}

bool sc_dt::xnor_reduce

(

const sc_concatref &

a

)

[inline]

sc_concatref.h の 472 行で定義されています。

{
    return a.xnor_reduce();
}

bool sc_dt::xnor_reduce

(

const sc_uint_base &

a

)

[inline]

sc_uint_base.h の 1311 行で定義されています。

{
    return a.xnor_reduce();
}

bool sc_dt::xnor_reduce

(

const sc_uint_subref_r &

a

)

[inline]

sc_uint_base.h の 1128 行で定義されています。

{
    return a.xnor_reduce();
}

bool sc_dt::xnor_reduce

(

const sc_int_base &

a

)

[inline]

sc_int_base.h の 1340 行で定義されています。

{
    return a.xnor_reduce();
}

bool sc_dt::xnor_reduce

(

const sc_int_subref_r &

a

)

[inline]

sc_int_base.h の 1157 行で定義されています。

{
    return a.xnor_reduce();
}

template<class X>

sc_logic_value_t sc_dt::xnor_reduce

(

const sc_proxy< X > &

a

)

[inline]

sc_proxy.h の 1499 行で定義されています。

{
    return a.xnor_reduce();
}

CLASS_TYPE sc_dt::XOR_HELPER	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_signed.cpp の 4648 行で定義されています。

void sc_dt::xor_on_help	(	small_type	us,
		int	,
		int	und,
		sc_digit *	ud,
		small_type	vs,
		int	,
		int	vnd,
		const sc_digit *	vd
	)

sc_nbexterns.cpp の 788 行で定義されています。

{
  
  register sc_digit *x = ud;
  register const sc_digit *y = vd;
  int xnd = und;
  int ynd = vnd;

  if (xnd < ynd)
    ynd = xnd;

  const sc_digit *xend = (x + xnd);
  const sc_digit *yend = (y + ynd);

  // x is longer than y.

  small_type s = mul_signs(us, vs);

  if (s > 0) {

    if (us > 0) { // case 3

      while (y < yend) {
        (*x) = ((*x) ^ (*y)) & DIGIT_MASK;
        x++;
        y++;
      }

      // No change for the rest of x.

    }
    else {  // case 4

      register sc_digit xcarry = 1;
      register sc_digit ycarry = 1;

      while (y < yend) {
        xcarry += (~(*x) & DIGIT_MASK);
        ycarry += (~(*y++) & DIGIT_MASK);
        (*x++) = (xcarry ^ ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        xcarry += (~(*x) & DIGIT_MASK);
        ycarry += DIGIT_MASK;
        (*x++) = (xcarry ^ ycarry) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
        ycarry >>= BITS_PER_DIGIT;
      }
    }
  }
  else {

    if (us > 0) { // case 5

      register sc_digit ycarry = 1;

      while (y < yend) {
        ycarry += (~(*y++) & DIGIT_MASK);
        (*x) = ((*x) ^ ycarry) & DIGIT_MASK;
        x++;
        ycarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        ycarry += DIGIT_MASK;
        (*x) = ((*x) ^ ycarry) & DIGIT_MASK;
        x++;
        ycarry >>= BITS_PER_DIGIT;
      }

    }
    else {  // case 6

      register sc_digit xcarry = 1;

      while (y < yend) {
        xcarry += (~(*x) & DIGIT_MASK);
        (*x++) = (xcarry ^ (*y++)) & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
      }

      while (x < xend) {
        xcarry += (~(*x) & DIGIT_MASK);
        (*x++) = xcarry & DIGIT_MASK;
        xcarry >>= BITS_PER_DIGIT;
      }
    }
  }
}

bool sc_dt::xor_reduce

(

const sc_concatref &

a

)

[inline]

sc_concatref.h の 465 行で定義されています。

{
    return a.xor_reduce();
}

bool sc_dt::xor_reduce

(

const sc_uint_base &

a

)

[inline]

sc_uint_base.h の 1304 行で定義されています。

{
    return a.xor_reduce();
}

bool sc_dt::xor_reduce

(

const sc_uint_subref_r &

a

)

[inline]

sc_uint_base.h の 1121 行で定義されています。

{
    return a.xor_reduce();
}

bool sc_dt::xor_reduce

(

const sc_int_base &

a

)

[inline]

sc_int_base.h の 1333 行で定義されています。

{
    return a.xor_reduce();
}

bool sc_dt::xor_reduce

(

const sc_int_subref_r &

a

)

[inline]

sc_int_base.h の 1150 行で定義されています。

{
    return a.xor_reduce();
}

template<class X>

sc_logic_value_t sc_dt::xor_reduce

(

const sc_proxy< X > &

a

)

[inline]

sc_proxy.h の 1491 行で定義されています。

{
    return a.xor_reduce();
}

sc_signed sc_dt::xor_signed_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

sc_unsigned sc_dt::xor_unsigned_friend	(	small_type	us,
		int	unb,
		int	und,
		const sc_digit *	ud,
		small_type	vs,
		int	vnb,
		int	vnd,
		const sc_digit *	vd
	)

---

変数

const int sc_dt::bits_in_int = sizeof(int) * CHAR_BIT

scfx_rep.h の 87 行で定義されています。

const int sc_dt::bits_in_word = sizeof(word) * CHAR_BIT

scfx_rep.h の 88 行で定義されています。

const sc_digit sc_dt::ctrl_array[] [static]

初期値:

    { SC_DIGIT_ZERO, SC_DIGIT_ZERO, ~SC_DIGIT_ZERO, ~SC_DIGIT_ZERO }

sc_lv_base.cpp の 62 行で定義されています。

const sc_digit sc_dt::data_array[] [static]

初期値:

    { SC_DIGIT_ZERO, ~SC_DIGIT_ZERO, SC_DIGIT_ZERO, ~SC_DIGIT_ZERO }

sc_lv_base.cpp の 59 行で定義されています。

uint64 sc_dt::div

sc_fxval.h の 989 行で定義されています。

word_list* sc_dt::free_words[32] = { 0 } [static]

scfx_mant.cpp の 78 行で定義されています。

scfx_rep_node* sc_dt::list = 0 [static]

scfx_rep.cpp の 346 行で定義されています。

const int sc_dt::mantissa0_size = SCFX_IEEE_DOUBLE_M_SIZE - bits_in_int [static]

scfx_rep.cpp の 69 行で定義されています。

const uint_type sc_dt::mask_int

sc_int64_mask.cpp の 64 行で定義されています。

const int sc_dt::min_mant = 4

scfx_rep.h の 85 行で定義されています。

const small_type sc_dt::NB_DEFAULT_BASE = SC_DEC

sc_nbdefs.cpp の 75 行で定義されています。

scfx_pow10 sc_dt::pow10_fx [static]

scfx_rep.cpp の 67 行で定義されています。

const sc_switch sc_dt::SC_BUILTIN_CAST_SWITCH_ = SC_ON

sc_fxdefs.h の 210 行で定義されています。

const int sc_dt::SC_BUILTIN_CTE_WL_ = 64

sc_fxdefs.h の 221 行で定義されています。

const int sc_dt::SC_BUILTIN_DIV_WL_ = 64

sc_fxdefs.h の 220 行で定義されています。

const int sc_dt::SC_BUILTIN_IWL_ = 32

sc_fxdefs.h の 193 行で定義されています。

const int sc_dt::SC_BUILTIN_MAX_WL_ = 1024

sc_fxdefs.h の 222 行で定義されています。

const int sc_dt::SC_BUILTIN_N_BITS_ = 0

sc_fxdefs.h の 196 行で定義されています。

const sc_o_mode sc_dt::SC_BUILTIN_O_MODE_ = SC_WRAP

sc_fxdefs.h の 195 行で定義されています。

const sc_q_mode sc_dt::SC_BUILTIN_Q_MODE_ = SC_TRN

sc_fxdefs.h の 194 行で定義されています。

const int sc_dt::SC_BUILTIN_WL_ = 32

sc_fxdefs.h の 192 行で定義されています。

const sc_switch sc_dt::SC_DEFAULT_CAST_SWITCH_ = SC_BUILTIN_CAST_SWITCH_

sc_fxdefs.h の 213 行で定義されています。

const int sc_dt::SC_DEFAULT_CTE_WL_ = SC_BUILTIN_CTE_WL_

sc_fxdefs.h の 234 行で定義されています。

const int sc_dt::SC_DEFAULT_DIV_WL_ = SC_BUILTIN_DIV_WL_

sc_fxdefs.h の 228 行で定義されています。

const int sc_dt::SC_DEFAULT_IWL_ = SC_BUILTIN_IWL_

sc_fxdefs.h の 200 行で定義されています。

const int sc_dt::SC_DEFAULT_MAX_WL_ = SC_BUILTIN_MAX_WL_

sc_fxdefs.h の 240 行で定義されています。

const int sc_dt::SC_DEFAULT_N_BITS_ = SC_BUILTIN_N_BITS_

sc_fxdefs.h の 203 行で定義されています。

const sc_o_mode sc_dt::SC_DEFAULT_O_MODE_ = SC_BUILTIN_O_MODE_

sc_fxdefs.h の 202 行で定義されています。

const sc_q_mode sc_dt::SC_DEFAULT_Q_MODE_ = SC_BUILTIN_Q_MODE_

sc_fxdefs.h の 201 行で定義されています。

const int sc_dt::SC_DEFAULT_WL_ = SC_BUILTIN_WL_

sc_fxdefs.h の 199 行で定義されています。

const sc_digit sc_dt::SC_DIGIT_ONE = (sc_digit)1

sc_proxy.h の 90 行で定義されています。

const int sc_dt::SC_DIGIT_SIZE = BITS_PER_BYTE * sizeof( sc_digit )

sc_proxy.h の 87 行で定義されています。

const sc_digit sc_dt::SC_DIGIT_TWO = (sc_digit)2

sc_proxy.h の 91 行で定義されています。

const sc_digit sc_dt::SC_DIGIT_ZERO = (sc_digit)0

sc_proxy.h の 89 行で定義されています。

const sc_logic sc_dt::SC_LOGIC_0

sc_logic.h の 596 行で定義されています。

const sc_logic sc_dt::sc_logic_0

sc_logic.h の 602 行で定義されています。

const sc_logic sc_dt::SC_LOGIC_1

sc_logic.h の 597 行で定義されています。

const sc_logic sc_dt::sc_logic_1

sc_logic.h の 603 行で定義されています。

const sc_logic sc_dt::SC_LOGIC_X

sc_logic.h の 599 行で定義されています。

const sc_logic sc_dt::sc_logic_X

sc_logic.h の 605 行で定義されています。

const sc_logic sc_dt::SC_LOGIC_Z

sc_logic.h の 598 行で定義されています。

const sc_logic sc_dt::sc_logic_Z

sc_logic.h の 604 行で定義されています。

const unsigned int sc_dt::SCFX_IEEE_DOUBLE_BIAS = 1023U

scfx_ieee.h の 91 行で定義されています。

const int sc_dt::SCFX_IEEE_DOUBLE_E_MAX = 1023

scfx_ieee.h の 93 行で定義されています。

const int sc_dt::SCFX_IEEE_DOUBLE_E_MIN = -1022

scfx_ieee.h の 94 行で定義されています。

const unsigned int sc_dt::SCFX_IEEE_DOUBLE_M_SIZE = 52

scfx_ieee.h の 96 行で定義されています。

const unsigned int sc_dt::SCFX_IEEE_FLOAT_BIAS = 127U

scfx_ieee.h の 429 行で定義されています。

const int sc_dt::SCFX_IEEE_FLOAT_E_MAX = 127

scfx_ieee.h の 431 行で定義されています。

const int sc_dt::SCFX_IEEE_FLOAT_E_MIN = -126

scfx_ieee.h の 432 行で定義されています。

const unsigned int sc_dt::SCFX_IEEE_FLOAT_M_SIZE = 23

scfx_ieee.h の 434 行で定義されています。

const int sc_dt::SCFX_POW10_TABLE_SIZE = 32

scfx_pow10.h の 66 行で定義されています。

const uint64 sc_dt::UINT64_32ONES = 0x00000000ffffffffULL

sc_nbdefs.cpp の 68 行で定義されています。

const uint64 sc_dt::UINT64_ONE = 1ULL

sc_nbdefs.cpp の 67 行で定義されています。

const uint64 sc_dt::UINT64_ZERO = 0ULL

sc_nbdefs.cpp の 66 行で定義されています。

const uint64 sc_dt::UINT_ONE = UINT64_ONE

sc_nbdefs.cpp の 79 行で定義されています。

const uint64 sc_dt::UINT_ZERO = UINT64_ZERO

sc_nbdefs.cpp の 78 行で定義されています。