Parte 5

curso c++ finanzas

Monte-Carlo c++ – opciones cesta

Objectivos

-implementar valoración opciones cesta (basket, himalaya, rainbow , spread options, autocallables)

Opcion Cesta

vamos a ver como calcular con c++ opciones cesta con 2 subyacentes con payoff:

$$ ( w_1S_1+w_2S_2-K)^+ $$
donde $$ w_i $$ son pesos de cada acción en el payoff (lo normal es pesos iguales que suman 1)
como siempre consideramos tipos de interés 0 y las acciones no pagan dividendos (sino hay que añadir termino $$ (r-q)dt$$ en la dinámica

$$dS_1=S_1 \sigma_1 dW_1(t)$$
$$dS_2=S_2 \sigma_2 dW_2(t)$$

$$ dW_i dW_j=\rho_{i,j} dt$$

donde $$\rho_{i,j}$$ es la matriz de correlaciones.
una vez tenemos la matriz de correlaciones construimos su descomposición Cholesky.
la podemos hacer con boost o con Quantlib , con quantlib es mas facil.ya que usamos quantlib usaremos sus clases para matrices y vectores.
QuantLib::Matrix para matrices y QuantLib::Array para Así podemos escribir A=B*x para multiplicar matriz por vector.

para obtener las gaussianas con matriz correlación dada generaremos primero las gaussianas independientes $$\vec{\epsilon}= (\epsilon_1, \epsilon_2)$$ .
Asi que el vector de gaussianas correladas sera $$M_{cholesky} \vec{\epsilon}$$

aqui viene el codigo (con pesos=1)

#include 
#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=10000;

	std::vector S0(2);
	S0[0]=100.0;// S1(0) - spot price of first stock
	S0[1]=100.0;//S2(0) - spot price of second stock

	std::vector sigma(2);
	sigma[0]=0.2; //volatility of S1
	sigma[1]=0.2;//volatility of S2

	double T=1.0;//maturity in years
	double K=100.0;//strike of option
	double sum=0;//for monte-carlo averaging
	double payoff=0;
	double NT=100;//number of time intervals
	double dt=T/NT;
	
	QuantLib::Matrix rho(2,2);//correlation matrix

	rho[0][0]=1;rho[0][1]=0.5;
	rho[1][0]=0.5;rho[1][1]=1;

	QuantLib::Matrix cholesky=QuantLib::CholeskyDecomposition(rho);
	
	for(int iSim=0;iSim Sprev(S0); //create a vector equal to S0 with its values
		std::vector Snext(2);//create vector with 2 elemens

		for(double t=0;t
		Publicado en curso c++ finanzas			

Parte 4

curso c++ finanzas

Monte-Carlo c++ – payoffs asiática y lookback

Objetivos

– implementar opcion asiática con c++
– implementar opcion lookback

Aquí mostraremos como extender el programa precedente a las opciones que dependen del camino

Opción Asiática

empezaremos con la opción asiática:
payoff:

$$ payoff=(\frac{1}{T}\int_0^T S_t dt – K)^+ $$

1) en vez de calcular la integral continua calcularemos la media aritmética del precio de la acción S
2) para calcular la media dividimos el intervalo de tiempo [0..T] en N partes , cada una dt

0–dt–2td–3dt–…. T

tendremos que simular cada camino de la acción paso a paso
para pasar del paso precedente al paso siguiente de la acción usaremos dinámica Black Scholes con tipos de interés 0 (para simplificar las formulas)

$$S_0=100$$
$$S_{dt}=S_0 exp( -0.5 \sigma^2 dt + \sigma \sqrt{dt} x )$$
$$S_{next}=S_{prev} exp( -0.5 \sigma^2 dt + \sigma \sqrt{dt} x )$$

monte carlo c++

Aqui esta el código para la opción asiática

#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=1000;

	double S0=100.0;
	double sigma=0.2;
	double T=1.0;
	double K=100.0;
	double sum=0;
	double payoff=0;
	double NT=100;
	double dt=T/NT;
	
	for(int iSim=0;iSim
#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=1000;

	double S0=100.0;
	double sigma=0.2;
	double T=1.0;
	double K=100.0;
	double sum=0;
	double payoff=0;
	double NT=100;
	double dt=T/NT;
	
	for(int iSim=0;iSim
		Publicado en curso c++ finanzas			

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
		Publicado en curso c++ finanzas			

C++ finanzas curso – parte 2 – Black-Scholes a través de la integración numérica

objetivo

cálculo de opción de compra (Call) de Black-Scholes con c++

C++ y QuantLib tienen muchos tipos de variables. En las finanzas cuantitativas los tipos más útiles son:

double – para almacenar números reales
int – para almacenar números enteros
QuantLib :: Date – para almacenar fechas
QuantLib :: Array – guardar array de doubles
QuantLib :: Matrix – para almacenar la matriz 2D de doubles

vamos a empezar haciendo con integración numérica

borrar todos los contenidos del fichero source.cpp copiar y pegar el código siguiente

ejemplo – la integración numérica Call

este código calculará integral
$$ \int_ {0} ^ {1} e^x dx $$

#include  
#include  //for using math functions

//everything after // is a comment

double f(double x) //declaration of function f(x)=exp(x)
{
return std::exp(x);
}

void main() 
{
	
	double dt=0.0001; //integration step
	double sum=0; //current value of integral
	for(double t=0;t<1.0;t+=dt) //for loop    t+=dt means t=t+dt
	{
	sum+=f(t)*dt; // its equivalent to write sum=sum+f(t)*dt;
	}
std::cout<<"integral "<< sum; //output

int dummy;std::cin>>dummy;//screen delay
}

leer acerca de las estructuras de control de bucle y otra aquí: http://www.cplusplus.com/doc/tutorial/control/

Notas importantes:
utilizar 1.0 en vez de 1
en c + + 1.0 y 1 son diferentes números 1.0 es el número real y 1 es el número entero
que significa que 1/2 = 0. mientras que 1.0/2 es 0.5

al hacer comparaciones de dobles no lo uses si (x == 0)
utilizar si (std :: abs (x) <epsilon) donde épsilon es su precisión (por ejemplo 10 ^ -8)

la variable t es «visible» sólo dentro loop
Consulte «Variables scope» aquí http://www.cplusplus.com/doc/tutorial/variables/

Aquí hemos utilizado la forma más simple de integración numérica
para un integratoin rápido / más precisa puede utilizar otros métodos
muchos de ellos se describen en el libro gratis «recetas numéricas en c»
este libro es para C, pero la estructura del código sería el mismo

ejemplo

– opción Call en Black Scholes usando integración

Ahora vamos a cambiar el programa anterior para calcular opción Call en modelo Black-Scholes con tasas de interés cero

dinámica neutral al riesgo:
$$ dS_t = S_t \sigma dWt $$
así
$$ S_T S_0 = exp (-0.5 \sigma^2 + \sigma \sqrt x T) $$
donde x es un estándar gaussiano
por lo que el precio de la opción llamada será
$$ Call = \int_{-\infty}^{+\infty} (S_0 e ^ {-0,5 \sigma ^ 2 + \sigma \sqrt T x} – K) ^ + \phi (x) dx $$
donde $$ \phi(x) = \frac {1} {\sqrt {2 \pi}} exp (-0.5 x ^ 2) $$ densidad gaussiana estándar
S0 = 100
volatilidad = 20%
vencimiento = T = 1 año

#include 
#include 
#include 

double density(double x) //normal density 
{
	const double pi = boost::math::constants::pi();
	return 1.0/sqrt(2.0*pi)*std::exp(-0.5*x*x);
}

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

double f(double K,double S0,double T,double sigma,double x) //function to integrate  
{
return pp(S0*std::exp(-0.5*sigma*sigma*T+sigma*std::sqrt(T)*x)-K)*density(x);  
}

void main()
{
	double S0=100.0;
	double sigma=0.2;
	double T=1.0;
	double K=80.0;
	double dx=0.0001;
	double sum=0;

	for(double x=-10.0;x<10.0;x+=dx)
	{
	sum+=f(K,S0,T,sigma,x)*dx;
	}
std::cout<<"call= "<< sum;

int dummy;std::cin>>dummy;
}

Notas:

tenemos que pasar argumentos de nuevo a la función integrada debido a que su alcance original está dentro main () , por lo que las variables K, S0 etc no son visibles en el interior función f (x)
usamos impulsar aquí para extraer constante Pi, por lo que será más fácil de portar a programas linux por ejemplo (estándar de C++ no tiene constantes matemáticas)

ejercicios

– Debugear primer programa mediante el establecimiento de puntos de interrupción y ver las variables de suma y t valor del cambio
– Cambiar el primer programa para integrar a través de regla trapezoidal , compruebe los resultados con respuesta conocida $$ e^1-1 $$
– Cambie segundo programa para incluir los tipos de interés no cero
– Cambie segundo programa para calcular el precio puesto
– Verificar llama poner la paridad

algunos trucos

si tienes un error siempre comienza corrigiendo primer error de compilación (doble clic en la línea de error de compilación)
algunos mensajes de error de + c + son bastante crípticos y son el resultado de errores anteriores

por ejemplo, eliminar el «;» después sentencia return
pulse F7 para compilar
Ahora haga doble clic en el primer error:

black scholes c++

curso c++ finanzas para principiantes – Parte 1 – hola mundo

REQUISITOS del curso c++ finanzas
:
– Experiencia en programación en otro lenguaje
– conocimientos en finanzas cuantitativas básicas

Los objetivos del curso :

– valorar diferentes derivados financieros utilizando código en C++
– Usar funciones basicas de QuantLib y Boost utiles en la ingeniería financiera

instalación C++, Boost y QuantLib

1) instalar Visual Studio 2012 Express:

http://www.microsoft.com/visualstudio/eng/downloads # d-express-windows-desktop

debugging c++ program

2) instalar Boost

Hello world finance c++

– Descargar la última versión de Boost de http://www.boost.org

c++ boost download

– Descomprimirlo en la unidad C:
[asi que la libreria estara en c:\boost_1_53_0]

– Ir al directorio c:\boost_1_53_0 y ejecutar bootstrap.bat
– Ejecutar b2.exe
puede tardar mucho tiempo en ejecutarlo – es normal.

build boost library

– Ir al directorio c:\boost_1_53_0\stage
mover directorio «lib» en c:\boost_1_53_0\ para que todas las bibliotecas construidas se encuentren dentro de c:\boost_1_53_0\lib

3) instalar QuantLib

descargar QuantLib
http://sourceforge.net/projects/quantlib/files/

quantlib download

descomprimir a C:\

– Abrir Visual Studio Express for Desktop

File-> abrir proyecto QuantLib_vc10.sln (esta en directorio QuantLib)

quantlib solution

Seleccione la opción «update» en el siguiente diálogo. Esto convertira los archivos a formato de Visual Studio 2012

en el Explorador de soluciones seleccione QuantLib
pulse Shift-F4 (o Menu-> View-> properties)

añadir a la variable «include directories» la ruta de boost
añadir a la variable «library directories» la ruta de boost\lib

set boost directories

ahora eliminar todos los proyectos, excepto QuantLib de la solución (haga clic en cada proyecto en el Explorador de soluciones y pulse «del»)

pulse F7 para compilar QuantLib [o Menu->build solution]

Programa Hello world

Menu>New Project

elija Visual C++ -> Win32 Console Application

new win32 console app

presione OK->NEXT (NO presionar FINISH aún)

marque «Empty Project»
desmarque la opción «Security …»

new empty project

haga clic en Finalizar

Haga clic derecho sobre ConsoleApplication1 y incluir directorios QuantLib y Boost:

hello world c++ finance

haga clic derecho en «Sources» -> Add -> Add new Item

add new c++ file

en la ventana que aparece pegar el siguiente código:

#include 
#include 

using namespace QuantLib;

void main()
{
	
	Date date1(30,January,2013);
	Date date2;
	date2=date1+1*Years;

std::cout<>dummy;
}

hello world quantlib

pulse F7 para compilar

haga doble clic en el error:

quantlib compile error visual studio 2012

y cambiar la siguiente línea:

#  error "unknown Microsoft compiler"

por

#  define QL_LIB_TOOLSET "vc100"

para que se vea así:

quantlib compile error

pulse F7 para construir proyectos y F5 para ejecutar

hello world quantlib

rápida explicación del código:

#include <ql/quantlib.hpp>
#include

estas líneas simplemente insertar archivos denominados quantlib.hpp y iostream en el archivo de origen
se necesita quantlib.hpp tener funciones QuantLib y definiciones (Fecha objeto)
y iostream se utiliza para escribir en la consola de salida

using namespace QuantLib;

sin que esta línea que te tenías que escribir «QuantLib ::» antes de cada objeto QuantLib

void main()
{

	Date date1(30,January,2013);
	Date date2;
	date2=date1+1*Years;

std::cout<>dummy;
}

estas líneas definen la función principal
en c + +, cuando se inicia programa de consola que se inicia la ejecución de la función main ()

	Date date1(30,January,2013);
	Date date2;

Aquí se definen dos objetos QuantLib (variables) date1 y date2 y asignamos un valor de la primera variable

date2=date1+1*Years;
std::cout<
aquí se le asigna el valor de date2 se que es 1 año a partir de date1
y std :: cout parte imprime el resultado a la consola
int dummy;std::cin>>dummy;

esto es necesario para poner en pausa la pantalla
depuración del programa
para depurar haga clic en el area donde  aparece el punto rojo y presione F5
debugging c++ program
se iniciará la depuración y puede flotar cursor sobre la variable para ver su valor.
como se puede ver date1 es un número en vez de fecha . Es porque QuantLib internamente utiliza el formato de Excel para las fechas.
pulse F10 para ejecutar las instrucciones de una en una y F5 de nuevo para continuar con el programa hasta el siguiente breakpoint