public BasicFixedLeg(IsdaCompliantDiscountCurveCalibrator outerInstance, LocalDate curveSpotDate, LocalDate maturityDate, Period swapInterval, DayCount swapDCC, DayCount curveDcc, BusinessDayAdjustment busAdj, ReferenceData refData)
{
this.outerInstance = outerInstance;
IList <LocalDate> list = new List <LocalDate>();
LocalDate tDate = maturityDate;
int step = 1;
while (tDate.isAfter(curveSpotDate))
{
list.Add(tDate);
tDate = maturityDate.minus(swapInterval.multipliedBy(step++));
}
// remove spotDate from list, if it ends up there
list.Remove(curveSpotDate);
nPayment = list.Count;
swapPaymentTime = new double[nPayment];
yearFraction = new double[nPayment];
LocalDate prev = curveSpotDate;
int j = nPayment - 1;
for (int i = 0; i < nPayment; i++, j--)
{
LocalDate current = list[j];
LocalDate adjCurr = busAdj.adjust(current, refData);
yearFraction[i] = swapDCC.relativeYearFraction(prev, adjCurr);
swapPaymentTime[i] = curveDcc.relativeYearFraction(curveSpotDate, adjCurr); // Payment times always good business days
prev = adjCurr;
}
}
static SwaptionCubeData()
{
EXPIRIES.Add(Period.ofMonths(1));
EXPIRIES.Add(Period.ofMonths(3));
EXPIRIES.Add(Period.ofMonths(6));
EXPIRIES.Add(Period.ofYears(1));
EXPIRIES.Add(Period.ofYears(2));
EXPIRIES.Add(Period.ofYears(5));
TENORS.Add(Tenor.TENOR_1Y);
TENORS.Add(Tenor.TENOR_2Y);
TENORS.Add(Tenor.TENOR_5Y);
EXPIRIES_SIMPLE.Add(Period.ofMonths(1));
EXPIRIES_SIMPLE.Add(Period.ofMonths(6));
EXPIRIES_SIMPLE.Add(Period.ofYears(1));
TENORS_SIMPLE.Add(Tenor.TENOR_1Y);
TENORS_SIMPLE.Add(Tenor.TENOR_2Y);
EXPIRIES_SIMPLE_2.Add(Period.ofMonths(1));
EXPIRIES_SIMPLE_2.Add(Period.ofMonths(3));
EXPIRIES_SIMPLE_2.Add(Period.ofMonths(6));
EXPIRIES_SIMPLE_2.Add(Period.ofYears(1));
for (int i = 0; i < EXPIRIES_SIMPLE_2.Count; i++)
{
BusinessDayAdjustment bda = EUR_FIXED_1Y_EURIBOR_6M.FloatingLeg.StartDateBusinessDayAdjustment;
EXPIRIES_SIMPLE_2_TIME[2 * i] = DAY_COUNT.relativeYearFraction(DATA_DATE, bda.adjust(DATA_DATE.plus(EXPIRIES_SIMPLE_2[i]), REF_DATA));
EXPIRIES_SIMPLE_2_TIME[2 * i + 1] = EXPIRIES_SIMPLE_2_TIME[2 * i];
}
}
static CalibrationDiscountingSmithWilsonTest()
{
IBOR_INDICES.Add(GBP_LIBOR_6M);
DSC_NAMES[CURVE_NAME] = GBP;
IDX_NAMES[CURVE_NAME] = IBOR_INDICES;
for (int i = 0; i < FWD6_NB_NODES; i++)
{
ALL_NODES[i] = FixedIborSwapCurveNode.of(FixedIborSwapTemplate.of(Period.ZERO, Tenor.of(FWD6_IRS_TENORS[i]), GBP_FIXED_6M_LIBOR_6M), QuoteId.of(StandardId.of(SCHEME, FWD6_ID_VALUE[i])));
NODE_TIMES[i] = CURVE_DC.relativeYearFraction(VAL_DATE, ALL_NODES[i].date(VAL_DATE, REF_DATA));
}
ImmutableMarketDataBuilder builder = ImmutableMarketData.builder(VAL_DATE);
for (int i = 0; i < FWD6_NB_NODES; i++)
{
builder.addValue(QuoteId.of(StandardId.of(SCHEME, FWD6_ID_VALUE[i])), FWD6_MARKET_QUOTES[i]);
}
ALL_QUOTES = builder.build();
IList <CurveNode[]> groupNodes = new List <CurveNode[]>();
groupNodes.Add(ALL_NODES);
CURVES_NODES.Add(groupNodes);
IList <CurveMetadata> groupMetadata = new List <CurveMetadata>();
groupMetadata.Add(DefaultCurveMetadata.builder().curveName(CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.DISCOUNT_FACTOR).dayCount(CURVE_DC).build());
CURVES_METADATA.Add(groupMetadata);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the time to expiry for the valuation date time.
/// </summary>
/// <param name="valuationDateTime"> the valuation date time </param>
/// <param name="dayCount"> the day count </param>
/// <param name="refData"> the reference data </param>
/// <returns> the time to expiry </returns>
public double timeToExpiry(ZonedDateTime valuationDateTime, DayCount dayCount, ReferenceData refData)
{
LocalDate valuationDate = valuationDateTime.toLocalDate();
LocalDate spotDate = spotDateOffset.adjust(valuationDate, refData);
LocalDate deliveryDate = businessDayAdjustment.adjust(spotDate.plus(tenor), refData);
LocalDate expiryDate = expiryDateOffset_Renamed.adjust(deliveryDate, refData);
return(dayCount.relativeYearFraction(valuationDate, expiryDate));
}
private IList <ZeroRateSensitivity> dscSensitivityFD(RatesProvider provider, NotionalExchange @event, double eps)
{
Currency currency = @event.Currency;
LocalDate paymentDate = @event.PaymentDate;
double discountFactor = provider.discountFactor(currency, paymentDate);
double paymentTime = DAY_COUNT.relativeYearFraction(VAL_DATE, paymentDate);
RatesProvider provUp = mock(typeof(RatesProvider));
RatesProvider provDw = mock(typeof(RatesProvider));
when(provUp.ValuationDate).thenReturn(VAL_DATE);
when(provUp.discountFactor(currency, paymentDate)).thenReturn(discountFactor * Math.Exp(-eps * paymentTime));
when(provDw.ValuationDate).thenReturn(VAL_DATE);
when(provDw.discountFactor(currency, paymentDate)).thenReturn(discountFactor * Math.Exp(eps * paymentTime));
DiscountingNotionalExchangePricer pricer = DiscountingNotionalExchangePricer.DEFAULT;
double pvUp = pricer.presentValue(@event, provUp);
double pvDw = pricer.presentValue(@event, provDw);
double res = 0.5 * (pvUp - pvDw) / eps;
IList <ZeroRateSensitivity> zeroRateSensi = new List <ZeroRateSensitivity>();
zeroRateSensi.Add(ZeroRateSensitivity.of(currency, paymentTime, res));
return(zeroRateSensi);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calibrates the ISDA compliant discount curve to the market data.
/// <para>
/// This creates the single discount curve for a specified currency.
/// The curve nodes in {@code IsdaCreditCurveDefinition} should be term deposit or fixed-for-Ibor swap,
/// and the number of nodes should be greater than 1.
///
/// </para>
/// </summary>
/// <param name="curveDefinition"> the curve definition </param>
/// <param name="marketData"> the market data </param>
/// <param name="refData"> the reference data </param>
/// <returns> the ISDA compliant discount curve </returns>
public IsdaCreditDiscountFactors calibrate(IsdaCreditCurveDefinition curveDefinition, MarketData marketData, ReferenceData refData)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<? extends com.opengamma.strata.market.curve.IsdaCreditCurveNode> curveNodes = curveDefinition.getCurveNodes();
IList <IsdaCreditCurveNode> curveNodes = curveDefinition.CurveNodes;
int nNodes = curveNodes.Count;
ArgChecker.isTrue(nNodes > 1, "the number of curve nodes must be greater than 1");
LocalDate curveSnapDate = marketData.ValuationDate;
LocalDate curveValuationDate = curveDefinition.CurveValuationDate;
DayCount curveDayCount = curveDefinition.DayCount;
BasicFixedLeg[] swapLeg = new BasicFixedLeg[nNodes];
double[] termDepositYearFraction = new double[nNodes];
double[] curveNodeTime = new double[nNodes];
double[] rates = new double[nNodes];
ImmutableList.Builder <ParameterMetadata> paramMetadata = ImmutableList.builder();
int nTermDeposit = 0;
LocalDate curveSpotDate = null;
for (int i = 0; i < nNodes; i++)
{
LocalDate cvDateTmp;
IsdaCreditCurveNode node = curveNodes[i];
rates[i] = marketData.getValue(node.ObservableId);
LocalDate adjMatDate = node.date(curveSnapDate, refData);
paramMetadata.add(node.metadata(adjMatDate));
if (node is DepositIsdaCreditCurveNode)
{
DepositIsdaCreditCurveNode termDeposit = (DepositIsdaCreditCurveNode)node;
cvDateTmp = termDeposit.SpotDateOffset.adjust(curveSnapDate, refData);
curveNodeTime[i] = curveDayCount.relativeYearFraction(cvDateTmp, adjMatDate);
termDepositYearFraction[i] = termDeposit.DayCount.relativeYearFraction(cvDateTmp, adjMatDate);
ArgChecker.isTrue(nTermDeposit == i, "TermDepositCurveNode should not be after FixedIborSwapCurveNode");
++nTermDeposit;
}
else if (node is SwapIsdaCreditCurveNode)
{
SwapIsdaCreditCurveNode swap = (SwapIsdaCreditCurveNode)node;
cvDateTmp = swap.SpotDateOffset.adjust(curveSnapDate, refData);
curveNodeTime[i] = curveDayCount.relativeYearFraction(cvDateTmp, adjMatDate);
BusinessDayAdjustment busAdj = swap.BusinessDayAdjustment;
swapLeg[i] = new BasicFixedLeg(this, cvDateTmp, cvDateTmp.plus(swap.Tenor), swap.PaymentFrequency.Period, swap.DayCount, curveDayCount, busAdj, refData);
}
else
{
throw new System.ArgumentException("unsupported cuve node type");
}
if (i > 0)
{
ArgChecker.isTrue(curveNodeTime[i] - curveNodeTime[i - 1] > 0, "curve nodes should be ascending in terms of tenor");
ArgChecker.isTrue(cvDateTmp.Equals(curveSpotDate), "spot lag should be common for all of the curve nodes");
}
else
{
ArgChecker.isTrue(curveNodeTime[i] >= 0d, "the first node should be after curve spot date");
curveSpotDate = cvDateTmp;
}
}
ImmutableList <ParameterMetadata> parameterMetadata = paramMetadata.build();
double[] ratesMod = Arrays.copyOf(rates, nNodes);
for (int i = 0; i < nTermDeposit; ++i)
{
double dfInv = 1d + ratesMod[i] * termDepositYearFraction[i];
ratesMod[i] = Math.Log(dfInv) / curveNodeTime[i];
}
InterpolatedNodalCurve curve = curveDefinition.curve(DoubleArray.ofUnsafe(curveNodeTime), DoubleArray.ofUnsafe(ratesMod));
for (int i = nTermDeposit; i < nNodes; ++i)
{
curve = fitSwap(i, swapLeg[i], curve, rates[i]);
}
Currency currency = curveDefinition.Currency;
DoubleMatrix sensi = quoteValueSensitivity(nTermDeposit, termDepositYearFraction, swapLeg, ratesMod, curve, curveDefinition.ComputeJacobian);
if (curveValuationDate.isEqual(curveSpotDate))
{
if (curveDefinition.ComputeJacobian)
{
JacobianCalibrationMatrix jacobian = JacobianCalibrationMatrix.of(ImmutableList.of(CurveParameterSize.of(curveDefinition.Name, nNodes)), MATRIX_ALGEBRA.getInverse(sensi));
NodalCurve curveWithParamMetadata = curve.withMetadata(curve.Metadata.withInfo(CurveInfoType.JACOBIAN, jacobian).withParameterMetadata(parameterMetadata));
return(IsdaCreditDiscountFactors.of(currency, curveValuationDate, curveWithParamMetadata));
}
NodalCurve curveWithParamMetadata = curve.withMetadata(curve.Metadata.withParameterMetadata(parameterMetadata));
return(IsdaCreditDiscountFactors.of(currency, curveValuationDate, curveWithParamMetadata));
}
double offset = curveDayCount.relativeYearFraction(curveSpotDate, curveValuationDate);
return(IsdaCreditDiscountFactors.of(currency, curveValuationDate, withShift(curve, parameterMetadata, sensi, curveDefinition.ComputeJacobian, offset)));
}
