JavaScript/Oggetto Math

L'oggetto Math mette a disposizione dello sviluppatore JavaScript numerose funzioni e costanti matematiche; è un oggetto particolare, in quanto non richiede di lavorare su istanze di oggetti ma permette di accedere ai suoi metodi usando la notazione:

Math.nome_metodo();
Math.nome_proprietà

Proprietà

Le proprietà dell'oggetto Math consistono in diverse costanti matematiche:

PI: restituisce il valore approssimato di Pi greco
E: restituisce il valore della costante matematica E
LN2 e LN10: il valore del logaritmo naturale di 2 e di 10

Ovviamente sono tutte proprietà di sola lettura

Metodi

Ecco una lista dei metodi corrispondenti alle principali funzioni matematiche e trigonometriche:

abs(): restituisce il valore assoluto (o modulo) del numero fornito come argomento
min() e max(): restituiscono il minimo e il massimo tra i due numeri passati come parametri
sqrt() e pow(b, n): restituiscono la radice quadrata del numero passato o l'nesima potenza del numero b
sin(), cos() e tan(): restituiscono il seno, il coseno e la tangente trigonometrica dell'angolo passato in radianti
log(): restituisce il logaritmo naturale in base $e\;$ del numero passato come parametro

Arrotondare i numeri

Per l'arrotondamento l'oggetto Math mette a disposizione tre metodi:

ceil(): arrotonda il numero al numero intero maggiore più vicino (per eccesso). Ad esempio:

Math.ceil(10.01) //restituisce 11
Math.ceil(-6.3) //restituisce -6

floor(): arrotonda l'oggetto al numero intero minore più vicino (per difetto). Ad esempio:

Math.floor(10.01) //restituisce 10
Math.floor(-6.3) //restituisce -7

round(): arrotonda l'oggetto per eccesso se la parte decimale è maggiore o uguale a 5, altrimenti arrotonda per difetto:

Math.round(10.01) //restituisce 10
Math.round(-6.3) //restituisce -6
Math.round(2.5) //restituisce 3

Tutte queste tre funzioni differiscono da parseInt() che non arrotonda i numeri, bensì li tronca. Ad esempio:

Math.parseInt(10.01) //restituisce 10
Math.parseInt(-6.3) //restituisce -6
Math.parseInt(2.5) //restituisce 2

Generare numeri casuali

L'uso di Math permette anche di generare numeri (pseudo) casuali tramite il metodo:

Math.random()

che restituisce un numero casuale decimale compreso tra 0 (incluso) e 1 (escluso). Nella pratica non è molto utile se non viene trasformato in un numero intero. Ad esempio questo codice simula il lancio di un dado:

var numLanci = prompt ("Quanti lanci vuoi effettuare?", 10);
var i; var lancio;
for (i = 0; i < numLanci; i++) {
 lancio = Math.floor(Math.random() * 6 + 1);
 alert("Lancio " + (i + 1) + ": " + lancio);
}

La riga che ci interessa è quella dell'assegnazione della variabile lancio. Per capire l'algoritmo usato, ragioniamo sul risultato che vogliamo ottenere.
Il numero che vogliamo ottenere (che chiameremo d) deve essere un numero intero compreso tra 1 e 6 inclusi. Dal momento che il generatore restituisce numeri tra 0 incluso e 1 escluso, dovremo:

moltiplicare per sei il numero casuale ottenuto (che chiameremo n): in questo modo possiamo ottenere un numero che va da 0 (se n = 0, allora d = 0) fino a sei escluso. Infatti d potrebbe essere uguale a 6 solo se n potesse essere uguale a 1, cosa che non è possibile
sommare uno al valore ottenuto: in questo modo d sarà compreso tra 1 (incluso) e 7 (escluso)
arrotondare il valore per difetto: in questo modo d sarà un numero intero compreso tra 1 e 6; infatti, dato che il 7 è escluso, arrotondando per difetto potremo ottenere al massimo 6.

Un esempio pratico

Di seguito viene mostrata un'applicazione pratica dei metodi dell'oggetto Math per la creazione di una funzione che arrotondi le cifre alla nesima cifra decimale indicata.

function arrotonda (num, dec, mod) {
 var div = Math.pow(10, dec);
 switch (mod) {
  case 'e':
  case 'E': //arrotonda per eccesso
   return Math.ceil(num * div) / div;
  break;
  case 'd':
  case 'D': //arrotonda per difetto
   return Math.floor(num * div) / div;
  break;
  case 't':
  case 'T': //troncamento
   return parseInt(num * div) / div;
  break;
  case 'a':
  case 'A': 
  default: //arrotonda
   return Math.round(num * div) / div;
 }
}
//per testarla usiamo queste righe di codice...
alert(arrotonda(3.43, 1, 't'));
alert(arrotonda(3.42, 1, 'e'));
alert(arrotonda(3.469, 2, 'd'));
alert(arrotonda(3.427, 2, 'e'));
alert(arrotonda(3.55, 1, 'a'));
alert(arrotonda(3.46, 1, 't'));

La funzione appena mostrata arrotonda il numero fornito come primo parametro alla cifra decimale fornita come secondo parametro usando diversi metodi di arrotondamento. Il tutto sta nel fatto che le funzioni di Math agiscono solo sui numeri interi e non su quelli decimali.
Per effettuare gli arrotondamenti, quindi, spostiamo la virgola di n posizioni decimali fornite come parametro ed eseguiamo l'arrotondamento desiderato; successivamente, spostiamo di nuovo la virgola all'indietro. Per spostare la virgola è sufficiente moltiplicare e dividere per una potenza di dieci: per fare ciò ci serviamo del metodo Math.pow()