← (précédent) A.4 LLes variables (2) : opérateurs et opérations
A.6 La classe String
Accueil S O M M A I R E

A.5 La classe Math

Cette classe contient des fonctions permettant d' effectuer des opérations mathématiques élémentaires telles que l'exponentiel, le logarithme, la racine carrée, les fonctions trigonométriques, les minimums et les maximums, etc...

Cette classe fournit par ailleurs deux variables constantes qui sont : Math.PI correspondant au fameux pi = 3.14 et Math.E correspondant au e de l' exponentielle. Commençons d' ailleurs par là.
EXEMPLE ZERO :

1.     public class ConstantesMaths
2.     {
3.          public static void main (String [] args)
4.          {
5.               System.out.println("valeur de pi  = " + Math.PI);
6.               System.out.printl("valeur de l' exponentielle = " + Math.E);
7.          }
8.     }


Compilez puis exécutez ce programme, il sera affiché :

valeur de pi = 3.141592653589793
valeur de l' exponentielle = 2.718281828459045


Vous l' aurez compris, Math.PI et Math.E sont des variables prédéfinies. De plus, elles sont constantes. C' est pourquoi leur nom est tout en majuscules. Je devine la question que vous vous posez. Pourquoi les autres lettres de Math ne sont-ils pas en majuscules ? Bonne question. Car en fait, les noms de ces variables sont en fait : PI et E. Pourquoi alors écrire Math.E et Math.PI ? La réponse est toute simple. Vous vous souvenez, je vous ai dit que lorsqu' on utilise une fonction dans la classe où elle n' est pas définie, on écrit le nom de la classe suivi d' un point, suivi du nom de la fonction. Exemple : Lire.entierByte() est l' utilisation de la fonction entierByte() de la classe Lire dans une classe différente de Lire. De même, quand on utilise une variable dans une classe dans laquelle est elle n' est pas définie, on l' utilise en écrivant le nom de la classe suivie d' un point, suivi du nom de la variable. D' où Math.PI et Math.E Le nom de la classe Math, comme toute classe, a seulement sa première lettre écrite en majuscules. Pigé ? Math.PI représente le fameux pi qui permet de calculer surface ou périmètre d' un cercle.
Math.E représente le fameux e dont le logarithme népérien est égal à 1. On l' appelle le nombre d' Euler.
EXEMPLE 1 :

1.     public class FonctionsMaths1
2.     {
3.          public static void main (String [] args)
4.          {
5.               double d1 = 6524.13;  double d2 = - 6524.13;              
6.               float f1 = 25.11f; float f2 = - 25.11f;
7.               long l1 = 36254789541l; long l2 = - 36254789541l;
8.               int i1 = 23541;   int i2 = - 23541;
9.               System.out.println("valeur absolue de d1 = " + Math.abs(d1));
10.              System.out.println("valeur absolue de d2 = " + Math.abs(d2));
11.              System.out.println("valeur absolue de f1 = " + Math.abs(f1));
12.              System.out.println("valeur absolue de f2 = " + Math.abs(f2));
13.              System.out.println("valeur absolue de l1 = " + Math.abs(l1));
14.              System.out.println("valeur absolue de l2 = " + Math.abs(l2));
15.              System.out.println("valeur absolue de i1 = " + Math.abs(i1));
16.              System.out.println("valeur absolue de i2 = " + Math.abs(i2));
17.         }
18.    }


Compilez puis exécutez ce programme, il sera affiché :

valeur absolue de d1 = 6524.13
valeur absolue de d2 = 6524.13
valeur absolue de f1 = 25.11
valeur absolue de f2 = 25.11
valeur absolue de l1 = 36254789541l
valeur absolue de l2 = 36254789541l
valeur absolue de i1 = 23541
valeur absolue de i2 = 23541


Vous l' aurez compris, la fonction abs() de la classe Math fournit la valeur absolue d' un nombre réel. Comme je vous l' ai déjà dit, En programmation structurée, quand on utilise une fonction dans une classe dans laquelle elle n' est pas définie, on précise le nom de la classe. Nom de la classe suivie d' un point, suivi du nom de la fonction. D' où Math.abs().

La fonction abs() accepte dans ses parenthèses une valeur (on dit aussi que la fonction abs() requiert un argument) de type byte, short, int, long, float ou double. A partir de maintenant, sachez que si une fonction requiert un argument de type nombre réel double, alors, tout nombre (byte, short, int, long ou float) convient. Puisque Java fait la conversion implicite de tout nombre en double.
EXEMPLE 2 :

1.     public class FonctionsMaths2
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = 0.707;
6.               System.out.println("arc-cosinus de a = " + Math.acos(a) + " radians");
7.               System.out.println("arc-sinus de a = " + Math.asin(a) + " radians"); 
8.               System.out.println("arc-tangente de a = " + Math.atan(a) + " radians");   
9.               
10.               
11.        }
12.    }


Compilez puis exécutez ce programme, il sera affiché :

arc-cosinus de a = 0.7855491633997437
arc-sinus de a = 0.785247163395153
arc-tangente de a = 0.6154085176292563


La fonction acos() fournit (on dit aussi renvoie ou retourne) l'arc-cosinus d'un angle, dont la valeur se trouve dans l'intervalle 0 et pi radians. On met dans les parenthèses de la fonction, la valeur du cosinus dont on cherche l' angle.
Rappelons que si y = arc-cosinus(x), alors x = cosinus(y).
Dans ses parenthèses, on y met une valeur comprise entre -1 et +1 dont le type est byte, short, int, long, float ou double

La fonction asin() fournit l'arc-sinus d'un angle, dont la valeur se trouve dans l'intervalle - pi/2 et + pi/2 radians. On met dans les parenthèses, la valeur du sinus dont on cherche l' angle. Rappelons que si y = arc-sinus(x), alors x = sinus(y).
Dans ses parenthèses, on y met une valeur comprise entre -1 et +1 dont le type est byte, short, int, long, float ou double

La fonction atan() fournit l'arc-tangente d'un angle, dont la valeur se trouve dans l'intervalle - pi/2 et + pi/2 radians. On met dans les parenthèses, la valeur du sinus dont on cherche l' angle.
Rappelons que si y = arc-tangente(x), alors x = tangente(y).
Dans ses parenthèses, on y met une valeur comprise entre -infini et + infini dont le type est byte, short, int, long, float ou double
EXEMPLE 3 :

1.     public class FonctionsMaths3
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = Math.PI/2;
6.               System.out.println("cosinus de a = " + Math.cos(a) );
7.               System.out.println("sinus de a = " + Math.sin(a) ); 
8.               System.out.println("tangente de a = " + Math.tan(a) );   
9.               
10.               
11.        }
12.    }


compilez puis exécutez ce programme, il sera affiché :

cosinus de a = 6.123233995736766E-17
sinus de a = 1.0
tangente de a = 1.63312393537E16

ligne 7 : on affecte la valeur pi sur 2 à la variable a qui représente la valeur d' un angle en radians. Math.PI représente la variable prédéfinie dont la valeur est le fameux pi = 3.14..... En dégré, pi radians = 180 dégrés. donc Math.PI/2 = 90 dégrés. le cosinus est infiniment petit. La lettre E représente l' exposant. on a donc 6.12... 10 puissance moins 17, presque zéro. La tangente est infiniement grand : 1.63... 10 puissance plus 16.

La fonction cos() de la classe Math fournit le cosinus d' un angle. Cette fonction requiert comme argument, un nombre de type double, et fournit une valeur de type double comprise entre -1.0 et +1.0
La fonction sin() de la classe Math fournit le sinus d' un angle. Cette fonction requiert comme argument, un nombre de type double, et fournit une valeur de type double comprise entre -1.0 et +1.0
La fonction tan() de la classe Math fournit la tangente d' un angle. Cette fonction requiert comme argument, un nombre de type double, et fournit une valeur de type double comprise entre - infini et + infini
EXEMPLE 4 :

1.     public class FonctionsMaths4
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = 1; 
6.               System.out.println("exponentielle a = " + Math.exp(a) ); 
7.               System.out.println("logarithme népérien de a  = " + Math.log(a) );   
8.               System.out.println("logarithme népérien de e  = " + Math.log(Math.E) );
9.               
10.        }
11.    }


compilez puis exécutez ce programme, il sera affiché :

exponentielle a = 2.718281828459045
logarithme népérien de a = 0.0
logarithme népérien de e = 1.0


La fonction exp() de la classe Math requiert un argument de type double et fournit une valeur de type double égale à (Math.E) élevé à la puissance du nombre qui se trouve dans les parenthèses. Comme a = 1, alors exponentielle a = e, le nombre d' Euler
La fonction log() de la classe Math requiert un argument de type double et renvoie le logarithme népérien (ln) du nombre qui se trouve entre ses parenthèses. C' est pourquoi ln(1) donne zéro (0.0) et ln(e) donne 1.
EXEMPLE 5 :

1.     public class FonctionsMaths5
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = 24.253; double b = 35.14;
6.               System.out.println("le plus grand nombre entre a et b = " + Math.max(a, b) ); 
8.               System.out.println("le plus petit nombre entre a et b = " + Math.min(a, b) );   
7.               
8.               
9.         }
10.    }


compilez puis exécutez ce programme, il sera affiché :

le plus grand nombre entre a et b = 35.14 le plus petit nombre entre a et b = 24.253

La fonction max() de la classe Math requiert deux arguments de type double et fournit le plus grand des deux.
La fonction min() de la classe Math requiert deux arguments de type double et fournit le plus petit des deux.
EXEMPLE 6 :

1.     public class FonctionsMaths6
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = 33.3; double b = 124.42; double c = 124.52
6.               System.out.println("partie entière de (a + 1) = " + Math.ceil(a) ); 
7.               System.out.println("partie entière de a = " + Math.floor(a) );   
8.               System.out.println("nombre entier plus proche de b = " + Math.round(b) ); 
9.               System.out.println("nombre entier plus proche de c = " + Math.round(c) ); 
10.        }
11.    }


compilez puis exécutez ce programme, il sera affiché :

partie entière de (a + 1) = 34.0
partie entière de a = 33.0
nombre entier plus proche de b = 124
nombre entier plus proche de c = 125


La fonction ceil() de la classe Math requiert un argument de type double et fournit un nombre réel égal à la partie entière de l' argument + 1
La fonction floor() de la classe Math requiert un argument de type double et fournit un nombre réel égal à la partie entière de l' argument
La fonction round() de la classe Math requiert un argument de type double et fournit un nombre entier de type long égal à la partie entière de l' argument si le premier chiffre de la partie décimale est strictement inférieur à 5. Si ce chiffre est supérieur ou égal à 5, alors le nombre entier est égal à la partie entière de l' argument + 1.
EXEMPLE 7:

1.     public class FonctionsMaths7
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = 2.0; double b = 3.0; double c = 16.0;
6.               System.out.println("a puissance b = " + Math.pow(a, b) ); 
7.               System.out.println("b puissance a = " + Math.pow(b, a) ); 
8.               System.out.println("racine carrée de c = " + Math.sqrt(c) ); 
9.              
10.        }
11.    }
compilez puis exécutez, il sera affiché :
a puissance b = 8.0
b puissance a = 6.0 racine carrée de c = 4.0

La fonction pow() de la classe Math requiert 2 arguments de type double et fournit un nombre de type double égal au premier nombre élevé à la puissance du deuxième. Remarquez la différence dans les 2 premiers résultats.

La fonction sqrt() de la classe Math requiert un seul argument de type double et fournit unn nombre de type double égal à la racine carrée de l' argument .
EXEMPLE 8:

1.     public class FonctionsMaths8
2.     {
3.          public static void main (String [] args)
4.          {
5.               System.out.println("un nombre au hasard compris entre 0 et 1 = " + Math.random());
6.              
7.          }
8.    }
compilez puis exécutez, il sera affiché :
un nombre au hasard compris entre 0 et 1 = ?

Le point d' intérrogation représente un nombre pris au hasard entre 0 et 1. Ce nombre est supérieur ou égal à zéro et strictement inférieur à 1

La fonction random() de la classe Math ne requiert aucun argument. Elle se contente de fournir un nombre de type double pris au hasard entre 0 et 1. L' intervalle [0, 1[ est fermée à zéro et ouvert à 1.

A partir de cette fonction, on pourra générer des nombres entiers compris dans n' importe quel intervalle. Par exemple, un nombre compris entre zéro et 50. Voir exemple suivant.
Jusqu' ici, nous nous sommes contentés d' afficher les valeurs fournies par les fonctions de la classe Math. Sachez qu' on peut mettre ces valeurs dans des variables. Par exemple si on veut les transformer. exemple suivant...
EXEMPLE 9:

1.     public class FonctionsMaths9
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = Math.random() * 50;
5.               System.out.println("un nombre au hasard compris entre 0 et 50 (50 exclu) = " + a);
6.              
7.          }
8.    }


compilez puis exécutez, il sera affiché :
un nombre au hasard compris entre 0 et 50 = ?

Le point d' intérrogation représente un nombre pris au hasard entre 0 et 50.
La fonction random() de la classe Math ne requiert aucun argument. Elle se contente de fournir un nombre de type double pris au hasard entre 0 et 1. Ici, on a multiplié ce nombre par 50, puis on a mis le résultat dans une variable de type double. Normal, Math.random() fournit un nombre de type double. Ce nombre, multiplié par 50, donne aussi un nombre de type de double. L' intervalle [0, 1[ multiplié par 50 donne l' intervalle [0, 50[. Donc la variable a contiendra un nombre pris au hasard et compris entre 0 et 50. 50 étant exclu.

Si vous voulez voir un autre nombre au hasard, exécutez sans compiler. On recompile un programme seulement lorsqu' on a changé de code.
Il existe d' autres fonctions de la classe Math. Vous pouvez les trouver sur la plate-forme java en tapant dans google plateforme java
Attention, si vous êtes nul en anglais, vous aurez du mal à les comprendre.



Vous avez remarqué, les fonctions de la classe Math fournissent souvent des valeurs avec plusieurs chiffres après la virgule (après le point). Comment faire pour limiter le nombre de chiffres après la virgule ?... Exemple suivant :
EXEMPLE 10:

1.     public class FonctionsMaths10
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = 2.23541326897; 
6.               a = a * 100;
7.               System.out.println("nouvelle valeur de a = " + a);
8.               a = Math.round(a);
9.               System.out.println("partie enti\u00e8re de a = " + a);
10.              a /= 100;
11.              System.out.println("valeur de a avec 2 chiffres en partie décimale = " + a ); 
12.              
13.        }
14.    }


Pour afficher une variable de type double en limitant le nombre de chiffres en partie décimale à 2, on commence par le multiplier par 100. D' où l' affichage : nouvelle valeur de a = 223.541326897Pour 3 chiffres, on multiplie par 1000, etc...
Ensuite, on donne à a la valeur correspondant à sa partie entière. Mais la fonction Math.round() fournit la partie entière augmentée de 1 parce que le premier chiffre de la partie décimale est supérieure ou égale à 5. D' où l' affichage : partie entière de a = 224.0
Je rappelle que bien que la fonction Math.round() fournisse une valeur de type long (voir exemple 6), on peut la mettre dans une variable de type double. Il y a conversion implicite du type long en type double. C' est pourquoi au lieu de 224, on a 224.0
Ensuite, je rappelle que a /= 100; veut dire a = a / 100; (Exemple 11 de la partie 1.4 les variables (II)) Donc on divise la valeur de a (224.0) par 100, puis on met le résultat dans la variable a. D' où l' affichage : valeur de a avec 2 chiffres en partie décimale = 2.24




Nous savons que la fonction Math.random() fournit un nombre compris entre 0 et 1. Nous savons que nous pouvons élargir cet intervalle en multipliant la fonction par un nombre.
Math.random() * 50 fournit un nombre dans l'intervalle [0 50[
Math.random() * 100 fournit un nombre dans l'intervalle [0 100[
Math.random() * 111 fournit un nombre dans l'intervalle [0 111[ etc, etc...

Nous savons que ce nombre est forcément de type double. Maintenant, supposons que nous voulions un nombre entier compris entre 0 et 50. Que faire ? ...
Exemple suivant.

EXEMPLE 11:

1.     public class FonctionsMaths11
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = Math.random() * 50;
6.               System.out.println("un nombre au hasard compris dans [0 50[ = " + a);
7.               int b = (int)a;
8.               System.out.println("un nombre entier au hasard compris dans [0 50[ = " + b);
9.               
10.         }
11.   }
Compilez puis exécutez ce programme. Il sera affiché :

un nombre au hasard compris dans [0 50[ = ? un nombre entier au hasard compris dans [0 50[ = ?entier Explications :

? représente un nombre de type double compris entre 0 et 50 (50 exclu)
?entier représente n'importe quel nombre entier compris entre 0 et 50 (50 exclu)

Ligne 5 : je mets dans la variable a de type double, un nombre généré au hasard entre 0 et 50.
Ligne 6 : affichage de "un nombre au hasard compris dans [0 50[ = ?
ligne 7 : Je mets dans la variable b de type int, la variable a de type double, mais préalablement castée (convertie) en type int.

Reppel : si on met une valeur de type double dans une variable de type int (moins étendue), on se retrouve avec l'affichage d'une erreur à la compilation comme
error : possible loss of precision
Pour éviter ça, on converti d'abord le type plus étendu en le type moins étendu. D'où la ligne 7 : (int)a

Ainsi, dans la variable b, c'est seulement la partie entière de a qui y sera affectée.



Nous savons que la fonction Math.random() fournit un nombre compris entre 0 et 1. Nous savons que nous pouvons élargir cet intervalle en multipliant la fonction par un nombre.
Math.random() * 50 fournit un nombre dans l'intervalle [0 50[
Math.random() * 100 fournit un nombre dans l'intervalle [0 100[
Math.random() * 111 fournit un nombre dans l'intervalle [0 111[ etc, etc...

Mais si nous voulons un nombre au hasard (entier ou non) compris entre 5 et 50, que faire ?
exemple suivant
EXEMPLE 12:

1.     public class FonctionsMaths12
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = Math.random() * 50;
6.               System.out.println("un nombre au hasard compris dans [0 50[ = " + a);
7.               a = a + 5;
8.               System.out.println("un nombre au hasard compris dans [5 55[ = " + a);
9.               int b = (int)a;
10.              System.out.println("un nombre entier au hasard compris dans [5 55[ = " + b);
11.              
12.         }
13.   }
compilez puis exécutez ce programme, il sera affiché :

un nombre au hasard compris dans [0 50[ = ?
un nombre au hasard compris dans [5 55[ = ??
un nombre au hasard compris dans [5 55[ = ???

Explications :

ligne 5 : dans la variable a de type double, j'affecte un nombre pris au hasard entre 0 et 50 (50 exclu)
ligne 6 : affichage de la valeur de a. ? = nombre au hasard entre 0 et 50
ligne 7 : j'ajoute la valeur 5 = a. Donc, on passe de l'intervalle [0 50[ à l'intervalle [0 55[
ligne 8 : affichage de la valeur de a. ?? = nombre au hasard entre 0 et 55 (55 exclu)
ligne 9 : je caste a en type int (nombre entier) et je sa valeur dans la variable de type int b
ligne 10 : affichage de la valeur de b. ??? = nombre au hasard entre 5 et 55 (55 exclu)

Mais il y a un problème. Je vous ai dit juste avant d'écrire l'exemple 12 ci-dessus, qu'on allait chercher un nombre au hasard entre 5 et 55 et non entre 0 et 55. Or, quand on ajoute une valeur (ici, 5 en l'occurence) à un intervalle, il s'ajoute aux 2 bornes de l'intervalle.
Alors que faire pour obtenir un nombre dans l'intervalle 5 et 55. C'est tout simple.
On ne choisit plus l'intervale [0 50[, mais plutôt l'intervalle [0 45[. Ainsi, en ajout ajoutant 5 à cet intervalle, on obtient [5 50[. L'exemple 12 devient alors ceci :
EXEMPLE 13:

1.     public class FonctionsMaths13
2.     {
3.          public static void main (String [] args)
4.          {
5.               double a = Math.random() * 45;
6.               System.out.println("un nombre au hasard compris dans [0 45[ = " + a);
7.               a = a + 5;
8.               System.out.println("un nombre au hasard compris dans [5 50[ = " + a);
9.               int b = (int)a;
10.              System.out.println("un nombre entier au hasard compris dans [5 50[ = " + b);
11.              
12.         }
13.   }
Pas besoin de vous expliquer quoique ce soit. C'est la même chose que dans l'ex 12. y a qu'à changer les bornes de l'intervalle dans les explications.

Les autres fonction de la classe Math peuvent être retrouvées sur Internet :


Tapez "class Math java plattform" dans google.


Sahez aussi que cette fonction Math.random() permet aussi de trier au hasard une valeur qui n'est pas numérique. Comment ?
Par exemple, dans une base de données ou dans un tableau, on a des noms précédés par des numéros.
On tire au hasard un nombre et on affiche le nom dont le numéro correspond au nombre trié au hasard.

On verra un exemple concret dans l'un des deux chapitres consacrés aux tableaux.

Le mot random est un mot anglais qui signifie : aléatoire.
← (précédent) A.4 LLes variables (2) : opérateurs et opérations
A.6 La classe String
Accueil S O M M A I R E

A.5 La classe Math