Simulación de Monte Carlo aplicada al Fútbol

Simulación de Monte Carlo aplicada al Fútbol

Ahora que está de moda el tema de las “Clasificatorias” al mundial Brasil 2014, pues me anime a simular lo que queda del torneo.
Como mencione en un post anterior, puede usarse la simulación de Monte Carlo para estos fines. Pero veamos como lo lograremos.
En primer lugar, ¿Cuál es el objetivo del juego? Pues el GOL, entonces lo que simularemos será justo eso. Pero como vimos es necesario tener las frecuencias de los eventos. Y pues me di el afán de analizar esta situación.
Veamos, tenemos que ver cuán frecuente es que un equipo puede hacer en un partido 0, 1, 2, 3 … n goles, además de eso está el hecho de que un equipo es Local y el rival es visitante, o ambos están en terreno neutral.
Busque en la página de la FIFA información de los procesos de eliminatorias desde 1964 y obtuve las siguientes estadísticas:

Frecuencia de Goles por partido

Mundial	Goles anotados por partido por Equipo
	0	1	2	3	4	5	6	7	8	Total
1966	10	10	10	4	1	1	1	1		38
1970	17	14	9	4	1	1	2			48
1974	9	12	5	1	3					30
1978	15	16	5	2	1	1	1		1	42
1982	13	12	5	5		1				36
1986	16	18	17	6	2		1			60
1990	10	10	11	2	1	1	1			36
1994	23	20	10	2	3	3	1	2		64
1998	40	60	25	8	7	2	2			144
2002	60	58	32	18	5	6	1			180
2006	57	63	28	18	8	6				180
2010	65	56	34	14	8	5	2			184
2014	21	36	16	6	8	1				88
Total	356	385	207	90	48	28	12	3	1	1130

Como vemos, desde 1966 se han anotado 1130 Goles en procesos de Clasificatorias para los mundiales, y la frecuencia partidos en los que no se han anotado goles es de 356, mientras que en los que se ha anotado 1 Gol es de 385, incluso hay 1 solo caso (1978) en el que se anotaron 8 Goles!!!, con esta información podríamos armar la tabla de frecuencias para un estado “Neutral”, sin embargo, es sabido que los equipos se hacen más fuertes cuando juegan en sus estadios, y esto lo vamos a ver en las siguiente tabla:

Mundial	Goles anotados por partido por Equipo																			Total general
	Local									Total	Visitante								Total
	0	1	2	3	4	5	6	7	8		0	1	2	3	4	5	6	7
1966	3	3	7	3	1	1		1		19	7	7	3	1			1		19	38
1970	7	7	4	3	1		2			24	10	7	5	1		1			24	48
1974	3	5	3	1	3					15	6	7	2						15	30
1978	5	7	4	1	1	1	1		1	21	10	9	1	1					21	42
1982	4	6	2	5		1				18	9	6	3						18	36
1986	6	8	9	4	2		1			30	10	10	8	2					30	60
1990	3	3	9	1		1	1			18	7	7	2	1	1				18	36
1994	9	7	9	1	3	1	1	1		32	14	13	1	1		2		1	32	64
1998	13	25	18	6	7	1	2			72	27	35	7	2		1			72	144
2002	22	26	18	16	3	5				90	38	32	14	2	2	1	1		90	180
2006	21	27	16	13	8	5				90	36	36	12	5		1			90	180
2010	24	28	21	7	5	5	2			92	41	28	13	7	3				92	184
2014	4	19	7	5	8	1				44	17	17	9	1					44	88
Total general	124	171	127	66	42	22	10	2	1	565	232	214	80	24	6	6	2	1	565	1130

Aquí vemos una comparación de goles de Local y Visitante, como se aprecia, la frecuencia de 0 goles anotados para los locales ha bajado drásticamente, mientras que para los visitantes ha subido bastante. Esto demuestra el hecho de que el local en su estadio se hace “Más Fuerte”, entonces podríamos armar las tablas de frecuencia para los estados de “Local” y “Visitante”
Entonces tenemos la siguiente tabla de frecuencias:

Goles	Frecuencias
	Local	Visitante	Neutral
0	124	232	356
1	171	214	385
2	127	80	207
3	66	24	90
4	42	6	48
5	22	6	28
6	10	2	12
7	2	1	3
8	1		1
Total general	565	565	1130

¿Entonces ya está?, pues parece que sí, con esto sería suficiente para poder simular los resultados del resto del torneo, sin embargo, podríamos añadir un “Modificador” de posibilidades, basadas en por ejemplo:

• Plantel
• Arqueros
• Defensas
• Medio Campo
• Delanteros
• Moral del Equipo
• Fatiga del Equipo
• Entrenador
• Apoyo de la Afición

Esto debido a que por ejemplo un encuentro entre Argentina contra Bolivia (disculpen amigos Bolivianos), Argentina, tiene un mejor plantel, y si nos basamos solo en las frecuencias descritas anteriormente, pues no sería del todo “Justo”.
Entonces comparemos planteles, “Arqueros + Defensas” contra “Delanteros +Medio Campo”, de cada equipo, afectados por supuesto por las otras variables
Entonces el modelo que planteo es el siguiente:
El plantel tendrá un acumulado de máximo 100 puntos, distribuido de la siguiente manera:

• Arqueros 15%
• Defensas 35%
• Medio Campo 25%
• Delanteros 25%

El resto de variables afectarían al acumulado de plantel, con la siguiente configuración:

• Moral del Equipo +/- 15%
• Fatiga del Equipo +/- 5%
• Entrenador +/- 3%
• Apoyo de la Afición +/- 10%

Claro que esta distribución debería ser configurable
Entonces definamos variables:

• Plantel PLA
• Arqueros ARQ
• Defensas DEF
• Medio Campo MED
• Delanteros DEL
• Moral del Equipo ME
• Fatiga del Equipo FE
• Entrenador ENT
• Apoyo de la Afición AF

Entonces la fórmula para el “Peso” de un equipo seria:
PESO=(ARQ+DEF+MED+DEL)*(1+ME)*(1+FE)*(1+ENT)*(1+AF)
Entonces, por ejemplo, supongamos la siguiente configuración para Argentina

• Plantel 95
• Arqueros 15
• Defensas 30
• Medio Campo 25
• Delanteros 25
• Moral del Equipo 0.10
• Fatiga del Equipo 0
• Entrenador 0.03
• Apoyo de la Afición -0.02

Esto quiere decir que tiene los valores más altos en el plantel, en apoyo de la afición tiene una merma, y fatiga del equipo está en 0, porque suponemos que empiezan en un estado neutral de fatiga. Por lo tanto su “Peso” seria:
PESO=(15+30+25+25)*(1+0.10)*(1+0)*(1+0.03)*(1-0.02)=105.48
Ahora hagamos una para Bolivia:

• Plantel 59
• Arqueros 5
• Defensas 20
• Medio Campo 15
• Delanteros 19
• Moral del Equipo 0.05
• Fatiga del Equipo -0.01
• Entrenador 0
• Apoyo de la Afición 0.09

Esto quiere decir que por ejemplo, el entrenador no aporta “nada”, tiene un plantel inferior al de Argentina, pero su afición lo apoya bastante; entonces su peso seria:
PESO=(5+20+15+19)*(1+0.05)*(1-0.01)*(1+0)*(1+0.09)=66.85
Como vemos, Argentina tiene un mayor “peso” que Bolivia, y debería tener mayor oportunidad de anotar goles
Ahora, esto parece estar listo, sin embargo, no es lo mismo enfrentar a Bolivia contra Argentina, que a Bolivia contra Paraguay; ya que supongamos, que tienen los mismos pesos, pero uno tiene mejor delantera que defensas del otro equipo, entonces nos falta aún analizar este aspecto.
Hagamos una merma más entonces. Comparamos (Defensas + Arqueros) de uno, contra (Medio Campo + Delanteros) del otro
Nace una nueva variable: Peso en el Encuentro=PEN
Las formulas serían las siguientes:
PEN1=PESO1*((ARQ1+DEF1)/(MED2+DEL2))=105.48*((15+30)/(15+19))=139.61
PEN2=PESO2*((ARQ2+DEF2)/(MED1+DEL1))=66.85*((5+20)/(25+25))=33.425
Ahora que tenemos los pesos para encuentro de cada uno, calculamos con que modificadores simularemos usando el método de Monte Carlo
M1=PEN1/Max(PEN1,PEN2)=139.61/139.61=1
M2=PEN2/Max(PEN1,PEN2)=33.425/139.61=0.2394
Listo, ahora tengo el modificador calculado para ambos equipos, y este actuara de la siguiente manera:
Suponemos que:

• Argentina es Local, y obtengo un aleatorio de 0.425
• Bolivia es Visita, y obtengo un aleatorio de 0.862

Aplicamos modificadores:

• Aleatorio para Argentina: 0.425*M1=0.425*1=0.425
• Aleatorio para Bolivia: 0.862*M2=0.862*0.2394=0.2064

Ahora veamos las frecuencias:

Frecuencias para Local

Goles	Frec	Frec Rel	Frec Acum	Inicio	Final
1	171	0.30265	0.3027	0.0000	0.3027
2	127	0.22478	0.5274	0.3027	0.5274
0	124	0.21947	0.7469	0.5274	0.7469
3	66	0.11681	0.8637	0.7469	0.8637
4	42	0.07434	0.9381	0.8637	0.9381
5	22	0.03894	0.9770	0.9381	0.9770
6	10	0.01770	0.9947	0.9770	0.9947
7	2	0.00354	0.9982	0.9947	0.9982
8	1	0.00177	1.0000	0.9982	1.0000
Total	565	1.00000

Como suponemos que el local es Argentina, su aleatorio, al ser el mayor no le afecta el modificador, y caería en la zona de 2 Goles
Ahora para Bolivia:

Frecuencias para Visita

Goles	Frec	Frec Rel	Frec Acum	Inicio	Final
0	232	0.41062	0.4106	0.0000	0.4106
1	214	0.37876	0.7894	0.4106	0.7894
2	80	0.14159	0.9310	0.7894	0.9310
3	24	0.04248	0.9735	0.9310	0.9735
4	6	0.01062	0.9841	0.9735	0.9841
5	6	0.01062	0.9947	0.9841	0.9947
6	2	0.00354	0.9982	0.9947	0.9982
7	1	0.00177	1.0000	0.9982	1.0000
8	0	0.00000	-----	-----	-----
Total	565	1.00000

Bolivia al ser visitante, usa esta tabla de frecuencias, y como vemos, con su aleatorio modificado caería en 0 Goles, mientras que si no hubiéramos aplicado el modificador caería en la zona de 2 Goles
Por lo tanto, el resultado sería:

• Si se aplica modificadores: Argentina (2) – (0) Bolivia
• Si no se aplica modificadores: Argentina (2) – (2) Bolivia

Como vemos, la aplicación de los modificadores brindan “justicia” al resultado, pero como sabemos, los números aleatorios, nos pueden dar cualquier resultado, pero creo que el modelo propuesto describe un poco mejor la realidad
Ahora supongamos que Argentina es la Visita, y tenemos los mismos modificadores y números aleatorios, el resultado seria:

Frecuencias para Local

Goles	Frec	Frec Rel	Frec Acum	Inicio	Final
1	171	0.30265	0.3027	0.0000	0.3027
2	127	0.22478	0.5274	0.3027	0.5274
0	124	0.21947	0.7469	0.5274	0.7469
3	66	0.11681	0.8637	0.7469	0.8637
4	42	0.07434	0.9381	0.8637	0.9381
5	22	0.03894	0.9770	0.9381	0.9770
6	10	0.01770	0.9947	0.9770	0.9947
7	2	0.00354	0.9982	0.9947	0.9982
8	1	0.00177	1.0000	0.9982	1.0000
Total	565	1.00000

Frecuencias para Visita

Goles	Frec	Frec Rel	Frec Acum	Inicio	Final
0	232	0.41062	0.4106	0.0000	0.4106
1	214	0.37876	0.7894	0.4106	0.7894
2	80	0.14159	0.9310	0.7894	0.9310
3	24	0.04248	0.9735	0.9310	0.9735
4	6	0.01062	0.9841	0.9735	0.9841
5	6	0.01062	0.9947	0.9841	0.9947
6	2	0.00354	0.9982	0.9947	0.9982
7	1	0.00177	1.0000	0.9982	1.0000
8	0	0.00000	1.0000	1.0000	1.0000
Total	565	1.00000

• Si se aplican modificadores: Bolivia (1) – (1) Argentina
• Si no se aplican modificadores: Bolivia (3) – (1) Argentina

Conclusiones

El método de Montecarlo si es aplicable para este tipo de problemas
Es necesario señalar que el uso de los modificadores planteados, proporcionan un sentido de “Justicia” a la simulación

Finalizando

Bueno eso es todo por esta vez, en un próximo post, implementaremos una aplicación para hacer esta simulación

Simulación de Monte Carlo en Visual Basic

Simulación de Monte Carlo

Un poco de Teoria

La simulación de Monte Carlo es una técnica cuantitativa que hace uso de la estadística y los ordenadores para imitar, mediante modelos matemáticos, el comportamiento aleatorio de sistemas reales no dinámicos (por lo general, cuando se trata de sistemas cuyo estado va cambiando con el paso del tiempo, se recurre bien a la simulación de eventos discretos o bien a la simulación de sistemas continuos).
La clave de la simulación MC consiste en crear un modelo matemático del sistema, proceso o actividad que se quiere analizar, identificando aquellas variables (inputs del modelo) cuyo comportamiento aleatorio determina el comportamiento global del sistema. Una vez identificados dichos inputs o variables aleatorias, se lleva a cabo un experimento consistente en:

1. Generar –con ayuda del ordenador- muestras aleatorias (valores concretos) para dichos inputs, y
2. Analizar el comportamiento del sistema ante los valores generados. 

Tras repetir n veces este experimento, dispondremos de n observaciones sobre el comportamiento del sistema, lo cual nos será de utilidad para entender el funcionamiento del mismo –obviamente, nuestro análisis será tanto más preciso cuanto mayor sea el número n de experimentos que llevemos a cabo.
Veamos un ejemplo sencillo:
En la tabla inferior se muestra un análisis histórico de 200 días sobre el número de consultas diarias realizadas a un sistema de información empresarial (EIS) residente en un servidor central.
La tabla incluye el número de consultas diarias (0 a 5) junto con las frecuencias absolutas (número de días que se producen 0, 1, ..., 5 consultas), las frecuencias relativas (10/200 = 0,05, ...), y las frecuencias relativas acumuladas.

Consultas EIS	Frecuencias Absolutas (dias)	Frecuencia Relativa	Frecuencia Relativa Acumulada
0	10	0.05	0.05
1	20	0.10	0.15
2	40	0.20	0.35
3	60	0.30	0.65
4	40	0.20	0.85
5	30	0.15	1.00
Total	200	1.00

Podemos interpretar la frecuencia relativa como la probabilidad de que ocurra el suceso asociado, en este caso, la probabilidad de un determinado número de consultas (así, p.e., la probabilidad de que se den 3 consultas en un día sería de 0,30), por lo que la tabla anterior nos proporciona la distribución de probabilidad asociada a una variable aleatoria discreta (la variable aleatoria es el número de consultas al EIS, que sólo puede tomar valores enteros entre 0 y 5).
Supongamos que queremos conocer el número esperado (o medio) de consultas por día.
La respuesta a esta pregunta es fácil si recurrimos a la teoría de la probabilidad: Denotando por X a la variable aleatoria que representa el número diario de consultas al EIS,sabemos que: E[X]=0*0.05+1*0.10+...+5*0,15=2,95
Por otra parte, también podemos usar simulación de Monte Carlo para estimar el número esperado de consultas diarias (en este caso se ha podido obtener el valor exacto usando teoría de probabilidad, pero ello no siempre será factible). Veamos cómo:
Cuando se conozca la distribución de probabilidad asociada a una variable aleatoria discreta, será posible usar la columna de frecuencias relativas acumuladas para obtener los llamados intervalos de números aleatorios asociados a cada suceso. En este caso, los intervalos obtenidos son:

• [0.00,0.05) para el suceso 0 
• [0.05,0.15) para el suceso 1 
• [0.15,0.35) para el suceso 2 
• [0.35,0.65) para el suceso 3 
• [0.65,0.85) para el suceso 4 
• [0.85,1.00) para el suceso 5 

El gráfico siguiente nos muestra cada una de las probabilidades sobre el número de consultas. En él, se aprecia claramente la relación existente entre probabilidad de cada suceso y el área que éste ocupa.

Esto significa que, al generar un número pseudo-aleatorio con el ordenador (proveniente de una distribución uniforme entre 0 y 1), estaremos llevando a cabo un experimento cuyo resultado, obtenido de forma aleatoria y según la distribución de probabilidad anterior, estará asociado a un suceso. Así por ejemplo, si el ordenador nos proporciona el número pseudo-aleatorio 0.2567, podremos suponer que ese día se han producido 2 consultas al EIS. A continuación simularemos una serie de numeros pseudo-aleatorios y veremos cual es el resultado:

Aleatorio	Clase
0.74594	4
0.02769	0
0.41357	3
0.08281	1
0.92104	5
0.45407	3
0.79709	4
0.07949	1
0.48303	3
0.38276	3
0.99765	5
Promedio	2.909

En este caso, hemos obtenido un valor estimado que se acerca bastante con el valor real anteriormente calculado vía la definición teórica de la media. Sin embargo, debido a la componente aleatoria intrínseca al modelo, normalmente obtendremos valores “cercanos” al valor real, siendo dichos valores diferentes unos de otros (cada simulación proporcionará sus propios resultados). 

Si usamos pocas observaciones, los valores que obtendríamos no serían estimaciones tan buenas al valor real. Por el contrario, es de esperar que si hubiésemos usado 1000 (o mejor aún 10000) observaciones, los valores que obtendríamos en estarían todos muy cercanos al valor real.

Ahora implementemos esta Simulación

Primero veamos que necesitamos para implementar esta simulación:

1. Definir las "FRECUENCIAS" para cada "CLASE"
2. Generar los "RANGOS" en base a las "FRECUENCIAS ACUMULADAS" de las "CLASES"
3. En base a un "VALOR ALEATORIO" necesitamos evaluar en que "RANGO" cae, para así saber que "CLASE" le corresponde
4. Retornar como resultado la "CLASE" a la que le corresponde este "VALOR ALEATORIO"
5. Obtener el "VALOR ESPERADO" en base a una serie de "OBSERVACIONES"

Ahora, se han resaltado algunos puntos, y pasaremos a ver uno de ellos, el Rango. para eso definiremos la siguiente clase:

Public Class Rango
    Sub New(i As Nullable(Of Double), f As Nullable(Of Double))
        If i.HasValue Then Inicio = i
        If f.HasValue Then Final = f
    End Sub
    Property Inicio As Nullable(Of Double) = Double.NegativeInfinity
    Property Final As Nullable(Of Double) = Double.PositiveInfinity
    Public Function Dentro(v As Double) As Boolean
        Return Inicio <= v And v < Final
    End Function
    Public Overrides Function ToString() As String
        Return String.Format("De {0,6:N10} a {1,6:N10}", Inicio, Final)
    End Function
End Class

Si nos fijamos, en el constructor, pasamos el inicio y el final para el rango, pero usamos Nullable(Of Double) esto para permitir rangos orientados hacia el infinito positivo o negativo, según sea el caso.
Esto se comprueba en la definición de las propiedades
La función Dentro es la que evalúa si un valor esta dentro de este rango.
Por ultimo se ha sobreescrito la función ToString, con el fin de facilitar la depuración y ver el rango sin necesidad de expandir el la depuración

Ahora vamos a ver la Clase MonteCarlo:

Public Class Montercarlo
    Public Shared Property TamañoMuestra As Integer = 1000
    Private Shared _aleatorio As New Random
    Private _rangos As Dictionary(Of Integer, Rango)
    Private _frecuencias As Dictionary(Of Integer, Double)

    Public Sub New()
        _frecuencias = New Dictionary(Of Integer, Double)
    End Sub

    Public Sub AddFrecuencia(clase As Integer, frecuencia As Double)
        _frecuencias.Add(clase, frecuencia)
        CalcularRangos()
    End Sub

    Private Sub CalcularRangos()
        Dim _frecOrd = (From f In _frecuencias Order By f.Value Descending).ToList
        Dim _frecSum = _frecOrd.Sum(Function(k) k.Value)
        _rangos = New Dictionary(Of Integer, Rango)
        Dim v1 As Decimal = 0
        Dim v2 As Decimal = 0
        For Each f In _frecOrd
            v1 = v2
            v2 += f.Value / _frecSum
            _rangos.Add(f.Key, New Rango(v1, v2))
        Next
    End Sub

    Public Function GetUno() As Integer
        Return GetId(GetAleatorio())
    End Function

    Private Function GetId(v As Double) As Integer
        Return (From r In _rangos Where r.Value.Dentro(v)).FirstOrDefault.Key
    End Function

    Public Function GetEsperado() As Integer
        Dim muestra As New List(Of Double)
        For i = 1 To TamañoMuestra
            muestra.Add(GetUno())
        Next
        Return Aggregate a In muestra Into Average(a)
    End Function

    Private Function GetAleatorio() As Double
        Return _aleatorio.NextDouble)
    End Function
End Class

Ahora, tenemos varias cosas que resaltar:

Private _rangos As Dictionary(Of Integer, Rango)
Private _frecuencias As Dictionary(Of Integer, Double)

Aqui tenemos dos diccionarios privados, uno para los Rangos y otro para las Frecuencias. Y por que diccionarios? pues porque facilita la busqueda por Clave. La idea es que conforme vamos ingresando Frecuencias, recalcularemos los rangos, ya que no se sabe a priori los rangos. Por eso se implemento la funcion AddFrecuncia:

Public Sub AddFrecuencia(clase As Integer, frecuencia As Double)
    _frecuencias.Add(clave, frecuencia)
    CalcularRangos()
End Sub

Como se aprecia, pasamos la clase y la frecuencia, y la clase actua como Key en el diccionario y la frecuencia como Value. Inmediatamante añadida la frecuencia recalculamos los rangos

    Private Sub CalcularRangos()
        Dim _frecOrd = (From f In _frecuencias Order By f.Value Descending).ToList
        Dim _frecSum = _frecOrd.Sum(Function(k) k.Value)
        _rangos = New Dictionary(Of Integer, Rango)
        Dim v1 As Decimal = 0
        Dim v2 As Decimal = 0
        For Each f In _frecOrd
            v1 = v2
            v2 += f.Value / _frecSum
            _rangos.Add(f.Key, New Rango(v1, v2))
        Next
    End Sub

Aqui calculamos los rangos. si se fijan hay una variable _frecord, que contendra las frecuncias ordendas; en base a una consulta "LinQ to Objects". Ordenamos las frecuencias como una optimización del Metodo Monte Carlo para algunas aplicaciones (veremos para que en un post futuro). Tambien Hay una variable _frecsum, que calcula, en base a una consulta LinQ la sumatoria de las frecuencias, para poder calcular luego las frecuencias acumuladas, requisito indispensable para calcular los rangos. La sumatoria se esta haciendo con una función Lambda Bueno, luego hay un simple bucle donde vamos agregando objetos "Rango" con un Key igual a la clase. El resultado es el siguiente:

Como vemos, ya estan generados los rangos, pero cabe destacar que estos mismos estan reordenados en forma descendente en base a su frecuencia, esto ayuda en casos en que se necesita aplicar un modificador a la variable aleatoria y asi dar prioridad a los mas frecuentes, como dije, esto lo veremos en otro post.

Ahora veamos como generar numeros aleatorios:

Private Shared _aleatorio As New Random
Private Function GetAleatorio() As Double
    Return _aleatorio.NextDouble)
End Function

Primero definimos una variable estatica del tipo Random, y nos valemos de su método NextDouble, que nos devuelve un aleatorio entre 0 y 1 Y ahora veremos como obtener una "Observacion":

    Public Function GetUno() As Integer
        Return GetId(GetAleatorio())
    End Function

    Private Function GetId(v As Double) As Integer
        Return (From r In _rangos Where r.Value.Dentro(v)).FirstOrDefault.Key
    End Function

La funcion "GetUno" llama a la funcion "GetId" pasandole un aleatorio.
La funcion "GetId" busca en el diccionario de rangos, usando una consulta LinQ, uno donde el valor aleatorio se encuentre "dentro" y no devuelve el "key" del primer resultado
Ahora ya sabemos como obtener una observación, solo nos faltaria obtener el "valor esperado", y esto se hace con:

    Public Shared Property TamañoMuestra As Integer = 1000
    Public Function GetEsperado() As Integer
        Dim muestra As New List(Of Double)
        For i = 1 To TamañoMuestra
            muestra.Add(GetUno())
        Next
        Return Aggregate a In muestra Into Average(a)
    End Function

Como vemos, hemos presupuesto un tamaño demuestra de 1000 observaciones, y simplemente con un bucle vamos añadiendo muestras a una lista, para luego, mediante una consulta LinQ de agregación calculamos la media y retornamos este valor.
Ahora simulemos el caso que vimos en la parte teorica:

Imports GaSKSoft.Predictor.Montecarlo
Module Module1

    Sub Main()
        Dim m As New Montercarlo
        m = New Montercarlo
        m.AddFrecuencia(0, 10)
        m.AddFrecuencia(1, 20)
        m.AddFrecuencia(2, 40)
        m.AddFrecuencia(3, 60)
        m.AddFrecuencia(4, 40)
        m.AddFrecuencia(5, 30)
        Console.WriteLine("Frecuencias:")
        Console.WriteLine("0: 10")
        Console.WriteLine("1: 20")
        Console.WriteLine("2: 40")
        Console.WriteLine("3: 60")
        Console.WriteLine("4: 40")
        Console.WriteLine("5: 30")
        Console.WriteLine(
            "El valor esperado para una muestra de {0} observaciones es:{1}",
            Montercarlo.TamañoMuestra,
            m.GetEsperado())
        Console.ReadKey()
    End Sub

End Module

Y el resultado es:

Como vemos, con una muestra de 1000 observaciones, el resultado es mas preciso.

Concluciones

El metodo de Monte Carlo nos ayuda a simular situaciones en las que las probabilidades de varios eventos son conocidos, y se requiere obtener, en base a estas, un valor esperado, tomando como base una "nube" de observaciones.

En este post tambien se ha utilizado Consultas LinQ to Objects, y demuestra que reduce significativamente el proceso de consultar listas, incluso se le pueden calcular agregados del tipo suma, promedio, producto, cuenta, etc. en una sola linea!!!!!

Finalizando

Espero que el post les guste y les sirva para alguna implementación futura.