// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | |

// for details. All rights reserved. Use of this source code is governed by a | |

// BSD-style license that can be found in the LICENSE file. | |

part of dart.core; | |

/// A double-precision floating point number. | |

/// | |

/// Representation of Dart doubles containing double specific constants | |

/// and operations and specializations of operations inherited from | |

/// [num]. Dart doubles are 64-bit floating-point numbers as specified in the | |

/// IEEE 754 standard. | |

/// | |

/// The [double] type is contagious. Operations on [double]s return | |

/// [double] results. | |

/// | |

/// It is a compile-time error for a class to attempt to extend or implement | |

/// double. | |

abstract class double extends num { | |

static const double nan = 0.0 / 0.0; | |

static const double infinity = 1.0 / 0.0; | |

static const double negativeInfinity = -infinity; | |

static const double minPositive = 5e-324; | |

static const double maxFinite = 1.7976931348623157e+308; | |

double remainder(num other); | |

double operator +(num other); | |

double operator -(num other); | |

double operator *(num other); | |

double operator %(num other); | |

double operator /(num other); | |

int operator ~/(num other); | |

double operator -(); | |

double abs(); | |

/// The sign of the double's numerical value. | |

/// | |

/// Returns -1.0 if the value is less than zero, | |

/// +1.0 if the value is greater than zero, | |

/// and the value itself if it is -0.0, 0.0 or NaN. | |

double get sign; | |

/// Returns the integer closest to this number. | |

/// | |

/// Rounds away from zero when there is no closest integer: | |

/// `(3.5).round() == 4` and `(-3.5).round() == -4`. | |

/// | |

/// Throws an [UnsupportedError] if this number is not finite | |

/// (NaN or an infinity), . | |

int round(); | |

/// Returns the greatest integer no greater than this number. | |

/// | |

/// Rounds the number towards negative infinity. | |

/// | |

/// Throws an [UnsupportedError] if this number is not finite | |

/// (NaN or infinity), . | |

int floor(); | |

/// Returns the least integer which is not smaller than this number. | |

/// | |

/// Rounds the number towards infinity. | |

/// | |

/// Throws an [UnsupportedError] if this number is not finite | |

/// (NaN or an infinity), . | |

int ceil(); | |

/// Returns the integer obtained by discarding any fractional | |

/// part of this number. | |

/// | |

/// Rounds the number towards zero. | |

/// | |

/// Throws an [UnsupportedError] if this number is not finite | |

/// (NaN or an infinity), . | |

int truncate(); | |

/// Returns the integer double value closest to `this`. | |

/// | |

/// Rounds away from zero when there is no closest integer: | |

/// `(3.5).roundToDouble() == 4` and `(-3.5).roundToDouble() == -4`. | |

/// | |

/// If this is already an integer valued double, including `-0.0`, or it is not | |

/// a finite value, the value is returned unmodified. | |

/// | |

/// For the purpose of rounding, `-0.0` is considered to be below `0.0`, | |

/// and `-0.0` is therefore considered closer to negative numbers than `0.0`. | |

/// This means that for a value, `d` in the range `-0.5 < d < 0.0`, | |

/// the result is `-0.0`. | |

double roundToDouble(); | |

/// Returns the greatest integer double value no greater than `this`. | |

/// | |

/// If this is already an integer valued double, including `-0.0`, or it is not | |

/// a finite value, the value is returned unmodified. | |

/// | |

/// For the purpose of rounding, `-0.0` is considered to be below `0.0`. | |

/// A number `d` in the range `0.0 < d < 1.0` will return `0.0`. | |

double floorToDouble(); | |

/// Returns the least integer double value no smaller than `this`. | |

/// | |

/// If this is already an integer valued double, including `-0.0`, or it is not | |

/// a finite value, the value is returned unmodified. | |

/// | |

/// For the purpose of rounding, `-0.0` is considered to be below `0.0`. | |

/// A number `d` in the range `-1.0 < d < 0.0` will return `-0.0`. | |

double ceilToDouble(); | |

/// Returns the integer double value obtained by discarding any fractional | |

/// digits from `this`. | |

/// | |

/// If this is already an integer valued double, including `-0.0`, or it is not | |

/// a finite value, the value is returned unmodified. | |

/// | |

/// For the purpose of rounding, `-0.0` is considered to be below `0.0`. | |

/// A number `d` in the range `-1.0 < d < 0.0` will return `-0.0`, and | |

/// in the range `0.0 < d < 1.0` it will return 0.0. | |

double truncateToDouble(); | |

/// Provide a representation of this [double] value. | |

/// | |

/// The representation is a number literal such that the closest double value | |

/// to the representation's mathematical value is this [double]. | |

/// | |

/// Returns "NaN" for the Not-a-Number value. | |

/// Returns "Infinity" and "-Infinity" for positive and negative Infinity. | |

/// Returns "-0.0" for negative zero. | |

/// | |

/// For all doubles, `d`, converting to a string and parsing the string back | |

/// gives the same value again: `d == double.parse(d.toString())` (except when | |

/// `d` is NaN). | |

String toString(); | |

/// Parse [source] as an double literal and return its value. | |

/// | |

/// Accepts an optional sign (`+` or `-`) followed by either the characters | |

/// "Infinity", the characters "NaN" or a floating-point representation. | |

/// A floating-point representation is composed of a mantissa and an optional | |

/// exponent part. The mantissa is either a decimal point (`.`) followed by a | |

/// sequence of (decimal) digits, or a sequence of digits | |

/// optionally followed by a decimal point and optionally more digits. The | |

/// (optional) exponent part consists of the character "e" or "E", an optional | |

/// sign, and one or more digits. | |

/// The [source] must not be `null`. | |

/// | |

/// Leading and trailing whitespace is ignored. | |

/// | |

/// If the [source] string is not a valid double literal, the [onError] | |

/// is called with the [source] as argument, and its return value is | |

/// used instead. | |

/// Throws a [FormatException] if the [source] string is not valid | |

/// and no `onError` is provided. | |

/// | |

/// Examples of accepted strings: | |

/// ``` | |

/// "3.14" | |

/// " 3.14 \xA0" | |

/// "0." | |

/// ".0" | |

/// "-1.e3" | |

/// "1234E+7" | |

/// "+.12e-9" | |

/// "-NaN" | |

/// ``` | |

/// The [onError] parameter is deprecated and will be removed. | |

/// Instead of `double.parse(string, (string) { ... })`, | |

/// you should use `double.tryParse(string) ?? (...)`. | |

external static double parse(String source, | |

[@deprecated double onError(String source)?]); | |

/// Parse [source] as an double literal and return its value. | |

/// | |

/// Like [parse] except that this function returns `null` for invalid inputs | |

/// instead of throwing. | |

external static double? tryParse(String source); | |

} |