gcc/libjava/java/lang/Float.java

/* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */
 
package java.lang;

/**
 * @author Andrew Haley <aph@cygnus.com>
 * @date September 25, 1998.  
 */
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
 * "The Java Language Specification", ISBN 0-201-63451-1
 * plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
 * Status:  Believed complete and correct.
 */

public final class Float extends Number implements Comparable
{
  public static final float MAX_VALUE = 3.4028235e+38f;
  public static final float MIN_VALUE = 1.4e-45f;
  public static final float NEGATIVE_INFINITY = -1.0f/0.0f;
  public static final float POSITIVE_INFINITY = 1.0f/0.0f;
  public static final float NaN = 0.0f/0.0f;

  // This initialization is seemingly circular, but it is accepted
  // by javac, and is handled specially by gcc.
  public static final Class TYPE = float.class;

  private float value;

  private static final long serialVersionUID = -2671257302660747028L;

  public Float (float value)
  {
    this.value = value;
  }

  public Float (double value)
  {
    this.value = (float)value;
  }

  public Float (String s) throws NumberFormatException
  {
    this.value = valueOf (s).floatValue ();
  }

  public static float parseFloat (String s) throws NumberFormatException
  {
    // The spec says that parseFloat() should work like
    // Double.valueOf().  This is equivalent, in our implementation,
    // but more efficient.
    return (float) Double.parseDouble (s);
  }

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

  public boolean equals (Object obj)
  {
    if (!(obj instanceof Float))
      return false;

    Float f = (Float) obj;

    return floatToIntBits (value) == floatToIntBits (f.floatValue ());
  }

  public int hashCode ()
  {
    return floatToIntBits (value);
  }

  public int intValue ()
  {
    return (int) value;
  }

  public long longValue ()
  {
    return (long) value;
  }

  public float floatValue ()
  {
    return (float) value;
  }

  public double doubleValue ()
  {
    return (double) value;
  }

  public byte byteValue ()
  {
    return (byte) value;
  }

  public short shortValue ()
  {
    return (short) value;
  }

  public static String toString (float v)
  {
    return Double.toString ((double) v, true);
  } 

  public static Float valueOf (String s) throws NumberFormatException
  {
    return new Float (Double.valueOf (s).floatValue ());
  }

  public boolean isNaN ()
  {
    return isNaN (value);
  }

  public static boolean isNaN (float v)
  {
    int bits = floatToIntBits (v);
    int e = bits & 0x7f800000;
    int f = bits & 0x007fffff;

    return e == 0x7f800000 && f != 0;
  }

  public boolean isInfinite ()
  {
    return isInfinite (value);
  }

  public static boolean isInfinite (float v)
  {
    int bits = floatToIntBits (v);
    int f = bits & 0x7fffffff;

    return f == 0x7f800000;
  }

  public static native int floatToIntBits (float value);
  
  public static int floatToRawIntBits (float value)
  {
    // FIXME: Is this supposed to be different? NaN values seem to be handled
    // the same in the JDK.
    return floatToIntBits (value);
  }

  public static native float intBitsToFloat (int bits);

  public int compareTo (Float d)
  {
    float v = d.value;
    if (isNaN (value))
      return isNaN (v) ? 1 : 0;
    else if (isNaN (v))
      return -1;
    else if (value == 0.0 && v == -0.0)
      return 1;
    else if (value == -0.0 && v == 0.0)
      return -1;
    else if (value == v)
      return 0;

    return value > v ? 1 : -1;
  }

  public int compareTo (Object o)
  {
    return compareTo ((Float) o);
  }
}