recursal/MDN huggingface dataset:
Math.hypot()
============

Сводка
------

Метод **`Math.hypot()`** возвращает квадратный корень суммы квадратов своих аргументов, то есть



Math.hypot
(

v
1

,

v
2

,
…
,

v
n

)

=

∑

i
=
1

n

v
i
2

=

v
1
2

+

v
2
2

+
…
+

v
n
2

\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}

Синтаксис
---------
```

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

### Параметры

`value1, value2, ...`

Числа.

Описание
--------

Поскольку метод `hypot()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.hypot()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

При вызове без аргументов результатом вызова будет значение +0.

Если хотя бы один из аргументов не может быть преобразован в число, результатом будет `NaN`.

При вызове с одним аргументом, метод `Math.hypot()` то же самое значение, что и метод `Math.abs()`.

Примеры
-------

### Пример: использование метода `Math.hypot()`


```js
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, то же самое, что и Math.abs(-3)
```

Полифил
-------

Этот метод может эмулироваться следующим образом:


```js
Math.hypot =
  Math.hypot ||
  function () {
    var y = 0;
    var length = arguments.length;

    for (var i = 0; i < length; i++) {
      if (arguments[i] === Infinity || arguments[i] === -Infinity) {
        return Infinity;
      }
      y += arguments[i] \* arguments[i];
    }
    return Math.sqrt(y);
  };
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.hypot |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.abs()`
* `Math.pow()`
* `Math.sqrt()`
Math.LN10
=========

Сводка
------

Свойство **`Math.LN10`** представляет натуральный логарифм из 10, приблизительно равный 2,302:


Math.LN10

=
ln
(
10
)
≈
2,302

\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2,302



| Атрибуты свойства `Math.LN10` |
| --- |
| Записываемое | нет |
| Перечисляемое | нет |
| Настраиваемое | нет |

Описание
--------

Поскольку свойство `LN10` является статическим свойством объекта `Math`, вы всегда должны использовать его как `Math.LN10`, а не пытаться создавать экземпляр объекта `Math` и получать свойство от него (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование свойства `Math.LN10`

Следующая функция возвращает натуральный логарифм из 10:


```js
function getNatLog10() {
  return Math.LN10;
}

getNatLog10(); // 2.302585092994046
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ln10 |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.exp()`
* `Math.log()`
* `Math.log10()` 
Экспериментальная возможность
Math.expm1()
============

Сводка
------

Метод **`Math.expm1()`** возвращает значение выражения `ex - 1`, где `x` — аргумент метода, а e — основание натурального логарифма.

Синтаксис
---------
```

Math.expm1(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `expm1()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.expm1()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.expm1()`


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

Полифил
-------

Этот метод может эмулироваться при помощи метода `Math.exp()`:


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

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.expm1 |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.E`
* `Math.exp()`
* `Math.log()`
* `Math.log10()` 
Экспериментальная возможность
* `Math.log1p()` 
Экспериментальная возможность
* `Math.log2()` 
Экспериментальная возможность
* `Math.pow()`
Math.atanh()
============

Сводка
------

Метод **`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{ уникальный } ; y ; \text{такой, что} ; \tanh(y) = x

Синтаксис
---------
```

Math.atanh(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `atanh()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.atanh()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.atanh()`


```js
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, метод `Math.atanh()` возвращает `NaN`.

Полифил
-------

Для 


|
x
|

<
1

\left|x\right| < 1

, мы имеем 


artanh
(
x
)
=

1
2

ln

(

1
+
x

1
-
x

)

\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)

, так что этот метод может эмулироваться следующим образом:


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

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.atanh |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.acosh()` 
Экспериментальная возможность
* `Math.asinh()` 
Экспериментальная возможность
* `Math.cosh()` 
Экспериментальная возможность
* `Math.sinh()` 
Экспериментальная возможность
* `Math.tanh()` 
Экспериментальная возможность
Math.sin()
==========

Сводка
------

Метод **`Math.sin()`** возвращает синус числа.

Синтаксис
---------
```

Math.sin(x)
```

### Параметры

`x`

Число радиан.

Описание
--------

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

Поскольку метод `sin()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.sin()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.sin()`


```js
Math.sin(0); // 0
Math.sin(1); // 0.8414709848078965

Math.sin(Math.PI / 2); // 1
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sin |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.tan()`
Math.log()
==========

Сводка
------

Метод **`Math.log()`** возвращает натуральный (по основанию `e`) логарифм числа, то есть



∀
x
>
0
,

Math.log
(
x
)

=
ln
(
x
)
=
уникальный

y

такой, что

e
y

=
x

\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{уникальный} ; y ; \text{такой, что} ; e^y = x

Синтаксис
---------
```

Math.log(x)
```

### Параметры

`x`

Число.

Описание
--------

Если значение `x` меньше 0, возвращаемое значение всегда будет равным `NaN`.

Поскольку метод `log()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.log()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.log()`


```js
Math.log(-1); // NaN, выход за пределы диапазона
Math.log(0); // -Infinity
Math.log(1); // 0
Math.log(10); // 2.302585092994046
```

### Пример: использование метода `Math.log()` с различными основаниями

Следующая функция возвращает логарифм из `y` по основанию `x` (то есть, 


log
x

y

\log\_x y

):


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


Если вы выполните `getBaseLog(10, 1000)`, функция вернёт `2.9999999999999996` из-за особенностей округления чисел с плавающей запятой, что довольно близко к правильному ответу — 3.

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.exp()`
* `Math.log1p()` 
Экспериментальная возможность
* `Math.log10()` 
Экспериментальная возможность
* `Math.log2()` 
Экспериментальная возможность
* `Math.pow()`
Math.E
======

Сводка
------

Свойство **`Math.E`** представляет основание натурального логарифма, e, приблизительно равное 2,718.


Math.E

=
e
≈
2,718

\mathtt{\mi{Math.E}} = e \approx 2,718



| Атрибуты свойства `Math.E` |
| --- |
| Записываемое | нет |
| Перечисляемое | нет |
| Настраиваемое | нет |

Описание
--------

Поскольку свойство `E` является статическим свойством объекта `Math`, вы всегда должны использовать его как `Math.E`, а не пытаться создавать экземпляр объекта `Math` и получать свойство от него (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование свойства `Math.E`

Следующая функция возвращает e:


```js
function getNapier() {
  return Math.E;
}

getNapier(); // 2.718281828459045
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.e |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.exp()`
* `Math.log()`
* `Math.log1p()` 
Экспериментальная возможность
Math.log10()
============

Сводка
------

Метод **`Math.log10()`** возвращает десятичный (по основанию 10) логарифм числа, то есть



∀
x
>
0
,

Math.log10
(
x
)

=

log
10

(
x
)
=
уникальный

y

такой, что

10
y

=
x

\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log\_10(x) = \text{уникальный} ; y ; \text{такой, что} ; 10^y = x

Синтаксис
---------
```

Math.log10(x)
```

### Параметры

`x`

Число.

Описание
--------

Если значение `x` меньше 0, возвращаемое значение всегда будет равным `NaN`.

Поскольку метод `log10()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.log10()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.log10()`


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

Полифил
-------

Этот метод может эмулироваться следующим способом:


```js
Math.log10 =
  Math.log10 ||
  function (x) {
    return Math.log(x) / Math.LN10;
  };
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log10 |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.exp()`
* `Math.log()`
* `Math.log1p()` 
Экспериментальная возможность
* `Math.log2()` 
Экспериментальная возможность
* `Math.pow()`
Math.fround()
=============

Сводка
------

Метод **`Math.fround()`** возвращает ближайшее число с плавающей запятой одинарной точности, представляющее указанное число.

Синтаксис
---------
```

Math.fround(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `fround()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.fround()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.fround()`


```js
Math.fround(0); // 0
Math.fround(1); // 1
Math.fround(1.337); // 1.3370000123977661
Math.fround(1.5); // 1.5
Math.fround(NaN); // NaN
```

Полифил
-------

Этот метод может эмулироваться следующим образом, при условии, что среда выполнения поддерживает объект `Float32Array`:


```js
Math.fround =
  Math.fround ||
  function (x) {
    return new Float32Array([x])[0];
  };
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.fround |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.round()`
Math.acosh()
============

Сводка
------

Метод **`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{ уникальный } ; y \geq 0 ; \text{такой, что} ; \cosh(y) = x

Синтаксис
---------
```

Math.acosh(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `acosh()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.acosh()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.acosh()`


```js
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()` возвращает `NaN`.

Полифил
-------

Для всех 


x
≥
1

x \geq 1

, мы имеем 


arcosh
(
x
)
=
ln

(

x
+

x
2

-
1

)

\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right)

, так что этот метод может эмулироваться следующим образом:


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

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.acosh |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.asinh()` 
Экспериментальная возможность
* `Math.atanh()` 
Экспериментальная возможность
* `Math.cosh()` 
Экспериментальная возможность
* `Math.sinh()` 
Экспериментальная возможность
* `Math.tanh()` 
Экспериментальная возможность
Math.SQRT1\_2
=============

Сводка
------

Свойство **`Math.SQRT1_2`** представляет квадратный корень из 1/2, приблизительно равный 0,707:


Math.SQRT1\_2

=

1
2

=

1

2

≈
0,707

\mathtt{\mi{Math.SQRT1\_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0,707



| Атрибуты свойства `Math.SQRT1_2` |
| --- |
| Записываемое | нет |
| Перечисляемое | нет |
| Настраиваемое | нет |

Описание
--------

Поскольку свойство `SQRT1_2` является статическим свойством объекта `Math`, вы всегда должны использовать его как `Math.SQRT1_2`, а не пытаться создавать экземпляр объекта `Math` и получать свойство от него (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование свойства `Math.SQRT1_2`

Следующая функция возвращает единицу, делённую на квадратный корень из двух:


```js
function getRoot1\_2() {
  return Math.SQRT1\_2;
}

getRoot1\_2(); // 0.7071067811865476
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt1\_2 |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.pow()`
* `Math.sqrt()`
Math.acos()
===========

Сводка
------

Метод **`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{такой, что} ; \cos(y) = x

Синтаксис
---------
```

Math.acos(x)
```

### Параметры

`x`

Число.

Описание
--------

Метод `Math.acos()` возвращает числовое значение между 0 и π радианами для значения `x`, лежащего в диапазоне от -1 до 1. Метод вернёт `NaN`, если значение `x` выйдет за этот диапазон.

Поскольку метод `acos()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.acos()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.acos()`


```js
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()` возвращает `NaN`.

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.acos |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.LOG10E
===========

Сводка
------

Свойство **`Math.LOG10E`** представляет десятичный логарифм из e, приблизительно равный 0,434:


Math.LOG10E

=

log
10

(
e
)
≈
0,434

\mathtt{\mi{Math.LOG10E}} = \log\_10(e) \approx 0,434



| Атрибуты свойства `Math.LOG10E` |
| --- |
| Записываемое | нет |
| Перечисляемое | нет |
| Настраиваемое | нет |

Описание
--------

Поскольку свойство `LOG10E` является статическим свойством объекта `Math`, вы всегда должны использовать его как `Math.LOG10E`, а не пытаться создавать экземпляр объекта `Math` и получать свойство от него (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование свойства `Math.LOG10E`

Следующая функция возвращает десятичный логарифм из e:


```js
function getLog10e() {
  return Math.LOG10E;
}

getLog10e(); // 0.4342944819032518
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log10e |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.exp()`
* `Math.log()`
* `Math.log10()` 
Экспериментальная возможность
Math.exp()
==========

Сводка
------

Метод **`Math.exp()`** возвращает значение выражения `ex`, где `x` — аргумент метода, а `e` — число Эйлера, основание натурального логарифма.

Синтаксис
---------
```

Math.exp(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `exp()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.exp()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.exp()`


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

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.exp |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.E`
* `Math.expm1()` 
Экспериментальная возможность
* `Math.log()`
* `Math.log10()` 
Экспериментальная возможность
* `Math.log1p()` 
Экспериментальная возможность
* `Math.log2()` 
Экспериментальная возможность
* `Math.pow()`
Math.cbrt()
===========

Сводка
------

Метод **`Math.cbrt()`** возвращает кубический корень числа, то есть



M
a
t
h
.
c
b
r
t
(
x
)

=

x
3

=
уникальный

y

такой, что

y
3

=
x

\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{уникальный} ; y ; \text{такой, что} ; y^3 = x


Синтаксис
```

Math.cbrt(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `cbrt()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.cbrt()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.cbrt()`


```js
Math.cbrt(-1); // -1
Math.cbrt(0); // 0
Math.cbrt(1); // 1

Math.cbrt(2); // 1.2599210498948734
```

Полифил
-------

Для всех 


x
≥
0

x \geq 0

, мы имеем 


x
3

=

x

1
/
3

\sqrt[3]{x} = x^{1/3}

, так что этот метод может эмулироваться следующим образом:


```js
Math.cbrt =
  Math.cbrt ||
  function (x) {
    if (x === 0 || x === +1 / 0 || x === -1 / 0 || x !== x) {
      return x;
    }
    var a = Math.abs(x);
    var y = Math.exp(Math.log(a) / 3);
    // from http://en.wikipedia.org/wiki/Cube\_root#Numerical\_methods
    return (x / a) \* (y + (a / (y \* y) - y) / 3);
  };
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.cbrt |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.pow()`
* `Math.sqrt()`
Math.imul()
===========

Сводка
------

Метод **`Math.imul()`** возвращает результат перемножения в стиле C двух 32-битных чисел.

Синтаксис
---------
```

Math.imul(a, b)
```

### Параметры

`a`

Первое число.

`b`

Второе число.

Описание
--------

Метод `Math.imul()` позволяет выполнять быстрое перемножение двух 32-битных чисел с семантикой C. Эта возможность полезна для таких проектов, как Emscripten. Поскольку метод `imul()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.imul()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.imul()`


```js
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
```

Полифил
-------

Этот метод может эмулироваться следующим способом:


```js
Math.imul =
  Math.imul ||
  function (a, b) {
    var ah = (a >>> 16) & 0xffff;
    var al = a & 0xffff;
    var bh = (b >>> 16) & 0xffff;
    var bl = b & 0xffff;
    // сдвиг на 0 бит закрепляет знак в старшей части числа
    // окончательный |0 преобразует беззнаковое значение обратно в знаковое значение
    return (al \* bl + (((ah \* bl + al \* bh) << 16) >>> 0)) | 0;
  };
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.imul |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.