Decimal - Matemática de ponto Fixo e Flutuante¶

O módulo decimal implementa aritmética de ponto fixo e flutuante usando o modelo familiar para a maioria das pessoas, em vez da versão de ponto flutuante IEEE implementada pela maioria dos hardwares. Uma instância decimal pode representar qualquer número exatamente, arredondar para cima ou para baixo e aplicar um limite ao número de dígitos significativos.

Para informações detalhadas sobrea biblioteca você pode consultar a sua documentação

Decimal¶

Os valores decimais são representados como instâncias da classe Decimal. O construtor usa como argumento um número inteiro ou uma string. Os números de ponto flutuante devem ser convertidos em uma sequência antes de serem usados para criar um decimal, permitindo que o chamador lide explicitamente com o número de dígitos de valores que não podem ser expressos exatamente usando representações de ponto flutuante de hardware.

O início usual do uso de decimais é importar o módulo, exibir o contexto atual com getcontext() e, se necessário, definir novos valores para precisão, arredondamento ou traps ativados:

In [2]:

from decimal import *
getcontext()

Out[2]:

Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])

In [11]:

# Setando um novo valor de precisão
getcontext().prec = 13

Instâncias decimais podem ser construídas a partir de números inteiros, strings, floats ou tuplas. A construção de um número inteiro ou de um ponto flutuante realiza uma conversão exata do valor desse número inteiro ou ponto flutuante. Os números decimais incluem valores especiais como NaN, que significa "Não é um número", Infinito positivo e negativo e -0:

In [12]:

Decimal(10)

Out[12]:

Decimal('10')

In [13]:

Decimal('3.14')

Out[13]:

Decimal('3.14')

In [52]:

Decimal(3.145)

Out[52]:

Decimal('3.145000000000000017763568394002504646778106689453125')

In [22]:

Decimal((0, (3, 1, 4), -3))

Out[22]:

Decimal('0.314')

In [23]:

Decimal(str(2.0 ** 0.5))

Out[23]:

Decimal('1.4142135623730951')

In [24]:

Decimal(2) ** Decimal('0.5')

Out[24]:

Decimal('1.414213562373095048801688724')

In [25]:

Decimal('NaN')

Out[25]:

Decimal('NaN')

In [26]:

Decimal('-Infinity')

Out[26]:

Decimal('-Infinity')

Realizando Operações¶

In [49]:

import decimal

a = decimal.Decimal('5.7')
b = decimal.Decimal('3.14')
c = 4

print(f'a = {a}')
print(f'b = {b}')
print(f'c = {c}')

a = 5.7
b = 3.14
c = 4

In [50]:

print(f'{a} + {b} = {a+b}')
print(f'{a} - {b} = {a-b}')
print(f'{a} * {b} = {a*b}')
print(f'{a} / {b} = {a/b}')

5.7 + 3.14 = 8.84
5.7 - 3.14 = 2.56
5.7 * 3.14 = 17.898
5.7 / 3.14 = 1.815286624203821656050955414

In [51]:

print(f'{a} + {c} = {a+c}')
print(f'{a} - {c} = {a-c}')
print(f'{a} * {c} = {a*c}')
print(f'{a} / {c} = {a/c}')

5.7 + 4 = 9.7
5.7 - 4 = 1.7
5.7 * 4 = 22.8
5.7 / 4 = 1.425

Funções Matemáticas¶

In [34]:

Decimal(2).sqrt()

Out[34]:

Decimal('1.414213562373095048801688724')

In [35]:

Decimal(1).exp()

Out[35]:

Decimal('2.718281828459045235360287471')

In [36]:

Decimal('10').ln()

Out[36]:

Decimal('2.302585092994045684017991455')

In [37]:

Decimal('100').log10()

Out[37]:

Decimal('2')

O método quantize() arredonda um número para um expoente fixo. Esse método é útil para aplicativos monetários que geralmente arredondam os resultados para um número fixo de casas:

In [38]:

Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)

Out[38]:

Decimal('7.32')

In [39]:

Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)

Out[39]:

Decimal('8')

In [43]:

Decimal('8.133333').quantize(Decimal('.001'), rounding=ROUND_DOWN)

Out[43]:

Decimal('8.133')

In [45]:

Decimal('7.325').quantize(Decimal('1.00'), rounding=ROUND_UP)

Out[45]:

Decimal('7.33')

In [48]:

Decimal('7.325').quantize(Decimal('1.0000000'), rounding=ROUND_UP)

Out[48]:

Decimal('7.3250000')