---

LmmLattice.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_lmmlattice_h    
#define martingale_lmmlattice_h

// template class LmmLattice must be fully defined in header
#include "TypedefsMacros.h"
#include "Lattice.h"              // base class
#include "Node.h"                 // base class
#include "Utils.h"
#include "Array.h"                // direct member
#include "Matrix.h"               // direct member
#include "LiborFactorLoading.h" 
#include "Node.h"                 // problem with typedefed forward declarations


class std::ostream;



MTGL_BEGIN_NAMESPACE(Martingale)


// forward declaration
class BondCall;


/**********************************************************************************
 *
 *            GENERAL LMM LATTICE
 *
 *********************************************************************************/
 
 
        
 

class LmmLattice : public Lattice<StandardBrownianNode> {
        
protected:
        
        // factor loading of the underlying driftless LMM
        LiborFactorLoading* factorLoading; 
        
        int n,                  // dimension (number of accrual intervals)
            r,                  // number of factors
            nSteps;             // number of time steps in each accrual interval
        
        Real delta;
        Real dt;
        Real a;
        RealArray1D sg;
        RealArray1D log_U0;
        RealArray1D mu;  
        RealMatrix R;     

        
public:


int getNumberOfFactors(){ return r; }

LiborFactorLoading* getFactorLoading(){ return factorLoading; } 
        
int getSteps(){ return nSteps; }
        
Real getTimeStep(){ return delta/nSteps; }

int getTenor(int s){ return (int)(s*dt/delta); }

Real transitionProbability(int i){ return 1.0/(1<<r); }

                
// CONSTRUCTOR
        
LmmLattice(int q, LiborFactorLoading* fl, int t, int steps=1, bool verbose=false);

virtual ~LmmLattice(){ }


// SAMPLE LATTICE AND TEST

static LmmLattice* sample(int r, int n, int p, int nSteps, bool verbose=false);


void rescaleVols();

void testFactorization() const;

std::ostream& printSelf(std::ostream& os) const;


static void test(int r, int n);


// LIBOR PATH FUNCTIONALS

// The parameters is only needed to recognize the case s=0.
// It then propagates through all functions using this one.
// Keep it anyway, it might be useful for more complicated option payoffs.
const RealArray1D& Hvect(int p, StandardBrownianNode* node, int s);

Real L(int j, StandardBrownianNode* node, int s);


Real H_pq(int p, int q, StandardBrownianNode* node, int s);


Real swapRate(int p, int q, StandardBrownianNode* node, int s);
                

Real forwardSwaptionPayoff(int p, int q, Real kappa, StandardBrownianNode* node, int s);


Real forwardCapletPayoff(int i, Real kappa, StandardBrownianNode* node, int s);


Real forwardBondCallPayoff(BondCall* bc, StandardBrownianNode* node, int s);

                        
private:
        
// build lattice with m time steps.
void buildLattice(int m, bool verbose);

// continuous time reached after time step s=0,1,...
Real tau(int s);

        static RealArray1D H_;     // workspace for accrual factors H_j
        static RealArray1D V_;     // workspace for volatility parts V_j of the log(U_j)
                                   // book, 8.1 

                
}; // end LmmLattice





MTGL_END_NAMESPACE(Martingale)

#endif
 

---