What is the largest number the Decimal class can handle?

Question

My program calculates the mathematical constant e, which is irrational. In order to do this, I needed to get factorials of very large numbers.

int cannot handle numbers larger than 170!. (I found that the largest Google's calculator can handle is 170.654259, but I'm not sure how a non integer can be factorized.) float can not handle very large numbers either.

I calculated e to 750000 digits, and math.factorial(750000) is a mind-boggling, large number. Yet, Decimal handled it with apparent ease.

How large of a number can Decimal handle before an OverflowError is raised? Is the size different in Python 2 versus Python 3?

Answer 1

What is the largest number the Decimal class can handle?

The largest magnitude is infinity:

>>> from decimal import Decimal
>>> Decimal('Inf')
Decimal('Infinity')

The largest representable finite number on a given platform depends on decimal.MAX_EMAX:

>>> from decimal import Context, MAX_EMAX
>>> d = Context(Emax=MAX_EMAX, prec=1).create_decimal('9e'+str(MAX_EMAX))
>>> d.is_finite()
True
>>> d.next_plus()
Decimal('Infinity')
>>> d
Decimal('9E+999999999999999999')

The number of significant digits depends on decimal.MAX_PREC e.g., to calculate e with the given precision:

>>> from decimal import Context
>>> Context(prec=60).exp(1)
Decimal('2.71828182845904523536028747135266249775724709369995957496697')

The constants (MAX_EMAX, MAX_PREC) are only relevant for the C implementation. Pure Python version can use larger values:

>>> from decimal import Context, MAX_EMAX
>>> Context(Emax=MAX_EMAX+1, prec=1).create_decimal('9e'+str(MAX_EMAX+1))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: valid range for Emax is [0, MAX_EMAX]
>>> from _pydecimal import Context, MAX_EMAX
>>> Context(Emax=MAX_EMAX+1, prec=1).create_decimal('9e'+str(MAX_EMAX+1))
Decimal('9E+1000000000000000000')

Answer 2

It depends on the context you provide for the Decimal object. From the library documentation:

class decimal.Context(prec=None, rounding=None, traps=None, flags=None, Emin=None, Emax=None, capitals=1)

Emax and Emin control the bounds of your decimal. If the exponent is greater than Emax or less than Emin there will be an overflow signal. You can look at the fields in decimal.defaultContext to see what they are by default, or decimal.getContext() to see what they are at any given time.

Edit: As @davidism pointed out you don't get exact answers from decimal calculations. The default precision of the module is 28. So all integers up to 999999999999999999999999999999 (28 nines) can be represented exactly, and higher numbers might be rounded.