From 218934fa2ed1c702a6d3923d2aa2cc6b43c48684 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:43:23 -0500 Subject: initial commit --- .../reference/global_objects/math/abs/index.html | 104 +++++++++++ .../reference/global_objects/math/acos/index.html | 110 ++++++++++++ .../reference/global_objects/math/acosh/index.html | 91 ++++++++++ .../reference/global_objects/math/asin/index.html | 103 +++++++++++ .../reference/global_objects/math/asinh/index.html | 92 ++++++++++ .../reference/global_objects/math/atan/index.html | 106 +++++++++++ .../reference/global_objects/math/atan2/index.html | 119 +++++++++++++ .../reference/global_objects/math/atanh/index.html | 92 ++++++++++ .../reference/global_objects/math/cbrt/index.html | 100 +++++++++++ .../reference/global_objects/math/ceil/index.html | 174 ++++++++++++++++++ .../reference/global_objects/math/clz32/index.html | 113 ++++++++++++ .../reference/global_objects/math/cos/index.html | 83 +++++++++ .../reference/global_objects/math/cosh/index.html | 93 ++++++++++ .../reference/global_objects/math/e/index.html | 85 +++++++++ .../reference/global_objects/math/exp/index.html | 76 ++++++++ .../reference/global_objects/math/expm1/index.html | 85 +++++++++ .../reference/global_objects/math/floor/index.html | 164 +++++++++++++++++ .../global_objects/math/fround/index.html | 114 ++++++++++++ .../reference/global_objects/math/hypot/index.html | 119 +++++++++++++ .../reference/global_objects/math/imul/index.html | 97 +++++++++++ .../reference/global_objects/math/index.html | 153 ++++++++++++++++ .../reference/global_objects/math/ln10/index.html | 66 +++++++ .../reference/global_objects/math/ln2/index.html | 70 ++++++++ .../reference/global_objects/math/log/index.html | 113 ++++++++++++ .../reference/global_objects/math/log10/index.html | 92 ++++++++++ .../global_objects/math/log10e/index.html | 66 +++++++ .../reference/global_objects/math/log1p/index.html | 94 ++++++++++ .../reference/global_objects/math/log2/index.html | 102 +++++++++++ .../reference/global_objects/math/log2e/index.html | 66 +++++++ .../reference/global_objects/math/max/index.html | 102 +++++++++++ .../reference/global_objects/math/min/index.html | 98 +++++++++++ .../reference/global_objects/math/pi/index.html | 64 +++++++ .../reference/global_objects/math/pow/index.html | 117 +++++++++++++ .../global_objects/math/random/index.html | 113 ++++++++++++ .../reference/global_objects/math/sign/index.html | 116 ++++++++++++ .../reference/global_objects/math/sin/index.html | 78 +++++++++ .../reference/global_objects/math/sinh/index.html | 93 ++++++++++ .../reference/global_objects/math/sqrt/index.html | 81 +++++++++ .../global_objects/math/sqrt1_2/index.html | 65 +++++++ .../reference/global_objects/math/sqrt2/index.html | 65 +++++++ .../reference/global_objects/math/tan/index.html | 83 +++++++++ .../reference/global_objects/math/tanh/index.html | 85 +++++++++ .../reference/global_objects/math/trunc/index.html | 128 ++++++++++++++ .../index.html" | 194 +++++++++++++++++++++ 44 files changed, 4424 insertions(+) create mode 100644 files/uk/web/javascript/reference/global_objects/math/abs/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/acos/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/acosh/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/asin/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/asinh/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/atan/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/atan2/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/atanh/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/cbrt/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/ceil/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/clz32/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/cos/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/cosh/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/e/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/exp/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/expm1/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/floor/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/fround/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/hypot/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/imul/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/ln10/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/ln2/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/log/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/log10/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/log10e/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/log1p/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/log2/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/log2e/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/max/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/min/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/pi/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/pow/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/random/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/sign/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/sin/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/sinh/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/sqrt/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/sqrt1_2/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/sqrt2/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/tan/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/tanh/index.html create mode 100644 files/uk/web/javascript/reference/global_objects/math/trunc/index.html create mode 100644 "files/uk/web/javascript/reference/global_objects/math/\320\267\320\260\320\276\320\272\321\200\321\203\320\263\320\265\320\273\320\275\320\275\321\217/index.html" (limited to 'files/uk/web/javascript/reference/global_objects/math') diff --git a/files/uk/web/javascript/reference/global_objects/math/abs/index.html b/files/uk/web/javascript/reference/global_objects/math/abs/index.html new file mode 100644 index 0000000000..b75b1e811c --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/abs/index.html @@ -0,0 +1,104 @@ +--- +title: Math.abs() +slug: Web/JavaScript/Reference/Global_Objects/Math/abs +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs +--- +
{{JSRef}}
+ +

Функція Math.abs() повертає абсолютне значення (модуль) числа, що дорівнює:

+ +

Math.abs(x)=|x|={xifx>00ifx=0-xifx<0

+ +
{{EmbedInteractiveExample("pages/js/math-abs.html")}}
+ + + +

Синтаксис

+ +
Math.abs(x)
+ +

Параметри

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Абсолютне значення данного числа.

+ +

Опис

+ +

Оскільки abs() статичний метод об'єкту Math, він завжди використовується як Math.abs(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

Приклади

+ +

Поведінка методу Math.abs()

+ +

Передача пустого об'єкту, масиву з кількома числами, не числової строки {{jsxref("undefined")}}/пустої змінної, повертає  {{jsxref("NaN")}}. Передача {{jsxref("null")}}, пустої строки або пустого масиву, повертає - 0.

+ +
Math.abs('-1');     // 1
+Math.abs(-2);       // 2
+Math.abs(null);     // 0
+Math.abs('');       // 0
+Math.abs([]);       // 0
+Math.abs([2]);      // 2
+Math.abs([1,2]);    // NaN
+Math.abs({});       // NaN
+Math.abs('string'); // NaN
+Math.abs();         // NaN
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. Реалізовано у JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.1', 'Math.abs')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.abs', 'Math.abs')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.abs', 'Math.abs')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.abs")}}

+ +

Дивись також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/acos/index.html b/files/uk/web/javascript/reference/global_objects/math/acos/index.html new file mode 100644 index 0000000000..f549eb1b4c --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/acos/index.html @@ -0,0 +1,110 @@ +--- +title: Math.acos() +slug: Web/JavaScript/Reference/Global_Objects/Math/acos +tags: + - JavaScript + - Math + - Довідка + - арккосинус + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos +--- +
{{JSRef}}
+ +

Math.acos() - це метод, який повертає арккосинус (у радіанах)  від числа, що являється:

+ +

∀x∊[-1;1],Math.acos(x)=arccos(x)= такий унікальний y∊[0;π],для якогоcos(y)=x\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ унікальний } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x

+ +

{{EmbedInteractiveExample("pages/js/math-acos.html")}}

+ +

 

+ + + +

 

+ +

Синтакс

+ +
Math.acos(x)
+ +

Параметри

+ +
+
x
+
Число.
+
+

Результат

+
+
Значення арккосинуса (у радіанах) поданого числа між -1 та 1; інакше - {{jsxref("NaN")}}.
+
+ +

Опис

+ +

Math.acos(x) метод вертає число між  0 і π радіан,  для x між-1 і 1. Якщо число вийде за межі -1 ... +1,  метод поверне {{jsxref("NaN")}}.

+ +

Оскільки acos() є статичним методом в обєкта Math, ви завжди повинні використовувати його як Math.acos(), а не викликати метод на створеному екземплярі обєкта Math (тому що Math не є конструктором).

+ +

Приклади

+ +

 

+ +
Math.acos(-2);  // NaN
+Math.acos(-1);  // 3.141592653589793
+Math.acos(0);   // 1.5707963267948966
+Math.acos(0.5); // 1.0471975511965979
+Math.acos(1);   // 0
+Math.acos(2);   // NaN
+
+ +

Для значень менших за -1 або більших за 1, Math.acos() повертає {{jsxref("NaN")}}.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. Реалізовано у JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.2', 'Math.acos')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.acos', 'Math.acos')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.acos', 'Math.acos')}}{{Spec2('ESDraft')}} 
+ +

Підтримка браузерами

+ +
+ +
+ +
{{Compat("javascript.builtins.Math.acos")}}
+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/acosh/index.html b/files/uk/web/javascript/reference/global_objects/math/acosh/index.html new file mode 100644 index 0000000000..01bdf629fa --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/acosh/index.html @@ -0,0 +1,91 @@ +--- +title: Math.acosh() +slug: Web/JavaScript/Reference/Global_Objects/Math/acosh +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acosh +--- +
{{JSRef}}
+ +

Функція Math.acosh() повертає гіперболічний арккосинус числа. Тобто:

+ +

∀x≥1,Math.acosh(x)=arcosh(x)= такий унікальний y≥0, для якогоcosh(y)=x\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } \; y \geq 0 \; \text{such that} \; \cosh(y) = x

+ +
{{EmbedInteractiveExample("pages/js/math-acosh.html")}}
+ + + +

Синтаксис

+ +
Math.acosh(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Гіперболічний арккосинус даного числа. У випадку, якщо аргумент менший за 1 - {{jsxref("NaN")}}.

+ +

Опис

+ +

У зв'язку із тим, що acosh() - статичний метод Math, слід завжди звертатись до нього у формі Math.acosh(). Намагатись викликати acosh(), звертаючись до методів  створених вами об'єктів Math - некоректно (Math не являється конструктором).

+ +

Приклади

+ +

Використання Math.acosh()

+ +
Math.acosh(-1);  // NaN
+Math.acosh(0);   // NaN
+Math.acosh(0.5); // NaN
+Math.acosh(1);   // 0
+Math.acosh(2);   // 1.3169578969248166
+
+ +

Для значень, що менші за 1 Math.acosh() повертає {{jsxref("NaN")}}.

+ +

Поліфіл

+ +

Для будь-якого x≥1x \geq 1 у нас є arcosh(x)=ln(x+x2-1)\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right). Таким чином ми можемо зімітувати метод за допомогою наступної функції:

+ +
Math.acosh = Math.acosh || function(x) {
+  return Math.log(x + Math.sqrt(x * x - 1));
+};
+
+ +

Специфікації

+ + + + + + + + + + + + +
Специфікації
{{SpecName('ESDraft', '#sec-math.acosh', 'Math.acosh')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.acosh")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/asin/index.html b/files/uk/web/javascript/reference/global_objects/math/asin/index.html new file mode 100644 index 0000000000..53a2a41b26 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/asin/index.html @@ -0,0 +1,103 @@ +--- +title: Math.asin() +slug: Web/JavaScript/Reference/Global_Objects/Math/asin +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin +--- +
{{JSRef}}
+ +

Метод Math.asin() повертає значення (в радіанах) арксинуса числа, що являється

+ +

∀x∊[-1;1],Math.asin(x)=arcsin(x)= такому унікальному y∊[-π2;π2], для якогоsin(y)=x\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x

+ +
{{EmbedInteractiveExample("pages/js/math-asin.html")}}
+ + + +

Синтаксис

+ +
Math.asin(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Арксинус  (в радіанах) поданого числа від -1 до 1; інакше - {{jsxref("NaN")}}.

+ +

Опис

+ +

Метод Math.asin(x) повертає числове значення між -π2-\frac{\pi}{2} та π2\frac{\pi}{2} радіан для x від -1 до 1. Якщо значення x за межами цього проміжку, він повертає {{jsxref("NaN")}}.

+ +

Оскільки asin() - це статичний метод об'єкту Math, він завжди використовується як Math.asin(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

Приклади

+ +

Використання Math.asin()

+ +
Math.asin(-2);  // NaN
+Math.asin(-1);  // -1.5707963267948966 (-pi/2)
+Math.asin(0);   // 0
+Math.asin(0.5); // 0.5235987755982989
+Math.asin(1);   // 1.5707963267948966 (pi/2)
+Math.asin(2);   // NaN
+
+ +

Для значень, менших за -1 чи більших за 1, Math.asin() повертає {{jsxref("NaN")}}.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатус документуПримітка
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. Реалізовано у JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.3', 'Math.asin')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.asin', 'Math.asin')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.asin', 'Math.asin')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.asin")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/asinh/index.html b/files/uk/web/javascript/reference/global_objects/math/asinh/index.html new file mode 100644 index 0000000000..4d58b44c80 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/asinh/index.html @@ -0,0 +1,92 @@ +--- +title: Math.asinh() +slug: Web/JavaScript/Reference/Global_Objects/Math/asinh +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asinh +--- +
{{JSRef}}
+ +

Функція Math.asinh() повертає гіперболічний арксинус числа, що являється:

+ +

Math.asinh(x)=arsinh(x)= такий унікальний y,  для якого sinh(y)=x\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } \; y \; \text{such that} \; \sinh(y) = x

+ +
{{EmbedInteractiveExample("pages/js/math-asinh.html")}}
+ + + +

Синтаксис

+ +
Math.asinh(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Гіперболічний арксинус поданого числа.

+ +

Опис

+ +

Оскільки asinh() статичний метод об'єкту Math, він завжди використовується як Math.asinh(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

Приклади

+ +

Застосування Math.asinh()

+ +
Math.asinh(1);  // 0.881373587019543
+Math.asinh(0);  // 0
+
+ +

Поліфіл

+ +

В якості швидкого і брудного трюку для грубої імітації оригіналу можна застосувати формулу arsinh(x)=ln(x+x2+1)\operatorname {arsinh} (x) = \ln \left(x + \sqrt{x^{2} + 1} \right) у вигляді такої функції:

+ +
Math.asinh = Math.asinh || function(x) {
+  if (x === -Infinity) {
+    return x;
+  } else {
+    return Math.log(x + Math.sqrt(x * x + 1));
+  }
+};
+
+ +

Являючись формально вірною, вона страждає від значної кількості помилок, пов'язаних із обчисленням чисел із плаваючою комою. Точні результати потребують спеціальної обробки додатніх і від'ємних, дрібних і великих значень аргументів, так, як це зроблено, наприклад, у  glibc чи GNU Scientific Library.

+ +

Специфікації

+ + + + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.asinh', 'Math.asinh')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.asinh")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/atan/index.html b/files/uk/web/javascript/reference/global_objects/math/atan/index.html new file mode 100644 index 0000000000..bbc76aade4 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/atan/index.html @@ -0,0 +1,106 @@ +--- +title: Math.atan() +slug: Web/JavaScript/Reference/Global_Objects/Math/atan +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan +--- +
{{JSRef}}
+ +

Функція Math.atan() повертає арктангенс (у радіанах) від числа, що являється:

+ +

Math.atan(x)=arctan(x)= такий унікальний y∊[-π2;π2], для якого tan(y)=x\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x

+ +
{{EmbedInteractiveExample("pages/js/math-atan.html")}}
+ + + +

Синтаксис

+ +
Math.atan(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Арктангенс (у радіанах) від поданого числа.

+ +

Опис

+ +

Метод Math.atan() повертає числове значення з-поміж -π2-\frac{\pi}{2} та π2\frac{\pi}{2} радіан.

+ +

Оскільки atan() статичний метод об'єкту Math, він завжди використовується як Math.atan(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

Приклади

+ +

Застосування Math.atan()

+ +
Math.atan(1);   // 0.7853981633974483
+Math.atan(0);   // 0
+Math.atan(-0);  // -0
+
+Math.atan(Infinity);   //  1.5707963267948966
+Math.atan(-Infinity);  // -1.5707963267948966
+
+// The angle that the line [(0,0);(x,y)] forms with the x-axis in a Cartesian coordinate system
+Math.atan(y / x);
+
+ +

Зверніть увагу - можливо вам захочеться уникнути використання ±Infinity із стилістичних міркуваня. У цьому випадку {{jsxref("Math.atan2()")}} із 0 в якості другого аргументу може бути ліпшим варіантом.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатус документуПримітка
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. Реалізовано у JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.4', 'Math.atan')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.atan', 'Math.atan')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.atan', 'Math.atan')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.atan")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/atan2/index.html b/files/uk/web/javascript/reference/global_objects/math/atan2/index.html new file mode 100644 index 0000000000..a571a3adc4 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/atan2/index.html @@ -0,0 +1,119 @@ +--- +title: Math.atan2() +slug: Web/JavaScript/Reference/Global_Objects/Math/atan2 +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2 +--- +
{{JSRef}}
+ +

Функція Math.atan2() повертає арктангенс частки поданих чисел.

+ +
{{EmbedInteractiveExample("pages/js/math-atan2.html")}}
+ + + +

Синтаксис

+ +
Math.atan2(y, x)
+ +

Аргументи

+ +
+
y
+
Перше число.
+
x
+
Друге число.
+
+ +

Результат

+ +

Арктангенс частки даних аргументів

+ +

Опис

+ +

Метод Math.atan2() повертає числове значення з-поміж -π та π, що являє собою кут Тета нахилу вектора (x, y). Тобто це кут між додатнім напрямком осі OX і вектором (x, y), виміряний проти годинникової стрілки. Як і інші методи Math,  atan2() повертає значення кута у радіанах.

+ +
+

Зауважте порядок розміщення аргументів функції: першою йде координата y, а другою — x.

+
+ +

 

+ +

A simple diagram showing the angle returned by atan2(y, x)

+ +

На відміну від Math.atan(), що працює із часткою координат x та y, Math.atan2() приймає їх на вхід окремо.

+ +

Оскільки atan2() - це статичний метод об'єкту Math, він завжди використовується як Math.atan2(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

Приклади

+ +

Застосування Math.atan2()

+ +
Math.atan2(90, 15); // 1.4056476493802699
+Math.atan2(15, 90); // 0.16514867741462683
+
+Math.atan2(±0, -0);               // ±PI.
+Math.atan2(±0, +0);               // ±0.
+Math.atan2(±0, -x);               // ±PI for x > 0.
+Math.atan2(±0, x);                // ±0 for x > 0.
+Math.atan2(-y, ±0);               // -PI/2 for y > 0.
+Math.atan2(y, ±0);                // PI/2 for y > 0.
+Math.atan2(±y, -Infinity);        // ±PI for finite y > 0.
+Math.atan2(±y, +Infinity);        // ±0 for finite y > 0.
+Math.atan2(±Infinity, x);         // ±PI/2 for finite x.
+Math.atan2(±Infinity, -Infinity); // ±3*PI/4.
+Math.atan2(±Infinity, +Infinity); // ±PI/4.
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатус документуПримітка
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. Реалізовано у JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.5', 'Math.atan2')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.atan2', 'Math.atan2')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.atan2")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/atanh/index.html b/files/uk/web/javascript/reference/global_objects/math/atanh/index.html new file mode 100644 index 0000000000..b99208c599 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/atanh/index.html @@ -0,0 +1,92 @@ +--- +title: Math.atanh() +slug: Web/JavaScript/Reference/Global_Objects/Math/atanh +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atanh +--- +
{{JSRef}}
+ +

Функція Math.atanh() повертає значення гіперболічного акртангенса числа, що являється:

+ +

∀x∊(-1,1),Math.atanh(x)=arctanh(x)= такий унікальний y, для якогоtanh(y)=x\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ the unique } \; y \; \text{such that} \; \tanh(y) = x

+ +
{{EmbedInteractiveExample("pages/js/math-atanh.html")}}
+ + + +

Синтаксис

+ +
Math.atanh(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Гіперболічний арктангенс даного числа.

+ +

Опис

+ +

Оскільки atanh() - статичний метод об'єкту Math, він завжди використовується як Math.atanh(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

Приклади

+ +

Застосування Math.atanh()

+ +
Math.atanh(-2);  // NaN
+Math.atanh(-1);  // -Infinity
+Math.atanh(0);   // 0
+Math.atanh(0.5); // 0.5493061443340548
+Math.atanh(1);   // Infinity
+Math.atanh(2);   // NaN
+
+ +

Для числових значень, що більші за 1 чи менші від -1, результатом є {{jsxref("NaN")}}.

+ +

Поліфіл

+ +

Для |x|<1\left|x\right| < 1, ми маємо artanh(x)=12ln(1+x1-x)\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right), тобто можемо емулювати необхідний функціонал за допомогою наступної функції:

+ +
Math.atanh = Math.atanh || function(x) {
+  return Math.log((1+x)/(1-x)) / 2;
+};
+
+ +

Специфікації

+ + + + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.atanh', 'Math.atanh')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.atanh")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/cbrt/index.html b/files/uk/web/javascript/reference/global_objects/math/cbrt/index.html new file mode 100644 index 0000000000..ff889e3849 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/cbrt/index.html @@ -0,0 +1,100 @@ +--- +title: Math.cbrt() +slug: Web/JavaScript/Reference/Global_Objects/Math/cbrt +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cbrt +--- +
{{JSRef}}
+ +

Функція Math.cbrt() повертає кубічний корінь числа. Тобто:

+ +

Math.cbrt(x)=x3=такий унікальнийy,для якогоy3=x\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x

+ +
{{EmbedInteractiveExample("pages/js/math-cbrt.html")}}
+ + + +

Синтаксис

+ +
Math.cbrt(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Кубічний корінь даного числа.

+ +

Опис

+ +

Оскільки cbrt() - це статичний метод об'єкту Math, він завжди використовується як Math.cbrt(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

Приклади

+ +

Застосування Math.cbrt()

+ +
Math.cbrt(NaN); // NaN
+Math.cbrt(-1); // -1
+Math.cbrt(-0); // -0
+Math.cbrt(-Infinity); // -Infinity
+Math.cbrt(0); // 0
+Math.cbrt(1); // 1
+Math.cbrt(Infinity); // Infinity
+Math.cbrt(null); // 0
+Math.cbrt(2);  // 1.2599210498948734
+
+ +

Поліфіл

+ +

Для всіх x≥0x \geq 0 маємо x3=x1/3\sqrt[3]{x} = x^{1/3}, тобто цей метод може бути зімітованим за допомогою функції:

+ +
if (!Math.cbrt) {
+  Math.cbrt = function(x) {
+    var y = Math.pow(Math.abs(x), 1/3);
+    return x < 0 ? -y : y;
+  };
+}
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатус документуПримітка
{{SpecName('ES6', '#sec-math.cbrt', 'Math.cbrt')}}{{Spec2('ES6')}}Первинне визначення.
{{SpecName('ESDraft', '#sec-math.cbrt', 'Math.cbrt')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.cbrt")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/ceil/index.html b/files/uk/web/javascript/reference/global_objects/math/ceil/index.html new file mode 100644 index 0000000000..c4e035d57d --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/ceil/index.html @@ -0,0 +1,174 @@ +--- +title: Math.ceil() +slug: Web/JavaScript/Reference/Global_Objects/Math/ceil +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil +--- +
{{JSRef}}
+ +

Функція Math.ceil() повертає найменше ціле число, що є більшим або дорівнює даному числу.

+ +

 

+ +
{{EmbedInteractiveExample("pages/js/math-ceil.html")}}
+ + + +

 

+ +

Синтаксис

+ +
Math.ceil(x)
+ +

Параметри

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Найменше ціле число, що є більшим або дорівнює даному числу.

+ +

Опис

+ +

Оскільки ceil()є статичним методом Math, він завжди використовується як Math.ceil(), а не метод створеного Вами об'єкту Math (Math не є конструктором).

+ +

Приклади

+ +

Використання Math.ceil()

+ +

Наступні приклади демонструють використання Math.ceil().

+ +
Math.ceil(.95);    // 1
+Math.ceil(4);      // 4
+Math.ceil(7.004);  // 8
+Math.ceil(-0.95);  // -0
+Math.ceil(-4);     // -4
+Math.ceil(-7.004); // -7
+
+ +

Робота з десятковими числами

+ +
// Замикання
+(function() {
+  /**
+   * Десяткове вирівнювання числа.
+   *
+   * @param {String}  type  Тип вирівнювання.
+   * @param {Number}  value Число.
+   * @param {Integer} exp   Показник степеня (десятковий логарифм від основи округлення).
+   * @returns {Number} Вирівняне значення.
+   */
+  function decimalAdjust(type, value, exp) {
+    // Якщо показник степеня невизначений, або 0...
+    if (typeof exp === 'undefined' || +exp === 0) {
+      return Math[type](value);
+    }
+    value = +value;
+    exp = +exp;
+    // Якщо значення не є числом, або ж показник степеня не цілий...
+    if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
+      return NaN;
+    }
+    // Зсув
+    value = value.toString().split('e');
+    value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
+    // Зворотній зсув
+    value = value.toString().split('e');
+    return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
+  }
+
+  // Десяткове округлення
+  if (!Math.round10) {
+    Math.round10 = function(value, exp) {
+      return decimalAdjust('round', value, exp);
+    };
+  }
+  // Десяткове округлення до нижнього
+  if (!Math.floor10) {
+    Math.floor10 = function(value, exp) {
+      return decimalAdjust('floor', value, exp);
+    };
+  }
+  // Десяткове округлення до верхнього
+  if (!Math.ceil10) {
+    Math.ceil10 = function(value, exp) {
+      return decimalAdjust('ceil', value, exp);
+    };
+  }
+})();
+
+// Округлення
+Math.round10(55.55, -1);   // 55.6
+Math.round10(55.549, -1);  // 55.5
+Math.round10(55, 1);       // 60
+Math.round10(54.9, 1);     // 50
+Math.round10(-55.55, -1);  // -55.5
+Math.round10(-55.551, -1); // -55.6
+Math.round10(-55, 1);      // -50
+Math.round10(-55.1, 1);    // -60
+// Округлення до нижнього
+Math.floor10(55.59, -1);   // 55.5
+Math.floor10(59, 1);       // 50
+Math.floor10(-55.51, -1);  // -55.6
+Math.floor10(-51, 1);      // -60
+// Округлення до верхнього
+Math.ceil10(55.51, -1);    // 55.6
+Math.ceil10(51, 1);        // 60
+Math.ceil10(-55.59, -1);   // -55.5
+Math.ceil10(-59, 1);       // -50
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. Реалізовано у  JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.ceil', 'Math.ceil')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.ceil")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/clz32/index.html b/files/uk/web/javascript/reference/global_objects/math/clz32/index.html new file mode 100644 index 0000000000..9c77d005ec --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/clz32/index.html @@ -0,0 +1,113 @@ +--- +title: Math.clz32() +slug: Web/JavaScript/Reference/Global_Objects/Math/clz32 +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32 +--- +
{{JSRef}}
+ +

Функція Math.clz32() повертає кількість ведучих нульових бітів 32-бітного двоїчного уявлення даного числа.

+ +
{{EmbedInteractiveExample("pages/js/math-clz32.html")}}
+ + + +

Синтаксис

+ +
Math.clz32(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Кількість ведучих нульових бітів 32-бітного двоїчного уявлення даного числа.

+ +

Опис

+ +

"clz32" - це скорочено від CountLeadingZeroes32.

+ +

Якщо аргумент x не є числом, він спочатку буде приведений до числового формату, а потім - до 32-бітного беззнакового цілого.

+ +

Якщо в результаті 32-бітне беззнакове ціле число є нулем - функція повертає 32, тому що всі його біти являються нульовими.

+ +

Ця функція, зокрема, дуже помічна для систем, що компілюють щось у JS. Наприклад - Emscripten.

+ +

Приклади

+ +

Застосування Math.clz32()

+ +
Math.clz32(1);                // 31
+Math.clz32(1000);             // 22
+Math.clz32();                 // 32
+
+[NaN, Infinity, -Infinity, 0, -0, null, undefined, 'foo', {}, []].filter(
+function(n) {
+  return Math.clz32(n) !== 32
+});                           // []
+
+Math.clz32(true);             // 31
+Math.clz32(3.5);              // 30
+
+ +

Поліфіл

+ +

Найбільш ефективний поліфіл:

+ +
if (!Math.clz32) {
+  Math.clz32 = function(x) {
+    // Let n be ToUint32(x).
+    // Let p be the number of leading zero bits in
+    // the 32-bit binary representation of n.
+    // Return p.
+    if (x == null || x === 0) {
+      return 32;
+    }
+    return 31 - Math.floor(Math.log(x >>> 0) * Math.LOG2E);
+  };
+}
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатус документуПримітка
{{SpecName('ES2015', '#sec-math.clz32', 'Math.clz32')}}{{Spec2('ES2015')}}Первинне визначення.
{{SpecName('ESDraft', '#sec-math.clz32', 'Math.clz32')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.clz32")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/cos/index.html b/files/uk/web/javascript/reference/global_objects/math/cos/index.html new file mode 100644 index 0000000000..8cce369812 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/cos/index.html @@ -0,0 +1,83 @@ +--- +title: Math.cos() +slug: Web/JavaScript/Reference/Global_Objects/Math/cos +tags: + - JavaScript + - Math + - cos + - Довідка + - геометрія + - косинус + - метод + - тригонометрія +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos +--- +
{{JSRef}}
+ +

 Статична функція Math.cos() повертає {{interwiki("wikipedia", "косинус")}} поданого кута, який повинен бути вказаним у {{interwiki("wikipedia", "радіан", "радіанах")}}. Значення косинуса дорівнює відношеннюдовжини прилеглого катета довжини гіпотенузи . 

+ +
{{EmbedInteractiveExample("pages/js/math-cos.html")}}
+ + + +

Синтаксис

+ +
Math.cos(x)
+ +

Аргументи

+ +
+
x
+
Кут у радіанах, косинус якого необхідно отримати.
+
+ +

Результат

+ +

Косинус даного числа.

+ +

Опис

+ +

Метод Math.cos() повертає числове значення з-поміж -1 та 1, що відповідає косинусу кута.

+ +

Оскільки cos() є статичним методом в обєкта Math, ви завжди повинні використовувати його як Math.cos(), а не викликати метод на створеному екземплярі обєкта Math (тому що Math не є конструктором).

+ +

Приклади

+ +

Застосування Math.cos()

+ +
Math.cos(0);           // 1
+Math.cos(1);           // 0.5403023058681398
+
+Math.cos(Math.PI);     // -1
+Math.cos(2 * Math.PI); // 1
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.cos', 'Math.cos')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.cos")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/cosh/index.html b/files/uk/web/javascript/reference/global_objects/math/cosh/index.html new file mode 100644 index 0000000000..5973ba2868 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/cosh/index.html @@ -0,0 +1,93 @@ +--- +title: Math.cosh() +slug: Web/JavaScript/Reference/Global_Objects/Math/cosh +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cosh +--- +
{{JSRef}}
+ +

Функція Math.cosh() повертає значення гіперболічного косинуса числа, що може бути також виражене через {{jsxref("Math.E", "сталу e", "", 1)}}:

+ +

Math.cosh(x)=ex+e-x2\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}

+ +
{{EmbedInteractiveExample("pages/js/math-cosh.html")}}
+ + + +

Синтаксис

+ +
Math.cosh(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Гіперболічний косинус даного числа.

+ +

Опис

+ +

Оскільки cosh() - це статичний метод об'єкту Math, він завжди використовується як Math.cosh(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

Приклади

+ +

Застосування Math.cosh()

+ +
Math.cosh(0);  // 1
+Math.cosh(1);  // 1.5430806348152437
+Math.cosh(-1); // 1.5430806348152437
+
+ +

Поліфіл

+ +

Ця функцію можна зімітувати за допомогою {{jsxref("Math.exp()")}}:

+ +
Math.cosh = Math.cosh || function(x) {
+  return (Math.exp(x) + Math.exp(-x)) / 2;
+}
+
+ +

або ж викликаючи {{jsxref("Math.exp()")}} лише один раз:

+ +
Math.cosh = Math.cosh || function(x) {
+  var y = Math.exp(x);
+  return (y + 1 / y) / 2;
+};
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.cosh', 'Math.cosh')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.cosh")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/e/index.html b/files/uk/web/javascript/reference/global_objects/math/e/index.html new file mode 100644 index 0000000000..d04b6dce98 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/e/index.html @@ -0,0 +1,85 @@ +--- +title: Math.E +slug: Web/JavaScript/Reference/Global_Objects/Math/E +tags: + - JavaScript + - Math + - Властивість + - Довідка + - Поле +translation_of: Web/JavaScript/Reference/Global_Objects/Math/E +--- +
{{JSRef}}
+ +

Поле Math.E відображає сталу Ейлера ee, основу натуральних логарифмів, що наближено дорівнює 2.718.

+ +

Math.E=e≈2.718\mathtt{\mi{Math.E}} = e \approx 2.718

+ +
{{EmbedInteractiveExample("pages/js/math-e.html")}}
+ + + +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

У зв'язку із тим, що E - це статичне поле Math, слід завжди звертатись до нього Math.E. Намагатись викликати E, звертаючись до полів  створених вами об'єктів Math - некоректно (Math не являється конструктором).

+ +

Приклади

+ +

Використання Math.E

+ +

Наступна функція повертає e:

+ +
function getNapier() {
+  return Math.E;
+}
+
+getNapier(); // 2.718281828459045
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатус документуПримітка
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. Реалізовано у JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.e', 'Math.E')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.e', 'Math.E')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.E")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/exp/index.html b/files/uk/web/javascript/reference/global_objects/math/exp/index.html new file mode 100644 index 0000000000..770c983bb5 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/exp/index.html @@ -0,0 +1,76 @@ +--- +title: Math.exp() +slug: Web/JavaScript/Reference/Global_Objects/Math/exp +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp +--- +
{{JSRef}}
+ +

Функція Math.exp() повертає ex, де x - аргумент, а e - {{jsxref("Math.E", "число (стала) Ейлера", "", 1)}}, основа натурального логарифму.

+ +
{{EmbedInteractiveExample("pages/js/math-exp.html")}}
+ + + +

Синтаксис

+ +
Math.exp(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Число, що відображає ex, де e - це  {{jsxref("Math.E", "стала Ейлера", "", 1)}}, та x - аргумент.

+ +

Опис

+ +

Так як exp() - це статичний метод об'єкту Math, він завжди використовується як Math.exp(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

Приклади

+ +

Застосування Math.exp()

+ +
Math.exp(-1); // 0.36787944117144233
+Math.exp(0);  // 1
+Math.exp(1);  // 2.718281828459045
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.exp', 'Math.exp')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.exp")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/expm1/index.html b/files/uk/web/javascript/reference/global_objects/math/expm1/index.html new file mode 100644 index 0000000000..9ff397ce07 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/expm1/index.html @@ -0,0 +1,85 @@ +--- +title: Math.expm1() +slug: Web/JavaScript/Reference/Global_Objects/Math/expm1 +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/expm1 +--- +
{{JSRef}}
+ +

Функція Math.expm1() повертає результат обчислення виразу ex - 1, де x - це аргумент, а {{jsxref("Math.E", "e", "", 1)}} - основа натурального логарифму.

+ +
{{EmbedInteractiveExample("pages/js/math-expm1.html")}}
+ + + +

Синтаксис

+ +
Math.expm1(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Число, що відображає результат виразу ex - 1, де e - це {{jsxref("Math.E", "стала Ейлера", "", 1)}}, а x - аргумент.

+ +

Опис

+ +

Оскільки expm1() - це статичний метод об'єкту Math, він завжди використовується як Math.expm1(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

Приклади

+ +

Застосуваня Math.expm1()

+ +
Math.expm1(-1); // -0.6321205588285577
+Math.expm1(0);  // 0
+Math.expm1(1);  // 1.718281828459045
+
+ +

Поліфіл

+ +

Даний функціонал можна емулювати за допомогою функції {{jsxref("Math.exp()")}}:

+ +
Math.expm1 = Math.expm1 || function(x) {
+  return Math.exp(x) - 1;
+};
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.expm1', 'Math.expm1')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.expm1")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/floor/index.html b/files/uk/web/javascript/reference/global_objects/math/floor/index.html new file mode 100644 index 0000000000..2507381ebd --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/floor/index.html @@ -0,0 +1,164 @@ +--- +title: Math.floor() +slug: Web/JavaScript/Reference/Global_Objects/Math/floor +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor +--- +
{{JSRef}}
+ +

Метод Math.floor() повертає найбільше ціле число, менше або рівне даному числу.

+ +

Синтаксис

+ +
Math.floor(x)
+ +

Параметри

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Найбільше ціле число, менше або рівне даному числу.

+ +

Опис

+ +

Оскільки floor() є статичним методом об'єкту Math, він завжди використовується як Math.floor(), а не метод створеного Вами об'єкту Math (Math не є конструктором).

+ +

Приклади

+ +

Використання Math.floor()

+ +
Math.floor( 45.95); //  45
+Math.floor( 45.05); //  45
+Math.floor(  4   ); //   4
+Math.floor(-45.05); // -46
+Math.floor(-45.95); // -46
+
+ +

Десяткове округлення

+ +
// Замикання
+(function() {
+  /**
+   * Десяткове округлення числа до необхідної точності.
+   *
+   * @param {String}  type  Тип округлення.
+   * @param {Number}  value Число.
+   * @param {Integer} exp   Степінь (десятковий логарифм від основи округлення).
+   * @returns {Number} Округлене число.
+   */
+  function decimalAdjust(type, value, exp) {
+    // Якщо exp невизначений або дорівнює нулю...
+    if (typeof exp === 'undefined' || +exp === 0) {
+      return Math[type](value);
+    }
+    value = +value;
+    exp = +exp;
+    // Якщо value не є числом, або ж степінь exp не являється цілим...
+    if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
+      return NaN;
+    }
+    // Зсув
+    value = value.toString().split('e');
+    value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
+    // Зворотній зсув
+    value = value.toString().split('e');
+    return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
+  }
+
+  // Десяткове округлення
+  if (!Math.round10) {
+    Math.round10 = function(value, exp) {
+      return decimalAdjust('round', value, exp);
+    };
+  }
+  // Десяткове округлення до меншого
+  if (!Math.floor10) {
+    Math.floor10 = function(value, exp) {
+      return decimalAdjust('floor', value, exp);
+    };
+  }
+  // Десяткове округлення до більшого
+  if (!Math.ceil10) {
+    Math.ceil10 = function(value, exp) {
+      return decimalAdjust('ceil', value, exp);
+    };
+  }
+})();
+
+// Округлення
+Math.round10(55.55, -1);   // 55.6
+Math.round10(55.549, -1);  // 55.5
+Math.round10(55, 1);       // 60
+Math.round10(54.9, 1);     // 50
+Math.round10(-55.55, -1);  // -55.5
+Math.round10(-55.551, -1); // -55.6
+Math.round10(-55, 1);      // -50
+Math.round10(-55.1, 1);    // -60
+// Floor
+Math.floor10(55.59, -1);   // 55.5
+Math.floor10(59, 1);       // 50
+Math.floor10(-55.51, -1);  // -55.6
+Math.floor10(-51, 1);      // -60
+// Ceil
+Math.ceil10(55.51, -1);    // 55.6
+Math.ceil10(51, 1);        // 60
+Math.ceil10(-55.59, -1);   // -55.5
+Math.ceil10(-59, 1);       // -50
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.9', 'Math.floor')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.floor', 'Math.floor')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.floor', 'Math.floor')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.floor")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/fround/index.html b/files/uk/web/javascript/reference/global_objects/math/fround/index.html new file mode 100644 index 0000000000..1b7994ccb4 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/fround/index.html @@ -0,0 +1,114 @@ +--- +title: Math.fround() +slug: Web/JavaScript/Reference/Global_Objects/Math/fround +tags: + - JavaScript + - Math + - fround + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/fround +--- +
{{JSRef}}
+ +

Функція Math.fround() повертає найближче зображення числового аргументу у вигляді 32-бітного числа з рухомою комою {{interwiki("wikipedia", "Число_одинарної_точності","одинарної точності" )}}.

+ +
{{EmbedInteractiveExample("pages/js/math-fround.html")}}
+ + + +

Синтаксис

+ +
var singleFloat = Math.fround(doubleFloat);
+ +

Аргументи

+ +
+
doubleFloat
+
{{jsxref("Number")}}. Якщо аргумент має інший тип - його буде приведено до числа, або ж до {{jsxref("NaN")}} у випадку, якщо таке приведення неможливе.
+
+ +

Результат

+ +

Зображеня аргументу у вигляді найближчого 32-бітного числа з рухомою комою {{interwiki("wikipedia", "Число_одинарної_точності","одинарної точності" )}}.

+ +

Опис

+ +

JavaScript всередині використовує 64-бітні числа із рухомою комою подвійної точності. Це забезпечує дуже високу точність обчислень. Однак, інколи у вас може виникнути потреба працювати із 32-бітними числами того ж типу. Зокрема, якщо ви читаєте дані із {{jsxref("Float32Array")}}. Це може викликати певну плутанину: перевірка рівності 64-бітного та 32-бітного чисел може дати негативний результат, навіть якщо числа здаються однаковими.

+ +

Щоб вирішити цю проблему, можна застосувати Math.fround() для перетворення 64-бітного числа у 32-бітне. JavaScript всередині продовжить вважати числа за 64-бітні, натомість виконуючи "округлення до найближчого парного" на 23-му біті мантиси, і встановлююючи наступний за нею біт в 0. Якщо число виходить за межі 32-бітного із рухомою комою, то в результаті буде отримана {{jsxref("Infinity")}} чи -Infinity.

+ +

Оскільки fround()є статичним методом Math, він завжди використовується як Math.fround(), а не метод створеного Вами об'єкту Math (Math не є конструктором).

+ +

Приклади

+ +

Застосування Math.fround()

+ +

Число 1.5 може бути точно відтворено у двійковій системі числення, причому 32-бітний і 64-бітний результати будуть однакові:

+ +
Math.fround(1.5); // 1.5
+Math.fround(1.5) === 1.5; // true
+
+ +

Однак, число 1.337 не може бути точно зображено у двійковій системі числення, тож  32-бітне і 64-бітне зображення цього числа будуть відрізнятись:

+ +
Math.fround(1.337); // 1.3370000123977661
+Math.fround(1.337) === 1.337; // false
+
+ +

21502^150 - занадто велике для 32-бітного числа із рухомою комою, тому результатом буде Infinity:

+ +
2 ** 150; // 1.42724769270596e+45
+Math.fround(2 ** 150); // Infinity
+
+ +

Якщо аргумент не може бути приведеним до числа, чи просто являється not-a-number (NaN), Math.fround() поверне NaN:

+ +
Math.fround('abc'); // NaN
+Math.fround(NaN); // NaN
+
+ +

Поліфіл

+ +

Даний функціонал можна відтворити за допомогою наступної функції (за умови наявної підтримки {{jsxref("Float32Array")}}):

+ +
Math.fround = Math.fround || (function (array) {
+  return function(x) {
+    return array[0] = x, array[0];
+  };
+})(new Float32Array(1));
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатус документуПримітка
{{SpecName('ES6', '#sec-math.fround', 'Math.fround')}}{{Spec2('ES6')}}Первинне визначення.
{{SpecName('ESDraft', '#sec-math.fround', 'Math.fround')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.fround")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/hypot/index.html b/files/uk/web/javascript/reference/global_objects/math/hypot/index.html new file mode 100644 index 0000000000..465d368930 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/hypot/index.html @@ -0,0 +1,119 @@ +--- +title: Math.hypot() +slug: Web/JavaScript/Reference/Global_Objects/Math/hypot +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot +--- +
{{JSRef}}
+ +

Функція Math.hypot() повертає квадратний корінь від суми квадратів поданих аргументів

+ +

Math.hypot(v1,v2,…,vn)=∑i=1nvi2=v12+v22+…+vn2\mathtt{\operatorname{Math.hypot}(v_1, v_2, \dots, v_n)} = \sqrt{\sum_{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}

+ +
{{EmbedInteractiveExample("pages/js/math-hypot.html")}}
+ + + +

Синтаксис

+ +
Math.hypot([value1[, value2[, ...]]])
+ +

Аргументи

+ +
+
value1, value2, ...
+
Числа.
+
+ +

Результат

+ +

Квадратний корінь від суми квадратів поданих аргументів. Якщо хоча б один з аргументів не може бути приведений до числа - результатом буде {{jsxref("NaN")}}.

+ +

Опис

+ +

Обчислення гіпотенузи прямокутного трикутника чи модуля комплексного числа відбувається за формулою Math.sqrt(v1*v1 + v2*v2), де v1 та v2 - це катети прямокутного трикутника, або ж дійсна та уявна частини комплексного числа.  Для обчислення відстані у двох, чи більше вимірах, варто просто додати більше квадратів під знак кореня, наприклад: Math.sqrt(v1*v1 + v2*v2 + v3*v3 + v4*v4).  

+ +

Ця ж функція дозволяє робити це швидше і простіше, варто просто викликати Math.hypot(v1, v2) чи Math.hypot(v1, v2, v3, v4, ...).

+ +

Вона також дозволяє уникнути проблеми у випадках, коли гіпотенуза ваших чисел дуже велика.  Найбільше число, яке ви можете зобразити за допомогою чисел подвійної точності у JS - це Number.MAX_VALUE = 1.797...e+308 .  Якщо ваші вхідні числа більші за 1e154, спроба піднести їх до квадрату у результаті дасть Infinity, що повністю зруйнує результат.  Тобто, Math.sqrt(1e200*1e200 + 1e200*1e200) = Infinity .  Якщо ж ви натомість застосуєте hypot(), ви отримаєте цілком нормальний результат Math.hypot(1e200, 1e200) = 1.4142...e+200 .  Це також справедливо для дуже малих чисел.  Math.sqrt(1e-200*1e-200 + 1e-200*1e-200) = 0, але Math.hypot(1e-200, 1e-200) =1.4142...e-200, тобто цілком корисний результат.

+ +

Оскільки hypot() - це статичний метод об'єкту Math, він завжди використовується як Math.hypot(), а не як метод створеного об'єкту Math  (Math не є конструктором).

+ +

У випадку, якщо функція викликається без аргументів, результатом є +0.

+ +

А якщо хоча б один з аргументів не може бути зведеним до числа, в результаті отримаємо {{jsxref("NaN")}}.

+ +

Якщо дано лише один аргумент, Math.hypot() повертає такий самий результат, як і Math.abs().

+ +

Приклади

+ +

Застосування Math.hypot()

+ +
Math.hypot(3, 4);        // 5
+Math.hypot(3, 4, 5);     // 7.0710678118654755
+Math.hypot();            // 0
+Math.hypot(NaN);         // NaN
+Math.hypot(3, 4, 'foo'); // NaN, +'foo' => NaN
+Math.hypot(3, 4, '5');   // 7.0710678118654755, +'5' => 5
+Math.hypot(-3);          // 3, the same as Math.abs(-3)
+
+ +

Поліфіл

+ +

Цей функціонал можна легко повторити ось такою функцією:

+ +
Math.hypot = Math.hypot || function() {
+  var y = 0, i = arguments.length;
+  while (i--) y += arguments[i] * arguments[i];
+  return Math.sqrt(y);
+};
+
+ +

Більш складний варіант, який дозволяє уникнути описаних вище проблем виходу за межі точності числового формату:

+ +
Math.hypot = function (x, y) {
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=896264#c28
+  var max = 0;
+  var s = 0;
+  for (var i = 0; i < arguments.length; i += 1) {
+    var arg = Math.abs(Number(arguments[i]));
+    if (arg > max) {
+      s *= (max / arg) * (max / arg);
+      max = arg;
+    }
+    s += arg === 0 && max === 0 ? 0 : (arg / max) * (arg / max);
+  }
+  return max === 1 / 0 ? 1 / 0 : max * Math.sqrt(s);
+};
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.hypot', 'Math.hypot')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.hypot")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/imul/index.html b/files/uk/web/javascript/reference/global_objects/math/imul/index.html new file mode 100644 index 0000000000..21f5d59a3e --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/imul/index.html @@ -0,0 +1,97 @@ +--- +title: Math.imul() +slug: Web/JavaScript/Reference/Global_Objects/Math/imul +tags: + - JavaScript + - Math + - imul + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/imul +--- +
{{JSRef}}
+ +

Функція Math.imul() повертає результат C-подібного 32-бітного множення двох аргументів.

+ +
{{EmbedInteractiveExample("pages/js/math-imul.html")}}
+ + + +

Синтаксис

+ +
var product = Math.imul(a, b);
+ +

Аргументи

+ +
+
a
+
Перше число.
+
b
+
Друге число.
+
+ +

Результат

+ +

Результат C-подібного 32-бітного множення даних аргументів.

+ +

Опис

+ +

Math.imul() дає можливість виконувати 32-бітне цілочисельне множення з C-подібною семантикою. Ця особливість дуже корисна для проектів на зразок Emscripten.

+ +

У зв'язку з тим, що imul() - це статичний метод Math, слід завжди викликати його як Math.imul(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Якщо ви використаєте звичайні числа із рухомою комою в imul, ви отримаєте значну деградацію продуктивності. Причина криється у доволі коштовній з точки зору ресурсів конвертації числа із рухомою комою у ціле для виконання множення, і зворотній конвертації результату. imul() існує у зв'язку із тим, що він швидший у єдиному (поки що) випадку: застосування у AsmJS. AsmJS дозволяє JIST-оптимізаторам простіше реалізовувати цілі числа всередині у JavaScript. Множення двох чисел, що уже зберігаються як цілі (що, поки що, можливо лише з AsmJS) за допомогою imul - це єдина потенційна можливість для Math.imul покращити продуктивність у сучасних браузерах.

+ +

Приклади

+ +

Застосування Math.imul()

+ +
Math.imul(2, 4);          // 8
+Math.imul(-1, 8);         // -8
+Math.imul(-2, -2);        // 4
+Math.imul(0xffffffff, 5); // -5
+Math.imul(0xfffffffe, 5); // -10
+
+ +

Поліфіл

+ +

Цей метод може бути реалізований за допомогою наступної функції:

+ +
Math.imul = Math.imul || function(a, b) {
+  var aHi = (a >>> 16) & 0xffff;
+  var aLo = a & 0xffff;
+  var bHi = (b >>> 16) & 0xffff;
+  var bLo = b & 0xffff;
+  // зсув на 0 фіксує знак старшої частини
+  // |0 наприкінці перетворює беззнакове значення у число із знаком
+  return ((aLo * bLo) + (((aHi * bLo + aLo * bHi) << 16) >>> 0) | 0);
+};
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатус документуПримітка
{{SpecName('ES6', '#sec-math.imul', 'Math.imul')}}{{Spec2('ES6')}}Первинне визначення.
{{SpecName('ESDraft', '#sec-math.imul', 'Math.imul')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.imul")}}

diff --git a/files/uk/web/javascript/reference/global_objects/math/index.html b/files/uk/web/javascript/reference/global_objects/math/index.html new file mode 100644 index 0000000000..2a3acad478 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/index.html @@ -0,0 +1,153 @@ +--- +title: Math +slug: Web/JavaScript/Reference/Global_Objects/Math +tags: + - JavaScript + - Math + - Довідка +translation_of: Web/JavaScript/Reference/Global_Objects/Math +--- +
{{JSRef}}
+ +

Math - це вбудований об'єкт із полями і методами для реалізації математичних сталих та функцій. Не являється функцією.

+ +

Math працює з числами типу {{jsxref("Number")}}. Він не підходить для роботи з {{jsxref("BigInt")}}.

+ +

Опис

+ +

На відміну від багатьох інших глобальних об'єктів, Math не являється конструктором. Всі поля і методи Math статичні. Тобто до сталої Пі потрібно звертатись  Math.PI, а функцію синуса викликати через Math.sin(x), де x являється аргументом статичного методу. Всі константи задані із максимальною для дійсних чисел у JavaScript точністю.

+ +

Властивості

+ +
+
{{jsxref("Math.E")}}
+
Стала Ейлера, основа натуральних логарифмів. Приблизно дорівнює 2.718.
+
{{jsxref("Math.LN2")}}
+
Числове значення натурального логарифму від 2. Приблизно дорівнює 0.693.
+
{{jsxref("Math.LN10")}}
+
Числове значення натурального логарифму від 10. Приблизно дорівнює 2.303.
+
{{jsxref("Math.LOG2E")}}
+
Логарифм від ee за основою 2, приблизно дорівнює 1.443.
+
{{jsxref("Math.LOG10E")}}
+
Логарифм від e за основою 10, приблизно дорівнює 0.434.
+
{{jsxref("Math.PI")}}
+
Значення відношення довжини кола до його діаметру, наближено дорівнює 3.14159.
+
{{jsxref("Math.SQRT1_2")}}
+
Квадратний корінь від ½ (еквівалентно 12\frac {1}{\sqrt{2}}). Наближено дорівнює 0.707.
+
{{jsxref("Math.SQRT2")}}
+
Значення квадратного кореня від 2, наближено 1.414.
+
+ +

Методи

+ +
+

Варто зазначити, що тригонометричні функції (sin(), cos(), tan(), asin(), acos(), atan(), atan2()) очікують (і повертають) значення кутів у радіанах.

+ +

Для конвертації радіан в градуси, розділіть значення на (Math.PI / 180). Або помножте на цю величину для виконання зворотної конвертації

+
+ +
+

Майте на увазі, що точність багатьох математичних функцій залежить від конкретної реалізації платформи. Тобто одна і та ж функція у різних браузерах може дати дещо різний результат. Навіть більше - один і той самий JS-рушій на різних ОС чи архітектурах також може дати різні результати!

+
+ +
+
{{jsxref("Global_Objects/Math/abs", "Math.abs(x)")}}
+
Повертає абсолютне значення (модуль) числа.
+
{{jsxref("Global_Objects/Math/acos", "Math.acos(x)")}}
+
Повертає арккосинус числа.
+
{{jsxref("Global_Objects/Math/acosh", "Math.acosh(x)")}}
+
Повертає значення гіперболічного арккосинуса числа.
+
{{jsxref("Global_Objects/Math/asin", "Math.asin(x)")}}
+
Повертає арксинус числа.
+
{{jsxref("Global_Objects/Math/asinh", "Math.asinh(x)")}}
+
Повертає значення гіперболічного арксинуса числа.
+
{{jsxref("Global_Objects/Math/atan", "Math.atan(x)")}}
+
Повертає арктангенс числа.
+
{{jsxref("Global_Objects/Math/atanh", "Math.atanh(x)")}}
+
Повертає значення гіперболічного арктангенса числа.
+
{{jsxref("Global_Objects/Math/atan2", "Math.atan2(y, x)")}}
+
Повертає значення арктангенсу частки поданих чисел.
+
{{jsxref("Global_Objects/Math/cbrt", "Math.cbrt(x)")}}
+
Повертає кубічний корінь числа.
+
{{jsxref("Global_Objects/Math/ceil", "Math.ceil(x)")}}
+
Повертає число, округлене "до більшого".
+
{{jsxref("Global_Objects/Math/clz32", "Math.clz32(x)")}}
+
Повертає кількість ведучих нулів 32-бітного цілочисельного уявлення даного числа.
+
{{jsxref("Global_Objects/Math/cos", "Math.cos(x)")}}
+
Повертає косинус числа.
+
{{jsxref("Global_Objects/Math/cosh", "Math.cosh(x)")}}
+
Повертає значення гіперболічного косинуса числа.
+
{{jsxref("Global_Objects/Math/exp", "Math.exp(x)")}}
+
Повертає результат обчислення Ex, де x - це аргумент функції, а E - стала Ейлера (2.718…, основа натурального логарифму).
+
{{jsxref("Global_Objects/Math/expm1", "Math.expm1(x)")}}
+
Повертає різницю exp(x) і 1 (тобто значення виразу ex-1e^x - 1).
+
{{jsxref("Global_Objects/Math/floor", "Math.floor(x)")}}
+
Повертає результат округлення "до меншого".
+
{{jsxref("Global_Objects/Math/fround", "Math.fround(x)")}}
+
Повертає найближче число із рухомою комою (крапкою) одинарної точності від аргументу.
+
{{jsxref("Global_Objects/Math/hypot", "Math.hypot([x[, y[, …]]])")}}
+
Повертає квадратний корінь від суми квадратів аргументів.
+
{{jsxref("Global_Objects/Math/imul", "Math.imul(x, y)")}}
+
Повертає результат 32-бітного цілочисельного множення аргументів.
+
{{jsxref("Global_Objects/Math/log", "Math.log(x)")}}
+
Повертає натуральний логарифм (㏒e, або ln) числа.
+
{{jsxref("Global_Objects/Math/log1p", "Math.log1p(x)")}}
+
Повертає натуральний логарифм (㏒e, або ln) виразу 1 + x від числаx.
+
{{jsxref("Global_Objects/Math/log10", "Math.log10(x)")}}
+
Повертає логарифм за основою 10 від аргументу.
+
{{jsxref("Global_Objects/Math/log2", "Math.log2(x)")}}
+
Повертає логарифм за основою 2 від аргументу.
+
{{jsxref("Global_Objects/Math/max", "Math.max([x[, y[, …]]])")}}
+
Повертає найбільше із нуля чи більше аргументів.
+
{{jsxref("Global_Objects/Math/min", "Math.min([x[, y[, …]]])")}}
+
Повертає найменше із нуля чи більше аргументів.
+
{{jsxref("Global_Objects/Math/pow", "Math.pow(x, y)")}}
+
Повертає результат піднесення до степеня xy.
+
{{jsxref("Global_Objects/Math/random", "Math.random()")}}
+
Повертає псевдовипадкове число від 0 до 1.
+
{{jsxref("Global_Objects/Math/round", "Math.round(x)")}}
+
Повертає значення аргументу, округлене до найближчого цілого.
+
{{jsxref("Global_Objects/Math/sign", "Math.sign(x)")}}
+
Повертає знак поданого числа. Визначає, чи являється аргумент додатним числом, від'ємним, чи дорівнює 0.
+
{{jsxref("Global_Objects/Math/sin", "Math.sin(x)")}}
+
Повертає значення синуса аргументу.
+
{{jsxref("Global_Objects/Math/sinh", "Math.sinh(x)")}}
+
Повертає значення гіперболічного синуса аргументу.
+
{{jsxref("Global_Objects/Math/sqrt", "Math.sqrt(x)")}}
+
Повертає додатне значення квадратного кореня від аргументу.
+
{{jsxref("Global_Objects/Math/tan", "Math.tan(x)")}}
+
Повертає значення тангенса аргументу.
+
{{jsxref("Global_Objects/Math/tanh", "Math.tanh(x)")}}
+
Повертає значення гіперболічного тангенса аргументу.
+
Math.toSource() {{non-standard_inline}}
+
Повертає строку "Math".
+
{{jsxref("Global_Objects/Math/trunc", "Math.trunc(x)")}}
+
Повертає цілу частину x, відкидаючи всю дробову частину.
+
+ +

Специфікації

+ + + + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math-object', 'Math')}}
+ +

Підтримка у браузерах

+ + + +
{{Compat("javascript.builtins.Math")}}
+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/ln10/index.html b/files/uk/web/javascript/reference/global_objects/math/ln10/index.html new file mode 100644 index 0000000000..82c50b1911 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/ln10/index.html @@ -0,0 +1,66 @@ +--- +title: Math.LN10 +slug: Web/JavaScript/Reference/Global_Objects/Math/LN10 +tags: + - JavaScript + - Math + - Властивість + - Довідка + - Поле +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10 +--- +
{{JSRef}}
+ +

Поле Math.LN10 відображає значення натурального логарифму 10, що наближено дорівнює 2.302:

+ +

Math.LN10=ln(10)≈2.302\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302

+ +
{{EmbedInteractiveExample("pages/js/math-ln10.html")}}
+ + + +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

У зв'язку із тим, що LN10 - це статичне поле Math, слід завжди використовувати його через Math.LN10, замість викликання його як поля створених вами об'єктів Math (Math не являється конструктором).

+ +

Examples

+ +

Використання Math.LN10

+ +

Наступна функція повертає натуральний логарифм 10:

+ +
function getNatLog10() {
+  return Math.LN10;
+}
+
+getNatLog10(); // 2.302585092994046
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.ln10', 'Math.LN10')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.LN10")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/ln2/index.html b/files/uk/web/javascript/reference/global_objects/math/ln2/index.html new file mode 100644 index 0000000000..99e5c1f0a3 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/ln2/index.html @@ -0,0 +1,70 @@ +--- +title: Math.LN2 +slug: Web/JavaScript/Reference/Global_Objects/Math/LN2 +tags: + - JavaScript + - Math + - Властивість + - Довідка + - Поле +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2 +--- +
{{JSRef}}
+ +

Поле Math.LN2 відображає значення натурального логарифму 2, що наближено дорівнює 0.693:

+ +

Math.LN2=ln(2)≈0.693\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693

+ +
{{EmbedInteractiveExample("pages/js/math-ln2.html")}}
+ + + +
{{js_property_attributes(0, 0, 0)}}
+ + + +

Опис

+ +

У зв'язку із тим, що LN2 - це статичне поле Math, слід завжди використовувати його через Math.LN2, замість викликання його як поля створених вами об'єктів Math (Math не являється конструктором).

+ + + +

Приклади

+ +

Використання Math.LN2

+ +

Наступна функція повертає натуральний логарифм від 2:

+ +
function getNatLog2() {
+  return Math.LN2;
+}
+
+getNatLog2(); // 0.6931471805599453
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.ln2', 'Math.LN2')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.LN2")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/log/index.html b/files/uk/web/javascript/reference/global_objects/math/log/index.html new file mode 100644 index 0000000000..df7d650070 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/log/index.html @@ -0,0 +1,113 @@ +--- +title: Math.log() +slug: Web/JavaScript/Reference/Global_Objects/Math/log +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log +--- +
{{JSRef}}
+ +

Функція Math.log() повертає натуральний логарифм (тобто за основою {{jsxref("Math.E", "e")}}) від числа, що являється:

+ +

∀x>0,Math.log(x)=ln(x)=такий унікальнийy,для якогоey=x\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x

+ +

Функція JavaScript Math.log() еквівелентна ln(x) у математиці.

+ +
{{EmbedInteractiveExample("pages/js/math-log.html")}}
+ + + +

Синтаксис

+ +
Math.log(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Натуральний логарифм (за основою {{jsxref("Math.E", "e")}}) даного числа. Якщо число від'ємне - функція повертає {{jsxref("NaN")}}.

+ +

Опис

+ +

Якщо значення аргументу x від'ємне - функція завжди повертає {{jsxref("NaN")}}.

+ +

У зв'язку з тим, що log() - це статичний метод Math, слід завжди викликати його як Math.log(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Якщо вам потрібно отримати значення натурального логарифму від 2 чи 10, застосуйте вбудовані сталі {{jsxref("Math.LN2")}} чи {{jsxref("Math.LN10")}} .  Якщо вам потрібно отримати значення логарифму за основою 2 чи 10 - використайте {{jsxref("Math.log2()")}} або {{jsxref("Math.log10()")}} .  Якщо вам потрібен логарифм за іншою основою, використайте Math.log(x) / Math.log(іншаОснова), як у прикладі нижче; можливо вам також знадобиться попередньо обчислити 1 / Math.log(іншаОснова).

+ +

Приклади

+ +

Застосування Math.log()

+ +
Math.log(-1); // NaN, out of range
+Math.log(0);  // -Infinity
+Math.log(1);  // 0
+Math.log(10); // 2.302585092994046
+
+ +

Застосування Math.log() з іншою основою

+ +

Наступна функція повертає логарифм від y за основою x (тобто, logxy\log_x y):

+ +
function getBaseLog(x, y) {
+  return Math.log(y) / Math.log(x);
+}
+
+ +

Щоправда, якщо ви виконаєте getBaseLog(10, 1000), вона поверне 2.9999999999999996 у зв'язку із округленням чисел із рухомою комою. Звісно, це з дуже великою точністю близько до дійсного результату в 3.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусПримітка
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. Реалізовано у JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.10', 'Math.log')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.log', 'Math.log')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.log', 'Math.log')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.log")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/log10/index.html b/files/uk/web/javascript/reference/global_objects/math/log10/index.html new file mode 100644 index 0000000000..5a55bfb3f4 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/log10/index.html @@ -0,0 +1,92 @@ +--- +title: Math.log10() +slug: Web/JavaScript/Reference/Global_Objects/Math/log10 +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log10 +--- +
{{JSRef}}
+ +

Функція Math.log10() повертає логарифм за основою 10 від поданого числа, що являється

+ +

∀x>0,Math.log10(x)=log10(x)=таким унікальнимy, для якого10y=x\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x

+ +
{{EmbedInteractiveExample("pages/js/math-log10.html")}}
+ + + +

Синтаксис

+ +
Math.log10(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Логарифм за основою 10 від даного числа. Якщо аргумент від'ємний, то функція повертає {{jsxref("NaN")}}.

+ +

Опис

+ +

Якщо значення x менше 0, результатом являється {{jsxref("NaN")}}.

+ +

У зв'язку з тим, що log10() - це статичний метод Math, слід завжди викликати його як Math.log10(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Ця функція еквівалентна Math.log(x) / Math.log(10).  Для отримання log10(e) слід використовувати вбудовану сталу {{jsxref("Math.LOG10E")}}, яка уже дорівнює 1 / {{jsxref("Math.LN10")}}.  

+ +

Приклади

+ +

Застосування Math.log10()

+ +
Math.log10(2);      // 0.3010299956639812
+Math.log10(1);      // 0
+Math.log10(0);      // -Infinity
+Math.log10(-2);     // NaN
+Math.log10(100000); // 5
+
+ +

Поліфіл

+ +

Метод може бути реалізований за допомогою такої функції:

+ +
Math.log10 = Math.log10 || function(x) {
+  return Math.log(x) * Math.LOG10E;
+};
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.log10', 'Math.log10')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.log10")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/log10e/index.html b/files/uk/web/javascript/reference/global_objects/math/log10e/index.html new file mode 100644 index 0000000000..a04db0bd60 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/log10e/index.html @@ -0,0 +1,66 @@ +--- +title: Math.LOG10E +slug: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +tags: + - JavaScript + - Math + - Властивість + - Довідка + - Поле +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +--- +
{{JSRef}}
+ +

Поле Math.LOG10E відображає значення логарифму ee за основою 10, що приблизно дорівнює 0.434:

+ +

Math.LOG10E=log10(e)≈0.434\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434

+ +
{{EmbedInteractiveExample("pages/js/math-log10e.html")}}
+ + + +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

У зв'язку із тим, що LOG10E - це статичне поле Math, слід завжди звертатись до нього у формі Math.LOG10E. Намагатись викликати LOG10E, звертаючись до полів  створених вами об'єктів Math - некоректно (Math не являється конструктором).

+ +

Приклади

+ +

Використання Math.LOG10E

+ +

Наступна функція повертає логарифм ee за основою 10:

+ +
function getLog10e() {
+  return Math.LOG10E;
+}
+
+getLog10e(); // 0.4342944819032518
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.log10e', 'Math.LOG10E')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.LOG10E")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/log1p/index.html b/files/uk/web/javascript/reference/global_objects/math/log1p/index.html new file mode 100644 index 0000000000..99edc4fbf5 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/log1p/index.html @@ -0,0 +1,94 @@ +--- +title: Math.log1p() +slug: Web/JavaScript/Reference/Global_Objects/Math/log1p +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log1p +--- +
{{JSRef}}
+ +

Функція Math.log1p() повертає натуральний логарифм (за основою {{jsxref("Math.E", "e")}}) від результату виразу 1 + дане число. Тобто

+ +

∀x>-1,Math.log1p(x)=ln(1+x)\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)

+ +
{{EmbedInteractiveExample("pages/js/math-log1p.html")}}
+ + + +

Синтаксис

+ +
Math.log1p(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Натуральний логарифм (за основою {{jsxref("Math.E", "e")}}) від 1+x. Якщо значення аргументу менше за -1, функція повертає {{jsxref("NaN")}}.

+ +

Опис

+ +

Для дуже малих значень x, додавання 1 може повністю або частково зменшити точність .  Числа із рухомою комою подвійної точності, що застосовуються у JS, дають вам приблизно 15 знаків точності.  1 + 1e-15 = 1.000000000000001, але 1 + 1e-16 = 1.000000000000000, тобто 1.0. Просто тому, що 15 останніх знаків при такому округленні зникають.  

+ +

Коли ви обчислюєте log(1 + x), ви отримаєте результат, дуже близький до x у випадках, коли x являється малою величиною (саме тому це називається 'натуральним' логарифмом). Якщо ви обчислите Math.log(1 + 1.1111111111e-15) - ви, ймовірно, отримаєте щось близьке до 1.1111111111e-15.  Якщо ж, натомість, ви візьмете логарифм від 1.00000000000000111022 (так, двійкове округлення інколи виглядає не надто гарно), ви отримаєте в якості відповіді 1.11022...e-15, із лише трьома значущими цифрами. Зате за допомогою Math.log1p(1.1111111111e-15) ви отримаєте значно точніший результат - 1.1111111110999995e-15 - із 15 значущими цифрами (власне навіть 16 для цього випадку).

+ +

Якщо значення x менше, ніж -1, результатом зажди буде {{jsxref("NaN")}}.

+ +

У зв'язку з тим, що log1p() - це статичний метод Math, слід завжди викликати його як Math.log1p(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Приклади

+ +

Застосування Math.log1p()

+ +
Math.log1p(1);  // 0.6931471805599453
+Math.log1p(0);  // 0
+Math.log1p(-1); // -Infinity
+Math.log1p(-2); // NaN
+
+ +

Поліфіл

+ +

Метод може бути відтворений за допомогою наступної функції:

+ +
Math.log1p = Math.log1p || function(x) {
+  return Math.log(1 + x);
+};
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.log1p', 'Math.log1p')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.log1p")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/log2/index.html b/files/uk/web/javascript/reference/global_objects/math/log2/index.html new file mode 100644 index 0000000000..43e87c72f8 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/log2/index.html @@ -0,0 +1,102 @@ +--- +title: Math.log2() +slug: Web/JavaScript/Reference/Global_Objects/Math/log2 +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2 +--- +
{{JSRef}}
+ +

Функція Math.log2() повертає логарифм за основою 2 від числа.  Інакше кажучи,

+ +

∀x>0,Math.log2(x)=log2(x)=такий унікальнійy,для якого2y=x\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x

+ +
{{EmbedInteractiveExample("pages/js/math-log2.html")}}
+ + + +

Синтаксис

+ +
Math.log2(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Логарифм за основою 2 від даного числа. Якщо значення аргументу від'ємне, функція повертає {{jsxref("NaN")}}.

+ +

Опис

+ +

Якщо значення аргументу x менше від 0, результат завжди дорівнює {{jsxref("NaN")}}.

+ +

У зв'язку з тим, що log2() - це статичний метод Math, слід завжди викликати його як Math.log2(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Ця фукнція є еквівалентною комбінації методів Math.log(x) / Math.log(2).  Для log2(e) використовуйте вбудовану сталу {{jsxref("Math.LOG2E")}}, яка дорівнює 1 / {{jsxref("Math.LN2")}}.  

+ +

Приклади

+ +

Застосування Math.log2()

+ +
Math.log2(3);    // 1.584962500721156
+Math.log2(2);    // 1
+Math.log2(1);    // 0
+Math.log2(0);    // -Infinity
+Math.log2(-2);   // NaN
+Math.log2(1024); // 10
+
+ +

Поліфіл

+ +

Даний поліфіл емулює функцію Math.log2. Зауважте, що він повертає неточні значення для деяких аргументів (наприклад, 1 << 29), тому обгорніть його у {{jsxref("Math.round()")}}, якщо працюєте із бітовими масками.

+ +
Math.log2 = Math.log2 || function(x) {
+  return Math.log(x) * Math.LOG2E;
+};
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатус документуПримітка
{{SpecName('ES2015', '#sec-math.log2', 'Math.log2')}}{{Spec2('ES2015')}}Первинне визначення.
{{SpecName('ESDraft', '#sec-math.log2', 'Math.log2')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.log2")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/log2e/index.html b/files/uk/web/javascript/reference/global_objects/math/log2e/index.html new file mode 100644 index 0000000000..fab39f96f0 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/log2e/index.html @@ -0,0 +1,66 @@ +--- +title: Math.LOG2E +slug: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +tags: + - JavaScript + - Math + - Властивість + - Довідка + - Поле +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +--- +
{{JSRef}}
+ +

Поле Math.LOG2E відображає логарифм ee за основою 2, що приблизно дорівнює 1.442:

+ +

Math.LOG2E=log2(e)≈1.442\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442

+ +
{{EmbedInteractiveExample("pages/js/math-log2e.html")}}
+ + + +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

У зв'язку із тим, що LOG2E - це статичне поле Math, слід завжди звертатись до нього у формі Math.LOG2E. Намагатись викликати LOG2E, звертаючись до полів  створених вами об'єктів Math - некоректно (Math не являється конструктором).

+ +

Приклади

+ +

Застосування Math.LOG2E

+ +

Наступна функція повертає логарифм ee за основою 2:

+ +
function getLog2e() {
+  return Math.LOG2E;
+}
+
+getLog2e(); // 1.4426950408889634
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.log2e', 'Math.LOG2E')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.LOG2E")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/max/index.html b/files/uk/web/javascript/reference/global_objects/math/max/index.html new file mode 100644 index 0000000000..d76643fb1e --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/max/index.html @@ -0,0 +1,102 @@ +--- +title: Math.max() +slug: Web/JavaScript/Reference/Global_Objects/Math/max +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/max +--- +
{{JSRef}}
+ +

Фукнція Math.max() повертає найбільше значення із довільної кількості (0 та більше) аргументів.

+ +
{{EmbedInteractiveExample("pages/js/math-max.html")}}
+ + + +

Синтаксис

+ +
Math.max([value1[, value2[, ...]]])
+ +

Аргументи

+ +
+
value1, value2, ...
+
Числа.
+
+ +

Результат

+ +

Найбільше із даних чисел. Якщо хоча б один із аргументів неможливо привести до числового типу - буде повернуто {{jsxref("NaN")}}.

+ +

Опис

+ +

У зв'язку з тим, що max() - це статичний метод Math, слід завжди викликати його як Math.max(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Якщо не дано жодного аргумента, результатом буде -{{jsxref("Infinity")}}.

+ +

Якщо щонайменше один із аргументів не можна привести до числового типу, то результатом буде {{jsxref("NaN")}}.

+ +

Приклади

+ +

Застосування Math.max()

+ +
Math.max(10, 20);   //  20
+Math.max(-10, -20); // -10
+Math.max(-10, 20);  //  20
+
+ +

Отримання найбільшого з елементів масиву

+ +

{{jsxref("Array.prototype.reduce", "Array.reduce()")}} може застосовуватись для пошуку найбільшого елементу в числовому масиві шляхом порівняння кожного значення:

+ +
var arr = [1,2,3];
+var max = arr.reduce(function(a, b) {
+    return Math.max(a, b);
+});
+
+ +

Наступна функція використовує {{jsxref("Function.prototype.apply()")}} для отримання найбільшого серед масиву чисел. getMaxOfArray([1, 2, 3]) еквівалентна до Math.max(1, 2, 3), проте ви можете застосовувати getMaxOfArray() для масивів, сформованих у процесі виконання програми. Цей спосіб слід застосовувати лише для масивів з відносно невеликою кількістю елементів.

+ +
function getMaxOfArray(numArray) {
+  return Math.max.apply(null, numArray);
+}
+ + + +

Новий оператор поширення (spread operator) - це більш компактний спосіб записати рішення на базі apply для отримання максимуму із масиву чисел:

+ +
var arr = [1, 2, 3];
+var max = Math.max(...arr);
+
+ +

Однак, як оператор поширення (...), так і apply призведуть до помилки або повернуть невірний результат, якщо вхідний масив має забагато елементів, бо вони намагаються передати елементи масиву в якості параметрів функції. Дивіться Використання методу apply і вбудованих фукнцій для більш докладної інформації. Рішення на базі reduce не має такої проблеми.

+ + + +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.max', 'Math.max')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.max")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/min/index.html b/files/uk/web/javascript/reference/global_objects/math/min/index.html new file mode 100644 index 0000000000..f5e5993976 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/min/index.html @@ -0,0 +1,98 @@ +--- +title: Math.min() +slug: Web/JavaScript/Reference/Global_Objects/Math/min +tags: + - JavaScript + - Math + - min + - Довідка + - Мінімум + - Найменше + - Найменше значення + - Найменше число + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/min +--- +
{{JSRef}}
+ +

Статична функція Math.min() повертає найменше з чисел, поданих на вхід, або ж {{jsxref("NaN")}}, якщо жоден із аргументів не є числом та не може бути перетворений у нього.

+ +
{{EmbedInteractiveExample("pages/js/math-min.html")}}
+ + + +

Синтаксис

+ +
Math.min([value1[, value2[, ...]]])
+ +

Аргументі

+ +
+
value1, value2, ...
+
Нуль, чи більше чисел, з-поміж яких буде вибрано найменше значення.
+
+ +

Результат

+ +

Найменше з поданих чисел. Якщо хоча б один із аргументів не можна перетворити на число, результатом буде {{jsxref("NaN")}}. Якщо функція викликана без аргументів, вона поверне {{jsxref("Infinity")}}.

+ +

Опис

+ +

У зв'язку з тим, що min() - це статичний метод Math, слід завжди викликати його як Math.min(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Якщо не дано жодного аргументу, результатом буде {{jsxref("Infinity")}}.

+ +

Якщо хоча б один із аргументів не може бути приведеним до числа, результатом буде {{jsxref("NaN")}}.

+ +

Приклади

+ +

Застосування Math.min()

+ +

Знайти мінімальне значення з-поміж x та y, і присвоїти його z:

+ +
var x = 10, y = -20;
+var z = Math.min(x, y);
+
+ +

Вибірка значень із Math.min()

+ +

Math.min() часто використовується для того, щоб вибрати значення, що менше або дорівнює якійсь межі. Зокрема, це

+ +
var x = f(foo);
+
+if (x > boundary) {
+  x = boundary;
+}
+
+ +

можна переписати ось так:

+ +
var x = Math.min(f(foo), boundary);
+
+ +

{{jsxref("Math.max()")}} може використовуватись подібним чином для вибірки значень із протилежного боку.

+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.min', 'Math.min')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.min")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/pi/index.html b/files/uk/web/javascript/reference/global_objects/math/pi/index.html new file mode 100644 index 0000000000..de82df2302 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/pi/index.html @@ -0,0 +1,64 @@ +--- +title: Math.PI +slug: Web/JavaScript/Reference/Global_Objects/Math/PI +tags: + - JavaScript + - Math + - Властивість + - Довідка + - Поле +translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI +--- +
{{JSRef}}
+ +

Поле Math.PI відображає значення відношення довжини кола до його діаметру, що приблизно дорівнює 3.14159:

+ +

Math.PI=π≈3.14159\mathtt{\mi{Math.PI}} = \pi \approx 3.14159

+ +
{{EmbedInteractiveExample("pages/js/math-pi.html")}}
+ + + +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

У зв'язку із тим, що PI - це статичне поле Math, слід завжди звертатись до нього у формі Math.PI. Намагатись викликати PI, звертаючись до полів  створених вами об'єктів Math - некоректно (Math не являється конструктором).

+ +

Приклади

+ +

Застосування Math.PI

+ +

Наступна функція використовує Math.PI для обчислення довжини кола за заданим діаметром:

+ +
function calculateCircumference(radius) {
+  return Math.PI * (radius + radius);
+}
+
+calculateCircumference(1);  // 6.283185307179586
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.pi', 'Math.PI')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.PI")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/pow/index.html b/files/uk/web/javascript/reference/global_objects/math/pow/index.html new file mode 100644 index 0000000000..951aeccb66 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/pow/index.html @@ -0,0 +1,117 @@ +--- +title: Math.pow() +slug: Web/JavaScript/Reference/Global_Objects/Math/pow +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow +--- +
{{JSRef}}
+ +

Функція Math.pow() повертає результат піднесення основи до показника степеня, тобто, основастепінь.

+ +

 

+ +
{{EmbedInteractiveExample("pages/js/math-pow.html")}}
+ + + +

 

+ +

Синтаксис

+ +
Math.pow(base, exponent)
+ +

Параметри

+ +
+
base
+
Основа степеня.
+
exponent
+
Показник степеня, до якого буде піднесено основу.
+
+ +

Результат

+ +

Число, що відображає значення основи, піднесеної до показника степеня.

+ +

Опис

+ +

Тому що pow() є статичним методом Math, він завжди використовується як Math.pow(), аніж як метод створеного об'єкту Math (Math не має конструктора).

+ +

Приклади

+ +

Використання Math.pow()

+ +
// просте
+Math.pow(7, 2);    // 49
+Math.pow(7, 3);    // 343
+Math.pow(2, 10);   // 1024
+// дроби як показники степеня
+Math.pow(4, 0.5);  // 2 (корінь квадратний від 4)
+Math.pow(8, 1/3);  // 2 (корінь кубічний від 8)
+Math.pow(2, 0.5);  // 1.4142135623730951 (корінь квадратний від 2)
+Math.pow(2, 1/3);  // 1.2599210498948732 (корінь кубічний від 2)
+// показники степеня зі знаками
+Math.pow(7, -2);   // 0.02040816326530612 (1/49)
+Math.pow(8, -1/3); // 0.5
+// основи зі знаками
+Math.pow(-7, 2);   // 49 (квадрати завжди позитивні)
+Math.pow(-7, 3);   // -343 (куби можуть бути негативними)
+Math.pow(-7, 0.5); // NaN (негативні числа не мають дійсного квадратного кореня)
+// через те, що "парні" та "непарні" корені є близькими один до одного,
+// та через обмеження точності представлення чисел з рухомою комою
+// негативні основи з дробовими показниками степіня завжди повертають NaN
+
+Math.pow(-7, 1/3); // NaN
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення, впроваджене у JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.13', 'Math.pow')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.pow', 'Math.pow')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.pow', 'Math.pow')}}{{Spec2('ESDraft')}} 
+ +

Сумісність із браузерами

+ + + +

{{Compat("javascript.builtins.Math.pow")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/random/index.html b/files/uk/web/javascript/reference/global_objects/math/random/index.html new file mode 100644 index 0000000000..14ee5ccbd5 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/random/index.html @@ -0,0 +1,113 @@ +--- +title: Math.random() +slug: Web/JavaScript/Reference/Global_Objects/Math/random +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/random +--- +
{{JSRef}}
+ +

Функція Math.random() повертає псевдо-випадкове число із рухомою комою з проміжку 0–1 (включно із 0, але не включаючи 1) із приблизно рівномірним розподілом значень на ньому (в подальшому його можна масштабувати до потрібних розмірів). Вихідне зерно-параметр для алгоритму генерації випадкового числа обирається реалізацією; воно не може бути обраним чи перевизначеним користувачем.

+ +
{{EmbedInteractiveExample("pages/js/math-random.html")}}
+ +
+

Math.random() не надає криптографічно стійких випадкових чисел. Не слід застосовувати їх будь-де у місцях, пов'язаних із інформаційною безпекою. Натомість використовуйте Web Crypto API, а точніше - метод {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.

+
+ +

Синтаксис

+ +
Math.random()
+ +

Результат

+ +

Псевдовипадкове число із рухомою комою між 0 (включно) та 1 (виключно).

+ +

Приклади

+ +

Зауважте, що числа у JavaScript являються стандартизованими згідно IEEE 754 числами із рухомою комою із поведінкою "округлення до найближчого парного". Тому проміжки, що охоплюються наступними фукнціями (за винятком власне Math.random()) не зовсім точні. За умови дуже великих обраних меж (253 чи більших) можливо у дуже рідкісних випадках отримати значення верхньої межі, яке зазвичай виключається.

+ +

Отримання випадкового числа з-поміж 0 (включно) та 1 (виключно)

+ +
function getRandom() {
+  return Math.random();
+}
+
+ +

Отримання випадкового числа з-поміж двох значень

+ +

Наступний приклад повертає випадкове число між двома вказаними значеннями. Результат не менший від (інколи дорівнює) min, і менший за (але не дорівнює) max.

+ +
function getRandomArbitrary(min, max) {
+  return Math.random() * (max - min) + min;
+}
+
+ +

Отримання випадкового цілого з-поміж двох значень

+ +

Наступний приклад повертає випадкове ціле число між двома заданими значеннями. Результат не менший від min (або ж від наступного цілого, більшого за min, якщо min не являється цілим), і менший за (але не дорівнює) max.

+ +
function getRandomInt(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min)) + min; //Включно з мінімальним та виключаючи максимальне значення
+
+}
+
+ +
+

Застосування Math.round() для отримання цілих може виглядати доволі привабливо, проте це призведе до спотворення рівномірного розподілу ймовірності результатів, що може бути неприйнятним для ваших потреб.

+
+ +

Отримання випадкового цілого з-поміж двох значень, включно

+ +

В той час, коли фукнція getRandomInt() включає до спектру результатів мінімум, вона виключає звідти максимум. Що, якщо вам знадобиться включити до можливих результатів як мінімум, так і максимум? Наступна фукнція getRandomIntInclusive() дозволяє цього досягти:

+ +
function getRandomIntInclusive(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min; //Включаючи мінімум та максимум
+}
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатус документуПримітка
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. JavaScript 1.0 (UNIX Only) / JavaScript 1.1 (All platforms).
{{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.random', 'Math.random')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.random', 'Math.random')}}{{Spec2('ESDraft')}} 
+ +

Сумісність із браузерами

+ + + +

{{Compat("javascript.builtins.Math.random")}}

+ +

 

diff --git a/files/uk/web/javascript/reference/global_objects/math/sign/index.html b/files/uk/web/javascript/reference/global_objects/math/sign/index.html new file mode 100644 index 0000000000..a3b2668270 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/sign/index.html @@ -0,0 +1,116 @@ +--- +title: Math.sign() +slug: Web/JavaScript/Reference/Global_Objects/Math/sign +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign +--- +
{{JSRef}}
+ +

Функція Math.sign() повертає знак числа, визначаючи, чи являється число додатнім, від'ємним, або нулем.

+ +
{{EmbedInteractiveExample("pages/js/math-sign.html")}}
+ + + +

Синтаксис

+ +
Math.sign(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Число, що відображає знак аргументу. Якщо аргумент являється додатнім числом, від'ємним числом, додатнім чи від'ємним нулем, функція поверне відповідно 1, -1, 0 чи -0. В інших випадках результатом буде {{jsxref("NaN")}}.

+ +

Опис

+ +

У зв'язку з тим, що sign() - це статичний метод Math, слід завжди викликати його як Math.sign(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Ця функція має 5 різних видів результатів: 1, -1, 0, -0, NaN. Вони відповідно відображають "додатнє число", "від'ємне число", "додатній нуль", "від'ємний нуль" та {{jsxref("NaN")}}.

+ +

Аргумент буде неявно перетворено у number при передачі у функцію.

+ +

Приклади

+ +

Застосування Math.sign()

+ +
Math.sign(3);     //  1
+Math.sign(-3);    // -1
+Math.sign('-3');  // -1
+Math.sign(0);     //  0
+Math.sign(-0);    // -0
+Math.sign(NaN);   // NaN
+Math.sign('foo'); // NaN
+Math.sign();      // NaN
+
+ +

Поліфіл

+ +
if (!Math.sign) {
+  Math.sign = function(x) {
+    // Якщо x - NaN, результатом буде NaN.
+    // Якщо x - -0, результатом буде -0.
+    // Якщо x - +0, результатом буде +0.
+    // Якщо x від'ємний, але не -0, результатом буде -1.
+    // Якщо x додатній, але не +0, результатом буде +1.
+    return ((x > 0) - (x < 0)) || +x;
+    // Більш наочне уявлення представлено нижче
+    //
+    // ( (x > 0) ? 0 : 1 )  // якщо від'ємний x - то від'ємна 1
+    //          +           // інакще (бо не може бути одночасно - та +)
+    // ( (x < 0) ? 0 : -1 ) // якщо додатній x - то додатня 1
+    //         ||           // якщо x є 0, -0, чи NaN, чи не являється числом,
+    //         +x           // то результатом буде x, (чи) якщо x не є
+    //                      // числом, то x приводиться до чисельного типу
+  };
+}
+
+ +

У наведеному вище поліфілі не потрібно ніяких додаткових приведень типів (x > 0) чи (x < 0), бо їх віднімання одного від іншого вже вимагає конвертації із булевого типу в числа.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусПримітка
{{SpecName('ES6', '#sec-math.sign', 'Math.sign')}}{{Spec2('ES6')}}Первинне визначення.
{{SpecName('ESDraft', '#sec-math.sign', 'Math.sign')}}{{Spec2('ESDraft')}} 
+ +

Сумісність із браузерами

+ + + +

{{Compat("javascript.builtins.Math.sign")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/sin/index.html b/files/uk/web/javascript/reference/global_objects/math/sin/index.html new file mode 100644 index 0000000000..9a9c2bffe4 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/sin/index.html @@ -0,0 +1,78 @@ +--- +title: Math.sin() +slug: Web/JavaScript/Reference/Global_Objects/Math/sin +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin +--- +
{{JSRef}}
+ +

Функція Math.sin() повертає синус числа.

+ +
{{EmbedInteractiveExample("pages/js/math-sin.html")}}
+ + + +

Синтаксис

+ +
Math.sin(x)
+ +

Аргументи

+ +
+
x
+
Число (кут у радіанах).
+
+ +

Результат

+ +

Синус даного числа.

+ +

Опис

+ +

Метод Math.sin() повертає число з-поміж -1 та 1, що відповідає синусу даного у радіанах кута.

+ +

У зв'язку з тим, що sin() - це статичний метод Math, слід завжди викликати його як Math.sin(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Приклади

+ +

Застосування Math.sin()

+ +
Math.sin(0);           // 0
+Math.sin(1);           // 0.8414709848078965
+
+Math.sin(Math.PI / 2); // 1
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.sin', 'Math.sin')}}
+ +

Сумісність із браузерами

+ + + +

{{Compat("javascript.builtins.Math.sin")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/sinh/index.html b/files/uk/web/javascript/reference/global_objects/math/sinh/index.html new file mode 100644 index 0000000000..f3e3d83b02 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/sinh/index.html @@ -0,0 +1,93 @@ +--- +title: Math.sinh() +slug: Web/JavaScript/Reference/Global_Objects/Math/sinh +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh +--- +
{{JSRef}}
+ +

Функція Math.sinh() повертає гіперболічний синус числа. За допомогою{{jsxref("Math.E", "сталої e", "", 1)}} це можна обчислити так:

+ +

Math.sinh(x)=ex-e-x2\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}

+ +
{{EmbedInteractiveExample("pages/js/math-sinh.html")}}
+ + + +

Синтаксис

+ +
Math.sinh(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Гіперболічний синус даного числа.

+ +

Опис

+ +

У зв'язку з тим, що sinh() - це статичний метод Math, слід завжди викликати його як Math.sinh(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Приклади

+ +

Застосування Math.sinh()

+ +
Math.sinh(0); // 0
+Math.sinh(1); // 1.1752011936438014
+
+ +

Поліфіл

+ +

Такий же результат можна отримати за допомогою фукнції {{jsxref("Math.exp()")}}:

+ +
Math.sinh = Math.sinh || function(x) {
+  return (Math.exp(x) - Math.exp(-x)) / 2;
+}
+
+ +

або ж викликаючи {{jsxref("Math.exp()")}} лише один раз:

+ +
Math.sinh = Math.sinh || function(x) {
+  var y = Math.exp(x);
+  return (y - 1 / y) / 2;
+}
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.sinh', 'Math.sinh')}}
+ +

Сумісність із браузерами

+ + + +

{{Compat("javascript.builtins.Math.sinh")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/sqrt/index.html b/files/uk/web/javascript/reference/global_objects/math/sqrt/index.html new file mode 100644 index 0000000000..7ef247ceff --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/sqrt/index.html @@ -0,0 +1,81 @@ +--- +title: Math.sqrt() +slug: Web/JavaScript/Reference/Global_Objects/Math/sqrt +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt +--- +
{{JSRef}}
+ +

Функція Math.sqrt() повертає квадратний корінь від числа, що являється

+ +

∀x≥0,Math.sqrt(x)=x=такий унікальнийy≥0, для якогоy2=x\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x

+ +
{{EmbedInteractiveExample("pages/js/math-sqrt.html")}}
+ + + +

Синтаксис

+ +
Math.sqrt(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Квадратний корінь даного числа. Якщо число від'ємне, функція повертає {{jsxref("NaN")}}.

+ +

Опис

+ +

Якщо значення x від'ємне, Math.sqrt() повертає {{jsxref("NaN")}}.

+ +

У зв'язку з тим, що sqrt() - це статичний метод Math, слід завжди викликати його як Math.sqrt(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Приклади

+ +

Застосування Math.sqrt()

+ +
Math.sqrt(9); // 3
+Math.sqrt(2); // 1.414213562373095
+
+Math.sqrt(1);  // 1
+Math.sqrt(0);  // 0
+Math.sqrt(-1); // NaN
+Math.sqrt(-0); // -0
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.sqrt', 'Math.sqrt')}}
+ +

Сумісність із браузерами

+ + + +

{{Compat("javascript.builtins.Math.sqrt")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/sqrt1_2/index.html b/files/uk/web/javascript/reference/global_objects/math/sqrt1_2/index.html new file mode 100644 index 0000000000..a73d0f91af --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/sqrt1_2/index.html @@ -0,0 +1,65 @@ +--- +title: Math.SQRT1_2 +slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +tags: + - JavaScript + - Math + - Властивість + - Довідка + - Поле +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +--- +
{{JSRef}}
+ +

Поле Math.SQRT1_2 відображає значення квадратного кореня від 1/2, що приблизно дорівнює 0.707:

+ +

Math.SQRT1_2=12=12=22≈0.707\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} = \frac{\sqrt{2}}{2} \approx 0.707

+ +
{{EmbedInteractiveExample("pages/js/math-sqrt1_2.html")}}
+ + + +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

У зв'язку із тим, що SQRT1_2 - це статичне поле Math, слід завжди звертатись до нього у формі Math.SQRT1_2. Намагатись викликати SQRT1_2, звертаючись до полів  створених вами об'єктів Math - некоректно (Math не являється конструктором).

+ +

Приклади

+ +

Застосування Math.SQRT1_2

+ +

Наступна функція повертає значення квадратного кореня від 1/2:

+ +
function getRoot1_2() {
+  return Math.SQRT1_2;
+}
+
+getRoot1_2(); // 0.7071067811865476
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.SQRT1_2")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/sqrt2/index.html b/files/uk/web/javascript/reference/global_objects/math/sqrt2/index.html new file mode 100644 index 0000000000..546d939b3f --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/sqrt2/index.html @@ -0,0 +1,65 @@ +--- +title: Math.SQRT2 +slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +tags: + - JavaScript + - Math + - Властивість + - Довідка + - Поле +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +--- +
{{JSRef}}
+ +

Поле Math.SQRT2 відображає значення квадратного кореня із 2, що приблизно дорівнює 1.414:

+ +

Math.SQRT2=2≈1.414\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414

+ +
{{EmbedInteractiveExample("pages/js/math-sqrt2.html")}}
+ + + +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

У зв'язку із тим, що SQRT2 - це статичне поле Math, слід завжди звертатись до нього у формі Math.SQRT2. Намагатись викликати SQRT2, звертаючись до полів  створених вами об'єктів Math - некоректно (Math не являється конструктором).

+ +

Приклади

+ +

Використання Math.SQRT2

+ +

Наступна функція повертає значення квадратного кореня із 2:

+ +
function getRoot2() {
+  return Math.SQRT2;
+}
+
+getRoot2(); // 1.4142135623730951
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.sqrt2', 'Math.SQRT2')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.SQRT2")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/tan/index.html b/files/uk/web/javascript/reference/global_objects/math/tan/index.html new file mode 100644 index 0000000000..1a5149a778 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/tan/index.html @@ -0,0 +1,83 @@ +--- +title: Math.tan() +slug: Web/JavaScript/Reference/Global_Objects/Math/tan +tags: + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan +--- +
{{JSRef}}
+ +

Функція Math.tan() повертає тангенс від числа.

+ +
{{EmbedInteractiveExample("pages/js/math-tan.html")}}
+ + + +

Синтаксис

+ +
Math.tan(x)
+ +

Аргументи

+ +
+
x
+
Число, що являє собою кут в радіанах.
+
+ +

Результат

+ +

Тангенс даного числа.

+ +

Опис

+ +

Метод Math.tan() повертає числове значення, що відповідає тангенсу поданого кута.

+ +

У зв'язку з тим, що tan() - це статичний метод Math, слід завжди викликати його як Math.tan(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Приклади

+ +

Застосування Math.tan()

+ +
Math.tan(1); // 1.5574077246549023
+
+ +

Так як функція Math.tan() приймає значення в радіанах, але зазвичай зручніше працювати із градусами, наступна функція приймає значення кута в градусах, перетворює його в радіани та повертає тангенс.

+ +
function getTanDeg(deg) {
+  var rad = deg * Math.PI/180;
+  return Math.tan(rad);
+}
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.tan', 'Math.tan')}}
+ +

Підтримка в браузерах

+ + + +

{{Compat("javascript.builtins.Math.tan")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/tanh/index.html b/files/uk/web/javascript/reference/global_objects/math/tanh/index.html new file mode 100644 index 0000000000..84bd6008fb --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/tanh/index.html @@ -0,0 +1,85 @@ +--- +title: Math.tanh() +slug: Web/JavaScript/Reference/Global_Objects/Math/tanh +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tanh +--- +
{{JSRef}}
+ +

Функція Math.tanh() повертає значення гіперболічного тангенса від числа, що також можна висловити як:

+ +

tanhx=sinhxcoshx=ex-e-xex+e-x=e2x-1e2x+1\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}

+ +
{{EmbedInteractiveExample("pages/js/math-tanh.html")}}
+ +

Синтаксис

+ +
Math.tanh(x)
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Гіперболічний тангенс даного числа.

+ +

Опис

+ +

У зв'язку з тим, що tanh() - це статичний метод Math, слід завжди викликати його як Math.tanh(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Приклади

+ +

Застосування Math.tanh()

+ +
Math.tanh(0);        // 0
+Math.tanh(Infinity); // 1
+Math.tanh(1);        // 0.7615941559557649
+
+ +

Поліфіл

+ +

Даний метод можна емулювати за допомогою функції {{jsxref("Math.exp()")}}:

+ +
Math.tanh = Math.tanh || function(x){
+    var a = Math.exp(+x), b = Math.exp(-x);
+    return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b);
+}
+
+ +

Специфікації

+ + + + + + + + + + +
Специфікація
{{SpecName('ESDraft', '#sec-math.tanh', 'Math.tanh')}}
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.tanh")}}

+ +

Дивіться також

+ + diff --git a/files/uk/web/javascript/reference/global_objects/math/trunc/index.html b/files/uk/web/javascript/reference/global_objects/math/trunc/index.html new file mode 100644 index 0000000000..d3fa2704c5 --- /dev/null +++ b/files/uk/web/javascript/reference/global_objects/math/trunc/index.html @@ -0,0 +1,128 @@ +--- +title: Math.trunc() +slug: Web/JavaScript/Reference/Global_Objects/Math/trunc +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Довідка + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc +--- +
{{JSRef}}
+ +

Функція Math.trunc() повертає цілу частину числа, повністю відкидаючи дробову.

+ +
{{EmbedInteractiveExample("pages/js/math-trunc.html")}}
+ + + +

Синтаксис

+ +
Math.trunc(x)
+
+ +

Аргументи

+ +
+
x
+
Число.
+
+ +

Результат

+ +

Ціла частина даного числа.

+ +

Опис

+ +

На відміну від трьох інших методів Math ({{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} та {{jsxref("Math.round()")}}), принцип роботи Math.trunc() дуже простий. Функція просто відкидає кому (крапку) та всі цифри правої частини, не зважаючи на те, являється аргумент додатнім, чи від'ємним.

+ +

Аргумент, поданий на вхід цієї функції, буде неявно приведений до чисельного типу.

+ +

У зв'язку з тим, що trunc() - це статичний метод Math, слід завжди викликати його як Math.trunc(), аніж як метод створеного вами об'єкту Math (оскільки Math не являється конструктором).

+ +

Приклади

+ +

Застосування Math.trunc()

+ +
Math.trunc(13.37);    // 13
+Math.trunc(42.84);    // 42
+Math.trunc(0.123);    //  0
+Math.trunc(-0.123);   // -0
+Math.trunc('-1.123'); // -1
+Math.trunc(NaN);      // NaN
+Math.trunc('foo');    // NaN
+Math.trunc();         // NaN
+
+ +

Поліфіл

+ +
if (!Math.trunc) {
+	Math.trunc = function(v) {
+		v = +v;
+		if (!isFinite(v)) return v;
+
+		return (v - v % 1)   ||   (v < 0 ? -0 : v === 0 ? v : 0);
+
+		// повертає:
+		//  0        ->  0
+		// -0        -> -0
+		//  0.2      ->  0
+		// -0.2      -> -0
+		//  0.7      ->  0
+		// -0.7      -> -0
+		//  Infinity ->  Infinity
+		// -Infinity -> -Infinity
+		//  NaN      ->  NaN
+		//  null     ->  0
+	};
+}
+
+ +

чи:

+ +
if (!Math.trunc) {
+	Math.trunc = function(v) {
+		v = +v;
+		return (v - v % 1)   ||   (!isFinite(v) || v === 0 ? v : v < 0 ? -0 : 0);
+	};
+}
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусПримітка
{{SpecName('ES2015', '#sec-math.trunc', 'Math.trunc')}}{{Spec2('ES2015')}}Первинне визначення.
{{SpecName('ESDraft', '#sec-math.trunc', 'Math.trunc')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ + + +

{{Compat("javascript.builtins.Math.trunc")}}

+ +

Дивіться також

+ + diff --git "a/files/uk/web/javascript/reference/global_objects/math/\320\267\320\260\320\276\320\272\321\200\321\203\320\263\320\265\320\273\320\275\320\275\321\217/index.html" "b/files/uk/web/javascript/reference/global_objects/math/\320\267\320\260\320\276\320\272\321\200\321\203\320\263\320\265\320\273\320\275\320\275\321\217/index.html" new file mode 100644 index 0000000000..92cc055f83 --- /dev/null +++ "b/files/uk/web/javascript/reference/global_objects/math/\320\267\320\260\320\276\320\272\321\200\321\203\320\263\320\265\320\273\320\275\320\275\321\217/index.html" @@ -0,0 +1,194 @@ +--- +title: Math.round() +slug: Web/JavaScript/Reference/Global_Objects/Math/заокругелння +tags: + - JavaScript + - Math + - Довідка + - Заокруглення + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Math/round +--- +
{{JSRef}}
+ +

Функція Math.round() повертає значення числа заокруглене до найближчого цілого.

+ +

 

+ +
{{EmbedInteractiveExample("pages/js/math-round.html")}}
+ + + +

 

+ +

Синтаксис

+ +
Math.round(x)
+ +

Параметри

+ +
+
x
+
Число.
+
+ +

Повернуте значення

+ +

Значення отриманого числа, округлене до найближчого цілого.

+ +

Опис

+ +

Якщо дробова частина числа більша або рівна 0.5, аргумент буде округлено до найближчого більшого цілого. Якщо дробова частина числа менша 0.5, аргумент буде округлено до найближчого меншого цілого. Якщо дробова частина рівна 0.5, то аргумент буде округлено до найближчого цілого в напрямку +∞.  Зверніть увагу, що функція round() відрізняється від багатьох мов, які часто приводять цей випадок до наступного цілого числа, віддаленого від нуля (маємо інший результат у випадку від'ємних чисел з дробовою частиною рівною 0.5).

+ +

Оскільки round() - це статичний метод Math, ви завжди використовуєте його як Math.round (), а не як метод об'єкта Math, який ви створили (Math не має конструктора).

+ +

Приклади

+ +
Math.round( 20.49); //  20
+Math.round( 20.5);  //  21
+Math.round( 42  );  //  42
+Math.round(-20.5);  // -20
+Math.round(-20.51); // -21
+
+ +

Десяткове округлення

+ +
// Closure
+(function() {
+  /**
+   * Decimal adjustment of a number.
+   *
+   * @param {String}  type  The type of adjustment.
+   * @param {Number}  value The number.
+   * @param {Integer} exp   The exponent (the 10 logarithm of the adjustment base).
+   * @returns {Number} The adjusted value.
+   */
+  function decimalAdjust(type, value, exp) {
+    // If the exp is undefined or zero...
+    if (typeof exp === 'undefined' || +exp === 0) {
+      return Math[type](value);
+    }
+    value = +value;
+    exp = +exp;
+    // If the value is not a number or the exp is not an integer...
+    if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
+      return NaN;
+    }
+    // If the value is negative...
+    if (value < 0) {
+      return -decimalAdjust(type, -value, exp);
+    }
+    // Shift
+    value = value.toString().split('e');
+    value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
+    // Shift back
+    value = value.toString().split('e');
+    return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
+  }
+
+  // Decimal round
+  if (!Math.round10) {
+    Math.round10 = function(value, exp) {
+      return decimalAdjust('round', value, exp);
+    };
+  }
+  // Decimal floor
+  if (!Math.floor10) {
+    Math.floor10 = function(value, exp) {
+      return decimalAdjust('floor', value, exp);
+    };
+  }
+  // Decimal ceil
+  if (!Math.ceil10) {
+    Math.ceil10 = function(value, exp) {
+      return decimalAdjust('ceil', value, exp);
+    };
+  }
+})();
+
+// Round
+Math.round10(55.55, -1);   // 55.6
+Math.round10(55.549, -1);  // 55.5
+Math.round10(55, 1);       // 60
+Math.round10(54.9, 1);     // 50
+Math.round10(-55.55, -1);  // -55.5
+Math.round10(-55.551, -1); // -55.6
+Math.round10(-55, 1);      // -50
+Math.round10(-55.1, 1);    // -60
+Math.round10(1.005, -2);   // 1.01 -- compare this with Math.round(1.005*100)/100 above
+Math.round10(-1.005, -2);  // -1.01
+// Floor
+Math.floor10(55.59, -1);   // 55.5
+Math.floor10(59, 1);       // 50
+Math.floor10(-55.51, -1);  // -55.6
+Math.floor10(-51, 1);      // -60
+// Ceil
+Math.ceil10(55.51, -1);    // 55.6
+Math.ceil10(51, 1);        // 60
+Math.ceil10(-55.59, -1);   // -55.5
+Math.ceil10(-59, 1);       // -50
+
+ +

PHP-Like rounding Method

+ +

The code below can be used to add your own version of Math.round to your own namespace which takes a precision parameter. Unlike Decimal rounding in the example above, this performs no conversion to and from strings, and the precision parameter works same way as PHP and Excel whereby a positive 1 would round to 1 decimal place and -1 would round to the tens.

+ +
var myNamespace = {};
+
+myNamespace.round = function(number, precision) {
+    var factor = Math.pow(10, precision);
+    var tempNumber = number * factor;
+    var roundedTempNumber = Math.round(tempNumber);
+    return roundedTempNumber / factor;
+};
+
+myNamespace.round(1234.5678, 1); // 1234.6
+myNamespace.round(1234.5678, -1); // 1230
+ +

Cпецифікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення. Впроваджено в JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.15', 'Math.round')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.round', 'Math.round')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.round', 'Math.round')}}{{Spec2('ESDraft')}} 
+ +

Сумісність браузерів

+ + + +

{{Compat("javascript.builtins.Math.round")}}

+ +

Дивіться також

+ + -- cgit v1.2.3-54-g00ecf