Parte 3

curso c++ finanzas

Monte-Carlo c++

Objetivos

– generar números aleatorios
– Calcular una opción Call con Monte – Carlo
– intro a std::vector

Aquí vamos a ver cómo utilizar contenedores std::vector en C++

en muchos libros de c++ usan c++ arrays (por ejemplo, double x[10]) para almacenar variables.Esto tiene bastantes inconvenientes para los principiantes, así que aquí vamos a utilizar std::vector para almacenar números reales.
std::vector es un objeto – esto significa que se puede añadir un punto «.» después del nombre del objeto y se podra ver que tiene no sólo un valor, sino muchas diferentes «sub-variables» y «sub-funciones»

generación de números aleatorios gaussianas

Para implementar el motor de Monte-Carlo en C++ necesitaremos números gaussianos estándar.
C++ tiene una función de generar los números aleatorios, pero no son buenos para la ingeniería financiera (funcion random() ).

Uno de los más utilizados generadores de numeros seudo-aleatorios con buenas características es algoritmo Mersenne Twister
Ya esta implementado en Boost. Después de que tengamos números aleatorios uniformes podemos generar las variables gaussianas con una function. Esta también esta implementada en Boost.
aquí está el código para generar 100 gaussianas estándar:

#include 
#include 
#include 
#include 



void main()
{

    boost::mt19937 mt; //create object of mersenne twister generator
    boost::normal_distribution<> distribution; // create distribution object
    boost::variate_generator>* normal(new boost::variate_generator>(mt,distribution)); //create variate generator which will generate gaussians
	
	for (int i=0;i<100;i++)
           std::cout<< (*normal)()<>dummy;
}

aquí hemos usado puntero a variable.
puntero es básicamente la dirección de la variable en la memoria.
para acceder a las variables por punteros se utiliza asterisco *
leer más sobre punteros aquí

para almacenar estos números podemos utilizar la clase std::vector
leer más sobre esta clase Aqui

aquí vamos a ilustrar su uso común:

#include 
#include 
#include 
#include 
#include 


void main()
{

    boost::mt19937 mt; 
    boost::normal_distribution<> distribution;
    boost::variate_generator>* normal    (new boost::variate_generator>(mt,distribution));
	
    std::vector v;

    for (int i=0;i<100;i++)
	v.push_back( (*normal)() ) ;
	
     for (int i=0;i<100;i++)
	std::cout<>dummy;
}

ahora vamos a hacer una funcion para calcular la media de los elementos de este vector:

#include 
#include 
#include 
#include 
#include 


double mean(std::vector& v) //here we use &  to indicate that we pass value of variable to function by address and not by creating new variable and copying data into it
{
	int N=v.size();
	double sum=0;
	for(int i=0;i distribution;
    boost::variate_generator>* normal(new boost::variate_generator>(mt,distribution));
	
	std::vector v;

	for (int i=0;i<100;i++)
		v.push_back( (*normal)() ) ;
	
	for (int i=0;i<100;i++)
		std::cout<
std::vector v;//crear vector vacio
std::vector v(10);//create vector de 10 elementos  primer elemento es v[0]
v[0]=4;//asignar valor al primer elemento del vector
v.resize(100);//resize vector to have 100 elements;
v.size();//retorna numero de elementos en el vector

si se quiere hacer operaciones simples de vectores hay posibilidades de que estas operaciones ya están implementadas en STL o en Boost.
por ejemplo, nuestro programa anterior para calcular la media de conjunto podría reescribirse utilizando algoritmos de STL de la siguiente manera:

sum =std::accumulate(v.begin(),v.end(),0.0); //need to #include 

so before writing a function to do simple things on vector google first somthing among the lines «std::vector sum of elements»

Ejercicio

– cambiar el programa precedente para calcular la varianza de los números aleatorios

Ya que tenemos numeros gaussianos ya estamos listos para implementar pricing de la opcion call con Monte Carlo

opción Call con monte carlo c++

suponemos la dinamica de Black-Scholes con tipos de interes cero
asi que:

$$S_T=S_0 exp(-0.5 \sigma^2 T + \sigma \sqrt{T} x )$$
donde x es la gaussiana estándar

Precio monte carlo de call es la media de los payoffs obtenidos
$$ (S_T(x)-K)^+$$

#include 
#include 
#include 
#include 


double pp(double x) //positive part   x+   
{
if(x>0) return x;
return 0;
}

void main()
{

	boost::mt19937 mt; 
	boost::normal_distribution<> distribution;
	boost::variate_generator>* normal(new boost::variate_generator>(mt,distribution));
	
	int numberSimulations=100000;

	double S0=100.0;
	double sigma=0.2;
	double T=1.0;
	double K=100.0;
	double sum=0;
	double payoff=0;

	for(int iSim=0;iSim
					
‹ curso c++ finanzas [parte 2] – opcion Call via integracion
					
curso c++ finanzas [parte 4] – Monte Carlo c++ opcion asiatica y lookback ›