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

**`Math.imul()`** 関数は、2 つの引数で C 言語風の 32 ビット乗算を行った結果を返します。

試してみましょう
--------

構文
--
```

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

### 引数

`a`

第一の数値。

`b`

第二の数値。

### 返値

与えられた引数で C 言語風の 32 ビット乗算を行った結果です。

解説
--

`Math.imul()` で C 言語と同様のの意味を持った 32 ビット乗算を行うことができます。この機能は Emscripten などのプロジェクトに有効です。

`imul()` は `Math` の静的メソッドなので、常に `Math.imul()` として使用し、自分で `Math` オブジェクトを生成してそのメソッドとして使用しないでください。 (`Math` にはコンストラクターがありません)。

通常の JavaScript の浮動小数点数を imul で使用すると、性能が低下します。これは、乗算のために浮動小数点から整数に変換し、乗算された整数を浮動小数点に変換するというコストのかかる作業があるからです。 imul が存在する理由は、 (今のところ) たった 1 つの状況では imul の方が高速だからです。それは AsmJS です。 AsmJS は JIST オプティマイザーが JavaScript で内部整数をより簡単に実装できるようにします。内部的に整数として格納されている 2 つの数値を imul で乗算すること (これは AsmJS でのみ可能です) は、 Math.imul が現在のブラウザーで性能を発揮する可能性がある唯一の潜在的な状況です。

例
-

### 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
if (!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;
    // the shift by 0 fixes the sign on the high part
    // the final |0 converts the unsigned value into a signed value
    return (aLo \* bLo + (((aHi \* bLo + aLo \* bHi) << 16) >>> 0)) | 0;
  };
```


しかし、このポリフィルが使われるであろうブラウザーは、 JavaScript の内部整数型で最適化されておらず、すべての数値に浮動小数点を使用している可能性が高いため、次の関数の方が性能が高くなります。


```js
if (!Math.imul)
  Math.imul = function (opA, opB) {
    opB |= 0; // ensure that opB is an integer. opA will automatically be coerced.
    // floating points give us 53 bits of precision to work with plus 1 sign bit
    // automatically handled for our convienence:
    // 1. 0x003fffff /\*opA & 0x000fffff\*/ \* 0x7fffffff /\*opB\*/ = 0x1fffff7fc00001
    // 0x1fffff7fc00001 < Number.MAX\_SAFE\_INTEGER /\*0x1fffffffffffff\*/
    var result = (opA & 0x003fffff) \* opB;
    // 2. We can remove an integer coersion from the statement above because:
    // 0x1fffff7fc00001 + 0xffc00000 = 0x1fffffff800001
    // 0x1fffffff800001 < Number.MAX\_SAFE\_INTEGER /\*0x1fffffffffffff\*/
    if (opA & 0xffc00000 /\*!== 0\*/) result += ((opA & 0xffc00000) \* opB) | 0;
    return result | 0;
  };
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* Emscripten
Math.random()
=============

**`Math.random()`** 関数は、 0 以上 1 未満 (0 は含むが、 1 は含まない) の範囲で浮動小数点の擬似乱数を返します。その範囲ではほぼ均一な分布で、ユーザーは範囲の拡大をすることができます。実装側で乱数生成アルゴリズムの初期シードを選択します。ユーザーが初期シードを選択、またはリセットすることは出来ません。

試してみましょう
--------

**メモ:** `Math.random()` の提供する乱数は、暗号に使用可能な安全性を備えて*いません*。セキュリティに関連する目的では使用しないでください。代わりに Web Crypto API (より具体的には `window.crypto.getRandomValues()` メソッド) を使用してください。

構文
--
```

Math.random()
```

### 返値

`0` (含む) から 1 (含まない) までの擬似乱数である浮動小数点数です。

例
-

JavaScript における数値は、IEEE 754 浮動小数点での round-to-nearest-even を行うため、以下の関数の値域が ( `Math.random()` 自体の値域が正しくても) 厳密ではないことに注意してください。非常に大きい境界値 (253 以上) のうち*極めて*稀な数値で、通常なら返されないはずの上限値が出力されてしまうことがあり得ます。

### 0 以上 1 未満の乱数を得る


```js
function getRandom() {
  return Math.random();
}
```

### 2 つの値の間の乱数を得る

この例は指定した値の間の乱数を返します。返値は `min` 以上、 `max` 未満です。


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

### 2 つの値の間のランダムな整数を得る

この例は指定した値の間のランダムな整数を返します。返値は `min` 以上 (`min` が整数でない場合、 `min` より大きい次の整数以上)、 `max` 未満です。


```js
function getRandomInt(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() \* (max - min) + min); //The maximum is exclusive and the minimum is inclusive
}
```


**メモ:** `Math.round()` を使う方が魅力的かもしれませんが、その場合は乱数が不均一な分布に従うことになるので、ユーザーのニーズに合わないかもしれません。

### 包括的に 2 つの値の間のランダムな整数を得る

上記の `getRandomInt()` 関数が返す乱数の範囲は `min` を含みますが、`max` は除外されます。 `min` も `max` も範囲に含まれた乱数を生成したいなら、以下の `getRandomIntInclusive()` 関数を使うといいでしょう。


```js
function getRandomIntInclusive(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() \* (max - min + 1) + min); //The maximum is inclusive and the minimum is inclusive
}
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `window.crypto.getRandomValues()`
Math.asin()
===========

**`Math.asin()`** 関数は、引数として与えた数値の逆正弦 (アークサイン) をラジアン単位で返します。



∀
x
∊
[

-
1

;
1
]
,

Math.asin
(
x
)

=
arcsin
(
x
)
=
 the unique 

y
∊

[

-

π
2

;

π
2

]

such that

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

試してみましょう
--------

構文
--
```

Math.asin(x)
```

### 引数

`x`

数値です。

### 返値

与えられた数値が **-1** から **1** までの場合、その逆正弦 (アークサイン) をラジアン単位で返します。さもなければ、 `NaN` を返します。

解説
--

`Math.asin()` メソッドは、 `-1` から `1` までの *x* に対して、 


-

π
2

-\frac{\pi}{2}

 から 


π
2

\frac{\pi}{2}

 までのラジアンの数値を返します。 *x* の値がこの範囲を越えている場合、このメソッドは `NaN` を返します。

`asin()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.asin()` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.asin() の使用


```js
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()` は `NaN` を返します。

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `Math.acos()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.abs()
==========

**`Math.abs()`** 関数は、数値の絶対値を返します。



Math.abs
(
x
)

=

|
x
|

=

{

x

if

x
>
0

0

if

x
=
0

-
x

if

x
<
0


{\mathtt{\operatorname{Math.abs}(z)}} = {|z|} = \begin{cases} x & \text{if} \quad x \geq 0 \ x & \text{if} \quad x < 0 \end{cases}

試してみましょう
--------

構文
--
```

Math.abs(x)
```

### 引数

`x`

数値です。

### 返値

与えられた数値の絶対値。

解説
--

`abs()` は `Math` オブジェクトの静的メソッドなので、 `Math` オブジェクトを生成してメソッドとして使用するのではなく、常に `Math.abs()` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.abs() の動作

空のオブジェクト、複数のメンバーを持つ配列、数値でない文字列、 `undefined`、 空の変数を渡すと、 `NaN` を返します。 `null` を渡すと空文字列を返し、空の配列は 0 を返します。


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

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Math.acos()
===========

**`Math.acos()`** 関数は、引数として与えた数値の逆余弦 (アークコサイン) をラジアン単位で返します。



∀
x
∊
[

-
1

;
1
]
,

Math.acos
(
x
)

=
arccos
(
x
)
=
 the unique 

y
∊
[
0
;
π
]

such that

cos
(
y
)
=
x

\forall x \in [{-1};1],;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } ; y \in [0; \pi] , \text{such that} ; \cos(y) = x

試してみましょう
--------

構文
--
```

Math.acos(x)
```

### 引数

`x`

コサインを表す数値で、 `x` は `-1` と `1` の間です。

### 返値

与えられた数値が `-1` から `1` までの場合、その逆余弦 (アークコサイン) をラジアン単位で返します。それ以外の場合は `NaN` を返します。

解説
--

`Math.acos()` メソッドは、-1 から 1 までの `x` に対して、0 から π までのラジアンの数値を返します。`x` の値がこの範囲を越えている場合、このメソッドは `NaN` を返します。

`acos()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.acos()` として使用するようにしてください (`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.fround()
=============

**`Math.fround()`** 関数は、ある `Number` を表す最も近い32ビット単精度浮動小数点数を返します。

試してみましょう
--------

構文
--
```

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

### 引数

`doubleFloat`

`Number`。この引数が異なる方であった場合は、数値に変換されるか、変換できなければ `NaN` になります。

### 返値

与えられた値を表す最も近い 32 ビット単精度浮動小数点数です。

解説
--

JavaScript は内部的に 64 ビットの倍精度浮動小数点数を使用しており、非常に高い精度を提供しています。しかし、例えば `Float32Array` から値を読み込む場合など 32 ビットの浮動小数点数を扱うことがあるかもしれません。これは混乱を招く可能性があります。 64 ビットの浮動小数点数と 32 ビットの浮動小数点数が等しいかどうかをチェックすると、一見同じように見える数値であっても失敗することがあります。

これを解決するには、 `Math.fround()` を使用して、 64 ビット浮動小数点数を 32 ビットの浮動小数点数にキャストすることができます。内部的には、 JavaScript は数値を 64 ビットの浮動小数点数として扱い続けますが、仮数の 23 番目のビットに「偶数への丸め」を実行し、それに続く仮数ビットをすべて 0 に設定します。数値が 32 ビットの浮動小数点数の範囲外の場合は、 `Infinity` または `-Infinity` が返されます。

`fround()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.fround()` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.fround() の使用

1.5 という数値は二進数で正確に表すことができ、32 ビットと 64 ビットとで同じになります。


```js
Math.fround(1.5); // 1.5
Math.fround(1.5) === 1.5; // true
```


しかし、 1.337 という数値は二進数では正確に表すことができず、32 ビットと 64 ビットとで異なります。


```js
Math.fround(1.337); // 1.3370000123977661
Math.fround(1.337) === 1.337; // false
```



2
150

2^150

 は 32 ビット浮動小数点では大きすぎるため、 `Infinity` が返されます。


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


引数が数値に変換できない場合、または非数 (`NaN`) であった場合、 `Math.fround()` は `NaN` を返します。


```js
Math.fround("abc"); // NaN
Math.fround(NaN); // NaN
```

ポリフィル
-----

これは `Float32Array` に対応している場合、次の関数でエミュレートできます。


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


古いブラウザーに対応するには、より遅いですが、次のものも利用できます。


```js
if (!Math.fround)
  Math.fround = function (arg) {
    arg = Number(arg);
    // Return early for ±0 and NaN.
    if (!arg) return arg;
    var sign = arg < 0 ? -1 : 1;
    if (sign < 0) arg = -arg;
    // Compute the exponent (8 bits, signed).
    var exp = Math.floor(Math.log(arg) / Math.LN2);
    var powexp = Math.pow(2, Math.max(-126, Math.min(exp, 127)));
    // Handle subnormals: leading digit is zero if exponent bits are all zero.
    var leading = exp < -127 ? 0 : 1;
    // Compute 23 bits of mantissa, inverted to round toward zero.
    var mantissa = Math.round((leading - arg / powexp) \* 0x800000);
    if (mantissa <= -0x800000) return sign \* Infinity;
    return sign \* powexp \* (leading - mantissa / 0x800000);
  };
```

仕様書
---

| 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.log10()
============

**`Math.log10()`** 静的メソッドは、数値の 10 を底とした対数を返します。すなわち次の値です。



∀
x
>
0
,

𝙼𝚊𝚝𝚑.𝚕𝚘𝚐𝟷𝟶
(
𝚡
)

=

log
10

(
x
)
=
the unique 
y
 such that 

10
y

=
x

\forall x > 0,;\mathtt{\operatorname{Math.log10}(x)} = \log\_{10}(x) = \text{the unique } y \text{ such that } 10^y = x

試してみましょう
--------

構文
--


```js
Math.log10(x)
```

### 引数

`x`

0 以上の数値です。

### 返値

`x` の 10 を底とした対数です。 `x < 0` であった場合、 `NaN` を返します。

解説
--

`log10()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.log10()` として使用するようにしてください（`Math` はコンストラクターではありません）。

この関数は `Math.log(x) / Math.log(10)` と同等です。 `log10(e)` には定数 `Math.LOG10E` を使用してください (これは 1 / `Math.LN10` です。)

例
-

### Math.log10() の使用


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

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `Math.log10` のポリフィル (`core-js`)
* `Math.exp()`
* `Math.log()`
* `Math.log1p()`
* `Math.log2()`
* `Math.pow()`
Math.acosh()
============

**`Math.acosh()`** 関数は、数値の双曲線余弦 (ハイパーボリックアークコサイン) を返します。



∀
x
≥
1
,

Math.acosh
(
x
)

=
arcosh
(
x
)
=
 the unique 

y
≥
0

such that

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

試してみましょう
--------

構文
--
```

Math.acosh(x)
```

### 引数

`x`

数値。

### 返値

与えられた数値の双曲線余弦 (ハイパーボリックアークコサイン) です。数値が **1** 未満であれば、 `NaN` になります。

解説
--

`acosh()` は `Math` の静的メソッドであるため、作成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.acosh()` として使用するようにしてください (`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.sin()
==========

**`Math.sin()`** 関数は、引数として与えた数の正弦 (サイン) を返します。

試してみましょう
--------

構文
--
```

Math.sin(x)
```

### 引数

`x`

数値 (ラジアンで指定)。

### 返値

指定された数値の正弦 (サイン) です。

解説
--

`Math.sin()` メソッドはラジアンで指定された角度の正弦 (サイン) を表す -1 から 1 までの範囲の数値を表します。

`sin()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.sin()` として使用するようにしてください (`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
)
=
the unique

y

such that

e
y

=
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)* と同等です。

試してみましょう
--------

構文
--
```

Math.log(x)
```

### 引数

`x`

数値です。

### 返値

(`e` を底とした) 与えられた数値の自然対数です。数値が負の数であった場合、 `NaN` が返されます。

解説
--

`x` の値が 0 であった場合、返値は常に `-Infinity` です。

`x` の値が 0 未満であった場合、返値は常に `NaN` です。

`log()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.log()` として使用するようにしてください (`Math` はコンストラクターではありません)。

2 または 10 の自然対数が必要な場合は、定数の `Math.LN2` または `Math.LN10` を使用してください。 2 や 10 を底とした対数が必要な場合は、 `Math.log2()` または `Math.log10()` を使用してください。他の数を底とした対数が必要な場合は、下記の例にあるように Math.log(x) / Math.log(otherBase) を使用してください。事前に 1 / Math.log(otherBase) を計算しておいた方がいいかもしれません。

例
-

### Math.log() の使用


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

### 様々な底による Math.log() の使用

以下の関数は、 `x` を底とした `y` の対数を返します (すなわち 


log
x

y

\log\_x y

)。


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


`getBaseLog(10, 1000)` を実行すると、実際の答えが 3 であるのに対し、浮動小数点の丸め処理により近似値の `2.9999999999999996` を返します。

仕様書
---

| 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.SQRT1\_2
=============

**`Math.SQRT2`** プロパティは、 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` オブジェクトを生成してプロパティとして使用するのではなく、常に `Math.SQRT1_2` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.SQRT1\_2 の使用

以下の関数は 1 を 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.cbrt()
===========

**`Math.cbrt()`** 関数は、引数として与えた数の立方根を返します。すなわち、



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

=

x
3

=
the unique

y

such that

y
3

=
x

\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} ; y ; \text{such that} ; y^3 = x

試してみましょう
--------

構文
--
```

Math.cbrt(x)
```

### 引数

*x*

数値。

### 返値

与えられた数値の立方根です。

解説
--

`cbrt()` は `Math` の静的なメソッドであるため、自ら生成した `Math` オブジェクトのメソッドとしてではなく、常に、 `Math.cbrt()` として使用してください (`Math` はコンストラクターではありません)。

ポリフィル
-----

すべての 


x
≥
0

x \geq 0

 に対して、 


x
3

=

x

1
/
3

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

 が存在し、次の関数でエミュレートできます:


```js
if (!Math.cbrt) {
  Math.cbrt = (function (pow) {
    return function cbrt(x) {
      // ensure negative numbers remain negative:
      return x < 0 ? -pow(-x, 1 / 3) : pow(x, 1 / 3);
    };
  })(Math.pow); // localize Math.pow to increase efficiency
}
```

例
-

### Math.cbrt() の使用


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

仕様書
---

| 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.pow()
==========

**`Math.pow()`** 関数は `base` を `exponent` 乗した値、つまり、`baseexponent` の値を返します。

試してみましょう
--------

構文
--
```

Math.pow(base, exponent)
```

### 引数

`base`

底となる数です。

`exponent`

`base` を累乗する指数です。

### 返値

指定された低を指定された指数だけ累乗したものを表す数値です。

解説
--

**`Math.pow()`** 関数は `base` の `exponent` 乗、すなわち `baseexponent` を返します。 `base` と `exponent` は 10 進数の数値です。

`pow()` は `Math` の静的メソッドなので、常に `Math.pow()` として使用し、自分で `Math` オブジェクトを生成してそのメソッドとして使用しないでください。 (`Math` にはコンストラクターがありません)。

例
-

### Math.pow() の使用


```js
// 単純
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 (2乗は正の数)
Math.pow(-7, 3); // -343 (3乗は負の数)
Math.pow(-7, 0.5); // NaN (負の数には実数の平方根がない)
// due to "even" and "odd" roots laying close to each other,
// and limits in the floating number precision,
// negative bases with fractional exponents always return NaN
Math.pow(-7, 1 / 3); // NaN
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `Math.cbrt()`
* `Math.exp()`
* `Math.log()`
* `Math.sqrt()`
* べき乗演算子
Math.E
======

**`Math.E`** プロパティはオイラー定数である、自然対数の底 (e)、約 2.718 を表します。

試してみましょう
--------

値
-


𝙼𝚊𝚝𝚑.𝙴
=
e
≈
2.718

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



| `Math.E` のプロパティ属性 |
| --- |
| 書込可能 | 不可 |
| 列挙可能 | 不可 |
| 設定可能 | 不可 |

解説
--

`E` は `Math` オブジェクトの静的プロパティなので、`Math` オブジェクトを生成してプロパティとして使用するのではなく、常に `Math.E` として使用するようにしてください（`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.LOG10E
===========

**`Math.LOG10E`** は静的データプロパティで、 10 を底とした e の対数、約 0.434 を表します。

試してみましょう
--------

値
-


𝙼𝚊𝚝𝚑.𝙻𝙾𝙶𝟷𝟶𝙴
=

log
10

(
e
)
≈
0.434

\mathtt{\mi{Math.LOG10E}} = \log\_{10}(\mathrm{e}) \approx 0.434



| `Math.LOG10E` のプロパティ属性 |
| --- |
| 書込可能 | 不可 |
| 列挙可能 | 不可 |
| 設定可能 | 不可 |

解説
--

`LOG10E` は `Math` オブジェクトの静的プロパティなので、自分で作成した `Math` オブジェクトのプロパティとして使用するのではなく、常に `Math.LOG10E` として使用するようにしてください（`Math` はコンストラクターではありません）。

例
-

### Math.LOG10E の使用

以下の関数は、10 を底とした 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.round()
============

**`Math.round()`** 関数は、引数として与えた数を四捨五入して、もっとも近似の整数を返します。

試してみましょう
--------

構文
--
```

Math.round(x)
```

### 引数

`x`

数値

### 返値

与えられた値をもっとも近似の整数に四捨五入した値。

解説
--

引数の小数部分が 0.5 以上の場合、その引数は、次に大きい整数に切り上げられます。引数の小数部分が 0.5 未満の場合、その引数は、次に小さい整数に切り下げられます。小数部分が 0.5 である場合は、正の無限大の方向で次の整数に丸められます。**これは多くの言語の `round()` 関数と異なることに注意してください。この場合はたいてい、*0 から遠ざかる*次の整数に丸められます** (小数部分が 0.5 である負の値を四捨五入する場合に、結果が変わります)。

`round()` は `Math` オブジェクトの静的なメソッドなので、自ら生成した `Math` オブジェクトのメソッドとしてではなく、常に、`Math.round()` として使用するようにしてください (`Math` のコンストラクターはありません)。

例
-

### round の使用


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

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `Number.toPrecision()`
* `Number.toFixed()`
* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.sign()`
* `Math.trunc()`
Math.tan()
==========

**`Math.tan()`** 関数は、数値のタンジェントを返します。

試してみましょう
--------

構文
--
```

Math.tan(x)
```

### 引数

`x`

数値です。

### 返値

与えられた数値のタンジェントです。

解説
--

`Math.tan()` メソッドは、ある角度のタンジェントを表す数値を返します。

`tan()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.tan()` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.tan() の使用


```js
Math.tan(1); // 1.5574077246549023
```


`Math.tan()` 関数はラジアンを受け付けますが、角度で使用したほうが簡単な場合が多いので、次の関数は角度の値を受け付け、それをラジアンに変換してタンジェントを返します。


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

仕様書
---

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

ブラウザーの互換性
---------

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.sin()`
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` オブジェクトを生成してプロパティとして使用するのではなく、常に `Math.LN10` として使用するようにしてください (`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()`