• 
  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ę?

• 
  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?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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