decimal.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025
# Parham Forati, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-16 12:56+0000\n"
"PO-Revision-Date: 2026-09-14 10:21+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: Persian (https://github.com/python/python-docs-fa/)\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 3.6\n"

msgid ":mod:`!decimal` --- Decimal fixed-point and floating-point arithmetic"
msgstr ":mod:`!decimal` --- حساب دهدهی ممیز ثابت و ممیز شناور"

msgid "**Source code:** :source:`Lib/decimal.py`"
msgstr "**کد منبع:** :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 "ماژول :mod:`!decimal` پشتیبانی از محاسبات ممیز شناور اعشاری سریع و با گرد کردن صحیح را فراهم می‌کند. این ماژول چندین مزیت نسبت به نوع داده :class:`float` دارد:"

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 "Decimal «بر اساس یک `مدل ممیز شناور <https://speleotrove.com/decimal/damodel.html#refnumber>`__ است که با در نظر گرفتن انسان‌ها طراحی شده و لزوماً دارای یک اصل راهنمای برتر است -- رایانه‌ها باید حسابی فراهم کنند که به همان شیوه‌ای کار کند که حسابی که مردم در مدرسه می‌آموزند، کار می‌کند.» -- گزیده‌ای از مشخصات حساب اعشاری."

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 "اعداد دهدهی را می‌توان به‌صورت دقیق بازنمایی کرد. در مقابل، اعدادی مانند ``1.1`` و ``2.2`` بازنمایی دقیقی در ممیز شناور دودویی ندارند. کاربران نهایی معمولاً انتظار ندارند ``1.1 + 2.2`` به‌صورت ``3.3000000000000003`` نمایش داده شود، همان‌گونه که در ممیز شناور دودویی رخ می‌دهد."

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 "این دقت در محاسبات حسابی نیز برقرار است. در ممیز شناور اعشاری، ``0.1 + 0.1 + 0.1 - 0.3`` دقیقاً برابر با صفر است. در ممیز شناور دودویی، نتیجه ``5.5511151231257827e-017`` است. هرچند به صفر نزدیک است، اما این تفاوت‌ها مانع از بررسی برابری قابل‌اعتماد می‌شوند و ممکن است انباشته شوند. به همین دلیل، ممیز شناور اعشاری در برنامه‌های حسابداری که دارای ناورداهای برابری دقیق هستند، ترجیح داده می‌شود."

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 "ماژول decimal مفهوم ارقام معنادار را در بر می‌گیرد، به‌طوری‌که ``1.30 + 1.20`` برابر ``2.50`` است. صفر پایانی برای نشان دادن معناداری حفظ می‌شود. این نمایش مرسوم برای کاربردهای مالی است. برای ضرب، روش «کتاب درسی» از تمام ارقام عوامل ضرب استفاده می‌کند. برای مثال، ``1.3 * 1.2`` مقدار ``1.56`` را می‌دهد، در حالی که ``1.30 * 1.20`` مقدار ``1.5600`` را می‌دهد."

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 "برخلاف ممیز شناور دودویی مبتنی بر سخت‌افزار، ماژول decimal دارای دقت قابل تغییر توسط کاربر (با پیش‌فرض ۲۸ رقم اعشار) است که می‌تواند به هر اندازه‌ای که برای یک مسئله مشخص لازم باشد، بزرگ باشد:"

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 "هر دو نوع ممیز شناور دودویی و اعشاری بر اساس استانداردهای منتشرشده پیاده‌سازی شده‌اند. در حالی که نوع float توکار تنها بخش محدودی از قابلیت‌های خود را در اختیار می‌گذارد، ماژول decimal تمام بخش‌های مورد نیاز استاندارد را در اختیار می‌گذارد. در صورت نیاز، برنامه‌نویس کنترل کاملی بر گرد کردن و مدیریت سیگنال دارد. این شامل گزینه‌ای برای اعمال حساب دقیق با استفاده از استثناها جهت مسدود کردن هرگونه عملیات غیردقیق است."

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 "ماژول decimal طراحی شده است تا «بدون جانبداری، هم از حساب اعشاری دقیق و بدون گرد کردن (که گاهی حساب ممیز ثابت نامیده می‌شود) و هم از حساب ممیز شناور گردشده» پشتیبانی کند. — گزیده‌ای از مشخصات حساب اعشاری."

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 "یک عدد ده‌دهی تغییرناپذیر است. این عدد دارای علامت، ارقام ضریب و توان است. برای حفظ معناداری، صفرهای انتهایی از ارقام ضریب حذف نمی‌شوند. اعداد ده‌دهی همچنین شامل مقادیر خاصی مانند ``Infinity``، ``-Infinity`` و ``NaN`` هستند. این استاندارد همچنین ``-0`` را از ``+0`` متمایز می‌کند."

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 "زمینه‌ی محاسبات، محیطی است که دقت، قواعد گرد کردن، محدودیت‌های توان‌ها، پرچم‌های نشان‌دهنده‌ی نتایج عملیات و فعال‌سازهای تله را مشخص می‌کند؛ فعال‌سازهای تله تعیین می‌کنند که آیا سیگنال‌ها به‌عنوان استثنا در نظر گرفته می‌شوند یا خیر. گزینه‌های گرد کردن شامل :const:`ROUND_CEILING`، :const:`ROUND_DOWN`، :const:`ROUND_FLOOR`، :const:`ROUND_HALF_DOWN`، :const:`ROUND_HALF_EVEN`، :const:`ROUND_HALF_UP`، :const:`ROUND_UP` و :const:`ROUND_05UP` هستند."

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 "سیگنال‌ها گروه‌هایی از شرایط استثنایی هستند که در طول محاسبات رخ می‌دهند. بسته به نیازهای برنامه، ممکن است سیگنال‌ها نادیده گرفته شوند، به‌عنوان اطلاع‌رسانی در نظر گرفته شوند، یا به‌عنوان استثنا مدیریت شوند. سیگنال‌های ماژول decimal عبارتند از: :const:`Clamped`، :const:`InvalidOperation`، :const:`DivisionByZero`، :const:`Inexact`، :const:`Rounded`، :const:`Subnormal`، :const:`Overflow`، :const:`Underflow` و :const:`FloatOperation`."

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 "مشخصات حساب اعشاری عمومی IBM، `The General Decimal Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."

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 "آغاز معمول استفاده از اعداد اعشاری، ایمپورت کردن ماژول، مشاهده‌ی زمینه‌ی فعلی با :func:`getcontext` و، در صورت لزوم، تنظیم مقادیر جدید برای دقت، گرد کردن، یا تله‌های فعال است::"

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 ""
">>> 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"

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 "نمونه‌های Decimal را می‌توان از اعداد صحیح، رشته‌ها، اعداد اعشاری یا تاپل‌ها ساخت. ساخت از یک عدد صحیح یا عدد اعشاری، تبدیل دقیق مقدار آن عدد صحیح یا عدد اعشاری را انجام می‌دهد. اعداد Decimal شامل مقادیر ویژه‌ای مانند ``NaN`` هستند که مخفف «Not a number» است، همچنین ``Infinity`` مثبت و منفی، و ``-0``::"

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 ""
">>> 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')"

msgid "If the :exc:`FloatOperation` signal is trapped, accidental mixing of decimals and floats in constructors or ordering comparisons raises an exception::"
msgstr "اگر سیگنال :exc:`FloatOperation` به دام بیفتد، ترکیب ناخواسته‌ی decimalها و floatها در سازنده‌ها یا مقایسه‌های ترتیبی باعث پرتاب یک استثنا می‌شود::"

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 ""
">>> 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"

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 "معناداری یک Decimal جدید صرفاً با تعداد ارقام ورودی تعیین می‌شود. دقت و گرد کردن زمینه فقط در حین عملیات حسابی اعمال می‌شوند."

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 ""
">>> 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')"

msgid "If the internal limits of the C version are exceeded, constructing a decimal raises :class:`InvalidOperation`::"
msgstr "در صورت تجاوز از محدودیت‌های داخلی نسخه C، ساخت یک decimal باعث پرتاب :class:`InvalidOperation` می‌شود::"

msgid ""
">>> Decimal(\"1e9999999999999999999\")\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]"
msgstr ""
">>> Decimal(\"1e9999999999999999999\")\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]"

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 ""
">>> 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')"

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 "دسیمال‌ها را می‌توان (با تابع توکار :func:`format` یا :ref:`f-strings`) به‌صورت نماد ممیز ثابت یا علمی قالب‌بندی کرد، با استفاده از همان سینتکس قالب‌بندی (مراجعه کنید به :ref:`formatspec`) که نوع توکار :class:`float` دارد:"

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 ""
">>> 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"

msgid "And some mathematical functions are also available to Decimal:"
msgstr "و برخی از توابع ریاضی نیز برای Decimal در دسترس هستند:"

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 "متد :meth:`~Decimal.quantize` یک عدد را به یک توان ثابت گرد می‌کند. این متد برای کاربردهای مالی که اغلب نتایج را به تعداد ثابتی از ارقام اعشار گرد می‌کنند، مفید است:"

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 "همان‌طور که در بالا نشان داده شد، تابع :func:`getcontext` به زمینه‌ی جاری دسترسی پیدا می‌کند و امکان تغییر تنظیمات را فراهم می‌کند. این رویکرد نیازهای بیشتر برنامه‌های کاربردی را برآورده می‌کند."

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 "برای کارهای پیشرفته‌تر، ممکن است ایجاد زمینه‌های جایگزین با استفاده از سازنده‌ی :meth:`Context` مفید باشد. برای فعال کردن یک زمینه جایگزین، از تابع :func:`setcontext` استفاده کنید."

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 "مطابق با استاندارد، ماژول :mod:`!decimal` دو زمینه استاندارد آماده استفاده، :const:`BasicContext` و :const:`ExtendedContext` را فراهم می‌کند. مورد اول به‌ویژه برای اشکال‌زدایی مفید است، زیرا بسیاری از تله‌ها فعال هستند:"

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 ""
">>> 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"

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 "زمینه‌ها همچنین پرچم‌های سیگنال برای پایش شرایط استثنایی پیش‌آمده در حین محاسبات دارند. این پرچم‌ها تا زمانی که به‌صراحت پاک نشوند، فعال باقی می‌مانند؛ بنابراین بهتر است پیش از هر مجموعه‌ای از محاسبات تحت پایش، پرچم‌ها را با استفاده از متد :meth:`~Context.clear_flags` پاک کنید. ::"

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 ""
">>> 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=[])"

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 "مدخل *flags* نشان می‌دهد که تقریب گویای عدد پی گرد شده است (ارقام فراتر از دقت زمینه دور ریخته شدند) و نتیجه نادقیق است (برخی از ارقام دور ریخته‌شده غیرصفر بودند)."

msgid "Individual traps are set using the dictionary in the :attr:`~Context.traps` attribute of a context:"
msgstr "تله‌های منفرد با استفاده از دیکشنری موجود در ویژگی :attr:`~Context.traps` یک زمینه تنظیم می‌شوند:"

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 ""
">>> 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"

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 "بیشتر برنامه‌ها زمینه‌ی جاری را تنها یک بار، در آغاز برنامه تنظیم می‌کنند. و در بسیاری از برنامه‌های کاربردی، داده‌ها درون یک حلقه با یک تبدیل (cast) واحد به :class:`Decimal` تبدیل می‌شوند. پس از تنظیم زمینه و ایجاد مقادیر Decimal، بخش عمده‌ی برنامه داده‌ها را دقیقاً مانند سایر انواع عددی پایتون دستکاری می‌کند."

msgid "Decimal objects"
msgstr "اشیای Decimal"

msgid "Construct a new :class:`Decimal` object based from *value*."
msgstr "یک شیء جدید :class:`Decimal` بر اساس *value* بسازید."

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 "*value* می‌تواند یک عدد صحیح، رشته، تاپل، :class:`float`، یا یک شیء :class:`Decimal` دیگر باشد. اگر *value* ارائه نشود، ``Decimal('0')`` برگردانده می‌شود. اگر *value* یک رشته باشد، باید پس از حذف نویسه‌های فضای سفید در ابتدا و انتها، و همچنین زیرسطرها در سراسر آن، با سینتکس رشته عددی اعشاری مطابقت کند::"

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 ""
"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"

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 "سایر ارقام دهدهی یونیکد نیز در هر جایی که ``digit`` در بالا آمده است، مجاز هستند. این موارد شامل ارقام دهدهی از الفباهای مختلف دیگر (برای مثال، ارقام عربی-هندی و دوناگری) به‌همراه ارقام تمام‌عرض ``'\\uff10'`` تا ``'\\uff19'`` می‌شوند. بزرگی و کوچکی حروف اهمیت ندارد، بنابراین، برای مثال، ``inf``، ``Inf``، ``INFINITY`` و ``iNfINity`` همگی نگارش‌های قابل‌قبول برای بی‌نهایت مثبت هستند."

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 "اگر *value* یک :class:`tuple` باشد، باید سه کامپوننت داشته باشد: یک علامت (``0`` برای مثبت یا ``1`` برای منفی)، یک :class:`tuple` از ارقام، و یک توان عدد صحیح. برای مثال، ``Decimal((0, (1, 4, 1, 4), -3))`` ``Decimal('1.414')`` را برمی‌گرداند."

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 "اگر *value* یک :class:`float` باشد، مقدار ممیز شناور دودویی بدون از دست دادن دقت به معادل دهدهی دقیق خود تبدیل می‌شود. این تبدیل اغلب ممکن است به ۵۳ رقم دقت یا بیشتر نیاز داشته باشد. برای مثال، ``Decimal(float('1.1'))`` به ``Decimal('1.100000000000000088817841970012523233890533447265625')`` تبدیل می‌شود."

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 "دقت *زمینه* بر تعداد ارقام ذخیره‌شده تأثیر نمی‌گذارد. این موضوع منحصراً بر اساس تعداد ارقام موجود در *مقدار* تعیین می‌شود. برای مثال، ``Decimal('3.00000')`` حتی اگر دقت زمینه فقط ۳ باشد، هر ۵ صفر را ثبت می‌کند."

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 "هدف از آرگومان *context* تعیین این است که اگر *value* رشته‌ای نامعتبر باشد، چه کاری انجام شود. اگر زمینه برای :const:`InvalidOperation` دام داشته باشد، یک استثنا پرتاب می‌شود؛ در غیر این صورت، سازنده یک Decimal جدید با مقدار ``NaN`` برمی‌گرداند."

msgid "Once constructed, :class:`Decimal` objects are immutable."
msgstr "پس از ساخته شدن، اشیای :class:`Decimal` تغییرناپذیر هستند."

msgid "The argument to the constructor is now permitted to be a :class:`float` instance."
msgstr "آرگومان سازنده اکنون می‌تواند یک نمونه :class:`float` باشد."

msgid ":class:`float` arguments raise an exception if the :exc:`FloatOperation` trap is set. By default the trap is off."
msgstr "آرگومان‌های :class:`float` در صورت تنظیم بودن تله‌ی :exc:`FloatOperation` یک استثنا پرتاب می‌کنند. به‌طور پیش‌فرض، این تله غیرفعال است."

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 "اشیای ممیز شناور اعشاری بسیاری از ویژگی‌ها را با سایر انواع عددی توکار مانند :class:`float` و :class:`int` به اشتراک می‌گذارند. تمام عملیات ریاضی معمول و متدهای ویژه قابل اعمال هستند. به همین ترتیب، اشیای اعشاری را می‌توان کپی کرد، پیکل کرد، چاپ کرد، به‌عنوان کلیدهای دیکشنری استفاده کرد، به‌عنوان عناصر مجموعه استفاده کرد، مقایسه کرد، مرتب کرد و به نوع دیگری (مانند :class:`float` یا :class:`int`) تبدیل کرد."

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 "تفاوت‌های کوچکی میان عملیات حسابی بر روی اشیای Decimal و عملیات حسابی بر روی اعداد صحیح و اعداد اعشاری وجود دارد. هنگامی که عملگر باقی‌مانده ``%`` بر روی اشیای Decimal اعمال شود، علامت نتیجه، علامت *مقسوم* است، نه علامت مقسوم‌علیه::"

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 "عملگر تقسیم عدد صحیح ``//`` به‌طور مشابه رفتار می‌کند و به جای کف خارج‌قسمت واقعی، بخش عدد صحیح آن را (با قطع به سمت صفر) برمی‌گرداند تا اتحاد معمول ``x == (x // y) * y + x % y`` حفظ شود::"

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 "عملگرهای ``%`` و ``//`` به‌ترتیب عملیات ``remainder`` و ``divide-integer`` را همان‌گونه که در مشخصات آمده است پیاده‌سازی می‌کنند."

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 "به‌طور کلی نمی‌توان اشیاء Decimal را در عملیات حسابی با floatها یا نمونه‌هایی از :class:`fractions.Fraction` ترکیب کرد: برای مثال، تلاش برای جمع کردن یک :class:`Decimal` با یک :class:`float` باعث پرتاب یک :exc:`TypeError` می‌شود.  با این حال، می‌توان از عملگرهای مقایسه‌ای پایتون برای مقایسه‌ی یک نمونه‌ی :class:`Decimal` یعنی ``x`` با عدد دیگری ``y`` استفاده کرد.  این کار از بروز نتایج گیج‌کننده هنگام انجام مقایسه‌های برابری میان اعدادی از انواع مختلف جلوگیری می‌کند."

msgid "Mixed-type comparisons between :class:`Decimal` instances and other numeric types are now fully supported."
msgstr "مقایسه‌های بین انواع مختلف میان نمونه‌های :class:`Decimal` و سایر انواع عددی اکنون به‌طور کامل پشتیبانی می‌شوند."

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 "توان تنظیم‌شده را پس از حذف رقم‌های سمت راست ضریب تا جایی که تنها رقم نخست باقی بماند، برمی‌گرداند: ``Decimal('321e+5').adjusted()`` عدد هفت را برمی‌گرداند. برای تعیین موقعیت باارزش‌ترین رقم نسبت به نقطه اعشار استفاده می‌شود."

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 "یک جفت عدد صحیح ``(n, d)`` برمی‌گرداند که نمونه‌ی :class:`Decimal` داده‌شده را به‌صورت کسر، در ساده‌ترین حالت و با مخرج مثبت نمایش می‌دهد::"

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 "این تبدیل دقیق است. برای بی‌نهایت‌ها، OverflowError و برای NaNها، ValueError پرتاب می‌شود."

msgid "Return a :term:`named tuple` representation of the number: ``DecimalTuple(sign, digits, exponent)``."
msgstr "نمایشی به‌صورت :term:`named tuple` از عدد برمی‌گرداند: ``DecimalTuple(sign, digits, exponent)``."

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 "کدگذاری کانونیکال آرگومان را برمی‌گرداند.  در حال حاضر، کدگذاری یک نمونه‌ی :class:`Decimal` همیشه کانونیکال است، بنابراین این عملیات آرگومان خود را بدون تغییر برمی‌گرداند."

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 "مقادیر دو نمونه از Decimal را مقایسه می‌کند. :meth:`compare` یک نمونه از Decimal برمی‌گرداند، و اگر هر یک از دو عملوند NaN باشد، نتیجه NaN است::"

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 ""
"a یا b یک NaN باشد  ==> Decimal('NaN')\n"
"a < b            ==> Decimal('-1')\n"
"a == b           ==> Decimal('0')\n"
"a > b            ==> Decimal('1')"

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 "این عملیات دقیقاً مشابه متد :meth:`compare` است، با این تفاوت که همه NaNها سیگنال‌دهی می‌کنند. یعنی، اگر هیچ‌کدام از عملوندها یک NaN سیگنال‌دهنده (signaling NaN) نباشد، هر عملوند NaN ساکت (quiet NaN) به‌عنوان یک NaN سیگنال‌دهنده در نظر گرفته می‌شود."

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 "دو عملوند را با استفاده از بازنمایی انتزاعی آن‌ها به جای مقدار عددی‌شان مقایسه می‌کند. مشابه متد :meth:`compare`، اما نتیجه ترتیب کاملی بر نمونه‌های :class:`Decimal` ارائه می‌دهد. دو نمونه‌ی :class:`Decimal` با مقدار عددی یکسان اما بازنمایی‌های متفاوت، در این ترتیب نابرابر مقایسه می‌شوند:"

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 "NaNهای آرام و سیگنال‌ده (signaling) نیز در ترتیب کامل گنجانده شده‌اند. نتیجه این تابع ``Decimal('0')`` است اگر هر دو عملوند نمایش یکسانی داشته باشند، ``Decimal('-1')`` است اگر عملوند اول در ترتیب کامل پایین‌تر از عملوند دوم باشد، و ``Decimal('1')`` است اگر عملوند اول در ترتیب کامل بالاتر از عملوند دوم باشد. برای جزئیات ترتیب کامل، به مشخصات مراجعه کنید."

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 "این عملیات تحت تأثیر زمینه قرار نمی‌گیرد و ساکت است: هیچ پرچمی تغییر نمی‌کند و هیچ گردکردنی انجام نمی‌شود. به‌عنوان یک استثنا، نسخه‌ی C ممکن است در صورتی که عملوند دوم نتواند به‌طور دقیق تبدیل شود، استثنای InvalidOperation را پرتاب کند."

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 "دو عملوند را همانند :meth:`compare_total` با استفاده از نمایش انتزاعی آن‌ها مقایسه می‌کند، نه با استفاده از مقدارشان، اما علامت هر عملوند را نادیده می‌گیرد. ``x.compare_total_mag(y)`` معادل ``x.copy_abs().compare_total(y.copy_abs())`` است."

msgid "Just returns self, this method is only to comply with the Decimal Specification."
msgstr "فقط self را برمی‌گرداند؛ این متد تنها برای انطباق با Decimal Specification است."

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 "مقدار تابع نمایی (طبیعی) ``e**x`` را برای عدد داده‌شده برمی‌گرداند. نتیجه با استفاده از حالت گرد کردن :const:`ROUND_HALF_EVEN` به‌درستی گرد می‌شود."

msgid "Alternative constructor that only accepts instances of :class:`float` or :class:`int`."
msgstr "سازنده جایگزینی که فقط نمونه‌هایی از :class:`float` یا :class:`int` را می‌پذیرد."

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 "توجه داشته باشید که ``Decimal.from_float(0.1)`` با ``Decimal('0.1')`` یکسان نیست. از آنجا که ۰٫۱ در نقطه‌شناور دودویی دقیقاً قابل بازنمایی نیست، مقدار به نزدیک‌ترین مقدار قابل بازنمایی ذخیره می‌شود که ``0x1.999999999999ap-4`` است. مقدار معادل آن در مبنای ده ``0.1000000000000000055511151231257827021181583404541015625`` است."

msgid "From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed directly from a :class:`float`."
msgstr "از پایتون 3.2 به بعد، همچنین می‌توان یک نمونه :class:`Decimal` را مستقیماً از یک :class:`float` ساخت."

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 "Alternative constructor that only accepts instances of :class:`float`, :class:`int` or :class:`Decimal`, but not strings or tuples."
msgstr "سازنده جایگزینی که فقط نمونه‌های :class:`float`، :class:`int` یا :class:`Decimal` را می‌پذیرد، اما رشته‌ها یا تاپل‌ها را نمی‌پذیرد."

msgid ""
">>> Decimal.from_number(314)\n"
"Decimal('314')\n"
">>> Decimal.from_number(0.1)\n"
"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"
">>> Decimal.from_number(Decimal('3.14'))\n"
"Decimal('3.14')"
msgstr ""
">>> Decimal.from_number(314)\n"
"Decimal('314')\n"
">>> Decimal.from_number(0.1)\n"
"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"
">>> Decimal.from_number(Decimal('3.14'))\n"
"Decimal('3.14')"

msgid "Fused multiply-add.  Return self*other+third with no rounding of the intermediate product self*other."
msgstr "ضرب-جمع ادغام‌شده (Fused multiply-add). حاصل self*other+third را بدون گرد کردن حاصل‌ضرب میانی self*other برمی‌گرداند."

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 "اگر آرگومان کانونیکال باشد، :const:`True` و در غیر این صورت :const:`False` را برمی‌گرداند. در حال حاضر، یک نمونه از :class:`Decimal` همیشه کانونیکال است، بنابراین این عملیات همیشه :const:`True` را برمی‌گرداند."

msgid "Return :const:`True` if the argument is a finite number, and :const:`False` if the argument is an infinity or a NaN."
msgstr "اگر آرگومان یک عدد متناهی باشد، :const:`True` را برمی‌گرداند، و اگر آرگومان یک بی‌نهایت یا NaN باشد، :const:`False` را برمی‌گرداند."

msgid "Return :const:`True` if the argument is either positive or negative infinity and :const:`False` otherwise."
msgstr "اگر آرگومان بی‌نهایت مثبت یا منفی باشد، :const:`True` و در غیر این صورت :const:`False` برمی‌گرداند."

msgid "Return :const:`True` if the argument is a (quiet or signaling) NaN and :const:`False` otherwise."
msgstr "اگر آرگومان یک NaN (بی‌صدا یا سیگنال‌دهنده) باشد، :const:`True` و در غیر این صورت :const:`False` را برمی‌گرداند."

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 "اگر آرگومان یک عدد متناهی *نرمال* باشد، :const:`True` را برمی‌گرداند. اگر آرگومان صفر، زیرنرمال (subnormal)، بی‌نهایت یا یک NaN باشد، :const:`False` را برمی‌گرداند."

msgid "Return :const:`True` if the argument is a quiet NaN, and :const:`False` otherwise."
msgstr "اگر آرگومان یک NaN ساکت (quiet NaN) باشد، :const:`True` و در غیر این صورت :const:`False` را برمی‌گرداند."

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 "اگر آرگومان علامت منفی داشته باشد، :const:`True` و در غیر این صورت :const:`False` بازمی‌گرداند. توجه داشته باشید که صفرها و NaNها هر دو می‌توانند علامت داشته باشند."

msgid "Return :const:`True` if the argument is a signaling NaN and :const:`False` otherwise."
msgstr "اگر آرگومان یک NaN سیگنال‌دهنده باشد، :const:`True` و در غیر این صورت :const:`False` را برمی‌گرداند."

msgid "Return :const:`True` if the argument is subnormal, and :const:`False` otherwise."
msgstr "اگر آرگومان زیرنرمال باشد، :const:`True` و در غیر این صورت :const:`False` را برمی‌گرداند."

msgid "Return :const:`True` if the argument is a (positive or negative) zero and :const:`False` otherwise."
msgstr "اگر آرگومان صفر (مثبت یا منفی) باشد، :const:`True` را برمی‌گرداند و در غیر این صورت :const:`False` را برمی‌گرداند."

msgid "Return the natural (base e) logarithm of the operand.  The result is correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr "لگاریتم طبیعی (مبنای e) عملوند را برمی‌گرداند. نتیجه با استفاده از حالت گردکردن :const:`ROUND_HALF_EVEN` به‌درستی گرد می‌شود."

msgid "Return the base ten logarithm of the operand.  The result is correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr "لگاریتم عملوند در مبنای ۱۰ را برمی‌گرداند. نتیجه با استفاده از حالت گرد کردن :const:`ROUND_HALF_EVEN` به‌درستی گرد می‌شود."

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 "برای یک عدد غیرصفر، توان تعدیل‌شده‌ی عملوندش را به‌عنوان یک نمونه‌ی :class:`Decimal` برمی‌گرداند. اگر عملوند صفر باشد، ``Decimal('-Infinity')`` برگردانده می‌شود و پرچم :const:`DivisionByZero` پرتاب می‌شود. اگر عملوند بی‌نهایت باشد، ``Decimal('Infinity')`` برگردانده می‌شود."

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 ":meth:`logical_and` یک عمل منطقی است که دو *عملوند منطقی* می‌گیرد (به :ref:`logical_operands_label` مراجعه کنید). نتیجه، ``and`` رقم‌به‌رقم دو عملوند است."

msgid ":meth:`logical_invert` is a logical operation.  The result is the digit-wise inversion of the operand."
msgstr ":meth:`logical_invert` یک عملیات منطقی است. نتیجه، وارونگی رقم‌به‌رقم عملوند است."

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 ":meth:`logical_or` یک عملیات منطقی است که دو *عملوند منطقی* می‌گیرد (ببینید :ref:`logical_operands_label`). نتیجه، ``or`` رقم‌به‌رقم دو عملوند است."

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 ":meth:`logical_xor` یک عملیات منطقی است که دو *عملوند منطقی* را می‌گیرد (ببینید :ref:`logical_operands_label`). نتیجه، یا انحصاری رقم‌به‌رقم دو عملوند است."

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 "مانند ``max(self, other)`` است، با این تفاوت که پیش از برگرداندن، قاعده‌ی گرد کردن زمینه اعمال می‌شود و مقادیر ``NaN`` یا سیگنال‌دهی می‌شوند یا نادیده گرفته می‌شوند (بسته به زمینه و این‌که سیگنال‌دهنده باشند یا آرام )."

msgid "Similar to the :meth:`.max` method, but the comparison is done using the absolute values of the operands."
msgstr "مشابه متد :meth:`.max`، اما مقایسه با استفاده از مقادیر مطلق عملوندها انجام می‌شود."

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 "مانند ``min(self, other)`` است، به جز اینکه قاعده‌ی گرد کردن زمینه پیش از بازگرداندن اعمال می‌شود و مقادیر ``NaN`` یا سیگنال داده می‌شوند یا نادیده گرفته می‌شوند (بسته به زمینه و اینکه آن‌ها سیگنال‌دهنده باشند یا ساکت)."

msgid "Similar to the :meth:`.min` method, but the comparison is done using the absolute values of the operands."
msgstr "مشابه متد :meth:`.min`، اما مقایسه با استفاده از مقادیر مطلق عملوندها انجام می‌شود."

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 "برای مثال، ``Decimal('32.100')`` و ``Decimal('0.321000e+2')`` هر دو به مقدار معادل ``Decimal('32.1')`` نرمال می‌شوند."

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 "در آخرین نسخه‌های مشخصات، این عملیات همچنین با نام ``reduce`` نیز شناخته می‌شود."

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 "``\"-Infinity\"``، که نشان می‌دهد عملوند بی‌نهایت منفی است."

msgid "``\"-Normal\"``, indicating that the operand is a negative normal number."
msgstr "``\"-Normal\"``، نشان می‌دهد که عملوند یک عدد نرمال منفی است."

msgid "``\"-Subnormal\"``, indicating that the operand is negative and subnormal."
msgstr "``\"-Subnormal\"``، که نشان می‌دهد عملوند منفی و زیرنرمال است."

msgid "``\"-Zero\"``, indicating that the operand is a negative zero."
msgstr "``\"-Zero\"``، که نشان می‌دهد عملوند یک صفر منفی است."

msgid "``\"+Zero\"``, indicating that the operand is a positive zero."
msgstr "``\"+Zero\"``، نشان می‌دهد که عملوند یک صفر مثبت است."

msgid "``\"+Subnormal\"``, indicating that the operand is positive and subnormal."
msgstr "``\"+Subnormal\"``، نشان می‌دهد که عملوند مثبت و زیرنرمال است."

msgid "``\"+Normal\"``, indicating that the operand is a positive normal number."
msgstr "``\"+Normal\"``، که نشان می‌دهد عملوند یک عدد نرمال مثبت است."

msgid "``\"+Infinity\"``, indicating that the operand is positive infinity."
msgstr "``\"+Infinity\"``، که نشان‌دهنده‌ی بی‌نهایت مثبت بودن عملوند است."

msgid "``\"NaN\"``, indicating that the operand is a quiet NaN (Not a Number)."
msgstr "``\"NaN\"``، که نشان می‌دهد عملوند یک NaN ساکت (Not a Number) است."

msgid "``\"sNaN\"``, indicating that the operand is a signaling NaN."
msgstr "``\"sNaN\"``، که نشان می‌دهد عملوند یک NaN سیگنال‌دهنده است."

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 "برخلاف سایر عملیات، اگر طول ضریب پس از عملیات کوانتایز (quantize) بیشتر از دقت باشد، یک :const:`InvalidOperation` علامت‌دهی می‌شود. این تضمین می‌کند که، مگر اینکه شرایط خطایی وجود داشته باشد، توان کوانتایزشده همواره برابر با توان عملوند سمت راست است."

msgid "Also unlike other operations, quantize never signals Underflow, even if the result is subnormal and inexact."
msgstr "همچنین برخلاف سایر عملیات‌ها، quantize هرگز سیگنال Underflow را صادر نمی‌کند، حتی اگر نتیجه زیرنرمال و غیردقیق باشد."

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 "اگر توان عملوند دوم بزرگ‌تر از توان عملوند اول باشد، ممکن است گرد کردن لازم باشد. در این حالت، حالت گرد کردن توسط آرگومان ``rounding`` در صورتی که داده شده باشد تعیین می‌شود، در غیر این صورت توسط آرگومان ``context`` داده‌شده تعیین می‌شود؛ اگر هیچ‌کدام از آرگومان‌ها داده نشوند، از حالت گرد کردن زمینه‌ی نخ جاری استفاده می‌شود."

msgid "An error is returned whenever the resulting exponent is greater than :attr:`~Context.Emax` or less than :meth:`~Context.Etiny`."
msgstr "هر زمان که توان حاصل بزرگ‌تر از :attr:`~Context.Emax` یا کوچک‌تر از :meth:`~Context.Etiny` باشد، یک خطا بازگردانده می‌شود."

msgid "Return ``Decimal(10)``, the radix (base) in which the :class:`Decimal` class does all its arithmetic.  Included for compatibility with the specification."
msgstr "``Decimal(10)`` را برمی‌گرداند، یعنی مبنایی (پایه‌ای) که کلاس :class:`Decimal` تمام محاسبات خود را در آن انجام می‌دهد. برای سازگاری با مشخصات گنجانده شده است."

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 "باقی‌مانده‌ی تقسیم *self* بر *other* را برمی‌گرداند. این با ``self % other`` در این تفاوت دارد که علامت باقی‌مانده به‌گونه‌ای انتخاب می‌شود که مقدار مطلق آن کمینه شود. دقیق‌تر، مقدار بازگشتی ``self - n * other`` است که در آن ``n`` نزدیک‌ترین عدد صحیح به مقدار دقیق ``self / other`` است، و اگر دو عدد صحیح به یک اندازه نزدیک باشند، عدد زوج انتخاب می‌شود."

msgid "If the result is zero then its sign will be the sign of *self*."
msgstr "اگر نتیجه صفر باشد، علامت آن همان علامت *self* خواهد بود."

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 "بررسی می‌کند که آیا self و other توان یکسانی دارند یا اینکه هر دو ``NaN`` هستند."

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 "عملوند اول را با توان تنظیم‌شده توسط عملوند دوم بازمی‌گرداند. معادل آن، عملوند اول ضرب‌شده در ``10**other`` را بازمی‌گرداند. عملوند دوم باید یک عدد صحیح باشد."

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 "برای مثال، این ``Decimal('123E+1')`` را به ``Decimal('1.23E+3')`` تبدیل می‌کند."

msgid "Identical to the :meth:`to_integral_value` method.  The ``to_integral`` name has been kept for compatibility with older versions."
msgstr "یکسان با متد :meth:`to_integral_value`. نام ``to_integral`` برای سازگاری با نسخه‌های قدیمی‌تر حفظ شده است."

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 "به نزدیک‌ترین عدد صحیح گرد می‌شود، و در صورت وقوع گرد کردن، بنا به مورد :const:`Inexact` یا :const:`Rounded` سیگنال داده می‌شود. حالت گرد کردن در صورت داده شدن پارامتر ``rounding`` با آن، و در غیر این صورت با ``context`` داده‌شده تعیین می‌شود. اگر هیچ‌کدام از پارامترها داده نشود، حالت گرد کردن زمینه‌ی جاری استفاده می‌شود."

msgid "Round to the nearest integer without signaling :const:`Inexact` or :const:`Rounded`.  If given, applies *rounding*; otherwise, uses the rounding method in either the supplied *context* or the current context."
msgstr "به نزدیک‌ترین عدد صحیح گرد می‌کند، بدون این‌که :const:`Inexact` یا :const:`Rounded` سیگنال داده شود. در صورت داده شدن، *rounding* را اعمال می‌کند؛ در غیر این صورت، از روش گرد کردن در *context* ارائه‌شده یا زمینه‌ی جاری استفاده می‌کند."

msgid "Decimal numbers can be rounded using the :func:`.round` function:"
msgstr "می‌توان اعداد اعشاری را با استفاده از تابع :func:`.round` گرد کرد:"

msgid "If *ndigits* is not given or ``None``, returns the nearest :class:`int` to *number*, rounding ties to even, and ignoring the rounding mode of the :class:`Decimal` context.  Raises :exc:`OverflowError` if *number* is an infinity or :exc:`ValueError` if it is a (quiet or signaling) NaN."
msgstr "اگر *ndigits* داده نشود یا ``None`` باشد، نزدیک‌ترین :class:`int` به *number* بازگردانده می‌شود، به‌گونه‌ای که موارد تساوی در گرد کردن به عدد زوج گرد می‌شوند و حالت گرد کردن زمینه‌ی :class:`Decimal` نادیده گرفته می‌شود. اگر *number* یک بی‌نهایت باشد، :exc:`OverflowError` پرتاب می‌شود و اگر یک NaN (ساکت یا سیگنال‌دهی) باشد، :exc:`ValueError` پرتاب می‌شود."

msgid "If *ndigits* is an :class:`int`, the context's rounding mode is respected and a :class:`Decimal` representing *number* rounded to the nearest multiple of ``Decimal('1E-ndigits')`` is returned; in this case, ``round(number, ndigits)`` is equivalent to ``self.quantize(Decimal('1E-ndigits'))``.  Returns ``Decimal('NaN')`` if *number* is a quiet NaN.  Raises :class:`InvalidOperation` if *number* is an infinity, a signaling NaN, or if the length of the coefficient after the quantize operation would be greater than the current context's precision.  In other words, for the non-corner cases:"
msgstr "اگر *ndigits* یک :class:`int` باشد، حالت گرد کردن زمینه رعایت می‌شود و یک :class:`Decimal` برگردانده می‌شود که نشان‌دهنده‌ی *number* گردشده به نزدیک‌ترین مضرب ``Decimal('1E-ndigits')`` است؛ در این حالت، ``round(number, ndigits)`` معادل ``self.quantize(Decimal('1E-ndigits'))`` است.  اگر *number* یک NaN ساکت (quiet NaN) باشد، ``Decimal('NaN')`` را برمی‌گرداند.  اگر *number* یک بی‌نهایت یا یک NaN سیگنال‌دهنده باشد، یا اگر طول ضریب پس از عملیات quantize بیشتر از دقت زمینه‌ی فعلی باشد، :class:`InvalidOperation` را پرتاب می‌کند.  به عبارت دیگر، برای حالت‌های غیرمرزی:"

msgid "if *ndigits* is positive, return *number* rounded to *ndigits* decimal places;"
msgstr "اگر *ndigits* مثبت باشد، *number* را که تا *ndigits* رقم اعشاری گرد شده است برمی‌گرداند؛"

msgid "if *ndigits* is zero, return *number* rounded to the nearest integer;"
msgstr "اگر *ndigits* صفر باشد، *number* را که به نزدیک‌ترین عدد صحیح گرد شده است برمی‌گرداند؛"

msgid "if *ndigits* is negative, return *number* rounded to the nearest multiple of ``10**abs(ndigits)``."
msgstr "اگر *ndigits* منفی باشد، *number* را که به نزدیک‌ترین مضرب ``10**abs(ndigits)`` گرد شده است، برمی‌گرداند."

msgid "For example::"
msgstr "برای مثال::"

msgid ""
">>> from decimal import Decimal, getcontext, ROUND_DOWN\n"
">>> getcontext().rounding = ROUND_DOWN\n"
">>> round(Decimal('3.75'))     # context rounding ignored\n"
"4\n"
">>> round(Decimal('3.5'))      # round-ties-to-even\n"
"4\n"
">>> round(Decimal('3.75'), 0)  # uses the context rounding\n"
"Decimal('3')\n"
">>> round(Decimal('3.75'), 1)\n"
"Decimal('3.7')\n"
">>> round(Decimal('3.75'), -1)\n"
"Decimal('0E+1')"
msgstr ""
">>> from decimal import Decimal, getcontext, ROUND_DOWN\n"
">>> getcontext().rounding = ROUND_DOWN\n"
">>> round(Decimal('3.75'))     # context rounding ignored\n"
"4\n"
">>> round(Decimal('3.5'))      # round-ties-to-even\n"
"4\n"
">>> round(Decimal('3.75'), 0)  # uses the context rounding\n"
"Decimal('3')\n"
">>> round(Decimal('3.75'), 1)\n"
"Decimal('3.7')\n"
">>> round(Decimal('3.75'), -1)\n"
"Decimal('0E+1')"

msgid "Logical operands"
msgstr "عملوندهای منطقی"

msgid "The :meth:`~Decimal.logical_and`, :meth:`~Decimal.logical_invert`, :meth:`~Decimal.logical_or`, and :meth:`~Decimal.logical_xor` methods expect their arguments to be *logical operands*.  A *logical operand* is a :class:`Decimal` instance whose exponent and sign are both zero, and whose digits are all either ``0`` or ``1``."
msgstr "متدهای :meth:`~Decimal.logical_and`، :meth:`~Decimal.logical_invert`، :meth:`~Decimal.logical_or` و :meth:`~Decimal.logical_xor` انتظار دارند که آرگومان‌های آن‌ها *عملوندهای منطقی* باشند. یک *عملوند منطقی* نمونه‌ای از :class:`Decimal` است که توان و علامت آن هر دو صفر هستند و تمام ارقام آن یا ``0`` هستند یا ``1``."

msgid "Context objects"
msgstr "اشیاء زمینه"

msgid "Contexts are environments for arithmetic operations.  They govern precision, set rules for rounding, determine which signals are treated as exceptions, and limit the range for exponents."
msgstr "زمینه‌ها محیط‌هایی برای عملیات حسابی هستند. آن‌ها دقت را کنترل می‌کنند، قواعد گرد کردن را تنظیم می‌کنند، تعیین می‌کنند که کدام سیگنال‌ها به‌عنوان استثنا در نظر گرفته شوند، و بازه‌ی توان‌ها را محدود می‌کنند."

msgid "Each thread has its own current context which is accessed or changed using the :func:`getcontext` and :func:`setcontext` functions:"
msgstr "هر نخ زمینه‌ی جاری خود را دارد که با استفاده از توابع :func:`getcontext` و :func:`setcontext` قابل دسترسی یا تغییر است:"

msgid "Return the current context for the active thread."
msgstr "زمینه فعلی برای نخ فعال را برمی‌گرداند."

msgid "Set the current context for the active thread to *c*."
msgstr "زمینه فعلی نخ فعال را روی *c* تنظیم کنید."

msgid "You can also use the :keyword:`with` statement and the :func:`localcontext` function to temporarily change the active context."
msgstr "شما همچنین می‌توانید از دستور :keyword:`with` و تابع :func:`localcontext` برای تغییر موقت زمینه‌ی فعال استفاده کنید."

msgid "Return a context manager that will set the current context for the active thread to a copy of *ctx* on entry to the with-statement and restore the previous context when exiting the with-statement. If no context is specified, a copy of the current context is used.  The *kwargs* argument is used to set the attributes of the new context."
msgstr "یک مدیر زمینه برمی‌گرداند که هنگام ورود به دستور with، زمینه فعلی نخ فعال را به یک کپی از *ctx* تنظیم می‌کند و هنگام خروج از دستور with، زمینه قبلی را بازگردانی می‌کند. اگر هیچ زمینه‌ای مشخص نشده باشد، از یک کپی از زمینه فعلی استفاده می‌شود. آرگومان *kwargs* برای تنظیم ویژگی‌های زمینه جدید استفاده می‌شود."

msgid "For example, the following code sets the current decimal precision to 42 places, performs a calculation, and then automatically restores the previous context::"
msgstr "برای مثال، کد زیر دقت اعشاری کنونی را روی ۴۲ رقم اعشار تنظیم می‌کند، یک محاسبه انجام می‌دهد و سپس به‌طور خودکار زمینه پیشین را بازمی‌گرداند::"

msgid ""
"from decimal import localcontext\n"
"\n"
"with localcontext() as ctx:\n"
"    ctx.prec = 42   # Perform a high precision calculation\n"
"    s = calculate_something()\n"
"s = +s  # Round the final result back to the default precision"
msgstr ""
"from decimal import localcontext\n"
"\n"
"with localcontext() as ctx:\n"
"    ctx.prec = 42   # Perform a high precision calculation\n"
"    s = calculate_something()\n"
"s = +s  # Round the final result back to the default precision"

msgid "Using keyword arguments, the code would be the following::"
msgstr "با استفاده از آرگومان‌های کلیدواژه‌ای، کد به‌شکل زیر خواهد بود::"

msgid ""
"from decimal import localcontext\n"
"\n"
"with localcontext(prec=42) as ctx:\n"
"    s = calculate_something()\n"
"s = +s"
msgstr ""
"from decimal import localcontext\n"
"\n"
"with localcontext(prec=42) as ctx:\n"
"    s = calculate_something()\n"
"s = +s"

msgid "Raises :exc:`TypeError` if *kwargs* supplies an attribute that :class:`Context` doesn't support.  Raises either :exc:`TypeError` or :exc:`ValueError` if *kwargs* supplies an invalid value for an attribute."
msgstr "اگر *kwargs* ویژگی‌ای را ارائه دهد که :class:`Context` از آن پشتیبانی نمی‌کند، :exc:`TypeError` پرتاب می‌شود. اگر *kwargs* مقدار نامعتبری برای یک ویژگی ارائه دهد، یا :exc:`TypeError` یا :exc:`ValueError` پرتاب می‌شود."

msgid ":meth:`localcontext` now supports setting context attributes through the use of keyword arguments."
msgstr ":meth:`localcontext` اکنون از تنظیم ویژگی‌های زمینه از طریق آرگومان‌های کلیدواژه‌ای پشتیبانی می‌کند."

msgid "Return a context object initialized to the proper values for one of the IEEE interchange formats.  The argument must be a multiple of 32 and less than :const:`IEEE_CONTEXT_MAX_BITS`."
msgstr "یک شیء زمینه را برمی‌گرداند که با مقادیر مناسب برای یکی از قالب‌های مبادله‌ای IEEE مقداردهی اولیه‌شده است. آرگومان باید مضربی از ۳۲ و کمتر از :const:`IEEE_CONTEXT_MAX_BITS` باشد."

msgid "New contexts can also be created using the :class:`Context` constructor described below. In addition, the module provides three pre-made contexts:"
msgstr "همچنین می‌توان زمینه‌های جدید را با استفاده از سازنده‌ی :class:`Context` که در زیر توضیح داده شده است، ایجاد کرد. علاوه بر این، این ماژول سه زمینه‌ی از پیش ساخته‌شده ارائه می‌دهد:"

msgid "This is a standard context defined by the General Decimal Arithmetic Specification.  Precision is set to nine.  Rounding is set to :const:`ROUND_HALF_UP`.  All flags are cleared.  All traps are enabled (treated as exceptions) except :const:`Inexact`, :const:`Rounded`, and :const:`Subnormal`."
msgstr "این یک زمینه استاندارد است که توسط مشخصات عمومی محاسبات اعشاری (General Decimal Arithmetic Specification) تعریف شده است. دقت روی ۹ تنظیم شده است. گرد کردن روی :const:`ROUND_HALF_UP` تنظیم شده است. همه پرچم‌ها پاک شده‌اند. همه تله‌ها فعال شده‌اند (به‌عنوان استثنا در نظر گرفته می‌شوند)، به جز :const:`Inexact`، :const:`Rounded` و :const:`Subnormal`."

msgid "Because many of the traps are enabled, this context is useful for debugging."
msgstr "چون بسیاری از تله‌ها فعال هستند، این زمینه برای اشکال‌زدایی مفید است."

msgid "This is a standard context defined by the General Decimal Arithmetic Specification.  Precision is set to nine.  Rounding is set to :const:`ROUND_HALF_EVEN`.  All flags are cleared.  No traps are enabled (so that exceptions are not raised during computations)."
msgstr "این یک زمینه استاندارد است که توسط مشخصات عمومی محاسبات اعشاری (General Decimal Arithmetic Specification) تعریف شده است. دقت روی ۹ تنظیم شده است. گرد کردن روی :const:`ROUND_HALF_EVEN` تنظیم شده است. همه پرچم‌ها پاک شده‌اند. هیچ تله‌ای فعال نیست (تا استثناها در حین محاسبات پرتاب نشوند)."

msgid "Because the traps are disabled, this context is useful for applications that prefer to have result value of ``NaN`` or ``Infinity`` instead of raising exceptions.  This allows an application to complete a run in the presence of conditions that would otherwise halt the program."
msgstr "از آنجا که تله‌ها غیرفعال هستند، این زمینه برای برنامه‌هایی مفید است که ترجیح می‌دهند به‌جای پرتاب استثنا، مقدار نتیجه ``NaN`` یا ``Infinity`` باشد. این امر به برنامه اجازه می‌دهد که اجرا را در شرایطی که در غیر این صورت موجب توقف برنامه می‌شدند، به پایان برساند."

msgid "This context is used by the :class:`Context` constructor as a prototype for new contexts.  Changing a field (such a precision) has the effect of changing the default for new contexts created by the :class:`Context` constructor."
msgstr "این زمینه توسط سازنده‌ی :class:`Context` به‌عنوان یک نمونه‌ی اولیه برای زمینه‌های جدید استفاده می‌شود. تغییر یک فیلد (مانند دقت) باعث تغییر پیش‌فرض برای زمینه‌های جدید ایجادشده توسط سازنده‌ی :class:`Context` می‌شود."

msgid "This context is most useful in multi-threaded environments.  Changing one of the fields before threads are started has the effect of setting system-wide defaults.  Changing the fields after threads have started is not recommended as it would require thread synchronization to prevent race conditions."
msgstr "این زمینه بیشترین کاربرد را در محیط‌های چندنخی دارد. تغییر یکی از فیلدها پیش از آغاز نخ‌ها، به‌منزله‌ی تنظیم پیش‌فرض‌های سراسری سیستم است. تغییر فیلدها پس از آغاز نخ‌ها توصیه نمی‌شود، زیرا نیازمند همگام‌سازی نخ‌ها برای جلوگیری از شرایط رقابتی خواهد بود."

msgid "In single threaded environments, it is preferable to not use this context at all.  Instead, simply create contexts explicitly as described below."
msgstr "در محیط‌های تک‌نخی، بهتر است اصلاً از این زمینه استفاده نکنید. در عوض، به‌سادگی زمینه‌ها را به‌صراحت همان‌طور که در زیر توضیح داده شده است ایجاد کنید."

msgid "The default values are :attr:`Context.prec`\\ =\\ ``28``, :attr:`Context.rounding`\\ =\\ :const:`ROUND_HALF_EVEN`, and enabled traps for :class:`Overflow`, :class:`InvalidOperation`, and :class:`DivisionByZero`."
msgstr "مقادیر پیش‌فرض عبارت‌اند از :attr:`Context.prec`\\ =\\ ``28``، :attr:`Context.rounding`\\ =\\ :const:`ROUND_HALF_EVEN`، و تله‌های فعال برای :class:`Overflow`، :class:`InvalidOperation` و :class:`DivisionByZero`."

msgid "In addition to the three supplied contexts, new contexts can be created with the :class:`Context` constructor."
msgstr "علاوه بر سه زمینه‌ی فراهم‌شده، می‌توان زمینه‌های جدید را با سازنده‌ی :class:`Context` ایجاد کرد."

msgid "Creates a new context.  If a field is not specified or is :const:`None`, the default values are copied from the :const:`DefaultContext`.  If the *flags* field is not specified or is :const:`None`, all flags are cleared."
msgstr "یک زمینه جدید ایجاد می‌کند. اگر فیلدی مشخص‌نشده باشد یا :const:`None` باشد، مقادیر پیش‌فرض از :const:`DefaultContext` کپی می‌شوند. اگر فیلد *flags* مشخص‌نشده باشد یا :const:`None` باشد، تمام پرچم‌ها پاک می‌شوند."

msgid "An integer in the range [``1``, :const:`MAX_PREC`] that sets the precision for arithmetic operations in the context."
msgstr "یک عدد صحیح در بازه‌ی [``1``, :const:`MAX_PREC`] که دقت عملیات حسابی را در زمینه تنظیم می‌کند."

msgid "One of the constants listed in the section `Rounding Modes`_."
msgstr "یکی از ثابت‌های فهرست‌شده در بخش `Rounding Modes`_."

msgid "Lists of any signals to be set. Generally, new contexts should only set traps and leave the flags clear."
msgstr "فهرست‌هایی از هر سیگنالی که باید تنظیم شود. به‌طور کلی، زمینه‌های جدید فقط باید تله‌ها را تنظیم کنند و پرچم‌ها را پاک باقی بگذارند."

msgid "Integers specifying the outer limits allowable for exponents. *Emin* must be in the range [:const:`MIN_EMIN`, ``0``], *Emax* in the range [``0``, :const:`MAX_EMAX`]."
msgstr "اعداد صحیحی که کران‌های بیرونی مجاز برای توان‌ها را مشخص می‌کنند. *Emin* باید در بازه‌ی [:const:`MIN_EMIN`، ``0``] باشد، *Emax* در بازه‌ی [``0``، :const:`MAX_EMAX`]."

msgid "Either ``0`` or ``1`` (the default). If set to ``1``, exponents are printed with a capital ``E``; otherwise, a lowercase ``e`` is used: ``Decimal('6.02e+23')``."
msgstr "یا ``0`` یا ``1`` (پیش‌فرض). اگر روی ``1`` تنظیم شود، توان‌ها با ``E`` بزرگ چاپ می‌شوند؛ در غیر این صورت، از ``e`` کوچک استفاده می‌شود: ``Decimal('6.02e+23')``."

msgid "Either ``0`` (the default) or ``1``.  If set to ``1``, the exponent ``e`` of a :class:`Decimal` instance representable in this context is strictly limited to the range ``Emin - prec + 1 <= e <= Emax - prec + 1``. If *clamp* is ``0`` then a weaker condition holds: the adjusted exponent of the :class:`Decimal` instance is at most :attr:`~Context.Emax`.  When *clamp* is ``1``, a large normal number will, where possible, have its exponent reduced and a corresponding number of zeros added to its coefficient, in order to fit the exponent constraints; this preserves the value of the number but loses information about significant trailing zeros.  For example::"
msgstr "یا ``0`` (پیش‌فرض) یا ``1``. اگر روی ``1`` تنظیم شود، توان ``e`` نمونه‌ی :class:`Decimal` قابل‌نمایش در این زمینه، به‌طور دقیق به محدوده ``Emin - prec + 1 <= e <= Emax - prec + 1`` محدود می‌شود. اگر *clamp* برابر ``0`` باشد، شرط ضعیف‌تری برقرار است: توان تنظیم‌شده‌ی نمونه‌ی :class:`Decimal` حداکثر :attr:`~Context.Emax` است. هنگامی که *clamp* برابر ``1`` باشد، توان یک عدد عادی بزرگ، در صورت امکان، کاهش می‌یابد و تعداد متناظری صفر به ضریب آن اضافه می‌شود تا محدودیت‌های توان رعایت شود؛ این کار مقدار عدد را حفظ می‌کند، اما اطلاعات مربوط به صفرهای انتهایی معنادار را از دست می‌دهد. برای مثال::"

msgid ""
">>> Context(prec=6, Emax=999, clamp=1).create_decimal('1.23e999')\n"
"Decimal('1.23000E+999')"
msgstr ""
">>> Context(prec=6, Emax=999, clamp=1).create_decimal('1.23e999')\n"
"Decimal('1.23000E+999')"

msgid "A *clamp* value of ``1`` allows compatibility with the fixed-width decimal interchange formats specified in IEEE 754."
msgstr "مقدار *clamp* (محدودسازی) برابر با ``1`` امکان سازگاری با قالب‌های مبادله‌ای اعشاری با عرض ثابت مشخص‌شده در IEEE 754 را فراهم می‌کند."

msgid "The :class:`Context` class defines several general purpose methods as well as a large number of methods for doing arithmetic directly in a given context. In addition, for each of the :class:`Decimal` methods described above (with the exception of the :meth:`~Decimal.adjusted` and :meth:`~Decimal.as_tuple` methods) there is a corresponding :class:`Context` method.  For example, for a :class:`Context` instance ``C`` and :class:`Decimal` instance ``x``, ``C.exp(x)`` is equivalent to ``x.exp(context=C)``.  Each :class:`Context` method accepts a Python integer (an instance of :class:`int`) anywhere that a Decimal instance is accepted."
msgstr "کلاس :class:`Context` چندین متد با کاربرد عمومی و همچنین تعداد زیادی متد برای انجام عملیات حسابی به‌صورت مستقیم در یک زمینه‌ی داده‌شده تعریف می‌کند. علاوه بر این، به ازای هر یک از متدهای :class:`Decimal` که در بالا توضیح داده شده‌اند (به‌استثنای متدهای :meth:`~Decimal.adjusted` و :meth:`~Decimal.as_tuple`)، یک متد متناظر در :class:`Context` وجود دارد. برای مثال، برای یک نمونه‌ی :class:`Context` به نام ``C`` و یک نمونه‌ی :class:`Decimal` به نام ``x``، عبارت ``C.exp(x)`` معادل ``x.exp(context=C)`` است. هر متد :class:`Context` در هر جا که یک نمونه‌ی Decimal پذیرفته شود، یک عدد صحیح پایتون (نمونه‌ای از :class:`int`) را می‌پذیرد."

msgid "Resets all of the flags to ``0``."
msgstr "همه‌ی پرچم‌ها را به ``0`` بازنشانی می‌کند."

msgid "Resets all of the traps to ``0``."
msgstr "همه‌ی تله‌ها را به ``0`` بازنشانی می‌کند."

msgid "Return a duplicate of the context."
msgstr "یک کپی از زمینه را برمی‌گرداند."

msgid "Return a copy of the Decimal instance num."
msgstr "یک رونوشت از نمونه‌ی Decimal به نام num برمی‌گرداند."

msgid "Creates a new Decimal instance from *num* but using *self* as context. Unlike the :class:`Decimal` constructor, the context precision, rounding method, flags, and traps are applied to the conversion."
msgstr "یک نمونه جدید از Decimal را از *num* ایجاد می‌کند، اما از *self* به‌عنوان زمینه استفاده می‌کند. برخلاف سازنده‌ی :class:`Decimal`، دقت زمینه، روش گرد کردن، پرچم‌ها و تله‌ها در تبدیل اعمال می‌شوند."

msgid "This is useful because constants are often given to a greater precision than is needed by the application.  Another benefit is that rounding immediately eliminates unintended effects from digits beyond the current precision. In the following example, using unrounded inputs means that adding zero to a sum can change the result:"
msgstr "این مفید است، زیرا ثابت‌ها اغلب با دقتی بیشتر از حد نیاز برنامه ارائه می‌شوند. مزیت دیگر این است که گرد کردن بلافاصله اثرات ناخواسته‌ی ارقام فراتر از دقت فعلی را حذف می‌کند. در مثال زیر، استفاده از ورودی‌های گردنشده به این معناست که افزودن صفر به یک مجموع می‌تواند نتیجه را تغییر دهد:"

msgid ""
">>> getcontext().prec = 3\n"
">>> Decimal('3.4445') + Decimal('1.0023')\n"
"Decimal('4.45')\n"
">>> Decimal('3.4445') + Decimal(0) + Decimal('1.0023')\n"
"Decimal('4.44')"
msgstr ""
">>> getcontext().prec = 3\n"
">>> Decimal('3.4445') + Decimal('1.0023')\n"
"Decimal('4.45')\n"
">>> Decimal('3.4445') + Decimal(0) + Decimal('1.0023')\n"
"Decimal('4.44')"

msgid "This method implements the to-number operation of the IBM specification. If the argument is a string, no leading or trailing whitespace or underscores are permitted."
msgstr "این متد عملیات تبدیل به عددِ مشخصات IBM را پیاده‌سازی می‌کند. اگر آرگومان یک رشته باشد، هیچ‌گونه فضای سفید یا زیرخطی در ابتدا یا انتها مجاز نیست."

msgid "Creates a new Decimal instance from a float *f* but rounding using *self* as the context.  Unlike the :meth:`Decimal.from_float` class method, the context precision, rounding method, flags, and traps are applied to the conversion."
msgstr "یک نمونه جدید Decimal از float *f* ایجاد می‌کند، اما گرد کردن با استفاده از *self* به‌عنوان زمینه انجام می‌شود. برخلاف متد کلاس :meth:`Decimal.from_float`، دقت زمینه، روش گرد کردن، پرچم‌ها و تله‌ها بر تبدیل اعمال می‌شوند."

msgid ""
">>> context = Context(prec=5, rounding=ROUND_DOWN)\n"
">>> context.create_decimal_from_float(math.pi)\n"
"Decimal('3.1415')\n"
">>> context = Context(prec=5, traps=[Inexact])\n"
">>> context.create_decimal_from_float(math.pi)\n"
"Traceback (most recent call last):\n"
"    ...\n"
"decimal.Inexact: None"
msgstr ""
">>> context = Context(prec=5, rounding=ROUND_DOWN)\n"
">>> context.create_decimal_from_float(math.pi)\n"
"Decimal('3.1415')\n"
">>> context = Context(prec=5, traps=[Inexact])\n"
">>> context.create_decimal_from_float(math.pi)\n"
"Traceback (most recent call last):\n"
"    ...\n"
"decimal.Inexact: None"

msgid "Returns a value equal to ``Emin - prec + 1`` which is the minimum exponent value for subnormal results.  When underflow occurs, the exponent is set to :const:`Etiny`."
msgstr "مقداری برابر با ``Emin - prec + 1`` برمی‌گرداند که کمترین مقدار توان برای نتایج زیرنرمال است. هنگامی که زیرریز (underflow) رخ می‌دهد، توان روی :const:`Etiny` تنظیم می‌شود."

msgid "Returns a value equal to ``Emax - prec + 1``."
msgstr "مقداری برابر با ``Emax - prec + 1`` برمی‌گرداند."

msgid "The usual approach to working with decimals is to create :class:`Decimal` instances and then apply arithmetic operations which take place within the current context for the active thread.  An alternative approach is to use context methods for calculating within a specific context.  The methods are similar to those for the :class:`Decimal` class and are only briefly recounted here."
msgstr "رویکرد معمول برای کار با اعداد اعشاری، ایجاد نمونه‌های :class:`Decimal` و سپس اعمال عملیات حسابی است که در زمینه‌ی جاری برای نخ فعال انجام می‌شوند. رویکرد جایگزین، استفاده از متدهای زمینه برای محاسبه در یک زمینه‌ی مشخص است. این متدها مشابه متدهای کلاس :class:`Decimal` هستند و در اینجا تنها به‌اختصار بازگو شده‌اند."

msgid "Returns the absolute value of *x*."
msgstr "مقدار مطلق *x* را برمی‌گرداند."

msgid "Return the sum of *x* and *y*."
msgstr "مجموع *x* و *y* را برمی‌گرداند."

msgid "Returns the same Decimal object *x*."
msgstr "همان شیء Decimal یعنی *x* را بازمی‌گرداند."

msgid "Compares *x* and *y* numerically."
msgstr "*x* و *y* را به‌صورت عددی مقایسه می‌کند."

msgid "Compares the values of the two operands numerically."
msgstr "مقادیر دو عملوند را به‌صورت عددی مقایسه می‌کند."

msgid "Compares two operands using their abstract representation."
msgstr "دو عملوند را با استفاده از نمایش انتزاعی آن‌ها مقایسه می‌کند."

msgid "Compares two operands using their abstract representation, ignoring sign."
msgstr "دو عملوند را با استفاده از بازنمایی انتزاعی آن‌ها، با چشم‌پوشی از علامت، مقایسه می‌کند."

msgid "Returns a copy of *x* with the sign set to 0."
msgstr "نسخه‌ای از *x* برمی‌گرداند که علامت آن روی ۰ تنظیم شده است."

msgid "Returns a copy of *x* with the sign inverted."
msgstr "یک کپی از *x* با علامت معکوس‌شده برمی‌گرداند."

msgid "Copies the sign from *y* to *x*."
msgstr "علامت را از *y* به *x* کپی می‌کند."

msgid "Return *x* divided by *y*."
msgstr "*x* تقسیم‌شده بر *y* را برمی‌گرداند."

msgid "Return *x* divided by *y*, truncated to an integer."
msgstr "حاصل تقسیم *x* بر *y* را به‌صورت یک عدد صحیح بریده‌شده برمی‌گرداند."

msgid "Divides two numbers and returns the integer part of the result."
msgstr "دو عدد را تقسیم می‌کند و بخش صحیح نتیجه را برمی‌گرداند."

msgid "Returns ``e ** x``."
msgstr "``e ** x`` را برمی‌گرداند."

msgid "Returns *x* multiplied by *y*, plus *z*."
msgstr "حاصل‌ضرب *x* در *y* به‌علاوه *z* را برمی‌گرداند."

msgid "Returns ``True`` if *x* is canonical; otherwise returns ``False``."
msgstr "اگر *x* کانونیکال باشد، ``True`` را برمی‌گرداند؛ در غیر این صورت ``False`` را برمی‌گرداند."

msgid "Returns ``True`` if *x* is finite; otherwise returns ``False``."
msgstr "اگر *x* متناهی باشد، ``True`` را برمی‌گرداند؛ در غیر این صورت ``False`` را برمی‌گرداند."

msgid "Returns ``True`` if *x* is infinite; otherwise returns ``False``."
msgstr "اگر *x* بی‌نهایت باشد، ``True`` را برمی‌گرداند؛ در غیر این صورت ``False`` را برمی‌گرداند."

msgid "Returns ``True`` if *x* is a qNaN or sNaN; otherwise returns ``False``."
msgstr "اگر *x* یک qNaN یا sNaN باشد، ``True`` برمی‌گرداند؛ در غیر این صورت ``False`` برمی‌گرداند."

msgid "Returns ``True`` if *x* is a normal number; otherwise returns ``False``."
msgstr "اگر *x* یک عدد عادی باشد، ``True`` را برمی‌گرداند؛ در غیر این صورت ``False`` را برمی‌گرداند."

msgid "Returns ``True`` if *x* is a quiet NaN; otherwise returns ``False``."
msgstr "اگر *x* یک NaN ساکت (quiet NaN) باشد، ``True`` را برمی‌گرداند؛ در غیر این صورت ``False`` را برمی‌گرداند."

msgid "Returns ``True`` if *x* is negative; otherwise returns ``False``."
msgstr "اگر *x* منفی باشد، ``True`` را برمی‌گرداند؛ در غیر این صورت ``False`` را برمی‌گرداند."

msgid "Returns ``True`` if *x* is a signaling NaN; otherwise returns ``False``."
msgstr "اگر *x* یک NaN سیگنال‌دهنده باشد، ``True`` را برمی‌گرداند؛ در غیر این صورت ``False`` را برمی‌گرداند."

msgid "Returns ``True`` if *x* is subnormal; otherwise returns ``False``."
msgstr "اگر *x* زیرنرمال باشد، ``True`` را برمی‌گرداند؛ در غیر این صورت ``False`` را برمی‌گرداند."

msgid "Returns ``True`` if *x* is a zero; otherwise returns ``False``."
msgstr "اگر *x* صفر باشد، ``True`` را برمی‌گرداند؛ در غیر این صورت ``False`` را برمی‌گرداند."

msgid "Returns the natural (base e) logarithm of *x*."
msgstr "لگاریتم طبیعی *x* (مبنای e) را برمی‌گرداند."

msgid "Returns the base 10 logarithm of *x*."
msgstr "لگاریتم *x* در مبنای ۱۰ را برمی‌گرداند."

msgid "Returns the exponent of the magnitude of the operand's MSD."
msgstr "توان مرتبه‌ی بزرگی پرارزش‌ترین رقم (MSD) عملوند را برمی‌گرداند."

msgid "Applies the logical operation *and* between each operand's digits."
msgstr "عملیات منطقی *and* را بین رقم‌های هر عملوند اعمال می‌کند."

msgid "Invert all the digits in *x*."
msgstr "تمام ارقام *x* را معکوس کنید."

msgid "Applies the logical operation *or* between each operand's digits."
msgstr "عملیات منطقی *or* را بین ارقام هر عملوند اعمال می‌کند."

msgid "Applies the logical operation *xor* between each operand's digits."
msgstr "عملیات منطقی *xor* را بین رقم‌های هر عملوند اعمال می‌کند."

msgid "Compares two values numerically and returns the maximum."
msgstr "دو مقدار را به‌صورت عددی مقایسه می‌کند و بیشینه را برمی‌گرداند."

msgid "Compares the values numerically with their sign ignored."
msgstr "مقادیر را به‌صورت عددی با نادیده گرفتن علامت آن‌ها مقایسه می‌کند."

msgid "Compares two values numerically and returns the minimum."
msgstr "دو مقدار را به‌صورت عددی مقایسه می‌کند و کمینه را برمی‌گرداند."

msgid "Minus corresponds to the unary prefix minus operator in Python."
msgstr "منها با عملگر پیشوندی یک‌عملوندی منها در پایتون متناظر است."

msgid "Return the product of *x* and *y*."
msgstr "حاصل‌ضرب *x* و *y* را برمی‌گرداند."

msgid "Returns the largest representable number smaller than *x*."
msgstr "بزرگ‌ترین عدد قابل نمایش کوچک‌تر از *x* را بازمی‌گرداند."

msgid "Returns the smallest representable number larger than *x*."
msgstr "کوچک‌ترین عدد قابل‌نمایش بزرگ‌تر از *x* را برمی‌گرداند."

msgid "Returns the number closest to *x*, in direction towards *y*."
msgstr "نزدیک‌ترین عدد به *x* را در جهت به سمت *y* برمی‌گرداند."

msgid "Reduces *x* to its simplest form."
msgstr "*x* را به ساده‌ترین شکل خود تقلیل می‌دهد."

msgid "Returns an indication of the class of *x*."
msgstr "نشانگر کلاس *x* را برمی‌گرداند."

msgid "Plus corresponds to the unary prefix plus operator in Python.  This operation applies the context precision and rounding, so it is *not* an identity operation."
msgstr "Plus معادل عملگر یک‌عملوندی پیش‌وندی پلاس در پایتون است. این عملیات دقت و گرد کردن زمینه را اعمال می‌کند، بنابراین یک عملیات همانی *نیست*."

msgid "Return ``x`` to the power of ``y``, reduced modulo ``modulo`` if given."
msgstr "``x`` به توان ``y`` را برمی‌گرداند و در صورت داده شدن، به پیمانه‌ی ``modulo`` کاهش می‌یابد."

msgid "With two arguments, compute ``x**y``.  If ``x`` is negative then ``y`` must be integral.  The result will be inexact unless ``y`` is integral and the result is finite and can be expressed exactly in 'precision' digits. The rounding mode of the context is used. Results are always correctly rounded in the Python version."
msgstr "با دو آرگومان، ``x**y`` محاسبه می‌شود. اگر ``x`` منفی باشد، ``y`` باید عدد صحیح باشد. نتیجه نادقیق خواهد بود، مگر اینکه ``y`` عدد صحیح باشد و نتیجه متناهی باشد و بتوان آن را دقیقاً با 'precision' رقم بیان کرد. از حالت گرد کردن زمینه استفاده می‌شود. نتایج در نسخه‌ی پایتون همیشه به‌درستی گرد می‌شوند."

msgid "``Decimal(0) ** Decimal(0)`` results in ``InvalidOperation``, and if ``InvalidOperation`` is not trapped, then results in ``Decimal('NaN')``."
msgstr "``Decimal(0) ** Decimal(0)`` منجر به ``InvalidOperation`` می‌شود، و اگر ``InvalidOperation`` به دام نیفتد، نتیجه ``Decimal('NaN')`` خواهد بود."

msgid "The C module computes :meth:`power` in terms of the correctly rounded :meth:`exp` and :meth:`ln` functions. The result is well-defined but only \"almost always correctly rounded\"."
msgstr "ماژول C، :meth:`power` را بر حسب توابع :meth:`exp` و :meth:`ln` که به‌درستی گرد شده‌اند محاسبه می‌کند. نتیجه خوش‌تعریف است، اما فقط «تقریباً همیشه به‌درستی گرد شده» است."

msgid "With three arguments, compute ``(x**y) % modulo``.  For the three argument form, the following restrictions on the arguments hold:"
msgstr "با سه آرگومان، ``(x**y) % modulo`` را محاسبه می‌کند. برای قالب با سه آرگومان، محدودیت‌های زیر روی آرگومان‌ها برقرار است:"

msgid "all three arguments must be integral"
msgstr "هر سه آرگومان باید عدد صحیح باشند"

msgid "``y`` must be nonnegative"
msgstr "``y`` باید غیرمنفی باشد"

msgid "at least one of ``x`` or ``y`` must be nonzero"
msgstr "حداقل یکی از ``x`` یا ``y`` باید غیرصفر باشد"

msgid "``modulo`` must be nonzero and have at most 'precision' digits"
msgstr "``modulo`` باید غیرصفر باشد و حداکثر 'precision' رقم داشته باشد"

msgid "The value resulting from ``Context.power(x, y, modulo)`` is equal to the value that would be obtained by computing ``(x**y) % modulo`` with unbounded precision, but is computed more efficiently.  The exponent of the result is zero, regardless of the exponents of ``x``, ``y`` and ``modulo``.  The result is always exact."
msgstr "مقدار حاصل از ``Context.power(x, y, modulo)`` برابر با مقداری است که از محاسبه‌ی ``(x**y) % modulo`` با دقت نامحدود به دست می‌آید، اما به‌صورت کارآمدتری محاسبه می‌شود. توان نتیجه صفر است، صرف‌نظر از توان‌های ``x``، ``y`` و ``modulo``. نتیجه همیشه دقیق است."

msgid "Returns a value equal to *x* (rounded), having the exponent of *y*."
msgstr "مقداری برابر با *x* (گردشده) برمی‌گرداند که دارای توان *y* است."

msgid "Just returns 10, as this is Decimal, :)"
msgstr "فقط ۱۰ را برمی‌گرداند، زیرا این Decimal است، :)"

msgid "Returns the remainder from integer division."
msgstr "باقی‌مانده‌ی تقسیم عدد صحیح را برمی‌گرداند."

msgid "The sign of the result, if non-zero, is the same as that of the original dividend."
msgstr "علامت نتیجه، اگر غیرصفر باشد، همان علامت مقسوم اصلی است."

msgid "Returns ``x - y * n``, where *n* is the integer nearest the exact value of ``x / y`` (if the result is 0 then its sign will be the sign of *x*)."
msgstr "``x - y * n`` را برمی‌گرداند، که در آن *n* نزدیک‌ترین عدد صحیح به مقدار دقیق ``x / y`` است (اگر نتیجه ۰ باشد، علامت آن علامت *x* خواهد بود)."

msgid "Returns a rotated copy of *x*, *y* times."
msgstr "نسخه‌ای چرخش‌یافته از *x* را به تعداد *y* بار برمی‌گرداند."

msgid "Returns ``True`` if the two operands have the same exponent."
msgstr "اگر دو عملوند توان یکسانی داشته باشند، ``True`` برمی‌گرداند."

msgid "Returns the first operand after adding the second value its exp."
msgstr "اولین عملوند را پس از افزودن مقدار دوم به توان آن برمی‌گرداند."

msgid "Returns a shifted copy of *x*, *y* times."
msgstr "رونوشتی از *x* برمی‌گرداند که *y* بار جابه‌جاشده است."

msgid "Square root of a non-negative number to context precision."
msgstr "ریشه دوم یک عدد غیرمنفی تا دقت زمینه."

msgid "Return the difference between *x* and *y*."
msgstr "اختلاف بین *x* و *y* را برمی‌گرداند."

msgid "Rounds to an integer."
msgstr "به یک عدد صحیح گرد می‌شود."

msgid "Converts a number to a string using scientific notation."
msgstr "یک عدد را با استفاده از نماد علمی به رشته تبدیل می‌کند."

msgid "Constants"
msgstr "ثابت‌ها"

msgid "The constants in this section are only relevant for the C module. They are also included in the pure Python version for compatibility."
msgstr "ثابت‌های این بخش تنها برای ماژول C مرتبط هستند. این ثابت‌ها برای سازگاری در نسخه پایتون خالص نیز گنجانده شده‌اند."

msgid "32-bit"
msgstr "۳۲ بیتی"

msgid "64-bit"
msgstr "۶۴ بیتی"

msgid "``425000000``"
msgstr "``425000000``"

msgid "``999999999999999999``"
msgstr "``999999999999999999``"

msgid "``-425000000``"
msgstr "``-425000000``"

msgid "``-999999999999999999``"
msgstr "``-999999999999999999``"

msgid "``-849999999``"
msgstr "``-849999999``"

msgid "``-1999999999999999997``"
msgstr "``-1999999999999999997``"

msgid "``256``"
msgstr "``256``"

msgid "``512``"
msgstr "``512``"

msgid "The value is ``True``.  Deprecated, because Python now always has threads."
msgstr "مقدار ``True`` است. منسوخ شده است، زیرا پایتون اکنون همیشه نخ دارد."

msgid "The default value is ``True``. If Python is :option:`configured using the --without-decimal-contextvar option <--without-decimal-contextvar>`, the C version uses a thread-local rather than a coroutine-local context and the value is ``False``.  This is slightly faster in some nested context scenarios."
msgstr "مقدار پیش‌فرض ``True`` است. اگر پایتون :option:`با گزینه‌ی --without-decimal-contextvar پیکربندی شده باشد <--without-decimal-contextvar>`، نسخه‌ی C به‌جای زمینه‌ی محلی به هم‌روال از زمینه‌ی محلی به نخ استفاده می‌کند و مقدار ``False`` خواهد بود. این حالت در برخی سناریوهای زمینه‌ی تودرتو کمی سریع‌تر است."

msgid "Rounding modes"
msgstr "حالت‌های گرد کردن"

msgid "Round towards ``Infinity``."
msgstr "گرد کردن به سمت ``Infinity``."

msgid "Round towards zero."
msgstr "گرد کردن به سمت صفر."

msgid "Round towards ``-Infinity``."
msgstr "گرد کردن به سمت ``-Infinity``."

msgid "Round to nearest with ties going towards zero."
msgstr "گرد کردن به نزدیک‌ترین مقدار، در موارد مساوی به سمت صفر."

msgid "Round to nearest with ties going to nearest even integer."
msgstr "گرد کردن به نزدیک‌ترین مقدار، به‌طوری که موارد تساوی به نزدیک‌ترین عدد صحیح زوج گرد شوند."

msgid "Round to nearest with ties going away from zero."
msgstr "گرد کردن به نزدیک‌ترین مقدار، به‌طوری که در موارد تساوی، دور از صفر گرد می‌شود."

msgid "Round away from zero."
msgstr "گرد کردن به دور از صفر."

msgid "Round away from zero if last digit after rounding towards zero would have been 0 or 5; otherwise round towards zero."
msgstr "اگر آخرین رقم پس از گرد کردن به سمت صفر، ۰ یا ۵ باشد، به دور از صفر گرد می‌شود؛ در غیر این صورت به سمت صفر گرد می‌شود."

msgid "Signals"
msgstr "سیگنال‌ها"

msgid "Signals represent conditions that arise during computation. Each corresponds to one context flag and one context trap enabler."
msgstr "سیگنال‌ها نشان‌دهنده‌ی شرایطی هستند که در حین محاسبه رخ می‌دهند. هر یک با یک پرچم زمینه و یک فعال‌ساز تله‌ی زمینه متناظر است."

msgid "The context flag is set whenever the condition is encountered. After the computation, flags may be checked for informational purposes (for instance, to determine whether a computation was exact). After checking the flags, be sure to clear all flags before starting the next computation."
msgstr "پرچم زمینه هرگاه که شرط رخ دهد تنظیم می‌شود. پس از محاسبه، پرچم‌ها را می‌توان برای اهداف اطلاع‌رسانی بررسی کرد (برای نمونه، برای تعیین اینکه آیا یک محاسبه دقیق بوده است). پس از بررسی پرچم‌ها، حتماً همه‌ی پرچم‌ها را پیش از آغاز محاسبه‌ی بعدی پاک کنید."

msgid "If the context's trap enabler is set for the signal, then the condition causes a Python exception to be raised.  For example, if the :class:`DivisionByZero` trap is set, then a :exc:`DivisionByZero` exception is raised upon encountering the condition."
msgstr "اگر فعال‌ساز تله‌ی زمینه برای سیگنال تنظیم شده باشد، آنگاه شرط باعث پرتاب یک استثنای پایتون می‌شود. برای مثال، اگر تله‌ی :class:`DivisionByZero` تنظیم شده باشد، هنگام مواجهه با شرط، یک استثنای :exc:`DivisionByZero` پرتاب می‌شود."

msgid "Altered an exponent to fit representation constraints."
msgstr "توانی برای تطابق با محدودیت‌های بازنمایی تغییر داده شد."

msgid "Typically, clamping occurs when an exponent falls outside the context's :attr:`~Context.Emin` and :attr:`~Context.Emax` limits.  If possible, the exponent is reduced to fit by adding zeros to the coefficient."
msgstr "معمولاً، محدودسازی (clamping) زمانی رخ می‌دهد که یک توان خارج از محدوده‌های :attr:`~Context.Emin` و :attr:`~Context.Emax` زمینه قرار گیرد. در صورت امکان، توان با افزودن صفر به ضریب کاهش می‌یابد تا در محدوده قرار گیرد."

msgid "Base class for other signals and a subclass of :exc:`ArithmeticError`."
msgstr "کلاس پایه برای سایر سیگنال‌ها و زیرکلاسی از :exc:`ArithmeticError`."

msgid "Signals the division of a non-infinite number by zero."
msgstr "نشان‌دهنده تقسیم یک عدد غیربی‌نهایت بر صفر است."

msgid "Can occur with division, modulo division, or when raising a number to a negative power.  If this signal is not trapped, returns ``Infinity`` or ``-Infinity`` with the sign determined by the inputs to the calculation."
msgstr "ممکن است در تقسیم، تقسیم پیمانه‌ای، یا هنگام رساندن یک عدد به توان منفی رخ دهد. اگر این سیگنال به دام نیفتد، ``Infinity`` یا ``-Infinity`` را با علامتی که توسط ورودی‌های محاسبه تعیین می‌شود برمی‌گرداند."

msgid "Indicates that rounding occurred and the result is not exact."
msgstr "نشان می‌دهد که گرد کردن رخ داده است و نتیجه دقیق نیست."

msgid "Signals when non-zero digits were discarded during rounding. The rounded result is returned.  The signal flag or trap is used to detect when results are inexact."
msgstr "سیگنال زمانی رخ می‌دهد که رقم‌های غیرصفر در حین گرد کردن دور ریخته شوند. نتیجه‌ی گرد شده بازگردانده می‌شود. پرچم سیگنال یا تله برای تشخیص زمانی که نتایج نادقیق هستند استفاده می‌شود."

msgid "An invalid operation was performed."
msgstr "یک عملیات نامعتبر انجام شد."

msgid "Indicates that an operation was requested that does not make sense. If not trapped, returns ``NaN``.  Possible causes include::"
msgstr "نشان می‌دهد که عملیاتی درخواست شده است که معنادار نیست. اگر تله‌گذاری (trap) نشده باشد، ``NaN`` را برمی‌گرداند. علل احتمالی عبارت‌اند از::"

msgid ""
"Infinity - Infinity\n"
"0 * Infinity\n"
"Infinity / Infinity\n"
"x % 0\n"
"Infinity % x\n"
"sqrt(-x) and x > 0\n"
"0 ** 0\n"
"x ** (non-integer)\n"
"x ** Infinity"
msgstr ""
"Infinity - Infinity\n"
"0 * Infinity\n"
"Infinity / Infinity\n"
"x % 0\n"
"Infinity % x\n"
"sqrt(-x) and x > 0\n"
"0 ** 0\n"
"x ** (non-integer)\n"
"x ** Infinity"

msgid "Numerical overflow."
msgstr "سرریز عددی."

msgid "Indicates the exponent is larger than :attr:`Context.Emax` after rounding has occurred.  If not trapped, the result depends on the rounding mode, either pulling inward to the largest representable finite number or rounding outward to ``Infinity``.  In either case, :class:`Inexact` and :class:`Rounded` are also signaled."
msgstr "نشان می‌دهد که توان پس از انجام گرد کردن، بزرگ‌تر از :attr:`Context.Emax` است. اگر تله‌گذاری نشده باشد، نتیجه به حالت گرد کردن بستگی دارد؛ یا به سمت داخل به بزرگ‌ترین عدد متناهی قابل نمایش کشیده می‌شود یا به سمت خارج به ``Infinity`` گرد می‌شود. در هر صورت، :class:`Inexact` و :class:`Rounded` نیز علامت داده می‌شوند."

msgid "Rounding occurred though possibly no information was lost."
msgstr "گرد کردن رخ داد، هرچند ممکن است اطلاعاتی از دست نرفته باشد."

msgid "Signaled whenever rounding discards digits; even if those digits are zero (such as rounding ``5.00`` to ``5.0``).  If not trapped, returns the result unchanged.  This signal is used to detect loss of significant digits."
msgstr "این سیگنال هرگاه گرد کردن باعث حذف ارقامی شود، داده می‌شود؛ حتی اگر آن ارقام صفر باشند (مانند گرد کردن ``5.00`` به ``5.0``).  اگر به دام نیفتد، نتیجه بدون تغییر برگردانده می‌شود.  این سیگنال برای تشخیص از دست رفتن ارقام معنادار استفاده می‌شود."

msgid "Exponent was lower than :attr:`~Context.Emin` prior to rounding."
msgstr "توان پیش از گرد کردن کمتر از :attr:`~Context.Emin` بود."

msgid "Occurs when an operation result is subnormal (the exponent is too small). If not trapped, returns the result unchanged."
msgstr "هنگامی رخ می‌دهد که نتیجه‌ی یک عملیات زیرنرمال باشد (توان بیش از حد کوچک باشد). اگر تله برای آن فعال نباشد، نتیجه بدون تغییر بازگردانده می‌شود."

msgid "Numerical underflow with result rounded to zero."
msgstr "زیرریز عددی با نتیجه‌ای که به صفر گرد شده است."

msgid "Occurs when a subnormal result is pushed to zero by rounding. :class:`Inexact` and :class:`Subnormal` are also signaled."
msgstr "هنگامی رخ می‌دهد که یک نتیجه زیرنرمال بر اثر گرد کردن به صفر رانده شود. :class:`Inexact` و :class:`Subnormal` نیز سیگنال داده می‌شوند."

msgid "Enable stricter semantics for mixing floats and Decimals."
msgstr "فعال‌سازی معناشناسی سخت‌گیرانه‌تر برای ترکیب اعداد اعشاری و Decimalها."

msgid "If the signal is not trapped (default), mixing floats and Decimals is permitted in the :class:`~decimal.Decimal` constructor, :meth:`~decimal.Context.create_decimal` and all comparison operators. Both conversion and comparisons are exact. Any occurrence of a mixed operation is silently recorded by setting :exc:`FloatOperation` in the context flags. Explicit conversions with :meth:`~decimal.Decimal.from_float` or :meth:`~decimal.Context.create_decimal_from_float` do not set the flag."
msgstr "اگر سیگنال به دام نیفتد (پیش‌فرض)، ترکیب شناورها و Decimalها در سازنده‌ی :class:`~decimal.Decimal`، :meth:`~decimal.Context.create_decimal` و تمام عملگرهای مقایسه‌ای مجاز است. هم تبدیل‌ها و هم مقایسه‌ها دقیق هستند. هر بار وقوع یک عملیات مختلط، به‌صورت خاموش با تنظیم :exc:`FloatOperation` در پرچم‌های زمینه ثبت می‌شود. تبدیل‌های صریح با :meth:`~decimal.Decimal.from_float` یا :meth:`~decimal.Context.create_decimal_from_float` این پرچم را تنظیم نمی‌کنند."

msgid "Otherwise (the signal is trapped), only equality comparisons and explicit conversions are silent. All other mixed operations raise :exc:`FloatOperation`."
msgstr "در غیر این صورت (سیگنال به دام افتاده است)، فقط مقایسه‌های برابری و تبدیل‌های صریح بی‌صدا هستند. تمام عملیات مختلط دیگر :exc:`FloatOperation` را پرتاب می‌کنند."

msgid "The following table summarizes the hierarchy of signals::"
msgstr "جدول زیر سلسله‌مراتب سیگنال‌ها را خلاصه می‌کند::"

msgid ""
"exceptions.ArithmeticError(exceptions.Exception)\n"
"    DecimalException\n"
"        Clamped\n"
"        DivisionByZero(DecimalException, exceptions.ZeroDivisionError)\n"
"        Inexact\n"
"            Overflow(Inexact, Rounded)\n"
"            Underflow(Inexact, Rounded, Subnormal)\n"
"        InvalidOperation\n"
"        Rounded\n"
"        Subnormal\n"
"        FloatOperation(DecimalException, exceptions.TypeError)"
msgstr ""
"exceptions.ArithmeticError(exceptions.Exception)\n"
"    DecimalException\n"
"        Clamped\n"
"        DivisionByZero(DecimalException, exceptions.ZeroDivisionError)\n"
"        Inexact\n"
"            Overflow(Inexact, Rounded)\n"
"            Underflow(Inexact, Rounded, Subnormal)\n"
"        InvalidOperation\n"
"        Rounded\n"
"        Subnormal\n"
"        FloatOperation(DecimalException, exceptions.TypeError)"

msgid "Floating-point notes"
msgstr "نکات مربوط به اعداد اعشاری"

msgid "Mitigating round-off error with increased precision"
msgstr "کاهش خطای گرد کردن با افزایش دقت"

msgid "The use of decimal floating point eliminates decimal representation error (making it possible to represent ``0.1`` exactly); however, some operations can still incur round-off error when non-zero digits exceed the fixed precision."
msgstr "استفاده از ممیز شناور اعشاری، خطای بازنمایی اعشاری را برطرف می‌کند (و امکان بازنمایی دقیق ``0.1`` را ممکن می‌سازد)؛ با این حال، برخی عملیات هنوز ممکن است دچار خطای گرد کردن شوند، هنگامی که ارقام غیرصفر از دقت ثابت بیشتر شوند."

msgid "The effects of round-off error can be amplified by the addition or subtraction of nearly offsetting quantities resulting in loss of significance.  Knuth provides two instructive examples where rounded floating-point arithmetic with insufficient precision causes the breakdown of the associative and distributive properties of addition:"
msgstr "اثرات خطای گرد کردن می‌تواند با جمع یا تفریق کمیت‌هایی که تقریباً یکدیگر را خنثی می‌کنند، تشدید شود و به از دست رفتن ارقام معنادار بینجامد. کنوت دو مثال آموزنده ارائه می‌دهد که در آن‌ها حساب ممیز شناور گردشده با دقت ناکافی باعث از کار افتادن ویژگی‌های شرکت‌پذیری و توزیع‌پذیری جمع می‌شود:"

msgid ""
"# Examples from Seminumerical Algorithms, Section 4.2.2.\n"
">>> from decimal import Decimal, getcontext\n"
">>> getcontext().prec = 8\n"
"\n"
">>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')\n"
">>> (u + v) + w\n"
"Decimal('9.5111111')\n"
">>> u + (v + w)\n"
"Decimal('10')\n"
"\n"
">>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')\n"
">>> (u*v) + (u*w)\n"
"Decimal('0.01')\n"
">>> u * (v+w)\n"
"Decimal('0.0060000')"
msgstr ""
"# Examples from Seminumerical Algorithms, Section 4.2.2.\n"
">>> from decimal import Decimal, getcontext\n"
">>> getcontext().prec = 8\n"
"\n"
">>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')\n"
">>> (u + v) + w\n"
"Decimal('9.5111111')\n"
">>> u + (v + w)\n"
"Decimal('10')\n"
"\n"
">>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')\n"
">>> (u*v) + (u*w)\n"
"Decimal('0.01')\n"
">>> u * (v+w)\n"
"Decimal('0.0060000')"

msgid "The :mod:`!decimal` module makes it possible to restore the identities by expanding the precision sufficiently to avoid loss of significance:"
msgstr "ماژول :mod:`!decimal` امکان برقراری مجدد اتحادها را با افزایش دقت به‌اندازه کافی برای جلوگیری از از دست رفتن معناداری فراهم می‌کند:"

msgid ""
">>> getcontext().prec = 20\n"
">>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')\n"
">>> (u + v) + w\n"
"Decimal('9.51111111')\n"
">>> u + (v + w)\n"
"Decimal('9.51111111')\n"
">>>\n"
">>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')\n"
">>> (u*v) + (u*w)\n"
"Decimal('0.0060000')\n"
">>> u * (v+w)\n"
"Decimal('0.0060000')"
msgstr ""
">>> getcontext().prec = 20\n"
">>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')\n"
">>> (u + v) + w\n"
"Decimal('9.51111111')\n"
">>> u + (v + w)\n"
"Decimal('9.51111111')\n"
">>>\n"
">>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')\n"
">>> (u*v) + (u*w)\n"
"Decimal('0.0060000')\n"
">>> u * (v+w)\n"
"Decimal('0.0060000')"

msgid "Special values"
msgstr "مقادیر خاص"

msgid "The number system for the :mod:`!decimal` module provides special values including ``NaN``, ``sNaN``, ``-Infinity``, ``Infinity``, and two zeros, ``+0`` and ``-0``."
msgstr "سیستم اعداد ماژول :mod:`!decimal` مقادیر ویژه‌ای از جمله ``NaN``، ``sNaN``، ``-Infinity``، ``Infinity`` و دو صفر، ``+0`` و ``-0`` را فراهم می‌کند."

msgid "Infinities can be constructed directly with:  ``Decimal('Infinity')``. Also, they can arise from dividing by zero when the :exc:`DivisionByZero` signal is not trapped.  Likewise, when the :exc:`Overflow` signal is not trapped, infinity can result from rounding beyond the limits of the largest representable number."
msgstr "بی‌نهایت‌ها را می‌توان مستقیماً با ``Decimal('Infinity')`` ساخت. همچنین، آن‌ها می‌توانند در اثر تقسیم بر صفر، زمانی که سیگنال :exc:`DivisionByZero` به دام نیفتاده باشد، به وجود آیند. به همین ترتیب، زمانی که سیگنال :exc:`Overflow` به دام نیفتاده باشد، بی‌نهایت می‌تواند در اثر گرد کردن فراتر از محدوده‌ی بزرگ‌ترین عدد قابل نمایش حاصل شود."

msgid "The infinities are signed (affine) and can be used in arithmetic operations where they get treated as very large, indeterminate numbers.  For instance, adding a constant to infinity gives another infinite result."
msgstr "بی‌نهایت‌ها علامت‌دار (affine) هستند و می‌توان از آن‌ها در عملیات حسابی استفاده کرد، که در آن‌ها به‌عنوان اعدادی بسیار بزرگ و نامعین در نظر گرفته می‌شوند. برای مثال، افزودن یک ثابت به بی‌نهایت، نتیجه‌ی بی‌نهایت دیگری می‌دهد."

msgid "Some operations are indeterminate and return ``NaN``, or if the :exc:`InvalidOperation` signal is trapped, raise an exception.  For example, ``0/0`` returns ``NaN`` which means \"not a number\".  This variety of ``NaN`` is quiet and, once created, will flow through other computations always resulting in another ``NaN``.  This behavior can be useful for a series of computations that occasionally have missing inputs --- it allows the calculation to proceed while flagging specific results as invalid."
msgstr "برخی عملیات‌ها نامعین هستند و ``NaN`` را برمی‌گردانند، یا اگر سیگنال :exc:`InvalidOperation` به دام افتاده باشد، استثنایی را پرتاب می‌کنند. برای مثال، ``0/0`` مقدار ``NaN`` را برمی‌گرداند که به معنای «عدد نیست» است. این نوع ``NaN`` ساکت است و پس از ایجاد، در دیگر محاسبات جریان می‌یابد و همیشه به ``NaN`` دیگری منجر می‌شود. این رفتار می‌تواند برای مجموعه‌ای از محاسبات که گاهی ورودی‌های ناموجود دارند مفید باشد — این امر اجازه می‌دهد محاسبه ادامه یابد، در حالی که نتایج خاصی را به‌عنوان نامعتبر علامت‌گذاری می‌کند."

msgid "A variant is ``sNaN`` which signals rather than remaining quiet after every operation.  This is a useful return value when an invalid result needs to interrupt a calculation for special handling."
msgstr "یکی از گونه‌ها ``sNaN`` است که به‌جای ساکت ماندن پس از هر عملیات، سیگنال می‌دهد. این مقدار بازگشتی مفیدی است، هنگامی که نیاز است یک نتیجه نامعتبر محاسبه‌ای را برای مدیریت ویژه متوقف کند."

msgid "The behavior of Python's comparison operators can be a little surprising where a ``NaN`` is involved.  A test for equality where one of the operands is a quiet or signaling ``NaN`` always returns :const:`False` (even when doing ``Decimal('NaN')==Decimal('NaN')``), while a test for inequality always returns :const:`True`.  An attempt to compare two Decimals using any of the ``<``, ``<=``, ``>`` or ``>=`` operators will raise the :exc:`InvalidOperation` signal if either operand is a ``NaN``, and return :const:`False` if this signal is not trapped.  Note that the General Decimal Arithmetic specification does not specify the behavior of direct comparisons; these rules for comparisons involving a ``NaN`` were taken from the IEEE 854 standard (see Table 3 in section 5.7).  To ensure strict standards-compliance, use the :meth:`~Decimal.compare` and :meth:`~Decimal.compare_signal` methods instead."
msgstr "رفتار عملگرهای مقایسه‌ای پایتون می‌تواند در مواردی که یک ``NaN`` در میان باشد، کمی غافلگیرکننده باشد. آزمون برابری در صورتی که یکی از عملوندها یک ``NaN`` ساکت یا سیگنال‌دهنده باشد، همیشه :const:`False` برمی‌گرداند (حتی هنگام انجام ``Decimal('NaN')==Decimal('NaN')``)، در حالی که آزمون نابرابری همیشه :const:`True` برمی‌گرداند. تلاش برای مقایسه‌ی دو Decimal با استفاده از هر یک از عملگرهای ``<``، ``<=``، ``>`` یا ``>=``، در صورتی که یکی از عملوندها ``NaN`` باشد، سیگنال :exc:`InvalidOperation` را پرتاب می‌کند و اگر این سیگنال به دام نیفتد، :const:`False` برمی‌گرداند. توجه داشته باشید که مشخصه‌ی General Decimal Arithmetic رفتار مقایسه‌های مستقیم را تعیین نمی‌کند؛ این قواعد برای مقایسه‌های شامل یک ``NaN`` از استاندارد IEEE 854 گرفته شده‌اند (جدول ۳ در بخش ۵.۷ را ببینید). برای اطمینان از انطباق دقیق با استانداردها، در عوض از متدهای :meth:`~Decimal.compare` و :meth:`~Decimal.compare_signal` استفاده کنید."

msgid "The signed zeros can result from calculations that underflow. They keep the sign that would have resulted if the calculation had been carried out to greater precision.  Since their magnitude is zero, both positive and negative zeros are treated as equal and their sign is informational."
msgstr "صفرهای علامت‌دار می‌توانند از محاسباتی که دچار زیرریز (underflow) می‌شوند حاصل شوند. آن‌ها علامتی را حفظ می‌کنند که اگر محاسبه با دقت بیشتری انجام می‌شد، حاصل می‌شد. از آنجا که بزرگی آن‌ها صفر است، صفرهای مثبت و منفی هر دو برابر در نظر گرفته می‌شوند و علامت آن‌ها صرفاً اطلاع‌رسانی است."

msgid "In addition to the two signed zeros which are distinct yet equal, there are various representations of zero with differing precisions yet equivalent in value.  This takes a bit of getting used to.  For an eye accustomed to normalized floating-point representations, it is not immediately obvious that the following calculation returns a value equal to zero:"
msgstr "علاوه بر دو صفر علامت‌دار که متمایز اما برابر هستند، نمایش‌های گوناگونی از صفر با دقت‌های متفاوت اما هم‌ارز در مقدار وجود دارد. این موضوع کمی نیاز به عادت کردن دارد. برای چشمی که به نمایش‌های نقطه‌شناور نرمال‌شده عادت کرده است، فوراً بدیهی نیست که محاسبه‌ی زیر مقداری برابر با صفر برمی‌گرداند:"

msgid "Working with threads"
msgstr "کار با نخ‌ها"

msgid "The :func:`getcontext` function accesses a different :class:`Context` object for each thread.  Having separate thread contexts means that threads may make changes (such as ``getcontext().prec=10``) without interfering with other threads."
msgstr "تابع :func:`getcontext` برای هر نخ به یک شیء :class:`Context` متفاوت دسترسی دارد. داشتن زمینه‌های جداگانه برای نخ‌ها به این معناست که نخ‌ها می‌توانند تغییراتی (مانند ``getcontext().prec=10``) بدون تداخل با سایر نخ‌ها ایجاد کنند."

msgid "Likewise, the :func:`setcontext` function automatically assigns its target to the current thread."
msgstr "به همین ترتیب، تابع :func:`setcontext` به‌طور خودکار هدف خود را به نخ جاری اختصاص می‌دهد."

msgid "If :func:`setcontext` has not been called before :func:`getcontext`, then :func:`getcontext` will automatically create a new context for use in the current thread.  New context objects have default values set from the :data:`decimal.DefaultContext` object."
msgstr "اگر :func:`setcontext` پیش از :func:`getcontext` فراخوانی نشده باشد، آنگاه :func:`getcontext` به‌طور خودکار یک زمینه جدید برای استفاده در نخ جاری ایجاد می‌کند. اشیای زمینه جدید دارای مقادیر پیش‌فرضی هستند که از شیء :data:`decimal.DefaultContext` تنظیم شده‌اند."

msgid "The :data:`sys.flags.thread_inherit_context` flag affects the context for new threads.  If the flag is false, new threads will start with an empty context.  In this case, :func:`getcontext` will create a new context object when called and use the default values from *DefaultContext*.  If the flag is true, new threads will start with a copy of context from the caller of :meth:`threading.Thread.start`."
msgstr "پرچم :data:`sys.flags.thread_inherit_context` بر زمینه‌ی نخ‌های جدید تأثیر می‌گذارد. اگر پرچم نادرست باشد، نخ‌های جدید با یک زمینه‌ی خالی آغاز می‌شوند. در این حالت، :func:`getcontext` هنگام فراخوانی یک شیء زمینه‌ی جدید ایجاد می‌کند و از مقادیر پیش‌فرض *DefaultContext* استفاده می‌کند. اگر پرچم درست باشد، نخ‌های جدید با رونوشتی از زمینه‌ی فراخواننده‌ی :meth:`threading.Thread.start` آغاز می‌شوند."

msgid "To control the defaults so that each thread will use the same values throughout the application, directly modify the *DefaultContext* object. This should be done *before* any threads are started so that there won't be a race condition between threads calling :func:`getcontext`. For example::"
msgstr "برای کنترل پیش‌فرض‌ها به گونه‌ای که هر نخ در سراسر برنامه از مقادیر یکسانی استفاده کند، مستقیماً شیء *DefaultContext* را تغییر دهید. این کار باید *پیش از* شروع هر نخی انجام شود تا شرایط رقابتی بین نخ‌هایی که :func:`getcontext` را فراخوانی می‌کنند، وجود نداشته باشد. برای مثال::"

msgid ""
"# Set applicationwide defaults for all threads about to be launched\n"
"DefaultContext.prec = 12\n"
"DefaultContext.rounding = ROUND_DOWN\n"
"DefaultContext.traps = ExtendedContext.traps.copy()\n"
"DefaultContext.traps[InvalidOperation] = 1\n"
"setcontext(DefaultContext)\n"
"\n"
"# Afterwards, the threads can be started\n"
"t1.start()\n"
"t2.start()\n"
"t3.start()\n"
" . . ."
msgstr ""
"# Set applicationwide defaults for all threads about to be launched\n"
"DefaultContext.prec = 12\n"
"DefaultContext.rounding = ROUND_DOWN\n"
"DefaultContext.traps = ExtendedContext.traps.copy()\n"
"DefaultContext.traps[InvalidOperation] = 1\n"
"setcontext(DefaultContext)\n"
"\n"
"# Afterwards, the threads can be started\n"
"t1.start()\n"
"t2.start()\n"
"t3.start()\n"
" . . ."

msgid "Recipes"
msgstr "دستورهای عملی"

msgid "Here are a few recipes that serve as utility functions and that demonstrate ways to work with the :class:`Decimal` class::"
msgstr "در ادامه چند راه‌حل آورده شده است که به‌عنوان توابع سودمند به کار می‌روند و روش‌هایی برای کار با کلاس :class:`Decimal` را نشان می‌دهند::"

msgid ""
"def moneyfmt(value, places=2, curr='', sep=',', dp='.',\n"
"             pos='', neg='-', trailneg=''):\n"
"    \"\"\"Convert Decimal to a money formatted string.\n"
"\n"
"    places:  required number of places after the decimal point\n"
"    curr:    optional currency symbol before the sign (may be blank)\n"
"    sep:     optional grouping separator (comma, period, space, or blank)\n"
"    dp:      decimal point indicator (comma or period)\n"
"             only specify as blank when places is zero\n"
"    pos:     optional sign for positive numbers: '+', space or blank\n"
"    neg:     optional sign for negative numbers: '-', '(', space or blank\n"
"    trailneg:optional trailing minus indicator:  '-', ')', space or blank\n"
"\n"
"    >>> d = Decimal('-1234567.8901')\n"
"    >>> moneyfmt(d, curr='$')\n"
"    '-$1,234,567.89'\n"
"    >>> moneyfmt(d, places=0, sep='.', dp='', neg='', trailneg='-')\n"
"    '1.234.568-'\n"
"    >>> moneyfmt(d, curr='$', neg='(', trailneg=')')\n"
"    '($1,234,567.89)'\n"
"    >>> moneyfmt(Decimal(123456789), sep=' ')\n"
"    '123 456 789.00'\n"
"    >>> moneyfmt(Decimal('-0.02'), neg='<', trailneg='>')\n"
"    '<0.02>'\n"
"\n"
"    \"\"\"\n"
"    q = Decimal(10) ** -places      # 2 places --> '0.01'\n"
"    sign, digits, exp = value.quantize(q).as_tuple()\n"
"    result = []\n"
"    digits = list(map(str, digits))\n"
"    build, next = result.append, digits.pop\n"
"    if sign:\n"
"        build(trailneg)\n"
"    for i in range(places):\n"
"        build(next() if digits else '0')\n"
"    if places:\n"
"        build(dp)\n"
"    if not digits:\n"
"        build('0')\n"
"    i = 0\n"
"    while digits:\n"
"        build(next())\n"
"        i += 1\n"
"        if i == 3 and digits:\n"
"            i = 0\n"
"            build(sep)\n"
"    build(curr)\n"
"    build(neg if sign else pos)\n"
"    return ''.join(reversed(result))\n"
"\n"
"def pi():\n"
"    \"\"\"Compute Pi to the current precision.\n"
"\n"
"    >>> print(pi())\n"
"    3.141592653589793238462643383\n"
"\n"
"    \"\"\"\n"
"    getcontext().prec += 2  # extra digits for intermediate steps\n"
"    three = Decimal(3)      # substitute \"three=3.0\" for regular floats\n"
"    lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24\n"
"    while s != lasts:\n"
"        lasts = s\n"
"        n, na = n+na, na+8\n"
"        d, da = d+da, da+32\n"
"        t = (t * n) / d\n"
"        s += t\n"
"    getcontext().prec -= 2\n"
"    return +s               # unary plus applies the new precision\n"
"\n"
"def exp(x):\n"
"    \"\"\"Return e raised to the power of x.  Result type matches input type.\n"
"\n"
"    >>> print(exp(Decimal(1)))\n"
"    2.718281828459045235360287471\n"
"    >>> print(exp(Decimal(2)))\n"
"    7.389056098930650227230427461\n"
"    >>> print(exp(2.0))\n"
"    7.38905609893\n"
"    >>> print(exp(2+0j))\n"
"    (7.38905609893+0j)\n"
"\n"
"    \"\"\"\n"
"    getcontext().prec += 2\n"
"    i, lasts, s, fact, num = 0, 0, 1, 1, 1\n"
"    while s != lasts:\n"
"        lasts = s\n"
"        i += 1\n"
"        fact *= i\n"
"        num *= x\n"
"        s += num / fact\n"
"    getcontext().prec -= 2\n"
"    return +s\n"
"\n"
"def cos(x):\n"
"    \"\"\"Return the cosine of x as measured in radians.\n"
"\n"
"    The Taylor series approximation works best for a small value of x.\n"
"    For larger values, first compute x = x % (2 * pi).\n"
"\n"
"    >>> print(cos(Decimal('0.5')))\n"
"    0.8775825618903727161162815826\n"
"    >>> print(cos(0.5))\n"
"    0.87758256189\n"
"    >>> print(cos(0.5+0j))\n"
"    (0.87758256189+0j)\n"
"\n"
"    \"\"\"\n"
"    getcontext().prec += 2\n"
"    i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1\n"
"    while s != lasts:\n"
"        lasts = s\n"
"        i += 2\n"
"        fact *= i * (i-1)\n"
"        num *= x * x\n"
"        sign *= -1\n"
"        s += num / fact * sign\n"
"    getcontext().prec -= 2\n"
"    return +s\n"
"\n"
"def sin(x):\n"
"    \"\"\"Return the sine of x as measured in radians.\n"
"\n"
"    The Taylor series approximation works best for a small value of x.\n"
"    For larger values, first compute x = x % (2 * pi).\n"
"\n"
"    >>> print(sin(Decimal('0.5')))\n"
"    0.4794255386042030002732879352\n"
"    >>> print(sin(0.5))\n"
"    0.479425538604\n"
"    >>> print(sin(0.5+0j))\n"
"    (0.479425538604+0j)\n"
"\n"
"    \"\"\"\n"
"    getcontext().prec += 2\n"
"    i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1\n"
"    while s != lasts:\n"
"        lasts = s\n"
"        i += 2\n"
"        fact *= i * (i-1)\n"
"        num *= x * x\n"
"        sign *= -1\n"
"        s += num / fact * sign\n"
"    getcontext().prec -= 2\n"
"    return +s"
msgstr ""
"def moneyfmt(value, places=2, curr='', sep=',', dp='.',\n"
"             pos='', neg='-', trailneg=''):\n"
"    \"\"\"Convert Decimal to a money formatted string.\n"
"\n"
"    places:  required number of places after the decimal point\n"
"    curr:    optional currency symbol before the sign (may be blank)\n"
"    sep:     optional grouping separator (comma, period, space, or blank)\n"
"    dp:      decimal point indicator (comma or period)\n"
"             only specify as blank when places is zero\n"
"    pos:     optional sign for positive numbers: '+', space or blank\n"
"    neg:     optional sign for negative numbers: '-', '(', space or blank\n"
"    trailneg:optional trailing minus indicator:  '-', ')', space or blank\n"
"\n"
"    >>> d = Decimal('-1234567.8901')\n"
"    >>> moneyfmt(d, curr='$')\n"
"    '-$1,234,567.89'\n"
"    >>> moneyfmt(d, places=0, sep='.', dp='', neg='', trailneg='-')\n"
"    '1.234.568-'\n"
"    >>> moneyfmt(d, curr='$', neg='(', trailneg=')')\n"
"    '($1,234,567.89)'\n"
"    >>> moneyfmt(Decimal(123456789), sep=' ')\n"
"    '123 456 789.00'\n"
"    >>> moneyfmt(Decimal('-0.02'), neg='<', trailneg='>')\n"
"    '<0.02>'\n"
"\n"
"    \"\"\"\n"
"    q = Decimal(10) ** -places      # 2 places --> '0.01'\n"
"    sign, digits, exp = value.quantize(q).as_tuple()\n"
"    result = []\n"
"    digits = list(map(str, digits))\n"
"    build, next = result.append, digits.pop\n"
"    if sign:\n"
"        build(trailneg)\n"
"    for i in range(places):\n"
"        build(next() if digits else '0')\n"
"    if places:\n"
"        build(dp)\n"
"    if not digits:\n"
"        build('0')\n"
"    i = 0\n"
"    while digits:\n"
"        build(next())\n"
"        i += 1\n"
"        if i == 3 and digits:\n"
"            i = 0\n"
"            build(sep)\n"
"    build(curr)\n"
"    build(neg if sign else pos)\n"
"    return ''.join(reversed(result))\n"
"\n"
"def pi():\n"
"    \"\"\"Compute Pi to the current precision.\n"
"\n"
"    >>> print(pi())\n"
"    3.141592653589793238462643383\n"
"\n"
"    \"\"\"\n"
"    getcontext().prec += 2  # extra digits for intermediate steps\n"
"    three = Decimal(3)      # substitute \"three=3.0\" for regular floats\n"
"    lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24\n"
"    while s != lasts:\n"
"        lasts = s\n"
"        n, na = n+na, na+8\n"
"        d, da = d+da, da+32\n"
"        t = (t * n) / d\n"
"        s += t\n"
"    getcontext().prec -= 2\n"
"    return +s               # unary plus applies the new precision\n"
"\n"
"def exp(x):\n"
"    \"\"\"Return e raised to the power of x.  Result type matches input type.\n"
"\n"
"    >>> print(exp(Decimal(1)))\n"
"    2.718281828459045235360287471\n"
"    >>> print(exp(Decimal(2)))\n"
"    7.389056098930650227230427461\n"
"    >>> print(exp(2.0))\n"
"    7.38905609893\n"
"    >>> print(exp(2+0j))\n"
"    (7.38905609893+0j)\n"
"\n"
"    \"\"\"\n"
"    getcontext().prec += 2\n"
"    i, lasts, s, fact, num = 0, 0, 1, 1, 1\n"
"    while s != lasts:\n"
"        lasts = s\n"
"        i += 1\n"
"        fact *= i\n"
"        num *= x\n"
"        s += num / fact\n"
"    getcontext().prec -= 2\n"
"    return +s\n"
"\n"
"def cos(x):\n"
"    \"\"\"Return the cosine of x as measured in radians.\n"
"\n"
"    The Taylor series approximation works best for a small value of x.\n"
"    For larger values, first compute x = x % (2 * pi).\n"
"\n"
"    >>> print(cos(Decimal('0.5')))\n"
"    0.8775825618903727161162815826\n"
"    >>> print(cos(0.5))\n"
"    0.87758256189\n"
"    >>> print(cos(0.5+0j))\n"
"    (0.87758256189+0j)\n"
"\n"
"    \"\"\"\n"
"    getcontext().prec += 2\n"
"    i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1\n"
"    while s != lasts:\n"
"        lasts = s\n"
"        i += 2\n"
"        fact *= i * (i-1)\n"
"        num *= x * x\n"
"        sign *= -1\n"
"        s += num / fact * sign\n"
"    getcontext().prec -= 2\n"
"    return +s\n"
"\n"
"def sin(x):\n"
"    \"\"\"Return the sine of x as measured in radians.\n"
"\n"
"    The Taylor series approximation works best for a small value of x.\n"
"    For larger values, first compute x = x % (2 * pi).\n"
"\n"
"    >>> print(sin(Decimal('0.5')))\n"
"    0.4794255386042030002732879352\n"
"    >>> print(sin(0.5))\n"
"    0.479425538604\n"
"    >>> print(sin(0.5+0j))\n"
"    (0.479425538604+0j)\n"
"\n"
"    \"\"\"\n"
"    getcontext().prec += 2\n"
"    i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1\n"
"    while s != lasts:\n"
"        lasts = s\n"
"        i += 2\n"
"        fact *= i * (i-1)\n"
"        num *= x * x\n"
"        sign *= -1\n"
"        s += num / fact * sign\n"
"    getcontext().prec -= 2\n"
"    return +s"

msgid "Decimal FAQ"
msgstr "پرسش‌های متداول درباره‌ی Decimal"

msgid "Q: It is cumbersome to type ``decimal.Decimal('1234.5')``.  Is there a way to minimize typing when using the interactive interpreter?"
msgstr "پرسش: وارد کردن ``decimal.Decimal('1234.5')`` دشوار است. آیا راهی برای به حداقل رساندن میزان تایپ هنگام استفاده از مفسر تعاملی وجود دارد؟"

msgid "A: Some users abbreviate the constructor to just a single letter:"
msgstr "پاسخ: برخی کاربران سازنده را فقط به یک حرف خلاصه می‌کنند:"

msgid "Q: In a fixed-point application with two decimal places, some inputs have many places and need to be rounded.  Others are not supposed to have excess digits and need to be validated.  What methods should be used?"
msgstr "پرسش: در یک برنامه ممیز ثابت با دو رقم اعشار، برخی ورودی‌ها رقم‌های اعشار زیادی دارند و باید گرد شوند. برخی دیگر نباید ارقام اضافی داشته باشند و باید اعتبارسنجی شوند. از چه متدهایی باید استفاده کرد؟"

msgid "A: The :meth:`~Decimal.quantize` method rounds to a fixed number of decimal places. If the :const:`Inexact` trap is set, it is also useful for validation:"
msgstr "A: متد :meth:`~Decimal.quantize` به تعداد ثابتی از رقم‌های اعشاری گرد می‌کند. اگر تله‌ی :const:`Inexact` تنظیم شده باشد، برای اعتبارسنجی نیز مفید است:"

msgid "Q: Once I have valid two place inputs, how do I maintain that invariant throughout an application?"
msgstr "پ: هنگامی که ورودی‌های معتبر با دو رقم اعشاری داشته باشم، چگونه می‌توانم آن ناوردا را در سراسر یک برنامه حفظ کنم؟"

msgid "A: Some operations like addition, subtraction, and multiplication by an integer will automatically preserve fixed point.  Others operations, like division and non-integer multiplication, will change the number of decimal places and need to be followed-up with a :meth:`~Decimal.quantize` step:"
msgstr "پاسخ: برخی عملیات مانند جمع، تفریق و ضرب در یک عدد صحیح به‌طور خودکار ممیز ثابت را حفظ می‌کنند. عملیات دیگر، مانند تقسیم و ضرب در عدد غیرصحیح، تعداد ارقام اعشار را تغییر می‌دهند و باید پس از آن‌ها یک مرحله :meth:`~Decimal.quantize` انجام شود:"

msgid "In developing fixed-point applications, it is convenient to define functions to handle the :meth:`~Decimal.quantize` step:"
msgstr "در توسعه‌ی برنامه‌های ممیز ثابت، تعریف توابع برای مدیریت مرحله‌ی :meth:`~Decimal.quantize` مطلوب است:"

msgid "Q: There are many ways to express the same value.  The numbers ``200``, ``200.000``, ``2E2``, and ``.02E+4`` all have the same value at various precisions. Is there a way to transform them to a single recognizable canonical value?"
msgstr "پرسش: راه‌های زیادی برای بیان یک مقدار یکسان وجود دارد. اعداد ``200``، ``200.000``، ``2E2`` و ``.02E+4`` همگی در دقت‌های مختلف مقدار یکسانی دارند. آیا راهی برای تبدیل آن‌ها به یک مقدار کانونیکال واحد و قابل‌تشخیص وجود دارد؟"

msgid "A: The :meth:`~Decimal.normalize` method maps all equivalent values to a single representative:"
msgstr "پاسخ: متد :meth:`~Decimal.normalize` تمام مقادیر هم‌ارز را به یک نماینده‌ی واحد نگاشت می‌کند:"

msgid "Q: When does rounding occur in a computation?"
msgstr "پ: گرد کردن در یک محاسبه چه زمانی رخ می‌دهد؟"

msgid "A: It occurs *after* the computation.  The philosophy of the decimal specification is that numbers are considered exact and are created independent of the current context.  They can even have greater precision than current context.  Computations process with those exact inputs and then rounding (or other context operations) is applied to the *result* of the computation::"
msgstr "پاسخ: این امر *پس از* محاسبه رخ می‌دهد. فلسفه‌ی مشخصات decimal این است که اعداد دقیق فرض می‌شوند و مستقل از زمینه‌ی جاری ایجاد می‌شوند. حتی می‌توانند دقتی بیشتر از زمینه‌ی جاری داشته باشند. محاسبات با آن ورودی‌های دقیق انجام می‌شوند و سپس گرد کردن (یا سایر عملیات زمینه) به *نتیجه‌ی* محاسبه اعمال می‌شود::"

msgid ""
">>> getcontext().prec = 5\n"
">>> pi = Decimal('3.1415926535')   # More than 5 digits\n"
">>> pi                             # All digits are retained\n"
"Decimal('3.1415926535')\n"
">>> pi + 0                         # Rounded after an addition\n"
"Decimal('3.1416')\n"
">>> pi - Decimal('0.00005')        # Subtract unrounded numbers, then round\n"
"Decimal('3.1415')\n"
">>> pi + 0 - Decimal('0.00005').   # Intermediate values are rounded\n"
"Decimal('3.1416')"
msgstr ""
">>> getcontext().prec = 5\n"
">>> pi = Decimal('3.1415926535')   # More than 5 digits\n"
">>> pi                             # All digits are retained\n"
"Decimal('3.1415926535')\n"
">>> pi + 0                         # Rounded after an addition\n"
"Decimal('3.1416')\n"
">>> pi - Decimal('0.00005')        # Subtract unrounded numbers, then round\n"
"Decimal('3.1415')\n"
">>> pi + 0 - Decimal('0.00005').   # Intermediate values are rounded\n"
"Decimal('3.1416')"

msgid "Q: Some decimal values always print with exponential notation.  Is there a way to get a non-exponential representation?"
msgstr "پرسش: برخی مقادیر اعشاری همیشه با نماد نمایی چاپ می‌شوند. آیا راهی برای دریافت نمایش غیرنمایی وجود دارد؟"

msgid "A: For some values, exponential notation is the only way to express the number of significant places in the coefficient.  For example, expressing ``5.0E+3`` as ``5000`` keeps the value constant but cannot show the original's two-place significance."
msgstr "پاسخ: برای برخی از مقدارها، نماد نمایی تنها راه بیان تعداد ارقام معنادار در ضریب است. برای مثال، بیان ``5.0E+3`` به‌صورت ``5000`` مقدار را ثابت نگه می‌دارد، اما نمی‌تواند نشان دهد که مقدار اصلی دو رقم معنادار دارد."

msgid "If an application does not care about tracking significance, it is easy to remove the exponent and trailing zeroes, losing significance, but keeping the value unchanged:"
msgstr "اگر برنامه‌ای به پیگیری ارقام معنادار اهمیتی نمی‌دهد، می‌توان به‌راحتی توان و صفرهای انتهایی را حذف کرد؛ با این کار ارقام معنادار از دست می‌روند، اما مقدار بدون تغییر می‌ماند:"

msgid "Q: Is there a way to convert a regular float to a :class:`Decimal`?"
msgstr "پرسش: آیا راهی برای تبدیل یک عدد اعشاری معمولی به :class:`Decimal` وجود دارد؟"

msgid "A: Yes, any binary floating-point number can be exactly expressed as a Decimal though an exact conversion may take more precision than intuition would suggest:"
msgstr "پ: بله، هر عدد ممیز شناور دودویی را می‌توان دقیقاً به‌صورت یک Decimal بیان کرد، هرچند یک تبدیل دقیق ممکن است به دقت بیشتری نسبت به آنچه به‌طور شهودی انتظار می‌رود نیاز داشته باشد:"

msgid ""
">>> Decimal(math.pi)\n"
"Decimal('3.141592653589793115997963468544185161590576171875')"
msgstr ""
">>> Decimal(math.pi)\n"
"Decimal('3.141592653589793115997963468544185161590576171875')"

msgid "Q: Within a complex calculation, how can I make sure that I haven't gotten a spurious result because of insufficient precision or rounding anomalies."
msgstr "پرسش: در یک محاسبه‌ی پیچیده، چگونه می‌توانم مطمئن شوم که به دلیل دقت ناکافی یا ناهنجاری‌های گردکردن، نتیجه‌ای کاذب به دست نیاورده‌ام."

msgid "A: The decimal module makes it easy to test results.  A best practice is to re-run calculations using greater precision and with various rounding modes. Widely differing results indicate insufficient precision, rounding mode issues, ill-conditioned inputs, or a numerically unstable algorithm."
msgstr "پاسخ: ماژول decimal آزمایش نتایج را آسان می‌کند. بهترین روش این است که محاسبات را با دقت بیشتر و با حالت‌های مختلف گرد کردن دوباره اجرا کنید. نتایج بسیار متفاوت، دقت ناکافی، مشکلات مربوط به حالت گرد کردن، ورودی‌های بدشرط یا یک الگوریتم ناپایدار عددی را نشان می‌دهند."

msgid "Q: I noticed that context precision is applied to the results of operations but not to the inputs.  Is there anything to watch out for when mixing values of different precisions?"
msgstr "پرسش: متوجه شده‌ام که دقت زمینه بر نتایج عملیات اعمال می‌شود، اما نه بر ورودی‌ها. آیا هنگام ترکیب مقادیر با دقت‌های مختلف، نکته‌ای وجود دارد که باید به آن توجه کنید؟"

msgid "A: Yes.  The principle is that all values are considered to be exact and so is the arithmetic on those values.  Only the results are rounded.  The advantage for inputs is that \"what you type is what you get\".  A disadvantage is that the results can look odd if you forget that the inputs haven't been rounded:"
msgstr "پاسخ: بله. اصل این است که همه مقادیر دقیق در نظر گرفته می‌شوند و عملیات حسابی روی آن مقادیر نیز دقیق است. فقط نتایج گرد می‌شوند. مزیت آن برای ورودی‌ها این است که «آنچه تایپ می‌کنید، همان را دریافت می‌کنید». عیب آن این است که اگر فراموش کنید ورودی‌ها گرد نشده‌اند، نتایج ممکن است عجیب به نظر برسند:"

msgid ""
">>> getcontext().prec = 3\n"
">>> Decimal('3.104') + Decimal('2.104')\n"
"Decimal('5.21')\n"
">>> Decimal('3.104') + Decimal('0.000') + Decimal('2.104')\n"
"Decimal('5.20')"
msgstr ""
">>> getcontext().prec = 3\n"
">>> Decimal('3.104') + Decimal('2.104')\n"
"Decimal('5.21')\n"
">>> Decimal('3.104') + Decimal('0.000') + Decimal('2.104')\n"
"Decimal('5.20')"

msgid "The solution is either to increase precision or to force rounding of inputs using the unary plus operation:"
msgstr "راه‌حل یا افزایش دقت است یا گرد کردن اجباری ورودی‌ها با استفاده از عملیات مثبت یک‌عملوندی:"

msgid ""
">>> getcontext().prec = 3\n"
">>> +Decimal('1.23456789')      # unary plus triggers rounding\n"
"Decimal('1.23')"
msgstr ""
">>> getcontext().prec = 3\n"
">>> +Decimal('1.23456789')      # unary plus triggers rounding\n"
"Decimal('1.23')"

msgid "Alternatively, inputs can be rounded upon creation using the :meth:`Context.create_decimal` method:"
msgstr "به‌عنوان جایگزین، ورودی‌ها می‌توانند در زمان ایجاد با استفاده از متد :meth:`Context.create_decimal` گرد شوند:"

msgid "Q: Is the CPython implementation fast for large numbers?"
msgstr "پرسش: آیا پیاده‌سازی CPython برای اعداد بزرگ سریع است؟"

msgid "A: Yes.  In the CPython and PyPy3 implementations, the C/CFFI versions of the decimal module integrate the high speed `libmpdec <https://www.bytereef.org/mpdecimal/doc/libmpdec/index.html>`_ library for arbitrary precision correctly rounded decimal floating-point arithmetic [#]_. ``libmpdec`` uses `Karatsuba multiplication <https://en.wikipedia.org/wiki/Karatsuba_algorithm>`_ for medium-sized numbers and the `Number Theoretic Transform <https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general)#Number-theoretic_transform>`_ for very large numbers."
msgstr "پاسخ: بله. در پیاده‌سازی‌های CPython و PyPy3، نسخه‌های C/CFFI ماژول decimal از کتابخانه پرسرعت `libmpdec <https://www.bytereef.org/mpdecimal/doc/libmpdec/index.html>`_ برای حساب ممیز شناور اعشاری با دقت دلخواه و گردکردن صحیح بهره می‌برند [#]_. ``libmpdec`` برای اعداد با اندازه متوسط از `ضرب کاراتسوبا <https://fa.wikipedia.org/wiki/الگوریتم_کاراتسوبا>`_ و برای اعداد بسیار بزرگ از `تبدیل نظریه‌ای اعداد (Number Theoretic Transform) <https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general)#Number-theoretic_transform>`_ استفاده می‌کند."

msgid "The context must be adapted for exact arbitrary precision arithmetic. :attr:`~Context.Emin` and :attr:`~Context.Emax` should always be set to the maximum values, :attr:`~Context.clamp` should always be 0 (the default).  Setting :attr:`~Context.prec` requires some care."
msgstr "زمینه باید برای عملیات حسابی دقیق با دقت دلخواه تطبیق داده شود. :attr:`~Context.Emin` و :attr:`~Context.Emax` باید همیشه روی مقادیر بیشینه تنظیم شوند، :attr:`~Context.clamp` باید همیشه ۰ (پیش‌فرض) باشد. تنظیم :attr:`~Context.prec` به کمی دقت نیاز دارد."

msgid "The easiest approach for trying out bignum arithmetic is to use the maximum value for :attr:`~Context.prec` as well [#]_::"
msgstr "ساده‌ترین روش برای آزمایش حساب اعداد بزرگ (bignum arithmetic) این است که از حداکثر مقدار :attr:`~Context.prec` نیز استفاده کنید [#]_::"

msgid ""
">>> setcontext(Context(prec=MAX_PREC, Emax=MAX_EMAX, Emin=MIN_EMIN))\n"
">>> x = Decimal(2) ** 256\n"
">>> x / 128\n"
"Decimal('904625697166532776746648320380374280103671755200316906558262375061821325312')"
msgstr ""
">>> setcontext(Context(prec=MAX_PREC, Emax=MAX_EMAX, Emin=MIN_EMIN))\n"
">>> x = Decimal(2) ** 256\n"
">>> x / 128\n"
"Decimal('904625697166532776746648320380374280103671755200316906558262375061821325312')"

msgid "For inexact results, :const:`MAX_PREC` is far too large on 64-bit platforms and the available memory will be insufficient::"
msgstr "برای نتایج غیردقیق، :const:`MAX_PREC` در پلتفرم‌های ۶۴ بیتی بسیار بیش‌ازحد بزرگ است و حافظه‌ی در دسترس کافی نخواهد بود::"

msgid ""
">>> Decimal(1) / 3\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"MemoryError"
msgstr ""
">>> Decimal(1) / 3\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"MemoryError"

msgid "On systems with overallocation (e.g. Linux), a more sophisticated approach is to adjust :attr:`~Context.prec` to the amount of available RAM.  Suppose that you have 8GB of RAM and expect 10 simultaneous operands using a maximum of 500MB each::"
msgstr "در سیستم‌هایی با تخصیص بیش‌ازحد (overallocation)، مانند لینوکس، رویکرد پیشرفته‌تر این است که :attr:`~Context.prec` را متناسب با مقدار RAM در دسترس تنظیم کنید. فرض کنید ۸ گیگابایت RAM دارید و انتظار ۱۰ عملوند همزمان را دارید که هرکدام حداکثر ۵۰۰ مگابایت مصرف می‌کنند::"

msgid ""
">>> import sys\n"
">>>\n"
">>> # Maximum number of digits for a single operand using 500MB in 8-byte words\n"
">>> # with 19 digits per word (4-byte and 9 digits for the 32-bit build):\n"
">>> maxdigits = 19 * ((500 * 1024**2) // 8)\n"
">>>\n"
">>> # Check that this works:\n"
">>> c = Context(prec=maxdigits, Emax=MAX_EMAX, Emin=MIN_EMIN)\n"
">>> c.traps[Inexact] = True\n"
">>> setcontext(c)\n"
">>>\n"
">>> # Fill the available precision with nines:\n"
">>> x = Decimal(0).logical_invert() * 9\n"
">>> sys.getsizeof(x)\n"
"524288112\n"
">>> x + 2\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  decimal.Inexact: [<class 'decimal.Inexact'>]"
msgstr ""
">>> import sys\n"
">>>\n"
">>> # Maximum number of digits for a single operand using 500MB in 8-byte words\n"
">>> # with 19 digits per word (4-byte and 9 digits for the 32-bit build):\n"
">>> maxdigits = 19 * ((500 * 1024**2) // 8)\n"
">>>\n"
">>> # Check that this works:\n"
">>> c = Context(prec=maxdigits, Emax=MAX_EMAX, Emin=MIN_EMIN)\n"
">>> c.traps[Inexact] = True\n"
">>> setcontext(c)\n"
">>>\n"
">>> # Fill the available precision with nines:\n"
">>> x = Decimal(0).logical_invert() * 9\n"
">>> sys.getsizeof(x)\n"
"524288112\n"
">>> x + 2\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  decimal.Inexact: [<class 'decimal.Inexact'>]"

msgid "In general (and especially on systems without overallocation), it is recommended to estimate even tighter bounds and set the :attr:`Inexact` trap if all calculations are expected to be exact."
msgstr "به‌طور کلی (و به‌ویژه در سیستم‌های بدون تخصیص بیش‌ازحد (overallocation))، توصیه می‌شود کران‌های حتی محدودتری را برآورد کنید و اگر انتظار می‌رود همه‌ی محاسبات دقیق باشند، تله‌ی :attr:`Inexact` را تنظیم کنید."

msgid "This approach now works for all exact results except for non-integer powers."
msgstr "این روش اکنون برای همه‌ی نتایج دقیق، به‌جز توان‌هایی که عدد صحیح نیستند، کار می‌کند."