1 /* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 
3 /*
4  Copyright (C) 2007, 2009 Chris Kenyon
5 
6  This file is part of QuantLib, a free-software/open-source library
7  for financial quantitative analysts and developers - http://quantlib.org/
8 
9  QuantLib is free software: you can redistribute it and/or modify it
10  under the terms of the QuantLib license.  You should have received a
11  copy of the license along with this program; if not, please email
12  <quantlib-dev@lists.sf.net>. The license is also available online at
13  <http://quantlib.org/license.shtml>.
14 
15  This program is distributed in the hope that it will be useful, but WITHOUT
16  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17  FOR A PARTICULAR PURPOSE.  See the license for more details.
18 */
19 
20 #include <ql/termstructures/inflationtermstructure.hpp>
21 #include <ql/indexes/inflationindex.hpp>
22 
23 namespace QuantLib {
24 
InflationTermStructure(Rate baseRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const DayCounter & dayCounter,const ext::shared_ptr<Seasonality> & seasonality)25     InflationTermStructure::InflationTermStructure(
26                                         Rate baseRate,
27                                         const Period& observationLag,
28                                         Frequency frequency,
29                                         bool indexIsInterpolated,
30                                         const DayCounter& dayCounter,
31                                         const ext::shared_ptr<Seasonality> &seasonality)
32     : TermStructure(dayCounter),
33       observationLag_(observationLag), frequency_(frequency), indexIsInterpolated_(indexIsInterpolated),
34       baseRate_(baseRate) {
35         setSeasonality(seasonality);
36     }
37 
InflationTermStructure(const Date & referenceDate,Rate baseRate,const Period & observationLag,Frequency frequency,const bool indexIsInterpolated,const Calendar & calendar,const DayCounter & dayCounter,const ext::shared_ptr<Seasonality> & seasonality)38     InflationTermStructure::InflationTermStructure(
39                                         const Date& referenceDate,
40                                         Rate baseRate,
41                                         const Period& observationLag,
42                                         Frequency frequency,
43                                         const bool indexIsInterpolated,
44                                         const Calendar& calendar,
45                                         const DayCounter& dayCounter,
46                                         const ext::shared_ptr<Seasonality> &seasonality)
47     : TermStructure(referenceDate, calendar, dayCounter),
48       observationLag_(observationLag),
49       frequency_(frequency), indexIsInterpolated_(indexIsInterpolated),
50       baseRate_(baseRate) {
51         setSeasonality(seasonality);
52     }
53 
InflationTermStructure(Natural settlementDays,const Calendar & calendar,Rate baseRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const DayCounter & dayCounter,const ext::shared_ptr<Seasonality> & seasonality)54     InflationTermStructure::InflationTermStructure(
55                                         Natural settlementDays,
56                                         const Calendar& calendar,
57                                         Rate baseRate,
58                                         const Period& observationLag,
59                                         Frequency frequency,
60                                         bool indexIsInterpolated,
61                                         const DayCounter &dayCounter,
62                                         const ext::shared_ptr<Seasonality> &seasonality)
63     : TermStructure(settlementDays, calendar, dayCounter),
64       observationLag_(observationLag),
65       frequency_(frequency), indexIsInterpolated_(indexIsInterpolated),
66       baseRate_(baseRate) {
67         setSeasonality(seasonality);
68     }
69 
InflationTermStructure(Rate baseRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const Handle<YieldTermStructure> & yTS,const DayCounter & dayCounter,const ext::shared_ptr<Seasonality> & seasonality)70     InflationTermStructure::InflationTermStructure(
71                                         Rate baseRate,
72                                         const Period& observationLag,
73                                         Frequency frequency,
74                                         bool indexIsInterpolated,
75                                         const Handle<YieldTermStructure>& yTS,
76                                         const DayCounter& dayCounter,
77                                         const ext::shared_ptr<Seasonality> &seasonality)
78     : TermStructure(dayCounter),
79       observationLag_(observationLag), frequency_(frequency), indexIsInterpolated_(indexIsInterpolated),
80       baseRate_(baseRate), nominalTermStructure_(yTS) {
81         registerWith(nominalTermStructure_);
82         setSeasonality(seasonality);
83     }
84 
InflationTermStructure(const Date & referenceDate,Rate baseRate,const Period & observationLag,Frequency frequency,const bool indexIsInterpolated,const Handle<YieldTermStructure> & yTS,const Calendar & calendar,const DayCounter & dayCounter,const ext::shared_ptr<Seasonality> & seasonality)85     InflationTermStructure::InflationTermStructure(
86                                         const Date& referenceDate,
87                                         Rate baseRate,
88                                         const Period& observationLag,
89                                         Frequency frequency,
90                                         const bool indexIsInterpolated,
91                                         const Handle<YieldTermStructure>& yTS,
92                                         const Calendar& calendar,
93                                         const DayCounter& dayCounter,
94                                         const ext::shared_ptr<Seasonality> &seasonality)
95     : TermStructure(referenceDate, calendar, dayCounter),
96       observationLag_(observationLag),
97       frequency_(frequency), indexIsInterpolated_(indexIsInterpolated),
98       baseRate_(baseRate), nominalTermStructure_(yTS) {
99         registerWith(nominalTermStructure_);
100         setSeasonality(seasonality);
101     }
102 
InflationTermStructure(Natural settlementDays,const Calendar & calendar,Rate baseRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const Handle<YieldTermStructure> & yTS,const DayCounter & dayCounter,const ext::shared_ptr<Seasonality> & seasonality)103     InflationTermStructure::InflationTermStructure(
104                                         Natural settlementDays,
105                                         const Calendar& calendar,
106                                         Rate baseRate,
107                                         const Period& observationLag,
108                                         Frequency frequency,
109                                         bool indexIsInterpolated,
110                                         const Handle<YieldTermStructure>& yTS,
111                                         const DayCounter &dayCounter,
112                                         const ext::shared_ptr<Seasonality> &seasonality)
113     : TermStructure(settlementDays, calendar, dayCounter),
114       observationLag_(observationLag),
115       frequency_(frequency), indexIsInterpolated_(indexIsInterpolated),
116       baseRate_(baseRate), nominalTermStructure_(yTS) {
117         registerWith(nominalTermStructure_);
118         setSeasonality(seasonality);
119     }
120 
121 
setSeasonality(const ext::shared_ptr<Seasonality> & seasonality)122     void InflationTermStructure::setSeasonality(
123                           const ext::shared_ptr<Seasonality>& seasonality) {
124         // always reset, whether with null or new pointer
125         seasonality_ = seasonality;
126         if (seasonality_ != 0) {
127             QL_REQUIRE(seasonality_->isConsistent(*this),
128                        "Seasonality inconsistent with "
129                        "inflation term structure");
130         }
131         notifyObservers();
132     }
133 
134 
checkRange(const Date & d,bool extrapolate) const135     void InflationTermStructure::checkRange(const Date& d,
136                                             bool extrapolate) const {
137         QL_REQUIRE(d >= baseDate(),
138                    "date (" << d << ") is before base date (" << baseDate() << ")");
139         QL_REQUIRE(extrapolate || allowsExtrapolation() || d <= maxDate(),
140                    "date (" << d << ") is past max curve date ("
141                    << maxDate() << ")");
142     }
143 
checkRange(Time t,bool extrapolate) const144     void InflationTermStructure::checkRange(Time t,
145                                             bool extrapolate) const {
146         QL_REQUIRE(t >= timeFromReference(baseDate()),
147                    "time (" << t << ") is before base date");
148         QL_REQUIRE(extrapolate || allowsExtrapolation() || t <= maxTime(),
149                    "time (" << t << ") is past max curve time ("
150                    << maxTime() << ")");
151     }
152 
153 
ZeroInflationTermStructure(const DayCounter & dayCounter,Rate baseZeroRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const ext::shared_ptr<Seasonality> & seasonality)154     ZeroInflationTermStructure::ZeroInflationTermStructure(
155                                     const DayCounter& dayCounter,
156                                     Rate baseZeroRate,
157                                     const Period& observationLag,
158                                     Frequency frequency,
159                                     bool indexIsInterpolated,
160                                     const ext::shared_ptr<Seasonality> &seasonality)
161     : InflationTermStructure(baseZeroRate, observationLag, frequency, indexIsInterpolated,
162                              dayCounter, seasonality) {
163     }
164 
ZeroInflationTermStructure(const Date & referenceDate,const Calendar & calendar,const DayCounter & dayCounter,Rate baseZeroRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const ext::shared_ptr<Seasonality> & seasonality)165     ZeroInflationTermStructure::ZeroInflationTermStructure(
166                                     const Date& referenceDate,
167                                     const Calendar& calendar,
168                                     const DayCounter& dayCounter,
169                                     Rate baseZeroRate,
170                                     const Period& observationLag,
171                                     Frequency frequency,
172                                     bool indexIsInterpolated,
173                                     const ext::shared_ptr<Seasonality> &seasonality)
174     : InflationTermStructure(referenceDate, baseZeroRate, observationLag, frequency, indexIsInterpolated,
175                              calendar, dayCounter, seasonality) {
176     }
177 
ZeroInflationTermStructure(Natural settlementDays,const Calendar & calendar,const DayCounter & dayCounter,Rate baseZeroRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const ext::shared_ptr<Seasonality> & seasonality)178     ZeroInflationTermStructure::ZeroInflationTermStructure(
179                                     Natural settlementDays,
180                                     const Calendar& calendar,
181                                     const DayCounter& dayCounter,
182                                     Rate baseZeroRate,
183                                     const Period& observationLag,
184                                     Frequency frequency,
185                                     bool indexIsInterpolated,
186                                     const ext::shared_ptr<Seasonality> &seasonality)
187     : InflationTermStructure(settlementDays, calendar, baseZeroRate, observationLag, frequency, indexIsInterpolated,
188                              dayCounter, seasonality) {
189     }
190 
191 #if defined(__GNUC__)
192 #pragma GCC diagnostic push
193 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
194 #endif
195 #if defined(__clang__)
196 #pragma clang diagnostic push
197 #pragma clang diagnostic ignored "-Wc++11-extensions"
198 #endif
199 #if defined(QL_PATCH_MSVC)
200 #pragma warning(push)
201 #pragma warning(disable:4996)
202 #endif
203 
ZeroInflationTermStructure(const DayCounter & dayCounter,Rate baseZeroRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const Handle<YieldTermStructure> & yTS,const ext::shared_ptr<Seasonality> & seasonality)204     ZeroInflationTermStructure::ZeroInflationTermStructure(
205                                     const DayCounter& dayCounter,
206                                     Rate baseZeroRate,
207                                     const Period& observationLag,
208                                     Frequency frequency,
209                                     bool indexIsInterpolated,
210                                     const Handle<YieldTermStructure>& yTS,
211                                     const ext::shared_ptr<Seasonality> &seasonality)
212     : InflationTermStructure(baseZeroRate, observationLag, frequency, indexIsInterpolated,
213                              yTS, dayCounter, seasonality) {
214     }
215 
ZeroInflationTermStructure(const Date & referenceDate,const Calendar & calendar,const DayCounter & dayCounter,Rate baseZeroRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const Handle<YieldTermStructure> & yTS,const ext::shared_ptr<Seasonality> & seasonality)216     ZeroInflationTermStructure::ZeroInflationTermStructure(
217                                     const Date& referenceDate,
218                                     const Calendar& calendar,
219                                     const DayCounter& dayCounter,
220                                     Rate baseZeroRate,
221                                     const Period& observationLag,
222                                     Frequency frequency,
223                                     bool indexIsInterpolated,
224                                     const Handle<YieldTermStructure>& yTS,
225                                     const ext::shared_ptr<Seasonality> &seasonality)
226     : InflationTermStructure(referenceDate, baseZeroRate, observationLag, frequency, indexIsInterpolated,
227                              yTS, calendar, dayCounter, seasonality) {
228     }
229 
ZeroInflationTermStructure(Natural settlementDays,const Calendar & calendar,const DayCounter & dayCounter,Rate baseZeroRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const Handle<YieldTermStructure> & yTS,const ext::shared_ptr<Seasonality> & seasonality)230     ZeroInflationTermStructure::ZeroInflationTermStructure(
231                                     Natural settlementDays,
232                                     const Calendar& calendar,
233                                     const DayCounter& dayCounter,
234                                     Rate baseZeroRate,
235                                     const Period& observationLag,
236                                     Frequency frequency,
237                                     bool indexIsInterpolated,
238                                     const Handle<YieldTermStructure>& yTS,
239                                     const ext::shared_ptr<Seasonality> &seasonality)
240     : InflationTermStructure(settlementDays, calendar, baseZeroRate, observationLag, frequency, indexIsInterpolated,
241                              yTS, dayCounter, seasonality) {
242     }
243 
244 #if defined(QL_PATCH_MSVC)
245 #pragma warning(pop)
246 #endif
247 #if defined(__clang__)
248 #pragma clang diagnostic pop
249 #endif
250 #if defined(__GNUC__)
251 #pragma GCC diagnostic pop
252 #endif
253 
zeroRate(const Date & d,const Period & instObsLag,bool forceLinearInterpolation,bool extrapolate) const254     Rate ZeroInflationTermStructure::zeroRate(const Date &d, const Period& instObsLag,
255                                               bool forceLinearInterpolation,
256                                               bool extrapolate) const {
257 
258         Period useLag = instObsLag;
259         if (instObsLag == Period(-1,Days)) {
260             useLag = observationLag();
261         }
262 
263         Rate zeroRate;
264         if (forceLinearInterpolation) {
265             std::pair<Date,Date> dd = inflationPeriod(d-useLag, frequency());
266             dd.second = dd.second + Period(1,Days);
267             Real dp = dd.second - dd.first;
268             Real dt = d - dd.first;
269             // if we are interpolating we only check the exact point
270             // this prevents falling off the end at curve maturity
271             InflationTermStructure::checkRange(d, extrapolate);
272             Time t1 = timeFromReference(dd.first);
273             Time t2 = timeFromReference(dd.second);
274             Rate z1 = zeroRateImpl(t1);
275             Rate z2 = zeroRateImpl(t2);
276             zeroRate = z1 + (z2-z1) * (dt/dp);
277         } else {
278             if (indexIsInterpolated()) {
279                 InflationTermStructure::checkRange(d-useLag, extrapolate);
280                 Time t = timeFromReference(d-useLag);
281                 zeroRate = zeroRateImpl(t);
282             } else {
283                 std::pair<Date,Date> dd = inflationPeriod(d-useLag, frequency());
284                 InflationTermStructure::checkRange(dd.first, extrapolate);
285                 Time t = timeFromReference(dd.first);
286                 zeroRate = zeroRateImpl(t);
287             }
288         }
289 
290         if (hasSeasonality()) {
291             zeroRate = seasonality()->correctZeroRate(d-useLag, zeroRate, *this);
292         }
293         return zeroRate;
294     }
295 
zeroRate(Time t,bool extrapolate) const296     Rate ZeroInflationTermStructure::zeroRate(Time t,
297                                               bool extrapolate) const {
298         checkRange(t, extrapolate);
299         return zeroRateImpl(t);
300     }
301 
302 
YoYInflationTermStructure(const DayCounter & dayCounter,Rate baseYoYRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const ext::shared_ptr<Seasonality> & seasonality)303     YoYInflationTermStructure::YoYInflationTermStructure(
304                                     const DayCounter& dayCounter,
305                                     Rate baseYoYRate,
306                                     const Period& observationLag,
307                                     Frequency frequency,
308                                     bool indexIsInterpolated,
309                                     const ext::shared_ptr<Seasonality> &seasonality)
310     : InflationTermStructure(baseYoYRate, observationLag, frequency, indexIsInterpolated,
311                              dayCounter, seasonality) {}
312 
YoYInflationTermStructure(const Date & referenceDate,const Calendar & calendar,const DayCounter & dayCounter,Rate baseYoYRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const ext::shared_ptr<Seasonality> & seasonality)313     YoYInflationTermStructure::YoYInflationTermStructure(
314                                     const Date& referenceDate,
315                                     const Calendar& calendar,
316                                     const DayCounter& dayCounter,
317                                     Rate baseYoYRate,
318                                     const Period& observationLag,
319                                     Frequency frequency,
320                                     bool indexIsInterpolated,
321                                     const ext::shared_ptr<Seasonality> &seasonality)
322     : InflationTermStructure(referenceDate, baseYoYRate, observationLag, frequency, indexIsInterpolated,
323                              calendar, dayCounter, seasonality) {}
324 
YoYInflationTermStructure(Natural settlementDays,const Calendar & calendar,const DayCounter & dayCounter,Rate baseYoYRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const ext::shared_ptr<Seasonality> & seasonality)325     YoYInflationTermStructure::YoYInflationTermStructure(
326                                     Natural settlementDays,
327                                     const Calendar& calendar,
328                                     const DayCounter& dayCounter,
329                                     Rate baseYoYRate,
330                                     const Period& observationLag,
331                                     Frequency frequency,
332                                     bool indexIsInterpolated,
333                                     const ext::shared_ptr<Seasonality> &seasonality)
334     : InflationTermStructure(settlementDays, calendar, baseYoYRate, observationLag,
335                              frequency, indexIsInterpolated, dayCounter, seasonality) {}
336 
337 #if defined(__GNUC__)
338 #pragma GCC diagnostic push
339 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
340 #endif
341 #if defined(__clang__)
342 #pragma clang diagnostic push
343 #pragma clang diagnostic ignored "-Wc++11-extensions"
344 #endif
345 #if defined(QL_PATCH_MSVC)
346 #pragma warning(push)
347 #pragma warning(disable:4996)
348 #endif
349 
YoYInflationTermStructure(const DayCounter & dayCounter,Rate baseYoYRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const Handle<YieldTermStructure> & yTS,const ext::shared_ptr<Seasonality> & seasonality)350     YoYInflationTermStructure::YoYInflationTermStructure(
351                                     const DayCounter& dayCounter,
352                                     Rate baseYoYRate,
353                                     const Period& observationLag,
354                                     Frequency frequency,
355                                     bool indexIsInterpolated,
356                                     const Handle<YieldTermStructure>& yTS,
357                                     const ext::shared_ptr<Seasonality> &seasonality)
358     : InflationTermStructure(baseYoYRate, observationLag, frequency, indexIsInterpolated,
359                              yTS, dayCounter, seasonality) {}
360 
YoYInflationTermStructure(const Date & referenceDate,const Calendar & calendar,const DayCounter & dayCounter,Rate baseYoYRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const Handle<YieldTermStructure> & yTS,const ext::shared_ptr<Seasonality> & seasonality)361     YoYInflationTermStructure::YoYInflationTermStructure(
362                                     const Date& referenceDate,
363                                     const Calendar& calendar,
364                                     const DayCounter& dayCounter,
365                                     Rate baseYoYRate,
366                                     const Period& observationLag,
367                                     Frequency frequency,
368                                     bool indexIsInterpolated,
369                                     const Handle<YieldTermStructure>& yTS,
370                                     const ext::shared_ptr<Seasonality> &seasonality)
371     : InflationTermStructure(referenceDate, baseYoYRate, observationLag, frequency, indexIsInterpolated,
372                              yTS, calendar, dayCounter, seasonality) {}
373 
YoYInflationTermStructure(Natural settlementDays,const Calendar & calendar,const DayCounter & dayCounter,Rate baseYoYRate,const Period & observationLag,Frequency frequency,bool indexIsInterpolated,const Handle<YieldTermStructure> & yTS,const ext::shared_ptr<Seasonality> & seasonality)374     YoYInflationTermStructure::YoYInflationTermStructure(
375                                     Natural settlementDays,
376                                     const Calendar& calendar,
377                                     const DayCounter& dayCounter,
378                                     Rate baseYoYRate,
379                                     const Period& observationLag,
380                                     Frequency frequency,
381                                     bool indexIsInterpolated,
382                                     const Handle<YieldTermStructure>& yTS,
383                                     const ext::shared_ptr<Seasonality> &seasonality)
384     : InflationTermStructure(settlementDays, calendar, baseYoYRate, observationLag,
385                              frequency, indexIsInterpolated,
386                              yTS, dayCounter, seasonality) {}
387 
388 #if defined(QL_PATCH_MSVC)
389 #pragma warning(pop)
390 #endif
391 #if defined(__clang__)
392 #pragma clang diagnostic pop
393 #endif
394 #if defined(__GNUC__)
395 #pragma GCC diagnostic pop
396 #endif
397 
398 
yoyRate(const Date & d,const Period & instObsLag,bool forceLinearInterpolation,bool extrapolate) const399     Rate YoYInflationTermStructure::yoyRate(const Date &d, const Period& instObsLag,
400                                               bool forceLinearInterpolation,
401                                               bool extrapolate) const {
402 
403         Period useLag = instObsLag;
404         if (instObsLag == Period(-1,Days)) {
405             useLag = observationLag();
406         }
407 
408         Rate yoyRate;
409         if (forceLinearInterpolation) {
410             std::pair<Date,Date> dd = inflationPeriod(d-useLag, frequency());
411             dd.second = dd.second + Period(1,Days);
412             Real dp = dd.second - dd.first;
413             Real dt = (d-useLag) - dd.first;
414             // if we are interpolating we only check the exact point
415             // this prevents falling off the end at curve maturity
416             InflationTermStructure::checkRange(d, extrapolate);
417             Time t1 = timeFromReference(dd.first);
418             Time t2 = timeFromReference(dd.second);
419             Rate y1 = yoyRateImpl(t1);
420             Rate y2 = yoyRateImpl(t2);
421             yoyRate = y1 + (y2-y1) * (dt/dp);
422         } else {
423             if (indexIsInterpolated()) {
424                 InflationTermStructure::checkRange(d-useLag, extrapolate);
425                 Time t = timeFromReference(d-useLag);
426                 yoyRate = yoyRateImpl(t);
427             } else {
428                 std::pair<Date,Date> dd = inflationPeriod(d-useLag, frequency());
429                 InflationTermStructure::checkRange(dd.first, extrapolate);
430                 Time t = timeFromReference(dd.first);
431                 yoyRate = yoyRateImpl(t);
432             }
433         }
434 
435         if (hasSeasonality()) {
436             yoyRate = seasonality()->correctYoYRate(d-useLag, yoyRate, *this);
437         }
438         return yoyRate;
439     }
440 
yoyRate(Time t,bool extrapolate) const441     Rate YoYInflationTermStructure::yoyRate(Time t,
442                                             bool extrapolate) const {
443         checkRange(t, extrapolate);
444         return yoyRateImpl(t);
445     }
446 
447 
448 
449 
inflationPeriod(const Date & d,Frequency frequency)450     std::pair<Date,Date> inflationPeriod(const Date& d,
451                                          Frequency frequency) {
452 
453         Month month = d.month();
454         Year year = d.year();
455 
456         Month startMonth, endMonth;
457         switch (frequency) {
458           case Annual:
459             startMonth = January;
460             endMonth = December;
461             break;
462           case Semiannual:
463             if (month <= June) {
464                 startMonth = January;
465                 endMonth = June;
466             } else {
467                 startMonth = July;
468                 endMonth = December;
469             }
470             break;
471           case Quarterly:
472             if (month <= March) {
473                 startMonth = January;
474                 endMonth = March;
475             } else if (month <= June) {
476                 startMonth = April;
477                 endMonth = June;
478             } else if (month <= September) {
479                 startMonth = July;
480                 endMonth = September;
481             } else {
482                 startMonth = October;
483                 endMonth = December;
484             }
485             break;
486           case Monthly:
487             startMonth = endMonth = month;
488             break;
489           default:
490             QL_FAIL("Frequency not handled: " << frequency);
491             break;
492         };
493 
494         Date startDate = Date(1, startMonth, year);
495         Date endDate = Date::endOfMonth(Date(1, endMonth, year));
496 
497         return std::make_pair(startDate,endDate);
498     }
499 
500 
inflationYearFraction(Frequency f,bool indexIsInterpolated,const DayCounter & dayCounter,const Date & d1,const Date & d2)501     Time inflationYearFraction(Frequency f, bool indexIsInterpolated,
502                                const DayCounter &dayCounter,
503                                const Date &d1, const Date &d2) {
504 
505         Time t=0;
506         if (indexIsInterpolated) {
507             // N.B. we do not use linear interpolation between flat
508             // fixing forecasts for forecasts.  This avoids awkwardnesses
509             // when bootstrapping the inflation curve.
510             t = dayCounter.yearFraction(d1, d2);
511         } else {
512             // I.e. fixing is constant for the whole inflation period.
513             // Use the value for half way along the period.
514             // But the inflation time is the time between period starts
515             std::pair<Date,Date> limD1 = inflationPeriod(d1, f);
516             std::pair<Date,Date> limD2 = inflationPeriod(d2, f);
517             t = dayCounter.yearFraction(limD1.first, limD2.first);
518         }
519 
520         return t;
521     }
522 
523 
524 }
525