/// <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);
}
