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