CODEWITHSUNDEEP
pythonrandom
user3550811
user3550811

Reputation: 103

Random number function python that includes 1?

I am new to Python and am trying to create a program for a project- firstly, I need to generate a point between the numbers 0-1.0, including 0 and 1.0 ([0, 1.0]). I searched the python library for functions (https://docs.python.org/2/library/random.html) and I found this function: 

random.random()

This will return the next random floating point number in the range [0.0, 1.0). This is a problem, since it does not include 1. Although the chances of actually generating a 1 are very slim anyway, it is still important because this is a scientific program that will be used in a larger data collection.

I also found this function:

rand.randint

This will return an integer, which is also a problem.

I researched on the website and previously asked questions and found that this function:

random.uniform(a, b)

will only return a number that is greater than or equal to a and less than b.

Does anyone know how to create a random function on python that will include [0, 1.0]?

Please correct me if I was mistaken on any of this information. Thank you.

*The random numbers represent the x value of a three dimensional point on a sphere.

Upvotes: 9

Views: 8387

Answers (7)

myradio
myradio

Reputation: 1775

2023: numpy.random.uniform does the job.

numpy.random.uniform(low=0.0, high=1.0, size=None)

Includes both, low and high.

Upvotes: 0

Moh Zulkifli Katili
Moh Zulkifli Katili

Reputation: 1

I've had the same problem, this should help you. a: upper limit, b: lower limit, and digit: digit after comma

def konv_des (bin,a,b,l,digit):
    des=int(bin,2)
    return round(a+(des*(b-a)/((2**l)-1)),digit)

def rand_bin(p):
    key1 = ""
    for i in range(p):
        temp = str(random.randint(0, 1))
        key1 += temp
    return(key1)

def rand_chrom(a,b,digit):
    l = 1
    eq=False
    while eq==False:
        l += 1
        eq=2**(l-1) < (b-a)*(10**digit) and (b-a)*(10**digit) <= (2**l)-1
    return konv_des(rand_bin(l),a,b,l,digit)

#run
rand_chrom(0,1,4)

Upvotes: 0

&#211;scar L&#243;pez
&#211;scar L&#243;pez

Reputation: 236004

Try this:

import random
random.uniform(0.0, 1.0)

Which will, according to the documentation [Python 3.x]:

Return a random floating point number N such that a <= N <= b for a <= b and b <= N <= a for b < a.

Notice that the above paragraph states that b is in fact included in the range of possible values returned by the function. However, beware of the second part (emphasis mine):

The end-point value b may or may not be included in the range depending on floating-point rounding in the equation a + (b-a) * random().

Upvotes: 3

merlin2011
merlin2011

Reputation: 75545

Consider the following function built on top of random.uniform. I believe that the re-sampling approach should cause all numbers in the desired interval to appear with equal probability, because the probability of returning candidate > b is 0, and originally all numbers should be equally likely.

import sys
import random


def myRandom(a, b):
    candidate = uniform.random(a, b + sys.float_info.epsilon)
    while candidate > b:
       candidate = uniform.random(a, b + sys.float_info.epsilon)
    return candidate

As gnibbler mentioned below, for the general case, it may make more sense to change both the calls to the following. Note that this will only work correctly if b > 0.

 candidate = uniform.random(a, b*1.000001)

Upvotes: 4

GoofyBall
GoofyBall

Reputation: 411

For floating point numbers you can use numpy's machine limits for floats class to get the smallest possible value for 64bit or 32bit floating point numbers. In theory, you should be able to add this value to b in random.uniform(a, b) making 1 inclusive in your generator:

import numpy
import random

def randomDoublePrecision():
    floatinfo = numpy.finfo(float)
    epsilon = floatinfo.eps
    a = random.uniform(0, 1 + eps)
    return a

This assumes that you are using full precision floating point numbers for your number generator. For more info read this Wikipedia article.

Upvotes: 1

icedtrees
icedtrees

Reputation: 6466

Could you make do with something like this?

random.randint(0, 1000) / 1000.0

Or more formally:

precision = 3
randomNumber = random.randint(0, 10 ** precision) / float(10 ** precision)

Upvotes: 7

CT Zhu
CT Zhu

Reputation: 54330

Would it be just:

list_rnd=[random.random() for i in range(_number_of_numbers_you_want)]
list_rnd=[item/max(list_rnd) for item in list_rnd]

Generate a list of random numbers and divide it by its max value. The resulting list still flows uniform distribution.

Upvotes: 0

Related Questions