Comment vérifier si un nombre est infini en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une valeur de type double en Java représente l'infini positif ou négatif. Cette compétence est essentielle lorsqu'il s'agit de traiter des calculs à virgule flottante qui peuvent produire des résultats en dehors de la plage numérique standard, comme ceux impliquant une division par zéro.

Grâce à des exercices pratiques, vous utiliserez la méthode Double.isInfinite() pour identifier les valeurs infinies, explorerez comment une division par zéro peut conduire à l'infini et comprendrez la différence entre les valeurs infinies et NaN (Not-a-Number).

Skills Graph

Utilisation de Double.isInfinite() pour la vérification

Dans cette étape, nous allons apprendre à vérifier si une valeur de type double en Java représente l'infini positif ou négatif. Cela est particulièrement utile lorsqu'il s'agit de traiter des calculs qui peuvent aboutir à des valeurs en dehors de la plage normale des nombres à virgule flottante, comme une division par zéro.

Java propose une méthode intégrée appelée isInfinite() dans la classe Double spécialement à cette fin.

Créons un simple programme Java pour démontrer comment utiliser Double.isInfinite().

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert. Vous devriez être dans le répertoire ~/project.

2. Remplacez tout le contenu du fichier par le code suivant :

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

   Examinons les nouvelles parties de ce code :

   • double positiveInfinity = Double.POSITIVE_INFINITY; : Cette ligne déclare une variable de type double et lui assigne la valeur spéciale représentant l'infini positif.
   • double negativeInfinity = Double.NEGATIVE_INFINITY; : Cette ligne déclare une variable de type double et lui assigne la valeur spéciale représentant l'infini négatif.
   • double finiteNumber = 10.0; : Cette ligne déclare une variable double normale avec une valeur finie.
   • System.out.println("Is positiveInfinity infinite? " + Double.isInfinite(positiveInfinity)); : Cette ligne appelle la méthode Double.isInfinite() en utilisant positiveInfinity comme argument. La méthode retourne true si la valeur est infinie (positive ou négative) et false sinon. Le résultat est ensuite affiché dans la console.
   • Les deux lignes System.out.println suivantes font la même chose pour negativeInfinity et finiteNumber.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Maintenant, compilons notre programme. Ouvrez le terminal en bas de l'éditeur WebIDE et assurez-vous que vous êtes dans le répertoire ~/project. Exécutez la commande suivante :

   javac HelloJava.java

   Si la compilation réussit, vous ne verrez aucun message de sortie.

5. Enfin, exécutez le programme compilé en utilisant la commande java :

   java HelloJava

   Vous devriez voir une sortie similaire à ceci :

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

Cette sortie confirme que Double.isInfinite() identifie correctement à la fois l'infini positif et négatif, tout en retournant false pour un nombre fini normal.

Test avec une division par zéro

Dans l'étape précédente, nous avons vu comment Double.isInfinite() fonctionne avec des valeurs d'infini prédéfinies. Maintenant, explorons un scénario courant où l'infini peut apparaître dans les calculs : la division par zéro.

En arithmétique standard, la division par zéro est indéfinie. Cependant, en arithmétique à virgule flottante (que le type double utilise), diviser un nombre non nul par zéro donne l'infini positif ou négatif, selon le signe du numérateur. Diviser zéro par zéro, ou l'infini par l'infini, donne une valeur spéciale appelée "Not a Number" (NaN), que nous aborderons dans l'étape suivante.

Modifions notre programme pour démontrer la division par zéro et vérifier le résultat en utilisant Double.isInfinite().

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE. Vous devriez être dans le répertoire ~/project.

2. Remplacez le code actuel par le suivant :

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

   Voici ce qui se passe dans ce nouveau code :

   • double positiveResult = 10.0 / 0.0; : Nous divisons un nombre positif (10.0) par zéro (0.0). En arithmétique à virgule flottante, cela donne l'infini positif.
   • double negativeResult = -10.0 / 0.0; : Nous divisons un nombre négatif (-10.0) par zéro (0.0). Cela donne l'infini négatif.
   • double zeroResult = 0.0 / 10.0; : Nous divisons zéro (0.0) par un nombre non nul (10.0). Cela donne zéro, qui est un nombre fini.
   • Nous affichons ensuite les résultats de ces divisions et utilisons Double.isInfinite() pour vérifier si chaque résultat est infini.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme modifié dans le terminal :

   javac HelloJava.java

   Encore une fois, l'absence de sortie indique que la compilation a réussi.

5. Exécutez le programme :

   java HelloJava

   Vous devriez voir une sortie similaire à ceci :

   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

Cela démontre que diviser un nombre à virgule flottante non nul par zéro produit correctement l'infini (positif ou négatif), et que Double.isInfinite() identifie précisément ces résultats. Diviser zéro par un nombre non nul donne zéro, qui n'est pas infini.

Différencier l'infini du NaN

Dans les étapes précédentes, nous avons appris à utiliser Double.isInfinite() et à comprendre comment la division par zéro peut conduire à l'infini. Cependant, il existe une autre valeur spéciale en arithmétique à virgule flottante appelée NaN, qui signifie "Not a Number" (pas un nombre). Le NaN représente le résultat d'une opération indéfinie ou non représentable, comme la division de zéro par zéro ou la racine carrée d'un nombre négatif.

Il est important de pouvoir différencier les valeurs infinies du NaN, car elles représentent différents types de résultats exceptionnels. Java propose la méthode Double.isNaN() pour vérifier si une valeur de type double est un NaN.

Modifions notre programme une dernière fois pour inclure un calcul qui aboutit à un NaN et voyons comment le distinguer de l'infini.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE. Vous devriez être dans le répertoire ~/project.

2. Remplacez le code actuel par le suivant :

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

   Voici un détail des modifications :

   • double positiveInfinity = 10.0 / 0.0; : Nous conservons la division qui aboutit à l'infini positif.
   • double nanResult = 0.0 / 0.0; : Cette ligne effectue la division de zéro par zéro, qui donne un NaN.
   • double finiteNumber = 5.0; : Un nombre fini normal pour comparaison.
   • Nous incluons maintenant des appels à Double.isNaN() pour chaque résultat, en plus de Double.isInfinite().

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme dans le terminal :

   javac HelloJava.java

5. Exécutez le programme :

   java HelloJava

   Vous devriez voir une sortie similaire à ceci :

   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

Cette sortie montre clairement la différence entre les valeurs infinies et le NaN. Double.isInfinite() retourne true uniquement pour l'infini positif ou négatif, tandis que Double.isNaN() retourne true uniquement pour le NaN. Pour un nombre fini, les deux méthodes retournent false. Comprendre cette distinction est crucial pour gérer les erreurs potentielles et les résultats inattendus dans les calculs à virgule flottante.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une valeur de type double en Java représente l'infini positif ou négatif en utilisant la méthode Double.isInfinite(). Nous avons vu comment utiliser cette méthode avec les valeurs prédéfinies Double.POSITIVE_INFINITY et Double.NEGATIVE_INFINITY, ainsi qu'avec un nombre fini, pour comprendre son comportement. Cette méthode est essentielle pour gérer les résultats potentiellement infinis des calculs à virgule flottante.