swaptionvolcube.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2006 Ferdinando Ametrano
 Copyright (C) 2015 Peter Caspers
 
 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_swaption_volatility_cube_h
#define quantlib_swaption_volatility_cube_h
 
#include <ql/termstructures/volatility/swaption/swaptionvoldiscrete.hpp>
#include <ql/termstructures/volatility/smilesection.hpp>
 
namespace QuantLib {
 
    class SwapIndex;
    class Quote;
 
 
    class SwaptionVolatilityCube : public SwaptionVolatilityDiscrete {
      public:
        SwaptionVolatilityCube(const Handle<SwaptionVolatilityStructure>& atmVolStructure,
                               const std::vector<Period>& optionTenors,
                               const std::vector<Period>& swapTenors,
                               const std::vector<Spread>& strikeSpreads,
                               std::vector<std::vector<Handle<Quote> > > volSpreads,
                               ext::shared_ptr<SwapIndex> swapIndexBase,
                               ext::shared_ptr<SwapIndex> shortSwapIndexBase,
                               bool vegaWeightedSmileFit);
 
        DayCounter dayCounter() const override { return atmVol_->dayCounter(); }
        Date maxDate() const override { return atmVol_->maxDate(); }
        Time maxTime() const override { return atmVol_->maxTime(); }
        const Date& referenceDate() const override { return atmVol_->referenceDate(); }
        Calendar calendar() const override { return atmVol_->calendar(); }
        Natural settlementDays() const override { return atmVol_->settlementDays(); }
 
        Rate minStrike() const override { return -QL_MAX_REAL; }
        Rate maxStrike() const override { return QL_MAX_REAL; }
 
        const Period& maxSwapTenor() const override { return atmVol_->maxSwapTenor(); }
 
        Rate atmStrike(const Date& optionDate,
                       const Period& swapTenor) const;
        Rate atmStrike(const Period& optionTenor,
                       const Period& swapTenor) const {
            Date optionDate = optionDateFromTenor(optionTenor);
            return atmStrike(optionDate, swapTenor);
        }
        Handle<SwaptionVolatilityStructure> atmVol() const { return atmVol_; }
        const std::vector<Spread>& strikeSpreads() const { return strikeSpreads_; }
        const std::vector<std::vector<Handle<Quote> > >& volSpreads() const { return volSpreads_; }
        ext::shared_ptr<SwapIndex> swapIndexBase() const { return swapIndexBase_; }
        ext::shared_ptr<SwapIndex> shortSwapIndexBase() const { return shortSwapIndexBase_; }
        bool vegaWeightedSmileFit() const { return vegaWeightedSmileFit_; }
 
        void performCalculations() const override {
            QL_REQUIRE(nStrikes_ >= requiredNumberOfStrikes(),
                       "too few strikes (" << nStrikes_
                                           << ") required are at least "
                                           << requiredNumberOfStrikes());
            SwaptionVolatilityDiscrete::performCalculations();
        }
        VolatilityType volatilityType() const override;
 
      protected:
        void registerWithVolatilitySpread();
        virtual Size requiredNumberOfStrikes() const { return 2; }
        Volatility volatilityImpl(Time optionTime, Time swapLength, Rate strike) const override;
        Volatility
        volatilityImpl(const Date& optionDate, const Period& swapTenor, Rate strike) const override;
        Real shiftImpl(Time optionTime, Time swapLength) const override;
        Handle<SwaptionVolatilityStructure> atmVol_;
        Size nStrikes_;
        std::vector<Spread> strikeSpreads_;
        mutable std::vector<Rate> localStrikes_;
        mutable std::vector<Volatility> localSmile_;
        std::vector<std::vector<Handle<Quote> > > volSpreads_;
        ext::shared_ptr<SwapIndex> swapIndexBase_, shortSwapIndexBase_;
        bool vegaWeightedSmileFit_;
    };
 
    // inline
 
    inline VolatilityType SwaptionVolatilityCube::volatilityType() const {
        return atmVol_->volatilityType();
    }
 
    inline Volatility SwaptionVolatilityCube::volatilityImpl(
                                                        Time optionTime,
                                                        Time swapLength,
                                                        Rate strike) const {
        return smileSectionImpl(optionTime, swapLength)->volatility(strike);
    }
 
    inline Volatility SwaptionVolatilityCube::volatilityImpl(
                                                    const Date& optionDate,
                                                    const Period& swapTenor,
                                                    Rate strike) const {
        return smileSectionImpl(optionDate, swapTenor)->volatility(strike);
    }
 
    inline Real SwaptionVolatilityCube::shiftImpl(Time optionTime,
                                                  Time swapLength) const {
        return atmVol_->shift(optionTime, swapLength);
    }
}
 
#endif