---

Trigger.h

Go to the documentation of this file.

/* WARANTY NOTICE AND COPYRIGHT
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

Copyright (C) Michael J. Meyer

matmjm@mindspring.com
spyqqqdia@yahoo.com

*/


#ifndef martingale_trigger_h    
#define martingale_trigger_h

#include "TypedefsMacros.h"
#include "Optimizer.h"        // base class BFGS


MTGL_BEGIN_NAMESPACE(Martingale)


// dependencies
class LiborMarketModel;
class BermudanSwaption;




/**********************************************************************************
 *
 *                                     TRIGGER
 *
 *********************************************************************************/ 
 
class Trigger {
        
public:
        
virtual bool isTriggered(int t, int s) = 0;
        
virtual int nextTriggered(int t) = 0;
        
virtual ~Trigger(){ }
        

}; // end Trigger



/*******************************************************************************
 *
 *                     PjTrigger
 *
 ******************************************************************************/


class PjTrigger : public Trigger {
        
    
    LiborMarketModel* LMM;
    BermudanSwaption* bswpn;
   
    double kappa;       // swaption strike
   
    int nPath,          // number of training paths
        p,              // swaption exercise begins T_p
        q;              // swap ends T_q 
   
    bool verbose;       // messages during optimization
   
    Array1D<RealArray2D*> path; 
        // the components 0,1,2,3 of path_i=*path[i] are as follows:   
    // path_i[t][0].... Libor X(t,t) 
    // path_i[t][1].... swaprate S_{t+1,n}(t) 
    // path_i[t][2].... forward swap payoff from immediate exercise (>=0)
    // path_i[t][3].... time s>=t of optimal exercise starting at time t
    // all computed from Libor sample path i for p<=t<q
   
    RealArray1D p1,p2,p3;  // the coefficients p_j(t) in Jaeckel's trigger
                               // at each exercise time t.
    RealArray1D S;         // S[t]=S_{t+1,n}(0), swaprate
        
public:
        
// ACCESSORS

int getPaths(){ return nPath; }
int get_q(){ return q; }
RealArray2D& getTrainingPath(int i){ return *(path[i]); }

        
// CONSTRUCTOR

PjTrigger
(LiborMarketModel* lmm, BermudanSwaption* swpn, bool vbose);

~PjTrigger();


           
// THE TRIGGER CONDITION

bool isTriggered(int t, int s);


int nextTriggered(int t);


bool exercise(int i, int t, const RealArray1D& x);

Real objectiveFunction(int t, const RealArray1D& v);
          
 
private:

void fillTrainingPaths();
           
void computeCoefficients();
 

// PARAMETER OPTIMIZATION AT EACH EXERCISE TIME t  

class LocalBFGS : public BFGS {
           
        int t;                // time t at which the parameters are optimized
        PjTrigger* trg;       // the trigger which contains the optimizer
        
public:
       
       
    LocalBFGS
    (PjTrigger* pj_trg, int s, const RealArray1D x, int nVals, 
     Real stepmax, const RealArray1D h, bool verbose);
       
    // the function we want to optimize
        // forward payoff fom exercise for s>=t under parameters v
    Real f(const RealArray1D& v);

}; // end LocalBFGS


class LocalSobolSearch : public SobolSearch {
           
        int t;                // time t at which the parameters are optimized
        PjTrigger* trg;       // the trigger which contains the optimizer
        
public:
       
       
    LocalSobolSearch
    (PjTrigger* pj_trg, int s, const RealArray1D x, int nVals, 
     const RealArray1D delta, bool verbose);
       
    // the function we want to optimize
        // forward payoff fom exercise for s>=t under parameters v
    Real f(const RealArray1D& v);

}; // end LocalSobolSearch
 
 
};  // end PjTrigger

        

        
MTGL_END_NAMESPACE(Martingale)

#endif
 

---