# [Numpy-discussion] Random int64 and float64 numbers

Charles R Harris charlesr.harris@gmail....
Thu Nov 5 20:23:01 CST 2009

```On Thu, Nov 5, 2009 at 7:04 PM, <josef.pktd@gmail.com> wrote:

> On Thu, Nov 5, 2009 at 6:36 PM, Charles R Harris
> <charlesr.harris@gmail.com> wrote:
> >
> >
> > On Thu, Nov 5, 2009 at 4:26 PM, David Warde-Farley <dwf@cs.toronto.edu>
> > wrote:
> >>
> >> On 5-Nov-09, at 4:54 PM, David Goldsmith wrote:
> >>
> >> > Interesting thread, which leaves me wondering two things: is it
> >> > documented
> >> > somewhere (e.g., at the IEEE site) precisely how many *decimal*
> >> > mantissae
> >> > are representable using the 64-bit IEEE standard for float
> >> > representation
> >> > (if that makes sense);
> >>
> >> IEEE-754 says nothing about decimal representations aside from how to
> >> round when converting to and from strings. You have to provide/accept
> >> *at least* 9 decimal digits in the significand for single-precision
> >> and 17 for double-precision (section 5.6). AFAIK implementations will
> >> vary in how they handle cases where a binary significand would yield
> >> more digits than that.
> >>
> >
> > I believe that was the argument for the extended precision formats. The
> > givien number of decimal digits is sufficient to recover the same float
> that
> > produced them if a slightly higher precision is used in the conversion.
> >
> > Chuck
>
> >From the discussion for the floating point representation, it seems that
> a uniform random number generator would have a very coarse grid
> in the range for example -1e30 to +1e30 compared to interval -0.5,0.5.
>
> How many points can be represented by a float in [-0.5,0.5] compared
> to [1e30, 1e30+1.]?
> If I interpret this correctly, then there are as many floating point
> numbers
> in [0,1] as in [1,inf), or am I misinterpreting this.
>
> So how does a PRNG handle a huge interval of uniform numbers?
>
>
There are several implementations, but the ones I'm familiar with reduce to
scaling. If the rng produces random unsigned integers, then the range of
integers is scaled to the interval [0,1). The variations involve explicit
scaling (portable) or bit twiddling of the IEEE formats. In straight forward
scaling some ranges of the random integers may not map 1-1, so the unused
bits are masked off first; if you want doubles you only need 52 bits, etc.
For bit twiddling there is an implicit 1 in the mantissa, so the basic range
works out to [1,2), but that can be fixed by subtracting 1 from the result.
Handling larger ranges than [0,1) just involves another scaling.

Chuck
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://mail.scipy.org/pipermail/numpy-discussion/attachments/20091105/7f498a27/attachment.html
```