inflationindex.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2007 Chris Kenyon
 Copyright (C) 2021 Ralf Konrad Eckel
 
 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_inflation_index_hpp
#define quantlib_inflation_index_hpp
 
#include <ql/currency.hpp>
#include <ql/handle.hpp>
#include <ql/index.hpp>
#include <ql/indexes/region.hpp>
#include <ql/termstructures/inflationtermstructure.hpp>
 
namespace QuantLib {
 
    class ZeroInflationIndex;
 
    struct CPI {
        enum InterpolationType {
            AsIndex, 
            Flat,    
            Linear   
        };
 
 
        static Real laggedFixing(const ext::shared_ptr<ZeroInflationIndex>& index,
                                 const Date& date,
                                 const Period& observationLag,
                                 InterpolationType interpolationType);
    };
 
 
    class InflationIndex : public Index, public Observer {
      public:
        InflationIndex(std::string familyName,
                       Region region,
                       bool revised,
                       Frequency frequency,
                       const Period& availabilitiyLag,
                       Currency currency);
 
        QL_DEPRECATED
        InflationIndex(std::string familyName,
                       Region region,
                       bool revised,
                       bool interpolated,
                       Frequency frequency,
                       const Period& availabilitiyLag,
                       Currency currency);
 
 
        std::string name() const override;
 
        Calendar fixingCalendar() const override;
        bool isValidFixingDate(const Date&) const override { return true; }
 
        Real fixing(const Date& fixingDate, bool forecastTodaysFixing = false) const override = 0;
 
        void addFixing(const Date& fixingDate, Rate fixing, bool forceOverwrite = false) override;
 
 
        void update() override;
 
 
        std::string familyName() const;
        Region region() const;
        bool revised() const;
        QL_DEPRECATED
        bool interpolated() const;
 
        Frequency frequency() const;
        Period availabilityLag() const;
        Currency currency() const;
 
      protected:
        Date referenceDate_;
        std::string familyName_;
        Region region_;
        bool revised_;
        Frequency frequency_;
        Period availabilityLag_;
        Currency currency_;
 
        QL_DEPRECATED
        bool interpolated_ = false;
 
      private:
        std::string name_;
    };
 
 
    class ZeroInflationIndex : public InflationIndex {
      public:
        ZeroInflationIndex(
            const std::string& familyName,
            const Region& region,
            bool revised,
            Frequency frequency,
            const Period& availabilityLag,
            const Currency& currency,
            Handle<ZeroInflationTermStructure> ts = {});
 
        QL_DEPRECATED
        ZeroInflationIndex(
            const std::string& familyName,
            const Region& region,
            bool revised,
            bool interpolated,
            Frequency frequency,
            const Period& availabilityLag,
            const Currency& currency,
            Handle<ZeroInflationTermStructure> ts = {});
 
 
 
        Real fixing(const Date& fixingDate, bool forecastTodaysFixing = false) const override;
 
        Handle<ZeroInflationTermStructure> zeroInflationTermStructure() const;
        ext::shared_ptr<ZeroInflationIndex> clone(const Handle<ZeroInflationTermStructure>& h) const;
      private:
        bool needsForecast(const Date& fixingDate) const;
        Real forecastFixing(const Date& fixingDate) const;
        Handle<ZeroInflationTermStructure> zeroInflation_;
    };
 
 
 
    class YoYInflationIndex : public InflationIndex {
      public:
 
 
        YoYInflationIndex(
            const ext::shared_ptr<ZeroInflationIndex>& underlyingIndex,
            bool interpolated,
            Handle<YoYInflationTermStructure> ts = {});
 
 
        YoYInflationIndex(
            const std::string& familyName,
            const Region& region,
            bool revised,
            bool interpolated,
            Frequency frequency,
            const Period& availabilityLag,
            const Currency& currency,
            Handle<YoYInflationTermStructure> ts = {});
 
 
        QL_DEPRECATED
        YoYInflationIndex(
            const std::string& familyName,
            const Region& region,
            bool revised,
            bool interpolated,
            bool ratio, // is this one a genuine index or a ratio?
            Frequency frequency,
            const Period& availabilityLag,
            const Currency& currency,
            Handle<YoYInflationTermStructure> ts = {});
 
 
 
        Rate fixing(const Date& fixingDate, bool forecastTodaysFixing = false) const override;
 
 
        // Override the deprecation above
        bool interpolated() const;
        bool ratio() const;
        ext::shared_ptr<ZeroInflationIndex> underlyingIndex() const;
        Handle<YoYInflationTermStructure> yoyInflationTermStructure() const;
 
        ext::shared_ptr<YoYInflationIndex> clone(const Handle<YoYInflationTermStructure>& h) const;
 
      protected:
        // Override the deprecation above
        bool interpolated_;
 
      private:
        Rate forecastFixing(const Date& fixingDate) const;
        bool ratio_;
        ext::shared_ptr<ZeroInflationIndex> underlyingIndex_;
        Handle<YoYInflationTermStructure> yoyInflation_;
    };
 
 
    namespace detail {
        namespace CPI {
            // Returns either CPI::Flat or CPI::Linear depending on the combination of index and
            // CPI::InterpolationType.
            QuantLib::CPI::InterpolationType effectiveInterpolationType(
                const ext::shared_ptr<ZeroInflationIndex>& index,
                const QuantLib::CPI::InterpolationType& type = QuantLib::CPI::AsIndex);
 
 
            // checks whether the combination of index and CPI::InterpolationType results
            // effectively in CPI::Linear
            bool
            isInterpolated(const ext::shared_ptr<ZeroInflationIndex>& index,
                           const QuantLib::CPI::InterpolationType& type = QuantLib::CPI::AsIndex);
        }
    }
 
 
    // inline
 
    inline std::string InflationIndex::name() const {
        return name_;
    }
 
    inline void InflationIndex::update() {
        notifyObservers();
    }
 
    inline std::string InflationIndex::familyName() const {
        return familyName_;
    }
 
    inline Region InflationIndex::region() const {
        return region_;
    }
 
    inline bool InflationIndex::revised() const {
        return revised_;
    }
 
    inline Frequency InflationIndex::frequency() const {
        return frequency_;
    }
 
    inline Period InflationIndex::availabilityLag() const {
        return availabilityLag_;
    }
 
    inline Currency InflationIndex::currency() const {
        return currency_;
    }
 
    inline Handle<ZeroInflationTermStructure>
    ZeroInflationIndex::zeroInflationTermStructure() const {
        return zeroInflation_;
    }
 
    inline bool YoYInflationIndex::interpolated() const {
        return interpolated_;
    }
 
    inline bool YoYInflationIndex::ratio() const {
        return ratio_;
    }
 
    inline ext::shared_ptr<ZeroInflationIndex> YoYInflationIndex::underlyingIndex() const {
        return underlyingIndex_;
    }
 
    inline Handle<YoYInflationTermStructure>
    YoYInflationIndex::yoyInflationTermStructure() const {
        return yoyInflation_;
    }
 
    inline bool detail::CPI::isInterpolated(const ext::shared_ptr<ZeroInflationIndex>& index,
                                            const QuantLib::CPI::InterpolationType& type) {
        return detail::CPI::effectiveInterpolationType(index, type) == QuantLib::CPI::Linear;
    }
}
 
#endif