UNIVERSIDAD CENTRAL DEL ECUADOR

FACULTAD DE CIENCIAS FÍSICAS Y MATEMÁTICA

CARRERA DE INGENIERÍA INFORMÁTICA

TEMA: GENERADOR DE NUMEROS SEUDOALEATORIOS CON

EL MÉTODO MULTIPLICATIVO CON PRUEBAS ESTADISTICA

ESTUDIANTES: ERICK LITA

MICHAEL SALAZAR
YANDRY TORRES

DOCENTE: MAT. JORGE ARROBA

MATERIA: SIMULACIÓN Y TEORÍA DE COLAS

Contenido
Introducción ........................................................................................................ 3

Objetivo general.............................................................................................. 4

Objetivos específicos ...................................................................................... 4

Marco teórico...................................................................................................... 4

Generación de números seudoaleatorios ....................................................... 4

Métodos Congruenciales ................................................................................ 5

Método Congruencial Lineal........................................................................ 5

Método Congruencial Multiplicativo ............................................................. 5

Comprobación de aleatoriedad ....................................................................... 6

Test de Corridas ............................................................................................. 7

Desarrollo .................................................................................................... 7

Ejemplo ....................................................................................................... 8

Test de Kolmogorov–Smirnov......................................................................... 9

Desarrollo .................................................................................................. 10

Implementación ................................................................................................ 11

Recomendaciones............................................................................................ 14

Conclusiones .................................................................................................... 15

Bibliografía ....................................................................................................... 16

2
 INTRODUCCIÓN
El presente documento abarca el tema de la generación de números aleatorios
el cual es fundamental en la catedra de simulación de sistemas y teoría de colas,
cabe recalcar que para la simulación se requiere números seudoaleatorios en un
intervalo de (0, 1) es decir, una secuencia o sucesión de números que contenga
n números, todos ellos diferentes, n recibe el nombre del periodo o ciclo de vida
del generador que creó la secuencia.

Es importante mencionar que el conjunto de números seudoaleatorios debe ser

lo suficientemente grande, además que este conjunto de números será sometido
a diferentes pruebas para verificar que cumpla con las propiedades de los
números aleatorios, una vez comprobada su validez se tomara la decisión de
utilizar dichos números o simplemente desecharlos.

La generación de números seudoaleatorios resulta una actividad relativamente

sencilla ya que solo se necesitará diseñar un algoritmo de generación, lo
complejo en este proceso es que el conjunto de números contenga un periodo o
ciclo de vida amplio y a su vez logre pasar las diferentes pruebas que se tiene
pensado aplicar.

Actualmente estos números se generan mediante computadores y se los

denominan seudoaleatorios pues todos los números de la sucesión se generan
con predecibles a partir de un primer número llamado semilla, con la cual dicha
muestra de números seudoaleatorios para que sea mínimamente aceptable
debe comportarse como si se tratara de una muestra genuina de datos
independientes U (0,1).

A continuación, vamos a exponer el desarrollo de la aplicación que genera

números seudoaleatorios con uno del método de congruenciales visto en clase
el cual se denomina Método Multiplicativo, esta aplicación la vamos a desarrollar
en Java con el IDE NetBeans versión 8.1, además vamos a utilizar librerías
especializadas en modelos estadístico que nos va a permite de fácil
implementación a la hora de utilizar fórmulas matemáticas.

3
Objetivo general

Generar números seudoaleatorios mediante código fuente e implementar

pruebas de uniformidad e independencia para determinar si siguen una
distribución uniforme y son independientes entre sí.

Objetivos específicos

- Codificar mediante código de programación (Java) el método

congruencial multiplicativo para la generación de números
seudoaleatorios.
- Realizar la prueba de Kolmogórov-Smirnov (KS) y la prueba de Corridas
o Run Tes para comprobar su distribución e independencia.

MARCO TEÓRICO
A continuación, se detalla los conceptos necesarios que serán fundamentales al
momento de realizar el diseño y la implementación de la aplicación.

Generación de números seudoaleatorios

Según (Computación, Dpto, 2010) indica:

Casi todos los métodos de simulación se basan en la posibilidad de crear

números aleatorios con distribución U (0,1). Hasta la aparición de las
computadoras, los números aleatorios se obtenías de procedimientos
experimentales como lotería o ruleta y se almacenaban en tablas.

Los números generados por computadora se llaman números

seudoaleatorios, dado que son predecibles a partir del primer número
denominado semilla. (p.2)

Para poder utilizar un generador automático de números seudoaleatorios,

este debe cumplir con ciertas propiedades:

• Producir muestras según la distribución U (0,1)

• Pasar los contrastes de aleatoriedad e independencia más habituales
• Que la sucesión generada sea producible a partir de la semilla
• Tener una longitud de ciclo tan grande como se desee

4
 • Generar valores a alta velocidad

Métodos Congruenciales

Método Congruencial Lineal

El generador congruencial lineal fue propuesto por D.H. Lehmer en 1940 y
consiste en, a partir de un número inicial llamado semilla, generar la secuencia
por recurrencia según el esquema:

𝑋𝑛+1 = (𝑎𝑋𝑛 + 𝑐)𝑚𝑜𝑑 𝑚

𝑒𝑛 𝑑𝑜𝑛𝑑𝑒
𝑎, 𝑒𝑠 𝑚𝑢𝑙𝑡𝑖𝑝𝑙𝑖𝑐𝑎𝑑𝑜𝑟 (0 ≤ 𝑎 < 𝑚)
𝑚, 𝑒𝑙 𝑚𝑜𝑑𝑢𝑙𝑜 (𝑚 > 0)
𝑐, 𝑒𝑙 𝑖𝑛𝑐𝑟𝑒𝑚𝑒𝑛𝑡𝑜 (0 ≤ 𝑐 < 𝑚)
𝑋0 , 𝑙𝑎 𝑠𝑒𝑚𝑖𝑙𝑙𝑎 (0 < 𝑋0 < 𝑚)

Método Congruencial Multiplicativo

Este método es un caso particular de los lineales cuando c = 0, entonces la
ecuación recursiva es:

𝑋𝑖+1 = 𝑎𝑋𝑖 𝑚𝑜𝑑(𝑛); 𝑐𝑜𝑛 𝑖 = 0,1,2,3, … . 𝑛

En comparación con el algoritmo congruencial lineal, la ventaja del algoritmo

multiplicativo es que implica una operación menos a realizar. Los parámetros de
arranque de este algoritmo son

X 0, a y m, los cuales deben ser enteros y mayores que cero. Para transformar
los números X i en el intervalo (0, 1) se usa la ecuación:

𝑋𝑖
𝑟𝑖 = ; con 𝑖 = 0,1, 2, 3, . . . , 𝑛
𝑚−1

De acuerdo con Banks, Carson, Nelson y Nicol, las condiciones que deben
cumplir los parámetros para que el algoritmo congruencial multiplicativo alcance
su máximo período son: m debe ser múltiplo de 2g, donde g debe ser entero, a=

5
3+8k, donde k = 0,1, 2, 3,…, X 0 debe ser un número impar. (Salmerón Cerdán
& Morales Giraldo, 2001)

Bajo estas condiciones se logra un período de vida máximo: N = k /4 = 2g−2.

Corolario 1.7. Un generador congruencial multiplicativo no puede tener periodo

completo.

Es evidente que es necesario que m sea grande con el fin de un periodo largo
y una alta densidad en el intervalo [0,1]. Sin embargo, la operación de dividir
por m y calcular el resto es relativamente lenta. Una elección de m adecuada
computacionalmente es m = 2k, donde k-bits es el tamaño de palabra (unidad
básica de trabajo) del microprocesador. El hecho de que esta elección sea
ventajosa reside en que nos podemos aprovechar del desbordamiento de
datos (integer overflow) para no tener que realizar la operación del generador
explícitamente. La cuestión es que si tenemos una máquina de k-bits,
entonces el mayor entero que puede ser representado es 2 k − 1 y en cualquier
intento de representar un entero mayor H, que ocuparía h > k dígitos binarios,
se perderían los h − k dígitos binarios más a la izquierda, y los k dígitos que
quedan se corresponden precisamente con H mod 2k.

Corolario 1.9. Un generador congruencial con m = 2k ≥ 4 tiene periodo completo

si y sólo si b es impar y 1 = a mod 4.

Los generadores multiplicativos tienen la ventaja computacional de que no es

necesario la suma de la constante b, pero, como hemos visto, no pueden tener
periodo completo. Afortunadamente, es posible obtener periodo m − 1 si m y
a se eligen adecuadamente. Los generadores multiplicativos se introdujeron
antes que los mixtos, han sido objeto de más estudio y actualmente se utilizan
más que los mixtos. (Salmerón Cerdán & Morales Giraldo, 2001)

Comprobación de aleatoriedad

En esta sección revisaremos algunos contrastes empíricos para analizar la

aleatoriedad de una secuencia de datos, procedente de un método propuesto
anteriormente. En ese sentido, las pruebas que mencionaremos a continuación

6
son las que vamos a implementar al final en nuestra aplicación y deben
contrastar tanto la uniformidad como la independencia de los datos, además en
todos los casos utilizaremos pruebas bilaterales, en el sentido en que
rechazaremos la hipótesis de aleatoriedad tanto si los datos se alejan
notoriamente de la aleatoriedad y en cuanto a la uniformidad e independencia,
como se acercan demasiado a ella.

Test de Corridas

Una corrida es una sucesión de letras idénticas (u otras clases de elementos)

seguida o precedida por letras diferentes o ninguna letra en absoluto. Para
ilustrar esto, considere la siguiente disposición de olmos saludables, H, y
enfermos, D, plantados hace muchos años a lo largo de una carretera:

HHHHDDDHHHHHHHDDHHDDDD

Usando el subrayado para combinar las letras que constituye las corridas,
encontramos que primero hay una corrida de cuatro H´s, luego una corrida de
tres D´s luego una corrida de siete H´s después una corrida de dos D´s, después
de dos H´s y por último una corrida de cuatro D´s.

El número total de corridas que aparece en una disposición de esta clase a

menudo es un buen indicio de una posible falta de azar. Si hay muy pocas
corridas podríamos sospechar que hay una agrupación o un conglomerado, o
quizá una tendencia; si hay muchas corridas, podríamos sospechar que hay
cierto patrón alternativo o cíclico.

Desarrollo
El método llamado prueba de corridas arriba y debajo de la media consiste en lo
siguiente:

- Denotaremos con un número (1) a aquel número que se encuentre por

debajo de la media.
- Denotaremos con un número (0) a aquel número que se encuentre por
arriba de la media.

Este procedimiento consiste en determinar una secuencia de unos y ceros de

acuerdo con la comparación de cada número que cumpla con la condición de

7
ser mayor o igual a 0.5 (en el caso de los ceros) o ser menor a 0.5 (en el caso
de los unos)

Luego se determina el número de corridas y los valores de n1 y n2.

Valores que se emplean

𝐶0 = 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑐𝑜𝑟𝑟𝑖𝑑𝑎𝑠 𝑒𝑛 𝑙𝑎𝑠 𝑠𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎

𝑛0 = 𝑐𝑎𝑛𝑡𝑖𝑑𝑎𝑑 𝑑𝑒 𝑐𝑒𝑟𝑜𝑠 𝑒𝑛 𝑙𝑎 𝑠𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎 𝑆
𝑛1 = 𝑐𝑎𝑛𝑡𝑖𝑑𝑎𝑑 𝑑𝑒 𝑢𝑛𝑜𝑠 𝑒𝑛 𝑙𝑎 𝑠𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎 𝑆
𝑁 = 𝑐𝑎𝑛𝑡𝑖𝑑𝑎𝑑 𝑑𝑒 𝑛𝑢𝑚𝑒𝑟𝑜𝑠, 𝑠𝑒 ℎ𝑎𝑙𝑙𝑎 𝑑𝑒 𝑙𝑎 𝑠𝑖𝑔𝑢𝑖𝑒𝑛𝑡𝑒 𝑚𝑎𝑛𝑒𝑟𝑎: 𝑛0 + 𝑛1

Posteriormente se calcula el valor esperado, la varianza del número de corridas

y el estadístico con las siguientes ecuaciones:

Valor esperado:

2𝑛0 𝑛1 1
𝜇𝑐0 = +
𝑁 2
Varianza del número de corridas:

2𝑛0 𝑛1 (2𝑛0 𝑛1 − 𝑁)
𝜎 2 𝑐0 =
𝑁 2 (𝑁 − 1)

El estadístico:

𝐶0 − 𝜇𝑐0
𝑧𝑜𝑏𝑠 =
𝜎𝑐0

Para saber si el estadístico de prueba está fuera del intervalo se emplea la

siguiente fórmula:

−𝑧𝛼/2 ≤ 𝑧𝑜𝑏𝑠 ≤ 𝑧𝛼/2

Si la condición anterior se cumple, entonces se concluye que los números

evaluados son independientes, de lo contrario se rechaza al conjunto.

Ejemplo
Determinar si la secuencia de 40 números es tal que la hipótesis de
independencia pueda ser rechazada donde α = 0.05

8
41, 68, 89, 94, 74, 91, 55, 62, 36, 27 19, 72, 75, 9, 54, 2, 1, 36, 16, 28 18, 1, 95,
69, 18, 47, 23, 32, 82, 53 31, 42, 73, 4, 83, 45, 13, 57,63, 29

La secuencia de corridas arriba y debajo es la siguiente:

1000000011
1001011111
1100111100
1101011001

𝐶0 = 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑐𝑜𝑟𝑟𝑖𝑑𝑎𝑠 𝑒𝑛 𝑙𝑎𝑠 𝑠𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎 = 17

𝑛0 = 𝑐𝑎𝑛𝑡𝑖𝑑𝑎𝑑 𝑑𝑒 𝑐𝑒𝑟𝑜𝑠 𝑒𝑛 𝑙𝑎 𝑠𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎 𝑆 = 18
𝑛1 = 𝑐𝑎𝑛𝑡𝑖𝑑𝑎𝑑 𝑑𝑒 𝑢𝑛𝑜𝑠 𝑒𝑛 𝑙𝑎 𝑠𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎 𝑆 = 22
𝑁 = 𝑐𝑎𝑛𝑡𝑖𝑑𝑎𝑑 𝑑𝑒 𝑛ú𝑚𝑒𝑟𝑜𝑠 = 40

A continuación, se determina el estadístico utilizando las ecuaciones propuestas

2𝑛0 𝑛1 1 2(18)(22)
𝜇𝑐0 = + = + 0.5 = 20.3
𝑁 2 40
2𝑛0 𝑛1 (2𝑛0 𝑛1 − 𝑁) 2(18)(22)[2(18)(22) − 40]
𝜎 2 𝑐0 = = = 9.5446
𝑁 2 (𝑁 − 1) 402 (40 − 1)
𝐶0 − 𝜇𝑐0 17 − 20.3
𝑧𝑜𝑏𝑠 = = = −0.345
𝜎𝑐0 9.544
ya que 𝑧0.025 = 1.96, la hipótesis de independencia no puede ser rechazada
sobre la base de esta prueba

𝑍𝑐𝑎𝑙𝑐𝑢𝑙𝑎𝑑𝑎 = −0.345 < 𝑍0.025 = 1.96

Test de Kolmogorov–Smirnov

El procedimiento de Kolmogorov-Smirnov prueba la hipótesis de que la

distribución acumulada de una variable aleatoria x es F0(x). Para probar esta
hipótesis, una muestra de tamaño n es obtenida de una distribución continua
F(x). En seguida, se determina la distribución acumulada de la muestra, la cual
se denota por Fn(x). Posteriormente Fn(x) es comparada con la distribución
acumulada hipotética F0(x). Si Fn(x) difiere demasiado de F0(x), entonces esto es
una amplia evidencia de que Fn(x) no es igual a F0(x).

9
La aplicación de esta prueba al caso de números seudoaleatorios uniformes,
puede ser descrita en los siguientes pasos:

Desarrollo
- Generar una muestra de números aleatorios uniformes de tamaño N.
- Ordenar dichos números en orden ascendente.
- Calcular la distribución acumulada de los números generados con la
siguiente
expresión
𝑖
𝐹𝑛 (𝑥) =
𝑛

Donde 𝑖 es la posición que ocupa el número aleatorio Xi en el vector

ordenado obtenido en el paso 2.

- Calcular el estadístico de prueba Kolmogorov-Smirnov del modo

siguiente:

𝐷𝑛 = 𝑚á𝑥 | 𝐹𝑛 (𝑋𝑖) – 𝑋𝑖 |

Para toda 𝑋𝑖

- Si 𝐷𝑛 es menor 𝑑𝛼 ,𝑛 , entonces no se puede rechazar la hipótesis de

que los números generados provienen de una distribución uniforme
(Test superado). La distribución de 𝐷𝑛 ha sido tabulada como una
función de 𝑛 y α para cuando
𝐹𝑛 (𝑥) = 𝐹0 (𝑥).

10
 IMPLEMENTACIÓN
Para simular los algoritmos expuesto anteriormente, procedemos a generar
números seudoaleatorios a través del método congruencial multiplicativo.
Tenemos las opciones de ingresar la semilla por teclado o también por la
frecuencia del reloj como se presenta a continuación.

Seleccionamos cualquiera de las opciones para ingresar la semilla y se nos

desplegar los campos para ingresar los componentes que necesita el sistema
para generar los números seudoaleatorios

Una vez hemos llenado los campos, damos clic en el botón “Generar” y
dependiendo de la cantidad de números que deseamos generar, se desplegara

11
una tabla en la parte superior derecha con dichos números, además se habilitara
el botón “Test K-S” para realizar la prueba de Kolmogorov-Smirnov requerida.

A continuación, realizamos el Test K-S y si la sucesión de números generados

anteriormente se desplegara el siguiente mensaje seguido de la tabla de
números D+ y D-

12
Una vez pasado la prueba de Kolmogorov-Smirnov se habilitará la prueba de
corridas o Run Test

Para finalizar realizamos la prueba de corridas para comprobar si la sucesión es

independiente o no, en ambos casos se desplegarán los mensajes respectivos
con los resultados

13
Para finalizar si la sucesión de números seudoaleatorios paso con éxito se
desplegara el mensaje “La sucesión generada es Aleatoria” caso contrario se
desplegará el siguiente mensaje.

RECOMENDACIONES
Se recomienda dejar los valores que vienen por defecto en cada variable ya que
con estos valores el periodo es más grande, en cada campo que tenemos que
ingresar los valores deben ser números enteros.

Se debe poner énfasis en buscar una semilla que nos genere una sucesión
uniforme e independiente para comprobar la validez de la ambas pruebas y tener
éxito en dichas pruebas.

Se debe de realizar varias pruebas del sistema hasta verificar que no haya
ninguna caída o que caiga en un bucle infinito del cual se llegue a colgar, además
se debe tener cuidado al momento de ingresar la cantidad de números que
generamos ya que si se llega a pedir una cantidad exagerada de números el
programa puede llegar a congelarse hasta incluso el computador.

Por ultimo se debe interpretar de manera correcta los resultados para que no
exista ningún tipo de confusión a la hora de comprobar mediante una prueba de
escritorio.

14
 CONCLUSIONES
El sistema puede generar números seudoaleatorios por medio del algoritmo
congruencial multiplicativo.

El sistema tiene la capacidad de ingresar la semilla por el usuario o por timer de

frecuencia del reloj.

Para dicho algoritmo, el sistema incluye las pruebas de uniformidad de

Kolmogorov Smirnov para saber si los números generados son aceptados o
rechazados a un determinado nivel de significación, y también encontramos la
prueba de corridas.

El sistema esta diseñado para que ha medida que van pasando cada prueba se
desplegarán diferentes botones de interacción.

El sistema muestra los resultados realizados por los diferentes algoritmos de

manera clara y concisa.

El sistema está realizado de una manera intuitiva para un fácil manejo al

momento de interpretar los resultados

15
 BIBLIOGRAFÍA
Bu, R. C. (1994). Simulación Un enfoque práctico. Limusa .

Computación, Dpto. (2010). Introducción a la simulación y a la generación de

números pseudoaleatorios.

Ross, S. M. (2012). Simulación. Elsevier.

Salmerón Cerdán, A., & Morales Giraldo, M. (2001). Estadistica Computacional.

Almería.

16