クラス sc_dt::sc_unsigned

#include <sc_unsigned.h>

sc_dt::sc_unsignedに対する継承グラフ

Inheritance graph
[凡例]

すべてのメンバ一覧

Public メソッド

 sc_unsigned (int nb=sc_length_param().len())
 sc_unsigned (const sc_unsigned &v)
 sc_unsigned (const sc_signed &v)
template<class T>
 sc_unsigned (const sc_generic_base< T > &v)
 sc_unsigned (const sc_bv_base &v)
 sc_unsigned (const sc_lv_base &v)
 sc_unsigned (const sc_int_subref_r &v)
 sc_unsigned (const sc_uint_subref_r &v)
 sc_unsigned (const sc_signed_subref_r &v)
 sc_unsigned (const sc_unsigned_subref_r &v)
const sc_unsigned & operator= (const sc_unsigned &v)
const sc_unsigned & operator= (const sc_unsigned_subref_r &a)
template<class T>
const sc_unsigned & operator= (const sc_generic_base< T > &a)
const sc_unsigned & operator= (const sc_signed &v)
const sc_unsigned & operator= (const sc_signed_subref_r &a)
const sc_unsigned & operator= (const char *v)
const sc_unsigned & operator= (int64 v)
const sc_unsigned & operator= (uint64 v)
const sc_unsigned & operator= (long v)
const sc_unsigned & operator= (unsigned long v)
const sc_unsigned & operator= (int v)
const sc_unsigned & operator= (unsigned int v)
const sc_unsigned & operator= (double v)
const sc_unsigned & operator= (const sc_int_base &v)
const sc_unsigned & operator= (const sc_uint_base &v)
const sc_unsigned & operator= (const sc_bv_base &)
const sc_unsigned & operator= (const sc_lv_base &)
virtual ~sc_unsigned ()
sc_digit * get_raw () const
virtual int concat_length (bool *xz_present_p) const
virtual bool concat_get_ctrl (sc_digit *dst_p, int low_i) const
virtual bool concat_get_data (sc_digit *dst_p, int low_i) const
virtual uint64 concat_get_uint64 () const
virtual void concat_set (int64 src, int low_i)
virtual void concat_set (const sc_signed &src, int low_i)
virtual void concat_set (const sc_unsigned &src, int low_i)
virtual void concat_set (uint64 src, int low_i)
sc_unsigned & operator++ ()
const sc_unsigned operator++ (int)
sc_unsigned & operator-- ()
const sc_unsigned operator-- (int)
void check_index (int i) const
void invalid_index (int i) const
sc_unsigned_bitref & operator[] (int i)
const sc_unsigned_bitref_r & operator[] (int i) const
sc_unsigned_bitref & bit (int i)
const sc_unsigned_bitref_r & bit (int i) const
void check_range (int l, int r) const
void invalid_range (int l, int r) const
sc_unsigned_subref & range (int i, int j)
const sc_unsigned_subref_r & range (int i, int j) const
sc_unsigned_subref & operator() (int i, int j)
const sc_unsigned_subref_r & operator() (int i, int j) const
int to_int () const
unsigned int to_uint () const
long to_long () const
unsigned long to_ulong () const
int64 to_int64 () const
uint64 to_uint64 () const
double to_double () const
const std::string to_string (sc_numrep numrep=SC_DEC) const
const std::string to_string (sc_numrep numrep, bool w_prefix) const
void print (::std::ostream &os=::std::cout) const
void scan (::std::istream &is=::std::cin)
void dump (::std::ostream &os=::std::cout) const
int length () const
bool iszero () const
bool sign () const
bool and_reduce () const
bool nand_reduce () const
bool or_reduce () const
bool nor_reduce () const
bool xor_reduce () const
bool xnor_reduce () const
bool test (int i) const
void set (int i)
void clear (int i)
void set (int i, bool v)
void invert (int i)
void reverse ()
void get_packed_rep (sc_digit *buf) const
void set_packed_rep (sc_digit *buf)
const sc_unsigned & operator+= (const sc_signed &v)
const sc_unsigned & operator+= (const sc_unsigned &v)
const sc_unsigned & operator+= (int64 v)
const sc_unsigned & operator+= (uint64 v)
const sc_unsigned & operator+= (long v)
const sc_unsigned & operator+= (unsigned long v)
const sc_unsigned & operator+= (int v)
const sc_unsigned & operator+= (unsigned int v)
const sc_unsigned & operator+= (const sc_int_base &v)
const sc_unsigned & operator+= (const sc_uint_base &v)
const sc_unsigned & operator-= (const sc_signed &v)
const sc_unsigned & operator-= (const sc_unsigned &v)
const sc_unsigned & operator-= (int64 v)
const sc_unsigned & operator-= (uint64 v)
const sc_unsigned & operator-= (long v)
const sc_unsigned & operator-= (unsigned long v)
const sc_unsigned & operator-= (int v)
const sc_unsigned & operator-= (unsigned int v)
const sc_unsigned & operator-= (const sc_int_base &v)
const sc_unsigned & operator-= (const sc_uint_base &v)
const sc_unsigned & operator*= (const sc_signed &v)
const sc_unsigned & operator*= (const sc_unsigned &v)
const sc_unsigned & operator*= (int64 v)
const sc_unsigned & operator*= (uint64 v)
const sc_unsigned & operator*= (long v)
const sc_unsigned & operator*= (unsigned long v)
const sc_unsigned & operator*= (int v)
const sc_unsigned & operator*= (unsigned int v)
const sc_unsigned & operator*= (const sc_int_base &v)
const sc_unsigned & operator*= (const sc_uint_base &v)
const sc_unsigned & operator/= (const sc_signed &v)
const sc_unsigned & operator/= (const sc_unsigned &v)
const sc_unsigned & operator/= (int64 v)
const sc_unsigned & operator/= (uint64 v)
const sc_unsigned & operator/= (long v)
const sc_unsigned & operator/= (unsigned long v)
const sc_unsigned & operator/= (int v)
const sc_unsigned & operator/= (unsigned int v)
const sc_unsigned & operator/= (const sc_int_base &v)
const sc_unsigned & operator/= (const sc_uint_base &v)
const sc_unsigned & operator%= (const sc_signed &v)
const sc_unsigned & operator%= (const sc_unsigned &v)
const sc_unsigned & operator%= (int64 v)
const sc_unsigned & operator%= (uint64 v)
const sc_unsigned & operator%= (long v)
const sc_unsigned & operator%= (unsigned long v)
const sc_unsigned & operator%= (int v)
const sc_unsigned & operator%= (unsigned int v)
const sc_unsigned & operator%= (const sc_int_base &v)
const sc_unsigned & operator%= (const sc_uint_base &v)
const sc_unsigned & operator &= (const sc_signed &v)
const sc_unsigned & operator &= (const sc_unsigned &v)
const sc_unsigned & operator &= (int64 v)
const sc_unsigned & operator &= (uint64 v)
const sc_unsigned & operator &= (long v)
const sc_unsigned & operator &= (unsigned long v)
const sc_unsigned & operator &= (int v)
const sc_unsigned & operator &= (unsigned int v)
const sc_unsigned & operator &= (const sc_int_base &v)
const sc_unsigned & operator &= (const sc_uint_base &v)
const sc_unsigned & operator|= (const sc_signed &v)
const sc_unsigned & operator|= (const sc_unsigned &v)
const sc_unsigned & operator|= (int64 v)
const sc_unsigned & operator|= (uint64 v)
const sc_unsigned & operator|= (long v)
const sc_unsigned & operator|= (unsigned long v)
const sc_unsigned & operator|= (int v)
const sc_unsigned & operator|= (unsigned int v)
const sc_unsigned & operator|= (const sc_int_base &v)
const sc_unsigned & operator|= (const sc_uint_base &v)
const sc_unsigned & operator^= (const sc_signed &v)
const sc_unsigned & operator^= (const sc_unsigned &v)
const sc_unsigned & operator^= (int64 v)
const sc_unsigned & operator^= (uint64 v)
const sc_unsigned & operator^= (long v)
const sc_unsigned & operator^= (unsigned long v)
const sc_unsigned & operator^= (int v)
const sc_unsigned & operator^= (unsigned int v)
const sc_unsigned & operator^= (const sc_int_base &v)
const sc_unsigned & operator^= (const sc_uint_base &v)
const sc_unsigned & operator<<= (const sc_signed &v)
const sc_unsigned & operator<<= (const sc_unsigned &v)
const sc_unsigned & operator<<= (int64 v)
const sc_unsigned & operator<<= (uint64 v)
const sc_unsigned & operator<<= (long v)
const sc_unsigned & operator<<= (unsigned long v)
const sc_unsigned & operator<<= (int v)
const sc_unsigned & operator<<= (unsigned int v)
const sc_unsigned & operator<<= (const sc_int_base &v)
const sc_unsigned & operator<<= (const sc_uint_base &v)
const sc_unsigned & operator>>= (const sc_signed &v)
const sc_unsigned & operator>>= (const sc_unsigned &v)
const sc_unsigned & operator>>= (int64 v)
const sc_unsigned & operator>>= (uint64 v)
const sc_unsigned & operator>>= (long v)
const sc_unsigned & operator>>= (unsigned long v)
const sc_unsigned & operator>>= (int v)
const sc_unsigned & operator>>= (unsigned int v)
const sc_unsigned & operator>>= (const sc_int_base &v)
const sc_unsigned & operator>>= (const sc_uint_base &v)

Static Public 変数

static sc_core::sc_vpool
< sc_unsigned > 		m_pool

Private 型

typedef bool elemtype

Private メソッド

 sc_unsigned (const sc_unsigned &v, small_type s)
 sc_unsigned (const sc_signed &v, small_type s)
 sc_unsigned (small_type s, int nb, int nd, sc_digit *d, bool alloc=true)
 sc_unsigned (const sc_signed *u, int l, int r)
 sc_unsigned (const sc_unsigned *u, int l, int r)
small_type default_sign () const
int num_bits (int nb) const
bool check_if_outside (int bit_num) const
void copy_digits (int nb, int nd, const sc_digit *d)
void makezero ()
void convert_2C_to_SM ()
void convert_SM_to_2C_to_SM ()
void convert_SM_to_2C ()

Private 変数

small_type sgn
int nbits
int ndigits
sc_digit * digit

フレンド

class sc_concatref
class sc_unsigned_bitref_r
class sc_unsigned_bitref
class sc_unsigned_subref_r
class sc_unsigned_subref
class sc_signed
class sc_signed_subref
class sc_signed_subref_r
sc_signed operator+ (const sc_unsigned &u, const sc_signed &v)
sc_signed operator+ (const sc_signed &u, const sc_unsigned &v)
sc_unsigned operator+ (const sc_unsigned &u, const sc_unsigned &v)
sc_signed operator+ (const sc_unsigned &u, int64 v)
sc_unsigned operator+ (const sc_unsigned &u, uint64 v)
sc_signed operator+ (const sc_unsigned &u, long v)
sc_unsigned operator+ (const sc_unsigned &u, unsigned long v)
sc_signed operator+ (const sc_unsigned &u, int v)
sc_unsigned operator+ (const sc_unsigned &u, unsigned int v)
sc_signed operator+ (int64 u, const sc_unsigned &v)
sc_unsigned operator+ (uint64 u, const sc_unsigned &v)
sc_signed operator+ (long u, const sc_unsigned &v)
sc_unsigned operator+ (unsigned long u, const sc_unsigned &v)
sc_signed operator+ (int u, const sc_unsigned &v)
sc_unsigned operator+ (unsigned int u, const sc_unsigned &v)
sc_unsigned operator+ (const sc_unsigned &u, const sc_uint_base &v)
sc_signed operator+ (const sc_unsigned &u, const sc_int_base &v)
sc_unsigned operator+ (const sc_uint_base &u, const sc_unsigned &v)
sc_signed operator+ (const sc_int_base &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_unsigned &u, const sc_unsigned &v)
sc_signed operator- (const sc_unsigned &u, int64 v)
sc_signed operator- (const sc_unsigned &u, uint64 v)
sc_signed operator- (const sc_unsigned &u, long v)
sc_signed operator- (const sc_unsigned &u, unsigned long v)
sc_signed operator- (const sc_unsigned &u, int v)
sc_signed operator- (const sc_unsigned &u, unsigned int v)
sc_signed operator- (int64 u, const sc_unsigned &v)
sc_signed operator- (uint64 u, const sc_unsigned &v)
sc_signed operator- (long u, const sc_unsigned &v)
sc_signed operator- (unsigned long u, const sc_unsigned &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_unsigned &u, const sc_uint_base &v)
sc_signed operator- (const sc_unsigned &u, const sc_int_base &v)
sc_signed operator- (const sc_uint_base &u, const sc_unsigned &v)
sc_signed operator- (const sc_int_base &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_unsigned operator* (const sc_unsigned &u, const sc_unsigned &v)
sc_signed operator* (const sc_unsigned &u, int64 v)
sc_unsigned operator* (const sc_unsigned &u, uint64 v)
sc_signed operator* (const sc_unsigned &u, long v)
sc_unsigned operator* (const sc_unsigned &u, unsigned long v)
sc_signed operator* (const sc_unsigned &u, int v)
sc_unsigned operator* (const sc_unsigned &u, unsigned int v)
sc_signed operator* (int64 u, const sc_unsigned &v)
sc_unsigned operator* (uint64 u, const sc_unsigned &v)
sc_signed operator* (long u, const sc_unsigned &v)
sc_unsigned operator* (unsigned long u, const sc_unsigned &v)
sc_signed operator* (int u, const sc_unsigned &v)
sc_unsigned operator* (unsigned int u, const sc_unsigned &v)
sc_unsigned operator* (const sc_unsigned &u, const sc_uint_base &v)
sc_signed operator* (const sc_unsigned &u, const sc_int_base &v)
sc_unsigned operator* (const sc_uint_base &u, const sc_unsigned &v)
sc_signed operator* (const sc_int_base &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_unsigned operator/ (const sc_unsigned &u, const sc_unsigned &v)
sc_signed operator/ (const sc_unsigned &u, int64 v)
sc_unsigned operator/ (const sc_unsigned &u, uint64 v)
sc_signed operator/ (const sc_unsigned &u, long v)
sc_unsigned operator/ (const sc_unsigned &u, unsigned long v)
sc_signed operator/ (const sc_unsigned &u, int v)
sc_unsigned operator/ (const sc_unsigned &u, unsigned int v)
sc_signed operator/ (int64 u, const sc_unsigned &v)
sc_unsigned operator/ (uint64 u, const sc_unsigned &v)
sc_signed operator/ (long u, const sc_unsigned &v)
sc_unsigned operator/ (unsigned long u, const sc_unsigned &v)
sc_signed operator/ (int u, const sc_unsigned &v)
sc_unsigned operator/ (unsigned int u, const sc_unsigned &v)
sc_unsigned operator/ (const sc_unsigned &u, const sc_uint_base &v)
sc_signed operator/ (const sc_unsigned &u, const sc_int_base &v)
sc_unsigned operator/ (const sc_uint_base &u, const sc_unsigned &v)
sc_signed operator/ (const sc_int_base &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_unsigned operator% (const sc_unsigned &u, const sc_unsigned &v)
sc_signed operator% (const sc_unsigned &u, int64 v)
sc_unsigned operator% (const sc_unsigned &u, uint64 v)
sc_signed operator% (const sc_unsigned &u, long v)
sc_unsigned operator% (const sc_unsigned &u, unsigned long v)
sc_signed operator% (const sc_unsigned &u, int v)
sc_unsigned operator% (const sc_unsigned &u, unsigned int v)
sc_signed operator% (int64 u, const sc_unsigned &v)
sc_unsigned operator% (uint64 u, const sc_unsigned &v)
sc_signed operator% (long u, const sc_unsigned &v)
sc_unsigned operator% (unsigned long u, const sc_unsigned &v)
sc_signed operator% (int u, const sc_unsigned &v)
sc_unsigned operator% (unsigned int u, const sc_unsigned &v)
sc_unsigned operator% (const sc_unsigned &u, const sc_uint_base &v)
sc_signed operator% (const sc_unsigned &u, const sc_int_base &v)
sc_unsigned operator% (const sc_uint_base &u, const sc_unsigned &v)
sc_signed operator% (const sc_int_base &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_unsigned operator & (const sc_unsigned &u, const sc_unsigned &v)
sc_signed operator & (const sc_unsigned &u, int64 v)
sc_unsigned operator & (const sc_unsigned &u, uint64 v)
sc_signed operator & (const sc_unsigned &u, long v)
sc_unsigned operator & (const sc_unsigned &u, unsigned long v)
sc_signed operator & (const sc_unsigned &u, int v)
sc_unsigned operator & (const sc_unsigned &u, unsigned int v)
sc_signed operator & (int64 u, const sc_unsigned &v)
sc_unsigned operator & (uint64 u, const sc_unsigned &v)
sc_signed operator & (long u, const sc_unsigned &v)
sc_unsigned operator & (unsigned long u, const sc_unsigned &v)
sc_signed operator & (int u, const sc_unsigned &v)
sc_unsigned operator & (unsigned int u, const sc_unsigned &v)
sc_unsigned operator & (const sc_unsigned &u, const sc_uint_base &v)
sc_signed operator & (const sc_unsigned &u, const sc_int_base &v)
sc_unsigned operator & (const sc_uint_base &u, const sc_unsigned &v)
sc_signed operator & (const sc_int_base &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_unsigned operator| (const sc_unsigned &u, const sc_unsigned &v)
sc_signed operator| (const sc_unsigned &u, int64 v)
sc_unsigned operator| (const sc_unsigned &u, uint64 v)
sc_signed operator| (const sc_unsigned &u, long v)
sc_unsigned operator| (const sc_unsigned &u, unsigned long v)
sc_signed operator| (const sc_unsigned &u, int v)
sc_unsigned operator| (const sc_unsigned &u, unsigned int v)
sc_signed operator| (int64 u, const sc_unsigned &v)
sc_unsigned operator| (uint64 u, const sc_unsigned &v)
sc_signed operator| (long u, const sc_unsigned &v)
sc_unsigned operator| (unsigned long u, const sc_unsigned &v)
sc_signed operator| (int u, const sc_unsigned &v)
sc_unsigned operator| (unsigned int u, const sc_unsigned &v)
sc_unsigned operator| (const sc_unsigned &u, const sc_uint_base &v)
sc_signed operator| (const sc_unsigned &u, const sc_int_base &v)
sc_unsigned operator| (const sc_uint_base &u, const sc_unsigned &v)
sc_signed operator| (const sc_int_base &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_unsigned operator^ (const sc_unsigned &u, const sc_unsigned &v)
sc_signed operator^ (const sc_unsigned &u, int64 v)
sc_unsigned operator^ (const sc_unsigned &u, uint64 v)
sc_signed operator^ (const sc_unsigned &u, long v)
sc_unsigned operator^ (const sc_unsigned &u, unsigned long v)
sc_signed operator^ (const sc_unsigned &u, int v)
sc_unsigned operator^ (const sc_unsigned &u, unsigned int v)
sc_signed operator^ (int64 u, const sc_unsigned &v)
sc_unsigned operator^ (uint64 u, const sc_unsigned &v)
sc_signed operator^ (long u, const sc_unsigned &v)
sc_unsigned operator^ (unsigned long u, const sc_unsigned &v)
sc_signed operator^ (int u, const sc_unsigned &v)
sc_unsigned operator^ (unsigned int u, const sc_unsigned &v)
sc_unsigned operator^ (const sc_unsigned &u, const sc_uint_base &v)
sc_signed operator^ (const sc_unsigned &u, const sc_int_base &v)
sc_unsigned operator^ (const sc_uint_base &u, const sc_unsigned &v)
sc_signed operator^ (const sc_int_base &u, const sc_unsigned &v)
sc_unsigned operator<< (const sc_unsigned &u, const sc_signed &v)
sc_signed operator<< (const sc_signed &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_uint_base &v)
sc_unsigned operator<< (const sc_unsigned &u, const sc_int_base &v)
sc_unsigned operator>> (const sc_unsigned &u, const sc_signed &v)
sc_signed operator>> (const sc_signed &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 &, const sc_uint_base &)
sc_unsigned operator>> (const sc_unsigned &, const sc_int_base &)
sc_unsigned operator+ (const sc_unsigned &u)
sc_signed operator- (const sc_unsigned &u)
bool operator== (const sc_unsigned &u, const sc_signed &v)
bool operator== (const sc_signed &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_uint_base &v)
bool operator== (const sc_unsigned &u, const sc_int_base &v)
bool operator== (const sc_uint_base &u, const sc_unsigned &v)
bool operator== (const sc_int_base &u, const sc_unsigned &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_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_uint_base &v)
bool operator!= (const sc_unsigned &u, const sc_int_base &v)
bool operator!= (const sc_uint_base &u, const sc_unsigned &v)
bool operator!= (const sc_int_base &u, const sc_unsigned &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_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_uint_base &v)
bool operator< (const sc_unsigned &u, const sc_int_base &v)
bool operator< (const sc_uint_base &u, const sc_unsigned &v)
bool operator< (const sc_int_base &u, const sc_unsigned &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_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_uint_base &v)
bool operator<= (const sc_unsigned &u, const sc_int_base &v)
bool operator<= (const sc_uint_base &u, const sc_unsigned &v)
bool operator<= (const sc_int_base &u, const sc_unsigned &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_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_uint_base &v)
bool operator> (const sc_unsigned &u, const sc_int_base &v)
bool operator> (const sc_uint_base &u, const sc_unsigned &v)
bool operator> (const sc_int_base &u, const sc_unsigned &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_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_uint_base &v)
bool operator>= (const sc_unsigned &u, const sc_int_base &v)
bool operator>= (const sc_uint_base &u, const sc_unsigned &v)
bool operator>= (const sc_int_base &u, const sc_unsigned &v)
sc_unsigned operator~ (const sc_unsigned &u)
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=0, small_type if_v_signed=0)
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.h の 971 行で定義されています。

型定義

typedef bool sc_dt::sc_unsigned::elemtype [private]

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

コンストラクタとデストラクタ

sc_dt::sc_unsigned::sc_unsigned ( int  nb = sc_length_param().len()  )  [explicit]

sc_dt::sc_unsigned::sc_unsigned ( const sc_unsigned &  v  ) 

sc_dt::sc_unsigned::sc_unsigned ( const sc_signed &  v  ) 

template<class T>
sc_dt::sc_unsigned::sc_unsigned ( const sc_generic_base< T > &  v  )  [inline, explicit]

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

02133 {
02134     int nb = v->length();
02135     sgn = default_sign();
02136     if( nb > 0 ) {
02137         nbits = num_bits( nb );
02138     } else {
02139         char msg[BUFSIZ];
02140         std::sprintf( msg,
02141                     "sc_unsigned( sc_generic_base<T> ) : nb = %d is not valid", nb);
02142         SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg );
02143     }
02144     ndigits = DIV_CEIL(nbits);
02145 #   ifdef SC_MAX_NBITS
02146         test_bound(nb);
02147 #    else
02148         digit = new sc_digit[ndigits];
02149 #    endif
02150     makezero();
02151     v->to_sc_unsigned(*this);
02152 }

sc_dt::sc_unsigned::sc_unsigned ( const sc_bv_base &  v  )  [explicit]

sc_dt::sc_unsigned::sc_unsigned ( const sc_lv_base &  v  )  [explicit]

sc_dt::sc_unsigned::sc_unsigned ( const sc_int_subref_r &  v  )  [explicit]

sc_dt::sc_unsigned::sc_unsigned ( const sc_uint_subref_r &  v  )  [explicit]

sc_dt::sc_unsigned::sc_unsigned ( const sc_signed_subref_r &  v  )  [explicit]

sc_dt::sc_unsigned::sc_unsigned ( const sc_unsigned_subref_r &  v  )  [explicit]

virtual sc_dt::sc_unsigned::~sc_unsigned (  )  [inline, virtual]

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

01045         {
01046 #           ifndef SC_MAX_NBITS
01047                 delete [] digit;
01048 #           endif
01049         }

sc_dt::sc_unsigned::sc_unsigned ( const sc_unsigned &  v,
small_type  s 
) [private]

sc_dt::sc_unsigned::sc_unsigned ( const sc_signed &  v,
small_type  s 
) [private]

sc_dt::sc_unsigned::sc_unsigned ( small_type  s,
int  nb,
int  nd,
sc_digit *  d,
bool  alloc = true 
) [private]

sc_dt::sc_unsigned::sc_unsigned ( const sc_signed *  u,
int  l,
int  r 
) [private]

sc_dt::sc_unsigned::sc_unsigned ( const sc_unsigned *  u,
int  l,
int  r 
) [private]

関数

const sc_unsigned& sc_dt::sc_unsigned::operator= ( const sc_unsigned &  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

const sc_unsigned& sc_dt::sc_unsigned::operator= ( const sc_unsigned_subref_r &  a  ) 

template<class T>
const sc_unsigned& sc_dt::sc_unsigned::operator= ( const sc_generic_base< T > &  a  )  [inline]

sc_dt::sc_biguint< W >で再定義されています。

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

01010         { a->to_sc_unsigned(*this); return *this; }

const sc_unsigned& sc_dt::sc_unsigned::operator= ( const sc_signed &  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

const sc_unsigned& sc_dt::sc_unsigned::operator= ( const sc_signed_subref_r &  a  ) 

const sc_unsigned & sc_dt::sc_unsigned::operator= ( const char *  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

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

00372 {
00373     if( a == 0 ) {
00374         SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
00375                          "character string is zero" );
00376     }
00377     if( *a == 0 ) {
00378         SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
00379                          "character string is empty" );
00380     }
00381     try {     
00382         int len = length();
00383         sc_ufix aa( a, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
00384         return this->operator = ( aa );
00385     } catch( sc_core::sc_report ) {
00386         char msg[BUFSIZ];
00387         std::sprintf( msg, "character string '%s' is not valid", a );
00388         SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
00389         // never reached
00390     }
00391     return *this;
00392 }

const sc_unsigned & sc_dt::sc_unsigned::operator= ( int64  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

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

00396 {
00397   sgn = get_sign(v);
00398   if ( sgn == SC_ZERO ) {
00399     vec_zero(ndigits, digit);
00400   }
00401   else {
00402     from_uint(ndigits, digit, (uint64) v);
00403     convert_SM_to_2C_to_SM(); 
00404   }
00405   return *this;
00406 }

const sc_unsigned & sc_dt::sc_unsigned::operator= ( uint64  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

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

00410 {
00411   if (v == 0) {
00412     sgn = SC_ZERO;
00413     vec_zero(ndigits, digit);
00414   }
00415   else {
00416     sgn = SC_POS;
00417     from_uint(ndigits, digit, v);
00418     convert_SM_to_2C_to_SM();
00419   }
00420   return *this;
00421 }

const sc_unsigned & sc_dt::sc_unsigned::operator= ( long  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

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

00425 {
00426   sgn = get_sign(v);
00427   if ( sgn == SC_ZERO ) {
00428     vec_zero(ndigits, digit);
00429   }
00430   else {
00431     from_uint(ndigits, digit, (unsigned long) v);
00432     convert_SM_to_2C_to_SM(); 
00433   }
00434   return *this;
00435 }

const sc_unsigned & sc_dt::sc_unsigned::operator= ( unsigned long  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

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

00439 {
00440   if (v == 0) {
00441     sgn = SC_ZERO;
00442     vec_zero(ndigits, digit);
00443   }
00444   else {
00445     sgn = SC_POS;
00446     from_uint(ndigits, digit, v);
00447     convert_SM_to_2C_to_SM();
00448   }
00449   return *this;
00450 }

const sc_unsigned& sc_dt::sc_unsigned::operator= ( int  v  )  [inline]

sc_dt::sc_biguint< W >で再定義されています。

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

01022         { return operator=((long) v); }

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

sc_dt::sc_biguint< W >で再定義されています。

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

01025         { return operator=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator= ( double  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

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

00454 {
00455   is_bad_double(v);
00456   sgn = SC_POS;
00457   register int i = 0;
00458   while (floor(v) && (i < ndigits)) {
00459 #ifndef WIN32
00460     digit[i++] = (sc_digit) floor(remainder(v, DIGIT_RADIX));
00461 #else
00462     digit[i++] = (sc_digit) floor(fmod(v, DIGIT_RADIX));
00463 #endif
00464     v /= DIGIT_RADIX;
00465   }
00466   vec_zero(i, ndigits, digit);
00467   convert_SM_to_2C_to_SM();
00468   return *this;  
00469 }

const sc_unsigned & sc_dt::sc_unsigned::operator= ( const sc_int_base &  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

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

00530 { return operator=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator= ( const sc_uint_base &  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

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

00627 { return operator=((uint64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator= ( const sc_bv_base &  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

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

00476 {
00477     int minlen = sc_min( nbits, v.length() );
00478     int i = 0;
00479     for( ; i < minlen; ++ i ) {
00480         safe_set( i, v.get_bit( i ), digit );
00481     }
00482     for( ; i < nbits; ++ i ) {
00483         safe_set( i, 0, digit );  // zero-extend
00484     }
00485     convert_2C_to_SM();
00486     return *this;
00487 }

const sc_unsigned & sc_dt::sc_unsigned::operator= ( const sc_lv_base &  v  ) 

sc_dt::sc_biguint< W >で再定義されています。

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

00491 {
00492     int minlen = sc_min( nbits, v.length() );
00493     int i = 0;
00494     for( ; i < minlen; ++ i ) {
00495         safe_set( i, sc_logic( v.get_bit( i ) ).to_bool(), digit );
00496     }
00497     for( ; i < nbits; ++ i ) {
00498         safe_set( i, 0, digit );  // zero-extend
00499     }
00500     convert_2C_to_SM();
00501     return *this;
00502 }

sc_digit* sc_dt::sc_unsigned::get_raw (  )  const [inline]

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

01053 { return digit; }

virtual int sc_dt::sc_unsigned::concat_length ( bool *  xz_present_p  )  const [inline, virtual]

sc_dt::sc_value_baseを再定義しています。

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

01055        { if ( xz_present_p ) *xz_present_p = false; return nbits-1; }

bool sc_dt::sc_unsigned::concat_get_ctrl ( sc_digit *  dst_p,
int  low_i 
) const [virtual]

sc_dt::sc_value_baseを再定義しています。

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

00123 {
00124     int      dst_i;        // Index to next word to set in dst_p.
00125     int      end_i;        // Index of high order word to set.
00126     int      left_shift;   // Amount to shift value left.
00127     sc_digit mask;         // Mask for partial word sets.
00128 
00129 
00130     // CALCULATE METRICS FOR DATA MOVEMENT:
00131 
00132     dst_i = low_i / BITS_PER_DIGIT;
00133     end_i = (low_i + nbits - 2) / BITS_PER_DIGIT;
00134     left_shift = low_i % BITS_PER_DIGIT;
00135 
00136 
00137     // MOVE FIRST WORD (IT MAY BE PARTIAL) AND THEN ANY OTHERS:
00138     // 
00139     // We may "clobber" upper bits, but they will be written at some point
00140     // anyway.
00141 
00142     mask = ~(-1 << left_shift);
00143     dst_p[dst_i] = ( dst_p[dst_i] & ~mask );
00144     dst_i++;
00145 
00146     for ( ; dst_i <= end_i; dst_i++ ) dst_p[dst_i] = 0;
00147 
00148     return false;
00149 }

bool sc_dt::sc_unsigned::concat_get_data ( sc_digit *  dst_p,
int  low_i 
) const [virtual]

sc_dt::sc_value_baseを再定義しています。

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

00152 {
00153     int      dst_i;        // Index to next word to set in dst_p.
00154     int      end_i;        // Index of high order word to set.
00155     int      high_i;       // Index w/in word of high order bit.
00156     int      left_shift;   // Amount to shift value left.
00157     sc_digit left_word;    // High word component for set.
00158     sc_digit mask;         // Mask for partial word sets.
00159     bool     result;       // True if inserting non-zero data.
00160     int      right_shift;  // Amount to shift value right.
00161     sc_digit right_word;   // Low word component for set.
00162     int      real_bits;    // nbits - 1.
00163     int      src_i;        // Index to next word to get from digit.
00164 
00165 
00166     // CALCULATE METRICS FOR DATA MOVEMENT:
00167 
00168     real_bits = nbits - 1;          // Remove that extra sign bit.
00169     dst_i = low_i / BITS_PER_DIGIT;
00170     high_i = low_i + real_bits - 1;
00171     end_i = high_i / BITS_PER_DIGIT;
00172     left_shift = low_i % BITS_PER_DIGIT;
00173 
00174 
00175     switch ( sgn )
00176     {
00177 
00178       // POSITIVE SOURCE VALUE:
00179 
00180       case SC_POS:
00181         result = true;
00182 
00183         // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
00184 
00185         if ( dst_i == end_i )
00186         {
00187             mask = ~(-1 << real_bits) << left_shift;
00188             dst_p[dst_i] = ( dst_p[dst_i] & ~mask ) | 
00189                 ((digit[0] << left_shift) & mask);
00190                     // #### We really want zero propogation on the top!
00191         }
00192 
00193 
00194         // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
00195 
00196         else if ( left_shift == 0 )
00197         {
00198             for ( src_i = 0; dst_i < end_i; dst_i++, src_i++ )
00199             {
00200                 dst_p[dst_i] = digit[src_i];
00201             }
00202             high_i = high_i % BITS_PER_DIGIT;
00203             mask = ~(-2 << high_i) & DIGIT_MASK;
00204             dst_p[dst_i] = digit[src_i] & mask;
00205         }
00206 
00207 
00208         // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
00209 
00210         else
00211         {
00212             high_i = high_i % BITS_PER_DIGIT;
00213             right_shift = BITS_PER_DIGIT - left_shift;
00214             mask = ~(-1 << left_shift);
00215             right_word = digit[0];
00216             dst_p[dst_i] = (dst_p[dst_i] & mask) | 
00217                 ((right_word << left_shift) & DIGIT_MASK);
00218             for ( src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++ )
00219             {
00220                 left_word = digit[src_i];
00221                 dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) |
00222                     (right_word >> right_shift);
00223                 right_word = left_word;
00224             }
00225             left_word = digit[src_i];
00226             mask = ~(-2 << high_i) & DIGIT_MASK;
00227             dst_p[dst_i] = ((left_word << left_shift) |
00228                 (right_word >> right_shift)) & mask;
00229         }
00230         break;
00231 
00232 
00233       // VALUE IS ZERO:
00234 
00235       default:
00236         result = false;
00237 
00238         // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
00239 
00240         if ( dst_i == end_i )
00241         {
00242             mask = ~(-1 << nbits) << left_shift;
00243             dst_p[dst_i] = dst_p[dst_i] & ~mask;
00244         }
00245 
00246 
00247         // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
00248 
00249         else if ( left_shift == 0 )
00250         {
00251             for ( src_i = 0; dst_i < end_i; dst_i++, src_i++ )
00252             {
00253                 dst_p[dst_i] = 0;
00254             }
00255             high_i = high_i % BITS_PER_DIGIT;
00256             mask = ~(-2 << high_i) & DIGIT_MASK;
00257             dst_p[dst_i] = 0; 
00258         }
00259 
00260 
00261         // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
00262 
00263         else
00264         {
00265             high_i = high_i % BITS_PER_DIGIT;
00266             right_shift = BITS_PER_DIGIT - left_shift;
00267             mask = ~(-1 << left_shift);
00268             dst_p[dst_i] = (dst_p[dst_i] & mask);
00269             for ( dst_i++; dst_i <= end_i; dst_i++ )
00270             {
00271                 dst_p[dst_i] = 0;
00272             }
00273         }
00274         break;
00275     }
00276     return result;
00277 }

uint64 sc_dt::sc_unsigned::concat_get_uint64 (  )  const [virtual]

sc_dt::sc_value_baseを再定義しています。

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

00282 {
00283     uint64        result;
00284 
00285     switch ( sgn )
00286     {
00287       case SC_POS:
00288         result = 0;        
00289         if ( ndigits > 2 )
00290             result = digit[2];
00291         if ( ndigits > 1 )
00292             result = (result << BITS_PER_DIGIT) | digit[1];
00293         result = (result << BITS_PER_DIGIT) | digit[0];    
00294         break;
00295       default:
00296         result = 0;
00297         break;
00298     }
00299     return result;
00300 }

void sc_dt::sc_unsigned::concat_set ( int64  src,
int  low_i 
) [virtual]

sc_dt::sc_value_baseを再定義しています。

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

00304 {    
00305     *this = (low_i < 64) ? src >> low_i : src >> 63;
00306 }

void sc_dt::sc_unsigned::concat_set ( const sc_signed &  src,
int  low_i 
) [virtual]

sc_dt::sc_value_baseを再定義しています。

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

00309 {
00310     if ( low_i < src.length() )
00311         *this = src >> low_i;
00312     else
00313         *this = (src<0) ? (int_type)-1 : 0;
00314 }

void sc_dt::sc_unsigned::concat_set ( const sc_unsigned &  src,
int  low_i 
) [virtual]

sc_dt::sc_value_baseを再定義しています。

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

00317 {
00318     if ( low_i < src.length() )
00319         *this = src >> low_i;
00320     else
00321         *this = 0;
00322 }

void sc_dt::sc_unsigned::concat_set ( uint64  src,
int  low_i 
) [virtual]

sc_dt::sc_value_baseを再定義しています。

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

00325 {
00326     *this = (low_i < 64) ? src >> low_i : 0;
00327 }

sc_unsigned& sc_dt::sc_unsigned::operator++ (  ) 

const sc_unsigned sc_dt::sc_unsigned::operator++ ( int   ) 

sc_unsigned& sc_dt::sc_unsigned::operator-- (  ) 

const sc_unsigned sc_dt::sc_unsigned::operator-- ( int   ) 

void sc_dt::sc_unsigned::check_index ( int  i  )  const [inline]

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

01078         { if ( (i < 0) || (i >= nbits-1) ) invalid_index(i); }

void sc_dt::sc_unsigned::invalid_index ( int  i  )  const

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

00089 {
00090     char msg[BUFSIZ];
00091     std::sprintf( msg,
00092          "sc_biguint bit selection: index = %d violates "
00093          "0 <= index <= %d",
00094          i, nbits - 2 );
00095     SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
00096 }

sc_unsigned_bitref& sc_dt::sc_unsigned::operator[] ( int  i  )  [inline]

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

01083         {
01084             check_index(i);
01085             sc_unsigned_bitref* result_p =
01086                 sc_unsigned_bitref::m_pool.allocate();
01087             result_p->initialize( this, i );
01088             return *result_p;
01089         }

const sc_unsigned_bitref_r& sc_dt::sc_unsigned::operator[] ( int  i  )  const [inline]

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

01092         {
01093             check_index(i);
01094             sc_unsigned_bitref* result_p =
01095                 sc_unsigned_bitref::m_pool.allocate();
01096             result_p->initialize( this, i );
01097             return *result_p;
01098         }

sc_unsigned_bitref& sc_dt::sc_unsigned::bit ( int  i  )  [inline]

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

01101         {
01102             check_index(i);
01103             sc_unsigned_bitref* result_p =
01104                 sc_unsigned_bitref::m_pool.allocate();
01105             result_p->initialize( this, i );
01106             return *result_p;
01107         }

const sc_unsigned_bitref_r& sc_dt::sc_unsigned::bit ( int  i  )  const [inline]

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

01110         {
01111             check_index(i);
01112             sc_unsigned_bitref* result_p =
01113                 sc_unsigned_bitref::m_pool.allocate();
01114             result_p->initialize( this, i );
01115             return *result_p;
01116         }

void sc_dt::sc_unsigned::check_range ( int  l,
int  r 
) const [inline]

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

01129         {
01130             if ( l < r )
01131             {
01132                 if ( (l < 0) || (r >= nbits-1) ) invalid_range(l,r);
01133             }
01134             else
01135             {
01136                 if ( (r < 0) || (l >= nbits-1) ) invalid_range(l,r);
01137             }
01138         }

void sc_dt::sc_unsigned::invalid_range ( int  l,
int  r 
) const

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

00100 {
00101     char msg[BUFSIZ];
00102     std::sprintf( msg,
00103          "sc_biguint part selection: left = %d, right = %d \n"
00104          "  violates either (0 <= left <= %d) or (0 <= right <= %d)",
00105          l, r, nbits-2, nbits-2 );
00106     SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
00107 }

sc_unsigned_subref& sc_dt::sc_unsigned::range ( int  i,
int  j 
) [inline]

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

01143         {
01144             check_range(i,j);
01145             sc_unsigned_subref* result_p =
01146                 sc_unsigned_subref::m_pool.allocate();
01147             result_p->initialize( this, i, j );
01148             return *result_p;
01149         }

const sc_unsigned_subref_r& sc_dt::sc_unsigned::range ( int  i,
int  j 
) const [inline]

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

01152         {
01153             check_range(i,j);
01154             sc_unsigned_subref* result_p =
01155                 sc_unsigned_subref::m_pool.allocate();
01156             result_p->initialize( this, i, j );
01157             return *result_p;
01158         }

sc_unsigned_subref& sc_dt::sc_unsigned::operator() ( int  i,
int  j 
) [inline]

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

01161         {
01162             check_range(i,j);
01163             sc_unsigned_subref* result_p =
01164                 sc_unsigned_subref::m_pool.allocate();
01165             result_p->initialize( this, i, j );
01166             return *result_p;
01167         }

const sc_unsigned_subref_r& sc_dt::sc_unsigned::operator() ( int  i,
int  j 
) const [inline]

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

01170         {
01171             check_range(i,j);
01172             sc_unsigned_subref* result_p =
01173                 sc_unsigned_subref::m_pool.allocate();
01174             result_p->initialize( this, i, j );
01175             return *result_p;
01176         }

int sc_dt::sc_unsigned::to_int (  )  const

unsigned int sc_dt::sc_unsigned::to_uint (  )  const

long sc_dt::sc_unsigned::to_long (  )  const

unsigned long sc_dt::sc_unsigned::to_ulong (  )  const

int64 sc_dt::sc_unsigned::to_int64 (  )  const

uint64 sc_dt::sc_unsigned::to_uint64 (  )  const

double sc_dt::sc_unsigned::to_double (  )  const

const std::string sc_dt::sc_unsigned::to_string ( sc_numrep  numrep = SC_DEC  )  const

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

00509 {
00510     int len = length();
00511     sc_ufix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
00512     return aa.to_string( numrep );
00513 }

const std::string sc_dt::sc_unsigned::to_string ( sc_numrep  numrep,
bool  w_prefix 
) const

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

00517 {
00518     int len = length();
00519     sc_ufix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
00520     return aa.to_string( numrep, w_prefix );
00521 }

void sc_dt::sc_unsigned::print ( ::std::ostream &  os = ::std::cout  )  const [inline]

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

01204         { os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }

void sc_dt::sc_unsigned::scan ( ::std::istream &  is = ::std::cin  ) 

void sc_dt::sc_unsigned::dump ( ::std::ostream &  os = ::std::cout  )  const

int sc_dt::sc_unsigned::length (  )  const [inline]

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

01212 { return nbits - 1; }  // Bit width.

bool sc_dt::sc_unsigned::iszero (  )  const

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

02050 {
02051   if (sgn == SC_ZERO)
02052     return true;
02053 
02054   else if (sgn == SC_NEG) {
02055 
02056     // A negative unsigned number can be zero, e.g., -16 in 4 bits, so
02057     // check that.
02058 
02059 #ifdef SC_MAX_NBITS
02060     sc_digit d[MAX_NDIGITS];
02061 #else
02062     sc_digit *d = new sc_digit[ndigits];
02063 #endif
02064 
02065     vec_copy(ndigits, d, digit);
02066     vec_complement(ndigits, d);
02067     trim_unsigned(nbits, ndigits, d);
02068 
02069     bool res = check_for_zero(ndigits, d);
02070 
02071 #ifndef SC_MAX_NBITS
02072     delete [] d;
02073 #endif
02074 
02075     return res;
02076     
02077   }
02078   else
02079     return false;
02080 }

bool sc_dt::sc_unsigned::sign (  )  const [inline]

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

01214 { return 0; }            // Sign.

bool sc_dt::sc_unsigned::and_reduce (  )  const

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

00335 {
00336     int i;   // Digit examining.
00337 
00338         if ( sgn == SC_ZERO ) return false;
00339     for ( i = 0; i < ndigits-1; i++ )
00340         if ( (digit[i] & DIGIT_MASK) != DIGIT_MASK ) return false;
00341     if ( (digit[i] & ~(-1 << ((nbits-1) % BITS_PER_DIGIT))) ==
00342         (sc_digit)~(-1 << ((nbits-1) % BITS_PER_DIGIT)))
00343                 return true;
00344     return false;
00345 }

bool sc_dt::sc_unsigned::nand_reduce (  )  const [inline]

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

01221         { return ( ! and_reduce() ); }

bool sc_dt::sc_unsigned::or_reduce (  )  const

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

00348 {
00349         return ( sgn == SC_ZERO ) ? false : true;
00350 }

bool sc_dt::sc_unsigned::nor_reduce (  )  const [inline]

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

01226         { return ( ! or_reduce() ); }

bool sc_dt::sc_unsigned::xor_reduce (  )  const

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

00353 {
00354     int i;   // Digit examining.
00355     int odd; // Flag for odd number of digits.
00356 
00357     odd = 0;
00358     for ( i = 0; i < nbits-1; i++ )
00359         if ( test(i) ) odd = ~odd;
00360     return odd ? true : false;
00361 }

bool sc_dt::sc_unsigned::xnor_reduce (  )  const [inline]

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

01231         { return ( ! xor_reduce() ); }

bool sc_dt::sc_unsigned::test ( int  i  )  const

void sc_dt::sc_unsigned::set ( int  i  ) 

void sc_dt::sc_unsigned::clear ( int  i  ) 

void sc_dt::sc_unsigned::set ( int  i,
bool  v 
) [inline]

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

01239     { if (v) set(i); else clear(i);  }

void sc_dt::sc_unsigned::invert ( int  i  )  [inline]

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

01241     { if (test(i)) clear(i); else set(i);  }

void sc_dt::sc_unsigned::reverse (  ) 

void sc_dt::sc_unsigned::get_packed_rep ( sc_digit *  buf  )  const

void sc_dt::sc_unsigned::set_packed_rep ( sc_digit *  buf  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator+= ( const sc_signed &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator+= ( const sc_unsigned &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator+= ( int64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator+= ( uint64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator+= ( long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator+= ( unsigned long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator+= ( int  v  )  [inline]

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

01310     { return operator+=((long) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator+= ( unsigned int  v  )  [inline]

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

01312     { return operator+=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator+= ( const sc_int_base &  v  ) 

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

00534 { return operator+=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator+= ( const sc_uint_base &  v  ) 

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

00637 { return operator+=((uint64) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator-= ( const sc_signed &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator-= ( const sc_unsigned &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator-= ( int64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator-= ( uint64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator-= ( long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator-= ( unsigned long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator-= ( int  v  )  [inline]

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

01348     { return operator-=((long) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator-= ( unsigned int  v  )  [inline]

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

01350     { return operator-=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator-= ( const sc_int_base &  v  ) 

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

00538 { return operator-=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator-= ( const sc_uint_base &  v  ) 

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

00641 { return operator-=((uint64) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator*= ( const sc_signed &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator*= ( const sc_unsigned &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator*= ( int64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator*= ( uint64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator*= ( long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator*= ( unsigned long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator*= ( int  v  )  [inline]

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

01388     { return operator*=((long) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator*= ( unsigned int  v  )  [inline]

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

01390     { return operator*=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator*= ( const sc_int_base &  v  ) 

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

00542 { return operator*=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator*= ( const sc_uint_base &  v  ) 

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

00651 { return operator*=((uint64) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator/= ( const sc_signed &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator/= ( const sc_unsigned &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator/= ( int64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator/= ( uint64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator/= ( long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator/= ( unsigned long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator/= ( int  v  )  [inline]

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

01428     { return operator/=((long) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator/= ( unsigned int  v  )  [inline]

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

01430     { return operator/=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator/= ( const sc_int_base &  v  ) 

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

00546 { return operator/=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator/= ( const sc_uint_base &  v  ) 

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

00661 { return operator/=((uint64) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator%= ( const sc_signed &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator%= ( const sc_unsigned &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator%= ( int64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator%= ( uint64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator%= ( long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator%= ( unsigned long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator%= ( int  v  )  [inline]

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

01468     { return operator%=((long) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator%= ( unsigned int  v  )  [inline]

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

01470     { return operator%=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator%= ( const sc_int_base &  v  ) 

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

00550 { return operator%=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator%= ( const sc_uint_base &  v  ) 

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

00671 { return operator%=((uint64) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator &= ( const sc_signed &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator &= ( const sc_unsigned &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator &= ( int64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator &= ( uint64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator &= ( long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator &= ( unsigned long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator &= ( int  v  )  [inline]

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

01510     { return operator&=((long) v); }

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

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

01512     { return operator&=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator &= ( const sc_int_base &  v  ) 

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

00554 { return operator&=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator &= ( const sc_uint_base &  v  ) 

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

00681 { return operator&=((uint64) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator|= ( const sc_signed &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator|= ( const sc_unsigned &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator|= ( int64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator|= ( uint64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator|= ( long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator|= ( unsigned long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator|= ( int  v  )  [inline]

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

01550     { return operator|=((long) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator|= ( unsigned int  v  )  [inline]

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

01552     { return operator|=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator|= ( const sc_int_base &  v  ) 

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

00558 { return operator|=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator|= ( const sc_uint_base &  v  ) 

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

00691 { return operator|=((uint64) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator^= ( const sc_signed &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator^= ( const sc_unsigned &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator^= ( int64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator^= ( uint64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator^= ( long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator^= ( unsigned long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator^= ( int  v  )  [inline]

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

01590     { return operator^=((long) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator^= ( unsigned int  v  )  [inline]

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

01592     { return operator^=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator^= ( const sc_int_base &  v  ) 

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

00562 { return operator^=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator^= ( const sc_uint_base &  v  ) 

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

00701 { return operator^=((uint64) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator<<= ( const sc_signed &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator<<= ( const sc_unsigned &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator<<= ( int64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator<<= ( uint64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator<<= ( long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator<<= ( unsigned long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator<<= ( int  v  )  [inline]

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

01625     { return operator<<=((long) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator<<= ( unsigned int  v  )  [inline]

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

01627     { return operator<<=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator<<= ( const sc_int_base &  v  ) 

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

00569 { return operator<<=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator<<= ( const sc_uint_base &  v  ) 

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

00708 { return operator<<=((uint64) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator>>= ( const sc_signed &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator>>= ( const sc_unsigned &  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator>>= ( int64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator>>= ( uint64  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator>>= ( long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator>>= ( unsigned long  v  ) 

const sc_unsigned& sc_dt::sc_unsigned::operator>>= ( int  v  )  [inline]

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

01656     { return operator>>=((long) v); }

const sc_unsigned& sc_dt::sc_unsigned::operator>>= ( unsigned int  v  )  [inline]

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

01658     { return operator>>=((unsigned long) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator>>= ( const sc_int_base &  v  ) 

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

00576 { return operator>>=((int64) v); }

const sc_unsigned & sc_dt::sc_unsigned::operator>>= ( const sc_uint_base &  v  ) 

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

00715 { return operator>>=((uint64) v); }

small_type sc_dt::sc_unsigned::default_sign (  )  const [inline, private]

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

01961     { return SC_POS; }

int sc_dt::sc_unsigned::num_bits ( int  nb  )  const [inline, private]

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

01963 { return nb + 1; }

bool sc_dt::sc_unsigned::check_if_outside ( int  bit_num  )  const [private]

void sc_dt::sc_unsigned::copy_digits ( int  nb,
int  nd,
const sc_digit *  d 
) [inline, private]

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

01968     { copy_digits_unsigned(sgn, nbits, ndigits, digit, nb, nd, d); }

void sc_dt::sc_unsigned::makezero (  )  [inline, private]

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

01971     { sgn = make_zero(ndigits, digit); }

void sc_dt::sc_unsigned::convert_2C_to_SM (  )  [inline, private]

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

01976     { sgn = convert_unsigned_2C_to_SM(nbits, ndigits, digit); }

void sc_dt::sc_unsigned::convert_SM_to_2C_to_SM (  )  [inline, private]

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

01979     { sgn = convert_unsigned_SM_to_2C_to_SM(sgn, nbits, ndigits, digit); }

void sc_dt::sc_unsigned::convert_SM_to_2C (  )  [inline, private]

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

01982     { convert_unsigned_SM_to_2C(sgn, ndigits, digit); }

フレンドと関連する関数

friend class sc_concatref [friend]

sc_dt::sc_value_baseを再定義しています。

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

friend class sc_unsigned_bitref_r [friend]

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

friend class sc_unsigned_bitref [friend]

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

friend class sc_unsigned_subref_r [friend]

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

friend class sc_unsigned_subref [friend]

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

friend class sc_signed [friend]

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

friend class sc_signed_subref [friend]

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

friend class sc_signed_subref_r [friend]

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

sc_signed operator+ ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

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

01108 {
01109 
01110   if (u.sgn == SC_ZERO) // case 1
01111     return sc_signed(v);
01112 
01113   if (v.sgn == SC_ZERO) // case 2
01114     return sc_signed(u);
01115 
01116   // cases 3 and 4
01117   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01118                            v.sgn, v.nbits, v.ndigits, v.digit);
01119 
01120 }

sc_signed operator+ ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

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

01125 {
01126 
01127   if (u.sgn == SC_ZERO) // case 1
01128     return sc_signed(v);
01129 
01130   if (v.sgn == SC_ZERO) // case 2
01131     return sc_signed(u);
01132 
01133   // cases 3 and 4
01134   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01135                            v.sgn, v.nbits, v.ndigits, v.digit);
01136 
01137 }

sc_unsigned operator+ ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

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

00820 {
00821 
00822   if (u.sgn == SC_ZERO) // case 1
00823     return sc_unsigned(v);
00824 
00825   if (v.sgn == SC_ZERO) // case 2
00826     return sc_unsigned(u);
00827 
00828   // cases 3 and 4
00829   return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
00830                              v.sgn, v.nbits, v.ndigits, v.digit);
00831   
00832 }

sc_signed operator+ ( const sc_unsigned &  u,
int64  v 
) [friend]

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

01198 {
01199 
01200   if (v == 0)  // case 2
01201     return sc_signed(u);
01202 
01203   CONVERT_INT64(v);
01204 
01205   if (u.sgn == SC_ZERO)  // case 1
01206     return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
01207 
01208   // cases 3 and 4
01209   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01210                            vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
01211 
01212 }

sc_unsigned operator+ ( const sc_unsigned &  u,
uint64  v 
) [friend]

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

00837 {
00838 
00839   if (v == 0)  // case 2
00840     return sc_unsigned(u);
00841 
00842   CONVERT_INT64(v);
00843 
00844   if (u.sgn == SC_ZERO)  // case 1
00845     return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
00846 
00847   // cases 3 and 4
00848   return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
00849                              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
00850 
00851 }

sc_signed operator+ ( const sc_unsigned &  u,
long  v 
) [friend]

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

01314 {
01315 
01316   if (v == 0)  // case 2
01317     return sc_signed(u);
01318 
01319   CONVERT_LONG(v);
01320 
01321   if (u.sgn == SC_ZERO)  // case 1
01322     return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
01323 
01324   // cases 3 and 4
01325   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01326                            vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
01327 
01328 }

sc_unsigned operator+ ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

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

00876 {
00877 
00878   if (v == 0) // case 2
00879     return sc_unsigned(u);
00880 
00881   CONVERT_LONG(v);
00882 
00883   if (u.sgn == SC_ZERO)  // case 1
00884     return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
00885 
00886   // cases 3 and 4
00887   return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
00888                              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
00889 
00890 }

sc_signed operator+ ( const sc_unsigned &  u,
int  v 
) [friend]

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

01391     { return operator+(u, (long) v); }

sc_unsigned operator+ ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

sc_signed operator+ ( int64  u,
const sc_unsigned &  v 
) [friend]

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

01217 {
01218 
01219   if (u == 0) // case 1
01220     return sc_signed(v);
01221 
01222   CONVERT_INT64(u);
01223 
01224   if (v.sgn == SC_ZERO)  // case 2
01225     return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
01226 
01227   // cases 3 and 4
01228 
01229   return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01230                            v.sgn, v.nbits, v.ndigits, v.digit);
01231 
01232 }

sc_unsigned operator+ ( uint64  u,
const sc_unsigned &  v 
) [friend]

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

00856 {
00857 
00858   if (u == 0) // case 1
00859     return sc_unsigned(v);
00860 
00861   CONVERT_INT64(u);
00862 
00863   if (v.sgn == SC_ZERO)  // case 2
00864     return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
00865 
00866   // cases 3 and 4
00867 
00868   return add_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
00869                              v.sgn, v.nbits, v.ndigits, v.digit);
00870 
00871 }

sc_signed operator+ ( long  u,
const sc_unsigned &  v 
) [friend]

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

01333 {
01334 
01335   if (u == 0) // case 1
01336     return sc_signed(v);
01337 
01338   CONVERT_LONG(u);
01339 
01340   if (v.sgn == SC_ZERO)  // case 2
01341     return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
01342 
01343   // cases 3 and 4
01344   return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01345                            v.sgn, v.nbits, v.ndigits, v.digit);
01346 
01347 }

sc_unsigned operator+ ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

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

00895 {
00896 
00897   if (u == 0) // case 1
00898     return sc_unsigned(v);
00899 
00900   CONVERT_LONG(u);
00901 
00902   if (v.sgn == SC_ZERO)  // case 2
00903     return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
00904 
00905   // cases 3 and 4
00906   return add_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
00907                              v.sgn, v.nbits, v.ndigits, v.digit);
00908 
00909 }

sc_signed operator+ ( int  u,
const sc_unsigned &  v 
) [friend]

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

01396     { return operator+((long) u, v); }

sc_unsigned operator+ ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

sc_unsigned operator+ ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00631 { return operator+(u, (uint64) v); }

sc_signed operator+ ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00617 { return operator + ( u, SCAST<int64>( v ) ); }

sc_unsigned operator+ ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00634 { return operator+((uint64) u, v); }

sc_signed operator+ ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00621 { return operator + ( SCAST<int64>( u ), v ); }

sc_signed operator- ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

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

01428 {
01429 
01430   if (v.sgn == SC_ZERO)  // case 1
01431     return sc_signed(u);
01432 
01433   if (u.sgn == SC_ZERO) // case 2
01434     return sc_signed(v, -v.sgn);
01435 
01436   // cases 3 and 4
01437   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01438                            -v.sgn, v.nbits, v.ndigits, v.digit);
01439 
01440 }

sc_signed operator- ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

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

01445 {
01446 
01447   if (v.sgn == SC_ZERO)  // case 1
01448     return sc_signed(u);
01449 
01450   if (u.sgn == SC_ZERO) // case 2
01451     return sc_signed(v, -v.sgn);
01452 
01453   // cases 3 and 4
01454   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01455                            -v.sgn, v.nbits, v.ndigits, v.digit);
01456 
01457 }

sc_signed operator- ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

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

01411 {
01412 
01413   if (v.sgn == SC_ZERO)  // case 1
01414     return sc_signed(u);
01415 
01416   if (u.sgn == SC_ZERO) // case 2
01417     return sc_signed(v, -v.sgn);
01418 
01419   // cases 3 and 4
01420   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01421                            -v.sgn, v.nbits, v.ndigits, v.digit);
01422 
01423 }

sc_signed operator- ( const sc_unsigned &  u,
int64  v 
) [friend]

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

01518 {
01519 
01520   if (v == 0) // case 1
01521     return sc_signed(u);
01522 
01523   CONVERT_INT64(v);
01524 
01525   if (u.sgn == SC_ZERO) // case 2
01526     return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
01527 
01528   // cases 3 and 4
01529   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01530                            -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
01531 
01532 }

sc_signed operator- ( const sc_unsigned &  u,
uint64  v 
) [friend]

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

01596 {
01597 
01598   if (v == 0) // case 1
01599     return sc_signed(u);
01600 
01601   CONVERT_INT64(v);
01602 
01603   if (u.sgn == SC_ZERO) // case 2
01604     return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
01605 
01606   // cases 3 and 4
01607 
01608   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01609                            -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
01610 
01611 }

sc_signed operator- ( const sc_unsigned &  u,
long  v 
) [friend]

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

01673 {
01674 
01675   if (v == 0) // case 1
01676     return sc_signed(u);
01677 
01678   CONVERT_LONG(v);
01679 
01680   if (u.sgn == SC_ZERO) // case 2
01681     return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
01682 
01683   // cases 3 and 4
01684   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01685                            -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
01686 
01687 }

sc_signed operator- ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

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

01748 {
01749 
01750   if (v == 0) // case 1
01751     return sc_signed(u);
01752 
01753   CONVERT_LONG(v);
01754 
01755   if (u.sgn == SC_ZERO) // case 2
01756     return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
01757 
01758   // cases 3 and 4
01759   return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01760                            -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
01761 
01762 }

sc_signed operator- ( const sc_unsigned &  u,
int  v 
) [friend]

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

01448     { return operator-(u, (long) v); }

sc_signed operator- ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

sc_signed operator- ( int64  u,
const sc_unsigned &  v 
) [friend]

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

01537 {
01538 
01539   if (u == 0) // case 1
01540     return sc_signed(v, -v.sgn);
01541 
01542   CONVERT_INT64(u);
01543 
01544   if (v.sgn == SC_ZERO) // case 2
01545     return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
01546 
01547   // cases 3 and 4
01548 
01549   return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01550                            -v.sgn, v.nbits, v.ndigits, v.digit);
01551 
01552 }

sc_signed operator- ( uint64  u,
const sc_unsigned &  v 
) [friend]

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

01616 {
01617 
01618   if (u == 0) // case 1
01619     return sc_signed(v, -v.sgn);
01620 
01621   CONVERT_INT64(u);
01622 
01623   if (v.sgn == SC_ZERO) // case 2
01624     return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
01625 
01626   // cases 3 and 4
01627   return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01628                            -v.sgn, v.nbits, v.ndigits, v.digit);
01629 
01630 }

sc_signed operator- ( long  u,
const sc_unsigned &  v 
) [friend]

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

01692 {
01693 
01694   if (u == 0) // case 1
01695     return sc_signed(v, -v.sgn);
01696 
01697   CONVERT_LONG(u);
01698 
01699   if (v.sgn == SC_ZERO) // case 2
01700     return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
01701 
01702   // cases 3 and 4
01703   return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01704                            -v.sgn, v.nbits, v.ndigits, v.digit);
01705 
01706 }

sc_signed operator- ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

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

01767 {
01768   if (u == 0) // case 1
01769     return sc_signed(v, -v.sgn);
01770 
01771   CONVERT_LONG(u);
01772 
01773   if (v.sgn == SC_ZERO) // case 2
01774     return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
01775 
01776   // cases 3 and 4
01777   return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01778                            -v.sgn, v.nbits, v.ndigits, v.digit);
01779 
01780 }

sc_signed operator- ( int  u,
const sc_unsigned &  v 
) [friend]

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

01457     { return operator-((long) u, v); }

sc_signed operator- ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

sc_signed operator- ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00879 { return operator-(u, (uint64) v); }

sc_signed operator- ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00638 { return operator-(u, (int64) v); }

sc_signed operator- ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00883 { return operator-((uint64) u, v); }

sc_signed operator- ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00642 { return operator-((int64) u, v); }

sc_signed operator* ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

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

01798 {
01799  
01800   small_type s = mul_signs(u.sgn, v.sgn);
01801 
01802   if (s == SC_ZERO) // case 1
01803     return sc_signed();
01804 
01805   // cases 2-4
01806   return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
01807                            v.nbits, v.ndigits, v.digit);
01808 
01809 }

sc_signed operator* ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

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

01814 {
01815  
01816   small_type s = mul_signs(u.sgn, v.sgn);
01817 
01818   if (s == SC_ZERO) // case 1
01819     return sc_signed();
01820 
01821   // cases 2-4
01822   return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
01823                            v.nbits, v.ndigits, v.digit);
01824 
01825 }

sc_unsigned operator* ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

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

00949 {
00950  
00951   small_type s = mul_signs(u.sgn, v.sgn);
00952 
00953   if (s == SC_ZERO) // case 1
00954     return sc_unsigned();
00955 
00956   // cases 2-4
00957   return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
00958                              v.nbits, v.ndigits, v.digit);
00959 
00960 }

sc_signed operator* ( const sc_unsigned &  u,
int64  v 
) [friend]

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

01882 {
01883 
01884   small_type s = mul_signs(u.sgn, get_sign(v));
01885 
01886   if (s == SC_ZERO) // case 1
01887     return sc_signed();
01888 
01889   CONVERT_INT64_2(v);
01890 
01891   // cases 2-4
01892   return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
01893                            BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
01894   
01895 }

sc_unsigned operator* ( const sc_unsigned &  u,
uint64  v 
) [friend]

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

00965 {
00966 
00967   small_type s = mul_signs(u.sgn, get_sign(v));
00968 
00969   if (s == SC_ZERO) // case 1
00970     return sc_unsigned();
00971 
00972   CONVERT_INT64_2(v);
00973 
00974   // cases 2-4
00975   return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
00976                              BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
00977   
00978 }

sc_signed operator* ( const sc_unsigned &  u,
long  v 
) [friend]

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

01990 {
01991 
01992   small_type s = mul_signs(u.sgn, get_sign(v));
01993 
01994   if (s == SC_ZERO) // case 1
01995     return sc_signed();
01996 
01997   CONVERT_LONG_2(v);
01998 
01999   // cases 2-4
02000   return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
02001                            BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
02002   
02003 }

sc_unsigned operator* ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

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

01001 {
01002 
01003   small_type s = mul_signs(u.sgn, get_sign(v));
01004 
01005   if (s == SC_ZERO) // case 1
01006     return sc_unsigned();
01007 
01008   CONVERT_LONG_2(v);
01009 
01010   // else cases 2-4
01011   return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
01012                              BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
01013   
01014 }

sc_signed operator* ( const sc_unsigned &  u,
int  v 
) [friend]

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

01510     { return operator*(u, (long) v); }

sc_unsigned operator* ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

sc_signed operator* ( int64  u,
const sc_unsigned &  v 
) [friend]

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

01900 {
01901 
01902   small_type s = mul_signs(v.sgn, get_sign(u));
01903 
01904   if (s == SC_ZERO) // case 1
01905     return sc_signed();
01906 
01907   CONVERT_INT64_2(u);
01908 
01909   // cases 2-4
01910   return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
01911                            v.nbits, v.ndigits, v.digit);
01912   
01913 }

sc_unsigned operator* ( uint64  u,
const sc_unsigned &  v 
) [friend]

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

00983 {
00984 
00985   small_type s = mul_signs(v.sgn, get_sign(u));
00986 
00987   if (s == SC_ZERO) // case 1
00988     return sc_unsigned();
00989 
00990   CONVERT_INT64_2(u);
00991 
00992   // cases 2-4
00993   return mul_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
00994                              v.nbits, v.ndigits, v.digit);
00995   
00996 }

sc_signed operator* ( long  u,
const sc_unsigned &  v 
) [friend]

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

02008 {
02009 
02010   small_type s = mul_signs(v.sgn, get_sign(u));
02011 
02012   if (s == SC_ZERO) // case 1
02013     return sc_signed();
02014 
02015   CONVERT_LONG_2(u);
02016 
02017   // cases 2-4
02018   return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
02019                            v.nbits, v.ndigits, v.digit);
02020   
02021 }

sc_unsigned operator* ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

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

01018 {
01019 
01020   small_type s = mul_signs(v.sgn, get_sign(u));
01021 
01022   if (s == SC_ZERO) // case 1
01023     return sc_unsigned();
01024 
01025   CONVERT_LONG_2(u);
01026 
01027   // cases 2-4
01028   return mul_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
01029                              v.nbits, v.ndigits, v.digit);
01030   
01031 }

sc_signed operator* ( int  u,
const sc_unsigned &  v 
) [friend]

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

01515     { return operator*((long) u, v); }

sc_unsigned operator* ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

sc_unsigned operator* ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00645 { return operator*(u, (uint64) v); }

sc_signed operator* ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00659 { return operator * ( u, SCAST<int64>( v ) ); }

sc_unsigned operator* ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00648 { return operator*((uint64) u, v); }

sc_signed operator* ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00663 { return operator * ( SCAST<int64>( u ), v ); }

sc_signed operator/ ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

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

02076 {
02077 
02078   small_type s = mul_signs(u.sgn, v.sgn);
02079 
02080   if (s == SC_ZERO) {
02081     div_by_zero(v.sgn); // case 1
02082     return sc_signed();  // case 2
02083   }
02084 
02085   // other cases
02086   return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
02087                            v.nbits, v.ndigits, v.digit);
02088 
02089 }

sc_signed operator/ ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

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

02094 {
02095 
02096   small_type s = mul_signs(u.sgn, v.sgn);
02097 
02098   if (s == SC_ZERO) {
02099     div_by_zero(v.sgn); // case 1
02100     return sc_signed();  // case 2
02101   }
02102 
02103   // other cases
02104   return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
02105                            v.nbits, v.ndigits, v.digit);
02106 
02107 }

sc_unsigned operator/ ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

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

01051 {
01052 
01053   small_type s = mul_signs(u.sgn, v.sgn);
01054 
01055   if (s == SC_ZERO) {
01056     div_by_zero(v.sgn); // case 1
01057     return sc_unsigned();  // case 2
01058   }
01059 
01060   // other cases
01061   return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
01062                              v.nbits, v.ndigits, v.digit);
01063 
01064 }

sc_signed operator/ ( const sc_unsigned &  u,
int64  v 
) [friend]

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

02170 {
02171 
02172   small_type s = mul_signs(u.sgn, get_sign(v));
02173 
02174   if (s == SC_ZERO) {
02175     div_by_zero(v);  // case 1
02176     return sc_signed();  // case 2
02177   }
02178 
02179   CONVERT_INT64_2(v);
02180 
02181   // other cases
02182   return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
02183                            BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
02184   
02185 }

sc_unsigned operator/ ( const sc_unsigned &  u,
uint64  v 
) [friend]

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

01069 {
01070 
01071   small_type s = mul_signs(u.sgn, get_sign(v));
01072 
01073   if (s == SC_ZERO) {
01074     div_by_zero(v);  // case 1
01075     return sc_unsigned();  // case 2
01076   }
01077 
01078   CONVERT_INT64_2(v);
01079 
01080   // other cases
01081   return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
01082                              BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
01083   
01084 }

sc_signed operator/ ( const sc_unsigned &  u,
long  v 
) [friend]

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

02291 {
02292 
02293   small_type s = mul_signs(u.sgn, get_sign(v));
02294 
02295   if (s == SC_ZERO) {
02296     div_by_zero(v);  // case 1
02297     return sc_signed();  // case 2
02298   }
02299 
02300   CONVERT_LONG_2(v);
02301 
02302   // other cases
02303   return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
02304                            BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
02305   
02306 }

sc_unsigned operator/ ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

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

01110 {
01111 
01112   small_type s = mul_signs(u.sgn, get_sign(v));
01113 
01114   if (s == SC_ZERO) {
01115     div_by_zero(v);  // case 1
01116     return sc_unsigned();  // case 2
01117   }
01118 
01119   CONVERT_LONG_2(v);
01120 
01121   // other cases
01122   return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
01123                              BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
01124   
01125 }

sc_signed operator/ ( const sc_unsigned &  u,
int  v 
) [friend]

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

01564     { return operator/(u, (long) v); }

sc_unsigned operator/ ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

sc_signed operator/ ( int64  u,
const sc_unsigned &  v 
) [friend]

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

02190 {
02191 
02192   small_type s = mul_signs(v.sgn, get_sign(u));
02193 
02194   if (s == SC_ZERO) {
02195     div_by_zero(v.sgn);  // case 1
02196     return sc_signed();  // case 2
02197   }
02198 
02199   CONVERT_INT64_2(u);
02200 
02201   // other cases
02202   return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
02203                            v.nbits, v.ndigits, v.digit);
02204   
02205 }

sc_unsigned operator/ ( uint64  u,
const sc_unsigned &  v 
) [friend]

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

01089 {
01090 
01091   small_type s = mul_signs(v.sgn, get_sign(u));
01092 
01093   if (s == SC_ZERO) {
01094     div_by_zero(v.sgn);  // case 1
01095     return sc_unsigned();  // case 2
01096 
01097   }
01098 
01099   CONVERT_INT64_2(u);
01100 
01101   // other cases
01102   return div_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
01103                              v.nbits, v.ndigits, v.digit);
01104   
01105 }

sc_signed operator/ ( long  u,
const sc_unsigned &  v 
) [friend]

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

02311 {
02312 
02313   small_type s = mul_signs(v.sgn, get_sign(u));
02314 
02315   if (s == SC_ZERO) {
02316     div_by_zero(v.sgn);  // case 1
02317     return sc_signed();  // case 2
02318   }
02319 
02320   CONVERT_LONG_2(u);
02321 
02322   // other cases
02323   return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
02324                            v.nbits, v.ndigits, v.digit);
02325   
02326 }

sc_unsigned operator/ ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

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

01130 {
01131 
01132   small_type s = mul_signs(v.sgn, get_sign(u));
01133 
01134   if (s == SC_ZERO) {
01135     div_by_zero(v.sgn);  // case 1
01136     return sc_unsigned();  // case 2
01137 
01138   }
01139 
01140   CONVERT_LONG_2(u);
01141 
01142   // other cases
01143   return div_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
01144                              v.nbits, v.ndigits, v.digit);
01145   
01146 }

sc_signed operator/ ( int  u,
const sc_unsigned &  v 
) [friend]

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

01569     { return operator/((long) u, v); }

sc_unsigned operator/ ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

sc_unsigned operator/ ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00655 { return operator/(u, (uint64) v); }

sc_signed operator/ ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00680 { return operator / ( u, SCAST<int64>( v ) ); }

sc_unsigned operator/ ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00658 { return operator/((uint64) u, v); }

sc_signed operator/ ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00684 { return operator / ( SCAST<int64>( u ), v ); }

sc_signed operator% ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

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

02387 {
02388 
02389   if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
02390     div_by_zero(v.sgn);  // case 1
02391     return sc_signed();  // case 2
02392   }
02393 
02394   // other cases
02395   return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
02396                            v.nbits, v.ndigits, v.digit);
02397 }

sc_signed operator% ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

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

02402 {
02403 
02404   if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
02405     div_by_zero(v.sgn);  // case 1
02406     return sc_signed();  // case 2
02407   }
02408 
02409   // other cases
02410   return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
02411                            v.nbits, v.ndigits, v.digit);
02412 }

sc_unsigned operator% ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

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

01166 {
01167 
01168   if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
01169     div_by_zero(v.sgn);  // case 1
01170     return sc_unsigned();  // case 2
01171   }
01172 
01173   // other cases
01174   return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01175                              v.nbits, v.ndigits, v.digit);
01176 }

sc_signed operator% ( const sc_unsigned &  u,
int64  v 
) [friend]

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

02472 {
02473 
02474   small_type vs = get_sign(v);
02475 
02476   if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
02477     div_by_zero(v);  // case 1
02478     return sc_signed();  // case 2
02479   }
02480 
02481   CONVERT_INT64_2(v);
02482 
02483   // other cases
02484   return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
02485                            BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
02486 
02487 }

sc_unsigned operator% ( const sc_unsigned &  u,
uint64  v 
) [friend]

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

01181 {
01182 
01183   if ((u.sgn == SC_ZERO) || (v == 0)) {
01184     div_by_zero(v);  // case 1
01185     return sc_unsigned();  // case 2
01186   }
01187 
01188   CONVERT_INT64_2(v);
01189 
01190   // other cases
01191   return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01192                              BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
01193 
01194 }

sc_signed operator% ( const sc_unsigned &  u,
long  v 
) [friend]

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

02587 {
02588 
02589   small_type vs = get_sign(v);
02590 
02591   if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
02592     div_by_zero(v);  // case 1
02593     return sc_signed();  // case 2
02594   }
02595 
02596   CONVERT_LONG_2(v);
02597 
02598   // other cases
02599   return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
02600                            BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
02601 }

sc_unsigned operator% ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

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

01217 {
01218 
01219   if ((u.sgn == SC_ZERO) || (v == 0)) {
01220     div_by_zero(v);  // case 1
01221     return sc_unsigned();  // case 2
01222   }
01223 
01224   CONVERT_LONG_2(v);
01225 
01226   // other cases
01227   return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01228                              BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
01229 
01230 }

sc_signed operator% ( const sc_unsigned &  u,
int  v 
) [friend]

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

01618     { return operator%(u, (long) v); }

sc_unsigned operator% ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

sc_signed operator% ( int64  u,
const sc_unsigned &  v 
) [friend]

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

02492 {
02493 
02494   small_type us = get_sign(u);
02495 
02496   if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
02497     div_by_zero(v.sgn);  // case 1
02498     return sc_signed();  // case 2
02499   }
02500 
02501   CONVERT_INT64_2(u);
02502 
02503   // other cases
02504   return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
02505                            v.nbits, v.ndigits, v.digit);
02506 
02507 }

sc_unsigned operator% ( uint64  u,
const sc_unsigned &  v 
) [friend]

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

01199 {
01200 
01201   if ((u == 0) || (v.sgn == SC_ZERO)) {
01202     div_by_zero(v.sgn);  // case 1
01203     return sc_unsigned();  // case 2
01204   }
01205 
01206   CONVERT_INT64(u);
01207 
01208   // other cases
01209   return mod_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01210                              v.nbits, v.ndigits, v.digit);
01211 
01212 }

sc_signed operator% ( long  u,
const sc_unsigned &  v 
) [friend]

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

02606 {
02607 
02608   small_type us = get_sign(u);
02609 
02610   if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
02611     div_by_zero(v.sgn);  // case 1
02612     return sc_signed();  // case 2
02613   }
02614 
02615   CONVERT_LONG_2(u);
02616 
02617   // other cases
02618   return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
02619                            v.nbits, v.ndigits, v.digit);
02620 
02621 }

sc_unsigned operator% ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

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

01235 {
01236 
01237   if ((u == 0) || (v.sgn == SC_ZERO)) {
01238     div_by_zero(v.sgn);  // case 1
01239     return sc_unsigned();  // case 2
01240   }
01241 
01242   CONVERT_LONG(u);
01243 
01244   // other cases
01245   return mod_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01246                              v.nbits, v.ndigits, v.digit);
01247 
01248 }

sc_signed operator% ( int  u,
const sc_unsigned &  v 
) [friend]

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

01623     { return operator%((long) u, v); }

sc_unsigned operator% ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

sc_unsigned operator% ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00665 { return operator%(u, (uint64) v); }

sc_signed operator% ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00701 { return operator % ( u, SCAST<int64>( v ) ); }

sc_unsigned operator% ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00668 { return operator%((uint64) u, v); }

sc_signed operator% ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00705 { return operator % ( SCAST<int64>( u ), v ); }

sc_signed operator & ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

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

02676 {
02677 
02678   if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
02679     return sc_signed();
02680 
02681   // other cases
02682   return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
02683                            v.sgn, v.nbits, v.ndigits, v.digit);
02684 
02685 }

sc_signed operator & ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

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

02690 {
02691 
02692   if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
02693     return sc_signed();
02694 
02695   // other cases
02696   return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
02697                            v.sgn, v.nbits, v.ndigits, v.digit);
02698 
02699 }

sc_unsigned operator & ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

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

01267 {
01268 
01269   if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
01270     return sc_unsigned();
01271 
01272   // other cases
01273   return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01274                              v.sgn, v.nbits, v.ndigits, v.digit);
01275 
01276 }

sc_signed operator & ( const sc_unsigned &  u,
int64  v 
) [friend]

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

02750 {
02751 
02752   if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
02753     return sc_signed();
02754 
02755   CONVERT_INT64(v);
02756 
02757   // other cases
02758   return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
02759                            vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
02760 
02761 }

sc_unsigned operator & ( const sc_unsigned &  u,
uint64  v 
) [friend]

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

01281 {
01282 
01283   if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
01284     return sc_unsigned();
01285 
01286   CONVERT_INT64(v);
01287 
01288   // other cases
01289   return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01290                              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
01291   
01292 }

sc_signed operator & ( const sc_unsigned &  u,
long  v 
) [friend]

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

02846 {
02847 
02848   if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
02849     return sc_signed();
02850 
02851   CONVERT_LONG(v);
02852 
02853   // other cases
02854   return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
02855                            vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
02856 
02857 }

sc_unsigned operator & ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

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

01313 {
01314 
01315   if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
01316     return sc_unsigned();
01317 
01318   CONVERT_LONG(v);
01319 
01320   // other cases
01321   return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01322                              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
01323 
01324 }

sc_signed operator & ( const sc_unsigned &  u,
int  v 
) [friend]

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

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

sc_unsigned operator & ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

sc_signed operator & ( int64  u,
const sc_unsigned &  v 
) [friend]

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

02766 {
02767 
02768   if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
02769     return sc_signed();
02770 
02771   CONVERT_INT64(u);
02772 
02773   // other cases
02774   return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
02775                            v.sgn, v.nbits, v.ndigits, v.digit);
02776 
02777 }

sc_unsigned operator & ( uint64  u,
const sc_unsigned &  v 
) [friend]

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

01297 {
01298 
01299   if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
01300     return sc_unsigned();
01301 
01302   CONVERT_INT64(u);
01303 
01304   // other cases
01305   return and_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01306                              v.sgn, v.nbits, v.ndigits, v.digit);
01307 
01308 }

sc_signed operator & ( long  u,
const sc_unsigned &  v 
) [friend]

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

02862 {
02863 
02864   if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
02865     return sc_signed();
02866 
02867   CONVERT_LONG(u);
02868 
02869   // other cases
02870   return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
02871                            v.sgn, v.nbits, v.ndigits, v.digit);
02872 
02873 }

sc_unsigned operator & ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

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

01329 {
01330 
01331   if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
01332     return sc_unsigned();
01333 
01334   CONVERT_LONG(u);
01335 
01336   // other cases
01337   return and_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01338                              v.sgn, v.nbits, v.ndigits, v.digit);
01339 
01340 }

sc_signed operator & ( int  u,
const sc_unsigned &  v 
) [friend]

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

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

sc_unsigned operator & ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

sc_unsigned operator & ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

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

sc_signed operator & ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00722 { return operator & ( u, SCAST<int64>( v ) ); }

sc_unsigned operator & ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

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

sc_signed operator & ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00726 { return operator & ( SCAST<int64>( u ), v ); }

sc_signed operator| ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

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

02925 {
02926 
02927   if (v.sgn == SC_ZERO)  // case 1
02928     return sc_signed(u);
02929 
02930   if (u.sgn == SC_ZERO)  // case 2
02931     return sc_signed(v);
02932 
02933   // other cases
02934   return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
02935                           v.sgn, v.nbits, v.ndigits, v.digit);
02936 
02937 }

sc_signed operator| ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

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

02942 {
02943 
02944   if (v.sgn == SC_ZERO)  // case 1
02945     return sc_signed(u);
02946 
02947   if (u.sgn == SC_ZERO)  // case 2
02948     return sc_signed(v);
02949 
02950   // other cases
02951   return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
02952                           v.sgn, v.nbits, v.ndigits, v.digit);
02953 
02954 }

sc_unsigned operator| ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

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

01360 {
01361 
01362   if (v.sgn == SC_ZERO)  // case 1
01363     return sc_unsigned(u);
01364 
01365   if (u.sgn == SC_ZERO)  // case 2
01366     return sc_unsigned(v);
01367 
01368   // other cases
01369   return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01370                             v.sgn, v.nbits, v.ndigits, v.digit);
01371 
01372 }

sc_signed operator| ( const sc_unsigned &  u,
int64  v 
) [friend]

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

03014 {
03015 
03016   if (v == 0)  // case 1
03017     return sc_signed(u);
03018 
03019   CONVERT_INT64(v);
03020 
03021   if (u.sgn == SC_ZERO)  // case 2
03022     return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
03023 
03024   // other cases
03025   return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
03026                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
03027 
03028 }

sc_unsigned operator| ( const sc_unsigned &  u,
uint64  v 
) [friend]

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

01377 {
01378 
01379   if (v == 0)  // case 1
01380     return sc_unsigned(u);
01381 
01382   CONVERT_INT64(v);
01383 
01384   if (u.sgn == SC_ZERO)  // case 2
01385     return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
01386 
01387   // other cases
01388   return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01389                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
01390 
01391 }

sc_signed operator| ( const sc_unsigned &  u,
long  v 
) [friend]

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

03128 {
03129 
03130   if (v == 0)  // case 1
03131     return sc_signed(u);
03132 
03133   CONVERT_LONG(v);
03134 
03135   if (u.sgn == SC_ZERO)  // case 2
03136     return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
03137 
03138   // other cases
03139   return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
03140                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
03141 
03142 }

sc_unsigned operator| ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

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

01415 {
01416 
01417   if (v == 0)  // case 1
01418     return sc_unsigned(u);
01419 
01420   CONVERT_LONG(v);
01421 
01422   if (u.sgn == SC_ZERO)  // case 2
01423     return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
01424 
01425   // other cases
01426   return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01427                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
01428 
01429 }

sc_signed operator| ( const sc_unsigned &  u,
int  v 
) [friend]

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

01728     { return operator|(u, (long) v); }

sc_unsigned operator| ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

sc_signed operator| ( int64  u,
const sc_unsigned &  v 
) [friend]

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

03033 {
03034 
03035   if (u == 0)
03036     return sc_signed(v);
03037 
03038   CONVERT_INT64(u);
03039 
03040   if (v.sgn == SC_ZERO)
03041     return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
03042 
03043   // other cases
03044   return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
03045                           v.sgn, v.nbits, v.ndigits, v.digit);
03046 
03047 }

sc_unsigned operator| ( uint64  u,
const sc_unsigned &  v 
) [friend]

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

01396 {
01397 
01398   if (u == 0)
01399     return sc_unsigned(v);
01400 
01401   CONVERT_INT64(u);
01402 
01403   if (v.sgn == SC_ZERO)
01404     return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
01405 
01406   // other cases
01407   return or_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01408                             v.sgn, v.nbits, v.ndigits, v.digit);
01409 
01410 }

sc_signed operator| ( long  u,
const sc_unsigned &  v 
) [friend]

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

03147 {
03148 
03149   if (u == 0)
03150     return sc_signed(v);
03151 
03152   CONVERT_LONG(u);
03153 
03154   if (v.sgn == SC_ZERO)
03155     return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
03156 
03157   // other cases
03158   return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
03159                           v.sgn, v.nbits, v.ndigits, v.digit);
03160 
03161 }

sc_unsigned operator| ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

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

01434 {
01435 
01436   if (u == 0)
01437     return sc_unsigned(v);
01438 
01439   CONVERT_LONG(u);
01440 
01441   if (v.sgn == SC_ZERO)
01442     return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
01443 
01444   // other cases
01445   return or_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01446                             v.sgn, v.nbits, v.ndigits, v.digit);
01447 
01448 }

sc_signed operator| ( int  u,
const sc_unsigned &  v 
) [friend]

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

01733     { return operator|((long) u, v); }

sc_unsigned operator| ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

sc_unsigned operator| ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00685 { return operator|(u, (uint64) v); }

sc_signed operator| ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00743 { return operator | ( u, SCAST<int64>( v ) ); }

sc_unsigned operator| ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00688 { return operator|((uint64) u, v); }

sc_signed operator| ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00747 { return operator | ( SCAST<int64>( u ), v ); }

sc_signed operator^ ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

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

03220 {
03221 
03222   if (v.sgn == SC_ZERO)  // case 1
03223     return sc_signed(u);
03224 
03225   if (u.sgn == SC_ZERO)  // case 2
03226     return sc_signed(v);
03227 
03228   // other cases
03229   return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
03230                            v.sgn, v.nbits, v.ndigits, v.digit);
03231 
03232 }

sc_signed operator^ ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

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

03237 {
03238 
03239   if (v.sgn == SC_ZERO)  // case 1
03240     return sc_signed(u);
03241 
03242   if (u.sgn == SC_ZERO)  // case 2
03243     return sc_signed(v);
03244 
03245   // other cases
03246   return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
03247                            v.sgn, v.nbits, v.ndigits, v.digit);
03248 
03249 }

sc_unsigned operator^ ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

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

01469 {
01470 
01471   if (v.sgn == SC_ZERO)  // case 1
01472     return sc_unsigned(u);
01473 
01474   if (u.sgn == SC_ZERO)  // case 2
01475     return sc_unsigned(v);
01476 
01477   // other cases
01478   return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01479                              v.sgn, v.nbits, v.ndigits, v.digit);
01480 
01481 }

sc_signed operator^ ( const sc_unsigned &  u,
int64  v 
) [friend]

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

03309 {
03310 
03311   if (v == 0)  // case 1
03312     return sc_signed(u);
03313 
03314   CONVERT_INT64(v);
03315 
03316   if (u.sgn == SC_ZERO)  // case 2
03317     return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
03318 
03319   // other cases
03320   return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
03321                            vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
03322 
03323 }

sc_unsigned operator^ ( const sc_unsigned &  u,
uint64  v 
) [friend]

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

01486 {
01487 
01488   if (v == 0)  // case 1
01489     return sc_unsigned(u);
01490 
01491   CONVERT_INT64(v);
01492 
01493   if (u.sgn == SC_ZERO)  // case 2
01494     return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
01495 
01496   // other cases
01497   return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01498                              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
01499 
01500 }

sc_signed operator^ ( const sc_unsigned &  u,
long  v 
) [friend]

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

03421 {
03422 
03423   if (v == 0)  // case 1
03424     return sc_signed(u);
03425 
03426   CONVERT_LONG(v);
03427 
03428   if (u.sgn == SC_ZERO)  // case 2
03429     return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
03430 
03431   // other cases
03432   return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
03433                            vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
03434 
03435 }

sc_unsigned operator^ ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

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

01522 {
01523 
01524   if (v == 0)  // case 1
01525     return sc_unsigned(u);
01526 
01527   CONVERT_LONG(v);
01528 
01529   if (u.sgn == SC_ZERO)  // case 2
01530     return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
01531 
01532   // other cases
01533   return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
01534                              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
01535 
01536 }

sc_signed operator^ ( const sc_unsigned &  u,
int  v 
) [friend]

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

01782     { return operator^(u, (long) v); }

sc_unsigned operator^ ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

sc_signed operator^ ( int64  u,
const sc_unsigned &  v 
) [friend]

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

03328 {
03329 
03330   if (u == 0)
03331     return sc_signed(v);
03332 
03333   CONVERT_INT64(u);
03334 
03335   if (v.sgn == SC_ZERO)
03336     return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
03337 
03338   // other cases
03339   return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
03340                            v.sgn, v.nbits, v.ndigits, v.digit);
03341 
03342 }

sc_unsigned operator^ ( uint64  u,
const sc_unsigned &  v 
) [friend]

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

01504 {
01505   if (u == 0)
01506     return sc_unsigned(v);
01507 
01508   CONVERT_INT64(u);
01509 
01510   if (v.sgn == SC_ZERO)
01511     return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
01512 
01513   // other cases
01514   return xor_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01515                              v.sgn, v.nbits, v.ndigits, v.digit);
01516 
01517 }

sc_signed operator^ ( long  u,
const sc_unsigned &  v 
) [friend]

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

03440 {
03441 
03442   if (u == 0)
03443     return sc_signed(v);
03444 
03445   CONVERT_LONG(u);
03446 
03447   if (v.sgn == SC_ZERO)
03448     return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
03449 
03450   // other cases
03451   return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
03452                            v.sgn, v.nbits, v.ndigits, v.digit);
03453 
03454 }

sc_unsigned operator^ ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

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

01540 {
01541   if (u == 0)
01542     return sc_unsigned(v);
01543 
01544   CONVERT_LONG(u);
01545 
01546   if (v.sgn == SC_ZERO)
01547     return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
01548 
01549   // other cases
01550   return xor_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01551                              v.sgn, v.nbits, v.ndigits, v.digit);
01552 
01553 }

sc_signed operator^ ( int  u,
const sc_unsigned &  v 
) [friend]

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

01787     { return operator^((long) u, v); }

sc_unsigned operator^ ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

sc_unsigned operator^ ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00695 { return operator^(u, (uint64) v); }

sc_signed operator^ ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00764 { return operator ^ ( u, SCAST<int64>( v ) ); }

sc_unsigned operator^ ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00698 { return operator^((uint64) u, v); }

sc_signed operator^ ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00768 { return operator ^ ( SCAST<int64>( u ), v ); }

sc_unsigned operator<< ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

sc_signed operator<< ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

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

03509 {
03510   if (v.sgn == SC_ZERO)
03511     return sc_signed(u);
03512 
03513   return operator<<(u, v.to_ulong());
03514 }

sc_unsigned operator<< ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

sc_unsigned operator<< ( const sc_unsigned &  u,
int64  v 
) [friend]

sc_unsigned operator<< ( const sc_unsigned &  u,
uint64  v 
) [friend]

sc_unsigned operator<< ( const sc_unsigned &  u,
long  v 
) [friend]

sc_unsigned operator<< ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

sc_unsigned operator<< ( const sc_unsigned &  u,
int  v 
) [friend]

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

01614     { return operator<<(u, (long) v); }

sc_unsigned operator<< ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

sc_unsigned operator<< ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00705 { return operator<<(u, (uint64) v); }

sc_unsigned operator<< ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00566 { return operator<<(u, (int64) v); }

sc_unsigned operator>> ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

sc_signed operator>> ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

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

03526 {
03527 
03528   if (v.sgn == SC_ZERO)
03529     return sc_signed(u);
03530 
03531   return operator>>(u, v.to_ulong());
03532 
03533 }

sc_unsigned operator>> ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

sc_unsigned operator>> ( const sc_unsigned &  u,
int64  v 
) [friend]

sc_unsigned operator>> ( const sc_unsigned &  u,
uint64  v 
) [friend]

sc_unsigned operator>> ( const sc_unsigned &  u,
long  v 
) [friend]

sc_unsigned operator>> ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

sc_unsigned operator>> ( const sc_unsigned &  u,
int  v 
) [friend]

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

01645     { return operator>>(u, (long) v); }

sc_unsigned operator>> ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

sc_unsigned operator>> ( const sc_unsigned &  ,
const sc_uint_base &   
) [friend]

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

00712 { return operator>>(u, (uint64) v); }

sc_unsigned operator>> ( const sc_unsigned &  ,
const sc_int_base &   
) [friend]

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

00573 { return operator>>(u, (int64) v); }

sc_unsigned operator+ ( const sc_unsigned &  u  )  [friend]

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

01608 {
01609   return sc_unsigned(u);
01610 }

sc_signed operator- ( const sc_unsigned &  u  )  [friend]

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

03557 {
03558   return sc_signed(u, -u.sgn);
03559 }

bool operator== ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

bool operator== ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

bool operator== ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

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

01619 {
01620   if (&u == &v)
01621     return true;
01622   if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
01623                        v.sgn, v.nbits, v.ndigits, v.digit) != 0)
01624     return false;
01625   return true;
01626 }

bool operator== ( const sc_unsigned &  u,
int64  v 
) [friend]

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

01655 {
01656   if (v < 0)
01657     return false;
01658   CONVERT_INT64(v);
01659   if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
01660                        vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0)
01661     return false;
01662   return true;
01663 }

bool operator== ( const sc_unsigned &  u,
uint64  v 
) [friend]

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

01681 {
01682   CONVERT_INT64(v);
01683   if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
01684                        vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0)
01685     return false;
01686   return true;
01687 }

bool operator== ( const sc_unsigned &  u,
long  v 
) [friend]

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

01703 {
01704   if (v < 0)
01705     return false;
01706   CONVERT_LONG(v);
01707   if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
01708                        vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
01709     return false;
01710   return true;
01711 }

bool operator== ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

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

01729 {
01730   CONVERT_LONG(v);
01731   if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
01732                        vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
01733     return false;
01734   return true;
01735 }

bool operator== ( const sc_unsigned &  u,
int  v 
) [friend]

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

01682     { return operator==(u, (long) v); }

bool operator== ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

bool operator== ( int64  u,
const sc_unsigned &  v 
) [friend]

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

01668 {
01669   if (u < 0)
01670     return false;
01671   CONVERT_INT64(u);
01672   if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01673                        v.sgn, v.nbits, v.ndigits, v.digit) != 0)
01674     return false;
01675   return true;
01676 }

bool operator== ( uint64  u,
const sc_unsigned &  v 
) [friend]

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

01692 {
01693   CONVERT_INT64(u);
01694   if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01695                        v.sgn, v.nbits, v.ndigits, v.digit) != 0)
01696     return false;
01697   return true;
01698 }

bool operator== ( long  u,
const sc_unsigned &  v 
) [friend]

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

01716 {
01717   if (u < 0)
01718     return false;
01719   CONVERT_LONG(u);
01720   if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01721                        v.sgn, v.nbits, v.ndigits, v.digit) != 0)
01722     return false;
01723   return true;
01724 }

bool operator== ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

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

01740 {
01741   CONVERT_LONG(u);
01742   if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01743                        v.sgn, v.nbits, v.ndigits, v.digit) != 0)
01744     return false;
01745   return true;
01746 }

bool operator== ( int  u,
const sc_unsigned &  v 
) [friend]

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

01691     { return operator==((long) u,  v); }

bool operator== ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

bool operator== ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00719 { return operator==(u, (uint64) v); }

bool operator== ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00580 { return operator==(u, (int64) v); }

bool operator== ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00722 { return operator==((uint64) u, v); }

bool operator== ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00583 { return operator==((int64) u, v); }

bool operator!= ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

bool operator!= ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

bool operator!= ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

bool operator!= ( const sc_unsigned &  u,
int64  v 
) [friend]

bool operator!= ( const sc_unsigned &  u,
uint64  v 
) [friend]

bool operator!= ( const sc_unsigned &  u,
long  v 
) [friend]

bool operator!= ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

bool operator!= ( const sc_unsigned &  u,
int  v 
) [friend]

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

01711     { return operator!=(u, (long) v); }

bool operator!= ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

01713     { return operator!=(u, (unsigned long) v); }

bool operator!= ( int64  u,
const sc_unsigned &  v 
) [friend]

bool operator!= ( uint64  u,
const sc_unsigned &  v 
) [friend]

bool operator!= ( long  u,
const sc_unsigned &  v 
) [friend]

bool operator!= ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

bool operator!= ( int  u,
const sc_unsigned &  v 
) [friend]

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

01720     { return operator!=((long) u,  v); }

bool operator!= ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

01722     { return operator!=((unsigned long) u,  v); }

bool operator!= ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00726 { return operator!=(u, (uint64) v); }

bool operator!= ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00587 { return operator!=(u, (int64) v); }

bool operator!= ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00729 { return operator!=((uint64) u, v); }

bool operator!= ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00590 { return operator!=((int64) u, v); }

bool operator< ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

bool operator< ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

bool operator< ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

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

01775 {
01776   if (&u == &v)
01777     return false;
01778   if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
01779                        v.sgn, v.nbits, v.ndigits, v.digit) < 0)
01780     return true;
01781   return false;
01782 }

bool operator< ( const sc_unsigned &  u,
int64  v 
) [friend]

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

01811 {
01812   if (v < 0)
01813     return false;
01814   CONVERT_INT64(v);
01815   if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
01816                        vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0)
01817     return true;
01818   return false;
01819 }

bool operator< ( const sc_unsigned &  u,
uint64  v 
) [friend]

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

01837 {
01838   CONVERT_INT64(v);
01839   if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
01840                        vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0)
01841     return true;
01842   return false;
01843 }

bool operator< ( const sc_unsigned &  u,
long  v 
) [friend]

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

01859 {
01860   if (v < 0)
01861     return false;
01862   CONVERT_LONG(v);
01863   if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
01864                        vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0)
01865     return true;
01866   return false;
01867 }

bool operator< ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

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

01885 {
01886   CONVERT_LONG(v);
01887   if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
01888                        vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0)
01889     return true;
01890   return false;
01891 }

bool operator< ( const sc_unsigned &  u,
int  v 
) [friend]

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

01740     { return operator<(u, (long) v); }

bool operator< ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

bool operator< ( int64  u,
const sc_unsigned &  v 
) [friend]

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

01824 {
01825   if (u < 0)
01826     return true;
01827   CONVERT_INT64(u);
01828   if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01829                        v.sgn, v.nbits, v.ndigits, v.digit) < 0)
01830     return true;
01831   return false;
01832 }

bool operator< ( uint64  u,
const sc_unsigned &  v 
) [friend]

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

01848 {
01849   CONVERT_INT64(u);
01850   if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
01851                        v.sgn, v.nbits, v.ndigits, v.digit) < 0)
01852     return true;
01853   return false;    
01854 }

bool operator< ( long  u,
const sc_unsigned &  v 
) [friend]

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

01872 {
01873   if (u < 0)
01874     return true;
01875   CONVERT_LONG(u);
01876   if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01877                        v.sgn, v.nbits, v.ndigits, v.digit) < 0)
01878     return true;
01879   return false;
01880 }

bool operator< ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

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

01896 {
01897   CONVERT_LONG(u);
01898   if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
01899                        v.sgn, v.nbits, v.ndigits, v.digit) < 0)
01900     return true;
01901   return false;    
01902 }

bool operator< ( int  u,
const sc_unsigned &  v 
) [friend]

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

01749     { return operator<((long) u,  v); }

bool operator< ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

bool operator< ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00733 { return operator<(u, (uint64) v); }

bool operator< ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00594 { return operator<(u, (int64) v); }

bool operator< ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00736 { return operator<((uint64) u, v); }

bool operator< ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00597 { return operator<((int64) u, v); }

bool operator<= ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

bool operator<= ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

bool operator<= ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

bool operator<= ( const sc_unsigned &  u,
int64  v 
) [friend]

bool operator<= ( const sc_unsigned &  u,
uint64  v 
) [friend]

bool operator<= ( const sc_unsigned &  u,
long  v 
) [friend]

bool operator<= ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

bool operator<= ( const sc_unsigned &  u,
int  v 
) [friend]

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

01769     { return operator<=(u, (long) v); }

bool operator<= ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

01771     { return operator<=(u, (unsigned long) v); }

bool operator<= ( int64  u,
const sc_unsigned &  v 
) [friend]

bool operator<= ( uint64  u,
const sc_unsigned &  v 
) [friend]

bool operator<= ( long  u,
const sc_unsigned &  v 
) [friend]

bool operator<= ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

bool operator<= ( int  u,
const sc_unsigned &  v 
) [friend]

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

01778     { return operator<=((long) u,  v); }

bool operator<= ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

01780     { return operator<=((unsigned long) u,  v); }

bool operator<= ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00740 { return operator<=(u, (uint64) v); }

bool operator<= ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00601 { return operator<=(u, (int64) v); }

bool operator<= ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00743 { return operator<=((uint64) u, v); }

bool operator<= ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00604 { return operator<=((int64) u, v); }

bool operator> ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

bool operator> ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

bool operator> ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

bool operator> ( const sc_unsigned &  u,
int64  v 
) [friend]

bool operator> ( const sc_unsigned &  u,
uint64  v 
) [friend]

bool operator> ( const sc_unsigned &  u,
long  v 
) [friend]

bool operator> ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

bool operator> ( const sc_unsigned &  u,
int  v 
) [friend]

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

01798     { return operator>(u, (long) v); }

bool operator> ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

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

bool operator> ( int64  u,
const sc_unsigned &  v 
) [friend]

bool operator> ( uint64  u,
const sc_unsigned &  v 
) [friend]

bool operator> ( long  u,
const sc_unsigned &  v 
) [friend]

bool operator> ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

bool operator> ( int  u,
const sc_unsigned &  v 
) [friend]

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

01807     { return operator>((long) u,  v); }

bool operator> ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

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

bool operator> ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00747 { return operator>(u, (uint64) v); }

bool operator> ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00608 { return operator>(u, (int64) v); }

bool operator> ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00750 { return operator>((uint64) u, v); }

bool operator> ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00611 { return operator>((int64) u, v); }

bool operator>= ( const sc_unsigned &  u,
const sc_signed &  v 
) [friend]

bool operator>= ( const sc_signed &  u,
const sc_unsigned &  v 
) [friend]

bool operator>= ( const sc_unsigned &  u,
const sc_unsigned &  v 
) [friend]

bool operator>= ( const sc_unsigned &  u,
int64  v 
) [friend]

bool operator>= ( const sc_unsigned &  u,
uint64  v 
) [friend]

bool operator>= ( const sc_unsigned &  u,
long  v 
) [friend]

bool operator>= ( const sc_unsigned &  u,
unsigned long  v 
) [friend]

bool operator>= ( const sc_unsigned &  u,
int  v 
) [friend]

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

01827     { return operator>=(u, (long) v); }

bool operator>= ( const sc_unsigned &  u,
unsigned int  v 
) [friend]

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

01829     { return operator>=(u, (unsigned long) v); }

bool operator>= ( int64  u,
const sc_unsigned &  v 
) [friend]

bool operator>= ( uint64  u,
const sc_unsigned &  v 
) [friend]

bool operator>= ( long  u,
const sc_unsigned &  v 
) [friend]

bool operator>= ( unsigned long  u,
const sc_unsigned &  v 
) [friend]

bool operator>= ( int  u,
const sc_unsigned &  v 
) [friend]

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

01836     { return operator>=((long) u,  v); }

bool operator>= ( unsigned int  u,
const sc_unsigned &  v 
) [friend]

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

01838     { return operator>=((unsigned long) u,  v); }

bool operator>= ( const sc_unsigned &  u,
const sc_uint_base &  v 
) [friend]

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

00754 { return operator>=(u, (uint64) v); }

bool operator>= ( const sc_unsigned &  u,
const sc_int_base &  v 
) [friend]

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

00615 { return operator>=(u, (int64) v); }

bool operator>= ( const sc_uint_base &  u,
const sc_unsigned &  v 
) [friend]

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

00757 { return operator>=((uint64) u, v); }

bool operator>= ( const sc_int_base &  u,
const sc_unsigned &  v 
) [friend]

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

00618 { return operator>=((int64) u, v); }

sc_unsigned operator~ ( const sc_unsigned &  u  )  [friend]

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 = 0,
small_type  if_v_signed = 0 
) [friend]

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

01981 {
01982 
01983   if (us == vs) {
01984 
01985     if (us == SC_ZERO)
01986       return 0;
01987 
01988     else {
01989 
01990       int cmp_res = vec_skip_and_cmp(und, ud, vnd, vd);
01991 
01992       if (us == SC_POS)
01993         return cmp_res;
01994       else
01995         return -cmp_res;
01996 
01997     }
01998   }
01999   else {
02000 
02001     if (us == SC_ZERO)
02002       return -vs;
02003 
02004     if (vs == SC_ZERO)
02005       return us;
02006 
02007     int cmp_res;
02008 
02009     int nd = (us == SC_NEG ? und : vnd);
02010 
02011 #ifdef SC_MAX_NBITS
02012     sc_digit d[MAX_NDIGITS];
02013 #else
02014     sc_digit *d = new sc_digit[nd];
02015 #endif
02016 
02017     if (us == SC_NEG) {
02018 
02019       vec_copy(nd, d, ud);
02020       vec_complement(nd, d);
02021       trim(if_u_signed, unb, nd, d);
02022       cmp_res = vec_skip_and_cmp(nd, d, vnd, vd);
02023 
02024     }
02025     else {
02026 
02027       vec_copy(nd, d, vd);
02028       vec_complement(nd, d);
02029       trim(if_v_signed, vnb, nd, d);
02030       cmp_res = vec_skip_and_cmp(und, ud, nd, d);
02031 
02032     }
02033 
02034 #ifndef SC_MAX_NBITS
02035     delete [] d;
02036 #endif
02037 
02038     return cmp_res;
02039 
02040   }
02041 }

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 
) [friend]

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 
) [friend]

sc_unsigned mul_unsigned_friend ( small_type  s,
int  unb,
int  und,
const sc_digit *  ud,
int  vnb,
int  vnd,
const sc_digit *  vd 
) [friend]

sc_unsigned div_unsigned_friend ( small_type  s,
int  unb,
int  und,
const sc_digit *  ud,
int  vnb,
int  vnd,
const sc_digit *  vd 
) [friend]

sc_unsigned mod_unsigned_friend ( small_type  us,
int  unb,
int  und,
const sc_digit *  ud,
int  vnb,
int  vnd,
const sc_digit *  vd 
) [friend]

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 
) [friend]

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 
) [friend]

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 
) [friend]

変数

sc_core::sc_vpool< sc_unsigned > sc_dt::sc_unsigned::m_pool [static]

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

small_type sc_dt::sc_unsigned::sgn [private]

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

int sc_dt::sc_unsigned::nbits [private]

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

int sc_dt::sc_unsigned::ndigits [private]

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

sc_digit* sc_dt::sc_unsigned::digit [private]

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

このクラスの説明は次のファイルから生成されました:
SystemCに対してFri Jun 6 20:13:07 2008に生成されました。  doxygen 1.5.6