Как проверить, является ли число бесконечным в Java

Введение

В этом практическом занятии (лабораторной работе) вы научитесь проверять, представляет ли значение типа double в Java положительную или отрицательную бесконечность. Это важный навык при работе с вещественными вычислениями, которые могут привести к результатам, выходящим за пределы стандартного числового диапазона, например, при делении на ноль.

С помощью практических упражнений вы будете использовать метод Double.isInfinite() для определения бесконечных значений, изучать, как деление на ноль может привести к бесконечности, и понимать разницу между бесконечными значениями и NaN (Not-a-Number - нечисло).

Использование метода Double.isInfinite() для проверки

На этом этапе мы научимся проверять, представляет ли значение типа double в Java положительную или отрицательную бесконечность. Это особенно полезно при работе с вычислениями, которые могут привести к значениям, выходящим за пределы нормального диапазона вещественных чисел, например, при делении на ноль.

В Java в классе Double предусмотрен встроенный метод isInfinite() специально для этой цели.

Создадим простую Java-программу, чтобы показать, как использовать метод Double.isInfinite().

Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт. Вы должны находиться в директории ~/project.
Замените все содержимое файла следующим кодом:
```
public class HelloJava {
    public static void main(String[] args) {
        double positiveInfinity = Double.POSITIVE_INFINITY;
        double negativeInfinity = Double.NEGATIVE_INFINITY;
        double finiteNumber = 10.0;

        System.out.println("Is positiveInfinity infinite? " + Double.isInfinite(positiveInfinity));
        System.out.println("Is negativeInfinity infinite? " + Double.isInfinite(negativeInfinity));
        System.out.println("Is finiteNumber infinite? " + Double.isInfinite(finiteNumber));
    }
}
```
Рассмотрим новые части этого кода:
- double positiveInfinity = Double.POSITIVE_INFINITY;: Эта строка объявляет переменную типа double и присваивает ей специальное значение, представляющее положительную бесконечность.
- double negativeInfinity = Double.NEGATIVE_INFINITY;: Эта строка объявляет переменную типа double и присваивает ей специальное значение, представляющее отрицательную бесконечность.
- double finiteNumber = 10.0;: Эта строка объявляет обычную переменную типа double с конечным значением.
- System.out.println("Is positiveInfinity infinite? " + Double.isInfinite(positiveInfinity));: Эта строка вызывает метод Double.isInfinite() с аргументом positiveInfinity. Метод возвращает true, если значение является бесконечным (положительной или отрицательной), и false в противном случае. Затем результат выводится в консоль.
- Следующие две строки System.out.println выполняют то же самое для negativeInfinity и finiteNumber.
Сохраните файл (Ctrl+S или Cmd+S).
Теперь скомпилируем нашу программу. Откройте терминал в нижней части WebIDE и убедитесь, что вы находитесь в директории ~/project. Выполните следующую команду:
```
javac HelloJava.java
```
Если компиляция прошла успешно, вы не увидите никакого вывода.
Наконец, запустите скомпилированную программу с помощью команды java:
```
java HelloJava
```
Вы должны увидеть вывод, похожий на следующий:
```
Is positiveInfinity infinite? true
Is negativeInfinity infinite? true
Is finiteNumber infinite? false
```

Этот вывод подтверждает, что метод Double.isInfinite() правильно определяет как положительную, так и отрицательную бесконечность, возвращая false для обычного конечного числа.

Тестирование с делением на ноль

На предыдущем этапе мы увидели, как работает метод Double.isInfinite() с предопределенными значениями бесконечности. Теперь рассмотрим распространенный сценарий, при котором в вычислениях может возникнуть бесконечность: деление на ноль.

В стандартной арифметике деление на ноль не определено. Однако в арифметике с плавающей запятой (которая используется для типа double), деление ненулевого числа на ноль приводит к положительной или отрицательной бесконечности, в зависимости от знака числителя. Деление нуля на ноль или бесконечности на бесконечность приводит к специальному значению, называемому "Not a Number" (NaN - нечисло), которое мы рассмотрим на следующем этапе.

Модифицируем нашу программу, чтобы продемонстрировать деление на ноль и проверить результат с помощью метода Double.isInfinite().

Откройте файл HelloJava.java в редакторе WebIDE. Вы должны находиться в директории ~/project.
Замените текущий код следующим:
```
public class HelloJava {
    public static void main(String[] args) {
        double positiveResult = 10.0 / 0.0;
        double negativeResult = -10.0 / 0.0;
        double zeroResult = 0.0 / 10.0;

        System.out.println("Result of 10.0 / 0.0: " + positiveResult);
        System.out.println("Is 10.0 / 0.0 infinite? " + Double.isInfinite(positiveResult));

        System.out.println("Result of -10.0 / 0.0: " + negativeResult);
        System.out.println("Is -10.0 / 0.0 infinite? " + Double.isInfinite(negativeResult));

        System.out.println("Result of 0.0 / 10.0: " + zeroResult);
        System.out.println("Is 0.0 / 10.0 infinite? " + Double.isInfinite(zeroResult));
    }
}
```
Рассмотрим, что происходит в этом новом коде:
- double positiveResult = 10.0 / 0.0;: Мы делим положительное число (10.0) на ноль (0.0). В арифметике с плавающей запятой это приводит к положительной бесконечности.
- double negativeResult = -10.0 / 0.0;: Мы делим отрицательное число (-10.0) на ноль (0.0). Это приводит к отрицательной бесконечности.
- double zeroResult = 0.0 / 10.0;: Мы делим ноль (0.0) на ненулевое число (10.0). Это приводит к нулю, которое является конечным числом.
- Затем мы выводим результаты этих делений и используем метод Double.isInfinite() для проверки, является ли каждый результат бесконечным.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте модифицированную программу в терминале:
```
javac HelloJava.java
```
Опять же, отсутствие вывода означает успешную компиляцию.

Запустите программу:

java HelloJava

Вы должны увидеть вывод, похожий на следующий:

Result of 10.0 / 0.0: Infinity
Is 10.0 / 0.0 infinite? true
Result of -10.0 / 0.0: -Infinity
Is -10.0 / 0.0 infinite? true
Result of 0.0 / 10.0: 0.0
Is 0.0 / 10.0 infinite? false

Это демонстрирует, что деление ненулевого вещественного числа на ноль корректно дает бесконечность (положительную или отрицательную), и метод Double.isInfinite() точно определяет эти результаты. Деление нуля на ненулевое число дает ноль, которое не является бесконечным.

Различия между бесконечностью и NaN

На предыдущих этапах мы изучили метод Double.isInfinite() и то, как деление на ноль может привести к бесконечности. Однако в арифметике с плавающей запятой есть еще одно специальное значение, называемое NaN, что означает "Not a Number" (нечисло). NaN представляет результат неопределенной или нерепрезентируемой операции, например, деление нуля на ноль или взятие квадратного корня из отрицательного числа.

Важно уметь различать бесконечные значения и NaN, так как они представляют разные типы исключительных результатов. В Java есть метод Double.isNaN(), который позволяет проверить, является ли значение типа double равным NaN.

Последний раз модифицируем нашу программу, чтобы включить вычисление, которое дает NaN, и посмотреть, как отличить его от бесконечности.

Откройте файл HelloJava.java в редакторе WebIDE. Вы должны находиться в директории ~/project.

Замените текущий код следующим:

public class HelloJava {
    public static void main(String[] args) {
        double positiveInfinity = 10.0 / 0.0;
        double nanResult = 0.0 / 0.0;
        double finiteNumber = 5.0;

        System.out.println("Result of 10.0 / 0.0: " + positiveInfinity);
        System.out.println("Is 10.0 / 0.0 infinite? " + Double.isInfinite(positiveInfinity));
        System.out.println("Is 10.0 / 0.0 NaN? " + Double.isNaN(positiveInfinity));

        System.out.println("Result of 0.0 / 0.0: " + nanResult);
        System.out.println("Is 0.0 / 0.0 infinite? " + Double.isInfinite(nanResult));
        System.out.println("Is 0.0 / 0.0 NaN? " + Double.isNaN(nanResult));

        System.out.println("Result of 5.0: " + finiteNumber);
        System.out.println("Is 5.0 infinite? " + Double.isInfinite(finiteNumber));
        System.out.println("Is 5.0 NaN? " + Double.isNaN(finiteNumber));
    }
}

Рассмотрим изменения:

double positiveInfinity = 10.0 / 0.0;: Мы сохраняем деление, которое дает положительную бесконечность.
double nanResult = 0.0 / 0.0;: Эта строка выполняет деление нуля на ноль, которое дает NaN.
double finiteNumber = 5.0;: Обычное конечное число для сравнения.
Теперь мы добавили вызовы метода Double.isNaN() для каждого результата, помимо метода Double.isInfinite().

Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте программу в терминале:
```
javac HelloJava.java
```

Запустите программу:

java HelloJava

Вы должны увидеть вывод, похожий на следующий:

Result of 10.0 / 0.0: Infinity
Is 10.0 / 0.0 infinite? true
Is 10.0 / 0.0 NaN? false
Result of 0.0 / 0.0: NaN
Is 0.0 / 0.0 infinite? false
Is 0.0 / 0.0 NaN? true
Result of 5.0: 5.0
Is 5.0 infinite? false
Is 5.0 NaN? false

Этот вывод четко показывает разницу между бесконечными значениями и NaN. Метод Double.isInfinite() возвращает true только для положительной или отрицательной бесконечности, в то время как метод Double.isNaN() возвращает true только для NaN. Для конечного числа оба метода возвращают false. Понимание этого различия является важным для обработки потенциальных ошибок и неожиданных результатов в арифметике с плавающей запятой.

Резюме

В этом практическом занятии мы научились проверять, представляет ли значение типа double в Java положительную или отрицательную бесконечность с помощью метода Double.isInfinite(). Мы увидели, как использовать этот метод с предопределенными значениями Double.POSITIVE_INFINITY и Double.NEGATIVE_INFINITY, а также с конечным числом, чтобы понять его поведение. Этот метод является важным для обработки потенциальных бесконечных результатов арифметических операций с плавающей запятой.