"math" --- 수학 함수
********************

======================================================================

이 모듈은 C 표준에서 정의된 수학 함수에 대한 액세스를 제공합니다.

이 함수는 복소수와 함께 사용할 수 없습니다; 복소수를 지원해야 하면
"cmath" 모듈에 있는 같은 이름의 함수를 사용하십시오. 대부분 사용자는
복소수를 이해하는 데 필요한 수준의 수학을 배우고 싶어 하지 않기 때문에
복소수를 지원하는 함수와 그렇지 않은 함수를 구별했습니다. 복소수 결과
대신 예외를 수신하면 매개 변수로 사용된 예상치 못한 복소수를 조기에 감
지할 수 있기 때문에, 프로그래머는 처음 위치에서 생성된 경로와 원인을
파악할 수 있습니다.

이 모듈에서 제공하는 함수는 다음과 같습니다. 달리 명시되지 않는 한 모
든 반환 값은 float입니다.


Number-theoretic and representation functions
=============================================

math.ceil(x)

   *x*보다 크거나 같은 가장 작은 정수인 *x*의 천장값(ceiling)을 반환합
   니다. *x*가 float가 아니면, "x.__ceil__"에 위임하고, 이것은
   "Integral" 값을 반환해야 합니다.

math.comb(n, k)

   반복과 순서 없이 *n* 개의 항목에서 *k* 개의 항목을 선택하는 방법의
   수를 반환합니다.

   "k <= n"이면 "n! / (k! * (n - k)!)"로 평가되고, "k > n"이면 0으로
   평가됩니다.

   "(1 + x)ⁿ"의 다항식 전개에서 k 번째 항의 계수와 같기 때문에 이항 계
   수(binomial coefficient)라고도 합니다.

   인자 중 어느 하나라도 정수가 아니면 "TypeError"를 발생시킵니다. 인
   자 중 어느 하나라도 음수이면 "ValueError"를 발생시킵니다.

   Added in version 3.8.

math.copysign(x, y)

   *x*의 크기(절댓값)와 *y*의 부호를 갖는 float를 반환합니다. 부호 있
   는 0을 지원하는 플랫폼에서, "copysign(1.0, -0.0)"은 *-1.0*을 반환합
   니다.

math.fabs(x)

   *x*의 절댓값을 반환합니다.

math.factorial(n)

   *n* 계승(factorial)을 정수로 반환합니다. *n*이 정수(integral)가 아
   니거나 음수면 "ValueError"를 발생시킵니다.

   버전 3.9부터 폐지됨: Accepting floats with integral values (like
   "5.0") is deprecated.

math.floor(x)

   *x*보다 작거나 같은 가장 큰 정수인 *x*의 바닥값(floor)을 반환합니다
   . *x*가 float가 아니면, "x.__floor__"에 위임하고, 이것은 "Integral"
   값을 반환해야 합니다.

math.fmod(x, y)

   플랫폼 C 라이브러리 함수 "fmod(x, y)"이 정의한 대로, "x / y"의 부동
   소수점 나머지를 반환합니다. 파이썬 표현식 "x % y"가 같은 결과를 반
   환하지 않을 수 있음에 유의하십시오. C 표준의 의도는 어떤 정수 *n*에
   대해 "fmod(x, y)"가 "x - n*y"와 정확히 (수학적으로; 무한 정밀도로)
   같고, 결과는 *x*와 같은 부호를 가지며 크기(절댓값)는 "abs(y)"보다
   작아지도록 하는 것입니다. 파이썬의 "x % y"는 대신 *y*의 부호를 갖는
   결과를 반환하며 float 인자에 대해 정확하게 계산할 수 없을 수 있습니
   다. 예를 들어, "fmod(-1e-100, 1e100)"는 "-1e-100"이지만, 파이썬의
   "-1e-100 % 1e100"의 결과는 "1e100-1e-100"이며, 부동 소수점으로 정확
   하게 표현할 수 없어서, 의외의 "1e100"으로 반올림됩니다. 이러한 이유
   로, 함수 "fmod()"는 일반적으로 float로 작업할 때 선호되는 반면 파이
   썬의 "x % y"는 정수로 작업할 때 선호됩니다.

math.frexp(x)

   *x*의 가수(mantissa)와 지수(exponent)를 "(m, e)" 쌍으로 반환합니다.
   *m*은 float이고, *e*는 정수이며, 정확히 "x == m * 2**e"가 성립합니
   다. *x*가 0이면, "(0.0, 0)"을 반환하고, 그렇지 않으면 "0.5 <=
   abs(m) < 1"입니다. 이것은 float의 내부 표현을 이식성 있는 방식으로
   "분리"하는 데 사용됩니다.

math.fsum(iterable)

   이터러블(iterable)에 있는 값의 정확한(accurate) 부동 소수점 합을 반
   환합니다. 여러 중간 부분 합을 추적하여 정밀도 손실을 방지합니다.

   알고리즘의 정확도는 IEEE-754 산술의 보증과 자리 올림 모드가 짝수로
   반올림(half-even)인 일반적인 경우에 의존합니다. 윈도우 이외의 일부
   빌드에서, 하부 C 라이브러리는 확장 정밀도 덧셈을 사용하고, 때때로
   중간 합을 이중 자리 올림(double-round) 하여 최하위 비트(least
   significant bit)에서 분리할 수 있습니다.

   자세한 논의와 두 가지 대안은, ASPN cookbook recipes for accurate
   floating point summation을 참조하십시오.

math.gcd(*integers)

   지정된 정수 인자의 최대 공약수를 반환합니다. 인자 중 하나가 0이 아
   니면, 반환된 값은 모든 인자를 나누는 가장 큰 양의 정수입니다. 모든
   인자가 0이면, 반환 값은 "0"입니다. 인자가 없는 "gcd()"는 "0"을 반환
   합니다.

   Added in version 3.5.

   버전 3.9에서 변경: 임의의 개수 인자에 대한 지원이 추가되었습니다.
   이전에는, 단지 두 개의 인자만 지원되었습니다.

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

   값 *a*와 *b*가 서로 가까이 있으면 "True"를, 그렇지 않으면 "False"를
   반환합니다.

   두 값이 근접한 것으로 간주하는지는 주어진 절대와 상대 허용 오차에
   따라 결정됩니다. 에러가 발생하지 않으면, 결과는 다음과 같습니다:
   "abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)".

   *rel_tol*은 상대 허용 오차입니다 -- *a*와 *b* 중 더 큰 절댓값에 대
   해 상대적으로, *a*와 *b* 간에 허용되는 최대 차이입니다. 예를 들어,
   허용 오차를 5%로 설정하려면, "rel_tol=0.05"를 전달하십시오. 기본 허
   용 오차는 "1e-09"이며, 두 값이 약 9자리 십진 숫자 내에서 같다는 것
   을 보장합니다. *rel_tol*은 음이 아니고 "1.0"보다 작아야 합니다.

   *abs_tol* is the absolute tolerance; it defaults to "0.0" and it
   must be nonnegative.  When comparing "x" to "0.0", "isclose(x, 0)"
   is computed as "abs(x) <= rel_tol  * abs(x)", which is "False" for
   any nonzero "x" and *rel_tol* less than "1.0".  So add an
   appropriate positive *abs_tol* argument to the call.

   IEEE 754 특수 값 "NaN", "inf" 및 "-inf"는 IEEE 규칙에 따라 처리됩니
   다. 특히, "NaN"은 "NaN"을 포함하여 다른 어떤 값과도 근접한 것으로
   간주하지 않습니다. "inf"와 "-inf"는 오직 자신과만 가까운 것으로 간
   주합니다.

   Added in version 3.5.

   더 보기: **PEP 485** -- 근사적 동등성을 검사하는 함수

math.isfinite(x)

   *x*가 무한대나 NaN이 아니면 "True"를, 그렇지 않으면 "False"를 반환
   합니다. ("0.0"은 *유한*한 것으로 간주합니다.)

   Added in version 3.2.

math.isinf(x)

   *x*가 양 또는 음의 무한대이면 "True"를, 그렇지 않으면 "False"를 반
   환합니다.

math.isnan(x)

   *x*가 NaN(not a number)이면 "True"를, 그렇지 않으면 "False"를 반환
   합니다.

math.isqrt(n)

   음이 아닌 정수 *n*의 정수 제곱근을 반환합니다. 이것은 *n*의 정확한
   제곱근의 바닥(floor)입니다, 또는, 동등하게, *a*² ≤ *n*을 만족하는
   가장 큰 정수 *a*입니다.

   일부 응용 프로그램에서는, *n* ≤ *a*² 을 만족하는 가장 작은 정수
   *a*, 즉 *n*의 정확한 제곱근의 천장(ceiling)을 구하는 것이 더 편리합
   니다. 양의 *n*에 대해, 이것은 "a = 1 + isqrt(n - 1)"을 사용하여 계
   산할 수 있습니다.

   Added in version 3.8.

math.lcm(*integers)

   지정된 정수 인자의 최소 공배수를 반환합니다. 모든 인자가 0이 아니면
   , 반환 값은 모든 인자의 배수인 가장 작은 양의 정수입니다. 인자 중
   어느 하나가 0이면, 반환 값은 "0"입니다. 인자가 없는 "lcm()"은 "1"을
   반환합니다.

   Added in version 3.9.

math.ldexp(x, i)

   "x * (2**i)"를 반환합니다. 이것은 본질적으로 함수 "frexp()"의 역입
   니다.

math.modf(x)

   *x*의 소수와 정수 부분을 반환합니다. 두 결과 모두 *x*의 부호를 가지
   며 float입니다.

math.nextafter(x, y, steps=1)

   *x*에서 *y* 방향으로 *steps* 스텝 다음의 부동 소수점 값을 반환합니
   다.

   *x*가 *y*와 같으면, *steps*이 0이 아닌 한 *y*를 반환합니다.

   예:

   * "math.nextafter(x, math.inf)"는 올라갑니다: 양의 무한대를 향해.

   * "math.nextafter(x, -math.inf)"는 내려갑니다: 음의 무한대를 향해.

   * "math.nextafter(x, 0.0)"는 0을 향합니다.

   * "math.nextafter(x, math.copysign(math.inf, x))"는 0에서 멀어집니
     다.

   "math.ulp()"도 참조하십시오.

   Added in version 3.9.

   버전 3.12에서 변경: *steps* 인자를 추가했습니다.

math.perm(n, k=None)

   반복 없고 순서 있게 *n* 개의 항목에서 *k* 개의 항목을 선택하는 방법
   의 수를 반환합니다.

   "k <= n"이면 "n! / (n - k)!" 로 평가되고, "k > n"이면 0으로 평가됩
   니다.

   *k*가 지정되지 않거나 "None"이면, *k*의 기본값은 *n*이고 함수는
   "n!" 을 반환합니다.

   인자 중 어느 하나라도 정수가 아니면 "TypeError"를 발생시킵니다. 인
   자 중 어느 하나라도 음수이면 "ValueError"를 발생시킵니다.

   Added in version 3.8.

math.prod(iterable, *, start=1)

   입력 *이터러블(iterable)*에 있는 모든 요소의 곱을 계산합니다. 곱의
   기본 *start* 값은 "1"입니다.

   iterable이 비어 있으면, start 값을 반환합니다. 이 함수는 숫자 값과
   함께 사용하기 위한 것으로, 숫자가 아닌 형을 거부 할 수 있습니다.

   Added in version 3.8.

math.remainder(x, y)

   *y*에 대한 *x*의 IEEE 754 스타일 나머지를 반환합니다. 유한한 *x* 와
   0이 아닌 유한한 *y*에 대해, 이것은 차이 "x - n*y"입니다. 여기서 "n"
   은 몫 "x / y"의 정확한 값에 가장 가까운 정수입니다. "x / y"가 두 개
   의 인접한 정수 사이의 정확히 중간이면, 가장 가까운 *짝수* 정수가
   "n"으로 사용됩니다. 따라서 나머지 "r = remainder(x, y)"는 항상
   "abs(r) <= 0.5 * abs(y)"를 만족합니다.

   IEEE 754에 따른 특별한 경우: 특히, "remainder(x, math.inf)"는 모든
   유한한 *x*에 대해서는 *x*이고, "remainder(x, 0)"과
   "remainder(math.inf, x)"는 모든 NaN이 아닌 *x*에 대해 "ValueError"
   를 발생시킵니다. 나머지 연산의 결과가 0이면, 해당 0은 *x* 와 같은
   부호를 갖습니다.

   IEEE 754 이진 부동 소수점을 사용하는 플랫폼에서, 이 연산의 결과는
   항상 정확하게 표현 가능합니다: 자리 올림 오차는 발생하지 않습니다.

   Added in version 3.7.

math.sumprod(p, q)

   Return the sum of products of values from two iterables *p* and
   *q*.

   Raises "ValueError" if the inputs do not have the same length.

   대략 다음과 동등합니다:

      sum(itertools.starmap(operator.mul, zip(p, q, strict=True)))

   For float and mixed int/float inputs, the intermediate products and
   sums are computed with extended precision.

   Added in version 3.12.

math.trunc(x)

   Return *x* with the fractional part removed, leaving the integer
   part.  This rounds toward 0: "trunc()" is equivalent to "floor()"
   for positive *x*, and equivalent to "ceil()" for negative *x*. If
   *x* is not a float, delegates to "x.__trunc__", which should return
   an "Integral" value.

math.ulp(x)

   float *x*의 최하위 비트 값을 반환합니다:

   * *x*가 NaN(not a number)이면, *x*를 반환합니다.

   * *x*가 음수이면, "ulp(-x)"를 반환합니다.

   * *x*가 양의 무한대이면, *x*를 반환합니다.

   * *x*가 0과 같으면, 가장 작은 양의 *정규화되지 않은(denormalized)*
     표현 가능한 float를 반환합니다 (가장 작은 양의 *정규화된* float,
     "sys.float_info.min"보다 작습니다).

   * *x*가 가장 큰 양의 표현 가능한 float와 같으면, *x*보다 작은 첫 번
     째 float가 "x - ulp(x)"가 되도록, *x*의 최하위 비트 값을 반환합니
     다.

   * 그렇지 않으면 (*x*가 양의 유한 수이면), *x*보다 큰 첫 번째 float
     가 "x + ulp(x)"가 되도록, *x*의 최하위 비트 값을 반환합니다.

   ULP는 "Unit in the Last Place(마지막 자리의 단위)"를 나타냅니다.

   "math.nextafter()"와 "sys.float_info.epsilon"도 참조하십시오.

   Added in version 3.9.

Note that "frexp()" and "modf()" have a different call/return pattern
than their C equivalents: they take a single argument and return a
pair of values, rather than returning their second return value
through an 'output parameter' (there is no such thing in Python).

"ceil()", "floor()" 및 "modf()" 함수의 경우, 충분히 큰 절댓값을 갖는 *
모든* 부동 소수점 숫자는 정확한 정수입니다. 파이썬 float는 일반적으로
53비트 이하의 정밀도를 가지는데 (플랫폼 C double 형과 같습니다), 이때
"abs(x) >= 2**52"를 만족하는 모든 float *x*는 소수 비트를 갖지 않습니
다.


Power and logarithmic functions
===============================

math.cbrt(x)

   *x*의 세제곱근을 반환합니다.

   Added in version 3.11.

math.exp(x)

   *e*의 *x* 거듭제곱을 반환합니다. 여기서 *e* = 2.718281... 는 자연로
   그의 밑(base)입니다. 일반적으로 "math.e ** x"나 "pow(math.e, x)"보
   다 정확합니다.

math.exp2(x)

   *2*의 *x* 거듭제곱을 반환합니다.

   Added in version 3.11.

math.expm1(x)

   *e*의 *x* 거듭제곱에서 1을 뺀 값을 반환합니다. 여기서 *e*는 자연로
   그의 밑(base)입니다. 작은 float *x*의 경우, "exp(x) - 1"의 뺄셈은
   상당한 정밀도 소실을 일으킬 수 있습니다; "expm1()" 함수는 이 양을
   최대 정밀도로 계산하는 방법을 제공합니다:

   >>> from math import exp, expm1
   >>> exp(1e-5) - 1  # gives result accurate to 11 places
   1.0000050000069649e-05
   >>> expm1(1e-5)    # result accurate to full precision
   1.0000050000166668e-05

   Added in version 3.2.

math.log(x[, base])

   하나의 인자를 제공하면, *x*의 자연로그를 반환합니다 (밑 *e*).

   두 개의 인자를 제공하면, 주어진 *밑(base)*으로 *x*의 로그를 반환합
   니다, "log(x)/log(base)"로 계산합니다.

math.log1p(x)

   *1+x*의 자연로그를 반환합니다 (밑 *e*). 결과는 0에 가까운 *x*에 대
   해 정확한 방식으로 계산됩니다.

math.log2(x)

   *x*의 밑이 2인 로그를 반환합니다. 이것은 일반적으로 "log(x, 2)"보다
   정확합니다.

   Added in version 3.3.

   더 보기:

     "int.bit_length()"는 부호와 선행 0을 제외하고 정수를 이진수로 나
     타내는 데 필요한 비트 수를 반환합니다.

math.log10(x)

   *x*의 밑이 10인 로그를 반환합니다. 이것은 일반적으로 "log(x, 10)"보
   다 정확합니다.

math.pow(x, y)

   Return "x" raised to the power "y".  Exceptional cases follow the
   IEEE 754 standard as far as possible.  In particular, "pow(1.0, x)"
   and "pow(x, 0.0)" always return "1.0", even when "x" is a zero or a
   NaN.  If both "x" and "y" are finite, "x" is negative, and "y" is
   not an integer then "pow(x, y)" is undefined, and raises
   "ValueError".

   내장 "**" 연산자와 달리, "math.pow()"는 두 인자를 모두 "float" 형으
   로 변환합니다. 정확한 정수 거듭제곱을 계산하려면 "**"나 내장
   "pow()" 함수를 사용하십시오.

   버전 3.11에서 변경: The special cases "pow(0.0, -inf)" and
   "pow(-0.0, -inf)" were changed to return "inf" instead of raising
   "ValueError", for consistency with IEEE 754.

math.sqrt(x)

   *x*의 제곱근을 반환합니다.


삼각 함수
=========

math.acos(x)

   *x*의 아크 코사인(arc cosine)을 라디안으로 반환합니다. 결과는 "0"과
   "pi" 사이입니다.

math.asin(x)

   *x*의 아크 사인(arc sine)을 라디안으로 반환합니다. 결과는 "-pi/2"와
   "pi/2" 사이입니다.

math.atan(x)

   *x*의 아크 탄젠트(arc tangent)를 라디안으로 반환합니다. 결과는
   "-pi/2"와 "pi/2" 사이입니다.

math.atan2(y, x)

   "atan(y / x)"를 라디안으로 반환합니다. 결과는 "-pi"와 "pi" 사이입니
   다. 평면에 있는 원점에서 점 "(x, y)"까지의 벡터는 양의 X 축과 이 각
   도를 이룹니다. "atan2()"의 요점은 두 입력의 부호가 모두 알려져 있기
   때문에 각도에 대한 정확한 사분면을 계산할 수 있다는 것입니다. 예를
   들어, "atan(1)"과 "atan2(1, 1)"은 모두 "pi/4"이지만, "atan2(-1,
   -1)"은 "-3*pi/4"입니다.

math.cos(x)

   *x* 라디안의 코사인(cosine)을 반환합니다.

math.dist(p, q)

   각각 좌표 시퀀스(또는 이터러블)로 제공되는, 두 점 *p*와 *q* 사이의
   유클리드 거리를 반환합니다. 두 점의 차원(dimension)은 같아야 합니다
   .

   대략 다음과 동등합니다:

      sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))

   Added in version 3.8.

math.hypot(*coordinates)

   유클리드 크기(norm) "sqrt(sum(x**2 for x in coordinates))"를 반환합
   니다. 원점에서 coordinates로 지정된 점까지의 벡터의 길이입니다.

   2차원 점 "(x, y)"의 경우, 피타고라스 정리를 사용하여 직각 삼각형의
   빗변(hypotenuse)을 계산하는 것과 동등합니다, "sqrt(x*x + y*y)".

   버전 3.8에서 변경: n 차원 점에 대한 지원이 추가되었습니다. 이전에는
   , 2차원인 경우만 지원되었습니다.

   버전 3.10에서 변경: Improved the algorithm's accuracy so that the
   maximum error is under 1 ulp (unit in the last place).  More
   typically, the result is almost always correctly rounded to within
   1/2 ulp.

math.sin(x)

   *x* 라디안의 사인(sine)을 반환합니다.

math.tan(x)

   *x* 라디안의 탄젠트(tangent)를 반환합니다.


각도 변환
=========

math.degrees(x)

   각도 *x*를 라디안에서 도(degree)로 변환합니다.

math.radians(x)

   각도 *x*를 도(degree)에서 라디안으로 변환합니다.


쌍곡선 함수
===========

쌍곡선 함수는 원 대신 쌍곡선을 기반으로 하는 삼각 함수의 동류(analog)
입니다.

math.acosh(x)

   *x*의 역 쌍곡 코사인(inverse hyperbolic cosine)을 반환합니다.

math.asinh(x)

   *x*의 역 쌍곡 사인(inverse hyperbolic sine)을 반환합니다.

math.atanh(x)

   *x*의 역 쌍곡 탄젠트(inverse hyperbolic tangent)를 반환합니다.

math.cosh(x)

   *x*의 쌍곡 코사인(hyperbolic cosine)을 반환합니다.

math.sinh(x)

   *x*의 쌍곡 사인(hyperbolic sine)을 반환합니다.

math.tanh(x)

   *x*의 쌍곡 탄젠트(hyperbolic tangent)를 반환합니다.


특수 함수
=========

math.erf(x)

   *x*의 오차 함수(error function)를 반환합니다.

   "erf()" 함수는 누적 표준 정규 분포와 같은 전통적인 통계 함수를 계산
   하는 데 사용할 수 있습니다:

      def phi(x):
          '표준 정규 분포의 누적 분포 함수'
          return (1.0 + erf(x / sqrt(2.0))) / 2.0

   Added in version 3.2.

math.erfc(x)

   *x*의 여오차 함수를 반환합니다. 여오차 함수(complementary error
   function)는 "1.0 - erf(x)"로 정의됩니다. 뺄셈으로 인해 유효 숫자의
   소실이 발생하는 *x*의 큰 값에 사용됩니다.

   Added in version 3.2.

math.gamma(x)

   *x*의 감마 함수(Gamma function)를 반환합니다.

   Added in version 3.2.

math.lgamma(x)

   *x*의 감마 함수의 절댓값의 자연로그를 반환합니다.

   Added in version 3.2.


상수
====

math.pi

   사용 가능한 정밀도로, 수학 상수 *π* = 3.141592...

math.e

   사용 가능한 정밀도로, 수학 상수 *e* = 2.718281...

math.tau

   사용 가능한 정밀도로, 수학 상수 *τ* = 6.283185... 타우(tau)는 원주
   와 반지름의 비율인 2*π*에 해당하는 원 상수입니다. 타우에 대한 자세
   한 내용은, Vi Hart의 비디오 Pi is (still) Wrongdmf 확인하고, 두 배
   의 파이를 먹는 것으로 타우 데이(Tau day)를 축하하십시오!

   Added in version 3.6.

math.inf

   부동 소수점 양의 무한대. (음의 무한대는 "-math.inf"를 사용하십시오
   .) "float('inf')"의 출력과 동등합니다.

   Added in version 3.5.

math.nan

   A floating-point "not a number" (NaN) value. Equivalent to the
   output of "float('nan')". Due to the requirements of the IEEE-754
   standard, "math.nan" and "float('nan')" are not considered to equal
   to any other numeric value, including themselves. To check whether
   a number is a NaN, use the "isnan()" function to test for NaNs
   instead of "is" or "==". Example:

   >>> import math
   >>> math.nan == math.nan
   False
   >>> float('nan') == float('nan')
   False
   >>> math.isnan(math.nan)
   True
   >>> math.isnan(float('nan'))
   True

   Added in version 3.5.

   버전 3.11에서 변경: It is now always available.

"math" 모듈은 대부분 플랫폼 C 수학 라이브러리 함수 주위의 얇은 래퍼로
구성됩니다. 예외적인 경우의 행동은 적절한 경우 C99 표준의 부록 F를 따
릅니다. 현재 구현은 "sqrt(-1.0)"이나 "log(0.0)"과 같은 잘못된 연산의
경우 "ValueError"를 발생시키고 (C99 부록 F에서 잘못된 연산이나 0으로
나누기를 신호를 주도록 권장하는 경우), 오버플로 하는 결과(예를 들어,
"exp(1000.0)")의 경우 "OverflowError"를 발생시킵니다. 하나 이상의 입력
인자가 NaN이 아니면, NaN은 위의 함수에서 반환되지 않습니다; 입력 인자
가 NaN이면 대부분 함수는 NaN을 반환하지만, (다시 한번 C99 부록 F를 따
라) 이 규칙에는 예를 들어 "pow(float('nan'), 0.0)"이나
"hypot(float('nan'), float('inf'))"와 같은 몇 가지 예외가 있습니다.

파이썬은 신호를 주는 NaN(signaling NaN)을 조용한 NaN(quiet NaN)과 구별
하기 위해 노력하지 않으며, 신호를 주는 NaN의 동작은 지정되지 않은 상태
로 남아 있습니다. 일반적인 동작은 모든 NaN을 조용한 것으로 취급하는 것
입니다.

더 보기:

  모듈 "cmath"
     이 함수 중 많은 것들의 복소수 버전.
