/// <summary>
/// Creates an instance.
/// </summary>
/// <param name="trades"> the trades </param>
/// <param name="measures"> the calibration measures </param>
/// <param name="providerGenerator"> the provider generator, used to create child providers </param>
/// <param name="curveOrder"> the curve order </param>
public CalibrationDerivative(IList <ResolvedTrade> trades, CalibrationMeasures measures, RatesProviderGenerator providerGenerator, IList <CurveParameterSize> curveOrder)
{
this.measures = measures;
this.trades = trades;
this.providerGenerator = providerGenerator;
this.curveOrder = curveOrder;
}
//-------------------------------------------------------------------------
// calibrates a single group
private DoubleArray calibrateGroup(RatesProviderGenerator providerGenerator, ImmutableList <ResolvedTrade> trades, ImmutableList <double> initialGuesses, ImmutableList <CurveParameterSize> curveOrder)
{
// setup for calibration
System.Func <DoubleArray, DoubleArray> valueCalculator = new CalibrationValue(trades, measures, providerGenerator);
System.Func <DoubleArray, DoubleMatrix> derivativeCalculator = new CalibrationDerivative(trades, measures, providerGenerator, curveOrder);
// calibrate
DoubleArray initGuessMatrix = DoubleArray.copyOf(initialGuesses);
return(rootFinder.findRoot(valueCalculator, derivativeCalculator, initGuessMatrix));
}
/// <summary>
/// Calibrates a list of curve groups, each containing one or more curves.
/// <para>
/// The calibration is defined using a list of <seealso cref="RatesCurveGroupDefinition"/>.
/// Observable market data and existing known data are also needed to complete the calibration.
/// </para>
/// <para>
/// A curve must only exist in one group.
///
/// </para>
/// </summary>
/// <param name="allGroupsDefn"> the curve group definitions </param>
/// <param name="knownData"> the starting data for the calibration </param>
/// <param name="marketData"> the market data required to build a trade for the instrument </param>
/// <param name="refData"> the reference data, used to resolve the trades </param>
/// <returns> the rates provider resulting from the calibration </returns>
public ImmutableRatesProvider calibrate(IList <RatesCurveGroupDefinition> allGroupsDefn, ImmutableRatesProvider knownData, MarketData marketData, ReferenceData refData)
{
// this method effectively takes one CurveGroupDefinition
// the list is a split of the definition, not multiple independent definitions
if (!knownData.ValuationDate.Equals(marketData.ValuationDate))
{
throw new System.ArgumentException(Messages.format("Valuation dates do not match: {} and {}", knownData.ValuationDate, marketData.ValuationDate));
}
// perform calibration one group at a time, building up the result by mutating these variables
ImmutableRatesProvider providerCombined = knownData;
ImmutableList <CurveParameterSize> orderPrev = ImmutableList.of();
ImmutableMap <CurveName, JacobianCalibrationMatrix> jacobians = ImmutableMap.of();
foreach (RatesCurveGroupDefinition groupDefn in allGroupsDefn)
{
if (groupDefn.Entries.Empty)
{
continue;
}
RatesCurveGroupDefinition groupDefnBound = groupDefn.bindTimeSeries(knownData.ValuationDate, knownData.TimeSeries);
// combine all data in the group into flat lists
ImmutableList <ResolvedTrade> trades = groupDefnBound.resolvedTrades(marketData, refData);
ImmutableList <double> initialGuesses = groupDefnBound.initialGuesses(marketData);
ImmutableList <CurveParameterSize> orderGroup = toOrder(groupDefnBound);
ImmutableList <CurveParameterSize> orderPrevAndGroup = ImmutableList.builder <CurveParameterSize>().addAll(orderPrev).addAll(orderGroup).build();
// calibrate
RatesProviderGenerator providerGenerator = ImmutableRatesProviderGenerator.of(providerCombined, groupDefnBound, refData);
DoubleArray calibratedGroupParams = calibrateGroup(providerGenerator, trades, initialGuesses, orderGroup);
ImmutableRatesProvider calibratedProvider = providerGenerator.generate(calibratedGroupParams);
// use calibration to build Jacobian matrices
if (groupDefnBound.ComputeJacobian)
{
jacobians = updateJacobiansForGroup(calibratedProvider, trades, orderGroup, orderPrev, orderPrevAndGroup, jacobians);
}
ImmutableMap <CurveName, DoubleArray> sensitivityToMarketQuote = ImmutableMap.of();
if (groupDefnBound.ComputePvSensitivityToMarketQuote)
{
ImmutableRatesProvider providerWithJacobian = providerGenerator.generate(calibratedGroupParams, jacobians);
sensitivityToMarketQuote = sensitivityToMarketQuoteForGroup(providerWithJacobian, trades, orderGroup);
}
orderPrev = orderPrevAndGroup;
// use Jacobians to build output curves
providerCombined = providerGenerator.generate(calibratedGroupParams, jacobians, sensitivityToMarketQuote);
}
// return the calibrated provider
return(providerCombined);
}
/// <summary>
/// Creates an instance.
/// </summary>
/// <param name="trades"> the trades </param>
/// <param name="measures"> the calibration measures </param>
/// <param name="providerGenerator"> the provider generator, used to create child providers </param>
internal CalibrationValue(IList <ResolvedTrade> trades, CalibrationMeasures measures, RatesProviderGenerator providerGenerator)
{
this.trades = trades;
this.measures = measures;
this.providerGenerator = providerGenerator;
}
