public UnitParameterSensitivity yValueParameterSensitivity(double x)
{
UnitParameterSensitivity baseSens = baseCurve.yValueParameterSensitivity(x);
UnitParameterSensitivity spreadSens = spreadCurve.yValueParameterSensitivity(x);
return(UnitParameterSensitivity.combine(Name, baseSens, spreadSens));
}
//-------------------------------------------------------------------------
public override UnitParameterSensitivity createParameterSensitivity(DoubleArray sensitivities)
{
UnitParameterSensitivity baseSens = baseCurve.createParameterSensitivity(sensitivities.subArray(0, baseCurve.ParameterCount));
UnitParameterSensitivity spreadSens = spreadCurve.createParameterSensitivity(sensitivities.subArray(baseCurve.ParameterCount, sensitivities.size()));
return(UnitParameterSensitivity.combine(Name, baseSens, spreadSens));
}
public virtual void test_localVolatilityFromImpliedVolatility()
{
double r = 0.05;
double q = 0.01;
System.Func <double, double> interestRate = (double?x) =>
{
return(r);
};
System.Func <double, double> dividendRate = (double?x) =>
{
return(q);
};
foreach (double strike in TEST_STRIKES)
{
foreach (double time in TEST_TIMES)
{
double computedVol = CALC.localVolatilityFromImpliedVolatility(VOL_SURFACE, SPOT, interestRate, dividendRate).zValue(time, strike);
double expectedVol = volFromFormula(r, q, time, strike, VOL_SURFACE);
assertEquals(computedVol, expectedVol, FD_EPS);
UnitParameterSensitivity computedSensi = CALC.localVolatilityFromImpliedVolatility(VOL_SURFACE, SPOT, interestRate, dividendRate).zValueParameterSensitivity(time, strike);
for (int i = 0; i < VOLS.size(); ++i)
{
InterpolatedNodalSurface surfaceUp = VOL_SURFACE.withZValues(VOLS.with(i, VOLS.get(i) + FD_EPS));
InterpolatedNodalSurface surfaceDw = VOL_SURFACE.withZValues(VOLS.with(i, VOLS.get(i) - FD_EPS));
double volUp = CALC.localVolatilityFromImpliedVolatility(surfaceUp, SPOT, interestRate, dividendRate).zValue(time, strike);
double volDw = CALC.localVolatilityFromImpliedVolatility(surfaceDw, SPOT, interestRate, dividendRate).zValue(time, strike);
double expectedSensi = 0.5 * (volUp - volDw) / FD_EPS;
assertEquals(computedSensi.Sensitivity.get(i), expectedSensi, FD_EPS * 10d);
}
}
}
}
private CurrencyParameterSensitivity parameterSensitivity(IborFutureOptionSensitivity point)
{
double simpleMoneyness = moneynessOnPrice ? point.StrikePrice - point.FuturePrice : point.FuturePrice - point.StrikePrice;
UnitParameterSensitivity unitSens = surface.zValueParameterSensitivity(point.Expiry, simpleMoneyness);
return(unitSens.multipliedBy(point.Currency, point.Sensitivity));
}
private CurrencyParameterSensitivity parameterSensitivity(FxOptionSensitivity point)
{
double expiry = point.Expiry;
UnitParameterSensitivity unitSens = curve.yValueParameterSensitivity(expiry);
return(unitSens.multipliedBy(point.Currency, point.Sensitivity));
}
private CurrencyParameterSensitivity parameterSensitivity(FxOptionSensitivity point)
{
double expiry = point.Expiry;
double strike = point.CurrencyPair.isInverse(currencyPair) ? 1d / point.Strike : point.Strike;
UnitParameterSensitivity unitSens = surface.zValueParameterSensitivity(expiry, strike);
return(unitSens.multipliedBy(point.Currency, point.Sensitivity));
}
private CurrencyParameterSensitivity parameterSensitivity(SwaptionSensitivity point)
{
double expiry = point.Expiry;
double tenor = point.Tenor;
UnitParameterSensitivity unitSens = surface.zValueParameterSensitivity(expiry, tenor);
return(unitSens.multipliedBy(point.Currency, point.Sensitivity));
}
public CurrencyParameterSensitivities parameterSensitivity(ZeroRateSensitivity pointSens)
{
double yearFraction = pointSens.YearFraction;
UnitParameterSensitivity unitSens = curve.yValueParameterSensitivity(yearFraction);
CurrencyParameterSensitivity curSens = unitSens.multipliedBy(pointSens.Currency, pointSens.Sensitivity);
return(CurrencyParameterSensitivities.of(curSens));
}
public virtual void test_sensitivities()
{
ParameterizedFunctionalCurve test = ParameterizedFunctionalCurve.of(METADATA, PARAMETERS, VALUE_FUNCTION, DERIVATIVE_FUNCTION, SENSITIVITY_FUNCTION);
DoubleArray sensiVal = DoubleArray.of(1d, 2d, 3d);
assertEquals(test.createParameterSensitivity(sensiVal), UnitParameterSensitivity.of(METADATA.CurveName, METADATA.ParameterMetadata.get(), sensiVal));
assertEquals(test.createParameterSensitivity(USD, sensiVal), CurrencyParameterSensitivity.of(METADATA.CurveName, METADATA.ParameterMetadata.get(), USD, sensiVal));
}
private CurrencyParameterSensitivity parameterSensitivity(SwaptionSensitivity point)
{
double expiry = point.Expiry;
double moneyness = point.Strike - point.Forward;
UnitParameterSensitivity unitSens = surface.zValueParameterSensitivity(expiry, moneyness);
return(unitSens.multipliedBy(point.Currency, point.Sensitivity));
}
private CurrencyParameterSensitivity parameterSensitivity(IborCapletFloorletSensitivity point)
{
double expiry = point.Expiry;
double strike = point.Strike;
UnitParameterSensitivity unitSens = surface.zValueParameterSensitivity(expiry, strike);
return(unitSens.multipliedBy(point.Currency, point.Sensitivity));
}
private CurrencyParameterSensitivity parameterSensitivity(BondFutureOptionSensitivity pointSensitivity)
{
double logMoneyness = Math.Log(pointSensitivity.StrikePrice / pointSensitivity.FuturePrice);
double expiryTime = pointSensitivity.Expiry;
UnitParameterSensitivity unitSens = surface.zValueParameterSensitivity(expiryTime, logMoneyness);
return(unitSens.multipliedBy(pointSensitivity.Currency, pointSensitivity.Sensitivity));
}
//-------------------------------------------------------------------------
public CurrencyParameterSensitivities parameterSensitivity(IborRateSensitivity pointSensitivity)
{
LocalDate maturityDate = pointSensitivity.Observation.MaturityDate;
double relativeYearFraction = this.relativeYearFraction(maturityDate);
UnitParameterSensitivity unitSensitivity = curve.yValueParameterSensitivity(relativeYearFraction);
CurrencyParameterSensitivity sensitivity = unitSensitivity.multipliedBy(pointSensitivity.Currency, pointSensitivity.Sensitivity);
return(CurrencyParameterSensitivities.of(sensitivity));
}
//-------------------------------------------------------------------------
public virtual void test_values()
{
ParameterizedFunctionalCurve test = ParameterizedFunctionalCurve.of(METADATA, PARAMETERS, VALUE_FUNCTION, DERIVATIVE_FUNCTION, SENSITIVITY_FUNCTION);
double x = 5.2;
assertEquals(test.yValue(x), VALUE_FUNCTION.apply(PARAMETERS, x));
assertEquals(test.firstDerivative(x), DERIVATIVE_FUNCTION.apply(PARAMETERS, x));
assertEquals(test.yValueParameterSensitivity(x), UnitParameterSensitivity.of(METADATA.CurveName, METADATA.ParameterMetadata.get(), SENSITIVITY_FUNCTION.apply(PARAMETERS, x)));
}
public virtual void yParameterSensitivity()
{
for (int i = 0; i < X_SAMPLE.Length; i++)
{
UnitParameterSensitivity dComputed = ADD_FIXED_CURVE.yValueParameterSensitivity(X_SAMPLE[i]);
UnitParameterSensitivity dExpected = SPREAD_CURVE.yValueParameterSensitivity(X_SAMPLE[i]);
assertTrue(dComputed.compareKey(dExpected) == 0);
assertTrue(dComputed.Sensitivity.equalWithTolerance(dExpected.Sensitivity, TOLERANCE_Y));
}
}
public virtual void test_yValueParameterSensitivity()
{
for (int i = 0; i < NUM_SAMPLES; ++i)
{
UnitParameterSensitivity computed = COMBINED_CURVE.yValueParameterSensitivity(X_SAMPLES.get(i));
UnitParameterSensitivity baseSens = BASE_CURVE.yValueParameterSensitivity(X_SAMPLES.get(i));
UnitParameterSensitivity spreadSens = SPREAD_CURVE.yValueParameterSensitivity(X_SAMPLES.get(i));
assertEquals(computed.split(), ImmutableList.of(baseSens, spreadSens));
}
}
//-------------------------------------------------------------------------
public CurrencyParameterSensitivities parameterSensitivity(ZeroRateSensitivity pointSens)
{
double yearFraction = pointSens.YearFraction;
double rp = curve.yValue(yearFraction);
double rcBar = 1.0;
double rpBar = 1.0 / (1 + rp / frequency) * rcBar;
UnitParameterSensitivity unitSens = curve.yValueParameterSensitivity(yearFraction).multipliedBy(rpBar);
CurrencyParameterSensitivity curSens = unitSens.multipliedBy(pointSens.Currency, pointSens.Sensitivity);
return(CurrencyParameterSensitivities.of(curSens));
}
public virtual void test_createParameterSensitivity()
{
DoubleArray values = DoubleArray.of(3d, 4d, 6d, 1d, 2d, 5d, 8d);
DoubleArray valuesBase = DoubleArray.of(3d, 4d, 6d);
DoubleArray valuesSpread = DoubleArray.of(1d, 2d, 5d, 8d);
UnitParameterSensitivity computed = COMBINED_CURVE.createParameterSensitivity(values);
UnitParameterSensitivity baseSens = BASE_CURVE.createParameterSensitivity(valuesBase);
UnitParameterSensitivity spreadSens = SPREAD_CURVE.createParameterSensitivity(valuesSpread);
assertEquals(computed.split(), ImmutableList.of(baseSens, spreadSens));
}
//-------------------------------------------------------------------------
public CurrencyParameterSensitivities parameterSensitivity(ZeroRateSensitivity pointSens)
{
double yearFraction = pointSens.YearFraction;
if (Math.Abs(yearFraction) < EFFECTIVE_ZERO)
{
return(CurrencyParameterSensitivities.empty()); // Discount factor in 0 is always 1, no sensitivity.
}
double discountFactor = this.discountFactor(yearFraction);
UnitParameterSensitivity unitSens = curve.yValueParameterSensitivity(yearFraction);
CurrencyParameterSensitivity curSens = unitSens.multipliedBy(-1d / (yearFraction * discountFactor)).multipliedBy(pointSens.Currency, pointSens.Sensitivity);
return(CurrencyParameterSensitivities.of(curSens));
}
public UnitParameterSensitivity yValueParameterSensitivity(double x)
{
int i = seasonalityIndex(x);
double adjustment = seasonality.get(i);
double derivativeFactor = 0d;
if (adjustmentType.Equals(ShiftType.ABSOLUTE))
{
derivativeFactor = 1d;
}
else if (adjustmentType.Equals(ShiftType.SCALED))
{
derivativeFactor = adjustment;
}
else
{
throw new System.ArgumentException("ShiftType " + adjustmentType + " is not supported for sensitivities");
}
// remove the first point from the underlying sensitivity
UnitParameterSensitivity u = underlying.yValueParameterSensitivity(x);
UnitParameterSensitivity u2 = UnitParameterSensitivity.of(u.MarketDataName, u.ParameterMetadata.subList(1, u.ParameterMetadata.size()), u.Sensitivity.subArray(1));
return(u2.multipliedBy(derivativeFactor));
}
public UnitParameterSensitivity yValueParameterSensitivity(double x)
{
ImmutableList <ParameterMetadata> paramMeta = ImmutableList.of(getParameterMetadata(0));
return(UnitParameterSensitivity.of(metadata.CurveName, paramMeta, SENSITIVITY));
}
//-------------------------------------------------------------------------
public virtual void test_createParameterSensitivity()
{
InterpolatedNodalCurve test = InterpolatedNodalCurve.of(METADATA_ENTRIES, XVALUES, YVALUES, INTERPOLATOR);
assertThat(test.createParameterSensitivity(DoubleArray.of(2d, 3d, 4d))).isEqualTo(UnitParameterSensitivity.of(CURVE_NAME, DoubleArray.of(2d, 3d, 4d)));
assertThat(test.createParameterSensitivity(Currency.GBP, DoubleArray.of(2d, 3d, 4d))).isEqualTo(CurrencyParameterSensitivity.of(CURVE_NAME, Currency.GBP, DoubleArray.of(2d, 3d, 4d)));
}
//-------------------------------------------------------------------------
public override UnitParameterSensitivity createParameterSensitivity(DoubleArray sensitivities)
{
return(UnitParameterSensitivity.of(Name, parameterMetadata, sensitivities));
}
public UnitParameterSensitivity zValueParameterSensitivity(double x, double y)
{
return(Metadata.ParameterMetadata.Present ? UnitParameterSensitivity.of(Metadata.SurfaceName, Metadata.ParameterMetadata.get(), deformationFunction.apply(DoublesPair.of(x, y)).Derivatives) : UnitParameterSensitivity.of(Metadata.SurfaceName, deformationFunction.apply(DoublesPair.of(x, y)).Derivatives));
}
