math-as-code - GitLite

KO | EN

gitlite — search

#python #ai #llm #go #android #rust #macos #nodejs #java #windows #mcp #ios #openai #open-source

math-as-code

(★ 15,486)

코드 형태로 작성된 수학 기호 치트 시트

파일 탐색기

최종 버전 다운로드 (.zip)

.gitignore
.npmignore
CONTRIBUTING.md
LICENSE.md
package.json
PYTHON-README.md
README-zh.md
README.md

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/Experience-Monks/math-as-code

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd math-as-code

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Node.js

쉬움 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Node.js npm 명령어를 쓰려면 Node.js가 설치되어 있어야 합니다. LTS(장기지원) 버전을 추천합니다.

npm install

package.json에 명시된 라이브러리들을 내려받아 설치합니다.

npm start

개발/실행 서버를 켭니다.

✅ 명령어 실행 후 터미널에 나타나는 주소(보통 http://localhost:3000 형태)를 브라우저에서 열어보세요.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# math-as-code
>[Chinese translation (中文版)](./README-zh.md)
>[Python version (English)](./PYTHON-README.md)
이 가이드는 JavaScript 코드와의 비교를 통해 개발자들이 수학적 표기법에 쉽게 익숙해질 수 있도록 돕기 위한 레퍼런스입니다.
동기: 독학한 게임 및 그래픽스 프로그래머들에게 학술 논문은 위협적으로 느껴질 수 있습니다. :)
이 가이드는 아직 완성되지 않았습니다. 오류를 발견하거나 기여하고 싶으신 경우, [open a ticket](https://github.com/Jam3/math-as-code/issues)을 통해 이슈를 열어주시거나 PR을 보내주세요.
> \*\*참고\*\*: 간결함을 위해 일부 코드 예제에서는 [npm packages](https://www.npmjs.com/)를 사용합니다. 구현 세부 사항은 해당 GitHub 저장소를 참고하세요.
# 서문
수학 기호는 저자, 맥락, 연구 분야(선형대수학, 집합론 등)에 따라 다른 의미를 가질 수 있습니다. 이 가이드가 특정 기호의 \*모든\* 용도를 다루지는 않을 수 있습니다. 어떤 경우에는 기호가 실제로 어떻게 나타나는지 보여주기 위해 실제 사례(블로그 글, 논문 등)가 인용됩니다.
더 완벽한 목록은 [Wikipedia - List of Mathematical Symbols](https://en.wikipedia.org/wiki/List\_of\_mathematical\_symbols)를 참고하세요.
간결함을 위해, 여기 있는 많은 코드 예제들은 부동소수점 값을 다루며 수치적으로 강건하지(robust) 않습니다. 이것이 문제가 될 수 있는 이유에 대한 자세한 내용은 Mikola Lysenko의 [Robust Arithmetic Notes](https://github.com/mikolalysenko/robust-arithmetic-notes)를 참고하세요.
# 목차
- [변수 이름 명명 규칙](#variable-name-conventions)
- [등호 `=` `≈` `≠` `:=`](#equals-symbols)
- [제곱근과 복소수 `√` \*`i`\*](#square-root-and-complex-numbers)
- [점곱과 십자곱 `·` `×` `∘`](#dot--cross)
- [스칼라 곱셈](#scalar-multiplication)
- [벡터 곱셈](#vector-multiplication)
- [내적](#dot-product)
- [외적](#cross-product)
- [시그마 `Σ`](#sigma) - \*합계\*
- [대문자 파이 `Π`](#capital-pi) - \*수열의 곱\*
- [파이프 `||`](#pipes)
- [절댓값](#absolute-value)
- [유클리드 노름](#euclidean-norm)
- [행렬식](#determinant)
- [모자 \*\*`â`\*\*](#hat) - \*단위 벡터\*
- ["원소" `∈` `∉`](#element)
- [일반적인 수 집합 `ℝ` `ℤ` `ℚ` `ℕ`](#common-number-sets)
- [함수 `ƒ`](#function)
- [구간별 함수](#piecewise-function)
- [일반적인 함수들](#common-functions)
- [함수 표기법 `↦` `→`](#function-notation)
- [프라임 `′`](#prime)
- [바닥 함수와 천장 함수 `⌊` `⌉`](#floor--ceiling)
- [화살표](#arrows)
- [실질 함의 `⇒` `→`](#material-implication)
- [부등호 `<` `≥` `≫`](#equality)
- [논리곱과 논리합 `∧` `∨`](#conjunction--disjunction)
- [논리 부정 `¬` `~` `!`](#logical-negation)
- [구간](#intervals)
- [더 보기...](#more)
## 변수 이름 명명 규칙
맥락과 연구 분야에 따라 다양한 명명 규칙이 존재하며, 항상 일관되지는 않습니다. 하지만 일부 문헌에서는 변수 이름이 다음과 같은 패턴을 따르는 것을 볼 수 있습니다:
- \*s\* - 스칼라를 위한 이탤릭체 소문자 (예: 숫자)
- \*\*x\*\* - 벡터를 위한 볼드체 소문자 (예: 2D 점)
- \*\*A\*\* - 행렬을 위한 볼드체 대문자 (예: 3D 변환)
- \*θ\* - 상수와 특수 변수를 위한 이탤릭체 소문자 그리스 문자 (예: [극소각 \*θ\*, \*theta\*](https://en.wikipedia.org/wiki/Spherical\_coordinate\_system))
이 가이드 역시 이 형식을 따를 것입니다.
## 등호 기호
등호 `=`와 유사한 기호들이 여러 개 있습니다. 몇 가지 흔한 예시는 다음과 같습니다:
- `=`은 등호(값이 같음)를 의미합니다.
- `≠`는 부등호(값이 같지 않음)를 의미합니다.
- `≈`는 대략 같음을 의미합니다 (`π ≈ 3.14159`).
- `:=`는 정의를 의미합니다 (A는 B로 정의됨).
JavaScript에서의 표현:
```js
// equality
2 === 3
// inequality
2 !== 3
// approximately equal
almostEqual(Math.PI, 3.14159, 1e-5)
function almostEqual(a, b, epsilon) {
return Math.abs(a - b) <= epsilon
}
```
`:=`, `=:` 및 `=` 기호가 \*정의\* 용도로 사용되는 것을 볼 수 있습니다.[1]
예를 들어, 아래는 \*x\*를 2\*kj\*의 다른 이름으로 정의합니다.
![equals1](http://latex.code

cogs.com/svg.latex?x%20%3A%3D%202kj)
JavaScript에서 우리는 변수를 \*정의\*하고 별칭을 제공하기 위해 `var`를 사용할 수 있습니다:
```js
var x = 2 \* k \* j
```
하지만 이는 가변적이며, 당시의 값에 대한 스냅샷만 가져옵니다. 일부 언어에는 수학적 \*정의\*에 더 가까운 전처리기 `#define` 문이 있습니다.
JavaScript(ES6)에서 더 정확한 \*정의\*는 다음과 비슷할 수 있습니다:
```js
const f = (k, j) => 2 \* k \* j
```
반면에 다음은 등식을 나타냅니다:
![equals2](http://latex.codecogs.com/svg.latex?x%20%3D%202kj)
위의 방정식은 코드에서 [assertion](https://developer.mozilla.org/en-US/docs/Web/API/console/assert)으로 해석될 수 있습니다:
```js
console.assert(x === (2 \* k \* j))
```
## 제곱근과 복소수
제곱근 연산의 형식은 다음과 같습니다:
![squareroot](http://latex.codecogs.com/svg.latex?%5Cleft%28%5Csqrt%7Bx%7D%5Cright%29%5E2%20%3D%20x)
프로그래밍에서는 다음과 같이 `sqrt` 함수를 사용합니다:
```js
var x = 9;
console.log(Math.sqrt(x));
//=> 3
```
복소수는 ![complex](http://latex.codecogs.com/svg.latex?a&space+&spaceib) 형식의 표현식이며, 여기서 ![a](http://latex.codecogs.com/svg.latex?a)는 실수부이고 ![b](http://latex.codecogs.com/svg.latex?b)는 허수부입니다. 허수 ![i](http://latex.codecogs.com/svg.latex?i)는 다음과 같이 정의됩니다:
![imaginary](http://latex.codecogs.com/svg.latex?i%3D%5Csqrt%7B-1%7D).
JavaScript에는 복소수를 위한 내장 기능이 없지만, 복소수 산술을 지원하는 몇 가지 라이브러리가 있습니다. 예를 들어 [mathjs](https://www.npmjs.com/package/mathjs)를 사용할 수 있습니다:
```js
var math = require('mathjs')
var a = math.complex(3, -1)
//=> { re: 3, im: -1 }
var b = math.sqrt(-1)
//=> { re: 0, im: 1 }
console.log(math.multiply(a, b).toString())
//=> '1 + 3i'
```
이 라이브러리는 문자열 표현식 평가도 지원하므로, 위 코드는 다음과 같이 다시 작성할 수 있습니다:
```js
console.log(math.eval('(3 - i) \* i').toString())
//=> '1 + 3i'
```
기존 구현체들:
- [immutable-complex](https://www.npmjs.com/package/immutable-complex)
- [complex-js](https://www.npmjs.com/package/complex-js)
- [Numeric-js](http://www.numericjs.com/)
## 점 & 크로스
점 `·`과 크로스 `×` 기호는 문맥에 따라 다른 용도로 사용됩니다.
당연해 보일 수 있지만, 다른 섹션으로 넘어가기 전에 미묘한 차이를 이해하는 것이 중요합니다.
#### 스칼라 곱셈
두 기호 모두 스칼라의 단순 곱셈을 나타낼 수 있습니다. 다음은 동치입니다:
![dotcross1](http://latex.codecogs.com/svg.latex?5%20%5Ccdot%204%20%3D%205%20%5Ctimes%204)
프로그래밍 언어에서는 보통 곱셈을 위해 별표(asterisk)를 사용합니다:
```js
var result = 5 \* 4
```
종종 곱셈 기호는 (예: 두 숫자 사이의) 모호함을 피하기 위해서만 사용됩니다. 여기서는 이를 완전히 생략할 수 있습니다:
![dotcross2](http://latex.codecogs.com/svg.latex?3kj)
이 변수들이 스칼라를 나타낸다면 코드는 다음과 같습니다:
```js
var result = 3 \* k \* j
```
#### 벡터 곱셈
하나의 벡터와 스칼라의 곱셈, 또는 벡터와 다른 벡터의 요소별(element-wise) 곱셈을 나타낼 때는 일반적으로 점 `·`이나 크로스 `×` 기호를 사용하지 않습니다. 이들은 선형 대수학에서 곧 논의할 다른 의미를 가집니다.
앞서의 예를 가져와 벡터에 적용해 보겠습니다. 요소별 벡터 곱셈의 경우, [Hadamard product](https://en.wikipedia.org/wiki/Hadamard\_product\_%28matrices%29)를 나타내기 위해 열린 점 `∘`을 볼 수 있습니다.[2]
![dotcross3](http://latex.codecogs.com/svg.latex?3%5Cmathbf%7Bk%7D%5Ccirc%5Cmathbf%7Bj%7D)
다른 경우에는 저자가 원이 있는 점 `⊙`이나 채워진 동그라미 `●`과 같은 다른 표기법을 명시적으로 정의할 수도 있습니다.[3]
2D 벡터를 나타내기 위해 배열 `[x, y]`을 사용하는 코드는 다음과 같습니다.
```js
var s = 3
var k = [ 1, 2 ]
var j = [ 2, 3 ]
var tmp = multiply(k, j)
var result = multiplyScalar(tmp, s)
//=> [ 6, 18 ]
```
우리의 `multiply`와 `multiplyScalar` 함수는 다음과 같습니다:
```js
function multiply(a

, b) {
return [ a[0] \* b[0], a[1] \* b[1] ]
}
function multiplyScalar(a, scalar) {
return [ a[0] \* scalar, a[1] \* scalar ]
}
```
마찬가지로, 행렬 곱셈은 보통 점 `·`이나 교차 기호 `×`를 사용하지 않습니다. 행렬 곱셈은 나중에 다루겠습니다.
#### dot product
점 기호 `·`는 두 벡터의 [\*dot product\*](https://en.wikipedia.org/wiki/Dot\_product)를 나타내는 데 사용할 수 있습니다. 결과가 스칼라로 평가되기 때문에 때로는 이를 \*스칼라곱(scalar product)\*이라고도 부릅니다.
![dotcross4](http://latex.codecogs.com/svg.latex?%5Cmathbf%7Bk%7D%5Ccdot%20%5Cmathbf%7Bj%7D)
이는 선형 대수학에서 매우 흔한 기능이며, 3D 벡터의 경우 다음과 같을 수 있습니다:
```js
var k = [ 0, 1, 0 ]
var j = [ 1, 0, 0 ]
var d = dot(k, j)
//=> 0
```
결과인 `0`은 두 벡터가 서로 수직임을 알려줍니다. 다음은 3차원 컴포넌트 벡터를 위한 `dot` 함수입니다:
```js
function dot(a, b) {
return a[0] \* b[0] + a[1] \* b[1] + a[2] \* b[2]
}
```
#### cross product
교차 기호 `×`는 두 벡터의 [\*cross product\*](https://en.wikipedia.org/wiki/Cross\_product)를 나타내는 데 사용할 수 있습니다.
![dotcross5](http://latex.codecogs.com/svg.latex?%5Cmathbf%7Bk%7D%5Ctimes%20%5Cmathbf%7Bj%7D)
코드로 표현하면 다음과 같습니다:
```js
var k = [ 0, 1, 0 ]
var j = [ 1, 0, 0 ]
var result = cross(k, j)
//=> [ 0, 0, -1 ]
```
여기서 얻은 결과 `[ 0, 0, -1 ]`은 \*\*k\*\*와 \*\*j\*\* 모두에 수직입니다.
우리의 `cross` 함수:
```js
function cross(a, b) {
var ax = a[0], ay = a[1], az = a[2],
bx = b[0], by = b[1], bz = b[2]
var rx = ay \* bz - az \* by
var ry = az \* bx - ax \* bz
var rz = ax \* by - ay \* bx
return [ rx, ry, rz ]
}
```
벡터 곱셈, cross product, dot product의 다른 구현체들에 대해서는 다음을 참고하세요:
- [gl-vec3](https://github.com/stackgl/gl-vec3)
- [gl-vec2](https://github.com/stackgl/gl-vec2)
- [vectors](https://github.com/hughsk/vectors) - n차원 포함
## sigma
그리스 대문자 `Σ` (시그마)는 [Summation(합산)](https://en.wikipedia.org/wiki/Summation)을 의미합니다. 즉, 여러 숫자를 더하는 것입니다.
![sigma](http://latex.codecogs.com/svg.latex?%5Csum\_%7Bi%3D1%7D%5E%7B100%7Di)
여기서 `i=1`은 `1`에서 시작함을 뜻하고, 시그마 위의 숫자 `100`은 끝을 뜻합니다. 각각 하한과 상한입니다. "E" 오른쪽에 있는 \*i\*는 우리가 무엇을 더하고 있는지를 알려줍니다. 코드로 표현하면 다음과 같습니다:
```js
var sum = 0
for (var i = 1; i <= 100; i++) {
sum += i
}
```
`sum`의 결과는 `5050`입니다.
\*\*팁:\*\* 정수의 경우, 이 특정 패턴은 다음과 같이 최적화될 수 있습니다:
```js
var n = 100 // 상한
var sum = (n \* (n + 1)) / 2
```
\*i\* 즉, "더할 대상"이 다른 또 다른 예시입니다:
![sum2](http://latex.codecogs.com/svg.latex?%5Csum\_%7Bi%3D1%7D%5E%7B100%7D%282i+1%29)
코드로 표현하면:
```js
var sum = 0
for (var i = 1; i <= 100; i++) {
sum += (2 \* i + 1)
}
```
`sum`의 결과는 `10200`입니다.
이 표기법은 `for` 루프를 중첩하는 것과 매우 유사하게 중첩될 수 있습니다. 작성자가 순서를 바꾸기 위해 괄호로 묶지 않은 이상, 가장 오른쪽에 있는 시그마를 먼저 계산해야 합니다. 하지만 다음의 경우, 유한합을 다루고 있기 때문에 순서는 상관없습니다.
![sigma3](http://latex.codecogs.com/svg.latex?%5Csum\_%7Bi%3D1%7D%5E%7B2%7D%5Csum\_%7Bj%3D4%7D%5E%7B6%7D%283ij%29)
코드로 표현하면:
```js
var sum = 0
for (var i = 1; i <= 2; i++) {
for (var j = 4; j <= 6; j++) {
sum += (3 \* i \* j)
}
}
```
여기서 `sum`은 `135`가 됩니다.
## capital Pi
대문자 파이 또는 "빅 파이(Big Pi)"는 일련의 값들의 곱을 구하기 위해 곱셈을 사용한다는 점만 제외하면 [Sigma](#sigma)와 매우 유사합니다.
다음 예시를 봅시다:
![capitalPi](http://latex.codecogs.com/svg.latex?%5Cprod\_%7Bi%3D1%7D%5E%7B6%7Di)
코드로 표현하면 다음과 같을 수 있습니다:
```js
var value = 1
for (var i = 1; i <= 6; i++) {
value \*= i
}
```
여기서 `value`는 `720`으로 평가됩니다.
## pipes
\*바(bars)\*라고도 불리는 파이프 기호는 문맥에 따라 다른 의미를 가질 수 있습니다. 아래는 세 가지 일반적인 용도입니다: [absolute value](#absolute-value), [Euclidean norm](#euclidean-norm), 그리고 determinan

t](#determinant).
이 세 가지 기능은 모두 객체의 \*길이\*를 설명합니다.
#### absolute value
![pipes1](http://latex.codecogs.com/svg.latex?%5Cleft%20%7C%20x%20%5Cright%20%7C)
숫자 \*x\*에 대해, `|x|`는 \*x\*의 절대값을 의미합니다. 코드로 표현하면 다음과 같습니다:
```js
var x = -5
var result = Math.abs(x)
// => 5
```
#### Euclidean norm
![pipes4](http://latex.codecogs.com/svg.latex?%5Cleft%20%5C%7C%20%5Cmathbf%7Bv%7D%20%5Cright%20%5C%7C)
벡터 \*\*v\*\*에 대해, `‖v‖`는 \*\*v\*\*의 [Euclidean norm](https://en.wikipedia.org/wiki/Norm\_%28mathematics%29#Euclidean\_norm)입니다. 이는 벡터의 "크기(magnitude)" 또는 "길이(length)"라고도 부릅니다.
\*절대값\* 표기법과의 혼동을 피하기 위해 보통 겹바(double-bars)로 나타내지만, 단일 바를 사용하는 경우도 볼 수 있습니다:
![pipes2](http://latex.codecogs.com/svg.latex?%5Cleft%20%7C%20%5Cmathbf%7Bv%7D%20%5Cright%20%7C)
3차원 벡터를 나타내기 위해 배열 `[x, y, z]`를 사용하는 예제입니다.
```js
var v = [ 0, 4, -3 ]
length(v)
//=> 5
```
`length` 함수:
```js
function length (vec) {
var x = vec[0]
var y = vec[1]
var z = vec[2]
return Math.sqrt(x \* x + y \* y + z \* z)
}
```
기타 구현체:
- [magnitude](https://github.com/mattdesl/magnitude/blob/864ff5a7eb763d34bf154ac5f5332d7601192b70/index.js) - n차원
- [gl-vec2/length](https://github.com/stackgl/gl-vec2/blob/21f460a371540258521fd2f720d80f14e87bd400/length.js) - 2차원 벡터
- [gl-vec3/length](https://github.com/stackgl/gl-vec3/blob/507480fa57ba7c5fb70679cf531175a52c48cf53/length.js) - 3차원 벡터
#### determinant
![pipes3](http://latex.codecogs.com/svg.latex?%5Cleft%20%7C%5Cmathbf%7BA%7D%20%5Cright%20%7C)
행렬 \*\*A\*\*에 대해, `|A|`는 행렬 \*\*A\*\*의 [determinant](https://en.wikipedia.org/wiki/Determinant)를 의미합니다.
열 우선(column-major) 형식의 평면 배열로 표현된 2x2 행렬의 행렬식을 계산하는 예제입니다.
```js
var determinant = require('gl-mat2/determinant')
var matrix = [ 1, 0, 0, 1 ]
var det = determinant(matrix)
//=> 1
```
구현체:
- [gl-mat4/determinant](https://github.com/stackgl/gl-mat4/blob/c2e2de728fe7eba592f74cd02266100cc21ec89a/determinant.js) - [gl-mat3](https://github.com/stackgl/gl-mat3) 및 [gl-mat2](https://github.com/stackgl/gl-mat2)도 참고하세요.
- [ndarray-determinant](https://www.npmjs.com/package/ndarray-determinant)
- [glsl-determinant](https://www.npmjs.com/package/glsl-determinant)
- [robust-determinant](https://www.npmjs.com/package/robust-determinant)
- [robust-determinant-2](https://www.npmjs.com/package/robust-determinant-2) 및 [robust-determinant-3](https://www.npmjs.com/package/robust-determinant-3) (각각 2x2 및 3x3 행렬 전용)
## hat
기하학에서 문자 위에 붙는 "모자(hat)" 기호는 [unit vector](https://en.wikipedia.org/wiki/Unit\_vector)를 나타내는 데 사용됩니다. 예를 들어, 다음은 \*\*a\*\*의 단위 벡터입니다:
![hat](http://latex.codecogs.com/svg.latex?%5Chat%7B%5Cmathbf%7Ba%7D%7D)
데카르트 공간에서 단위 벡터는 일반적으로 길이가 1입니다. 즉, 벡터의 각 성분은 -1.0에서 1.0 사이의 범위를 갖습니다. 여기서는 3차원 벡터를 단위 벡터로 \*정규화(normalize)\*합니다:
```js
var a = [ 0, 4, -3 ]
normalize(a)
//=> [ 0, 0.8, -0.6 ]
```
3차원 벡터에서 작동하는 `normalize` 함수입니다:
```js
function normalize(vec) {
var x = vec[0]
var y = vec[1]
var z = vec[2]
var squaredLength = x \* x + y \* y + z \* z
if (squaredLength > 0) {
var length = Math.sqrt(squaredLength)
vec[0] = x / length
vec[1] = y / length
vec[2] = z / length
}
return vec
}
```
기타 구현체:
- [gl-vec3/normalize](https://github.com/stackgl/gl-vec3/blob/507480fa57ba7c5fb70679cf531175a52c48cf53/normalize.js) 및 [gl-vec2/normalize](https://github.com/stackgl/gl-vec2/blob/21f460a371540258521fd2f720d80f14e87bd400/normalize.js)
- [vectors/normalize-nd](https://github.com/hughsk/vectors/blob/master/normalize-nd.js) (n차원)
## element
집합론에서 "원소" 기호인 `∈`과 `∋`는 어떤 대상이 \*집합\*의 원소인지 여부를 설명하는 데 사용할 수 있습니다.

\*. 예를 들어:
![element1](http://latex.codecogs.com/svg.latex?A%3D%5Cleft%20%5C%7B3%2C9%2C14%7D%7B%20%5Cright%20%5C%7D%2C%203%20%5Cin%20A)
여기 숫자 집합 \*A\*인 `{ 3, 9, 14 }`가 있고, `3`은 그 집합의 "원소(element of)"라고 말하고 있습니다.
ES5에서의 간단한 구현은 다음과 같습니다:
```js
var A = [ 3, 9, 14 ]
A.indexOf(3) >= 0
//=> true
```
하지만 고유한 값만 유지하는 `Set`을 사용하는 것이 더 정확할 것입니다. 이는 ES6의 기능입니다.
```js
var A = new Set([ 3, 9, 14 ])
A.has(3)
//=> true
```
방향이 바뀐 `∋`도 같지만, 순서가 바뀝니다:
![element2](http://latex.codecogs.com/svg.latex?A%3D%5Cleft%20%5C%7B3%2C9%2C14%7D%7B%20%5Cright%20%5C%7D%2C%20A%20%5Cni%203)
또한 다음과 같이 "원소가 아님" 기호인 `∉`과 `∌`을 사용할 수도 있습니다:
![element3](http://latex.codecogs.com/svg.latex?A%3D%5Cleft%20%5C%7B3%2C9%2C14%7D%7B%20%5Cright%20%5C%7D%2C%206%20%5Cnotin%20A)
## 공통 수 집합 (common number sets)
수식들 사이에서 몇 가지 대문자 [Blackboard](https://en.wikipedia.org/wiki/Blackboard\_bold) 글꼴을 볼 수 있습니다. 대개 이것들은 집합을 설명하는 데 사용됩니다.
예를 들어, \*k\*를 집합 `ℝ`의 [원소(#element)](#element)로 설명할 수 있습니다.
![real](http://latex.codecogs.com/svg.latex?k%20%5Cin%20%5Cmathbb%7BR%7D)
아래에는 몇 가지 공통 집합과 그 기호들이 나열되어 있습니다.
#### `ℝ` 실수 (real numbers)
대문자 `ℝ`은 \*실수(real numbers)\*의 집합을 나타냅니다. 여기에는 정수뿐만 아니라 유리수와 무리수가 포함됩니다.
JavaScript는 부동소수점과 정수를 동일한 타입으로 취급하므로, 앞서 언급한 \*k\* ∈ ℝ 예제는 다음과 같이 간단하게 테스트할 수 있습니다:
```js
function isReal (k) {
return typeof k === 'number' && isFinite(k);
}
```
\*참고:\* 실수는 또한 \*무한대가 아닌(not infinite)* \*유한한(finite)\* 수입니다.
#### `ℚ` 유리수 (rational numbers)
유리수는 분수 또는 \*비율(ratio)* (예: `⅗`)로 표현할 수 있는 실수입니다. 유리수는 분모가 0일 수 없습니다.
이것은 또한 분모를 1로 표현할 수 있으므로 모든 정수가 유리수임을 의미합니다.
반면에 무리수는 π (PI)처럼 비율로 표현할 수 없는 수입니다.
#### `ℤ` 정수 (integers)
정수, 즉 소수 부분이 없는 실수입니다. 이들은 양수일 수도 있고 음수일 수도 있습니다.
JavaScript에서의 간단한 테스트는 다음과 같습니다:
```js
function isInteger (n) {
return typeof n === 'number' && n % 1 === 0
}
```
#### `ℕ` 자연수 (natural numbers)
자연수, 즉 양의 정수이자 0 또는 양의 정수입니다. 문맥과 연구 분야에 따라 집합에 0이 포함될 수도 있고 포함되지 않을 수도 있으므로, 다음 중 하나의 형태를 가질 수 있습니다:
```js
{ 0, 1, 2, 3, ... }
{ 1, 2, 3, 4, ... }
```
예를 들어 전자는 컴퓨터 과학에서 더 흔하게 쓰입니다:
```js
function isNaturalNumber (n) {
return isInteger(n) && n >= 0
}
```
#### `ℂ` 복소수 (complex numbers)
복소수는 실수와 허수의 조합으로, 2차원 평면 위의 좌표로 볼 수 있습니다. 더 자세한 정보는 [A Visual, Intuitive Guide to Imaginary Numbers](http://betterexplained.com/articles/a-visual-intuitive-guide-to-imaginary-numbers/)를 참고하세요.
## 함수 (function)
[함수(Functions)](https://en.wikipedia.org/wiki/Function\_%28mathematics%29)는 수학의 핵심적인 기능이며, 이 개념은 코드로 변환하기 비교적 쉽습니다.
함수는 입력값을 출력값과 연관시킵니다. 예를 들어, 다음은 함수입니다:
![function1](http://latex.codecogs.com/svg.latex?x%5E%7B2%7D)
이 함수에 \*이름\*을 부여할 수 있습니다. 흔히 함수를 설명할 때 `ƒ`를 사용하지만, `A(x)`나 그 외의 이름으로 명명할 수도 있습니다.
![function2](http://latex.codecogs.com/svg.latex?f%5Cleft%20%28x%20%5Cright%20%29%20%3D%20x%5E%7B2%7D)
코드에서는 이를 `square`라고 이름 붙이고 다음과 같이 작성할 수 있습니다:
```js
function square (x) {
return Math.pow(x, 2)
}
```
때로는 함수에 이름이 없는 대신 출력값이 적혀 있기도 합니다.
![function3](http://latex.codecogs.com/svg.latex?y%20%3D%20x%5E%7B2%7D)
위의 예에서 \*x\*는 입력값이고, 관계는 \*제곱(squaring)*이며, \*y\*는 출력값입니다.
함수는 프로그래밍 언어에서처럼 여러 개의 매개변수를 가질 수도 있습니다. 이들은 다음과 같이 알려져 있습니다

수학에서는 \*arguments\*라 부르며, 함수가 받는 인자의 개수는 함수의 \*arity\*라고 알려져 있습니다.
![function4](http://latex.codecogs.com/svg.latex?f%28x%2Cy%29%20%3D%20%5Csqrt%7Bx%5E2%20+%20y%5E2%7D)
코드로 표현하면 다음과 같습니다:
```js
function length (x, y) {
return Math.sqrt(x \* x + y \* y)
}
```
### piecewise function
일부 함수는 입력값인 \*x\*에 따라 서로 다른 관계식을 사용합니다.
다음 함수 \*ƒ\*는 입력값에 따라 두 개의 "하위 함수(sub functions)" 중 하나를 선택합니다.
![piecewise1](http://latex.codecogs.com/svg.latex?f%28x%29%3D%20%5Cbegin%7Bcases%7D%20%5Cfrac%7Bx%5E2-x%7D%7Bx%7D%2C%26%20%5Ctext%7Bif%20%7D%20x%5Cgeq%201%5C%5C%200%2C%20%26%20%5Ctext%7Botherwise%7D%20%5Cend%7Bcases%7D)
이는 코드의 `if` / `else`와 매우 유사합니다. 우측의 조건들은 흔히 \*\*"for x < 0"\*\* 또는 \*\*"if x = 0"\*\*과 같이 작성됩니다. 조건이 참이면 왼쪽에 있는 함수가 사용됩니다.
구분 정의 함수(piecewise functions)에서 \*\*"otherwise"\*\*와 \*\*"elsewhere"\*\*는 코드의 `else` 문과 유사한 역할을 합니다.
```js
function f (x) {
if (x >= 1) {
return (Math.pow(x, 2) - x) / x
} else {
return 0
}
}
```
### common functions
수학에서 널리 쓰이는 함수 이름들이 있습니다. 프로그래머에게 이는 프로그래밍 언어에 "내장된(built-in)" 함수(JavaScript의 `parseInt` 같은 것)와 비슷할 수 있습니다.
대표적인 예로 \*sgn\* 함수가 있습니다. 이는 \*signum\* 또는 \*sign\* 함수입니다. [piecewise function](#piecewise-function) 표기법을 사용하여 설명해 보겠습니다:
![sgn](http://latex.codecogs.com/svg.latex?sgn%28x%29%20%3A%3D%20%5Cbegin%7Bcases%7D%20-1%26%20%5Ctext%7Bif%20%7D%20x%20%3C%200%5C%5C%200%2C%20%26%20%5Ctext%7Bif%20%7D%20%7Bx%20%3D%200%7D%5C%5C%201%2C%20%26%20%5Ctext%7Bif%20%7D%20x%20%3E%200%5C%5C%20%5Cend%7Bcases%7D)
코드로 구현하면 다음과 같을 수 있습니다:
```js
function sgn (x) {
if (x < 0) return -1
if (x > 0) return 1
return 0
}
```
이 함수가 모듈로 구현된 형태는 [signum](https://github.com/scijs/signum)을 참고하세요.
이러한 함수의 다른 예시로는 \*sin\*, \*cos\*, \*tan\*이 있습니다.
### function notation
일부 문헌에서는 함수를 좀 더 명시적인 표기법으로 정의하기도 합니다. 예를 들어, 앞에서 언급했던 `square` 함수로 돌아가 보겠습니다:
![function2](http://latex.codecogs.com/svg.latex?f%5Cleft%20%28x%20%5Cright%20%29%20%3D%20x%5E%7B2%7D)
이는 다음과 같은 형태로도 작성될 수 있습니다:
![mapsto](http://latex.codecogs.com/svg.latex?f%20%3A%20x%20%5Cmapsto%20x%5E2)
여기서 꼬리가 달린 화살표는 일반적으로 \*x가 x2에 대응한다\*는 의미의 "maps to"를 뜻합니다.
때로는 명확하지 않은 경우, 이 표기법을 통해 함수의 \*domain\*과 \*codomain\*을 함께 설명하기도 합니다. \*ƒ\*의 좀 더 형식적인 정의는 다음과 같이 작성될 수 있습니다:
![funcnot](http://latex.codecogs.com/svg.latex?%5Cbegin%7Balign\*%7D%20f%20%3A%26%5Cmathbb%7BR%7D%20%5Crightarrow%20%5Cmathbb%7BR%7D%5C%5C%20%26x%20%5Cmapsto%20x%5E2%20%5Cend%7Balign\*%7D)
함수의 \*domain\*과 \*codomain\*은 각각 함수의 \*input\*과 \*output\* 타입과 약간 비슷합니다. 정수를 출력하는 앞서의 \*sgn\* 함수를 사용한 다른 예시를 보겠습니다:
![domain2](http://latex.codecogs.com/svg.latex?sgn%20%3A%20%5Cmathbb%7BR%7D%20%5Crightarrow%20%5Cmathbb%7BZ%7D)
여기서 (꼬리가 없는) 화살표는 하나의 \*set\*을 다른 \*set\*으로 대응시키는 데 사용됩니다.
JavaScript 및 기타 동적 타이핑 언어에서는 문서화 및/또는 런타임 검사를 사용하여 함수의 입력/출력을 설명하고 유효성 검사를 수행할 수 있습니다. 예시:
```js
/\*\*
\* 숫자의 제곱을 구합니다.
\* @param {Number} a 실수
\* @return {Number} 실수
\*/
function square (a) {
if (typeof a !== 'number') {
throw new TypeError('expected a number')
}
return Math.pow(a, 2)
}
```
[flowtype](http://flowtype.org/)과 같은 일부 도구는 JavaScript에 정적 타이핑을 도입하려고 시도합니다.
Java와 같은 다른 언어들은 함수의 입력/출력의 정적 타입을 기반으로 한 진정한 메서드 오버로딩을 지원합니다. 이는 수학에 더 가까운데, 서로 다른 \*domain\*을 사용하는 두 함수는 같지 않기 때문입니다.
## prime
프라임 기호(`′`)는 변수 이름에서 종종 다음과 같이 사용됩니다.

전체적으로 완전히 다른 이름을 붙이지 않고 서로 비슷한 것들을 설명하는 데 사용됩니다. 어떤 변환을 거친 "다음 값"을 설명할 수 있습니다.
예를 들어, 2차원 점 \*(x, y)*를 취해 회전시킨 경우 그 결과를 \*(x′, y′)*로 명명할 수 있습니다. 또는 행렬 \*\*M\*\*의 \*전치(transpose)\*를 \*\*M′\*\*라고 부를 수 있습니다.
코드에서는 대개 `transformedPosition`과 같이 변수에 좀 더 설명적인 이름을 할당합니다.
수학적 [함수](#function)의 경우, 프라임 기호는 종종 해당 함수의 \*도함수(derivative)\*를 설명합니다. 도함수는 추후 섹션에서 설명하겠습니다. 앞서 살펴본 함수를 가져와 보겠습니다.
![function2](http://latex.codecogs.com/svg.latex?f%5Cleft%20%28x%20%5Cright%20%29%20%3D%20x%5E%7B2%7D)
이 함수의 도함수는 프라임 `′` 기호를 사용하여 작성할 수 있습니다.
![prime1](http://latex.codecogs.com/svg.latex?f%27%28x%29%20%3D%202x)
코드로는 다음과 같습니다.
```js
function f (x) {
return Math.pow(x, 2)
}
function fPrime (x) {
return 2 \* x
}
```
여러 개의 프라임 기호를 사용하여 2차 도함수 \*ƒ′′\*와 3차 도함수 \*ƒ′′′\*를 나타낼 수 있습니다. 이보다 더 높은 차수의 경우, 저자들은 대개 로마 숫자인 \*ƒ\*IV 또는 위 첨자 숫자인 \*ƒ\*(n)을 사용해 표현합니다.

## floor & ceiling
특수 괄호 `⌊x⌋`와 `⌈x⌉`는 각각 \*내림(floor)\*과 \*올림(ceil)\* 함수를 나타냅니다.
![floor](http://latex.codecogs.com/svg.latex?floor%28x%29%20%3D%20%5Clfloor%20x%20%5Crfloor)
![ceil](http://latex.codecogs.com/svg.latex?ceil%28x%29%20%3D%20%5Clceil%20x%20%5Crceil)
코드로는 다음과 같습니다.
```js
Math.floor(x)
Math.ceil(x)
```
두 기호가 섞인 `⌊x⌉` 형태는 대개 가장 가까운 정수로 반올림하는 함수를 나타냅니다.
![round](http://latex.codecogs.com/svg.latex?round%28x%29%20%3D%20%5Clfloor%20x%20%5Crceil)
코드로는 다음과 같습니다.
```js
Math.round(x)
```

## 화살표 (arrows)
화살표는 [함수 표기법](#function-notation)에서주로 사용됩니다. 이외에도 화살표를 볼 수 있는 몇 가지 영역이 있습니다.

#### 실질 함의 (material implication)
`⇒` 및 `→` 같은 화살표는 논리학에서 \*실질 함의\*를 나타내기 위해 가끔 사용됩니다. 즉, A가 참이면 B도 참이라는 뜻입니다.
![material1](http://latex.codecogs.com/svg.latex?A%20%5CRightarrow%20B)
이를 코드로 해석하면 다음과 같을 수 있습니다.
```js
if (A === true) {
console.assert(B === true)
}
```
화살표는 어느 방향이든 갈 수 있으며 (`⇐`, `⇒`), 양방향 모두 사용될 수도 있습니다 (`⇔`). \*A ⇒ B\*이고 \*B ⇒ A\*일 때, 두 명제는 동치(equivalent)라고 합니다.
![material-equiv](http://latex.codecogs.com/svg.latex?A%20%5CLeftrightarrow%20B)

#### 등식 및 부등식
수학에서 `<`, `>`, `≤`, `≥`는 대개 우리가 코드에서 사용하는 것과 같은 의미로 사용됩니다. 각각 \*보다 작음(less than)\*, \*보다 큼(greater than)\*, \*크지 않거나 같음(less than or equal to)\*, \*작지 않거나 같음(greater than or equal to)\*을 의미합니다.
```js
50 > 2 === true
2 < 10 === true
3 <= 4 === true
4 >= 4 === true
```
드물게 이러한 기호에 사선이 그어져 있는 것을 볼 수 있는데, 이는 \*부정(not)\*을 나타냅니다. 예를 들어 \*k\*가 \*j\*보다 "크지 않다"는 것을 의미합니다.
![ngt](http://latex.codecogs.com/svg.latex?k%20%5Cngtr%20j)
`≪`와 `≫`는 때때로 \*현저한\* 부등식을 나타내는 데 사용됩니다. 즉, \*k\*가 \*j\*보다 [자릿수(order of magnitude)](https://en.wikipedia.org/wiki/Order\_of\_magnitude) 이상으로 훨씬 크다는 뜻입니다.
![orderofmag](http://latex.codecogs.com/svg.latex?k%20%5Cgg%20j)
수학에서 \*자릿수(order of magnitude)\*는 꽤 구체적인 개념이며, 단순히 "정말 큰 차이"를 의미하는 것이 아닙니다. 위의 간단한 예시는 다음과 같습니다.
```js
orderOfMagnitude(k) > orderOfMagnitude(j)
```
그리고 아래는 [Math.trunc](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/Math/trunc) (ES6)를 사용한 `orderOfMagnitude` 함수입니다.
```js
function log10(n) {
// 밑이 10인 로그
return Math.log(n) / Math.LN10
}
function orderOfMagnitude (n) {
return Math.trunc(log10(n))
}
```
\*참고:\* 이는 수치적으로 견고하지 않습니다.
ES5에서의 폴리필(ponyfill)은 [math-trunc](https://www.npmjs.com/package/math-trunc)를참고하세요.

#### 논리곱과 논리합 (conjunction & disjunction)
논리학에서 화살표가 사용되는 또 다른 예는 논리곱(`∧`)과 논리합(`∨`)입니다. 이들은 프로그래머의 `AND` 및 `OR` 연산자와 각각 유사합니다.
다음은 논리곱인 `∧` (logical `AND`)를 보여줍니다.
![and](http://latex.code

cogs.com/svg.latex?k%20%3E%202%20%5Cland%20k%20%3C%204%20%5CLeftrightarrow%20k%20%3D%203)
JavaScript에서는 `&&`를 사용합니다. \*k\*가 자연수라고 가정할 때, 이 논리식은 \*k\*가 3임을 의미합니다:
```js
if (k > 2 && k < 4) {
console.assert(k === 3)
}
```
양쪽이 동치(`⇔`)이므로, 다음도 성립합니다:
```js
if (k === 3) {
console.assert(k > 2 && k < 4)
}
```
아래쪽 화살표 `∨`는 OR 연산과 같은 논리합을 의미합니다.
![logic-or](http://latex.codecogs.com/svg.latex?A%20%5Clor%20B)
코드 표현:
```js
A || B
```
## 논리 부정
간혹 `¬`, `~`, `!` 기호가 논리적 `NOT`을 나타내는 데 사용됩니다. 예를 들어, \*¬A\*는 A가 거짓일 때만 참이 됩니다.
\*not\* 기호를 사용하는 간단한 예시는 다음과 같습니다:
![negation](http://latex.codecogs.com/svg.latex?x%20%5Cneq%20y%20%5CLeftrightarrow%20%5Clnot%28x%20%3D%20y%29)
코드로 이를 해석하는 방법의 예:
```js
if (x !== y) {
console.assert(!(x === y))
}
```
\*참고:\* 틸다 `~`는 문맥에 따라 여러 가지 다른 의미를 가집니다. 예를 들어 \*행 동치\* (행렬 이론) 또는 \*자릿수(크기)가 같은 정도\* ([equality](#equality)에서 다룸) 등이 있습니다.
## 구간
때로는 함수가 특정 값의 범위로 제한된 실수 다룰 때가 있으며, 이러한 제약 조건은 \*구간(interval)\*을 사용하여 나타낼 수 있습니다.
예를 들어 0과 1 사이의 숫자를 0 및/또는 1을 포함하거나 포함하지 않는 방식으로 나타내면 다음과 같습니다:
- 0과 1을 모두 포함하지 않는 경우: ![interval-opened-left-opened-right](http://latex.codecogs.com/svg.latex?%280%2C%201%29)
- 0은 포함하고 1은 포함하지 않는 경우: ![interval-closed-left-opened-right](http://latex.codecogs.com/svg.latex?%5B0%2C%201%29)
- 0은 포함하지 않고 1은 포함하는 경우: ![interval-opened-left-closed-right](http://latex.codecogs.com/svg.latex?%280%2C%201%5D)
- 0과 1을 모두 포함하는 경우: ![interval-closed-left-closed-right](http://latex.codecogs.com/svg.latex?%5B0%2C%201%5D)
예를 들어 점 `x`가 3차원 단위 큐브(unit cube) 안에 있음을 나타낼 때는 다음과 같이 씁니다:
![interval-unit-cube](http://latex.codecogs.com/svg.latex?x%20%5Cin%20%5B0%2C%201%5D%5E3)
코드에서는 두 개의 요소를 가진 1차원 배열을 사용하여 구간을 나타낼 수 있습니다:
```js
var nextafter = require('nextafter')
var a = [nextafter(0, Infinity), nextafter(1, -Infinity)] // open interval
var b = [nextafter(0, Infinity), 1] // interval closed on the left
var c = [0, nextafter(1, -Infinity)] // interval closed on the right
var d = [0, 1] // closed interval
```
구간은 집합 연산과 함께 사용됩니다:
- \*교집합(intersection)\* 예: ![interval-intersection](http://latex.codecogs.com/svg.latex?%5B3%2C%205%29%20%5Ccap%20%5B4%2C%206%5D%20%3D%20%5B4%2C%205%29)
- \*합집합(union)\* 예: ![interval-union](http://latex.codecogs.com/svg.latex?%5B3%2C%205%29%20%5Ccup%20%5B4%2C%206%5D%20%3D%20%5B3%2C%206%5D)
- \*차집합(difference)\* 예: ![interval-difference-1](http://latex.codecogs.com/svg.latex?%5B3%2C%205%29%20-%20%5B4%2C%206%5D%20%3D%20%5B3%2C%204%29) 및 ![interval-difference-2](http://latex.codecogs.com/svg.latex?%5B4%2C%206%5D%20-%20%5B3%2C%205%29%20%3D%20%5B5%2C%206%5D)

코드에서:
```js
var Interval = require('interval-arithmetic')
var nextafter = require('nextafter')
var a = Interval(3, nextafter(5, -Infinity))
var b = Interval(4, 6)
Interval.intersection(a, b)
// {lo: 4, hi: 4.999999999999999}
Interval.union(a, b)
// {lo: 3, hi: 6}
Interval.difference(a, b)
// {lo: 3, hi: 3.9999999999999996}
Interval.difference(b, a)
// {lo: 5, hi: 6}
```
참조:
- [next-after](https://github.com/scijs/nextafter)
- [interval-arithmetic](https://github.com/maurizzzio/interval-arithmetic)
## 더 보기...
이 가이드가 마음에 드시나요? [추가 기능](https://github.com/Jam3/math-as-code/issues/1)을 제안하거나 Pull Request를 보내주세요!
## 기여하기
기여 방법에 대한 자세한 내용은 [CONTRIBUTING.md](./CONTRIBUTING.md)를 참조하세요.
## 라이선스
MIT, 자세한 내용은 [LICENSE.md](http://github.com/Jam3/math-as-code/blob/master/LICENSE.md)를 참조하세요.
[1]: http://mimosa-pudica.net/improved-oren-nayar.html#images
[2]: http://buzzard.ups.edu/courses/2007spring/projects/million-paper.pdf
[3]: https://www.math.washington.edu/~morrow/464\_12/fft.pdf