Classe Math API Java.

Fonctions mathématiques
trigonometric
FONCTIONS CLASSE MATH JAVA

En ce qui concerne les fonctions mathématiques en Java, les fonctions disponibles sont définies dans la classe Math.
Il y a beaucoup de fonctions disponibles. Vous pouvez consulter la liste complète dans la documentation officielle de l'API de
Java (selon version de Java en usage par exemple pour la version 8
voir[Link]

A continuación, nous montrerons les fonctions les plus importantes et des exemples d'utilisation :

Fonction mathématique Signification Exemple d'utilisation Résultat

abs Valeur absolue int x = [Link](2.3); x = 2;

atan Arcotangente double x = [Link](1); x = 0.78539816339744;

sin Seno double x = [Link](0.5); x = 0.4794255386042;

cos Cosinus double x = [Link](0.5); x = 0,87758256189037;

bronzer Tangente double x = [Link](0.5); x = 0,54630248984379;

exp Exponentiation népérienne double x = [Link](1); x = 2.71828182845904;

journal Logarithme népérien double x = [Link](2.7172); x = 0.99960193833500;

pow Puissance double x = [Link](2.3); x = 8.0;

rond Arrondi double x = [Link](2.5); x = 3;

aléatoire Nombre aléatoire double x = [Link](); x = 0.20614522323378;

plancher Redondir au nombre entier inférieur double x = [Link](2.5); x = 2.0;

plafond Arrondi à l'entier supérieur double x = [Link](2,5); x = 3.0;

Il convient de souligner que les fonctions mathématiques, appartenant à la classe Math, se
invoquent toujours de la manière suivante : [Link](arguments).

Les fonctions liées aux angles (atan, cos, sin, tan, etc.) fonctionnent dans
radians. Par conséquent, pour travailler avec des degrés, nous devrons effectuer la
conversion opportune. La propre classe Math facilite les méthodes :toRadianspour
transformer des degrés sexagésimaux en radians et toDegrees pour transformer
radians en degrés sexagésimaux, bien que les conversions puissent ne pas être
totalement précises. Par exemple cos(toRadians(90.0)) devrait renvoyer 0, mais
il est probable qu'il renvoie une valeur d'environ zéro mais pas exactement
zéro en raison du fait que la précision décimale n'est pas absolue.

La fonction :random permet de générer des nombres aléatoires dans l'intervalle ]0,1[.
tanto le 0 que le 1 sont exclus.
La fonction d'exponentiation népérienne ou exponentiation de e, mathématiquement
signifie ex, que en Java serait [Link](x), où x est un nombre réel et la base
c'est la constante népérienne e = 2.7172...

La fonction logarithme népérien, signifie mathématiquement Ln x, qui en Java

correspondrait à l'expression [Link](x).
La fonction puissance, mathématiquement signifie baseexposant, que en Java se
convertirait en [Link](base,exposant), où base et exposant sont
nombres réels, donc, si nous voulons obtenir la racine cubique de 2, la
l'instruction serait [Link](2,0.333).
Il n'y a pas de fonction directe pour obtenir la partie entière d'un nombre réel,
mais pour ces cas, on peut l'obtenir de la manière suivante :
int x = (int)(8.7); --> x = 8;
int x = (int)(-8.7); --> x = -8;
Préciser que prendre la partie entière est différent d'arrondir.
Si vous allez travailler avec des constantes physiques ou mathématiques, cela vous intéressera.
instruction finale pour la déclaration de constantes. L'avantage de déclarer une
constante au lieu d'une variable, consiste en ce que la constante ne peut pas varier
au cours du programme. Par conséquent, il est empêché qu'il puisse avoir par erreur
une valeur invalide à un moment donné. Les constantes facilitent la
documentation du programme et le rend facile à modifier. Une déclaration de type
de constante pourrait être la suivante :
final double pi = 3.14159265358979;
Cependant, Java lui-même a une constante propre pour définir la
constante mathématique PI : [Link]
Le programme suivant montrera son utilisation dans la conversion d'un angle
sexagésimaux en radians.
 /* Exemple de classe java utilisant la constante PI de la classe Math–
[Link] */
classe publique Programme {
public static void main(String args[]) {
double sexagésimal = 30;
double radianes = [Link]/180 * sexagésimal;
[Link]("Angle en radians : " + radians);
}
}

DIFFÉRENCE ENTRE ROUND, CEIL ET FLOOR

Les fonctions round, ceil et floor sont utilisées pour obtenir un entier proche d'un
nombre décimal et ont des similitudes, en fait dans certains cas ils renvoient le
même résultat. Cependant, ils ont aussi des différences qui sont intéressantes
connaître. Ces trois fonctions s'appliquent aux valeurs numériques décimales et
retournent une valeur numérique qui, dans le cas de round, est un entier long, tandis que
que dans le cas de floor et ceil, renvoient une valeur de type double correspondante ou
équivalente avec un entier.

La méthode round arrondit toujours à l'entier le plus proche, par exemple 2,6
arrondit à 3 tandis que -2,6 arrondit à -3. Si le décimal est exactement
entre deux valeurs, on arrondit à l'entier supérieur le plus proche (par exemple 2,5
redondea à 3 et -2,5 redondea à -2).

Le méthode floor renvoie l'entier le plus petit, par exemple 2.9

quedaría en 2.0 y -2.9 quedaría en -3.0. También 2.1 quedaría en 2.0 y -2.1
quedaría à -3.0.

La méthode ceil renvoie l'entier supérieur, par exemple 2.9 deviendrait

en 3,0 et -2,9, cela donnerait -2,0. Aussi, 2,1 donnerait 3,0 et -2,1 donnerait -
2.0

Dans chaque programme, nous devrons déterminer quelle méthode est appropriée pour
obtenir les résultats souhaités. Par exemple, si nous devons arrondir
Quantités d'argent, il semble plus logique d'utiliser round. En revanche, si nous sommes
travaillant avec les âges d'une personne en années en utilisant des décimales, nous pourrons
raisonner différemment. L'âge d'une personne est une valeur positive (ce n'est pas
possible qu'elle prenne des valeurs négatives). On dit qu'une personne a x années
tant que je n'ai pas atteint x+1 ans, de sorte que pendant toute la période intermédiaire
nous disons qu'il a x ans. Par exemple, si j'ai 35 ans le 4 février de
2096, du 4 février 2096 au 3 février 2097 je dirai que
J'ai 35 ans. Mais dans un programme que je travaillais avec des décimales, au point
L'intermédiaire entre ces deux dates aurait 35,50 ans. Si je veux obtenir la valeur
que représente l'âge à partir de la valeur décimale, il sera logique d'utiliser le
méthode floor car elle nous renverra 35 pour toutes les valeurs décimales entre
35 et 36, tel que nous l'exprimons en langage naturel pour les âges. Dans ce cas
tanto round como ceil ne donneraient pas un résultat adéquat à nos
intérêts.

Écris ce code et vérifie ses résultats :

Quelques Méthodes de la Classe Math.

Méthode. Description.

abs(double a) Renvoie la valeur absolue d'une valeur double introduite en paramètre.

abs(float a) Retourne la valeur absolue d'une valeur flottante introduite comme paramètre.

abs(int a) Renvoie la valeur absolue d'une valeurEntier introduite en tant que paramètre.

abs(long a) Renvoie la valeur absolue d'une valeur longue introduite en paramètre.

acos(double a) Renvoie l'arccosinus d'une valeur introduite en paramètre.

addExact(int x, int y) Renvoie la somme de ses arguments, lançant une exception si le résultat d

addExact(long x, long y) Renvoie la somme de ses arguments, en lançant une exception si le résultat s
long.

asin(double a) Retourne l'arc sinus d'une valeur saisie.

atan(double a) Renvoie l'arc tangente d'une valeur saisie.

cbrt(double a) Renvoie la racine cubique d'une valeur double.

cos(double a) Renvoie le cosinus trigonométrique d'un angle.

exp(double a) Renvoie le nombre e d'Euler élevé à la puissance d'un double.

log(double a) Renvoie le logarithme naturel (base e) d'une valeur double.

log10(double a) Retourne le logarithme en base 10 d'une valeur double.

max(double a, double b) Renvoie le plus grand de deux valeurs double

max(float a, float b) Retourne la plus grande de deux valeurs float.

max(int a, int b) Renvoie le plus grand de deux valeurs entières.

max(long a, long b) Renvoie le plus grand des deux valeurs long.

min(double a, double b) Renvoie la plus petite des deux valeurs double.

min(float a, float b) Renvoie le plus petit de deux valeurs float.

min(int a, int b) Retourne le plus petit de deux valeurs entières.

min(long a, long b) Renvoie la plus petite de deux valeurs long.

multiplierExact(int x, int y) Renvoie le produit des arguments, en lançant une exception si le résultat
int.

multiplyExact(long x, long Retourne le produit des arguments, en lançant une exception si le résultat
y) long.

puissance(double a, double b) Retourne la valeur du premier argument élevé à la puissance du deuxième argument

aléatoire() Retourne une valeur double avec un signe positif, supérieure ou égale à 0,0 et moins

rond(double a) Renvoie le long arrondi le plus proche du double introduit.

arrondir(float a) Retourne l'entier le plus proche et arrondi du float introduit.

sin(double a) Retourne le sinus trigonométrique d'un angle.

sqrt(double a) Retourne la racine carrée positive correctement arrondie d'un double

tan(double a) Renvoie la tangente trigonométrique d'un angle.

Exemple de programme Java utilisant la classe Math.

Dans l'exemple suivant de programme Java, nous utilisons la classe Math pour effectuer quelques
calculs et opérations. Nous en profitons également et utilisons leclasse Decimalformatpour
présenter avec un format l'un des résultats qui nous sont donnés, de cette manière nous pratiquons
en consolidant ce que nous apprenons pendant le cours de java.

0
1 paquet clasemath;
2
3 import [Link];
4 /**
5 *
6 * @auteur [Link]
7 */
8 classe publique ClaseMath {
9
10 public static String metodoForm ( String patron, double dato) {
11 DecimalFormat objDF = new DecimalFormat (patron);
12 String result = [Link](dato);
13 retourner le résultat;
14 }
15
16 public static void main(String[] args) {
17 double num1 = -10,570;
18 double num2 = 4,10;
19 int num3 = 10;
20 int num4 = 38;
21 double dato;
22
23 [Link] ("La valeur absolue de %.3f est %.2f %n", num1, [Link](num1));
24
25 [Link] ("Le maximum de %d et %d est %d %n", num3, num4, [Link] (num3, num4));
26
27 [Link] ("Le minimum de %d et %d est %d %n", num3, num4, [Link] (num3, num4));
28
29 [Link] ("La valeur de e est %.4f %n", Math.E);
30
31 [Link] ("exp (%d) est %.3f %n", num3, [Link] (num3));
32
33 [Link] ("log (%d) est %.3f %n", num4, [Link] (num4));
34
35 [Link] ("%.2f élevé à %d est %f %n", num2, num3, dato = [Link] (num2, num3));
36
37 [Link]("Que con formato es: %n " +metodoForm("###,###.##",dato )+"%n");
38
39 [Link]("La racine carrée de (%.2f) est %.2f %n", num2, [Link](num2));
40 }
41 }
42
En console, nous aurions les résultats suivants :
Méthode random() de la classe Math.
Le méthode random peut être utilisé pour générer des nombres au hasard. L'intervalle ou la marge
avec lequel travaille la méthode random oscille entre 0.0 et 1.0 (ce dernier non inclus).
Par conséquent, pour générer un nombre entier entre 0 et 9, il faut écrire le suivant.
sentence:

0
1 int numero = (int) ([Link]() * 10);
2
De cette manière, en multipliant la valeur par 10, la plage des valeurs possibles devient :

0
1 0.0 <= numéro < 10.0
2
Pour terminer, vous pouvez voir un exemple de programme Java qui utilise la méthode random.
la classe de Math est làpage.

La classeMath
Classes et objets

Membres données constantes

Fonctions membre

Calcul du nombre irrationnel

La classe Math a des membres de données et des fonctions membres statiques, nous allons
connaître certaines de ces fonctions, comment elles s'appellent et quelle tâche elles accomplissent.

Membres données constantes

La classe Math définit deux constantes très utiles, le nombre et le numéro e.

classe publique finale Math {
public static final double E = 2.7182818284590452354;
public static final double PI = 3.14159265358979323846;
//...
}
Le modificateur final indique que les valeurs qu'ils contiennent ne peuvent pas être modifiées.
leurs valeurs constantes

On accède à ces constantes depuis la classe Math, de la manière suivante

[Link]("Pi est " + [Link]);
[Link]("e est " + Math.E);

Fonctions membre
La classe Math définit de nombreuses fonctions et différentes versions de chaque fonction.

Par exemple, pour trouver la valeur absolue d'un nombre, définissez les suivantes
fonctionnalités. On appelle l'une ou l'autre en fonction du type de données qui lui est passé dans son
unique argument.
classe publique finale Math {
public static int abs(int a) {
retourner (a < 0) ? -a : a;
}
public static long abs(long a) {
retourner (a < 0) ? -a : a;
}
public static float abs(float a) {
retourner (a < 0) ? -a : a;
}
public static double abs(double a) {
return (a < 0) ? -a : a;
}
//...
}

Par exemple, trouver la valeur absolue des nombres suivants

int i = -9;
double x = 0.3498;
|
|

[Link](i), appelle la première version, et [Link](x) appelle la dernière version.

Fonctions trigonométriques

Dans les fonctions trigonométriques, les arguments s'expriment en radians. Pour

exemple, l'angle de 45° se convertit en radians et ensuite on calcule le sinus, le cosinus
et la tangente
 double angulo = 45.0 * [Link]/180.0;
[Link]("cos(" + angulo + ") est " + [Link](angulo));
[Link]("sin(" + angulo + ") est " + [Link](angulo));
[Link]("tan(" + angulo + ") est " + [Link](angulo));

Pour passer des coordonnées rectangulaires aux coordonnées polaires, la fonction atan2 est utile, qui
admet deux arguments, l'ordonnée et l'abscisse du point. Retourne l'angle
en radians.
double y=-6.2; //ordonnée
double x=1.2; abscisse
[Link]("atan2(" + y + " , " + x + ") est " + Math.atan2(y,
x));

Fonctions exponentielle et logarithmique

La fonction exponentielle exp renvoie le nombre e élevé à une puissance

[Link]("exp(1.0) est " + [Link](1.0));

[Link]("exp(10.0) est " + [Link](10.0));
[Link]("exp(0.0) est " + [Link](0.0));

La fonction logcalcule le logarithme naturel (de base e) d'un nombre

[Link]("log(1.0) est " + [Link](1.0));
[Link]("log(10.0) est " + [Link](10.0));
[Link]("log(Math.E) est " + [Link](Math.E));

Fonction puissance et racine carrée

Pour élever un nombre x à la puissance y, on utilise pow(x, y)

[Link]("pow(10.0, 3.5) est " + [Link](10.0, 3.5));

Pour trouver la racine carrée d'un nombre, on utilise la fonction sqrt

[Link]("La racine carrée de " + x + " est " +
[Link](x));

Approximation d'un nombre décimal

Pour exprimer un nombre réel avec un nombre spécifié de décimales

nous utilisons la fonction round. Par exemple, pour exprimer les nombres x et y avec
deux chiffres décimaux écrits
double x = 72.3543;
double y = 0,3498;
 [Link](x + " est environ " +
(double)[Link](x*100)/100);
[Link](y + " est environ " +
(double)[Link](y*100)/100);

On obtient 72,35 et 0,35 comme on pourrait s'y attendre. Remarquez que round retourne un
nombre entier qu'il est nécessaire de promouvoir à double pour effectuer la
division par 100.
Si nous utilisons la fonction floor au lieu de round, nous obtiendrions

[Link](x + " est environ " + [Link](x*100)/100);

[Link](y + " est environ " + [Link](y*100)/100);

Se obtient 72,35 et 0,34. L'approximation du premier est correcte car la

la troisième chiffre décimal est 4 inférieur à 5. L'approximation du deuxième est incorrecte
puisque le troisième chiffre décimal est 9, supérieur à 5. Dans la plupart des
des erreurs dans les calculs, donc la différence entre flooryroundno n'est pas
significatif.

Le plus grand et le plus petit de deux nombres

Pour trouver le plus grand et le plus petit de deux nombres, on utilise les
fonctionsminymaxquebcomparent des nombres du même type.
int i = 7 ;
int j = -9;
double x = 72.3543;
double y = 0.3498;
// pour trouver le plus petit de deux nombres
[Link]("min(" + i + "," + j + ") est " + [Link](i,j));
[Link]("min(" + x + "," + y + ") est " + [Link](x,y));
// Pour trouver le plus grand de deux nombres
[Link]("max(" + i + "," + j + ") est " + [Link](i,j));
[Link]("max(" + x + "," + y + ") est " + [Link](x,y));

Nombres aléatoires

La classe Math définit une fonction appelée random qui retourne un nombre
pseudo-aléatoire compris dans l'intervalle [0.0, 1.0). Il existe une autre alternative, se
ils peuvent générer des nombres pseudo-aléatoires à partir d'un objet de
laclasseAléatoire, appelez la fonction miembronextDouble.
[Link]("Nombre aléatoire : " + [Link]());
[Link]("Un autre nombre aléatoire : " + [Link]());
Calcul du nombre irrationnel
Pour déterminer la longueur d'un cercle de rayon R, on commence par calculer le
périmètre d'un triangle équilatéral (3 côtés) inscrit dans ladite circonférence,
ensuite, d'un hexagone (6 côtés), un dodécagone (12 côtés), et ainsi de suite.
La limite de la succession des périmètres est précisément la longueur de la
circonférence2 R.

Si nous prenons un cercle de rayon unité, en divisant par deux les valeurs de
les périmètres nous obtiendrons les approximations successives du nombre
irrationnel .

À partir de la figure, nous pouvons calculer la longueur.

du côténun polygone régulier à côtés inscrits
dans la circonférence de rayon R, (en rouge).

De la même manière, nous obtenons la longueur du côté

d'un polygone régulier inscrit de 2n côtés (en
couleur bleue).

En tenant compte que

Nous établissons la relation entrenoui2net donc, entre le périmètre Pnsupprimer

polygone régulier dénados et le périmètre P2ndu polygone régulier de 2 côtés.

Prenant comme rayon R, l'unité

Pour un triangle, n=3, la longueur du côté est a.3=2sen60º, y le

périmètre
Pour un hexagone, n=6, la longueur du côté est a.6=2sen30º=1, y el
périmètreP6=6.
 et ainsi de suite.

Pour obtenir les approximations successives du nombre irrationnel par le biais de

formule antérieure nous procédons de la manière suivante

1. Nous partons de la valeur du périmètre P d'un triangle équilatéral inscrit dans

une circonférence de rayon un, la valeur de denes 3.
2. Nous calculons le périmètre P d'un polygone de 2n côtés à partir de la valeur de
périmètre d'un polygone régulier à n côtés.
La valeur obtenue sera la valeur du périmètre d'un polygone régulier
den=2nlados.
4. On imprime la valeur de P divisée par deux (approximation de )
5. On revient à l'étape 2.

Maintenant, nous devons transférer les formules mathématiques en code, et c'est ici que
nous pouvons avoir quelques surprises.

Tout d'abord, nous devons prendre en compte que l'expression es

mathématiquement équivalent à mais ce ne l'est pas quand nous travaillons avec

nombres sur l'ordinateur.

Par exemple, sans type de datoint. En évaluant le dénominateur dans le premier

l'expression obtenue est le carré d'une fonction qui croît très rapidement.
débordant (overflow) levaleur maximale qu'une variable peut contenir
entièredonné par Integer.MAX_VALUE. Entiers, la classe qui décrit les nombres
entiers. Par conséquent, lors de la réalisation des calculs sur l'ordinateur, il est conseillé d'utiliser
la deuxième expression au lieu de la première, même si nous changeons le type de donnée
dendeintalong.

Le calcul de implique un nombre infini d'itérations, car comme nous avons

visto qu'il n'est pas possible de dépasser la valeur maximale qu'une peut garder
variable entière, notre première intention serait de programmer une boucle qui réalise
le nombre maximum d'itérations
double perimetre=3*[Link](3); //triangle équilatéral inscrit
long n=3;
int i=0; nombre d'itérations
tandis que(n<Long.MAX_VALUE){
périmètre=2*n*[Link]([Link](4.0-
(périmètre/n)*(périmètre/n));
n=2*n;
i++;
 [Link](i + " -- " + perimetro / 2);
}

Avec une certaine surprise, nous avons observé la sortie du programme une fois qu'il a été complété.
le boucle, un zéro est imprimé, au lieu de 3.14159265358979323846.

Si nous observons les 30 premières itérations, nous voyons, comme cela est montré dans la
figure inférieure, que la valeur la plus proche de s'obtient lors des itérations 13, 14,
15 et 16.
tandis que(i<30){
//...
}

La conclusion finale est que nous devons faire très attention à transférer les
formules mathématiques en code. Les données de type prédéfini ne peuvent que
garder des valeurs entre un maximum et un minimum, tel queonous avons vu dans son
dé[Link]'autre part, une variable de type double a une précision limitée.
donc cela ne représente pas tous les nombres réels mais un ensemble fini