/// <summary> /// Writes the curve settings in a CSV format to an appendable. /// </summary> /// <param name="underlying"> the underlying appendable destination </param> /// <param name="group"> the curve group </param> public static void writeCurveSettings(Appendable underlying, RatesCurveGroup group) { CsvOutput csv = CsvOutput.standard(underlying); // header csv.writeLine(HEADERS_SETTINGS); // rows IDictionary <Currency, Curve> discountingCurves = group.DiscountCurves; ISet <CurveName> names = new HashSet <CurveName>(); foreach (KeyValuePair <Currency, Curve> entry in discountingCurves.SetOfKeyValuePairs()) { Curve curve = entry.Value; csv.writeLine(curveSettings(curve)); names.Add(curve.Name); } IDictionary <Index, Curve> forwardCurves = group.ForwardCurves; foreach (KeyValuePair <Index, Curve> entry in forwardCurves.SetOfKeyValuePairs()) { Curve curve = entry.Value; if (!names.Contains(curve.Name)) { csv.writeLine(curveSettings(curve)); names.Add(curve.Name); } } }
//------------------------------------------------------------------------- public virtual void test_load_all_curves() { ListMultimap <LocalDate, RatesCurveGroup> allGroups = RatesCurvesCsvLoader.loadAllDates(ResourceLocator.of(GROUPS_1), ResourceLocator.of(SETTINGS_1), ImmutableList.of(ResourceLocator.of(CURVES_1), ResourceLocator.of(CURVES_2), ResourceLocator.of(CURVES_3))); assertEquals(allGroups.size(), 2); assertCurves(allGroups.get(CURVE_DATE)); IList <RatesCurveGroup> curves3 = allGroups.get(CURVE_DATE_CURVES_3); assertEquals(curves3.Count, 1); RatesCurveGroup group = curves3[0]; // All curve points are set to 0 in test data to ensure these are really different curve instances Curve usdDisc = group.findDiscountCurve(Currency.USD).get(); InterpolatedNodalCurve usdDiscNodal = (InterpolatedNodalCurve)usdDisc; assertEquals(usdDiscNodal.Metadata.CurveName, CurveName.of("USD-Disc")); assertTrue(usdDiscNodal.YValues.equalZeroWithTolerance(0d)); Curve usd3ml = group.findForwardCurve(IborIndices.USD_LIBOR_3M).get(); InterpolatedNodalCurve usd3mlNodal = (InterpolatedNodalCurve)usd3ml; assertEquals(usd3mlNodal.Metadata.CurveName, CurveName.of("USD-3ML")); assertTrue(usd3mlNodal.YValues.equalZeroWithTolerance(0d)); }
// write a single group to CSV private static void writeCurveGroup(CsvOutput csv, RatesCurveGroup group) { string groupName = group.Name.Name; IDictionary <Currency, Curve> discountingCurves = group.DiscountCurves; foreach (KeyValuePair <Currency, Curve> entry in discountingCurves.SetOfKeyValuePairs()) { IList <string> line = new List <string>(4); line.Add(groupName); line.Add(DISCOUNT); line.Add(entry.Key.ToString()); line.Add(entry.Value.Name.Name); csv.writeLine(line); } IDictionary <Index, Curve> forwardCurves = group.ForwardCurves; foreach (KeyValuePair <Index, Curve> entry in forwardCurves.SetOfKeyValuePairs()) { IList <string> line = new List <string>(4); line.Add(groupName); line.Add(FORWARD); line.Add(entry.Key.ToString()); line.Add(entry.Value.Name.Name); csv.writeLine(line); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "Missing settings for curve: .*") public void test_noSettings() public virtual void test_noSettings() { IList <RatesCurveGroup> curveGroups = RatesCurvesCsvLoader.load(CURVE_DATE, ResourceLocator.of(GROUPS_1), ResourceLocator.of(SETTINGS_EMPTY), ImmutableList.of(ResourceLocator.of(CURVES_1))); assertEquals(curveGroups.Count, 1); RatesCurveGroup curveGroup = Iterables.getOnlyElement(curveGroups); assertUsdDisc(curveGroup.findDiscountCurve(Currency.USD).get()); }
//------------------------------------------------------------------------- private void assertCurves(IList <RatesCurveGroup> curveGroups) { assertNotNull(curveGroups); assertEquals(curveGroups.Count, 1); RatesCurveGroup curveGroup = curveGroups[0]; assertEquals(curveGroup.Name, CurveGroupName.of("Default")); assertUsdDisc(curveGroup.findDiscountCurve(Currency.USD).get()); Curve usd3ml = curveGroup.findForwardCurve(IborIndices.USD_LIBOR_3M).get(); assertUsd3ml(usd3ml); }
//------------------------------------------------------------------------- /// <summary> /// Writes the curve groups definition in a CSV format to a file. /// </summary> /// <param name="file"> the file </param> /// <param name="valuationDate"> the valuation date </param> /// <param name="group"> the curve group </param> public static void writeCurveNodes(File file, LocalDate valuationDate, RatesCurveGroup group) { try { using (Writer writer = new StreamWriter(new FileStream(file, FileMode.Create, FileAccess.Write), Encoding.UTF8)) { writeCurveNodes(writer, valuationDate, group); } } catch (IOException ex) { throw new UncheckedIOException(ex); } }
public virtual void test_of_curveGroup() { ImmutableMap <Currency, Curve> discounts = ImmutableMap.of(USD, ConstantCurve.of(CURVE_ID_DSC.CurveName, 1)); ImmutableMap <Index, Curve> forwards = ImmutableMap.of(USD_LIBOR_3M, ConstantCurve.of(CURVE_ID_FWD.CurveName, 1)); RatesCurveGroup group = RatesCurveGroup.of(CURVE_ID_DSC.CurveGroupName, discounts, forwards); RatesMarketDataLookup test = RatesMarketDataLookup.of(group); assertEquals(test.queryType(), typeof(RatesMarketDataLookup)); assertEquals(test.DiscountCurrencies, ImmutableSet.of(USD)); assertEquals(test.getDiscountMarketDataIds(USD), ImmutableSet.of(CURVE_ID_DSC)); assertEquals(test.ForwardIndices, ImmutableSet.of(USD_LIBOR_3M)); assertEquals(test.getForwardMarketDataIds(USD_LIBOR_3M), ImmutableSet.of(CURVE_ID_FWD)); assertThrowsIllegalArg(() => test.getDiscountMarketDataIds(GBP)); assertThrowsIllegalArg(() => test.getForwardMarketDataIds(GBP_LIBOR_3M)); }
//------------------------------------------------------------------------- /// <summary> /// Parses one or more CSV format curve files for all available dates. /// <para> /// A predicate is specified that is used to filter the dates that are returned. /// This could match a single date, a set of dates or all dates. /// </para> /// <para> /// If the files contain a duplicate entry an exception will be thrown. /// /// </para> /// </summary> /// <param name="datePredicate"> the predicate used to select the dates </param> /// <param name="groupsCharSource"> the curve groups CSV character source </param> /// <param name="settingsCharSource"> the curve settings CSV character source </param> /// <param name="curveValueCharSources"> the CSV character sources for curves </param> /// <returns> the loaded curves, mapped by date and identifier </returns> /// <exception cref="IllegalArgumentException"> if the files contain a duplicate entry </exception> public static ImmutableListMultimap <LocalDate, RatesCurveGroup> parse(System.Predicate <LocalDate> datePredicate, CharSource groupsCharSource, CharSource settingsCharSource, ICollection <CharSource> curveValueCharSources) { IList <RatesCurveGroupDefinition> curveGroups = RatesCurveGroupDefinitionCsvLoader.parseCurveGroupDefinitions(groupsCharSource); IDictionary <LocalDate, IDictionary <CurveName, Curve> > curves = parseCurves(datePredicate, settingsCharSource, curveValueCharSources); ImmutableListMultimap.Builder <LocalDate, RatesCurveGroup> builder = ImmutableListMultimap.builder(); foreach (RatesCurveGroupDefinition groupDefinition in curveGroups) { foreach (KeyValuePair <LocalDate, IDictionary <CurveName, Curve> > entry in curves.SetOfKeyValuePairs()) { RatesCurveGroup curveGroup = RatesCurveGroup.ofCurves(groupDefinition, entry.Value.values()); builder.put(entry.Key, curveGroup); } } return(builder.build()); }
/// <summary> /// Writes the curve nodes in a CSV format to an appendable. /// </summary> /// <param name="underlying"> the underlying appendable destination </param> /// <param name="valuationDate"> the valuation date </param> /// <param name="group"> the curve group </param> public static void writeCurveNodes(Appendable underlying, LocalDate valuationDate, RatesCurveGroup group) { CsvOutput csv = CsvOutput.standard(underlying); // header csv.writeLine(HEADERS_NODES); // rows string valuationDateStr = valuationDate.ToString(); IDictionary <Currency, Curve> discountingCurves = group.DiscountCurves; ISet <CurveName> names = new HashSet <CurveName>(); foreach (KeyValuePair <Currency, Curve> entry in discountingCurves.SetOfKeyValuePairs()) { Curve curve = entry.Value; nodeLines(valuationDateStr, curve, csv); names.Add(curve.Name); } IDictionary <Index, Curve> forwardCurves = group.ForwardCurves; foreach (KeyValuePair <Index, Curve> entry in forwardCurves.SetOfKeyValuePairs()) { Curve curve = entry.Value; if (!names.Contains(curve.Name)) { nodeLines(valuationDateStr, curve, csv); names.Add(curve.Name); } } }
public virtual void test_builtData() { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.List<com.opengamma.strata.calc.marketdata.PerturbationMapping<?>> perturbationMapping = new java.util.ArrayList<>(); IList <PerturbationMapping <object> > perturbationMapping = new List <PerturbationMapping <object> >(); int nScenarios = 3; foreach (KeyValuePair <QuoteId, double> entry in MARKET_QUOTES.entrySet()) { DoubleArray shifts = DoubleArray.of(nScenarios, n => Math.Pow(0.9, n)); ScenarioPerturbation <double> perturb = GenericDoubleShifts.of(ShiftType.SCALED, shifts); perturbationMapping.Add(PerturbationMapping.of(MarketDataFilter.ofId(entry.Key), perturb)); } ScenarioDefinition scenarioDefinition = ScenarioDefinition.ofMappings(perturbationMapping); ImmutableMarketData dataWithSurface = ImmutableMarketData.builder(VALUATION_DATE).addValueMap(MARKET_QUOTES).addValueMap(MARKET_FX_QUOTES).addValue(VOL_ID, EXP_VOLS).addValue(RatesCurveGroupId.of(CURVE_GROUP_NAME), RatesCurveGroup.ofCurves(CURVE_GROUP_DEFINITION, EXP_RATES.toImmutableRatesProvider().DiscountCurves.values())).build(); ScenarioMarketData marketDataCalibrated = StandardComponents.marketDataFactory().createMultiScenario(REQUIREMENTS, SCENARIO_CONFIG, dataWithSurface, REF_DATA, scenarioDefinition); Results results = CALC_RUNNER.calculateMultiScenario(RULES, TARGETS, COLUMN, marketDataCalibrated, REF_DATA); CurrencyScenarioArray computed = results.get(0, 0, typeof(CurrencyScenarioArray)).Value; CurrencyAmount expected = PRICER.presentValue(OPTION_TRADE.resolve(REF_DATA), EXP_RATES, EXP_VOLS).convertedTo(USD, EXP_RATES); // dependency graph is absent, thus scenarios are not created assertTrue(computed.ScenarioCount == 1); assertEquals(computed.get(0), expected); }