twofactormodel.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2001, 2002, 2003 Sadruddin Rejeb
 Copyright (C) 2005 StatPro Italia srl
 
 This file is part of QuantLib, a free-software/open-source library
 for financial quantitative analysts and developers - http://quantlib.org/
 
 QuantLib is free software: you can redistribute it and/or modify it
 under the terms of the QuantLib license.  You should have received a
 copy of the license along with this program; if not, please email
 <quantlib-dev@lists.sf.net>. The license is also available online at
 <http://quantlib.org/license.shtml>.
 
 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 license for more details.
*/
 
#ifndef quantlib_two_factor_model_hpp
#define quantlib_two_factor_model_hpp
 
#include <ql/methods/lattices/lattice2d.hpp>
#include <ql/models/model.hpp>
#include <utility>
 
namespace QuantLib {
    class StochasticProcess1D;
    class StochasticProcess;
 
    class TwoFactorModel : public ShortRateModel {
      public:
        explicit TwoFactorModel(Size nParams);
 
        class ShortRateDynamics;
        class ShortRateTree;
 
        virtual ext::shared_ptr<ShortRateDynamics> dynamics() const = 0;
 
        ext::shared_ptr<Lattice> tree(const TimeGrid& grid) const override;
    };
 
 
    class TwoFactorModel::ShortRateDynamics {
      public:
        ShortRateDynamics(ext::shared_ptr<StochasticProcess1D> xProcess,
                          ext::shared_ptr<StochasticProcess1D> yProcess,
                          Real correlation)
        : xProcess_(std::move(xProcess)), yProcess_(std::move(yProcess)),
          correlation_(correlation) {}
        virtual ~ShortRateDynamics() = default;
 
        virtual Rate shortRate(Time t, Real x, Real y) const = 0;
 
        const ext::shared_ptr<StochasticProcess1D>& xProcess() const {
            return xProcess_;
        }
 
        const ext::shared_ptr<StochasticProcess1D>& yProcess() const {
            return yProcess_;
        }
 
        Real correlation() const {
            return correlation_;
        }
 
        ext::shared_ptr<StochasticProcess> process() const;
 
      private:
        ext::shared_ptr<StochasticProcess1D> xProcess_, yProcess_;
        Real correlation_;
    };
 
    class TwoFactorModel::ShortRateTree
        : public TreeLattice2D<TwoFactorModel::ShortRateTree,TrinomialTree> {
      public:
        ShortRateTree(const ext::shared_ptr<TrinomialTree>& tree1,
                      const ext::shared_ptr<TrinomialTree>& tree2,
                      const ext::shared_ptr<ShortRateDynamics>& dynamics);
 
        DiscountFactor discount(Size i, Size index) const {
            Size modulo = tree1_->size(i);
            Size index1 = index % modulo;
            Size index2 = index / modulo;
 
            Real x = tree1_->underlying(i, index1);
            Real y = tree2_->underlying(i, index2);
 
            Rate r = dynamics_->shortRate(timeGrid()[i], x, y);
            return std::exp(-r*timeGrid().dt(i));
        }
      private:
        ext::shared_ptr<ShortRateDynamics> dynamics_;
    };
 
}
 
 
#endif