Classe Java Math e suoi metodi

In questo articolo forniremo una breve panoramica della classe Math in Java. Parliamo dei metodi di questa classe e di come usarli. La classe Math risiede nel pacchetto java.lang e fornisce una serie di metodi statici per eseguire una serie di calcoli matematici diversi. Di seguito sono riportati esempi di calcoli per i quali la classe Math può essere utile:

• Calcolo dei valori assoluti (valori modulo)
• Calcolo dei valori delle funzioni trigonometriche (seno, coseno, ecc.)
• Elevazione a vari gradi
• Estrazione di radici di vario grado
• Generazione di numeri casuali
• Arrotondamento
• Eccetera.

Di seguito proveremo a vedere come la classe Java Math aiuta a risolvere i problemi sopra elencati. Iniziamo ad analizzare la classe con metodi che permettono di calcolare un valore modulo. Il metodo ABS è responsabile di ciò. Questo metodo è sovraccaricato e la classe Math presenta le seguenti differenze:

• doppi addominali statici (doppia a)
• addominali flottanti statici (float a)
• statico int abs(int a)
• addominali lunghi statici (lunga a)

Esempio di utilizzo:

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
    }

Calcolo dei valori delle funzioni trigonometriche

La classe Math ti consente di calcolare varie funzioni trigonometriche: seno, coseno, tangente, ecc. Un elenco completo dei metodi può essere trovato sul sito web della documentazione ufficiale . Di seguito è riportato un elenco di questi metodi:

• doppio peccato statico (doppia a)
• doppio cos statico (doppio a)
• doppia abbronzatura statica (doppia a)
• doppio asin statico (doppia a)
• doppio acos statico (doppia a)
• doppio atan statico (doppia a)

Metodi di calcolo: seno, coseno, tangente, arcoseno, arcocoseno, arcotangente. Ciascun metodo calcola un valore per l'angolo "a". Questo parametro viene passato a ciascun metodo e in ogni caso viene misurato in radianti (e non in gradi, come siamo abituati). Ci sono due novità qui, buone e cattive. Cominciamo con quello buono. La classe Math dispone di metodi per convertire i radianti in gradi e i gradi in radianti:

• statico double toGradi(doppio angrad)
• statico double toRadianti(doppio angdeg)

Qui il metodo toDegrees convertirà l'angolo angrad, misurato in radianti, in gradi. Il metodo toRadians, invece, converte l'angolo angdeg, misurato in gradi, in radianti. La brutta notizia è che questo avviene con qualche errore. Ecco un esempio di calcolo di seno e coseno:

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

Il programma produrrà:

0.0
0.49999999999999994
1.0

1.0
0.8660254037844387
6.123233995736766E-17

Che non corrisponde del tutto alle tabelle dei seni e dei coseni, anche a causa di errori nella conversione da gradi a radianti.

Esponenziazione

Per elevare un numero a potenza, la classe Math fornisce un metodo pow, che ha la seguente firma:

static double pow(double a, double b)

Questo metodo eleva il parametro "a" alla potenza "b". Esempi:

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
    }

Estrazione della radice

La classe Math fornisce metodi per ricavare radici quadrate e cubiche. I seguenti metodi sono responsabili di questa procedura:

• doppio quadrato statico (doppia a)
• doppio cbrt statico (doppia a)

Il metodo sqrt prende la radice quadrata e il metodo cbrt prende la radice cubica. Esempi:

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
    }

Generazione di numeri casuali

Per generare numeri casuali, la classe Math fornisce il metodo random. Questo metodo genera un numero reale (doppio) positivo casuale compreso tra 0,0 e 1,0. La firma del metodo è simile alla seguente:

public static double random()

Diamo un'occhiata agli esempi:

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

Dopo aver eseguito il metodo main, sulla console veniva visualizzato quanto segue:

0.37057465028778513
0.2516253742011597
0.9315649439611121
0.6346725713527239
0.7442959932755443

Con un po' di manipolazione è possibile utilizzare il metodo casuale della classe Math per ottenere numeri interi casuali compresi in un determinato intervallo. Ecco un esempio di una funzione che accetta due argomenti min e max e restituisce un numero intero casuale compreso nell'intervallo da min (incluso) a max (incluso):

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

Scriviamo un metodo Main in cui testeremo il metodo 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;
    }
}

Dopo aver eseguito il metodo principale, l'output potrebbe assomigliare a questo:

-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

Arrotondamento

Per arrotondare i numeri in Java, uno degli strumenti sono i metodi della classe Math. Più precisamente i metodi round, ceil e floor:

• tondo lungo statico (doppia a)
• statico int round(float a)
• doppio pavimento statico (doppia a)
• doppia cella statica (doppia a)

Il metodo circolare: arrotonda come al solito alla persona media. Se la parte frazionaria di un numero è maggiore o uguale a 0,5 il numero verrà arrotondato per eccesso, altrimenti per difetto. Il metodo floor arrotonda sempre il numero per difetto (verso l'infinito negativo), indipendentemente dai valori della parte frazionaria. Il metodo ceil, invece, indipendentemente dai valori della parte frazionaria, arrotonda i numeri per eccesso (verso l’infinito positivo). Diamo un'occhiata agli esempi:

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
}

Conclusione

In questo articolo abbiamo dato uno sguardo superficiale alla lezione di matematica. Abbiamo esaminato come utilizzando questa classe puoi:

• Calcola valori modulo;
• Calcolare i valori delle funzioni trigonometriche;
• Elevare i numeri a potenze;
• Estrarre radici quadrate e cubiche;
• Generare numeri casuali;
• Numeri tondi.

Ci sono molti altri metodi interessanti in questa classe. Che potete trovare sul sito ufficiale della documentazione . Bene, per la prima conoscenza, i metodi sopra elencati sono abbastanza sufficienti.