math.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-01-05 00:15+0000\n"
"PO-Revision-Date: 2024-04-26 15:15+0800\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Poedit 3.4.2\n"

#: ../../library/math.rst:2
msgid ":mod:`!math` --- Mathematical functions"
msgstr ":mod:`!math` --- 數學函式"

#: ../../library/math.rst:13
msgid ""
"This module provides access to the mathematical functions defined by the C "
"standard."
msgstr "此模組提供對 C 標準中定義的數學相關函式的存取。"

#: ../../library/math.rst:16
msgid ""
"These functions cannot be used with complex numbers; use the functions of "
"the same name from the :mod:`cmath` module if you require support for "
"complex numbers.  The distinction between functions which support complex "
"numbers and those which don't is made since most users do not want to learn "
"quite as much mathematics as required to understand complex numbers.  "
"Receiving an exception instead of a complex result allows earlier detection "
"of the unexpected complex number used as a parameter, so that the programmer "
"can determine how and why it was generated in the first place."
msgstr ""
"這些函式不支援複數；若你需要計算複數，請使用 :mod:`cmath` 模組的同名函式。這"
"是因為大多數的使用者並不想學習那麼多理解複數所需的數學概念，所以根據支援複數"
"與否分為兩種函式。收到一個例外而非複數回傳值，有助於程式設計師提早察覺參數中"
"包含非預期的複數，進而從源頭查出導致此情況的原因。"

#: ../../library/math.rst:25
msgid ""
"The following functions are provided by this module.  Except when explicitly "
"noted otherwise, all return values are floats."
msgstr "此模組提供下列函式。除非特意註明，否則回傳值皆為浮點數。"

#: ../../library/math.rst:30
msgid "**Number-theoretic functions**"
msgstr "**數論函式**"

#: ../../library/math.rst:32
msgid ":func:`comb(n, k) <comb>`"
msgstr ":func:`comb(n, k) <comb>`"

#: ../../library/math.rst:32
msgid ""
"Number of ways to choose *k* items from *n* items without repetition and "
"without order"
msgstr "從 *n* 個物品中不重複且不考慮排序地取出 *k* 個物品的方法數。"

#: ../../library/math.rst:33
msgid ":func:`factorial(n) <factorial>`"
msgstr ":func:`factorial(n) <factorial>`"

#: ../../library/math.rst:33
msgid "*n* factorial"
msgstr ""

#: ../../library/math.rst:34
msgid ":func:`gcd(*integers) <gcd>`"
msgstr ":func:`gcd(*integers) <gcd>`"

#: ../../library/math.rst:34
msgid "Greatest common divisor of the integer arguments"
msgstr ""

#: ../../library/math.rst:35
msgid ":func:`isqrt(n) <isqrt>`"
msgstr ":func:`isqrt(n) <isqrt>`"

#: ../../library/math.rst:35
msgid "Integer square root of a nonnegative integer *n*"
msgstr ""

#: ../../library/math.rst:36
msgid ":func:`lcm(*integers) <lcm>`"
msgstr ":func:`lcm(*integers) <lcm>`"

#: ../../library/math.rst:36
msgid "Least common multiple of the integer arguments"
msgstr ""

#: ../../library/math.rst:37
msgid ":func:`perm(n, k) <perm>`"
msgstr ":func:`perm(n, k) <perm>`"

#: ../../library/math.rst:37
msgid ""
"Number of ways to choose *k* items from *n* items without repetition and "
"with order"
msgstr "從 *n* 個物品中不重複但考慮排序地取出 *k* 個物品的方法數。"

#: ../../library/math.rst:39
msgid "**Floating point arithmetic**"
msgstr ""

#: ../../library/math.rst:41
msgid ":func:`ceil(x) <ceil>`"
msgstr ":func:`ceil(x) <ceil>`"

#: ../../library/math.rst:41
msgid "Ceiling of *x*, the smallest integer greater than or equal to *x*"
msgstr ""

#: ../../library/math.rst:42
msgid ":func:`fabs(x) <fabs>`"
msgstr ":func:`fabs(x) <fabs>`"

#: ../../library/math.rst:42
msgid "Absolute value of *x*"
msgstr "*x* 的絕對值。"

#: ../../library/math.rst:43
msgid ":func:`floor(x)  <floor>`"
msgstr ":func:`floor(x)  <floor>`"

#: ../../library/math.rst:43
msgid "Floor of *x*, the largest integer less than or equal to *x*"
msgstr ""

#: ../../library/math.rst:44
msgid ":func:`fma(x, y, z) <fma>`"
msgstr ":func:`fma(x, y, z) <fma>`"

#: ../../library/math.rst:44
msgid "Fused multiply-add operation: ``(x * y) + z``"
msgstr ""

#: ../../library/math.rst:45
msgid ":func:`fmod(x, y) <fmod>`"
msgstr ":func:`fmod(x, y) <fmod>`"

#: ../../library/math.rst:45
msgid "Remainder of division ``x / y``"
msgstr ""

#: ../../library/math.rst:46
msgid ":func:`modf(x) <modf>`"
msgstr ":func:`modf(x) <modf>`"

#: ../../library/math.rst:46
msgid "Fractional and integer parts of *x*"
msgstr ""

#: ../../library/math.rst:47
msgid ":func:`remainder(x, y) <remainder>`"
msgstr ":func:`remainder(x, y) <remainder>`"

#: ../../library/math.rst:47
msgid "Remainder of *x* with respect to *y*"
msgstr ""

#: ../../library/math.rst:48
msgid ":func:`trunc(x) <trunc>`"
msgstr ":func:`trunc(x) <trunc>`"

#: ../../library/math.rst:48
msgid "Integer part of *x*"
msgstr ""

#: ../../library/math.rst:50
msgid "**Floating point manipulation functions**"
msgstr "**浮點數操作函式**"

#: ../../library/math.rst:52
msgid ":func:`copysign(x, y) <copysign>`"
msgstr ":func:`copysign(x, y) <copysign>`"

#: ../../library/math.rst:52
msgid "Magnitude (absolute value) of *x* with the sign of *y*"
msgstr ""

#: ../../library/math.rst:53
msgid ":func:`frexp(x) <frexp>`"
msgstr ":func:`frexp(x) <frexp>`"

#: ../../library/math.rst:53
msgid "Mantissa and exponent of *x*"
msgstr ""

#: ../../library/math.rst:54
msgid ":func:`isclose(a, b, rel_tol, abs_tol) <isclose>`"
msgstr ":func:`isclose(a, b, rel_tol, abs_tol) <isclose>`"

#: ../../library/math.rst:54
msgid "Check if the values *a* and *b* are close to each other"
msgstr ""

#: ../../library/math.rst:55
msgid ":func:`isfinite(x) <isfinite>`"
msgstr ":func:`isfinite(x) <isfinite>`"

#: ../../library/math.rst:55
msgid "Check if *x* is neither an infinity nor a NaN"
msgstr ""

#: ../../library/math.rst:56
msgid ":func:`isinf(x) <isinf>`"
msgstr ":func:`isinf(x) <isinf>`"

#: ../../library/math.rst:56
msgid "Check if *x* is a positive or negative infinity"
msgstr ""

#: ../../library/math.rst:57
msgid ":func:`isnan(x) <isnan>`"
msgstr ":func:`isnan(x) <isnan>`"

#: ../../library/math.rst:57
msgid "Check if *x* is a NaN  (not a number)"
msgstr ""

#: ../../library/math.rst:58
msgid ":func:`ldexp(x, i) <ldexp>`"
msgstr ":func:`ldexp(x, i) <ldexp>`"

#: ../../library/math.rst:58
msgid "``x * (2**i)``, inverse of function :func:`frexp`"
msgstr ""

#: ../../library/math.rst:59
msgid ":func:`nextafter(x, y, steps) <nextafter>`"
msgstr ":func:`nextafter(x, y, steps) <nextafter>`"

#: ../../library/math.rst:59
msgid "Floating-point value *steps* steps after *x* towards *y*"
msgstr ""

#: ../../library/math.rst:60
msgid ":func:`ulp(x) <ulp>`"
msgstr ":func:`ulp(x) <ulp>`"

#: ../../library/math.rst:60
msgid "Value of the least significant bit of *x*"
msgstr ""

#: ../../library/math.rst:62
msgid "**Power, exponential and logarithmic functions**"
msgstr ""

#: ../../library/math.rst:64
msgid ":func:`cbrt(x) <cbrt>`"
msgstr ":func:`cbrt(x) <cbrt>`"

#: ../../library/math.rst:64
msgid "Cube root of *x*"
msgstr ""

#: ../../library/math.rst:65
msgid ":func:`exp(x) <exp>`"
msgstr ":func:`exp(x) <exp>`"

#: ../../library/math.rst:65
msgid "*e* raised to the power *x*"
msgstr ""

#: ../../library/math.rst:66
msgid ":func:`exp2(x) <exp2>`"
msgstr ":func:`exp2(x) <exp2>`"

#: ../../library/math.rst:66
msgid "*2* raised to the power *x*"
msgstr ""

#: ../../library/math.rst:67
msgid ":func:`expm1(x) <expm1>`"
msgstr ":func:`expm1(x) <expm1>`"

#: ../../library/math.rst:67
msgid "*e* raised to the power *x*, minus 1"
msgstr ""

#: ../../library/math.rst:68
msgid ":func:`log(x, base) <log>`"
msgstr ":func:`log(x, base) <log>`"

#: ../../library/math.rst:68
msgid "Logarithm of *x* to the given base (*e* by default)"
msgstr ""

#: ../../library/math.rst:69
msgid ":func:`log1p(x) <log1p>`"
msgstr ":func:`log1p(x) <log1p>`"

#: ../../library/math.rst:69
msgid "Natural logarithm of *1+x* (base *e*)"
msgstr ""

#: ../../library/math.rst:70
msgid ":func:`log2(x) <log2>`"
msgstr ":func:`log2(x) <log2>`"

#: ../../library/math.rst:70
msgid "Base-2 logarithm of *x*"
msgstr ""

#: ../../library/math.rst:71
msgid ":func:`log10(x) <log10>`"
msgstr ":func:`log10(x) <log10>`"

#: ../../library/math.rst:71
msgid "Base-10 logarithm of *x*"
msgstr ""

#: ../../library/math.rst:72
msgid ":func:`pow(x, y) <math.pow>`"
msgstr ":func:`pow(x, y) <math.pow>`"

#: ../../library/math.rst:72
msgid "*x* raised to the power *y*"
msgstr ""

#: ../../library/math.rst:73
msgid ":func:`sqrt(x) <sqrt>`"
msgstr ":func:`sqrt(x) <sqrt>`"

#: ../../library/math.rst:73
msgid "Square root of *x*"
msgstr "*x* 的平方根"

#: ../../library/math.rst:75
msgid "**Summation and product functions**"
msgstr ""

#: ../../library/math.rst:77
msgid ":func:`dist(p, q) <dist>`"
msgstr ":func:`dist(p, q) <dist>`"

#: ../../library/math.rst:77
msgid ""
"Euclidean distance between two points *p* and *q* given as an iterable of "
"coordinates"
msgstr ""

#: ../../library/math.rst:78
msgid ":func:`fsum(iterable) <fsum>`"
msgstr ":func:`fsum(iterable) <fsum>`"

#: ../../library/math.rst:78
msgid "Sum of values in the input *iterable*"
msgstr ""

#: ../../library/math.rst:79
msgid ":func:`hypot(*coordinates) <hypot>`"
msgstr ":func:`hypot(*coordinates) <hypot>`"

#: ../../library/math.rst:79
msgid "Euclidean norm of an iterable of coordinates"
msgstr ""

#: ../../library/math.rst:80
msgid ":func:`prod(iterable, start) <prod>`"
msgstr ":func:`prod(iterable, start) <prod>`"

#: ../../library/math.rst:80
msgid "Product of elements in the input *iterable* with a *start* value"
msgstr ""

#: ../../library/math.rst:81
msgid ":func:`sumprod(p, q) <sumprod>`"
msgstr ":func:`sumprod(p, q) <sumprod>`"

#: ../../library/math.rst:81
msgid "Sum of products from two iterables *p* and *q*"
msgstr ""

#: ../../library/math.rst:83
msgid "**Angular conversion**"
msgstr ""

#: ../../library/math.rst:85
msgid ":func:`degrees(x) <degrees>`"
msgstr ":func:`degrees(x) <degrees>`"

#: ../../library/math.rst:85
msgid "Convert angle *x* from radians to degrees"
msgstr ""

#: ../../library/math.rst:86
msgid ":func:`radians(x) <radians>`"
msgstr ":func:`radians(x) <radians>`"

#: ../../library/math.rst:86
msgid "Convert angle *x* from degrees to radians"
msgstr ""

#: ../../library/math.rst:88
msgid "**Trigonometric functions**"
msgstr ""

#: ../../library/math.rst:90
msgid ":func:`acos(x) <acos>`"
msgstr ":func:`acos(x) <acos>`"

#: ../../library/math.rst:90
msgid "Arc cosine of *x*"
msgstr ""

#: ../../library/math.rst:91
msgid ":func:`asin(x) <asin>`"
msgstr ":func:`asin(x) <asin>`"

#: ../../library/math.rst:91
msgid "Arc sine of *x*"
msgstr ""

#: ../../library/math.rst:92
msgid ":func:`atan(x) <atan>`"
msgstr ":func:`atan(x) <atan>`"

#: ../../library/math.rst:92
msgid "Arc tangent of *x*"
msgstr ""

#: ../../library/math.rst:93
msgid ":func:`atan2(y, x) <atan2>`"
msgstr ":func:`atan2(y, x) <atan2>`"

#: ../../library/math.rst:93
msgid "``atan(y / x)``"
msgstr "``atan(y / x)``"

#: ../../library/math.rst:94
msgid ":func:`cos(x) <cos>`"
msgstr ":func:`cos(x) <cos>`"

#: ../../library/math.rst:94
msgid "Cosine of *x*"
msgstr ""

#: ../../library/math.rst:95
msgid ":func:`sin(x) <sin>`"
msgstr ":func:`sin(x) <sin>`"

#: ../../library/math.rst:95
msgid "Sine of *x*"
msgstr ""

#: ../../library/math.rst:96
msgid ":func:`tan(x) <tan>`"
msgstr ":func:`tan(x) <tan>`"

#: ../../library/math.rst:96
msgid "Tangent of *x*"
msgstr ""

#: ../../library/math.rst:98
msgid "**Hyperbolic functions**"
msgstr ""

#: ../../library/math.rst:100
msgid ":func:`acosh(x) <acosh>`"
msgstr ":func:`acosh(x) <acosh>`"

#: ../../library/math.rst:100
msgid "Inverse hyperbolic cosine of *x*"
msgstr ""

#: ../../library/math.rst:101
msgid ":func:`asinh(x) <asinh>`"
msgstr ":func:`asinh(x) <asinh>`"

#: ../../library/math.rst:101
msgid "Inverse hyperbolic sine of *x*"
msgstr ""

#: ../../library/math.rst:102
msgid ":func:`atanh(x) <atanh>`"
msgstr ":func:`atanh(x) <atanh>`"

#: ../../library/math.rst:102
msgid "Inverse hyperbolic tangent of *x*"
msgstr ""

#: ../../library/math.rst:103
msgid ":func:`cosh(x) <cosh>`"
msgstr ":func:`cosh(x) <cosh>`"

#: ../../library/math.rst:103
msgid "Hyperbolic cosine of *x*"
msgstr ""

#: ../../library/math.rst:104
msgid ":func:`sinh(x) <sinh>`"
msgstr ":func:`sinh(x) <sinh>`"

#: ../../library/math.rst:104
msgid "Hyperbolic sine of *x*"
msgstr ""

#: ../../library/math.rst:105
msgid ":func:`tanh(x) <tanh>`"
msgstr ":func:`tanh(x) <tanh>`"

#: ../../library/math.rst:105
msgid "Hyperbolic tangent of *x*"
msgstr ""

#: ../../library/math.rst:107
msgid "**Special functions**"
msgstr ""

#: ../../library/math.rst:109
msgid ":func:`erf(x) <erf>`"
msgstr ":func:`erf(x) <erf>`"

#: ../../library/math.rst:109
msgid "`Error function <https://en.wikipedia.org/wiki/Error_function>`_ at *x*"
msgstr ""

#: ../../library/math.rst:110
msgid ":func:`erfc(x) <erfc>`"
msgstr ":func:`erfc(x) <erfc>`"

#: ../../library/math.rst:110
msgid ""
"`Complementary error function <https://en.wikipedia.org/wiki/"
"Error_function>`_ at *x*"
msgstr ""

#: ../../library/math.rst:111
msgid ":func:`gamma(x) <gamma>`"
msgstr ":func:`gamma(x) <gamma>`"

#: ../../library/math.rst:111
msgid "`Gamma function <https://en.wikipedia.org/wiki/Gamma_function>`_ at *x*"
msgstr ""

#: ../../library/math.rst:112
msgid ":func:`lgamma(x) <lgamma>`"
msgstr ":func:`lgamma(x) <lgamma>`"

#: ../../library/math.rst:112
msgid ""
"Natural logarithm of the absolute value of the `Gamma function <https://"
"en.wikipedia.org/wiki/Gamma_function>`_ at *x*"
msgstr ""

#: ../../library/math.rst:114
msgid "**Constants**"
msgstr "**常數**"

#: ../../library/math.rst:116
msgid ":data:`pi`"
msgstr ":data:`pi`"

#: ../../library/math.rst:116
msgid "*π* = 3.141592..."
msgstr "*π* = 3.141592..."

#: ../../library/math.rst:117
msgid ":data:`e`"
msgstr ":data:`e`"

#: ../../library/math.rst:117
msgid "*e* = 2.718281..."
msgstr "*e* = 2.718281..."

#: ../../library/math.rst:118
msgid ":data:`tau`"
msgstr ":data:`tau`"

#: ../../library/math.rst:118
msgid "*τ* = 2\\ *π* = 6.283185..."
msgstr "*τ* = 2\\ *π* = 6.283185..."

#: ../../library/math.rst:119
msgid ":data:`inf`"
msgstr ":data:`inf`"

#: ../../library/math.rst:119
msgid "Positive infinity"
msgstr "正無限大"

#: ../../library/math.rst:120
msgid ":data:`nan`"
msgstr ":data:`nan`"

#: ../../library/math.rst:120
msgid "\"Not a number\" (NaN)"
msgstr ""

#: ../../library/math.rst:125
msgid "Number-theoretic functions"
msgstr "數論函式"

#: ../../library/math.rst:129
msgid ""
"Return the number of ways to choose *k* items from *n* items without "
"repetition and without order."
msgstr "回傳從 *n* 個物品中不重複且不考慮排序地取出 *k* 個物品的方法數。"

#: ../../library/math.rst:132
msgid ""
"Evaluates to ``n! / (k! * (n - k)!)`` when ``k <= n`` and evaluates to zero "
"when ``k > n``."
msgstr "當 ``k <= n`` 時其值為 ``n! / (k! * (n - k)!)``，否則其值為 ``0``。"

#: ../../library/math.rst:135
msgid ""
"Also called the binomial coefficient because it is equivalent to the "
"coefficient of k-th term in polynomial expansion of ``(1 + x)ⁿ``."
msgstr ""
"因為此值等同於 ``(1 + x)ⁿ`` 進行多項式展開後第 k 項的係數，所以又稱為二項式係"
"數。"

#: ../../library/math.rst:139 ../../library/math.rst:205
msgid ""
"Raises :exc:`TypeError` if either of the arguments are not integers. "
"Raises :exc:`ValueError` if either of the arguments are negative."
msgstr ""
"當任一參數非整數型別時會引發 :exc:`TypeError`。當任一參數為負數時會引"
"發 :exc:`ValueError`。"

#: ../../library/math.rst:147
msgid ""
"Return *n* factorial as an integer.  Raises :exc:`ValueError` if *n* is not "
"integral or is negative."
msgstr ""
"以整數回傳 *n* 的階乘。若 *n* 非整數型別或其值為負會引發 :exc:`ValueError`。"

#: ../../library/math.rst:150
msgid "Floats with integral values (like ``5.0``) are no longer accepted."
msgstr "其值為整數的浮點數（如：``5.0``）已不再被接受。"

#: ../../library/math.rst:156
msgid ""
"Return the greatest common divisor of the specified integer arguments. If "
"any of the arguments is nonzero, then the returned value is the largest "
"positive integer that is a divisor of all arguments.  If all arguments are "
"zero, then the returned value is ``0``.  ``gcd()`` without arguments returns "
"``0``."
msgstr ""
"回傳指定整數引數的最大公因數。若存在任一非零引數，回傳值為所有引數共有因數中"
"最大的正整數。若所有引數皆為零，則回傳值為 ``0``。``gcd()`` 若未傳入任何引數"
"也將回傳 ``0``。"

#: ../../library/math.rst:164
msgid ""
"Added support for an arbitrary number of arguments. Formerly, only two "
"arguments were supported."
msgstr "新增支援任意數量的引數。先前僅支援兩個引數。"

#: ../../library/math.rst:171
msgid ""
"Return the integer square root of the nonnegative integer *n*. This is the "
"floor of the exact square root of *n*, or equivalently the greatest integer "
"*a* such that *a*\\ ² |nbsp| ≤ |nbsp| *n*."
msgstr ""
"回傳非負整數 *n* 的整數平方根。此值為 *n* 精確平方根經下取整的值，亦等同於滿"
"足 *a*\\ ² |nbsp| ≤ |nbsp| *n* 的最大整數值 *a*。"

#: ../../library/math.rst:175
msgid ""
"For some applications, it may be more convenient to have the least integer "
"*a* such that *n* |nbsp| ≤ |nbsp| *a*\\ ², or in other words the ceiling of "
"the exact square root of *n*. For positive *n*, this can be computed using "
"``a = 1 + isqrt(n - 1)``."
msgstr ""
"於有些應用程式中，取得滿足 *n* |nbsp| ≤ |nbsp| *a*\\ ² 的最小整數值 *a* ── 或"
"者說 *n* 精確平方根經上取整的值 ── 會更加方便。對正數 *n*，此值可使用 ``a = "
"1 + isqrt(n - 1)`` 計算。"

#: ../../library/math.rst:185
msgid ""
"Return the least common multiple of the specified integer arguments. If all "
"arguments are nonzero, then the returned value is the smallest positive "
"integer that is a multiple of all arguments.  If any of the arguments is "
"zero, then the returned value is ``0``.  ``lcm()`` without arguments returns "
"``1``."
msgstr ""
"回傳指定整數引數的最小公倍數。若所有引數值皆非零，回傳值為所有引數共有倍數中"
"最小的正整數。若存在任一引數值為零，則回傳值為 ``0``。``lcm()`` 若未傳入任何"
"引數將回傳 ``1``。"

#: ../../library/math.rst:196
msgid ""
"Return the number of ways to choose *k* items from *n* items without "
"repetition and with order."
msgstr ""

#: ../../library/math.rst:199
msgid ""
"Evaluates to ``n! / (n - k)!`` when ``k <= n`` and evaluates to zero when "
"``k > n``."
msgstr ""

#: ../../library/math.rst:202
msgid ""
"If *k* is not specified or is ``None``, then *k* defaults to *n* and the "
"function returns ``n!``."
msgstr ""

#: ../../library/math.rst:212
msgid "Floating point arithmetic"
msgstr ""

#: ../../library/math.rst:216
msgid ""
"Return the ceiling of *x*, the smallest integer greater than or equal to "
"*x*. If *x* is not a float, delegates to :meth:`x.__ceil__ "
"<object.__ceil__>`, which should return an :class:`~numbers.Integral` value."
msgstr ""
"回傳 *x* 經上取整的值，即大於或等於 *x* 的最小整數。若 *x* 並非浮點數，此函式"
"將委派給 :meth:`x.__ceil__ <object.__ceil__>`，並回"
"傳 :class:`~numbers.Integral` 型別的值。"

#: ../../library/math.rst:223
msgid "Return the absolute value of *x*."
msgstr "回傳 *x* 的絕對值。"

#: ../../library/math.rst:228
msgid ""
"Return the floor of *x*, the largest integer less than or equal to *x*.  If "
"*x* is not a float, delegates to :meth:`x.__floor__ <object.__floor__>`, "
"which should return an :class:`~numbers.Integral` value."
msgstr ""
"回傳 *x* 經下取整的值，即小於或等於 *x* 的最大整數。若 *x* 並非浮點數，此函式"
"將委派給 :meth:`x.__floor__ <object.__floor__>`，並回"
"傳 :class:`~numbers.Integral` 型別的值。"

#: ../../library/math.rst:235
msgid ""
"Fused multiply-add operation. Return ``(x * y) + z``, computed as though "
"with infinite precision and range followed by a single round to the "
"``float`` format. This operation often provides better accuracy than the "
"direct expression ``(x * y) + z``."
msgstr ""

#: ../../library/math.rst:240
msgid ""
"This function follows the specification of the fusedMultiplyAdd operation "
"described in the IEEE 754 standard. The standard leaves one case "
"implementation-defined, namely the result of ``fma(0, inf, nan)`` and "
"``fma(inf, 0, nan)``. In these cases, ``math.fma`` returns a NaN, and does "
"not raise any exception."
msgstr ""

#: ../../library/math.rst:251
msgid ""
"Return the floating-point remainder of ``x / y``, as defined by the platform "
"C library function ``fmod(x, y)``. Note that the Python expression ``x % y`` "
"may not return the same result.  The intent of the C standard is that "
"``fmod(x, y)`` be exactly (mathematically; to infinite precision) equal to "
"``x - n*y`` for some integer *n* such that the result has the same sign as "
"*x* and magnitude less than ``abs(y)``.  Python's ``x % y`` returns a result "
"with the sign of *y* instead, and may not be exactly computable for float "
"arguments. For example, ``fmod(-1e-100, 1e100)`` is ``-1e-100``, but the "
"result of Python's ``-1e-100 % 1e100`` is ``1e100-1e-100``, which cannot be "
"represented exactly as a float, and rounds to the surprising ``1e100``.  For "
"this reason, function :func:`fmod` is generally preferred when working with "
"floats, while Python's ``x % y`` is preferred when working with integers."
msgstr ""
"回傳 ``x / y`` 的浮點數餘數，其以平臺上的 C 函式庫 ``fmod(x, y)`` 函式定義。"
"請注意此函式與 Python 運算式 ``x % y`` 可能不會回傳相同結果。C 標準要求 "
"``fmod(x, y)`` 的回傳值完全等同（數學定義上，即無限精度）於 ``x - n*y``，*n* "
"為可使回傳值與 *x* 同號且長度小於 ``abs(y)`` 的整數。Python 運算式 ``x % y`` "
"的回傳值則與 *y* 同號，且可能無法精確地計算浮點數引數。例如：``fmod(-1e-100, "
"1e100)`` 的值為 ``-1e-100``，但 Python 運算式 ``-1e-100 % 1e100`` 的結果為 "
"``1e100-1e-100``，此值無法準確地表示成浮點數，並會四捨五入為出乎意料的 "
"``1e100``。因此，處理浮點數時通常會選擇函式 :func:`fmod`，而處理整數時會選擇 "
"Python 運算式 ``x % y``。"

#: ../../library/math.rst:267
msgid ""
"Return the fractional and integer parts of *x*.  Both results carry the sign "
"of *x* and are floats."
msgstr ""

#: ../../library/math.rst:270
msgid ""
"Note that :func:`modf` has a different call/return pattern than its C "
"equivalents: it takes a single argument and return a pair of values, rather "
"than returning its second return value through an 'output parameter' (there "
"is no such thing in Python)."
msgstr ""

#: ../../library/math.rst:278
msgid ""
"Return the IEEE 754-style remainder of *x* with respect to *y*.  For finite "
"*x* and finite nonzero *y*, this is the difference ``x - n*y``, where ``n`` "
"is the closest integer to the exact value of the quotient ``x / y``.  If "
"``x / y`` is exactly halfway between two consecutive integers, the nearest "
"*even* integer is used for ``n``.  The remainder ``r = remainder(x, y)`` "
"thus always satisfies ``abs(r) <= 0.5 * abs(y)``."
msgstr ""

#: ../../library/math.rst:285
msgid ""
"Special cases follow IEEE 754: in particular, ``remainder(x, math.inf)`` is "
"*x* for any finite *x*, and ``remainder(x, 0)`` and ``remainder(math.inf, "
"x)`` raise :exc:`ValueError` for any non-NaN *x*. If the result of the "
"remainder operation is zero, that zero will have the same sign as *x*."
msgstr ""

#: ../../library/math.rst:291
msgid ""
"On platforms using IEEE 754 binary floating point, the result of this "
"operation is always exactly representable: no rounding error is introduced."
msgstr ""

#: ../../library/math.rst:299
msgid ""
"Return *x* with the fractional part removed, leaving the integer part.  This "
"rounds toward 0: ``trunc()`` is equivalent to :func:`floor` for positive "
"*x*, and equivalent to :func:`ceil` for negative *x*. If *x* is not a float, "
"delegates to :meth:`x.__trunc__ <object.__trunc__>`, which should return "
"an :class:`~numbers.Integral` value."
msgstr ""

#: ../../library/math.rst:306
msgid ""
"For the :func:`ceil`, :func:`floor`, and :func:`modf` functions, note that "
"*all* floating-point numbers of sufficiently large magnitude are exact "
"integers. Python floats typically carry no more than 53 bits of precision "
"(the same as the platform C double type), in which case any float *x* with "
"``abs(x) >= 2**52`` necessarily has no fractional bits."
msgstr ""

#: ../../library/math.rst:314
msgid "Floating point manipulation functions"
msgstr ""

#: ../../library/math.rst:318
msgid ""
"Return a float with the magnitude (absolute value) of *x* but the sign of "
"*y*.  On platforms that support signed zeros, ``copysign(1.0, -0.0)`` "
"returns *-1.0*."
msgstr ""
"回傳與 *x* 相同長度（絕對值）且與 *y* 同號的浮點數。在支援帶符號零的平臺上，"
"``copysign(1.0, -0.0)`` 回傳 *-1.0*。"

#: ../../library/math.rst:325
msgid ""
"Return the mantissa and exponent of *x* as the pair ``(m, e)``.  *m* is a "
"float and *e* is an integer such that ``x == m * 2**e`` exactly. If *x* is "
"zero, returns ``(0.0, 0)``, otherwise ``0.5 <= abs(m) < 1``.  This is used "
"to \"pick apart\" the internal representation of a float in a portable way."
msgstr ""
"以 ``(m, e)`` 對的格式回傳 *x* 的尾數 *m* 及指數 *e*。*m* 是浮點數而 *e* 是整"
"數，且兩者精確地使 ``x == m * 2**e``。若 *x* 為零，回傳 ``(0.0, 0)``，否則令 "
"``0.5 <= abs(m) < 1``。此函式用於以可攜的方式「分割」浮點數內部表示法。"

#: ../../library/math.rst:330
msgid ""
"Note that :func:`frexp` has a different call/return pattern than its C "
"equivalents: it takes a single argument and return a pair of values, rather "
"than returning its second return value through an 'output parameter' (there "
"is no such thing in Python)."
msgstr ""

#: ../../library/math.rst:337
msgid ""
"Return ``True`` if the values *a* and *b* are close to each other and "
"``False`` otherwise."
msgstr "若 *a* 及 *b* 兩值足夠接近便回傳 ``True``，否則回傳 ``False``。"

#: ../../library/math.rst:340
msgid ""
"Whether or not two values are considered close is determined according to "
"given absolute and relative tolerances.  If no errors occur, the result will "
"be: ``abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)``."
msgstr ""
"兩數是否足夠接近取決於給定的絕對及相對容許偏差 (tolerance)。如果沒有錯誤發"
"生，結果將為：``abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)``。"

#: ../../library/math.rst:344
msgid ""
"*rel_tol* is the relative tolerance -- it is the maximum allowed difference "
"between *a* and *b*, relative to the larger absolute value of *a* or *b*. "
"For example, to set a tolerance of 5%, pass ``rel_tol=0.05``.  The default "
"tolerance is ``1e-09``, which assures that the two values are the same "
"within about 9 decimal digits.  *rel_tol* must be nonnegative and less than "
"``1.0``."
msgstr ""
"*rel_tol* 為相對容許偏差 ── *a* 與 *b* 兩數差的最大容許值，與 *a* 及 *b* 兩數"
"的絕對值中較大者相關。例如欲設置 5% 的容許偏差，則傳入 ``rel_tol=0.05``。其預"
"設值為 ``1e-09``，該值可確保兩數於大約 9 個十進數位內相同。*rel_tol* 須不為負"
"且小於 ``1.0``。"

#: ../../library/math.rst:351
msgid ""
"*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 ``x`` and "
"rel_tol less than ``1.0``.  So add an appropriate positive abs_tol argument "
"to the call."
msgstr ""

#: ../../library/math.rst:357
msgid ""
"The IEEE 754 special values of ``NaN``, ``inf``, and ``-inf`` will be "
"handled according to IEEE rules.  Specifically, ``NaN`` is not considered "
"close to any other value, including ``NaN``.  ``inf`` and ``-inf`` are only "
"considered close to themselves."
msgstr ""
"定義於 IEEE 754 浮點標準中的特殊值 ``NaN``、``inf`` 和 ``-inf`` 會根據該標準"
"處理。更明確地說，``NaN`` 不會與包含自身在內的任何數字足夠接近，而 ``inf`` "
"及 ``-inf`` 皆只與自身接近。"

#: ../../library/math.rst:366
msgid ":pep:`485` -- A function for testing approximate equality"
msgstr ":pep:`485` ── 用於測試近似相等的函式"

#: ../../library/math.rst:371
msgid ""
"Return ``True`` if *x* is neither an infinity nor a NaN, and ``False`` "
"otherwise.  (Note that ``0.0`` *is* considered finite.)"
msgstr ""
"若 *x* 不是無限值或 ``NaN`` 便回傳 ``True``，否則回傳 ``False``。（注意 "
"``0.0`` 被視為有限數。）"

#: ../../library/math.rst:379
msgid ""
"Return ``True`` if *x* is a positive or negative infinity, and ``False`` "
"otherwise."
msgstr "若 *x* 是正無限值或負無限值便回傳 ``True``，否則回傳 ``False``。"

#: ../../library/math.rst:385
msgid ""
"Return ``True`` if *x* is a NaN (not a number), and ``False`` otherwise."
msgstr ""
"若 *x* 是 ``NaN`` ── 即非數字（NaN, not a number）── 便回傳 ``True``，否則回"
"傳 ``False``。"

#: ../../library/math.rst:390
msgid ""
"Return ``x * (2**i)``.  This is essentially the inverse of "
"function :func:`frexp`."
msgstr "回傳 ``x * (2**i)``。此函式本質上為 :func:`frexp` 的反函式。"

#: ../../library/math.rst:396
msgid "Return the floating-point value *steps* steps after *x* towards *y*."
msgstr ""

#: ../../library/math.rst:398
msgid "If *x* is equal to *y*, return *y*, unless *steps* is zero."
msgstr ""

#: ../../library/math.rst:400
msgid "Examples:"
msgstr "範例："

#: ../../library/math.rst:402
msgid "``math.nextafter(x, math.inf)`` goes up: towards positive infinity."
msgstr ""

#: ../../library/math.rst:403
msgid "``math.nextafter(x, -math.inf)`` goes down: towards minus infinity."
msgstr ""

#: ../../library/math.rst:404
msgid "``math.nextafter(x, 0.0)`` goes towards zero."
msgstr ""

#: ../../library/math.rst:405
msgid "``math.nextafter(x, math.copysign(math.inf, x))`` goes away from zero."
msgstr ""

#: ../../library/math.rst:407
msgid "See also :func:`math.ulp`."
msgstr "另請參閱 :func:`math.ulp`。"

#: ../../library/math.rst:411
msgid "Added the *steps* argument."
msgstr "新增 *steps* 引數。"

#: ../../library/math.rst:417
msgid "Return the value of the least significant bit of the float *x*:"
msgstr ""

#: ../../library/math.rst:419
msgid "If *x* is a NaN (not a number), return *x*."
msgstr ""

#: ../../library/math.rst:420
msgid "If *x* is negative, return ``ulp(-x)``."
msgstr "若 *x* 為負值，回傳 ``ulp(-x)``。"

#: ../../library/math.rst:421
msgid "If *x* is a positive infinity, return *x*."
msgstr "若 *x* 為正無限值，回傳 *x*。"

#: ../../library/math.rst:422
msgid ""
"If *x* is equal to zero, return the smallest positive *denormalized* "
"representable float (smaller than the minimum positive *normalized* "
"float, :data:`sys.float_info.min <sys.float_info>`)."
msgstr ""

#: ../../library/math.rst:425
msgid ""
"If *x* is equal to the largest positive representable float, return the "
"value of the least significant bit of *x*, such that the first float smaller "
"than *x* is ``x - ulp(x)``."
msgstr ""

#: ../../library/math.rst:428
msgid ""
"Otherwise (*x* is a positive finite number), return the value of the least "
"significant bit of *x*, such that the first float bigger than *x* is ``x + "
"ulp(x)``."
msgstr ""

#: ../../library/math.rst:432
msgid "ULP stands for \"Unit in the Last Place\"."
msgstr ""

#: ../../library/math.rst:434
msgid ""
"See also :func:`math.nextafter` and :data:`sys.float_info.epsilon "
"<sys.float_info>`."
msgstr ""

#: ../../library/math.rst:441
msgid "Power, exponential and logarithmic functions"
msgstr ""

#: ../../library/math.rst:445
msgid "Return the cube root of *x*."
msgstr ""

#: ../../library/math.rst:452
msgid ""
"Return *e* raised to the power *x*, where *e* = 2.718281... is the base of "
"natural logarithms.  This is usually more accurate than ``math.e ** x`` or "
"``pow(math.e, x)``."
msgstr ""

#: ../../library/math.rst:459
msgid "Return *2* raised to the power *x*."
msgstr ""

#: ../../library/math.rst:466
msgid ""
"Return *e* raised to the power *x*, minus 1.  Here *e* is the base of "
"natural logarithms.  For small floats *x*, the subtraction in ``exp(x) - 1`` "
"can result in a `significant loss of precision <https://en.wikipedia.org/"
"wiki/Loss_of_significance>`_\\; the :func:`expm1` function provides a way to "
"compute this quantity to full precision:"
msgstr ""

#: ../../library/math.rst:483
msgid "With one argument, return the natural logarithm of *x* (to base *e*)."
msgstr ""

#: ../../library/math.rst:485
msgid ""
"With two arguments, return the logarithm of *x* to the given *base*, "
"calculated as ``log(x)/log(base)``."
msgstr ""

#: ../../library/math.rst:491
msgid ""
"Return the natural logarithm of *1+x* (base *e*). The result is calculated "
"in a way which is accurate for *x* near zero."
msgstr ""

#: ../../library/math.rst:497
msgid ""
"Return the base-2 logarithm of *x*. This is usually more accurate than "
"``log(x, 2)``."
msgstr ""

#: ../../library/math.rst:504
msgid ""
":meth:`int.bit_length` returns the number of bits necessary to represent an "
"integer in binary, excluding the sign and leading zeros."
msgstr ""

#: ../../library/math.rst:510
msgid ""
"Return the base-10 logarithm of *x*.  This is usually more accurate than "
"``log(x, 10)``."
msgstr ""

#: ../../library/math.rst:516
msgid ""
"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 :exc:`ValueError`."
msgstr ""

#: ../../library/math.rst:523
msgid ""
"Unlike the built-in ``**`` operator, :func:`math.pow` converts both its "
"arguments to type :class:`float`.  Use ``**`` or the built-in :func:`pow` "
"function for computing exact integer powers."
msgstr ""

#: ../../library/math.rst:527
msgid ""
"The special cases ``pow(0.0, -inf)`` and ``pow(-0.0, -inf)`` were changed to "
"return ``inf`` instead of raising :exc:`ValueError`, for consistency with "
"IEEE 754."
msgstr ""

#: ../../library/math.rst:535
msgid "Return the square root of *x*."
msgstr ""

#: ../../library/math.rst:539
msgid "Summation and product functions"
msgstr ""

#: ../../library/math.rst:543
msgid ""
"Return the Euclidean distance between two points *p* and *q*, each given as "
"a sequence (or iterable) of coordinates.  The two points must have the same "
"dimension."
msgstr ""

#: ../../library/math.rst:547 ../../library/math.rst:608
msgid "Roughly equivalent to::"
msgstr ""

#: ../../library/math.rst:549
msgid "sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))"
msgstr "sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))"

#: ../../library/math.rst:556
msgid ""
"Return an accurate floating-point sum of values in the iterable.  Avoids "
"loss of precision by tracking multiple intermediate partial sums."
msgstr ""
"回傳可疊代物件（iterable）中所有值的精確浮點數和。透過追蹤過程中多個部分和"
"（partial sum）以避免精確度損失。"

#: ../../library/math.rst:559
msgid ""
"The algorithm's accuracy depends on IEEE-754 arithmetic guarantees and the "
"typical case where the rounding mode is half-even.  On some non-Windows "
"builds, the underlying C library uses extended precision addition and may "
"occasionally double-round an intermediate sum causing it to be off in its "
"least significant bit."
msgstr ""
"此演算法準確性奠基於保證 IEEE-754 浮點標準及典型奇進偶捨（half-even）模式。於"
"有些非 Windows 平台建置時，底層 C 函式庫使用延伸精度加法運算，而可能導致對過"
"程中同一部分和重複捨入，並使其最低有效位不如預期。"

#: ../../library/math.rst:565
msgid ""
"For further discussion and two alternative approaches, see the `ASPN "
"cookbook recipes for accurate floating-point summation <https://"
"code.activestate.com/recipes/393090-binary-floating-point-summation-accurate-"
"to-full-p/>`_\\."
msgstr ""
"更深入的討論及兩種替代做法請參閱 `ASPN cookbook recipes 精準的浮點數總和 "
"<https://code.activestate.com/recipes/393090/>`_。"

#: ../../library/math.rst:572
msgid ""
"Return the Euclidean norm, ``sqrt(sum(x**2 for x in coordinates))``. This is "
"the length of the vector from the origin to the point given by the "
"coordinates."
msgstr ""

#: ../../library/math.rst:576
msgid ""
"For a two dimensional point ``(x, y)``, this is equivalent to computing the "
"hypotenuse of a right triangle using the Pythagorean theorem, ``sqrt(x*x + "
"y*y)``."
msgstr ""

#: ../../library/math.rst:580
msgid ""
"Added support for n-dimensional points. Formerly, only the two dimensional "
"case was supported."
msgstr ""

#: ../../library/math.rst:584
msgid ""
"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."
msgstr ""

#: ../../library/math.rst:592
msgid ""
"Calculate the product of all the elements in the input *iterable*. The "
"default *start* value for the product is ``1``."
msgstr ""

#: ../../library/math.rst:595
msgid ""
"When the iterable is empty, return the start value.  This function is "
"intended specifically for use with numeric values and may reject non-numeric "
"types."
msgstr ""

#: ../../library/math.rst:604
msgid "Return the sum of products of values from two iterables *p* and *q*."
msgstr ""

#: ../../library/math.rst:606
msgid "Raises :exc:`ValueError` if the inputs do not have the same length."
msgstr ""

#: ../../library/math.rst:610
msgid "sum(itertools.starmap(operator.mul, zip(p, q, strict=True)))"
msgstr "sum(itertools.starmap(operator.mul, zip(p, q, strict=True)))"

#: ../../library/math.rst:612
msgid ""
"For float and mixed int/float inputs, the intermediate products and sums are "
"computed with extended precision."
msgstr ""

#: ../../library/math.rst:619
msgid "Angular conversion"
msgstr ""

#: ../../library/math.rst:623
msgid "Convert angle *x* from radians to degrees."
msgstr ""

#: ../../library/math.rst:628
msgid "Convert angle *x* from degrees to radians."
msgstr ""

#: ../../library/math.rst:632
msgid "Trigonometric functions"
msgstr ""

#: ../../library/math.rst:636
msgid ""
"Return the arc cosine of *x*, in radians. The result is between ``0`` and "
"``pi``."
msgstr ""

#: ../../library/math.rst:642
msgid ""
"Return the arc sine of *x*, in radians. The result is between ``-pi/2`` and "
"``pi/2``."
msgstr ""

#: ../../library/math.rst:648
msgid ""
"Return the arc tangent of *x*, in radians. The result is between ``-pi/2`` "
"and ``pi/2``."
msgstr ""

#: ../../library/math.rst:654
msgid ""
"Return ``atan(y / x)``, in radians. The result is between ``-pi`` and "
"``pi``. The vector in the plane from the origin to point ``(x, y)`` makes "
"this angle with the positive X axis. The point of :func:`atan2` is that the "
"signs of both inputs are known to it, so it can compute the correct quadrant "
"for the angle. For example, ``atan(1)`` and ``atan2(1, 1)`` are both ``pi/"
"4``, but ``atan2(-1, -1)`` is ``-3*pi/4``."
msgstr ""

#: ../../library/math.rst:664
msgid "Return the cosine of *x* radians."
msgstr ""

#: ../../library/math.rst:669
msgid "Return the sine of *x* radians."
msgstr ""

#: ../../library/math.rst:674
msgid "Return the tangent of *x* radians."
msgstr ""

#: ../../library/math.rst:678
msgid "Hyperbolic functions"
msgstr ""

#: ../../library/math.rst:680
msgid ""
"`Hyperbolic functions <https://en.wikipedia.org/wiki/Hyperbolic_functions>`_ "
"are analogs of trigonometric functions that are based on hyperbolas instead "
"of circles."
msgstr ""

#: ../../library/math.rst:686
msgid "Return the inverse hyperbolic cosine of *x*."
msgstr ""

#: ../../library/math.rst:691
msgid "Return the inverse hyperbolic sine of *x*."
msgstr ""

#: ../../library/math.rst:696
msgid "Return the inverse hyperbolic tangent of *x*."
msgstr ""

#: ../../library/math.rst:701
msgid "Return the hyperbolic cosine of *x*."
msgstr ""

#: ../../library/math.rst:706
msgid "Return the hyperbolic sine of *x*."
msgstr ""

#: ../../library/math.rst:711
msgid "Return the hyperbolic tangent of *x*."
msgstr ""

#: ../../library/math.rst:715
msgid "Special functions"
msgstr "特殊函式"

#: ../../library/math.rst:719
msgid ""
"Return the `error function <https://en.wikipedia.org/wiki/Error_function>`_ "
"at *x*."
msgstr ""

#: ../../library/math.rst:722
msgid ""
"The :func:`erf` function can be used to compute traditional statistical "
"functions such as the `cumulative standard normal distribution <https://"
"en.wikipedia.org/wiki/Cumulative_distribution_function>`_::"
msgstr ""

#: ../../library/math.rst:726
msgid ""
"def phi(x):\n"
"    'Cumulative distribution function for the standard normal distribution'\n"
"    return (1.0 + erf(x / sqrt(2.0))) / 2.0"
msgstr ""

#: ../../library/math.rst:735
msgid ""
"Return the complementary error function at *x*.  The `complementary error "
"function <https://en.wikipedia.org/wiki/Error_function>`_ is defined as "
"``1.0 - erf(x)``.  It is used for large values of *x* where a subtraction "
"from one would cause a `loss of significance <https://en.wikipedia.org/wiki/"
"Loss_of_significance>`_\\."
msgstr ""

#: ../../library/math.rst:746
msgid ""
"Return the `Gamma function <https://en.wikipedia.org/wiki/Gamma_function>`_ "
"at *x*."
msgstr ""

#: ../../library/math.rst:754
msgid ""
"Return the natural logarithm of the absolute value of the Gamma function at "
"*x*."
msgstr ""

#: ../../library/math.rst:761
msgid "Constants"
msgstr "常數"

#: ../../library/math.rst:765
msgid "The mathematical constant *π* = 3.141592..., to available precision."
msgstr ""

#: ../../library/math.rst:770
msgid "The mathematical constant *e* = 2.718281..., to available precision."
msgstr ""

#: ../../library/math.rst:775
msgid ""
"The mathematical constant *τ* = 6.283185..., to available precision. Tau is "
"a circle constant equal to 2\\ *π*, the ratio of a circle's circumference to "
"its radius. To learn more about Tau, check out Vi Hart's video `Pi is "
"(still) Wrong <https://www.youtube.com/watch?v=jG7vhMMXagQ>`_, and start "
"celebrating `Tau day <https://tauday.com/>`_ by eating twice as much pie!"
msgstr ""

#: ../../library/math.rst:786
msgid ""
"A floating-point positive infinity.  (For negative infinity, use ``-"
"math.inf``.)  Equivalent to the output of ``float('inf')``."
msgstr ""

#: ../../library/math.rst:794
msgid ""
"A floating-point \"not a number\" (NaN) value. Equivalent to the output of "
"``float('nan')``. Due to the requirements of the `IEEE-754 standard <https://"
"en.wikipedia.org/wiki/IEEE_754>`_, ``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 :func:`isnan` function to test for "
"NaNs instead of ``is`` or ``==``. Example:"
msgstr ""

#: ../../library/math.rst:814
msgid "It is now always available."
msgstr ""

#: ../../library/math.rst:820
msgid ""
"The :mod:`math` module consists mostly of thin wrappers around the platform "
"C math library functions.  Behavior in exceptional cases follows Annex F of "
"the C99 standard where appropriate.  The current implementation will "
"raise :exc:`ValueError` for invalid operations like ``sqrt(-1.0)`` or "
"``log(0.0)`` (where C99 Annex F recommends signaling invalid operation or "
"divide-by-zero), and :exc:`OverflowError` for results that overflow (for "
"example, ``exp(1000.0)``).  A NaN will not be returned from any of the "
"functions above unless one or more of the input arguments was a NaN; in that "
"case, most functions will return a NaN, but (again following C99 Annex F) "
"there are some exceptions to this rule, for example ``pow(float('nan'), "
"0.0)`` or ``hypot(float('nan'), float('inf'))``."
msgstr ""

#: ../../library/math.rst:832
msgid ""
"Note that Python makes no effort to distinguish signaling NaNs from quiet "
"NaNs, and behavior for signaling NaNs remains unspecified. Typical behavior "
"is to treat all NaNs as though they were quiet."
msgstr ""

#: ../../library/math.rst:839
msgid "Module :mod:`cmath`"
msgstr ":mod:`cmath` 模組"

#: ../../library/math.rst:840
msgid "Complex number versions of many of these functions."
msgstr ""