mirror of https://github.com/lukechilds/node.git
Ryan Dahl
15 years ago
128 changed files with 108355 additions and 1429 deletions
@ -0,0 +1,119 @@ |
|||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|||
// Redistribution and use in source and binary forms, with or without
|
|||
// modification, are permitted provided that the following conditions are
|
|||
// met:
|
|||
//
|
|||
// * Redistributions of source code must retain the above copyright
|
|||
// notice, this list of conditions and the following disclaimer.
|
|||
// * Redistributions in binary form must reproduce the above
|
|||
// copyright notice, this list of conditions and the following
|
|||
// disclaimer in the documentation and/or other materials provided
|
|||
// with the distribution.
|
|||
// * Neither the name of Google Inc. nor the names of its
|
|||
// contributors may be used to endorse or promote products derived
|
|||
// from this software without specific prior written permission.
|
|||
//
|
|||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|||
#ifndef V8_CACHED_POWERS_H_ |
|||
#define V8_CACHED_POWERS_H_ |
|||
|
|||
#include "diy_fp.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
struct CachedPower { |
|||
uint64_t significand; |
|||
int16_t binary_exponent; |
|||
int16_t decimal_exponent; |
|||
}; |
|||
|
|||
// The following defines implement the interface between this file and the
|
|||
// generated 'powers_ten.h'.
|
|||
// GRISU_CACHE_NAME(1) contains all possible cached powers.
|
|||
// GRISU_CACHE_NAME(i) contains GRISU_CACHE_NAME(1) where only every 'i'th
|
|||
// element is kept. More formally GRISU_CACHE_NAME(i) contains the elements j*i
|
|||
// with 0 <= j < k with k such that j*k < the size of GRISU_CACHE_NAME(1).
|
|||
// The higher 'i' is the fewer elements we use.
|
|||
// Given that there are less elements, the exponent-distance between two
|
|||
// elements in the cache grows. The variable GRISU_CACHE_MAX_DISTANCE(i) stores
|
|||
// the maximum distance between two elements.
|
|||
#define GRISU_CACHE_STRUCT CachedPower |
|||
#define GRISU_CACHE_NAME(i) kCachedPowers##i |
|||
#define GRISU_CACHE_MAX_DISTANCE(i) kCachedPowersMaxDistance##i |
|||
#define GRISU_CACHE_OFFSET kCachedPowerOffset |
|||
#define GRISU_UINT64_C V8_2PART_UINT64_C |
|||
// The following include imports the precompiled cached powers.
|
|||
#include "powers_ten.h" // NOLINT |
|||
|
|||
static const double kD_1_LOG2_10 = 0.30102999566398114; // 1 / lg(10)
|
|||
|
|||
// We can't use a function since we reference variables depending on the 'i'.
|
|||
// This way the compiler is able to see at compile time that only one
|
|||
// cache-array variable is used and thus can remove all the others.
|
|||
#define COMPUTE_FOR_CACHE(i) \ |
|||
if (!found && (gamma - alpha + 1 >= GRISU_CACHE_MAX_DISTANCE(i))) { \ |
|||
int kQ = DiyFp::kSignificandSize; \ |
|||
double k = ceiling((alpha - e + kQ - 1) * kD_1_LOG2_10); \ |
|||
int index = (GRISU_CACHE_OFFSET + static_cast<int>(k) - 1) / i + 1; \ |
|||
cached_power = GRISU_CACHE_NAME(i)[index]; \ |
|||
found = true; \ |
|||
} \ |
|||
|
|||
static void GetCachedPower(int e, int alpha, int gamma, int* mk, DiyFp* c_mk) { |
|||
// The following if statement should be optimized by the compiler so that only
|
|||
// one array is referenced and the others are not included in the object file.
|
|||
bool found = false; |
|||
CachedPower cached_power; |
|||
COMPUTE_FOR_CACHE(20); |
|||
COMPUTE_FOR_CACHE(19); |
|||
COMPUTE_FOR_CACHE(18); |
|||
COMPUTE_FOR_CACHE(17); |
|||
COMPUTE_FOR_CACHE(16); |
|||
COMPUTE_FOR_CACHE(15); |
|||
COMPUTE_FOR_CACHE(14); |
|||
COMPUTE_FOR_CACHE(13); |
|||
COMPUTE_FOR_CACHE(12); |
|||
COMPUTE_FOR_CACHE(11); |
|||
COMPUTE_FOR_CACHE(10); |
|||
COMPUTE_FOR_CACHE(9); |
|||
COMPUTE_FOR_CACHE(8); |
|||
COMPUTE_FOR_CACHE(7); |
|||
COMPUTE_FOR_CACHE(6); |
|||
COMPUTE_FOR_CACHE(5); |
|||
COMPUTE_FOR_CACHE(4); |
|||
COMPUTE_FOR_CACHE(3); |
|||
COMPUTE_FOR_CACHE(2); |
|||
COMPUTE_FOR_CACHE(1); |
|||
if (!found) { |
|||
UNIMPLEMENTED(); |
|||
// Silence compiler warnings.
|
|||
cached_power.significand = 0; |
|||
cached_power.binary_exponent = 0; |
|||
cached_power.decimal_exponent = 0; |
|||
} |
|||
*c_mk = DiyFp(cached_power.significand, cached_power.binary_exponent); |
|||
*mk = cached_power.decimal_exponent; |
|||
ASSERT((alpha <= c_mk->e() + e) && (c_mk->e() + e <= gamma)); |
|||
} |
|||
#undef GRISU_REDUCTION |
|||
#undef GRISU_CACHE_STRUCT |
|||
#undef GRISU_CACHE_NAME |
|||
#undef GRISU_CACHE_MAX_DISTANCE |
|||
#undef GRISU_CACHE_OFFSET |
|||
#undef GRISU_UINT64_C |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_CACHED_POWERS_H_
|
|||
File diff suppressed because it is too large
@ -0,0 +1,136 @@ |
|||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|||
// Redistribution and use in source and binary forms, with or without
|
|||
// modification, are permitted provided that the following conditions are
|
|||
// met:
|
|||
//
|
|||
// * Redistributions of source code must retain the above copyright
|
|||
// notice, this list of conditions and the following disclaimer.
|
|||
// * Redistributions in binary form must reproduce the above
|
|||
// copyright notice, this list of conditions and the following
|
|||
// disclaimer in the documentation and/or other materials provided
|
|||
// with the distribution.
|
|||
// * Neither the name of Google Inc. nor the names of its
|
|||
// contributors may be used to endorse or promote products derived
|
|||
// from this software without specific prior written permission.
|
|||
//
|
|||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|||
#ifndef V8_DIY_FP_H_ |
|||
#define V8_DIY_FP_H_ |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// This "Do It Yourself Floating Point" class implements a floating-point number
|
|||
// with a uint64 significand and an int exponent. Normalized DiyFp numbers will
|
|||
// have the most significant bit of the significand set.
|
|||
// Multiplication and Subtraction do not normalize their results.
|
|||
// DiyFp are not designed to contain special doubles (NaN and Infinity).
|
|||
class DiyFp { |
|||
public: |
|||
static const int kSignificandSize = 64; |
|||
|
|||
DiyFp() : f_(0), e_(0) {} |
|||
DiyFp(uint64_t f, int e) : f_(f), e_(e) {} |
|||
|
|||
// this = this - other.
|
|||
// The exponents of both numbers must be the same and the significand of this
|
|||
// must be bigger than the significand of other.
|
|||
// The result will not be normalized.
|
|||
void Subtract(const DiyFp& other) { |
|||
ASSERT(e_ == other.e_); |
|||
ASSERT(f_ >= other.f_); |
|||
f_ -= other.f_; |
|||
} |
|||
|
|||
// Returns a - b.
|
|||
// The exponents of both numbers must be the same and this must be bigger
|
|||
// than other. The result will not be normalized.
|
|||
static DiyFp Minus(const DiyFp& a, const DiyFp& b) { |
|||
DiyFp result = a; |
|||
result.Subtract(b); |
|||
return result; |
|||
} |
|||
|
|||
|
|||
// this = this * other.
|
|||
void Multiply(const DiyFp& other) { |
|||
// 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; |
|||
uint64_t a = f_ >> 32; |
|||
uint64_t b = f_ & kM32; |
|||
uint64_t c = other.f_ >> 32; |
|||
uint64_t d = other.f_ & kM32; |
|||
uint64_t ac = a * c; |
|||
uint64_t bc = b * c; |
|||
uint64_t ad = a * d; |
|||
uint64_t bd = b * d; |
|||
uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32); |
|||
tmp += 1U << 31; // round
|
|||
uint64_t result_f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32); |
|||
e_ += other.e_ + 64; |
|||
f_ = result_f; |
|||
} |
|||
|
|||
// returns a * b;
|
|||
static DiyFp Times(const DiyFp& a, const DiyFp& b) { |
|||
DiyFp result = a; |
|||
result.Multiply(b); |
|||
return result; |
|||
} |
|||
|
|||
void Normalize() { |
|||
ASSERT(f_ != 0); |
|||
uint64_t f = f_; |
|||
int e = e_; |
|||
|
|||
// This method is mainly called for normalizing boundaries. In general
|
|||
// boundaries need to be shifted by 10 bits. We thus optimize for this case.
|
|||
const uint64_t k10MSBits = V8_2PART_UINT64_C(0xFFC00000, 00000000); |
|||
while ((f & k10MSBits) == 0) { |
|||
f <<= 10; |
|||
e -= 10; |
|||
} |
|||
while ((f & kUint64MSB) == 0) { |
|||
f <<= 1; |
|||
e--; |
|||
} |
|||
f_ = f; |
|||
e_ = e; |
|||
} |
|||
|
|||
static DiyFp Normalize(const DiyFp& a) { |
|||
DiyFp result = a; |
|||
result.Normalize(); |
|||
return result; |
|||
} |
|||
|
|||
uint64_t f() const { return f_; } |
|||
int e() const { return e_; } |
|||
|
|||
void set_f(uint64_t new_value) { f_ = new_value; } |
|||
void set_e(int new_value) { e_ = new_value; } |
|||
|
|||
private: |
|||
static const uint64_t kUint64MSB = V8_2PART_UINT64_C(0x80000000, 00000000); |
|||
|
|||
uint64_t f_; |
|||
int e_; |
|||
}; |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_DIY_FP_H_
|
|||
@ -0,0 +1,169 @@ |
|||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|||
// Redistribution and use in source and binary forms, with or without
|
|||
// modification, are permitted provided that the following conditions are
|
|||
// met:
|
|||
//
|
|||
// * Redistributions of source code must retain the above copyright
|
|||
// notice, this list of conditions and the following disclaimer.
|
|||
// * Redistributions in binary form must reproduce the above
|
|||
// copyright notice, this list of conditions and the following
|
|||
// disclaimer in the documentation and/or other materials provided
|
|||
// with the distribution.
|
|||
// * Neither the name of Google Inc. nor the names of its
|
|||
// contributors may be used to endorse or promote products derived
|
|||
// from this software without specific prior written permission.
|
|||
//
|
|||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|||
#ifndef V8_DOUBLE_H_ |
|||
#define V8_DOUBLE_H_ |
|||
|
|||
#include "diy_fp.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// We assume that doubles and uint64_t have the same endianness.
|
|||
static uint64_t double_to_uint64(double d) { return BitCast<uint64_t>(d); } |
|||
static double uint64_to_double(uint64_t d64) { return BitCast<double>(d64); } |
|||
|
|||
// Helper functions for doubles.
|
|||
class Double { |
|||
public: |
|||
static const uint64_t kSignMask = V8_2PART_UINT64_C(0x80000000, 00000000); |
|||
static const uint64_t kExponentMask = V8_2PART_UINT64_C(0x7FF00000, 00000000); |
|||
static const uint64_t kSignificandMask = |
|||
V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
|||
static const uint64_t kHiddenBit = V8_2PART_UINT64_C(0x00100000, 00000000); |
|||
|
|||
Double() : d64_(0) {} |
|||
explicit Double(double d) : d64_(double_to_uint64(d)) {} |
|||
explicit Double(uint64_t d64) : d64_(d64) {} |
|||
|
|||
DiyFp AsDiyFp() const { |
|||
ASSERT(!IsSpecial()); |
|||
return DiyFp(Significand(), Exponent()); |
|||
} |
|||
|
|||
// this->Significand() must not be 0.
|
|||
DiyFp AsNormalizedDiyFp() const { |
|||
uint64_t f = Significand(); |
|||
int e = Exponent(); |
|||
|
|||
ASSERT(f != 0); |
|||
|
|||
// The current double could be a denormal.
|
|||
while ((f & kHiddenBit) == 0) { |
|||
f <<= 1; |
|||
e--; |
|||
} |
|||
// Do the final shifts in one go. Don't forget the hidden bit (the '-1').
|
|||
f <<= DiyFp::kSignificandSize - kSignificandSize - 1; |
|||
e -= DiyFp::kSignificandSize - kSignificandSize - 1; |
|||
return DiyFp(f, e); |
|||
} |
|||
|
|||
// Returns the double's bit as uint64.
|
|||
uint64_t AsUint64() const { |
|||
return d64_; |
|||
} |
|||
|
|||
int Exponent() const { |
|||
if (IsDenormal()) return kDenormalExponent; |
|||
|
|||
uint64_t d64 = AsUint64(); |
|||
int biased_e = static_cast<int>((d64 & kExponentMask) >> kSignificandSize); |
|||
return biased_e - kExponentBias; |
|||
} |
|||
|
|||
uint64_t Significand() const { |
|||
uint64_t d64 = AsUint64(); |
|||
uint64_t significand = d64 & kSignificandMask; |
|||
if (!IsDenormal()) { |
|||
return significand + kHiddenBit; |
|||
} else { |
|||
return significand; |
|||
} |
|||
} |
|||
|
|||
// Returns true if the double is a denormal.
|
|||
bool IsDenormal() const { |
|||
uint64_t d64 = AsUint64(); |
|||
return (d64 & kExponentMask) == 0; |
|||
} |
|||
|
|||
// We consider denormals not to be special.
|
|||
// Hence only Infinity and NaN are special.
|
|||
bool IsSpecial() const { |
|||
uint64_t d64 = AsUint64(); |
|||
return (d64 & kExponentMask) == kExponentMask; |
|||
} |
|||
|
|||
bool IsNan() const { |
|||
uint64_t d64 = AsUint64(); |
|||
return ((d64 & kExponentMask) == kExponentMask) && |
|||
((d64 & kSignificandMask) != 0); |
|||
} |
|||
|
|||
|
|||
bool IsInfinite() const { |
|||
uint64_t d64 = AsUint64(); |
|||
return ((d64 & kExponentMask) == kExponentMask) && |
|||
((d64 & kSignificandMask) == 0); |
|||
} |
|||
|
|||
|
|||
int Sign() const { |
|||
uint64_t d64 = AsUint64(); |
|||
return (d64 & kSignMask) == 0? 1: -1; |
|||
} |
|||
|
|||
|
|||
// Returns the two boundaries of this.
|
|||
// The bigger boundary (m_plus) is normalized. The lower boundary has the same
|
|||
// exponent as m_plus.
|
|||
void NormalizedBoundaries(DiyFp* out_m_minus, DiyFp* out_m_plus) const { |
|||
DiyFp v = this->AsDiyFp(); |
|||
bool significand_is_zero = (v.f() == kHiddenBit); |
|||
DiyFp m_plus = DiyFp::Normalize(DiyFp((v.f() << 1) + 1, v.e() - 1)); |
|||
DiyFp m_minus; |
|||
if (significand_is_zero && v.e() != kDenormalExponent) { |
|||
// The boundary is closer. Think of v = 1000e10 and v- = 9999e9.
|
|||
// Then the boundary (== (v - v-)/2) is not just at a distance of 1e9 but
|
|||
// at a distance of 1e8.
|
|||
// The only exception is for the smallest normal: the largest denormal is
|
|||
// at the same distance as its successor.
|
|||
// Note: denormals have the same exponent as the smallest normals.
|
|||
m_minus = DiyFp((v.f() << 2) - 1, v.e() - 2); |
|||
} else { |
|||
m_minus = DiyFp((v.f() << 1) - 1, v.e() - 1); |
|||
} |
|||
m_minus.set_f(m_minus.f() << (m_minus.e() - m_plus.e())); |
|||
m_minus.set_e(m_plus.e()); |
|||
*out_m_plus = m_plus; |
|||
*out_m_minus = m_minus; |
|||
} |
|||
|
|||
double value() const { return uint64_to_double(d64_); } |
|||
|
|||
private: |
|||
static const int kSignificandSize = 52; // Excludes the hidden bit.
|
|||
static const int kExponentBias = 0x3FF + kSignificandSize; |
|||
static const int kDenormalExponent = -kExponentBias + 1; |
|||
|
|||
uint64_t d64_; |
|||
}; |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_DOUBLE_H_
|
|||
@ -0,0 +1,494 @@ |
|||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|||
// Redistribution and use in source and binary forms, with or without
|
|||
// modification, are permitted provided that the following conditions are
|
|||
// met:
|
|||
//
|
|||
// * Redistributions of source code must retain the above copyright
|
|||
// notice, this list of conditions and the following disclaimer.
|
|||
// * Redistributions in binary form must reproduce the above
|
|||
// copyright notice, this list of conditions and the following
|
|||
// disclaimer in the documentation and/or other materials provided
|
|||
// with the distribution.
|
|||
// * Neither the name of Google Inc. nor the names of its
|
|||
// contributors may be used to endorse or promote products derived
|
|||
// from this software without specific prior written permission.
|
|||
//
|
|||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|||
#include "v8.h" |
|||
|
|||
#include "grisu3.h" |
|||
|
|||
#include "cached_powers.h" |
|||
#include "diy_fp.h" |
|||
#include "double.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
template <int alpha = -60, int gamma = -32> |
|||
class Grisu3 { |
|||
public: |
|||
// Provides a decimal representation of v.
|
|||
// Returns true if it succeeds, otherwise the result can not be trusted.
|
|||
// There will be *length digits inside the buffer (not null-terminated).
|
|||
// If the function returns true then
|
|||
// v == (double) (buffer * 10^decimal_exponent).
|
|||
// The digits in the buffer are the shortest representation possible: no
|
|||
// 0.099999999999 instead of 0.1.
|
|||
// The last digit will be closest to the actual v. That is, even if several
|
|||
// digits might correctly yield 'v' when read again, the closest will be
|
|||
// computed.
|
|||
static bool grisu3(double v, |
|||
char* buffer, int* length, int* decimal_exponent); |
|||
|
|||
private: |
|||
// Rounds the buffer according to the rest.
|
|||
// If there is too much imprecision to round then false is returned.
|
|||
// Similarily false is returned when the buffer is not within Delta.
|
|||
static bool RoundWeed(char* buffer, int len, uint64_t wp_W, uint64_t Delta, |
|||
uint64_t rest, uint64_t ten_kappa, uint64_t ulp); |
|||
// Dispatches to the a specialized digit-generation routine. The chosen
|
|||
// routine depends on w.e (which in turn depends on alpha and gamma).
|
|||
// Currently there is only one digit-generation routine, but it would be easy
|
|||
// to add others.
|
|||
static bool DigitGen(DiyFp low, DiyFp w, DiyFp high, |
|||
char* buffer, int* len, int* kappa); |
|||
// Generates w's digits. The result is the shortest in the interval low-high.
|
|||
// All DiyFp are assumed to be imprecise and this function takes this
|
|||
// imprecision into account. If the function cannot compute the best
|
|||
// representation (due to the imprecision) then false is returned.
|
|||
static bool DigitGen_m60_m32(DiyFp low, DiyFp w, DiyFp high, |
|||
char* buffer, int* length, int* kappa); |
|||
}; |
|||
|
|||
|
|||
template<int alpha, int gamma> |
|||
bool Grisu3<alpha, gamma>::grisu3(double v, |
|||
char* buffer, |
|||
int* length, |
|||
int* decimal_exponent) { |
|||
DiyFp w = Double(v).AsNormalizedDiyFp(); |
|||
// boundary_minus and boundary_plus are the boundaries between v and its
|
|||
// neighbors. Any number strictly between boundary_minus and boundary_plus
|
|||
// will round to v when read as double.
|
|||
// Grisu3 will never output representations that lie exactly on a boundary.
|
|||
DiyFp boundary_minus, boundary_plus; |
|||
Double(v).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
|||
ASSERT(boundary_plus.e() == w.e()); |
|||
DiyFp ten_mk; // Cached power of ten: 10^-k
|
|||
int mk; // -k
|
|||
GetCachedPower(w.e() + DiyFp::kSignificandSize, alpha, gamma, &mk, &ten_mk); |
|||
ASSERT(alpha <= w.e() + ten_mk.e() + DiyFp::kSignificandSize && |
|||
gamma >= w.e() + ten_mk.e() + DiyFp::kSignificandSize); |
|||
// Note that ten_mk is only an approximation of 10^-k. A DiyFp only contains a
|
|||
// 64 bit significand and ten_mk is thus only precise up to 64 bits.
|
|||
|
|||
// The DiyFp::Times procedure rounds its result, and ten_mk is approximated
|
|||
// too. The variable scaled_w (as well as scaled_boundary_minus/plus) are now
|
|||
// off by a small amount.
|
|||
// In fact: scaled_w - w*10^k < 1ulp (unit in the last place) of scaled_w.
|
|||
// In other words: let f = scaled_w.f() and e = scaled_w.e(), then
|
|||
// (f-1) * 2^e < w*10^k < (f+1) * 2^e
|
|||
DiyFp scaled_w = DiyFp::Times(w, ten_mk); |
|||
ASSERT(scaled_w.e() == |
|||
boundary_plus.e() + ten_mk.e() + DiyFp::kSignificandSize); |
|||
// In theory it would be possible to avoid some recomputations by computing
|
|||
// the difference between w and boundary_minus/plus (a power of 2) and to
|
|||
// compute scaled_boundary_minus/plus by subtracting/adding from
|
|||
// scaled_w. However the code becomes much less readable and the speed
|
|||
// enhancements are not terriffic.
|
|||
DiyFp scaled_boundary_minus = DiyFp::Times(boundary_minus, ten_mk); |
|||
DiyFp scaled_boundary_plus = DiyFp::Times(boundary_plus, ten_mk); |
|||
|
|||
// DigitGen will generate the digits of scaled_w. Therefore we have
|
|||
// v == (double) (scaled_w * 10^-mk).
|
|||
// Set decimal_exponent == -mk and pass it to DigitGen. If scaled_w is not an
|
|||
// integer than it will be updated. For instance if scaled_w == 1.23 then
|
|||
// the buffer will be filled with "123" und the decimal_exponent will be
|
|||
// decreased by 2.
|
|||
int kappa; |
|||
bool result = DigitGen(scaled_boundary_minus, scaled_w, scaled_boundary_plus, |
|||
buffer, length, &kappa); |
|||
*decimal_exponent = -mk + kappa; |
|||
return result; |
|||
} |
|||
|
|||
// Generates the digits of input number w.
|
|||
// w is a floating-point number (DiyFp), consisting of a significand and an
|
|||
// exponent. Its exponent is bounded by alpha and gamma. Typically alpha >= -63
|
|||
// and gamma <= 3.
|
|||
// Returns false if it fails, in which case the generated digits in the buffer
|
|||
// should not be used.
|
|||
// Preconditions:
|
|||
// * low, w and high are correct up to 1 ulp (unit in the last place). That
|
|||
// is, their error must be less that a unit of their last digits.
|
|||
// * low.e() == w.e() == high.e()
|
|||
// * low < w < high, and taking into account their error: low~ <= high~
|
|||
// * alpha <= w.e() <= gamma
|
|||
// Postconditions: returns false if procedure fails.
|
|||
// otherwise:
|
|||
// * buffer is not null-terminated, but len contains the number of digits.
|
|||
// * buffer contains the shortest possible decimal digit-sequence
|
|||
// such that LOW < buffer * 10^kappa < HIGH, where LOW and HIGH are the
|
|||
// correct values of low and high (without their error).
|
|||
// * if more than one decimal representation gives the minimal number of
|
|||
// decimal digits then the one closest to W (where W is the correct value
|
|||
// of w) is chosen.
|
|||
// Remark: this procedure takes into account the imprecision of its input
|
|||
// numbers. If the precision is not enough to guarantee all the postconditions
|
|||
// then false is returned. This usually happens rarely (~0.5%).
|
|||
template<int alpha, int gamma> |
|||
bool Grisu3<alpha, gamma>::DigitGen(DiyFp low, |
|||
DiyFp w, |
|||
DiyFp high, |
|||
char* buffer, |
|||
int* len, |
|||
int* kappa) { |
|||
ASSERT(low.e() == w.e() && w.e() == high.e()); |
|||
ASSERT(low.f() + 1 <= high.f() - 1); |
|||
ASSERT(alpha <= w.e() && w.e() <= gamma); |
|||
// The following tests use alpha and gamma to avoid unnecessary dynamic tests.
|
|||
if ((alpha >= -60 && gamma <= -32) || // -60 <= w.e() <= -32
|
|||
(alpha <= -32 && gamma >= -60 && // Alpha/gamma overlaps -60/-32 region.
|
|||
-60 <= w.e() && w.e() <= -32)) { |
|||
return DigitGen_m60_m32(low, w, high, buffer, len, kappa); |
|||
} else { |
|||
// A simple adaption of the special case -60/-32 would allow greater ranges
|
|||
// of alpha/gamma and thus reduce the number of precomputed cached powers of
|
|||
// ten.
|
|||
UNIMPLEMENTED(); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
static const uint32_t kTen4 = 10000; |
|||
static const uint32_t kTen5 = 100000; |
|||
static const uint32_t kTen6 = 1000000; |
|||
static const uint32_t kTen7 = 10000000; |
|||
static const uint32_t kTen8 = 100000000; |
|||
static const uint32_t kTen9 = 1000000000; |
|||
|
|||
// Returns the biggest power of ten that is <= than the given number. We
|
|||
// furthermore receive the maximum number of bits 'number' has.
|
|||
// If number_bits == 0 then 0^-1 is returned
|
|||
// The number of bits must be <= 32.
|
|||
static void BiggestPowerTen(uint32_t number, |
|||
int number_bits, |
|||
uint32_t* power, |
|||
int* exponent) { |
|||
switch (number_bits) { |
|||
case 32: |
|||
case 31: |
|||
case 30: |
|||
if (kTen9 <= number) { |
|||
*power = kTen9; |
|||
*exponent = 9; |
|||
break; |
|||
} // else fallthrough
|
|||
case 29: |
|||
case 28: |
|||
case 27: |
|||
if (kTen8 <= number) { |
|||
*power = kTen8; |
|||
*exponent = 8; |
|||
break; |
|||
} // else fallthrough
|
|||
case 26: |
|||
case 25: |
|||
case 24: |
|||
if (kTen7 <= number) { |
|||
*power = kTen7; |
|||
*exponent = 7; |
|||
break; |
|||
} // else fallthrough
|
|||
case 23: |
|||
case 22: |
|||
case 21: |
|||
case 20: |
|||
if (kTen6 <= number) { |
|||
*power = kTen6; |
|||
*exponent = 6; |
|||
break; |
|||
} // else fallthrough
|
|||
case 19: |
|||
case 18: |
|||
case 17: |
|||
if (kTen5 <= number) { |
|||
*power = kTen5; |
|||
*exponent = 5; |
|||
break; |
|||
} // else fallthrough
|
|||
case 16: |
|||
case 15: |
|||
case 14: |
|||
if (kTen4 <= number) { |
|||
*power = kTen4; |
|||
*exponent = 4; |
|||
break; |
|||
} // else fallthrough
|
|||
case 13: |
|||
case 12: |
|||
case 11: |
|||
case 10: |
|||
if (1000 <= number) { |
|||
*power = 1000; |
|||
*exponent = 3; |
|||
break; |
|||
} // else fallthrough
|
|||
case 9: |
|||
case 8: |
|||
case 7: |
|||
if (100 <= number) { |
|||
*power = 100; |
|||
*exponent = 2; |
|||
break; |
|||
} // else fallthrough
|
|||
case 6: |
|||
case 5: |
|||
case 4: |
|||
if (10 <= number) { |
|||
*power = 10; |
|||
*exponent = 1; |
|||
break; |
|||
} // else fallthrough
|
|||
case 3: |
|||
case 2: |
|||
case 1: |
|||
if (1 <= number) { |
|||
*power = 1; |
|||
*exponent = 0; |
|||
break; |
|||
} // else fallthrough
|
|||
case 0: |
|||
*power = 0; |
|||
*exponent = -1; |
|||
break; |
|||
default: |
|||
// Following assignments are here to silence compiler warnings.
|
|||
*power = 0; |
|||
*exponent = 0; |
|||
UNREACHABLE(); |
|||
} |
|||
} |
|||
|
|||
|
|||
// Same comments as for DigitGen but with additional precondition:
|
|||
// -60 <= w.e() <= -32
|
|||
//
|
|||
// Say, for the sake of example, that
|
|||
// w.e() == -48, and w.f() == 0x1234567890abcdef
|
|||
// w's value can be computed by w.f() * 2^w.e()
|
|||
// We can obtain w's integral digits by simply shifting w.f() by -w.e().
|
|||
// -> w's integral part is 0x1234
|
|||
// w's fractional part is therefore 0x567890abcdef.
|
|||
// Printing w's integral part is easy (simply print 0x1234 in decimal).
|
|||
// In order to print its fraction we repeatedly multiply the fraction by 10 and
|
|||
// get each digit. Example the first digit after the comma would be computed by
|
|||
// (0x567890abcdef * 10) >> 48. -> 3
|
|||
// The whole thing becomes slightly more complicated because we want to stop
|
|||
// once we have enough digits. That is, once the digits inside the buffer
|
|||
// represent 'w' we can stop. Everything inside the interval low - high
|
|||
// represents w. However we have to pay attention to low, high and w's
|
|||
// imprecision.
|
|||
template<int alpha, int gamma> |
|||
bool Grisu3<alpha, gamma>::DigitGen_m60_m32(DiyFp low, |
|||
DiyFp w, |
|||
DiyFp high, |
|||
char* buffer, |
|||
int* length, |
|||
int* kappa) { |
|||
// low, w and high are imprecise, but by less than one ulp (unit in the last
|
|||
// place).
|
|||
// If we remove (resp. add) 1 ulp from low (resp. high) we are certain that
|
|||
// the new numbers are outside of the interval we want the final
|
|||
// representation to lie in.
|
|||
// Inversely adding (resp. removing) 1 ulp from low (resp. high) would yield
|
|||
// numbers that are certain to lie in the interval. We will use this fact
|
|||
// later on.
|
|||
// We will now start by generating the digits within the uncertain
|
|||
// interval. Later we will weed out representations that lie outside the safe
|
|||
// interval and thus _might_ lie outside the correct interval.
|
|||
uint64_t unit = 1; |
|||
DiyFp too_low = DiyFp(low.f() - unit, low.e()); |
|||
DiyFp too_high = DiyFp(high.f() + unit, high.e()); |
|||
// too_low and too_high are guaranteed to lie outside the interval we want the
|
|||
// generated number in.
|
|||
DiyFp unsafe_interval = DiyFp::Minus(too_high, too_low); |
|||
// We now cut the input number into two parts: the integral digits and the
|
|||
// fractionals. We will not write any decimal separator though, but adapt
|
|||
// kappa instead.
|
|||
// Reminder: we are currently computing the digits (stored inside the buffer)
|
|||
// such that: too_low < buffer * 10^kappa < too_high
|
|||
// We use too_high for the digit_generation and stop as soon as possible.
|
|||
// If we stop early we effectively round down.
|
|||
DiyFp one = DiyFp(static_cast<uint64_t>(1) << -w.e(), w.e()); |
|||
// Division by one is a shift.
|
|||
uint32_t integrals = static_cast<uint32_t>(too_high.f() >> -one.e()); |
|||
// Modulo by one is an and.
|
|||
uint64_t fractionals = too_high.f() & (one.f() - 1); |
|||
uint32_t divider; |
|||
int divider_exponent; |
|||
BiggestPowerTen(integrals, DiyFp::kSignificandSize - (-one.e()), |
|||
÷r, ÷r_exponent); |
|||
*kappa = divider_exponent + 1; |
|||
*length = 0; |
|||
// Loop invariant: buffer = too_high / 10^kappa (integer division)
|
|||
// The invariant holds for the first iteration: kappa has been initialized
|
|||
// with the divider exponent + 1. And the divider is the biggest power of ten
|
|||
// that is smaller than integrals.
|
|||
while (*kappa > 0) { |
|||
int digit = integrals / divider; |
|||
buffer[*length] = '0' + digit; |
|||
(*length)++; |
|||
integrals %= divider; |
|||
(*kappa)--; |
|||
// Note that kappa now equals the exponent of the divider and that the
|
|||
// invariant thus holds again.
|
|||
uint64_t rest = |
|||
(static_cast<uint64_t>(integrals) << -one.e()) + fractionals; |
|||
// Invariant: too_high = buffer * 10^kappa + DiyFp(rest, one.e())
|
|||
// Reminder: unsafe_interval.e() == one.e()
|
|||
if (rest < unsafe_interval.f()) { |
|||
// Rounding down (by not emitting the remaining digits) yields a number
|
|||
// that lies within the unsafe interval.
|
|||
return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f(), |
|||
unsafe_interval.f(), rest, |
|||
static_cast<uint64_t>(divider) << -one.e(), unit); |
|||
} |
|||
divider /= 10; |
|||
} |
|||
|
|||
// The integrals have been generated. We are at the point of the decimal
|
|||
// separator. In the following loop we simply multiply the remaining digits by
|
|||
// 10 and divide by one. We just need to pay attention to multiply associated
|
|||
// data (like the interval or 'unit'), too.
|
|||
// Instead of multiplying by 10 we multiply by 5 (cheaper operation) and
|
|||
// increase its (imaginary) exponent. At the same time we decrease the
|
|||
// divider's (one's) exponent and shift its significand.
|
|||
// Basically, if fractionals was a DiyFp (with fractionals.e == one.e):
|
|||
// fractionals.f *= 10;
|
|||
// fractionals.f >>= 1; fractionals.e++; // value remains unchanged.
|
|||
// one.f >>= 1; one.e++; // value remains unchanged.
|
|||
// and we have again fractionals.e == one.e which allows us to divide
|
|||
// fractionals.f() by one.f()
|
|||
// We simply combine the *= 10 and the >>= 1.
|
|||
while (true) { |
|||
fractionals *= 5; |
|||
unit *= 5; |
|||
unsafe_interval.set_f(unsafe_interval.f() * 5); |
|||
unsafe_interval.set_e(unsafe_interval.e() + 1); // Will be optimized out.
|
|||
one.set_f(one.f() >> 1); |
|||
one.set_e(one.e() + 1); |
|||
// Integer division by one.
|
|||
int digit = static_cast<int>(fractionals >> -one.e()); |
|||
buffer[*length] = '0' + digit; |
|||
(*length)++; |
|||
fractionals &= one.f() - 1; // Modulo by one.
|
|||
(*kappa)--; |
|||
if (fractionals < unsafe_interval.f()) { |
|||
return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f() * unit, |
|||
unsafe_interval.f(), fractionals, one.f(), unit); |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
// Rounds the given generated digits in the buffer and weeds out generated
|
|||
// digits that are not in the safe interval, or where we cannot find a rounded
|
|||
// representation.
|
|||
// Input: * buffer containing the digits of too_high / 10^kappa
|
|||
// * the buffer's length
|
|||
// * distance_too_high_w == (too_high - w).f() * unit
|
|||
// * unsafe_interval == (too_high - too_low).f() * unit
|
|||
// * rest = (too_high - buffer * 10^kappa).f() * unit
|
|||
// * ten_kappa = 10^kappa * unit
|
|||
// * unit = the common multiplier
|
|||
// Output: returns true on success.
|
|||
// Modifies the generated digits in the buffer to approach (round towards) w.
|
|||
template<int alpha, int gamma> |
|||
bool Grisu3<alpha, gamma>::RoundWeed(char* buffer, |
|||
int length, |
|||
uint64_t distance_too_high_w, |
|||
uint64_t unsafe_interval, |
|||
uint64_t rest, |
|||
uint64_t ten_kappa, |
|||
uint64_t unit) { |
|||
uint64_t small_distance = distance_too_high_w - unit; |
|||
uint64_t big_distance = distance_too_high_w + unit; |
|||
// Let w- = too_high - big_distance, and
|
|||
// w+ = too_high - small_distance.
|
|||
// Note: w- < w < w+
|
|||
//
|
|||
// The real w (* unit) must lie somewhere inside the interval
|
|||
// ]w-; w+[ (often written as "(w-; w+)")
|
|||
|
|||
// Basically the buffer currently contains a number in the unsafe interval
|
|||
// ]too_low; too_high[ with too_low < w < too_high
|
|||
//
|
|||
// By generating the digits of too_high we got the biggest last digit.
|
|||
// In the case that w+ < buffer < too_high we try to decrement the buffer.
|
|||
// This way the buffer approaches (rounds towards) w.
|
|||
// There are 3 conditions that stop the decrementation process:
|
|||
// 1) the buffer is already below w+
|
|||
// 2) decrementing the buffer would make it leave the unsafe interval
|
|||
// 3) decrementing the buffer would yield a number below w+ and farther away
|
|||
// than the current number. In other words:
|
|||
// (buffer{-1} < w+) && w+ - buffer{-1} > buffer - w+
|
|||
// Instead of using the buffer directly we use its distance to too_high.
|
|||
// Conceptually rest ~= too_high - buffer
|
|||
while (rest < small_distance && // Negated condition 1
|
|||
unsafe_interval - rest >= ten_kappa && // Negated condition 2
|
|||
(rest + ten_kappa < small_distance || // buffer{-1} > w+
|
|||
small_distance - rest >= rest + ten_kappa - small_distance)) { |
|||
buffer[length - 1]--; |
|||
rest += ten_kappa; |
|||
} |
|||
|
|||
// We have approached w+ as much as possible. We now test if approaching w-
|
|||
// would require changing the buffer. If yes, then we have two possible
|
|||
// representations close to w, but we cannot decide which one is closer.
|
|||
if (rest < big_distance && |
|||
unsafe_interval - rest >= ten_kappa && |
|||
(rest + ten_kappa < big_distance || |
|||
big_distance - rest > rest + ten_kappa - big_distance)) { |
|||
return false; |
|||
} |
|||
|
|||
// Weeding test.
|
|||
// The safe interval is [too_low + 2 ulp; too_high - 2 ulp]
|
|||
// Since too_low = too_high - unsafe_interval this is equivalent too
|
|||
// [too_high - unsafe_interval + 4 ulp; too_high - 2 ulp]
|
|||
// Conceptually we have: rest ~= too_high - buffer
|
|||
return (2 * unit <= rest) && (rest <= unsafe_interval - 4 * unit); |
|||
} |
|||
|
|||
|
|||
bool grisu3(double v, char* buffer, int* sign, int* length, int* point) { |
|||
ASSERT(v != 0); |
|||
ASSERT(!Double(v).IsSpecial()); |
|||
|
|||
if (v < 0) { |
|||
v = -v; |
|||
*sign = 1; |
|||
} else { |
|||
*sign = 0; |
|||
} |
|||
int decimal_exponent; |
|||
bool result = Grisu3<-60, -32>::grisu3(v, buffer, length, &decimal_exponent); |
|||
*point = *length + decimal_exponent; |
|||
buffer[*length] = '\0'; |
|||
return result; |
|||
} |
|||
|
|||
} } // namespace v8::internal
|
|||
@ -0,0 +1,55 @@ |
|||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|||
// Redistribution and use in source and binary forms, with or without
|
|||
// modification, are permitted provided that the following conditions are
|
|||
// met:
|
|||
//
|
|||
// * Redistributions of source code must retain the above copyright
|
|||
// notice, this list of conditions and the following disclaimer.
|
|||
// * Redistributions in binary form must reproduce the above
|
|||
// copyright notice, this list of conditions and the following
|
|||
// disclaimer in the documentation and/or other materials provided
|
|||
// with the distribution.
|
|||
// * Neither the name of Google Inc. nor the names of its
|
|||
// contributors may be used to endorse or promote products derived
|
|||
// from this software without specific prior written permission.
|
|||
//
|
|||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|||
#ifndef V8_GRISU3_H_ |
|||
#define V8_GRISU3_H_ |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// Grisu3 will produce at most kGrisu3MaximalLength digits. This does not
|
|||
// include the terminating '\0' character.
|
|||
static const int kGrisu3MaximalLength = 17; |
|||
|
|||
// Provides a decimal representation of v.
|
|||
// v must satisfy v != 0 and it must not be Infinity or NaN.
|
|||
// Returns true if it succeeds, otherwise the result can not be trusted.
|
|||
// There will be *length digits inside the buffer followed by a null terminator.
|
|||
// If the function returns true then
|
|||
// v == (double) (buffer * 10^(decimal-point - length)).
|
|||
// The digits in the buffer are the shortest representation possible: no
|
|||
// 0.099999999999 instead of 0.1.
|
|||
// The last digit will be closest to the actual v. That is, even if several
|
|||
// digits might correctly yield 'v' when read again, the buffer will contain the
|
|||
// one closest to v.
|
|||
// The variable 'sign' will be '0' if the given number is positive, and '1'
|
|||
// otherwise.
|
|||
bool grisu3(double d, char* buffer, int* sign, int* length, int* decimal_point); |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_GRISU3_H_
|
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,44 @@ |
|||
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
|||
// Redistribution and use in source and binary forms, with or without
|
|||
// modification, are permitted provided that the following conditions are
|
|||
// met:
|
|||
//
|
|||
// * Redistributions of source code must retain the above copyright
|
|||
// notice, this list of conditions and the following disclaimer.
|
|||
// * Redistributions in binary form must reproduce the above
|
|||
// copyright notice, this list of conditions and the following
|
|||
// disclaimer in the documentation and/or other materials provided
|
|||
// with the distribution.
|
|||
// * Neither the name of Google Inc. nor the names of its
|
|||
// contributors may be used to endorse or promote products derived
|
|||
// from this software without specific prior written permission.
|
|||
//
|
|||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|||
#ifndef GAY_SHORTEST_H_ |
|||
#define GAY_SHORTEST_H_ |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
struct GayShortest { |
|||
double v; |
|||
const char* representation; |
|||
int decimal_point; |
|||
}; |
|||
|
|||
Vector<const GayShortest> PrecomputedShortestRepresentations(); |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // GAY_SHORTEST_H_
|
|||
@ -0,0 +1,67 @@ |
|||
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
|||
|
|||
#include <stdlib.h> |
|||
|
|||
#include "v8.h" |
|||
|
|||
#include "platform.h" |
|||
#include "cctest.h" |
|||
#include "diy_fp.h" |
|||
|
|||
|
|||
using namespace v8::internal; |
|||
|
|||
|
|||
TEST(Subtract) { |
|||
DiyFp diy_fp1 = DiyFp(3, 0); |
|||
DiyFp diy_fp2 = DiyFp(1, 0); |
|||
DiyFp diff = DiyFp::Minus(diy_fp1, diy_fp2); |
|||
|
|||
CHECK(2 == diff.f()); // NOLINT
|
|||
CHECK_EQ(0, diff.e()); |
|||
diy_fp1.Subtract(diy_fp2); |
|||
CHECK(2 == diy_fp1.f()); // NOLINT
|
|||
CHECK_EQ(0, diy_fp1.e()); |
|||
} |
|||
|
|||
|
|||
TEST(Multiply) { |
|||
DiyFp diy_fp1 = DiyFp(3, 0); |
|||
DiyFp diy_fp2 = DiyFp(2, 0); |
|||
DiyFp product = DiyFp::Times(diy_fp1, diy_fp2); |
|||
|
|||
CHECK(0 == product.f()); // NOLINT
|
|||
CHECK_EQ(64, product.e()); |
|||
diy_fp1.Multiply(diy_fp2); |
|||
CHECK(0 == diy_fp1.f()); // NOLINT
|
|||
CHECK_EQ(64, diy_fp1.e()); |
|||
|
|||
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x80000000, 00000000), 11); |
|||
diy_fp2 = DiyFp(2, 13); |
|||
product = DiyFp::Times(diy_fp1, diy_fp2); |
|||
CHECK(1 == product.f()); // NOLINT
|
|||
CHECK_EQ(11 + 13 + 64, product.e()); |
|||
|
|||
// Test rounding.
|
|||
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x80000000, 00000001), 11); |
|||
diy_fp2 = DiyFp(1, 13); |
|||
product = DiyFp::Times(diy_fp1, diy_fp2); |
|||
CHECK(1 == product.f()); // NOLINT
|
|||
CHECK_EQ(11 + 13 + 64, product.e()); |
|||
|
|||
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x7fffffff, ffffffff), 11); |
|||
diy_fp2 = DiyFp(1, 13); |
|||
product = DiyFp::Times(diy_fp1, diy_fp2); |
|||
CHECK(0 == product.f()); // NOLINT
|
|||
CHECK_EQ(11 + 13 + 64, product.e()); |
|||
|
|||
// Halfway cases are allowed to round either way. So don't check for it.
|
|||
|
|||
// Big numbers.
|
|||
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF), 11); |
|||
diy_fp2 = DiyFp(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF), 13); |
|||
// 128bit result: 0xfffffffffffffffe0000000000000001
|
|||
product = DiyFp::Times(diy_fp1, diy_fp2); |
|||
CHECK(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFe) == product.f()); |
|||
CHECK_EQ(11 + 13 + 64, product.e()); |
|||
} |
|||
@ -0,0 +1,204 @@ |
|||
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
|||
|
|||
#include <stdlib.h> |
|||
|
|||
#include "v8.h" |
|||
|
|||
#include "platform.h" |
|||
#include "cctest.h" |
|||
#include "diy_fp.h" |
|||
#include "double.h" |
|||
|
|||
|
|||
using namespace v8::internal; |
|||
|
|||
|
|||
TEST(Uint64Conversions) { |
|||
// Start by checking the byte-order.
|
|||
uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF); |
|||
CHECK_EQ(3512700564088504e-318, Double(ordered).value()); |
|||
|
|||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|||
CHECK_EQ(5e-324, Double(min_double64).value()); |
|||
|
|||
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
|||
CHECK_EQ(1.7976931348623157e308, Double(max_double64).value()); |
|||
} |
|||
|
|||
TEST(AsDiyFp) { |
|||
uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF); |
|||
DiyFp diy_fp = Double(ordered).AsDiyFp(); |
|||
CHECK_EQ(0x12 - 0x3FF - 52, diy_fp.e()); |
|||
// The 52 mantissa bits, plus the implicit 1 in bit 52 as a UINT64.
|
|||
CHECK(V8_2PART_UINT64_C(0x00134567, 89ABCDEF) == diy_fp.f()); // NOLINT
|
|||
|
|||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|||
diy_fp = Double(min_double64).AsDiyFp(); |
|||
CHECK_EQ(-0x3FF - 52 + 1, diy_fp.e()); |
|||
// This is a denormal; so no hidden bit.
|
|||
CHECK(1 == diy_fp.f()); // NOLINT
|
|||
|
|||
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
|||
diy_fp = Double(max_double64).AsDiyFp(); |
|||
CHECK_EQ(0x7FE - 0x3FF - 52, diy_fp.e()); |
|||
CHECK(V8_2PART_UINT64_C(0x001fffff, ffffffff) == diy_fp.f()); // NOLINT
|
|||
} |
|||
|
|||
|
|||
TEST(AsNormalizedDiyFp) { |
|||
uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF); |
|||
DiyFp diy_fp = Double(ordered).AsNormalizedDiyFp(); |
|||
CHECK_EQ(0x12 - 0x3FF - 52 - 11, diy_fp.e()); |
|||
CHECK((V8_2PART_UINT64_C(0x00134567, 89ABCDEF) << 11) == |
|||
diy_fp.f()); // NOLINT
|
|||
|
|||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|||
diy_fp = Double(min_double64).AsNormalizedDiyFp(); |
|||
CHECK_EQ(-0x3FF - 52 + 1 - 63, diy_fp.e()); |
|||
// This is a denormal; so no hidden bit.
|
|||
CHECK(V8_2PART_UINT64_C(0x80000000, 00000000) == diy_fp.f()); // NOLINT
|
|||
|
|||
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
|||
diy_fp = Double(max_double64).AsNormalizedDiyFp(); |
|||
CHECK_EQ(0x7FE - 0x3FF - 52 - 11, diy_fp.e()); |
|||
CHECK((V8_2PART_UINT64_C(0x001fffff, ffffffff) << 11) == |
|||
diy_fp.f()); // NOLINT
|
|||
} |
|||
|
|||
|
|||
TEST(IsDenormal) { |
|||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|||
CHECK(Double(min_double64).IsDenormal()); |
|||
uint64_t bits = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
|||
CHECK(Double(bits).IsDenormal()); |
|||
bits = V8_2PART_UINT64_C(0x00100000, 00000000); |
|||
CHECK(!Double(bits).IsDenormal()); |
|||
} |
|||
|
|||
|
|||
TEST(IsSpecial) { |
|||
CHECK(Double(V8_INFINITY).IsSpecial()); |
|||
CHECK(Double(-V8_INFINITY).IsSpecial()); |
|||
CHECK(Double(OS::nan_value()).IsSpecial()); |
|||
uint64_t bits = V8_2PART_UINT64_C(0xFFF12345, 00000000); |
|||
CHECK(Double(bits).IsSpecial()); |
|||
// Denormals are not special:
|
|||
CHECK(!Double(5e-324).IsSpecial()); |
|||
CHECK(!Double(-5e-324).IsSpecial()); |
|||
// And some random numbers:
|
|||
CHECK(!Double(0.0).IsSpecial()); |
|||
CHECK(!Double(-0.0).IsSpecial()); |
|||
CHECK(!Double(1.0).IsSpecial()); |
|||
CHECK(!Double(-1.0).IsSpecial()); |
|||
CHECK(!Double(1000000.0).IsSpecial()); |
|||
CHECK(!Double(-1000000.0).IsSpecial()); |
|||
CHECK(!Double(1e23).IsSpecial()); |
|||
CHECK(!Double(-1e23).IsSpecial()); |
|||
CHECK(!Double(1.7976931348623157e308).IsSpecial()); |
|||
CHECK(!Double(-1.7976931348623157e308).IsSpecial()); |
|||
} |
|||
|
|||
|
|||
TEST(IsInfinite) { |
|||
CHECK(Double(V8_INFINITY).IsInfinite()); |
|||
CHECK(Double(-V8_INFINITY).IsInfinite()); |
|||
CHECK(!Double(OS::nan_value()).IsInfinite()); |
|||
CHECK(!Double(0.0).IsInfinite()); |
|||
CHECK(!Double(-0.0).IsInfinite()); |
|||
CHECK(!Double(1.0).IsInfinite()); |
|||
CHECK(!Double(-1.0).IsInfinite()); |
|||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|||
CHECK(!Double(min_double64).IsInfinite()); |
|||
} |
|||
|
|||
|
|||
TEST(IsNan) { |
|||
CHECK(Double(OS::nan_value()).IsNan()); |
|||
uint64_t other_nan = V8_2PART_UINT64_C(0xFFFFFFFF, 00000001); |
|||
CHECK(Double(other_nan).IsNan()); |
|||
CHECK(!Double(V8_INFINITY).IsNan()); |
|||
CHECK(!Double(-V8_INFINITY).IsNan()); |
|||
CHECK(!Double(0.0).IsNan()); |
|||
CHECK(!Double(-0.0).IsNan()); |
|||
CHECK(!Double(1.0).IsNan()); |
|||
CHECK(!Double(-1.0).IsNan()); |
|||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|||
CHECK(!Double(min_double64).IsNan()); |
|||
} |
|||
|
|||
|
|||
TEST(Sign) { |
|||
CHECK_EQ(1, Double(1.0).Sign()); |
|||
CHECK_EQ(1, Double(V8_INFINITY).Sign()); |
|||
CHECK_EQ(-1, Double(-V8_INFINITY).Sign()); |
|||
CHECK_EQ(1, Double(0.0).Sign()); |
|||
CHECK_EQ(-1, Double(-0.0).Sign()); |
|||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|||
CHECK_EQ(1, Double(min_double64).Sign()); |
|||
} |
|||
|
|||
|
|||
TEST(NormalizedBoundaries) { |
|||
DiyFp boundary_plus; |
|||
DiyFp boundary_minus; |
|||
DiyFp diy_fp = Double(1.5).AsNormalizedDiyFp(); |
|||
Double(1.5).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
|||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|||
// 1.5 does not have a significand of the form 2^p (for some p).
|
|||
// Therefore its boundaries are at the same distance.
|
|||
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
|||
CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
|||
|
|||
diy_fp = Double(1.0).AsNormalizedDiyFp(); |
|||
Double(1.0).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
|||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|||
// 1.0 does have a significand of the form 2^p (for some p).
|
|||
// Therefore its lower boundary is twice as close as the upper boundary.
|
|||
CHECK_GT(boundary_plus.f() - diy_fp.f(), diy_fp.f() - boundary_minus.f()); |
|||
CHECK((1 << 9) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
|||
CHECK((1 << 10) == boundary_plus.f() - diy_fp.f()); // NOLINT
|
|||
|
|||
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
|||
diy_fp = Double(min_double64).AsNormalizedDiyFp(); |
|||
Double(min_double64).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
|||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|||
// min-value does not have a significand of the form 2^p (for some p).
|
|||
// Therefore its boundaries are at the same distance.
|
|||
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
|||
// Denormals have their boundaries much closer.
|
|||
CHECK((static_cast<uint64_t>(1) << 62) == |
|||
diy_fp.f() - boundary_minus.f()); // NOLINT
|
|||
|
|||
uint64_t smallest_normal64 = V8_2PART_UINT64_C(0x00100000, 00000000); |
|||
diy_fp = Double(smallest_normal64).AsNormalizedDiyFp(); |
|||
Double(smallest_normal64).NormalizedBoundaries(&boundary_minus, |
|||
&boundary_plus); |
|||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|||
// Even though the significand is of the form 2^p (for some p), its boundaries
|
|||
// are at the same distance. (This is the only exception).
|
|||
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
|||
CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
|||
|
|||
uint64_t largest_denormal64 = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
|||
diy_fp = Double(largest_denormal64).AsNormalizedDiyFp(); |
|||
Double(largest_denormal64).NormalizedBoundaries(&boundary_minus, |
|||
&boundary_plus); |
|||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|||
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
|||
CHECK((1 << 11) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
|||
|
|||
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
|||
diy_fp = Double(max_double64).AsNormalizedDiyFp(); |
|||
Double(max_double64).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
|||
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
|||
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
|||
// max-value does not have a significand of the form 2^p (for some p).
|
|||
// Therefore its boundaries are at the same distance.
|
|||
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
|||
CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
|||
} |
|||
@ -0,0 +1,116 @@ |
|||
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
|||
|
|||
#include <stdlib.h> |
|||
|
|||
#include "v8.h" |
|||
|
|||
#include "platform.h" |
|||
#include "cctest.h" |
|||
#include "diy_fp.h" |
|||
#include "double.h" |
|||
#include "gay_shortest.h" |
|||
#include "grisu3.h" |
|||
|
|||
using namespace v8::internal; |
|||
|
|||
static const int kBufferSize = 100; |
|||
|
|||
TEST(GrisuVariousDoubles) { |
|||
char buffer[kBufferSize]; |
|||
int sign; |
|||
int length; |
|||
int point; |
|||
int status; |
|||
|
|||
double min_double = 5e-324; |
|||
status = grisu3(min_double, buffer, &sign, &length, &point); |
|||
CHECK(status); |
|||
CHECK_EQ(0, sign); |
|||
CHECK_EQ("5", buffer); |
|||
CHECK_EQ(-323, point); |
|||
|
|||
double max_double = 1.7976931348623157e308; |
|||
status = grisu3(max_double, buffer, &sign, &length, &point); |
|||
CHECK(status); |
|||
CHECK_EQ(0, sign); |
|||
CHECK_EQ("17976931348623157", buffer); |
|||
CHECK_EQ(309, point); |
|||
|
|||
status = grisu3(4294967272.0, buffer, &sign, &length, &point); |
|||
CHECK(status); |
|||
CHECK_EQ(0, sign); |
|||
CHECK_EQ("4294967272", buffer); |
|||
CHECK_EQ(10, point); |
|||
|
|||
status = grisu3(4.1855804968213567e298, buffer, &sign, &length, &point); |
|||
CHECK(status); |
|||
CHECK_EQ(0, sign); |
|||
CHECK_EQ("4185580496821357", buffer); |
|||
CHECK_EQ(299, point); |
|||
|
|||
status = grisu3(5.5626846462680035e-309, buffer, &sign, &length, &point); |
|||
CHECK(status); |
|||
CHECK_EQ(0, sign); |
|||
CHECK_EQ("5562684646268003", buffer); |
|||
CHECK_EQ(-308, point); |
|||
|
|||
status = grisu3(2147483648.0, buffer, &sign, &length, &point); |
|||
CHECK(status); |
|||
CHECK_EQ(0, sign); |
|||
CHECK_EQ("2147483648", buffer); |
|||
CHECK_EQ(10, point); |
|||
|
|||
status = grisu3(3.5844466002796428e+298, buffer, &sign, &length, &point); |
|||
if (status) { // Not all grisu3 variants manage to compute this number.
|
|||
CHECK_EQ("35844466002796428", buffer); |
|||
CHECK_EQ(0, sign); |
|||
CHECK_EQ(299, point); |
|||
} |
|||
|
|||
uint64_t smallest_normal64 = V8_2PART_UINT64_C(0x00100000, 00000000); |
|||
double v = Double(smallest_normal64).value(); |
|||
status = grisu3(v, buffer, &sign, &length, &point); |
|||
if (status) { |
|||
CHECK_EQ(0, sign); |
|||
CHECK_EQ("22250738585072014", buffer); |
|||
CHECK_EQ(-307, point); |
|||
} |
|||
|
|||
uint64_t largest_denormal64 = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
|||
v = Double(largest_denormal64).value(); |
|||
status = grisu3(v, buffer, &sign, &length, &point); |
|||
if (status) { |
|||
CHECK_EQ(0, sign); |
|||
CHECK_EQ("2225073858507201", buffer); |
|||
CHECK_EQ(-307, point); |
|||
} |
|||
} |
|||
|
|||
|
|||
TEST(GrisuGayShortest) { |
|||
char buffer[kBufferSize]; |
|||
bool status; |
|||
int sign; |
|||
int length; |
|||
int point; |
|||
int succeeded = 0; |
|||
int total = 0; |
|||
bool needed_max_length = false; |
|||
|
|||
Vector<const GayShortest> precomputed = PrecomputedShortestRepresentations(); |
|||
for (int i = 0; i < precomputed.length(); ++i) { |
|||
const GayShortest current_test = precomputed[i]; |
|||
total++; |
|||
double v = current_test.v; |
|||
status = grisu3(v, buffer, &sign, &length, &point); |
|||
CHECK_GE(kGrisu3MaximalLength, length); |
|||
if (!status) continue; |
|||
if (length == kGrisu3MaximalLength) needed_max_length = true; |
|||
succeeded++; |
|||
CHECK_EQ(0, sign); // All precomputed numbers are positive.
|
|||
CHECK_EQ(current_test.decimal_point, point); |
|||
CHECK_EQ(current_test.representation, buffer); |
|||
} |
|||
CHECK_GT(succeeded*1.0/total, 0.99); |
|||
CHECK(needed_max_length); |
|||
} |
|||
@ -0,0 +1,48 @@ |
|||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|||
// Redistribution and use in source and binary forms, with or without
|
|||
// modification, are permitted provided that the following conditions are
|
|||
// met:
|
|||
//
|
|||
// * Redistributions of source code must retain the above copyright
|
|||
// notice, this list of conditions and the following disclaimer.
|
|||
// * Redistributions in binary form must reproduce the above
|
|||
// copyright notice, this list of conditions and the following
|
|||
// disclaimer in the documentation and/or other materials provided
|
|||
// with the distribution.
|
|||
// * Neither the name of Google Inc. nor the names of its
|
|||
// contributors may be used to endorse or promote products derived
|
|||
// from this software without specific prior written permission.
|
|||
//
|
|||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|||
// Test Math.sin and Math.abs.
|
|||
|
|||
assertEquals(1, Math.abs(1)); // Positive SMI.
|
|||
assertEquals(1, Math.abs(-1)); // Negative SMI.
|
|||
assertEquals(0.5, Math.abs(0.5)); // Positive double.
|
|||
assertEquals(0.5, Math.abs(-0.5)); // Negative double.
|
|||
assertEquals('Infinity', Math.abs(Number('+Infinity').toString())); |
|||
assertEquals('Infinity', Math.abs(Number('-Infinity').toString())); |
|||
assertEquals('NaN', Math.abs(NaN).toString()); |
|||
assertEquals('NaN', Math.abs(-NaN).toString()); |
|||
|
|||
var minusZero = 1 / (-1 / 0); |
|||
function isMinusZero(x) { |
|||
return x === 0 && 1 / x < 0; |
|||
} |
|||
|
|||
assertTrue(!isMinusZero(0)); |
|||
assertTrue(isMinusZero(minusZero)); |
|||
assertEquals(0, Math.abs(minusZero)); |
|||
assertTrue(!isMinusZero(Math.abs(minusZero))); |
|||
assertTrue(!isMinusZero(Math.abs(0.0))); |
|||
@ -0,0 +1,61 @@ |
|||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|||
// Redistribution and use in source and binary forms, with or without
|
|||
// modification, are permitted provided that the following conditions are
|
|||
// met:
|
|||
//
|
|||
// * Redistributions of source code must retain the above copyright
|
|||
// notice, this list of conditions and the following disclaimer.
|
|||
// * Redistributions in binary form must reproduce the above
|
|||
// copyright notice, this list of conditions and the following
|
|||
// disclaimer in the documentation and/or other materials provided
|
|||
// with the distribution.
|
|||
// * Neither the name of Google Inc. nor the names of its
|
|||
// contributors may be used to endorse or promote products derived
|
|||
// from this software without specific prior written permission.
|
|||
//
|
|||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|||
// Check pops with various number of arguments.
|
|||
(function() { |
|||
var a = []; |
|||
for (var i = 0; i < 7; i++) { |
|||
a = [7, 6, 5, 4, 3, 2, 1]; |
|||
|
|||
assertEquals(1, a.pop(), "1st pop"); |
|||
assertEquals(6, a.length, "length 1st pop"); |
|||
|
|||
assertEquals(2, a.pop(1), "2nd pop"); |
|||
assertEquals(5, a.length, "length 2nd pop"); |
|||
|
|||
assertEquals(3, a.pop(1, 2), "3rd pop"); |
|||
assertEquals(4, a.length, "length 3rd pop"); |
|||
|
|||
assertEquals(4, a.pop(1, 2, 3), "4th pop"); |
|||
assertEquals(3, a.length, "length 4th pop"); |
|||
|
|||
assertEquals(5, a.pop(), "5th pop"); |
|||
assertEquals(2, a.length, "length 5th pop"); |
|||
|
|||
assertEquals(6, a.pop(), "6th pop"); |
|||
assertEquals(1, a.length, "length 6th pop"); |
|||
|
|||
assertEquals(7, a.pop(), "7th pop"); |
|||
assertEquals(0, a.length, "length 7th pop"); |
|||
|
|||
assertEquals(undefined, a.pop(), "8th pop"); |
|||
assertEquals(0, a.length, "length 8th pop"); |
|||
|
|||
assertEquals(undefined, a.pop(1, 2, 3), "9th pop"); |
|||
assertEquals(0, a.length, "length 9th pop"); |
|||
} |
|||
})(); |
|||
@ -0,0 +1,68 @@ |
|||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|||
// Redistribution and use in source and binary forms, with or without
|
|||
// modification, are permitted provided that the following conditions are
|
|||
// met:
|
|||
//
|
|||
// * Redistributions of source code must retain the above copyright
|
|||
// notice, this list of conditions and the following disclaimer.
|
|||
// * Redistributions in binary form must reproduce the above
|
|||
// copyright notice, this list of conditions and the following
|
|||
// disclaimer in the documentation and/or other materials provided
|
|||
// with the distribution.
|
|||
// * Neither the name of Google Inc. nor the names of its
|
|||
// contributors may be used to endorse or promote products derived
|
|||
// from this software without specific prior written permission.
|
|||
//
|
|||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|||
// Check pushes with various number of arguments.
|
|||
(function() { |
|||
var a = []; |
|||
for (var i = 0; i < 7; i++) { |
|||
a = []; |
|||
|
|||
assertEquals(0, a.push()); |
|||
assertEquals([], a, "after .push()"); |
|||
|
|||
assertEquals(1, a.push(1), "length after .push(1)"); |
|||
assertEquals([1], a, "after .push(1)"); |
|||
|
|||
assertEquals(3, a.push(2, 3), "length after .push(2, 3)"); |
|||
assertEquals([1, 2, 3], a, "after .push(2, 3)"); |
|||
|
|||
assertEquals(6, a.push(4, 5, 6), |
|||
"length after .push(4, 5, 6)"); |
|||
assertEquals([1, 2, 3, 4, 5, 6], a, |
|||
"after .push(4, 5, 5)"); |
|||
|
|||
assertEquals(10, a.push(7, 8, 9, 10), |
|||
"length after .push(7, 8, 9, 10)"); |
|||
assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], a, |
|||
"after .push(7, 8, 9, 10)"); |
|||
|
|||
assertEquals(15, a.push(11, 12, 13, 14, 15), |
|||
"length after .push(11, 12, 13, 14, 15)"); |
|||
assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], a, |
|||
"after .push(11, 12, 13, 14, 15)"); |
|||
|
|||
assertEquals(21, a.push(16, 17, 18, 19, 20, 21), |
|||
"length after .push(16, 17, 18, 19, 20, 21)"); |
|||
assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21], a, |
|||
"after .push(16, 17, 18, 19, 20, 21)"); |
|||
|
|||
assertEquals(28, a.push(22, 23, 24, 25, 26, 27, 28), |
|||
"length hafter .push(22, 23, 24, 25, 26, 27, 28)"); |
|||
assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], a, |
|||
"after .push(22, 23, 24, 25, 26, 27, 28)"); |
|||
} |
|||
})(); |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue