如何生成与比例无关的随机浮点数？

Question

I want to generate what I'm choosing to call "arbitrary" positive floating-point numbers; that is, random numbers which are independent of scale (in other words, numbers whose logarithms are uniformly distributed). I'm not much of a mathematician, so for all I know there may be another name for what I'm after.

Here's my initial, naïve solution:

import sys
import random

def arbitrary(min=sys.float_info.min_10_exp, max=sys.float_info.max_10_exp):
    return 10 ** random.uniform(min, max)

It strikes me that this is probably not ideal: for one thing, I imagine that there might be some interaction between the limited precision of random.uniform() and the floating point representation itself that would cause bunching and gaps in the expected output at higher orders of magnitude.

Is there a better approach? Would it make more sense to just produce a string of random bits and then turn that into the floating point number they represent?

EDIT : As pointed out by Oli Charlesworth in the comments, the "convert random bits to a float" idea doesn't do what I want (which is a uniform distribution of log(n)).

Answer 1

You are correct that your approach doesn't return some numbers. For example, there is no floating-point number between 1.0 and 1.0000000000000002 , but 10**1.0000000000000002 is 10.000000000000005 , and there are two numbers between 10.0 and 10.000000000000005 : 10.000000000000002 and 10.000000000000004 . Those two numbers will never be returned by your algorithm.

But you can cheat and use Decimal to exponentiate with greater precision:

>>> float(10 ** Decimal('1'))
10.0
>>> float(10 ** Decimal('1.0000000000000001'))
10.000000000000002
>>> float(10 ** Decimal('1.00000000000000015'))
10.000000000000004
>>> float(10 ** Decimal('1.0000000000000002'))
10.000000000000005

So, arbitrary needs to generate random Decimal exponents of sufficient precision and use them as exponents. Assuming 64 binary digits is enough precision for the exponent, the code would look like this:

import sys, random
from decimal import Decimal

def _random_decimal(minval, maxval, added_prec):
    # generate a Decimal in the range [minval, maxval) with the
    # precision of additional ADDED_PREC binary digits
    rangelen = maxval - minval
    denom = rangelen << added_prec
    return minval + Decimal(rangelen) * random.randrange(denom) / denom

def arbitrary():
    min_exp = sys.float_info.min_exp - sys.float_info.mant_dig
    max_exp = sys.float_info.max_exp
    return float(2 ** _random_decimal(min_exp, max_exp, 64))