"An IEEE 754 64-bit [floating point number][]. A `Float` is capable of approximately representing numeric values between: - 2<sup>-1022</sup>, approximately 1.79769\{#00D7}10<sup>308</sup>, and - (2-2<sup>-52</sup>)\{#00D7}2<sup>1023</sup>, approximately 5\{#00D7}10<sup>-324</sup>. Zero is represented by distinct instances `+0.0`, `-0.0`, but these instances are equal. In addition, the following special values exist: - [[infinity]] and `-infinity`, and - undefined values. As required by the IEEE standard, an undefined value, often denoted [NaN][], is not equal to any other value, nor even to itself. Thus, the definition of [[equals]] for `Float` violates the general contract defined by [[Object.equals]]. A floating point value with a zero [[fractionalPart]] is considered equal to its [[integer]] part. Literal floating point values are written with a decimal point and, optionally, a magnitude or exponent: 1.0 1.0E6 1.0M 1.0E-6 1.0u In the case of a fractional magnitude, the decimal point is optional. Underscores may be used to group digits into groups of three. [floating point number]: http://www.validlab.com/goldberg/paper.pdf [NaN]: http://en.wikipedia.org/wiki/NaN" see (`function parseFloat`) shared native final class Float(Float float) extends Object() satisfies Number<Float> & Exponentiable<Float,Float> { "Determines whether this value is undefined (that is, Not a Number or NaN). The undefined value has the property that it is not equal (`==`) to itself, and as a consequence the undefined value cannot sensibly be used in most collections." shared Boolean undefined => this!=this; "Determines whether this value is infinite in magnitude. Produces `true` for `infinity` and `-infinity`. Produces `false` for a finite number, `+0.0`, `-0.0`, or undefined." see (`value infinity`, `value finite`) shared Boolean infinite => this==infinity || this==-infinity; "Determines whether this value is finite. Produces `false` for `infinity`, `-infinity`, and undefined." see (`value infinite`, `value infinity`) shared Boolean finite => this!=infinity && this!=-infinity && !this.undefined; "The sign of this value. Produces `1` for a positive number or `infinity`. Produces `-1` for a negative number or `-infinity`. Produces `0.0` for `+0.0`, `-0.0`, or undefined." shared actual native Integer sign; "Determines if this value is a positive number or `infinity`. Produces `false` for a negative number, `+0.0`, `-0.0`, or undefined." shared actual native Boolean positive; "Determines if this value is a negative number or `-infinity`. Produces `false` for a positive number, `+0.0`, `-0.0`, or undefined." shared actual native Boolean negative; "Determines if this value is a positive number, `+0.0`, or `infinity`. Produces `false` for a negative number, `-0.0`, or undefined." shared native Boolean strictlyPositive; "Determines if this value is a negative number, `-0.0`, or `-infinity`. Produces `false` for a positive number, `+0.0`, or undefined." shared native Boolean strictlyNegative; "Determines if the given object is equal to this `Float`, that is, if: - the given object is also a `Float`, - neither this value nor the given value is [[undefined]], and either - both values are [[infinite]] and have the same [[sign]], or both represent the same finite floating point value as defined by the IEEE specification. Or if: - the given object is an [[Integer]], - this value is neither [[undefined]], nor [[infinite]], - the [[fractionalPart]] of this value equals `0.0`, and - the [[integer]] part of this value equals the given integer." shared actual native Boolean equals(Object that); shared actual native Integer hash; shared actual native Comparison compare(Float other); shared actual native Float plus(Float other); shared actual native Float minus(Float other); shared actual native Float times(Float other); shared actual native Float divided(Float other); shared actual native Float power(Float other); shared actual native Float wholePart; shared actual native Float fractionalPart; shared actual native Float magnitude; shared actual native Float negated; "This value, represented as an [[Integer]], after truncation of its fractional part, if such a representation is possible." throws (`class OverflowException`, "if the the [[wholePart]] of this value is too large or too small to be represented as an `Integer`") shared native Integer integer; shared actual native Float timesInteger(Integer integer); shared actual native Float plusInteger(Integer integer); shared actual native Float powerOfInteger(Integer integer); shared actual native String string; shared actual native Boolean largerThan(Float other); shared actual native Boolean smallerThan(Float other); shared actual native Boolean notSmallerThan(Float other); shared actual native Boolean notLargerThan(Float other); }