//-------------------------------------------------------------------------
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));
}
//-------------------------------------------------------------------------
/// <summary>
/// Loads one or more CSV format curve files for a specific date.
/// <para>
/// Only those quotes that match the specified date will be loaded.
/// </para>
/// <para>
/// If the files contain a duplicate entry an exception will be thrown.
///
/// </para>
/// </summary>
/// <param name="marketDataDate"> the curve date to load </param>
/// <param name="groupsResource"> the curve groups CSV resource </param>
/// <param name="settingsResource"> the curve settings CSV resource </param>
/// <param name="curveValueResources"> the CSV resources for curves </param>
/// <returns> the loaded curves, mapped by an identifying key </returns>
/// <exception cref="IllegalArgumentException"> if the files contain a duplicate entry </exception>
public static ImmutableList <LegalEntityCurveGroup> load(LocalDate marketDataDate, ResourceLocator groupsResource, ResourceLocator settingsResource, ICollection <ResourceLocator> curveValueResources)
{
ICollection <CharSource> curveCharSources = curveValueResources.Select(r => r.CharSource).ToList();
ListMultimap <LocalDate, LegalEntityCurveGroup> map = parse(d => marketDataDate.Equals(d), groupsResource.CharSource, settingsResource.CharSource, curveCharSources);
return(ImmutableList.copyOf(map.get(marketDataDate)));
}
/// <summary>
/// Gets all rates curves.
/// </summary>
/// <returns> the map of all rates curves </returns>
public virtual SortedDictionary <LocalDate, RatesCurveGroup> loadAllRatesCurves()
{
if (!subdirectoryExists(CURVES_DIR))
{
throw new System.ArgumentException("No rates curves directory found");
}
ResourceLocator curveGroupsResource = getResource(CURVES_DIR, CURVES_GROUPS_FILE);
if (curveGroupsResource == null)
{
throw new System.ArgumentException(Messages.format("Unable to load rates curves: curve groups file not found at {}/{}", CURVES_DIR, CURVES_GROUPS_FILE));
}
ResourceLocator curveSettingsResource = getResource(CURVES_DIR, CURVES_SETTINGS_FILE);
if (curveSettingsResource == null)
{
throw new System.ArgumentException(Messages.format("Unable to load rates curves: curve settings file not found at {}/{}", CURVES_DIR, CURVES_SETTINGS_FILE));
}
ListMultimap <LocalDate, RatesCurveGroup> curveGroups = RatesCurvesCsvLoader.loadAllDates(curveGroupsResource, curveSettingsResource, RatesCurvesResources);
// There is only one curve group in the market data file so this will always succeed
IDictionary <LocalDate, RatesCurveGroup> curveGroupMap = Maps.transformValues(curveGroups.asMap(), groups => groups.GetEnumerator().next());
return(new SortedDictionary <>(curveGroupMap));
}
public MaxRunningAppsEnforcer(FairScheduler scheduler)
{
// Tracks the number of running applications by user.
this.scheduler = scheduler;
this.usersNumRunnableApps = new Dictionary <string, int>();
this.usersNonRunnableApps = ArrayListMultimap.Create();
}
// find all trade IDs by party herf id
private ListMultimap <string, StandardId> parseAllTradeIds(XmlElement tradeHeaderEl)
{
// look through each partyTradeIdentifier
ListMultimap <string, StandardId> allIds = ArrayListMultimap.create();
IList <XmlElement> partyTradeIdentifierEls = tradeHeaderEl.getChildren("partyTradeIdentifier");
foreach (XmlElement partyTradeIdentifierEl in partyTradeIdentifierEls)
{
Optional <XmlElement> partyRefOptEl = partyTradeIdentifierEl.findChild("partyReference");
if (partyRefOptEl.Present && partyRefOptEl.get().findAttribute(HREF).Present)
{
string partyHref = partyRefOptEl.get().findAttribute(HREF).get();
// try to find a tradeId, either in versionedTradeId or as a direct child
Optional <XmlElement> vtradeIdOptEl = partyTradeIdentifierEl.findChild("versionedTradeId");
Optional <XmlElement> tradeIdOptEl = vtradeIdOptEl.map(vt => vt.getChild("tradeId")).orElse(partyTradeIdentifierEl.findChild("tradeId"));
if (tradeIdOptEl.Present && tradeIdOptEl.get().findAttribute("tradeIdScheme").Present)
{
XmlElement tradeIdEl = tradeIdOptEl.get();
string scheme = tradeIdEl.getAttribute("tradeIdScheme");
// ignore if there is an empty scheme or value
if (scheme.Length > 0 && tradeIdEl.Content.Length > 0)
{
allIds.put(partyHref, StandardId.of(StandardId.encodeScheme(scheme), tradeIdEl.Content));
}
}
}
}
return(allIds);
}
// creates the tasks for a single target
private static IList <CalculationTask> createTargetTasks <T1>(CalculationTarget resolvedTarget, int rowIndex, CalculationFunction <T1> function, IList <Column> columns)
{
// create the cells and group them
ListMultimap <CalculationParameters, CalculationTaskCell> grouped = ArrayListMultimap.create();
for (int colIndex = 0; colIndex < columns.Count; colIndex++)
{
Column column = columns[colIndex];
Measure measure = column.Measure;
ReportingCurrency reportingCurrency = column.ReportingCurrency.orElse(ReportingCurrency.NATURAL);
CalculationTaskCell cell = CalculationTaskCell.of(rowIndex, colIndex, measure, reportingCurrency);
// group to find cells that can be shared, with same mappings and params (minus reporting currency)
CalculationParameters @params = column.Parameters.filter(resolvedTarget, measure);
grouped.put(@params, cell);
}
// build tasks
ImmutableList.Builder <CalculationTask> taskBuilder = ImmutableList.builder();
foreach (CalculationParameters @params in grouped.Keys)
{
taskBuilder.add(CalculationTask.of(resolvedTarget, function, @params, grouped.get(@params)));
}
return(taskBuilder.build());
}
// parse a single file
private void parse(CharSource charSource, ListMultimap <string, CurveSensitivities> parsed, IList <FailureItem> failures)
{
try
{
using (CsvIterator csv = CsvIterator.of(charSource, true))
{
if (!csv.containsHeader(TENOR_HEADER) && !csv.containsHeader(DATE_HEADER))
{
failures.Add(FailureItem.of(FailureReason.PARSING, "CSV file could not be parsed as sensitivities, invalid format"));
}
else if (csv.containsHeader(REFERENCE_HEADER) && csv.containsHeader(TYPE_HEADER) && csv.containsHeader(VALUE_HEADER))
{
parseStandardFormat(csv, parsed, failures);
}
else if (csv.containsHeader(REFERENCE_HEADER))
{
parseListFormat(csv, parsed, failures);
}
else
{
parseGridFormat(csv, parsed, failures);
}
}
}
catch (Exception ex)
{
failures.Add(FailureItem.of(FailureReason.PARSING, ex, "CSV file could not be parsed: {}", ex.Message));
}
}
//-------------------------------------------------------------------------
public virtual void toListMultimap()
{
IDictionary <string, int> map = ImmutableMap.of("a", 1, "aa", 2, "b", 10, "bb", 20, "c", 1);
ListMultimap <string, int> expected = ImmutableListMultimap.of("a", 1, "a", 2, "b", 10, "b", 20, "c", 1);
ListMultimap <string, int> result = MapStream.of(map).mapKeys(s => s.substring(0, 1)).toListMultimap();
assertThat(result).isEqualTo(expected);
}
//-------------------------------------------------------------------------
// parses the file in grid format
private void parseGridFormat(CsvIterator csv, ListMultimap <string, CurveSensitivities> parsed, IList <FailureItem> failures)
{
// find the applicable reference columns
IDictionary <string, CurveName> references = new LinkedHashMap <string, CurveName>();
foreach (string header in csv.headers())
{
string headerLowerCase = header.ToLower(Locale.ENGLISH);
if (!REF_HEADERS.contains(headerLowerCase) && !resolver.isInfoColumn(headerLowerCase))
{
references[header] = CurveName.of(header);
}
}
// loop around all rows, peeking to match batches with the same identifier
// no exception catch at this level to avoid infinite loops
while (csv.hasNext())
{
CsvRow peekedRow = csv.peek();
PortfolioItemInfo info = parseInfo(peekedRow);
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
string id = info.Id.map(StandardId::toString).orElse("");
// process in batches, where the ID is the same
CurveSensitivitiesBuilder builder = CurveSensitivities.builder(info);
IList <CsvRow> batchRows = csv.nextBatch(r => matchId(r, id));
foreach (CsvRow batchRow in batchRows)
{
try
{
ParameterMetadata metadata = parseMetadata(batchRow, true);
CurveSensitivitiesType type = batchRow.findValue(TYPE_HEADER).map(str => CurveSensitivitiesType.of(str)).orElse(CurveSensitivitiesType.ZERO_RATE_DELTA);
foreach (KeyValuePair <string, CurveName> entry in references.SetOfKeyValuePairs())
{
CurveName reference = entry.Value;
CurveName resolvedCurveName = resolver.checkCurveName(reference);
string valueStr = batchRow.getField(entry.Key);
Currency currency = parseCurrency(batchRow, reference);
if (valueStr.Length > 0)
{
double value = LoaderUtils.parseDouble(valueStr);
builder.add(type, resolvedCurveName, currency, metadata, value);
}
}
}
catch (System.ArgumentException ex)
{
failures.Add(FailureItem.of(PARSING, "CSV file could not be parsed at line {}: {}", batchRow.lineNumber(), ex.Message));
}
}
CurveSensitivities sens = builder.build();
if (!sens.TypedSensitivities.Empty)
{
parsed.put(sens.Id.map(object.toString).orElse(""), sens);
}
}
}
// parse all the root-level party elements
private static ImmutableListMultimap <string, string> parseParties(XmlElement root)
{
ListMultimap <string, string> parties = ArrayListMultimap.create();
foreach (XmlElement child in root.getChildren("party"))
{
parties.putAll(child.getAttribute(ID), findPartyIds(child));
}
return(ImmutableListMultimap.copyOf(parties));
}
//-------------------------------------------------------------------------
/// <summary>
/// Parses one or more CSV format position files, returning sensitivities.
/// <para>
/// The standard way to write sensitivities files is for each file to contain one sensitivity instance.
/// The file format can handle multiple instances per file, where each instance has a separate identifier.
/// Most files will not have the identifier columns, thus the identifier will be the empty string.
/// </para>
/// <para>
/// The returned multimap is keyed by identifier. The value will contain one entry for each instance.
/// If desired, the results can be reduced using <seealso cref="CurveSensitivities#mergedWith(CurveSensitivities)"/>
/// to merge those with the same identifier.
/// </para>
/// <para>
/// CSV files sometimes contain a Unicode Byte Order Mark.
/// Callers are responsible for handling this, such as by using <seealso cref="UnicodeBom"/>.
///
/// </para>
/// </summary>
/// <param name="charSources"> the CSV character sources </param>
/// <returns> the loaded sensitivities, parsing errors are captured in the result </returns>
public ValueWithFailures <ListMultimap <string, CurveSensitivities> > parse(ICollection <CharSource> charSources)
{
ListMultimap <string, CurveSensitivities> parsed = ArrayListMultimap.create();
IList <FailureItem> failures = new List <FailureItem>();
foreach (CharSource charSource in charSources)
{
parse(charSource, parsed, failures);
}
return(ValueWithFailures.of(ImmutableListMultimap.copyOf(parsed), failures));
}
//-------------------------------------------------------------------------
// parses the file in standard format
private void parseStandardFormat(CsvIterator csv, ListMultimap <string, CurveSensitivities> parsed, IList <FailureItem> failures)
{
// loop around all rows, peeking to match batches with the same identifier
// no exception catch at this level to avoid infinite loops
while (csv.hasNext())
{
CsvRow peekedRow = csv.peek();
PortfolioItemInfo info = parseInfo(peekedRow);
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
string id = info.Id.map(StandardId::toString).orElse("");
// process in batches, where the ID is the same
CurveSensitivitiesBuilder builder = CurveSensitivities.builder(info);
IList <CsvRow> batchRows = csv.nextBatch(r => matchId(r, id));
foreach (CsvRow batchRow in batchRows)
{
try
{
CurveName reference = CurveName.of(batchRow.getValue(REFERENCE_HEADER));
CurveName resolvedCurveName = resolver.checkCurveName(reference);
CurveSensitivitiesType type = CurveSensitivitiesType.of(batchRow.getValue(TYPE_HEADER));
ParameterMetadata metadata = parseMetadata(batchRow, false);
Currency currency = parseCurrency(batchRow, reference);
string valueStr = batchRow.getField(VALUE_HEADER);
if (valueStr.Length > 0)
{
double value = LoaderUtils.parseDouble(valueStr);
builder.add(type, resolvedCurveName, currency, metadata, value);
}
}
catch (System.ArgumentException ex)
{
failures.Add(FailureItem.of(PARSING, "CSV file could not be parsed at line {}: {}", batchRow.lineNumber(), ex.Message));
}
}
CurveSensitivities sens = builder.build();
if (!sens.TypedSensitivities.Empty)
{
parsed.put(sens.Id.map(object.toString).orElse(""), sens);
}
}
}