Что такое nan java

NaN в Java

Проще говоря, NaN — это числовое значение типа данных, которое означает «не число».

В этом кратком руководстве мы объясним значение NaN в Java и различные операции, которые могут создавать или использовать это значение.

2. Что такое NaN ?​

NaN обычно указывает на результат недопустимых операций. Например, попытка разделить ноль на ноль является одной из таких операций.

Мы также используем NaN для непредставимых значений. Квадратный корень из -1 является одним из таких случаев, поскольку мы можем описать значение ( i ) только комплексными числами.

Стандарт IEEE для арифметики с плавающей запятой (IEEE 754) определяет значение NaN . В Java этот стандарт реализуют типы с плавающей запятой float и double .

Java определяет константы NaN для типов float и double как Float .NaN и Double.NaN :

“ Константа, содержащая значение Not-a-Number (NaN) типа double. Это эквивалентно значению, возвращаемому Double.longBitsToDouble(0x7ff8000000000000L)».

«Константа, содержащая значение Not-a-Number (NaN) типа float. Это эквивалентно значению, возвращаемому Float.intBitsToFloat(0x7fc00000)».

У нас нет такого типа констант для других числовых типов данных в Java.

3. Сравнение с NaN ​

При написании методов на Java мы должны проверять, что ввод действителен и находится в ожидаемом диапазоне. Значение NaN не является допустимым входом в большинстве случаев. Поэтому мы должны убедиться, что входное значение не является значением NaN , и соответствующим образом обработать эти входные значения.

NaN нельзя сравнивать ни с каким значением плавающего типа. Это означает, что мы получим false для всех операций сравнения, включающих NaN (кроме «!=», для которого мы получаем true ).

Мы получаем истину для « x != x» тогда и только тогда , когда x равно NaN:

 System.out.println("NaN == 1 = " + (NAN == 1));   System.out.println("NaN > 1 = " + (NAN > 1));   System.out.println("NaN < 1 = "+ (NAN  1));   System.out.println("NaN != 1 = " + (NAN != 1));   System.out.println("NaN == NaN = " + (NAN == NAN));   System.out.println("NaN > NaN = " + (NAN > NAN));   System.out.println("NaN < NaN = "+ (NAN  NAN));   System.out.println("NaN != NaN = " + (NAN != NAN)); 

Давайте посмотрим на результат выполнения кода выше:

NaN == 1 = false NaN > 1 = false NaN < 1 = falseNaN != 1 = true NaN == NaN = false NaN > NaN = false NaN < NaN = falseNaN != NaN = true 

Следовательно, мы не можем проверить наличие NaN , сравнивая с NaN с помощью «==» или «!=». На самом деле нам следует редко использовать операторы «==» или «!=» с типами float или double .

Вместо этого мы можем использовать выражение « x ! = х» . Это выражение возвращает true только для NAN.

Мы также можем использовать методы Float.isNaN и Double.isNaN для проверки этих значений . Это предпочтительный подход, поскольку он более читаем и понятен:

 double x = 1;   System.out.println(x + " is NaN = " + (x != x));   System.out.println(x + " is NaN = " + (Double.isNaN(x)));   x = Double.NaN;   System.out.println(x + " is NaN = " + (x != x));   System.out.println(x + " is NaN = " + (Double.isNaN(x))); 

При запуске этого кода мы получим следующий результат:

1.0 is NaN = false 1.0 is NaN = false NaN is NaN = true NaN is NaN = true 

4. Операции, производящие NaN ​

При выполнении операций с типами float и double нам нужно знать о значениях NaN .

Некоторые методы и операции с плавающей запятой производят значения NaN вместо создания исключения. Нам может понадобиться явно обрабатывать такие результаты.

Распространенным случаем, приводящим к нечисловым значениям, являются математически неопределенные числовые операции :

 double ZERO = 0;   System.out.println("ZERO / ZERO = " + (ZERO / ZERO));   System.out.println("INFINITY - INFINITY = " +   (Double.POSITIVE_INFINITY - Double.POSITIVE_INFINITY));   System.out.println("INFINITY * ZERO = " + (Double.POSITIVE_INFINITY * ZERO)); 

Эти примеры приводят к следующему результату:

ZERO / ZERO = NaN INFINITY - INFINITY = NaN INFINITY * ZERO = NaN 

Числовые операции, которые не дают результатов в действительных числах, также производят NaN:

 System.out.println("SQUARE ROOT OF -1 = " + Math.sqrt(-1));   System.out.println("LOG OF -1 = " + Math.log(-1)); 

Эти заявления приведут к:

SQUARE ROOT OF -1 = NaN LOG OF -1 = NaN 

Все числовые операции с NaN в качестве операнда дают в результате NaN :

 System.out.println("2 + NaN = " + (2 + Double.NaN));   System.out.println("2 - NaN = " + (2 - Double.NaN));   System.out.println("2 * NaN = " + (2 * Double.NaN));   System.out.println("2 / NaN = " + (2 / Double.NaN)); 

И результат вышеизложенного:

2 + NaN = NaN 2 - NaN = NaN 2 * NaN = NaN 2 / NaN = NaN 

Наконец, мы не можем присвоить null переменным типа double или float . Вместо этого мы можем явно присвоить NaN таким переменным, чтобы указать отсутствующие или неизвестные значения:

 double maxValue = Double.NaN; 

5. Вывод​

В этой статье мы обсудили NaN и различные связанные с ним операции. Мы также обсудили необходимость обработки NaN при явном выполнении вычислений с плавающей запятой в Java.

Полный исходный код можно найти на GitHub .

• 1. Обзор
• 2. Что такое NaN ?
• 3. Сравнение с NaN
• 4. Операции, производящие NaN
• 5. Вывод

Что такое nan java

Глобальное свойство NaN является значением, представляющим не-число (Not-A-Number).

Атрибуты свойства NaN
Записываемое	нет
Перечисляемое	нет
Настраиваемое	нет

Интерактивный пример

Описание

NaN является свойством глобального объекта.

Начальным значением NaN является Not-A-Number (не-число) — то же самое значение, что и у Number.NaN . В современных браузерах NaN является ненастраиваемым и незаписываемым свойством. Даже когда это не так, избегайте его переопределения.

В программах NaN используется довольно редко. Это возвращаемое значение в ситуациях, когда математические ( Math ) функции не срабатывают должным образом (например, при вызове Math.sqrt(-1) ) или когда функция, пытающаяся считать число из строки, терпит неудачу по причине того, что в строке не число ( parseInt(‘blabla’) ).

Проверка на равенство NaN

NaN является неравным (посредством сравнения через == , != , === , and !== ) любому другому значению, включая другое значение NaN. Используйте Number.isNaN() или isNaN() , чтобы наиболее понятным образом определить является ли значение значением NaN. Или выполните само-сравнение: NaN, и только NaN, в результате такого сравнения будет неравным самому себе.

NaN === NaN; // false Number.NaN === NaN; // false isNaN(NaN); // true isNaN(Number.NaN); // true function valueIsNaN(v)  return v !== v; > valueIsNaN(1); // false valueIsNaN(NaN); // true valueIsNaN(Number.NaN); // true 

Тем не менее, обратите внимание на разницу между функцией isNaN() и методом Number.isNaN() : первая вернёт true , если значение в настоящий момент является NaN , или если оно станет NaN после того, как преобразуется в число, в то время как последний вернёт true , только если текущим значением является NaN :

isNaN("hello world"); // true Number.isNaN("hello world"); // false 

Спецификации

Specification
ECMAScript Language Specification # sec-value-properties-of-the-global-object-nan

Совместимость с браузерами

BCD tables only load in the browser

Смотрите также

Found a content problem with this page?

• Edit the page on GitHub.
• Report the content issue.
• View the source on GitHub.

This page was last modified on 7 авг. 2023 г. by MDN contributors.

Your blueprint for a better internet.

MDN

Support

• Product help
• Report an issue

Our communities

Developers

• Web Technologies
• Learn Web Development
• MDN Plus
• Hacks Blog

• Website Privacy Notice
• Cookies
• Legal
• Community Participation Guidelines

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2023 by individual mozilla.org contributors. Content available under a Creative Commons license.

Проверьте, равен ли двойной номер NaN в Java

В этом посте будет обсуждаться, как проверить, равно ли значение double NaN в Java.

Значение Not-a-Number (NaN) можно интерпретировать как неопределенное или непредставимое значение, особенно в арифметике с плавающей запятой. В Java вы не можете сравнивать NaN с числом с плавающей запятой или двойным числом, используя == оператор, согласно стандарту IEEE 754 с плавающей запятой.

1. Использование isNaN() метод

The Double класс предоставляет статический метод isNaN(double) который возвращает true, если указанное число является NaN, и false в противном случае.

Приложение E. Специальные значения с плавающей запятой

Деление целого на ноль недопустимо и выбрасывает ArithmeticException, но деление значения с плавающей запятой на ноль не вызывает исключения. Арифметика с плавающей запятой может переполняться до бесконечности, если результат операции слишком велик для double или float или стремиться к нулю, если результат слишком мал для double или float. Java предоставляет специальные значения с плавающей запятой POSITIVE_INFINITY, NEGATIVE_INFINITY и NaN (Not a Number – не число) для обозначения этих результатов. Эти значения определяются как специальные константы в классе Float и Double.

Если положительное число с плавающей запятой делится на ноль, результат будет POSITIVE_INFINITY. Если отрицательное число с плавающей запятой делится на ноль, результатом является NEGATIVE_INFINITY. Если ноль с плавающей точкой делится на ноль, результатом является NaN, что означает, что результат математически не определен. Строковыми представлениями этих трех значений являются Infinity, -Infinity и NaN. Например,

System.out.print(1.0 / 0); // Печатает Infinity System.out.print(–1.0 / 0); // Печатает -Infinity System.out.print(0.0 / 0); // Печатает NaN

Эти специальные значения также могут использоваться в качестве операндов в вычислениях. Например, число, разделенное на POSITIVE_INFINITY, дает положительный ноль. В таблицеприведены различные комбинации операторов /, *, %, +, и —

x	y	x/y	x*y	x%y	x+y	x-y
Конечное число	± 0.0	± infinity	± 0.0	NaN	Конечное число	Конечное число
Конечное число	± infinity	± 0.0	± 0.0	x	± infinity	infinity
± 0.0	± 0.0	NaN	± 0.0	NaN	± 0.0	± 0.0
± infinity	Конечное число	± infinity	± 0.0	NaN	± infinity	± infinity
± infinity	± infinity	NaN	± 0.0	NaN	± infinity	infinity
± 0.0	± infinity	± 0.0	NaN	± 0.0	± infinity	± 0.0
NaN	Любое число	NaN	NaN	NaN	NaN	NaN
Любое число	NaN	NaN	NaN	NaN	NaN	NaN

Примечание: если одним из операндов является NaN, то результатом будет NaN.