471,086 Members | 1,188 Online
Bytes | Software Development & Data Engineering Community
Post +

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 471,086 software developers and data experts.

The smallest and largest values of numeric types

tom
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.
Apr 17 '07 #1
9 2948
In article <QA**************@read3.inet.fi>, to*@finland.com wrote:
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.
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.
Apr 17 '07 #2
Lou Pecora wrote:
In article <QA**************@read3.inet.fi>, to*@finland.com wrote:
>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.

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.
I'm surprised they also didn't turn up my replies to those questions.
Does anyone know where this package is? Or what might replace it. It
is very useful.
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

Apr 17 '07 #3
On Apr 17, 7:12 am, t...@finland.com wrote:
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.
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/br...dapters.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
fu******@amor.org

Apr 17 '07 #4
tom
Thank you for your answers. Seems like the limits of numeric values
aren't considered as important in Python as in C ;)
Apr 17 '07 #5
fumanchu wrote:
On Apr 17, 7:12 am, t...@finland.com wrote:
>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.

This should work for ints:

import sys
print sys.maxint
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.
>>import sys
sys.maxint
2147483647
>>sys.maxint+1
2147483648L
>>sys.maxint*2
4294967294L
>>sys.maxint**10
20859248300531693115643211913059311997417115606882 00050463950578047164169337729650765802242049L

Of course performance decreases for longer longs.
--
Michael Hoffman
Apr 17 '07 #6
On Apr 17, 11:37 am, t...@finland.com wrote:
Thank you for your answers. Seems like the limits of numeric values
aren't considered as important in Python as in C ;)
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.

Apr 17 '07 #7

"Michael Hoffman" <ca*******@mh391.invalidwrote:
>
20859248300531693115643211913059311997417115606882 000504639505780471641693377296
50765802242049L
>
Of course performance decreases for longer longs.
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

Apr 18 '07 #8
On Wed, 18 Apr 2007 07:15:11 +0200, Hendrik van Rooyen wrote:
I once made a thing that tried to find the limit of longs and stopped
when I had two or three screenfulls of numbers.
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.

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..
Yes, longs are limited only by the amount of memory accessible.
--
Steven D'Aprano

Apr 18 '07 #9
On Apr 18, 3:09´┐Żam, Steven D'Aprano <s...@REMOVEME.cybersource.com.au>
wrote:
On Wed, 18 Apr 2007 07:15:11 +0200, Hendrik van Rooyen wrote:
I once made a thing that tried to find the limit of longs and stopped
when I had two or three screenfulls of numbers.

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.
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..

Yes, longs are limited only by the amount of memory accessible.
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.
>
--
Steven D'Aprano

Apr 18 '07 #10

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

2 posts views Thread by Keke922 | last post: by
3 posts views Thread by success_ny | last post: by
13 posts views Thread by Peter Ammon | last post: by
90 posts views Thread by John Salerno | last post: by

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.