public virtual void discountFactors_curveName()
{
CurveMetadata test = Curves.discountFactors(CURVE_NAME, ACT_360);
CurveMetadata expected = DefaultCurveMetadata.builder().curveName(CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.DISCOUNT_FACTOR).dayCount(ACT_360).build();
assertEquals(test, expected);
}
public virtual void zeroRates_curveName()
{
CurveMetadata test = Curves.zeroRates(CURVE_NAME, ACT_360);
CurveMetadata expected = DefaultCurveMetadata.builder().curveName(CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(ACT_360).build();
assertEquals(test, expected);
}
public virtual void forwardRates_curveNameParams()
{
CurveMetadata test = Curves.forwardRates(CURVE_NAME, ACT_360, PARAMS);
CurveMetadata expected = DefaultCurveMetadata.builder().curveName(CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.FORWARD_RATE).dayCount(ACT_360).parameterMetadata(PARAMS).build();
assertEquals(test, expected);
}
public virtual void sabrParameterByExpiry_curveNameParams()
{
CurveMetadata test = Curves.sabrParameterByExpiry(CURVE_NAME, ACT_365F, ValueType.SABR_NU, PARAMS);
CurveMetadata expected = DefaultCurveMetadata.builder().curveName(CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.SABR_NU).dayCount(ACT_365F).parameterMetadata(PARAMS).build();
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void recoveryRates_string()
{
CurveMetadata test = Curves.recoveryRates(NAME, ACT_360);
CurveMetadata expected = DefaultCurveMetadata.builder().curveName(CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.RECOVERY_RATE).dayCount(ACT_360).build();
assertEquals(test, expected);
}
public virtual void blackVolatilityByExpiry_curveNameParams()
{
CurveMetadata test = Curves.blackVolatilityByExpiry(CURVE_NAME, ACT_360, PARAMS);
CurveMetadata expected = DefaultCurveMetadata.builder().curveName(CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.BLACK_VOLATILITY).dayCount(ACT_360).parameterMetadata(PARAMS).build();
assertEquals(test, expected);
}
static BondFuturesJpyEnd2EndTest()
{
for (int i = 0; i < NB_UND_BONDS; ++i)
{
PeriodicSchedule periodSchedule = PeriodicSchedule.of(START_DATE[i], MATURITY_DATE[i], Frequency.P6M, BUSINESS_ADJUST, StubConvention.SHORT_INITIAL, false);
FixedCouponBond product = FixedCouponBond.builder().securityId(SecurityId.of(BOND_SECURITY_ID[i])).dayCount(DAY_COUNT).fixedRate(UND_RATES[i] * ONE_PERCENT).legalEntityId(ISSUER_ID).currency(JPY).notional(NOTIONAL).accrualSchedule(periodSchedule).settlementDateOffset(SETTLEMENT_DAYS).yieldConvention(YIELD_CONVENTION).build();
UND_BOND[i] = product;
}
UND_BOND_SEP = new FixedCouponBond[NB_UND_BONDS - 2];
Array.Copy(UND_BOND, 2, UND_BOND_SEP, 0, NB_UND_BONDS - 2);
UND_BOND_JUN = new FixedCouponBond[NB_UND_BONDS - 1];
Array.Copy(UND_BOND, 1, UND_BOND_JUN, 0, NB_UND_BONDS - 1);
double[] timeIssuer = new double[] { 0.25136612021857924, 0.4972677595628415, 1.0139980537465378, 2.013998053746538, 2.857833670184894, 3.857833670184894, 4.860655737704918, 5.857833670184894, 7.104409012650647, 7.857833670184894, 8.857923497267759, 9.863313122239688, 14.857833670184894, 19.857833670184895, 29.857833670184895, 39.11262819073284 };
double[] rateIssuer = new double[] { -0.0013117084834668065, -0.0010851901424876163, -0.0020906775838723216, -0.0022137102045172784, -0.0022695678374162888, -0.0023424568490920798, -0.0021603059162879916, -0.0021667343131861225, -0.0018285921969274823, -0.001355094018965514, -6.763044056712535E-4, 1.9555294306801752E-4, 0.003944125562941363, 0.008054233458390252, 0.012276105941434846, 0.013537766297065804 };
double[] timeRepo = new double[] { 0.00273224043715847, 0.01912568306010929, 0.040983606557377046, 0.05737704918032787, 0.07923497267759563, 0.2459016393442623, 0.4972677595628415, 1.0002994236095515 };
double[] rateRepo = new double[] { 2.599662058772748E-4, -8.403529976927196E-4, -0.0010105103936934236, -0.0011506617573950931, -0.0012708071334455143, -0.00146106683851595, -0.0014710815100096722, -0.001481096281798276 };
CurveMetadata metaIssuer = Curves.zeroRates(ISSUER_CURVE_NAME, ACT_ACT_ISDA);
InterpolatedNodalCurve curveIssuer = InterpolatedNodalCurve.of(metaIssuer, DoubleArray.copyOf(timeIssuer), DoubleArray.copyOf(rateIssuer), INTERPOLATOR);
DiscountFactors dscIssuer = ZeroRateDiscountFactors.of(JPY, VALUATION, curveIssuer);
CurveMetadata metaRepo = Curves.zeroRates(REPO_CURVE_NAME, ACT_ACT_ISDA);
InterpolatedNodalCurve curve = InterpolatedNodalCurve.of(metaRepo, DoubleArray.copyOf(timeRepo), DoubleArray.copyOf(rateRepo), INTERPOLATOR);
DiscountFactors dscRepo = ZeroRateDiscountFactors.of(JPY, VALUATION, curve);
LED_PROVIDER = ImmutableLegalEntityDiscountingProvider.builder().issuerCurves(ImmutableMap.of(Pair.of(GROUP_ISSUER, JPY), dscIssuer)).issuerCurveGroups(ImmutableMap.of(ISSUER_ID, GROUP_ISSUER)).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO, JPY), dscRepo)).repoCurveGroups(ImmutableMap.of(ISSUER_ID, GROUP_REPO)).build();
}
//-------------------------------------------------------------------------
public override NodalCurve calibrate(IList <ResolvedCdsTrade> calibrationCDSs, DoubleArray premiums, DoubleArray pointsUpfront, CurveName name, LocalDate valuationDate, CreditDiscountFactors discountFactors, RecoveryRates recoveryRates, ReferenceData refData)
{
int n = calibrationCDSs.Count;
double[] guess = new double[n];
double[] t = new double[n];
double[] lgd = new double[n];
for (int i = 0; i < n; i++)
{
LocalDate endDate = calibrationCDSs[i].Product.ProtectionEndDate;
t[i] = discountFactors.relativeYearFraction(endDate);
lgd[i] = 1d - recoveryRates.recoveryRate(endDate);
guess[i] = (premiums.get(i) + pointsUpfront.get(i) / t[i]) / lgd[i];
}
DoubleArray times = DoubleArray.ofUnsafe(t);
CurveMetadata baseMetadata = DefaultCurveMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).curveName(name).dayCount(discountFactors.DayCount).build();
NodalCurve creditCurve = n == 1 ? ConstantNodalCurve.of(baseMetadata, t[0], guess[0]) : InterpolatedNodalCurve.of(baseMetadata, times, DoubleArray.ofUnsafe(guess), CurveInterpolators.PRODUCT_LINEAR, CurveExtrapolators.FLAT, CurveExtrapolators.PRODUCT_LINEAR);
for (int i = 0; i < n; i++)
{
System.Func <double, double> func = getPriceFunction(i, calibrationCDSs[i], premiums.get(i), pointsUpfront.get(i), valuationDate, creditCurve, discountFactors, recoveryRates, refData);
double[] bracket = BRACKER.getBracketedPoints(func, 0.8 * guess[i], 1.25 * guess[i], 0.0, double.PositiveInfinity);
double zeroRate = bracket[0] > bracket[1] ? ROOTFINDER.getRoot(func, bracket[1], bracket[0]) : ROOTFINDER.getRoot(func, bracket[0], bracket[1]); //Negative guess handled
creditCurve = creditCurve.withParameter(i, zeroRate);
}
return(creditCurve);
}
//-------------------------------------------------------------------------
public virtual void prices_string()
{
CurveMetadata test = Curves.prices(NAME);
CurveMetadata expected = DefaultCurveMetadata.builder().curveName(CURVE_NAME).xValueType(ValueType.MONTHS).yValueType(ValueType.PRICE_INDEX).build();
assertEquals(test, expected);
}
public override Builder set(string propertyName, object newValue)
{
switch (propertyName.GetHashCode())
{
case -450004177: // metadata
this.metadata_Renamed = (CurveMetadata)newValue;
break;
case 1681280954: // xValues
this.xValues_Renamed = (DoubleArray)newValue;
break;
case -1726182661: // yValues
this.yValues_Renamed = (DoubleArray)newValue;
break;
case 2096253127: // interpolator
this.interpolator_Renamed = (CurveInterpolator)newValue;
break;
case 1271703994: // extrapolatorLeft
this.extrapolatorLeft_Renamed = (CurveExtrapolator)newValue;
break;
case 773779145: // extrapolatorRight
this.extrapolatorRight_Renamed = (CurveExtrapolator)newValue;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return(this);
}
//-------------------------------------------------------------------------
/// <summary>
/// Returns a new curve with an additional node, specifying the parameter metadata.
/// <para>
/// The result will contain the specified node.
/// If the x-value equals an existing x-value, the y-value will be changed.
/// If the x-value does not equal an existing x-value, the node will be added.
/// </para>
/// <para>
/// The result will only contain the specified parameter metadata if this curve also has parameter meta-data.
///
/// </para>
/// </summary>
/// <param name="x"> the new x-value </param>
/// <param name="y"> the new y-value </param>
/// <param name="paramMetadata"> the new parameter metadata </param>
/// <returns> the updated curve </returns>
public InterpolatedNodalCurve withNode(double x, double y, ParameterMetadata paramMetadata)
{
int index = Arrays.binarySearch(xValues.toArrayUnsafe(), x);
if (index >= 0)
{
CurveMetadata md = metadata.ParameterMetadata.map(@params =>
{
IList <ParameterMetadata> extended = new List <ParameterMetadata>(@params);
extended[index] = paramMetadata;
return(metadata.withParameterMetadata(extended));
}).orElse(metadata);
DoubleArray yUpdated = yValues.with(index, y);
return(new InterpolatedNodalCurve(md, xValues, yUpdated, interpolator, extrapolatorLeft, extrapolatorRight));
}
int insertion = -(index + 1);
DoubleArray xExtended = xValues.subArray(0, insertion).concat(x).concat(xValues.subArray(insertion));
DoubleArray yExtended = yValues.subArray(0, insertion).concat(y).concat(yValues.subArray(insertion));
// add to existing metadata, or do nothing if no existing metadata
CurveMetadata md = metadata.ParameterMetadata.map(@params =>
{
IList <ParameterMetadata> extended = new List <ParameterMetadata>(@params);
extended.Insert(insertion, paramMetadata);
return(metadata.withParameterMetadata(extended));
}).orElse(metadata);
return(new InterpolatedNodalCurve(md, xExtended, yExtended, interpolator, extrapolatorLeft, extrapolatorRight));
}
//-------------------------------------------------------------------------
// constructs an interpolated nodal curve
internal InterpolatedNodalCurve createCurve(LocalDate date, IList <LoadedCurveNode> curveNodes)
{
// copy and sort
IList <LoadedCurveNode> nodes = new List <LoadedCurveNode>(curveNodes);
nodes.sort(System.Collections.IComparer.naturalOrder());
// build each node
double[] xValues = new double[nodes.Count];
double[] yValues = new double[nodes.Count];
IList <ParameterMetadata> pointsMetadata = new List <ParameterMetadata>(nodes.Count);
for (int i = 0; i < nodes.Count; i++)
{
LoadedCurveNode point = nodes[i];
double yearFraction = dayCount.yearFraction(date, point.Date);
xValues[i] = yearFraction;
yValues[i] = point.Value;
ParameterMetadata pointMetadata = LabelDateParameterMetadata.of(point.Date, point.Label);
pointsMetadata.Add(pointMetadata);
}
// create metadata
CurveMetadata curveMetadata = DefaultCurveMetadata.builder().curveName(curveName).xValueType(xValueType).yValueType(yValueType).dayCount(dayCount).parameterMetadata(pointsMetadata).build();
return(InterpolatedNodalCurve.builder().metadata(curveMetadata).xValues(DoubleArray.copyOf(xValues)).yValues(DoubleArray.copyOf(yValues)).interpolator(interpolator).extrapolatorLeft(extrapolatorLeft).extrapolatorRight(extrapolatorRight).build());
}
public virtual void prices_curveNameParams()
{
CurveMetadata test = Curves.prices(CURVE_NAME, PARAMS);
CurveMetadata expected = DefaultCurveMetadata.builder().curveName(CURVE_NAME).xValueType(ValueType.MONTHS).yValueType(ValueType.PRICE_INDEX).parameterMetadata(PARAMS).build();
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public ConstantNodalCurve withNode(double x, double y, ParameterMetadata paramMetadata)
{
ArgChecker.isTrue(x == xValue, "x should be equal to the existing x-value");
CurveMetadata md = metadata.withParameterMetadata(ImmutableList.of(paramMetadata));
return(new ConstantNodalCurve(md, x, y));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public Builder set(String propertyName, Object newValue)
public override Builder set(string propertyName, object newValue)
{
switch (propertyName.GetHashCode())
{
case -450004177: // metadata
this.metadata_Renamed = (CurveMetadata)newValue;
break;
case 458736106: // parameters
this.parameters_Renamed = (DoubleArray)newValue;
break;
case 636119145: // valueFunction
this.valueFunction_Renamed = (System.Func <DoubleArray, double, double>)newValue;
break;
case 1663351423: // derivativeFunction
this.derivativeFunction_Renamed = (System.Func <DoubleArray, double, double>)newValue;
break;
case -1353652329: // sensitivityFunction
this.sensitivityFunction_Renamed = (System.Func <DoubleArray, double, DoubleArray>)newValue;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return(this);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
ParameterizedFunctionalCurve test1 = ParameterizedFunctionalCurve.of(METADATA, PARAMETERS, VALUE_FUNCTION, DERIVATIVE_FUNCTION, SENSITIVITY_FUNCTION);
coverImmutableBean(test1);
DoubleArray @params = DoubleArray.of(1.2);
CurveMetadata metadata = DefaultCurveMetadata.builder().curveName("test").yValueType(ValueType.DISCOUNT_FACTOR).xValueType(ValueType.YEAR_FRACTION).build();
System.Func <DoubleArray, double, double> value = (DoubleArray t, double?u) =>
{
return(t.get(0) * u);
};
System.Func <DoubleArray, double, double> deriv = (DoubleArray t, double?u) =>
{
return(t.get(0));
};
System.Func <DoubleArray, double, DoubleArray> sensi = (DoubleArray t, double?u) =>
{
return(DoubleArray.of(u));
};
ParameterizedFunctionalCurve test2 = ParameterizedFunctionalCurve.of(metadata, @params, value, deriv, sensi);
coverBeanEquals(test1, test2);
}
public virtual void test_withMetadata()
{
ParameterizedFunctionalCurve @base = ParameterizedFunctionalCurve.of(METADATA, PARAMETERS, VALUE_FUNCTION, DERIVATIVE_FUNCTION, SENSITIVITY_FUNCTION);
CurveMetadata metadata = DefaultCurveMetadata.builder().curveName("test").yValueType(ValueType.DISCOUNT_FACTOR).xValueType(ValueType.YEAR_FRACTION).build();
ParameterizedFunctionalCurve expected = ParameterizedFunctionalCurve.of(metadata, PARAMETERS, VALUE_FUNCTION, DERIVATIVE_FUNCTION, SENSITIVITY_FUNCTION);
assertEquals(@base.withMetadata(metadata), expected);
}
/// <summary>
/// Restricted copy constructor. </summary>
/// <param name="beanToCopy"> the bean to copy from, not null </param>
internal Builder(ParameterizedFunctionalCurve beanToCopy)
{
this.metadata_Renamed = beanToCopy.Metadata;
this.parameters_Renamed = beanToCopy.Parameters;
this.valueFunction_Renamed = beanToCopy.ValueFunction;
this.derivativeFunction_Renamed = beanToCopy.DerivativeFunction;
this.sensitivityFunction_Renamed = beanToCopy.SensitivityFunction;
}
static ParameterizedFunctionalCurveTest()
{
TenorParameterMetadata param1 = TenorParameterMetadata.of(Tenor.TENOR_1Y);
TenorParameterMetadata param2 = TenorParameterMetadata.of(Tenor.TENOR_5Y);
TenorParameterMetadata param3 = TenorParameterMetadata.of(Tenor.TENOR_10Y);
METADATA = DefaultCurveMetadata.builder().curveName("test").yValueType(ValueType.DISCOUNT_FACTOR).xValueType(ValueType.YEAR_FRACTION).parameterMetadata(param1, param2, param3).build();
}
/// <summary>
/// Restricted copy constructor. </summary>
/// <param name="beanToCopy"> the bean to copy from, not null </param>
internal Builder(InterpolatedNodalCurve beanToCopy)
{
this.metadata_Renamed = beanToCopy.Metadata;
this.xValues_Renamed = beanToCopy.XValues;
this.yValues_Renamed = beanToCopy.YValues;
this.interpolator_Renamed = beanToCopy.Interpolator;
this.extrapolatorLeft_Renamed = beanToCopy.ExtrapolatorLeft;
this.extrapolatorRight_Renamed = beanToCopy.ExtrapolatorRight;
}
//-------------------------------------------------------------------------
public virtual void test_metadata()
{
RatesCurveGroupDefinition test = RatesCurveGroupDefinition.builder().name(CurveGroupName.of("Test")).addCurve(CURVE_DEFN1, GBP, GBP_LIBOR_1M, GBP_LIBOR_3M).build();
LocalDate valuationDate = date(2015, 6, 30);
CurveMetadata meta = CURVE_DEFN1.metadata(valuationDate, REF_DATA);
assertEquals(test.metadata(valuationDate, REF_DATA), ImmutableList.of(meta));
}
public virtual void underlyingCurve()
{
assertEquals(ADD_FIXED_CURVE.split(), ImmutableList.of(FIXED_CURVE, SPREAD_CURVE));
CurveMetadata metadata = DefaultCurveMetadata.builder().curveName(CurveName.of("newCurve")).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(ACT_365F).parameterMetadata(PARAM_METADATA_SPREAD).build();
InterpolatedNodalCurve newCurve = InterpolatedNodalCurve.of(metadata, XVALUES_SPREAD, YVALUES_SPREAD, INTERPOLATOR);
assertEquals(ADD_FIXED_CURVE.withUnderlyingCurve(0, newCurve), AddFixedCurve.of(newCurve, SPREAD_CURVE));
assertEquals(ADD_FIXED_CURVE.withUnderlyingCurve(1, newCurve), AddFixedCurve.of(FIXED_CURVE, newCurve));
assertThrowsIllegalArg(() => ADD_FIXED_CURVE.withUnderlyingCurve(2, newCurve));
}
//-------------------------------------------------------------------------
public virtual void test_underlyingCurves()
{
CurveMetadata metadata = DefaultCurveMetadata.builder().curveName("newCurve").xValueType(YEAR_FRACTION).yValueType(ZERO_RATE).dayCount(ACT_365F).parameterMetadata(PARAM_METADATA_SPREAD).build();
InterpolatedNodalCurve newCurve = InterpolatedNodalCurve.of(metadata, XVALUES_SPREAD, YVALUES_SPREAD, NATURAL_CUBIC_SPLINE, LINEAR, LINEAR);
assertEquals(COMBINED_CURVE.withUnderlyingCurve(0, newCurve), CombinedCurve.of(newCurve, SPREAD_CURVE, COMBINED_CURVE.Metadata));
assertEquals(COMBINED_CURVE.withUnderlyingCurve(1, newCurve), CombinedCurve.of(BASE_CURVE, newCurve, COMBINED_CURVE.Metadata));
assertEquals(COMBINED_CURVE.split(), ImmutableList.of(BASE_CURVE, SPREAD_CURVE));
assertThrowsIllegalArg(() => COMBINED_CURVE.withUnderlyingCurve(2, newCurve));
}
public virtual void test_of_badCurve()
{
InterpolatedNodalCurve notYearFraction = InterpolatedNodalCurve.of(Curves.prices(NAME), DoubleArray.of(0, 10), DoubleArray.of(1, 2), INTERPOLATOR);
InterpolatedNodalCurve notDiscountFactor = InterpolatedNodalCurve.of(Curves.zeroRates(NAME, ACT_365F), DoubleArray.of(0, 10), DoubleArray.of(1, 2), INTERPOLATOR);
CurveMetadata noDayCountMetadata = DefaultCurveMetadata.builder().curveName(NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.DISCOUNT_FACTOR).build();
InterpolatedNodalCurve notDayCount = InterpolatedNodalCurve.of(noDayCountMetadata, DoubleArray.of(0, 10), DoubleArray.of(1, 2), INTERPOLATOR);
assertThrowsIllegalArg(() => SimpleDiscountFactors.of(GBP, DATE_VAL, notYearFraction));
assertThrowsIllegalArg(() => SimpleDiscountFactors.of(GBP, DATE_VAL, notDiscountFactor));
assertThrowsIllegalArg(() => SimpleDiscountFactors.of(GBP, DATE_VAL, notDayCount));
}
//-------------------------------------------------------------------------
public virtual void test_withMetadata()
{
IList <ParameterMetadata> combinedParamMeta = new List <ParameterMetadata>();
((IList <ParameterMetadata>)combinedParamMeta).AddRange(PARAM_METADATA_BASE);
((IList <ParameterMetadata>)combinedParamMeta).AddRange(PARAM_METADATA_SPREAD);
CurveMetadata newMetadata = DefaultCurveMetadata.builder().curveName("newName").xValueType(YEAR_FRACTION).yValueType(ZERO_RATE).dayCount(ACT_365F).parameterMetadata(combinedParamMeta).build();
CombinedCurve computed = COMBINED_CURVE.withMetadata(newMetadata);
CombinedCurve expected = CombinedCurve.of(BASE_CURVE, SPREAD_CURVE, newMetadata);
assertEquals(computed, expected);
}
// one valuation date, one set of market data
private MarketDataBox <RatesCurveInputs> buildSingleCurveInputs <T1>(CurveDefinition filteredDefn, IDictionary <T1> marketData, LocalDate valuationDate, ReferenceData refData) where T1 : com.opengamma.strata.data.MarketDataId <T1>
{
// There is only a single map of values and single valuation date - create a single CurveInputs instance
CurveMetadata curveMetadata = filteredDefn.metadata(valuationDate, refData);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<? extends com.opengamma.strata.data.MarketDataId<?>, ?> singleMarketDataValues = com.opengamma.strata.collect.MapStream.of(marketData).mapValues(box -> box.getSingleValue()).toMap();
IDictionary <MarketDataId <object>, ?> singleMarketDataValues = MapStream.of(marketData).mapValues(box => box.SingleValue).toMap();
RatesCurveInputs curveInputs = RatesCurveInputs.of(singleMarketDataValues, curveMetadata);
return(MarketDataBox.ofSingleValue(curveInputs));
}
// update vols
private SabrParametersIborCapletFloorletVolatilities updateParameters(SabrIborCapletFloorletVolatilityCalibrationDefinition sabrDefinition, SabrParametersIborCapletFloorletVolatilities volatilities, DoubleArray newValues)
{
SabrParameters sabrParams = volatilities.Parameters;
CurveMetadata alphaMetadata = sabrParams.AlphaCurve.Metadata;
CurveMetadata betaMetadata = sabrParams.BetaCurve.Metadata;
CurveMetadata rhoMetadata = sabrParams.RhoCurve.Metadata;
CurveMetadata nuMetadata = sabrParams.NuCurve.Metadata;
IList <Curve> newCurveList = sabrDefinition.createSabrParameterCurve(ImmutableList.of(alphaMetadata, betaMetadata, rhoMetadata, nuMetadata), newValues);
SabrParameters newSabrParams = SabrParameters.of(newCurveList[0], newCurveList[1], newCurveList[2], newCurveList[3], sabrDefinition.ShiftCurve, sabrDefinition.SabrVolatilityFormula);
SabrParametersIborCapletFloorletVolatilities newVols = SabrParametersIborCapletFloorletVolatilities.of(volatilities.Name, volatilities.Index, volatilities.ValuationDateTime, newSabrParams);
return(newVols);
}
public virtual void test_dayCount()
{
CurveMetadata baseMetadata = DefaultCurveMetadata.builder().curveName(BASE_NAME).xValueType(YEAR_FRACTION).yValueType(ZERO_RATE).dayCount(ACT_365F).build();
CurveMetadata spreadMetadata = DefaultCurveMetadata.builder().curveName(SPREAD_NAME).xValueType(YEAR_FRACTION).yValueType(ZERO_RATE).dayCount(DayCounts.ACT_360).build();
InterpolatedNodalCurve baseCurve = InterpolatedNodalCurve.of(baseMetadata, XVALUES_BASE, YVALUES_BASE, NATURAL_CUBIC_SPLINE, LINEAR, LINEAR);
InterpolatedNodalCurve spreadCurve = InterpolatedNodalCurve.of(spreadMetadata, XVALUES_SPREAD, YVALUES_SPREAD, PCHIP, LINEAR, LINEAR);
CurveMetadata combinedMetadata1 = DefaultCurveMetadata.builder().curveName("CombinedCurve").xValueType(YEAR_FRACTION).yValueType(ZERO_RATE).dayCount(DayCounts.ACT_360).build();
assertThrowsIllegalArg(() => CombinedCurve.of(baseCurve, spreadCurve, combinedMetadata1));
CurveMetadata combinedMetadata2 = DefaultCurveMetadata.builder().curveName("CombinedCurve").xValueType(YEAR_FRACTION).yValueType(ZERO_RATE).dayCount(ACT_365F).build();
assertThrowsIllegalArg(() => CombinedCurve.of(baseCurve, spreadCurve, combinedMetadata2));
}
// restricted constructor
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ImmutableConstructor private ParameterizedFunctionalCurve(CurveMetadata metadata, com.opengamma.strata.collect.array.DoubleArray parameters, System.Func<com.opengamma.strata.collect.array.DoubleArray, double, double> valueFunction, System.Func<com.opengamma.strata.collect.array.DoubleArray, double, double> derivativeFunction, System.Func<com.opengamma.strata.collect.array.DoubleArray, double, com.opengamma.strata.collect.array.DoubleArray> sensitivityFunction)
private ParameterizedFunctionalCurve(CurveMetadata metadata, DoubleArray parameters, System.Func <DoubleArray, double, double> valueFunction, System.Func <DoubleArray, double, double> derivativeFunction, System.Func <DoubleArray, double, DoubleArray> sensitivityFunction)
{
JodaBeanUtils.notNull(metadata, "metadata");
JodaBeanUtils.notNull(parameters, "parameters");
JodaBeanUtils.notNull(valueFunction, "valueFunction");
JodaBeanUtils.notNull(derivativeFunction, "derivativeFunction");
JodaBeanUtils.notNull(sensitivityFunction, "sensitivityFunction");
this.metadata = metadata;
this.parameters = parameters;
this.valueFunction = valueFunction;
this.derivativeFunction = derivativeFunction;
this.sensitivityFunction = sensitivityFunction;
this.parameterMetadata = IntStream.range(0, ParameterCount).mapToObj(i => getParameterMetadata(i)).collect(toImmutableList());
}
//-------------------------------------------------------------------------
// restricted constructor
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ImmutableConstructor private ConstantNodalCurve(CurveMetadata metadata, double xValue, double yValue)
private ConstantNodalCurve(CurveMetadata metadata, double xValue, double yValue)
{
JodaBeanUtils.notNull(metadata, "metadata");
metadata.ParameterMetadata.ifPresent(@params =>
{
if (@params.size() != 1)
{
throw new System.ArgumentException("Length of parameter metadata must be 1");
}
});
this.metadata = metadata;
this.xValue = xValue;
this.yValue_Renamed = yValue;
this.parameterMetadata = ImmutableList.of(getParameterMetadata(0));
}
