Overflow error

Discussion in 'Python' started by Jane Austine, Jul 27, 2004.

  1. Jane Austine

    Jane Austine Guest

    >>> from math import e
    >>> e**709

    8.218407461554662e+307
    >>> e**710


    Traceback (most recent call last):
    File "<pyshell#15>", line 1, in -toplevel-
    e**710
    OverflowError: (34, 'Result too large')

    What should I do to calculate e**710?

    I'm using Python 2.3.4 on WinXP.
     
    Jane Austine, Jul 27, 2004
    #1
    1. Advertising

  2. (Jane Austine) writes:

    > >>> from math import e
    > >>> e**709

    > 8.218407461554662e+307
    > >>> e**710

    >
    > Traceback (most recent call last):
    > File "<pyshell#15>", line 1, in -toplevel-
    > e**710
    > OverflowError: (34, 'Result too large')
    >
    > What should I do to calculate e**710?


    Well, it's too big for your platform's C double, so you need a
    different representation. I don't know if there are big float
    packages out there that handle such things (likely, though) or if
    there are Python interfaces to the same (less likely). Or you could
    store the logarithms of the numbers you are interested in. Why do you
    need such huge nubmers?

    Cheers,
    mwh

    --
    <exarkun> today's lesson
    <exarkun> don't strace X in an xterm
    -- from Twisted.Quotes
     
    Michael Hudson, Jul 27, 2004
    #2
    1. Advertising

  3. Michael Hudson wrote:

    > (Jane Austine) writes:
    >
    >
    >>>>>from math import e
    >>>>>e**709

    >>
    >>8.218407461554662e+307
    >>
    >>>>>e**710

    >>
    >>Traceback (most recent call last):
    >> File "<pyshell#15>", line 1, in -toplevel-
    >> e**710
    >>OverflowError: (34, 'Result too large')
    >>
    >>What should I do to calculate e**710?

    >
    >
    > Well, it's too big for your platform's C double, so you need a
    > different representation. I don't know if there are big float
    > packages out there that handle such things (likely, though) or if
    > there are Python interfaces to the same (less likely). Or you could
    > store the logarithms of the numbers you are interested in. Why do you
    > need such huge nubmers?
    >
    > Cheers,
    > mwh
    >

    Using a little bit of magic:

    First get a good approximation of e:
    Using my bits package, I can do:

    import bits, math
    scaling = bits.lsb(math.e)
    characteristic = bits.extract(math.e, scaling, 10)
    # This has the same effect as:
    # scaling, characteristic = -51, 6121026514868073L
    # Now e = characteristic * 2.**scaling
    result_scaling = scaling * 710
    result_characteristic = characteristic ** 710
    intpart = result_characteristic >> -result_scaling
    # and you'll have to grab as much fractpart as you want.

    Similarly, for decimal, type in enough digits (for your taste) of e
    from some reference book, and omit the decimal point.
    Then track the exponent in base ten, and you can obtain similar results:

    scaling, characteristic = -5, 271828
    result_scaling = scaling * 710
    result_characteristic = characteristic ** 710
    intpart = result_characteristic // 10 ** -result_scaling


    So, you needn't use floating point if you are willing to type in
    constants. Both of these give a number which is 223. * 10 ** 50 to
    three digits, and they differ in the fourth digit (4 or 3 if you round).
    The binary-based version (the first above) produces:
    2233994766....
    While the decimal-based version produces:
    2232928102....
    This is certainly due to using so few decimal places for e in the
    decimal version.
    In Knuth's Art of Computer Programming (at least volume 3, which I
    happen to have at hand) Appendix A, you can get 41 decimal digits for e,
    or 45 octal digits if you prefer to work with binary. I believe
    (without checking) that each of the volumes contains this appendix.
    The big advantage of using decimal is (a) more readily available tables
    of constants come in decimal than in binary, and (b) if you _do_ want
    to print some of the fractpart, it is easier just to change the division
    to include the extra digits, while for the binary versions you'll have
    to multiply by 10**digits before the division.

    --
    -Scott David Daniels
     
    Scott David Daniels, Jul 28, 2004
    #3
  4. Jane Austine

    Paul Rubin Guest

    (Jane Austine) writes:
    > >>> from math import e
    > >>> e**709

    > 8.218407461554662e+307
    > >>> e**710

    >
    > Traceback (most recent call last):
    > File "<pyshell#15>", line 1, in -toplevel-
    > e**710
    > OverflowError: (34, 'Result too large')
    >
    > What should I do to calculate e**710?


    Is this a homework problem?

    Aw heck, you can do something like this:

    from math import *
    a,b = divmod(710 * log10(e), 1.0) # int and frac parts of log10(e**710)
    print '%f * 10**%d'%(10.** b, a)

    This prints: 2.233995 * 10**308
     
    Paul Rubin, Jul 29, 2004
    #4
  5. Jane Austine

    Dan Bishop Guest

    Michael Hudson <> wrote in message news:<>...
    > (Jane Austine) writes:
    >
    > > >>> from math import e
    > > >>> e**709

    > 8.218407461554662e+307
    > > >>> e**710

    > >
    > > Traceback (most recent call last):
    > > File "<pyshell#15>", line 1, in -toplevel-
    > > e**710
    > > OverflowError: (34, 'Result too large')
    > >
    > > What should I do to calculate e**710?

    >
    > Well, it's too big for your platform's C double, so you need a
    > different representation. I don't know if there are big float
    > packages out there that handle such things (likely, though) or if
    > there are Python interfaces to the same (less likely).


    You can also do it with rationals:

    >>> def unboundedRange(start=0):

    .... n = start
    .... while True:
    .... yield n
    .... n += 1
    ....
    >>> def exp(x, tolerance=rational(1, 10**8)):

    .... total = term = 1
    .... for n in unboundedRange(1):
    .... term *= rational(x, n)
    .... total += term
    .... if abs(term) < tolerance:
    .... break
    .... return total
    ....
    >>> float(exp(1))

    2.7182818282861687
    >>> long(exp(710))

    223399476616171103125364445811681000656812286337946419939922579763369439173505508238045208936075928608008858947959672204126540307964255760331629484074081710600724815623037686564199430826371986947985157927836355814874856465984698389900107606439843841800268119591413945009951691796042715693932113514608158683164L

    However, I don't recommend this, because it's *very* slow.
     
    Dan Bishop, Jul 29, 2004
    #5
  6. Jane Austine

    Jane Austine Guest

    (Dan Bishop) wrote in message news:<>...
    > Michael Hudson <> wrote in message news:<>...
    > > (Jane Austine) writes:
    > >
    > > > >>> from math import e
    > > > >>> e**709

    > 8.218407461554662e+307
    > > > >>> e**710
    > > >
    > > > Traceback (most recent call last):
    > > > File "<pyshell#15>", line 1, in -toplevel-
    > > > e**710
    > > > OverflowError: (34, 'Result too large')
    > > >
    > > > What should I do to calculate e**710?

    > >
    > > Well, it's too big for your platform's C double, so you need a
    > > different representation. I don't know if there are big float
    > > packages out there that handle such things (likely, though) or if
    > > there are Python interfaces to the same (less likely).

    >
    > You can also do it with rationals:
    >
    > >>> def unboundedRange(start=0):

    > ... n = start
    > ... while True:
    > ... yield n
    > ... n += 1
    > ...
    > >>> def exp(x, tolerance=rational(1, 10**8)):

    > ... total = term = 1
    > ... for n in unboundedRange(1):
    > ... term *= rational(x, n)
    > ... total += term
    > ... if abs(term) < tolerance:
    > ... break
    > ... return total
    > ...
    > >>> float(exp(1))

    > 2.7182818282861687
    > >>> long(exp(710))

    > 223399476616171103125364445811681000656812286337946419939922579763369439173505508238045208936075928608008858947959672204126540307964255760331629484074081710600724815623037686564199430826371986947985157927836355814874856465984698389900107606439843841800268119591413945009951691796042715693932113514608158683164L
    >
    > However, I don't recommend this, because it's *very* slow.


    Interesting. Where do I get the "rational" module?
     
    Jane Austine, Jul 31, 2004
    #6
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Replies:
    0
    Views:
    499
  2. Replies:
    0
    Views:
    405
  3. greatwall
    Replies:
    3
    Views:
    513
    Chris Smith
    May 27, 2006
  4. C. Sengstock

    floating point error: overflow?

    C. Sengstock, Sep 24, 2003, in forum: C Programming
    Replies:
    3
    Views:
    4,244
    Mike Wahler
    Sep 26, 2003
  5. Satchidanand Haridas

    Overflow error

    Satchidanand Haridas, Jul 28, 2004, in forum: Python
    Replies:
    0
    Views:
    439
    Satchidanand Haridas
    Jul 28, 2004
Loading...

Share This Page