| 26 | /// In addition, this class provides several methods for converting a double to a String and a String to a double, as well as other constants and methods useful when dealing with a double. |
| 27 | /// Since: JDK1.0, CLDC 1.1 |
| 28 | public final class Double extends Number implements Comparable<Double> { |
| 29 | |
| 30 | public static final Class<Double> TYPE = double.class; |
| 31 | /// The largest positive finite value of type double. It is equal to the value returned by Double.longBitsToDouble(0x7fefffffffffffffL) |
| 32 | /// See Also:Constant Field Values |
| 33 | public static final double MAX_VALUE=1.7976931348623157E308d; |
| 34 | |
| 35 | /// The smallest positive value of type double. It is equal to the value returned by Double.longBitsToDouble(0x1L). |
| 36 | public static final double MIN_VALUE=0.0d; |
| 37 | |
| 38 | /// A Not-a-Number (NaN) value of type double. It is equal to the value returned by Double.longBitsToDouble(0x7ff8000000000000L). |
| 39 | /// See Also:Constant Field Values |
| 40 | public static final double NaN=0d/0d; |
| 41 | |
| 42 | /// The negative infinity of type double. It is equal to the value returned by Double.longBitsToDouble(0xfff0000000000000L). |
| 43 | /// See Also:Constant Field Values |
| 44 | public static final double NEGATIVE_INFINITY=-1d/0d; |
| 45 | |
| 46 | /// The positive infinity of type double. It is equal to the value returned by Double.longBitsToDouble(0x7ff0000000000000L). |
| 47 | /// See Also:Constant Field Values |
| 48 | public static final double POSITIVE_INFINITY=1d/0d; |
| 49 | |
| 50 | /// Constructs a newly allocated Double object that represents the primitive double argument. |
| 51 | /// value - the value to be represented by the Double. |
| 52 | public Double(double value){ |
| 53 | //TODO codavaj!! |
| 54 | } |
| 55 | |
| 56 | /// Returns the value of this Double as a byte (by casting to a byte). |
| 57 | public byte byteValue(){ |
| 58 | return 0; //TODO codavaj!! |
| 59 | } |
| 60 | |
| 61 | /// Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout. |
| 62 | /// Bit 63 (the bit that is selected by the mask 0x8000000000000000L) represents the sign of the floating-point number. Bits 62-52 (the bits that are selected by the mask 0x7ff0000000000000L) represent the exponent. Bits 51-0 (the bits that are selected by the mask 0x000fffffffffffffL) represent the significand (sometimes called the mantissa) of the floating-point number. |
| 63 | /// If the argument is positive infinity, the result is 0x7ff0000000000000L. |
| 64 | /// If the argument is negative infinity, the result is 0xfff0000000000000L. |
| 65 | /// If the argument is NaN, the result is 0x7ff8000000000000L. |
| 66 | /// In all cases, the result is a long integer that, when given to the longBitsToDouble(long) method, will produce a floating-point value equal to the argument to doubleToLongBits. |
| 67 | public static long doubleToLongBits(double value){ |
| 68 | return 0l; //TODO codavaj!! |
| 69 | } |
| 70 | |
| 71 | /// Returns the double value of this Double. |
| 72 | public double doubleValue(){ |
| 73 | return 0.0d; //TODO codavaj!! |
| 74 | } |
| 75 | |
| 76 | /// Compares this object against the specified object. The result is true if and only if the argument is not null and is a Double object that represents a double that has the identical bit pattern to the bit pattern of the double represented by this object. For this purpose, two double values are considered to be the same if and only if the method |
| 77 | /// returns the same long value when applied to each. |
| 78 | /// Note that in most cases, for two instances of class Double, d1 and d2, the value of d1.equals(d2) is true if and only if |
| 79 | /// d1.doubleValue() |
| 80 | /// == d2.doubleValue() |
| 81 | /// also has the value true. However, there are two exceptions: If d1 and d2 both represent Double.NaN, then the equals method returns true, even though Double.NaN==Double.NaN has the value false. If d1 represents +0.0 while d2 represents -0.0, or vice versa, the equals test has the value false, even though +0.0==-0.0 has the value true. This allows hashtables to operate properly. |
| 82 | public boolean equals(java.lang.Object obj){ |
| 83 | return false; //TODO codavaj!! |
| 84 | } |
| 85 |
nothing calls this directly
no outgoing calls
no test coverage detected