Basic types Numbers

An IEEE 754 64-bit floating point number. A `Float` is capable of approximately representing numeric values between:

- 2-1022, approximately 1.79769×10308, and
- (2-2-52)×21023, approximately 5×10-324.

Zero is represented by distinct instances `+0.0`, `-0.0`, but these instances are equal. `-0.0` can be distinguished from `+0.0` using `f == 0.0 && f.strictlyNegative`.

In addition, the following special values exist:

- `infinity` and `-infinity`, and
- undefined values, denoted NaN by the IEEE standard.

As required by the IEEE standard no undefined value is 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.

See also `parseFloat()`

- `Anything`
  - `Object`
    - `Float` ...and other supertypes

- `Float`
  - `Exponentiable`
    - `Numeric`
      - `Invertible`
        - `Summable`
  - `Number`
    - `Comparable`
    - `Numeric`
      - `Invertible`
        - `Summable`
  - `Object`
    - `Anything`

no subtypes hierarchy

Initializer
`Float(Float float)`

Attributes
`absolute` | See `magnitude`
`finite` | Source Code `shared Boolean finite` Determines whether this value is finite. Produces `false` for `infinity`, `-infinity`, and undefined. See also `infinite`, `infinity`
`fractionalPart` | Source Code `shared actual Float fractionalPart` The fractional part of this number, after truncation of the integral part. For `Integral` numeric types, the fractional part is always zero. Refines `Number.fractionalPart`
`hash` | Source Code `shared actual Integer hash` The hash value of the value, which allows the value to be an element of a hash-based set or key of a hash-based map. Implementations must respect the constraint that: if `x==y` then `x.hash==y.hash`. Therefore, a class which refines `Object.equals()` must also refine `hash`. Because the `Integer` type is platform-dependent a compiler for a given platform is permitted to further manipulate the calculated hash for an object, and the resulting hash may differ between platforms. Refines `Object.hash`
`infinite` | Source Code `shared Boolean infinite` 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 also `infinity`, `finite`
`integer` | Source Code `shared Integer integer` This value, represented as an `Integer`, after truncation of its fractional part, if such a representation is possible. Throws `OverflowException` if the the `wholePart` of this value is too large or too small to be represented as an `Integer`
`magnitude` | Source Code `shared actual Float magnitude` The magnitude of this number, defined for any instance `x` as: `-x` if `x<0`, or `x` otherwise, where `0` is the additive identity. Hence: `x.magnitude >= 0` for any `x`, and `x.magnitude == 0` if and only if `x==0`. Refines `Number.magnitude` Aliases: `absolute`
`negated` | Source Code `shared actual Float negated` The additive inverse of this value. Refines `Invertible.negated`
`negative` | Source Code `shared actual Boolean negative` Determines if this value is a negative number or `-infinity`. Produces `false` for a positive number, `+0.0`, `-0.0`, or undefined. Refines `Number.negative`
`notANumber` | See `undefined`
`positive` | Source Code `shared actual Boolean positive` Determines if this value is a positive number or `infinity`. Produces `false` for a negative number, `+0.0`, `-0.0`, or undefined. Refines `Number.positive`
`sign` | Source Code `shared actual Integer sign` 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. Refines `Number.sign`
`strictlyNegative` | Source Code `shared Boolean strictlyNegative` Determines if this value is a negative number, `-0.0`, or `-infinity`. Produces `false` for a positive number, `+0.0`, or undefined.
`strictlyPositive` | Source Code `shared Boolean strictlyPositive` Determines if this value is a positive number, `+0.0`, or `infinity`. Produces `false` for a negative number, `-0.0`, or undefined.
`string` | Source Code `shared actual String string` A string representing this floating point number. `"NaN"`, for any undefined value `"Infinity"`, for `infinity`, `"-Infinity"`, for `-infinity`, or, a Ceylon floating point literal that evaluates to this floating point number, for example, `"1.0"`, `"-0.0"`, or `"1.5E10"`. See also `formatFloat()` Refines `Object.string`
`undefined` | Source Code `shared Boolean undefined` Determines whether this value is undefined. The IEEE standard denotes undefined values NaN (an abbreviation of Not a Number). Undefined values include: indeterminate forms including `0.0/0.0`, `infinity/infinity`, `0.0*infinity`, and `infinity-infinity`, along with complex numbers like `sqrt(-1.0)` and `log(-1.0)`. An 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. Aliases: `notANumber`
`wholePart` | Source Code `shared actual Float wholePart` The integral value of the number after truncation of the fractional part. For `Integral` numeric types, the integral value of a number is the number itself. Refines `Number.wholePart`

Inherited Attributes
Attributes inherited from: `Object` `hash`, `string`
Attributes inherited from: `Invertible<Other>` `negated`
Attributes inherited from: `Number<Other>` `absolute`, `fractionalPart`, `magnitude`, `negative`, `positive`, `sign`, `wholePart`

Methods
`compare` | Source Code `shared actual Comparison compare(Float other)` Compares this value with the given value. Implementations must respect the constraints that: `x==y` if and only if `x<=>y == equal` (consistency with `equals()`), if `x>y` then `y<x` (symmetry), and if `x>y` and `y>z` then `x>z` (transitivity). Refines `Comparable.compare`
`divided` | Source Code `shared actual Float divided(Float other)` The quotient obtained by dividing this number by the given number. For integral numeric types, this operation results in a remainder. When the given number is `0`, the additive identity, the behavior depends on the numeric type: For some numeric types, including `Integer`, division by `0` results in an exception. For others, including `Float`, it results in a special value of the type, for example, `infinity`. Refines `Numeric.divided`
`equals` | Source Code `shared actual Boolean equals(Object that)` 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`, the `integer` part of this value equals the given integer, and the given integer is between -253 and 253 (exclusive). Refines `Object.equals`
`largerThan` | Source Code `shared actual Boolean largerThan(Float other)` Determines if this value is strictly larger than the given value. Refines `Comparable.largerThan`
`minus` | Source Code `shared actual Float minus(Float other)` The difference between this number and the given number. Must produce the value `x + -y`. Refines `Invertible.minus`
`notLargerThan` | Source Code `shared actual Boolean notLargerThan(Float other)` Determines if this value is smaller than or equal to the given value. Refines `Comparable.notLargerThan`
`notSmallerThan` | Source Code `shared actual Boolean notSmallerThan(Float other)` Determines if this value is larger than or equal to the given value. Refines `Comparable.notSmallerThan`
`plus` | Source Code `shared actual Float plus(Float other)` The result of adding the given value to this value. This operation should never perform any kind of mutation upon either the receiving value or the argument value. Refines `Summable.plus`
`plusInteger` | Source Code `shared actual Float plusInteger(Integer integer)` The result of adding this number to the given `Integer`. Refines `Number.plusInteger`
`power` | Source Code `shared actual Float power(Float other)` The result of raising this number to the given floating point power, where, following the definition of the IEEE `pow()` function, the following indeterminate forms all evaluate to `1.0`: `0.0^0.0`, `infinity^0.0` and `(-infinity)^0.0`, `1.0^infinity` and `(-1.0)^infinity`. Furthermore: `0.0^infinity` evaluates to `0.0`, and `0.0^(-infinity)` evaluates to `infinity`. If this is a `negative` number, and the given power has a nonzero `fractionalPart`, the result is `undefined`. For any negative power `y<0.0`: `0.0^y` evaluates to `infinity`, `(-0.0)^y` evaluates to `-infinity`, and for any nonzero floating point number `x`, `x^y` evaluates to `1.0/x^(-y)`. Refines `Exponentiable.power`
`powerOfInteger` | Source Code `shared actual Float powerOfInteger(Integer integer)` The result of raising this number to the given integer power, where the following indeterminate forms evaluate to `1.0`: `0.0^0`, `infinity^0` and `(-infinity)^0`. For any negative integer power `n<0`: `0.0^n` evaluates to `infinity`, `(-0.0)^n` evaluates to `-infinity`, and for any nonzero floating point number `x`, `x^n` evaluates to `1.0/x^(-n)`. Refines `Number.powerOfInteger`
`smallerThan` | Source Code `shared actual Boolean smallerThan(Float other)` Determines if this value is strictly smaller than the given value. Refines `Comparable.smallerThan`
`times` | Source Code `shared actual Float times(Float other)` The product of this number and the given number. Refines `Numeric.times`
`timesInteger` | Source Code `shared actual Float timesInteger(Integer integer)` The result of multiplying this number by the given `Integer`. Refines `Number.timesInteger`

Inherited Methods
Methods inherited from: `Object` `equals()`
Methods inherited from: `Comparable<Other>` `compare()`, `largerThan()`, `notLargerThan()`, `notSmallerThan()`, `smallerThan()`
Methods inherited from: `Exponentiable<This,Other>` `power()`
Methods inherited from: `Invertible<Other>` `minus()`
Methods inherited from: `Number<Other>` `plusInteger()`, `powerOfInteger()`, `timesInteger()`
Methods inherited from: `Numeric<Other>` `divided()`, `times()`
Methods inherited from: `Summable<Other>` `plus()`