Classe Java Math et ses méthodes

Dans cet article, nous donnerons un bref aperçu de la classe Math en Java. Parlons des méthodes de ce cours et de comment les utiliser. La classe Math réside dans le package java.lang et fournit un ensemble de méthodes statiques pour effectuer un certain nombre de calculs mathématiques différents. Voici des exemples de calculs pour lesquels le cours Math peut être utile :

• Calcul des valeurs absolues (valeurs modulo)
• Calcul des valeurs des fonctions trigonométriques (sinus, cosinus, etc.)
• Élévation à différents degrés
• Extraire des racines à différents degrés
• Génération de nombres aléatoires
• Arrondi
• Etc.

Ci-dessous, nous essaierons de voir comment la classe Java Math aide à résoudre les problèmes répertoriés ci-dessus. Commençons par analyser la classe avec des méthodes qui permettent de calculer une valeur modulo. La méthode abs en est responsable. Cette méthode est surchargée et la classe Math présente les différences suivantes :

• double abs statique (double a)
• flotteur statique abs (flotteur a)
• statique int abs(int a)
• abs longs statiques (long a)

Exemple d'utilisation :

public static void main(String[] args) {
        System.out.println(Math.abs(-1));      // 1
        System.out.println(Math.abs(-21.8d));  // 21.8
        System.out.println(Math.abs(4532L));   // 4532
        System.out.println(Math.abs(5.341f));  // 5.341
    }

Calculer les valeurs des fonctions trigonométriques

Le cours Math vous permet de calculer diverses fonctions trigonométriques - sinus, cosinus, tangentes, etc. Une liste complète des méthodes peut être trouvée sur le site de documentation officiel . Vous trouverez ci-dessous une liste de ces méthodes :

• double péché statique (double a)
• double cos statique (double a)
• double bronzage statique (double a)
• double asin statique (double a)
• double acos statique (double a)
• double atan statique (double a)

Les méthodes calculent : sinus, cosinus, tangente, arc sinus, arc cosinus, arc tangente. Chaque méthode calcule une valeur pour l'angle « a ». Ce paramètre est transmis à chaque méthode et est dans chaque cas mesuré en radians (et non en degrés, comme nous en avons l'habitude). Il y a deux nouvelles ici, une bonne et une mauvaise. Commençons par le bon. La classe Math propose des méthodes pour convertir les radians en degrés et les degrés en radians :

• statique double toDegrés (double angrad)
• statique double toRadians (double angdeg)

Ici, la méthode toDegrees convertira l'angle angrad, mesuré en radians, en degrés. La méthode toRadians, au contraire, convertit l'angle angdeg, mesuré en degrés, en radians. La mauvaise nouvelle est que cela se produit avec une erreur. Voici un exemple de calcul de sinus et cosinus :

public static void main(String[] args) {
        System.out.println(Math.sin(Math.toRadians(0)));   
        System.out.println(Math.sin(Math.toRadians(30)));  
        System.out.println(Math.sin(Math.toRadians(90)));  

        System.out.println(Math.cos(Math.toRadians(0)));   
        System.out.println(Math.cos(Math.toRadians(30)));  
        System.out.println(Math.cos(Math.toRadians(90)));  
    }

Le programme affichera :

0.0
0.49999999999999994
1.0

1.0
0.8660254037844387
6.123233995736766E-17

Ce qui ne correspond pas tout à fait aux tableaux des sinus et des cosinus, en partie à cause d'erreurs dans la conversion des degrés en radians.

Exponentiation

Pour élever un nombre à une puissance, la classe Math fournit une méthode pow, qui a la signature suivante :

static double pow(double a, double b)

Cette méthode élève le paramètre « a » à la puissance « b ». Exemples:

public static void main(String[] args) {
        System.out.println(Math.pow(1,2)); // 1.0
        System.out.println(Math.pow(2,2)); // 4.0
        System.out.println(Math.pow(3,2)); // 9.0
        System.out.println(Math.pow(4,2)); // 16.0
        System.out.println(Math.pow(5,2)); // 25.0

        System.out.println(Math.pow(1,3)); // 1.0
        System.out.println(Math.pow(2,3)); // 8.0
        System.out.println(Math.pow(3,3)); // 27.0
        System.out.println(Math.pow(4,3)); // 64.0
        System.out.println(Math.pow(5,3)); // 125.0
    }

Extraction de racines

La classe Math fournit des méthodes pour prendre des racines carrées et cubiques. Les méthodes suivantes sont responsables de cette procédure :

• statique double sqrt (double a)
• statique double cbrt (double a)

La méthode sqrt prend la racine carrée et la méthode cbrt prend la racine cubique. Exemples:

public static void main(String[] args) {
        System.out.println(Math.sqrt(4));   // 2.0
        System.out.println(Math.sqrt(9));   // 3.0
        System.out.println(Math.sqrt(16));  // 4.0

        System.out.println(Math.cbrt(8));   // 2.0
        System.out.println(Math.cbrt(27));  // 3.0
        System.out.println(Math.cbrt(125)); // 5.0
    }

Génération de nombres aléatoires

Pour générer des nombres aléatoires, la classe Math fournit la méthode aléatoire. Cette méthode génère un nombre réel (double) positif aléatoire compris entre 0,0 et 1,0. La signature de la méthode ressemble à ceci :

public static double random()

Regardons des exemples :

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println(Math.random());
        }
    }

Après avoir exécuté la méthode main, ce qui suit s'est affiché sur la console :

0.37057465028778513
0.2516253742011597
0.9315649439611121
0.6346725713527239
0.7442959932755443

Avec un peu de manipulation, vous pouvez utiliser la méthode aléatoire de la classe Math pour obtenir des nombres entiers aléatoires situés dans une certaine plage. Voici un exemple de fonction qui prend deux arguments min et max et renvoie un entier aléatoire compris entre min (inclus) et max (inclus) :

    static int randomInARange(int min, int max) {
        return  (int) (Math.random() * ((max - min) + 1)) + min;
    }

Écrivons une méthode Main dans laquelle nous testerons la méthode randomInARange :

public class MathExample {


    public static void main(String[] args) {
        // Карта, в которой мы будем хранить количество выпадений Howого-то числа
        Map<Integer, Integer> map = new TreeMap<>();

        // За 10000 операций
        for (int i = 0; i < 10000; i++) {

            // Сгенерируем рандомное число от -10 включительно до 10 включительно
            final Integer randomNumber = randomInARange(-10, 10);


            if (!map.containsKey(randomNumber)) {
                // Если карта еще не содержит "выпавшего случайного числа"
                // Положим его в карту с кол-вом выпадений = 1
                map.put(randomNumber, 1);
            } else {
                // Иначе, увеличим количество выпадений данного числа на 1
                map.put(randomNumber, map.get(randomNumber) + 1);
            }
        }

        // Выведем на экран содержимое карты в формате ключ=[meaning]
        for (Map.Entry<Integer, Integer> entry : map.entrySet()){
            System.out.println(String.format("%d=[%d]", entry.getKey(), entry.getValue()));
        }
    }

    static int randomInARange(int min, int max) {
        return  (int) (Math.random() * ((max - min) + 1)) + min;
    }
}

Après avoir exécuté la méthode main, le résultat pourrait ressembler à ceci :

-10=[482]
-9=[495]
-8=[472]
-7=[514]
-6=[457]
-5=[465]
-4=[486]
-3=[500]
-2=[490]
-1=[466]
0=[458]
1=[488]
2=[461]
3=[470]
4=[464]
5=[463]
6=[484]
7=[479]
8=[459]
9=[503]
10=[444]

Process finished with exit code 0

Arrondi

Pour arrondir les nombres en Java, l'un des outils est la méthode de la classe Math. Plus précisément, les méthodes rondes, plafond et sol :

• long rond statique (double a)
• statique int rond (float a)
• double plancher statique (double a)
• double plafond statique (double a)

La méthode ronde - arrondit comme d'habitude à la personne moyenne. Si la partie fractionnaire du nombre est supérieure ou égale à 0,5, alors le nombre sera arrondi au chiffre supérieur, sinon arrondi au chiffre inférieur. La méthode du plancher, quelles que soient les valeurs de la partie fractionnaire, arrondit toujours le nombre à l'inférieur (vers l'infini négatif). La méthode du plafond, au contraire, quelles que soient les valeurs de la partie fractionnaire, arrondit les nombres (vers l'infini positif). Regardons des exemples :

    public static void main(String[] args) {
        System.out.println(Math.round(1.3)); // 1      
        System.out.println(Math.round(1.4)); // 1      
        System.out.println(Math.round(1.5)); // 2      
        System.out.println(Math.round(1.6)); // 2      

        System.out.println(Math.floor(1.3)); // 1.0      
        System.out.println(Math.floor(1.4)); // 1.0      
        System.out.println(Math.floor(1.5)); // 1.0      
        System.out.println(Math.floor(1.6)); // 1.0      

        System.out.println(Math.ceil(1.3)); // 2.0   
        System.out.println(Math.ceil(1.4)); // 2.0   
        System.out.println(Math.ceil(1.5)); // 2.0   
        System.out.println(Math.ceil(1.6)); // 2.0   
    }

Conclusion

Dans cet article, nous avons jeté un regard superficiel sur le cours de mathématiques. Nous avons vu comment, en utilisant cette classe, vous pouvez :

• Calculer les valeurs modulo ;
• Calculer les valeurs des fonctions trigonométriques ;
• Élever le nombre aux pouvoirs ;
• Extraire les racines carrées et cubiques ;
• Générer des nombres aléatoires ;
• Chiffres ronds.

Il existe de nombreuses autres méthodes intéressantes dans cette classe. Qui peut être trouvé sur le site de documentation officiel . Eh bien, pour la première connaissance, les méthodes énumérées ci-dessus sont tout à fait suffisantes.