com.opengamma.strata.measure.index.IborFutureTradeCalculationFunction Maven / Gradle / Ivy
/*
* Copyright (C) 2016 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.strata.measure.index;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.opengamma.strata.basics.ReferenceData;
import com.opengamma.strata.basics.Resolvable;
import com.opengamma.strata.basics.currency.Currency;
import com.opengamma.strata.basics.index.IborIndex;
import com.opengamma.strata.calc.Measure;
import com.opengamma.strata.calc.runner.CalculationFunction;
import com.opengamma.strata.calc.runner.CalculationParameters;
import com.opengamma.strata.calc.runner.FunctionRequirements;
import com.opengamma.strata.collect.ArgChecker;
import com.opengamma.strata.collect.result.FailureReason;
import com.opengamma.strata.collect.result.Result;
import com.opengamma.strata.data.FieldName;
import com.opengamma.strata.data.MarketDataId;
import com.opengamma.strata.data.scenario.ScenarioMarketData;
import com.opengamma.strata.market.observable.QuoteId;
import com.opengamma.strata.measure.Measures;
import com.opengamma.strata.measure.rate.RatesMarketDataLookup;
import com.opengamma.strata.measure.rate.RatesScenarioMarketData;
import com.opengamma.strata.product.SecuritizedProductPortfolioItem;
import com.opengamma.strata.product.index.IborFuture;
import com.opengamma.strata.product.index.IborFuturePosition;
import com.opengamma.strata.product.index.IborFutureTrade;
import com.opengamma.strata.product.index.ResolvedIborFutureTrade;
/**
* Perform calculations on a single {@code IborFutureTrade} or {@code IborFuturePosition}
* for each of a set of scenarios.
*
* This uses the standard discounting calculation method.
* An instance of {@link RatesMarketDataLookup} must be specified.
* The supported built-in measures are:
*
* - {@linkplain Measures#PRESENT_VALUE Present value}
*
- {@linkplain Measures#PV01_CALIBRATED_SUM PV01 calibrated sum}
*
- {@linkplain Measures#PV01_CALIBRATED_BUCKETED PV01 calibrated bucketed}
*
- {@linkplain Measures#PV01_MARKET_QUOTE_SUM PV01 market quote sum}
*
- {@linkplain Measures#PV01_MARKET_QUOTE_BUCKETED PV01 market quote bucketed}
*
- {@linkplain Measures#UNIT_PRICE Unit price}
*
- {@linkplain Measures#PAR_SPREAD Par spread}
*
- {@linkplain Measures#RESOLVED_TARGET Resolved trade}
*
*
* Price
* The price of an Ibor future is based on the interest rate of the underlying index.
* It is defined as {@code (100 - percentRate)}.
*
* Strata uses decimal prices for Ibor futures in the trade model, pricers and market data.
* The decimal price is based on the decimal rate equivalent to the percentage.
* For example, a price of 99.32 implies an interest rate of 0.68% which is represented in Strata by 0.9932.
*
* @param the trade or position type
*/
public class IborFutureTradeCalculationFunction & Resolvable>
implements CalculationFunction {
/**
* The trade instance
*/
public static final IborFutureTradeCalculationFunction TRADE =
new IborFutureTradeCalculationFunction<>(IborFutureTrade.class);
/**
* The position instance
*/
public static final IborFutureTradeCalculationFunction POSITION =
new IborFutureTradeCalculationFunction<>(IborFuturePosition.class);
/**
* The calculations by measure.
*/
private static final ImmutableMap CALCULATORS =
ImmutableMap.builder()
.put(Measures.PRESENT_VALUE, IborFutureMeasureCalculations.DEFAULT::presentValue)
.put(Measures.PV01_CALIBRATED_SUM, IborFutureMeasureCalculations.DEFAULT::pv01CalibratedSum)
.put(Measures.PV01_CALIBRATED_BUCKETED, IborFutureMeasureCalculations.DEFAULT::pv01CalibratedBucketed)
.put(Measures.PV01_MARKET_QUOTE_SUM, IborFutureMeasureCalculations.DEFAULT::pv01MarketQuoteSum)
.put(Measures.PV01_MARKET_QUOTE_BUCKETED, IborFutureMeasureCalculations.DEFAULT::pv01MarketQuoteBucketed)
.put(Measures.UNIT_PRICE, IborFutureMeasureCalculations.DEFAULT::unitPrice)
.put(Measures.PAR_SPREAD, IborFutureMeasureCalculations.DEFAULT::parSpread)
.put(Measures.RESOLVED_TARGET, (rt, smd) -> rt)
.build();
private static final ImmutableSet MEASURES = CALCULATORS.keySet();
/**
* The trade or position type.
*/
private final Class targetType;
/**
* Creates an instance.
*
* @param targetType the trade or position type
*/
private IborFutureTradeCalculationFunction(Class targetType) {
this.targetType = ArgChecker.notNull(targetType, "targetType");
}
//-------------------------------------------------------------------------
@Override
public Class targetType() {
return targetType;
}
@Override
public Set supportedMeasures() {
return MEASURES;
}
@Override
public Optional identifier(T target) {
return target.getInfo().getId().map(id -> id.toString());
}
@Override
public Currency naturalCurrency(T target, ReferenceData refData) {
return target.getCurrency();
}
//-------------------------------------------------------------------------
@Override
public FunctionRequirements requirements(
T target,
Set measures,
CalculationParameters parameters,
ReferenceData refData) {
// extract data from product
IborFuture product = target.getProduct();
QuoteId quoteId = QuoteId.of(product.getSecurityId().getStandardId(), FieldName.SETTLEMENT_PRICE);
Currency currency = product.getCurrency();
IborIndex index = product.getIndex();
// use lookup to build requirements
RatesMarketDataLookup ratesLookup = parameters.getParameter(RatesMarketDataLookup.class);
FunctionRequirements ratesReqs = ratesLookup.requirements(currency, index);
ImmutableSet> valueReqs = ImmutableSet.>builder()
.add(quoteId)
.addAll(ratesReqs.getValueRequirements())
.build();
return ratesReqs.toBuilder().valueRequirements(valueReqs).build();
}
//-------------------------------------------------------------------------
@Override
public Map> calculate(
T target,
Set measures,
CalculationParameters parameters,
ScenarioMarketData scenarioMarketData,
ReferenceData refData) {
// resolve the trade once for all measures and all scenarios
ResolvedIborFutureTrade resolved = target.resolve(refData);
// use lookup to query market data
RatesMarketDataLookup ratesLookup = parameters.getParameter(RatesMarketDataLookup.class);
RatesScenarioMarketData marketData = ratesLookup.marketDataView(scenarioMarketData);
// loop around measures, calculating all scenarios for one measure
Map> results = new HashMap<>();
for (Measure measure : measures) {
results.put(measure, calculate(measure, resolved, marketData));
}
return results;
}
// calculate one measure
private Result calculate(
Measure measure,
ResolvedIborFutureTrade resolved,
RatesScenarioMarketData marketData) {
SingleMeasureCalculation calculator = CALCULATORS.get(measure);
if (calculator == null) {
return Result.failure(FailureReason.UNSUPPORTED, "Unsupported measure for IborFuture: {}", measure);
}
return Result.of(() -> calculator.calculate(resolved, marketData));
}
//-------------------------------------------------------------------------
@FunctionalInterface
interface SingleMeasureCalculation {
public abstract Object calculate(
ResolvedIborFutureTrade resolved,
RatesScenarioMarketData marketData);
}
}