defaulttermstructure.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2008 Chris Kenyon
 Copyright (C) 2008 Roland Lichters
 Copyright (C) 2008 StatPro Italia srl
 Copyright (C) 2009 Ferdinando Ametrano
 
 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_default_term_structure_hpp
#define quantlib_default_term_structure_hpp
 
#include <ql/termstructure.hpp>
#include <ql/quote.hpp>
 
namespace QuantLib {
 
 
    class DefaultProbabilityTermStructure : public TermStructure {
      public:
        DefaultProbabilityTermStructure(
            const DayCounter& dc = DayCounter(),
            std::vector<Handle<Quote> > jumps = {},
            const std::vector<Date>& jumpDates = {});
        DefaultProbabilityTermStructure(
            const Date& referenceDate,
            const Calendar& cal = Calendar(),
            const DayCounter& dc = DayCounter(),
            std::vector<Handle<Quote> > jumps = {},
            const std::vector<Date>& jumpDates = {});
        DefaultProbabilityTermStructure(
            Natural settlementDays,
            const Calendar& cal,
            const DayCounter& dc = DayCounter(),
            std::vector<Handle<Quote> > jumps = {},
            const std::vector<Date>& jumpDates = {});
 
        Probability survivalProbability(const Date& d,
                                        bool extrapolate = false) const;
        Probability survivalProbability(Time t,
                                        bool extrapolate = false) const;
 
        Probability defaultProbability(const Date& d,
                                       bool extrapolate = false) const;
        Probability defaultProbability(Time t,
                                       bool extrapolate = false) const;
        Probability defaultProbability(const Date&,
                                       const Date&,
                                       bool extrapolate = false) const;
        Probability defaultProbability(Time,
                                       Time,
                                       bool extrapo = false) const;
 
        Real defaultDensity(const Date& d,
                            bool extrapolate = false) const;
        Real defaultDensity(Time t,
                            bool extrapolate = false) const;
 
        Rate hazardRate(const Date& d,
                        bool extrapolate = false) const;
        Rate hazardRate(Time t,
                        bool extrapolate = false) const;
 
 
        const std::vector<Date>& jumpDates() const;
        const std::vector<Time>& jumpTimes() const;
 
 
        void update() override;
      protected:
        virtual Probability survivalProbabilityImpl(Time) const = 0;
        virtual Real defaultDensityImpl(Time) const = 0;
        virtual Real hazardRateImpl(Time) const;
      private:
        // methods
        void setJumps();
        // data members
        std::vector<Handle<Quote> > jumps_;
        std::vector<Date> jumpDates_;
        std::vector<Time> jumpTimes_;
        Size nJumps_;
        Date latestReference_;
    };
 
    // inline definitions
 
    inline
    Probability DefaultProbabilityTermStructure::survivalProbability(
                                                     const Date& d,
                                                     bool extrapolate) const {
        return survivalProbability(timeFromReference(d), extrapolate);
    }
 
    inline
    Probability DefaultProbabilityTermStructure::defaultProbability(
                                                     const Date& d,
                                                     bool extrapolate) const {
        return 1.0 - survivalProbability(d, extrapolate);
    }
 
    inline
    Probability DefaultProbabilityTermStructure::defaultProbability(
                                                     Time t,
                                                     bool extrapolate) const {
        return 1.0 - survivalProbability(t, extrapolate);
    }
 
    inline
    Real DefaultProbabilityTermStructure::defaultDensity(
                                                     const Date& d,
                                                     bool extrapolate) const {
        return defaultDensity(timeFromReference(d), extrapolate);
    }
 
    inline
    Real DefaultProbabilityTermStructure::defaultDensity(
                                                     Time t,
                                                     bool extrapolate) const {
        checkRange(t, extrapolate);
        return defaultDensityImpl(t);
    }
 
    inline
    Rate DefaultProbabilityTermStructure::hazardRate(const Date& d,
                                                     bool extrapolate) const {
        return hazardRate(timeFromReference(d), extrapolate);
    }
 
   inline
    Rate DefaultProbabilityTermStructure::hazardRateImpl(Time t) const {
        Probability S = survivalProbability(t, true);
        return S == 0.0 ? Rate(0.0) : defaultDensity(t, true)/S;
    }
 
    inline Rate DefaultProbabilityTermStructure::hazardRate(Time t,
                                                            bool extrapolate) const {
        checkRange(t, extrapolate);
        return hazardRateImpl(t);
    }
 
    inline
    const std::vector<Date>&
    DefaultProbabilityTermStructure::jumpDates() const {
        return this->jumpDates_;
    }
 
    inline
    const std::vector<Time>&
    DefaultProbabilityTermStructure::jumpTimes() const {
        return this->jumpTimes_;
    }
 
    inline void DefaultProbabilityTermStructure::update() {
        TermStructure::update();
        if (referenceDate() != latestReference_)
            setJumps();
    }
 
}
 
#endif