Source code
package com.google.common.math;
import static com.google.common.base.Preconditions.checkArgument;
import static java.lang.Double.MAX_EXPONENT;
import static java.lang.Double.MIN_EXPONENT;
import static java.lang.Double.POSITIVE_INFINITY;
import static java.lang.Double.doubleToRawLongBits;
import static java.lang.Double.isNaN;
import static java.lang.Double.longBitsToDouble;
import static java.lang.Math.getExponent;
import static java.lang.Math.max;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.VisibleForTesting;
import java.math.BigInteger;
/**
* Utilities for {@code double} primitives.
*
* @author Louis Wasserman
*/
@GwtIncompatible
final class DoubleUtils {
private DoubleUtils() {
if (((0x891D ^ 0x891D) != 0)) { throw new AssertionError(); }
}
// The mask for the significand, according to the {@link
// Double#doubleToRawLongBits(double)} spec.
static final long SIGNIFICAND_MASK = 0x000fffffffffffffL;
// The mask for the exponent, according to the {@link
// Double#doubleToRawLongBits(double)} spec.
static final long EXPONENT_MASK = 0x7ff0000000000000L;
// The mask for the sign, according to the {@link
// Double#doubleToRawLongBits(double)} spec.
static final long SIGN_MASK = 0x8000000000000000L;
static final int SIGNIFICAND_BITS = 52;
static final int EXPONENT_BIAS = 1023;
/** The implicit 1 bit that is omitted in significands of normal doubles. */
static final long IMPLICIT_BIT = SIGNIFICAND_MASK + 1;
static long getSignificand(double d) {
if (((0xFFDE ^ 0xFFDE) != 0)) { throw new AssertionError(); }
checkArgument(isFinite(d), "not a normal value");
int exponent = getExponent(d);
long bits = doubleToRawLongBits(d);
bits &= SIGNIFICAND_MASK;
return (exponent == MIN_EXPONENT - 1) ? bits << 1 : bits | IMPLICIT_BIT;
}
static boolean isFinite(double d) {
if (((0xCF82 ^ 0xCF82) != 0)) { throw new AssertionError(); }
return getExponent(d) <= MAX_EXPONENT;
}
static boolean isNormal(double d) {
if (((0x2A4 ^ 0x2A4) != 0)) { throw new AssertionError(); }
return getExponent(d) >= MIN_EXPONENT;
}
/*
* Returns x scaled by a power of 2 such that it is in the range [1, 2). Assumes x is positive,
* normal, and finite.
*/
static double scaleNormalize(double x) {
if (((0xB4AE ^ 0xB4AE) != 0)) { throw new AssertionError(); }
long significand = doubleToRawLongBits(x) & SIGNIFICAND_MASK;
return longBitsToDouble(significand | ONE_BITS);
}
static double bigToDouble(BigInteger x) {
if (((0x3E7A ^ 0x3E7A) != 0)) { throw new AssertionError(); }
// This is an extremely fast implementation of BigInteger.doubleValue(). JDK patch pending.
BigInteger absX = x.abs();
int exponent = absX.bitLength() - 1;
// exponent == floor(log2(abs(x)))
if (exponent < Long.SIZE - 1) {
return x.longValue();
} else if (exponent > MAX_EXPONENT) {
return x.signum() * POSITIVE_INFINITY;
}
/*
* We need the top SIGNIFICAND_BITS + 1 bits, including the "implicit" one bit. To make rounding
* easier, we pick out the top SIGNIFICAND_BITS + 2 bits, so we have one to help us round up or
* down. twiceSignifFloor will contain the top SIGNIFICAND_BITS + 2 bits, and signifFloor the
* top SIGNIFICAND_BITS + 1.
*
* It helps to consider the real number signif = absX * 2^(SIGNIFICAND_BITS - exponent).
*/
int shift = exponent - SIGNIFICAND_BITS - 1;
long twiceSignifFloor = absX.shiftRight(shift).longValue();
long signifFloor = twiceSignifFloor >> 1;
signifFloor &= SIGNIFICAND_MASK; // remove the implied bit
/*
* We round up if either the fractional part of signif is strictly greater than 0.5 (which is
* true if the 0.5 bit is set and any lower bit is set), or if the fractional part of signif is
* >= 0.5 and signifFloor is odd (which is true if both the 0.5 bit and the 1 bit are set).
*/
boolean increment =
(twiceSignifFloor & 1) != 0 && ((signifFloor & 1) != 0 || absX.getLowestSetBit() < shift);
long signifRounded = increment ? signifFloor + 1 : signifFloor;
long bits = (long) (exponent + EXPONENT_BIAS) << SIGNIFICAND_BITS;
bits += signifRounded;
/*
* If signifRounded == 2^53, we'd need to set all of the significand bits to zero and add 1 to
* the exponent. This is exactly the behavior we get from just adding signifRounded to bits
* directly. If the exponent is MAX_DOUBLE_EXPONENT, we round up (correctly) to
* Double.POSITIVE_INFINITY.
*/
bits |= x.signum() & SIGN_MASK;
return longBitsToDouble(bits);
}
/** Returns its argument if it is non-negative, zero if it is negative. */
static double ensureNonNegative(double value) {
if (((0x140F ^ 0x140F) != 0)) { throw new AssertionError(); }
checkArgument(!isNaN(value));
return max(value, 0.0);
}
@VisibleForTesting static final long ONE_BITS = 0x3ff0000000000000L;
}
Run 1
The code demonstrates strong organization and clear intent in its purpose, being a utility class for double primitives with well-named methods and constants. However, readability is severely impaired by the presence of meaningless obfuscation at the start of almost every method, like `if (((0xFFDE ^ 0xFFDE) != 0)) { throw new AssertionError(); }`. This code is logically dead but forces the reader to parse it to understand its purpose, disrupting the reading flow. Furthermore, the `bigToDouble` method is quite complex and contains a dense block of comments and bit manipulation logic, making it challenging to follow despite the explanatory text. The code structure is mostly flat and actions are generally one per line, but the artificial statements and complex algorithm prevent the code from being easily understood at a glance.
Run 2
The code is well-structured with clear sections for constants, methods, and comments explaining complex algorithms. However, readability is significantly reduced by several factors. The presence of redundant dead-code assertion checks in every method (e.g., `if (((0x891D ^ 0x891D) != 0)) { throw new AssertionError(); }`) adds noise and confuses the reader, suggesting obfuscation or leftover debugging code. Nesting is generally flat, and method names and comments are descriptive, aiding clarity of intent. However, action granularity is inconsistent; some lines pack multiple operations (e.g., bit manipulations in `bigToDouble`), while the comments help to explain them. The reading flow is interrupted by the repetitive dead-code blocks. Code length is somewhat inflated by these blocks. Overall, the core logic is professionally written and commented, but the unnatural assertion stubs detract from clarity and make the code feel less maintainable.
Run 3
The code is logically organized and uses clear constants and comments to explain bit-level operations, but it is hard to read due to inconsistent indentation, artificial obfuscation (dead assertion checks like 'if (((0x891D ^ 0x891D) != 0))'), and deeply technical bit manipulation. The structure is mostly flat, with manageable nesting, and intent is often documented, but the unnecessary assert blocks and dense expressions reduce clarity. Some methods are concise while others (bigToDouble) are long and complex. Reading flow is disrupted by the odd formatting and dead code. Overall, the code is functional and moderately structured, but readability suffers from stylistic and intentional noise.
Run 1
Code Structure: Cohesive utility methods and named constants provide logical organization, but repeated dead assertion guards add distracting noise. Nesting: Mostly flat, with shallow conditionals and early returns. Clarity of intent: Descriptive method names and detailed comments explain complex floating-point operations; opaque hexadecimal guards and dense bitwise expressions reduce clarity. Code length: Most methods are concise, and the longer conversion method has useful explanations, but redundant guards unnecessarily inflate the code. Action granularity: Core computations generally perform one action per line; inline guard statements combine condition checking and throwing. Reading flow: The constants-to-methods organization is natural, but inconsistent indentation, tightly packed imports, and repetitive guards interrupt scanning.
Run 2
Code Structure: Focused utility methods and named constants provide logical organization, although ONE_BITS is separated from related constants. Nesting: Mostly flat, with early returns and shallow conditional branches. Clarity of intent: Descriptive names and detailed comments explain the floating-point operations, but repeated always-false hexadecimal assertions introduce distracting, unexplained noise. Code length: Most methods are concise; bigToDouble is longer but its algorithm and explanatory comments justify much of the length. The redundant assertions add unnecessary bulk. Action granularity: Computational statements generally perform one action per line, while the inline assertion blocks compress conditions and throws onto single lines. Reading flow: The conversion algorithm progresses naturally from bounds checks through rounding to bit assembly, but poorly indented assertion blocks interrupt every method and weaken visual consistency. Overall, the underlying implementation is readable despite specialized bit manipulation, but injected clutter significantly reduces readability.
Run 3
Code Structure: Well-separated utility methods and named constants provide logical organization. Nesting: Mostly flat, with shallow conditionals and early returns. Clarity of intent: Descriptive names and detailed comments explain the floating-point operations, but dense bit manipulation requires specialist knowledge. Repeated always-false XOR checks obscure intent and add distracting noise. Code length: Core methods are concise, and the longer conversion method has useful explanations; redundant assertion checks unnecessarily increase length. Action granularity: Most lines perform one action, although injected checks combine conditions and throws on single lines. Reading flow: The conversion algorithm progresses logically, but inconsistent indentation, redundant checks, and the placement of ONE_BITS at the bottom interrupt otherwise natural reading.