Python Generate Non Uniform Randint

Question

If I use python random's randint function, I seem to be getting a uniform distribution as below.

How do I make this a non-uniform randint?

EDIT: I have realised that what I am asking for is not possible. I either have a fixed bias, or my function ends up in a uniform distribution. Thank you for your time.

I do not care about specifying a specific range like this: Generate random numbers with a given (numerical) distribution (numpy.random.choice/ random.choice), the answer can have any distribution over the range.

Thank you for your time.

Eg:

#Counter({2: 10760, 6: 190364, 4: 40092, 0: 160068, 7: 99936, 3: 99885, 8: 99845, 9: 99725, 5: 99675, 1: 99650})

Current Example Code:

from collections import Counter
from random import randint
list_size=1000000
random_list=list(sorted([randint(0,9) for x in range(list_size)]))
Counter(random_list)
#Counter({2: 100760, 6: 100364, 4: 100092, 0: 100068, 7: 99936, 3: 99885, 8: 99845, 9: 99725, 5: 99675, 1: 99650})

Things I have tried:

def really_random(start,stop):
    random_array_size=random.randint(3,10)
    random_array_choice=random.randint(0,random_array_size-1)
    random_value=[random.randint(start,stop) for x in range(random_array_size)][random_array_choice]
    return random_value

def really_random_test(start,stop):
    list_size = 100000
    random_list = list(sorted([really_random(start, stop) for x in range(list_size)]))
    print(Counter(random_list))

still pretty uniform

#Counter({7: 10094, 9: 10066, 3: 10044, 1: 10027, 5: 10012, 8: 10012, 0: 10009, 6: 9985, 2: 9878, 4: 9873})

Answer 1

You seem to be under the impression that if the distribution of the random numbers is uniform, that makes them "not random". This isn't true - the real requirement for the randomness of a generated number is that you can't predict it. Note this helpful sentence from the Wikipedia article on randomness:

Individual random events are by definition unpredictable, but since they often follow a probability distribution, the frequency of different outcomes over numerous events (or "trials") is predictable.

Knowing that "out of x entries, each entry occurs nearly 1/x times" does not help you predict what the next random number will be. Imagine rolling a fair die many, many times. The more times you roll it, the more uniform the distribution of results will look. But this doesn't mean the die is somehow less random.

Python's random number generator could have used any distribution, and still have been just as "random". But usually, for programming purposes, it's very helpful to know that each result is equally likely (i.e. that you're rolling a fair die and not a weighted one). So what I'm trying to say is - the randint function is almost definitely the right tool for your purposes.

Answer 2

If you generate uniform random numbers and then, say, square them, the results will be random yet not uniform. So, what is it you want?

Answer 3

I suppose, you want to generate numbers that are really random (actually pseudo-random). If so, to my knowledge there is three types of generators to do that:

• Algorithmic generators (Stochastic simulation - Monte Carlo).
• Algorithmic generators + physical mechanisms (lotteries, casino machines, etc.).
• Non-linear algorithmic generators with random parameters (cryptology).

I have already implemented algorithmic generators (the easiest to implemented) with linear congruence (More on this link) in a system simulation project.

class PseudoRandomNumberGenerator:
    """Pseudo random number generator with linear congruence"""
    
    def __init__(self, seed: int, multiplier: int, shift: int, modulus: int):
        self.seed = seed
        self.multiplier = multiplier
        self.shift = shift
        self.modulus = modulus
        
    def next(self, a: int, b: int):
        """Get the next random number within range [a, b["""
        self.seed = (self.multiplier * self.seed + self.shift) % self.modulus
        
        # Make projection of generated number on the interval [a, b[
        slope = (b - a) / (self.modulus - 1)
        
        return int(self.seed * slope + a)

The choice of the seed, multiplier, shift and modulus have to be well since these parameters determine the size of one cycle. The longer the cycle, the more robust the generator.

You can try these parameters: seed=53123027, multiplier=1664525, shift=1013904223, modulus=2**32. Or you can simply search in the litterature.