package java.lang; import ej.annotation.Nullable; /** * The {@code Double} class wraps a value of the primitive type {@code double} in an object. An * object of type {@code Double} contains a single field whose type is {@code double}. * *

* In addition, this class provides several methods for converting a {@code double} to a * {@code String} and a {@code String} to a {@code double}, as well as other constants and methods * useful when dealing with a {@code double}. */ public final class Double extends Number implements Comparable { /** * Maximum exponent a finite {@code double} variable may have. It is equal to the value returned by * {@code Math.getExponent(Double.MAX_VALUE)}. */ public static final int MAX_EXPONENT = 1023; /** * A constant holding the largest positive finite value of type {@code double}, * (2-2-52)·21023. It is equal to the hexadecimal floating-point * literal {@code 0x1.fffffffffffffP+1023} and also equal to * {@code Double.longBitsToDouble(0x7fefffffffffffffL)}. */ public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; /** * Minimum exponent a normalized {@code double} variable may have. It is equal to the value returned * by {@code Math.getExponent(Double.MIN_NORMAL)}. */ public static final int MIN_EXPONENT = -1022; /** * A constant holding the smallest positive normal value of type {@code double}, 2-1022. * It is equal to the hexadecimal floating-point literal {@code 0x1.0p-1022} and also equal to * {@code Double.longBitsToDouble(0x0010000000000000L)}. */ public static final double MIN_NORMAL = 0x1.0p-1022; /** * A constant holding the smallest positive nonzero value of type {@code double}, 2-1074. * It is equal to the hexadecimal floating-point literal {@code 0x0.0000000000001P-1022} and also * equal to {@code Double.longBitsToDouble(0x1L)}. */ public static final double MIN_VALUE = 0x0.0000000000001P-1022; /** * A constant holding a Not-a-Number (NaN) value of type {@code double}. It is equivalent to the * value returned by {@code Double.longBitsToDouble(0x7ff8000000000000L)}. */ public static final double NaN = 0.0d / 0.0; /** * A constant holding the negative infinity of type {@code double}. It is equal to the value * returned by {@code Double.longBitsToDouble(0xfff0000000000000L)}. */ public static final double NEGATIVE_INFINITY = -1.0 / 0.0; /** * A constant holding the positive infinity of type {@code double}. It is equal to the value * returned by {@code Double.longBitsToDouble(0x7ff0000000000000L)}. */ public static final double POSITIVE_INFINITY = 1.0 / 0.0; /** * The number of bits used to represent a {@code double} value. */ public static final int SIZE = 64; /** * Constructs a newly allocated {@code Double} object that represents the primitive {@code double} * argument. * * @param value * the value to be represented by the {@code Double}. */ public Double(double value) { throw new RuntimeException(); } /** * Constructs a newly allocated {@code Double} object that represents the floating-point value of * type {@code double} represented by the string. The string is converted to a {@code double} value * as if by the {@code valueOf} method. * * @param s * a string to be converted to a {@code Double}. * @throws NumberFormatException * if the string does not contain a parsable number. * @see java.lang.Double#valueOf(java.lang.String) */ public Double(String s) throws NumberFormatException { throw new RuntimeException(); } /** * Returns the value of this {@code Double} as a {@code byte} (by casting to a {@code byte}). * * @return the {@code double} value represented by this object converted to type {@code byte} */ @Override public byte byteValue() { throw new RuntimeException(); } /** * Compares the two specified {@code double} values. The sign of the integer value returned is the * same as that of the integer that would be returned by the call: * * 

     * new Double(d1).compareTo(new Double(d2))
     *
* * @param d1 * the first {@code double} to compare * @param d2 * the second {@code double} to compare * @return the value {@code 0} if {@code d1} is numerically equal to {@code d2}; a value less than * {@code 0} if {@code d1} is numerically less than {@code d2}; and a value greater than * {@code 0} if {@code d1} is numerically greater than {@code d2}. */ public static int compare(double d1, double d2) { throw new RuntimeException(); } /** * Returns a representation of the specified floating-point value according to the IEEE 754 * floating-point "double format" bit layout. * *

* Bit 63 (the bit that is selected by the mask {@code 0x8000000000000000L}) represents the sign of * the floating-point number. Bits 62-52 (the bits that are selected by the mask * {@code 0x7ff0000000000000L}) represent the exponent. Bits 51-0 (the bits that are selected by the * mask {@code 0x000fffffffffffffL}) represent the significand (sometimes called the mantissa) of * the floating-point number. * *

* If the argument is positive infinity, the result is {@code 0x7ff0000000000000L}. * *

* If the argument is negative infinity, the result is {@code 0xfff0000000000000L}. * *

* If the argument is NaN, the result is {@code 0x7ff8000000000000L}. * *

* In all cases, the result is a {@code long} integer that, when given to the * {@link #longBitsToDouble(long)} method, will produce a floating-point value the same as the * argument to {@code doubleToLongBits} (except all NaN values are collapsed to a single "canonical" * NaN value). * * @param value * a {@code double} precision floating-point number. * @return the bits that represent the floating-point number. */ public static long doubleToLongBits(double value) { throw new RuntimeException(); } /** * Returns a representation of the specified floating-point value according to the IEEE 754 * floating-point "double format" bit layout, preserving Not-a-Number (NaN) values. * *

* Bit 63 (the bit that is selected by the mask {@code 0x8000000000000000L}) represents the sign of * the floating-point number. Bits 62-52 (the bits that are selected by the mask * {@code 0x7ff0000000000000L}) represent the exponent. Bits 51-0 (the bits that are selected by the * mask {@code 0x000fffffffffffffL}) represent the significand (sometimes called the mantissa) of * the floating-point number. * *

* If the argument is positive infinity, the result is {@code 0x7ff0000000000000L}. * *

* If the argument is negative infinity, the result is {@code 0xfff0000000000000L}. * *

* If the argument is NaN, the result is the {@code long} integer representing the actual NaN value. * Unlike the {@code doubleToLongBits} method, {@code doubleToRawLongBits} does not collapse all the * bit patterns encoding a NaN to a single "canonical" NaN value. * *

* In all cases, the result is a {@code long} integer that, when given to the * {@link #longBitsToDouble(long)} method, will produce a floating-point value the same as the * argument to {@code doubleToRawLongBits}. * * @param value * a {@code double} precision floating-point number. * @return the bits that represent the floating-point number. */ public static long doubleToRawLongBits(double value) { throw new RuntimeException(); } /** * Returns {@code true} if the specified number is infinitely large in magnitude, {@code false} * otherwise. * * @param v * the value to be tested. * @return {@code true} if the value of the argument is positive infinity or negative infinity; * {@code false} otherwise. */ public static boolean isInfinite(double v) { throw new RuntimeException(); } /** * Returns {@code true} if the specified number is a Not-a-Number (NaN) value, {@code false} * otherwise. * * @param v * the value to be tested. * @return {@code true} if the value of the argument is NaN; {@code false} otherwise. */ public static boolean isNaN(double v) { throw new RuntimeException(); } /** * Returns the {@code double} value corresponding to a given bit representation. The argument is * considered to be a representation of a floating-point value according to the IEEE 754 * floating-point "double format" bit layout. * *

* If the argument is {@code 0x7ff0000000000000L}, the result is positive infinity. * *

* If the argument is {@code 0xfff0000000000000L}, the result is negative infinity. * *

* If the argument is any value in the range {@code 0x7ff0000000000001L} through * {@code 0x7fffffffffffffffL} or in the range {@code 0xfff0000000000001L} through * {@code 0xffffffffffffffffL}, the result is a NaN. No IEEE 754 floating-point operation provided * by Java can distinguish between two NaN values of the same type with different bit patterns. * Distinct values of NaN are only distinguishable by use of the {@code Double.doubleToRawLongBits} * method. * *

* In all other cases, let s, e, and m be three values that can be computed * from the argument: * *

* * 
     * int s = ((bits >> 63) == 0) ? 1 : -1;
     * int e = (int) ((bits >> 52) & 0x7ffL);
     * long m = (e == 0) ? (bits & 0xfffffffffffffL) << 1 : (bits & 0xfffffffffffffL) | 0x10000000000000L;
     *
* *
* * Then the floating-point result equals the value of the mathematical expression * s·m·2e-1075. * *

* Note that this method may not be able to return a {@code double} NaN with exactly same bit * pattern as the {@code long} argument. IEEE 754 distinguishes between two kinds of NaNs, quiet * NaNs and signaling NaNs. The differences between the two kinds of NaN are generally not * visible in Java. Arithmetic operations on signaling NaNs turn them into quiet NaNs with a * different, but often similar, bit pattern. However, on some processors merely copying a signaling * NaN also performs that conversion. In particular, copying a signaling NaN to return it to the * calling method may perform this conversion. So {@code longBitsToDouble} may not be able to return * a {@code double} with a signaling NaN bit pattern. Consequently, for some {@code long} values, * {@code doubleToRawLongBits(longBitsToDouble(start))} may not equal {@code start}. * Moreover, which particular bit patterns represent signaling NaNs is platform dependent; although * all NaN bit patterns, quiet or signaling, must be in the NaN range identified above. * * @param bits * any {@code long} integer. * @return the {@code double} floating-point value with the same bit pattern. */ public static double longBitsToDouble(long bits) { throw new RuntimeException(); } /** * Returns a new {@code double} initialized to the value represented by the specified * {@code String}, as performed by the {@code valueOf} method of class {@code Double}. * * @param s * the string to be parsed. * @return the {@code double} value represented by the string argument. * @throws NullPointerException * if the string is null * @throws NumberFormatException * if the string does not contain a parsable {@code double}. * @see java.lang.Double#valueOf(String) */ public static double parseDouble(String s) throws NumberFormatException { throw new RuntimeException(); } /** * Returns a string representation of the {@code double} argument. All characters mentioned below * are ASCII characters. *

* How many digits must be printed for the fractional part of m or a? There must be at * least one digit to represent the fractional part, and beyond that as many, but only as many, more * digits as are needed to uniquely distinguish the argument value from adjacent values of type * {@code double}. That is, suppose that x is the exact mathematical value represented by the * decimal representation produced by this method for a finite nonzero argument d. Then * d must be the {@code double} value nearest to x; or if two {@code double} values * are equally close to x, then d must be one of them and the least significant bit of * the significand of d must be {@code 0}. * * @param d * the {@code double} to be converted. * @return a string representation of the argument. */ public static String toString(double d) { throw new RuntimeException(); } /** * Returns a {@code Double} instance representing the specified {@code double} value. If a new * {@code Double} instance is not required, this method should generally be used in preference to * the constructor {@link #Double(double)}, as this method is likely to yield significantly better * space and time performance by caching frequently requested values. * * @param d * a double value. * @return a {@code Double} instance representing {@code d}. */ public static Double valueOf(double d) { throw new RuntimeException(); } /** * Returns a {@code Double} object holding the {@code double} value represented by the argument * string {@code s}. * *

* If {@code s} is {@code null}, then a {@code NullPointerException} is thrown. * *

* Leading and trailing whitespace characters in {@code s} are ignored. Whitespace is removed as if * by the {@link String#trim} method; that is, both ASCII space and control characters are removed. * The rest of {@code s} should constitute a FloatValue as described by the lexical syntax * rules: * *

*
*
FloatValue: *
Signopt {@code NaN} *
Signopt {@code Infinity} *
Signopt FloatingPointLiteral *
Signopt HexFloatingPointLiteral *
SignedInteger *
* *
*
HexFloatingPointLiteral: *
HexSignificand BinaryExponent FloatTypeSuffixopt *
* *
*
HexSignificand: *
HexNumeral *
HexNumeral {@code .} *
{@code 0x} HexDigitsopt {@code .} HexDigits *
{@code 0X} HexDigitsopt {@code .} HexDigits *
* *
*
BinaryExponent: *
BinaryExponentIndicator SignedInteger *
* *
*
BinaryExponentIndicator: *
{@code p} *
{@code P} *
* *
* * where Sign, FloatingPointLiteral, HexNumeral, HexDigits, * SignedInteger and FloatTypeSuffix are as defined in the lexical structure sections * of The Java™ Language Specification, except that underscores are not accepted * between digits. If {@code s} does not have the form of a FloatValue, then a * {@code NumberFormatException} is thrown. Otherwise, {@code s} is regarded as representing an * exact decimal value in the usual "computerized scientific notation" or as an exact hexadecimal * value; this exact numerical value is then conceptually converted to an "infinitely precise" * binary value that is then rounded to type {@code double} by the usual round-to-nearest rule of * IEEE 754 floating-point arithmetic, which includes preserving the sign of a zero value. * * Note that the round-to-nearest rule also implies overflow and underflow behaviour; if the exact * value of {@code s} is large enough in magnitude (greater than or equal to ( {@link #MAX_VALUE} + * {@link Math#ulp(double) ulp(MAX_VALUE)}/2), rounding to {@code double} will result in an infinity * and if the exact value of {@code s} is small enough in magnitude (less than or equal to * {@link #MIN_VALUE}/2), rounding to float will result in a zero. * * Finally, after rounding a {@code Double} object representing this {@code double} value is * returned. * *

* Note that trailing format specifiers, specifiers that determine the type of a floating-point * literal ({@code 1.0f} is a {@code float} value; {@code 1.0d} is a {@code double} value), do * not influence the results of this method. In other words, the numerical value of the * input string is converted directly to the target floating-point type. The two-step sequence of * conversions, string to {@code float} followed by {@code float} to {@code double}, is not * equivalent to converting a string directly to {@code double}. For example, the {@code float} * literal {@code 0.1f} is equal to the {@code double} value {@code 0.10000000149011612}; the * {@code float} literal {@code 0.1f} represents a different numerical value than the {@code double} * literal {@code 0.1}. (The numerical value 0.1 cannot be exactly represented in a binary * floating-point number.) * * @param s * the string to be parsed. * @return a {@code Double} object holding the value represented by the {@code String} argument. * @throws NumberFormatException * if the string does not contain a parsable number. */ public static Double valueOf(String s) throws NumberFormatException { throw new RuntimeException(); } /** * Compares two {@code Double} objects numerically. There are two ways in which comparisons * performed by this method differ from those performed by the Java language numerical comparison * operators ({@code <, <=, ==, >=, >}) when applied to primitive {@code double} values: *

* This ensures that the natural ordering of {@code Double} objects imposed by this method is * consistent with equals. * * @param anotherDouble * the {@code Double} to be compared. * @return the value {@code 0} if {@code anotherDouble} is numerically equal to this {@code Double}; * a value less than {@code 0} if this {@code Double} is numerically less than * {@code anotherDouble}; and a value greater than {@code 0} if this {@code Double} is * numerically greater than {@code anotherDouble}. */ @Override public int compareTo(Double anotherDouble) { throw new RuntimeException(); } /** * Returns the {@code double} value of this {@code Double} object. * * @return the {@code double} value represented by this object */ @Override public double doubleValue() { throw new RuntimeException(); } /** * Compares this object against the specified object. The result is {@code true} if and only if the * argument is not {@code null} and is a {@code Double} object that represents a {@code double} that * has the same value as the {@code double} represented by this object. For this purpose, two * {@code double} values are considered to be the same if and only if the method * {@link #doubleToLongBits(double)} returns the identical {@code long} value when applied to each. * *

* Note that in most cases, for two instances of class {@code Double}, {@code d1} and {@code d2} , * the value of {@code d1.equals(d2)} is {@code true} if and only if * *

{@code d1.doubleValue() == d2.doubleValue()}
* *

* also has the value {@code true}. However, there are two exceptions: *

* This definition allows hash tables to operate properly. * * @param obj * the object to compare with. * @return {@code true} if the objects are the same; {@code false} otherwise. * @see java.lang.Double#doubleToLongBits(double) */ @Override public boolean equals(@Nullable Object obj) { throw new RuntimeException(); } /** * Returns the {@code float} value of this {@code Double} object. * * @return the {@code double} value represented by this object converted to type {@code float} */ @Override public float floatValue() { throw new RuntimeException(); } /** * Returns a hash code for this {@code Double} object. The result is the exclusive OR of the two * halves of the {@code long} integer bit representation, exactly as produced by the method * {@link #doubleToLongBits(double)}, of the primitive {@code double} value represented by this * {@code Double} object. That is, the hash code is the value of the expression: * *
{@code (int)(v^(v>>>32))}
* * where {@code v} is defined by: * *
{@code long v = Double.doubleToLongBits(this.doubleValue());}
* * @return a {@code hash code} value for this object. */ @Override public int hashCode() { throw new RuntimeException(); } /** * Returns the value of this {@code Double} as an {@code int} (by casting to type {@code int}). * * @return the {@code double} value represented by this object converted to type {@code int} */ @Override public int intValue() { throw new RuntimeException(); } /** * Returns {@code true} if this {@code Double} value is infinitely large in magnitude, {@code false} * otherwise. * * @return {@code true} if the value represented by this object is positive infinity or negative * infinity; {@code false} otherwise. */ public boolean isInfinite() { throw new RuntimeException(); } /** * Returns {@code true} if this {@code Double} value is a Not-a-Number (NaN), {@code false} * otherwise. * * @return {@code true} if the value represented by this object is NaN; {@code false} otherwise. */ public boolean isNaN() { throw new RuntimeException(); } /** * Returns the value of this {@code Double} as a {@code long} (by casting to type {@code long}). * * @return the {@code double} value represented by this object converted to type {@code long} */ @Override public long longValue() { throw new RuntimeException(); } /** * Returns the value of this {@code Double} as a {@code short} (by casting to a {@code short}). * * @return the {@code double} value represented by this object converted to type {@code short} */ @Override public short shortValue() { throw new RuntimeException(); } /** * Returns a string representation of this {@code Double} object. The primitive {@code double} value * represented by this object is converted to a string exactly as if by the method {@code toString} * of one argument. * * @return a {@code String} representation of this object. * @see java.lang.Double#toString(double) */ @Override public String toString() { throw new RuntimeException(); } }