Simulacion de Sistemas Continuos

Universidad Internacional de La Rioja
Máster universitario en
Ingeniería Matemática y Computación
Modelado y Simulación
Numérica
Simulación de sistemas continuos
Presentado por: Fernando Manrique Ochoa

Jaime Rojas Coronel
Kevin Lucón Rivas
Nicolás Ernesto Cortés Malagón
Fecha: 27 de enero de 2020

Asignatura Datos del alumno Fecha
Modelado y Apellidos:
Simulación 27 de enero de 2020
Numérica Nombre:
Contenido
Generación de números aleatorios ..................................................................... 1
Ejercicio 1 ................................................................................................................. 1
Ejercicio 2 ................................................................................................................. 1
Ejercicio 3 ................................................................................................................. 3
Ejercicio 4 ................................................................................................................. 4
Ejercicio 5 ................................................................................................................. 5
Generación de variables aleatorias ..................................................................... 7
Ejercicio 6 ................................................................................................................. 7
Ejercicio 7 ................................................................................................................. 9
Ejercicio 8 ............................................................................................................... 12
Ejercicio 9 ............................................................................................................... 15
Simulación de eventos discretos y análisis estadístico ............................. 19
Ejercicio 10 ............................................................................................................. 19
Ejercicio 11 ............................................................................................................. 20
Ejercicio 12 ............................................................................................................. 23
Numérica Nombre:
Generación de números aleatorios

Ejercicio 1
Completa el siguiente esquema con las condiciones que deben verificarse para tener el
periodo máximo o completo:
» Métodos de generación de números aleatorios congruenciales

Fórmula general: 𝑥𝑛 = (𝑎𝑥𝑛−1 + 𝑏) mod 𝑚
o Métodos congruenciales mixtos (𝑏 ≠ 0).

 Caso general 𝑚 cualquier valor.
Se obtiene periodo completo, 𝑝 = 𝑚, cuando:
» 𝑚 y 𝑏 son primos relativos. (m. c. d(𝑚, 𝑏) = 1)
» Todo número primo que divide a 𝑚 también divide a 𝑎 − 1.
» Si 4 divide a 𝑚, entonces también divide a 𝑎 − 1.
 Caso 𝑚 = 2𝑘 (𝑚 potencia de 2, 𝑘 ≥ 2).
Se obtiene periodo completo, p=2𝑘 , cuando:
» 𝑏 es impar.
» 4 divide a 𝑎 − 1.
o Métodos congruenciales multiplicativos ( 𝑏 = 0)

 Caso general 𝑚 cualquier valor.
Se obtiene periodo máximo, 𝑝 = 𝑚 − 1, cuando:
» 𝑚 es primo.
∗
» 𝑎 es raíz primitiva de 𝑚. (𝑎 genera ℤ𝑚 )
 Caso 𝑚 = 2𝑘 (𝑚 potencia de 2, 𝑘 ≥ 4).
Se obtiene periodo máximo, 𝑝 = 2𝑘−2 , cuando:
1. 𝑥0 es impar.
2. 𝑎 ≡ 3 𝑚𝑜𝑑 8 o 𝑎 ≡ 5 𝑚𝑜𝑑 8
Ejercicio 2
Para cada uno de los cuatro casos anteriores. Propón valores para 𝑎, 𝑏, 𝑚 y 𝑥0 para que
el periodo sea máximo/completo y superior a 50.
1
Numérica Nombre:
Caso 𝑏 ≠ 0, 𝑚 cualquier valor

Escogemos 𝑚 > 50, 𝒎 = 𝟕𝟐 = 23 ⋅ 32 y hacemos que 4 y 3 sean también
divisores de 𝑎 − 1: tomamos 𝑎 − 1 = 4 ⋅ 3, es decir 𝒂 = 𝟏𝟑. Ahora, escogemos 𝑏
coprimo con 𝑚, 𝒃 = 𝟓 y finalmente, escogemos un valor para 𝑥0 , 𝒙𝟎 = 𝟏.
De esta forma el generador es:
𝒙𝒏 = 𝟏𝟑𝒙𝒏−𝟏 + 𝟓 𝒎𝒐𝒅 𝟕𝟐, 𝒙𝟎 = 𝟏
Con periodo completo, 𝒑 = 𝟕𝟐.
Caso 𝑏 ≠ 0, 𝑚 = 2𝑘
Elegimos 𝑚, potencia de 2 mayor que 50: 𝒎 = 𝟐𝟔 , 𝑎 − 1 múltiplo de 4:
𝑎 − 1 = 4, es decir 𝒂 = 𝟓, 𝑏 impar: 𝒃 = 𝟑 y un valor inicial: 𝒙𝟎 = 𝟏.
Por lo tanto, el generador es:
𝒙𝒏 = 𝟓𝒙𝒏−𝟏 + 𝟑 𝒎𝒐𝒅 𝟔𝟒, 𝒙𝟎 = 𝟏
Con periodo completo, 𝒑 = 𝟔𝟒.
Caso 𝑏 = 0, 𝑚 cualquier valor

𝑚 será un número primo mayor que 51: m= 𝟓𝟑.
𝑎 es una raíz primitiva de 53: 𝒂 = 𝟐.
Valor inicial: 𝒙𝟎 = 𝟏.
Así, el generador es:
𝒙𝒏 = 𝟐𝒙𝒏−𝟏 𝒎𝒐𝒅 𝟓𝟑, 𝒙𝟎 = 𝟏
Con periodo máximo, 𝒑 = 𝟓𝟐.
Podemos comprobar que 2 es raíz primitiva de 53 con los valores de la siguiente tabla
que obtuvimos con ayuda de Mathematica.
2 mod 53 = 2 210 mod 53 = 17 219 mod 53 = 12 228 mod 53 = 49

22 mod 53 = 4 211 mod 53 = 34 220 mod 53 = 24 229 mod 53 = 45
23 mod 53 = 8 212 mod 53 = 15 221 mod 53 = 48 230 mod 53 = 37
24 mod 53 = 16 213 mod 53 = 30 222 mod 53 = 43 231 mod 53 = 21
25 mod 53 = 32 214 mod 53 = 7 223 mod 53 = 33 232 mod 53 = 42
26 mod 53 = 11 215 mod 53 = 14 224 mod 53 = 13 233 mod 53 = 31
27 mod 53 = 22 216 mod 53 = 28 225 mod 53 = 26 234 mod 53 = 9
28 mod 53 = 44 217 mod 53 = 3 226 mod 53 = 52 235 mod 53 = 18
29 mod 53 = 35 218 mod 53 = 6 227 mod 53 = 51 236 mod 53 = 36
2
Numérica Nombre:
237 mod 53 = 19 241 mod 53 = 39 245 mod 53 = 41 249 mod 53 = 20

238 mod 53 = 38 242 mod 53 = 25 246 mod 53 = 29 250 mod 53 = 40
239 mod 53 = 23 243 mod 53 = 50 247 mod 53 = 5 251 mod 53 = 27
240 mod 53 = 46 244 mod 53 = 47 248 mod 53 = 10 252 mod 53 = 1
Verificamos que la primera potencia 𝑘 para la cual 2𝑘 ≡ 1 𝑚𝑜𝑑 53 es 52 = 53 − 1, es
decir, 2 es raíz primitiva de 53.
Caso 𝑏 = 0, 𝑚 = 2𝑘
Necesitamos que 2𝑘−2 > 50, entonces tomemos 𝒎 = 𝟐𝟖 .
Elijamos 𝑎 ≡ 3 mod 8: 𝒂 = 𝟏𝟏 y 𝑥0 impar: 𝒙𝟎 = 𝟑
Con estas condiciones, el generador es:
𝒙𝒏 = 𝟏𝟏𝒙𝒏−𝟏 𝒎𝒐𝒅 𝟐𝟓𝟔, 𝒙𝟎 = 𝟑
Con periodo máximo, 𝒑 = 𝟐𝟔 = 𝟔𝟒.
Ejercicio 3
Realizar una función en Matlab que genere valores aleatorios.
function [u, x] = gen_num_alea(a, b, m, x)

persistent X;
if(exist('x', 'var')) % verifica si x se pasó por parámetro
X = mod(a*x + b, m);
u = X/m;
x = X;
elseif isempty(X) % verifica si X no tiene asignado ningún valor
disp('Error, falta el valor inicial de x');
else % X tiene un valor previo
X = mod(a*X + b, m);
u = X/m;
x = X;
end
end
3
Numérica Nombre:
Ejercicio 4
Generación de 10000 (diez mil) iterados de valores aleatorios entre 0 y 1.
El siguiente código de Matlab nos permite obtener una ‘cantidad’ de números
aleatorios con 𝑎 = 41, 𝑏 = 9, 𝑚 = 214 𝑦 el primer valor de 𝑥 = 4:
cantidad = 10000; % cantidad de números generados

a = 41; % a-1 es múltiplo de 4
b = 9; % b es impar
m = 2^14; % m es potencia de 2
x=4;
U=zeros(cantidad, 1);
U(1)=gen_num_alea(a, b, m, x); % primer valor con x por parámetro
for i=1 : cantidad-1
U(i + 1)=gen_num_alea(a, b, m);
end
histogram(U, 10); % La función histogram de Matlab grafica el histograma
xlabel(strcat('Muestra de ', num2str(cantidad), ' números aleatorios'));
title('HISTOGRAMA');
Al ejecutarlo obtenemos la siguiente gráfica:
4
Numérica Nombre:
A continuación mostramos los primeros 100 números generados:

0.010559 0.463928 0.331360 0.862854 0.308411
0.433472 0.021606 0.586304 0.377563 0.645386
0.772888 0.886414 0.039001 0.480652 0.461365
0.688965 0.343506 0.599609 0.707275 0.916504
0.248108 0.084290 0.584534 0.998840 0.577209
0.172974 0.456421 0.966431 0.953003 0.666138
0.092468 0.713806 0.624207 0.073669 0.312195
0.791748 0.266602 0.593018 0.020996 0.800537
0.462219 0.931213 0.314270 0.861389 0.822571
0.951538 0.180298 0.885620 0.317505 0.725952
0.013611 0.392761 0.310974 0.018250 0.764587
0.558594 0.103760 0.750488 0.748779 0.348633
0.902893 0.254700 0.770569 0.700500 0.294495
0.019165 0.443237 0.593872 0.721069 0.074829
0.786316 0.173279 0.349304 0.564392 0.068542
0.239502 0.104980 0.322021 0.140625 0.810791
0.820129 0.304749 0.203430 0.766174 0.242981
0.625854 0.495239 0.341187 0.413696 0.962769
0.660583 0.305359 0.989197 0.962097 0.474060
0.084473 0.520264 0.557617 0.446533 0.437012
Ejercicio 5
Dados los siguientes generadores congruenciales:
1. 𝑥𝑛 = 5𝑥𝑛−1 + 3 𝑚𝑜𝑑 31, 𝑥0 = 3
2. 𝑦𝑛 = 9𝑦𝑛−1 + 7 𝑚𝑜𝑑 64, 𝑦0 = 4
3. 𝑧𝑛 = 19𝑧𝑛−1 𝑚𝑜𝑑 256, 𝑧0 = 5
Calcular (y justificar debidamente) el periodo de los métodos.

» Primer caso:
𝑎 = 5, 𝑏 = 3, 𝑚 = 31, 𝑥0 = 3.
Podemos ver que 𝑏 ≠ 0 (método mixto), 31 es un número primo que divide a 𝑚
pero no divide a 𝑎 − 1 y 𝑚 no es potencia de 2, por lo tanto el método no cumple
con condiciones ni de periodo completo ni de periodo máximo. Entonces, para
calcular el periodo, procedemos a generar una serie de valores 𝑥𝑛 hasta que 𝑥0
se repita.
𝑥0 = 3
𝑥1 = 5𝑥0 + 3 mod 31 = 18 𝑚𝑜𝑑 31 = 18
𝑥2 = 5𝑥1 + 3 mod 31 = 93 𝑚𝑜𝑑 31 = 0
5
Numérica Nombre:
𝑥3 = 5𝑥2 + 3 mod 31 = 3 𝑚𝑜𝑑 31 = 3 = 𝑥0
Por lo tanto el periodo es 3.
» Segundo caso
𝑎 = 9 , 𝑏 = 7, 𝑚 = 64, 𝑦0 = 4
Vemos que se trata de un método mixto (𝑏 ≠ 0) que cumple con las condiciones:
𝑚 es potencia de 2 (𝑚 = 26 ), 𝑏 es impar y 4 divide a 𝑎 − 1 = 8.
Por lo tanto, el periodo es completo, igual a 64.
» Tercer caso
𝑎 = 19, 𝑏 = 0, 𝑚 = 256, 𝑧0 = 5
Vemos que se trata de un método multiplicativo (𝑏 = 0) que cumple con las
condiciones: 𝑚 es potencia de 2 ( 𝑚 = 28 ), 𝑎 ≡ 3 𝑚𝑜𝑑 8 y 𝑧0 es impar.
Por lo tanto, el periodo es 28−2 = 64.
Combinación de los tres generadores:
Observación: 𝑧𝑛 es lineal multiplicativo, pero 𝑥𝑛 y 𝑦𝑛 son lineales mixtos, por lo tanto

no podemos usar el método visto en clase. Sin embargo podemos usar el siguiente
resultado:
 Si 𝑈1 , … , 𝑈𝑘 son variables aleatorias independientes e idénticamente
distribuidas 𝑢(0,1), entonces la parte fraccionaria de 𝑈1 + ⋯ + 𝑈𝑘 también
sigue una distribución 𝑢(0,1)
𝑈1 + ⋯ + 𝑈𝑘 − [𝑈1 + ⋯ + 𝑈𝑘 ] ~ 𝑢(0,1)
 Si 𝑢1 , 𝑢2 … , 𝑢𝑘 están generados por algoritmos congruenciales con ciclos de
periodo 𝑐1 , 𝑐2 … , 𝑐𝑘 , respectivamente, entonces la parte fraccionaria de
𝑢1 + 𝑢2+ … + 𝑢𝑘 tiene un ciclo de periodo 𝑚. 𝑐. 𝑚. {𝑐1 , 𝑐2 … , 𝑐𝑘 }.
Así, podemos generar la siguiente sucesión de números aleatorios:
5𝑥𝑛−1 + 3 9𝑦𝑛−1 + 7 19𝑧𝑛−1 5𝑥𝑛−1 + 3 9𝑦𝑛−1 + 7 19𝑧𝑛−1

𝑤𝑛 = + + −[ + + ]
31 64 256 31 64 256
Con periodo 𝑝 = 𝑚. 𝑐. 𝑚. { 3, 64, 64 } = 192.
6
Numérica Nombre:
Generación de variables aleatorias

Ejercicio 6
a) Describe el algoritmo de la transformada inversa.
Sea 𝑋 una variable aleatoria con función de distribución 𝐹(𝑋). Queremos generar
una muestra aleatoria que se ajuste a esta distribución.
Algoritmo:
1. Generar un valor aleatorio 𝑟 con distribución uniforme en el intervalo (0,1)
2. Tomar 𝑥 = 𝐹 −1 (𝑟) como un valor de la muestra.
3. Volver al paso 1 y repetir el proceso hasta que el tamaño de la muestra sea
adecuado.
b) Calcula mediante el método de la transformada inversa tres valores aleatorios

siguiendo la distribución:
𝑥
, si 0 ≤ 𝑥 ≤ 2
𝑓(𝑥) = {2
0, en caso contrario
Primero hallamos la función de distribución:
0, 𝑠𝑖 𝑥 < 0
𝑥 𝑥
𝑡
𝐹(𝑥) = ∫ 𝑓(𝑡) 𝑑𝑡 = ∫ 𝑑𝑡, 𝑠𝑖 0 ≤ 𝑥 ≤ 2
−∞ 0 2
{ 1, 𝑠𝑖 𝑥 > 2
0, 𝑠𝑖 𝑥 < 0
2
𝐹(𝑥) = 𝑥 , 𝑠𝑖 0 ≤ 𝑥 ≤ 2
4
{ 1, 𝑠𝑖 𝑥 > 2
Usamos los primeros valores de la tabla obtenida en el Ejercicio 4:
𝑟1 = 0.010559, 𝑟2 = 0.433472 y 𝑟3 = 0.772888.
7
Numérica Nombre:
Teniendo en cuenta que la región de interés, donde la función de distribución 𝐹 es

invertible, es el intervalo [0,2], procedemos a despejar 𝑥 de la ecuación
𝑥2
𝑟=
4
Obteniendo
𝐹 −1 (𝑟) = 2√𝑟
Así, obtenemos la muestra:
𝑥1 = 𝐹 −1 (0.010559) = 2√0.010559 = 𝟎. 𝟐𝟎𝟓𝟓𝟏𝟓
𝑥2 = 𝐹 −1 (0.433472 ) = 2√0.433472 = 𝟏. 𝟑𝟏𝟔𝟕𝟕𝟏
𝑥3 = 𝐹 −1 (0.772888) = 2√0.772888 = 𝟏. 𝟕𝟓𝟖𝟐𝟖𝟏
c) Elabora una función en Matlab que utilice la función del ejercicio 0 para generar
valores aleatorios siguiendo esta distribución.
function u = gen_var_traninv()
persistent X;
a=41;
b=9;
m=2^14;
if isempty(X)
X = 4;
r = gen_num_alea(a, b, m, X);
else
r = gen_num_alea(a, b, m);
end
u = 2*sqrt(r);
end
8
Numérica Nombre:
Ejercicio 7
a) Describe el algoritmo del método de la composición.
Este método se aplica cuando la función de distribución, 𝐹(𝑥) (o de densidad, 𝑓(𝑥))
se puede escribir como combinación convexa de otras funciones de distribución ( o
de densidad).
𝑛 𝑛
𝐹(𝑥) = ∑ 𝑝𝑖 𝐹𝑖 (𝑥) ≡ 𝑓(𝑥) = ∑ 𝑝𝑖 𝑓𝑖 (𝑥)

𝑖=1 𝑖=1
𝑛
Donde los valores 𝑝𝑖 satisfacen, 𝑝𝑖 ≥ 0 𝑦 ∑ 𝑝𝑖 = 1

𝑖=1
Algoritmo:
1. Escribir la función de distribución como combinación convexa
𝑛
𝐹(𝑥) = ∑ 𝑝𝑖 𝐹𝑖 (𝑥)
𝑖=1
2. Generar un valor aleatorio 𝑟 con distribución uniforme en el intervalo (0,1)

3. Si 𝑟 < 𝑝1 definir 𝑘 = 1, en otro caso determinar el valor de 𝑘 para el cual
𝑘−1 𝑘
∑ 𝑝𝑖 ≤ 𝑟 ≤ ∑ 𝑝𝑖
𝑖=1 𝑖=1
4. Generar un valor aleatorio 𝑢 con distribución uniforme en el intervalo (0,1)

5. Tomar 𝑥 = 𝐹𝑘−1 (𝑢) como un valor de la muestra.
6. Volver al paso 1 y repetir el proceso hasta que el tamaño de la muestra sea
adecuado.
b) Calcula mediante el método de la composición tres valores aleatorios siguiendo la

distribución:
1 3(𝑥 + 1)2 𝑒𝑥
𝑓(𝑥) = { + + , si 0 ≤ 𝑥 ≤ 1
4 14 4𝑒 − 4
0 , en caso contrario
1. Para 0≤𝑥 ≤1,
1 3 2 𝑒𝑥
𝑓(𝑥) = + (𝑥 + 2𝑥 + 1) +
4 14 4𝑒 − 4
1 3 2 3 3 𝑒𝑥
= + 𝑥 + 𝑥+ +
4 14 7 14 4𝑒 − 4
9
Numérica Nombre:
13 3 2 3 𝑒𝑥
= + 𝑥 + 𝑥+ (∗)
28 14 7 4𝑒 − 4
13 1 3 1 𝑒𝑥 − 1
= + 3𝑥 2 + 2𝑥 + ( )
28 14 14 4 𝑒−1
Es decir,
13 1 3 1
𝑓(𝑥) = 𝑓1 (𝑥) + 𝑓2 (𝑥) + 𝑓3 (𝑥) + 𝑓4 (𝑥)
28 14 14 4
Donde
𝑒𝑥
𝑓1 (𝑥) = 1, 𝑓2 (𝑥) = 2𝑥, 𝑓3 (𝑥) = 3𝑥 2 , 𝑓4 (𝑥) =
𝑒−1
Nota: los valores 𝑝𝑖 los obtuvimos integrando entre 0 y 1 cada sumando en (*).
1
3 3
Por ejemplo, 𝑝3 = ∫ 𝑥 𝑑𝑥 = . Esto garantiza que las funciones 𝑓1 , 𝑓2 , 𝑓3 y 𝑓4 sean
7 14
0
funciones de densidad.
La función de distribución en el intervalo [0,1] es
𝑥
13 3 2 3 𝑒𝑡
𝐹(𝑥) = ∫ ( + 𝑡 + 𝑡+ ) 𝑑𝑡
28 14 7 4𝑒 − 4
0
13 1 3 3 𝑒𝑥 − 1
= 𝑥+ 𝑥 + 𝑥2 +
28 14 14 4𝑒 − 4
13 1 3 2 1 𝑒𝑥 − 1
= 𝑥 + 𝑥3 + 𝑥 + ( )
28 14 14 4 𝑒−1
Que podemos escribir en la forma:
13 1 3 1
𝐹(𝑥) = 𝐹1 (𝑥) + 𝐹2 (𝑥) + 𝐹3 (𝑥) + 𝐹4 (𝑥)
28 14 14 4
Donde
𝑒𝑥 − 1
𝐹1 (𝑥) = 𝑥, 𝐹2 (𝑥) = 𝑥 3 , 𝐹3 (𝑥) = 𝑥 2 , 𝐹4 (𝑥) =
𝑒−1
10
Numérica Nombre:
Nótese que además
13 1 3 1
+ + + =1
28 14 14 4
Las inversas de estas funciones son:
1⁄
𝐹1−1 (𝑥) = 𝑥, 𝐹2−1 (𝑥) = 𝑥 3, 𝐹3−1 (𝑥) = √𝑥, 𝐹4−1 (𝑥) = ln((𝑒 − 1)𝑥 + 1)
2. Nuevamente vamos a usar los primeros valores de la tabla del ejercicio 4:
𝑟1 = 0.010559, 𝑟2 = 0.433472 y 𝑟3 = 0.772888.
3. Los valores 𝑝1 < 𝑝1 + 𝑝2 < 𝑝1 + 𝑝2 + 𝑝3 < 𝑝1 + 𝑝2 + 𝑝3 + 𝑝4 son
13 15 21
< < <1
28 28 28
que aproximadamente son
0.464 < 0.536 < 0.750 < 1
Tenemos entonces que

𝑟1 < 𝑝1 , 𝑟2 < 𝑝1 , 𝑝3 < 𝑟3 < 𝑝4
4. Generamos 3 números aleatorios usando una distribución uniforme, independiente

de la que ya usamos, por ejemplo gen_num_alea(17, 3, 2^14, 13) seguido de dos
veces gen_num_alea(17, 3, 2^14):
𝑢1 = 0.013672, 𝑢2 = 0.232605, 𝑢3 = 0.954468
5. Teniendo en cuenta los resultados anteriores, los valores de la muestra son:
𝑥1 = 𝐹1−1 (𝑢1 ) = 𝐹1−1 (0.013672) = 𝟎. 𝟎𝟏𝟑𝟔𝟕𝟐
𝑥2 = 𝐹1−1 (𝑢2 ) = 𝐹1−1 (0.232605) = 𝟎. 𝟐𝟑𝟐𝟔𝟎𝟓
𝑥3 = 𝐹4−1 (𝑢4 ) = 𝐹4−1 (0.954468) = ln((𝑒 − 1) ⋅ 0.954468 + 1) = 𝟎. 𝟗𝟕𝟎𝟕𝟗𝟔
11
Numérica Nombre:
function u = gen_var_compo()
persistent X;
persistent Y;
if isempty(X)
[u1, X] = gen_num_alea(41, 9, 2^14, 4);
else
[u1, X] = gen_num_alea(41, 9, 2^14, X);
end
if isempty(Y)
[u2, Y] = gen_num_alea(17, 3, 2^14, 13);
else
[u2, Y] = gen_num_alea(17, 3, 2^14, Y);
end
if(u1<0.464)
u = u2;
elseif(u1<0.536)
u = u2^(1/3);
elseif(u1<0.750)
u = sqrt(u2);
else
u = log(u2*(exp(1)-1)+1);
end
end
Ejercicio 8
a) Describe el algoritmo del método de aceptación rechazo.
Sea 𝑋 y 𝑌 variables aleatorias con funciones de densidad 𝑓 y 𝑔, respectivamente,

definidas en un intervalo 𝐼 ⊆ ℝ. Supongamos que tenemos un método para generar
muestras de la variable 𝑌. Si existe un número 𝑐 ≥ 1 tal que
𝑓(𝑥)
≤ 𝑐 𝑝𝑎𝑟𝑎 𝑡𝑜𝑑𝑜 𝑥 ∈ 𝐼
𝑔(𝑥)
Entonces podemos obtener muestras de la variable 𝑋 con el siguiente algoritmo:
12
Numérica Nombre:
1. Se generan 𝑟 𝑐𝑜𝑛 𝑑𝑖𝑠𝑡𝑟𝑖𝑏𝑢𝑐𝑖ó𝑛 𝑢𝑛𝑖𝑓𝑜𝑟𝑚𝑒 𝑒𝑛 (0,1) y 𝑥 con distribución 𝑔.

2. Se genera 𝑦 con distribución uniforme en (0, 𝑐𝑔(𝑥)).
3. Si 𝑦 ≤ 𝑓(𝑥), se toma 𝑥 como valor de la muestra. Si no vuelve al paso 1.
4. Se repite el proceso hasta que el número de muestras sea adecuado.
𝑓(𝑥)
Observación: c suele calcularse como el máximo de ℎ(𝑥) = en el intervalo 𝐼
𝑔(𝑥)
b) Calcula mediante el método de aceptación-rechazo tres valores aleatorios siguiendo

la distribución:
1 𝑥
− + , 𝑠𝑖 2 ≤ 𝑥 ≤ 6
6 12
𝑓(𝑥) = 4 𝑥
− , si 6 ≤ 𝑥 ≤ 8
3 6
{ 0, en caso contrario
1 𝑥 1
De 2 ≤ 𝑥 ≤ 6 obtenemos que 0 ≤ − + ≤
6 12 3
4 𝑥 1
De 6 ≤ 𝑥 ≤ 8 obtenemos que 0 ≤ − ≤
3 6 3
1
Entonces 𝑓(𝑥) ≤ para 2 ≤ 𝑥 ≤ 8
3
1
Que es lo mismo que 𝑓(𝑥) ≤ 2 ⋅ para 2 ≤ 𝑥 ≤ 8
6
1
Nótese que 𝑔(𝑥) = 6 es función de densidad en el intervalo 𝐼 = (2, 8)
De esta forma se cumple

𝑓(𝑥)
≤ 𝑐, 𝑐𝑜𝑛 𝑐 = 2
𝑔(𝑥)
Ya tenemos las condiciones, ahora apliquemos el algoritmo:
1. Para los valores de 𝑟 podemos usar los ya obtenidos en el ejercicio 4.

Los valores de 𝑥 se obtienen haciendo 𝑥 = 2 + 6𝑟.
2. Los valores de 𝑦 los obtenemos a partir de la distribución uniforme
1
u = gen_num_alea(17, 3, 2^14 ) haciendo 𝑦 = 3 𝑢
1
Nótese que 𝑐 ⋅ 𝑔(𝑥) = 3 , por lo tanto 𝑦~(0, 𝑐 ⋅ 𝑔(𝑥))
3. En la siguiente tabla se muestran los resultados hasta obtener los cuatro primeros
valores aceptados para la muestra.
13
Numérica Nombre:
r x u y 𝑓(𝑥) 𝑦 ≤ 𝑓(𝑥) muestra

0.010559 2.063354 0.013672 0.004557 0.005280 SI 2.063354
0.433472 4.600830 0.232605 0.077535 0.216736 SI 4.600830
0.772888 6.637329 0.954468 0.318156 0.227112 NO
0.688965 6.133789 0.226135 0.075378 0.311035 SI 6.133789
0.248108 3.488647 0.844482 0.281494 0.124054 NO
0.172974 3.037842 0.356384 0.118795 0.086487 NO
0.092468 2.554810 0.058716 0.019572 0.046234 SI 2.554810
function u=gen_var_acerec()
persistent X;
persistent Y;
if isempty(X)
X=4;
end
[r1, X] = gen_num_alea(41, 9, 2^14, X);

x=2+6*r1;
if(x<6)
f=(x/12)-(1/6);
else
f=(4/3)-(x/6);
end
if isempty(Y)
Y=13;
end
[r2,Y]= gen_num_alea(17, 3, 2^14, Y);

y=(1/3)*r2;
while(y>f)
[r1, X] = gen_num_alea(41, 9, 2^14, X);
x=2+6*r1;
14
Numérica Nombre:
if(x<6)
f=(x/12)-(1/6);
else
f=(4/3)-(x/6);
end
[r2,Y]= gen_num_alea(17, 3, 2^14, Y);
y=(1/3)*r2;
end
u=x;
end
En el código anterior se mantiene el paso de las variables X y Y por parámetro para que
las distribuciones de r1 y r2 sean independientes. Nótese que X y Y son variables
persistentes, r1 se genera usando X y r2 se genera usando Y.
Ejercicio 9
Para comparar las distribuciones de las muestras con las funciones de densidad vamos
a graficar simultáneamente cada histograma con la función de densidad al lado
1.
𝑥
, si 0 ≤ 𝑥 ≤ 2
𝑓(𝑥) = {2
0, en caso contrario
Código Matlab para generar la muestra y hacer las gráficas:
cantidad = 10000;
U = zeros(cantidad, 1);
for i=1 : cantidad
U(i) = gen_var_traninv(); % generación de las muestras
end
subplot(1, 2, 1)
histogram(U, 20, 'Normalization', 'pdf'); % gráfica del histograma
daspect([1 1 1]);
title('Histograma pdf1');
x = 0:0.1:2;
y = x/2;
15
Numérica Nombre:
subplot(1, 2, 2)
plot(x,y); % gráfica de la función de densidad original
daspect([1 1 1]);
xlabel('x');
title('función de densidad 1');
Gráfica resultante:
Vemos que la muestra seleccionada se distribuye de la forma esperada.
2.
1 3(𝑥 + 1)2 𝑒𝑥
𝑓(𝑥) = { + + , si 0 ≤ 𝑥 ≤ 1
4 14 4𝑒 − 4
0 , en caso contrario
cantidad = 10000;
U = zeros(cantidad, 1);
for i=1 : cantidad
U(i) = gen_var_compo(); % generación de las muestras
End
subplot(1, 2, 1)
daspect([1 1 1]); axis([0 1 0 1.6]);
16
Numérica Nombre:
x = 0:0.1:1;
y = 1/4+(3*(x+1).^2)/14+exp(x)/(4*exp(1)-1);
subplot(1, 2, 2)
plot(x,y); % gráfica de la función de densidad original
daspect([1 1 1]); axis([0 1 0 1.6]);
xlabel('x');
3.
1 𝑥
− + , 𝑠𝑖 2 ≤ 𝑥 ≤ 6
6 12
𝑓(𝑥) = 4 𝑥
− , si 6 ≤ 𝑥 ≤ 8
3 6
{ 0, en caso contrario
17
Numérica Nombre:
cantidad = 10000; U = zeros(cantidad, 1);

for i=1 : cantidad
U(i) = gen_var_acerec(); % generación de las muestras
End
subplot(1, 2, 1)
axis([2 8 0 0.4]);
x1 = 2:0.1:6; x2 = 6:0.1:8;
y1 = -1/6 +x1/12; y2 = 4/3-x2/6;
subplot(1, 2, 2)
plot(x1, y1, x2, y2); % gráfica de la función de densidad original
axis([2 8 0 0.4]);
xlabel('x');
18
Numérica Nombre:
Simulación de eventos discretos y análisis estadístico

Ejercicio 10
Intervalo de confianza para la media
Con desviación conocida:
𝜎 𝜎
𝑥̅ − 𝑧1−𝛼/2 ⋅ ≤ 𝜇 ≤ 𝑥̅ + 𝑧1−𝛼/2 ⋅
√𝑛 √𝑛
Donde 𝑧1−𝛼/2 es el valor crítico de la distribución normal que deja un área de 𝛼/2 en la
cola derecha.
Con desviación desconocida: Teniendo en cuenta que en Matlab la función std(lista)

devuelve la desviación estándar corregida, usaremos el intervalo en la forma
𝑆𝑛−1 𝑆𝑛−1
𝑥̅ − 𝑡1−𝛼/2 ⋅ ≤ 𝜇 ≤ 𝑥̅ + 𝑡1−𝛼/2 ⋅
√𝑛 √𝑛
Donde 𝑆𝑛−1 es la desviación estándar corregida y 𝑡1−𝛼/2 es el valor crítico de la

distribución 𝑡, con 𝑛 − 1 grados de libertad, que deja un área de 𝛼/2 en la cola derecha.
El código de la función en Matlab es el siguiente:

function [linf, lsup] = ic_media(lista, alpha, desviacion)
n=length(lista);
media=mean(lista);
if exist('desviacion','var')
z=norminv(1-alpha/2);
linf=media-z*desviacion/sqrt(n);
lsup=media+z*desviacion/sqrt(n);
else
desviacion=std(lista);
t=tinv(1-alpha/2,n-1);
linf=media-t*desviacion/sqrt(n);
lsup=media+t*desviacion/sqrt(n);
end
end
19
Numérica Nombre:
Intervalo de confianza para la desviación estándar

Usaremos el intervalo en la forma
2
(𝑛 − 1)𝑆𝑛−1 2
(𝑛 − 1)𝑆𝑛−1
√ 2 ≤ 𝜎 ≤ √ 2
𝜒1−𝛼∕2 𝜒𝛼∕2
2 2 2
Donde 𝑆𝑛−1 es la varianza corregida (insesgada) y, 𝜒𝛼∕2 y 𝜒1−𝛼∕2 son los valores
críticos de la distribución 𝜒 2 , con 𝑛 − 1 grados de libertad, que dejan un área de 𝛼/2 en
las colas izquierda y derecha, respectivamente.
El código en Matlab de la función es el siguiente:
function [linf, lsup] = ic_desv(lista, alpha)

s2 = var(lista);
n = length(lista);
linf = sqrt((n-1)*s2/chi2inv(1-alpha/2, n-1));
lsup = sqrt((n-1)*s2/chi2inv(alpha/2, n-1));
end
Ejercicio 11
La función propaga_orbita toma una posición inicial 𝑥 y una velocidad inicial 𝑣 de
una nave espacial alrededor de la Tierra y las propaga durante 𝑡 unidades de tiempo.
El último parámetro puede ser 0 o 1. Cuando es 1 se activa el efecto de la atmósfera
sobre la nave.
El siguiente código Matlab sirve para obtener datos que nos permitan comparar el
comportamiento de la función propaga_orbita con y sin atmósfera:
x0=[1.5,0,0]; % posición de referencia

v0=[0,1,0]; % velocidad inicial
t=107.1; % unidades de tiempo
%{
ejecutamos la función propaga_orbita 10000 veces sin atmósfera y
calculamos la distancia al centro de la tierra de la posición final
%}
distancias0=zeros(1,10000);
for i=1:10000
20
Numérica Nombre:
r1 = random('normal',0,0.05);
r = [r1,r2,r3];
x = x0+r; % posición inicial
[x,v,t] = propaga_orbita(t,x,v0,0);
distancias0(i) = norm(x); % distancia al centro
end
%{
Hallamos intervalos de confianza para la media y la desviación estándar
de las distancias calculadas
%}
[inf_media0, sup_media0]=ic_media(distancias0,0.05);
[inf_desv0, sup_desv0]=ic_desv(distancias0,0.05);
distancia_media0=mean(distancias0);
desviacion0=std(distancias0);
% Repetimos el procedimiento con atmósfera

distancias1=zeros(1,10000);
for i=1:10000
r1=random('normal',0,0.05);
r=[r1,r2,r3];
x=x0+r;
[x,v,t]=propaga_orbita(t,x,v0,1);
distancias1(i)=norm(x);
end
[inf_media1, sup_media1]=ic_media(distancias1,0.05);
[inf_desv1, sup_desv1]=ic_desv(distancias1,0.05);
distancia_media1=mean(distancias1);
desviacion1=std(distancias1);
% mostramos los resultados
fprintf('Resultados sin atmósfera\n\n');
fprintf(' Media_ 0');
disp(distancia_media0);
21
Numérica Nombre:
fprintf(' Desviación_0’);
disp(desviacion0);
fprintf(' IC_Media_0');
disp([inf_media0 sup_media0]);
fprintf(' IC_Desviación_0');
disp([inf_desv0 sup_desv0]);
fprintf('Resultados con atmósfera\n')
fprintf(' Media_1');
disp(distancia_media1);
fprintf(' Desviación_1');
disp(desviacion1);
fprintf(' IC_Media_1');
disp([inf_media1 sup_media1]);
fprintf(' IC_Desviación_1');
disp([inf_desv1 sup_desv1]);
Una ejecución del código anterior nos arrojó en consola los siguientes resultados:
Resultados sin atmósfera
Media_ 0 3.4618
Desviación_0 1.1870
IC_Media_0 3.4385 3.4850
IC_Desviación_0 1.1708 1.2037
Resultados con atmósfera
Media_1 3.3358
Desviación_1 1.1342
IC_Media_1 3.3135 3.3580
IC_Desviación_1 1.1187 1.1501
22
Numérica Nombre:
Ahora hagamos una prueba de hipótesis para determinar si la atmósfera ejerce efecto
o no sobre el movimiento de la nave. Asumimos que ejerce efecto si las medias
teóricas son diferentes.
𝐻0 : 𝜇1 = 𝜇2 (Hipótesis nula)
𝐻𝑎 : 𝜇1 ≠ 𝜇2 (Hipótesis alternativa)
Equivalentemente:
𝐻0 : 𝜇1 − 𝜇2 = 0
𝐻𝑎 : 𝜇1 − 𝜇2 ≠ 0
Estadístico:
𝑥̅ − 𝜇
𝑧=
𝑆2 𝑆2
√ 1+ 2
𝑛1 𝑛2
Donde: 𝜇 = 𝜇1 − 𝜇2 , 𝑥̅ = Media_0 – Media_1, 𝑆12 = Desviación_0,

𝑆22 = Desviación_1 y 𝑛1 = 𝑛2 = 10000.
Al reemplazar los valores obtenemos

𝑧 = 8.27
La región de aceptación está entre 𝑧𝛼∕2 y 𝑧1−𝛼∕2 , esto es, entre -1.96 y 1.96.
𝑧 = 8.27 está fuera de la región de aceptación, por lo tanto, podemos concluir que la
atmósfera ejerce efecto sobre el movimiento de la nave.
Ejercicio 12
» Simulación de 10000 lanzamientos de una moneda:
Código Matlab:
numeros=rand(1,10000);
subplot(2,2,1);
plot(numeros,'.');
title('números aleatorios');
subplot(2,2,2)
histogram (numeros, 'BinMethod','auto');
title ('Histograma');
23
Numérica Nombre:
for i=1:10000
if(rand(i<0.5))
numeros(i)=0;
else
numeros(i)=1;
end
end
subplot(2,2,3)
plot(numeros,'.');
title('Lanzamientos');
subplot(2,2,4)
histogram(numeros,'BinMethod','auto');
title ('Distribución de Lanzamientos');
En la lista ‘numeros’, 0 representa cara (O) y 1 representa cruz (X).
El código anterior, además de generar la lista de lanzamientos, nos proporciona el

siguiente resultado gráfico:
24
Numérica Nombre:
Con los resultados obtenidos en la lista ‘numeros’, realizamos las siguientes pruebas de
hipótesis:
1. Test de hipótesis de un lanzamiento (únicamente valoraremos si es cara o cruz).

Código Matlab:
n0=0;
n1=0;
for i=1:10000
if numeros(i)==0
n0=n0+1;
else
n1=n1+1;
end
end
disp([n0, n1]);
Salida: frecuencias correspondientes a O y X, respectivamente

4941 5059
Prueba de hipótesis
𝐻0 : 𝑝 = 0.5 (por lo tanto 𝑞 = 0.5)
𝐻𝑎 : 𝑝 ≠ 0.5
Estadístico:
(4941 − 5000)2 (5059 − 5000)2
𝜒[10000,2 ]2 = + = 1.3924
5000 5000
Valor crítico de la distribución
2
𝜒0.95;1 = 3.8415
Conclusión:
El estadístico de la prueba es menor que el valor crítico, por lo tanto, se acepta la
hipótesis nula.
2. Test de hipótesis de dos lanzamientos (agruparemos los lanzamientos de dos en dos)

Código Matlab:
n00=0;
n01=0;
n10=0;
25
Numérica Nombre:
n11=0;
for i=1:5000
if numeros(2*i-1)==0 && numeros(2*i)==0
n00=n00+1;
elseif numeros(2*i-1)==0 && numeros(2*i)==1
n01=n01+1;
n10=n10+1;
n11=n11+1;
end
end
Salida: frecuencias correspondientes a OO, OX, XO, XX, respectivamente.

1218 1198 1307 1277
Prueba de hipótesis:
𝐻0 : 𝑝1 = 𝑝2 = 𝑝3 = 𝑝4 = 0.25
𝐻𝑎 : No es cierto que 𝑝1 = 𝑝2 = 𝑝3 = 𝑝4 = 0.25
Estadístico: tengamos en cuenta que, en este caso, el tamaño de la muestra es 5000
porque son parejas.
(1218 − 1250)2 (1198 − 1250)2 (1307 − 1250)2 (1277 − 1250)2
𝜒[5000,4]2 = + + +
1250 1250 1250 1250
= 6.1648
Valor crítico de la distribución:
2
𝜒0.95;3 = 7.8147
Conclusión:
hipótesis nula.
3. Test de hipótesis de tres lanzamientos:

Código Matlab:
n000=0;
n001=0;
n010=0;
n100=0;
26
Numérica Nombre:
n011=0;
n101=0;
n110=0;
n111=0;
for i=1:3333
if numeros(3*i-2)==0 && numeros(3*i-1)==0 && numeros(3*i)==0
n000=n000+1;
elseif numeros(3*i-2)==0 && numeros(3*i-1)==0 && numeros(3*i)==1
n001=n001+1;
n010=n010+1;
n100=n100+1;
n011=n011+1;
n101=n101+1;
n110=n110+1;
n111=n111+1;
end
end
Salida: frecuencias correspondientes a OOO, OOX, OXO, XOO, OXX, XOX, XXO, XXX,
respectivamente.
393 412 434 416 399 412 426 441
𝐻0 : 𝑝1 = 𝑝2 = 𝑝3 = 𝑝4 = 𝑝5 = 𝑝6 = 𝑝7 = 𝑝8 = 0.125
𝐻𝑎 : No es cierto que 𝑝1 = 𝑝2 = 𝑝3 = 𝑝4 = 𝑝5 = 𝑝6 = 𝑝7 = 𝑝8 = 0.125
Estadístico: 𝑛𝑖 𝑝𝑖 = 3333 ⋅ 0.125 = 416.625 en todos los casos, por lo tanto
(393 − 416.625)2 (412 − 416.625)2 (434 − 416.625)2 (416 − 416.625)2
𝜒[3333,7]2 = + + +
416.625 416.625 416.625 416.625
(399 − 416.625) 2 (412 − 416.625) 2 (426 − 416.625) 2 (441 − 416.625)2
+ + + +
416.625 416.625 416.625 416.625
𝜒[3333,7]2 = 4.55
27
Numérica Nombre:

2
𝜒0.95;7 =14.0671
Conclusión:
hipótesis nula.
» Ahora repetimos el experimento con una moneda trucada, donde 𝑃("𝑐𝑎𝑟𝑎") = 0.6 y
𝑃("𝑐𝑟𝑢𝑧") = 0.4
Simulación de 10000 lanzamientos de una moneda trucada:
Código Matlab:
numeros=rand(1,10000);
subplot(2,2,1);
plot(numeros,'.');
title('números aleatorios');
subplot(2,2,2)
histogram (numeros, 'BinMethod','auto');
title ('Histograma');
for i=1:10000
if(rand(i<0.6))
numeros(i)=0;
else
numeros(i)=1;
end
end
subplot(2,2,3)
plot(numeros,'.');
title('Lanzamientos');
subplot(2,2,4)
histogram(numeros,'BinMethod','auto');
title ('Distribución de Lanzamientos');
Gráfica de salida:
28
Numérica Nombre:
4. Test de hipótesis de un lanzamiento (únicamente valoraremos si es cara o cruz).

Código Matlab:
n0=0;
n1=0;
for i=1:10000
if numeros(i)==0
n0=n0+1;
else
n1=n1+1;
end
end
disp([n0, n1]);
Salida: frecuencias de O y X, respectivamente.

5975 4025
Prueba de hipótesis
𝐻0 : 𝑝 = 0.6 (por lo tanto 𝑞 = 0.4)
𝐻𝑎 : 𝑝 ≠ 0.6
29
Numérica Nombre:
Estadístico:
(5975 − 0.6 ∗ 10000)2 (4025 − 0.4 ∗ 10000)2
𝜒[10000,2]2 = + = 0.2604
0.6 ∗ 10000 0.4 ∗ 10000
Valor crítico de la distribución
2
𝜒0.95;1 = 3.8415
Conclusión:
hipótesis nula.
5. Test de hipótesis de dos lanzamientos (agruparemos los lanzamientos de dos en dos)

Código Matlab:
n00=0;
n01=0;
n10=0;
n11=0;
for i=1:5000
if numeros(2*i-1)==0 && numeros(2*i)==0
n00=n00+1;
n01=n01+1;
n10=n10+1;
n11=n11+1;
end
end
Salida: frecuencias de OO, OX, XO y XX, respectivamente.

1784 1176 1231 809
𝐻0 : 𝑝1 = 0.36, 𝑝2 = 0.24, 𝑝3 = 0.24, 𝑝4 = 0.16
𝐻𝑎 : No es cierto que 𝑝1 = 0.36, 𝑝2 = 0.24, 𝑝3 = 0.24, 𝑝4 = 0.16
Estadístico:
30
Numérica Nombre:
(1784 − 0.36 ∗ 5000)2 (1176 − 0.24 ∗ 5000)2

𝜒[5000,4]2 = +
0.36 ∗ 5000 0.24 ∗ 5000
(1231 − 0.24 ∗ 5000)2 (809 − 0.16 ∗ 5000)2
+ +
0.24 ∗ 5000 0.16 ∗ 5000
𝜒[5000,4]2 = 1.5243
2
𝜒0.95;3 = 7.8147
Conclusión:
hipótesis nula.
6. Test de hipótesis de tres lanzamientos:

Código Matlab:
n000=0;
n001=0;
n010=0;
n100=0;
n011=0;
n101=0;
n110=0;
n111=0;
for i=1:3333
if numeros(3*i-2)==0 && numeros(3*i-1)==0 && numeros(3*i)==0
n000=n000+1;
n001=n001+1;
n010=n010+1;
n100=n100+1;
n011=n011+1;
n101=n101+1;
31
Numérica Nombre:
n110=n110+1;
n111=n111+1;
end
end
Salida:
frecuencias de OOO, OOX, OXO, XOO, OXX, XOX, XXO y XXX, respectivamente.
713 503 470 465 306 325 329 222
𝐻0 : 𝑝1 = 0.216, 𝑝2 = 𝑝3 = 𝑝4 = 0.144, 𝑝5 = 𝑝6 = 𝑝7 = 0.096, 𝑝8 = 0.064
𝐻𝑎 : No es cierto 𝐻0
Estadístico:
(713 − 0.216 ∗ 3333)2 (503 − 0.144 ∗ 3333)2 (470 − 0.144 ∗ 3333)2
𝜒[3333,8]2 = + +
0.216 ∗ 3333 0.144 ∗ 3333 0.144 ∗ 3333
(465 − 0.144 ∗ 3333)2 (306 − 0.096 ∗ 3333)2
+ +
0.144 ∗ 3333 0.096 ∗ 3333
(325 − 0.096 ∗ 3333)2 (329 − 0.096 ∗ 3333)2 (222 − 0.0643333)2
+ + +
0.096 ∗ 3333 0.096 ∗ 3333 0.0643333
𝜒[3333,8]2 = 3.1433
2
𝜒0.95;7 = 14.0671
Conclusión:
hipótesis nula.
32
Numérica Nombre:
A
Sí No
veces
Todos los miembros se han integrado al trabajo del
X
grupo
Todos los miembros participan activamente X
Todos los miembros respetan otras ideas aportadas X
Todos los miembros participan en la elaboración del
X
informe
Me he preocupado por realizar un trabajo cooperativo
X
con mis compañeros
Señala si consideras que algún aspecto del trabajo en
X
grupo no ha sido adecuado
33

Simulacion de Sistemas Continuos

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Simulacion de Sistemas Continuos

Cargado por

Copyright:

Formatos disponibles

Universidad Internacional de La Rioja

Presentado por: Fernando Manrique Ochoa

Fecha: 27 de enero de 2020

Generación de números aleatorios

» Métodos de generación de números aleatorios congruenciales

o Métodos congruenciales mixtos (𝑏 ≠ 0).

o Métodos congruenciales multiplicativos ( 𝑏 = 0)

Caso 𝑏 ≠ 0, 𝑚 cualquier valor

Caso 𝑏 = 0, 𝑚 cualquier valor

2 mod 53 = 2 210 mod 53 = 17 219 mod 53 = 12 228 mod 53 = 49

237 mod 53 = 19 241 mod 53 = 39 245 mod 53 = 41 249 mod 53 = 20

Necesitamos que 2𝑘−2 > 50, entonces tomemos 𝒎 = 𝟐𝟖 .

Elijamos 𝑎 ≡ 3 mod 8: 𝒂 = 𝟏𝟏 y 𝑥0 impar: 𝒙𝟎 = 𝟑

Con estas condiciones, el generador es:

𝒙𝒏 = 𝟏𝟏𝒙𝒏−𝟏 𝒎𝒐𝒅 𝟐𝟓𝟔, 𝒙𝟎 = 𝟑

Con periodo máximo, 𝒑 = 𝟐𝟔 = 𝟔𝟒.

function [u, x] = gen_num_alea(a, b, m, x)

cantidad = 10000; % cantidad de números generados

Al ejecutarlo obtenemos la siguiente gráfica:

A continuación mostramos los primeros 100 números generados:

Calcular (y justificar debidamente) el periodo de los métodos.

𝑥3 = 5𝑥2 + 3 mod 31 = 3 𝑚𝑜𝑑 31 = 3 = 𝑥0

Por lo tanto el periodo es 3.

Combinación de los tres generadores:

Observación: 𝑧𝑛 es lineal multiplicativo, pero 𝑥𝑛 y 𝑦𝑛 son lineales mixtos, por lo tanto

distribuidas 𝑢(0,1), entonces la parte fraccionaria de 𝑈1 + ⋯ + 𝑈𝑘 también

sigue una distribución 𝑢(0,1)

Así, podemos generar la siguiente sucesión de números aleatorios:

5𝑥𝑛−1 + 3 9𝑦𝑛−1 + 7 19𝑧𝑛−1 5𝑥𝑛−1 + 3 9𝑦𝑛−1 + 7 19𝑧𝑛−1

Con periodo 𝑝 = 𝑚. 𝑐. 𝑚. { 3, 64, 64 } = 192.

Generación de variables aleatorias

b) Calcula mediante el método de la transformada inversa tres valores aleatorios

Primero hallamos la función de distribución:

Usamos los primeros valores de la tabla obtenida en el Ejercicio 4:

𝑟1 = 0.010559, 𝑟2 = 0.433472 y 𝑟3 = 0.772888.

Teniendo en cuenta que la región de interés, donde la función de distribución 𝐹 es

Así, obtenemos la muestra:

𝑥1 = 𝐹 −1 (0.010559) = 2√0.010559 = 𝟎. 𝟐𝟎𝟓𝟓𝟏𝟓

𝑥2 = 𝐹 −1 (0.433472 ) = 2√0.433472 = 𝟏. 𝟑𝟏𝟔𝟕𝟕𝟏

𝑥3 = 𝐹 −1 (0.772888) = 2√0.772888 = 𝟏. 𝟕𝟓𝟖𝟐𝟖𝟏

𝐹(𝑥) = ∑ 𝑝𝑖 𝐹𝑖 (𝑥) ≡ 𝑓(𝑥) = ∑ 𝑝𝑖 𝑓𝑖 (𝑥)

Donde los valores 𝑝𝑖 satisfacen, 𝑝𝑖 ≥ 0 𝑦 ∑ 𝑝𝑖 = 1

2. Generar un valor aleatorio 𝑟 con distribución uniforme en el intervalo (0,1)

4. Generar un valor aleatorio 𝑢 con distribución uniforme en el intervalo (0,1)

b) Calcula mediante el método de la composición tres valores aleatorios siguiendo la

1. Para 0≤𝑥 ≤1,

La función de distribución en el intervalo [0,1] es

Que podemos escribir en la forma:

Nótese que además

Las inversas de estas funciones son:

2. Nuevamente vamos a usar los primeros valores de la tabla del ejercicio 4:

𝑟1 = 0.010559, 𝑟2 = 0.433472 y 𝑟3 = 0.772888.

3. Los valores 𝑝1 < 𝑝1 + 𝑝2 < 𝑝1 + 𝑝2 + 𝑝3 < 𝑝1 + 𝑝2 + 𝑝3 + 𝑝4 son

que aproximadamente son

0.464 < 0.536 < 0.750 < 1

Tenemos entonces que

4. Generamos 3 números aleatorios usando una distribución uniforme, independiente

5. Teniendo en cuenta los resultados anteriores, los valores de la muestra son:

𝑥1 = 𝐹1−1 (𝑢1 ) = 𝐹1−1 (0.013672) = 𝟎. 𝟎𝟏𝟑𝟔𝟕𝟐

𝑥2 = 𝐹1−1 (𝑢2 ) = 𝐹1−1 (0.232605) = 𝟎. 𝟐𝟑𝟐𝟔𝟎𝟓

𝑥3 = 𝐹4−1 (𝑢4 ) = 𝐹4−1 (0.954468) = ln((𝑒 − 1) ⋅ 0.954468 + 1) = 𝟎. 𝟗𝟕𝟎𝟕𝟗𝟔

Sea 𝑋 y 𝑌 variables aleatorias con funciones de densidad 𝑓 y 𝑔, respectivamente,

Entonces podemos obtener muestras de la variable 𝑋 con el siguiente algoritmo:

1. Se generan 𝑟 𝑐𝑜𝑛 𝑑𝑖𝑠𝑡𝑟𝑖𝑏𝑢𝑐𝑖ó𝑛 𝑢𝑛𝑖𝑓𝑜𝑟𝑚𝑒 𝑒𝑛 (0,1) y 𝑥 con distribución 𝑔.