Пример #1
0
@SuppressWarnings({
  "unchecked",
  "WeakerAccess",
  "UnnecessaryBoxing",
  "PointlessArithmeticExpression"
})
public final class Character implements java.io.Serializable, Comparable<Character> {
  public static final int MIN_RADIX = 2;
  public static final int MAX_RADIX = 36;
  public static final char MIN_VALUE = '\u0000';
  public static final char MAX_VALUE = '\uFFFF';
  public static final Class<Character> TYPE = (Class<Character>) Class.getPrimitiveClass("char");

  public static final byte UNASSIGNED = 0;
  public static final byte UPPERCASE_LETTER = 1;
  public static final byte LOWERCASE_LETTER = 2;
  public static final byte TITLECASE_LETTER = 3;
  public static final byte MODIFIER_LETTER = 4;
  public static final byte OTHER_LETTER = 5;
  public static final byte NON_SPACING_MARK = 6;
  public static final byte ENCLOSING_MARK = 7;
  public static final byte COMBINING_SPACING_MARK = 8;
  public static final byte DECIMAL_DIGIT_NUMBER = 9;
  public static final byte LETTER_NUMBER = 10;
  public static final byte OTHER_NUMBER = 11;
  public static final byte SPACE_SEPARATOR = 12;
  public static final byte LINE_SEPARATOR = 13;
  public static final byte PARAGRAPH_SEPARATOR = 14;
  public static final byte CONTROL = 15;
  public static final byte FORMAT = 16;
  public static final byte PRIVATE_USE = 18;
  public static final byte SURROGATE = 19;
  public static final byte DASH_PUNCTUATION = 20;
  public static final byte START_PUNCTUATION = 21;
  public static final byte END_PUNCTUATION = 22;
  public static final byte CONNECTOR_PUNCTUATION = 23;
  public static final byte OTHER_PUNCTUATION = 24;
  public static final byte MATH_SYMBOL = 25;
  public static final byte CURRENCY_SYMBOL = 26;
  public static final byte MODIFIER_SYMBOL = 27;
  public static final byte OTHER_SYMBOL = 28;
  public static final byte INITIAL_QUOTE_PUNCTUATION = 29;
  public static final byte FINAL_QUOTE_PUNCTUATION = 30;
  public static final byte DIRECTIONALITY_UNDEFINED = -1;
  public static final byte DIRECTIONALITY_LEFT_TO_RIGHT = 0;
  public static final byte DIRECTIONALITY_RIGHT_TO_LEFT = 1;
  public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2;
  public static final byte DIRECTIONALITY_EUROPEAN_NUMBER = 3;
  public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4;
  public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR = 5;
  public static final byte DIRECTIONALITY_ARABIC_NUMBER = 6;
  public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR = 7;
  public static final byte DIRECTIONALITY_NONSPACING_MARK = 8;
  public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL = 9;
  public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR = 10;
  public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR = 11;
  public static final byte DIRECTIONALITY_WHITESPACE = 12;
  public static final byte DIRECTIONALITY_OTHER_NEUTRALS = 13;
  public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING = 14;
  public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE = 15;
  public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING = 16;
  public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE = 17;
  public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT = 18;
  public static final char MIN_HIGH_SURROGATE = '\uD800';
  public static final char MAX_HIGH_SURROGATE = '\uDBFF';
  public static final char MIN_LOW_SURROGATE = '\uDC00';
  public static final char MAX_LOW_SURROGATE = '\uDFFF';
  public static final char MIN_SURROGATE = MIN_HIGH_SURROGATE;
  public static final char MAX_SURROGATE = MAX_LOW_SURROGATE;
  public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000;
  public static final int MIN_CODE_POINT = 0x000000;
  public static final int MAX_CODE_POINT = 0X10FFFF;

  private final char value;

  public Character(char value) {
    this.value = value;
  }

  @JTranscKeep
  public static Character valueOf(char value) {
    return new Character(value);
  }

  public char charValue() {
    return value;
  }

  @Override
  public int hashCode() {
    return value;
  }

  public static int hashCode(char value) {
    return value;
  }

  public boolean equals(Object that) {
    return that instanceof Character && this.value == ((Character) that).value;
  }

  public String toString() {
    return toString(value);
  }

  public static String toString(char value) {
    return new String(new char[] {value});
  }

  public static boolean isValidCodePoint(int cp) {
    return (cp >>> 16) < ((MAX_CODE_POINT + 1) >>> 16);
  }

  public static native boolean isBmpCodePoint(int codePoint);

  public static native boolean isSupplementaryCodePoint(int codePoint);

  public static native boolean isHighSurrogate(char ch);

  public static native boolean isLowSurrogate(char ch);

  public static boolean isSurrogate(char ch) {
    return false;
  }

  public static boolean isSurrogatePair(char high, char low) {
    return false;
  }

  public static int charCount(int codePoint) {
    return 1;
  }

  public static int toCodePoint(char high, char low) {
    return low;
  }

  public static int codePointAt(CharSequence seq, int index) {
    return seq.charAt(index);
  }

  public static int codePointAt(char[] a, int index) {
    return a[index];
  }

  public static int codePointAt(char[] a, int index, int limit) {
    return a[index];
  }

  // throws ArrayIndexOutOfBoundsException if index out of bounds
  // static int codePointAtImpl(char[] a, int index, int limit);
  public static native int codePointBefore(CharSequence seq, int index);

  public static native int codePointBefore(char[] a, int index);

  public static native int codePointBefore(char[] a, int index, int start);

  // throws ArrayIndexOutOfBoundsException if index-1 out of bounds
  // static int codePointBeforeImpl(char[] a, int index, int start);
  public static native char highSurrogate(int codePoint);

  public static native char lowSurrogate(int codePoint);

  public static int toChars(int codePoint, char[] dst, int dstIndex) {
    dst[dstIndex] = (char) codePoint;
    return 1;
  }

  public static char[] toChars(int codePoint) {
    return new char[] {(char) codePoint};
  }

  // static void toSurrogates(int codePoint, char[] dst, int index);
  public static int codePointCount(CharSequence seq, int beginIndex, int endIndex) {
    return endIndex + beginIndex;
  }

  public static int codePointCount(char[] a, int offset, int count) {
    return count;
  }

  // static int codePointCountImpl(char[] a, int offset, int count);
  public static native int offsetByCodePoints(CharSequence seq, int index, int codePointOffset);

  public static native int offsetByCodePoints(
      char[] a, int start, int count, int index, int codePointOffset);

  // native static int offsetByCodePointsImpl(char[] a, int start, int count, int index, int
  // codePointOffset);
  public static boolean isLowerCase(char ch) {
    return toLowerCase(ch) == ch;
  }

  public static boolean isLowerCase(int codePoint) {
    return toLowerCase(codePoint) == codePoint;
  }

  public static boolean isUpperCase(char ch) {
    return toUpperCase(ch) == ch;
  }

  public static boolean isUpperCase(int codePoint) {
    return toUpperCase(codePoint) == codePoint;
  }

  public static native boolean isTitleCase(char ch);

  public static native boolean isTitleCase(int codePoint);

  @JTranscMethodBody(target = "js", value = "return p0 >= 48 && p0 <= 57;")
  public static boolean isDigit(char ch) {
    return (ch >= '0') && (ch <= '9');
  }

  public static boolean isDigit(int codePoint) {
    return isDigit((char) codePoint);
  }

  public static native boolean isDefined(char ch);

  public static native boolean isDefined(int codePoint);

  public static boolean isLetter(char ch) {
    return ((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z'));
  }

  public static boolean isLetter(int codePoint) {
    return isLetter((char) codePoint);
  }

  public static boolean isLetterOrDigit(char ch) {
    return isLetter(ch) || isDigit(ch);
  }

  public static boolean isLetterOrDigit(int codePoint) {
    return isLetter(codePoint) || isDigit(codePoint);
  }

  @Deprecated
  public static boolean isJavaLetter(char ch) {
    return isLetter(ch);
  }

  @Deprecated
  public static boolean isJavaLetterOrDigit(char ch) {
    return isLetter(ch) || isDigit(ch);
  }

  public static boolean isAlphabetic(int codePoint) {
    return isLetter(codePoint);
  }

  public static native boolean isIdeographic(int codePoint);

  public static boolean isJavaIdentifierStart(char ch) {
    return isLetter(ch) || ch == '_';
  }

  public static boolean isJavaIdentifierStart(int codePoint) {
    return isJavaIdentifierStart((char) codePoint);
  }

  public static boolean isJavaIdentifierPart(char ch) {
    return isLetter(ch) || isDigit(ch) || ch == '_';
  }

  public static boolean isJavaIdentifierPart(int codePoint) {
    return isJavaIdentifierPart((char) codePoint);
  }

  public static native boolean isUnicodeIdentifierStart(char ch);

  public static native boolean isUnicodeIdentifierStart(int codePoint);

  public static native boolean isUnicodeIdentifierPart(char ch);

  public static native boolean isUnicodeIdentifierPart(int codePoint);

  public static native boolean isIdentifierIgnorable(char ch);

  public static native boolean isIdentifierIgnorable(int codePoint);

  public static char toLowerCase(char ch) {
    return (char) toLowerCase((int) ch);
  }

  public static char toUpperCase(char ch) {
    return (char) toUpperCase((int) ch);
  }

  @HaxeMethodBody("return String.fromCharCode(p0).toLowerCase().charCodeAt(0);")
  @JTranscMethodBody(
      target = "js",
      value = "return String.fromCharCode(p0).toLowerCase().charCodeAt(0);")
  public static int toLowerCase(int codePoint) {
    if (codePoint >= 'A' && codePoint < 'Z') return (codePoint - 'A') + 'a';
    return codePoint;
  }

  @HaxeMethodBody("return String.fromCharCode(p0).toUpperCase().charCodeAt(0);")
  @JTranscMethodBody(
      target = "js",
      value = "return String.fromCharCode(p0).toUpperCase().charCodeAt(0);")
  public static int toUpperCase(int codePoint) {
    if (codePoint >= 'a' && codePoint < 'z') return (codePoint - 'a') + 'A';
    return codePoint;
  }

  public static char toTitleCase(char ch) {
    // @TODO: Approximation
    return toUpperCase(ch);
  }

  public static int toTitleCase(int codePoint) {
    return toTitleCase((char) codePoint);
  }

  public static int digit(char ch, int radix) {
    if (ch >= '0' && ch <= '9') return ch - '0';
    if (ch >= 'a' && ch <= 'z') return (ch - 'a') + 10;
    if (ch >= 'A' && ch <= 'Z') return (ch - 'A') + 10;
    return -1;
  }

  public static int digit(int codePoint, int radix) {
    return digit((char) codePoint, radix);
  }

  public static int getNumericValue(char ch) {
    return digit(ch, 10);
  }

  public static int getNumericValue(int codePoint) {
    return digit(codePoint, 10);
  }

  @Deprecated
  public static boolean isSpace(char value) {
    return (value <= 0x0020)
        && (((((1L << 0x0009) | (1L << 0x000A) | (1L << 0x000C) | (1L << 0x000D) | (1L << 0x0020))
                    >> value)
                & 1L)
            != 0);
  }

  public static boolean isSpaceChar(char ch) {
    return isSpaceChar((int) ch);
  }

  public static boolean isSpaceChar(int codePoint) {
    switch (codePoint) {
      case 0x0020:
      case 0x00A0:
      case 0x1680:
      case 0x180E:
      case 0x2000:
      case 0x2001:
      case 0x2002:
      case 0x2003:
      case 0x2004:
      case 0x2005:
      case 0x2006:
      case 0x2007:
      case 0x2008:
      case 0x2009:
      case 0x200A:
      case 0x200B:
      case 0x202F:
      case 0x205F:
      case 0x3000:
      case 0xFEFF:
        return true;
    }
    return false;
  }

  public static boolean isWhitespace(char ch) {
    return isWhitespace((int) ch);
  }

  public static boolean isWhitespace(int codePoint) {
    switch (codePoint) {
      case 9:
      case 10:
      case 11:
      case 12:
      case 13:
      case 28:
      case 29:
      case 30:
      case 31:
      case 32:
      case 5760:
      case 6158:
      case 8192:
      case 8193:
      case 8194:
      case 8195:
      case 8196:
      case 8197:
      case 8198:
      case 8200:
      case 8201:
      case 8202:
      case 8232:
      case 8233:
      case 8287:
      case 12288:
        return true;
    }
    return false;
  }

  public static boolean isISOControl(char ch) {
    return isISOControl((int) ch);
  }

  public static boolean isISOControl(int codePoint) {
    return codePoint <= 0x9F && (codePoint >= 0x7F || (codePoint >>> 5 == 0));
  }

  public static native int getType(char ch);

  public static native int getType(int codePoint);

  public static char forDigit(int digit, int radix) {
    if (digit >= 0 && digit <= 9) return (char) ('0' + (digit - 0));
    if (digit >= 10 && digit <= 35) return (char) ('a' + (digit - 10));
    return '\0';
  }

  public static byte getDirectionality(char ch) {
    return getDirectionality((int) ch);
  }

  public static boolean isMirrored(char ch) {
    return isMirrored((int) ch);
  }

  public static native byte getDirectionality(int codePoint);

  public static native boolean isMirrored(int codePoint);

  public int compareTo(Character anotherCharacter) {
    return compare(this.value, anotherCharacter.value);
  }

  public static int compare(char l, char r) {
    return l - r;
  }

  static char[] toUpperCaseCharArray(int codePoint) {
    return new char[] {(char) toUpperCase(codePoint)};
  }

  public static final int SIZE = 16;
  public static final int BYTES = SIZE / Byte.SIZE;

  @HaxeMethodBody("return N.swap16(p0) & 0xFFFF;")
  public static char reverseBytes(char ch) {
    return (char) (((ch & 0xFF00) >> 8) | (ch << 8));
  }

  public static String getName(int codePoint) {
    // @TODO: Not implemented!
    return Integer.toHexString(codePoint);
  }

  public static class Subset {}

  public static final class UnicodeBlock extends Subset {
    public static UnicodeBlock forName(String name) {
      return new UnicodeBlock();
    }

    public static UnicodeBlock of(int codePoint) {
      return new UnicodeBlock();
    }
  }

  public enum UnicodeScript {
    COMMON;

    public static UnicodeScript forName(String name) {
      return COMMON;
    }

    public static UnicodeScript of(int codePoint) {
      return COMMON;
    }
  }
}
/**
 * The Boolean class wraps a value of the primitive type {@code boolean} in an object. An object of
 * type {@code Boolean} contains a single field whose type is {@code boolean}.
 *
 * <p>In addition, this class provides many methods for converting a {@code boolean} to a {@code
 * String} and a {@code String} to a {@code boolean}, as well as other constants and methods useful
 * when dealing with a {@code boolean}.
 *
 * @author Arthur van Hoff
 * @since 1.0
 */
public final class Boolean implements java.io.Serializable, Comparable<Boolean> {
  /** The {@code Boolean} object corresponding to the primitive value {@code true}. */
  public static final Boolean TRUE = new Boolean(true);

  /** The {@code Boolean} object corresponding to the primitive value {@code false}. */
  public static final Boolean FALSE = new Boolean(false);

  /**
   * The Class object representing the primitive type boolean.
   *
   * @since 1.1
   */
  @SuppressWarnings("unchecked")
  public static final Class<Boolean> TYPE = (Class<Boolean>) Class.getPrimitiveClass("boolean");

  /**
   * The value of the Boolean.
   *
   * @serial
   */
  private final boolean value;

  /** use serialVersionUID from JDK 1.0.2 for interoperability */
  private static final long serialVersionUID = -3665804199014368530L;

  /**
   * Allocates a {@code Boolean} object representing the {@code value} argument.
   *
   * <p><b>Note: It is rarely appropriate to use this constructor. Unless a <i>new</i> instance is
   * required, the static factory {@link #valueOf(boolean)} is generally a better choice. It is
   * likely to yield significantly better space and time performance.</b>
   *
   * @param value the value of the {@code Boolean}.
   */
  public Boolean(boolean value) {
    this.value = value;
  }

  /**
   * Allocates a {@code Boolean} object representing the value {@code true} if the string argument
   * is not {@code null} and is equal, ignoring case, to the string {@code "true"}. Otherwise,
   * allocate a {@code Boolean} object representing the value {@code false}. Examples:
   *
   * <p>{@code new Boolean("True")} produces a {@code Boolean} object that represents {@code true}.
   * <br>
   * {@code new Boolean("yes")} produces a {@code Boolean} object that represents {@code false}.
   *
   * @param s the string to be converted to a {@code Boolean}.
   */
  public Boolean(String s) {
    this(parseBoolean(s));
  }

  /**
   * Parses the string argument as a boolean. The {@code boolean} returned represents the value
   * {@code true} if the string argument is not {@code null} and is equal, ignoring case, to the
   * string {@code "true"}.
   *
   * <p>Example: {@code Boolean.parseBoolean("True")} returns {@code true}.<br>
   * Example: {@code Boolean.parseBoolean("yes")} returns {@code false}.
   *
   * @param s the {@code String} containing the boolean representation to be parsed
   * @return the boolean represented by the string argument
   * @since 1.5
   */
  public static boolean parseBoolean(String s) {
    return ((s != null) && s.equalsIgnoreCase("true"));
  }

  /**
   * Returns the value of this {@code Boolean} object as a boolean primitive.
   *
   * @return the primitive {@code boolean} value of this object.
   */
  @HotSpotIntrinsicCandidate
  public boolean booleanValue() {
    return value;
  }

  /**
   * Returns a {@code Boolean} instance representing the specified {@code boolean} value. If the
   * specified {@code boolean} value is {@code true}, this method returns {@code Boolean.TRUE}; if
   * it is {@code false}, this method returns {@code Boolean.FALSE}. If a new {@code Boolean}
   * instance is not required, this method should generally be used in preference to the constructor
   * {@link #Boolean(boolean)}, as this method is likely to yield significantly better space and
   * time performance.
   *
   * @param b a boolean value.
   * @return a {@code Boolean} instance representing {@code b}.
   * @since 1.4
   */
  @HotSpotIntrinsicCandidate
  public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
  }

  /**
   * Returns a {@code Boolean} with a value represented by the specified string. The {@code Boolean}
   * returned represents a true value if the string argument is not {@code null} and is equal,
   * ignoring case, to the string {@code "true"}.
   *
   * @param s a string.
   * @return the {@code Boolean} value represented by the string.
   */
  public static Boolean valueOf(String s) {
    return parseBoolean(s) ? TRUE : FALSE;
  }

  /**
   * Returns a {@code String} object representing the specified boolean. If the specified boolean is
   * {@code true}, then the string {@code "true"} will be returned, otherwise the string {@code
   * "false"} will be returned.
   *
   * @param b the boolean to be converted
   * @return the string representation of the specified {@code boolean}
   * @since 1.4
   */
  public static String toString(boolean b) {
    return b ? "true" : "false";
  }

  /**
   * Returns a {@code String} object representing this Boolean's value. If this object represents
   * the value {@code true}, a string equal to {@code "true"} is returned. Otherwise, a string equal
   * to {@code "false"} is returned.
   *
   * @return a string representation of this object.
   */
  public String toString() {
    return value ? "true" : "false";
  }

  /**
   * Returns a hash code for this {@code Boolean} object.
   *
   * @return the integer {@code 1231} if this object represents {@code true}; returns the integer
   *     {@code 1237} if this object represents {@code false}.
   */
  @Override
  public int hashCode() {
    return Boolean.hashCode(value);
  }

  /**
   * Returns a hash code for a {@code boolean} value; compatible with {@code Boolean.hashCode()}.
   *
   * @param value the value to hash
   * @return a hash code value for a {@code boolean} value.
   * @since 1.8
   */
  public static int hashCode(boolean value) {
    return value ? 1231 : 1237;
  }

  /**
   * Returns {@code true} if and only if the argument is not {@code null} and is a {@code Boolean}
   * object that represents the same {@code boolean} value as this object.
   *
   * @param obj the object to compare with.
   * @return {@code true} if the Boolean objects represent the same value; {@code false} otherwise.
   */
  public boolean equals(Object obj) {
    if (obj instanceof Boolean) {
      return value == ((Boolean) obj).booleanValue();
    }
    return false;
  }

  /**
   * Returns {@code true} if and only if the system property named by the argument exists and is
   * equal to the string {@code "true"}. (Beginning with version 1.0.2 of the Java&trade; platform,
   * the test of this string is case insensitive.) A system property is accessible through {@code
   * getProperty}, a method defined by the {@code System} class.
   *
   * <p>If there is no property with the specified name, or if the specified name is empty or null,
   * then {@code false} is returned.
   *
   * @param name the system property name.
   * @return the {@code boolean} value of the system property.
   * @throws SecurityException for the same reasons as {@link System#getProperty(String)
   *     System.getProperty}
   * @see java.lang.System#getProperty(java.lang.String)
   * @see java.lang.System#getProperty(java.lang.String, java.lang.String)
   */
  public static boolean getBoolean(String name) {
    boolean result = false;
    try {
      result = parseBoolean(System.getProperty(name));
    } catch (IllegalArgumentException | NullPointerException e) {
    }
    return result;
  }

  /**
   * Compares this {@code Boolean} instance with another.
   *
   * @param b the {@code Boolean} instance to be compared
   * @return zero if this object represents the same boolean value as the argument; a positive value
   *     if this object represents true and the argument represents false; and a negative value if
   *     this object represents false and the argument represents true
   * @throws NullPointerException if the argument is {@code null}
   * @see Comparable
   * @since 1.5
   */
  public int compareTo(Boolean b) {
    return compare(this.value, b.value);
  }

  /**
   * Compares two {@code boolean} values. The value returned is identical to what would be returned
   * by:
   *
   * <pre>
   *    Boolean.valueOf(x).compareTo(Boolean.valueOf(y))
   * </pre>
   *
   * @param x the first {@code boolean} to compare
   * @param y the second {@code boolean} to compare
   * @return the value {@code 0} if {@code x == y}; a value less than {@code 0} if {@code !x && y};
   *     and a value greater than {@code 0} if {@code x && !y}
   * @since 1.7
   */
  public static int compare(boolean x, boolean y) {
    return (x == y) ? 0 : (x ? 1 : -1);
  }

  /**
   * Returns the result of applying the logical AND operator to the specified {@code boolean}
   * operands.
   *
   * @param a the first operand
   * @param b the second operand
   * @return the logical AND of {@code a} and {@code b}
   * @see java.util.function.BinaryOperator
   * @since 1.8
   */
  public static boolean logicalAnd(boolean a, boolean b) {
    return a && b;
  }

  /**
   * Returns the result of applying the logical OR operator to the specified {@code boolean}
   * operands.
   *
   * @param a the first operand
   * @param b the second operand
   * @return the logical OR of {@code a} and {@code b}
   * @see java.util.function.BinaryOperator
   * @since 1.8
   */
  public static boolean logicalOr(boolean a, boolean b) {
    return a || b;
  }

  /**
   * Returns the result of applying the logical XOR operator to the specified {@code boolean}
   * operands.
   *
   * @param a the first operand
   * @param b the second operand
   * @return the logical XOR of {@code a} and {@code b}
   * @see java.util.function.BinaryOperator
   * @since 1.8
   */
  public static boolean logicalXor(boolean a, boolean b) {
    return a ^ b;
  }
}
Пример #3
0
/**
 * The {@code Float} class wraps a value of primitive type {@code float} in an object. An object of
 * type {@code Float} contains a single field whose type is {@code float}.
 *
 * <p>In addition, this class provides several methods for converting a {@code float} to a {@code
 * String} and a {@code String} to a {@code float}, as well as other constants and methods useful
 * when dealing with a {@code float}.
 *
 * @author Lee Boynton
 * @author Arthur van Hoff
 * @author Joseph D. Darcy
 * @since JDK1.0
 */
public final class Float extends Number implements Comparable<Float> {
  /**
   * A constant holding the positive infinity of type {@code float}. It is equal to the value
   * returned by {@code Float.intBitsToFloat(0x7f800000)}.
   */
  public static final float POSITIVE_INFINITY = 1.0f / 0.0f;

  /**
   * A constant holding the negative infinity of type {@code float}. It is equal to the value
   * returned by {@code Float.intBitsToFloat(0xff800000)}.
   */
  public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;

  /**
   * A constant holding a Not-a-Number (NaN) value of type {@code float}. It is equivalent to the
   * value returned by {@code Float.intBitsToFloat(0x7fc00000)}.
   */
  public static final float NaN = 0.0f / 0.0f;

  /**
   * A constant holding the largest positive finite value of type {@code float},
   * (2-2<sup>-23</sup>)&middot;2<sup>127</sup>. It is equal to the hexadecimal floating-point
   * literal {@code 0x1.fffffeP+127f} and also equal to {@code Float.intBitsToFloat(0x7f7fffff)}.
   */
  public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f

  /**
   * A constant holding the smallest positive normal value of type {@code float}, 2<sup>-126</sup>.
   * It is equal to the hexadecimal floating-point literal {@code 0x1.0p-126f} and also equal to
   * {@code Float.intBitsToFloat(0x00800000)}.
   *
   * @since 1.6
   */
  public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f

  /**
   * A constant holding the smallest positive nonzero value of type {@code float}, 2<sup>-149</sup>.
   * It is equal to the hexadecimal floating-point literal {@code 0x0.000002P-126f} and also equal
   * to {@code Float.intBitsToFloat(0x1)}.
   */
  public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f

  /**
   * Maximum exponent a finite {@code float} variable may have. It is equal to the value returned by
   * {@code Math.getExponent(Float.MAX_VALUE)}.
   *
   * @since 1.6
   */
  public static final int MAX_EXPONENT = 127;

  /**
   * Minimum exponent a normalized {@code float} variable may have. It is equal to the value
   * returned by {@code Math.getExponent(Float.MIN_NORMAL)}.
   *
   * @since 1.6
   */
  public static final int MIN_EXPONENT = -126;

  /**
   * The number of bits used to represent a {@code float} value.
   *
   * @since 1.5
   */
  public static final int SIZE = 32;

  /**
   * The {@code Class} instance representing the primitive type {@code float}.
   *
   * @since JDK1.1
   */
  public static final Class<Float> TYPE = Class.getPrimitiveClass("float");

  /**
   * Returns a string representation of the {@code float} argument. All characters mentioned below
   * are ASCII characters.
   *
   * <ul>
   *   <li>If the argument is NaN, the result is the string "{@code NaN}".
   *   <li>Otherwise, the result is a string that represents the sign and magnitude (absolute value)
   *       of the argument. If the sign is negative, the first character of the result is '{@code
   *       -}' (<code>'&#92;u002D'</code>); if the sign is positive, no sign character appears in
   *       the result. As for the magnitude <i>m</i>:
   *       <ul>
   *         <li>If <i>m</i> is infinity, it is represented by the characters {@code "Infinity"};
   *             thus, positive infinity produces the result {@code "Infinity"} and negative
   *             infinity produces the result {@code "-Infinity"}.
   *         <li>If <i>m</i> is zero, it is represented by the characters {@code "0.0"}; thus,
   *             negative zero produces the result {@code "-0.0"} and positive zero produces the
   *             result {@code "0.0"}.
   *         <li>If <i>m</i> is greater than or equal to 10<sup>-3</sup> but less than
   *             10<sup>7</sup>, then it is represented as the integer part of <i>m</i>, in decimal
   *             form with no leading zeroes, followed by '{@code .}' (<code>'&#92;u002E'</code>),
   *             followed by one or more decimal digits representing the fractional part of
   *             <i>m</i>.
   *         <li>If <i>m</i> is less than 10<sup>-3</sup> or greater than or equal to
   *             10<sup>7</sup>, then it is represented in so-called "computerized scientific
   *             notation." Let <i>n</i> be the unique integer such that 10<sup><i>n</i> </sup>&le;
   *             <i>m</i> {@literal <} 10<sup><i>n</i>+1</sup>; then let <i>a</i> be the
   *             mathematically exact quotient of <i>m</i> and 10<sup><i>n</i></sup> so that 1 &le;
   *             <i>a</i> {@literal <} 10. The magnitude is then represented as the integer part of
   *             <i>a</i>, as a single decimal digit, followed by '{@code .}' (<code>'&#92;u002E'
   *             </code>), followed by decimal digits representing the fractional part of <i>a</i>,
   *             followed by the letter '{@code E}' (<code>'&#92;u0045'</code>), followed by a
   *             representation of <i>n</i> as a decimal integer, as produced by the method {@link
   *             java.lang.Integer#toString(int)}.
   *       </ul>
   * </ul>
   *
   * How many digits must be printed for the fractional part of <i>m</i> or <i>a</i>? 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 float}. That is, suppose that <i>x</i> is the exact mathematical value represented
   * by the decimal representation produced by this method for a finite nonzero argument <i>f</i>.
   * Then <i>f</i> must be the {@code float} value nearest to <i>x</i>; or, if two {@code float}
   * values are equally close to <i>x</i>, then <i>f</i> must be one of them and the least
   * significant bit of the significand of <i>f</i> must be {@code 0}.
   *
   * <p>To create localized string representations of a floating-point value, use subclasses of
   * {@link java.text.NumberFormat}.
   *
   * @param f the float to be converted.
   * @return a string representation of the argument.
   */
  public static String toString(float f) {
    return new FloatingDecimal(f).toJavaFormatString();
  }

  /**
   * Returns a hexadecimal string representation of the {@code float} argument. All characters
   * mentioned below are ASCII characters.
   *
   * <ul>
   *   <li>If the argument is NaN, the result is the string "{@code NaN}".
   *   <li>Otherwise, the result is a string that represents the sign and magnitude (absolute value)
   *       of the argument. If the sign is negative, the first character of the result is '{@code
   *       -}' (<code>'&#92;u002D'</code>); if the sign is positive, no sign character appears in
   *       the result. As for the magnitude <i>m</i>:
   *       <ul>
   *         <li>If <i>m</i> is infinity, it is represented by the string {@code "Infinity"}; thus,
   *             positive infinity produces the result {@code "Infinity"} and negative infinity
   *             produces the result {@code "-Infinity"}.
   *         <li>If <i>m</i> is zero, it is represented by the string {@code "0x0.0p0"}; thus,
   *             negative zero produces the result {@code "-0x0.0p0"} and positive zero produces the
   *             result {@code "0x0.0p0"}.
   *         <li>If <i>m</i> is a {@code float} value with a normalized representation, substrings
   *             are used to represent the significand and exponent fields. The significand is
   *             represented by the characters {@code "0x1."} followed by a lowercase hexadecimal
   *             representation of the rest of the significand as a fraction. Trailing zeros in the
   *             hexadecimal representation are removed unless all the digits are zero, in which
   *             case a single zero is used. Next, the exponent is represented by {@code "p"}
   *             followed by a decimal string of the unbiased exponent as if produced by a call to
   *             {@link Integer#toString(int) Integer.toString} on the exponent value.
   *         <li>If <i>m</i> is a {@code float} value with a subnormal representation, the
   *             significand is represented by the characters {@code "0x0."} followed by a
   *             hexadecimal representation of the rest of the significand as a fraction. Trailing
   *             zeros in the hexadecimal representation are removed. Next, the exponent is
   *             represented by {@code "p-126"}. Note that there must be at least one nonzero digit
   *             in a subnormal significand.
   *       </ul>
   * </ul>
   *
   * <table border>
   * <caption><h3>Examples</h3></caption>
   * <tr><th>Floating-point Value</th><th>Hexadecimal String</th>
   * <tr><td>{@code 1.0}</td> <td>{@code 0x1.0p0}</td>
   * <tr><td>{@code -1.0}</td>        <td>{@code -0x1.0p0}</td>
   * <tr><td>{@code 2.0}</td> <td>{@code 0x1.0p1}</td>
   * <tr><td>{@code 3.0}</td> <td>{@code 0x1.8p1}</td>
   * <tr><td>{@code 0.5}</td> <td>{@code 0x1.0p-1}</td>
   * <tr><td>{@code 0.25}</td>        <td>{@code 0x1.0p-2}</td>
   * <tr><td>{@code Float.MAX_VALUE}</td>
   *     <td>{@code 0x1.fffffep127}</td>
   * <tr><td>{@code Minimum Normal Value}</td>
   *     <td>{@code 0x1.0p-126}</td>
   * <tr><td>{@code Maximum Subnormal Value}</td>
   *     <td>{@code 0x0.fffffep-126}</td>
   * <tr><td>{@code Float.MIN_VALUE}</td>
   *     <td>{@code 0x0.000002p-126}</td>
   * </table>
   *
   * @param f the {@code float} to be converted.
   * @return a hex string representation of the argument.
   * @since 1.5
   * @author Joseph D. Darcy
   */
  public static String toHexString(float f) {
    if (Math.abs(f) < FloatConsts.MIN_NORMAL && f != 0.0f) { // float subnormal
      // Adjust exponent to create subnormal double, then
      // replace subnormal double exponent with subnormal float
      // exponent
      String s =
          Double.toHexString(
              FpUtils.scalb(
                  (double) f,
                  /* -1022+126 */
                  DoubleConsts.MIN_EXPONENT - FloatConsts.MIN_EXPONENT));
      return s.replaceFirst("p-1022$", "p-126");
    } else // double string will be the same as float string
    return Double.toHexString(f);
  }

  /**
   * Returns a {@code Float} object holding the {@code float} value represented by the argument
   * string {@code s}.
   *
   * <p>If {@code s} is {@code null}, then a {@code NullPointerException} is thrown.
   *
   * <p>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 <i>FloatValue</i> as described by the
   * lexical syntax rules:
   *
   * <blockquote>
   *
   * <dl>
   *   <dt><i>FloatValue:</i>
   *   <dd><i>Sign<sub>opt</sub></i> {@code NaN}
   *   <dd><i>Sign<sub>opt</sub></i> {@code Infinity}
   *   <dd><i>Sign<sub>opt</sub> FloatingPointLiteral</i>
   *   <dd><i>Sign<sub>opt</sub> HexFloatingPointLiteral</i>
   *   <dd><i>SignedInteger</i>
   * </dl>
   *
   * <p>
   *
   * <dl>
   *   <dt><i>HexFloatingPointLiteral</i>:
   *   <dd><i>HexSignificand BinaryExponent FloatTypeSuffix<sub>opt</sub></i>
   * </dl>
   *
   * <p>
   *
   * <dl>
   *   <dt><i>HexSignificand:</i>
   *   <dd><i>HexNumeral</i>
   *   <dd><i>HexNumeral</i> {@code .}
   *   <dd>{@code 0x} <i>HexDigits<sub>opt</sub> </i>{@code .}<i> HexDigits</i>
   *   <dd>{@code 0X}<i> HexDigits<sub>opt</sub> </i>{@code .} <i>HexDigits</i>
   * </dl>
   *
   * <p>
   *
   * <dl>
   *   <dt><i>BinaryExponent:</i>
   *   <dd><i>BinaryExponentIndicator SignedInteger</i>
   * </dl>
   *
   * <p>
   *
   * <dl>
   *   <dt><i>BinaryExponentIndicator:</i>
   *   <dd>{@code p}
   *   <dd>{@code P}
   * </dl>
   *
   * </blockquote>
   *
   * where <i>Sign</i>, <i>FloatingPointLiteral</i>, <i>HexNumeral</i>, <i>HexDigits</i>,
   * <i>SignedInteger</i> and <i>FloatTypeSuffix</i> are as defined in the lexical structure
   * sections of the <a href="http://java.sun.com/docs/books/jls/html/">Java Language
   * Specification</a>. If {@code s} does not have the form of a <i>FloatValue</i>, 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 float} by the usual round-to-nearest rule of IEEE 754
   * floating-point arithmetic, which includes preserving the sign of a zero value.
   *
   * <p>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(float) ulp(MAX_VALUE)}/2), rounding to {@code float} 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.
   *
   * <p>Finally, after rounding a {@code Float} object representing this {@code float} value is
   * returned.
   *
   * <p>To interpret localized string representations of a floating-point value, use subclasses of
   * {@link java.text.NumberFormat}.
   *
   * <p>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
   * <em>not</em> 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. In general, the two-step
   * sequence of conversions, string to {@code double} followed by {@code double} to {@code float},
   * is <em>not</em> equivalent to converting a string directly to {@code float}. For example, if
   * first converted to an intermediate {@code double} and then to {@code float}, the string<br>
   * {@code "1.00000017881393421514957253748434595763683319091796875001d"}<br>
   * results in the {@code float} value {@code 1.0000002f}; if the string is converted directly to
   * {@code float}, <code>1.000000<b>1</b>f</code> results.
   *
   * <p>To avoid calling this method on an invalid string and having a {@code NumberFormatException}
   * be thrown, the documentation for {@link Double#valueOf Double.valueOf} lists a regular
   * expression which can be used to screen the input.
   *
   * @param s the string to be parsed.
   * @return a {@code Float} object holding the value represented by the {@code String} argument.
   * @throws NumberFormatException if the string does not contain a parsable number.
   */
  public static Float valueOf(String s) throws NumberFormatException {
    return new Float(FloatingDecimal.readJavaFormatString(s).floatValue());
  }

  /**
   * Returns a {@code Float} instance representing the specified {@code float} value. If a new
   * {@code Float} instance is not required, this method should generally be used in preference to
   * the constructor {@link #Float(float)}, as this method is likely to yield significantly better
   * space and time performance by caching frequently requested values.
   *
   * @param f a float value.
   * @return a {@code Float} instance representing {@code f}.
   * @since 1.5
   */
  public static Float valueOf(float f) {
    return new Float(f);
  }

  /**
   * Returns a new {@code float} initialized to the value represented by the specified {@code
   * String}, as performed by the {@code valueOf} method of class {@code Float}.
   *
   * @param s the string to be parsed.
   * @return the {@code float} value represented by the string argument.
   * @throws NullPointerException if the string is null
   * @throws NumberFormatException if the string does not contain a parsable {@code float}.
   * @see java.lang.Float#valueOf(String)
   * @since 1.2
   */
  public static float parseFloat(String s) throws NumberFormatException {
    return FloatingDecimal.readJavaFormatString(s).floatValue();
  }

  /**
   * 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 argument is NaN; {@code false} otherwise.
   */
  public static boolean isNaN(float v) {
    return (v != v);
  }

  /**
   * 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 argument is positive infinity or negative infinity; {@code false}
   *     otherwise.
   */
  public static boolean isInfinite(float v) {
    return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
  }

  /**
   * The value of the Float.
   *
   * @serial
   */
  private final float value;

  /**
   * Constructs a newly allocated {@code Float} object that represents the primitive {@code float}
   * argument.
   *
   * @param value the value to be represented by the {@code Float}.
   */
  public Float(float value) {
    this.value = value;
  }

  /**
   * Constructs a newly allocated {@code Float} object that represents the argument converted to
   * type {@code float}.
   *
   * @param value the value to be represented by the {@code Float}.
   */
  public Float(double value) {
    this.value = (float) value;
  }

  /**
   * Constructs a newly allocated {@code Float} object that represents the floating-point value of
   * type {@code float} represented by the string. The string is converted to a {@code float} value
   * as if by the {@code valueOf} method.
   *
   * @param s a string to be converted to a {@code Float}.
   * @throws NumberFormatException if the string does not contain a parsable number.
   * @see java.lang.Float#valueOf(java.lang.String)
   */
  public Float(String s) throws NumberFormatException {
    // REMIND: this is inefficient
    this(valueOf(s).floatValue());
  }

  /**
   * Returns {@code true} if this {@code Float} 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() {
    return isNaN(value);
  }

  /**
   * Returns {@code true} if this {@code Float} 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() {
    return isInfinite(value);
  }

  /**
   * Returns a string representation of this {@code Float} object. The primitive {@code float} value
   * represented by this object is converted to a {@code String} exactly as if by the method {@code
   * toString} of one argument.
   *
   * @return a {@code String} representation of this object.
   * @see java.lang.Float#toString(float)
   */
  public String toString() {
    return Float.toString(value);
  }

  /**
   * Returns the value of this {@code Float} as a {@code byte} (by casting to a {@code byte}).
   *
   * @return the {@code float} value represented by this object converted to type {@code byte}
   */
  public byte byteValue() {
    return (byte) value;
  }

  /**
   * Returns the value of this {@code Float} as a {@code short} (by casting to a {@code short}).
   *
   * @return the {@code float} value represented by this object converted to type {@code short}
   * @since JDK1.1
   */
  public short shortValue() {
    return (short) value;
  }

  /**
   * Returns the value of this {@code Float} as an {@code int} (by casting to type {@code int}).
   *
   * @return the {@code float} value represented by this object converted to type {@code int}
   */
  public int intValue() {
    return (int) value;
  }

  /**
   * Returns value of this {@code Float} as a {@code long} (by casting to type {@code long}).
   *
   * @return the {@code float} value represented by this object converted to type {@code long}
   */
  public long longValue() {
    return (long) value;
  }

  /**
   * Returns the {@code float} value of this {@code Float} object.
   *
   * @return the {@code float} value represented by this object
   */
  public float floatValue() {
    return value;
  }

  /**
   * Returns the {@code double} value of this {@code Float} object.
   *
   * @return the {@code float} value represented by this object is converted to type {@code double}
   *     and the result of the conversion is returned.
   */
  public double doubleValue() {
    return (double) value;
  }

  /**
   * Returns a hash code for this {@code Float} object. The result is the integer bit
   * representation, exactly as produced by the method {@link #floatToIntBits(float)}, of the
   * primitive {@code float} value represented by this {@code Float} object.
   *
   * @return a hash code value for this object.
   */
  public int hashCode() {
    return floatToIntBits(value);
  }

  /**
   * 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 Float} object that represents a {@code float}
   * with the same value as the {@code float} represented by this object. For this purpose, two
   * {@code float} values are considered to be the same if and only if the method {@link
   * #floatToIntBits(float)} returns the identical {@code int} value when applied to each.
   *
   * <p>Note that in most cases, for two instances of class {@code Float}, {@code f1} and {@code
   * f2}, the value of {@code f1.equals(f2)} is {@code true} if and only if
   *
   * <blockquote>
   *
   * <pre>
   *   f1.floatValue() == f2.floatValue()
   * </pre>
   *
   * </blockquote>
   *
   * <p>also has the value {@code true}. However, there are two exceptions:
   *
   * <ul>
   *   <li>If {@code f1} and {@code f2} both represent {@code Float.NaN}, then the {@code equals}
   *       method returns {@code true}, even though {@code Float.NaN==Float.NaN} has the value
   *       {@code false}.
   *   <li>If {@code f1} represents {@code +0.0f} while {@code f2} represents {@code -0.0f}, or vice
   *       versa, the {@code equal} test has the value {@code false}, even though {@code
   *       0.0f==-0.0f} has the value {@code true}.
   * </ul>
   *
   * This definition allows hash tables to operate properly.
   *
   * @param obj the object to be compared
   * @return {@code true} if the objects are the same; {@code false} otherwise.
   * @see java.lang.Float#floatToIntBits(float)
   */
  public boolean equals(Object obj) {
    return (obj instanceof Float) && (floatToIntBits(((Float) obj).value) == floatToIntBits(value));
  }

  /**
   * Returns a representation of the specified floating-point value according to the IEEE 754
   * floating-point "single format" bit layout.
   *
   * <p>Bit 31 (the bit that is selected by the mask {@code 0x80000000}) represents the sign of the
   * floating-point number. Bits 30-23 (the bits that are selected by the mask {@code 0x7f800000})
   * represent the exponent. Bits 22-0 (the bits that are selected by the mask {@code 0x007fffff})
   * represent the significand (sometimes called the mantissa) of the floating-point number.
   *
   * <p>If the argument is positive infinity, the result is {@code 0x7f800000}.
   *
   * <p>If the argument is negative infinity, the result is {@code 0xff800000}.
   *
   * <p>If the argument is NaN, the result is {@code 0x7fc00000}.
   *
   * <p>In all cases, the result is an integer that, when given to the {@link #intBitsToFloat(int)}
   * method, will produce a floating-point value the same as the argument to {@code floatToIntBits}
   * (except all NaN values are collapsed to a single "canonical" NaN value).
   *
   * @param value a floating-point number.
   * @return the bits that represent the floating-point number.
   */
  public static int floatToIntBits(float value) {
    int result = floatToRawIntBits(value);
    // Check for NaN based on values of bit fields, maximum
    // exponent and nonzero significand.
    if (((result & FloatConsts.EXP_BIT_MASK) == FloatConsts.EXP_BIT_MASK)
        && (result & FloatConsts.SIGNIF_BIT_MASK) != 0) result = 0x7fc00000;
    return result;
  }

  /**
   * Returns a representation of the specified floating-point value according to the IEEE 754
   * floating-point "single format" bit layout, preserving Not-a-Number (NaN) values.
   *
   * <p>Bit 31 (the bit that is selected by the mask {@code 0x80000000}) represents the sign of the
   * floating-point number. Bits 30-23 (the bits that are selected by the mask {@code 0x7f800000})
   * represent the exponent. Bits 22-0 (the bits that are selected by the mask {@code 0x007fffff})
   * represent the significand (sometimes called the mantissa) of the floating-point number.
   *
   * <p>If the argument is positive infinity, the result is {@code 0x7f800000}.
   *
   * <p>If the argument is negative infinity, the result is {@code 0xff800000}.
   *
   * <p>If the argument is NaN, the result is the integer representing the actual NaN value. Unlike
   * the {@code floatToIntBits} method, {@code floatToRawIntBits} does not collapse all the bit
   * patterns encoding a NaN to a single "canonical" NaN value.
   *
   * <p>In all cases, the result is an integer that, when given to the {@link #intBitsToFloat(int)}
   * method, will produce a floating-point value the same as the argument to {@code
   * floatToRawIntBits}.
   *
   * @param value a floating-point number.
   * @return the bits that represent the floating-point number.
   * @since 1.3
   */
  public static native int floatToRawIntBits(float value);

  /**
   * Returns the {@code float} 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 "single format" bit layout.
   *
   * <p>If the argument is {@code 0x7f800000}, the result is positive infinity.
   *
   * <p>If the argument is {@code 0xff800000}, the result is negative infinity.
   *
   * <p>If the argument is any value in the range {@code 0x7f800001} through {@code 0x7fffffff} or
   * in the range {@code 0xff800001} through {@code 0xffffffff}, 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 Float.floatToRawIntBits} method.
   *
   * <p>In all other cases, let <i>s</i>, <i>e</i>, and <i>m</i> be three values that can be
   * computed from the argument:
   *
   * <blockquote>
   *
   * <pre>
   * int s = ((bits &gt;&gt; 31) == 0) ? 1 : -1;
   * int e = ((bits &gt;&gt; 23) & 0xff);
   * int m = (e == 0) ?
   *                 (bits & 0x7fffff) &lt;&lt; 1 :
   *                 (bits & 0x7fffff) | 0x800000;
   * </pre>
   *
   * </blockquote>
   *
   * Then the floating-point result equals the value of the mathematical expression
   * <i>s</i>&middot;<i>m</i>&middot;2<sup><i>e</i>-150</sup>.
   *
   * <p>Note that this method may not be able to return a {@code float} NaN with exactly same bit
   * pattern as the {@code int} argument. IEEE 754 distinguishes between two kinds of NaNs, quiet
   * NaNs and <i>signaling NaNs</i>. 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 intBitsToFloat} may not be able
   * to return a {@code float} with a signaling NaN bit pattern. Consequently, for some {@code int}
   * values, {@code floatToRawIntBits(intBitsToFloat(start))} may <i>not</i> 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 an integer.
   * @return the {@code float} floating-point value with the same bit pattern.
   */
  public static native float intBitsToFloat(int bits);

  /**
   * Compares two {@code Float} 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 float} values:
   *
   * <ul>
   *   <li>{@code Float.NaN} is considered by this method to be equal to itself and greater than all
   *       other {@code float} values (including {@code Float.POSITIVE_INFINITY}).
   *   <li>{@code 0.0f} is considered by this method to be greater than {@code -0.0f}.
   * </ul>
   *
   * This ensures that the <i>natural ordering</i> of {@code Float} objects imposed by this method
   * is <i>consistent with equals</i>.
   *
   * @param anotherFloat the {@code Float} to be compared.
   * @return the value {@code 0} if {@code anotherFloat} is numerically equal to this {@code Float};
   *     a value less than {@code 0} if this {@code Float} is numerically less than {@code
   *     anotherFloat}; and a value greater than {@code 0} if this {@code Float} is numerically
   *     greater than {@code anotherFloat}.
   * @since 1.2
   * @see Comparable#compareTo(Object)
   */
  public int compareTo(Float anotherFloat) {
    return Float.compare(value, anotherFloat.value);
  }

  /**
   * Compares the two specified {@code float} values. The sign of the integer value returned is the
   * same as that of the integer that would be returned by the call:
   *
   * <pre>
   *    new Float(f1).compareTo(new Float(f2))
   * </pre>
   *
   * @param f1 the first {@code float} to compare.
   * @param f2 the second {@code float} to compare.
   * @return the value {@code 0} if {@code f1} is numerically equal to {@code f2}; a value less than
   *     {@code 0} if {@code f1} is numerically less than {@code f2}; and a value greater than
   *     {@code 0} if {@code f1} is numerically greater than {@code f2}.
   * @since 1.4
   */
  public static int compare(float f1, float f2) {
    if (f1 < f2) return -1; // Neither val is NaN, thisVal is smaller
    if (f1 > f2) return 1; // Neither val is NaN, thisVal is larger

    int thisBits = Float.floatToIntBits(f1);
    int anotherBits = Float.floatToIntBits(f2);

    return (thisBits == anotherBits
        ? 0
        : // Values are equal
        (thisBits < anotherBits
            ? -1
            : // (-0.0, 0.0) or (!NaN, NaN)
            1)); // (0.0, -0.0) or (NaN, !NaN)
  }

  /** use serialVersionUID from JDK 1.0.2 for interoperability */
  private static final long serialVersionUID = -2671257302660747028L;
}