recursal/MDN huggingface dataset:
Math.SQRT2
==========

**`Math.SQRT2`** プロパティは、 2 の平方根、約 1.414 を表します。


Math.SQRT2

=

2

≈
1.414

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

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

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

解説
--

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

例
-

### Math.SQRT2 の使用

以下の関数は 2 の平方根を返します。


```js
function getRoot2() {
  return Math.SQRT2;
}

getRoot2(); // 1.4142135623730951
```

仕様書
---

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

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

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

関連情報
----

* `Math.pow()`
* `Math.sqrt()`
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, ...`

数値です。

### 返値

与えられた各引数の二乗の合計値の平方根を返します。1 つ上の引数が数値に変換できなかった場合は、 `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, ...)` を呼び出すだけです。

`Math.hypot` はまた、数値が非常に大きい場合のオーバーフロー/アンダーフローの問題を回避します。 JS で表現できる最大の数は `Number.MAX_VALUE` で、これは約 10308 です。数字の大きさが約 10154 よりも大きい場合、その 2 乗を取ると無限大になります。例えば、 `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 になります。引数のいずれかが ±Infinity であった場合、結果は Infinity になります。引数のいずれかが NaN であった場合は (他に ±Infinity の引数がない限り)、結果は NaN になります。数値に変換できない引数があった場合は、結果は `NaN` になります。

引数が 1 つの場合、 `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(NaN, Infinity); // Infinity
Math.hypot(3, 4, "foo"); // NaN, since +'foo' => NaN
Math.hypot(3, 4, "5"); // 7.0710678118654755, +'5' => 5
Math.hypot(-3); // 3, the same as Math.abs(-3)
```

ポリフィル
-----

オーバーフロー/アンダーフローの問題を処理しないナイーブなアプローチです。


```js
if (!Math.hypot)
  Math.hypot = function () {
    var y = 0,
      i = arguments.length,
      containsInfinity = false;
    while (i--) {
      var arg = arguments[i];
      if (arg === Infinity || arg === -Infinity) containsInfinity = true;
      y += arg \* arg;
    }
    return containsInfinity ? Infinity : Math.sqrt(y);
  };
```


アンダーフローやオーバーフローを回避するポリフィルです。


```js
if (!Math.hypot)
  Math.hypot = function () {
    var max = 0;
    var s = 0;
    var containsInfinity = false;
    for (var i = 0; i < arguments.length; ++i) {
      var arg = Math.abs(Number(arguments[i]));
      if (arg === Infinity) containsInfinity = true;
      if (arg > max) {
        s \*= (max / arg) \* (max / arg);
        max = arg;
      }
      s += arg === 0 && max === 0 ? 0 : (arg / max) \* (arg / max);
    }
    return containsInfinity
      ? Infinity
      : max === 1 / 0
        ? 1 / 0
        : max \* Math.sqrt(s);
  };
```

仕様書
---

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

**`Math.log1p()`** 関数は、 1 + 数値の (`e` を底とする) 自然対数を返します。



∀
x
>
-
1
,

Math.log1p
(
x
)

=
ln
(
1
+
x
)

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

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

構文
--
```

Math.log1p(x)
```

### 引数

`x`

数値です。

### 返値

1 + 与えられた数値の (`e` を底とした) 自然対数です。数値が **-1** よりも小さかった場合は `NaN` が返されます。

解説
--

`x` の値が非常に小さかった場合、 1 を加えると有効精度が減少します。 JS で使用する倍精度浮動小数点型の精度は 15 桁です。 1 + 1e-15 = 1.000000000000001 ですが、 1 + 1e-16 = 1.000000000000000 となり、 15 桁を超えた桁は四捨五入されるため、正確に 1.0 となります。

log(1 + x) を計算すると、 x が小さければ、 x にとても近い答えになるはずです (これが「自然」対数と呼ばれる所以です)。 Math.log(1 + 1.1111111111e-15) を計算すると、 1.1111111111e-15 に近い答えが得られるはずです。しかし、 1.00000000000000111022 の対数を取ることになります (四捨五入は二進数なので、時に醜い結果になることがあります) ので、答えは 1.11022...e-15 となり、正しい数字は 3 桁だけです。もし、代わりに Math.log1p(1.1111111111e-15) を計算した場合は、もっとずっと正確な答えである 1.1111111110999995e-15 が得られ、 15 桁の正しい数字が得られます (この場合は実際には 16 桁です)。

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

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

ポリフィル
-----

これは次の関数でエミュレートできます。


```js
Math.log1p =
  Math.log1p ||
  function (x) {
    x = Number(x);
    if (x < -1 || x !== x) return NaN;
    if (x === 0 || x === Infinity) return x;

    var nearX = x + 1 - 1;

    return nearX === 0 ? x : x \* (Math.log(x + 1) / nearX);
  };
```

例
-

### Math.log1p() の使用


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

仕様書
---

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

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

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

関連情報
----

* `Math.exp()`
* `Math.log()`
* `Math.expm1()`
* `Math.log10()`
* `Math.log2()`
* `Math.pow()`
Math.exp()
==========

**`Math.exp()`** 関数は `ex` (`x` は引数、 `e` はオイラー数 (ネイピア定数とも)、自然対数の底) を返します。

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

構文
--
```

Math.exp(x)
```

### 引数

`x`

数値です。

### 返値

`ex` (`e` はオイラー数、 `x` は引数) を表す数値です。

解説
--

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

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



Math.asinh
(
x
)

=
arsinh
(
x
)
=
 the unique 

y

such that

sinh
(
y
)
=
x

\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } ; y ; \text{such that} ; \sinh(y) = x

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

構文
--
```

Math.asinh(x)
```

### 引数

`x`

数値

### 返値

与えられた数値の双曲線逆正弦 (ハイパーボリックアークサイン) です。

解説
--

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

例
-

### Math.asinh() の使用


```js
Math.asinh(1); // 0.881373587019543
Math.asinh(0); // 0
```

ポリフィル
-----

`Math.asinh` は、次の関数でエミュレートできます。


```js
if (!Math.asinh)
  Math.asinh = function (x) {
    var absX = Math.abs(x),
      w;
    if (absX < 3.725290298461914e-9)
      // |x| < 2^-28
      return x;
    if (absX > 268435456)
      // |x| > 2^28
      w = Math.log(absX) + Math.LN2;
    else if (absX > 2)
      // 2^28 >= |x| > 2
      w = Math.log(2 \* absX + 1 / (Math.sqrt(x \* x + 1) + absX));
    else
      var t = x \* x,
        w = Math.log1p(absX + t / (1 + Math.sqrt(1 + t)));

    return x > 0 ? w : -w;
  };
```


`Math.log1p` にもポリフィルを適用する必要があるかもしれません。詳しくは Math.log1p を参照してください。

仕様書
---

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

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

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

関連情報
----

* `Math.acosh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.sinh()`
* `Math.tanh()`
Math.PI
=======

**`Math.PI`** プロパティは、円周と直径の比率、およそ 3.14159 を表します。


Math.PI

=
π
≈
3.14159

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

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

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

解説
--

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

例
-

### Math.PI の使用

次の関数は `Math.PI` を使用して、指定された半径を持つ円の円周を計算します。


```js
function calculateCircumference(radius) {
  return Math.PI \* (radius + radius);
}

calculateCircumference(1); // 6.283185307179586
```

仕様書
---

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

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

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

関連情報
----

* `Math`
Math.expm1()
============

**`Math.expm1()`** 関数は `ex - 1` (`x` は引数、 e は自然対数の底) を返します。

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

構文
--
```

Math.expm1(x)
```

### 引数

`x`

数値です。

### 返値

`ex - 1` (`e` はオイラー数、 `x` は引数) を表す数値です。

解説
--

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

y

such that

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

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

構文
--
```

Math.atanh(x)
```

### 引数

`x`

数値。

### 返値

与えられた数値の双曲線逆正接 (ハイパーボリックアークタンジェント) です。

解説
--

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

**`Math.sign()`** 関数は、引数として渡された数値の符号が**正**か**負**かを表す +/- 1 を返します。 `Math.sign()` に渡された数が 0 であれば、 +/- 0 を返します。なお、数値が正である場合、明示的な (+) は返され**ません**。

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

構文
--
```

Math.sign(x)
```

### 引数

`x`

数値です。引数が `number` ではない場合は、暗黙に変換されます。

### 返値

与えられた引数の符号を表す数値です。

* 引数が正の値の場合は、 `1` を返します。
* 引数が負の値の場合は、 `-1` を返します。
* 引数が正のゼロの場合は、 `0` を返します。
* 引数が負のゼロの場合は、 `-0` を返します。
* それ以外は `NaN` を返します。
解説
--

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

ポリフィル
-----


```js
if (!Math.sign) {
  Math.sign = function (x) {
    // If x is NaN, the result is NaN.
    // If x is -0, the result is -0.
    // If x is +0, the result is +0.
    // If x is negative and not -0, the result is -1.
    // If x is positive and not +0, the result is +1.
    return (x > 0) - (x < 0) || +x;
    // A more aesthetic pseudo-representation:
    //
    // ( (x > 0) ? 1 : 0 ) // if x is positive, then positive one
    // + // else (because you can't be both - and +)
    // ( (x < 0) ? -1 : 0 ) // if x is negative, then negative one
    // || // if x is 0, -0, or NaN, or not a number,
    // +x // then the result will be x, (or) if x is
    // // not a number, then x converts to number
  };
}
```


上記のポリフィルでは `(x > 0)` と `(x < 0)` の数値を互いに減算することで、真偽値から数値型へ強制的に型変換されるため、追加の型強制は必要ありません。

例
-

### Math.sign() の使用


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

仕様書
---

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

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

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

関連情報
----

* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.trunc()`
Math.sinh()
===========

**`Math.sinh()`** 関数は、引数として与えた数の双曲線正弦 (ハイパーボリックサイン) を返します。これは定数 e を使用して次のように表すことができます。


Math.sinh(x)

=

e
x

-

e

-
x

2

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

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

構文
--
```

Math.sinh(x)
```

### 引数

`x`

数値。

### 返値

指定された数値の双曲線正弦 (ハイパーボリックサイン) です。

解説
--

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

ポリフィル
-----

これは `Math.exp()` 関数を使用して次のようにエミュレートできます。


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


または `Math.exp()` 関数を一度だけ呼び出すようにすると、次のようになります。


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

例
-

### Using Math.sinh() の使用


```js
Math.sinh(0); // 0
Math.sinh(1); // 1.1752011936438014
```

仕様書
---

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

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

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

関連情報
----

* `Math.acosh()`
* `Math.asinh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.tanh()`
Math.log2()
===========

**`Math.log2()`** 関数は、数値の 2 を底とした対数を返します。



∀
x
>
0
,

Math.log2
(
x
)

=

log
2

(
x
)
=
the unique

y

such that

2
y

=
x

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

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

構文
--
```

Math.log2(x)
```

### 引数

`x`

数値です。

### 返値

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

解説
--

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

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

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

ポリフィル
-----

このポリフィルは `Math.log2` 関数をエミュレートします。なお、これは入力値によっては不正確な値を返すので (1 << 29 など)、ビットマスクで使用するときは `Math.round()` で囲んでください。


```js
if (!Math.log2)
  Math.log2 = function (x) {
    return Math.log(x) \* Math.LOG2E;
  };
```

例
-

### Math.log2() の使用


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

仕様書
---

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

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

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

関連情報
----

* `Math.exp()`
* `Math.log()`
* `Math.log10()`
* `Math.log1p()`
* `Math.pow()`
Math.atan2()
============

**`Math.atan2()`** 関数は、`Math.atan2(y, x)` に対して点 (0, 0) から点 (x, y) までの半直線と、正の x 軸の間の平面上での角度 (ラジアン単位) を返します。

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

構文
--
```

Math.atan2(y, x)
```

### 引数

`y`

点の y 座標です。

`x`

点の x 座標です。

### 返値

点 (0, 0) から点 


(x,y)

 までの半直線と、正の x 軸の間の (


[
-
π
,
π
]

[-\pi, \pi]

 内の) ラジアン単位の角度です。

解説
--

`Math.atan2()` メソッドは、`(x, y)` 座標のシータ角を表す -π から π までの数値を返します。これは、ラジアン単位で表された、正の X 軸と点 `(x, y)` の間の反時計回りの角度です。このメソッドへ渡す引数は、初めに y 座標、次に x 座標であることに注意してください。

![A simple diagram showing the angle returned by atan2(y, x)](/ja/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2/atan2.png)

`Math.atan2()` は、`x` と `y` が別々に渡され、 `Math.atan()` は 2 つの引数の比率が渡されます。

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

例
-

### Math.atan2() の使用


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

仕様書
---

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

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

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

関連情報
----

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.trunc()
============

**`Math.trunc()`** 関数は、引数として与えた数の小数部の桁を取り除くことによって整数部を返します。

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

構文
--


```js
Math.trunc(x)
```

### 引数

`x`

数値。

### 返値

`x` の整数部です。

解説
--

他の 3 つの `Math` メソッド、`Math.floor()`、`Math.ceil()`、`Math.round()` とは異なり、 `Math.trunc()` の動作は非常にシンプルで分かりやすいです。引数が正の数または負の数であるかに関わらず、ただ小数点とそれ以降にある数字を*切り捨て*ます。

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

例
-

### Math.trunc() の使用


```js
Math.trunc(-Infinity); // -Infinity
Math.trunc("-1.123"); // -1
Math.trunc(-0.123); // -0
Math.trunc(-0); // -0
Math.trunc(0); // 0
Math.trunc(0.123); // 0
Math.trunc(13.37); // 13
Math.trunc(42.84); // 42
Math.trunc(Infinity); // Infinity
```

### ビット単位の no-op を使った数値の切り捨て

**警告:** 無視できないエッジケースがあるため、これは `Math.trunc()` のポリフィルにはなりません。

ビット演算はオペランドを 32 ビット整数に変換します。一般的なテクニックは以下の通りです。


```js
const original = 3.14;
const truncated1 = ~~original; // 二重否定
const truncated2 = original & -1; // Bitwise AND with -1
const truncated3 = original | 0; // Bitwise OR with 0
const truncated4 = original ^ 0; // Bitwise XOR with 0
const truncated5 = original >> 0; // Bitwise shifting by 0
```


これは本質的に `toInt32` であり、 `Math.trunc` とは異なることに注意してください。値が -231 - 1 < `value` < 231 (-2147483649 < `value` < 2147483648) を満たさない場合、変換がオーバーフローしてしまいます。


```js
const a = ~~2147483648; // -2147483648
const b = ~~-2147483649; // 2147483647
const c = ~~4294967296; // 0
```


`Math.trunc()` の代用として `~~` を使うのは、入力の範囲が 32 ビット整数の範囲に収まっていると確信できる場合だけにしてください。

仕様書
---

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

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

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

関連情報
----

* `Math.trunc` のポリフィル (`core-js`)
* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
Math.ceil()
===========

**`Math.ceil()`** 関数は、引数として与えた数以上の最小の整数を返します。

**注:** `Math.ceil(`null`)` は整数の 0 を返し、 `NaN` エラーは返しません。

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

構文
--
```

Math.ceil(x)
```

### 引数

`x`

数値。

### 返値

引数として与えた数以上の最小の整数を返します。

解説
--

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

例
-

### Math.ceil() の使用

以下の例は、`Math.ceil()` を使用した例です。


```js
Math.ceil(0.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
```

### 10 進補正 (Decimal adjustment)


```js
// 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;
    }
    // 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
// 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
```

仕様書
---

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

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

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

関連情報
----

* `Math.abs()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`