/** Test {@link CurveGroupEntry}. */
@Test
public class CurveGroupEntryTest {
private static final InterpolatedNodalCurveDefinition CURVE_DEFN =
InterpolatedNodalCurveDefinition.builder()
.name(CurveName.of("Test"))
.xValueType(ValueType.YEAR_FRACTION)
.yValueType(ValueType.ZERO_RATE)
.dayCount(ACT_365F)
.nodes(
ImmutableList.of(
DummyFraCurveNode.of(
Period.ofMonths(1),
GBP_LIBOR_1M,
QuoteKey.of(StandardId.of("OG", "Ticker")))))
.interpolator(CurveInterpolators.LINEAR)
.extrapolatorLeft(CurveExtrapolators.FLAT)
.extrapolatorRight(CurveExtrapolators.FLAT)
.build();
private static final InterpolatedNodalCurveDefinition CURVE_DEFN2 =
CURVE_DEFN.toBuilder().name(CurveName.of("Test2")).build();
public void test_builder() {
CurveGroupEntry test =
CurveGroupEntry.builder()
.curveDefinition(CURVE_DEFN)
.discountCurrencies(GBP)
.iborIndices(GBP_LIBOR_1M, GBP_LIBOR_3M)
.overnightIndices(GBP_SONIA)
.build();
assertEquals(test.getCurveDefinition(), CURVE_DEFN);
assertEquals(test.getDiscountCurrencies(), ImmutableSet.of(GBP));
assertEquals(test.getIborIndices(), ImmutableSet.of(GBP_LIBOR_1M, GBP_LIBOR_3M));
assertEquals(test.getOvernightIndices(), ImmutableSet.of(GBP_SONIA));
}
// -------------------------------------------------------------------------
public void coverage() {
CurveGroupEntry test =
CurveGroupEntry.builder().curveDefinition(CURVE_DEFN).discountCurrencies(GBP).build();
coverImmutableBean(test);
CurveGroupEntry test2 =
CurveGroupEntry.builder()
.curveDefinition(CURVE_DEFN2)
.iborIndices(GBP_LIBOR_1M)
.overnightIndices(GBP_SONIA)
.build();
coverBeanEquals(test, test2);
}
public void test_serialization() {
CurveGroupEntry test =
CurveGroupEntry.builder().curveDefinition(CURVE_DEFN).discountCurrencies(GBP).build();
assertSerialization(test);
}
}
/** Test {@link CurveGroup}. */
@Test
public class CurveGroupTest {
private static final CurveGroupName NAME = CurveGroupName.of("TestGroup");
private static final CurveGroupName NAME2 = CurveGroupName.of("TestGroup2");
private static final CurveName DISCOUNT_NAME = CurveName.of("Discount");
private static final CurveName IBOR_NAME = CurveName.of("Ibor");
private static final CurveName OVERNIGHT_NAME = CurveName.of("Overnight");
private static final Curve DISCOUNT_CURVE = ConstantNodalCurve.of("Discount", 0.99);
private static final Map<Currency, Curve> DISCOUNT_CURVES = ImmutableMap.of(GBP, DISCOUNT_CURVE);
private static final Curve IBOR_CURVE = ConstantNodalCurve.of("Ibor", 0.5);
private static final Curve OVERNIGHT_CURVE = ConstantNodalCurve.of("Overnight", 0.6);
private static final Map<Index, Curve> IBOR_CURVES = ImmutableMap.of(GBP_LIBOR_3M, IBOR_CURVE);
// -------------------------------------------------------------------------
public void test_of() {
CurveGroup test = CurveGroup.of(NAME, DISCOUNT_CURVES, IBOR_CURVES);
assertThat(test.getName()).isEqualTo(NAME);
assertThat(test.getDiscountCurves()).isEqualTo(DISCOUNT_CURVES);
assertThat(test.getForwardCurves()).isEqualTo(IBOR_CURVES);
assertThat(test.findDiscountCurve(GBP)).hasValue(DISCOUNT_CURVE);
assertThat(test.findDiscountCurve(USD)).isEmpty();
assertThat(test.findForwardCurve(GBP_LIBOR_3M)).hasValue(IBOR_CURVE);
assertThat(test.findForwardCurve(CHF_LIBOR_3M)).isEmpty();
}
public void test_builder() {
CurveGroup test =
CurveGroup.builder()
.name(NAME)
.discountCurves(DISCOUNT_CURVES)
.forwardCurves(IBOR_CURVES)
.build();
assertThat(test.getName()).isEqualTo(NAME);
assertThat(test.getDiscountCurves()).isEqualTo(DISCOUNT_CURVES);
assertThat(test.getForwardCurves()).isEqualTo(IBOR_CURVES);
assertThat(test.findDiscountCurve(GBP)).hasValue(DISCOUNT_CURVE);
assertThat(test.findDiscountCurve(USD)).isEmpty();
assertThat(test.findForwardCurve(GBP_LIBOR_3M)).hasValue(IBOR_CURVE);
assertThat(test.findForwardCurve(CHF_LIBOR_3M)).isEmpty();
}
public void test_ofCurves() {
CurveGroupDefinition definition =
CurveGroupDefinition.builder()
.name(CurveGroupName.of("group"))
.addCurve(DISCOUNT_NAME, GBP, GBP_LIBOR_1M)
.addForwardCurve(IBOR_NAME, USD_LIBOR_1M, USD_LIBOR_2M)
.addForwardCurve(OVERNIGHT_NAME, EUR_EONIA)
.build();
CurveGroup group = CurveGroup.ofCurves(definition, DISCOUNT_CURVE, OVERNIGHT_CURVE, IBOR_CURVE);
assertThat(group.findDiscountCurve(GBP)).hasValue(DISCOUNT_CURVE);
assertThat(group.findForwardCurve(USD_LIBOR_1M)).hasValue(IBOR_CURVE);
assertThat(group.findForwardCurve(USD_LIBOR_2M)).hasValue(IBOR_CURVE);
assertThat(group.findForwardCurve(EUR_EONIA)).hasValue(OVERNIGHT_CURVE);
}
public void test_ofCurves_missingCurve() {
CurveGroupDefinition definition =
CurveGroupDefinition.builder()
.name(CurveGroupName.of("group"))
.addCurve(DISCOUNT_NAME, GBP, GBP_LIBOR_1M)
.addForwardCurve(IBOR_NAME, USD_LIBOR_1M, USD_LIBOR_2M)
.addForwardCurve(OVERNIGHT_NAME, EUR_EONIA)
.build();
assertThrowsIllegalArg(
() -> CurveGroup.ofCurves(definition, DISCOUNT_CURVE, IBOR_CURVE),
"No curve found named 'Overnight' when building curve group 'group'");
}
// -------------------------------------------------------------------------
public void coverage() {
CurveGroup test = CurveGroup.of(NAME, DISCOUNT_CURVES, IBOR_CURVES);
coverImmutableBean(test);
CurveGroup test2 = CurveGroup.of(NAME2, ImmutableMap.of(), ImmutableMap.of());
coverBeanEquals(test, test2);
}
public void test_serialization() {
CurveGroup test = CurveGroup.of(NAME, DISCOUNT_CURVES, IBOR_CURVES);
assertSerialization(test);
}
}
/** Test {@link AddFixedCurve}. */
@Test
public class AddFixedCurveTest {
private static final String NAME_FIXED = "FixedCurve";
private static final String NAME_SPREAD = "SpreadCurve";
private static final CurveName FIXED_CURVE_NAME = CurveName.of(NAME_FIXED);
private static final CurveName SPREAD_CURVE_NAME = CurveName.of(NAME_SPREAD);
private static final CurveMetadata METADATA_FIXED = Curves.zeroRates(FIXED_CURVE_NAME, ACT_365F);
private static final String LABEL_1 = "Node1";
private static final String LABEL_2 = "Node2";
private static final String LABEL_3 = "Node3";
private static final List<ParameterMetadata> PARAM_METADATA_SPREAD = new ArrayList<>();
static {
PARAM_METADATA_SPREAD.add(LabelDateParameterMetadata.of(LocalDate.of(2015, 1, 1), LABEL_1));
PARAM_METADATA_SPREAD.add(LabelDateParameterMetadata.of(LocalDate.of(2015, 2, 1), LABEL_2));
PARAM_METADATA_SPREAD.add(LabelDateParameterMetadata.of(LocalDate.of(2015, 3, 1), LABEL_3));
}
private static final CurveMetadata METADATA_SPREAD =
DefaultCurveMetadata.builder()
.curveName(SPREAD_CURVE_NAME)
.xValueType(ValueType.YEAR_FRACTION)
.yValueType(ValueType.ZERO_RATE)
.dayCount(ACT_365F)
.parameterMetadata(PARAM_METADATA_SPREAD)
.build();
private static final DoubleArray XVALUES_FIXED = DoubleArray.of(1d, 2d, 3d, 4d);
private static final DoubleArray YVALUES_FIXED = DoubleArray.of(0.05d, 0.07d, 0.08d, 0.09d);
private static final DoubleArray XVALUES_SPREAD = DoubleArray.of(1.5d, 2.5d, 4.5d);
private static final DoubleArray YVALUES_SPREAD = DoubleArray.of(0.04d, 0.045d, 0.05d);
private static final CurveInterpolator INTERPOLATOR = CurveInterpolators.LINEAR;
private static final double[] X_SAMPLE = {0.5d, 1.0d, 1.5d, 1.75d, 10.0d};
private static final int NB_X_SAMPLE = X_SAMPLE.length;
private static final InterpolatedNodalCurve FIXED_CURVE =
InterpolatedNodalCurve.of(METADATA_FIXED, XVALUES_FIXED, YVALUES_FIXED, INTERPOLATOR);
private static final InterpolatedNodalCurve SPREAD_CURVE =
InterpolatedNodalCurve.of(METADATA_SPREAD, XVALUES_SPREAD, YVALUES_SPREAD, INTERPOLATOR);
private static final AddFixedCurve ADD_FIXED_CURVE = AddFixedCurve.of(FIXED_CURVE, SPREAD_CURVE);
private static final double TOLERANCE_Y = 1.0E-10;
public void test_invalid() {
// null fixed
assertThrowsIllegalArg(() -> AddFixedCurve.of(null, SPREAD_CURVE));
// null spread
assertThrowsIllegalArg(() -> AddFixedCurve.of(FIXED_CURVE, null));
}
public void getter() {
assertEquals(ADD_FIXED_CURVE.getMetadata(), METADATA_SPREAD);
assertEquals(ADD_FIXED_CURVE.getParameterCount(), XVALUES_SPREAD.size());
assertEquals(ADD_FIXED_CURVE.getParameter(0), ADD_FIXED_CURVE.getSpreadCurve().getParameter(0));
assertEquals(
ADD_FIXED_CURVE.getParameterMetadata(0),
ADD_FIXED_CURVE.getSpreadCurve().getParameterMetadata(0));
assertEquals(
ADD_FIXED_CURVE.withParameter(0, 9d),
AddFixedCurve.of(FIXED_CURVE, SPREAD_CURVE.withParameter(0, 9d)));
assertEquals(
ADD_FIXED_CURVE.withPerturbation((i, v, m) -> v + 1d),
AddFixedCurve.of(FIXED_CURVE, SPREAD_CURVE.withPerturbation((i, v, m) -> v + 1d)));
assertEquals(
ADD_FIXED_CURVE.withMetadata(METADATA_FIXED),
AddFixedCurve.of(FIXED_CURVE, SPREAD_CURVE.withMetadata(METADATA_FIXED)));
}
public void yValue() {
for (int i = 0; i < NB_X_SAMPLE; i++) {
double yComputed = ADD_FIXED_CURVE.yValue(X_SAMPLE[i]);
double yExpected = FIXED_CURVE.yValue(X_SAMPLE[i]) + SPREAD_CURVE.yValue(X_SAMPLE[i]);
assertEquals(yComputed, yExpected, TOLERANCE_Y);
}
}
public void firstDerivative() {
for (int i = 0; i < NB_X_SAMPLE; i++) {
double dComputed = ADD_FIXED_CURVE.firstDerivative(X_SAMPLE[i]);
double dExpected =
FIXED_CURVE.firstDerivative(X_SAMPLE[i]) + SPREAD_CURVE.firstDerivative(X_SAMPLE[i]);
assertEquals(dComputed, dExpected, TOLERANCE_Y);
}
}
public 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.getSensitivity().equalWithTolerance(dExpected.getSensitivity(), TOLERANCE_Y));
}
}
// -------------------------------------------------------------------------
public void coverage() {
coverImmutableBean(ADD_FIXED_CURVE);
coverBeanEquals(ADD_FIXED_CURVE, AddFixedCurve.of(SPREAD_CURVE, FIXED_CURVE));
}
}
