The smallest and largest values of numeric types

Discussion in 'Python' started by tom, Apr 17, 2007.

  1. tom

    tom Guest

    Hi!
    How can I determine the smallest and largest values of numeric types
    (for example int) possible in my system? I think there exists a function
    for this task but I don't know it.
     
    tom, Apr 17, 2007
    #1
    1. Advertisements

  2. tom

    Lou Pecora Guest

    There is or was a module called "kinds" which was an implementation of
    PEP 0242. I have it and it gives the values you are looking for (and
    more). But I don't know where I got it. I think it was once
    distributed with Macpython on MacPython.org, but I'm not sure. I've
    searched for it, but nothing shows up except my own questions about it
    from many years ago and they have no clues.

    Does anyone know where this package is? Or what might replace it. It
    is very useful.
     
    Lou Pecora, Apr 17, 2007
    #2
    1. Advertisements

  3. tom

    Robert Kern Guest

    I'm surprised they also didn't turn up my replies to those questions.
    It used to be distributed with Numeric.

    http://numpy.cvs.sourceforge.net/numpy/kinds/

    numpy exposes the same information for floating point types with its finfo
    class. Nothing particular for ints.

    --
    Robert Kern

    "I have come to believe that the whole world is an enigma, a harmless enigma
    that is made terrible by our own mad attempt to interpret it as though it had
    an underlying truth."
    -- Umberto Eco
     
    Robert Kern, Apr 17, 2007
    #3
  4. tom

    fumanchu Guest

    This should work for ints:

    import sys
    print sys.maxint


    For floats, just try until it fails. This is from
    http://projects.amor.org/geniusql/browser/trunk/geniusql/adapters.py#l41

    # Determine max binary digits for float on this system. Crude but
    effective.
    maxfloat_digits = 2
    while True:
    L = (2 ** (maxfloat_digits + 1)) - 1
    if int(float(L)) != L:
    break
    maxfloat_digits += 1

    Note this will get you the number of binary digits, which is not a
    simple matter to translate to maximum and minimum values, since floats
    are inexact numerics. IEEE 754 floats are stored with one bit for the
    sign, some bits for the exponent (which is biased) and some for the
    significand. See http://babbage.cs.qc.edu/IEEE-754/32bit.html for a
    visual example of how it works.


    Robert Brewer
    System Architect
    Amor Ministries
     
    fumanchu, Apr 17, 2007
    #4
  5. tom

    tom Guest

    Thank you for your answers. Seems like the limits of numeric values
    aren't considered as important in Python as in C ;)
     
    tom, Apr 17, 2007
    #5
  6. One should note that ints bigger than sys.maxint are possible almost
    seamlessly since Python will use longs for these numbers:

    Python 2.5 (r25:51908, Mar 13 2007, 08:13:14)
    [GCC 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)] on cygwin
    Type "help", "copyright", "credits" or "license" for more information.2085924830053169311564321191305931199741711560688200050463950578047164169337729650765802242049L

    Of course performance decreases for longer longs.
     
    Michael Hoffman, Apr 17, 2007
    #6
  7. tom

    mensanator Guest

    Sure, they're important, we just don't want to notice them. That's why
    conversion to longs is automatic, so that number size limits don't
    cause problems and your problems are solved rather than throw
    exceptions or produce invalid results.
     
    mensanator, Apr 17, 2007
    #7
  8. I once made a thing that tried to find the limit of longs and stopped
    when I had two or three screenfulls of numbers.

    I came to the conclusion that for "integer" arithmetic like this,
    the limit is either your memory size, or some other number
    that is so big that in practice you don't have to worry about it..

    - Hendrik
     
    Hendrik van Rooyen, Apr 18, 2007
    #8
  9. You should find that converting longs to strings (say, for printing them)
    is *very* slow. E.g. the following code

    big = 10L**100 # one google, a big number
    while True:
    print big # so we can see the last value before it fails
    big *= 10

    will run terribly slow and should be written as:

    big = 10L**100 # one google, a big number
    try:
    while True:
    big *= 10
    except: # don't know what exception will be raised, so catch ANYTHING
    print len(str(big))-1 # the number of digits

    only does the slow conversion to string once, instead of every time around
    the loop. However, once your machine starts paging, it will still slow
    down a lot.



    Yes, longs are limited only by the amount of memory accessible.
     
    Steven D'Aprano, Apr 18, 2007
    #9
  10. tom

    mensanator Guest

    But there may be other limitations even if you have the memory.

    For example, this test is limited to generation 10
    because tne 11th generation produces "outrageous
    exponent" error. Here, every 9th 1st generation,
    starting from the fifth is a second generation, every
    9th sencond, starting from the fifth, is a 3rd generation,
    every 9th 3rd gen, starting from the 5th is a 4th gen, etc.

    Closed form: Type12MH(k,i)
    Find ith, kth Generation Type [1,2] Mersenne Hailstone
    using the closed form equation

    2**(6*((i-1)*9**(k-1)+(9**(k-1)-1)/2+1)-1)-1

    2**5-1 generation: 1
    2**29-1 generation: 2
    2**245-1 generation: 3
    2**2189-1 generation: 4
    2**19685-1 generation: 5
    2**177149-1 generation: 6
    2**1594325-1 generation: 7
    2**14348909-1 generation: 8
    2**129140165-1 generation: 9
    2**1162261469-1 generation:10

    1.797 seconds

    There is never a number too large to worry about.
     
    mensanator, Apr 18, 2007
    #10
    1. Advertisements

Ask a Question

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

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.