diff -rupN QuantLib-1.6/ql/termstructures/inflation/seasonality.cpp QuantLib-1.6_patch/ql/termstructures/inflation/seasonality.cpp
--- QuantLib-1.6/ql/termstructures/inflation/seasonality.cpp	2015-05-04 16:37:08.000000000 +0200
+++ QuantLib-1.6_patch/ql/termstructures/inflation/seasonality.cpp	2015-07-08 21:18:51.527451535 +0200
@@ -1,219 +1,280 @@
-/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-
-/*
- Copyright (C) 2008 Piero Del Boca
- Copyright (C) 2009 Chris Kenyon
-
-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.
-*/
-
-
-#include <ql/termstructures/inflation/seasonality.hpp>
-#include <ql/termstructures/inflationtermstructure.hpp>
-#include <ql/errors.hpp>
-
-namespace QuantLib {
-
-    bool Seasonality::isConsistent(const InflationTermStructure&) const {
-        return true;
-    }
-
-
-    //Multiplicative Seasonality on price = on CPI/RPI/HICP/etc
-    //
-    MultiplicativePriceSeasonality::MultiplicativePriceSeasonality() {
-    }
-
-
-    void MultiplicativePriceSeasonality::validate() const
-    {
-        switch (this->frequency()) {
-            case Semiannual:        //2
-            case EveryFourthMonth:  //3
-            case Quarterly:         //4
-            case Bimonthly:         //6
-            case Monthly:           //12
-            case Biweekly:          // etc.
-            case Weekly:
-            case Daily:
-                QL_REQUIRE( (this->seasonalityFactors().size() %
-                             this->frequency()) == 0,
-                           "For frequency " << this->frequency()
-                           << " require multiple of " << ((int)this->frequency()) << " factors "
-                           << this->seasonalityFactors().size() << " were given.");
-            break;
-            default:
-                QL_FAIL("bad frequency specified: " << this->frequency()
-                        << ", only semi-annual through daily permitted.");
-            break;
-        }
-    }
-
-
-    bool MultiplicativePriceSeasonality::isConsistent(const InflationTermStructure& iTS) const
-    {
-        // If multi-year is the specification consistent with the term structure start date?
-        // We do NOT test daily seasonality because this will, in general, never be consistent
-        // given weekends, holidays, leap years, etc.
-        if(this->frequency() == Daily) return true;
-        if(Size(this->frequency()) == seasonalityFactors().size()) return true;
-
-        // how many years do you need to test?
-        Size nTest = seasonalityFactors().size() / this->frequency();
-        // ... relative to the start of the inflation curve
-        std::pair<Date,Date> lim = inflationPeriod(iTS.baseDate(), iTS.frequency());
-        Date curveBaseDate = lim.second;
-        Real factorBase = this->seasonalityFactor(curveBaseDate);
-
-        Real eps = 0.00001;
-        for (Size i = 1; i < nTest; i++) {
-            Real factorAt = this->seasonalityFactor(curveBaseDate+Period(i,Years));
-            QL_REQUIRE(std::fabs(factorAt-factorBase)<eps,"seasonality is inconsistent with inflation term structure, factors "
-                       << factorBase << " and later factor " << factorAt << ", " << i << " years later from inflation curve "
-                       <<" with base date at " << curveBaseDate);
-        }
-
-        return true;
-    }
-
-
-    MultiplicativePriceSeasonality::MultiplicativePriceSeasonality(const Date& seasonalityBaseDate, const Frequency frequency,
-                                                                   const std::vector<Rate> seasonalityFactors)
-    {
-        set(seasonalityBaseDate, frequency, seasonalityFactors);
-    }
-
-    void MultiplicativePriceSeasonality::set(const Date& seasonalityBaseDate, const Frequency frequency,
-                                             const std::vector<Rate> seasonalityFactors)
-    {
-        frequency_ = frequency;
-        seasonalityFactors_ = std::vector<Rate>(seasonalityFactors.size());
-        for(Size i=0; i<seasonalityFactors.size(); i++) {
-            seasonalityFactors_[i] = seasonalityFactors[i];
-        }
-        seasonalityBaseDate_ = seasonalityBaseDate;
-        validate();
-    }
-
-    Date MultiplicativePriceSeasonality::seasonalityBaseDate() const {
-        return seasonalityBaseDate_;
-    }
-
-    Frequency MultiplicativePriceSeasonality::frequency() const {
-        return frequency_;
-    }
-
-    std::vector<Rate> MultiplicativePriceSeasonality::seasonalityFactors() const {
-        return seasonalityFactors_;
-    }
-
-
-    Rate MultiplicativePriceSeasonality::correctZeroRate(const Date &d,
-                                                         const Rate r,
-                                                         const InflationTermStructure& iTS) const {
-        std::pair<Date,Date> lim = inflationPeriod(iTS.baseDate(), iTS.frequency());
-        Date curveBaseDate = lim.second;
-        return seasonalityCorrection(r, d, iTS.dayCounter(), curveBaseDate, true);
-    }
-
-
-    Rate MultiplicativePriceSeasonality::correctYoYRate(const Date &d,
-                                                        const Rate r,
-                                                        const InflationTermStructure& iTS) const {
-        std::pair<Date,Date> lim = inflationPeriod(iTS.baseDate(), iTS.frequency());
-        Date curveBaseDate = lim.second;
-        return seasonalityCorrection(r, d, iTS.dayCounter(), curveBaseDate, false);
-    }
-
-
-    Real MultiplicativePriceSeasonality::seasonalityFactor(const Date &to) const {
-
-        Date from = seasonalityBaseDate();
-        Frequency factorFrequency = frequency();
-        Size nFactors = seasonalityFactors().size();
-        Period factorPeriod(factorFrequency);
-        Size which = 0;
-        if (from==to) {
-            which = 0;
-        } else {
-            // days, weeks, months, years are the only time unit possibilities
-            Integer diffDays = std::abs(to - from);  // in days
-            Integer dir = 1;
-            if(from > to)dir = -1;
-            Integer diff;
-            if (factorPeriod.units() == Days) {
-                diff = dir*diffDays;
-            } else if (factorPeriod.units() == Weeks) {
-                diff = dir * (diffDays / 7);
-            } else if (factorPeriod.units() == Months) {
-                std::pair<Date,Date> lim = inflationPeriod(to, factorFrequency);
-                diff = diffDays / (31*factorPeriod.length());
-                Date go = from + dir*diff*factorPeriod;
-                while ( !(lim.first <= go && go <= lim.second) ) {
-                    go += dir*factorPeriod;
-                    diff++;
-                }
-                diff=dir*diff;
-            } else if (factorPeriod.units() == Years) {
-                QL_FAIL("seasonality period time unit is not allowed to be : " << factorPeriod.units());
-            } else {
-                QL_FAIL("Unknown time unit: " << factorPeriod.units());
-            }
-            // now adjust to the available number of factors, direction dependent
-
-            if (dir==1) {
-                which = diff % nFactors;
-            } else {
-                which = (nFactors - (-diff % nFactors)) % nFactors;
-            }
-        }
-
-        return seasonalityFactors()[which];
-    }
-
-
-    Rate MultiplicativePriceSeasonality::seasonalityCorrection(Rate rate,
-                                                               const Date& atDate,
-                                                               const DayCounter& dc,
-                                                               const Date& curveBaseDate,
-                                                               const bool isZeroRate) const {
-        // need _two_ corrections in order to get: seasonality = factor[atDate-seasonalityBase] / factor[reference-seasonalityBase]
-        // i.e. for ZERO inflation rates you have the true fixing at the curve base so this factor must be normalized to one
-        //      for YoY inflation rates your reference point is the year before
-
-        Real factorAt = this->seasonalityFactor(atDate);
-
-        //Getting seasonality correction for either ZC or YoY
-        Rate f;
-        if (isZeroRate) {
-            Rate factorBase = this->seasonalityFactor(curveBaseDate);
-            Real seasonalityAt = factorAt / factorBase;
-            Time timeFromCurveBase = dc.yearFraction(curveBaseDate, atDate);
-            f = std::pow(seasonalityAt, 1/timeFromCurveBase);
-        }
-        else {
-            Rate factor1Ybefore = this->seasonalityFactor(atDate - Period(1,Years));
-            f = factorAt / factor1Ybefore;
-        }
-
-        return (rate + 1)*f - 1;
-    }
-
-}
-
-
-
-
-
-
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2008 Piero Del Boca
+ Copyright (C) 2009 Chris Kenyon
+ Copyright (C) 2015 Bernd Lewerenz
+
+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.
+*/
+
+
+#include <ql/termstructures/inflation/seasonality.hpp>
+#include <ql/termstructures/inflationtermstructure.hpp>
+#include <ql/errors.hpp>
+
+namespace QuantLib {
+
+    bool Seasonality::isConsistent(const InflationTermStructure&) const {
+        return true;
+    }
+
+
+    //Multiplicative Seasonality on price = on CPI/RPI/HICP/etc
+    //
+    MultiplicativePriceSeasonality::MultiplicativePriceSeasonality() {
+    }
+
+
+    void MultiplicativePriceSeasonality::validate() const
+    {
+        switch (this->frequency()) {
+            case Semiannual:        //2
+            case EveryFourthMonth:  //3
+            case Quarterly:         //4
+            case Bimonthly:         //6
+            case Monthly:           //12
+            case Biweekly:          // etc.
+            case Weekly:
+            case Daily:
+                QL_REQUIRE( (this->seasonalityFactors().size() %
+                             this->frequency()) == 0,
+                           "For frequency " << this->frequency()
+                           << " require multiple of " << ((int)this->frequency()) << " factors "
+                           << this->seasonalityFactors().size() << " were given.");
+            break;
+            default:
+                QL_FAIL("bad frequency specified: " << this->frequency()
+                        << ", only semi-annual through daily permitted.");
+            break;
+        }
+    }
+
+
+    bool MultiplicativePriceSeasonality::isConsistent(const InflationTermStructure& iTS) const
+    {
+        // If multi-year is the specification consistent with the term structure start date?
+        // We do NOT test daily seasonality because this will, in general, never be consistent
+        // given weekends, holidays, leap years, etc.
+        if(this->frequency() == Daily) return true;
+        if(Size(this->frequency()) == seasonalityFactors().size()) return true;
+
+        // how many years do you need to test?
+        Size nTest = seasonalityFactors().size() / this->frequency();
+        // ... relative to the start of the inflation curve
+        std::pair<Date,Date> lim = inflationPeriod(iTS.baseDate(), iTS.frequency());
+        Date curveBaseDate = lim.second;
+        Real factorBase = this->seasonalityFactor(curveBaseDate);
+
+        Real eps = 0.00001;
+        for (Size i = 1; i < nTest; i++) {
+            Real factorAt = this->seasonalityFactor(curveBaseDate+Period(i,Years));
+            QL_REQUIRE(std::fabs(factorAt-factorBase)<eps,"seasonality is inconsistent with inflation term structure, factors "
+                       << factorBase << " and later factor " << factorAt << ", " << i << " years later from inflation curve "
+                       <<" with base date at " << curveBaseDate);
+        }
+
+        return true;
+    }
+
+
+    MultiplicativePriceSeasonality::MultiplicativePriceSeasonality(const Date& seasonalityBaseDate, const Frequency frequency,
+                                                                   const std::vector<Rate> seasonalityFactors)
+    {
+        set(seasonalityBaseDate, frequency, seasonalityFactors);
+    }
+
+    void MultiplicativePriceSeasonality::set(const Date& seasonalityBaseDate, const Frequency frequency,
+                                             const std::vector<Rate> seasonalityFactors)
+    {
+        frequency_ = frequency;
+        seasonalityFactors_ = std::vector<Rate>(seasonalityFactors.size());
+        for(Size i=0; i<seasonalityFactors.size(); i++) {
+            seasonalityFactors_[i] = seasonalityFactors[i];
+        }
+        seasonalityBaseDate_ = seasonalityBaseDate;
+        validate();
+    }
+
+    Date MultiplicativePriceSeasonality::seasonalityBaseDate() const {
+        return seasonalityBaseDate_;
+    }
+
+    Frequency MultiplicativePriceSeasonality::frequency() const {
+        return frequency_;
+    }
+
+    std::vector<Rate> MultiplicativePriceSeasonality::seasonalityFactors() const {
+        return seasonalityFactors_;
+    }
+
+
+    Rate MultiplicativePriceSeasonality::correctZeroRate(const Date &d,
+                                                         const Rate r,
+                                                         const InflationTermStructure& iTS) const {
+        std::pair<Date,Date> lim = inflationPeriod(iTS.baseDate(), iTS.frequency());
+        Date curveBaseDate = lim.second;
+        return seasonalityCorrection(r, d, iTS.dayCounter(), curveBaseDate, true);
+    }
+
+
+    Rate MultiplicativePriceSeasonality::correctYoYRate(const Date &d,
+                                                        const Rate r,
+                                                        const InflationTermStructure& iTS) const {
+        std::pair<Date,Date> lim = inflationPeriod(iTS.baseDate(), iTS.frequency());
+        Date curveBaseDate = lim.second;
+        return seasonalityCorrection(r, d, iTS.dayCounter(), curveBaseDate, false);
+    }
+
+
+    Real MultiplicativePriceSeasonality::seasonalityFactor(const Date &to) const {
+
+        Date from = seasonalityBaseDate();
+        Frequency factorFrequency = frequency();
+        Size nFactors = seasonalityFactors().size();
+        Period factorPeriod(factorFrequency);
+        Size which = 0;
+        if (from==to) {
+            which = 0;
+        } else {
+            // days, weeks, months, years are the only time unit possibilities
+            Integer diffDays = std::abs(to - from);  // in days
+            Integer dir = 1;
+            if(from > to)dir = -1;
+            Integer diff;
+            if (factorPeriod.units() == Days) {
+                diff = dir*diffDays;
+            } else if (factorPeriod.units() == Weeks) {
+                diff = dir * (diffDays / 7);
+            } else if (factorPeriod.units() == Months) {
+                std::pair<Date,Date> lim = inflationPeriod(to, factorFrequency);
+                diff = diffDays / (31*factorPeriod.length());
+                Date go = from + dir*diff*factorPeriod;
+                while ( !(lim.first <= go && go <= lim.second) ) {
+                    go += dir*factorPeriod;
+                    diff++;
+                }
+                diff=dir*diff;
+            } else if (factorPeriod.units() == Years) {
+                QL_FAIL("seasonality period time unit is not allowed to be : " << factorPeriod.units());
+            } else {
+                QL_FAIL("Unknown time unit: " << factorPeriod.units());
+            }
+            // now adjust to the available number of factors, direction dependent
+
+            if (dir==1) {
+                which = diff % nFactors;
+            } else {
+                which = (nFactors - (-diff % nFactors)) % nFactors;
+            }
+        }
+
+        return seasonalityFactors()[which];
+    }
+
+
+    Rate MultiplicativePriceSeasonality::seasonalityCorrection(Rate rate,
+                                                               const Date& atDate,
+                                                               const DayCounter& dc,
+                                                               const Date& curveBaseDate,
+                                                               const bool isZeroRate) const {
+        // need _two_ corrections in order to get: seasonality = factor[atDate-seasonalityBase] / factor[reference-seasonalityBase]
+        // i.e. for ZERO inflation rates you have the true fixing at the curve base so this factor must be normalized to one
+        //      for YoY inflation rates your reference point is the year before
+
+        Real factorAt = this->seasonalityFactor(atDate);
+
+        //Getting seasonality correction for either ZC or YoY
+        Rate f;
+        if (isZeroRate) {
+            Rate factorBase = this->seasonalityFactor(curveBaseDate);
+            Real seasonalityAt = factorAt / factorBase;
+            Time timeFromCurveBase = dc.yearFraction(curveBaseDate, atDate);
+            f = std::pow(seasonalityAt, 1/timeFromCurveBase);
+        }
+        else {
+            Rate factor1Ybefore = this->seasonalityFactor(atDate - Period(1,Years));
+            f = factorAt / factor1Ybefore;
+        }
+
+        return (rate + 1)*f - 1;
+    }
+
+
+	Real DummySeasonality::seasonalityFactor(const Date &to) const {
+
+		Integer dir = 1;
+        Date from = seasonalityBaseDate();
+		Size fromMonth = from.month();
+		Size toMonth = to.month();
+
+		Period factorPeriod(frequency());
+
+		if (toMonth < fromMonth)
+		{
+			Size dummy = fromMonth;
+			fromMonth = toMonth;
+			toMonth = dummy;
+			dir = 0; // We calculate invers Factor in loop
+		}
+
+		QL_REQUIRE(seasonalityFactors().size() == 12 &&
+				factorPeriod.units() == Months,
+			"12 monthly seasonal factors needed for Dummy Seasonality" << 
+			std::endl << "got " << seasonalityFactors().size());
+             
+		Real seasonalCorrection = 1.0;
+		for (Size i = fromMonth ; i<toMonth; i++)
+		{
+			seasonalCorrection *= seasonalityFactors()[i];
+
+		}
+
+		if (!dir) // invers Factor required
+		{
+			seasonalCorrection = 1/seasonalCorrection;
+		}
+
+        return seasonalCorrection;
+    }
+
+	Rate DummySeasonality::seasonalityCorrection(Rate rate,
+                                                               const Date& atDate,
+                                                               const DayCounter& dc,
+                                                               const Date& curveBaseDate,
+                                                               const bool isZeroRate) const {
+
+        Real indexFactor = this->seasonalityFactor(atDate);
+
+        //Getting seasonality correction 
+        Rate f;
+        if (isZeroRate) {
+			std::pair<Date,Date> lim = inflationPeriod(curveBaseDate, Monthly);
+            Time timeFromCurveBase = dc.yearFraction(lim.first, atDate);
+            f = std::pow(indexFactor, 1/timeFromCurveBase);
+        }
+        else {
+            QL_FAIL("Seasonal Dummy Model is only defined on ZeroRates. Not on YoY " );
+        }
+
+        return (rate + 1)*f - 1;
+    }
+
+} // end Namespace QuantLib
+
+
+
+
+
+
diff -rupN QuantLib-1.6/ql/termstructures/inflation/seasonality.hpp QuantLib-1.6_patch/ql/termstructures/inflation/seasonality.hpp
--- QuantLib-1.6/ql/termstructures/inflation/seasonality.hpp	2015-05-04 16:37:08.000000000 +0200
+++ QuantLib-1.6_patch/ql/termstructures/inflation/seasonality.hpp	2015-07-08 21:18:51.527451535 +0200
@@ -1,166 +1,187 @@
-/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-
-/*
- Copyright (C) 2008 Piero Del Boca
- Copyright (C) 2009 Chris Kenyon
-
- 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_seasonality_hpp
-#define quantlib_seasonality_hpp
-
-#include <ql/time/daycounter.hpp>
-#include <ql/time/frequency.hpp>
-#include <boost/shared_ptr.hpp>
-#include <vector>
-
-namespace QuantLib {
-
-    class InflationTermStructure;
-
-    //! A transformation of an existing inflation swap rate.
-    /*! This is an abstract class and contains the functions
-        correctXXXRate which returns rates with the seasonality
-        correction.  Currently only the price multiplicative version
-        is implemented, but this covers stationary (1-year) and
-        non-stationary (multi-year) seasonality depending on how many
-        years of factors are given.  Seasonality is piecewise
-        constant, hence it will work with un-interpolated inflation
-        indices.
-
-        A seasonality assumption can be used to fill in inflation swap
-        curves between maturities that are usually given in integer
-        numbers of years, e.g. 8,9,10,15,20, etc.  Historical
-        seasonality may be observed in reported CPI values,
-        alternatively it may be affected by known future events, e.g.
-        announced changes in VAT rates.  Thus seasonality may be
-        stationary or non-stationary.
-
-        If seasonality is additive then both swap rates will show
-        affects.  Additive seasonality is not implemented.
-    */
-    class Seasonality {
-
-        public:
-
-        //! \name Seasonality interface
-        //@{
-        virtual Rate correctZeroRate(const Date &d, const Rate r,
-                                     const InflationTermStructure& iTS) const = 0;
-        virtual Rate correctYoYRate(const Date &d, const Rate r,
-                                    const InflationTermStructure& iTS) const = 0;
-        /*! It is possible for multi-year seasonalities to be
-            inconsistent with the inflation term structure they are
-            given to.  This method enables testing - but programmers
-            are not required to implement it.  E.g. for price
-            seasonality the corrections at whole years after the
-            inflation curve base date should be the same or else there
-            can be an inconsistency with quoted instruments.
-            Alternatively, the seasonality can be set _before_ the
-            inflation curve is bootstrapped.
-        */
-        virtual bool isConsistent(const InflationTermStructure& iTS) const;
-        //@}
-
-        virtual ~Seasonality() {}
-    };
-
-    //! Multiplicative seasonality in the price index (CPI/RPI/HICP/etc).
-
-    /*! Stationary multiplicative seasonality in CPI/RPI/HICP (i.e. in
-        price) implies that zero inflation swap rates are affected,
-        but that year-on-year inflation swap rates show no effect.  Of
-        course, if the seasonality in CPI/RPI/HICP is non-stationary
-        then both swap rates will be affected.
-
-        Factors must be in multiples of the minimum required for one
-        year, e.g. 12 for monthly, and these factors are reused for as
-        long as is required, i.e. they wrap around.  So, for example,
-        if 24 factors are given this repeats every two years.  True
-        stationary seasonality can be obtained by giving the same
-        number of factors as the frequency dictates e.g. 12 for
-        monthly seasonality.
-
-        \warning Multi-year seasonality (i.e. non-stationary) is
-                 fragile: the user <b>must</b> ensure that corrections
-                 at whole years before and after the inflation term
-                 structure base date are the same.  Otherwise there
-                 can be an inconsistency with quoted rates.  This is
-                 enforced if the frequency is lower than daily.  This
-                 is not enforced for daily seasonality because this
-                 will always be inconsistent due to weekends,
-                 holidays, leap years, etc.  If you use multi-year
-                 daily seasonality it is up to you to check.
-
-        \note Factors are normalized relative to their appropriate
-              reference dates.  For zero inflation this is the
-              inflation curve true base date: since you have a fixing
-              for that date the seasonality factor must be one.  For
-              YoY inflation the reference is always one year earlier.
-
-        Seasonality is treated as piecewise constant, hence it works
-        correctly with uninterpolated indices if the seasonality
-        correction factor frequency is the same as the index frequency
-        (or less).
-    */
-    class MultiplicativePriceSeasonality : public Seasonality {
-
-        private:
-            Date seasonalityBaseDate_;
-            Frequency frequency_;
-            std::vector<Rate> seasonalityFactors_;
-
-        public:
-
-            //Constructors
-            //
-            MultiplicativePriceSeasonality();
-
-            MultiplicativePriceSeasonality(const Date& seasonalityBaseDate, const Frequency frequency,
-                                           const std::vector<Rate> seasonalityFactors);
-
-            virtual void set(const Date& seasonalityBaseDate, const Frequency frequency,
-                     const std::vector<Rate> seasonalityFactors);
-
-            //! inspectors
-            //@{
-            virtual Date seasonalityBaseDate() const;
-            virtual Frequency frequency() const;
-            virtual std::vector<Rate> seasonalityFactors() const;
-            //! The factor returned is NOT normalized relative to ANYTHING.
-            virtual Rate seasonalityFactor(const Date &d) const;
-            //@}
-
-            //! \name Seasonality interface
-            //@{
-            virtual Rate correctZeroRate(const Date &d, const Rate r,
-                                         const InflationTermStructure& iTS) const;
-            virtual Rate correctYoYRate(const Date &d, const Rate r,
-                                        const InflationTermStructure& iTS) const;
-            virtual bool isConsistent(const InflationTermStructure& iTS) const;
-            //@}
-
-            //Destructor
-            virtual ~MultiplicativePriceSeasonality() {};
-
-        protected:
-            virtual void validate() const;
-            virtual Rate seasonalityCorrection(Rate r, const Date &d, const DayCounter &dc,
-                                               const Date &curveBaseDate, bool isZeroRate) const;
-    };
-
-}  // end of namespace QuantLib
-#endif
-
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2008 Piero Del Boca
+ Copyright (C) 2009 Chris Kenyon
+ Copyright (C) 2015 Bernd Lewerenz
+
+ 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_seasonality_hpp
+#define quantlib_seasonality_hpp
+
+#include <ql/time/daycounter.hpp>
+#include <ql/time/frequency.hpp>
+#include <boost/shared_ptr.hpp>
+#include <vector>
+
+namespace QuantLib {
+
+    class InflationTermStructure;
+
+    //! A transformation of an existing inflation swap rate.
+    /*! This is an abstract class and contains the functions
+        correctXXXRate which returns rates with the seasonality
+        correction.  Currently only the price multiplicative version
+        is implemented, but this covers stationary (1-year) and
+        non-stationary (multi-year) seasonality depending on how many
+        years of factors are given.  Seasonality is piecewise
+        constant, hence it will work with un-interpolated inflation
+        indices.
+
+        A seasonality assumption can be used to fill in inflation swap
+        curves between maturities that are usually given in integer
+        numbers of years, e.g. 8,9,10,15,20, etc.  Historical
+        seasonality may be observed in reported CPI values,
+        alternatively it may be affected by known future events, e.g.
+        announced changes in VAT rates.  Thus seasonality may be
+        stationary or non-stationary.
+
+        If seasonality is additive then both swap rates will show
+        affects.  Additive seasonality is not implemented.
+    */
+    class Seasonality {
+
+        public:
+
+        //! \name Seasonality interface
+        //@{
+        virtual Rate correctZeroRate(const Date &d, const Rate r,
+                                     const InflationTermStructure& iTS) const = 0;
+        virtual Rate correctYoYRate(const Date &d, const Rate r,
+                                    const InflationTermStructure& iTS) const = 0;
+        /*! It is possible for multi-year seasonalities to be
+            inconsistent with the inflation term structure they are
+            given to.  This method enables testing - but programmers
+            are not required to implement it.  E.g. for price
+            seasonality the corrections at whole years after the
+            inflation curve base date should be the same or else there
+            can be an inconsistency with quoted instruments.
+            Alternatively, the seasonality can be set _before_ the
+            inflation curve is bootstrapped.
+        */
+        virtual bool isConsistent(const InflationTermStructure& iTS) const;
+        //@}
+
+        virtual ~Seasonality() {}
+    };
+
+    //! Multiplicative seasonality in the price index (CPI/RPI/HICP/etc).
+
+    /*! Stationary multiplicative seasonality in CPI/RPI/HICP (i.e. in
+        price) implies that zero inflation swap rates are affected,
+        but that year-on-year inflation swap rates show no effect.  Of
+        course, if the seasonality in CPI/RPI/HICP is non-stationary
+        then both swap rates will be affected.
+
+        Factors must be in multiples of the minimum required for one
+        year, e.g. 12 for monthly, and these factors are reused for as
+        long as is required, i.e. they wrap around.  So, for example,
+        if 24 factors are given this repeats every two years.  True
+        stationary seasonality can be obtained by giving the same
+        number of factors as the frequency dictates e.g. 12 for
+        monthly seasonality.
+
+        \warning Multi-year seasonality (i.e. non-stationary) is
+                 fragile: the user <b>must</b> ensure that corrections
+                 at whole years before and after the inflation term
+                 structure base date are the same.  Otherwise there
+                 can be an inconsistency with quoted rates.  This is
+                 enforced if the frequency is lower than daily.  This
+                 is not enforced for daily seasonality because this
+                 will always be inconsistent due to weekends,
+                 holidays, leap years, etc.  If you use multi-year
+                 daily seasonality it is up to you to check.
+
+        \note Factors are normalized relative to their appropriate
+              reference dates.  For zero inflation this is the
+              inflation curve true base date: since you have a fixing
+              for that date the seasonality factor must be one.  For
+              YoY inflation the reference is always one year earlier.
+
+        Seasonality is treated as piecewise constant, hence it works
+        correctly with uninterpolated indices if the seasonality
+        correction factor frequency is the same as the index frequency
+        (or less).
+    */
+    class MultiplicativePriceSeasonality : public Seasonality {
+
+        private:
+            Date seasonalityBaseDate_;
+            Frequency frequency_;
+            std::vector<Rate> seasonalityFactors_;
+
+        public:
+
+            //Constructors
+            //
+            MultiplicativePriceSeasonality();
+
+            MultiplicativePriceSeasonality(const Date& seasonalityBaseDate, const Frequency frequency,
+                                           const std::vector<Rate> seasonalityFactors);
+
+            virtual void set(const Date& seasonalityBaseDate, const Frequency frequency,
+                     const std::vector<Rate> seasonalityFactors);
+
+            //! inspectors
+            //@{
+            virtual Date seasonalityBaseDate() const;
+            virtual Frequency frequency() const;
+            virtual std::vector<Rate> seasonalityFactors() const;
+            //! The factor returned is NOT normalized relative to ANYTHING.
+            virtual Rate seasonalityFactor(const Date &d) const;
+            //@}
+
+            //! \name Seasonality interface
+            //@{
+            virtual Rate correctZeroRate(const Date &d, const Rate r,
+                                         const InflationTermStructure& iTS) const;
+            virtual Rate correctYoYRate(const Date &d, const Rate r,
+                                        const InflationTermStructure& iTS) const;
+            virtual bool isConsistent(const InflationTermStructure& iTS) const;
+            //@}
+
+            //Destructor
+            virtual ~MultiplicativePriceSeasonality() {};
+
+        protected:
+            virtual void validate() const;
+            virtual Rate seasonalityCorrection(Rate r, const Date &d, const DayCounter &dc,
+                                               const Date &curveBaseDate, bool isZeroRate) const;
+    };
+
+	class DummySeasonality : public MultiplicativePriceSeasonality {
+
+	public:
+
+	DummySeasonality(const Date& seasonalityBaseDate,
+		const std::vector<Rate> seasonalityFactors): 
+	MultiplicativePriceSeasonality(seasonalityBaseDate,Monthly,seasonalityFactors){};
+
+	/*Rate correctZeroRate(const Date &d, const Rate r,
+                                         const InflationTermStructure& iTS) const;*/
+	Real seasonalityFactor(const Date &to) const;
+
+	protected:
+	virtual Rate seasonalityCorrection(Rate rate,
+                               const Date& atDate,
+                               const DayCounter& dc,
+                               const Date& curveBaseDate,
+                               bool isZeroRate) const ;
+	};
+
+}  // end of namespace QuantLib
+#endif
+
