# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2019
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 18:48+0900\n"
"PO-Revision-Date: 2018-06-29 17:18+0000\n"
"Last-Translator: Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2019\n"
"Language-Team: Portuguese (Brazil) (https://www.transifex.com/python-doc/teams/5390/pt_BR/)\n"
"Language: pt_BR\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"

#: ../../tutorial/floatingpoint.rst:9
msgid "Floating Point Arithmetic:  Issues and Limitations"
msgstr "Aritmética de ponto flutuante: problemas e limitações"

#: ../../tutorial/floatingpoint.rst:14
msgid ""
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions.  For example, the decimal fraction ::"
msgstr ""
"Números de ponto flutuante são representados no hardware do computador como "
"frações binárias (base 2). Por exemplo, a fração decimal::"

#: ../../tutorial/floatingpoint.rst:19
msgid ""
"has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction ::"
msgstr ""
"tem o valor 1/10 + 2/100 + 5/1000, e da mesma maneira a fração binária::"

#: ../../tutorial/floatingpoint.rst:23
msgid ""
"has value 0/2 + 0/4 + 1/8.  These two fractions have identical values, the "
"only real difference being that the first is written in base 10 fractional "
"notation, and the second in base 2."
msgstr ""
"tem o valor 0/2 + 0/4 + 1/8. Essas duas frações têm valores idênticos, a única\n"
"diferença real é que a primeira está representada na forma de frações base 10,\n"
"e a segunda na base 2."

#: ../../tutorial/floatingpoint.rst:27
msgid ""
"Unfortunately, most decimal fractions cannot be represented exactly as "
"binary fractions.  A consequence is that, in general, the decimal floating-"
"point numbers you enter are only approximated by the binary floating-point "
"numbers actually stored in the machine."
msgstr ""
"Infelizmente, muitas frações decimais não podem ser representadas precisamente\n"
"como frações binárias. O resultado é que, em geral, os números decimais de\n"
"ponto flutuante que você digita acabam sendo armazenados de forma apenas\n"
"aproximada, na forma de números binários de ponto flutuante."

#: ../../tutorial/floatingpoint.rst:32
msgid ""
"The problem is easier to understand at first in base 10.  Consider the "
"fraction 1/3.  You can approximate that as a base 10 fraction::"
msgstr ""
"O problema é mais fácil de entender primeiro em base 10. Considere a fração\n"
"1/3. Podemos representá-la aproximadamente como uma fração base 10::"

#: ../../tutorial/floatingpoint.rst:37 ../../tutorial/floatingpoint.rst:41
msgid "or, better, ::"
msgstr "ou melhor, ::"

#: ../../tutorial/floatingpoint.rst:45
msgid ""
"and so on.  No matter how many digits you're willing to write down, the "
"result will never be exactly 1/3, but will be an increasingly better "
"approximation of 1/3."
msgstr ""
"e assim por diante. Não importa quantos dígitos você está disposto a escrever,\n"
"o resultado nunca será exatamente 1/3, mas será uma aproximação de cada vez\n"
"melhor de 1/3."

#: ../../tutorial/floatingpoint.rst:49
msgid ""
"In the same way, no matter how many base 2 digits you're willing to use, the"
" decimal value 0.1 cannot be represented exactly as a base 2 fraction.  In "
"base 2, 1/10 is the infinitely repeating fraction ::"
msgstr ""
"Da mesma forma, não importa quantos dígitos de base 2 estejas disposto a "
"usar, o valor decimal 0.1 não pode ser representado exatamente como uma "
"fração de base 2. No sistema de base 2, 1/10 é uma fração binária que se "
"repete infinitamente::"

#: ../../tutorial/floatingpoint.rst:55
msgid ""
"Stop at any finite number of bits, and you get an approximation.  On most "
"machines today, floats are approximated using a binary fraction with the "
"numerator using the first 53 bits starting with the most significant bit and"
" with the denominator as a power of two.  In the case of 1/10, the binary "
"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly"
" equal to the true value of 1/10."
msgstr ""
"Se parares em qualquer número finito de bits, obterás uma aproximação. Hoje "
"em dia, na maioria dos computadores, as casas decimais são aproximados "
"usando uma fração binária onde o numerado utiliza os primeiros 53 bits "
"iniciando no bit mais significativo e tendo como denominador uma potência de"
" dois. No caso de 1/10, a fração binária seria ``602879701896397 / 2 ** 55``"
" o que chega bem perto, mas mesmo assim, não é igual ao valor original de "
"1/10."

#: ../../tutorial/floatingpoint.rst:62
msgid ""
"Many users are not aware of the approximation because of the way values are "
"displayed.  Python only prints a decimal approximation to the true decimal "
"value of the binary approximation stored by the machine.  On most machines, "
"if Python were to print the true decimal value of the binary approximation "
"stored for 0.1, it would have to display ::"
msgstr ""
"É fácil esquecer que o valor armazenado é uma aproximação da fração decimal "
"original, devido à forma como os floats são exibidos no interpretador "
"interativo. O Python exibe apenas uma aproximação decimal do verdadeiro "
"valor decimal da aproximação binária armazenada pela máquina. Se o Python "
"exibisse o verdadeiro valor decimal da aproximação binária que representa o "
"decimal 0.1, seria necessário mostrar::"

#: ../../tutorial/floatingpoint.rst:71
msgid ""
"That is more digits than most people find useful, so Python keeps the number"
" of digits manageable by displaying a rounded value instead ::"
msgstr ""
"Contém muito mais dígitos do que é o esperado e utilizado pela grande "
"maioria dos desenvolvedores, portanto, o Python limita o número de dígitos "
"exibidos, apresentando um valor arredondado, ao invés de mostrar todas as "
"casas decimais::"

#: ../../tutorial/floatingpoint.rst:77
msgid ""
"Just remember, even though the printed result looks like the exact value of "
"1/10, the actual stored value is the nearest representable binary fraction."
msgstr ""
"Lembre-se, mesmo que o resultado impresso seja o valor exato de 1/10, o "
"valor vque verdadeiramente estará armazenado será uma fração binária "
"representável que mais se aproxima."

#: ../../tutorial/floatingpoint.rst:80
msgid ""
"Interestingly, there are many different decimal numbers that share the same "
"nearest approximate binary fraction.  For example, the numbers ``0.1`` and "
"``0.10000000000000001`` and "
"``0.1000000000000000055511151231257827021181583404541015625`` are all "
"approximated by ``3602879701896397 / 2 ** 55``.  Since all of these decimal "
"values share the same approximation, any one of them could be displayed "
"while still preserving the invariant ``eval(repr(x)) == x``."
msgstr ""
"Curiosamente, existem muitos números decimais diferentes que compartilham a "
"mesma fração binária aproximada. Por exemplo, os números ``0.1`` ou o "
"``0.10000000000000001`` e "
"``0.1000000000000000055511151231257827021181583404541015625`` são todos "
"aproximações de ``3602879701896397/2 ** 55``. Como todos esses valores "
"decimais compartilham um mesma de aproximação, qualquer um poderá ser "
"exibido enquanto for preservado o invariante ``eval(repr(x)) == x``."

#: ../../tutorial/floatingpoint.rst:88
msgid ""
"Historically, the Python prompt and built-in :func:`repr` function would "
"choose the one with 17 significant digits, ``0.10000000000000001``.   "
"Starting with Python 3.1, Python (on most systems) is now able to choose the"
" shortest of these and simply display ``0.1``."
msgstr ""
"Historicamente, o prompt do Python e a função builtin :func:`repr` "
"utilizaria o que contivesse  17 dígitos "
"significativos,``0.10000000000000001``. Desde a versão do Python 3.1, o "
"Python (na maioria dos sistemas) agora é possível optar pela forma mais "
"curta (reduzida) exibindo simplesmente o número ``0.1``."

#: ../../tutorial/floatingpoint.rst:93
msgid ""
"Note that this is in the very nature of binary floating-point: this is not a"
" bug in Python, and it is not a bug in your code either.  You'll see the "
"same kind of thing in all languages that support your hardware's floating-"
"point arithmetic (although some languages may not *display* the difference "
"by default, or in all output modes)."
msgstr ""
"Note que essa é a própria natureza do ponto flutuante binário: não é um bug "
"do Python, e nem é um bug do seu código. Essa situação pode ser observada em"
" todas as linguagens que usam as instruções aritméticas de ponto flutuante "
"do hardware (apesar de algumas linguagens não *mostrarem* a diferença, por "
"padrão, ou em todos os modos de saída)."

#: ../../tutorial/floatingpoint.rst:99
msgid ""
"For more pleasant output, you may wish to use string formatting to produce a"
" limited number of significant digits::"
msgstr ""
"Para obter um valor mais agradável, poderás utilizar a formatação de "
"seqüência de caracteres sendo capaz de gerar um número limitado de dígitos "
"significativos::"

#: ../../tutorial/floatingpoint.rst:111
msgid ""
"It's important to realize that this is, in a real sense, an illusion: you're"
" simply rounding the *display* of the true machine value."
msgstr ""
"É importante perceber que tudo não passa de pura ilusão: estas simplesmente "
"arredondando a *exibição* da verdadeira maquinaria do valor."

#: ../../tutorial/floatingpoint.rst:114
msgid ""
"One illusion may beget another.  For example, since 0.1 is not exactly 1/10,"
" summing three values of 0.1 may not yield exactly 0.3, either::"
msgstr ""
"Uma ilusão pode gerar outra. Por exemplo, uma vez que 0,1 não é exatamente "
"1/10, somar três vezes o valor 0.1, não garantirá que o resultado seja "
"exatamente 0,3, isso porque::"

#: ../../tutorial/floatingpoint.rst:120
msgid ""
"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3"
" cannot get any closer to the exact value of 3/10, then pre-rounding with "
":func:`round` function cannot help::"
msgstr ""
"Inclusive, uma vez que o 0,1 não consegue aproximar-se do valor exato de "
"1/10 e 0,3 não pode se aproximar mais do valor exato de 3/10, temos então "
"que o pré-arredondamento com a função :func:`round` não servirá como ajuda::"

#: ../../tutorial/floatingpoint.rst:127
msgid ""
"Though the numbers cannot be made closer to their intended exact values, the"
" :func:`round` function can be useful for post-rounding so that results with"
" inexact values become comparable to one another::"
msgstr ""
"Embora os números não possam se aproximar mais dos exatos valores que "
"desejamos, a função :func:`round` poderá ser útil na obtenção do pós-"
"arredondamento para que os resultados contendo valores inexatos se tornem "
"comparáveis uns aos outros::"

#: ../../tutorial/floatingpoint.rst:134
msgid ""
"Binary floating-point arithmetic holds many surprises like this.  The "
"problem with \"0.1\" is explained in precise detail below, in the "
"\"Representation Error\" section.  See `The Perils of Floating Point "
"<http://www.lahey.com/float.htm>`_ for a more complete account of other "
"common surprises."
msgstr ""
"A aritmética de ponto flutuante binário traz muitas surpresas como essas. O "
"problema do \"0.1\" é explicado em detalhes precisos abaixo, na seção `Erro "
"de Representação`_. Para uma descrição mais completa de outras surpresas que"
" comumente nos deparamos, veja a seção `The Perils of Floating Point "
"<http://www.lahey.com/float.htm>`_ que contém diversos exemplos distintos."

#: ../../tutorial/floatingpoint.rst:139
msgid ""
"As that says near the end, \"there are no easy answers.\"  Still, don't be "
"unduly wary of floating-point!  The errors in Python float operations are "
"inherited from the floating-point hardware, and on most machines are on the "
"order of no more than 1 part in 2\\*\\*53 per operation.  That's more than "
"adequate for most tasks, but you do need to keep in mind that it's not "
"decimal arithmetic and that every float operation can suffer a new rounding "
"error."
msgstr ""
"Como dizemos perto do final, \"não há respostas fáceis\". Ainda assim, não "
"se percam indevidamente no uso do ponto flutuante! Os erros nas operações do"
" tipo float do Python são heranças do hardware de ponto flutuante e, a "
"maioria dos computadores estão na ordem de não mais do que 1 parte em "
"2\\*\\*53 por operação. Isso é mais do que o suficiente para a maioria das "
"tarefas, portanto, é importante lembrar que não se trata de uma aritmética "
"decimal e que toda operação com o tipo float poderá via a apresentar novos "
"problemas referentes ao arredondamento."

#: ../../tutorial/floatingpoint.rst:146
msgid ""
"While pathological cases do exist, for most casual use of floating-point "
"arithmetic you'll see the result you expect in the end if you simply round "
"the display of your final results to the number of decimal digits you "
"expect. :func:`str` usually suffices, and for finer control see the "
":meth:`str.format` method's format specifiers in :ref:`formatstrings`."
msgstr ""
"Embora existam casos patológicos, na maior parte das vezes, terás como "
"resultado final o valor esperado, se simplesmente arredondares a exibição "
"final dos resultados para a quantidade de dígitos decimais que esperas a "
"função :func:`str` geralmente será o suficiente, e , para seja necessário um"
" valor refinado, veja os especificadores de formato :meth:`str.format` "
"contido na seção :ref:`formatstrings`."

#: ../../tutorial/floatingpoint.rst:152
msgid ""
"For use cases which require exact decimal representation, try using the "
":mod:`decimal` module which implements decimal arithmetic suitable for "
"accounting applications and high-precision applications."
msgstr ""
"Para as situações que exijam uma representação decimal exata, experimente o "
"módulo :mod:`decimal` que possui, a implementação de uma adequada aritmética"
" decimal bastante utilizada nas aplicações contábeis e pelas aplicações que "
"demandam alta precisão."

#: ../../tutorial/floatingpoint.rst:156
msgid ""
"Another form of exact arithmetic is supported by the :mod:`fractions` module"
" which implements arithmetic based on rational numbers (so the numbers like "
"1/3 can be represented exactly)."
msgstr ""
"Uma outra forma de obter uma aritmética exata tem suporte pelo módulo "
":mod:`fracções` que implementa a aritmética baseada em números racionais "
"(portanto, os números fracionários como o 1/3 conseguem uma representação "
"precisa)."

#: ../../tutorial/floatingpoint.rst:160
msgid ""
"If you are a heavy user of floating point operations you should take a look "
"at the Numerical Python package and many other packages for mathematical and"
" statistical operations supplied by the SciPy project. See "
"<https://scipy.org>."
msgstr ""
"Caso necessites fazer um intenso uso das operações de ponto flutuante, é "
"importante que conheças o pacote Numerical Python e, também é importante "
"dizer, que existem diversos pacotes destinados ao trabalho intenso com "
"operações matemáticas e estatísticas que são fornecidas pelo projeto SciPy. "
"Veja <https://scipy.org>."

#: ../../tutorial/floatingpoint.rst:164
msgid ""
"Python provides tools that may help on those rare occasions when you really "
"*do* want to know the exact value of a float.  The "
":meth:`float.as_integer_ratio` method expresses the value of a float as a "
"fraction::"
msgstr ""
"O Python fornece ferramentas que podem ajudar nessas raras ocasiões em que "
"realmente *faz* necessitas conhecer o valor exato de um float. O método "
":meth:`float.as_integer_ratio` expressa o valor do tipo float em sua forma "
"fracionária::"

#: ../../tutorial/floatingpoint.rst:173
msgid ""
"Since the ratio is exact, it can be used to losslessly recreate the original"
" value::"
msgstr ""
"Uma vez que a relação seja exata, será possível utiliza-la para obter, sem "
"que haja quaisquer perda o valor original::"

#: ../../tutorial/floatingpoint.rst:179
msgid ""
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer::"
msgstr ""
"O método :meth:`float.hex` expressa um tipo float em hexadecimal (base 16), "
"o mesmo também conferirá o valor exato pelo computador::"

#: ../../tutorial/floatingpoint.rst:185
msgid ""
"This precise hexadecimal representation can be used to reconstruct the float"
" value exactly::"
msgstr ""
"Sua precisa representação hexadecimal poderá ser utilizada para reconstruir "
"o valor exato do float::"

#: ../../tutorial/floatingpoint.rst:191
msgid ""
"Since the representation is exact, it is useful for reliably porting values "
"across different versions of Python (platform independence) and exchanging "
"data with other languages that support the same format (such as Java and "
"C99)."
msgstr ""
"Como a representação será exata, é interessante utilizar valores confiáveis "
"em diferentes versões do Python (independente da plataforma) e a troca de "
"dados entre idiomas diferentes que forneçam o mesmo formato (como o Java e o"
" C99)."

#: ../../tutorial/floatingpoint.rst:195
msgid ""
"Another helpful tool is the :func:`math.fsum` function which helps mitigate "
"loss-of-precision during summation.  It tracks \"lost digits\" as values are"
" added onto a running total.  That can make a difference in overall accuracy"
" so that the errors do not accumulate to the point where they affect the "
"final total:"
msgstr ""
"Uma outra ferramenta que poderá ser útil é a função :func:`math.fsum` que "
"ajuda a mitigar a perda de precisão durante a soma. Ele rastreia \"dígitos "
"perdidos\", isso porque, os valores serão adicionados a um total em "
"execução. Isso poderá fazer a diferença na precisão geral de forma que os "
"erros não se acumulem chegando ao ponto de afetar o resultado final:"

#: ../../tutorial/floatingpoint.rst:209
msgid "Representation Error"
msgstr "Erro de representação"

#: ../../tutorial/floatingpoint.rst:211
msgid ""
"This section explains the \"0.1\" example in detail, and shows how you can "
"perform an exact analysis of cases like this yourself.  Basic familiarity "
"with binary floating-point representation is assumed."
msgstr ""
"Esta seção explica o exemplo do \"0,1\" em detalhes, e mostra como poderás "
"realizar uma análise exata de casos semelhantes. Assumimos que tenhas uma "
"familiaridade básica com a representação binária de ponto flutuante."

#: ../../tutorial/floatingpoint.rst:215
msgid ""
":dfn:`Representation error` refers to the fact that some (most, actually) "
"decimal fractions cannot be represented exactly as binary (base 2) "
"fractions. This is the chief reason why Python (or Perl, C, C++, Java, "
"Fortran, and many others) often won't display the exact decimal number you "
"expect."
msgstr ""
":dfn:`Erro de representação` refere-se ao fato de que algumas frações "
"decimais (a maioria, na verdade) não podem ser representadas exatamente como"
" frações binárias (base 2). Esta é a principal razão por que o Python (ou "
"Perl, C, C++, Java, Fortran, e muitas outras) frequentemente não exibe o "
"número decimal exato conforme o esperado::"

#: ../../tutorial/floatingpoint.rst:220
msgid ""
"Why is that?  1/10 is not exactly representable as a binary fraction. Almost"
" all machines today (November 2000) use IEEE-754 floating point arithmetic, "
"and almost all platforms map Python floats to IEEE-754 \"double precision\"."
"  754 doubles contain 53 bits of precision, so on input the computer strives"
" to convert 0.1 to the closest fraction it can of the form *J*/2**\\ *N* "
"where *J* is an integer containing exactly 53 bits.  Rewriting ::"
msgstr ""
"Por que isso acontece? 1/10 e 2/10 não são podem ser representados "
"exatamente ​​sendo frações binárias. Atualmente, quase todos computadores "
"(julho de 2010) usam aritmética de ponto flutuante conforme a norma "
"IEEE-754, e o Python, em quase todas as plataformas, representa um float "
"como um \"IEEE-754 double precision float\" (\"float de precisão dupla "
"IEEE-754\"). Os tais \"doubles IEEE-754\" têm 53 bits de precisão, por isso "
"na entrada o computador se esforça para converter \"0.1\" pra fração mais "
"próxima que puder, na forma *J*/2**\\ *N* onde *J* é um número inteiro "
"contendo exatamente 53 bits. Reescrevendo::"

#: ../../tutorial/floatingpoint.rst:229
msgid "as ::"
msgstr "como ::"

#: ../../tutorial/floatingpoint.rst:233
msgid ""
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
"2**53``), the best value for *N* is 56::"
msgstr ""
"e recordando que *J* tenha exatamente 53 bits (é ``>= 2**52``, mas ``< "
"2**53``), o melhor valor para *N* é 56::"

#: ../../tutorial/floatingpoint.rst:239
msgid ""
"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits."
"  The best possible value for *J* is then that quotient rounded::"
msgstr ""
"Ou seja, 56 é o único valor de *N* que deixa *J* com exatamente 53 bits. "
"Portanto, o melhor valor que conseguimos obter pra *J* será aquele que "
"possui o quociente arredondado::"

#: ../../tutorial/floatingpoint.rst:246
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up::"
msgstr ""
"Uma vez que o resto seja maior do que a metade de 10, a melhor aproximação "
"que poderá ser obtida se arredondarmos para cima::"

#: ../../tutorial/floatingpoint.rst:252
msgid ""
"Therefore the best possible approximation to 1/10 in 754 double precision "
"is::"
msgstr ""
"Portanto, a melhor aproximação possível de 1/10 como um \"IEEE-754 double "
"precision\" é aquele valor dividido por 2\\*\\* 56, o"

#: ../../tutorial/floatingpoint.rst:256
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr "Dividir o numerador e o denominador por dois reduzirá a fração para::"

#: ../../tutorial/floatingpoint.rst:260
msgid ""
"Note that since we rounded up, this is actually a little bit larger than "
"1/10; if we had not rounded up, the quotient would have been a little bit "
"smaller than 1/10.  But in no case can it be *exactly* 1/10!"
msgstr ""
"Note que, como arredondamos para cima, esse valor é, de fato, um pouco maior"
" que 1/10; se não tivéssemos arredondado para cima, o quociente teria sido "
"um pouco menor que 1/10. Mas em nenhum caso seria possível obter "
"*exatamente* o valor 1/10!"

#: ../../tutorial/floatingpoint.rst:264
msgid ""
"So the computer never \"sees\" 1/10:  what it sees is the exact fraction "
"given above, the best 754 double approximation it can get::"
msgstr ""
"Por isso, o computador nunca \"vê\" 1/10: o que ele vê é exatamente a fração"
" que é obtida pra cima, a melhor aproximação \"IEEE-754 double\" possível "
"é::"

#: ../../tutorial/floatingpoint.rst:270
msgid ""
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
"decimal digits::"
msgstr ""
"Se multiplicarmos essa fração por 10\\*\\*30, podemos ver o valor contendo "
"os 55 dígitos mais significativos::"

#: ../../tutorial/floatingpoint.rst:276
msgid ""
"meaning that the exact number stored in the computer is equal to the decimal"
" value 0.1000000000000000055511151231257827021181583404541015625. Instead of"
" displaying the full decimal value, many languages (including older versions"
" of Python), round the result to 17 significant digits::"
msgstr ""
"o que significa que o número exato armazenados no computador será "
"aproximadamente igual ao o valor decimal 0.100000000000000005551115123125. "
"Versões do Python anteriores a 2.7 e a 3.1, esse valor era exibido pelo "
"arredondamento dos 17 dígitos significativos, produzindo "
"'0.10000000000000001'. As últimas versões, o Python está exibindo fração "
"decimal mais curta que poderá ser convertida para o verdadeiro valor "
"binário, o que resulta simplesmente em '0.1'."

#: ../../tutorial/floatingpoint.rst:284
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations "
"easy::"
msgstr ""
"Módulos como o :mod:`fractions` e o :mod:`decimal` tornam esses cálculos "
"muito mais fáceis::"