Depto.

de Ingeniería Industrial

METODOS CONGRUENCIALES

Simulación

Docente: Talina Nieto Salas

Alumno: Juan Antonio Najera Tiscareño (17151131)

Grupo: 14-15hrs

Aguascalientes; Ags a 30 de Abril del 2020

 INDICE

INTRODUCCIÓN.......................................................................................................3

MÉTODOS CONGRUENCIALES.............................................................................4

Algoritmo congruencial lineal..........................................................................................4

Ejemplo 1....................................................................................................................................... 4
Ejemplo 2....................................................................................................................................... 7
Ejemplo 3....................................................................................................................................... 9

Algoritmo congruencial multiplicativo..........................................................................10

Ejemplo 1..................................................................................................................................... 10
Ejemplo 2..................................................................................................................................... 11
Ejemplo 3..................................................................................................................................... 12

Algoritmo congruencial aditivo......................................................................................13

Ejemplo 1..................................................................................................................................... 13
Ejemplo 2..................................................................................................................................... 14
Ejemplo 3..................................................................................................................................... 15

CONCLUSIÓN.........................................................................................................17

2
 INTRODUCCIÓN
Para recordar un poco sobre cómo es que estos métodos congruenciales existen,
daremos un paso atrás al tema anterior. Los números aleatorios constituyen la
parte principal de la simulación de procesos estocásticos y generalmente se usan
para generar el comportamiento de variables aleatorias, tanto continúas como
discretas. Debido a que no es posible generar números realmente aleatorios, los
consideramos como números pseudo-aleatorios, generados por medio de
algoritmos determinísticos que requieren parámetros de arranque. Entonces, esto
quiere decir que los métodos congruenciales que se verán a continuación son un
desarrollo de los números aleatorios, pero en este caso no se usan esos números
aleatorios sino los pseudo-aleatorios, que no es más que el valor de una variable
aleatoria x que tiene una distribución de probabilidad uniforme definida en el
intervalo (0, 1).

En el presente trabajo se han desarrollado ejemplos de tres métodos

congruenciales para generar números pseudo-aleatorios, los cuales se derivan del
empleo de diferentes versiones de la relación fundamental de congruencia. El
objetivo de cada uno de los métodos es la generación en un tiempo mínimo, de
sucesiones de números aleatorios con periodos máximos. Los métodos
congruenciales son: el lineal, el multiplicativo y el aditivo.

3
 MÉTODOS CONGRUENCIALES
Algoritmo congruencial lineal
Ejemplo 1. Generar 32 números entre 0 y 1 con los parámetros
X 0=25 , k=4 , g=5 , c=23.

m=2 g=25=32

a=1+4 k=1+ 4 ( 4 )=17

Xn ( a X i+ c ) mod(m) Xi
X0 25
X1 ( 17∗25+23 ) mod (32) 0
X2 ( 17∗0+23 ) mod (32) 23
X3 ( 17∗23+23 ) mod (32) 30
X4 ( 17∗30+23 ) mod(32) 21
X5 ( 17∗21+23 ) mod (32) 28
X6 ( 17∗28+23 ) mod(32) 19
X7 ( 17∗19+23 ) mod (32) 26
X8 ( 17∗26+23 ) mod (32) 17
X9 ( 17∗17+23 ) mod( 32) 24
X 10 ( 17∗24+23 ) mod (32) 15
X 11 ( 17∗15+23 ) mod (32) 22
X 12 ( 17∗22+23 ) mod (32) 13
X 13 ( 17∗13+23 ) mod (32) 20
X 14 ( 17∗20+23 ) mod(32) 11
X 15 ( 17∗11+23 ) mod( 32) 18
X 16 ( 17∗18+23 ) mod(32) 9
X 17 ( 17∗9+23 ) mod (32) 16
X 18 ( 17∗16+23 ) mod( 32) 7
X 19 ( 17∗7+23 ) mod( 32) 14
X 20 ( 17∗14+23 ) mod (32) 5
X 21 ( 17∗5+23 ) mod(32) 12
X 22 ( 17∗12+23 ) mod(32) 3
X 23 ( 17∗3+23 ) mod(32) 10
X 24 ( 17∗10+23 ) mod(32) 1
X 25 ( 17∗1+23 ) mod(32) 8
X 26 ( 17∗8+23 ) mod (32) 31
X 27 ( 17∗31+23 ) mod (32) 6
X 28 ( 17∗6+23 ) mod (32) 29
X 29 ( 17∗29+23 ) mod(32) 4
X 30 ( 17∗4 +23 ) mod(32) 27

4
X 31 ( 17∗27+23 ) mod (32) 2
X 31 ( 17∗2+23 ) mod(32) 25

rn Xi ri
m−1
r1 0 0
32−1
r2 23 0.7419
32−1
r3 30 0.9677
32−1
r4 21 0.6774
32−1
r5 28 0.9032
32−1
r6 19 0.6129
32−1
r7 26 0.8387
32−1
r8 17 0.5483
32−1
r9 24 0.7741
32−1
r 10 15 0.4838
32−1
r 11 22 0.7096
32−1
r 12 13 0.4193
32−1
r 13 20 0.6451
32−1
r 14 11 0.3548
32−1
r 15 18 0.5806
32−1
r 16 9 0.2903
32−1
r 17 16 0.5161
32−1
r 18 7 0.2258
32−1
r 19 14 0.4516
32−1

5
 r 20 5 0.1612
32−1
r 21 12 0.3870
32−1
r 22 3 0.0967
32−1
r 23 10 0.3225
32−1
r 24 1 0.0322
32−1
r 25 8 0.2580
32−1
r 26 31 1
32−1
r 27 6 0.1935
32−1
r 28 29 0.9354
32−1
r 29 4 0.1290
32−1
r 30 27 0.8709
32−1
r 31 2 0.0645
32−1
r 32 25 0 .8064
32−1

Ejemplo 2. Generar 16 números entre 0 y 1 con los parámetros

X 0=9 , k =3 , g=4 , c=11.

m=2 g=24 =16

a=1+4 k=1+ 4 ( 3 )=13

Xn ( a X i+ c ) mod(m) Xi
X0 9
X1 ( 13∗9+11 ) mod( 16) 0
X2 ( 13∗0+11 ) mod(16) 11
X3 ( 13∗11+11 ) mod(16) 10
X4 ( 13∗10+11 ) mod(16) 13
X5 ( 13∗13+11 ) mod(16) 4
X6 ( 13∗4+ 11 ) mod(16) 15

6
X7 ( 13∗15+11 ) mod(16) 14
X8 ( 13∗14+11 ) mod (16) 1
X9 ( 13∗1+ 11 ) mod(16) 8
X 10 ( 13∗8+11 ) mod(16) 3
X 11 ( 13∗3+11 ) mod(16) 2
X 12 ( 13∗2+ 11 ) mod(16) 5
X 13 ( 13∗5+11 ) mod(16) 12
X 14 ( 13∗12+ 11 ) mod(16) 7
X 15 ( 13∗7+11 ) mod(16) 6
X 16 ( 13∗6+11 ) mod( 16) 9

rn Xi ri
m−1
r1 0 0
16−1
r2 11 0.7333
16−1
r3 10 0.6666
16−1
r4 13 0.8666
16−1
r5 4 0.2666
16−1
r6 15 1
16−1
r7 14 0.9333
16−1
r8 1 0.0666
16−1
r9 8 0.5333
16−1
r 10 3 0.2
16−1
r 11 2 0.1333
16−1
r 12 5 0.3333
16−1
r 13 12 0.8
16−1
r 14 7 0.4666
16−1
r 15 6 0.4
16−1

7
 r 16 9 0.6
16−1

Ejemplo 3. Generar 8 números entre 0 y 1 con los parámetros

X 0=3 , k=1 , g=3 , c=7.

m=2 g=23=8

a=1+4 k=1+ 4 ( 1 )=5

Xn ( a X i+ c ) mod(m) Xi
X0 3
X1 ( 5∗3+7 ) mod(8) 6
X2 ( 5∗6+7 ) mod (8) 5
X3 ( 5∗5+7 ) mod( 8) 0
X4 ( 5∗0+7 ) mod(8) 7
X5 ( 5∗7+7 ) mod( 8) 2
X6 ( 5∗2+ 7 ) mod (8) 1
X7 ( 5∗1+ 7 ) mod(8) 4
X8 ( 5∗4 +7 ) mod(8) 3

rn Xi ri
m−1
r1 6 0.8571
8−1
r2 5 0.7142
8−1
r3 0 0
8−1
r4 7 1
8−1
r5 2 0.2857
8−1
r6 1 0.1428
8−1
r7 4 0.5714
8−1
r8 3 0.4285
8−1

8
Algoritmo congruencial multiplicativo
Ejemplo 1. Generar suficientes números r i entre 0 y 1 con los parámetros
X 0=25 , k=4 , g=5 , hasta encontrar el periodo o ciclo de vida.

m=2 g=25=32

a=3+8 k =3+8 ( 4 )=35

Xn ( a X i ) mod(m) Xi
X0 25
X1 ( 35∗25 ) mod(32) 11
X2 ( 35∗11 ) mod (32) 1
X3 ( 35∗1 ) mod (32) 3
X4 ( 35∗3 ) mod(32) 9
X5 ( 35∗9 ) mod(32) 27
X6 ( 35∗27 ) mod(32) 17
X7 ( 35∗17 ) mod (32) 19
X8 ( 35∗19 ) mod(32) 25

rn Xi ri
m−1
r1 11 0.3548
32−1
r2 1 0.0322
32−1
r3 3 0.0967
32−1
r4 9 0.2903
32−1
r5 27 0.8709
32−1
r6 17 0.5483
32−1
r7 19 0.6129
32−1
r8 25 0.8064
32−1

Ejemplo 2. Generar suficientes números r i entre 0 y 1 con los parámetros

X 0=9 , k =3 , g=4 , hasta encontrar el periodo o ciclo de vida.

9
m=2 g=24 =16

a=3+8 k =3+8 ( 3 ) =27

Xn ( a X i ) mod(m) Xi
X0 9
X1 ( 27∗9 ) mod(16) 3
X2 ( 27∗3 ) mod(16) 1
X3 ( 27∗1 ) mod(16) 11
X4 ( 27∗11 ) mod (16) 9

rn Xi ri
m−1
r1 3 0.2
16−1
r2 1 0.0666
16−1
r3 11 0.7333
16−1
r4 9 0.6
16−1

Ejemplo 3. Generar suficientes números r i entre 0 y 1 con los parámetros

X 0=51 , k=4 , g=6 , hasta encontrar el periodo o ciclo de vida.

m=2 g=26 =64

a=3+8 k =3+8 ( 4 )=35

Xn ( a X i ) mod(m) Xi
X0 51
X1 ( 35∗51 ) mod (64) 57
X2 ( 35∗57 ) mod (64 ) 11
X3 ( 35∗11 ) mod(64 ) 1
X4 ( 35∗1 ) mod (64) 35
X5 ( 35∗35 ) mod(64) 9
X6 ( 35∗9 ) mod(64 ) 59
X7 ( 35∗59 ) mod(64) 17
X8 ( 35∗17 ) mod (64 ) 19
X9 ( 35∗19 ) mod(64) 25

10
X 10 ( 35∗25 ) mod(64) 43
X 11 ( 35∗43 ) mod( 64) 33
X 12 ( 35∗33 ) mod(64) 3
X 13 ( 35∗3 ) mod(64) 41
X 14 ( 35∗41 ) mod(64 ) 27
X 15 ( 35∗27 ) mod(64 ) 49
X 16 ( 35∗49 ) mod( 64) 51

rn Xi ri
m−1
r1 57 0.9047
64−1
r2 11 0.1746
64−1
r3 1 0.0158
64−1
r4 35 0.5555
64−1
r5 9 0.1428
64−1
r6 59 0.9365
64−1
r7 17 0.2698
64−1
r8 19 0.3015
64−1
r9 25 0.3968
64−1
r 10 43 0.6825
64−1
r 11 33 0.5238
64−1
r 12 3 0.0476
64−1
r 13 41 0.6507
64−1
r 14 27 0.4285
64−1
r 15 49 0.7777
64−1
r 16 51 0.8095
64−1

11
Algoritmo congruencial aditivo
Ejemplo 1. Generar 8 números pseudo-aleatorios entre cero y uno, a partir de la
siguiente secuencia de números enteros:
X 1 =95 , X 2=89 , X 3 =72, X 4=64 , X 5=51 ; m=100.

Xn ( X i−1 + X i−n ) mod(m) Xi

X6 ( 51+95 ) mod( 100) 46
X7 ( 46 +89 ) mod(100) 35
X8 ( 35+72 ) mod(100) 7
X9 ( 7+64 ) mod(100) 71
X 10 ( 71+51 ) mod(100) 22
X 11 ( 22+46 ) mod(100) 68
X 12 ( 68+35 ) mod (100) 3
X 13 ( 3+7 ) mod (100) 10

rn Xi ri
m−1
r1 46 0.4646
100−1
r2 35 0.3535
100−1
r3 7 0.0707
100−1
r4 71 0.7171
100−1
r5 22 0.2222
100−1
r6 68 0.6868
100−1
r7 3 0.0303
100−1
r8 10 0.1010
100−1

Ejemplo 2. Generar 9 números pseudo-aleatorios entre cero y uno, a partir de la

siguiente secuencia de números enteros:
X 1 =55 , X 2=49 , X 3 =32 , X 4=24 , X 5=11 ; m=64.

Xn ( X i−1 + X i−n ) mod(m) Xi

12
 X6 ( 11+55 ) mod (64) 2
X7 ( 2+49 ) mod (64) 51
X8 ( 51+32 ) mod(64) 19
X9 ( 19+24 ) mod (64) 43
X 10 ( 43+ 11 ) mod (64) 54
X 11 ( 54+ 2 ) mod (64) 56
X 12 ( 56+51 ) mod ( 64) 43
X 13 ( 43+ 19 ) mod(64) 62
X 14 ( 62+43 ) mod (64) 41

rn Xi ri
m−1
r1 2 0.0317
64−1
r2 51 0.8095
64−1
r3 19 0.3015
64−1
r4 43 0.6825
64−1
r5 54 0.8571
64−1
r6 56 0.8888
64−1
r7 43 0.6825
64−1
r8 62 0.9841
64−1
r9 41 0.6507
64−1

Ejemplo 3. Generar 10 números pseudo-aleatorios entre cero y uno, a partir de la

siguiente secuencia de números enteros:
X 1 =30 , X 2=17 , X 3=3 , X 4=26 , X 5=29 ; m=32.

Xn ( X i−1 + X i−n ) mod(m) Xi

X6 ( 29+30 ) mod (32) 27
X7 ( 27+17 ) mod (32) 12
X8 ( 12+3 ) mod(32) 15
X9 ( 15+26 ) mod (32) 9

13
 X 10 ( 9+29 ) mod (32) 6
X 11 ( 6+27 ) mod(32) 1
X 12 ( 1+12 ) mod(32) 13
X 13 ( 13+15 ) mod( 32) 28
X 14 ( 28+9 ) mod (32) 5
X 15 ( 5+6 ) mod (32) 11

rn Xi ri
m−1
r1 27 0.8709
32−1
r2 12 0.3870
32−1
r3 15 0.4838
32−1
r4 9 0.2903
32−1
r5 6 0.1935
32−1
r6 1 0.0322
32−1
r7 13 0.4193
32−1
r8 28 0.9032
32−1
r9 5 0.1612
32−1
r 10 11 0.3548
32−1

CONCLUSIÓN
Una vez que se realizaron los métodos congrueniales anteriores, existen algunas
observaciones de cada uno. Primeramente, el método congruencial lineal es el
más usado. Genera una secuencia de números pseudo-aleatorios en la cual el
próximo número pseudo-aleatorios es determinado a partir del número generado,
es decir el número pseudo-aleatorios X n+1 es derivado a partir del número
pseudo-aleatorios X n. El método congruencial multiplicativo, el más simple en
cuestión personal, realiza la misma acción al momento de generar números
pseudo-aleatorios; la única diferencia y ventaja de este método es que implica una

14
operación menos a realizar una vez que se aplica la formula. El método
congruencial aditivo requiere una secuencia previa de números enteros para
generar una nueva secuencia de números enteros. Este se desarrolla un poco
diferente a los otros dos pero con el mismo objetivo.

Cada uno tiene su función para generar esos números pseudo-aleatorios

necesarios para un sinfín de cosas pero como ya mencione, el multiplicativo es el
más simple en cuestión personal. Los tres cumplen con los paramentros
apropiados para cualquier aplicación de la que se requiera, pero debemos de
tener en cuenta que no son los únicos con dentro de la simulación. Ya se vio en el
tema anterior que existen más, con diferentes formas de desarrollo pero nunca
con un objetivo distinto; ahora sí que es cuestión de cada quien elegir el que más
se les haga cómodo.

15