Método Longstaff Schwartz

Question

Intento aplicar el método LSM con este algoritmo pero mi precio es siempre demasiado bajo. Por ejemplo para una opción de venta americana con los siguientes parámetros:

S0 = 36, Strike = 40, tipo = 6%, T = 1 año, trayectoria discreta = 50, volatilidad = 20%.

Yo obtuve 4 dólares, pero el artículo de Longstaff y Schwartz indica 4,7 dólares. Con una volatilidad del 40%, el error es mayor: 5 dólares para mí frente a 7,3 dólares para L&S. Pero con mi árbol de precios tengo el mismo resultado que el artículo de L&S.

¿Podría ayudarme a encontrar el error, por favor?

void LeastSquaresMC::calcLeastSquaresMC()
{

     mu_ = (rate_ - vol_*vol_*0.5)*dt; // drift
     voldt = vol_*sqrt(dt); // diffusion
          for (i = 0; i < M_; i++)
          {
               Paths(i,0) = 36;

               for (j = 1; j < b; j++)
                    {
                         // generate deviate
                         deviate = G();
                         Paths(i,j) =  Paths(i,j-1)*exp(mu_+voldt*deviate);                         
                    }
          }
     // initialize cash flow matrix by zero
     for (i = 0; i < z; i++)
          {
               for (j = 0; j < b; j++)
                    {
                         CashFlow(i,j,0);
                    }
          }

     for (i = 0; i < z; i++)
          {
               for (j = 0; j < b; j++)
                    {
                         Exercise(i,j) = MAX(strike_-Paths(i,j),0);
                    }
          }
     // compute cash flows at maturity
     for (i = 0; i < z; i++)
          {
               CashFlow(i,b-1,(Exercise(i,b-1)));

          }
     //cout <<CashFlow << endl;
     // recursion
     computeLSM(b-1, Paths, CashFlow, Exercise);

}

double LeastSquaresMC::computeLSM(int time, Matrix& Paths, Matrix& CashFlow, Matrix& Exercise)
{

     double disc = exp(-rate_*dt);     // discount factor
     vector<double> Y;               // vector of payoffs (dependent variables)
     vector<double> B;               // vector of regression coefficients
     vector<double> C;               // continuation
     vector<int> num;
     vector<double> stock;          
     vector<int>::iterator i = num.begin();

     /*long z = M_*2;*/

     for (j = 0; j < z; j++)
          {
               if(Exercise(j,time-1)>0)
                    {

                                   Y.push_back(MAX(CashFlow(j,time),0)*disc);
                                   num.push_back(j);
                                   stock.push_back(Paths(j,time-1));                    
                    }
          }

     if (time > 1)
          {
               if(num.empty()==false)
                    {
                         int size_l = Y.size();
                         Matrix X(size_l,3);    // 1 X X^2 (columns)

                         for (j = 0; j < size_l; j++)
                              {
                                   X(j,0,1);
                                   X(j,1,stock[j]);
                                   X(j,2,stock[j]*stock[j]);
                              }
                         B = ((X.transpose()*X).Inverse())*(X.transpose()*Y);
                         C = X*B;
                         j=0;
                         for(i = num.begin() ; i != num.end(); ++i)
                              {
                              if (Exercise(*i,time-1)>C[j])

                                   {

                                        CashFlow(*i,time-1,Exercise(*i,time-1));
                                        for (l = time; l < b; l++)
                                             {
                                                  CashFlow(*i,l,0);
                                             }
                              j++;
                              }
                         computeLSM(time-1, Paths, CashFlow, Exercise);
                    }
               else
                    {
                         computeLSM(time-1, Paths, CashFlow, Exercise);
                    }
               }
          else
               {
                    return computeValue(CashFlow);
               }

     return 0.0;     
}

double LeastSquaresMC::computeValue (Matrix& CashFlow)
{

     double discValue = 0.0; // discounted value
          for (i = 0; i < z; i++)
               {
                    for (j = 1; j < b; j++)
                         {
                              if (CashFlow(i, j) > 0)
                              {
                                   discValue = discValue + CashFlow(i, j)*exp(-0.06*j);
                              }
                         }
               }
          cout <<"prix:"<<discValue/z << endl;
 return discValue/z;
}

Answer 1

Como han señalado otros, el código es muy difícil de leer. Lo que he detectado: ¿se hace bien el descuento? Veo que descuenta el valor de continuación sólo para calcular Y, pero ¿el descuento entra en la recursión?

(Tengo una implementación del LS en Java aquí: http://www.finmath.net/java )

Answer 2

Creo que simplemente estás descontando mal los flujos de caja (j es un índice):

Casi al final de su listado, en lugar de escribir

discValue = discValue + CashFlow(i, j)*exp(-0.06*j);

debes escribir

discValue = discValue + CashFlow(i, j)*exp(-0.06*j*dt);

Answer 3

Ese error me suena, de cuando yo mismo implementé esto en python. No puedo entender lo que tu código está haciendo (es demasiado extenso, con demasiados espacios en blanco, demasiada fragmentación en funciones, tiene sangrías extrañas, etc.) Pero mi conjetura es que, o bien no estás utilizando los resultados de la regresión como quant_dev mencionó, o estás truncando accidentalmente un flotador a un int en alguna parte - mi recuerdo es que una de esas dos cosas es lo que me mordió; utilizando los mismos datos de prueba, también obtuve 4.0 la primera vez que lo ejecuté.