"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. `-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|undefined]], 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. [floating point number]: http://www.validlab.com/goldberg/paper.pdf [NaN]: http://en.wikipedia.org/wiki/NaN" tagged("Basic types", "Numbers") shared native final class Float extends Object satisfies Number<Float> & Exponentiable<Float,Float> { "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" since("1.3.2") shared static Float sum({Float*} floats) { variable value sum = 0.0; for (float in floats) { sum += float; } return sum; } "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)" since("1.3.2") shared static Float product({Float*} floats) { variable value product = 1.0; for (float in floats) { product *= float; } return product; } "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." since("1.3.2") shared static Float|Absent max<Absent> (Iterable<Float,Absent> floats) given Absent satisfies Null { variable value max = 0.0/0.0; for (x in floats) { if (x.undefined || x==infinity) { return x; } if (max.undefined || x > max || x.strictlyPositive && max.strictlyNegative) { max = x; } } if (max.undefined) { assert (is Absent null); return null; } else { return max; } } "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." since("1.3.2") shared static Float|Absent min<Absent> (Iterable<Float,Absent> floats) given Absent satisfies Null { variable value min = 0.0/0.0; for (x in floats) { if (x.undefined || x==-infinity) { return x; } if (min.undefined || x < min || x.strictlyNegative && min.strictlyPositive) { min = x; } } if (min.undefined) { assert (is Absent null); return null; } else { return min; } } "The smaller of the two given floating point values, or an [[undefined]] value if and only if one of the values is undefined." since("1.3.2") shared static Float smallest(Float x, Float y) => if (x.strictlyNegative && y.strictlyPositive) then x else if (x.strictlyPositive && y.strictlyNegative) then y else if (x.undefined) then x else if (y.undefined) then y else if (x<y) then x else y; "The larger of the two given floating point values, or an [[undefined]] value if and only if one of the values is undefined." since("1.3.2") shared static Float largest(Float x, Float y) => if (x.strictlyNegative && y.strictlyPositive) then y else if (x.strictlyPositive && y.strictlyNegative) then x else if (x.undefined) then x else if (y.undefined) then y else if (x>y) then x else y; "The [[Float]] value of the given [[string representation|string]] 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')+" see (`function format`, `function Integer.parse`) tagged("Numbers", "Basic types") since("1.3.1") shared static Float|ParseException parse(String string) => parseFloatInternal(string); "The string decimal representation of the given [[floating point number|float]]. If the given number is [[negative|Float.negative]], the string representation will begin with `-`. The [[whole part|Float.wholePart]] and [[fractional parts|Float.fractionalPart]] 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." tagged("Numbers") see (`function parse`, `function Integer.format`) since("1.3.1") shared static String format( "The floating point value to format." Float float, "The minimum number of allowed decimal places. If `minDecimalPlaces<=0`, the result may have no decimal point." Integer minDecimalPlaces=1, "The maximum number of allowed decimal places. If `maxDecimalPlaces<=0`, the result always has no decimal point." Integer maxDecimalPlaces=9, "The character to use as the decimal separator. `decimalSeparator` may not be '-' or a digit as defined by the Unicode general category *Nd*." Character decimalSeparator = '.', "If not `null`, `thousandsSeparator` will be used to separate each group of three digits, starting immediately to the left of the decimal separator. `thousandsSeparator` may not be equal to the decimalSeparator and may not be '-' or a digit as defined by the Unicode general category *Nd*." Character? thousandsSeparator = null) => package.formatFloat(float, minDecimalPlaces, maxDecimalPlaces, decimalSeparator, thousandsSeparator); shared new(Float float) extends Object() {} "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|Object.equals]] (`==`) 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`. [NaN]: http://en.wikipedia.org/wiki/NaN" see (`function compare`) aliased("notANumber") 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 => if (this < 0.0) then -1 else if (this > 0.0) then 1 else 0; "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 => this > 0.0; "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 => this < 0.0; "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 => this > 0.0 || 1.0/this > 0.0; "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 => this < 0.0 || 1.0/this < 0.0; "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<sup>53</sup> and 2<sup>53</sup> (exclusive)." shared actual native Boolean equals(Object that); "A platform-dependent hash code for this `Float`." shared actual native Integer hash; "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`." throws (`class Exception`, "if either this value, the given value, or both are [[undefined]]") shared actual native Comparison compare(Float other) => if (this < other) then smaller else if (this > other) then larger else equal; shared actual native Float negated; 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); "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|other]] 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)`." shared actual native Float power(Float other); shared actual native Float wholePart; shared actual native Float fractionalPart; aliased("absolute") shared actual native Float magnitude => this <= 0.0 then 0.0-this else this; "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`") since("1.1.0") shared native Integer integer; shared actual native Float timesInteger(Integer integer) => times(integer.nearestFloat); shared actual native Float plusInteger(Integer integer) => plus(integer.nearestFloat); "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)`." shared actual native Float powerOfInteger(Integer integer); "A string representing this floating point number. - `\"NaN\"`, for any [[undefined value|undefined]] - `\"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 (`function formatFloat`) shared actual native String string; "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]]." shared actual native Boolean largerThan(Float other); "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]]." shared actual native Boolean smallerThan(Float other); "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]]." shared actual native Boolean notSmallerThan(Float other); "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]]." shared actual native Boolean notLargerThan(Float other); }