double_conversion::UInt128 Class Reference

Public Member Functions
	UInt128 ()
	UInt128 (uint64_t high, uint64_t low)
void	Multiply (uint32_t multiplicand)
void	Shift (int shift_amount)
int	DivModPowerOf2 (int power)
bool	IsZero () const
int	BitAt (int position) const

Detailed Description

Definition at line 37 of file fixed-dtoa.cc.

Constructor & Destructor Documentation

UInt128() [1/2]

double_conversion::UInt128::UInt128 ( )

inline

Definition at line 39 of file fixed-dtoa.cc.

: high_bits_(0), low_bits_(0) { }

UInt128() [2/2]

double_conversion::UInt128::UInt128 ( uint64_t  high, uint64_t  low  )

inline

Definition at line 40 of file fixed-dtoa.cc.

: high_bits_(high), low_bits_(low) { }

Member Function Documentation

BitAt()

int double_conversion::UInt128::BitAt ( int  position ) const

inline

Definition at line 101 of file fixed-dtoa.cc.

                                {
    if (position >= 64) {
      return static_cast<int>(high_bits_ >> (position - 64)) & 1;
    } else {
      return static_cast<int>(low_bits_ >> position) & 1;
    }
  }

DivModPowerOf2()

int double_conversion::UInt128::DivModPowerOf2 ( int  power )

inline

Definition at line 82 of file fixed-dtoa.cc.

                                {
    if (power >= 64) {
      int result = static_cast<int>(high_bits_ >> (power - 64));
      high_bits_ -= static_cast<uint64_t>(result) << (power - 64);
      return result;
    } else {
      uint64_t part_low = low_bits_ >> power;
      uint64_t part_high = high_bits_ << (64 - power);
      int result = static_cast<int>(part_low + part_high);
      high_bits_ = 0;
      low_bits_ -= part_low << power;
      return result;
    }
  }

IsZero()

bool double_conversion::UInt128::IsZero ( ) const

inline

Definition at line 97 of file fixed-dtoa.cc.

                      {
    return high_bits_ == 0 && low_bits_ == 0;
  }

Multiply()

void double_conversion::UInt128::Multiply ( uint32_t  multiplicand )

inline

Definition at line 42 of file fixed-dtoa.cc.

                                       {
    uint64_t accumulator;
 
    accumulator = (low_bits_ & kMask32) * multiplicand;
    uint32_t part = static_cast<uint32_t>(accumulator & kMask32);
    accumulator >>= 32;
    accumulator = accumulator + (low_bits_ >> 32) * multiplicand;
    low_bits_ = (accumulator << 32) + part;
    accumulator >>= 32;
    accumulator = accumulator + (high_bits_ & kMask32) * multiplicand;
    part = static_cast<uint32_t>(accumulator & kMask32);
    accumulator >>= 32;
    accumulator = accumulator + (high_bits_ >> 32) * multiplicand;
    high_bits_ = (accumulator << 32) + part;
    DOUBLE_CONVERSION_ASSERT((accumulator >> 32) == 0);
  }

Shift()

void double_conversion::UInt128::Shift ( int  shift_amount )

inline

Definition at line 59 of file fixed-dtoa.cc.

                               {
    DOUBLE_CONVERSION_ASSERT(-64 <= shift_amount && shift_amount <= 64);
    if (shift_amount == 0) {
      return;
    } else if (shift_amount == -64) {
      high_bits_ = low_bits_;
      low_bits_ = 0;
    } else if (shift_amount == 64) {
      low_bits_ = high_bits_;
      high_bits_ = 0;
    } else if (shift_amount <= 0) {
      high_bits_ <<= -shift_amount;
      high_bits_ += low_bits_ >> (64 + shift_amount);
      low_bits_ <<= -shift_amount;
    } else {
      low_bits_ >>= shift_amount;
      low_bits_ += high_bits_ << (64 - shift_amount);
      high_bits_ >>= shift_amount;
    }
  }

---

The documentation for this class was generated from the following file:

• third_party/dart-lang/sdk/third_party/double-conversion/src/fixed-dtoa.cc