Cómo comprobar si un número es infinito en Java

Introducción

En este laboratorio, aprenderá cómo verificar si un valor de tipo double en Java representa infinito positivo o negativo. Esta es una habilidad crucial cuando se tratan cálculos de punto flotante que pueden producir resultados fuera del rango numérico estándar, como aquellos que involucran la división por cero.

A través de ejercicios prácticos, utilizará el método Double.isInfinite() para identificar valores infinitos, explorará cómo la división por cero puede conducir a infinito y entenderá la diferencia entre valores infinitos y NaN (No es un número).

Skills Graph

Uso de Double.isInfinite() para la comprobación

En este paso, aprenderemos cómo verificar si un valor de tipo double en Java representa infinito positivo o negativo. Esto es especialmente útil cuando se realizan cálculos que pueden resultar en valores fuera del rango normal de los números de punto flotante, como la división por cero.

Java proporciona un método integrado llamado isInfinite() en la clase Double específicamente para este propósito.

Vamos a crear un sencillo programa de Java para demostrar cómo usar Double.isInfinite().

1. Abra el archivo HelloJava.java en el editor WebIDE si no está abierto. Debería estar en el directorio ~/project.

2. Reemplace todo el contenido del archivo con el siguiente código:

   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));
       }
   }

   Veamos las nuevas partes de este código:

   • double positiveInfinity = Double.POSITIVE_INFINITY;: Esta línea declara una variable de tipo double y le asigna el valor especial que representa el infinito positivo.
   • double negativeInfinity = Double.NEGATIVE_INFINITY;: Esta línea declara una variable de tipo double y le asigna el valor especial que representa el infinito negativo.
   • double finiteNumber = 10.0;: Esta línea declara una variable double normal con un valor finito.
   • System.out.println("Is positiveInfinity infinite? " + Double.isInfinite(positiveInfinity));: Esta línea llama al método Double.isInfinite() con positiveInfinity como argumento. El método devuelve true si el valor es infinito (ya sea positivo o negativo) y false en caso contrario. El resultado se imprime luego en la consola.
   • Las siguientes dos líneas System.out.println hacen lo mismo para negativeInfinity y finiteNumber.

3. Guarde el archivo (Ctrl+S o Cmd+S).

4. Ahora, vamos a compilar nuestro programa. Abra la Terminal en la parte inferior del WebIDE y asegúrese de estar en el directorio ~/project. Ejecute el siguiente comando:

   javac HelloJava.java

   Si la compilación es exitosa, no verá ninguna salida.

5. Finalmente, ejecute el programa compilado usando el comando java:

   java HelloJava

   Debería ver una salida similar a esta:

   Is positiveInfinity infinite? true
   Is negativeInfinity infinite? true
   Is finiteNumber infinite? false

Esta salida confirma que Double.isInfinite() identifica correctamente tanto el infinito positivo como el negativo, mientras que devuelve false para un número finito normal.

Prueba con división por cero

En el paso anterior, vimos cómo funciona Double.isInfinite() con valores de infinito predefinidos. Ahora, exploremos un escenario común en el que el infinito puede surgir en los cálculos: la división por cero.

En la aritmética estándar, la división por cero está indefinida. Sin embargo, en la aritmética de punto flotante (que utiliza double), dividir un número distinto de cero por cero da como resultado infinito positivo o negativo, dependiendo del signo del numerador. Dividir cero entre cero, o infinito entre infinito, da como resultado un valor especial llamado "No es un número" (NaN, por sus siglas en inglés), que cubriremos en el siguiente paso.

Modifiquemos nuestro programa para demostrar la división por cero y comprobar el resultado utilizando Double.isInfinite().

1. Abra el archivo HelloJava.java en el editor WebIDE. Debería estar en el directorio ~/project.

2. Reemplace el código actual con el siguiente:

   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));
       }
   }

   Esto es lo que sucede en este nuevo código:

   • double positiveResult = 10.0 / 0.0;: Dividimos un número positivo (10.0) entre cero (0.0). En la aritmética de punto flotante, esto da como resultado infinito positivo.
   • double negativeResult = -10.0 / 0.0;: Dividimos un número negativo (-10.0) entre cero (0.0). Esto da como resultado infinito negativo.
   • double zeroResult = 0.0 / 10.0;: Dividimos cero (0.0) entre un número distinto de cero (10.0). Esto da como resultado cero, que es un número finito.
   • Luego imprimimos los resultados de estas divisiones y usamos Double.isInfinite() para comprobar si cada resultado es infinito.

3. Guarde el archivo (Ctrl+S o Cmd+S).

4. Compile el programa modificado en la Terminal:

   javac HelloJava.java

   Nuevamente, la ausencia de salida indica una compilación exitosa.

5. Ejecute el programa:

   java HelloJava

   Debería ver una salida similar a esta:

   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

Esto demuestra que dividir un número de punto flotante distinto de cero entre cero produce correctamente infinito (positivo o negativo), y Double.isInfinite() identifica con precisión estos resultados. Dividir cero entre un número distinto de cero da como resultado cero, que no es infinito.

Diferenciar entre infinito y NaN

En los pasos anteriores, aprendimos sobre Double.isInfinite() y cómo la división por cero puede resultar en infinito. Sin embargo, hay otro valor especial en la aritmética de punto flotante llamado NaN, que significa "No es un número" (Not a Number en inglés). NaN representa el resultado de una operación indefinida o no representable, como dividir cero entre cero o calcular la raíz cuadrada de un número negativo.

Es importante poder diferenciar entre valores infinitos y NaN, ya que representan diferentes tipos de resultados excepcionales. Java proporciona el método Double.isNaN() para verificar si un valor de tipo double es NaN.

Modifiquemos nuestro programa por última vez para incluir un cálculo que resulte en NaN y ver cómo distinguirlo del infinito.

1. Abra el archivo HelloJava.java en el editor WebIDE. Debería estar en el directorio ~/project.

2. Reemplace el código actual con el siguiente:

   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));
       }
   }

   Aquí está un desglose de los cambios:

   • double positiveInfinity = 10.0 / 0.0;: Mantenemos la división que resulta en infinito positivo.
   • double nanResult = 0.0 / 0.0;: Esta línea realiza la división de cero entre cero, lo que resulta en NaN.
   • double finiteNumber = 5.0;: Un número finito normal para comparación.
   • Ahora incluimos llamadas a Double.isNaN() para cada resultado, además de Double.isInfinite().

3. Guarde el archivo (Ctrl+S o Cmd+S).

4. Compile el programa en la Terminal:

   javac HelloJava.java

5. Ejecute el programa:

   java HelloJava

   Debería ver una salida similar a esta:

   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

Esta salida muestra claramente la diferencia entre valores infinitos y NaN. Double.isInfinite() devuelve true solo para infinito positivo o negativo, mientras que Double.isNaN() devuelve true solo para NaN. Para un número finito, ambos métodos devuelven false. Comprender esta distinción es crucial para manejar posibles errores y resultados inesperados en cálculos de punto flotante.

Resumen

En este laboratorio (lab), aprendimos cómo verificar si un valor de tipo double en Java representa infinito positivo o negativo utilizando el método Double.isInfinite(). Vimos cómo usar este método con los valores predefinidos Double.POSITIVE_INFINITY y Double.NEGATIVE_INFINITY, así como con un número finito, para entender su comportamiento. Este método es crucial para manejar posibles resultados infinitos de cálculos de punto flotante.