Determines whether this value is finite. Produces false for infinity, -infinity, and undefined.

The fractional part of this number, after truncation of the integral part. For Integral numeric types, the fractional part is always zero.

A platform-dependent hash code for this Float.

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.

This value, represented as an Integer, after truncation of its fractional part, if such a representation is possible.

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.

The additive inverse of this value.

Determines if this value is a negative number or -infinity. Produces false for a positive number, +0.0, -0.0, or undefined.

Determines if this value is a positive number or infinity. Produces false for a negative number, +0.0, -0.0, or 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.

Determines if this value is a negative number, -0.0, or -infinity. Produces false for a positive number, +0.0, or undefined.

Determines if this value is a positive number, +0.0, or infinity. Produces false for a negative number, -0.0, or undefined.

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".

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.

If x is an undefined Float, then:

• x==x evaluates to false
• x!=x evaluates to true, and
• x>x, x<x, x>=x, x<=x all evaluate to false.

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.

Compare this value to the given value, where infinity is considered greater than every defined, finite value, and -infinity is considered smaller than every defined, finite value, and undefined values are considered incomparable.

Note that if x is an undefined Float and y is any Float that is not undefined, then:

• x<=>y produces an exception when evaluated, but
• x>y, x<y, x>=y, x<=y, and x==y all evaluate to false.

The quotient obtained by dividing this number by the given number. For integral numeric types, this operation rounds toward 0, the additive identity, and results in a remainder.

When the given divisor is exactly 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.

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 -2⁵³ and 2⁵³ (exclusive).

The string decimal representation of the given floating point number. If the given number is negative, the string representation will begin with -. The whole part and fractional parts of the number are separated by a . decimal point. Digits consist of decimal digits 0 to 9.

The number of decimal places following the decimal point is controlled by the parameters minDecimalPlaces and maxDecimalPlaces, which default to 1 and 9 respectively, so that by default the string representation always contains a decimal point, and never contains more than nine decimal places. The decimal representation is rounded so that the number of decimal places never exceeds the specified maximum.

For example:

• Float.format(1234.1234) is "1234.1234"
• Float.format(0.1234) is "0.1234"
• Float.format(1234.0) is "1234.0"
• Float.format(1234.0,0) is "1234"
• Float.format(1234.1234,6) is "1234.123400"
• Float.format(1234.1234,0,2) is "1234.12"
• Float.format(1234.123456,0,5) is "1234.12346"
• Float.format(0.0001,2,2) is "0.00"
• Float.format(0.0001,0,2) is "0"

Finally:

• Float.format(-0.0) is "0.0",
• Float.format(0.0/0) is "NaN",
• Float.format(1.0/0) is "Infinity", and
• Float.format(-1.0/0) is "-Infinity".

This function never produces a representation involving scientific notation.

Determines if this value is strictly larger than the given value, where infinity is considered greater than every defined, finite value, and -infinity is considered smaller than every defined, finite value. Evaluates to false if this value, the given value, or both are undefined.

The larger of the two given floating point values, or an undefined value if and only if one of the values is undefined.

The largest floating point value in the given stream, null if the stream is empty, or an undefined value if and only if the stream contains an undefined value.

The smallest floating point value in the given stream, null if the stream is empty, or an undefined value if and only if the stream contains an undefined value.

The difference between this number and the given number. Must produce the value x + -y.

Determines if this value is smaller than or equal to the given value, where infinity is considered greater than every defined, finite value, and -infinity is considered smaller than every defined, finite value. Evaluates to false if this value, the given value, or both are undefined.

Determines if this value is larger than or equal to the given value, where infinity is considered greater than every defined, finite value, and -infinity is considered smaller than every defined, finite value. Evaluates to false if this value, the given value, or both are undefined.

The Float value of the given string representation of a decimal floating point number, or null if the string does not represent a decimal floating point number.

If the given string representation contains more digits than can be represented by a Float, then the least significant digits are ignored.

The syntax accepted by this method is the same as the syntax for a Float literal in the Ceylon language except that it may optionally begin with a sign character (+ or -) and may not contain grouping underscore characters. That is, an optional sign character, followed by a string of decimal digits, followed by an optional decimal point and string of decimal digits, followed by an optional decimal exponent, for example, e+10 or E-5, or SI magnitude, k, M, G, T, P, m, u, n, p, or f.

Float: Sign? Digits ('.' Digits)? (Magnitude|Exponent) Sign: '+' | '-' Magnitude: 'k' | 'M' | 'G' | 'T' | 'P' | 'm' | 'u' | 'n' | 'p' | 'f' Exponent: ('e'|'E') Sign? Digits Digits: ('0'..'9')+

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.

For any two instances x and y of a type that implements Summable, x.plus(y) may be written as:

x + y

The result of adding this number to the given Integer.

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).

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).

The product of all the floating point values in the given stream, 1.0 if the stream is empty, or an undefined value if and only if the stream contains an undefined value.

This expression produces the geometric mean of a list of floating point values:

Float.product(list) ^ (1.0/list.size)

Determines if this value is strictly smaller than the given value, where infinity is considered greater than every defined, finite value, and -infinity is considered smaller than every defined, finite value. Evaluates to false if this value, the given value, or both are undefined.

The smaller of the two given floating point values, or an undefined value if and only if one of the values is undefined.

The sum of all the floating point values in the given stream, 0.0 if the stream is empty, or an undefined value if and only if the stream contains an undefined value.

This expression produces the mean of a list of floating point values:

Float.sum(list) / list.size

The product of this number and the given number.

The result of multiplying this number by the given Integer.