Math

W tym rozdziale dowiesz się...

E

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; // 2.718281828459045
Math.E = 1;
Math.E; // 2.718281828459045

LN10

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; // 2.302585092994046
Math.LN10 = 1;
Math.LN10; // 2.302585092994046

LN2

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; // 0.6931471805599453
Math.LN2 = 1;
Math.LN2; // 0.6931471805599453

LOG2E

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; // 1.4426950408889634
Math.LOG2E = 1;
Math.LOG2E; // 1.4426950408889634

LOG10E

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; // 0.4342944819032518
Math.LOG10E = 1;
Math.LOG10E; // 0.4342944819032518

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; // 3.141592653589793
Math.PI = 1;
Math.PI; // 3.141592653589793

SQRT1_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; // 0.7071067811865476
Math.SQRT1_2 = 1;
Math.SQRT1_2; // 0.7071067811865476

SQRT2

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; // 1.4142135623730951
Math.SQRT2 = 1;
Math.SQRT2; // 1.4142135623730951

abs

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(-10);       // 10
Math.abs(1.2);       // 1.2
Math.abs(-0);        // 0
Math.abs(-Infinity); // Infinity
Math.abs(NaN);       // NaN

acos

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(-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

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(-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

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(-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

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:

// 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

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(-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

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(-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

Math.exp(x)
Parametry:
Number x - dowolna liczba
Wartość:
Number - wartość funkcji eksponencjalnej

Oblicza wartość funkcji eksponencjalnej, tzn.: Math.Ex.

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

Przykład:

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

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(-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

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(-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

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();                    // -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

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();                    // 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

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.: xy.

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(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

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();                       // np.: 0.29363602958619595
10 + Math.floor(Math.random() * 90); // np.: 25

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ół.

Co prawda nie można wprost wykonać zaokrąglenia liczby do podanego miejsca po przecinku, ale można to zrobić w inny sposób. Na przykład aby zaokrąglić liczbę do drugiego miejsca po przecinku, należy wpisać:

Math.round(x * 100) / 100

Przykład:

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(1.239 * 100) / 100; // 1.24
 
Math.round(NaN);               // NaN
Math.round(undefined);         // NaN

sin

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.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

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(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

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(0);         // 0
 
Math.tan(NaN);       // NaN
Math.tan(Infinity);  // NaN
Math.tan(-Infinity); // NaN