QuantExt::ZeroInflation Namespace Reference

Functions
QuantLib::Date	lastAvailableFixing (const QuantLib::ZeroInflationIndex &index, const QuantLib::Date &asof)
	Check if today - availabilityLag is already known, otherwise return the fixingDate of the previous fixing. More...
QuantLib::Rate	cpiFixing (const QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > &index, const QuantLib::Date &maturity, const QuantLib::Period &obsLag, bool interpolated)
	Computes a CPI fixing giving an zeroIndex, with interpolation if needed. More...
QuantLib::Date	curveBaseDate (const bool baseDateLastKnownFixing, const QuantLib::Date &refDate, const QuantLib::Period obsLagCurve, const QuantLib::Frequency curveFreq, const QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > &index)
	derives the zero inflation curve base date based on the useLastKnownFixing rule More...
QuantLib::Date	fixingDate (const QuantLib::Date &d, const QuantLib::Period obsLag, const QuantLib::Frequency freq, bool interpolated)
QuantLib::Rate	guessCurveBaseRate (const bool baseDateLastKnownFixing, const QuantLib::Date &swapStart, const QuantLib::Date &asof, const QuantLib::Period &swapTenor, const QuantLib::DayCounter &swapZCLegDayCounter, const QuantLib::Period &swapObsLag, const QuantLib::Rate zeroCouponRate, const QuantLib::Period &curveObsLag, const QuantLib::DayCounter &curveDayCounter, const QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > &index, const bool interpolated, const QuantLib::ext::shared_ptr< QuantLib::Seasonality > &seasonality)
bool	isCPIVolSurfaceLogNormal (const QuantLib::ext::shared_ptr< QuantLib::CPIVolatilitySurface > &surface)

Function Documentation

lastAvailableFixing()

QuantLib::Date lastAvailableFixing	(	const QuantLib::ZeroInflationIndex &	index,
		const QuantLib::Date &	asof
	)

Check if today - availabilityLag is already known, otherwise return the fixingDate of the previous fixing.

Definition at line 156 of file inflation.cpp.

                                                                                                    {
    Date availbilityLagFixingDate = inflationPeriod(asof - index.availabilityLag(), index.frequency()).first;
    if (index.hasHistoricalFixing(availbilityLagFixingDate)) {
        return availbilityLagFixingDate;
    } else {
        // The fixing for the inflation period before the availability lag should be there
        return inflationPeriod(availbilityLagFixingDate - 1 * QuantLib::Days, index.frequency()).first;
    }
}

Here is the caller graph for this function:

cpiFixing()

QuantLib::Rate cpiFixing	(	const QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > &	index,
		const QuantLib::Date &	maturity,
		const QuantLib::Period &	obsLag,
		bool	interpolated
	)

Computes a CPI fixing giving an zeroIndex, with interpolation if needed.

Definition at line 166 of file inflation.cpp.

                                                                          {
    QuantLib::CPI::InterpolationType interpolation = interpolated ? QuantLib::CPI::Linear : QuantLib::CPI::Flat;
    return QuantLib::CPI::laggedFixing(index, maturity, obsLag, interpolation);
}

Here is the caller graph for this function:

curveBaseDate()

QuantLib::Date curveBaseDate	(	const bool	baseDateLastKnownFixing,
		const QuantLib::Date &	refDate,
		const QuantLib::Period	obsLagCurve,
		const QuantLib::Frequency	curveFreq,
		const QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > &	index
	)

derives the zero inflation curve base date based on the useLastKnownFixing rule

Definition at line 172 of file inflation.cpp.

                                                                                             {
    if (baseDateLastKnownFixing) {
        QL_REQUIRE(index, "can not compute curve base date based on the last known index fixing if no index provided");
        return lastAvailableFixing(*index, refDate);
    } else {
        return QuantLib::inflationPeriod(refDate - obsLagCurve, curveFreq).first;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

fixingDate()

QuantLib::Date fixingDate	(	const QuantLib::Date &	d,
		const QuantLib::Period	obsLag,
		const QuantLib::Frequency	,
		bool	interpolated
	)

computes the fixingDate for ZC CPI Swap following the rule for an interpolated index it is d - obsLag but for an interpolated index the fixing date is per definition on the start of the inflation period in which d - obsLag falls

Definition at line 183 of file inflation.cpp.

                                             {
    Date obsDate = d - obsLag;
    if (!interpolated)
        obsDate = QuantLib::inflationPeriod(obsDate, freq).first;
    return obsDate;
}

Here is the caller graph for this function:

guessCurveBaseRate()

QuantLib::Rate guessCurveBaseRate	(	const bool	baseDateLastKnownFixing,
		const QuantLib::Date &	swapStart,
		const QuantLib::Date &	asof,
		const QuantLib::Period &	swapTenor,
		const QuantLib::DayCounter &	swapZCLegDayCounter,
		const QuantLib::Period &	swapObsLag,
		const QuantLib::Rate	zeroCouponRate,
		const QuantLib::Period &	curveObsLag,
		const QuantLib::DayCounter &	curveDayCounter,
		const QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > &	index,
		const bool	interpolated,
		const QuantLib::ext::shared_ptr< QuantLib::Seasonality > &	seasonality = nullptr
	)

Computes the base rate for curve construction so that zero inflation rate is constant up to the first pillar Accounts for the acctual accrued inflation between the ZCIIS base date and the curve base date (e.g. last published fixing date) If curve base date and ZCIIS are the same, then the base rate is the ZCIIS rate

Definition at line 191 of file inflation.cpp.

                                                                                                 {
    QuantLib::ext::shared_ptr<QuantLib::MultiplicativePriceSeasonality> multiplicativeSeasonality =
        seasonality ? QuantLib::ext::dynamic_pointer_cast<QuantLib::MultiplicativePriceSeasonality>(seasonality) : nullptr;  
    
    QL_REQUIRE(seasonality ==  nullptr || multiplicativeSeasonality,
               "Only multiplicative seasonality supported at the moment");
 
    Date swapBaseDate = ZeroInflation::fixingDate(swapStart, swapObsLag, index->frequency(), interpolated);
 
    Date curveBaseDate =
        ZeroInflation::curveBaseDate(baseDateLastKnownFixing, asof, curveObsLag, index->frequency(), index);
 
    // If the baseDate in Curve is today - obsLag then the quoted zeroRate should be used
    if (!baseDateLastKnownFixing && swapBaseDate == curveBaseDate)
        return zeroCouponRate;
    
    QL_REQUIRE(index, "can not compute base cpi of the zero coupon swap");
    // Otherwise we need to take into account the accrued inflation between rate helper base date and curve base date
    // Check if historical fixings available
    try {
        checkIfFixingAvailable(swapStart, swapObsLag, interpolated, *index);
    } catch (const std::exception& e) {
        QL_FAIL("Can not estimate the curve base date, got " << e.what());
    }
 
    Date swapMaturity = swapStart + swapTenor;
    Date swapObservationDate = ZeroInflation::fixingDate(swapMaturity, swapObsLag, index->frequency(), interpolated);
 
    // TODO check historical fixings available
    Rate instrumentBaseCPI = cpiFixing(index, swapStart, swapObsLag, interpolated);
    Time timeFromSwapBase =
        inflationYearFraction(index->frequency(), interpolated, swapZCLegDayCounter, swapBaseDate, swapObservationDate);
 
    auto fwdCPI = instrumentBaseCPI * std::pow(1 + zeroCouponRate, timeFromSwapBase);
 
    double curveBaseFixing = index->fixing(curveBaseDate);
 
    if (!interpolated) {
        Time timeFromCurveBase = inflationYearFraction(index->frequency(), interpolated, curveDayCounter, curveBaseDate,
                                                       swapObservationDate);
        double rateWithSeasonality = std::pow(fwdCPI / curveBaseFixing, 1.0 / timeFromCurveBase) - 1.0;
        
        if (multiplicativeSeasonality) {
            double factorAt = multiplicativeSeasonality->seasonalityFactor(swapObservationDate);
            double factorBase = multiplicativeSeasonality->seasonalityFactor(curveBaseDate);
            double seasonalityFactor = std::pow(factorAt / factorBase, 1.0 / timeFromCurveBase);
            return (rateWithSeasonality + 1) / seasonalityFactor - 1;
        } else {
            return rateWithSeasonality;
        }
    } else {
        // Compute the interpolated  fixing of the ZCIIS at maturity
        auto fixingPeriod = inflationPeriod(swapObservationDate, index->frequency());
        auto paymentPeriod = inflationPeriod(swapMaturity, index->frequency());
        // Fixing times from curve base date
        Time timeToFixing1 =
            inflationYearFraction(index->frequency(), false, curveDayCounter, curveBaseDate, fixingPeriod.first);
        Time timeToFixing2 = inflationYearFraction(index->frequency(), false, curveDayCounter, curveBaseDate,
                                        fixingPeriod.second + 1 * Days);
 
        // Time interpolation
        Time timeToPayment =
            inflationYearFraction(index->frequency(), true, curveDayCounter, curveBaseDate, swapMaturity);
        Time timeToStartPaymentPeriod =
            inflationYearFraction(index->frequency(), false, curveDayCounter, curveBaseDate, paymentPeriod.first);
        Time timeToEndPaymenetPeriod = inflationYearFraction(index->frequency(), false, curveDayCounter, curveBaseDate,
                                        paymentPeriod.second + 1 * Days);
        Time interpolationFactor =
            (timeToPayment - timeToStartPaymentPeriod) / (timeToEndPaymenetPeriod - timeToStartPaymentPeriod);
 
        // Root search for a constant rate that the interpolation of both cpi matches the forward cpi
        Real target = fwdCPI / curveBaseFixing;
 
        Real seasonalityFactor1 = 1.0;
        Real seasonalityFactor2 = 1.0;
 
        if (multiplicativeSeasonality) {
            double factorAt1 = multiplicativeSeasonality->seasonalityFactor(fixingPeriod.first);
            double factorAt2 = multiplicativeSeasonality->seasonalityFactor(fixingPeriod.second + 1 * Days);
            double factorBase = multiplicativeSeasonality->seasonalityFactor(curveBaseDate);
            seasonalityFactor1 = factorAt1 / factorBase;
            seasonalityFactor2 = factorAt2 / factorBase;
        }
 
 
        std::function<double(double)> objectiveFunction = [&timeToFixing1, &timeToFixing2, &interpolationFactor,
                                                           &target, &seasonalityFactor1, &seasonalityFactor2](Rate r) {
            return target - (std::pow(1 + r, timeToFixing1) * seasonalityFactor1  +
                             (std::pow(1 + r, timeToFixing2) * seasonalityFactor2 -
                              std::pow(1 + r, timeToFixing1) * seasonalityFactor1) *
                                 interpolationFactor);
        };
 
        Rate guess = std::pow(fwdCPI / curveBaseFixing, 1.0 / timeToFixing2) - 1.0;
        Rate r = guess;
        try {
            QuantLib::Brent solver;
            r = solver.solve(objectiveFunction, 1e-8, guess, -0.1, 0.2);
        } catch (...) {
            r = guess;
        }
        return r;
    }
}

Here is the call graph for this function:

isCPIVolSurfaceLogNormal()

bool isCPIVolSurfaceLogNormal

(

const QuantLib::ext::shared_ptr< QuantLib::CPIVolatilitySurface > &

surface

)

checks if the vols are normal or lognormal if the volsurface is not derived from QuantExt::CPIVolatilitySurface we default to lognormal vols

Definition at line 302 of file inflation.cpp.

                                                                                                  {
    if (auto qvs = QuantLib::ext::dynamic_pointer_cast<QuantExt::CPIVolatilitySurface>(surface)) {
        return qvs->isLogNormal();
    } else {
        // QuantLib::CPIVolatilitySurface doesn't support volType so assume it's log normal
        return true;
    }
}