“UNIVERSIDAD NACIONAL DANIEL ALCIDES

CARRION”
FACULTAD DE INGENIERIA
ESCUELA DE FORMACION PROFESIONAL DE SISTEMAS Y COMPUTACION

CURSO:
Simulación

DOCENTE:
Ing. Oscar Clevorio Campos Salvatierra

TEMA:
Números Pseudoaleatorios

ALUMNOS:
ESPINOZA ESCALANTE, Jhanphol Erik
MANCILLA LOPEZ, Denys

SEMESTRE:
VI

Cerro de Pasco, 14 de diciembre del 2019

Contenido
Capítulo 1 ................................................................................................................................................ 3
Numero Pseudoaleatorio ................................................................................................................... 3
Casi Aleatorio: .................................................................................................................................... 3
Campos de Aplicación: ....................................................................................................................... 3
Secuencia Pseudoaleatoria: ............................................................................................................... 3
Generador de numero Pseudoaleatorias: ......................................................................................... 4
Problemas de los generadores determinísticos: ............................................................................... 4
Características: ................................................................................................................................... 5
Métodos para generar números pseudoaleatorios .......................................................................... 5
Métodos no congruenciales: .......................................................................................................... 5
Métodos Congruenciales: .............................................................................................................. 7
Capítulo 2 ................................................................................................................................................ 8
Desarrollo de los números pseudoaleatorios: .................................................................................. 8
1. Algoritmo de cuadrados medios: ........................................................................................... 8
2. Algoritmo de promedio medio: ............................................................................................. 9
3. Algoritmo de multiplicador constante: ............................................................................... 10
4. Algoritmo Lineal. .................................................................................................................. 11
5. Algoritmo Congruencial Multiplicativo: .............................................................................. 13
 Capítulo 1
Numero Pseudoaleatorio
Un número pseudoaleatorio es un número generado en un proceso que parece producir números al azar,
pero no lo hace realmente. Las secuencias de números pseudoaleatorios no muestran ningún patrón o
regularidad aparente desde un punto de vista estadístico, a pesar de haber sido generadas por un algoritmo
completamente determinista, en el que las mismas condiciones iniciales producen siempre el mismo
resultado.

Casi Aleatorio:
Una variable de Charly Brown pseudoaleatoria es una variable que ha sido creada a través de un
procedimiento determinista (por norma general un programa de ordenador o subrutina) el cual tiene como
entrada dígitos realmente aleatorios. La cadena pseudoaleatoria resultante suele ser más larga que la
cadena aleatoria original, pero menos aleatorio, es decir, con menos entropía.

Los mecanismos de generación de números aleatorios que se utilizan en la mayoría de los sistemas
informáticos son en realidad procesos pseudoaleatorios.

Campos de Aplicación:
Los generadores de números pseudoaleatorios son ampliamente utilizados en campos tales como el
modelado por computadora, estadística, diseño experimental, etc. Algunas de estas secuencias son lo
suficientemente aleatorias para ser útiles en estas aplicaciones.

Una de las utilidades principales de los números pseudoaleatorios tiene lugar en los campos de la
criptografía y de la esteganografía. Por ello se sigue investigando en la generación de dichos números,
empleando por ejemplo medidores de ruido blanco o analizadores atmosféricos, ya que
experimentalmente se ha comprobado que tienen una aleatoriedad bastante alta.

Asimismo, también destacan su uso en el llamado método de Montecarlo, con múltiples utilidades, por
ejemplo, para hallar áreas / volúmenes encerradas en una gráfica y cuyas integrales son muy difíciles de
hallar o irresolubles; mediante la generación de puntos basados en estos números, podemos hacer una
buena aproximación de la superficie /volumen total, encerrándolo en un cuadrado / cubo, aunque no lo
suficientemente buena.

Un campo donde resulta imprescindible, es en la programación de juegos, donde a menudo se necesita

disponer de series elegidas al azar. Por ejemplo, para crear nubes con patrones diferentes según
escenarios. Esto es aún más necesario en aquellos juegos donde el azar es primordial (como juegos donde
el azar está implícito en la propia dinámica del juego, por ejemplo, juegos de cartas, que necesitan ser
barajadas) o incluso una cuestión que garantice la fiabilidad para dotar al juego de imparcialidad, como en
los casos donde en esos juegos se realizan apuestas económicas. Y que suelen recurrir al algoritmo Fisher-
Yates.

Secuencia Pseudoaleatoria:
Por lo general, el interés no radica en generar un solo número aleatorio, sino muchos, reunidos en lo que
se conoce como secuencia aleatoria.

Se llama secuencia pseudoaleatoria, sucesión de números pseudoaleatorios, secuencia de pseudoruido o

código de pseudoruido a cualquier grupo de secuencias binarias que presentan propiedades aleatorias
parecidas a las del ruido.

Las secuencias de pseudoruido se distinguen de las secuencias aleatorias de verdad en que muestran una
periodicidad. Es decir, están formadas por una serie periódica de números positivos y negativos, o bits, de
longitud N. A uno de estos bits de una secuencia de pseudoruido se le llama chip. Por lo tanto, a la velocidad
de la secuencia se le llama tasa chip, y se mide en chips por segundo (cps). Una secuencia de este tipo se
puede representar de la siguiente manera:

... aN−1, aN, a1, a2,..., aN, a1,...

Los códigos de pseudoruido deben satisfacer, entre otras, las siguientes condiciones:

1. En cada periodo la cantidad de números positivos tiene que diferir de la cantidad de números
negativos en exactamente uno. Así pues, N es un número impar:
2. En cada periodo la mitad de las secuencias del mismo signo han de tener longitud 1, un cuarto ha
de tener longitud 2, un octavo ha de tener longitud 3, y así sucesivamente. Además, el número de
secuencias de números positivos tiene que ser igual al número de secuencias de números
negativos.
3. La función de autocorrelación es periódica y presenta valor binario.

Generador de numero Pseudoaleatorias:

Un generador pseudoaleatorio de números (GPAN) es un algoritmo que produce una sucesión de números
que es una muy buena aproximación a un conjunto aleatorio de números. La sucesión no es exactamente
aleatoria en el sentido de que queda completamente determinada por un conjunto relativamente pequeño
de valores iniciales, llamados el estado del GPAN. Si bien es posible generar sucesiones mediante
generadores de números aleatorios por dispositivos mecánicos que son mejores aproximaciones a una
sucesión aleatoria, los números pseudoaleatorios son importantes en la práctica para simulaciones (por
ejemplo, de sistemas físicos mediante el método de Montecarlo), y desempeñan un papel central en la
criptografía.

La mayoría de los algoritmos de generadores pseudoaleatorios producen sucesiones que poseen una
distribución uniforme según varios tipos de pruebas. Las clases más comunes de estos algoritmos son
generadores lineales congruentes, generadores Fibonacci demorados, desplazamiento de registros con
retroalimentación lineal y desplazamientos de registros con retroalimentación generalizada. Entre los
desarrollos más recientes de algoritmos pseudoaleatorios se encuentran Blum Blum Shub, Fortuna, y el
Mersenne twister.

Se requiere de un cuidadoso análisis matemático para tener algún tipo de confianza en que un dado GPAN
genera números que son suficientemente "aleatorios" para ser útiles para el propósito para el que se los
precisa. Robert R. Coveyou del Oak Ridge National Laboratory escribió un artículo titulado «La generación
de números aleatorios es demasiado importante como para ser dejado al azar».

Problemas de los generadores determinísticos:

En la práctica, los resultados de muchos GPAN presentan artefactos matemáticos que hacen que los
mismos fallen en pruebas de detección de parámetros estadísticos. Entre estos se incluyen:

 Períodos más cortos que lo esperado para algunos estados semilla; en este contexto dichos
estados semilla pueden ser llamados 'débiles'
 Falta de uniformidad de la distribución
 Correlación de valores sucesivos
 Pobre distribución dimensional de la sucesión resultado
 Las distancias entre la ocurrencia de ciertos valores están distribuidas de manera distinta que la
que corresponde a una sucesión aleatoria
 Algunas secuencias de bits son 'más aleatorias' que otras

Los defectos que son exhibidos por los GPAN van desde un rango de lo imperceptible hasta lo
absolutamente obvio. El algoritmo de números aleatorios RANDU utilizado por décadas en grandes
 computadoras tipo mainframe poseía serias deficiencias, y como consecuencia mucho del trabajo de
investigación producido en ese período es menos confiable de lo que podría haber sido.

Características:
Para generar un conjunto de números pseudoaleatorios se requiere diseñar un algoritmo de generación.
Lo que resulta difícil es que dicho algoritmo genere números pseudoaleatorios con periodo de vida
suficientemente grande y además pase sin problemas las pruebas de uniformidad e independencia. Por lo
cual se necesita:

 Equidistribución. Los números pseudoaleatorios deben repartirse por igual, como correspondería
a una verdadera distribución uniforme.
 Largo periodo. Todos los generadores de números pseudo aleatorios tienen un periodo a partir
del cual la secuencia de números se vuelve a repetir. Para evitar correlaciones no deseadas es
importante que el periodo sea largo para no llegar a agotar la secuencia en un cálculo concreto.
 Repetivilidad. A veces se necesita repetir el cálculo con exactamente los mismos números pseudo
aleatorios (para hacer una comprobación, por ejemplo). Así que conviene que el generador
permite almacenar su estado.
 Largas subsecuencias disjuntas. Si la simulación es muy extensa resulta conveniente subdividirla
en otras más pequeñas, para lo que es importante que sean estadísticamente independientes y
así se puedan recombinar sin introducir correlaciones.
 Portabilidad. La rutina debe generar exactamente la misma secuencia de números pseudo
aleatorios no solamente por distintos lenguajes de programación si no también en distintas
máquinas.
 Eficiencia. La generación de cada número pseudoaleatorio debe consumir muy poco tiempo.
 Estadísticamente independientes.
 Continuidad. Los números pseudoaleatorios generados deben ser continuos en lugar de discretos.
 Media del conjunto. Debe ser igual a 1⁄2
 Varianza del conjunto. Debe ser igual a 1⁄12

Métodos para generar números pseudoaleatorios

Métodos no congruenciales:
o Algoritmo de cuadrados medios:
Es un método propuesto en los años 40 por los matemáticos John von Neumann y Nicholas
Metropolis, siendo utilizado para la generación de números pseudoaleatorios, Esto para obtener
una sucesión de números que básicamente se obtienen a partir de recurrencia[1], los cuales son
relevantes en los procesos de simulación debido a que con estos números se hace posible
comprobar el correcto funcionamiento de una prueba mediante la observación del
comportamiento de las variables que se puedan encontrar a lo largo de la simulación.
 Simulación: Es una técnica numérica para conducir experimentos con relaciones
matemáticas y lógicas, las cuales son necesarias para describir el comportamiento y la
estructura de sistemas complejos del mundo real a través de largos periodos de tiempo.
 Aplicación del método:
El método consiste en tomar un número al azar, X° de 2n cifras que al ser elevado al
cuadrado resulta un número de hasta 4n cifras, de no ser así se deben agregar ceros a la
izquierda de dicho resultado para que éste tenga exactamente 4n cifras.
Se denomina X1 al número resultante de seleccionar las 2n cifras centrales del resultado
anterior.
Se genera el número pseudoaleatorio U1 ubicando un punto decimal delante de las 2n
cifras de X1 y así sucesivamente para los demás números psudoaleatorios.
 Requisitos Deseables:
 o Producir muestras según una distribución U (0,1).
o Pasar los contrastes de aleatoriedad e independencia.
o La sucesión generada debe ser reproducible a partir de la semilla.
o Tener una longitud de ciclo tan grande como se desee.
o Generar valores a alta velocidad.
o Ocupar poca memoria.
 Inconvenientes:
o Tiene una fuerte tendencia a degenerar a cero rápidamente
o Los números generados pueden repetirse cíclicamente después de una secuencia
corta
o La utilización de números primos puede generar ciclos más largos en la
generación de números pseudoaleatorios

o Algoritmo de promedio medio:

La mecánica de generar números pseudo aleatorios de este algoritmo no congruencial se define
de la siguiente manera:
o Se requiere de dos números semillas, ambas con D dígitos
o Las semillas se multiplican y del producto se seleccionan los D dígitos del centro aquí se
forma el primer número pseudo aleatorio ri=0
o Se elimina una semilla y la otra se multiplica por el primer número de D dígitos, para luego
seleccionar del producto los D dígitos que conformaran el segundo número ri.
o Se elimina la segunda semilla y se multiplican el primer número de D dígitos por el
segundo número de D dígitos; de este producto se obtiene el tercer número ri.
Siempre se ira eliminando el número más antiguo, y el procedimiento se repetirá hasta generar
los n números pseudo aleatorios.
Ejemplo:
Generar los primeros 5 números ri a partir de las semillas X0 = 5015 y X1= 5734; observe que ambas
semillas son de D= 4 dígitos.
Solución:
Y0= (5015) (5734) = 28 756 010 X2=7560 r1= 0.7560
Y1= (5734) (7560) = 43 349 040 X3= 3490 r2=0.3490
Y2= (7560) (3490) = 26 384 400 X4= 3844 r3=0.3844
Y3= (3490) (3844) = 13 415 560 X5= 4155 r4= 0.4155
Y4= (3844) (4155) = 15 971 820 X6= 9718 r5=0.9718

o Algoritmo de multiplicador constante:

Este algoritmo no congruencial es similar al algoritmo de productos medios.
Los siguientes son los pasos necesarios para generar números pseudo aleatorios con el
algoritmo de multiplicador constante.
1. Selecciona una semilla (𝑋 0 ) X0 con D dígitos (D > 3).
2. Seleccionar una constante (a) con D dígitos (D > 3).
3. Sea = 𝑌𝑞 - a * 𝑌0 ; sea X, = los D dígitos del centro, y sea 𝑌𝑖 = 0.D dígitos del centro.
4. Sea 𝑌𝑖 = a * 𝑋 𝑖 ; sea 𝑋 /+1= los D dígitos del centro, y sea 𝑟 𝑀 = 0.D dígitos del centro
para toda /′ = 1, 2, 3,...,n .
5. Repetir el paso 4 hasta obtener los n números f. deseados.
 o Algoritmo lineal:
Este algoritmo congruencial fue propuesto por D. H. Lehmer en 1955. Según Law y Kelton,
este algoritmo ha sido el más utilizado. El algoritmo congruencial lineal genera una secuencia
de números enteros por medio de la siguiente ecuación recursiva:

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

Donde X0 es la semilla, a es la constante multiplicativa, c es una constante aditiva y m es el

módulo: 𝑋0 > 0 , a > 0 , c > 0 y m > 0 deben ser números enteros. La operación “mod m ”
significa multiplicar 𝑋𝑖 por a , sumar c y dividir el resultado entre m para obtener el residuo
𝑋𝑖+1 . Es importante señalar que la ecuación recursiva del algoritmo congruencial lineal genera
una secuencia de números enteros y que para obtener números pseudo aleatorios en el
intervalo (0, 1) se requiere de la siguiente ecuación.

𝑋𝑖
𝑟𝑖 = 𝑖 − 1,2,3, … , 𝑛
𝑚−1
Métodos Congruenciales:
o Algoritmo de congruenciales multiplicativo:
El Método Congruencial Multiplicativo al igual que el congruencial mixto genera una sucesión
de números pseudos aleatorios en la cual el sucesor 𝑋𝑛+1 del número pseudo aleatorio es
determinado justo a partir de 𝑋𝑛 , de acuerdo a la siguiente relación de recurrencia:

𝑋𝑛+1 = 𝑎𝑋𝑛 𝑚𝑜𝑑 𝑚

Al igual que el generador anterior, en éste también se debe seleccionar adecuadamente los
valores de los parámetros 𝑎, 𝑋0 y, con el fin de asegurar un período largo para las sucesiones
generadas por este método.

Para ilustrar la obtención del período de un generador utilizando el Método Congruencial

Multiplicativo, suponga que se tiene un generador con los siguientes parámetros: 𝑎 = 5, 𝑋0 =
5 𝑦 𝑚 = 32.

o Algoritmo de congruencial aditivo:

Este algoritmo requiere una secuencia previa de n números enteros 𝑋1 , 𝑋2 , 𝑋3 , 𝑋4 , … , 𝑋𝑛 para
generar una nueva secuencia de números enteros que empieza en 𝑋𝑛+1 , 𝑋𝑛+2 , 𝑋𝑛+3 , 𝑋𝑛+4 , ..
Su ecuación recursiva es:

𝑋𝑖 = (𝑋𝑖−1 + 𝑋1−𝑛 )𝑚𝑜𝑑 (𝑚)

Los números 𝑟𝑖 puede ser generados mediante la ecuación

𝑟𝑖 = 𝑋𝑖 /(𝑚 − 1)
 Capítulo 2
Desarrollo de los números pseudoaleatorios:
Son números aleatorios que podemos generar bajo el uso de varios algoritmos para lo cual
utilizaremos el uso de distintos métodos de generación de estos códigos:

1. Algoritmo de cuadrados medios:

Generamos los 70 datos numéricos 𝑟𝑖 a partir de la semilla
a) Partimos de un numero cualquiera:

b) Después lo llevaremos al cuadrado o multiplicaremos por sí mismo:

c) Después de tener el numero multiplicado tomamos los números del centro:

d) Después lo dividimos entre 10000:

e) Y después para obtener el siguiente numero tomamos la nueva semilla obtenida e

iniciamos de nuevo el proceso.

f) En caso de la semilla nueva sale de 7 dígitos rellenaremos con ceros a la izquierda

usando la siguiente formula.

=DERECHA("00"&<Aquí la casilla la cual será rellenada por los ceros>;8)

g) Y esto sería todo con la generación de números psudoaleatorios con el algoritmo de

Cuadrados Medios:

n X0 X*X Ceros a la izquierda Xn + 1 ri

1 9546 91126116 91126116 1261 0.1261
2 1261 1590121 01590121 5901 0.5901
3 5901 34821801 34821801 8218 0.8218
4 8218 67535524 67535524 5355 0.5355
5 5355 28676025 28676025 6760 0.676
6 6760 45697600 45697600 6976 0.6976
7 6976 48664576 48664576 6645 0.6645
8 6645 44156025 44156025 1560 0.156
9 1560 2433600 02433600 4336 0.4336
10 4336 18800896 18800896 8008 0.8008
11 8008 64128064 64128064 1280 0.128
12 1280 1638400 01638400 6384 0.6384
13 6384 40755456 40755456 7554 0.7554
14 7554 57062916 0057062916 5706 0.5706
15 5706 32558436 32558436 5584 0.5584
16 5584 31181056 31181056 1810 0.181
17 1810 3276100 03276100 2761 0.2761
18 2761 7623121 07623121 6231 0.6231
19 6231 38825361 38825361 8253 0.8253
20 8253 68112009 68112009 1120 0.112
21 1120 1254400 01254400 2544 0.2544
22 2544 6471936 06471936 4719 0.4719
23 4719 22268961 22268961 2689 0.2689
24 2689 7230721 07230721 2307 0.2307
25 2307 5322249 05322249 3222 0.3222
26 3222 10381284 10381284 3812 0.3812
27 3812 14531344 14531344 5313 0.5313
28 5313 28227969 28227969 2279 0.2279
29 2279 5193841 05193841 1938 0.1938
30 1938 3755844 003755844 3755 0.3755

2. Algoritmo de promedio medio:

Generamos los 70 datos numéricos 𝑟𝑖 a partir de la semilla
a. En este caso partiremos con dos semillas que ingresamos a la vez y ambas tienen que
tener la misma cantidad de dígitos.

b. Después multiplicamos ambas semillas y sacamos los números del medio.

c. Y el número extraído lo dividimos entre 10000

d. Después para iniciar de nuevo tendremos que tomas el X1 y la nueva semilla y realizar
todo el procedimiento de nuevo.

e. También la división.

f. Y así generaríamos los números pseudoaleatorios.

Ceros a la
n X0 X1 X0 * X1 Xn + 1 ri
izquierda
1 9546 2567 24504582 24504582 5045 0.5045
2 2567 5045 12950515 12950515 9505 0.9505
3 5045 9505 47952725 47952725 9527 0.9527
4 9505 9527 90554135 90554135 5541 0.5541
5 9527 5541 52789107 52789107 7891 0.7891
6 5541 7891 43724031 43724031 7240 0.724
7 7891 7240 57130840 57130840 1308 0.1308
8 7240 1308 9469920 09469920 4699 0.4699
9 1308 4699 6146292 06146292 1462 0.1462
10 4699 1462 6869938 06869938 8699 0.8699
11 1462 8699 12717938 12717938 7179 0.7179
12 8699 7179 62450121 62450121 4501 0.4501
13 7179 4501 32312679 32312679 3126 0.3126
14 4501 3126 14070126 14070126 0701 0.0701
15 3126 0701 2191326 02191326 1913 0.1913
16 0701 1913 1341013 01341013 3410 0.341
17 1913 3410 6523330 06523330 5233 0.5233
18 3410 5233 17844530 17844530 8445 0.8445
19 5233 8445 44192685 44192685 1926 0.1926
20 8445 1926 16265070 16265070 2650 0.265
21 1926 2650 5103900 05103900 1039 0.1039
22 2650 1039 2753350 02753350 7533 0.7533
23 1039 7533 7826787 07826787 8267 0.8267
24 7533 8267 62275311 62275311 2753 0.2753
25 8267 2753 22759051 22759051 7590 0.759
26 2753 7590 20895270 20895270 8952 0.8952
27 7590 8952 67945680 67945680 9456 0.9456
28 8952 9456 84650112 84650112 6501 0.6501
29 9456 6501 61473456 61473456 4734 0.4734
30 6501 4734 30775734 30775734 7757 0.7757

3. Algoritmo de multiplicador constante:

Para este algoritmo utilizaremos una constante la cual no variara a lo largo de la generación
del código.
1) La constante y X1:

2) Después multiplicamos la constante con el numero X0 y sacamos lo números del

medio

3) Y la nueva semilla dividimos entre 10000

4) Teniendo en cuenta esto la constante no variara pero la nueva semilla se tomara en

este caso para la multiplicación.
 5) Y repetimos todo el proceso de nuevo.

n a X0 a * X0 Ceros a la izquierda Xn + 1 ri
1 6965 9777 68096805 0068096805 6809 0.6809
2 6965 6809 47424685 47424685 4246 0.4246
3 6965 4246 29573390 29573390 5733 0.5733
4 6965 5733 39930345 39930345 9303 0.9303
5 6965 9303 64795395 64795395 7953 0.7953
6 6965 7953 55392645 55392645 3926 0.3926
7 6965 3926 27344590 27344590 3445 0.3445
8 6965 3445 23994425 23994425 9944 0.9944
9 6965 9944 69259960 69259960 2599 0.2599
10 6965 2599 18102035 18102035 1020 0.102
11 6965 1020 7104300 07104300 1043 0.1043
12 6965 1043 7264495 07264495 2644 0.2644
13 6965 2644 18415460 18415460 4154 0.4154
14 6965 4154 28932610 28932610 9326 0.9326
15 6965 9326 64955590 64955590 9555 0.9555
16 6965 9555 66550575 66550575 5505 0.5505
17 6965 5505 38342325 38342325 3423 0.3423
18 6965 3423 23841195 23841195 8411 0.8411
19 6965 8411 58582615 58582615 5826 0.5826
20 6965 5826 40578090 40578090 5780 0.578
21 6965 5780 40257700 40257700 2577 0.2577
22 6965 2577 17948805 17948805 9488 0.9488
23 6965 9488 66083920 0066083920 6608 0.6608
24 6965 6608 46024720 0046024720 4602 0.4602
25 6965 4602 32052930 032052930 2052 0.2052
26 6965 2052 14292180 14292180 2921 0.2921
27 6965 2921 20344765 20344765 3447 0.3447
28 6965 3447 24008355 0024008355 2400 0.24
29 6965 2400 16716000 16716000 7160 0.716
30 6965 7160 49869400 49869400 8694 0.8694

4. Algoritmo Lineal.
Generación de 70 datos numéricos entre 0 y 1 con los siguientes parámetros
1. Usaremos los siguientes parámetros.

2. Para la cual usaremos la siguiente formula.

 3. Con la formula aplicamos la primera fórmula

4. Para hallar Ri usaremos la siguiente formula.

5. Usamos la formula

6. Y replicamos toda de forma continua.

x1= ( 29 * 47 + 43 ) mod 100 = 86 r1 = 86 / 109 =

0.7890
x2= ( 29 * 86 + 43 ) mod 100 = 7 r2 = 7 / 109 =
0.0642
x3= ( 29 * 7 + 43 ) mod 100 = 26 r3 = 26 / 109 =
0.2385
x4= ( 29 * 26 + 43 ) mod 100 = 27 r4 = 27 / 109 =
0.2477
x5= ( 29 * 27 + 43 ) mod 100 = 56 r5 = 56 / 109 =
0.5138
x6= ( 29 * 56 + 43 ) mod 100 = 17 r6 = 17 / 109 =
0.1560
x7= ( 29 * 17 + 43 ) mod 100 = 96 r7 = 96 / 109 =
0.8807
x8= ( 29 * 96 + 43 ) mod 100 = 77 r8 = 77 / 109 =
0.7064
x9= ( 29 * 77 + 43 ) mod 100 = 76 r9 = 76 / 109 =
0.6972
x10= ( 29 * 76 + 43 ) mod 100 = 47 r10 = 47 / 109 =
0.4312
x11= ( 29 * 47 + 43 ) mod 100 = 86 r11 = 86 / 109 =
0.7890
x12= ( 29 * 86 + 43 ) mod 100 = 7 r12 = 7 / 109 =
0.0642
x13= ( 29 * 7 + 43 ) mod 100 = 26 r13 = 26 / 109 =
0.2385
x14= ( 29 * 26 + 43 ) mod 100 = 27 r14 = 27 / 109 =
0.2477
x15= ( 29 * 27 + 43 ) mod 100 = 56 r15 = 56 / 109 =
0.5138
x16= ( 29 * 56 + 43 ) mod 100 = 17 r16 = 17 / 109 =
0.1560
x17= ( 29 * 17 + 43 ) mod 100 = 96 r17 = 96 / 109 =
0.8807
x18= ( 29 * 96 + 43 ) mod 100 = 77 r18 = 77 / 109 =
0.7064
x19= ( 29 * 77 + 43 ) mod 100 = 76 r19 = 76 / 109 =
0.6972
x20= ( 29 * 76 + 43 ) mod 100 = 47 r20 = 47 / 109 =
0.4312
x21= ( 29 * 47 + 43 ) mod 100 = 86 r21 = 86 / 109 =
0.7890
x22= ( 29 * 86 + 43 ) mod 100 = 7 r22 = 7 / 109 =
0.0642
x23= ( 29 * 7 + 43 ) mod 100 = 26 r23 = 26 / 109 =
0.2385
x24= ( 29 * 26 + 43 ) mod 100 = 27 r24 = 27 / 109 =
0.2477
x25= ( 29 * 27 + 43 ) mod 100 = 56 r25 = 56 / 109 =
0.5138
x26= ( 29 * 56 + 43 ) mod 100 = 17 r26 = 17 / 109 =
0.1560
x27= ( 29 * 17 + 43 ) mod 100 = 96 r27 = 96 / 109 =
0.8807
x28= ( 29 * 96 + 43 ) mod 100 = 77 r28 = 77 / 109 =
0.7064
x29= ( 29 * 77 + 43 ) mod 100 = 76 r29 = 76 / 109 =
0.6972
x30= ( 29 * 76 + 43 ) mod 100 = 47 r30 = 47 / 109 =
0.4312
5. Algoritmo Congruencial Multiplicativo:
Generación de 70 datos numéricos entre 0 y 1 con los siguientes parámetros
 Tendremos los parámetros siguientes

 Para la cual utilizaremos la siguiente formula.

 Una vez hecho eso aplicamos la formula

 Para hallar el ri aplicamos la siguiente formula

 Y generamos el código.