Generación de números uniformes

01 · Punto de partida

El generador escupe enteros, vos querés decimales

Todo generador de los Temas 12 a 18 entrega enteros: un LCG da 0 … m−1, un xorshift32 da 0 … 2³²−1. Pero la simulación habla en probabilidades, proporciones y si u < p: necesita decimales en [0,1) con densidad pareja. El puente es una división, y si la hacés mal introducís el primer sesgo de tu simulación.

Este tema cierra esa brecha: la receta canónica u = x / m, qué valores puede tomar realmente y por qué el 1 queda afuera.

• ¿Por qué se divide por m y no por m−1?
• ¿Cuántos decimales distintos puede dar un generador con módulo m?
• ¿Puede salir exactamente 0 o exactamente 1?
• ¿Por qué un double necesita 53 bits y no 32?

02 · Definición

U(0,1): pareja y sin bordes tramposos

03 · Precisión real

32 bits no llenan un double

Un float64 guarda 53 bits de mantisa: puede distinguir múltiplos de 2⁻⁵³ ≈ 1,1e−16. Un solo uint32 solo distingue múltiplos de 2⁻³² ≈ 2,3e−10: deja 2²¹ “huecos” vacíos entre cada par de valores. Por eso las librerías serias combinan dos enteros de 32 bits en uno de 53.

53 bits (CPython / NumPy)

u = (a·2²⁷ + b·2⁻²⁶…) / 2⁵³: con a de 27 bits y b de 26 bits se cubre toda la mantisa del double.

División entera accidental

En Python 2 o en C con enteros, x / m trunca a 0. Forzar flotante: x / float(m) o x / m en Python 3.

El 0 exacto

u = 0 sale con prob. 1/m: métodos como -log(u) deben mapearlo a (0,1] con 1−u (Tema 20).

04 · Ejemplos

Del módulo al decimal

1. 1
   LCG m = 16.

   Solo 16 decimales: 0, 0,0625, 0,125, …, 0,9375. Ideal para ver los “escalones” en el laboratorio.

2. 2
   xorshift32 / MT.

   u = x / 2**32: 4294967296 puntos, escalón 2,3e−10. A ojo, continuo.

3. 3
   Double de 53 bits.

   CPython combina 27 + 26 bits: escalón 1,1e−16, toda la mantisa cubierta sin huecos.

05 · Implementación en Python

Normalizar sin sesgo

Tomamos el LCG didáctico (a=5, c=3, m=16) y lo convertimos: mirá cómo los 16 valores se repiten cíclicamente y nunca tocan el 1.

def lcg_uniformes(semilla, n=16, a=5, c=3, m=16):
    x = semilla % m
    sal = []
    for _ in range(n):
        x = (a * x + c) % m
        sal.append(x / m)
    return sal


us = lcg_uniformes(7)
print([round(u, 4) for u in us])
print("min:", min(us), "max:", max(us), "distintos:", len(set(us)))

16 valores distintos como máximo, entre 0 y 0,9375. El 1 no aparece jamás: eso es [0,1).

53 bits como CPython

import random

# un uint32 solo llena 32 de los 53 bits del double
x32 = random.getrandbits(32) / 2**32
# receta real de CPython: 27 + 26 bits
a = random.getrandbits(27)
b = random.getrandbits(26)
u53 = (a * 67108864 + b) / 9007199254740992
print(round(x32, 12), round(u53, 12))
print("escalon 32 bits:", 2**-32, "escalon 53 bits:", 2**-53)

06 · Exploración

Laboratorio: la resolución se ve

Elegí el módulo del LCG testigo y la cantidad de valores. La curva es u(n); con m chico verás bandas discretas (solo m alturas posibles). El panel mide resolución 1/m, distintos y si aparece el 1.

Con m = 16 la cuadrícula es evidente; con m = 65536 parece continua, pero sigue siendo discreta con paso 1/65536.

Preguntas para explorar

1. Con m = 16 y N = 240: ¿cuántos distintos hay como máximo? ¿Qué pasa al pedir más valores que el módulo?
2. ¿Alguna configuración llega a u = 1? ¿Y a u = 0?
3. Si tu regla es “aprobar con u < 0,001”, ¿qué módulos la hacen imposible o dentada?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: el rango prometido

Generá 2000 uniformes del LCG m = 16 normalizado y verificá que están en [0,1): mínimo ≥ 0, máximo < 1.

def lcg_u(semilla, n, a=5, c=3, m=16):
    x = semilla % m
    for _ in range(n):
        x = (a * x + c) % m
        yield x / m


us = list(lcg_u(7, 2000))
print(min(us), max(us), all(0 <= u < 1 for u in us))

Ejercicio 2: contar la resolución

¿Cuántos valores distintos puede dar x / 256? Comprobalo generando 5000 y contando el conjunto.

def lcg_u256(semilla, n):
    x = semilla % 256
    for _ in range(n):
        x = (1103515245 * x + 12345) % 256
        yield x / 256


print(len(set(lcg_u256(1, 5000))))

Ejercicio 3: el 0 que rompe el log

Forzá u = 0 con semilla adecuada y mostrá que 1−u lo rescata para -log(u).

import math

# con m=16, semilla 5 da x=0 en el primer paso: u=0
x = (5 * 5 + 3) % 16
u = x / 16
print("u:", u)
print("1-u:", 1 - u, "-log(1-u):", round(-math.log(1 - u), 6))

09 · Síntesis

Ideas para recordar

En el próximo tema haremos zoom en el borde: la transformación al intervalo [0,1), el 0 exacto y el mapeo a (0,1].