C++ y las finanzas

cuantitativas
std::cpp 2013
Quantitative and Business Solutions / Valuation Design Noviembre 2013

Juan Morales Velasco

C++ y las finanzas cuantitativas / Noviembre 2013

Agradecimientos

Pgina 2

C++ y las finanzas cuantitativas / Noviembre 2013

ndice
1

Introduccin a las finanzas cuantitativas

Introduccin a los derivados financieros

C++ en las finanzas cuantitativas

Pgina 3

C++ y las finanzas cuantitativas / Noviembre 2013

Introduccin a
las finanzas
cuantitativas
Pgina 4

C++ y las finanzas cuantitativas / Noviembre 2013

Finanzas Cuantitativas
Aplicacin de las matemticas y la tecnologa a los mercados financieros
Se busca elaborar modelos matemticos que representen el rendimiento de un conjunto
de activos, basndose en un conjunto de hiptesis
Se toman los precios observables en mercado como inputs
El precio del producto es igual al coste de cobertura de sus riesgos. Esto exige disponer
de herramientas y sistemas
Consistencia matemtica vs teora econmica

Pgina 5

C++ y las finanzas cuantitativas / Noviembre 2013

Quants: Analistas cuantitativos

Ingenieros, Matemticos, Fsicos
Slidos conocimientos en matemticas
Slidos conocimientos en programacin
Harry Markowitz's
"Portfolio Selection"

1952

Nobel Black - Scholes

1969

1997

Robert Merton
introduce el clculo
estocstico

Pgina 6

C++ y las finanzas cuantitativas / Noviembre 2013

Quants: Herramientas
Mathematics
theory
Estadstica y teora de

la probabilidad

Ecuaciones

diferenciales

Variable compleja

Numerical
Methods
rboles/Diferencias

finitas

Simulacin Montecarlo
Optimizacin

multidimensional

Transformada de

Fourier

Computer
Science
Algoritmia
Reusabilidad
Eficiencia
Orientacin a Objetos
Conectividad
Tcnicas HPC: grid

computing, FPGAs,
GPUs

Pgina 7

C++ y las finanzas cuantitativas / Noviembre 2013

Introduccin a
los derivados
financieros
Pgina 8

C++ y las finanzas cuantitativas / Noviembre 2013

Qu es un derivado?
Los derivados son contratos financieros cuyo valor est ligado al valor de ciertos activos que cotizan
en un mercado de contado. De forma que a su vencimiento en tiempo T, su valor F(T) es conocido y
se puede determinar unvocamente en funcin de los valores de los activos subyacentes hasta
vencimiento ST
Funcin de pago de un futuro

Funcin de pago de una opcin de compra

6

4
Pago

Pago

2
0
-2

-4

10

12

Valor del subyacente

-6

La parte ms representativa del contrato o termsheet es lo que

se llama funcin de pago o payoff, F(ST,T). El caso ms sencillo
es el de los contratos de futuro, donde

F(T) = ST-K

3
2
1
0
0

6
8
Valor del subyacente

10

12

A partir de aqu se puede hacer tan complejo como se requiera,

pero un punto de inflexin son los contratos con ejercicio
opcional, el ms bsico vendra definido por F(T) = max(0, STK) que recibe el nombre de opcin call u opcin de compra
Pgina 9

C++ y las finanzas cuantitativas / Noviembre 2013

Derivado, como instrumento de cobertura

Una aerolnea tiene previsto su consumo de combustible durante el ao 2014.
Debido a que el precio al que comprar dicho combustible es incierto, su cuenta de resultados
durante dicho ejercicio presenta cierta variabilidad.
Funcin de pago de un
futuro

Funcin de pago de una

opcin de compra

Cubierto con Forward

K
Pago

Pago

2
0
-2
-4
-6

Cubierto con Opcin

12

3
2
1

Valor del subyacente

C0

ST

Compra forward de dicho combustible.

Se trata de una compra a efectuar a inicios del 2014 a un precio
determinado hoy
No existe beneficio producido por bajadas en el precio del
combustible

3
6
9
Valor del subyacente

12

ST

Podra entrar en un contrato en el que, en lugar de tener la

obligacin de comprar el combustible a cierto precio K, tuviera
la opcin
La aerolnea ejecutara la opcin en caso de que el precio del
subyacente en la fecha de vencimiento del derivado sea
superior a K
Pgina 10

C++ y las finanzas cuantitativas / Noviembre 2013

Valoracin del Derivado

dSt = St dt + S t dWt
123
123
Re ntabilidad

dWt ~ N 0, dt

Incertidumbre

20
18
16
14
12
10
8
6
4
2
0
0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

Pgina 11

C++ y las finanzas cuantitativas / Noviembre 2013

C++ en las
finanzas
cuantitativas
Pgina 12

C++ y las finanzas cuantitativas / Noviembre 2013

Por qu C++ en finanzas

Cuantitativas?
Compromiso
entre eficiencia y
simplicidad

Lenguaje de alto nivel enfocado al rendimiento

Encapsulacin:
Fomenta la reutilizacin
de cdigo

Necesario en proyectos grandes y/o complejos realizados por

equipos grandes a lo largo del tiempo

Soporta desarrollo
multiparadigma

Flexibilidad para enfocar cada problema desde la ptica justa

Lenguaje estandarizado
por ISO

Asegura su continuidad y su homogeneidad a lo largo del

tiempo
Pgina 13

C++ y las finanzas cuantitativas / Noviembre 2013

3.1

Optimizacin
de un
esquema de
simulacin de
Montecarlo
Pgina 14

C++ y las finanzas cuantitativas / Noviembre 2013

Objetivo
Acelerar la simulacin de un proceso estocstico bajo un esquema de simulacin de
Montecarlo
Resultado
Resultado resultado;
resultado;
Generador
Generador generador;
generador;
Simulador
simulador;
Simulador simulador;
Productor
Productor producto;
producto;
Inicializacion(generador,
Inicializacion(generador, simulador,
simulador, producto,
producto, resultado);
resultado);
for(unsigned
for(unsigned long
long ii == 0;
0; ii !=
!= nPaths;
nPaths; ++i)
++i)
{{
generador->camino();
generador->camino();
simulator->simula();
simulator->simula();
resultado
resultado +=
+= producto->calculaNPV();
producto->calculaNPV();
}}
resultado
resultado /=
/= nPaths;
nPaths;
{
{

Pgina 15

C++ y las finanzas cuantitativas / Noviembre 2013

Puntos a considerar
a) Generacin de
nmeros
aleatorios

b) Uso eficiente
de la memoria

c) Diseo

Pgina 16

C++ y las finanzas cuantitativas / Noviembre 2013

a)

Generacin de nmeros aleatorios:

Por qu?

Punto comn para todos los modelos que se resuelven por Montecarlo
Puede llegar a ser una parte importante del tiempo de simulacin:

Un
Unmodelo
modelode
desimulacin
simulacinde
detipo
tipoaacorto
cortoconsume
consume
aproximadamente
aproximadamentelalamitad
mitadde
desu
sutiempo
tiempode
desimulacin
simulacin
generando
generandonmeros
nmerosaleatorios
aleatorios

Pgina 17

C++ y las finanzas cuantitativas / Noviembre 2013

a)

Generacin de nmeros aleatorios:

Puntos a considerar

Velocidad vs Secuencia aleatoria:

Buscamos generadores rpidos que tengan una secuencia aleatoria suficientemente
larga
Tcnicas de reduccin de varianza:
Considerar usar la tcnicas de reduccin de varianza que nos permite reducir la
cantidad de nmeros aleatorios para converger a la solucin
Generacin distribuida de nmeros aleatorios:
Si se decide paralelizar la simulacin, los generadores de cada proceso no pueden
pisar la secuencia aleatoria, no siempre es suficiente con cambiar la semilla en cada
nodo

Pgina 18

C++ y las finanzas cuantitativas / Noviembre 2013

a)

Generacin de nmeros aleatorios:

Herramientas
std::rand

Genera nmeros aleatorios enteros entre 0 y RAND_MAX

No existen garantas sobre la calidad de la su secuencia aleatoria, en
particular los bits menos significativos:
// rand between 0 and 99
// rand between 0 and 99
int v1 = rand() % 100;
int v1 = rand() % 100;
int
int v2
v2 == int((double
int((double (rand())
(rand()) /RAND_MAX)
/RAND_MAX) ** 100)
100)
{{

Utiliza variables estticas lo que lo hace desaconsejable en aplicaciones

multihilo
No es recomendable usar std::rand en problemas donde la generacin de
nmeros aleatorios es crtica
Pgina 19

C++ y las finanzas cuantitativas / Noviembre 2013

a)

Generacin de nmeros aleatorios:

Herramientas

Nos provee de una gran variedad de generadores de nmeros aleatorios,

muy bien documentados

C++11 /

#include <random>>

Nueva librera de generacin de nmeros aleatorios

Pgina 20

C++ y las finanzas cuantitativas / Noviembre 2013

a)

Generacin de nmeros aleatorios:

Herramientas

#include
#include <iostream>
<iostream>
#include
<boost/random.hpp>
#include <boost/random.hpp>
#include
#include <boost/generator_iterator.hpp>
<boost/generator_iterator.hpp>
#include
<boost/math/distributions/normal.hpp>
#include <boost/math/distributions/normal.hpp>
int
int main()
main() {{
boost::mt19937
boost::mt19937 randomGenerator;
randomGenerator; //mersenne
//mersenne twister
twister generator.
generator.
boost::normal_distribution<>
normalDistribution(5.0,
boost::normal_distribution<> normalDistribution(5.0, 2.0);
2.0);
boost::variate_generator<boost::mt19937&,
boost::variate_generator<boost::mt19937&,
boost::normal_distribution<>
boost::normal_distribution<> >>
var_nor(randomGenerator, normalDistribution);
var_nor(randomGenerator, normalDistribution);

}}

for
for (( unsigned
unsigned long
long ii == 0;
0; ii << 10000;
10000; i++
i++ )) {{
double
double nn == var_nor();
var_nor();
std::cout
<<
n
<<
std::cout << n << std::endl;
std::endl;
}}

-5 -4 -3 -2 -1

9 10 11 12 13 14 15 16

Pgina 21

C++ y las finanzas cuantitativas / Noviembre 2013

b)

Uso eficiente de la memoria:

Por qu?

Menor
consumo de
memoria

Mayor
velocidad de
ejecucin

Main Memory

Bus

Menos tiempo perdido reservando memoria

Menos tiempo consumido accediendo a

memoria
Menos tiempo manipulando memoria

L3 Cache
L2 Cache

L1i Cache

L1d Cache

CPU Core

Pgina 22

C++ y las finanzas cuantitativas / Noviembre 2013

b)

Uso eficiente de la memoria:

Por qu?

Bajo un esquema de
Montecarlo sabemos a
priori casi toda la memoria
que vamos a usar

Intentar reservar la memoria que vamos a consumir

antes de realizar los clculos:
La reserva de memoria implica uso de cerrojos de
control
Heap vs Stack

Pgina 23

C++ y las finanzas cuantitativas / Noviembre 2013

b)

Uso eficiente de la memoria:

Herramientas
Programacin
Preventiva

Paso por valor vs paso por referencia

Deshabilitar constructores de copia?
Intentar no devolver elementos complejos a travs de funciones y
si es necesario, ayudar al compilador para que optimice:
Class ClaseA {
Class ClaseA {
public:
public:
ClaseA
ClaseA (int
(int value);
value);

const
const ClaseA
ClaseA operator+(const
operator+(const ClaseA&
ClaseA& a1,
a1, const
const ClaseA&
ClaseA& a2)
a2)
{{
return ClaseA(a1.getValue() + a2.getValue());
return ClaseA(a1.getValue() + a2.getValue());
}}
}
}
{{

No usar operadores de conversin

Minimizar el uso de variables locales o minimizar su mbito
Pgina 24

C++ y las finanzas cuantitativas / Noviembre 2013

b)

Uso eficiente de la memoria:

Herramientas

Smart
Pointers

C++03

C++11

std::auto_ptr
boost::scoped_ptr
boost::shared_ptr
boost::weak_ptr

std::unique_ptr
std::shared_ptr
std::weak_ptr

Pgina 25

C++ y las finanzas cuantitativas / Noviembre 2013

b)

Uso eficiente de la memoria:

Herramientas C++03
auto_ptr

scoped_ptr

{ //auto_ptr example
{ //auto_ptr example
std::auto_ptr<std::string> myAutoPtrA(new std::string("Hola Mundo"));
std::auto_ptr<std::string> myAutoPtrA(new std::string("Hola Mundo"));
std::auto_ptr<std::string> myAutoPtrB = myAutoPtrA;
std::auto_ptr<std::string> myAutoPtrB = myAutoPtrA;
bool isEmpty = myAutoPtrA.get() == NULL;
bool isEmpty = myAutoPtrA.get() == NULL;
std::cout << std::boolalpha << isEmpty << std::endl; //true
std::cout << std::boolalpha << isEmpty << std::endl; //true
}
}
{ //scoped_ptr example
{ //scoped_ptr example
boost::scoped_ptr<std::string> myScopedPtrA(new std::string("Hola Mundo"));
boost::scoped_ptr<std::string> myScopedPtrA(new std::string("Hola Mundo"));
boost::scoped_ptr<std::string> myScopedPtrB = myScopedPtrA;
boost::scoped_ptr<std::string> myScopedPtrB = myScopedPtrA;
}
}
Error 1 error C2248: 'boost::scoped_ptr<T>::scoped_ptr' :
Error 1 error C2248: 'boost::scoped_ptr<T>::scoped_ptr' :
cannot access private member declared in class 'boost::scoped_ptr<T>' ...
cannot access private member declared in class 'boost::scoped_ptr<T>' ...

shared_ptr

{// shared_ptr example

{// shared_ptr example
boost::shared_ptr<std::string> mySharedPtrA;
boost::shared_ptr<std::string> mySharedPtrA;
{
{
boost::shared_ptr<std::string> mySharedPtrB(new std::string("Hola Mundo"));
boost::shared_ptr<std::string> mySharedPtrB(new std::string("Hola Mundo"));
mySharedPtrA = mySharedPtrB;
mySharedPtrA = mySharedPtrB;
}
}
std::cout << *mySharedPtrA << std::endl; //Hola Mundo
std::cout << *mySharedPtrA << std::endl; //Hola Mundo
}
}
Pgina 26

C++ y las finanzas cuantitativas / Noviembre 2013

b)

Uso eficiente de la memoria:

Herramientas
shared_ptr

Intentar usar std::auto_ptr y boost::scoped_ptr

Intentar restringir el uso de smart pointers en los interfaces
Referencias circulares entre shared_ptr generan memory leaks
(uso de weak_ptr para romper la referencia circular)
Alteracin del ciclo de vida natural de las variables
Efecto garbage collection

Pgina 27

C++ y las finanzas cuantitativas / Noviembre 2013

b)

Uso eficiente de la memoria:

Herramientas
unique_ptr

{ //unique_ptr example
{ //unique_ptr example
std::unique_ptr<std::string> myUniquePtrA(new std::string("Hola Mundo"));
std::unique_ptr<std::string> myUniquePtrA(new std::string("Hola Mundo"));
std::unique_ptr<std::string> myUniquePtrB (std::move(myAutoPtrA));
std::unique_ptr<std::string> myUniquePtrB (std::move(myAutoPtrA));
}
}

No implementa constructor de copia, ni operador de asignacin

Se transfiere la propiedad del puntero a travs del constructor de
movimiento
void doSomethig(std::auto_ptr<std::string> myPtr){ }
void doSomethig(std::auto_ptr<std::string> myPtr){ }
void AutoPtrTest() {
void AutoPtrTest() {
std::auto_ptr<std::string> myAutoPtrA(new std::string("Hola Mundo"));
std::auto_ptr<std::string> myAutoPtrA(new std::string("Hola Mundo"));
doSomethig(myAutoPtrA);
doSomethig(myAutoPtrA);
std::cout << *myAutoPtrA << std::endl;
std::cout << *myAutoPtrA << std::endl;
}
}

Pgina 28

C++ y las finanzas cuantitativas / Noviembre 2013

b)

Uso eficiente de la memoria:

Herramientas

Patrones de
diseo

Flyweight
Implementacin boost de Joaqun M Lpez Muoz

Pgina 29

C++ y las finanzas cuantitativas / Noviembre 2013

c)

Diseo: La importancia de los detalles

No todas las
condiciones
cambian en cada
path

Existen ciertas condiciones del

programa que van a permanecer
constantes durante todos los caminos
aleatorios. No tiene sentido evaluar
en todos los paths una condicin con
la misma respuesta

Puntos crticos
de ejecucin

Bajo este esquema de

simulacin hay partes de cdigo por
las que podemos pasar millones de
veces, pequeos cambios de cdigo
en estos puntos pueden ser crticos
para el rendimiento

Patrones de
Diseo
Composite, Strategy,
State,

Profiling
1/x, sqrt(), exp(),

Pgina 30

Gracias por vuestra atencin