Simulación de sistemas

Simulación
de Sistemas
Efraı́n Soto Apolinar
Simulación
de Sistemas
Notas por:
Efraı́n Soto Apolinar
PISIS
Monterrey, N.L., México. 2008
Índice
1 Introducción
1.1
5
Conceptos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . .
7
1.1.1
Definiciones . . . . . . . . . . . . . . . . . . . . . . . . . .
9
1.1.2
Etapas del Estudio de Simulación . . . . . . . . . . . . . .
10
1.1.3
Distribuciones de probabilidad . . . . . . . . . . . . . . .
12
1.2
Simulación 01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
1.3
Simulación 02 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
1.3.1
Consideraciones . . . . . . . . . . . . . . . . . . . . . . . .
19
1.3.2
Simulación por computadora . . . . . . . . . . . . . . . .
20
1.3.3
Cálculo analı́tico . . . . . . . . . . . . . . . . . . . . . . .
23
Simulación 03 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
1.4.1
Definiciones . . . . . . . . . . . . . . . . . . . . . . . . . .
25
1.5
Simulación 04 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
31
1.6
Simulación 05 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
35
1.7
Simulación 06 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37
1.4
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
1.8
Simulación 07 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
1.9
Simulación 07 (Reposición) . . . . . . . . . . . . . . . . . . . . .
51
1.10 Simulación 08 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
55
1.11 Movimiento Browniano . . . . . . . . . . . . . . . . . . . . . . . .
59
1.11.1 Bosquejo de experimento . . . . . . . . . . . . . . . . . .
59
1.12 Simulación 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
2 Proyecto Final
2.1
73
Simulación del Recurso Eólico . . . . . . . . . . . . . . . . . . . .
75
2.1.1
Energı́a extraida del viento . . . . . . . . . . . . . . . . .
75
2.1.2
Distribución del viento . . . . . . . . . . . . . . . . . . . .
77
2.1.2.1
Distribución Weibull . . . . . . . . . . . . . . . .
77
2.1.2.2
Distribución Rayleigh . . . . . . . . . . . . . . .
78
2.1.2.3
Distribución de energı́a . . . . . . . . . . . . . .
78
2.1.2.4
Anemómetros digitales . . . . . . . . . . . . . .
79
2.1.2.5
Predicción del recurso eólico . . . . . . . . . . .
79
2.1.3
Un caso especı́fico . . . . . . . . . . . . . . . . . . . . . .
80
2.1.4
Implementación . . . . . . . . . . . . . . . . . . . . . . . .
80
2.1.5
Resultados de la simulación . . . . . . . . . . . . . . . . .
85
2.1.6
Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . .
90
3 End matter
93
3.1
Fuentes bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . .
95
3.2
Términos de uso . . . . . . . . . . . . . . . . . . . . . . . . . . .
97
3.3
Créditos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
99
1
Introducción
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
1.1 Conceptos Básicos
1.1
7
Conceptos Básicos
En esta sección se encuentran algunos conceptos básicos de la simulación de
sistemas.
Definición 1.1.1.
Simulación
Es la imitación de la operación de un proceso o sistema (encontrado en el mundo
real) y su evolución en el tiempo.
El comportamiento de un sistema conforme evoluciona en el tiempo se estudia
desarrollando un modelo de simulación.
Ventajas de la simulación
• Pueden estudiarse nuevas polı́ticas, procedimientos operacionales, reglas
de decisión, flujos de información, procedimientos organizacionales, etc.,
sin afectar la operación normal del sistema real.
• Pueden probarse nuevos diseños mecánicos, sistemas de transporte, etc.,
sin asignar grandes cantidades de recursos financieros para su adquisición.
• Puede probarse la factibilidad del cómo o por qué ciertos fenómenos pueden
ocurrir.
• Podemos acelerar o decelerar un fenómeno en investigación.
• Podemos obtener información acerca de la interacción de las variables.
• Podemos obtener información acerca de la importancia de cada una de las
variables en el desempeño general del sistema.
• Se puede desarrollar análisis de “cuello de botella”, indicando en qué
partes se están retrasando demasiado información, materiales, etc.
• Una simulación puede ayudar a entender cómo opera el sistema.
• Podemos responder preguntas del tipo: “¿Qué pasarı́a si...?”. Esto es
particularmente útil en el diseño de nuevos sistemas.
Desventajas de la simulación
• Construir un modelo requiere de entrenamiento. Es un arte que se aprende
con el tiempo y a través de la práctica. Más aún, si dos personas competentes construyen un modelo para el mismo sistema, pueden tener similitudes, pero es muy poco probable que sean exactamente iguales.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
8
Introducción
• Los resultados de la simulación pueden ser muy difı́ciles de interpretar.
Dado que la mayorı́a de los resultados de las simulaciones son esencialmente variables aleatorias (están basadas en entradas aleatorias), puede
ser difı́cil determinar si una observación es un resultado de las interrelaciones de las variables o de la aleatoriedad.
• La modelación de un sistema y su análisis puede consumir mucho tiempo
y ser costoso. Dedicarse a hacer la simulación de un sistema y su análisis
puede después indicar que este modelo es insuficiente.
• La simulación se utiliza en algunos casos aún cuando podemos encontrar
las soluciones analı́ticamente, o aún preferibles. Esto es verdadero en la
simulación de algunas lı́neas de espera donde hay disponibles modelos de
colas cerradas.
¿Cuándo es apropiada la simulación?
• La simulación permite el estudio, la experimentación, interacciones internas de un sistema, o de un subsistema dentro de un sistema complejo.
• Cambios organizacionales, informáticos y ambientales pueden ser simulados y el efecto de estas alteraciones puede observarse.
• El conocimiento ganado al diseñar un modelo de simulación puede ser de
gran valor para sugerir mejoras en el sistema investigado.
• Al cambiar las entradas del modelo y al observar las salidas, podemos
obtener sugerencias valiosas acerca de cuáles variables son más importantes y cómo interactuan entre ellas.
• La simulación puede utilizarse como un dispositivo pedagógico para fortalecer metodologı́as de soluciones analı́ticas.
• La simulación puede ser usada para experimentar con nuevos diseños o
polı́ticas antes de su implementación para prepararnos sabiéndo qué puede
ocurrir.
• La simulación puede utilizarse para verificar soluciones obtenidas analı́ticamente.
Áreas de aplicación
• Sistemas de manufactura.
• Sistemas públicos.
• Sistemas de trasnporte.
• Sistemas de construcción.
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.1 Conceptos Básicos
9
• Sistemas de entretenimiento.
• Reingenierı́a de procesos de negocios.
• Procesamiento de alimentos.
• Desempeño de sistemas computacionales.
1.1.1
Definiciones
Definición 1.1.2.
modelo
Representación de un sistema con el propósito de estudiarlo.
Definición 1.1.3.
Modelo matemático
Utiliza notación simbólica y ecuaciones matemáticas para representar el sistema.
Definición 1.1.4.
Simulación estática
Representa al sistema en un punto particular del tiempo. También se conoce
como simulación de Monte Carlo.
Definición 1.1.5.
Simulación dinámica
Representa el sistema y su evolución conforme avanza el tiempo.
Definición 1.1.6.
Modelo determinista
Es un modelo de simulación que no contiene variables aleatorias.
Definición 1.1.7.
modelo estocástico
Es un modelo de simulación que incluye una o varias variables aleatorias.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
10
Introducción
Nota: Entradas aleatorias generan salidas aleatorias. Dado que las salidas
son aleatorias, solamente podemos considerarlas como una estimación de las
verdaderas caracterı́sticas del modelo.
Definición 1.1.8.
Sistema discreto
Un sistema en el cual las variables de estado cambian con valores discretos.
Definición 1.1.9.
Sistema continuo
Un sistema en el cual las variables de estado cambian con valores continuos con
el tiempo.
1.1.2
Etapas del Estudio de Simulación
En el proceso de construción del modelo de simulación se realizan, en general,
los siguientes pasos:
Definición del sistema Determinar la interacción de las variables entre sı́, del
sistema con otros sistemas, etc. Debemos entender el problema antes de
iniciar con su solución.
Formulación del modelo Definir todas las variables que forman parte del
sistema, sus relaciones. Escribir una definición completa del problema.
incluir detalles como entradas y salidas esperadas, el procesamiento necesario, suposiciones sobre el problema, etc.
Colección de datos Definir con claridad los datos con que se va a alimentar
el modelo.
Implementación del modelo Decidir el lenguaje de programación a utilizar
para implementar el modelo en una computadora.
Validación Detallar las deficiencias del modelo o en los datos alimentados al
mismo.
• Opinión de expertos sobre los resultados de la simulación.
• La exactitud con que se predicen datos históricos.
• La exactitud de la predicción en el futuro.
• La comprobación de falla del modelo de simulación con datos que
hacen fallar al sistema real.
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.1 Conceptos Básicos
11
• La aceptación y confianza en el modelo de la persona que hará uso
de los resultados que arroje el experimento de la simulación.
Experimentación.
La experimentación con el modelo se realiza después de que éste ha sido validado.
Consiste en generar datos.
Interpretación.
Se interpretan los resultados que arroja la simulación para tomar una decisión.
Documentación.
Documentación técnica Servirá para hacer modificaciones al modelo.
Documentación para el usuario Manual detallado de uso del sistema de
simulación para la persona que maneje el sistema.
Nota: Las suposiciones deben siempre escribirse en la documentación del programa de computradora generado como simulador. Por ejemplo, si debemos
alimentar al sistema con un coeficiente para indicar un porcentaje que debe
cumplir con: 0 ≤ p ≤ 1, la documentación debe mencionar este requerimiento
de manera explı́cita.
Definición 1.1.10.
Software de calidad
Debe cumplir con los siguientes:
Funciona Debe realizar la tarea para la cual se le diseño, completa y correctamente.
Es legible y comprensible El manual del usuario es fácil de comprender para
un usuario. Las notas técnicas (del programador) son fácilmente comprensibles por otros programadores. Esto se logra con un buen diseño y con
escritura clara. El código autodocumentado sirve para que otros programadores entiendan nuestros programas.
Es modificable No debe requerirse mucho tiempo para hacer modificaciones al
sistema de simulación. El programa de cómputo debe fácilmente adaptarse
a pequeñas modificaciones sin gran problema.
Definición 1.1.11.
Código autodocumentado
Es el código que utiliza para cada uno de los identificadores de las variables el
nombre más parecido al uso que tiene en la realidad.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
12
Introducción
Por ejemplo el código:
double x,y,z;
x = y / z;
No nos dice mucho acerca de los significados de las variables x, y, z, sin embargo,
podemos escribir:
double velocidad, distancia, tiempo;
velocidad = distancia / tiempo;
lo cual hace evidente el significado de cada variable y entendible por otros programadores.
Definición 1.1.12.
Robustez
La habilidad de un programa de cómputo para recuperarse después de encontrar
un error, es decir, de continuar en operación.
Por ejemplo, en el caso de que un usuario ingrese por error una letra en lugar de
un dı́gito, el programa debe advertir al usuario del error y permitirle intentar
de nuevo.
1.1.3
Distribuciones de probabilidad
Se han creado cientos de distribuciones de probabilidad para ciertos procesos
fı́sicos. La elección de una distribución adecuada para cada proceso es importante.
Es una buena idea considerar las caracterı́ticas fı́sicas del proceso en estudio
para seleccionar una distribución. Cuestiones de continuidad o discretización,
si la variable está acotada o no acotada, etc., facilitan la decisión.
Una vez que vaya a elegir una distribución debe tener cuidado. Aquı́ se indican
algunos ejemplos.
Binomial Modela el número de triunfos en n intentos, cuando los intentos son
independientes con probabilidad de éxito p (todos los intentos tienen la
misma probabilidad de éxito). Por ejemplo, el número de piezas defectuosas en un lote de n piezas.
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.1 Conceptos Básicos
13
Binomial Negativa (incluida la distribución geométrica) Modela el número
de intentos requeridos para obtener k triunfos. Por ejemplo, el número de
piezas que debemos inspeccionar para encontrar 2 defectuosas.
Poisson Modela el número de eventos independientes que ocurren en una cantidad fija de tiempo y espacio. Por ejemplo, el número de clientes que llegan
a una tienda durante una hora, o el número de defectos encontrados en
una lámina de 50 m2 .
Normal Modela la distribución de un proceso que puede pensarse como la suma
de un número de subprocesos. Por ejemplo, el tiempo para ensamblar un
producto, que es igual a la suma de los tiempos requeridos para cada
operación del ensamble. Nótese que la distribución normal admite valores
negativos, los cuales pueden ser imposibles para procesos de tiempo.
Lognormal Modela la distribución de un proceso que pueden pensarse como el
resultado de la multiplicación de un número de subprocesos. Por ejemplo,
la rapidez de retorno de una inversión, cuando el interés es compuesto, es
el producto del retorno por el número de periodos.
Exponencial Modela el tiempo entre eventos independientes, o un proceso
en el tiempo que no tiene memoria (el hecho de saber cuánto tiempo
ha pasado no nos da información sobre cuánto tiempo debe pasar para
completar el proceso). Por ejemplo, el tiempo entre llegadas de un gran
número de clientes que actuan independientemente uno de otro.
Gamma Una distribución muy flexible usada para modelar variables aleatorias
no negativas. Esta distribución puede desplazarse (de cero) sumando una
constante.
Beta Una distribución muy flexible usada para modelar variables aleatorias con
un intervalo definido (limites inferior y superior fijos).
Erlang Modela procesos que pueden ser vistos como la suma de varios procesos con distribución exponencial. Por ejemplo, las fallas de la red computacional debido al fallo de una computadora y a dos computadoras de
respaldo, y cada una tiene un tiempo de fallo que tiene distribución exponencial.
Weibull Modela el tiempo de fallo de componentes. Por ejemplo, el tiempo de
falla de un aparato electrodoméstico.
Uniforme (Discreta o contı́nua) Modela incerteza completa, dado que todos
los valores tienen la misma probabilidad de salir.
Triangular Modela procesos donde solamente se conocen el mı́nimo, máximo
y el más frecuente. Por ejemplo, los tiempos requeridos mı́nimo, máximo
y el más frecuente para reparar un aparato electrico.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
14
Introducción
Empirica Vuelve a muestrear de los datos reales medidos. Frecuentemente se
utiliza cuando no se conoce una distribución teórica apropiada para el
proceso en estudio.
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.2 Simulación 01
1.2
15
Simulación 01
Primera simulación
Considere el planeta tierra con un tunel que le atraviesa por su centro. Se suelta
una piedra de masa m para que caiga a través de ese tunel. Simular la posición
de la piedra para cada instante t. Considere la masa de la tierra constante e
igual a M .
Desarrollar los siguientes casos:
1. Considerar la masa de la tierra M concentrada en su centro. Suponer que la
fricción con el aire es despreciable.
La fuerza que “siente” la piedra es su peso:
W = m · ẍ(t)
Por otra parte, esta fuerza es ocasionada por la atracción gravitatoria de la
tierra sobre la piedra:
m·M
FG = G
[x(t)]2
Igualando las fuerzas obtenemos:
m · ẍ(t) = G
m·M
[x(t)]2
Lo cual puede simplificarse para obtener:
ẍ(t) = G
M
[x(t)]2
La ecuación diferencial que representa el modelo matemático para esta situación
es:
ẍ(t) · [x(t)]2 = G M
(1.1)
La solución de esta ecuación no se ha logrado encontrar.
En primer lugar, como x(t) está en el denominador, tenemos división por
cero cuando la piedra está en el centro de la tierra.
De cualquier manera, se muestra una solución que muestra la velocidad en
función de la posición.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
16
Introducción
Definimos: v(t) = ẋ(t), entonces,
dv dx
dv
·
=v·
dx dt
dx
ẍ(t) = v̇(t) =
Entonces, la ecuación se reduce de orden obteniendo:
v·
dv
GM
= 2
dx
x
Podemos separar las variables para resolver la ecuación:
Z
Z
GM
dx
v dv =
x2
v2
GM
= −
+C
2
3 x3
de donde al despejar v(x) obtenemos:
r
−
v=
2 GM
+K
3 x3
(1.2)
Esta solución nos puede dar alguna información del fenómeno que estudiamos.
2. Considerar la masa de la tierra M distribuida uniformemente. Suponer que
la fricción con el aire es despreciable.
Por definición, la densidad de un material es igual al cociente de la masa del
mismo entre su volumen. La densidad de la tierra en este caso se considera
constante. Suponemos además que la forma de la tierra es esférica. El
volumen de una esfera de radio x(t) es:
V =
4
π [x(t)]3
3
Pero para la fórmula de la ley universal de gravitación de Newton necesitamos
la masa de la fracción de la tierra que sigue atrayendo a la piedra.
En este caso, se trata de una esfera de radio x(t), su masa puede calcularse
como el producto del volumen parcial por la densidad promedio de la tierra,
es decir:
4
M (t) = π [x(t)]3 ρT
3
Ahora, sustituimos este valor en la fórmula de la ecuación encontrada en el
primer mdelo:
Efraı́n Soto A.
4
[x(t)]3
m π ρT
3
[x(t)]2
m · ẍ(t)
=
G
ẍ(t)
=
4
π x(t) ρT G
3
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.2 Simulación 01
17
y definiendo: L =
4
π ρT G, podemos escribir de una manera más compacta:
3
ẍ(t) = L x(t)
(1.3)
La solución de esta ecuación es como sigue: suponemos una solución del tipo
x(t) = er t . Entonces, ẋ(t) = r er t , y ẍ(t) = r2 er t . Sustituyendo estos
resultados en la ecuación obtenemos:
r 2 er t
2 rt
= L er t
rt
− Le
r − L · er t
r e
2
=
0
=
0
pero er t 6= 0 para cualquier t. Entonces,
r2 − L =
r
=
0
+√
L
Y la solución de la ecuación es:
√
x(t) = C1 e
Lt
√
+ C2 e−
Lt
Con las condiciones iniciales podemos encontrar los valores de las constantes
C1 y C2 .
En caso de que L sea negativo, tendremos soluciones imaginarias.
3. Considerar la masa de la tierra M distribuida uniformemente. Suponer que
la fricción con el aire es directamente proporcional a la velocidad de la piedra.
Ahora, tenemos una nueva fuerza que consiste en la resistencia debido al aire.
En este caso se trata de una fuerza proporcional a ẋ(t).
Entonces, la ecuación que considera las fuerzas que actúan sobre la piedra
es:
4
m · ẍ(t) = π x(t) ρT m G − c · ẋ(t)
3
la cual puede expresarse como:
m · ẍ(t) + c · ẋ(t) − λx(t) = 0
(1.4)
4
π ρT m G.
3
La solución de esta ecuación es inmediata, dado que se trata de una ecuación
diferencial lineal de segundo orden.
donde λ =
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
18
Introducción
Suponemos que la solución es de la forma: x(t) = er t . Entonces, ẋ(t) = r er t ,
y ẍ(t) = r2 er t . Sustituyendo estos resultados en la ecuación obtenemos:
m r2 er t + c r er t − λ er t = 0
Inmediatamente observamos que podemos factorizar la función er t , para
obtener:
er t m r 2 + c r − λ = 0
pero er t 6= 0 para cualquier t. Esto nos obliga a hacer: m r2 + c r − λ = 0.
Aquı́ tenemos una ecuación cuadrática que se resuelve con la fórmula general:
√
−c + c2 + 4 mλ
r=
2m
y obtenemos los dos valores de r que hacen que x(t) = er t sean solución de
la ecuación diferencial: m · ẍ(t) + c · ẋ(t) − λx(t) = 0:
√
−c + c2 + 4 mλ
r1 =
√2 m
−c − c2 + 4 mλ
r2 =
2m
De donde la solución de la ecuación diferencial es:
x(t) = C1 er1 t + C2 er2 t
Con las condiciones iniciales podemos encontrar los valores de las constantes
C1 y C2 .
Por la forma del experimento, puede probarse que el valor de c > 0, y que
las raı́ces r1 , r2 de la ecuación caracterı́stica de la ecuación diferencial son
números complejos, y la solución tiene la forma:
x(t) = e−c/2m C1 eiρt + C2 e−iρt
y finalmente puede simplificarse, con la ayuda de las condiciones iniciales a:
x(t) = R e−c/2m cos(ρt)
√
donde ρ =
Efraı́n Soto A.
(1.5)
c2 + 4 mλ
.
2m
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.3 Simulación 02
1.3
19
Simulación 02
Problema 2
Se lanza un alfiler de longitud L a una mesa que tiene dibujadas lı́neas paralelas
equidistantes separadas a L unidades una de la otra. Calcular la probabilidad
de que el alfiler toque lı́nea.
1.3.1
Consideraciones
Se realizaron las siguientes suposiciones:
1. La longitud del alfiler es 1.
2. El alfiler siempre cae dentro de la mesa.
3. La distancia (medida verticalmente) de una recta a la cabeza del alfiler es
una variable aleatoria que presenta distribución uniforme.
4. El ángulo que forma el alfiler con las rectas dibujadas sobre la mesa es una
variable aleatoria que presenta distribución uniforme.
Con base en estas suposiciones, podemos definir como x la distancia (medida
verticalmente) de una recta a la cabeza del alfiler, y θ como el ángulo que forma
una de las rectas dibujadas sobre la mesa y el alfiler.
1
`i+1
θ
x
0
`i
Ahora definimos y como la posición de la punta del alfiler (el extremo opuesto
a la cabeza del alfiler).
Dado que el alfiler mide 1, la coordenada y puede calcularse con:
y = x + sin (2 π θ)
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
20
Introducción
donde π = 3.141592654 · · · , es la constante geométrica1 , y θ es el ángulo como
se definió anteriormente.
El alfiler tocará lı́nea siempre y cuando se cumpla alguna de las siguientes condiciones:
i. y > 1, ó
ii. y < 0
Geométricamente, de la figura podemos ver que en estos casos, la punta del
alfiler estará fuera del área encerrada por las lı́neas paralelas `i y `i+1 .
1.3.2
Simulación por computadora
En seguida se muestra el código del programa que simula este experimento.
/* Nombre del archivo: simulacion01.cpp
Descripción:
Este programa simula el siguiente experimento:
Se lanza un alfiler de longitud L a una mesa
que tiene dibujadas lı́neas paralelas equidistantes
separadas a L unidades una de la otra.
El usuario debe ingresar el número total de
experimentos (entero) que se deben realizar,
entendiendo por experimento la simulación de un
lanzamiento del alfiler sobre la mesa.
El resultado indica la probabilidad de que el
alfiler toque una de las lı́neas dibujadas sobre la
mesa.
------------------------------------------------------------------------------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
Fecha de última Modificación: 24 de enero de 2008
Lenguaje de Programación: C++
Compilador: Dev - C++ Versión 4.9.9.2.
------------------------------------------------------------------------------------------------------*/
#include <iostream> // Funciones básicas para input/output
#include <stdlib.h> // para usar la función rand()
#include <math.h> // funciones matemáticas (sin (double))
#include <conio.h> // para usar: getche, getch
1 Al multiplicar θ por 2 π convertimos la variable aleatoria θ, cuyos valores van desde 0
hasta 1 a radianes. Se trata de un simple mapeo uno a uno.
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.3 Simulación 02
21
using namespace std;
int main(void)
{
char respuesta;
int si, no, i, j, total;
double p, x, y, a;
const double pi = 3.141592654;
/*
x --> representa la distancia de una recta
paralela de referencia
al punto donde cayó la cabeza del alfiler.
y = x + sin (2 * pi * a)
a --> es el ángulo que forma el alfiler con
las rectas paralelas dibujadas sobre
la mesa
si --> es el número de veces que el alfiler
toca lı́nea
no --> es el número de veces que el alfiler
NO toca lı́nea
p
--> es la probabilidad de que toque...
total --> es el número de experimentos que
realizará el programa...
/
*
cout << "\nEste programa calcula la probabilidad de que";
cout << "\nal lanzar un alfiler de una longitud dada ";
cout << "\nsobre una mesa que tiene dibujadas lı́neas ";
cout << "\nparalelas separadas por una distancia igual ";
cout << "\na la longitud del alfiler, toque lı́nea... ";
//
for (;;)
{
cout << "\n\n\nIngrese el número de experimentos: ";
cin >> total;
si = no = 0;
p = 0;
for (i = 1 ; i <= total ; i++)
{ // realizo los experimentos
x = double(rand()) / double(RAND_MAX);
a = double(rand()) / double(RAND_MAX);
y = x + sin(2*pi*a);
if ((y < 0) || (y > 1))
{si++;}
else
{no++;}
} // end del ciclo for ()
p = double(si) / double(total);
cout << "\n\n\nDe los " << total << " experimentos ";
cout << si << " tocaron lı́nea, \nmientras que " << no ;
cout << " no tocaron lı́nea.\n";
cout << "\nDe aquı́ que la probabilidad de que el alfiler";
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
22
Introducción
cout << "\ntoque lı́nea es: " << p;
cout << "\n\n\n";
//
cout << "Presione < S > para salir...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’))
{
break; // Salir del ciclo for inicial...
}
cout <<"\n\n\n";
}
return 0;
}
Como los resultados generados con este programa son aleatorios, los resultados
varı́an ligeramente.
En la siguiente tabla se muestran algunos resultados obtenidos con el mismo.
No. Experimentos
100
200
300
400
500
600
700
800
900
1 000
10 000
106
108
Probabilidad
0.66
0.62
0.613333
0.63
0.644
0.646667
0.624173
0.64
0.647778
0.623
0.6437
0.636592
0.636612
De hecho, aún si se dan los mismos valores al programa, éste arrojará diferentes
resultados cada vez, dado que los valores que van tomando las variables x (que
representa la distancia desde la recta `i a la cabeza del alfiler) y θ (que representa
el ángulo que forma el alfiler con cualquiera de las lı́neas dibujadas sobre la mesa)
son variables aleatorias con distribución contı́nua.
Esto se puede verificar realizando los cálculos de nuevo con el programa alimentándolo con los mismos valores.
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.3 Simulación 02
1.3.3
23
Cálculo analı́tico
Para hacer el cálculo analı́tico podemos definir las siguientes coordenadas: Sea
d la distancia del centro del alfiler a la recta más cercana.
Sea ` esta recta, y sea α el menor ángulo formado entre ` y el alfiler. De aquı́
se deduce que:
1
π
0≤d≤ ,
y
0≤α≤
2
2
También es claro que el alfiler tocará la recta ` si la hipotenusa del triángulo es
menor a 0.5, es decir:
d
1
<
sin α
2
Entonces, al lanzar el alfiler, las coordenadas (d, α) tienen distribución uniforme
en los intervalos antes definidos, que se pueden representar mediante el siguiente
rectángulo:
1
2
π
2
La probabilidad de que el alfiler toque lı́nea es igual a la fracción del área del
1
rectángulo que yace debajo de la gráfica de la función: d = sin α.
2
El área del rectángulo es: π/4 y el área debajo de la gráfica de la función en
cuestión es:
Zπ/2
1
1
sin α dα =
2
2
0
y ası́ obtenemos:
1
2 = 2 ≈ 0.6366197724
p(A) = π
π
4
Ası́ que la simulación codificada en C++ es correcta.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
1.4 Simulación 03
1.4
1.4.1
25
Simulación 03
Definiciones
Definición 1.4.13.
Distribución de probabilidad
El conjuunto de todos los pares (x, p(x)) para los cuales p(x) > 0 se denomina
la distribución de probabilidad de la variable aleatoria X.
Un experimento binomial presenta las siguientes propiedades:
3 El experimento consiste de n intentos idénticos.
3 Cada intento resulta en uno de dos resultados. Uno de ellos se define como
éxito y el otro como fracaso.
3 La probabilidad de éxito en un intento es p y continua constante de un
intento a otro.
3 La probabilidad de fracaso es 1 − p.
3 Los intentos son independientes.
3 La variable aleatoria X es el número de éxitos observados durante los n
intentos.
Teorema.1.4.1
La distribución binomial está dada por:
n x n−x
p(x) =
p q
x
Desarrollar una simulación por computadora que simule experimentos de
Bernoulli. El programa debe repetir los intentos hasta que se supere un valor
fijo p de éxito, definido por el usuario. Este mismo experimento debe realizarse
con el método binomial. Se debe ir calculando el valor de la probabilidad binomial P (n, k) para k = 0, 1, 2 · · · i, hasta que se rebase el valor de p.
El programa debe indicar al usuario cuántos intentos de Bernoulli se requierieron
para superar el valor de p y cuántas iteraciones binomiales se requirieron para
alcanzar el mismo objetivo.
Se elaboró un programa que requiere de la siguiente información:
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
26
Introducción
3 Máximo de intentos de Bernoulli, que corresponde al número máximo de
experimentos de Bernoulli que se simularán.
3 El valor de la probabilidad de éxito, que corresponde al valor de p del
evento a simular.
El código en el lenguaje C++ se enlista en seguida.
/* Nombre del archivo: simulacion03.cpp
Descripción:
Este programa simula experimentos de Bernoulli
y probabilidad binomial.
------------------------------------------------------------------------------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 03 de febrero de 2008
Lenguaje de Programación: C++
Compilador: Dev - C++ Versión 4.9.9.2.
------------------------------------------------------------------------------------------------------*/
#include <iostream> // Funciones básicas para input/output
#include <stdlib.h> // para usar la función rand()
#include <math.h> // funciones matemáticas (pow (double))
#include <conio.h> // para usar: getche, getch
#include <ctime> // clock_t = clock();
int errores; // variable global...
int factorial(int n);
int permuta(int n, int k);
//
using namespace std;
int main(void){
char respuesta;
int i, j, kBer, kBin, n;
double p, q, prob, x;
//
cout << "\nEste programa simula experimentos binomiales";
cout << "\ny repeticiones de experimentos de Bernoulli...";
//
//
//
for (;;)
{
errores = 0;
kBer = 0;
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.4 Simulación 03
27
kBin = 0;
cout << "\n\n\nMáximo de intentos de Bernoulli: ";
cin >> n;
if((n < 0) || (n > 20)) {
cout << "\nn debe estar entre 1 y 20 (inclusive)...";
cout << "\n\n";
continue;
}
for (;;) { // para que pueda ingresar el valor de p...
cout << "\nIngrese el valor de la probabilidad de éxito: ";
cin >> p;
if ((p < 0) || (p > 1)) {
cout << "\np está entre cero y uno (inclusive)...";
cout << "\n\n\n";
continue;
}
q = 1 - p; // probabilidad de fracaso...
break;
} // termina el for...
//
//
//
// realizo el cálculo de acuerdo a Bernoulli...
for (i=1 ; i <= n ; i++) {
x = double(rand()) / double(RAND_MAX); // genero x
if (p >= x){
kBer++;
} // endif
} // end for
//
//
// realizo el cálculo por Binomial...
x = double(rand())/ double(RAND_MAX); // genero x
prob = 0; // inicio la probabilidad acumulada de Bernoulli
kBin = 0; // inicio el número de intentos...
for(;;){ // for infinito...
prob +=double(permuta(n,kBin))*pow(p,double(kBin))*pow(q,double(n-kBin));
if (prob >= x) {
break;
}
kBin++;
}
//
// Muestro los resultados...
cout << "\n\n\nIntentos con Bernoulli: " << kBer;
cout << "\n\nIntentos con Binomial: " << kBin;
cout << "\n\n\nTotal de errores: " << errores;
//
cout << "\n\n\nPresione < S > para salir...";
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
28
Introducción
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’))
{
break; // Salir del ciclo for inicial...
}
cout << "\n\n\n";
}
return 0;
}
/**************************************
Declaro la función factorial...
***************************************/
int factorial(int n)
{
long fi,i;
fi = i = 1;
while (i <= n)
{
fi *=i;
if (fi <= 0){ // por si se pasa la memoria...
cout << "\nLo siento, se rebasó la memoria...";
fi = 1;
errores++;
break;
}
i++;
}
return fi;
}
/**************************************
Declaro la función permuta...
***************************************/
int permuta(int n, int k)
{
int perm,subfactorial,i;
i = n - k + 1; // n - k + 1 para calcular el subfactorial
subfactorial = 1; // reinicio el subfactorial
while (i <= n){
subfactorial *= i;
i++;
}
perm = subfactorial / factorial(k);
return perm;
}
Los resultados que arroja el programa evidentemente varı́a con los datos con
que alimente al mismo.
Por ejemplo, con 12 intentos de Bernoulli máximo y una probabilidad de éxito
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.4 Simulación 03
29
de 0.35 obtenemos los siguientes resultados:
Este programa simula experimentos binomiales
y repeticiones de experimentos de Bernoulli...
Máximo de intentos de Bernoulli: 12
Ingrese el valor de la probabilidad de éxito: 0.35
Intentos con Bernoulli: 3
Intentos con Binomial: 5
Total de errores: 0
Presione < S > para salir...
Los resultados obtenidos de un segundo ejemplo considerando 12 intentos de
Bernoulli y un valor de p = 0.65, son:
Máximo de intentos de Bernoulli: 12
Ingrese el valor de la probabilidad de éxito: 0.65
Intentos con Bernoulli: 7
Intentos con Binomial: 9
Total de errores: 0
Un tercer ejemplo se muestra en seguida:
Máximo de intentos de Bernoulli: 12
Ingrese el valor de la probabilidad de éxito: 0.95
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
30
Introducción
Intentos con Bernoulli: 12
Intentos con Binomial: 12
Total de errores: 0
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.5 Simulación 04
1.5
31
Simulación 04
Suponga deseamos calcular la distribución de probabilidad de que ocurra un
accidente en una intersección de calles. Podemos considerar una unidad de
tiempo, por ejemplo una hora, o un minuto, de manera que la probabilidad de
que ocurra un accidente en ese intervalo sea distinta de cero.
Entonces, si p es la probabilidad de que ocurra exactamente un accidente, 1 − p
es la probabilidad de que NO ocurra.
Si la ocurrencia de un accidente en in intervalo de tiempo es independiente de
los demás intervalos, el número total de accidentes en un intervalo mayor, por
ejemplo, una semana, tendrá una distribución binomial.
Nosotros consideramos el caso en el que el producto n p permanece constante,
al hace cambiar el tamaño del intervalo, es decir, si n → ∞, p → 0, implica
n p = λ, siendo λ una constante.
Entonces,
n x
lim
p (1 − p)n−y
n→∞ x
x n−x
λ
n (n − 1) · · · (n − x + 1) λ
1−
= lim
n→∞
x!
n
n
−x
n
x
λ
λ
n (n − 1) · · · (n − x + 1)
λ
= lim
1−
1−
n→∞ x!
n
nx
n
n −y x
λ
λ
λ
1
2
x−1
1−
1−
1−
··· 1 −
lim 1 −
=
x! n→∞
n
n
n
n
n
Pero
lim
n→∞
λ
1−
n
n
= e−λ
y todos los demás factores se hacen 1, dado que n → ∞. Entonces:
P (x) =
λx −x
e
x!
Las variables que presentan esta distribución se conocen como variables aleatorias con distribución de Poisson.
Desarrollar un programa por computadora que simule experimentos con distribución de Poisson. El programa debe repetir los intentos hasta que se supere
un valor fijo p de éxito, definido por el usuario.
El programa debe indicar al usuario cuántos intentos del experimento se requierieron para superar el valor de p.
Se elaboró un programa que requiere de la siguiente información:
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
32
Introducción
3 Valor de Lambda, que corresponde al promedio de la muestra.
3 El valor de la probabilidad de éxito, que corresponde al valor de p del
evento a simular.
El código en el lenguaje C++ se enlista en seguida.
/* Nombre del archivo: simulacion04.cpp
Descripción:
Este programa simula experimentos con distribución de Poisson
y probabilidad binomial.
------------------------------------------------------------------------------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 03 de febrero de 2008
Lenguaje de Programación: C++
Compilador: Dev - C++ Versión 4.9.9.2.
------------------------------------------------------------------------------------------------------*/
#include <iostream> // Funciones básicas para input/output
#include <stdlib.h> // para usar la función rand()
#include <math.h> // funciones matemáticas (pow (double))
#include <conio.h> // para usar: getche, getch
#include <ctime> // clock_t = clock();
int errores; // variable global...
int factorial(int n);
int permuta(int n, int k);
//
using namespace std;
int main(void){
char respuesta;
int i, k;
double p, prob, x, lambda;
//
cout << "\nEste programa simula experimentos con";
cout << "\ndistribucion de Poisson...";
//
//
//
for (;;)
{
errores = 0;
cout << "\n\n\nValor de Lambda (Promedio): ";
cin >> lambda;
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.5 Simulación 04
33
if((lambda < 0)) {
cout << "\nLambda debe ser un valor positivo...\n\n";
continue;
}
for (;;) { // para que pueda ingresar el valor de p...
cout << "\nIngrese el valor de la probabilidad de éxito: ";
cin >> p;
if ((p < 0) || (p > 1)) {
cout << "\np está entre cero y uno (inclusive)...";
cout << "\n\n\n";
continue;
}
break;
} // termina el for...
//
//
// realizo el cálculo de la probabilidad...
srand(unsigned(time(0)));// Semilla para el aleatorio...
x = double(rand())/ double(RAND_MAX); // genero x
prob = 0; // inicio la probabilidad acumulada
for(i = 0 ; prob <= x ; i++){ // for infinito...
prob += exp(-lambda) * pow(lambda,i) / factorial(i);
//
}
//
// Muestro los resultados...
cout << "\n\n\nIntentos con Poisson: " << i-1;
cout << "\n\n\nTotal de errores: " << errores;
//
cout << "\n\n\nPresione < S > para salir...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’))
{
break; // Salir del ciclo for inicial...
}
cout << "\n\n\n";
}
return 0;
}
/**************************************
Declaro la función factorial...
***************************************/
int factorial(int n)
{
long fi,i;
fi = i = 1;
while (i <= n)
{
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
34
Introducción
fi *=i;
if (fi <= 0){ // por si se pasa la memoria...
cout << "\nLo siento, se rebasó la memoria...";
fi = 1;
errores++;
break;
}
i++;
}
return fi;
}
Un ejemplo de la ejecución del código se muestra enseguida:
Este programa simula experimentos con
distribucion de Poisson...
Valor de Lambda (Promedio): 12
Ingrese el valor de la probabilidad de Txito: 0.45
Intentos con Poisson: 13
Total de errores: 0
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.6 Simulación 05
1.6
35
Simulación 05
Desarrollar un programa por computadora que simule el lanzamiento de dos
dados.
El programa debe permitir al usuario indicar cuántos experimentos realizar y si
desea o no ver los resultados de cada experimento.
El programa debe imprimir en pantalla el promedio de la suma de todos los
experimentos realizados.
El código en el lenguaje C++ se enlista en seguida.
/* Nombre del archivo: simulacion05.cpp
Descripción:
Este programa simula el lanzamiento de dos dados...
------------------------------------------------------------------------------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 08 de febrero de 2008
Lenguaje de Programación: C++
Compilador: Dev - C++ Versión 4.9.9.2.
------------------------------------------------------------------------------------------------------*/
#include <iostream> // Funciones básicas para input/output
#include <stdlib.h> // para usar la función rand()
#include <conio.h> // para usar: getche, getch
#include <ctime> // clock_t = clock();
using namespace std;
int main(void){
char respuesta,resp;
int i, x, y, n; // variables aleatorias...
int suma;
double promedio;
//
cout << "\nEste programa simula el lanzamiento";
cout << "\nde dos dados...";
//
//
//
for (;;)
{
// realizo el cálculo de la probabilidad...
cout << "\n\n\n¿Cuántos lanzamientos deseas simular? ";
cin >> n;
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
36
Introducción
cout << "\n\n\n¿Deseas ver los resultados? [S / N] ";
cin >> resp;
srand(unsigned(time(0)));// Semilla para el aleatorio...
suma = 0; // reinicio la suma de resultados...
if ((resp == ’S’)||(resp == ’s’)){
cout << "\n\nSimulación ";
cout << "\t\tDADO 1: ";
cout << "\tDADO 2: ";
cout << "\tSUMA: \n";
}
for (i = 1 ; i <= n ; i++ ){
//
x = (rand() % 6) + 1;
y = (rand() % 6) + 1;
//
suma += x+y;
if ((resp == ’S’)||(resp == ’s’)){
// Muestro los resultados...
cout << "\t" << i << "\t";
cout << "\t
" << x << "\t";
cout << "\t
" << y << "\t";
cout << "\t
" << x+y << "\n\n";
}
}
promedio = double(suma) / double(i-1);
cout << "\n\n\n Suma Promedio: " << promedio;
//
cout << "\n\n\nPresione < S > para salir...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’))
{
break; // Salir del ciclo for inicial...
}
cout << "\n\n\n";
}
return 0;
}
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.7 Simulación 06
1.7
37
Simulación 06
Elaborar un programa que simule una variable aleatoria con distribución de
Poisson que a su vez toma una variable con distribución exponencial. Comparar
el número de intentos que debe realizar esta variable para alcanzar el valor 1
y compararlo con una variable aleatoria con distribución de Poisson que toma
una variable con distribución uniforme.
• Se muestra en seguida el código del programa que se preparó en el lenguaje
C++ .
/* Nombre del archivo: simulacion06.cpp
Descripción:
Este programa simula experimentos con distribución de Poisson
cuya variable de dominio tiene una distribución exponencial
y compararla con la distribución de Poisson con dominio en
una variable aleatoria con distribución uniforme.
------------------------------------------------------------------------------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 14 de febrero de 2008
Lenguaje de Programación: C++
Compilador: Dev - C++ Versión 4.9.9.2.
------------------------------------------------------------------------------------------------------*/
#include <iostream> // Funciones básicas para input/output
#include <stdlib.h> // para usar la función rand()
#include <math.h> // funciones matemáticas (pow (double))
#include <conio.h> // para usar: getche, getch
#include <ctime> // clock_t = clock();
int errores; // variable global...
int factorial(int n); // función...
using namespace std;
int main(void){
char respuesta;
int i, ipe, ip;
double prob, probe, u, lambda, x;
//
for (;;){
cout << "\nEste programa simula experimentos con";
cout << "\ndistribucion de Poisson a partir de una";
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
38
Introducción
cout << "\nvariable aleatoria con distribución exponencial...";
//
//
//srand(unsigned(time(0)));// Semilla para el aleatorio...
// Con distribución Poisson - Exponencial
probe = 0; // inicio la probabilidad acumulada
for(i = 0 ; probe <= 1 ; i++){ // calculo la probabilidad...
u = double(rand())/ double(RAND_MAX); // genero x
x = - log(1 - u) / u; //
probe += exp(-x) * pow(x,i) / factorial(i);
ipe = i;
}
//
// Ahora realizo el cálculo con distribución uniforme...
prob = 0; // inicio la probabilidad acumulada
for(i = 0 ; prob <= 1 ; i++){
prob += exp(-lambda) * pow(lambda,i) / factorial(i);
}
//
// Muestro los resultados...
cout << "\n\n\nIntentos con poisson exponencial: " << ipe;
cout << "\n\n\nIntentos con poisson uniforme: " << i;
//
cout << "\n\n\nPresione < S > para salir...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’)){
break; // Salir del ciclo for inicial...
}
cout << "\n\n\n";
}
return 0;
}
/**************************************
Declaro la función factorial...
***************************************/
int factorial(int n)
{
long fi,i;
fi = i = 1;
while (i <= n)
{
fi *=i;
if (fi <= 0){ // por si se pasa la memoria...
cout << "\nLo siento, se rebasó la memoria...";
fi = 1;
errores++;
break;
}
i++;
}
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.7 Simulación 06
39
return fi;
}
En seguida se muestran ejemplos de resultados obtenidos con este programa:
Este programa simula experimentos con
distribucion de Poisson a partir de una
variable aleatoria con distribuci=n exponencial...
Lo siento, se rebas= la memoria...
Intentos con poisson exponencial: 17
Intentos con poisson uniforme: 3
///////////////////////////////////////////////
Este programa simula experimentos con
distribucion de Poisson a partir de una
variable aleatoria con distribuci=n exponencial...
Lo siento, se rebas= la memoria...
Intentos con poisson exponencial: 17
Intentos con poisson uniforme: 3
///////////////////////////////////////////////
Este programa simula experimentos con
distribucion de Poisson a partir de una
variable aleatoria con distribuci=n exponencial...
Intentos con poisson exponencial: 16
Intentos con poisson uniforme: 3
///////////////////////////////////////////////
Este programa simula experimentos con
distribucion de Poisson a partir de una
variable aleatoria con distribuci=n exponencial...
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
40
Introducción
Intentos con poisson exponencial: 6
Intentos con poisson uniforme: 3
///////////////////////////////////////////////
Este programa simula experimentos con
distribucion de Poisson a partir de una
variable aleatoria con distribuci=n exponencial...
Lo siento, se rebas= la memoria...
Intentos con poisson exponencial: 17
Intentos con poisson uniforme: 3
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.8 Simulación 07
1.8
41
Simulación 07
Elaborar un programa que genere números aleatorios con distribución uniforme,
utilizando la siguiente definición:
∞
x X
(−x2 )i
Φ(x) = √
2 π i=0 2i · i! · (2 i + 1)
• Se muestra en seguida el código del programa que se preparó en el lenguaje
C++ .
/* Nombre del archivo: simulacion07Final.cpp
Descripción:
Este programa simula números aleatorios con
distribución normal.
------------------------------------------------------------------------------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 26 de febrero de 2008
Lenguaje de Programación: C++
Compilador: Dev - C++ Versión 4.9.9.2.
------------------------------------------------------------------------------------------------------*/
#include <iostream> // Funciones básicas para input/output
#include <stdlib.h> // para usar la función rand()
#include <math.h> // funciones matemáticas (pow (double))
#include <conio.h> // para usar: getche, getch
#include <ctime> // clock_t = clock();
#include <cmath>
int errores; // variable global...
double rfactorial(int n);
// función...
double normal(double x); // función...
double intnormal(double x);
const double pi = 3.141592653589; // global
using namespace std;
int main(void){
char respuesta;
double x, xa, u, approx, approxa;
double step, error, errorx;
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
42
Introducción
int j, total, cont, z;
char signo;
// para los dı́gitos...
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(8);
//
for (;;){
cout << "\nEste programa simula la generación de números";
cout << "\ncon distribucion normal a partir de una";
cout << "\nvariable aleatoria con distribución uniforme...";
//
//srand(unsigned(time(0))); // Semilla para el aleatorio...
//
cout << "\n\n\n¿Cuantos numeros desea generar? ";
cin >> total;
//
for (cont = 1 ; cont <= total ; cont++){
// Genera un aleatorio en [0,1]
u = double(rand()) / double(RAND_MAX);
//
x = 0;
// valor inicial supuesto (media)
z = 0;
if (u < 0.01){
step = u / 2;
}
else{
step = 0.25;
}
for (;;){
//
xa = x;
approx = normal(x);
//
// Decido si incremento o decremento x
while (approx < u){
x += step;
approx = normal(x);
//cout << "\napprox <... " << approx;
z++;
}
step /= 1.5;
while (approx > u){
x -= step;
approx = normal(x);
//cout << "\napprox >... " << approx;
z++;
}
step /= 1.5;
if (approx < 0.0001 && fabs(x) > 3.999){
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.8 Simulación 07
43
x = u / 2;
approx = normal(u);
}
// calculo el error relativo para x
if (fabs(xa - x) < 0.0001){
// Criterio para salir del ciclo...
cout << "\n" << cont << "\tu = " << u << "\tApprox = "
<< intnormal(x) << "\t x = " << x;
break;
}
} // end for que hace las iteraciones...
//
} // end for cont = 1 to total;
//
cout << "\n\n\nPresione < S > para salir...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’)){
break; // Salir...
}
cout << "\n\n\n";
} // end for infinito...
return 0; // Salir...
}
/**************************************
Declaro la función normal...
***************************************/
double normal(double x){
double u = 0;
double un, ua, temp;
int i;
if (x < -4){
return 0;
}
if (x > 4){
return 1;
}
for (i = 0 ; i < 40 ; i++){
ua = u;
u += pow(-0.5 * x * x,i) * rfactorial(i) / (2*i+1);
un = u;
} // endfor
if (x < 0 ){
u = 0.5 - u * x / sqrt(2*pi);
}
else{
u = 0.5 + u * x / sqrt(2*pi);
}
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
44
Introducción
return u;
}
/**************************************
Declaro la función intnormal...
***************************************/
double intnormal(double x){
double u = 0;
double ua, up, ac;
double xi, step;
// xi es la iteracion actual
// step es el tamaño del paso...
int i;
step = 0.00000001; // El paso es 1 / 1000
xi = 0; // empieza a integrar desde cero...
while (xi <= fabs(x)){
u += exp(-xi*xi / 2) * step;
xi += step;
} // end while
u = u / sqrt(2*pi) + 0.5;
if (x < 0 ){
return (u - 0.5);
}
else{
return u;
}
}
/**************************************
Declaro la función rfactorial...
***************************************/
double rfactorial(int n){
double fi, i;
int j;
fi = i = 1.0;
j = 1;
while (j <= n){
fi /=i;
i = i + 1;
j++;
}
return fi;
}
Un ejemplo de corrida se da en seguida:
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.8 Simulación 07
45
Este programa simula la generacion de numeros
con distribucion normal a partir de una
variable aleatoria con distribucion uniforme...
Cuantos numeros desea generar? 10
1
2
3
4
5
6
7
8
9
10
u
u
u
u
u
u
u
u
u
u
=
=
=
=
=
=
=
=
=
=
0.00125126
0.56358531
0.19330424
0.80874050
0.58500931
0.47987304
0.35029145
0.89596240
0.82284005
0.74660482
Approx
Approx
Approx
Approx
Approx
Approx
Approx
Approx
Approx
Approx
=
=
=
=
=
=
=
=
=
=
0.50024959
0.56354406
0.53849867
0.80873107
0.58496935
0.59481027
0.56951744
0.89594475
0.82283187
0.74659295
x
x
x
x
x
x
x
x
x
x
=
=
=
=
=
=
=
=
=
=
0.00062563
0.15996089
0.09665212
0.87322977
0.21462296
0.23993652
0.17514573
1.25877805
0.92621113
0.66380659
Presione < S > para salir...
Un programa modificado que NO genera números aleatorios para la variable u,
sino que el usuario da los valores que desea que se generen es el siguiente:
/* Nombre del archivo: simulacion07FinalB.cpp
Descripción:
Este programa simula transformación inversa de la
distribución normal, esto es, a partir del valor de
u = Phi(x) calcula de manera aproximada x.
El usuario indica el valor u que está en el
intervalo (0,1)
------------------------------------------------------------------------------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 26 de febrero de 2008
Lenguaje de Programación: C++
Compilador: Dev - C++ Versión 4.9.9.2.
------------------------------------------------------------------------------------------------------*/
#include <iostream> // Funciones básicas para input/output
#include <stdlib.h> // para usar la función rand()
#include <math.h> // funciones matemáticas (pow (double))
#include <conio.h> // para usar: getche, getch
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
46
Introducción
#include <ctime> // clock_t = clock();
#include <cmath>
int errores; // variable global...
double rfactorial(int n);
// función...
double normal(double x); // función...
double intnormal(double x);
const double pi = 3.141592653589; // global
using namespace std;
int main(void){
char respuesta;
double x, xa, u, approx, approxa;
double step, error, errorx;
int j, total, cont, z;
char signo;
// para los dı́gitos...
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(8);
//
for (;;){
cout << "\nEste programa simula la generación de números";
cout << "\ncon distribucion normal a partir de un";
cout << "\nvalor dado por el usuario entre cero y uno...";
for (;;){
cout << "\n\n\ningresa un valor entre cero y 1: ";
cin >> u;
if (u < 0 && u > 1){
cout << "\nError en argumento...";
cout << "\n\n";
continue;
}
break;
} // end for para pedir u
//
x = 0;
// valor inicial supuesto (media)
z = 0;
if (u < 0.01){
step = u / 2;
}
else{
step = 0.25;
}
for (;;){
//
xa = x;
approx = normal(x);
// Decido si incremento o decremento x
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.8 Simulación 07
47
while (approx < u){
x += step;
approx = normal(x);
//cout << "\napprox <... " << approx;
z++;
}
step /= 1.5;
while (approx > u){
x -= step;
approx = normal(x);
//cout << "\napprox >... " << approx;
z++;
}
step /= 1.5;
if (approx < 0.0001 && fabs(x) > 3.999){
x = u / 2;
approx = normal(u);
}
// calculo el error relativo para x
if (fabs(xa - x) < 0.0001){
// Criterio para salir del ciclo...
cout << "\tu = " << u << "\tApprox = " << intnormal(x)
<< "\t x = " << x;
break;
}
} // end for que hace las iteraciones...
//
//} // end for cont = 1 to total;
//
cout << "\n\n\nPresione < S > para salir...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’)){
break; // Salir...
}
cout << "\n\n\n";
} // end for infinito...
return 0; // Salir...
}
/**************************************
Declaro la función normal...
***************************************/
double normal(double x){
double u = 0;
double un, ua, temp;
int i;
if (x < -4){
return 0;
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
48
Introducción
}
if (x > 4){
return 1;
}
for (i = 0 ; i < 40 ; i++){
ua = u;
u += pow(-0.5 * x * x,i) * rfactorial(i) / (2*i+1);
un = u;
} // endfor
if (x < 0 ){
u = 0.5 - u * x / sqrt(2*pi);
}
else{
u = 0.5 + u * x / sqrt(2*pi);
}
return u;
}
/**************************************
Declaro la función normal...
***************************************/
double intnormal(double x){
double u = 0;
double ua, up, ac;
double xi, step;
// xi es la iteracion actual
// step es el tamaño del paso...
int i;
step = 0.00000001; // El paso es 1 / 1000
xi = 0; // empieza a integrar desde cero...
while (xi <= fabs(x)){
u += exp(-xi*xi / 2) * step;
xi += step;
} // endfor
u = u / sqrt(2*pi) + 0.5;
if (x < 0 ){
return (u - 0.5);
}
else{
return u;
}
}
/**************************************
Declaro la función rfactorial...
***************************************/
double rfactorial(int n){
double fi, i;
int j;
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.8 Simulación 07
49
fi = i = 1.0;
j = 1;
while (j <= n){
fi /=i;
i = i + 1;
j++;
}
return fi;
}
Y los resultados obtenidos con este programna son:
Este programa simula la generaci=n de n·meros
con distribucion normal a partir de un
valor dado por el usuario entre cero y uno...
ingresa un valor entre cero y 1: 0.8423
u = 0.84230000
Approx = 0.84228995
x = 1.00391391
Presione < S > para salir...c
Este programa simula la generaci=n de n·meros
con distribucion normal a partir de un
valor dado por el usuario entre cero y uno...
ingresa un valor entre cero y 1: 0.56657
u = 0.56657000
Approx = 0.56654646
x = 0.16758842
Presione < S > para salir...
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
1.9 Simulación 07 (Reposición)
1.9
51
Simulación 07 (Reposición)
Elaborar un programa que genere números aleatorios con distribución normal.
El usuario debe ingresar la media de la muestra y su varianza.
• Se muestra en seguida el código del programa que se preparó en el lenguaje
C++ .
/* Nombre del archivo: simulacion07A.cpp
Descripción:
Este programa simula una variable aleatoria
con distribución normal, dados el promedio y la
varianza de la muestra.
------------------------------------------------------------------------------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 03 de febrero de 2008
Lenguaje de Programación: C++
Compilador: Dev - C++ Versión 4.9.9.2.
------------------------------------------------------------------------------------------------------*/
#include <iostream> // Funciones básicas para input/output
#include <stdlib.h> // para usar la función rand()
#include <math.h> // funciones matemáticas (pow (double))
#include <conio.h> // para usar: getche, getch
#include <ctime> // clock_t = clock();
double normal(double media, double sigma); // función...
const double pi = 3.141592653589793238462643;
using namespace std;
int main(void){
char respuesta;
double x, varianza, promedio;
int i, j, total;
//
for (;;){
cout << "\nEste programa simula experimentos con";
cout << "\ndistribucion normal a partir de una";
cout << "\nvariable aleatoria con distribución normal.";
//
cout << "\n\n\n¿Cuántos numeros desea generar? ";
cin >> total;
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
52
Introducción
cout << "\n\n\nPromedio de la muestra: ";
cin >> promedio;
cout << "\nVarianza de la muestra: ";
cin >> varianza;
varianza = sqrt(varianza);
//
for (j = 1; j <= total ; j++){
x = rand(); // Genera un aleatorio
// Imprimo el indice con el número generado...
cout << "\n " << j << "\t" << normal(promedio, varianza);
}
cout << "\n\n\nPresione < S > para salir...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’)){
break; // Salir del ciclo for inicial...
}
cout << "\n\n\n";
}
return 0;
}
/**************************************
Declaro la función normal...
***************************************/
double normal(double media, double sigma){
double u, v, x, y, z;
u = double(rand()) / double(RAND_MAX);
v = double(rand()) / double(RAND_MAX);
x = sqrt(-2 * log(u)) * cos(2*pi*y);
if (u >= 0.5){
z = media + sigma * x;
}
else{
z = media - sigma * x;
}
return z;
}
Un ejemplo de corrida se muestra en seguida:
Este programa simula experimentos con
distribucion normal a partir de una
variable aleatoria con distribución normal.
¿Cuántos numeros desea generar? 25
Promedio de la muestra: 120
Varianza de la muestra: 15
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.9 Simulación 07 (Reposición)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
53
124.148
124.01
121.815
112.758
124.471
111.528
112.659
112.01
114.597
123.903
123.511
110.731
122.568
121.993
121.522
115.187
113.153
120.31
114.703
122.286
111.552
108.083
113.758
122.306
113.109
Presione < S > para salir...
Fuente bibliográfica del modelo matemático:
Autor: Banks, J.; Carson, J. S., Nelson, B.L.
Tı́tulo: Discrete–Event System Simulation
Editorial: Prentice Hall
Edición: 2da. Edición. 1 996.
Páginas: 341 – 343.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
1.10 Simulación 08
1.10
55
Simulación 08
Simular la generación de números aleatorios con distribución uniorme con el
método de aceptación - rechazo.
Método del rechazo
Se aplica solamente para variables aleatorias continuas.
Tenemos una V.A.C. y conocemos su distribución.
Sea Y una variable aleatoria continua con densidad g y sabemos cómo simular
esta variable aleatoria con esta distribución.
Deseamos simular una V.A.C. X con densidad f .
Supongamos que U es una V.A.C. continua con distribución uniforme en el
intervalo [0, 1].
Ya sabemos simular U y Y .
Sea c una cota superior del siguiente conjunto:
f (x)
|x ∈ R
A=
g(x)
Podemos suponer que el conjunto A está acotado superiormente, es decir, estamos suponiendo que dicha c existe.
Para simular la V.A.C. X con densidad f , podemos hacer lo siguiente:
Paso 1: Simular Y y U .
Sea u el valor simulado de U , y sea y el valor simulado de Y .
Paso 2: Decidir
Si:
u≤
f (y)
c · g(y)
Entonces el valor simulado de X es y.
Si no, regresar al paso 1.
El valor de c es el número esperado de iteraciones que se deben realizar para
que la simulación nos genere un valor para la V.A.C. X. Por lo tanto, es muy
conveniente elegir a c como la mı́nima cota superior:
f (x)
c ≡ sup
|x ∈ R
g(x)
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
56
Introducción
•
El código del programa en el lenguaje C++ se muestra en seguida:
/* Nombre del archivo: simulacion08.cpp
Este programa simula la generación de números
aleatorios con duistribución normal
por el método de aeptación - rechazo.
------------------------------------------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 01 de marzo de 2008
------------------------------------------------------------------*/
#include <cstdio> // Otra librerı́a...
#include <cstdlib> // Librerı́a por si se requiere
#include <iostream> // Funciones básicas para input/output
#include <math.h> // funciones matemáticas
#include <conio.h> // para usar: getche, getch
// Defino las funciones que voy a usar...
double f(double y);
double g(double y);
//
using namespace std;
int main(void){
int i, total;
char respuesta;
double x, y, z, u;
// el valor de c = 1.315489247
// const double c = sqrt(2 * 2.718281828 / 3.141592653);
const double c = 1.315489247;
//
for (;;){ // for infinito...
cout << "\nEste programa simula la generacion de numeros";
cout << "\ncon distribucion normal con el metodo de ";
cout << "\naceptacion y rechazo...";
cout << "\n\nCuantos numeros desea generar... ";
cin >> total;
cout << "\n\n\n"; // un poco de espacio...
for (i = 1; i<= total ; i++){
x = double(rand()) / double(RAND_MAX); // aleatorio
z = double(rand()) / double(RAND_MAX); // aleatorio
if (z < 0.5){ // genero el valor de y
y = log(2 * z);
}
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.10 Simulación 08
57
else
{
y = - log(2 - 2 * z);
}
// x es el valor a comparar...
// y es el argumento de las funciones...
u = f(y) / (c * g(y));
if (u >= x){
// aceptar el valor...
cout << "\n" << i << "\t----->\t" << y;
}
}
cout << "\n\n\nPresione < S > para salir...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’)){
break; // Salir del ciclo for inicial...
}
cout << "\n\n\n";
} // end for infinito...
return 0;
}
/*************************************
Defino la función f(y)
**************************************/
double f(double y){
return 0.39894228 * exp(- y * y / 2) ;
// el factor 0.39894228 = 1 / sqrt(2 * 3.141592653);
}
/*************************************
Defino la función g(y)
**************************************/
double g(double y){
return exp(-fabs(y)) / 2;
}
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
1.11 Movimiento Browniano
1.11
59
Movimiento Browniano
Proceso de Brown. Bt≥0
3 Cada Bt es una variable aleatoria contı́nua, salvo B0 = (0, 0).
3 Bt presenta una distribución normal con media 0 y varianza proporcional
al tiempo.
Bt,i ∼ N (0, αt)
{α > 0, α ∈ R}
3 Bt tiene dos componentes: Bt = (Bt,1 , Bt,2 ), siendo Bt,1 independiente de
Bt,2 con la misma distribución para cada valor de t.
3 Si t1 ≤ t2 ≤ t3 ≤ t4 , i ∈ 1, 2, entonces las variables aleatorias Bt2 ,i − Bt1 ,i
y Bt4 ,i −Bt3 ,i son independientes y tienen media 0 y varianza proporcional
a α (t2 − t1 ) y α (t4 − t3 ), respectivamente.
En general, Bt,i − Bs,i tiene distribución normal con media cero y varianza
α |t − s|, ∀t, s ≥ 0 con t 6= s.
Propiedad: Si (Bt )t≥0 es un proceso Browniano, entonces la probabilidad
de que el proceso sea contı́nuo con respecto al tiempo es 1. Sin embargo, la
probabilidad de que su trayectoria sea derivable en algún punto es cero.
Propiedad: Si t1 > t0 > 0, entonces, la trayectoria del proceso (Bt )t≥0 de t0 a
t1 tiene longitud infinita.
1.11.1
Bosquejo de experimento
Supongamos que conozco α = 1, de un proceso browniano. Si conozco la
posición de la partı́cula en n puntos, deseo conocer una aproximación de la
posición de la partı́cula para algún punto s que estuvo entre los puntos xi , xi+1 .
El promedio “esperado” de s es la media ponderada.
Una posible varianza serı́a la media geométrica: σ 2 = (v − s)(s − u)
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
60
Introducción
Bt (w)
Bs
Bu
Bv
u
O
s
v
t
Desconocemos x1 = Bs . Sabemos que x1 depende de x0 y de x2 , siendo x0 =
Bu , x1 = Bs y x2 = Bv .
Definimos: X = Bu , Y = Bs , W = Bv .
X es una variable aleatoria con distribución normal, media cero y varianza u:
X → N (0, u). De manera semejante:
Y
→
N (0, s)
W
→
N (0, v)
Las funciones de densidad de la variables aleatorias son:
x2
exp −
2u
X = fX (x) = √ √
u 2π
x2
exp −
2s
Y = fY (x) = √ √
s 2π
x2
exp −
2v
W = fW (x) = √ √
v 2π
Ahora calculamos la densidad de s condicionada por el valor de la variable
aleatoria X:
(x − x0 )2
exp −
v−u
p
fY |X=x0 =
π (v − u)
De manera semajante:
(x − x2 )2
exp −
v−u
p
=
π (v − u)
fY |W =x2
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.11 Movimiento Browniano
61
Podemos considerar como una variable aleatoria a Y |X = x0 y W |X = x0
condicionada cada una a W .
Supongamos que conocemos la distribución conjunta: fU,V (x, y):
fu (x)
=
Z∞
f (x, y) dy
−∞
Z∞
fv (x)
=
f (x, y) dy
−∞
También necesitamos calcular la distribución marginal condicionada.
Distribución bivariada
fXY = fX · fY |X
⇒
fY |X =
fXY
fX
Consideremos tres puntos. Conocemos t0 y x0 . Tenemos un movimiento browniano con varianza ∆t.
Bt (w)
x1
x0
x2
O
t0
t1
t2
t
La densidad de xt1 es normal con media x0 y varianza t1 − t0 ; la densidad de
xt2 es también normal y con media x0 y varianza t2 − t0 .
La densidad condicional de Xt2 dado que Xt1 = x1 es normal con media x1 y
varianza t2 − t1 .
Entonces, la densidad conjunta de (Xt1 , Xt2 ) está dada por:
La simulación que se generó en el lenguaje C++ se muestra enseguida:
/* Nombre del archivo: simulacion09.cpp
Este programa simula un movimiento browniano.
----------------------------------
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
62
Introducción
---------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 01 de marzo de 2008
------------------------------------------------------------------*/
#include <cstdio> // Otra librerı́a...
#include <cstdlib> // Librerı́a por si se requiere
#include <iostream> // Funciones básicas para input/output
#include <math.h> // funciones matemáticas
#include <conio.h> // para usar: getche, getch
#include <fstream> // para grabar datos generados...
//
const double PI = 3.141592653;
// función para generar los números pseudoaleatorios
// con distribución normal...
double dnormal(double media, double sigma);
double dnormal(void);
// Función para generar un número pseudoaleatorio
// con distribución uniforme en el intervalo (0,1)
double uniforme(void);
using namespace std;
int main(void){
char respuesta, semilla;
double t, step, tiempo; // escala de tiempo.
double xn, x = 0; // posición de la partı́cula.
double media, sigma; // parámetros de dist. Normal.
int i = 0;
//
for (;;){ // for infinito...
cout << "\nEste programa simula un ";
cout << "movimiento browniano ";
cout << "\n\nTiempo en segundos a simular: ";
cin >> tiempo;
for (;;){
cout << "\nIntervalo entre dos posiciones
consecutivas (seg): ";
cin >> step;
if (step <= 0){
cout << "\n\nEl intervalo debe ser un numero
positivo...";
cout << "\nPreferentemente menor a un segundo.";
}
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.11 Movimiento Browniano
63
else{ // ingresó un step positivo...
break;
cout << "\n\n\n";
}
}
cout << "\nMedia de la posicion: ";
cout << "\n(Presione 0 (cero) si la desconoce): ";
cin >> media;
cout << "Desviacion estandar de la posicion...";
cout << "\n(Presione 0 si la desconoce): ";
cin >> sigma;
if (sigma == 0){
sigma = 1;
}
for (;;){ // hasta que presione S ó N
cout << "\n\nDesea iniciar la semilla? [S/N]";
cin >> semilla;
if (semilla == ’S’ || semilla == ’s’){
srand(time(0));
cout << "\n\nSe reinicia la semilla...";
break; // salir del for infinito
}
if (semilla == ’N’ || semilla == ’n’){
cout << "\n\nNo se reinicia la semilla...";
break; // salir del for infinito
}
cout << "\n\nError en argumento...";
} // end for infinito para la semilla
cout << "\n\n\n"; // un poco de espacio...
t = 0; // reinicio el tiempo del experimento...
ofstream out_stream; // escritura de datos...
out_stream.open("brown.txt"); // creo y abro el archivo...
if (out_stream.fail()){ // si no puede abrir el archivo...
cout << "\n\nNo se pudo abrir el archivo...";
cout << "\nPor favor, reinicie el programa...";
exit(1); // Termina el programa
}
out_stream << "\n";
out_stream << "# Simulacion de un movimiento
Browniano" << "\n";
out_stream << "# el eje t representa al tiempo" << "\n";
out_stream << "# y el eje x (vertical) representa la
posicion..." << "\n";
out_stream << "# Los datos van desde t = 0 hasta t = "
<< tiempo << ".\n";
out_stream << "0 0 i\n"; // Primer dato...
for (t = step; t <= tiempo ; t += step){
x = dnormal(media, sigma);
out_stream << t << " " << x << " i\n";
i++;
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
64
Introducción
}
cout << "\n\n\nSe han grabado " << i << " datos en
el archivo";
cout << "\nbrown.txt\n";
out_stream << "# Este archivo contiene " << i << " datos.";
// pregunto si desea salir...
cout << "\n\n\nPresione < S > para salir...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’)){
break; // Salir del ciclo for inicial...
}
cout << "\n\n\n";
} // end for infinito...
return 0;
}
/**************************************
Declaro la función DNORMAL...
***************************************/
double dnormal(double media, double sigma){
/*
Esta función genera números pseudoaleatorios
con distribución uniforme a partir de su media
y su desviación estándar.
*/
double u, v, x, y, z;
u = uniforme();
y = uniforme();
x = sqrt(-2 * log(u)) * cos(2 * PI * y);
if (u >= 0.5){
z = media + sigma * x;
}
else{
z = media - sigma * x;
}
return z;
}
/**************************************
Declaro la función DNORMAL...
***************************************/
double dnormal(void){
/*
Esta función genera números pseudoaleatorios
con distribución uniforme.
*/
double u, x, y, z;
// Como no se definen la media y
// desviación estándar, las defino...
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.11 Movimiento Browniano
65
double media = 0, sigma = 1;
u = uniforme();
y = uniforme();
x = sqrt(-2 * log(u)) * cos(2 * PI * y);
if (u >= 0.5){
z = media + sigma * x;
}
else{
z = media - sigma * x;
}
return z;
}
/**************************************
Declaro la función UNIFORME...
***************************************/
double uniforme(void){
// Esta función genera un número pseudoaleatorio
// con distribución uniforme en el intervalo (0,1).
return (double(rand())/double(RAND_MAX));
}
Y la gráfica que muestra los resultados que se generaron con esta simulación es:
Bt
3
2
1
t (s)
0
1
2
3
4
5
6
7
−1
−2
−3
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
1.12 Simulación 11
1.12
67
Simulación 11
Escribir un programa con una función que genere números pseudo-aleatorios
con distribución uniforme.
La función debe ser creada por el autor del programa. NO se permite utilizar
la función rand() definida en ANSI-C o en C++ .
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/*
---------------------------------Nombre del Archivo: uniforme.cpp
Descripción:
Este programa simula la generación de números
pseudoaleatorios con distribución uniforme.
Tiene definidas las funciones:
- void suniforme(int seed);
- double uniforme(void);
- double uniforme(float a, float b);
que se diseñaron por el autor de este
programa.
Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 08 de mayo de 2008
17
18
19
20
21
22
23
24
------------------------------------------------------------------*/
#include <cstdio> // Otra librerı́a...
#include <cstdlib> // Librerı́a por si se requiere
#include <iostream> // Funciones básicas para input/output
#include <math.h> // funciones matemáticas
25
26
27
28
29
30
// reinicializar la semilla del aleatorio
void suniforme(int seed);
double uniforme(void);
double uniforme(float a, float b);
void duniforme(void);
31
32
33
// Constantes para las funciones:
const long PROBABILITY_RAND_MAX = 2147483647; // = 2ˆ31 - 1;
34
35
36
37
38
39
int main(int argc, char *argv[]){
char respuesta, distribucion;
double lambda; // promedio de la exponencial
int i, j;
for(;;){ // for infinito...
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
68
Introducción
40
41
42
43
printf("\n\nEste programa genera números aleatorios");
printf("\ncon distribución uniforme...");
// Llamo la función para generar los histogramas...
duniforme();
44
45
46
47
48
49
50
51
52
53
54
55
56
// pregunto si desea salir...
scanf("%c", &respuesta);
printf("\n\n\nPresione < S > para salir... ");
scanf("%c", &respuesta);
if ((respuesta == ’S’)||(respuesta == ’s’)){
break; // Salir del ciclo for inicial...
}
printf("\n\n\n");
} // end for infinito...
// system("PAUSE");
return 0;
}
57
58
59
60
61
62
63
64
65
66
67
68
69
/***************************************************
suniforme(int):
Esta función reinicia la semilla del generador
de números pseudo-aleatorios de la función
double uniforme(void).
****************************************************/
void suniforme(int seed){
static int semilla = seed;
//printf("\n\n\nPasó este punto...");
static bool first = false;
return;
}
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
/***************************************************
uniforme(void):
Esta función genera un número pseudo-aleatorio
con distribución uniforme en el intervalo (0,1).
****************************************************/
double uniforme(void){
double u;
int primo1 = 8191; // = 2ˆ13 - 1;
int primo2 = 524287; // = 2ˆ19 - 1;
static int semilla = 1001; // semilla inicial
static bool first = true;
if (first){
first = false;
return ((double)(semilla)/((double)
(PROBABILITY_RAND_MAX)));
}
unsigned modular = semilla;
//
modular = (primo1 * modular + primo2) %
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.12 Simulación 11
PROBABILITY_RAND_MAX;
semilla = modular; // cambio la semilla...
// calculo el valor que me va a devolver...
u = (double)(modular) / ((double)
(PROBABILITY_RAND_MAX));
return (u);
90
91
92
93
94
95
96
69
}
97
98
99
100
101
102
103
104
105
106
/***************************************************
uniforme(float a, float b):
Esta función genera un número pseudo-aleatorio
con distribución uniforme en el intervalo (a,b).
****************************************************/
double uniforme(float a, float b){
double x = (double)(a) + uniforme() * (double)(b - a);
return x;
}
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
/**************************************
Declaro la función DUNIFORME..
***************************************/
void duniforme(void){
/*
Para generar los números
con distribución uniforme...
*/
// divido el intervalo (0,1) en 10
// subintervalos de igual longitud
// I1 almacenará el número de números
// que caigan en el intervalo (0,0.1)
int I[9]; // los intervalos...
int errores = 0, max =0, min = 1000000;
int imax, imin;
int total; // cuántos vamos a generar...
int semilla;
int correcto = 0;
int i, j; // contadores
float x; // el número generado...
double escala; // para hacer la gráfica...
int factor; // para hacer la gráfica...
float a, b; // Lı́mites del intervalo
char seedu; // para saber si quiere indicar la semilla...
//
printf("\nIndique el lı́mite inferior del intervalo: ");
scanf("%f", &a);
printf("\nIndique el lı́mite superior del intervalo: ");
scanf("%f", &b);
for(;;){ // hasta que ingrese un número entero positivo
printf("\nIndique cuantos numeros desea generar: ");
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
70
Introducción
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
scanf("%d", &total);
if (total <= 0){
printf("\n\nError en argumento...");
printf("\nPor favor, ingrese un número entero positivo...");
printf("\n\n\n");
continue;
}
break;
}
for(;correcto == 0;){ // hasta que reinicie la semilla
printf("\n\nDesea reiniciar la semilla del aleatorio?
[S/N]");
scanf("%c", &seedu);
if (seedu == ’S’ || seedu == ’s’){
for(;;){ // Inicia for infinito ... [A]
printf("\nIndique el valor de la semilla:
(Número Entero) ");
scanf("%i", &semilla);
if (semilla == 0){
//printf("\n\n\nPasó este punto...");
suniforme((int)(time(0)));
printf("\n\nSe ha reiniciado la semilla del
aleatorio...");
printf("\nCon el reloj de la computadora...");
printf("\n\n");
correcto = 1;
break;
}
else{
if (semilla > 0){
suniforme(unsigned(semilla));
printf("\n\nSe ha reiniciado la semilla
del aleatorio...");
correcto = 1;
break;
}
else{ // No tecleó un entero positivo...
printf("Error en argumento...");
printf("\nPor favor, intente de nuevo...");
continue; // regresar a pedir la semilla.
}
} // End else...
} // end for infinito... [A]
}
if (seedu == ’N’ || seedu == ’n’){
printf("\n\nNo se reinicia la semilla del
aleatorio...\n\n");
break;
}
if (correcto == 0){
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
1.12 Simulación 11
printf("\n\nError en argumento...");
printf("\nPor favor, intente de nuevo...");
190
191
}
192
193
71
}
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
// Limpio la memoria del arreglo:
for (i = 0 ; i <= 9 ; i++){
I[i] = 0;
}
for (i = 0; i <= total; i++){
// Genero un pseudoaleatorio
x = uniforme(a, b);
for (j = 0 ; j <= 9 ; j++){
if (x > (a + 0.1 * j * (b - a)) && x <
(a + 0.1 * (j + 1) * (b - a))){
I[j]++;
}
}
}
// Encuentro el intervalo con
// mayor número de ocurrencias
for (i = 0; i <= 9 ; i++){
if (I[i] > max){
max = I[i];
imax = i;
}
if (I[i] < min){
min = I[i];
imin = i;
}
}
// Ahora imprimo los resultados...
for (i = 0 ; i <= 9 ; i++){
printf("\n Intervalo %.1f -- %.1f ", (1.0 * i * (b - a)/
10 + a), (1.0 * (i+1) * (b - a) / 10 + a));
escala = 35.0 * I[i] / max;
factor = int(escala + 0.5); // redondeo
// Imprime la barra del intervalo (i-1)
for (j = 0 ; j <= factor ; j++){
printf("|");
} // termina de imprimir la barra...
if (i == imax){
printf(" (%i) [Max]\n", I[i]);
continue;
}
if (i == imin){
printf(" (%i) [Min]\n", I[i]);
continue;
}
printf(" (%i) \n", I[i]);
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
72
Introducción
240
241
242
}
return;
} // Fin de la función DUNIFORME
Un ejemplo de corrida es la siguiente:
Este programa genera n·meros aleatorios
con distribuci 34 n uniforme...
Indique el lÝmite inferior del intervalo: 0
Indique el lÝmite superior del intervalo: 10
Indique cuantos numeros desea generar: 12000000
Desea reiniciar la semilla del aleatorio? [S/N]s
Indique el valor de la semilla: (N·mero Entero) 0
Se ha reiniciado la semilla del aleatorio...
Con el reloj de la computadora...
Intervalo
Intervalo
Intervalo
Intervalo
Intervalo
Intervalo
Intervalo
Intervalo
Intervalo
Intervalo
0.0
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
-----------
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0
|||||||||||||||||||||||||||||||||||| (1226331)
||||||||||||||||||||||||||||||||||| (1209130)
||||||||||||||||||||||||||||||||||| (1204179)
||||||||||||||||||||||||||||||||||| (1202058)
|||||||||||||||||||||||||||||||||||| (1224251)
||||||||||||||||||||||||||||||||||| (1207161)
|||||||||||||||||||||||||||||||||||| (1238754) [Max]
|||||||||||||||||||||||||||||||||| (1162282)
||||||||||||||||||||||||||||||||| (1128922)
||||||||||||||||||||||||||||||||||| (1196933)
Presione < S > para salir...
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
2
Proyecto Final
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
2.1 Simulación del Recurso Eólico
2.1
2.1.1
75
Simulación del Recurso Eólico
Energı́a extraida del viento
Un generador eólico utiliza la energı́a cinética del viento para generar electricidad.
Lo que pasa en realidad es que la energı́a del viento es transferida a un rotor
que tiene dos o más aspas acopladas mecánicamente al generador eléctrico.
La enegı́a cinética que contienen m kilogramos de viento que se mueve a velocidad v [m/s] es:
1
Ek = mv 2
2
Sin embargo, generalmente no conocemos la masa de aire que atravesarán las
aspas del generador eólico, ası́ que es una mejor idea expresarlo con términos
de la densidad y la velocidad del viento.
Por definición, la densidad ρ del viento es igual al cociente de su masa al volumen. De donde, m = ρ · V .
Podemos ver el volumen de aire que atraviesan las aspas del generador eólico
como el cilindro de altura v · t y área de base igual al área A [m2 ] que barren las
aspas del generador. Entonces, por unidad de tiempo, el volumen de aire que
atraviesan las aspas del generador eólico es:
V =A·v
Flujo volumétrico (m3 /s)
Ası́ que la energı́a cinética del viento con velocidad v puede expresarse como:
P =
1
ρAv 3
2
potencia (W)
El recurso eólico de dos sitios distintos se compara en base a la potencia eólica
especı́fica, es decir, por cada metro cuadrado de área que barren sus aspas.
Sabemos que la potencia eólica especı́fica varı́a con el cubo de la velocidad del
viento.
√
Considerando que 3 2 ≈ 1.2599, podemos darnos cuenta que cuando la velocidad
del viento aumenta en un 25.99% la potencia generada crece al doble. Por otra
parte, si la velocidad del viento disminuye el mismo porcentaje, la potencia
generada disminuye a la mitad.
√
También, 3 3 ≈ 1.4422 nos indica que si la velocidad del viento crece un 44.22%,
la potencia eléctrica generada aumentará al triple, mientras que si la velocidad
del viento disminuye en esa misma cantidad, la potencia generada disminuirá a
la tercera parte.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
76
Proyecto Final
He aquı́ la importancia de caracterizar la distribución de la velocidad del viento
para poder determinar correctamente la potencia generada en un sitio especı́fico.
La energı́a extraida del viento es igual a la diferencia de la energı́a cinética del
viento que atraviesa el generador antes y después de pasar a través de él:
P0 =
1
· ṁ · (v 2 − v02 )
2
donde P0 es la potencia [W] absorvida por el generador, ṁ es el flujo másico
[kg/s], v es la velocidad del viento [m/s] al entrar al generador y v0 es la velocidad
del viento [m/s] después de atravesar el generador.
La velocidad del viento es discontinua de v a v0 en el plano de las aspas del
generador. El flujo másico del viento a través de las aspas se calcula multiplicando la densidad por la velocidad promedio:
v + v0
ṁ = ρ · A ·
2
La potencia mecánica que mueve al rotor, que mueve finalmente al generador
eléctrico es:
1
v + v0
P0 =
ρA ·
· (v 2 − v02 )
2
2
Esta expresión puede reescribirse como:
P0 =
1
ρ A · v3
2
v 2 v0 0
1+
1−
v
v
2
Podemos definir:
v 2 v0 0
1+
1−
v
v
Cp =
2
que representa la fracción del viento que “aprovechan” las aspas del generador
eólico.
Para velocidades de entrada del viento a las aspas del generador eólico, los
valores de Cp dependen de la proporción v0 /v, alcanzando un máximo cuando
este cociente es igual a 1/3. Entonces, Cp = 16/27 ≈ 0.5926.
La máxima potencia transmitida a las aspas ocurrirá cuando v = 3 v0 , o bien,
cuando Cp = 0.5926. Entonces,
P0 =
1
ρ A · v 3 · (0.59)
2
En diseños prácticos de aspas, el valor máximo alcanzado es de aproximadamente 0.5 para turbinas de alta velocidad que trabajan con dos aspas, y entre
0.2 y 0.4 para turbinas de baja velocidad con más aspas.
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
2.1 Simulación del Recurso Eólico
77
Considerando Cp = 0.5 obtenemos una expresión más simple:
P0 =
2.1.2
1
ρ A · v3
4
Distribución del viento
Dato que el viento se origina con las diferencias de densidad en el aire debido
a los cambios de temperatura que el sol ocasiona en el aire atmosférico, con
la colaboración del movimiento rotativo de la tierra, los patrones de viento
generalmente se repiten con periodicidad de un año.
Dado que la potencia generada con un generador eólico es proporcional al cubo
de la velocidad del viento, su distribución se convierte en la medición más importante para determinar la cantidad de energı́a que un sitio considerado.
El comportamiento de la velocidad del viento nunca es estable. Depende de
muchos factores, entre el clima, la topografı́a del lugar y la altura en la que se
mide a partir del suelo.
La velocidad del viento cambia continuamente, por lo que la velocidad promedio
debe basarse en mediciones de al menos una década. De esta manera tendremos
mayor confianza en el valor asignado al sitio. Sin embargo, medir la velocidad
del viento por 10 años requiere de una inversión grande además de que un
proyecto generalmente no puede esperar tanto. En los casos en que se tienen
poca información, se mide la velocidad del viento y ésta se compara con la
velocidad medida en otro sitio cercano y a partir de estas consideraciones se
realiza una estimación del promedio anual del sitio considerado.
Las variaciones de la velocidad del viento se pueden describir por una función
de distribución de probabilidad.
2.1.2.1
Distribución Weibull
La distribución de la velocidad del viento en una localidad puede descibirse
utilizando al distribución Weibull con el parámetro k de forma y el parámetro
c de escala.
La probabilidad de que la velocidad de viento sea de v m/s durante algún
intervalo de tiempo dado es:
v k−1 −(v/c)k
k
h(v) =
e
para 0 < v < ∞
c
c
En la gráfica de distribución de probabilidad se grafica h vs. v para distintos
intervalos de tiempo, donde:
Fracción de tiempo en que la velocidad del viento está entre v y v + ∆v
h=
∆v
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
78
Proyecto Final
Por definición de la función de probabilidad, la probabilidad de que la velocidad
del viento esté entre cero e infinito en ese periodo de tiempo es igual a uno:
Z∞
h dv = 1
0
Si elegimos el periodo de tiempo igual a un año, y expresamos la integral en
términos del número de horas en un año, entonces tenemos:
h=
Número de horas que la velocidad del viento está entre v y v + ∆v
∆v
Las unidades de h son horas por año por metros por segundo, y la integral se
convierte en 8 760, el número total de horas en el año, en lugar de la unidad.
Para la distribución Weibull con valor de k = 1 tenemos la distribución exponencial. En el caso k = 2 la distribución se conoce como distribución Rayleigh.
Este tipo de distribución es el que presenta la velocidad de viento en muchos
sitios.
2.1.2.2
Distribución Rayleigh
• Distribución Rayleigh:
2
f (x)
=
Φ(u)
=
2 αxe−αx para x > 0
0
para x ≤ 0
donde: α > 0 u 2
2u
exp
−
c2
c
Para esta distribución:
µ =
σ2
2.1.2.3
=
r
1 π
2 α
1 π
1−
α
4
Distribución de energı́a
Si definimos la función de densidad de energı́a como:
e=
Contribución en kWh al año por las velocidades entre v y v + ∆v
∆v
podremos graficar esta distribución y la distribución de probabilidad de la velocidad y conocer a partir de qué velocidad el número de horas que el viento
presenta esa velocidad, decrece más rápido que v 3 . Este valor nos indicará un
decremento neto en la contribución energética anual global.
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
2.1 Simulación del Recurso Eólico
2.1.2.4
79
Anemómetros digitales
La velocidad promedio de un sitio en un periodo de tiempo se calcula sumando
muchas lecturas en ese periodo de tiempo entre el número de lecturas. La
mayorı́a de los anemómetros se instalaban con el propósito de medir la velocidad
del viento y no con propósitos de la medición del recurso energético. Ası́ que el
promedio calculado como se indicó se realizaba de manera semejante para una
hora, un dı́a y para un año:
n
1X
v̄ =
vi
n i=1
Pero para estimar el recurso eólico disponible en un lugar necesitamos calcular:
v
u n
u1 X 3
3
v
vrmc = t
n i=1 i
La expresión anterior no toma en cuenta la densidad del aire, que también afecta
la cantidad de energı́a producida por el viento. Para calcular el recurso eólico
de un sitio se recomienda utilizar la siguiente fórmula:
n
Prmc =
1 X
ρi vi3
2 n i=1
donde n es el número de mediciones realizadas, ρi es la densidad del aire [kg/m3 ]
en el momento de realizar la i-ésima medición y vi es la velocidad del viento
[m/s] en la i-ésima medición, y Prmc representa la densidad de energı́a promedio.
2.1.2.5
Predicción del recurso eólico
La energı́a que podemos aprovechar del viento depende de su velocidad, la cual
es una variable aleatoria. Para el operador de la granja eólica esto representa
una dificultad para designar el despacho de energı́a a la red, además de que no
se conoce la cantidad de energı́a disponible con anticipación.
Sin embargo, si la velocidad del viento puede pronosticarse con varias horas
de anticipación, podemos despachar la energı́a de una manera cómoda. Alexiadis, et al1 , han propuesto una nueva técnica para pronosticar la velocidad del
viento y la cantidad de energı́a producida con muchas horas de anticipación. La
técnica está basada en correlación cruzada en sitios vecinos y redes artificiales
neuronales. La técnica propuesta puede mejorar significativamente la precisión
de las predicciones comparado con el modelo comúnmente usado. El modelo
propuesto se calibra en diferentes sitios en un periodo de un año.
1 Alexiadis, M. C., Dokopoulos, P. S., and Sahsamanogdou, H. S. 1998. Wind Speed and
Power Forecasting Based on Spatial Correlation Models, IEEE Paper No. PE-437-EC-0-041998.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
80
Proyecto Final
2.1.3
Un caso especı́fico
• La Venta, Oaxaca. México2 .
– El viento presenta Distribución Weibull.
– Velocidad promedio del viento: 9.3 m/s.
– k = 1.77, c = 11.86 m/s a una altura de 32 metros.
– k = 1.73, c = 10.44 m/s a una altura de 15 metros.
2.1.4
Implementación
Enseguida se muestra el código de la implementación elaborada en el lenguaje
C++ .
/* Nombre del archivo: windFinal.cpp
Este programa simula la velocidad de viento de
una localidad de acuerdo a la distribución que
se especifique.
Calcula además, la densidad de recurso eólico
local (Watts/metro cuadrado) y en el caso de
la distribución Weibull, calcula la velocidad
de viento promedio como media ponderada de la
velocidad media de cada intervalo por la
probabilidad de que el viento presente esa
velocidad.
------------------------------------------------------------------Autor: Efraı́n Soto Apolinar
Email: [email protected]
[email protected]
Fecha de última Modificación: 01 de mayo de 2008
------------------------------------------------------------------*/
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <conio.h>
#include <fstream>
//
double uniforme (void);
double weibull(double c, double k);
//
void duniforme(void);
void drayleigh(void);
void dweibull(void);
float windPower(double windSpeed);
using namespace std;
int main(void){
char respuesta, semilla;
int i = 0;
2 Fuente: Evaluación del recurso eólico de La Venta, Juchitán, Oaxaca. M. A. Borja, O. A.
Jaramillo, M. F. Morales. Instituto de Investigaciones Eléctricas. Temixco, Morelos, México.
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
2.1 Simulación del Recurso Eólico
81
int continuar;
char distribucion;
for (;;){ // for infinito...
//continuar = 0;
cout << "Este programa simula el Recurso Eolico";
cout << "\nde un sitio dados los parametros de su distribucion.";
for (;;){ // hasta que presione S ó N
cout << "\n\nDesea iniciar la semilla del aleatorio? [S/N] ";
cin >> semilla;
if (semilla == ’S’ || semilla == ’s’){
srand(time(0));
cout << "Se reinicia la semilla...";
break; // salir del for infinito
}
if (semilla == ’N’ || semilla == ’n’){
cout << "No se reinicia la semilla...";
break; // salir del for infinito
}
cout << "\n\nError en argumento...";
} // end for infinito para la semilla
cout << "\n\nSeleccione la distribucion estadistica ";
cout << "\nque presenta el viento de la localidad: ";
cout << "\n[R] Rayleigh.";
cout << "\n[W] Weibull.";
cout << "\n[C] Cancelar...";
cout << "\nIngrese una opcion: ";
cin >> distribucion;
switch (distribucion){
case ’R’:
drayleigh();
break;
case ’r’:
drayleigh();
break;
case ’W’:
dweibull();
break;
case ’w’:
dweibull();
break;
case ’C’:
break;
case ’c’:
break;
default:
cout << "\n\nError en argumento...";
cout << "\nPor favor, intente de nuevo...";
continuar = 1;
} // end switch
if (continuar == 0){
// se debe salir...
break;
}
// pregunto si desea salir...
cout << "\n\nPresione < S > para salir... < C > para continuar...";
respuesta = getche();
if ((respuesta == ’S’)||(respuesta == ’s’)){
break; // Salir del ciclo for inicial...
}
cout << "\n\n\n";
respuesta = getche();
} // end for infinito...
return 0;
}
/**************************************
Declaro la función UNIFORME...
***************************************/
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
82
Proyecto Final
double uniforme(void){
// Esta función genera un número pseudoaleatorio
// en el intervalo (0,1) con distribución uniforme.
return (1.0 * rand()/(1.0 * RAND_MAX));
}
/**************************************
Declaro la función WEIBULL...
***************************************/
double weibull(double c, double k){
// Esta función genera números pseudoaleatorios
// con distribución Weibull
double x;
x = c * pow(-log(1 - uniforme()), 1/k);
return x;
}
/**************************************
Declaro la función RAYLEIGH...
***************************************/
double rayleigh(double media){
// Esta función genera números pseudoaleatorios
// con distribución rayleigh
// Fuente:
// http://www.brighton-webs.co.uk/distributions/rayleigh.asp
double factor, r;
factor = media / 1.253314;
r = sqrt(-2 * factor * factor * log(uniforme()));
return r;
}
/**************************************
Declaro la función DWEIBULL..
***************************************/
void dweibull(void){
/*
Para simular viento con distribución Weibull...
*/
int I[24]; // los intervalos...
int max =0, min = 1000000;
int i = 0, j; // contadores
double x; // el número generado...
double escala; // para hacer la gráfica...
int factor; // para hacer la gráfica...
double c, k; // parámetros alpha y beta
double t; // tiempo
float velocidadProm = 0; // Velocidad Promedio
float sv3 = 0;// suma de cubo de velocidad
float densidadEnergetica;
float energia = 0; // Energia anual
//
cout << "\nValor del parametro c: ";
cin >> c; // alpha
cout << "Valor del parametro k: ";
cin >> k; // beta
t = 0; // reinicio el tiempo del experimento...
FILE* f = fopen("speedwei.txt", "w+");
// limpio la memoria del array...
for (i = 0 ; i <= 24 ; i++){
I[i] = 0;
}
for (t = 0; t < 8760; t++){
x = weibull(c, k);// Genero un pseudoaleatorio
fprintf(f, "%f\n", x); // grabo en archivo...
sv3 += pow(x, 3.0) / 4.0;
energia += windPower(x);
for (i = 0 ; i <= 24 ; i++){
if ((x > 0.1 * i * c) && (x <= 0.1 * (i + 1) *c)){
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
2.1 Simulación del Recurso Eólico
83
I[i]++;
break;
}
}
}
fclose(f);
// Calculo la velocidad promedio...
for (i = 0 ; i <= 24 ; i++){
velocidadProm += 1.0 * I[i] * c / 8760;
}
velocidadProm = velocidadProm * 465 / 593; // factor de escala...
// Encuentro el intervalo con mayor número de ocurrencias
for (i = 0; i <= 24 ; i++){
if (I[i] > max){
max = I[i];
}
if (I[i] < min){
min = I[i];
}
}
for (i = 0 ; i <= 24 ; i++){
printf("\n%.2f m/s -- %.2f m/s ", (0.1 * i * velocidadProm),
(0.1 * (i+1) * velocidadProm));
escala = 35.0 * I[i] / max;
factor = (int)(escala + 0.5); // redondeo
// Imprime la barra del intervalo (i-1)
for (j = 0 ; j <= factor ; j++){
cout << "|";
} // termina de imprimir la barra...
if (I[i] == max){
cout << " (" << I[i] << ") [Maximo]";
continue;
}
if (I[i] == min){
cout << " (" << I[i] << ") [Minimo]";
continue;
}
cout << " (" << I[i] << ")";
}
printf("\n\nVelocidad Promedio del viento: %.2f m/s.",
velocidadProm);
// calculo recurso energético...
densidadEnergetica = sv3 / (2 * 8760);
printf("\nDensidad energetica promedio: %.3f W/mˆ2",
densidadEnergetica);
printf("\nEnergia anual estimada: %.2f W-hr/mˆ2.",
energia);
return;
} // Fin de la función DWEIBULL
/**************************************
Declaro la función DRAYLEIGH..
***************************************/
void drayleigh(void){
int I[24]; // los intervalos...
int max =0, min = 1000000;
int total; // cuántos vamos a generar...
int i, j; // contadores
int imax, imin;
double t;
double x; // el número generado...
float sv3 = 0.0;
float densidadEnergetica;
float energia = 0; // Energia anual
float media; // parámetro de la distribución
double escala; // para hacer la gráfica...
int factor; // para hacer la gráfica...
FILE* f = fopen("speedray.txt", "w+");
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
84
Proyecto Final
for(;;){// hasta que indique el valor de lambda
cout << "\nIntroduzca la velocidad media del viento: ";
scanf("%f", &media);
if (media <= 0.0){
cout << "\n\nEl valor debe ser positivo...";
cout << "\nPor favor intente de nuevo...\n";
continue;
}
break;
}
// limpio la memoria del array...
for (i = 0 ; i <= 24 ; i++){
I[i] = 0;
}
for (t = 0; t < 8760; t++){
x = rayleigh(media);// Genero un pseudoaleatorio
x = x * 593 / 465;
fprintf(f, "%f\n", x); // grabo en archivo...
sv3 += pow(x, 3.0) / 4;
energia += windPower(x);
for(i = 0 ; i <= 24 ; i++){
if ((x > 0.1 * i * media) && (x <= 0.2 * (i + 1) * media)){
I[i]++;
break;
}
}
}
fclose(f);
// Encuentro el intervalo con mayor número de ocurrencias
for (i = 0; i <= 24 ; i++){
if (I[i] > max){
max = I[i];
imax = i;
}
if (I[i] < min){
min = I[i];
imin = i;
}
}
// Ahora imprimo el histograma...
for (i = 0 ; i <= 24 ; i++){
printf("\n%.2f m/s -- %.2f m/s ", (0.1*i*media), (0.1*(i+1)*media));
escala = 35.0 * I[i] / max;
factor = (int)(escala + 0.5); // redondeo
// Imprime la barra del intervalo (i-1)
for (j = 0 ; j <= factor ; j++){
cout << "|";
} // termina de imprimir la barra...
if (I[i] == max){
cout << " (" << I[i] << ") [Maximo]";
continue;
}
if (I[i] == min){
cout << " (" << I[i] << ") [Minimo]";
continue;
}
cout << " (" << I[i] << ")";
}
// calculo recurso energético...
densidadEnergetica = sv3 / (2 * 8760);
printf("\n\nDensidad energetica promedio: %.3f W/mˆ2", densidadEnergetica);
printf("\nEnergia anual estimada: %.2f W-hr/mˆ2.", energia);
return;
} // Fin de la función DRAYLEIGH
/**************************************
Declaro la función WINDPOWER..
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
2.1 Simulación del Recurso Eólico
85
***************************************/
float windPower(double windSpeed){
/*
Esta función calcula la energı́a producida por el generador
considerando la el teorema de Welt’z,
Densidad del aire = 1,000 kg/mˆ3,
Area de rotor = 1 mˆ2
v ---> generada por el programa,
windspeed (con distribución dada)
*/
double rho = 1.00; // densidad del aire
double potencia; // Potencia generada
double eficiencia = 0.15; // eficiencia del generador
double weltz = 0.59; // factor de terorema de Weltz
potencia = eficiencia * rho * weltz * pow(windSpeed,3);
return potencia;
}
2.1.5
Resultados de la simulación
Se consideraron los siguientes datos:
• Velocidad promedio del viento: 9.3 m/s.
• k = 1.77, c = 11.86 m/s.
que corresponden a La Venta, Oaxaca. Los parámetros de la distribución
Weibull están calculados a partir de mediciones de velocidad de viento realizadas a 53 metros de altura (respecto del suelo).
Este programa simula el Recurso Eolico
de un sitio dados los parametros de su distribucion.
Desea iniciar la semilla del aleatorio? [S/N] s
Se reinicia la semilla...
Seleccione la distribucion estadistica
que presenta el viento de la localidad:
[R] Rayleigh.
[W] Weibull.
[C] Cancelar...
Ingrese una opcion: r
Introduzca la velocidad media del viento: 9.3
0.00
0.93
1.86
2.79
3.72
4.65
5.58
6.51
7.44
8.37
9.30
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
------------
Simulación
de Sistemas
0.93 m/s
1.86 m/s
2.79 m/s
3.72 m/s
4.65 m/s
5.58 m/s
6.51 m/s
7.44 m/s
8.37 m/s
9.30 m/s
10.23 m/s
|||||| (157)
|||||||||||||||| (449)
|||||||||||||||||||||||||| (752)
||||||||||||||||||||||||||||||||| (944)
|||||||||||||||||||||||||||||||||||| (1045) [Maximo]
|||||||||||||||||||||||||||||||||||| (1040)
|||||||||||||||||||||||||||||||||| (998)
|||||||||||||||||||||||||||||| (857)
|||||||||||||||||||||||| (699)
||||||||||||||||||| (523)
|||||||||||||||| (442)
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
86
Proyecto Final
10.23
11.16
12.09
13.02
13.95
14.88
15.81
16.74
17.67
18.60
19.53
20.46
21.39
22.32
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
---------------
11.16
12.09
13.02
13.95
14.88
15.81
16.74
17.67
18.60
19.53
20.46
21.39
22.32
23.25
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
m/s
||||||||||| (302)
|||||||| (196)
|||||| (143)
|||| (76)
||| (57)
|| (39)
|| (22)
| (7)
| (4)
| (6)
| (1)
| (0) [Minimo]
| (0) [Minimo]
| (0) [Minimo]
Densidad energetica promedio: 403.707 W/mˆ2
Energia anual estimada: 2503818.25 W-hr/mˆ2.
Presione < S > para salir... < C > para continuar... c
Este programa simula el Recurso Eolico
de un sitio dados los parametros de su distribucion.
Desea iniciar la semilla del aleatorio? [S/N] s
Se reinicia la semilla...
Seleccione la distribucion estadistica
que presenta el viento de la localidad:
[R] Rayleigh.
[W] Weibull.
[C] Cancelar...
Ingrese una opcion: w
Valor del parametro c: 11.86
Valor del parametro k: 1.77
0.00 m/s -- 0.92 m/s ||||||||| (159)
0.92 m/s -- 1.85 m/s ||||||||||||||||| (317)
1.85 m/s -- 2.77 m/s |||||||||||||||||||||||| (460)
2.77 m/s -- 3.69 m/s ||||||||||||||||||||||||||||||||| (640)
3.69 m/s -- 4.62 m/s |||||||||||||||||||||||||||||||| (631)
4.62 m/s -- 5.54 m/s |||||||||||||||||||||||||||||||||||| (706) [Maximo]
5.54 m/s -- 6.46 m/s |||||||||||||||||||||||||||||||||||| (699)
6.46 m/s -- 7.39 m/s |||||||||||||||||||||||||||||||||| (669)
7.39 m/s -- 8.31 m/s ||||||||||||||||||||||||||||||| (601)
8.31 m/s -- 9.23 m/s |||||||||||||||||||||||||||||||| (629)
9.23 m/s -- 10.16 m/s |||||||||||||||||||||||||||| (542)
10.16 m/s -- 11.08 m/s |||||||||||||||||||||||| (459)
11.08 m/s -- 12.00 m/s ||||||||||||||||||||||| (435)
12.00 m/s -- 12.93 m/s ||||||||||||||||||| (363)
12.93 m/s -- 13.85 m/s ||||||||||||||||| (315)
13.85 m/s -- 14.77 m/s |||||||||||||| (253)
14.77 m/s -- 15.70 m/s ||||||||||| (201)
15.70 m/s -- 16.62 m/s ||||||||| (153)
16.62 m/s -- 17.54 m/s |||||||| (135)
17.54 m/s -- 18.47 m/s |||||| (102)
18.47 m/s -- 19.39 m/s |||| (66)
19.39 m/s -- 20.32 m/s |||| (65)
20.32 m/s -- 21.24 m/s ||| (45)
21.24 m/s -- 22.16 m/s || (28)
22.16 m/s -- 23.09 m/s || (25) [Minimo]
Velocidad Promedio del viento: 9.23 m/s.
Densidad energetica promedio: 325.489 W/mˆ2
Energia anual estimada: 2018713.00 W-hr/mˆ2.
Presione < S > para salir... < C > para continuar... c
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
2.1 Simulación del Recurso Eólico
87
Este programa simula el Recurso Eolico
de un sitio dados los parametros de su distribucion.
Desea iniciar la semilla del aleatorio? [S/N] s
Se reinicia la semilla...
Seleccione la distribucion estadistica
que presenta el viento de la localidad:
[R] Rayleigh.
[W] Weibull.
[C] Cancelar...
Ingrese una opcion: r
Introduzca la velocidad media del viento: 8.62
0.00 m/s -- 0.86 m/s ||||||| (189)
0.86 m/s -- 1.72 m/s ||||||||||||||||| (489)
1.72 m/s -- 2.59 m/s ||||||||||||||||||||||||| (723)
2.59 m/s -- 3.45 m/s ||||||||||||||||||||||||||||||| (929)
3.45 m/s -- 4.31 m/s |||||||||||||||||||||||||||||||||||| (1075) [Maximo]
4.31 m/s -- 5.17 m/s ||||||||||||||||||||||||||||||||||| (1033)
5.17 m/s -- 6.03 m/s |||||||||||||||||||||||||||||||| (965)
6.03 m/s -- 6.90 m/s |||||||||||||||||||||||||||||| (898)
6.90 m/s -- 7.76 m/s |||||||||||||||||||||||| (700)
7.76 m/s -- 8.62 m/s ||||||||||||||||||| (562)
8.62 m/s -- 9.48 m/s |||||||||||||| (395)
9.48 m/s -- 10.34 m/s |||||||||| (264)
10.34 m/s -- 11.21 m/s |||||||| (210)
11.21 m/s -- 12.07 m/s ||||| (125)
12.07 m/s -- 12.93 m/s |||| (85)
12.93 m/s -- 13.79 m/s ||| (54)
13.79 m/s -- 14.65 m/s || (27)
14.65 m/s -- 15.52 m/s || (21)
15.52 m/s -- 16.38 m/s | (9)
16.38 m/s -- 17.24 m/s | (5)
17.24 m/s -- 18.10 m/s | (0) [Minimo]
18.10 m/s -- 18.96 m/s | (1)
18.96 m/s -- 19.83 m/s | (1)
19.83 m/s -- 20.69 m/s | (0) [Minimo]
20.69 m/s -- 21.55 m/s | (0) [Minimo]
Densidad energetica promedio: 310.544 W/mˆ2
Energia anual estimada: 1926020.50 W-hr/mˆ2.
Presione < S > para salir... < C > para continuar... c
Este programa simula el Recurso Eolico
de un sitio dados los parametros de su distribucion.
Desea iniciar la semilla del aleatorio? [S/N] s
Se reinicia la semilla...
Seleccione la distribucion estadistica
que presenta el viento de la localidad:
[R] Rayleigh.
[W] Weibull.
[C] Cancelar...
Ingrese una opcion: w
Valor del parametro c: 10.44
Valor del parametro k: 1.73
0.00 m/s -- 0.81 m/s
0.81 m/s -- 1.62 m/s
1.62 m/s -- 2.44 m/s
Simulación
de Sistemas
|||||||||| (169)
||||||||||||||||||| (354)
||||||||||||||||||||||||||| (509)
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
88
Proyecto Final
2.44 m/s -- 3.25 m/s |||||||||||||||||||||||||||||||| (609)
3.25 m/s -- 4.06 m/s ||||||||||||||||||||||||||||||||| (624)
4.06 m/s -- 4.87 m/s |||||||||||||||||||||||||||||||||||| (677) [Maximo]
4.87 m/s -- 5.68 m/s |||||||||||||||||||||||||||||||||||| (668)
5.68 m/s -- 6.50 m/s |||||||||||||||||||||||||||||||||||| (674)
6.50 m/s -- 7.31 m/s ||||||||||||||||||||||||||||||||| (615)
7.31 m/s -- 8.12 m/s ||||||||||||||||||||||||||||||| (575)
8.12 m/s -- 8.93 m/s |||||||||||||||||||||||||||||||| (593)
8.93 m/s -- 9.74 m/s |||||||||||||||||||||||||| (492)
9.74 m/s -- 10.56 m/s ||||||||||||||||||||| (394)
10.56 m/s -- 11.37 m/s |||||||||||||||||||| (359)
11.37 m/s -- 12.18 m/s ||||||||||||||| (278)
12.18 m/s -- 12.99 m/s |||||||||||||| (259)
12.99 m/s -- 13.80 m/s |||||||||||| (212)
13.80 m/s -- 14.62 m/s ||||||||| (155)
14.62 m/s -- 15.43 m/s ||||||| (120)
15.43 m/s -- 16.24 m/s |||||| (92)
16.24 m/s -- 17.05 m/s ||||| (75)
17.05 m/s -- 17.86 m/s ||||| (71)
17.86 m/s -- 18.68 m/s ||| (48)
18.68 m/s -- 19.49 m/s ||| (43)
19.49 m/s -- 20.30 m/s || (24) [Minimo]
Velocidad Promedio del viento: 8.12 m/s.
Densidad energetica promedio: 226.478 W/mˆ2
Energia anual estimada: 1404631.75 W-hr/mˆ2.
Presione < S > para salir... < C > para continuar...
El número entre paréntesis a la derecha de cada intervalo indica la cantidad
de horas que se tuvieron velocidades de viento en ese intervalo en un año, considerando que la distribución de probabilidad de esa variable aleatoria sigue la
distribución indicada.
Es de notar que la densidad energética varı́a al considerar distintas distribuciones, a pesar de utilizar los datos de un sitio obtenidos a partir del mismo
estudio y realizar el cálculo de la densidad de recurso eólico local con la misma
metodologı́a.
Para la distribución Weibull se obtuvo una densidad energética de 315.558
W/m2 , mientras que para el caso de la distribuión Rayleigh se obtuvo un valor
correspondiente de 403.202 W/m2 . El primer caso siendo un 78.26% de la segunda estimación.
También es importante indicar que no se calcula la densidad de recurso eólico
a partir de la velocidad promedio estimada, sino con las velocidades de viento,
conforme se van generando estos valores con la distribución correspondiente.
Cuando se elige la distribución Weibull, el programa calcula la velocidad promedio del viento a partir de la siguiente fórmula:
n
P
v=
vi · P (vi )
i=1
n
P
fi
i=1
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
2.1 Simulación del Recurso Eólico
89
donde n es es el número de intervalos en los cuales se dividió la distribución
al dibujar el histograma, vi es la velocidad promedio del intervalo i de la distribución, P (vi ) es la probabilidad de que el viento tenga la velocidad vi , que
se calculó dividiendo la frecuencia fi del i−ésimo intervalo entre el número de
mediciones realizadas.
A. Los resultados pronosticados...
Datos de la Ventosa, Oax. México. (32 metros)
3 Velocidad del Viento promedio:
Rayleigh: 9.3 m/s∗
Weibull: 9.23 m/s
3 Densidad energética promedio:
Rayleigh: 403.707 W/m2
Weibull: 325.489 W/m2
3 Energı́a anual estimada:
Rayleigh: 2.503 818 MW-hr/m2
Weibull: 2.018 713 MW-hr/m2
Para el caso de las mediciones a 15 metros, se utilizó la siguiente relación para
aproximar el valor de la velocidad de viento a esa altura:
• Sean v2 la velocidad del viento a la altura h2 ,
• y v1 la velocidad del viento a la altura h1 ...
• Entonces, se cumple:
v2 = v1
h2
h1
α
• donde α es el coeficiente de fricción superficial con el suelo caracteristico
local3 .
Valores tı́picos de α
Tipo de
Terreno
Lago, Océano, Terreno firme y plano
Pasto alto en terreno plano
Sembradı́os, arbustos, forraje
Bosque o selva
Población pequeña con árboles
Ciudad con edificios altos
3 Fuente:
Coeficiente de
Fricción (α)
0.10
0.15
0.20
0.25
0.30
0.40
Wind and Solar Power Systems. Patel, Mukind R. CRC Press. 1 999
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
90
Proyecto Final
Usando la relación anterior, y considerando que los generadores eólicos están
instalados en una playa, tenemos:
0.1
15
= 8.62 m/s.
vh=15m = 9.3
32
B. Los resultados pronosticados...
Datos de la Ventosa, Oax. México. (15 metros)
3 Velocidad del Viento promedio:
Rayleigh: 8.62 m/s∗
Weibull: 8.12 m/s
3 Densidad energética promedio:
Rayleigh: 310.544 W/m2
Weibull: 226.478 W/m2
3 Energı́a anual estimada:
Rayleigh: 1.926 021 MW-hr/m2
Weibull: 1.404 632 MW-hr/m2
2.1.6
Conclusiones
Resultados: los resultados obtenidos con la simulación están basados en consideraciones teóricas solamente. Para realizar cálculos más precisos se
requieren datos más detallados.
Por ejemplo, el programa calcula la densidad energética eólica, es decir,
la cantidad de energı́a que se espera recuperar con un generador eólico
por cada metro cuadrado de área que barran las aspas de los generadores
instalados en ese lugar.
Para pronosticar la cantidad de energı́a generada en ese lugar, se requiere,
además, el radio de las aspas de los generadores que se instalarán, las curvas de eficiencia de los generadores contra la velocidad del viento, entre
otros parámetros.
Problemas: Conseguir información sobre la distribución del viento y sus parámetros hasta hoy es complicado, no porque las personas que se encargan
de trabajar en esta área sean muy celosos de estos datos, sino porque hay
muy pocas bases de datos.
La mayorı́a de las mediciones que se habı́an hecho sobre las velocidades
de viento de diferentes localidades se habı́a realizado con fines de obtener
información para el pronóstico del tiempo. Estas mediciones solamente
estaban interesadas en la velocidad promedio del viento, y no en la distribución que presenta el viento y mucho menos en los parámetros de la
misma.
Para un proyecto de generación de energı́a a partir del viento, se requieren
conocer con precisión la distribución que presenta el viento, porque una
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
2.1 Simulación del Recurso Eólico
91
inversión grande requiere de estudios detallados para asegurar el éxito del
proyecto.
Trabajo Futuro: Él código del programa generado trabaja correctamente con
el compilador Dev-Cpp Versión 4.9.9.2.
La conversión de el código al lenguaje C es muy sencilla, y de hecho, algunas de las funciones que utiliza actualmente el código se elaboraron en
ANSI-C, de manera que la conversión debe resultar sencilla.
Por otra parte, serı́a una excelente idea convertir este código al lenguaje
Java, porque este lenguaje permite el uso de utilerı́as gráficas, que facilitarı́an la generación de una animación.
Lecciones Aprendidas:
1. La simulación de un sistema requiere, además de una buena preparación
en cuestiones técnicas de la materia (programación en algún lenguaje
de alto nivel, matemáticas, en particular estadı́stica, etc.), un sólido
conocimiento en las bases de la materia del evento o sistema que se
desea simular.
Una persona inexperta en el área de energı́a eólica pudo suponer que
la velocidad del viento podı́a considerarse con la misma magnitud
a 15, 32 ó 50 metros de altura, ocasionando errores graves en los
resultados obtenidos.
2. Cuando se desea realizar una simulación, se requiere de información
“de calidad”. Si no se cuenta con información “buena”, se corre el
riesgo de simular algo que no está acorde con la realidad.
En casos de sistemas que no se conocen muy bien, o que tienen poca
información sobre el mismo, conviene suponer algunos valores y finalmente decidir si esos valores son adecuados de acuerdo a los resultados que arroja la simulación y comparar éstos con los valores que
se debı́an esperar.
3. La simulación es solamente una simulación. No se debe considerar la
simulación como un sustituto del sistema real. De hecho, para hacer
la simulación hemos hecho muchas suposiciones que nos ayudan a
simplificar el sistema real.
En el caso de este proyecto, para el cálculo de la densidad energética
se consideró que la distribución que se midió y se reportó en el artı́culo
Evaluación del recurso eólico de La Venta, Juchitán, Oaxaca, era la
que el programa generado simulaba, y además que los valores de la
probabilidad para cada velocidad de viento considerada en cada inervalo del histograma de frecuencias generado por el mismo programa,
era el que se presentó en ese lugar.
Evidentemente, el valor de la densidad energética pronosticada cambiará, aún con el mismo algoritmo, si se aumenta o disminuye el
número de intervalos a considerar al dibujar el histograma de frecuencias de las velocidades de viento.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
92
Proyecto Final
Efraı́n Soto A.
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Simulación
de Sistemas
3
End matter
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
3.1 Fuentes bibliográficas
3.1
95
Fuentes bibliográficas
Para la fundamentación de este proyecto final se utilizaron las siguientes fuentes:
Wind and solar power systems Patel, Mukind R., CRC Press.
1999. ISBN 0-8493-1605-7
EE.UU.
Handbook of wind energy Tony Burton, et al. Ed. John Wiley & Sons.
EE.UU. 2001. ISBN 0-471-48997-2
y se consultaron los siguientes artı́culos:
3 Alexiadis, M. C., Dokopoulos, P. S., and Sahsamanogdou, H. S. 1998.
Wind Speed and Power Forecasting Based on Spatial Correlation Models,
I.E.E.E. Paper No. PE-437-EC-0-04-1998.
3 M. A. Borja, O. A. Jaramillo, M. F. Morales. Evaluación del recurso
eólico de La Venta, Juchitán, Oaxaca, 2001. I.S.E.S. Millenium Solar
Forum 2000. ERS-22-01.
En cuanto a la parte de programación en los lenguajes C++ y C, y generación
de números pseudoaletaorios, se consultaron las siguientes fuentes:
Discrete-event system simulation Jerry Banks, John S. Carson II, Barry
L. Nelson. Ed. Prentice Hall. 1996. (2nd Edition)
Probabilidad y estadı́stica para ingenieros Ronald E. Walpole, Raymond
H. Myers. Ed. McGraw-Hill. México. 1989.
Mathematical Statistics John E. Freund. Ed. Prentice Hall. EE.UU. 1992.
5ta. Edición.
C++ for mathematicians Edward Scheinerman. Ed. Chapman & Hall. 2006.
Problem solving with C++ Walter Savitch. Ed. Addison Wesley. 1999.
(2nd Edition)
Además, el modelo matemático para generar números pseudoaleatorios con distribución Rayleigh, se obtuvo de la siguiente dirección de internet:
http://www.brighton-webs.co.uk/distributions/rayleigh.asp
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
3.2 Términos de uso
3.2
97
Términos de uso
Efraı́n Soto Apolinar no es responsable por cualesquiera daños ocasionados por
el uso de este material.
Tienes derecho de leer el material y de divulgarlo a otras personas, con la única
condición de que no modifiques el documento en ninguna forma.
Si deseas utilizar alguna parte del material, puedes hacerlo, con la única condición
de que menciones la fuente, i.e., este material y a Efraı́n Soto Apolinar como el
autor.
Espero que este material pueda ser de ayuda a muchas personas que desean
aprender la simulación de sistemas.
Con estas notas estoy aprendiendo junto contigo.
En realidad el material que estas leyendo lo estoy generando como un resumen
de lo que voy aprendiendo. Voy a utilizarlo en lo futuro como una referencia.
Este material está siendo actualizado continuamente.
Te agradeceré que me envı́es un mensaje en caso de que encuentres errores en
las definiciones, procedimientos, soluciones, ortografı́a y/o gramática, etc., del
mismo.
El material no ha tenido ninguna revisión. Agradezco infinitamente tu ayuda.
Efraı́n Soto Apolinar.
Simulación
de Sistemas
Notas del curso Simulación de Sistemas
Prohibida la reproducción sin permiso previo del autor.
Efraı́n Soto A.
3.3
Créditos
Este documento se preparó con el software de tipografı́a cientı́fica LATEX 2ε .
Todas las figuras que se presentan en este material se elaboraron con el paquete
TikZ de LATEX 2ε .
Créditos...
Profesor: Dr. César Villarreal.
Estudiante: Efraı́n Soto Apolinar.
Diseño de portada: Efraı́n Soto Apolinar.
Edición: Efraı́n Soto Apolinar.
Composición tipográfica: Efraı́n Soto Apolinar.
Productor general: Efraı́n Soto Apolinar.
Revisión técnica: Pendiente.
Año de edición: 2008
Año de publicación: Pendiente
July 11, 2008
Última revisión:
6:31pm
Agradezco tus sugerencias, comentarios, correcciones, reclamos y todo lo que se
le parezca a cualquiera de las cuentas de correo electrónico:
[email protected]
[email protected]
@
@