public virtual void requirementsInverse() { FxRateMarketDataFunction function = new FxRateMarketDataFunction(); MarketDataRequirements requirements = function.requirements(FxRateId.of(CURRENCY_PAIR.inverse()), config()); assertThat(requirements).isEqualTo(MarketDataRequirements.of(QUOTE_ID)); }
public virtual MarketDataRequirements requirements(FxRateId id, MarketDataConfig marketDataConfig) { FxRateConfig fxRateConfig = marketDataConfig.get(typeof(FxRateConfig), id.ObservableSource); Optional <QuoteId> optional = fxRateConfig.getObservableRateKey(id.Pair); return(optional.map(key => MarketDataRequirements.of(key)).orElse(MarketDataRequirements.empty())); }
public virtual void requirements() { FxRateMarketDataFunction function = new FxRateMarketDataFunction(); MarketDataRequirements requirements = function.requirements(RATE_ID, config()); assertThat(requirements).isEqualTo(MarketDataRequirements.of(QUOTE_ID)); }
public virtual MarketDataRequirements requirements(CurveId id, MarketDataConfig config) { CurveGroupDefinition groupDefn = config.get(typeof(CurveGroupDefinition), id.CurveGroupName); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<? extends com.opengamma.strata.market.curve.CurveGroup> groupId = groupDefn.createGroupId(id.getObservableSource()); MarketDataId <CurveGroup> groupId = groupDefn.createGroupId(id.ObservableSource); return(MarketDataRequirements.of(groupId)); }
// obtains the data and calculates the grid of results private static void calculate(CalculationRunner runner) { // the trade that will have measures calculated IList <Trade> trades = ImmutableList.of(createVanillaFixedVsLibor3mSwap()); // the columns, specifying the measures to be calculated IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE), Column.of(Measures.PV01_CALIBRATED_SUM)); // use the built-in example market data ExampleMarketDataBuilder marketDataBuilder = ExampleMarketData.builder(); // the complete set of rules for calculating measures LocalDate valuationDate = LocalDate.of(2014, 1, 22); CalculationFunctions functions = StandardComponents.calculationFunctions(); CalculationRules rules = CalculationRules.of(functions, Currency.USD, marketDataBuilder.ratesLookup(valuationDate)); // mappings that select which market data to apply perturbations to // this applies the perturbations above to all curves PerturbationMapping <Curve> mapping = PerturbationMapping.of(MarketDataFilter.ofIdType(typeof(CurveId)), CurveParallelShifts.absolute(0, ONE_BP)); // create a scenario definition containing the single mapping above // this creates two scenarios - one for each perturbation in the mapping ScenarioDefinition scenarioDefinition = ScenarioDefinition.ofMappings(mapping); // build a market data snapshot for the valuation date MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate); // the reference data, such as holidays and securities ReferenceData refData = ReferenceData.standard(); // calculate the results MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData); ScenarioMarketData scenarioMarketData = marketDataFactory().createMultiScenario(reqs, MarketDataConfig.empty(), marketData, refData, scenarioDefinition); Results results = runner.calculateMultiScenario(rules, trades, columns, scenarioMarketData, refData); // TODO Replace the results processing below with a report once the reporting framework supports scenarios // The results are lists of currency amounts containing one value for each scenario //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> pvList = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 0).getValue(); ScenarioArray <object> pvList = (ScenarioArray <object>)results.get(0, 0).Value; //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> pv01List = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 1).getValue(); ScenarioArray <object> pv01List = (ScenarioArray <object>)results.get(0, 1).Value; double pvBase = ((CurrencyAmount)pvList.get(0)).Amount; double pvShifted = ((CurrencyAmount)pvList.get(1)).Amount; double pv01Base = ((CurrencyAmount)pv01List.get(0)).Amount; NumberFormat numberFormat = new DecimalFormat("###,##0.00", new DecimalFormatSymbols(Locale.ENGLISH)); Console.WriteLine(" PV (base) = " + numberFormat.format(pvBase)); Console.WriteLine(" PV (1 bp curve shift) = " + numberFormat.format(pvShifted)); Console.WriteLine("PV01 (algorithmic differentiation) = " + numberFormat.format(pv01Base)); Console.WriteLine(" PV01 (finite difference) = " + numberFormat.format(pvShifted - pvBase)); }
// obtains the data and calculates the grid of results private static void calculate(CalculationRunner runner) { // the trades that will have measures calculated IList <Trade> trades = createSwapTrades(); // the columns, specifying the measures to be calculated IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE), Column.of(Measures.PAR_RATE), Column.of(Measures.PV01_MARKET_QUOTE_BUCKETED), Column.of(Measures.PV01_CALIBRATED_BUCKETED)); // load quotes ImmutableMap <QuoteId, double> quotesCcp1 = QuotesCsvLoader.load(VAL_DATE, QUOTES_RESOURCE_CCP1); ImmutableMap <QuoteId, double> quotesCcp2 = QuotesCsvLoader.load(VAL_DATE, QUOTES_RESOURCE_CCP2); // load fixings ImmutableMap <ObservableId, LocalDateDoubleTimeSeries> fixings = FixingSeriesCsvLoader.load(FIXINGS_RESOURCE); // create the market data MarketData marketData = ImmutableMarketData.builder(VAL_DATE).addValueMap(quotesCcp1).addValueMap(quotesCcp2).addTimeSeriesMap(fixings).build(); // the reference data, such as holidays and securities ReferenceData refData = ReferenceData.standard(); // load the curve definition IDictionary <CurveGroupName, RatesCurveGroupDefinition> defnsCcp1 = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE_CCP1, SETTINGS_RESOURCE_CCP1, CALIBRATION_RESOURCE_CCP1); IDictionary <CurveGroupName, RatesCurveGroupDefinition> defnsCcp2 = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE_CCP2, SETTINGS_RESOURCE_CCP2, CALIBRATION_RESOURCE_CCP2); RatesCurveGroupDefinition curveGroupDefinitionCcp1 = defnsCcp1[CURVE_GROUP_NAME_CCP1].filtered(VAL_DATE, refData); RatesCurveGroupDefinition curveGroupDefinitionCcp2 = defnsCcp2[CURVE_GROUP_NAME_CCP2].filtered(VAL_DATE, refData); // the configuration that defines how to create the curves when a curve group is requested MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(CURVE_GROUP_NAME_CCP1, curveGroupDefinitionCcp1).add(CURVE_GROUP_NAME_CCP2, curveGroupDefinitionCcp2).build(); // the complete set of rules for calculating measures CalculationFunctions functions = StandardComponents.calculationFunctions(); RatesMarketDataLookup ratesLookupCcp1 = RatesMarketDataLookup.of(curveGroupDefinitionCcp1); RatesMarketDataLookup ratesLookupCcp2 = RatesMarketDataLookup.of(curveGroupDefinitionCcp2); // choose RatesMarketDataLookup instance based on counterparty TradeCounterpartyCalculationParameter perCounterparty = TradeCounterpartyCalculationParameter.of(ImmutableMap.of(CCP1_ID, ratesLookupCcp1, CCP2_ID, ratesLookupCcp2), ratesLookupCcp1); CalculationRules rules = CalculationRules.of(functions, perCounterparty); // calibrate the curves and calculate the results MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData); MarketData calibratedMarketData = marketDataFactory().create(reqs, marketDataConfig, marketData, refData); Results results = runner.calculate(rules, trades, columns, calibratedMarketData, refData); // use the report runner to transform the engine results into a trade report ReportCalculationResults calculationResults = ReportCalculationResults.of(VAL_DATE, trades, columns, results, functions, refData); TradeReportTemplate reportTemplate = ExampleData.loadTradeReportTemplate("swap-report-template2"); TradeReport tradeReport = TradeReport.of(calculationResults, reportTemplate); tradeReport.writeAsciiTable(System.out); }
// obtains the data and calculates the grid of results private static void calculate(CalculationRunner runner) { // the trades for which to calculate a P&L series IList <Trade> trades = ImmutableList.of(createTrade()); // the columns, specifying the measures to be calculated IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE)); // use the built-in example historical scenario market data ExampleMarketDataBuilder marketDataBuilder = ExampleMarketDataBuilder.ofResource(MARKET_DATA_RESOURCE_ROOT); // the complete set of rules for calculating measures CalculationFunctions functions = StandardComponents.calculationFunctions(); CalculationRules rules = CalculationRules.of(functions, marketDataBuilder.ratesLookup(LocalDate.of(2015, 4, 23))); // load the historical calibrated curves from which we will build our scenarios // these curves are provided in the example data environment SortedDictionary <LocalDate, RatesCurveGroup> historicalCurves = marketDataBuilder.loadAllRatesCurves(); // sorted list of dates for the available series of curves // the entries in the P&L vector we produce will correspond to these dates IList <LocalDate> scenarioDates = new List <LocalDate>(historicalCurves.Keys); // build the historical scenarios ScenarioDefinition historicalScenarios = buildHistoricalScenarios(historicalCurves, scenarioDates); // build a market data snapshot for the valuation date // this is the base snapshot which will be perturbed by the scenarios LocalDate valuationDate = LocalDate.of(2015, 4, 23); MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate); // the reference data, such as holidays and securities ReferenceData refData = ReferenceData.standard(); // calculate the results MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData); ScenarioMarketData scenarioMarketData = marketDataFactory().createMultiScenario(reqs, MarketDataConfig.empty(), marketData, refData, historicalScenarios); Results results = runner.calculateMultiScenario(rules, trades, columns, scenarioMarketData, refData); // the results contain the one measure requested (Present Value) for each scenario //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> scenarioValuations = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 0).getValue(); ScenarioArray <object> scenarioValuations = (ScenarioArray <object>)results.get(0, 0).Value; outputPnl(scenarioDates, scenarioValuations); }
// obtains the data and calculates the grid of results private static void calculate(CalculationRunner runner) { // the trades that will have measures calculated IList <Trade> trades = createSwapTrades(); // the columns, specifying the measures to be calculated IList <Column> columns = ImmutableList.of(Column.of(Measures.LEG_INITIAL_NOTIONAL), Column.of(Measures.PRESENT_VALUE), Column.of(Measures.LEG_PRESENT_VALUE), Column.of(Measures.PV01_CALIBRATED_SUM), Column.of(Measures.PAR_RATE), Column.of(Measures.ACCRUED_INTEREST), Column.of(Measures.PV01_CALIBRATED_BUCKETED), Column.of(AdvancedMeasures.PV01_SEMI_PARALLEL_GAMMA_BUCKETED)); // load quotes ImmutableMap <QuoteId, double> quotes = QuotesCsvLoader.load(VAL_DATE, QUOTES_RESOURCE); // load fixings ImmutableMap <ObservableId, LocalDateDoubleTimeSeries> fixings = FixingSeriesCsvLoader.load(FIXINGS_RESOURCE); // create the market data MarketData marketData = MarketData.of(VAL_DATE, quotes, fixings); // the reference data, such as holidays and securities ReferenceData refData = ReferenceData.standard(); // load the curve definition IDictionary <CurveGroupName, RatesCurveGroupDefinition> defns = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE, SETTINGS_RESOURCE, CALIBRATION_RESOURCE); RatesCurveGroupDefinition curveGroupDefinition = defns[CURVE_GROUP_NAME].filtered(VAL_DATE, refData); // the configuration that defines how to create the curves when a curve group is requested MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(CURVE_GROUP_NAME, curveGroupDefinition).build(); // the complete set of rules for calculating measures CalculationFunctions functions = StandardComponents.calculationFunctions(); RatesMarketDataLookup ratesLookup = RatesMarketDataLookup.of(curveGroupDefinition); CalculationRules rules = CalculationRules.of(functions, ratesLookup); // calibrate the curves and calculate the results MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData); MarketData calibratedMarketData = marketDataFactory().create(reqs, marketDataConfig, marketData, refData); Results results = runner.calculate(rules, trades, columns, calibratedMarketData, refData); // use the report runner to transform the engine results into a trade report ReportCalculationResults calculationResults = ReportCalculationResults.of(VAL_DATE, trades, columns, results, functions, refData); TradeReportTemplate reportTemplate = ExampleData.loadTradeReportTemplate("swap-report-template"); TradeReport tradeReport = TradeReport.of(calculationResults, reportTemplate); tradeReport.writeAsciiTable(System.out); }
// calculates the PV results for the instruments used in calibration from the config private static Pair <IList <Trade>, Results> calculate(CalculationRunner runner) { // the reference data, such as holidays and securities ReferenceData refData = ReferenceData.standard(); // load quotes ImmutableMap <QuoteId, double> quotes = QuotesCsvLoader.load(VAL_DATE, QUOTES_RESOURCE); // load time series IDictionary <ObservableId, LocalDateDoubleTimeSeries> fixings = FixingSeriesCsvLoader.load(FIXING_RESOURCE); // create the market data MarketData marketData = ImmutableMarketData.builder(VAL_DATE).addValueMap(quotes).addTimeSeriesMap(fixings).build(); // load the curve definition IDictionary <CurveGroupName, RatesCurveGroupDefinition> defns = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE, SETTINGS_RESOURCE, CALIBRATION_RESOURCE); RatesCurveGroupDefinition curveGroupDefinition = defns[CURVE_GROUP_NAME].filtered(VAL_DATE, refData); // extract the trades used for calibration IList <Trade> trades = curveGroupDefinition.CurveDefinitions.stream().flatMap(defn => defn.Nodes.stream()).filter(node => !(node is IborFixingDepositCurveNode)).map(node => node.trade(1d, marketData, refData)).collect(toImmutableList()); // the columns, specifying the measures to be calculated IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE)); // the configuration that defines how to create the curves when a curve group is requested MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(CURVE_GROUP_NAME, curveGroupDefinition).build(); // the complete set of rules for calculating measures CalculationFunctions functions = StandardComponents.calculationFunctions(); RatesMarketDataLookup ratesLookup = RatesMarketDataLookup.of(curveGroupDefinition); CalculationRules rules = CalculationRules.of(functions, ratesLookup); // calibrate the curves and calculate the results MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData); MarketData calibratedMarketData = marketDataFactory().create(reqs, marketDataConfig, marketData, refData); Results results = runner.calculate(rules, trades, columns, calibratedMarketData, refData); return(Pair.of(trades, results)); }