recursal/MDN huggingface dataset:
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


시도해보기
-----

구문
--


```js
Math.acos(x);
```

### 매개변수

`x`

각도를 나타내는 라디안.

### 반환 값

-1과 1 사이의 값이 주어진 경우, 그 값의 아크코사인. 아닐 경우 `NaN`

설명
--

The `Math.acos()` method returns a numeric value between 0 and π radians for `x` between -1 and 1. If the value of `x` is outside this range, it returns `NaN`.

Because `acos()` is a static method of `Math`, you always use it as `Math.acos()`, rather than as a method of a `Math` object you created (`Math` is not a constructor).

예제
--

### Using `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
```


For values less than -1 or greater than 1, `Math.acos()` returns `NaN`.

명세
--

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

브라우저 호환성
--------

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

See also
--------

* `Math.asin()` (en-US)
* `Math.atan()` (en-US)
* `Math.atan2()` (en-US)
* `Math.cos()` (en-US)
* `Math.sin()`
* `Math.tan()`
Math.LN2
========

The **`Math.LN2`** property represents the natural logarithm of 2, approximately 0.693:

**`Math.LN2`** 속성은 2의 자연로그 값, 약 0.693의 값을 가집니다.


Math.LN2

=
ln
(
2
)
≈
0.693

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

시도해보기
-----

| Property attributes of `Math.LN2` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`LN2`는 `Math`의 정적 속성이므로, 사용자가 생성한 `Math` 객체의 속성으로 접근할 수 없고 항상 `Math.LN2`를 사용해야 합니다. (`Math`는 생성자가 아닙니다)

Examples
--------

### `Math.LN2` 사용하기

다음 함수는 2의 자연 로그 값을 반환합니다.


```js
function getNatLog2() {
  return Math.LN2;
}

getNatLog2(); // 0.6931471805599453
```

명세
--

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

브라우저 호환성
--------

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

같이 보기
-----

* `Math.exp()`
* `Math.log()`
* `Math.log2()`
Math.SQRT1\_2
=============

**`Math.SQRT1_2`** 프로퍼티는 약 0.707의 값을 나타내는 루트 1/2을 나타냅니다:


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

시도해보기
-----

| Property attributes of `Math.SQRT1_2` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`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.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)`와 동일합니다. `log(e)`의 경우, 1 / `Math.LN10`인 상수 `Math.LOG10E`를 사용합니다.

예제
--

### 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.

같이 보기
-----

* `core-js`에서 `Math.log10`의 폴리필
* `Math.exp()`
* `Math.log()`
* `Math.log1p()` (en-US)
* `Math.log2()`
* `Math.pow()`
Math.acosh()
============

**`Math.acosh()`** 정적 메서드는 숫자의 역 쌍곡선 코사인를 반환합니다. 아래와 같습니다.



∀
x
≥
1
,

𝙼𝚊𝚝𝚑.𝚊𝚌𝚘𝚜𝚑
(
𝚡
)

=
arcosh
(
x
)
=
the unique 
y
≥
0
 such that 
cosh
(
y
)
=
x


=
ln

(

x
+

x
2

−
1

)

\begin{aligned}\forall x \geq 1,;\mathtt{\operatorname{Math.acosh}(x)} &= \operatorname{arcosh}(x) = \text{the unique } y \geq 0 \text{ such that } \cosh(y) = x\&= \ln\left(x + \sqrt{x^2 - 1}\right)\end{aligned}

시도해보기
-----

구문
--


```js
Math.acosh(x)
```

### 매개변수

`x`

1보다 크거나 같은 숫자.

### 반환 값

`x`의 역 쌍곡선 코사인. `x`가 1보다 작으면 `NaN`를 반환합니다.

설명
--

`acosh()`는 `Math`의 정적 메서드이기 때문에, 생성한 `Math` 객체 메서드보다 `Math.acosh()`를 항상 사용합니다 (`Math`는 생성자가 아닙니다).

예제
--

### Math.acosh() 사용


```js
Math.acosh(0); // NaN
Math.acosh(1); // 0
Math.acosh(2); // 1.3169578969248166
Math.acosh(Infinity); // Infinity
```

명세서
---

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

브라우저 호환성
--------

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

같이 보기
-----

* `core-js`의 `Math.acosh`의 폴리필
* `Math.asinh()` (en-US)
* `Math.atanh()` (en-US)
* `Math.cosh()` (en-US)
* `Math.sinh()`
* `Math.tanh()`
Math.exp()
==========

\*\*`Math.exp()`\*\*함수는 `x`를 인수로 하는 `e^x` 값을 반환합니다. 그리고 `e`는 오일러 상수(또는 네이피어 상수)는 자연 로그의 밑입니다.

시도해보기
-----

구문
--


```js
Math.exp(x);
```

### 매개변수

`x`

숫자

### 반환 값

`e`는 오일러 상수이고 `x`는 인수인 `e^x`값

Description
-----------

`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()` (en-US)
* `Math.log()`
* `Math.log10()`
* `Math.log1p()` (en-US)
* `Math.log2()`
* `Math.pow()`
Math.sqrt()
===========

**`Math.sqrt()`** 함수는 숫자의 제곱근을 반환합니다.



∀
x
≥
0
,

M
a
t
h
.
s
q
r
t
(
x
)

=

x

=
the unique

y
≥
0

such that

y
2

=
x

\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} ; y \geq 0 ; \text{such that} ; y^2 = x

문법
--


```js
Math.sqrt(x);
```

### 매개변수

`x`

숫자.

### 반환 값

주어진 숫자에 루트(**√** )를 씌웁니다. 만약 숫자가 음수이면 `NaN`를 반환합니다.

설명
--

만약 `x` 가 음수라면 `Math.sqrt()` 함수는 `NaN`를 반환합니다.

`sqrt()`는 `Math`의 정적 메서드 이므로 만든 `Math` 객체의 메서드가 아니라 항상 `Math.sqrt()`함수를 사용해야합니다. (`Math`는 생성자가 없습니다.)

예제
--

### `Math.sqrt()`


```js
Math.sqrt(9); // 3
Math.sqrt(2); // 1.414213562373095

Math.sqrt(1); // 1
Math.sqrt(0); // 0
Math.sqrt(-1); // NaN
```

명세서
---

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

브라우저 호환성
--------

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

참조
--

* `Math.cbrt()`
* `Math.exp()`
* `Math.log()`
* `Math.pow()`
Math.round()
============

**`Math.round()`** 함수는 입력값을 반올림한 수와 가장 가까운 정수 값을 반환합니다.

시도해보기
-----

문법
--


```js
Math.round(x);
```

### 매개 변수

`x`

수

### 반환 값

입력값을 반올림한 값과 가장 가까운 정수를 의미합니다.

Description
-----------

If the fractional portion of the argument is greater than 0.5, the argument is rounded to the integer with the next higher absolute value. If it is less than 0.5, the argument is rounded to the integer with the lower absolute value. If the fractional portion is exactly 0.5, the argument is rounded to the next integer in the direction of +∞. **Note that this differs from many languages' `round()` functions, which often round this case to the next integer *away from zero***, instead giving a different result in the case of negative numbers with a fractional part of exactly 0.5.

Because `round()` is a static method of `Math`, you always use it as `Math.round()`, rather than as a method of a `Math` object you created (`Math` has no constructor).

Examples
--------


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

See also
--------

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

**`Math.imul()`** 함수는 C 언어와 같은 양식으로 2개 파라메터의 32-bit 곱셈 결과를 리턴합니다.

문법
--


```js
Math.imul(a, b);
```

### 파라메터

`a`

첫 번째 숫자.

`b`

두 번째 숫자.

설명
--

`Math.imul()` 를 쓰면 C 언어와 같은 양식의 빠른 32-bit 정수 곱셈이 가능합니다. 이 기능은 Emscripten 같은 프로젝트에 유용합니다. `imul()` 이 `Math` 객체의 정적 메소드이기 때문에, `Math 객체를 직접 만들어서 사용하지 않고 (Math 는 생성자가 아닙니다), 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
```

Polyfill
--------

다음과 같은 함수로 Math.imul() 을 흉내낼 수 있습니다.


```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;
    // the shift by 0 fixes the sign on the high part
    // the final |0 converts the unsigned value into a signed value
    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.
Math.E
======

**`Math.E`** 속성은 자연로그의 밑 값 e를 나타내며 약 2.718의 값을 가집니다.


Math.E

=
e
≈
2.718

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

시도해보기
-----

| Property attributes of `Math.E` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`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()` (en-US)
Math.SQRT2
==========

**`Math.SQRT2`** 는 2의 제곱근을 나타내고 약 1.414 입니다:


Math.SQRT2

=

2

≈
1.414

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



| Property attributes of `Math.SQRT2` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

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

**`Math.log2()`** 함수는 숫자를 log2(숫자)로 반환합니다.



∀
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


시도해보기
-----

문법
--


```js
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.log2`의 폴리 필은
 `core-js`에 존재합니다.
* `Math.exp()`
* `Math.log()`
* `Math.log10()`
* `Math.log1p()` (en-US)
* `Math.pow()`
Math.fround()
=============

**`Math.fround()`** 함수는 single precision 포맷으로 표현할 수 있는 실수들 중에서 가장 가까운 숫자를 리턴합니다.

문법
--


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

Polyfill
--------

만약 `Float32Array` 가 지원된다면, Math.fround() 를 다음 함수로 흉내낼 수 있습니다.


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

명세
--

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

브라우저 호환성
--------

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

See also
--------

* `Math.round()`
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{고유값} ; y ; \text{같이} ; e^y = x


JavaScript **`Math.log()`** 함수는 *ln(x)* 수학적으로 같습니다.

문법
--


```js
Math.log(x);
```

### 인자

`x`

실수값.

### 반환값

자연 로가리즘은 (`e` 를 기초) 실수값으로 줍니다. 마이너스 실수값, `NaN` 계산됩니다.

설명
--

만일 값 `x` 가 마이너스라면, 항상 다음값이 계산됩니다 `NaN`.

왜그렇냐면 `Math` 의 log() 가 정적 메서드이기 때문,에 매번 다음처럼 `Math.log()` 써야합니다 (생성자로 초기화된 `Math` 개체가 아니기 때문입니다).

자연로그 2 나 10, 상수로쓸때 `Math.LN2` or `Math.LN10` . 로가리즘 기초값 2 나 10, 쓸때는 `Math.log2()` 혹은 `Math.log10()` . 로가리즘 다른 기초값은 Math.log(x) / Math.log(기초값) 처럼 예제참고; 미리계산하여 1 / Math.log(기초값) 할 수 있습니다.

예제
--

### `Math.log() 사용`


```js
Math.log(-1); // NaN, 정의범위 초과
Math.log(0); // -Infinity, 무한
Math.log(1); // 0
Math.log(10); // 2.302585092994046
```

### `Math.log()` 다른 기초값 사용

이 함수는 로가리즘 `y 에 대한것으로` 기초값 `x` (ie. 


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()` (en-US)
* `Math.log10()`
* `Math.log2()`
* `Math.pow()`
Math.sin()
==========

**`Math.sin()`** 함수는 숫자의 사인값을 반환합니다.

시도해보기
-----

Syntax
------


```js
Math.sin(x);
```

### 파라미터

`x`

숫자 (라디안으로 주어짐).

### 반환 값

주어진 숫자의 사인 값

설명
--

`Math.sin()` 메소드는 라디안으로 주어진 각도의 사인 값인 -1과 1 사이의 수를 반환합니다.

`sin()` 은 `Math`의 스태틱 메소드이기 때문에, `Math` 오브젝트 의 메소드로 사용하지 말고 항상 `Math.sin()`로 사용해야합니다. (`Math` 는 생성자가 아닙니다).

예
-

### Using `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()` (en-US)
* `Math.atan()` (en-US)
* `Math.atan2()` (en-US)
* `Math.cos()` (en-US)
* `Math.tan()`
Math.sinh()
===========

**`Math.sinh()`** 함수(쌍곡선 함수)는 사인값을 반환합니다 이 값은 아래와같은 식을통해서 표현할 수 있습니다.constant e:


Math.sinh(x)

=

e
x

-

e

-
x

2

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

시도해보기
-----

구문
--


```js
Math.sinh(x);
```

### Parameters

`x`

숫자.

### 반환 값

사인값.

설명
--

`sinh()` 는 `Math` 의 정적 함수이기 때문에, JavaScript 어디든 `Math.sinh()` 를 사용할 수 있습니다, 따라서 `Math` 오브젝트를 생성해서는 안됩니다. (`Math` 는 constructor(생성자) 가 아닙니다.).

예제
--

### `Math.sinh()` 사용하기


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

폴리필
---

This can be emulated with the help of the `Math.exp()` function:


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


or using only one call to the `Math.exp()` function:


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

명세서
---

| 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()` (en-US)
* `Math.atanh()` (en-US)
* `Math.cosh()` (en-US)
* `Math.tanh()`
Math.LOG10E
===========

**`Math.LOG10E`** 속성은 e의 로그 10 값, 약 0.434의 값을 가집니다.


Math.LOG10E

=

log
10

(
e
)
≈
0.434

\mathtt{\mi{Math.LOG10E}} = \log\_10(e) \approx 0.434

시도해보기
-----

| Property attributes of `Math.LOG10E` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`LOG10E`는 `Math`의 정적 속성이므로, 사용자가 생성한 `Math` 객체의 속성으로 접근할 수 없고 항상 `Math.LOG10E`를 사용해야 합니다. (`Math`는 생성자가 아닙니다)

예제
--

### `Math.LOG10E` 사용하기

다음 함수는 e의 로그 10 값을 반환합니다.


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

**`Math.tan()`** 함수는 탄젠트 값을 반환합니다

시도해보기
-----

문법
--


```js
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()` (en-US)
* `Math.atan()` (en-US)
* `Math.atan2()` (en-US)
* `Math.cos()` (en-US)
* `Math.sin()`
Math.tanh()
===========

**`Math.tanh()`** 함수는 쌍곡탄젠트 값을 반환합니다. 수식으로는 아래와 같습니다.



tanh
x
=

sinh
x

cosh
x

=

e
x

-

e

-
x


e
x

+

e

-
x

=

e

2
x

-
1

e

2
x

+
1

\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}

시도해보기
-----

Syntax
------


```js
Math.tanh(x);
```

### 파라미터

`x`

숫자.

### 반환 값

주어진 수의 쌍곡탄젠트 값

설명
--

`tanh()` 은 `Math`의 정적 메서드이므로 사용자가 만든 `Math` 객체의 메서드가 아닌 항상 `Math.tanh()` 으로 사용합니다 (`Math` 는 생성자가 아닙니다.).

예
-

### Using `Math.tanh()`


```js
Math.tanh(0); // 0
Math.tanh(Infinity); // 1
Math.tanh(1); // 0.7615941559557649
```

Polyfill
--------

This can be emulated with the help of the `Math.exp()` function:


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

명세서
---

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

브라우저 호환성
--------

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

함께 보기
-----

* `Math.acosh()`
* `Math.asinh()` (en-US)
* `Math.atanh()` (en-US)
* `Math.cosh()` (en-US)
* `Math.sinh()`
Math.pow()
==========

\*\*`Math.pow()`\*\*함수는`base^exponent`처럼
 `base` 에 `exponent`를 제곱한 값을 반환합니다.시도해보기
-----

문법
--


```js
Math.pow(base, exponent);
```

### 매개변수

`base`

밑 값.

`exponent`

`밑`
 을 제곱하기 위해 사용하는 지수.


### 반환 값

주어진 밑 값을 주어진 지수 값으로 거듭제곱한 숫자 값.

설명
--

 \*\*`Math.pow()`\*\*함수는 `base`의 `exponent`
 곱, 즉 `base^exponent`를 반환합니다.
 `base`와 `exponent`는 10진수입니다.

`pow()`는 `Math`의 정적 메서드이므로 `Math`객체를 생성하여 그 메서드로 사용하지 말고, 항상
 `Math.pow()`로 사용하십시오. (`Math`에는 생성자가 없습니다).
 만약 밑(base) 값이 음수이고 지수(exponent)가 정수가 아닌 경우 결과는 NaN입니다.

예제
--

### 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 (제곱의 결과값은 양수입니다.)
Math.pow(-7, 3); // -343 (세제곱은 음수가 될 수 있습니다.)
Math.pow(-7, 0.5); // NaN (음수는 실제 제곱근을 가지지 않습니다.)
// "짝수"와 "홀수" 근이 서로 가깝게 놓여 있고
// 부동소수점 정밀도의 한계로 인해,
// 밑이 음수이며 지수가 분수라면 언제나 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()`
* 멱승연산