/// <summary>
/// Gets the polynomials and derivative.
/// </summary>
/// <param name="n"> the n value </param>
/// <param name="alpha"> the alpha value </param>
/// <returns> the result </returns>
public virtual Pair <DoubleFunction1D, DoubleFunction1D>[] getPolynomialsAndFirstDerivative(int n, double alpha)
{
ArgChecker.isTrue(n >= 0);
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") com.opengamma.strata.collect.tuple.Pair<com.opengamma.strata.math.impl.function.DoubleFunction1D, com.opengamma.strata.math.impl.function.DoubleFunction1D>[] polynomials = new com.opengamma.strata.collect.tuple.Pair[n + 1];
Pair <DoubleFunction1D, DoubleFunction1D>[] polynomials = new Pair[n + 1];
DoubleFunction1D p, dp, p1, p2;
for (int i = 0; i <= n; i++)
{
if (i == 0)
{
polynomials[i] = Pair.of(One, Zero);
}
else if (i == 1)
{
polynomials[i] = Pair.of(F1, DF1);
}
else
{
p1 = polynomials[i - 1].First;
p2 = polynomials[i - 2].First;
p = (p1.multiply(2.0 * i + alpha - 1).subtract(p1.multiply(X)).subtract(p2.multiply((i - 1.0 + alpha))).divide(i));
dp = (p.multiply(i).subtract(p1.multiply(i + alpha))).divide(X);
polynomials[i] = Pair.of(p, dp);
}
}
return(polynomials);
}
public override Pair <DoubleFunction1D, DoubleFunction1D>[] getPolynomialsAndFirstDerivative(int n)
{
ArgChecker.isTrue(n >= 0);
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") com.opengamma.strata.collect.tuple.Pair<com.opengamma.strata.math.impl.function.DoubleFunction1D, com.opengamma.strata.math.impl.function.DoubleFunction1D>[] polynomials = new com.opengamma.strata.collect.tuple.Pair[n + 1];
Pair <DoubleFunction1D, DoubleFunction1D>[] polynomials = new Pair[n + 1];
DoubleFunction1D p, dp;
for (int i = 0; i <= n; i++)
{
if (i == 0)
{
polynomials[i] = Pair.of(One, Zero);
}
else if (i == 1)
{
polynomials[i] = Pair.of(X, One);
}
else
{
p = (polynomials[i - 1].First.multiply(X).multiply(2 * i - 1).subtract(polynomials[i - 2].First.multiply(i - 1))).multiply(1.0 / i);
dp = p.derivative();
polynomials[i] = Pair.of(p, dp);
}
}
return(polynomials);
}
/// <summary>
/// Calculates polynomials and derivative. </summary>
/// <param name="n"> the n value </param>
/// <param name="alpha"> the alpha value </param>
/// <param name="beta"> the beta value </param>
/// <returns> the result </returns>
public virtual Pair <DoubleFunction1D, DoubleFunction1D>[] getPolynomialsAndFirstDerivative(int n, double alpha, double beta)
{
ArgChecker.isTrue(n >= 0);
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") com.opengamma.strata.collect.tuple.Pair<com.opengamma.strata.math.impl.function.DoubleFunction1D, com.opengamma.strata.math.impl.function.DoubleFunction1D>[] polynomials = new com.opengamma.strata.collect.tuple.Pair[n + 1];
Pair <DoubleFunction1D, DoubleFunction1D>[] polynomials = new Pair[n + 1];
DoubleFunction1D p, dp, p1, p2;
for (int i = 0; i <= n; i++)
{
if (i == 0)
{
polynomials[i] = Pair.of(One, Zero);
}
else if (i == 1)
{
double a1 = (alpha + beta + 2) / 2;
polynomials[i] = Pair.of((DoubleFunction1D) new RealPolynomialFunction1D(new double[] { (alpha - beta) / 2, a1 }), (DoubleFunction1D) new RealPolynomialFunction1D(new double[] { a1 }));
}
else
{
int j = i - 1;
p1 = polynomials[j].First;
p2 = polynomials[j - 1].First;
DoubleFunction1D temp1 = p1.multiply(getB(alpha, beta, j));
DoubleFunction1D temp2 = p1.multiply(X).multiply(getC(alpha, beta, j));
DoubleFunction1D temp3 = p2.multiply(getD(alpha, beta, j));
p = (temp1.add(temp2).add(temp3)).divide(getA(alpha, beta, j));
dp = p.derivative();
polynomials[i] = Pair.of(p, dp);
}
}
return(polynomials);
}
//-------------------------------------------------------------------------
/// <summary>
/// Parses the year-month and variant.
/// </summary>
/// <param name="row"> the CSV row to parse </param>
/// <param name="type"> the ETD type </param>
/// <returns> the expiry year-month and variant </returns>
/// <exception cref="IllegalArgumentException"> if the row cannot be parsed </exception>
public static Pair <YearMonth, EtdVariant> parseEtdVariant(CsvRow row, EtdType type)
{
YearMonth yearMonth = LoaderUtils.parseYearMonth(row.getValue(EXPIRY_FIELD));
int week = row.findValue(EXPIRY_WEEK_FIELD).map(s => LoaderUtils.parseInteger(s)).orElse(0);
int day = row.findValue(EXPIRY_DAY_FIELD).map(s => LoaderUtils.parseInteger(s)).orElse(0);
Optional <EtdSettlementType> settleType = row.findValue(SETTLEMENT_TYPE_FIELD).map(s => parseEtdSettlementType(s));
Optional <EtdOptionType> optionType = row.findValue(EXERCISE_STYLE_FIELD).map(s => parseEtdOptionType(s));
// check valid combinations
if (!settleType.Present)
{
if (day == 0)
{
if (week == 0)
{
return(Pair.of(yearMonth, EtdVariant.ofMonthly()));
}
else
{
return(Pair.of(yearMonth, EtdVariant.ofWeekly(week)));
}
}
else
{
if (week == 0)
{
return(Pair.of(yearMonth, EtdVariant.ofDaily(day)));
}
else
{
throw new System.ArgumentException("ETD date columns conflict, cannot set both expiry day and expiry week");
}
}
}
else
{
if (day == 0)
{
throw new System.ArgumentException("ETD date columns conflict, must set expiry day for Flex " + type);
}
if (week != 0)
{
throw new System.ArgumentException("ETD date columns conflict, cannot set expiry week for Flex " + type);
}
if (type == EtdType.FUTURE)
{
return(Pair.of(yearMonth, EtdVariant.ofFlexFuture(day, settleType.get())));
}
else
{
if (!optionType.Present)
{
throw new System.ArgumentException("ETD option type not found for Flex Option");
}
return(Pair.of(yearMonth, EtdVariant.ofFlexOption(day, settleType.get(), optionType.get())));
}
}
}
public virtual void test_of_noLabel()
{
SwaptionSurfaceExpiryStrikeParameterMetadata test = SwaptionSurfaceExpiryStrikeParameterMetadata.of(TIME_TO_EXPIRY, STRIKE);
assertEquals(test.Identifier, Pair.of(TIME_TO_EXPIRY, STRIKE));
assertEquals(test.Label, Pair.of(TIME_TO_EXPIRY, STRIKE).ToString());
assertEquals(test.Strike, STRIKE);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_of_noLabel()
{
SwaptionSurfaceExpirySimpleMoneynessParameterMetadata test = SwaptionSurfaceExpirySimpleMoneynessParameterMetadata.of(TIME_TO_EXPIRY, SIMPLE_MONEYNESS);
assertEquals(test.Identifier, Pair.of(TIME_TO_EXPIRY, SIMPLE_MONEYNESS));
assertEquals(test.Label, Pair.of(TIME_TO_EXPIRY, SIMPLE_MONEYNESS).ToString());
assertEquals(test.SimpleMoneyness, SIMPLE_MONEYNESS);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_of_withStrikeType()
{
GenericVolatilitySurfacePeriodParameterMetadata test = GenericVolatilitySurfacePeriodParameterMetadata.of(TIME_TO_EXPIRY, STRIKE1);
assertEquals(test.Identifier, Pair.of(TIME_TO_EXPIRY, STRIKE1));
assertEquals(test.Label, Pair.of(TIME_TO_EXPIRY, STRIKE1.Label).ToString());
assertEquals(test.Strike, STRIKE1);
assertEquals(test.Period, TIME_TO_EXPIRY);
}
public virtual void test_of_noLabel()
{
SwaptionSurfaceExpiryTenorParameterMetadata test = SwaptionSurfaceExpiryTenorParameterMetadata.of(TIME_TO_EXPIRY, TENOR);
assertEquals(test.Identifier, Pair.of(TIME_TO_EXPIRY, TENOR));
assertEquals(test.Label, Pair.of(TIME_TO_EXPIRY, TENOR).ToString());
assertEquals(test.Tenor, TENOR);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_of_withLabel()
{
string label = "(1.5Y, 0.25)";
SwaptionSurfaceExpiryStrikeParameterMetadata test = SwaptionSurfaceExpiryStrikeParameterMetadata.of(TIME_TO_EXPIRY, STRIKE, label);
assertEquals(test.Identifier, Pair.of(TIME_TO_EXPIRY, STRIKE));
assertEquals(test.Label, label);
assertEquals(test.Strike, STRIKE);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_of_withStrikeType()
{
FxVolatilitySurfaceYearFractionParameterMetadata test = FxVolatilitySurfaceYearFractionParameterMetadata.of(TIME_TO_EXPIRY, STRIKE, CURRENCY_PAIR);
assertEquals(test.CurrencyPair, CURRENCY_PAIR);
assertEquals(test.Identifier, Pair.of(TIME_TO_EXPIRY, STRIKE));
assertEquals(test.Label, Pair.of(TIME_TO_EXPIRY, STRIKE.Label).ToString());
assertEquals(test.Strike, STRIKE);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_of_withLabel()
{
string label = "(1.5Y, 0.25)";
SwaptionSurfaceExpirySimpleMoneynessParameterMetadata test = SwaptionSurfaceExpirySimpleMoneynessParameterMetadata.of(TIME_TO_EXPIRY, SIMPLE_MONEYNESS, label);
assertEquals(test.Identifier, Pair.of(TIME_TO_EXPIRY, SIMPLE_MONEYNESS));
assertEquals(test.Label, label);
assertEquals(test.SimpleMoneyness, SIMPLE_MONEYNESS);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_of_withLabel()
{
string label = "(1.5Y, 36M)";
SwaptionSurfaceExpiryTenorParameterMetadata test = SwaptionSurfaceExpiryTenorParameterMetadata.of(TIME_TO_EXPIRY, TENOR, label);
assertEquals(test.Identifier, Pair.of(TIME_TO_EXPIRY, TENOR));
assertEquals(test.Label, label);
assertEquals(test.Tenor, TENOR);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_of_withLabel()
{
Pair <Period, Strike> pair = Pair.of(TIME_TO_EXPIRY, STRIKE2);
string label = "(2, 1.35)";
GenericVolatilitySurfacePeriodParameterMetadata test = GenericVolatilitySurfacePeriodParameterMetadata.of(TIME_TO_EXPIRY, STRIKE2, label);
assertEquals(test.Identifier, pair);
assertEquals(test.Label, label);
assertEquals(test.Strike, STRIKE2);
assertEquals(test.Period, TIME_TO_EXPIRY);
}
public virtual void test_of_withLabel()
{
Pair <double, Strike> pair = Pair.of(TIME_TO_EXPIRY, STRIKE1);
string label = "(1.5, 1.35)";
FxVolatilitySurfaceYearFractionParameterMetadata test = FxVolatilitySurfaceYearFractionParameterMetadata.of(TIME_TO_EXPIRY, STRIKE1, label, CURRENCY_PAIR);
assertEquals(test.CurrencyPair, CURRENCY_PAIR);
assertEquals(test.Identifier, pair);
assertEquals(test.Label, label);
assertEquals(test.Strike, STRIKE1);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_builder_noLabel()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.joda.beans.BeanBuilder<? extends GenericVolatilitySurfacePeriodParameterMetadata> builder = GenericVolatilitySurfacePeriodParameterMetadata.meta().builder();
BeanBuilder <GenericVolatilitySurfacePeriodParameterMetadata> builder = GenericVolatilitySurfacePeriodParameterMetadata.meta().builder();
Pair <Period, Strike> pair = Pair.of(TIME_TO_EXPIRY, STRIKE1);
builder.set(GenericVolatilitySurfacePeriodParameterMetadata.meta().period(), TIME_TO_EXPIRY);
builder.set(GenericVolatilitySurfacePeriodParameterMetadata.meta().strike(), STRIKE1);
GenericVolatilitySurfacePeriodParameterMetadata test = builder.build();
assertEquals(test.Identifier, pair);
assertEquals(test.Label, Pair.of(TIME_TO_EXPIRY, STRIKE1.Label).ToString());
assertEquals(test.Strike, STRIKE1);
assertEquals(test.Period, TIME_TO_EXPIRY);
}
public virtual void test_builder_noLabel()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.joda.beans.BeanBuilder<? extends SwaptionSurfaceExpiryStrikeParameterMetadata> builder = SwaptionSurfaceExpiryStrikeParameterMetadata.meta().builder();
BeanBuilder <SwaptionSurfaceExpiryStrikeParameterMetadata> builder = SwaptionSurfaceExpiryStrikeParameterMetadata.meta().builder();
Pair <double, double> pair = Pair.of(TIME_TO_EXPIRY, STRIKE);
builder.set(SwaptionSurfaceExpiryStrikeParameterMetadata.meta().yearFraction(), TIME_TO_EXPIRY);
builder.set(SwaptionSurfaceExpiryStrikeParameterMetadata.meta().strike(), STRIKE);
SwaptionSurfaceExpiryStrikeParameterMetadata test = builder.build();
assertEquals(test.Identifier, pair);
assertEquals(test.Label, pair.ToString());
assertEquals(test.Strike, STRIKE);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_builder_withLabel()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.joda.beans.BeanBuilder<? extends GenericVolatilitySurfaceYearFractionParameterMetadata> builder = GenericVolatilitySurfaceYearFractionParameterMetadata.meta().builder();
BeanBuilder <GenericVolatilitySurfaceYearFractionParameterMetadata> builder = GenericVolatilitySurfaceYearFractionParameterMetadata.meta().builder();
Pair <double, Strike> pair = Pair.of(TIME_TO_EXPIRY, STRIKE1);
string label = "(1.5, 0.75)";
builder.set(GenericVolatilitySurfaceYearFractionParameterMetadata.meta().yearFraction(), TIME_TO_EXPIRY);
builder.set(GenericVolatilitySurfaceYearFractionParameterMetadata.meta().strike(), STRIKE1);
builder.set(GenericVolatilitySurfaceYearFractionParameterMetadata.meta().label(), label);
GenericVolatilitySurfaceYearFractionParameterMetadata test = builder.build();
assertEquals(test.Identifier, pair);
assertEquals(test.Label, label);
assertEquals(test.Strike, STRIKE1);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_builder_noLabel()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.joda.beans.BeanBuilder<? extends FxVolatilitySurfaceYearFractionParameterMetadata> builder = FxVolatilitySurfaceYearFractionParameterMetadata.meta().builder();
BeanBuilder <FxVolatilitySurfaceYearFractionParameterMetadata> builder = FxVolatilitySurfaceYearFractionParameterMetadata.meta().builder();
Pair <double, Strike> pair = Pair.of(TIME_TO_EXPIRY, STRIKE);
builder.set(FxVolatilitySurfaceYearFractionParameterMetadata.meta().currencyPair(), CURRENCY_PAIR);
builder.set(FxVolatilitySurfaceYearFractionParameterMetadata.meta().yearFraction(), TIME_TO_EXPIRY);
builder.set(FxVolatilitySurfaceYearFractionParameterMetadata.meta().strike(), STRIKE);
FxVolatilitySurfaceYearFractionParameterMetadata test = builder.build();
assertEquals(test.CurrencyPair, CURRENCY_PAIR);
assertEquals(test.Identifier, pair);
assertEquals(test.Label, Pair.of(TIME_TO_EXPIRY, STRIKE.Label).ToString());
assertEquals(test.Strike, STRIKE);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_builder_withLabel()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.joda.beans.BeanBuilder<? extends SwaptionSurfaceExpirySimpleMoneynessParameterMetadata> builder = SwaptionSurfaceExpirySimpleMoneynessParameterMetadata.meta().builder();
BeanBuilder <SwaptionSurfaceExpirySimpleMoneynessParameterMetadata> builder = SwaptionSurfaceExpirySimpleMoneynessParameterMetadata.meta().builder();
Pair <double, double> pair = Pair.of(TIME_TO_EXPIRY, SIMPLE_MONEYNESS);
string label = "(1.5Y, 0.25)";
builder.set(SwaptionSurfaceExpirySimpleMoneynessParameterMetadata.meta().yearFraction(), TIME_TO_EXPIRY);
builder.set(SwaptionSurfaceExpirySimpleMoneynessParameterMetadata.meta().simpleMoneyness(), SIMPLE_MONEYNESS);
builder.set(SwaptionSurfaceExpirySimpleMoneynessParameterMetadata.meta().label(), label);
SwaptionSurfaceExpirySimpleMoneynessParameterMetadata test = builder.build();
assertEquals(test.Identifier, pair);
assertEquals(test.Label, label);
assertEquals(test.SimpleMoneyness, SIMPLE_MONEYNESS);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
/// <summary>
/// {@inheritDoc}
/// </summary>
public virtual GaussianQuadratureData generate(int n)
{
ArgChecker.isTrue(n > 0);
Pair <DoubleFunction1D, DoubleFunction1D>[] polynomials = LAGUERRE.getPolynomialsAndFirstDerivative(n, _alpha);
Pair <DoubleFunction1D, DoubleFunction1D> pair = polynomials[n];
DoubleFunction1D p1 = polynomials[n - 1].First;
DoubleFunction1D function = pair.First;
DoubleFunction1D derivative = pair.Second;
double[] x = new double[n];
double[] w = new double[n];
double root = 0;
for (int i = 0; i < n; i++)
{
root = ROOT_FINDER.getRoot(function, derivative, getInitialRootGuess(root, i, n, x)).Value;
x[i] = root;
w[i] = -GAMMA_FUNCTION.applyAsDouble(_alpha + n) / CombinatoricsUtils.factorialDouble(n) / (derivative.applyAsDouble(root) * p1.applyAsDouble(root));
}
return(new GaussianQuadratureData(x, w));
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
ImmutableMap <SecurityId, RepoGroup> repoSecurityGroups = ImmutableMap.of(SEC_A1, GROUP_REPO_X);
ImmutableMap <LegalEntityId, RepoGroup> repoGroups = ImmutableMap.of(ISSUER_A, GROUP_REPO_Y, ISSUER_B, GROUP_REPO_Y);
ImmutableMap <Pair <RepoGroup, Currency>, CurveId> repoCurves = ImmutableMap.of(Pair.of(GROUP_REPO_X, USD), CURVE_ID_USD1, Pair.of(GROUP_REPO_Y, USD), CURVE_ID_USD2, Pair.of(GROUP_REPO_Y, GBP), CURVE_ID_GBP1);
ImmutableMap <LegalEntityId, LegalEntityGroup> issuerGroups = ImmutableMap.of(ISSUER_A, GROUP_ISSUER_M, ISSUER_B, GROUP_ISSUER_N);
ImmutableMap <Pair <LegalEntityGroup, Currency>, CurveId> issuerCurves = ImmutableMap.of(Pair.of(GROUP_ISSUER_M, USD), CURVE_ID_USD3, Pair.of(GROUP_ISSUER_N, USD), CURVE_ID_USD4, Pair.of(GROUP_ISSUER_N, GBP), CURVE_ID_GBP2);
LegalEntityDiscountingMarketDataLookup test = LegalEntityDiscountingMarketDataLookup.of(repoSecurityGroups, repoGroups, repoCurves, issuerGroups, issuerCurves);
coverImmutableBean((ImmutableBean)test);
ImmutableMap <LegalEntityId, RepoGroup> repoGroups2 = ImmutableMap.of();
ImmutableMap <Pair <RepoGroup, Currency>, CurveId> repoCurves2 = ImmutableMap.of();
ImmutableMap <LegalEntityId, LegalEntityGroup> issuerGroups2 = ImmutableMap.of();
ImmutableMap <Pair <LegalEntityGroup, Currency>, CurveId> issuerCurves2 = ImmutableMap.of();
LegalEntityDiscountingMarketDataLookup test2 = LegalEntityDiscountingMarketDataLookup.of(repoGroups2, repoCurves2, issuerGroups2, issuerCurves2, OBS_SOURCE);
coverBeanEquals((ImmutableBean)test, (ImmutableBean)test2);
// related coverage
coverImmutableBean((ImmutableBean)test.marketDataView(MOCK_CALC_MARKET_DATA));
DefaultLegalEntityDiscountingScenarioMarketData.meta();
coverImmutableBean((ImmutableBean)test.marketDataView(MOCK_MARKET_DATA));
DefaultLegalEntityDiscountingMarketData.meta();
coverImmutableBean((ImmutableBean)test.marketDataView(MOCK_MARKET_DATA).discountingProvider());
DefaultLookupLegalEntityDiscountingProvider.meta();
}
public virtual void test_builder_fail()
{
// no relevant map for repo curve
assertThrowsIllegalArg(() => ImmutableLegalEntityDiscountingProvider.builder().issuerCurves(ImmutableMap.of(Pair.of(GROUP_ISSUER, GBP), DSC_FACTORS_ISSUER)).issuerCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_ISSUER)).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO_ISSUER, GBP), DSC_FACTORS_REPO)).repoCurveGroups(ImmutableMap.of(ID_ISSUER, RepoGroup.of("ISSUER2 BND 5Y"))).build());
// no relevant map for issuer curve
assertThrowsIllegalArg(() => ImmutableLegalEntityDiscountingProvider.builder().issuerCurves(ImmutableMap.of(Pair.of(GROUP_ISSUER, GBP), DSC_FACTORS_ISSUER)).issuerCurveGroups(ImmutableMap.of(ID_ISSUER, LegalEntityGroup.of("ISSUER2"))).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO_ISSUER, GBP), DSC_FACTORS_REPO)).repoCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_REPO_ISSUER)).build());
// issuer curve and valuation date are missing
assertThrowsIllegalArg(() => ImmutableLegalEntityDiscountingProvider.builder().issuerCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_ISSUER)).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO_SECURITY, GBP), DSC_FACTORS_REPO)).repoCurveSecurityGroups(ImmutableMap.of(ID_SECURITY, GROUP_REPO_SECURITY)).build());
// issuer curve date is different from valuation date
DiscountFactors dscFactorIssuer = ZeroRateDiscountFactors.of(GBP, date(2015, 6, 14), CURVE_ISSUER);
assertThrowsIllegalArg(() => ImmutableLegalEntityDiscountingProvider.builder().issuerCurves(ImmutableMap.of(Pair.of(GROUP_ISSUER, GBP), dscFactorIssuer)).issuerCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_ISSUER)).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO_SECURITY, GBP), DSC_FACTORS_REPO)).repoCurveSecurityGroups(ImmutableMap.of(ID_SECURITY, GROUP_REPO_SECURITY)).valuationDate(DATE).build());
// repo curve rate is different from valuation date
DiscountFactors dscFactorRepo = ZeroRateDiscountFactors.of(GBP, date(2015, 6, 14), CURVE_REPO);
assertThrowsIllegalArg(() => ImmutableLegalEntityDiscountingProvider.builder().issuerCurves(ImmutableMap.of(Pair.of(GROUP_ISSUER, GBP), DSC_FACTORS_ISSUER)).issuerCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_ISSUER)).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO_SECURITY, GBP), dscFactorRepo)).repoCurveSecurityGroups(ImmutableMap.of(ID_SECURITY, GROUP_REPO_SECURITY)).valuationDate(DATE).build());
}
public virtual void bucketedCs01SingleNodeCurveTest()
{
ImmutableCreditRatesProvider ratesProviderNoCredit = ImmutableCreditRatesProvider.builder().valuationDate(VALUATION_DATE).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY, RECOVERY_CURVE)).discountCurves(ImmutableMap.of(USD, YIELD_CURVE)).build();
QuoteId quoteId = QuoteId.of(StandardId.of("OG", END2.ToString()));
CdsIsdaCreditCurveNode node = CdsIsdaCreditCurveNode.ofParSpread(DatesCdsTemplate.of(START, END2, CDS_CONV), quoteId, LEGAL_ENTITY);
ImmutableMarketData marketData = ImmutableMarketData.builder(VALUATION_DATE).addValue(quoteId, DEAL_SPREAD * ONE_BP).build();
IsdaCreditCurveDefinition definition = IsdaCreditCurveDefinition.of(CREDIT_CURVE_NAME, USD, VALUATION_DATE, ACT_365F, ImmutableList.of(node), true, false);
LegalEntitySurvivalProbabilities creditCurve = BUILDER.calibrate(definition, marketData, ratesProviderNoCredit, REF_DATA);
ImmutableCreditRatesProvider ratesProvider = ImmutableCreditRatesProvider.builder().valuationDate(VALUATION_DATE).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY, RECOVERY_CURVE)).discountCurves(ImmutableMap.of(USD, YIELD_CURVE)).creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY, USD), creditCurve)).build();
double[] expectedFd = new double[] { -6.876275937539589E-4, 1.1832215762730414E-4, 0.0012340982402658796, 0.002784985575488008, 0.005287295115619095, 2429.636217554099, 3101.303324461041 };
CurrencyParameterSensitivity analytic = CS01_AN.bucketedCs01(CDS2, ImmutableList.copyOf(MARKET_CDS), ratesProvider, REF_DATA);
CurrencyParameterSensitivity fd = CS01_FD.bucketedCs01(CDS2, ImmutableList.copyOf(MARKET_CDS), ratesProvider, REF_DATA);
assertEquals(fd.Currency, USD);
assertEquals(fd.MarketDataName, CurveName.of("impliedSpreads"));
assertEquals(fd.ParameterCount, NUM_MARKET_CDS);
assertEquals(fd.ParameterMetadata, CDS_METADATA);
assertTrue(DoubleArrayMath.fuzzyEquals(fd.Sensitivity.multipliedBy(ONE_BP).toArray(), expectedFd, NOTIONAL * TOL));
assertEquals(analytic.Currency, USD);
assertEquals(analytic.MarketDataName, CurveName.of("impliedSpreads"));
assertEquals(analytic.ParameterCount, NUM_MARKET_CDS);
assertEquals(analytic.ParameterMetadata, CDS_METADATA);
assertTrue(DoubleArrayMath.fuzzyEquals(analytic.Sensitivity.toArray(), fd.Sensitivity.toArray(), NOTIONAL * ONE_BP * 10d));
}
//-------------------------------------------------------------------------
public virtual void test_of_map_invalid()
{
ImmutableMap <SecurityId, RepoGroup> repoSecurityGroups = ImmutableMap.of(SEC_A1, GROUP_REPO_X);
ImmutableMap <Pair <RepoGroup, Currency>, CurveId> repoCurves = ImmutableMap.of(Pair.of(GROUP_REPO_X, USD), CURVE_ID_USD1);
ImmutableMap <LegalEntityId, LegalEntityGroup> issuerGroups = ImmutableMap.of(ISSUER_A, GROUP_ISSUER_M);
ImmutableMap <Pair <LegalEntityGroup, Currency>, CurveId> issuerCurves = ImmutableMap.of(Pair.of(GROUP_ISSUER_M, USD), CURVE_ID_USD3);
assertThrowsIllegalArg(() => LegalEntityDiscountingMarketDataLookup.of(repoSecurityGroups, ImmutableMap.of(), ImmutableMap.of(), issuerGroups, issuerCurves));
assertThrowsIllegalArg(() => LegalEntityDiscountingMarketDataLookup.of(repoSecurityGroups, ImmutableMap.of(), repoCurves, issuerGroups, ImmutableMap.of()));
}
//-------------------------------------------------------------------------
public virtual void test_marketDataView()
{
ImmutableMap <SecurityId, RepoGroup> repoSecurityGroups = ImmutableMap.of(SEC_A1, GROUP_REPO_X);
ImmutableMap <Pair <RepoGroup, Currency>, CurveId> repoCurves = ImmutableMap.of(Pair.of(GROUP_REPO_X, USD), CURVE_ID_USD1);
ImmutableMap <LegalEntityId, LegalEntityGroup> issuerGroups = ImmutableMap.of(ISSUER_A, GROUP_ISSUER_M);
ImmutableMap <Pair <LegalEntityGroup, Currency>, CurveId> issuerCurves = ImmutableMap.of(Pair.of(GROUP_ISSUER_M, USD), CURVE_ID_USD3);
LegalEntityDiscountingMarketDataLookup test = LegalEntityDiscountingMarketDataLookup.of(repoSecurityGroups, ImmutableMap.of(), repoCurves, issuerGroups, issuerCurves);
LocalDate valDate = date(2015, 6, 30);
ScenarioMarketData md = new TestMarketDataMap(valDate, ImmutableMap.of(), ImmutableMap.of());
LegalEntityDiscountingScenarioMarketData multiScenario = test.marketDataView(md);
assertEquals(multiScenario.Lookup, test);
assertEquals(multiScenario.MarketData, md);
assertEquals(multiScenario.ScenarioCount, 1);
LegalEntityDiscountingMarketData scenario = multiScenario.scenario(0);
assertEquals(scenario.Lookup, test);
assertEquals(scenario.MarketData, md.scenario(0));
assertEquals(scenario.ValuationDate, valDate);
}
public virtual void test_bondDiscountingProvider()
{
ImmutableMap <SecurityId, RepoGroup> repoSecurityGroups = ImmutableMap.of(SEC_A1, GROUP_REPO_X);
ImmutableMap <LegalEntityId, RepoGroup> repoGroups = ImmutableMap.of(ISSUER_B, GROUP_REPO_X);
ImmutableMap <Pair <RepoGroup, Currency>, CurveId> repoCurves = ImmutableMap.of(Pair.of(GROUP_REPO_X, USD), CURVE_ID_USD1);
ImmutableMap <LegalEntityId, LegalEntityGroup> issuerGroups = ImmutableMap.of(ISSUER_A, GROUP_ISSUER_M);
ImmutableMap <Pair <LegalEntityGroup, Currency>, CurveId> issuerCurves = ImmutableMap.of(Pair.of(GROUP_ISSUER_M, USD), CURVE_ID_USD3);
LegalEntityDiscountingMarketDataLookup test = LegalEntityDiscountingMarketDataLookup.of(repoSecurityGroups, repoGroups, repoCurves, issuerGroups, issuerCurves);
LocalDate valDate = date(2015, 6, 30);
Curve repoCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_USD1.CurveName, ACT_360), 1d);
Curve issuerCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_USD3.CurveName, ACT_360), 2d);
MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.of(CURVE_ID_USD1, repoCurve, CURVE_ID_USD3, issuerCurve));
LegalEntityDiscountingProvider provider = test.discountingProvider(md);
assertEquals(provider.ValuationDate, valDate);
assertEquals(provider.findData(CURVE_ID_USD1.CurveName), repoCurve);
assertEquals(provider.findData(CURVE_ID_USD3.CurveName), issuerCurve);
assertEquals(provider.findData(CurveName.of("Rubbish")), null);
// check repo
RepoCurveDiscountFactors rcdf = provider.repoCurveDiscountFactors(SEC_A1, ISSUER_A, USD);
SimpleDiscountFactors rdf = (SimpleDiscountFactors)rcdf.DiscountFactors;
assertEquals(rdf.Curve.Name, repoCurve.Name);
assertEquals(rcdf, provider.repoCurveDiscountFactors(SEC_B1, ISSUER_B, USD));
assertThrowsIllegalArg(() => provider.repoCurveDiscountFactors(SEC_A1, ISSUER_A, GBP));
assertThrowsIllegalArg(() => provider.repoCurveDiscountFactors(SEC_C1, ISSUER_C, USD));
// check issuer
IssuerCurveDiscountFactors icdf = provider.issuerCurveDiscountFactors(ISSUER_A, USD);
SimpleDiscountFactors idf = (SimpleDiscountFactors)icdf.DiscountFactors;
assertEquals(idf.Curve.Name, issuerCurve.Name);
assertThrowsIllegalArg(() => provider.issuerCurveDiscountFactors(ISSUER_A, GBP));
assertThrowsIllegalArg(() => provider.issuerCurveDiscountFactors(ISSUER_C, USD));
}
//-------------------------------------------------------------------------
public virtual void test_of_map()
{
ImmutableMap <SecurityId, RepoGroup> repoSecurityGroups = ImmutableMap.of(SEC_A1, GROUP_REPO_X);
ImmutableMap <LegalEntityId, RepoGroup> repoGroups = ImmutableMap.of(ISSUER_A, GROUP_REPO_Y, ISSUER_B, GROUP_REPO_Y, ISSUER_C, GROUP_REPO_Y, ISSUER_D, GROUP_REPO_Y);
ImmutableMap <Pair <RepoGroup, Currency>, CurveId> repoCurves = ImmutableMap.of(Pair.of(GROUP_REPO_X, USD), CURVE_ID_USD1, Pair.of(GROUP_REPO_Y, USD), CURVE_ID_USD2, Pair.of(GROUP_REPO_Y, GBP), CURVE_ID_GBP1);
ImmutableMap <LegalEntityId, LegalEntityGroup> issuerGroups = ImmutableMap.of(ISSUER_A, GROUP_ISSUER_M, ISSUER_B, GROUP_ISSUER_N, ISSUER_C, GROUP_ISSUER_M);
ImmutableMap <Pair <LegalEntityGroup, Currency>, CurveId> issuerCurves = ImmutableMap.of(Pair.of(GROUP_ISSUER_M, USD), CURVE_ID_USD3, Pair.of(GROUP_ISSUER_N, USD), CURVE_ID_USD4, Pair.of(GROUP_ISSUER_N, GBP), CURVE_ID_GBP2);
LegalEntityDiscountingMarketDataLookup test = LegalEntityDiscountingMarketDataLookup.of(repoSecurityGroups, repoGroups, repoCurves, issuerGroups, issuerCurves);
assertEquals(test.queryType(), typeof(LegalEntityDiscountingMarketDataLookup));
assertEquals(test.requirements(SEC_A1, ISSUER_A, USD), FunctionRequirements.builder().valueRequirements(CURVE_ID_USD1, CURVE_ID_USD3).outputCurrencies(USD).build());
assertEquals(test.requirements(SEC_A2, ISSUER_A, USD), FunctionRequirements.builder().valueRequirements(CURVE_ID_USD2, CURVE_ID_USD3).outputCurrencies(USD).build());
assertEquals(test.requirements(SEC_B1, ISSUER_B, USD), FunctionRequirements.builder().valueRequirements(CURVE_ID_USD2, CURVE_ID_USD4).outputCurrencies(USD).build());
assertEquals(test.requirements(SEC_B1, ISSUER_B, GBP), FunctionRequirements.builder().valueRequirements(CURVE_ID_GBP1, CURVE_ID_GBP2).outputCurrencies(GBP).build());
assertThrowsIllegalArg(() => test.requirements(SEC_B1, LegalEntityId.of("XXX", "XXX"), GBP));
assertThrowsIllegalArg(() => test.requirements(SecurityId.of("XXX", "XXX"), LegalEntityId.of("XXX", "XXX"), GBP));
assertThrowsIllegalArg(() => test.requirements(SEC_A1, ISSUER_A, GBP));
assertThrowsIllegalArg(() => test.requirements(SEC_C1, ISSUER_C, GBP));
assertThrowsIllegalArg(() => test.requirements(SEC_D1, ISSUER_D, GBP));
assertEquals(test.discountingProvider(MOCK_MARKET_DATA), DefaultLookupLegalEntityDiscountingProvider.of((DefaultLegalEntityDiscountingMarketDataLookup)test, MOCK_MARKET_DATA));
}
/// <summary>
/// Obtains legal entity discounting rates provider from valuation date.
/// </summary>
/// <param name="valuationDate"> the valuation date </param>
/// <returns> the discounting rates provider </returns>
public static LegalEntityDiscountingProvider getLegalEntityDiscountingProviderJp(LocalDate valuationDate)
{
DiscountFactors dscIssuer = ZeroRateDiscountFactors.of(JPY, valuationDate, ISSUER_CURVE);
DiscountFactors dscRepo = ZeroRateDiscountFactors.of(JPY, valuationDate, REPO_CURVE);
return(ImmutableLegalEntityDiscountingProvider.builder().issuerCurves(ImmutableMap.of(Pair.of(GROUP_ISSUER, JPY), dscIssuer)).issuerCurveGroups(ImmutableMap.of(ISSUER_ID, GROUP_ISSUER)).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO, JPY), dscRepo)).repoCurveGroups(ImmutableMap.of(ISSUER_ID, GROUP_REPO)).build());
}
static MarketQuoteSensitivityCalculatorTest()
{
CurrencyParameterSensitivity sensi1 = CurrencyParameterSensitivity.of(CURVE_NAME_1, USD, SENSI_1);
CurrencyParameterSensitivity sensi2 = CurrencyParameterSensitivity.of(CURVE_NAME_2, GBP, SENSI_2);
ZeroRateDiscountFactors dscIssuer = ZeroRateDiscountFactors.of(USD, DATE, CURVE_1);
ZeroRateDiscountFactors dscRepo = ZeroRateDiscountFactors.of(GBP, DATE, CURVE_2);
PARAMETER_SENSITIVITIES = CurrencyParameterSensitivities.of(sensi1, sensi2);
PROVIDER = ImmutableLegalEntityDiscountingProvider.builder().issuerCurves(ImmutableMap.of(Pair.of(GROUP_ISSUER, USD), dscIssuer)).issuerCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_ISSUER)).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO_SECURITY, GBP), dscRepo)).repoCurveSecurityGroups(ImmutableMap.of(ID_SECURITY, GROUP_REPO_SECURITY)).build();
}
public virtual void test_serialization()
{
ImmutableMap <SecurityId, RepoGroup> repoSecurityGroups = ImmutableMap.of(SEC_A1, GROUP_REPO_X);
ImmutableMap <LegalEntityId, RepoGroup> repoGroups = ImmutableMap.of(ISSUER_A, GROUP_REPO_Y, ISSUER_B, GROUP_REPO_Y);
ImmutableMap <Pair <RepoGroup, Currency>, CurveId> repoCurves = ImmutableMap.of(Pair.of(GROUP_REPO_X, USD), CURVE_ID_USD1, Pair.of(GROUP_REPO_Y, USD), CURVE_ID_USD2, Pair.of(GROUP_REPO_Y, GBP), CURVE_ID_GBP1);
ImmutableMap <LegalEntityId, LegalEntityGroup> issuerGroups = ImmutableMap.of(ISSUER_A, GROUP_ISSUER_M, ISSUER_B, GROUP_ISSUER_N);
ImmutableMap <Pair <LegalEntityGroup, Currency>, CurveId> issuerCurves = ImmutableMap.of(Pair.of(GROUP_ISSUER_M, USD), CURVE_ID_USD3, Pair.of(GROUP_ISSUER_N, USD), CURVE_ID_USD4, Pair.of(GROUP_ISSUER_N, GBP), CURVE_ID_GBP2);
LegalEntityDiscountingMarketDataLookup test = LegalEntityDiscountingMarketDataLookup.of(repoSecurityGroups, repoGroups, repoCurves, issuerGroups, issuerCurves);
assertSerialization(test);
}
