double_conversion::DiyFp Class Reference

#include <diy-fp.h>

Public Member Functions
	DiyFp ()
	DiyFp (const uint64_t significand, const int32_t exponent)
void	Subtract (const DiyFp &other)
void	Multiply (const DiyFp &other)
void	Normalize ()
uint64_t	f () const
int32_t	e () const
void	set_f (uint64_t new_value)
void	set_e (int32_t new_value)

Static Public Member Functions
static DiyFp	Minus (const DiyFp &a, const DiyFp &b)
static DiyFp	Times (const DiyFp &a, const DiyFp &b)
static DiyFp	Normalize (const DiyFp &a)

Static Public Attributes
static const int	kSignificandSize = 64

Detailed Description

Definition at line 41 of file diy-fp.h.

Constructor & Destructor Documentation

DiyFp() [1/2]

double_conversion::DiyFp::DiyFp ( )

inline

Definition at line 45 of file diy-fp.h.

: f_(0), e_(0) {}

DiyFp() [2/2]

double_conversion::DiyFp::DiyFp ( const uint64_t  significand, const int32_t  exponent  )

inline

Definition at line 46 of file diy-fp.h.

: f_(significand), e_(exponent) {}

Member Function Documentation

e()

int32_t double_conversion::DiyFp::e ( ) const

inline

Definition at line 123 of file diy-fp.h.

{ return e_; }

f()

uint64_t double_conversion::DiyFp::f ( ) const

inline

Definition at line 122 of file diy-fp.h.

{ return f_; }

Minus()

static DiyFp double_conversion::DiyFp::Minus ( const DiyFp &  a, const DiyFp &  b  )

inlinestatic

Definition at line 61 of file diy-fp.h.

                                                     {
    DiyFp result = a;
    result.Subtract(b);
    return result;
  }

Multiply()

void double_conversion::DiyFp::Multiply ( const DiyFp &  other )

inline

Definition at line 68 of file diy-fp.h.

                                    {
    // Simply "emulates" a 128 bit multiplication.
    // However: the resulting number only contains 64 bits. The least
    // significant 64 bits are only used for rounding the most significant 64
    // bits.
    const uint64_t kM32 = 0xFFFFFFFFU;
    const uint64_t a = f_ >> 32;
    const uint64_t b = f_ & kM32;
    const uint64_t c = other.f_ >> 32;
    const uint64_t d = other.f_ & kM32;
    const uint64_t ac = a * c;
    const uint64_t bc = b * c;
    const uint64_t ad = a * d;
    const uint64_t bd = b * d;
    // By adding 1U << 31 to tmp we round the final result.
    // Halfway cases will be rounded up.
    const uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32) + (1U << 31);
    e_ += other.e_ + 64;
    f_ = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
  }

Normalize() [1/2]

void double_conversion::DiyFp::Normalize ( )

inline

Definition at line 96 of file diy-fp.h.

                   {
    DOUBLE_CONVERSION_ASSERT(f_ != 0);
    uint64_t significand = f_;
    int32_t exponent = e_;
 
    // This method is mainly called for normalizing boundaries. In general,
    // boundaries need to be shifted by 10 bits, and we optimize for this case.
    const uint64_t k10MSBits = DOUBLE_CONVERSION_UINT64_2PART_C(0xFFC00000, 00000000);
    while ((significand & k10MSBits) == 0) {
      significand <<= 10;
      exponent -= 10;
    }
    while ((significand & kUint64MSB) == 0) {
      significand <<= 1;
      exponent--;
    }
    f_ = significand;
    e_ = exponent;
  }

Normalize() [2/2]

static DiyFp double_conversion::DiyFp::Normalize ( const DiyFp &  a )

inlinestatic

Definition at line 116 of file diy-fp.h.

                                         {
    DiyFp result = a;
    result.Normalize();
    return result;
  }

set_e()

void double_conversion::DiyFp::set_e ( int32_t  new_value )

inline

Definition at line 126 of file diy-fp.h.

{ e_ = new_value; }

set_f()

void double_conversion::DiyFp::set_f ( uint64_t  new_value )

inline

Definition at line 125 of file diy-fp.h.

{ f_ = new_value; }

Subtract()

void double_conversion::DiyFp::Subtract ( const DiyFp &  other )

inline

Definition at line 52 of file diy-fp.h.

                                    {
    DOUBLE_CONVERSION_ASSERT(e_ == other.e_);
    DOUBLE_CONVERSION_ASSERT(f_ >= other.f_);
    f_ -= other.f_;
  }

Times()

static DiyFp double_conversion::DiyFp::Times ( const DiyFp &  a, const DiyFp &  b  )

inlinestatic

Definition at line 90 of file diy-fp.h.

                                                     {
    DiyFp result = a;
    result.Multiply(b);
    return result;
  }

Member Data Documentation

kSignificandSize

const int double_conversion::DiyFp::kSignificandSize = 64

static

Definition at line 43 of file diy-fp.h.

---

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

• third_party/dart-lang/sdk/third_party/double-conversion/src/diy-fp.h