Math - JS

W tym rozdziale dowiesz się...

Jakie funkcje matematyczne są dostępne w języku JavaScript?

E
Ile wynosi liczba Eulera (podstawa logarytmu naturalnego)?
LN10
Ile wynosi logarytm naturalny z liczby 10?
LN2
Ile wynosi logarytm naturalny z liczby 2?
LOG2E
Ile wynosi logarytm o podstawie 2 z liczby Eulera?
LOG10E
Ile wynosi logarytm o podstawie 10 z liczby Eulera?
PI
Ile wynosi liczba "pi"?
SQRT1_2
Ile wynosi pierwiastek kwadratowy z liczby 1/2?
SQRT2
Ile wynosi pierwiastek kwadratowy z liczby 2?
abs
Jak obliczyć wartość bezwzględną liczby?
acos
Jak obliczyć arcus cosinus?
asin
Jak obliczyć arcus sinus?
atan
Jak obliczyć arcus tangens?
atan2
Jak wyznaczyć kąt, utworzony między dodatnią poziomą półosią układu współrzędnych a prostą przechodzącą przez środek układu współrzędnych i zadany punkt?
ceil
W jaki sposób zaokrąglić liczbę w górę?
cos
Jak obliczyć cosinus?
exp
Jak obliczyć wartość funkcji eksponencjalnej?
floor
W jaki sposób zaokrąglić liczbę w dół?
log
Jak obliczyć wartość logarytmu naturalnego?
max
Jak wybrać największą liczbę ze zbioru?
min
Jak wybrać najmniejszą liczbę ze zbioru?
pow
Jak podnieść podaną liczbę do określonej potęgi?
random
Jak wylosować liczbę? Czy można wylosować liczbę całkowitą z podanego przedziału wartości?
round
Jak zaokrąglić liczbę? Czy można wykonać zaokrąglenie do podanego miejsca po przecinku?
sin
Jak obliczyć sinus?
sqrt
Jak obliczyć pierwiastek kwadratowy?
tan
Jak obliczyć tangens lub cotangens?

E

Ile wynosi liczba Eulera (podstawa logarytmu naturalnego)?

Math.E

Wartość:: Number - podstawa logarytmu naturalnego (liczba Eulera = 2.718281828459045235...)

Przechowuje wartość stałej matematycznej, będącej podstawą logarytmu naturalnego. Tej wartości nie można zmienić ani nie będzie dostępna w pętli for-in.

Przykład Math.E

Math.E; // 2.718281828459045
Math.E = 1;
Math.E; // 2.718281828459045

LN10

Ile wynosi logarytm naturalny z liczby 10?

Math.LN10

Wartość:: Number - logarytm naturalny z liczby 10 (2.302585092994046...)

Przechowuje wartość stałej, będącej wartością logarytmu naturalnego z liczby 10. Tej wartości nie można zmienić ani nie będzie dostępna w pętli for-in.

Przykład Math.LN10

Math.LN10; // 2.302585092994046
Math.LN10 = 1;
Math.LN10; // 2.302585092994046

LN2

Ile wynosi logarytm naturalny z liczby 2?

Math.LN2

Wartość:: Number - logarytm naturalny z liczby 2 (0.6931471805599453...)

Przechowuje wartość stałej matematycznej, będącej wartością logarytmu naturalnego z liczby 2. Tej wartości nie można zmienić ani nie będzie dostępna w pętli for-in.

Przykład Math.LN2

Math.LN2; // 0.6931471805599453
Math.LN2 = 1;
Math.LN2; // 0.6931471805599453

LOG2E

Ile wynosi logarytm o podstawie 2 z liczby Eulera?

Math.LOG2E

Wartość:: Number - logarytm o podstawie 2 z liczby Math.E (1.44269504088896343...)

Przechowuje wartość stałej, będącej wartością logarytmu o podstawie 2 z liczby Math.E. Tej wartości nie można zmienić ani nie będzie dostępna w pętli for-in.

Przykład Math.LOG2E

Math.LOG2E; // 1.4426950408889634
Math.LOG2E = 1;
Math.LOG2E; // 1.4426950408889634

LOG10E

Ile wynosi logarytm o podstawie 10 z liczby Eulera?

Math.LOG10E

Wartość:: Number - logarytm o podstawie 10 z liczby Math.E (0.4342944819032518...)

Przechowuje wartość stałej, będącej wartością logarytmu o podstawie 10 z liczby Math.E. Tej wartości nie można zmienić ani nie będzie dostępna w pętli for-in.

Przykład Math.LOG10E

Math.LOG10E; // 0.4342944819032518
Math.LOG10E = 1;
Math.LOG10E; // 0.4342944819032518

PI

Ile wynosi liczba "pi"?

Math.PI

Wartość:: Number - stosunek długości obwodu koła do jego średnicy (liczba π = 3.141592653589793...)

Przechowuje wartość stałej matematycznej, będącej wartością stosunku obwodu koła do jego średnicy. Tej wartości nie można zmienić ani nie będzie dostępna w pętli for-in.

Przykład Math.PI

Math.PI; // 3.141592653589793
Math.PI = 1;
Math.PI; // 3.141592653589793

SQRT1_2

Ile wynosi pierwiastek kwadratowy z liczby 1/2?

Math.SQRT1_2

Wartość:: Number - pierwiastek kwadratowy z liczby 0.5 (0.7071067811865476...)

Przechowuje wartość stałej, będącej wartością pierwiastka kwadratowego z liczby 0.5. Tej wartości nie można zmienić ani nie będzie dostępna w pętli for-in.

Przykład Math.SQRT1_2

Math.SQRT1_2; // 0.7071067811865476
Math.SQRT1_2 = 1;
Math.SQRT1_2; // 0.7071067811865476

SQRT2

Ile wynosi pierwiastek kwadratowy z liczby 2?

Math.SQRT2

Wartość:: Number - pierwiastek kwadratowy z liczby 2 (1.4142135623730951...)

Przechowuje wartość stałej, będącej wartością pierwiastka kwadratowego z liczby 2. Tej wartości nie można zmienić ani nie będzie dostępna w pętli for-in.

Przykład Math.SQRT2

Math.SQRT2; // 1.4142135623730951
Math.SQRT2 = 1;
Math.SQRT2; // 1.4142135623730951

abs

Jak obliczyć wartość bezwzględną liczby?

Math.abs(x)

Parametry:: Number x - dowolna liczba
Wartość:: Number - wartość bezwzględna

Oblicza wartość bezwzględną z podanej liczby. Wartość bezwzględna nie uwzględnia znaku liczby, tzn. nigdy nie jest ujemna. Dla liczb nieujemnych pozostawia przekazaną wartość bez zmian. Natomiast ujemnym zmienia znak na przeciwny (dodatni).

Przykład Math.abs

Math.abs(-10);       // 10
Math.abs(1.2);       // 1.2
Math.abs(-0);        // 0
Math.abs(-Infinity); // Infinity
Math.abs(NaN);       // NaN

acos

Jak obliczyć arcus cosinus?

Math.acos(x)

Parametry:: Number x - liczba rzeczywista z przedziału -1...1
Wartość:: Number - kąt wyrażony w radianach z przedziału od 0 do Math.PI

Oblicza wartość funkcji arcus cosinus, będącej odwrotnością funkcji Math.cos. Funkcja odwrotna przyporządkowuje wartościom funkcji właściwe im argumenty.

Aby sprawdzić, czy funkcja nie zwróciła przypadkiem niepoprawnego wyniku, użyj funkcji isNaN.

Przykład Math.acos

Math.acos(-Infinity); // NaN
Math.acos(-1.01);     // NaN
Math.acos(-1);        // 3.141592653589793 == Math.PI
Math.acos(-0.75);     // 2.4188584057763776
Math.acos(-0.5);      // 2.0943951023931957
Math.acos(-0.25);     // 1.8234765819369754
Math.acos(0);         // 1.5707963267948966
Math.acos(0.25);      // 1.318116071652818
Math.acos(0.5);       // 1.0471975511965979
Math.acos(0.75);      // 0.7227342478134157
Math.acos(1);         // 0
Math.acos(1.01);      // NaN
Math.acos(Infinity);  // NaN
Math.acos(NaN);       // NaN

asin

Jak obliczyć arcus sinus?

Math.asin(x)

Parametry:: Number x - liczba rzeczywista z przedziału -1...1
Wartość:: Number - kąt wyrażony w radianach z przedziału od -Math.PI/2 do Math.PI/2

Oblicza wartość funkcji arcus sinus, będącej odwrotnością funkcji Math.sin. Funkcja odwrotna przyporządkowuje wartościom funkcji właściwe im argumenty.

Aby sprawdzić, czy funkcja nie zwróciła przypadkiem niepoprawnego wyniku, użyj funkcji isNaN.

Przykład Math.asin

Math.asin(-Infinity); // NaN
Math.asin(-1.01);     // NaN
Math.asin(-1);        // -1.5707963267948966 == -Math.PI/2
Math.asin(-0.75);     // -0.848062078981481
Math.asin(-0.5);      // -0.5235987755982989
Math.asin(-0.25);     // -0.25268025514207865
Math.asin(0);         // 0
Math.asin(0.25);      // 0.25268025514207865
Math.asin(0.5);       // 0.5235987755982989
Math.asin(0.75);      // 0.848062078981481
Math.asin(1);         // 1.5707963267948966  == Math.PI/2
Math.asin(1.01);      // NaN
Math.asin(Infinity);  // NaN
Math.asin(NaN);       // NaN

atan

Jak obliczyć arcus tangens?

Math.atan(x)

Parametry:: Number x - dowolna liczba rzeczywista
Wartość:: Number - kąt wyrażony w radianach z przedziału od -Math.PI/2 do Math.PI/2

Oblicza wartość funkcji arcus tangens, będącej odwrotnością funkcji Math.tan. Funkcja odwrotna przyporządkowuje wartościom funkcji właściwe im argumenty.

Aby sprawdzić, czy funkcja nie zwróciła przypadkiem niepoprawnego wyniku, użyj funkcji isNaN.

Przykład Math.atan

Math.atan(-Infinity); // -1.5707963267948966 == -Math.PI/2
Math.atan(-1.01);     // -0.7903732467283024
Math.atan(-1);        // -0.7853981633974483
Math.atan(-0.75);     // -0.6435011087932844
Math.atan(-0.5);      // -0.4636476090008061
Math.atan(-0.25);     // -0.24497866312686414
Math.atan(0);         // 0
Math.atan(0.25);      // 0.24497866312686414
Math.atan(0.5);       // 0.4636476090008061
Math.atan(0.75);      // 0.6435011087932844
Math.atan(1);         // 0.7853981633974483
Math.atan(1.01);      // 0.7903732467283024
Math.atan(Infinity);  // 1.5707963267948966  == Math.PI/2
Math.atan(NaN);       // NaN

atan2

Jak wyznaczyć kąt, utworzony między dodatnią poziomą półosią układu współrzędnych a prostą przechodzącą przez środek układu współrzędnych i zadany punkt?

Math.atan2(y, x)

Parametry:: Number y - współrzędna pionowa; Number x - współrzędna pozioma
Wartość:: Number - kąt wyrażony w radianach z przedziału od -Math.PI do Math.PI

Oblicza wartość funkcji arcus tangens z ilorazu y/x. W wyniku otrzymujemy wartość kąta, utworzonego pomiędzy dodatnią poziomą półosią układu współrzędnych a prostą przechodzącą przez środek układu współrzędnych i zadany punkt. Kąt ten jest wyrażony w radianach i mierzony w kierunku przeciwnym do ruchu wskazówek zegara.

Zwróć uwagę, że pierwszym argumentem tej funkcji jest współrzędna pionowa, a nie - tak jak możemy być przyzwyczajeni - pozioma.

Przykład Math.atan2

// Dodatnia pozioma półoś:
Math.atan2(-0, 0); // -0
Math.atan2(0, 0); // 0
Math.atan2(0, 0.01); // 0
Math.atan2(0, 1); // 0
Math.atan2(0, Infinity); // 0
 
// Pierwsza ćwiartka układu współrzędnych
Math.atan2(0.5, 1);             // 0.4636476090008061
Math.atan2(1, 1);               // 0.7853981633974483 == Math.PI/4
Math.atan2(1, 0.5);             // 1.1071487177940904
Math.atan2(Infinity, Infinity); // 0.7853981633974483 == Math.PI/4
 
// Dodatnia pionowa półoś:
Math.atan2(0.01, 0); // 1.5707963267948966 == Math.PI/2
Math.atan2(1, 0); // 1.5707963267948966 == Math.PI/2
Math.atan2(Infinity, 0);          // 1.5707963267948966  == Math.PI/2
 
// Druga ćwiartka układu współrzędnych
Math.atan2(1, -0.5);              // 2.0344439357957027
Math.atan2(1, -1);                // 2.356194490192345   == 3/4*Math.PI
Math.atan2(0.5, -1);              // 2.677945044588987
Math.atan2(Infinity, -Infinity);  // 2.356194490192345   == 3/4*Math.PI
 
// Ujemna pozioma półoś:
Math.atan2(-0, -0);               // 3.141592653589793   == -Math.PI
Math.atan2(0, -0);                // 3.141592653589793   == Math.PI
Math.atan2(0, -0.01);             // 3.141592653589793   == Math.PI
Math.atan2(0, -1);                // 3.141592653589793   == Math.PI
Math.atan2(0, -Infinity);         // 3.141592653589793   == Math.PI
 
// Trzecia ćwiartka układu współrzędnych
Math.atan2(-0.5, 1);              // -0.4636476090008061
Math.atan2(-1, 1);                // -0.7853981633974483 == -Math.PI/4
Math.atan2(-1, 0.5);              // -1.1071487177940904
Math.atan2(-Infinity, Infinity);  // -0.7853981633974483 == -Math.PI/4
 
// Ujemna pionowa półoś:
Math.atan2(-0.01, 0);             // -1.5707963267948966 == -Math.PI/2
Math.atan2(-1, 0);                // -1.5707963267948966 == -Math.PI/2
Math.atan2(-Infinity, 0);         // -1.5707963267948966 == -Math.PI/2
 
// Czwarta ćwiartka układu współrzędnych
Math.atan2(-1, -0.5);             // -2.0344439357957027
Math.atan2(-1, -1);               // -2.356194490192345  == -3/4*Math.PI
Math.atan2(-0.5, -1);             // -2.677945044588987
Math.atan2(-Infinity, -Infinity); // -2.356194490192345  == -3/4*Math.PI
 
Math.atans(NaN, 0);               // NaN
Math.atan2(0, NaN);               // NaN
Math.atan2(NaN, NaN);             // NaN

ceil

W jaki sposób zaokrąglić liczbę w górę?

Math.ceil(x)

Parametry:: Number x - dowolna liczba rzeczywista
Wartość:: Number - liczba całkowita zaokrąglona w górę

Wykonuje zaokrąglenie dowolnej liczby rzeczywistej do najbliższej większej lub równej liczby całkowitej.

Math.ceil(x) == -Math.floor(-x)

Przykład Math.ceil

Math.ceil(-Infinity); // -Infinity
Math.ceil(-1.9);      // -1
Math.ceil(-1.1);      // -1
Math.ceil(-1);        // -1
Math.ceil(-0.9);      // 0
Math.ceil(-0.1);      // 0
Math.ceil(0);         // 0
Math.ceil(0.1);       // 1
Math.ceil(0.9);       // 1
Math.ceil(1);         // 1
Math.ceil(1.1);       // 2
Math.ceil(1.9);       // 2
Math.ceil(Infinity);  // Infinity
 
Math.ceil(NaN);       // NaN

cos

Jak obliczyć cosinus?

Math.cos(x)

Parametry:: Number x - kąt wyrażony w radianach
Wartość:: Number - liczba rzeczywista z przedziału -1...1

Oblicza wartość funkcji cosinus, będącej stosunkiem przyległej przyprostokątnej do przeciwprostokątnej w trójkącie prostokątnym.

Math.pow(Math.sin(x), 2) + Math.pow(Math.cos(x), 2) == 1

Przykład Math.cos

Math.cos(-2*Math.PI); // 1
Math.cos(-Math.PI);   // -1
Math.cos(0);          // 1
Math.cos(Math.PI);    // -1
Math.cos(2*Math.PI);  // 1
 
Math.cos(NaN);        // NaN
Math.cos(Infinity);   // NaN
Math.cos(-Infinity);  // NaN

exp

Jak obliczyć wartość funkcji eksponencjalnej?

Math.exp(x)

Parametry:: Number x - dowolna liczba
Wartość:: Number - wartość funkcji eksponencjalnej

Oblicza wartość funkcji eksponencjalnej, tzn.: Math.E^x.

Math.exp(x) == Math.pow(Math.E, x)

Przykład Math.exp

Math.exp(-Infinity); // 1
Math.exp(-1);        // 0.3678794411714424
Math.exp(-0.5);      // 0.6065306597126334
Math.exp(0);         // 1
Math.exp(0.5);       // 1.6487212707001282
Math.exp(1);         // 2.718281828459045
Math.exp(Infinity);  // Infinity
 
Math.exp(NaN);       // NaN

floor

W jaki sposób zaokrąglić liczbę w dół?

Math.floor(x)

Parametry:: Number x - dowolna liczba rzeczywista
Wartość:: Number - liczba całkowita zaokrąglona w dół

Wykonuje zaokrąglenie dowolnej liczby rzeczywistej do najbliższej mniejszej lub równej liczby całkowitej.

Math.floor(x) == -Math.ceil(-x)

Przykład Math.floor

Math.floor(-Infinity); // -Infinity
Math.floor(-1.9);      // -2
Math.floor(-1.1);      // -2
Math.floor(-1);        // -1
Math.floor(-0.9);      // -1
Math.floor(-0.1);      // -1
Math.floor(0);         // 0
Math.floor(0.1);       // 0
Math.floor(0.9);       // 0
Math.floor(1);         // 1
Math.floor(1.1);       // 1
Math.floor(1.9);       // 1
Math.floor(Infinity);  // Infinity
 
Math.floor(NaN);       // NaN

log

Jak obliczyć wartość logarytmu naturalnego?

Math.log(x)

Parametry:: Number x - liczba rzeczywista większa lub równa 0
Wartość:: Number - logarytm naturalny

Oblicza wartość logarytmu naturalnego, czyli logarytmu o podstawie Math.E.

Aby sprawdzić, czy funkcja nie zwróciła przypadkiem niepoprawnego wyniku, użyj funkcji isNaN.

Przykład Math.log

Math.log(-Infinity); // NaN
Math.log(-0.01);     // NaN
Math.log(0);         // -Infinity
Math.log(0.5);       // -0.6931471805599453
Math.log(1);         // 0
Math.log(Math.E);    // 1
Math.log(Infinity);  // Infinity
Math.log(NaN);       // NaN

max

Jak wybrać największą liczbę ze zbioru?

Math.max()
Math.max(value1)
Math.max(value1, value2...)

Parametry:: Number value1, Number value2... - lista dowolnych liczb
Wartość:: Number - największa z podanych liczb

Wyznacza największą z podanych liczb. Jeżeli do funkcji nie zostały przekazane żadne argumenty, zwracana jest wartość -Infinity. Jeżeli którakolwiek z podanych wartości wynosi NaN, funkcja zwraca wartość NaN (można to sprawdzić za pomocą funkcji isNaN).

Przykład Math.max

Math.max();                    // -Infinity
 
Math.max(1);                   // 1
Math.max(1, 2);                // 2
Math.max(-1.2, -1, 0, 1, 1.2); // 1.2
Math.max(-Infinity, Infinity); // Infinity
 
Math.max(NaN);                 // NaN
Math.max(NaN, 0);              // NaN
Math.max(0, NaN);              // NaN
Math.max(0, 1, NaN);           // NaN
Math.max(undefined);           // NaN

min

Jak wybrać najmniejszą liczbę ze zbioru?

Math.min()
Math.min(value1)
Math.min(value1, value2...)

Parametry:: Number value1, Number value2... - lista dowolnych liczb
Wartość:: Number - najmniejsza z podanych liczb

Wyznacza najmniejszą z podanych liczb. Jeżeli do funkcji nie zostały przekazane żadne argumenty, zwracana jest wartość Infinity. Jeżeli którakolwiek z podanych wartości wynosi NaN, funkcja zwraca wartość NaN (można to sprawdzić za pomocą funkcji isNaN).

Przykład Math.min

Math.min();                    // Infinity
 
Math.min(1);                   // 1
Math.min(1, 2);                // 1
Math.min(-1.2, -1, 0, 1, 1.2); // -1.2
Math.min(-Infinity, Infinity); // -Infinity
 
Math.min(NaN);                 // NaN
Math.min(NaN, 0);              // NaN
Math.min(0, NaN);              // NaN
Math.min(0, 1, NaN);           // NaN
Math.min(undefined);           // NaN

pow

Jak podnieść podaną liczbę do określonej potęgi?

Math.pow(x, y)

Parametry:: Number x - podstawa potęgi; Number y - wykładnik potęgi
Wartość:: Number - wartość funkcji wykładniczej

Oblicza wartość funkcji wykładniczej, tzn.: x^y.

Aby sprawdzić, czy funkcja zwróciła skończoną wartość, użyj isFinite. Natomiast w celu sprawdzenia, czy zwrócona wartość nie jest przypadkiem niepoprawną liczbą - isNaN.

Przykład Math.pow

Math.pow(2, 3);            // 8
Math.pow(4, 0.5);          // 2
Math.pow(2, -1);           // 0.5
 
Math.pow(-1, NaN);         // NaN
Math.pow(0, NaN);          // NaN
Math.pow(1, NaN);          // NaN
 
Math.pow(-1, 0);           // 1
Math.pow(0, 0);            // 1
Math.pow(1, 0);            // 1
Math.pow(NaN, 0);          // 1
 
Math.pow(-1, -0);          // 1
Math.pow(0, -0);           // 1
Math.pow(1, -0);           // 1
Math.pow(NaN, -0);         // 1
 
Math.pow(NaN, -1);         // NaN
Math.pow(NaN, 1);          // NaN
 
Math.pow(1.1, Infinity);   // Infinity
Math.pow(-1.1, Infinity);  // Infinity
 
Math.pow(1.1, -Infinity);  // 0
Math.pow(-1.1, -Infinity); // 0
 
Math.pow(1, Infinity);     // NaN
Math.pow(-1, Infinity);    // NaN
 
Math.pow(1, -Infinity);    // NaN
Math.pow(-1, -Infinity);   // NaN
 
Math.pow(-0.5, Infinity);  // 0
Math.pow(0.5, Infinity);   // 0
 
Math.pow(-0.5, -Infinity); // Infinity
Math.pow(0.5, -Infinity);  // Infinity
 
Math.pow(Infinity, 0.5);  // Infinity
Math.pow(Infinity, 1);    // Infinity
Math.pow(Infinity, 1.5);  // Infinity
 
Math.pow(Infinity, -1.5); // 0
Math.pow(Infinity, -1);   // 0
Math.pow(Infinity, -0.5); // 0
 
Math.pow(-Infinity, 1);   // -Infinity
Math.pow(-Infinity, 3);   // -Infinity
Math.pow(-Infinity, 5);   // -Infinity
 
Math.pow(-Infinity, 2);   // Infinity
Math.pow(-Infinity, 4);   // Infinity
Math.pow(-Infinity, 6);   // Infinity
 
Math.pow(-Infinity, -1);  // -0
Math.pow(-Infinity, -3);  // -0
Math.pow(-Infinity, -5);  // -0
 
Math.pow(-Infinity, -2);  // 0
Math.pow(-Infinity, -4);  // 0
Math.pow(-Infinity, -6);  // 0
 
Math.pow(0, 0.5);         // 0
Math.pow(0, 1);           // 0
Math.pow(0, 1.5);         // 0
 
Math.pow(0, -1.5);        // Infinity
Math.pow(0, -1);          // Infinity
Math.pow(0, -1.5);        // Infinity
 
Math.pow(-0, 1);          // -0
Math.pow(-0, 3);          // -0
Math.pow(-0, 5);          // -0
 
Math.pow(-0, 2);          // 0
Math.pow(-0, 4);          // 0
Math.pow(-0, 6);          // 0
 
Math.pow(-0, -1);         // -Infinity
Math.pow(-0, -3);         // -Infinity
Math.pow(-0, -5);         // -Infinity
 
Math.pow(-0, -2);         // Infinity
Math.pow(-0, -4);         // Infinity
Math.pow(-0, -6);         // Infinity
 
Math.pow(-1.5, 0.5);      // NaN
Math.pow(-0.5, 0.5);      // NaN
Math.pow(-1.5, -1.5);     // NaN
Math.pow(-1, -1.5);       // NaN

random

Jak wylosować liczbę? Czy można wylosować liczbę całkowitą z podanego przedziału wartości?

Math.random

Math.random()

Wartość:: Number - liczba pseudolosowa większa lub równa 0 i mniejsza od 1

Zwraca liczbę pseudolosową.

Co prawda nie można wprost podać zakresu, z którego chcemy wylosować liczbę, ale można to zrobić w inny sposób. Na przykład aby wylosować naturalną liczbę dwucyfrową (10...99), należy wpisać:

10 + Math.floor(Math.random() * 90)

Przykład Math.random

Math.random(); // np.: 0.29363602958619595

Wylosowanie liczby całkowitej z podanego przedziału

Co prawda nie można wprost wylosować liczby z podanego przedziału wartości, ale da się to zrobić poprzez bardzo proste operacje matematyczne. Na przykład aby wylosować liczbę całkowitą z przedziału od 10 do 99 (włącznie) wystarczy wpisać:

10 + Math.floor(Math.random() * 90); // np.: 25

round

Jak zaokrąglić liczbę? Czy można wykonać zaokrąglenie do podanego miejsca po przecinku?

Math.round

Math.round(x)

Parametry:: Number x - liczba rzeczywista
Wartość:: Number - zaokrąglona liczba całkowita

Zaokrągla wartość do liczby całkowitej - zgodnie z regułami matematycznymi. Jeżeli cyfra po przecinku jest większa lub równa 5, następuje zaokrąglenie w górę, a w przeciwnym razie w dół.

Przykład Math.round

Math.round(-Infinity); // -Infinity
Math.round(-1);        // -1
Math.round(-0.9);      // -1
Math.round(-0.5);      // -1
Math.round(-0.4);      // 0
Math.round(-0.1);      // 0
Math.round(0);         // 0
Math.round(0.1);       // 0
Math.round(0.4);       // 0
Math.round(0.5);       // 1
Math.round(0.9);       // 1
Math.round(1);         // 1
Math.round(Infinity);  // Infinity
 
Math.round(NaN);       // NaN
Math.round(undefined); // NaN

Zaokrąglenie liczby do podanego miejsca po przecinku

Co prawda nie da się wprost wykonać zaokrąglenia liczby do podanego miejsca po przecinku, ale można to zrobić w inny sposób. Trzeba jednak przy tym uważać na tzw. błąd zaokrągleń liczb zmiennoprzecinkowych. Na przykład aby zaokrąglić liczbę x do drugiego miejsca po przecinku, z czysto matematycznego punktu widzenia powinno wystarczyć wpisanie:

Math.round(x * 100) / 100

Niestety jak się możemy przekonać, w przypadku niektórych liczb wynik nie daje oczekiwanych rezultatów:

Math.round(1.005 * 100) / 100;  // 1
1.005 * 100;                    // 100.49999999999999
Math.round(100.49999999999999); // 100

Rozwiązaniem będzie zastosowanie notacji wykładniczej unikając tym samym błędu wynikającego z wykonywania operacji na liczbie zmiennoprzecinkowej:

Number(Math.round(1.005 + 'e+2') + 'e-2'); // 1.01

sin

Jak obliczyć sinus?

Math.sin(x)

Parametry:: Number x - kąt wyrażony w radianach
Wartość:: Number - liczba rzeczywista z przedziału -1...1

Oblicza wartość funkcji sininus, będącej stosunkiem przeciwległej przyprostokątnej do przeciwprostokątnej w trójkącie prostokątnym.

Math.pow(Math.sin(x), 2) + Math.pow(Math.cos(x), 2) == 1

Przykład Math.sin

Math.sin(-Math.PI/2); // -1
Math.sin(0);          // 0
Math.sin(Math.PI/2);  // 1
 
Math.sin(NaN);        // NaN
Math.sin(Infinity);   // NaN
Math.sin(-Infinity);  // NaN

sqrt

Jak obliczyć pierwiastek kwadratowy?

Math.sqrt(x)

Parametry:: Number x - nieujemna liczba rzeczywista
Wartość:: Number - nieujemna liczba rzeczywista

Oblicza wartość pierwiastka kwadratowego, takiego że:

Math.sqrt(Math.pow(x, 2)) == Math.abs(x)

Ta funkcja jest równoważna wywołaniu: Math.pow(x, 0.5).

Aby sprawdzić, czy funkcja nie zwróciła przypadkiem niepoprawnego wyniku, użyj funkcji isNaN.

Przykład Math.sqrt

Math.sqrt(0);        // 0
Math.sqrt(1);        // 1
Math.sqrt(4);        // 2
Math.sqrt(9);        // 3
Math.sqrt(16);       // 4
Math.sqrt(Infinity); // Infinity
 
Math.sqrt(NaN);      // NaN
Math.sqrt(-1);       // NaN

tan

Jak obliczyć tangens lub cotangens?

Math.tan(x)

Parametry:: Number x - kąt wyrażony w radianach
Wartość:: Number - liczba rzeczywista

Oblicza wartość funkcji tangens, będącej stosunkiem przeciwległej przyprostokątnej do przyległej przyprostokątnej w trójkącie prostokątnym.

Math.tan(x) == Math.sin(x) / Math.cos(x)

Choć specyfikacja nie zawiera funkcji ctan, cotangens można obliczyć w bardzo prosty sposób:
1 / Math.tan(x)

Przykład Math.tan

Math.tan(0);         // 0
 
Math.tan(NaN);       // NaN
Math.tan(Infinity);  // NaN
Math.tan(-Infinity); // NaN