public virtual void test_quote_secenarioDefinition()
{
//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);
ScenarioMarketData marketDataCalibrated = StandardComponents.marketDataFactory().createMultiScenario(REQUIREMENTS, SCENARIO_CONFIG, MARKET_DATA, REF_DATA, scenarioDefinition);
Results results = CALC_RUNNER.calculateMultiScenario(RULES, TARGETS, COLUMN, marketDataCalibrated, REF_DATA);
CurrencyScenarioArray pvs = results.get(0, 0, typeof(CurrencyScenarioArray)).Value;
for (int i = 0; i < nScenarios; ++i)
{
ImmutableMap.Builder <QuoteId, double> builder = ImmutableMap.builder();
foreach (KeyValuePair <QuoteId, double> entry in MARKET_QUOTES.entrySet())
{
builder.put(entry.Key, entry.Value * Math.Pow(0.9, i));
}
ImmutableMarketData shiftedMarketData = ImmutableMarketData.builder(VALUATION_DATE).addValueMap(builder.build()).addValueMap(MARKET_FX_QUOTES).build();
MarketData shiftedMarketDataCalibrated = StandardComponents.marketDataFactory().create(REQUIREMENTS, CONFIG, shiftedMarketData, REF_DATA);
Results shiftedResults = CALC_RUNNER.calculate(RULES, TARGETS, COLUMN, shiftedMarketDataCalibrated, REF_DATA);
CurrencyAmount pv = shiftedResults.get(0, 0, typeof(CurrencyAmount)).Value;
assertEquals(pvs.get(i), pv);
}
}
/// <summary>
/// Calculates the present value sensitivity of the FX barrier option product.
/// <para>
/// The present value sensitivity of the product is the sensitivity of <seealso cref="#presentValue"/> to
/// the underlying curve parameters.
/// </para>
/// <para>
/// The sensitivity is computed by bump and re-price.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <param name="baseTreeData"> the trinomial tree data </param>
/// <returns> the present value of the product </returns>
public virtual CurrencyParameterSensitivities presentValueSensitivityRates(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities, RecombiningTrinomialTreeData baseTreeData)
{
ArgChecker.isTrue(baseTreeData.NumberOfSteps == calibrator.NumberOfSteps, "the number of steps mismatch between pricer and trinomial tree data");
double shift = 1.0e-5;
CurrencyAmount pvBase = presentValue(option, ratesProvider, volatilities, baseTreeData);
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
ResolvedFxSingle underlyingFx = underlyingOption.Underlying;
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
ImmutableRatesProvider immRatesProvider = ratesProvider.toImmutableRatesProvider();
ImmutableMap <Currency, Curve> baseCurves = immRatesProvider.DiscountCurves;
CurrencyParameterSensitivities result = CurrencyParameterSensitivities.empty();
foreach (KeyValuePair <Currency, Curve> entry in baseCurves.entrySet())
{
if (currencyPair.contains(entry.Key))
{
Curve curve = entry.Value;
int nParams = curve.ParameterCount;
DoubleArray sensitivity = DoubleArray.of(nParams, i =>
{
Curve dscBumped = curve.withParameter(i, curve.getParameter(i) + shift);
IDictionary <Currency, Curve> mapBumped = new Dictionary <Currency, Curve>(baseCurves);
mapBumped[entry.Key] = dscBumped;
ImmutableRatesProvider providerDscBumped = immRatesProvider.toBuilder().discountCurves(mapBumped).build();
double pvBumped = presentValue(option, providerDscBumped, volatilities).Amount;
return((pvBumped - pvBase.Amount) / shift);
});
result = result.combinedWith(curve.createParameterSensitivity(pvBase.Currency, sensitivity));
}
}
return(result);
}
/// <summary>
/// Returns a string summary of the element.
/// <para>
/// The string form includes the attributes and content, but summarizes the child elements.
///
/// </para>
/// </summary>
/// <returns> the string form </returns>
public override string ToString()
{
StringBuilder buf = new StringBuilder(512);
buf.Append('<').Append(name);
foreach (KeyValuePair <string, string> entry in attributes.entrySet())
{
buf.Append(' ').Append(entry.Key).Append('=').Append('"').Append(entry.Value).Append('"');
}
buf.Append('>');
if (children.Empty)
{
buf.Append(content);
}
else
{
foreach (XmlElement child in children)
{
buf.Append(Environment.NewLine).Append(" <").Append(child.Name).Append(" ... />");
}
buf.Append(Environment.NewLine);
}
buf.Append("</").Append(name).Append('>');
return(buf.ToString());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ImmutableValidator private void validate()
private void validate()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (java.util.Map.Entry<Class, CalculationFunction<?>> entry : functions.entrySet())
foreach (KeyValuePair <Type, CalculationFunction <object> > entry in functions.entrySet())
{
ArgChecker.isTrue(entry.Key.IsAssignableFrom(entry.Value.targetType()), "Invalid map, key and function mismatch: {} and {}", entry.Key, entry.Value.targetType());
}
}
/// <summary>
/// Looks up the external name given a standard enum instance.
/// <para>
/// This searches the map of external names and returns the first matching entry
/// that maps to the given standard name.
///
/// </para>
/// </summary>
/// <param name="namedEnum"> the named enum to find an external name for </param>
/// <returns> the external name </returns>
/// <exception cref="IllegalArgumentException"> if there is no external name </exception>
public string reverseLookup(T namedEnum)
{
string name = namedEnum.Name;
foreach (KeyValuePair <string, string> entry in externalNames_Renamed.entrySet())
{
if (entry.Value.Equals(name))
{
return(entry.Key);
}
}
throw new System.ArgumentException(Messages.format("{}:{} external name not found for standard name: {}", extendedEnum.type.Name, group, name));
}
// append the explanation with indent
private void explanationString(StringBuilder buf, string indent)
{
buf.Append("{").Append(Environment.NewLine);
string entryIndent = indent + " ";
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (java.util.Map.Entry<ExplainKey<?>, Object> entry : map.entrySet())
foreach (KeyValuePair <ExplainKey <object>, object> entry in map.entrySet())
{
buf.Append(entryIndent).Append(entry.Key).Append(" = ");
if (entry.Value is System.Collections.IList)
{
// list
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") java.util.List<ExplainMap> list = (java.util.List<ExplainMap>) entry.getValue();
IList <ExplainMap> list = (IList <ExplainMap>)entry.Value;
explanationString(buf, entryIndent, list);
}
else
{
// single entry
try
{
buf.Append(StringConvert.INSTANCE.convertToString(entry.Value));
}
catch (Exception)
{
buf.Append(entry.Value);
}
}
buf.Append(',').Append(Environment.NewLine);
}
if (!map.entrySet().Empty)
{
buf.Remove(buf.lastIndexOf(","), 1);
}
buf.Append(indent).Append("}");
}
private double sumMod(ImmutableRatesProvider provider)
{
double result = 0.0;
// Index
ImmutableMap <Index, Curve> mapIndex = provider.IndexCurves;
foreach (KeyValuePair <Index, Curve> entry in mapIndex.entrySet())
{
if (entry.Key is IborIndex)
{
InterpolatedNodalCurve curveInt = checkInterpolated(entry.Value);
result += sumSingle(curveInt);
}
}
return(result);
}
// modified sensitivity function - sensitivities are computed only for ibor index curves
private CurrencyParameterSensitivities sensiModFn(ImmutableRatesProvider provider)
{
CurrencyParameterSensitivities sensi = CurrencyParameterSensitivities.empty();
// Index
ImmutableMap <Index, Curve> mapIndex = provider.IndexCurves;
foreach (KeyValuePair <Index, Curve> entry in mapIndex.entrySet())
{
if (entry.Key is IborIndex)
{
InterpolatedNodalCurve curveInt = checkInterpolated(entry.Value);
double sumSqrt = sumMod(provider);
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(curveInt.Name, USD, DoubleArray.of(curveInt.ParameterCount, i => 2d * sumSqrt * curveInt.XValues.get(i))));
}
}
return(sensi);
}
private double sumCombine(ImmutableRatesProvider provider)
{
double result = 0.0;
// Currency
ImmutableMap <Currency, Curve> mapCurrency = provider.DiscountCurves;
foreach (KeyValuePair <Currency, Curve> entry in mapCurrency.entrySet())
{
if (entry.Value is CombinedCurve)
{
InterpolatedNodalCurve baseCurveInt = checkInterpolated(entry.Value.Split().get(0));
InterpolatedNodalCurve spreadCurveInt = checkInterpolated(entry.Value.Split().get(1));
result += 0.25d * sumSingle(baseCurveInt);
result += sumSingle(spreadCurveInt);
}
else
{
InterpolatedNodalCurve curveInt = checkInterpolated(entry.Value);
result += sumSingle(curveInt);
}
}
// Index
ImmutableMap <Index, Curve> mapIndex = provider.IndexCurves;
foreach (KeyValuePair <Index, Curve> entry in mapIndex.entrySet())
{
if (entry.Value is CombinedCurve)
{
InterpolatedNodalCurve baseCurveInt = checkInterpolated(entry.Value.Split().get(0));
InterpolatedNodalCurve spreadCurveInt = checkInterpolated(entry.Value.Split().get(1));
result += 0.25d * sumSingle(baseCurveInt);
result += sumSingle(spreadCurveInt);
}
else
{
InterpolatedNodalCurve curveInt = checkInterpolated(entry.Value);
result += entry.Key.Equals(IborIndices.USD_LIBOR_3M) ? 0.25d * sumSingle(curveInt) : sumSingle(curveInt);
}
}
return(result);
}
private double sum(ImmutableRatesProvider provider)
{
double result = 0.0;
// Currency
ImmutableMap <Currency, Curve> mapCurrency = provider.DiscountCurves;
foreach (KeyValuePair <Currency, Curve> entry in mapCurrency.entrySet())
{
InterpolatedNodalCurve curveInt = checkInterpolated(entry.Value);
result += sumSingle(curveInt);
}
// Index
ImmutableMap <Index, Curve> mapIndex = provider.IndexCurves;
foreach (KeyValuePair <Index, Curve> entry in mapIndex.entrySet())
{
InterpolatedNodalCurve curveInt = checkInterpolated(entry.Value);
result += sumSingle(curveInt);
}
return(result);
}
// private function for testing. Returns the sum of rates multiplied by time
private CurrencyAmount creditFunction(ImmutableCreditRatesProvider provider)
{
double result = 0.0;
// credit curve
ImmutableMap <Pair <StandardId, Currency>, LegalEntitySurvivalProbabilities> mapCredit = provider.metaBean().creditCurves().get(provider);
foreach (KeyValuePair <Pair <StandardId, Currency>, LegalEntitySurvivalProbabilities> entry in mapCredit.entrySet())
{
InterpolatedNodalCurve curveInt = checkInterpolated(checkDiscountFactors(entry.Value.SurvivalProbabilities.toDiscountFactors()));
result += sumProduct(curveInt);
}
// repo curve
ImmutableMap <Currency, CreditDiscountFactors> mapDiscount = provider.metaBean().discountCurves().get(provider);
foreach (KeyValuePair <Currency, CreditDiscountFactors> entry in mapDiscount.entrySet())
{
InterpolatedNodalCurve curveInt = checkInterpolated(checkDiscountFactors(entry.Value.toDiscountFactors()));
result += sumProduct(curveInt);
}
return(CurrencyAmount.of(USD, result));
}
// modified sensitivity function - CombinedCurve involved
private CurrencyParameterSensitivities sensiCombinedFn(ImmutableRatesProvider provider)
{
CurrencyParameterSensitivities sensi = CurrencyParameterSensitivities.empty();
double sum = sumCombine(provider);
// Currency
ImmutableMap <Currency, Curve> mapCurrency = provider.DiscountCurves;
foreach (KeyValuePair <Currency, Curve> entry in mapCurrency.entrySet())
{
CombinedCurve curveComb = (CombinedCurve)entry.Value;
InterpolatedNodalCurve baseCurveInt = checkInterpolated(curveComb.BaseCurve);
InterpolatedNodalCurve spreadCurveInt = checkInterpolated(curveComb.SpreadCurve);
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(baseCurveInt.Name, USD, DoubleArray.of(baseCurveInt.ParameterCount, i => 2d * sum * baseCurveInt.XValues.get(i))));
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(spreadCurveInt.Name, USD, DoubleArray.of(spreadCurveInt.ParameterCount, i => 2d * sum * spreadCurveInt.XValues.get(i))));
}
// Index
ImmutableMap <Index, Curve> mapIndex = provider.IndexCurves;
foreach (KeyValuePair <Index, Curve> entry in mapIndex.entrySet())
{
if (entry.Value is CombinedCurve)
{
CombinedCurve curveComb = (CombinedCurve)entry.Value;
InterpolatedNodalCurve baseCurveInt = checkInterpolated(curveComb.BaseCurve);
InterpolatedNodalCurve spreadCurveInt = checkInterpolated(curveComb.SpreadCurve);
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(baseCurveInt.Name, USD, DoubleArray.of(baseCurveInt.ParameterCount, i => 2d * sum * baseCurveInt.XValues.get(i))));
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(spreadCurveInt.Name, USD, DoubleArray.of(spreadCurveInt.ParameterCount, i => 2d * sum * spreadCurveInt.XValues.get(i))));
}
else
{
InterpolatedNodalCurve curveInt = checkInterpolated(entry.Value);
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(curveInt.Name, USD, DoubleArray.of(curveInt.ParameterCount, i => 2d * sum * curveInt.XValues.get(i))));
}
}
return(sensi);
}
private double sum(ImmutableLegalEntityDiscountingProvider provider)
{
double result = 0d;
// repo curves
ImmutableMap <Pair <RepoGroup, Currency>, DiscountFactors> mapIndex = provider.RepoCurves;
foreach (KeyValuePair <Pair <RepoGroup, Currency>, DiscountFactors> entry in mapIndex.entrySet())
{
InterpolatedNodalCurve curve = (InterpolatedNodalCurve)getCurve(entry.Value);
result += sumSingle(curve);
}
// issuer curves
ImmutableMap <Pair <LegalEntityGroup, Currency>, DiscountFactors> mapCurrency = provider.IssuerCurves;
foreach (KeyValuePair <Pair <LegalEntityGroup, Currency>, DiscountFactors> entry in mapCurrency.entrySet())
{
InterpolatedNodalCurve curve = (InterpolatedNodalCurve)getCurve(entry.Value);
result += sumSingle(curve);
}
return(result);
}
// modified sensitivity function - CombinedCurve involved
private CurrencyParameterSensitivities sensiCombinedFnBond(ImmutableLegalEntityDiscountingProvider provider)
{
CurrencyParameterSensitivities sensi = CurrencyParameterSensitivities.empty();
double sum = sumCombine(provider);
// repo curves
ImmutableMap <Pair <RepoGroup, Currency>, DiscountFactors> mapCurrency = provider.RepoCurves;
foreach (KeyValuePair <Pair <RepoGroup, Currency>, DiscountFactors> entry in mapCurrency.entrySet())
{
CombinedCurve curveComb = (CombinedCurve)getCurve(entry.Value);
InterpolatedNodalCurve baseCurveInt = checkInterpolated(curveComb.BaseCurve);
InterpolatedNodalCurve spreadCurveInt = checkInterpolated(curveComb.SpreadCurve);
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(baseCurveInt.Name, USD, DoubleArray.of(baseCurveInt.ParameterCount, i => 2d * sum * baseCurveInt.XValues.get(i))));
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(spreadCurveInt.Name, USD, DoubleArray.of(spreadCurveInt.ParameterCount, i => 2d * sum * spreadCurveInt.XValues.get(i))));
}
// issuer curves
ImmutableMap <Pair <LegalEntityGroup, Currency>, DiscountFactors> mapIndex = provider.IssuerCurves;
foreach (KeyValuePair <Pair <LegalEntityGroup, Currency>, DiscountFactors> entry in mapIndex.entrySet())
{
CombinedCurve curveComb = (CombinedCurve)getCurve(entry.Value);
InterpolatedNodalCurve baseCurveInt = checkInterpolated(curveComb.BaseCurve);
InterpolatedNodalCurve spreadCurveInt = checkInterpolated(curveComb.SpreadCurve);
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(baseCurveInt.Name, USD, DoubleArray.of(baseCurveInt.ParameterCount, i => 2d * sum * baseCurveInt.XValues.get(i))));
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(spreadCurveInt.Name, USD, DoubleArray.of(spreadCurveInt.ParameterCount, i => 2d * sum * spreadCurveInt.XValues.get(i))));
}
return(sensi);
}
//-------------------------------------------------------------------------
private CurrencyParameterSensitivities sensiFnBond(ImmutableLegalEntityDiscountingProvider provider)
{
CurrencyParameterSensitivities sensi = CurrencyParameterSensitivities.empty();
double sum = this.sum(provider);
// repo curves
ImmutableMap <Pair <RepoGroup, Currency>, DiscountFactors> mapRepoCurves = provider.RepoCurves;
foreach (KeyValuePair <Pair <RepoGroup, Currency>, DiscountFactors> entry in mapRepoCurves.entrySet())
{
DiscountFactors discountFactors = entry.Value;
InterpolatedNodalCurve curve = (InterpolatedNodalCurve)getCurve(discountFactors);
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(curve.Name, discountFactors.Currency, DoubleArray.of(discountFactors.ParameterCount, i => 2d * curve.XValues.get(i) * sum)));
}
// issuer curves
ImmutableMap <Pair <LegalEntityGroup, Currency>, DiscountFactors> mapIssuerCurves = provider.IssuerCurves;
foreach (KeyValuePair <Pair <LegalEntityGroup, Currency>, DiscountFactors> entry in mapIssuerCurves.entrySet())
{
DiscountFactors discountFactors = entry.Value;
InterpolatedNodalCurve curve = (InterpolatedNodalCurve)getCurve(discountFactors);
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(curve.Name, discountFactors.Currency, DoubleArray.of(discountFactors.ParameterCount, i => 2d * curve.XValues.get(i) * sum)));
}
return(sensi);
}
// private function for testing. Returns the sum of rates multiplied by time
private CurrencyAmount fn(ImmutableLegalEntityDiscountingProvider provider)
{
double result = 0.0;
// issuer curve
ImmutableMap <Pair <LegalEntityGroup, Currency>, DiscountFactors> mapLegal = provider.metaBean().issuerCurves().get(provider);
foreach (KeyValuePair <Pair <LegalEntityGroup, Currency>, DiscountFactors> entry in mapLegal.entrySet())
{
InterpolatedNodalCurve curveInt = checkInterpolated(checkDiscountFactors(entry.Value));
result += sumProduct(curveInt);
}
// repo curve
ImmutableMap <Pair <RepoGroup, Currency>, DiscountFactors> mapRepo = provider.metaBean().repoCurves().get(provider);
foreach (KeyValuePair <Pair <RepoGroup, Currency>, DiscountFactors> entry in mapRepo.entrySet())
{
InterpolatedNodalCurve curveInt = checkInterpolated(checkDiscountFactors(entry.Value));
result += sumProduct(curveInt);
}
return(CurrencyAmount.of(USD, result));
}
