C'est la première fois que j'écris un générateur de nombres aléatoires et je ne faisais que déconner pour voir ce que je peux faire avec des formules aléatoires.

Je suis cependant curieux de savoir à quel point ma fonction est biaisée et avec la distribution de la fonction (entre 1 et 9). Voici mon code inutilement long:

import time

class Random:
    """random generator"""

    def __init__(self):
        """ Random()-> create a random number generator with a random seed
        a seed is needed in order to generate random numbers"""
        self.seed = time.time()

    def random(self):
        """ Random.random() -> get a random number using a formula"""
        self.seed =(((int(self.seed)*129381249123+2019383)**0.74123)/517247) % 288371

    def get_ran_num(self):
        """ Random.get_ran_num() -> return a random integer from 1 thru 10"""
        self.random()
        return int(list(str(int(self.seed)))[3])


ranNum = Random()

Ce serait formidable s'il existe des outils qui peuvent prendre une fonction aléatoire, puis l'exécuter plusieurs milliers de fois, puis en représenter graphiquement la distribution.

Merci d'avance

P / s: Comment puis-je améliorer mon RNG et le rendre encore plus aléatoire?

0
Tri Nguyen 8 mars 2016 à 04:17

3 réponses

Meilleure réponse

Si vous voulez juste une représentation visuelle, vous pouvez facilement utiliser

import matplotlib.pyplot as plt
# Random class here
ranNum = Random()
randNums = [ranNum.get_ran_num() for _ in range(100)]
nums = list(range(len(randNums)))
plt.plot(nums, randNums, 'ro')
plt.show()

Le voici pour 100 nombres aléatoires: https://i.gyazo.com/bd3f11fb80de18797dc888138d5e5113.png

Cependant, j'obtiens un IndexError lorsque je passe à des plages plus élevées. Vous devriez probablement corriger l'algorithme réel pour tout ce qui cause ce problème, mais la façon dont j'ai mis un pansement était:

def get_ran_num(self):
    """ Random.get_ran_num() -> return a random integer from 1 thru 10"""
    retval = None
    while True:
        try:
            self.random()
            retval = int(list(str(int(self.seed)))[3])
            break
        except IndexError as e:
            continue
    return retval

Voici un tracé pour 100 000 nombres aléatoires, ce qui est plutôt bien. Ce que vous recherchez, ce sont des lignes contiguës où aucune n'est sensiblement plus dense que les autres, mais vous devrez faire une bien meilleure analyse d'entropie pour découvrir quelque chose de plus utile qu'une représentation visuelle rapide. Dans votre cas, il semble que 6 soit un peu plus préféré. De plus, il semble qu'il se répète assez souvent.

enter image description here

1
Goodies 8 mars 2016 à 01:42

Je préférerais un tracé d'histogramme pour vérifier l'uniformité de la distribution de votre générateur de nombres aléatoires.

import numpy as np
import matplotlib
import matplotlib.pyplot as plt 
myarr = np.random.randint(1000, size=100000)
plt.hist(myarr, bins=40)
plt.show()

enter image description here

0
Pari Rajaram 1 juil. 2017 à 20:02

J'essaierais random.rand et matplotlib.

import numpy as np
import matplotlib.pyplot as plt


N = 50
x = np.random.rand(N)
y = np.random.rand(N)
colors = np.random.rand(N)
area = np.pi * (15 * np.random.rand(N))**2  # 0 to 15 point radiuses

plt.scatter(x, y, s=area, c=colors, alpha=0.5)
plt.show()

Quelque chose comme ça?

Edit: essayez-vous de générer un nombre pseudo aléatoire? De toute façon, vous auriez besoin d'une graine pour le registre à décalage, donc à cet égard, je ne sais pas si ce serait complètement aléatoire.

1
YouHaveaBigEgo 8 mars 2016 à 01:35