Класс Double

• Если аргумент NaN, результатом является строка "NaN".
• В противном случае результатом является строка, представляющая знак и модуль (абсолютное значение) аргумента. Если знак отрицательный, первый символ результата — '-' ('\u002D'); если знак положительный, символ знака в результате не появляется. Что касается модуля m:
  • Если m бесконечность, она представлена символами "Infinity"; таким образом, положительная бесконечность даёт результат "Infinity", а отрицательная бесконечность — результат "-Infinity".
  • Если m ноль, она представлена символами "0.0"; таким образом, отрицательный ноль даёт результат "-0.0", а положительный ноль — результат "0.0".
  • В противном случае m положительно и конечно. Она преобразуется в строку в два этапа:
    • Выбор десятичного числа: Выбирается чётко определённое десятичное число d_m для представления m. Это десятичное число (почти всегда) является кратчайшим, которое округляется до m в соответствии с политикой округления до ближайшего значения арифметики с плавающей точкой IEEE 754.
    • Форматирование как строки: Десятичное число d_m форматируется как строка, либо в простом, либо в компьютерном научном формате, в зависимости от его значения.

Десятичное число — это число вида s×10ⁱ для некоторых (уникальных) целых чисел s > 0 и i, таких что s не кратно 10. Эти целые числа — мантисса и экспонента десятичного числа соответственно. Длина десятичного числа — (уникальное) положительное целое число n, удовлетворяющее условию 10^n-1 ≤ s < 10ⁿ.

Десятичное число d_m для конечного положительного m определяется следующим образом:

• Пусть R — множество всех десятичных чисел, которые округляются до m в соответствии с обычной политикой округления до ближайшего значения арифметики с плавающей точкой IEEE 754.
• Пусть p — минимальная длина среди всех десятичных чисел в R.
• Когда p ≥ 2, пусть T — множество всех десятичных чисел в R с длиной p. В противном случае пусть T — множество всех десятичных чисел в R с длиной 1 или 2.
• Определите d_m как десятичное число в T, которое наиболее близко к m. Или, если таких десятичных чисел в T два, выберите то, у которого чётная мантисса.

Выбранное (уникальное) десятичное число d_m затем форматируется. Пусть s, i и n — мантисса, экспонента и длина d_m соответственно. Кроме того, пусть e = n + i - 1 и пусть s₁…s_n — обычное десятичное разложение s. Обратите внимание, что s₁ ≠ 0 и s_n ≠ 0. Ниже, десятичная точка '.' является '\u002E', а индикатор экспоненты 'E' является '\u0045'.

• Случай -3 ≤ e < 0: d_m форматируется как 0.0…0s₁…s_n, где между десятичной точкой и s₁ ровно -(n + i) нулей. Например, 123 × 10^-4 форматируется как 0.0123.
• Случай 0 ≤ e < 7:
  • Подслучай i ≥ 0: d_m форматируется как s₁…s_n0…0.0, где между s_n и десятичной точкой ровно i нулей. Например, 123 × 10² форматируется как 12300.0.
  • Подслучай i < 0: d_m форматируется как s₁…s_n+i.s_n+i+1…s_n, где справа от десятичной точки ровно -i цифр. Например, 123 × 10^-1 форматируется как 12.3.
• Случай e < -3 или e ≥ 7: для форматирования d_m используется компьютерный научный формат. Здесь e форматируется как с помощью Integer.toString(int).
  • Подслучай n = 1: d_m форматируется как s₁.0Ee. Например, 1 × 10²³ форматируется как 1.0E23.
  • Подслучай n > 1: d_m форматируется как s₁.s₂…s_nEe. Например, 123 × 10^-21 форматируется как 1.23E-19.

Для создания локализованных строковых представлений значения с плавающей точкой используйте подклассы NumberFormat.

• Если аргумент NaN, результатом является строка "NaN".
• В противном случае результатом является строка, представляющая знак и модуль аргумента. Если знак отрицательный, первый символ результата — '-' ('\u002D'); если знак положительный, символ знака в результате не появляется. Что касается модуля m:
  • Если m бесконечность, она представлена строкой "Infinity"; таким образом, положительная бесконечность даёт результат "Infinity", а отрицательная бесконечность — результат "-Infinity".
  • Если m ноль, она представлена строкой "0x0.0p0"; таким образом, отрицательный ноль даёт результат "-0x0.0p0", а положительный ноль — результат "0x0.0p0".
  • Если m — значение с плавающей точкой с нормализованным представлением, для представления полей мантиссы и экспоненты используются подстроки. Ментисса представляется символами "0x1.", за которыми следует шестнадцатеричное представление остальной части мантиссы как дроби. Завершающие нули в шестнадцатеричном представлении удаляются, за исключением случая, когда все цифры нули, в этом случае используется единичный ноль. Далее экспонента представляется символами "p", за которыми следует десятичная строка необусловленной экспоненты, как если бы она была получена вызовом Integer.toString к значению экспоненты.
  • Если m — значение с плавающей точкой с субнормализованным представлением, мантисса представляется символами "0x0.", за которыми следует шестнадцатеричное представление остальной части мантиссы как дроби. Завершающие нули в шестнадцатеричном представлении удаляются. Далее экспонента представляется символами "p-1022". Обратите внимание, что в субнормализованной мантиссе должна быть хотя бы одна ненулевая цифра.

Если s является null, то генерируется NullPointerException.

Пробельные символы в начале и конце s игнорируются. Пробелы удаляются так же, как и методом String.trim(); то есть удаляются как пробельные символы ASCII, так и управляющие символы. Остальная часть s должна соответствовать правилам лексического синтаксиса для FloatValue:

FloatValue:

Sign_opt NaN

Sign_opt Infinity

Sign_opt FloatingPointLiteral

Sign_opt HexFloatingPointLiteral

SignedInteger

HexFloatingPointLiteral:

HexSignificand BinaryExponent FloatTypeSuffix_opt

HexSignificand:

HexNumeral

HexNumeral .

0x HexDigits_opt . HexDigits

0X HexDigits_opt . HexDigits

BinaryExponent:

BinaryExponentIndicator SignedInteger

BinaryExponentIndicator:

p

P

Для интерпретации локализованных строковых представлений значения с плавающей точкой используйте подклассы NumberFormat.

Обратите внимание, что заключительные спецификаторы формата, определяющие тип литерала с плавающей точкой (1.0f — это значение float; 1.0d — это значение double), не влияют на результаты этого метода. Другими словами, числовое значение входной строки преобразуется непосредственно в целевой тип с плавающей точкой. Последовательность преобразований в два этапа, строка в float и затем float в double, не эквивалентна прямому преобразованию строки в double. Например, литерал float равен значению double 0.10000000149011612; литерал float 0.1f представляет другое числовое значение, чем литерал double 0.1. (Числовое значение 0,1 не может быть точно представлено в двоичном числе с плавающей точкой.)

Чтобы избежать вызова этого метода для недопустимой строки и получения исключения NumberFormatException, можно использовать следующий регулярный выражение для проверки входной строки:

 final String Digits     = "(\\p{Digit}+)";
 final String HexDigits  = "(\\p{XDigit}+)";
 // an exponent is 'e' or 'E' followed by an optionally
 // signed decimal integer.
 final String Exp        = "[eE][+-]?"+Digits;
 final String fpRegex    =
     ("[\\x00-\\x20]*"+  // Optional leading "whitespace"
      "[+-]?(" + // Optional sign character
      "NaN|" +           // "NaN" string
      "Infinity|" +      // "Infinity" string

      // A decimal floating-point string representing a finite positive
      // number without a leading sign has at most five basic pieces:
      // Digits . Digits ExponentPart FloatTypeSuffix
      //
      // Since this method allows integer-only strings as input
      // in addition to strings of floating-point literals, the
      // two sub-patterns below are simplifications of the grammar
      // productions from section 3.10.2 of
      // The Java Language Specification.

      // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt
      "((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)|"+

      // . Digits ExponentPart_opt FloatTypeSuffix_opt
      "(\\.("+Digits+")("+Exp+")?)|"+

      // Hexadecimal strings
      "((" +
       // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt
       "(0[xX]" + HexDigits + "(\\.)?)|" +

       // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt
       "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" +

       ")[pP][+-]?" + Digits + "))" +
      "[fFdD]?))" +
      "[\\x00-\\x20]*");// Optional trailing "whitespace"
 if (Pattern.matches(fpRegex, myString))
     Double.valueOf(myString); // Will not throw NumberFormatException
 else {
     // Perform suitable alternative action
 }

(int)(v^(v>>>32))

long v = Double.doubleToLongBits(this.doubleValue());

Бит 63 (бит, выбираемый маской 0x8000000000000000L) представляет знак числа с плавающей точкой. Биты 62-52 (биты, выбираемые маской 0x7ff0000000000000L) представляют показатель степени. Биты 51-0 (биты, выбираемые маской 0x000fffffffffffffL) представляют мантиссу (иногда называемую мантиссой) числа с плавающей точкой.

Если аргумент — положительная бесконечность, результат равен 0x7ff0000000000000L.

Если аргумент — отрицательная бесконечность, результат равен 0xfff0000000000000L.

Если аргумент — NaN, результат равен 0x7ff8000000000000L.

Во всех случаях результат — целое число long , которое при передаче методу longBitsToDouble(long) произведёт значение с плавающей точкой, такое же, как и аргумент doubleToLongBits (за исключением всех значений NaN, которые сводятся к единственному "каноническому" значению NaN).

Бит 63 (бит, выбираемый маской 0x8000000000000000L) представляет знак числа с плавающей точкой. Биты 62-52 (биты, выбираемые маской 0x7ff0000000000000L) представляют показатель степени. Биты 51-0 (биты, выбираемые маской 0x000fffffffffffffL) представляют мантиссу (иногда называемую мантиссой) числа с плавающей точкой.

Если аргумент — положительная бесконечность, результат равен 0x7ff0000000000000L.

Если аргумент — отрицательная бесконечность, результат равен 0xfff0000000000000L.

Если аргумент — NaN, результат — целое число long , представляющее фактическое значение NaN. В отличие от метода doubleToLongBits , doubleToRawLongBits не сводит все битовые шаблоны, кодирующие NaN, к одному "каноническому" значению NaN.

Во всех случаях результат — целое число long , которое при передаче методу longBitsToDouble(long) произведёт значение с плавающей точкой, такое же, как и аргумент doubleToRawLongBits.

Если аргумент равен 0x7ff0000000000000L, результат — положительная бесконечность.

Если аргумент равен 0xfff0000000000000L, результат — отрицательная бесконечность.

Если аргумент имеет любое значение в диапазоне 0x7ff0000000000001L по 0x7fffffffffffffffL или в диапазоне 0xfff0000000000001L по 0xffffffffffffffffL, результат — NaN. Ни одна операция с плавающей точкой IEEE 754, предоставляемая Java, не может отличить два значения NaN одного типа с разными битовыми шаблонами. Разные значения NaN можно различить только с помощью метода Double.doubleToRawLongBits.

Во всех остальных случаях пусть s, e и m — три значения, которые можно вычислить из аргумента:

int s = ((bits >> 63) == 0) ? 1 : -1;
int e = (int)((bits >> 52) & 0x7ffL);
long m = (e == 0) ?
                (bits & 0xfffffffffffffL) << 1 :
                (bits & 0xfffffffffffffL) | 0x10000000000000L;

Обратите внимание, что этот метод может не вернуть NaN с точно таким же битовым шаблоном, как и аргумент long. IEEE 754 различает два типа NaN: тихие NaN и NaN-сигнализации. Различия между двумя типами NaN обычно не видны в Java. Арифметические операции над NaN-сигнализациями превращают их в тихие NaN с другим, но часто похожим, битовым шаблоном. Однако на некоторых процессорах простое копирование NaN-сигнализации также выполняет это преобразование. В частности, копирование NaN-сигнализации для возврата в вызывающий метод может выполнить это преобразование. Поэтому longBitsToDouble может не вернуть double с битовым шаблоном NaN-сигнализации. Следовательно, для некоторых long значений doubleToRawLongBits(longBitsToDouble(start)) может не равняться start. Кроме того, конкретные битовые шаблоны, представляющие NaN-сигнализации, зависят от платформы; хотя все битовые шаблоны NaN, тихие или сигнализирующие, должны находиться в диапазоне NaN, указанном выше.

• NaN не упорядочен по отношению к другим значениям и не равен самому себе в операторах сравнения. Этот метод выбирает определение Double.NaN равным самому себе и больше всех других значений double (включая Double.POSITIVE_INFINITY).
• Положительный и отрицательный ноль сравниваются численно, но являются различными и различимыми значениями. Этот метод выбирает определение положительного нуля (+0.0d) как большего, чем отрицательный ноль (-0.0d).

    Double.valueOf(d1).compareTo(Double.valueOf(d2))