Matlab - Comando blsprice para valuar opciones financieras

Una consulta:
Estoy haciendo un programa para valorar opciones financieras y para ello uso el método de diferencias finitas, esquema explícito.
Programa:
function price = EuPutExpl(SO,K,r,T,sigma,Smax,dS,dt)
%% set up grid and adjust increments if necessary
M=round(Smax/dS);
dS=Smax/M;
N=round(T/dt);
dt=T/N;
matval=zeros(M+1,N+1);
vetS=linspace(0,Smax,M+1)';
veti=0:M;
vetj=0:N;
%%, set up boundary conditions
matval(:,N+1)= max(K-vetS,0);
matval(1,:)= K*exp(-r*dt*(N-vetj));
matval(M+1,:)= 0;
%%, set up coefficients
a = 0.5*dt*(sigma^2*veti-r).*veti;
b = 1-dt*(sigma^2*veti.^2+r);
c = 0.5*dt*(sigma^2*veti+r).*veti;
%%, solve backward in time
for j=N:-1:1
for i=2:M
matval(i,j)=a(i)*matval(i-1,j+1)+b(i)*matval(i,j+1)+c(i)*matval(i+1,j+1);
end
end
price = interp1(vetS, matval(:,1),SO,'spline');

*Cuando ejecuto el fichero con las entradas:
price = EuPutExpl(50,50,0.1,0.4166666666,0.4,100,2,0.0041666666667)
price = 4.0669

COMANDO MATLAB:
En el libro para validar nuestro resultado obtenido por el programa, se compara usando el siguiente comando
[c,p]=blsprice(50,50,0.1,5/12,0.4)
c = 6.1165
p = 4.0760
Los resultados obtenidos, por el comando "blsprice", son 2: c (opción call) y p(opción put). Mi programa "EuPutExpl", sólo me da el resultado de la opción put y notamos que este resultado es cercano al obtenido por el comando propio del matlab, como debería ser. El programa cumple las condiciones de estabilidad, convergencia y consistencia. Sin embargo, el problema es el siguiente:
Cuando cambio el primer parámetro de entrada sucede que para algunos valores, el resultado de mi programa se aproxima al valor obtenido por el comando "blsprice" (el cual por ser el comando propio del matlab, lo considero como inequívoco) y para otros valores no se aproxima.
Por ejemplo si ejecuto las siguietnes 2 líneas, los resultados si coinciden.:
price = EuPutExpl(10,50,0.1,0.4166666666,0.4,100,2,0.0041666666667)
[c,p]=blsprice(10,50,0.1,5/12,0.4)
Pero si ejecuto las siguietnes 2 líneas, los resultados no coinciden.:
price = EuPutExpl(60.5,50,0.1,0.4166666666,0.4,100,2,0.0041666666667)
[c,p]=blsprice(60.5,50,0.1,5/12,0.4).
Ya he me comunicado con el autor del libro, lo dejaré al final los datos para que lo pueda bajar desde la web www.libgen.org/, pero no he logrado alguna respuesta. Espero que alguien me pueda ayudar a qué se debe que los resultados si coincidan para ciertos valores, mientras para otros no.
*Datos del libro:
[3] Paolo Brandimarte (2006), ((Numerical Methods in Finance and Economics A MATLAB-Based Introduction)), segunda edicion. John Wiley & Sons: Torino Italia., capítulo 9.
PDT: He dejado una imagen, de la página del libro, donde se ve el programa y los resultados
Agradezco su tiempo y espero respuestas.
Saludos.

• consulta.zip(47,2 KB)

Tu me estas diciendo el método de diferencias finitas, pueda ser que el error esta en la teoría y no en el programa, en el método de diferencias finitas hay condiciones que tiene que cumplir para que la solución no diverja. Revisa la teoría un poco mas de los estas haciendo.

Saludos.
JOSE JEREMÍAS CABALLERO
Asesorías en Matlab
programador en matlab
Servicios de programación matlab
[email protected]

http://matlabcaballero.blogspot.com

http://www.lawebdelprogramador.com/foros/Matlab/1371532-FORMA_DE_APRENDER_MATLAB.html

Trata de hacer un algoritmo de tu teoría y luego tu propio programa. Eso seria la opción mas recomendable, solo haciendo tu propia programa podrás ver si es que hay error en el programa del libro.
La ultimo función lo encontré en una pagina, no soy economista sino te daría mas pista, pero si programo en matlab.

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

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

function[ price, p, Put] = opciones_fiancieras_por_diferencias_finitas(SO,K,r,T,sigma,Smax,dS,dt)

if nargin<1

    SO=50;

    K=50;

    r=0.1;

    T=5/12;

    sigma=0.4;

    Smax=100;

    dS=2;

    dt=5/1200;

end

 %% set up grid and adjust increments if necessary

 M=round(Smax/dS);

 dS=Smax/M;

 N=round(T/dt);

 dt=T/N;

 matval=zeros(M+1,N+1);

 vetS=linspace(0,Smax,M+1)';

 veti=0:M;

 vetj=0:N;

 %%, set up boundary conditions

 matval(:,N+1)= max(K-vetS,0);

 matval(1,:)= K*exp(-r*dt*(N-vetj));

 matval(M+1,:)= 0;

 %%, set up coefficients

 a = 0.5*dt*(sigma^2*veti-r).*veti;

 b = 1-dt*(sigma^2*veti.^2+r);

 c = 0.5*dt*(sigma^2*veti+r).*veti;

 %%, solve backward in time

 for j=N:-1:1

 for i=2:M

 matval(i,j)=a(i)*matval(i-1,j+1)+b(i)*matval(i,j+1)+c(i)*matval(i+1,j+1);

 end

 end

 price = interp1(vetS, matval(:,1),SO,'spline');

 [c,p]=blsprice(SO,K,r,T,sigma);

 [Call, Put] = blsprice1(SO,K,r,sigma,T);

 function [Call Put] = blsprice1(S,K,r,sigma,tau)

if tau==0 

    t=1;

else

    t=0;

end

y = (log(S/K)+(r-sigma^2/2)*tau)/(sigma*sqrt(tau)+t);

cdfn = normcdf(y+sigma*sqrt(tau));

if t==0 

    t_l = 1;

else

    t_l = 0;

end 

    Call = S*(cdfn*t_l+t)-K*exp(-r*tau)*normcdf(y)*t_l+t;

    Put = K*exp(-r*tau)*(normcdf(-y))*t_l+t-S*(normcdf(-y-sigma*sqrt(tau))*t_l+t);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

>> [ price p, Put]=opciones_fiancieras_por_diferencias_finitas(60.5,50,0.1,0.4166666666,0.4,100,2,0.0041666666667)

price =

   -3.797012792857867e+003

p =

   1.390603168163823

Put =

   1.390603168163821

Gracias por tu respuesta José.
1) Como lo indiqué, he verificado la estabilidad, convergencia y consistencia del método númerico, para el caso explícito.
2) Respecto a lo que has compartido, he notado que el fichero "opciones_fiancieras_por_diferencias_finitas" lleva casi todo el código del libro que he indicado, es razonable pue usa el método de diferencias finitas. Sin embargo, de lo que has compartido, las siguientes líneas de código son nuevas respecto a lo que he trabajado y lo que está en el libro. Respecto a esto, luego de haber analizado, concluyo lo siguiente:
function [Call Put] = blsprice1(S,K,r,sigma,tau)
if tau==0
t=1;
else
t=0;
end
y = (log(S/K)+(r-sigma^2/2)*tau)/(sigma*sqrt(tau)+t);
cdfn = normcdf(y+sigma*sqrt(tau));
if t==0
t_l = 1;
else
t_l = 0;
end
Call = S*(cdfn*t_l+t)-K*exp(-r*tau)*normcdf(y)*t_l+t;
Put = K*exp(-r*tau)*(normcdf(-y))*t_l+t-S*(normcdf(-y-sigma*sqrt(tau))*t_l+t);

Esta porción de código, no es una aplicación del método numérico. Es la utilización directa de la solución de Black-Scholes. En otras palabras, la EDP de Black-Scholes, al resolverla toma un expresión la cual se conoce como la fórmula de Black-Scholes. A la misma si le ingreso valores, me da un resultado que es el valor de la opción, ya se Put o call, dependiendo del problema. De esa forma, tenemos:
>> [ price p, Put]=opciones_fiancieras_por_diferencias_finitas(60.5,50,0.1,0.4166666666,0.4,100,2,0.0041666666667)
price = -3.797012792857867e+003
p = 1.390603168163823
Put = 1.390603168163821.
Al ejecutar tal fichero:
price=> es valor de la opción put, al usar el método de diferencias finitas.
p=> es el valor que se obtiene luego de aplicar la sentencia propia del matlab, "blsprice", que lo considero inequívoco.
put=> es el valor que se obtiene del fichero "blsprice1" y el cual usa la fórmula de Black-Scholes; es decir, sólo reemplaza esos valores en la solución de la ecuación de Black-Scholes y obtiene el resultado. ¡No hay un método numérico!
Resumen:
Dicho fichero es una comparación del valor de la opción, luego de aplicar el método de diferencias finitas, la fórmula de Black-Scholes y el comando blsprice. Mi problema sigue en pie, por qué para ciertos valores de "SO" (el primer parámetro de entrada) el resutlado que me da el método de diferencias finitas si se axproxima al valor que me da la sentencia "blsprice".
Agradecería si me pudieras compartir dicha web, de esa forma podría comunicarme con la persona que ha publicado o que trabaja en eso. Como indiqué en le entrada, me comuniqué con el autor pero aún no me responde y espero que lo haga, pues ya hace meses me comuniqué y tardó como 1 semana y media en responderme.
De todas formas agradezco su tiempo e interés.
Saludos.

Como te dije anteriormente, deberías empezar haciendo un algoritmo, luego un pseudocódigo, luego un programa en matlab, pero con tu propia lógica.
Derrepente el código del libro no esta considerando para ciertos valores, y al momento de hacer el código no lo ha tenido en cuenta.