public virtual void test_trade_noMarketData() { CdsIsdaCreditCurveNode node = CdsIsdaCreditCurveNode.ofParSpread(TEMPLATE, QUOTE_ID, LEGAL_ENTITY); MarketData marketData = MarketData.empty(VAL_DATE); assertThrows(() => node.trade(1d, marketData, REF_DATA), typeof(MarketDataNotFoundException)); }
//------------------------------------------------------------------------- public virtual void test_trade() { CdsIndexIsdaCreditCurveNode node = CdsIndexIsdaCreditCurveNode.ofQuotedSpread(TEMPLATE, QUOTE_ID, INDEX_ID, LEGAL_ENTITIES, 0.01); double rate = 0.0125; double quantity = -1234.56; MarketData marketData = ImmutableMarketData.builder(VAL_DATE).addValue(QUOTE_ID, rate).build(); CdsIndexCalibrationTrade trade = node.trade(quantity, marketData, REF_DATA); CdsTrade cdsTrade = TEMPLATE.createTrade(INDEX_ID, VAL_DATE, SELL, -quantity, 0.01, REF_DATA); CdsIndex cdsIndex = CdsIndex.of(SELL, INDEX_ID, LEGAL_ENTITIES, TEMPLATE.Convention.Currency, -quantity, date(2015, 6, 20), date(2025, 6, 20), Frequency.P3M, TEMPLATE.Convention.SettlementDateOffset.Calendar, 0.01); CdsIndex cdsIndexMod = cdsIndex.toBuilder().paymentSchedule(cdsIndex.PaymentSchedule.toBuilder().rollConvention(RollConventions.DAY_20).startDateBusinessDayAdjustment(cdsIndex.PaymentSchedule.BusinessDayAdjustment).build()).build(); CdsIndexTrade expected = CdsIndexTrade.builder().product(cdsIndexMod).info(cdsTrade.Info).build(); assertEquals(trade.UnderlyingTrade, expected); assertEquals(trade.Quote, CdsQuote.of(CdsQuoteConvention.QUOTED_SPREAD, rate)); CdsIndexIsdaCreditCurveNode node1 = CdsIndexIsdaCreditCurveNode.ofParSpread(TEMPLATE, QUOTE_ID, INDEX_ID, LEGAL_ENTITIES); CdsTrade cdsTrade1 = TEMPLATE.createTrade(INDEX_ID, VAL_DATE, SELL, -quantity, rate, REF_DATA); CdsIndexCalibrationTrade trade1 = node1.trade(quantity, marketData, REF_DATA); CdsIndex cdsIndex1 = CdsIndex.of(SELL, INDEX_ID, LEGAL_ENTITIES, TEMPLATE.Convention.Currency, -quantity, date(2015, 6, 20), date(2025, 6, 20), Frequency.P3M, TEMPLATE.Convention.SettlementDateOffset.Calendar, rate); CdsIndex cdsIndexMod1 = cdsIndex1.toBuilder().paymentSchedule(cdsIndex.PaymentSchedule.toBuilder().rollConvention(RollConventions.DAY_20).startDateBusinessDayAdjustment(cdsIndex1.PaymentSchedule.BusinessDayAdjustment).build()).build(); CdsIndexTrade expected1 = CdsIndexTrade.builder().product(cdsIndexMod1).info(cdsTrade1.Info).build(); assertEquals(trade1.UnderlyingTrade, expected1); assertEquals(trade1.Quote, CdsQuote.of(CdsQuoteConvention.PAR_SPREAD, rate)); }
public virtual void test_ofMatrix_source() { FxRateLookup test = FxRateLookup.ofMatrix(FxMatrixId.of(OBS_SOURCE)); MarketData marketData = ImmutableMarketData.builder(VAL_DATE).addValue(FxMatrixId.of(OBS_SOURCE), FxMatrix.of(GBP, USD, 1.5d)).build(); assertEquals(test.fxRateProvider(marketData).fxRate(GBP, USD), 1.5d); }
public virtual void test_ofRates_currency_source() { FxRateLookup test = FxRateLookup.ofRates(EUR, OBS_SOURCE); MarketData marketData = ImmutableMarketData.builder(VAL_DATE).addValue(FxRateId.of(GBP, USD, OBS_SOURCE), FxRate.of(GBP, USD, 1.5d)).build(); assertEquals(test.fxRateProvider(marketData).fxRate(GBP, USD), 1.5d); }
//------------------------------------------------------------------------- public virtual void calculate() { ImmutableList <CalculationTarget> targets = ImmutableList.of(TARGET); Column column1 = Column.of(TestingMeasures.PRESENT_VALUE); Column column2 = Column.of(TestingMeasures.BUCKETED_PV01); ImmutableList <Column> columns = ImmutableList.of(column1, column2); CalculationRules rules = CalculationRules.of(CalculationFunctions.empty()); MarketData md = MarketData.empty(date(2016, 6, 30)); ScenarioMarketData smd = ScenarioMarketData.empty(); // use of try-with-resources checks class is AutoCloseable using (CalculationRunner test = CalculationRunner.of(MoreExecutors.newDirectExecutorService())) { assertThat(test.calculate(rules, targets, columns, md, REF_DATA).get(0, 0).Failure).True; assertThat(test.calculateMultiScenario(rules, targets, columns, smd, REF_DATA).get(0, 0).Failure).True; } }
//------------------------------------------------------------------------- public virtual void test_trade() { CdsIsdaCreditCurveNode node = CdsIsdaCreditCurveNode.ofQuotedSpread(TEMPLATE, QUOTE_ID, LEGAL_ENTITY, 0.01); double rate = 0.0125; double quantity = -1234.56; MarketData marketData = ImmutableMarketData.builder(VAL_DATE).addValue(QUOTE_ID, rate).build(); CdsCalibrationTrade trade = node.trade(quantity, marketData, REF_DATA); CdsTrade expected = TEMPLATE.createTrade(LEGAL_ENTITY, VAL_DATE, SELL, -quantity, 0.01, REF_DATA); assertEquals(trade.UnderlyingTrade, expected); assertEquals(trade.Quote, CdsQuote.of(CdsQuoteConvention.QUOTED_SPREAD, rate)); CdsIsdaCreditCurveNode node1 = CdsIsdaCreditCurveNode.ofParSpread(TEMPLATE, QUOTE_ID, LEGAL_ENTITY); CdsTrade expected1 = TEMPLATE.createTrade(LEGAL_ENTITY, VAL_DATE, SELL, -quantity, rate, REF_DATA); CdsCalibrationTrade trade1 = node1.trade(quantity, marketData, REF_DATA); assertEquals(trade1.UnderlyingTrade, expected1); assertEquals(trade1.Quote, CdsQuote.of(CdsQuoteConvention.PAR_SPREAD, rate)); }
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)); }
//------------------------------------------------------------------------- // present value for one scenario private static CurrencyAmount calculatePresentValue(Security security, double quantity, MarketData marketData) { QuoteId id = QuoteId.of(security.SecurityId.StandardId); double price = marketData.getValue(id); return(security.Info.PriceInfo.calculateMonetaryAmount(quantity, price)); }