# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2026, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.13\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-04-17 15:40+0000\n"

"PO-Revision-Date: 2025-09-15 01:04+0000\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: pl\n"

"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "

"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "

"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid ":mod:`!decimal` --- Decimal fixed-point and floating-point arithmetic"

msgstr ""

msgid "**Source code:** :source:`Lib/decimal.py`"

msgstr "**Kod źródłowy:** :source:`Lib/decimal.py`"

msgid ""

"The :mod:`decimal` module provides support for fast correctly rounded "

"decimal floating-point arithmetic. It offers several advantages over the :"

"class:`float` datatype:"

msgstr ""

msgid ""

"Decimal \"is based on a `floating-point model <https://speleotrove.com/"

"decimal/damodel.html#refnumber>`__ which was designed with people in mind, "

"and necessarily has a paramount guiding principle -- computers must provide "

"an arithmetic that works in the same way as the arithmetic that people learn "

"at school.\" -- excerpt from the decimal arithmetic specification."

msgstr ""

msgid ""

"Decimal numbers can be represented exactly. In contrast, numbers like "

"``1.1`` and ``2.2`` do not have exact representations in binary floating "

"point. End users typically would not expect ``1.1 + 2.2`` to display as "

"``3.3000000000000003`` as it does with binary floating point."

msgstr ""

msgid ""

"The exactness carries over into arithmetic. In decimal floating point, "

"``0.1 + 0.1 + 0.1 - 0.3`` is exactly equal to zero. In binary floating "

"point, the result is ``5.5511151231257827e-017``. While near to zero, the "

"differences prevent reliable equality testing and differences can "

"accumulate. For this reason, decimal is preferred in accounting applications "

"which have strict equality invariants."

msgstr ""

msgid ""

"The decimal module incorporates a notion of significant places so that "

"``1.30 + 1.20`` is ``2.50``. The trailing zero is kept to indicate "

"significance. This is the customary presentation for monetary applications. "

"For multiplication, the \"schoolbook\" approach uses all the figures in the "

"multiplicands. For instance, ``1.3 * 1.2`` gives ``1.56`` while ``1.30 * "

"1.20`` gives ``1.5600``."

msgstr ""

msgid ""

"Unlike hardware based binary floating point, the decimal module has a user "

"alterable precision (defaulting to 28 places) which can be as large as "

"needed for a given problem:"

msgstr ""

msgid ""

"Both binary and decimal floating point are implemented in terms of published "

"standards. While the built-in float type exposes only a modest portion of "

"its capabilities, the decimal module exposes all required parts of the "

"standard. When needed, the programmer has full control over rounding and "

"signal handling. This includes an option to enforce exact arithmetic by "

"using exceptions to block any inexact operations."

msgstr ""

msgid ""

"The decimal module was designed to support \"without prejudice, both exact "

"unrounded decimal arithmetic (sometimes called fixed-point arithmetic) and "

"rounded floating-point arithmetic.\" -- excerpt from the decimal arithmetic "

"specification."

msgstr ""

msgid ""

"The module design is centered around three concepts: the decimal number, "

"the context for arithmetic, and signals."

msgstr ""

msgid ""

"A decimal number is immutable. It has a sign, coefficient digits, and an "

"exponent. To preserve significance, the coefficient digits do not truncate "

"trailing zeros. Decimals also include special values such as ``Infinity``, "

"``-Infinity``, and ``NaN``. The standard also differentiates ``-0`` from "

"``+0``."

msgstr ""

msgid ""

"The context for arithmetic is an environment specifying precision, rounding "

"rules, limits on exponents, flags indicating the results of operations, and "

"trap enablers which determine whether signals are treated as exceptions. "

"Rounding options include :const:`ROUND_CEILING`, :const:`ROUND_DOWN`, :const:"

"`ROUND_FLOOR`, :const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :const:"

"`ROUND_HALF_UP`, :const:`ROUND_UP`, and :const:`ROUND_05UP`."

msgstr ""

msgid ""

"Signals are groups of exceptional conditions arising during the course of "

"computation. Depending on the needs of the application, signals may be "

"ignored, considered as informational, or treated as exceptions. The signals "

"in the decimal module are: :const:`Clamped`, :const:`InvalidOperation`, :"

"const:`DivisionByZero`, :const:`Inexact`, :const:`Rounded`, :const:"

"`Subnormal`, :const:`Overflow`, :const:`Underflow` and :const:"

"`FloatOperation`."

msgstr ""

msgid ""

"For each signal there is a flag and a trap enabler. When a signal is "

"encountered, its flag is set to one, then, if the trap enabler is set to "

"one, an exception is raised. Flags are sticky, so the user needs to reset "

"them before monitoring a calculation."

msgstr ""

msgid ""

"IBM's General Decimal Arithmetic Specification, `The General Decimal "

"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."

msgstr ""

msgid "Quick-start tutorial"

msgstr ""

msgid ""

"The usual start to using decimals is importing the module, viewing the "

"current context with :func:`getcontext` and, if necessary, setting new "

"values for precision, rounding, or enabled traps::"

msgstr ""

msgid ""

">>> from decimal import *\n"

">>> getcontext()\n"

"Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n"

" capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,\n"

" InvalidOperation])\n"

"\n"

">>> getcontext().prec = 7 # Set a new precision"

msgstr ""

msgid ""

"Decimal instances can be constructed from integers, strings, floats, or "

"tuples. Construction from an integer or a float performs an exact conversion "

"of the value of that integer or float. Decimal numbers include special "

"values such as ``NaN`` which stands for \"Not a number\", positive and "

"negative ``Infinity``, and ``-0``::"

msgstr ""

msgid ""

">>> getcontext().prec = 28\n"

">>> Decimal(10)\n"

"Decimal('10')\n"

">>> Decimal('3.14')\n"

"Decimal('3.14')\n"

">>> Decimal(3.14)\n"

"Decimal('3.140000000000000124344978758017532527446746826171875')\n"

">>> Decimal((0, (3, 1, 4), -2))\n"

"Decimal('3.14')\n"

">>> Decimal(str(2.0 ** 0.5))\n"

"Decimal('1.4142135623730951')\n"

">>> Decimal(2) ** Decimal('0.5')\n"

"Decimal('1.414213562373095048801688724')\n"

">>> Decimal('NaN')\n"

"Decimal('NaN')\n"

">>> Decimal('-Infinity')\n"

"Decimal('-Infinity')"

msgstr ""

msgid ""

"If the :exc:`FloatOperation` signal is trapped, accidental mixing of "

"decimals and floats in constructors or ordering comparisons raises an "

"exception::"

msgstr ""

msgid ""

">>> c = getcontext()\n"

">>> c.traps[FloatOperation] = True\n"

">>> Decimal(3.14)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"decimal.FloatOperation: [<class 'decimal.FloatOperation'>]\n"

">>> Decimal('3.5') < 3.7\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"decimal.FloatOperation: [<class 'decimal.FloatOperation'>]\n"

">>> Decimal('3.5') == 3.5\n"

"True"

msgstr ""

msgid ""

"The significance of a new Decimal is determined solely by the number of "

"digits input. Context precision and rounding only come into play during "

"arithmetic operations."

msgstr ""

msgid ""

">>> getcontext().prec = 6\n"

">>> Decimal('3.0')\n"

"Decimal('3.0')\n"

">>> Decimal('3.1415926535')\n"

"Decimal('3.1415926535')\n"

">>> Decimal('3.1415926535') + Decimal('2.7182818285')\n"

"Decimal('5.85987')\n"

">>> getcontext().rounding = ROUND_UP\n"

">>> Decimal('3.1415926535') + Decimal('2.7182818285')\n"

"Decimal('5.85988')"

msgstr ""

msgid ""

"If the internal limits of the C version are exceeded, constructing a decimal "

"raises :class:`InvalidOperation`::"

msgstr ""

msgid ""

">>> Decimal(\"1e9999999999999999999\")\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]"

msgstr ""

msgid ""

"Decimals interact well with much of the rest of Python. Here is a small "

"decimal floating-point flying circus:"

msgstr ""

msgid ""

">>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))\n"

">>> max(data)\n"

"Decimal('9.25')\n"

">>> min(data)\n"

"Decimal('0.03')\n"

">>> sorted(data)\n"

"[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),\n"

" Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]\n"

">>> sum(data)\n"

"Decimal('19.29')\n"

">>> a,b,c = data[:3]\n"

">>> str(a)\n"

"'1.34'\n"

">>> float(a)\n"

"1.34\n"

">>> round(a, 1)\n"

"Decimal('1.3')\n"

">>> int(a)\n"

"1\n"

">>> a * 5\n"

"Decimal('6.70')\n"

">>> a * b\n"

"Decimal('2.5058')\n"

">>> c % a\n"

"Decimal('0.77')"

msgstr ""

msgid ""

"Decimals can be formatted (with :func:`format` built-in or :ref:`f-strings`) "

"in fixed-point or scientific notation, using the same formatting syntax "

"(see :ref:`formatspec`) as builtin :class:`float` type:"

msgstr ""

msgid ""

">>> format(Decimal('2.675'), \"f\")\n"

"'2.675'\n"

">>> format(Decimal('2.675'), \".2f\")\n"

"'2.68'\n"

">>> f\"{Decimal('2.675'):.2f}\"\n"

"'2.68'\n"

">>> format(Decimal('2.675'), \".2e\")\n"

"'2.68e+0'\n"

">>> with localcontext() as ctx:\n"

"... ctx.rounding = ROUND_DOWN\n"

"... print(format(Decimal('2.675'), \".2f\"))\n"

"...\n"

"2.67"

msgstr ""

msgid "And some mathematical functions are also available to Decimal:"

msgstr ""

msgid ""

"The :meth:`~Decimal.quantize` method rounds a number to a fixed exponent. "

"This method is useful for monetary applications that often round results to "

"a fixed number of places:"

msgstr ""

msgid ""

"As shown above, the :func:`getcontext` function accesses the current context "

"and allows the settings to be changed. This approach meets the needs of "

"most applications."

msgstr ""

msgid ""

"For more advanced work, it may be useful to create alternate contexts using "

"the :meth:`Context` constructor. To make an alternate active, use the :func:"

"`setcontext` function."

msgstr ""

msgid ""

"In accordance with the standard, the :mod:`decimal` module provides two "

"ready to use standard contexts, :const:`BasicContext` and :const:"

"`ExtendedContext`. The former is especially useful for debugging because "

"many of the traps are enabled:"

msgstr ""

msgid ""

">>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)\n"

">>> setcontext(myothercontext)\n"

">>> Decimal(1) / Decimal(7)\n"

"Decimal('0.142857142857142857142857142857142857142857142857142857142857')\n"

"\n"

">>> ExtendedContext\n"

"Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n"

" capitals=1, clamp=0, flags=[], traps=[])\n"

">>> setcontext(ExtendedContext)\n"

">>> Decimal(1) / Decimal(7)\n"

"Decimal('0.142857143')\n"

">>> Decimal(42) / Decimal(0)\n"

"Decimal('Infinity')\n"

"\n"

">>> setcontext(BasicContext)\n"

">>> Decimal(42) / Decimal(0)\n"

"Traceback (most recent call last):\n"

" File \"<pyshell#143>\", line 1, in -toplevel-\n"

" Decimal(42) / Decimal(0)\n"

"DivisionByZero: x / 0"

msgstr ""

msgid ""

"Contexts also have signal flags for monitoring exceptional conditions "

"encountered during computations. The flags remain set until explicitly "

"cleared, so it is best to clear the flags before each set of monitored "

"computations by using the :meth:`~Context.clear_flags` method. ::"

msgstr ""

msgid ""

">>> setcontext(ExtendedContext)\n"

">>> getcontext().clear_flags()\n"

">>> Decimal(355) / Decimal(113)\n"

"Decimal('3.14159292')\n"

">>> getcontext()\n"

"Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n"

" capitals=1, clamp=0, flags=[Inexact, Rounded], traps=[])"

msgstr ""

msgid ""

"The *flags* entry shows that the rational approximation to pi was rounded "

"(digits beyond the context precision were thrown away) and that the result "

"is inexact (some of the discarded digits were non-zero)."

msgstr ""

msgid ""

"Individual traps are set using the dictionary in the :attr:`~Context.traps` "

"attribute of a context:"

msgstr ""

msgid ""

">>> setcontext(ExtendedContext)\n"

">>> Decimal(1) / Decimal(0)\n"

"Decimal('Infinity')\n"

">>> getcontext().traps[DivisionByZero] = 1\n"

">>> Decimal(1) / Decimal(0)\n"

"Traceback (most recent call last):\n"

" File \"<pyshell#112>\", line 1, in -toplevel-\n"

" Decimal(1) / Decimal(0)\n"

"DivisionByZero: x / 0"

msgstr ""

msgid ""

"Most programs adjust the current context only once, at the beginning of the "

"program. And, in many applications, data is converted to :class:`Decimal` "

"with a single cast inside a loop. With context set and decimals created, "

"the bulk of the program manipulates the data no differently than with other "

"Python numeric types."

msgstr ""

msgid "Decimal objects"

msgstr ""

msgid "Construct a new :class:`Decimal` object based from *value*."

msgstr ""

msgid ""

"*value* can be an integer, string, tuple, :class:`float`, or another :class:"

"`Decimal` object. If no *value* is given, returns ``Decimal('0')``. If "

"*value* is a string, it should conform to the decimal numeric string syntax "

"after leading and trailing whitespace characters, as well as underscores "

"throughout, are removed::"

msgstr ""

msgid ""

"sign ::= '+' | '-'\n"

"digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | "

"'9'\n"

"indicator ::= 'e' | 'E'\n"

"digits ::= digit [digit]...\n"

"decimal-part ::= digits '.' [digits] | ['.'] digits\n"

"exponent-part ::= indicator [sign] digits\n"

"infinity ::= 'Infinity' | 'Inf'\n"

"nan ::= 'NaN' [digits] | 'sNaN' [digits]\n"

"numeric-value ::= decimal-part [exponent-part] | infinity\n"

"numeric-string ::= [sign] numeric-value | [sign] nan"

msgstr ""

msgid ""

"Other Unicode decimal digits are also permitted where ``digit`` appears "

"above. These include decimal digits from various other alphabets (for "

"example, Arabic-Indic and Devanāgarī digits) along with the fullwidth digits "

"``'\\uff10'`` through ``'\\uff19'``. Case is not significant, so, for "

"example, ``inf``, ``Inf``, ``INFINITY``, and ``iNfINity`` are all acceptable "

"spellings for positive infinity."

msgstr ""

msgid ""

"If *value* is a :class:`tuple`, it should have three components, a sign "

"(``0`` for positive or ``1`` for negative), a :class:`tuple` of digits, and "

"an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), -3))`` returns "

"``Decimal('1.414')``."

msgstr ""

msgid ""

"If *value* is a :class:`float`, the binary floating-point value is "

"losslessly converted to its exact decimal equivalent. This conversion can "

"often require 53 or more digits of precision. For example, "

"``Decimal(float('1.1'))`` converts to "

"``Decimal('1.100000000000000088817841970012523233890533447265625')``."

msgstr ""

msgid ""

"The *context* precision does not affect how many digits are stored. That is "

"determined exclusively by the number of digits in *value*. For example, "

"``Decimal('3.00000')`` records all five zeros even if the context precision "

"is only three."

msgstr ""

msgid ""

"The purpose of the *context* argument is determining what to do if *value* "

"is a malformed string. If the context traps :const:`InvalidOperation`, an "

"exception is raised; otherwise, the constructor returns a new Decimal with "

"the value of ``NaN``."

msgstr ""

msgid "Once constructed, :class:`Decimal` objects are immutable."

msgstr ""

msgid ""

"The argument to the constructor is now permitted to be a :class:`float` "

"instance."

msgstr ""

msgid ""

":class:`float` arguments raise an exception if the :exc:`FloatOperation` "

"trap is set. By default the trap is off."

msgstr ""

msgid ""

"Underscores are allowed for grouping, as with integral and floating-point "

"literals in code."

msgstr ""

msgid ""

"Decimal floating-point objects share many properties with the other built-in "

"numeric types such as :class:`float` and :class:`int`. All of the usual "

"math operations and special methods apply. Likewise, decimal objects can be "

"copied, pickled, printed, used as dictionary keys, used as set elements, "

"compared, sorted, and coerced to another type (such as :class:`float` or :"

"class:`int`)."

msgstr ""

msgid ""

"There are some small differences between arithmetic on Decimal objects and "

"arithmetic on integers and floats. When the remainder operator ``%`` is "

"applied to Decimal objects, the sign of the result is the sign of the "

"*dividend* rather than the sign of the divisor::"

msgstr ""

msgid ""

">>> (-7) % 4\n"

"1\n"

">>> Decimal(-7) % Decimal(4)\n"

"Decimal('-3')"

msgstr ""

">>> (-7) % 4\n"

"1\n"

">>> Decimal(-7) % Decimal(4)\n"

"Decimal('-3')"

msgid ""

"The integer division operator ``//`` behaves analogously, returning the "

"integer part of the true quotient (truncating towards zero) rather than its "

"floor, so as to preserve the usual identity ``x == (x // y) * y + x % y``::"

msgstr ""

msgid ""

">>> -7 // 4\n"

"-2\n"

">>> Decimal(-7) // Decimal(4)\n"

"Decimal('-1')"

msgstr ""

">>> -7 // 4\n"

"-2\n"

">>> Decimal(-7) // Decimal(4)\n"

"Decimal('-1')"

msgid ""

"The ``%`` and ``//`` operators implement the ``remainder`` and ``divide-"

"integer`` operations (respectively) as described in the specification."

msgstr ""

msgid ""

"Decimal objects cannot generally be combined with floats or instances of :"

"class:`fractions.Fraction` in arithmetic operations: an attempt to add a :"

"class:`Decimal` to a :class:`float`, for example, will raise a :exc:"

"`TypeError`. However, it is possible to use Python's comparison operators "

"to compare a :class:`Decimal` instance ``x`` with another number ``y``. "

"This avoids confusing results when doing equality comparisons between "

"numbers of different types."

msgstr ""

msgid ""

"Mixed-type comparisons between :class:`Decimal` instances and other numeric "

"types are now fully supported."

msgstr ""

msgid ""

"In addition to the standard numeric properties, decimal floating-point "

"objects also have a number of specialized methods:"

msgstr ""

msgid ""

"Return the adjusted exponent after shifting out the coefficient's rightmost "

"digits until only the lead digit remains: ``Decimal('321e+5').adjusted()`` "

"returns seven. Used for determining the position of the most significant "

"digit with respect to the decimal point."

msgstr ""

msgid ""

"Return a pair ``(n, d)`` of integers that represent the given :class:"

"`Decimal` instance as a fraction, in lowest terms and with a positive "

"denominator::"

msgstr ""

msgid ""

">>> Decimal('-3.14').as_integer_ratio()\n"

"(-157, 50)"

msgstr ""

">>> Decimal('-3.14').as_integer_ratio()\n"

"(-157, 50)"

msgid ""

"The conversion is exact. Raise OverflowError on infinities and ValueError "

"on NaNs."

msgstr ""

msgid ""

"Return a :term:`named tuple` representation of the number: "

"``DecimalTuple(sign, digits, exponent)``."

msgstr ""

msgid ""

"Return the canonical encoding of the argument. Currently, the encoding of "

"a :class:`Decimal` instance is always canonical, so this operation returns "

"its argument unchanged."

msgstr ""

msgid ""

"Compare the values of two Decimal instances. :meth:`compare` returns a "

"Decimal instance, and if either operand is a NaN then the result is a NaN::"

msgstr ""

msgid ""

"a or b is a NaN ==> Decimal('NaN')\n"

"a < b ==> Decimal('-1')\n"

"a == b ==> Decimal('0')\n"

"a > b ==> Decimal('1')"

msgstr ""

msgid ""

"This operation is identical to the :meth:`compare` method, except that all "

"NaNs signal. That is, if neither operand is a signaling NaN then any quiet "

"NaN operand is treated as though it were a signaling NaN."

msgstr ""

msgid ""

"Compare two operands using their abstract representation rather than their "

"numerical value. Similar to the :meth:`compare` method, but the result "

"gives a total ordering on :class:`Decimal` instances. Two :class:`Decimal` "

"instances with the same numeric value but different representations compare "

"unequal in this ordering:"

msgstr ""

msgid ""

"Quiet and signaling NaNs are also included in the total ordering. The "

"result of this function is ``Decimal('0')`` if both operands have the same "

"representation, ``Decimal('-1')`` if the first operand is lower in the total "

"order than the second, and ``Decimal('1')`` if the first operand is higher "

"in the total order than the second operand. See the specification for "

"details of the total order."

msgstr ""

msgid ""

"This operation is unaffected by context and is quiet: no flags are changed "

"and no rounding is performed. As an exception, the C version may raise "

"InvalidOperation if the second operand cannot be converted exactly."

msgstr ""

msgid ""

"Compare two operands using their abstract representation rather than their "

"value as in :meth:`compare_total`, but ignoring the sign of each operand. "

"``x.compare_total_mag(y)`` is equivalent to ``x.copy_abs().compare_total(y."

"copy_abs())``."

msgstr ""

msgid ""

"Just returns self, this method is only to comply with the Decimal "

"Specification."

msgstr ""

msgid ""

"Return the absolute value of the argument. This operation is unaffected by "

"the context and is quiet: no flags are changed and no rounding is performed."

msgstr ""

msgid ""

"Return the negation of the argument. This operation is unaffected by the "

"context and is quiet: no flags are changed and no rounding is performed."

msgstr ""

msgid ""

"Return a copy of the first operand with the sign set to be the same as the "

"sign of the second operand. For example:"

msgstr ""

msgid ""

"Return the value of the (natural) exponential function ``e**x`` at the given "

"number. The result is correctly rounded using the :const:`ROUND_HALF_EVEN` "

"rounding mode."

msgstr ""

msgid ""

"Alternative constructor that only accepts instances of :class:`float` or :"

"class:`int`."

msgstr ""

msgid ""

"Note ``Decimal.from_float(0.1)`` is not the same as ``Decimal('0.1')``. "

"Since 0.1 is not exactly representable in binary floating point, the value "

"is stored as the nearest representable value which is "

"``0x1.999999999999ap-4``. That equivalent value in decimal is "

"``0.1000000000000000055511151231257827021181583404541015625``."

msgstr ""

msgid ""

"From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed "

"directly from a :class:`float`."

msgstr ""

msgid ""

">>> Decimal.from_float(0.1)\n"

"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"

">>> Decimal.from_float(float('nan'))\n"

"Decimal('NaN')\n"

">>> Decimal.from_float(float('inf'))\n"

"Decimal('Infinity')\n"

">>> Decimal.from_float(float('-inf'))\n"

"Decimal('-Infinity')"

msgstr ""

">>> Decimal.from_float(0.1)\n"

"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"

">>> Decimal.from_float(float('nan'))\n"

"Decimal('NaN')\n"

">>> Decimal.from_float(float('inf'))\n"

"Decimal('Infinity')\n"

">>> Decimal.from_float(float('-inf'))\n"

"Decimal('-Infinity')"

msgid ""

"Fused multiply-add. Return self*other+third with no rounding of the "

"intermediate product self*other."

msgstr ""

msgid ""

"Return :const:`True` if the argument is canonical and :const:`False` "

"otherwise. Currently, a :class:`Decimal` instance is always canonical, so "

"this operation always returns :const:`True`."

msgstr ""

msgid ""

"Return :const:`True` if the argument is a finite number, and :const:`False` "

"if the argument is an infinity or a NaN."

msgstr ""

msgid ""

"Return :const:`True` if the argument is either positive or negative infinity "

"and :const:`False` otherwise."

msgstr ""

msgid ""

"Return :const:`True` if the argument is a (quiet or signaling) NaN and :"

"const:`False` otherwise."

msgstr ""

msgid ""

"Return :const:`True` if the argument is a *normal* finite number. Return :"

"const:`False` if the argument is zero, subnormal, infinite or a NaN."

msgstr ""

msgid ""

"Return :const:`True` if the argument is a quiet NaN, and :const:`False` "

"otherwise."

msgstr ""

msgid ""

"Return :const:`True` if the argument has a negative sign and :const:`False` "

"otherwise. Note that zeros and NaNs can both carry signs."

msgstr ""

msgid ""

"Return :const:`True` if the argument is a signaling NaN and :const:`False` "

"otherwise."

msgstr ""

msgid ""

"Return :const:`True` if the argument is subnormal, and :const:`False` "

"otherwise."

msgstr ""

msgid ""

"Return :const:`True` if the argument is a (positive or negative) zero and :"

"const:`False` otherwise."

msgstr ""

msgid ""

"Return the natural (base e) logarithm of the operand. The result is "

"correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."

msgstr ""

msgid ""

"Return the base ten logarithm of the operand. The result is correctly "

"rounded using the :const:`ROUND_HALF_EVEN` rounding mode."

msgstr ""

msgid ""

"For a nonzero number, return the adjusted exponent of its operand as a :"

"class:`Decimal` instance. If the operand is a zero then ``Decimal('-"

"Infinity')`` is returned and the :const:`DivisionByZero` flag is raised. If "

"the operand is an infinity then ``Decimal('Infinity')`` is returned."

msgstr ""

msgid ""

":meth:`logical_and` is a logical operation which takes two *logical "

"operands* (see :ref:`logical_operands_label`). The result is the digit-wise "

"``and`` of the two operands."

msgstr ""

msgid ""

":meth:`logical_invert` is a logical operation. The result is the digit-wise "

"inversion of the operand."

msgstr ""

msgid ""

":meth:`logical_or` is a logical operation which takes two *logical operands* "

"(see :ref:`logical_operands_label`). The result is the digit-wise ``or`` of "

"the two operands."

msgstr ""

msgid ""

":meth:`logical_xor` is a logical operation which takes two *logical "

"operands* (see :ref:`logical_operands_label`). The result is the digit-wise "

"exclusive or of the two operands."

msgstr ""

msgid ""

"Like ``max(self, other)`` except that the context rounding rule is applied "

"before returning and that ``NaN`` values are either signaled or ignored "

"(depending on the context and whether they are signaling or quiet)."

msgstr ""

msgid ""

"Similar to the :meth:`.max` method, but the comparison is done using the "

"absolute values of the operands."

msgstr ""

msgid ""

"Like ``min(self, other)`` except that the context rounding rule is applied "

"before returning and that ``NaN`` values are either signaled or ignored "

"(depending on the context and whether they are signaling or quiet)."

msgstr ""

msgid ""

"Similar to the :meth:`.min` method, but the comparison is done using the "

"absolute values of the operands."

msgstr ""

msgid ""

"Return the largest number representable in the given context (or in the "

"current thread's context if no context is given) that is smaller than the "

"given operand."

msgstr ""

msgid ""

"Return the smallest number representable in the given context (or in the "

"current thread's context if no context is given) that is larger than the "

"given operand."

msgstr ""

msgid ""

"If the two operands are unequal, return the number closest to the first "

"operand in the direction of the second operand. If both operands are "

"numerically equal, return a copy of the first operand with the sign set to "

"be the same as the sign of the second operand."

msgstr ""

msgid ""

"Used for producing canonical values of an equivalence class within either "

"the current context or the specified context."

msgstr ""

msgid ""

"This has the same semantics as the unary plus operation, except that if the "

"final result is finite it is reduced to its simplest form, with all trailing "

"zeros removed and its sign preserved. That is, while the coefficient is non-"

"zero and a multiple of ten the coefficient is divided by ten and the "

"exponent is incremented by 1. Otherwise (the coefficient is zero) the "

"exponent is set to 0. In all cases the sign is unchanged."

msgstr ""

msgid ""

"For example, ``Decimal('32.100')`` and ``Decimal('0.321000e+2')`` both "

"normalize to the equivalent value ``Decimal('32.1')``."

msgstr ""

msgid "Note that rounding is applied *before* reducing to simplest form."

msgstr ""

msgid ""

"In the latest versions of the specification, this operation is also known as "

"``reduce``."

msgstr ""

msgid ""

"Return a string describing the *class* of the operand. The returned value "

"is one of the following ten strings."

msgstr ""

msgid "``\"-Infinity\"``, indicating that the operand is negative infinity."

msgstr ""

msgid ""

"``\"-Normal\"``, indicating that the operand is a negative normal number."

msgstr ""

msgid ""

"``\"-Subnormal\"``, indicating that the operand is negative and subnormal."

msgstr ""

msgid "``\"-Zero\"``, indicating that the operand is a negative zero."

msgstr ""

msgid "``\"+Zero\"``, indicating that the operand is a positive zero."

msgstr ""

msgid ""

"``\"+Subnormal\"``, indicating that the operand is positive and subnormal."

msgstr ""

msgid ""

"``\"+Normal\"``, indicating that the operand is a positive normal number."

msgstr ""

msgid "``\"+Infinity\"``, indicating that the operand is positive infinity."

msgstr ""

msgid "``\"NaN\"``, indicating that the operand is a quiet NaN (Not a Number)."

msgstr ""

msgid "``\"sNaN\"``, indicating that the operand is a signaling NaN."

msgstr ""

msgid ""

"Return a value equal to the first operand after rounding and having the "

"exponent of the second operand."

msgstr ""

msgid ""

"Unlike other operations, if the length of the coefficient after the quantize "

"operation would be greater than precision, then an :const:`InvalidOperation` "

"is signaled. This guarantees that, unless there is an error condition, the "

"quantized exponent is always equal to that of the right-hand operand."

msgstr ""

msgid ""

"Also unlike other operations, quantize never signals Underflow, even if the "

"result is subnormal and inexact."

msgstr ""

msgid ""

"If the exponent of the second operand is larger than that of the first then "

"rounding may be necessary. In this case, the rounding mode is determined by "

"the ``rounding`` argument if given, else by the given ``context`` argument; "

"if neither argument is given the rounding mode of the current thread's "

"context is used."

msgstr ""

msgid ""

"An error is returned whenever the resulting exponent is greater than :attr:"

"`~Context.Emax` or less than :meth:`~Context.Etiny`."

msgstr ""

msgid ""

"Return ``Decimal(10)``, the radix (base) in which the :class:`Decimal` class "

"does all its arithmetic. Included for compatibility with the specification."

msgstr ""

msgid ""

"Return the remainder from dividing *self* by *other*. This differs from "

"``self % other`` in that the sign of the remainder is chosen so as to "

"minimize its absolute value. More precisely, the return value is ``self - n "

"* other`` where ``n`` is the integer nearest to the exact value of ``self / "

"other``, and if two integers are equally near then the even one is chosen."

msgstr ""

msgid "If the result is zero then its sign will be the sign of *self*."

msgstr ""

msgid ""

"Return the result of rotating the digits of the first operand by an amount "

"specified by the second operand. The second operand must be an integer in "

"the range -precision through precision. The absolute value of the second "

"operand gives the number of places to rotate. If the second operand is "

"positive then rotation is to the left; otherwise rotation is to the right. "

"The coefficient of the first operand is padded on the left with zeros to "

"length precision if necessary. The sign and exponent of the first operand "

"are unchanged."

msgstr ""

msgid ""

"Test whether self and other have the same exponent or whether both are "

"``NaN``."

msgstr ""

msgid ""

"Return the first operand with exponent adjusted by the second. Equivalently, "

"return the first operand multiplied by ``10**other``. The second operand "

"must be an integer."

msgstr ""

msgid ""

"Return the result of shifting the digits of the first operand by an amount "

"specified by the second operand. The second operand must be an integer in "

"the range -precision through precision. The absolute value of the second "

"operand gives the number of places to shift. If the second operand is "

"positive then the shift is to the left; otherwise the shift is to the "

"right. Digits shifted into the coefficient are zeros. The sign and "

"exponent of the first operand are unchanged."

msgstr ""

msgid "Return the square root of the argument to full precision."

msgstr ""

msgid ""

"Convert to a string, using engineering notation if an exponent is needed."

msgstr ""

msgid ""

"Engineering notation has an exponent which is a multiple of 3. This can "

"leave up to 3 digits to the left of the decimal place and may require the "

"addition of either one or two trailing zeros."

msgstr ""

msgid ""

"For example, this converts ``Decimal('123E+1')`` to ``Decimal('1.23E+3')``."

msgstr ""

msgid ""

"Identical to the :meth:`to_integral_value` method. The ``to_integral`` name "

"has been kept for compatibility with older versions."

msgstr ""

msgid ""

"Round to the nearest integer, signaling :const:`Inexact` or :const:`Rounded` "

"as appropriate if rounding occurs. The rounding mode is determined by the "

"``rounding`` parameter if given, else by the given ``context``. If neither "

"parameter is given then the rounding mode of the current context is used."

msgstr ""

msgid ""