JAVF: Liste des fonctions mathématiques usuelles de l’API

Dernière MAJ: 13.04.2008 12h30

c)~/2A env. - H. Nguyen-Phu

Cliquer sur un des signets ci-dessous pour obtenir la fonction correspondante :

ceil; cbrt; cos; cosh [Java 5]
exp; expm1; floor;

getExponent [Java 6]
hypot [Java 5]
IEEEremainder; log; log1p; log10 [Java 5]
max; min; pow; random; rint; round
signum [Java 5]; sin; sinh [Java 5];

sqrt; tan; tanh [Java 5];

toDegrees; toRadians

ulp [Java 5]

--------------------------------------------------------------------------

PRINCIPALES FONCTIONS MATHEMATIQUES | NOTATIONS MATHEMATIQUES USUELLES

de la classe 'java.lang.Math' [Java 5] |

--------------------------------------------------------------------------

Pour les fonctions qui suivent, le type courant TypeC est pris parmi la

liste {int, long, float, double} sauf indication contraire.

A NE PAS OUBLIER d’inclure, au tout début, l’importation de classe:

import static java.lang.Math.*;

Exemple:

Valeur absolue retourne TypeC

abs(TypeC r) | |r| ou Abs(r)

ou |

Math.abs(TypeC r) // pour les versions Java antérieures …

Valeur maximale renvoie le plus grand de ses deux arguments:

max(TypeC x, TypeC y) | Max(x,y) ou Sup(x,y)

retourne TypeC |

Valeur minimale renvoie le plus petit de ses deux arguments:

min(TypeC x, TypeC y) | Min(x,y) ou Inf(x,y)

retourne TypeC |

Signe d'un nombre réel de type 'Typelt', ici, Typelt = {float, double}:

Profil [Java 5]: public static Typelt signum(Typelt x)

signum(Typelt x) | retourne 0 si x = 0
retourne Typelt | -1.0 si x < 0

| +1.0 si x > 0

Taille de l' "ulp"  de l'argument  'd' de type 'Typelt'; "ulp" est défini comme la distance positive entre l'argument réel et la valeur réelle suivante, plus grande d'un ordre de grandeur (cf. exemple d’emploi ).

Profil [Java 5]:  public static Typelt ulp( Typelt d )

Ici, Typelt = {float, double}

ulp(Typelt  d)                        | retourne les cas particuliers

  retourne  Typelt                     | ci-dessous:

If the argument d is NaN, then the result is NaN.
If the argument d is positive or negative infinity, then the result is positive infinity.
If the argument d is positive or negative zero, then the result is Typelt.MIN_VALUE.
If the argument d is ±Float.MAX_VALUE, then the result is equal to 2¹⁰⁴
If the argument d is ±Double.MAX_VALUE, then the result is equal to 2⁹⁷¹.

Pour les méthodes ci-dessous qui retournent un réel double
(TypeC = 'double'), r désigne un argument de type 'double':

Arc-Cosinus:

acos(double r) | arc-cos(r) // résultat en radians

Arc-Sinus:

asin(double r) | arc-sin(r) // résultat en radians

Arc-Tangente:

atan(double r) | arc-tan(r) // résultat en radians

Arc-Tangente2: retourne la composante théta de (rho, theta) en radians

public static double atan2(double y,  | theta= Arc-tan(y/x) //et non pas (x/y)

                           double x)   | // Attention à  cette erreur fréquente

Extrait de la documentation de l’API Java:

Converts rectangular coordinates (x, y) to polar (r, theta). This method computes the phase theta by computing an arc tangent of y/x in the range of -pi to pi.

Arrondi par excès:

ceil(double r) | Partie_Entiere_sup(r)

retourne, sous la forme d'un double,

la partie entière supérieure ou égale à la valeur spécifiée

"Cubic root" - Profil de la méthode 'cbrt()' [Java 5.0]:

public static double cbrt(double r) | (r)^(1/3)

cbrt(double r) | ou racine_cubique(r)

Cosinus - Profil de la méthode 'cos()':

public static double cos(double r) | Cosinus(r) compris entre -1, +1

cos(double r) | ou Cos(r) // r en radians

Cosinus hyperbolique - Profil de la méthode 'cosh()' [Java 5.0]:

public static double cosh(double r) | Cosh(r)

cosh(double r) |

Exponentielle - Profil de la méthode 'exp()':
public static double exp(double a) |

exp(double r) | Exp(r) ou e^r

Exponentielle moins un  - Profil de la méthode 'expm1()':

public static double expm1(double x)  |

expm1(double r) | retourne Exp(r) - 1 ou (e^r – 1)

Extrait de la documentation de l’API Java:

Note that for values of x near 0, the exact sum of (expm1(x) + 1) is much closer to the true result of e^x than exp(x).

Arrondi par défaut:

floor(double r) | Partie_Entiere_inf(r)

retourne, sous la forme d'un double,

la partie entière inférieure ou égale à la valeur spécifiée

valeur de l'hypothénuse

Profil [Java 5]: public static double hypot(double x, double y)

hypot(a, b) | retourne (a² + b²)^0.5

Logarithme népérien: Profil de la fonction 'log()':

public static double log(double r)

log(double r) | Ln(r)

Logarithme en base 10 [Java 5]

public static double log10(double r)

log10(double r) | Log10(r)

Logarithme népérien de x plus un : Profil de la fonction 'log1p()':
public static double log1p(double x) | retourne Ln(x + 1)

Extrait de la documentation de l’API Java:

Note that for small values x, the result of log1p(x) is much closer to the true result of ln(1 + x) than the floating-point evaluation of log(1.0+x).

Modulo réel: Profil de la méthode 'IEEEremainder()':

public static double IEEEremainder(double x, double y)

IEEEremainder(double x, double y) |

retourne le reste de la division réelle du premier argument 'x' par

le second 'y' selon la norme IEEE 754.

Application : calcul du modulo d’un argument de nombres complexes à 2*PI près entre -PI et +PI.

Profil de l'élévation de r à la puissance y:

public static double pow(double r, double y)

pow(double r, double y) | r^y

Sinus - Profil de la méthode 'sin()':

public static double sin(double r) | Sinus(r) compris entre -1, +1

sin(double r) | ou Sin(r) // r en radians

Sinus hyperbolique - Profil de la méthode 'sinh()' [Java 5.0]:

public static double sinh(double r) | Sinh(r)

sinh(double r) |

sqrt() - Profil de la méthode 'sqrt()'| 'Square Root' ou racine carrée

public static double sqrt(double a)

sqrt(double r) | r^(1/2) // avec r >= 0 !

Cette fonction retourne ‘NaN’ (Not a Number) si r est négatif.

Exercice: Utiliser 'sqrt()' ou la méthode pow() pour calculer la racine quatrième

-------- d’un réel en remplaçant l’affichage ‘NaN’ par « Erreur: argument négatif ! »

via des boîtes de dialogues d’E/S du paquet ‘javax.swing’.

Tangente - Profil de la méthode 'tan()':

public static double tan(double r) | tan(r)

tan(double r) | // r en radians

Tangente hyperbolique - Profil de la méthode 'tanh()' [Java 5.0]:

public static double tanh(double r) | tanh(r)

tanh(double r) |

Conversion en degrés - Profil de la méthode 'toDegrees' [JDK 1.2]:
public static double toDegrees(double angrad)

toDegrees(r) | retourne (r * 180.0 / PI)

Conversion en radians - Profil de la méthode 'toRadians' [JDK 1.2]:

public static double toRadians(double angdeg)
toRadians(r) | retourne (r / 180.0 * PI)

Profil de la génération de nombres pseudo-aléatoires réels entre 0 et 1:

public static synchronized double random()

random() |

Exercice: Utiliser 'random()' ou la méthode nextInt() de la classe ‘Random’

-------- pour générer les 7 chiffres du jeu du LOTO selon l'exemple ci-après:

import java.util.Random; // cf. JDK 1.2 ou plus ...

public class g_entier { // Entre 0 et 49 !

// A modifier pour simuler correctement le jeu du LOTO

public static void main(String arg[]) {

Random R = new Random();

System.out.println("G_ENTIER.java - Emploi de nextInt()\n");

for(int i=0; i<7; ++i)

System.out.println(R.nextInt(49));

}

Partie entière (type ‘double’) d'un argument - Profil de 'rint()':

public static double rint(double a) |

rint(a) | Partie_Entiere_(a)

retourne, sous la forme d'un double,

la partie entière de la valeur spécifiée

Partie entière (type ‘Entier’) au plus près d'un argument ou Arrondi au plus proche

Profils de 'round()':

public static int round(float a)

public static long round(double a)

round(a) | PartieEntiereAuPlusProche(a)

retourne, sous la forme d'un entier 'int' ou 'long' suivant la nature

de l'argument 'a' qui est respectivement un 'float' ou un 'double'.

Algorithme adopté: On ajoute 0.5 à 'a' puis on prend la partie entière

inférieure de la valeur obtenue.

Exercice: Utiliser la méthode 'round()' dans les conversions monétaires

Euros vis à vis des anciennes monnaies nationales de la zone "Euro".

getExponent Fonction d’accès à l’exposant selon le codage IEEE 754 : (1.mantisse)* 2^exposant

Profils de ‘getExponent()’ [cf. Java 6]:

public static int getExponent(float f)

public static int getExponent(double d)

getExponent(a) | accèsExposantIEEE754(a)

retourne, sous la forme d'un entier 'int', l’exposant en base 10 correspondant (cf. exemple d’emploi ).