コード例 #1
0
  @Test
  public void sensitivityTest() {
    final VolatilitySurfaceProvider vsPro =
        new BasisSplineVolatilitySurfaceProvider(0.0, 0.15, 10, 3, 0.0, 10.0, 7, 2);

    final DoubleMatrix1D w = new DoubleMatrix1D(vsPro.getNumModelParameters());
    for (int i = 0; i < w.getNumberOfElements(); i++) {
      w.getData()[i] = RANDOM.nextDouble();
    }

    final VolatilitySurface volSurf = vsPro.getVolSurface(w);
    final Surface<Double, Double, DoubleMatrix1D> senseSurf =
        vsPro.getParameterSensitivitySurface(w);
    final Surface<Double, Double, Pair<Double, DoubleMatrix1D>> volAndSenseSurf =
        vsPro.getVolAndParameterSensitivitySurface(w);

    final int nSamples = 20;
    final DoublesPair[] points = new DoublesPair[nSamples];
    for (int i = 0; i < nSamples; i++) {
      final double t = 10.0 * RANDOM.nextDouble();
      final double k = 0.15 * RANDOM.nextDouble();
      points[i] = DoublesPair.of(t, k);

      final double vol = volSurf.getVolatility(points[i]);
      final DoubleMatrix1D sense = senseSurf.getZValue(points[i].toPair());
      final Pair<Double, DoubleMatrix1D> volAndSense =
          volAndSenseSurf.getZValue(points[i].toPair());
      assertEquals(vol, volAndSense.getFirst(), 1e-15);
      AssertMatrix.assertEqualsVectors(sense, volAndSense.getSecond(), 1e-15);
    }

    // create a DiscreteVolatilityFunctionProvider in order to compute the Jacobian for a (random)
    // set the points
    final DiscreteVolatilityFunctionProvider dvfp =
        new DiscreteVolatilityFunctionProviderFromVolSurface(vsPro);
    final DiscreteVolatilityFunction func = dvfp.from(points);
    final DoubleMatrix2D jac = func.calculateJacobian(w);
    final DoubleMatrix2D jacFD = func.calculateJacobianViaFD(w);
    AssertMatrix.assertEqualsMatrix(jacFD, jac, 1e-10);
  }
コード例 #2
0
  public void partitionByValue() {
    List<LocalDate> dates =
        dates(DATE_2010_01_01, DATE_2011_06_01, DATE_2012_01_01, DATE_2013_06_01, DATE_2014_01_01);
    LocalDateDoubleTimeSeries series =
        LocalDateDoubleTimeSeries.builder().putAll(dates, VALUES_10_14).build();

    Pair<LocalDateDoubleTimeSeries, LocalDateDoubleTimeSeries> partition =
        series.partitionByValue(d -> d > 10 && d < 14);

    LocalDateDoubleTimeSeries mid = partition.getFirst();
    LocalDateDoubleTimeSeries extreme = partition.getSecond();

    assertThat(mid.size()).isEqualTo(3);
    assertThat(extreme.size()).isEqualTo(2);

    assertThat(mid.get(DATE_2011_06_01)).hasValue(11);
    assertThat(mid.get(DATE_2012_01_01)).hasValue(12);
    assertThat(mid.get(DATE_2013_06_01)).hasValue(13);

    assertThat(extreme.get(DATE_2010_01_01)).hasValue(10);
    assertThat(extreme.get(DATE_2014_01_01)).hasValue(14);
  }
コード例 #3
0
  public void partition() {
    List<LocalDate> dates =
        dates(DATE_2010_01_01, DATE_2011_06_01, DATE_2012_01_01, DATE_2013_06_01, DATE_2014_01_01);
    LocalDateDoubleTimeSeries series =
        LocalDateDoubleTimeSeries.builder().putAll(dates, VALUES_10_14).build();

    Pair<LocalDateDoubleTimeSeries, LocalDateDoubleTimeSeries> partition =
        series.partition((ld, d) -> ld.getYear() % 2 == 0);

    LocalDateDoubleTimeSeries even = partition.getFirst();
    LocalDateDoubleTimeSeries odd = partition.getSecond();

    assertThat(even.size()).isEqualTo(3);
    assertThat(odd.size()).isEqualTo(2);

    assertThat(even.get(DATE_2010_01_01)).hasValue(10);
    assertThat(even.get(DATE_2012_01_01)).hasValue(12);
    assertThat(even.get(DATE_2014_01_01)).hasValue(14);

    assertThat(odd.get(DATE_2011_06_01)).hasValue(11);
    assertThat(odd.get(DATE_2013_06_01)).hasValue(13);
  }
コード例 #4
0
  @Test(enabled = true)
  public void swapRateDx2Ddcf() {
    final double theta = 1.99;
    final double rhog2pp = MODEL_PARAMETERS.getCorrelation();
    final double[][] gamma = MODEL_G2PP.gamma(MODEL_PARAMETERS, 0, theta);
    double[][] alphaFixed = new double[T_FIXED.length][2];
    double[] tau2Fixed = new double[T_FIXED.length];
    final double[][] alphaIbor = new double[T_IBOR.length][2];
    final double[] tau2Ibor = new double[T_IBOR.length];
    final double[][] hthetaFixed =
        MODEL_G2PP.volatilityMaturityPart(MODEL_PARAMETERS, theta, T_FIXED);
    alphaFixed = new double[2][T_FIXED.length];
    tau2Fixed = new double[T_FIXED.length];
    for (int loopcf = 0; loopcf < T_FIXED.length; loopcf++) {
      alphaFixed[loopcf][0] = Math.sqrt(gamma[0][0]) * hthetaFixed[0][loopcf];
      alphaFixed[loopcf][1] = Math.sqrt(gamma[1][1]) * hthetaFixed[1][loopcf];
      tau2Fixed[loopcf] =
          alphaFixed[loopcf][0] * alphaFixed[loopcf][0]
              + alphaFixed[loopcf][1] * alphaFixed[loopcf][1]
              + 2 * rhog2pp * gamma[0][1] * hthetaFixed[0][loopcf] * hthetaFixed[1][loopcf];
    }
    final double[][] hthetaIbor =
        MODEL_G2PP.volatilityMaturityPart(MODEL_PARAMETERS, theta, T_IBOR);
    for (int loopcf = 0; loopcf < T_IBOR.length; loopcf++) {
      alphaIbor[loopcf][0] = Math.sqrt(gamma[0][0]) * hthetaIbor[0][loopcf];
      alphaIbor[loopcf][1] = Math.sqrt(gamma[1][1]) * hthetaIbor[1][loopcf];
      tau2Ibor[loopcf] =
          alphaIbor[loopcf][0] * alphaIbor[loopcf][0]
              + alphaIbor[loopcf][1] * alphaIbor[loopcf][1]
              + 2 * rhog2pp * gamma[0][1] * hthetaIbor[0][loopcf] * hthetaIbor[1][loopcf];
    }

    final double shift = 1.0E-7;
    final double[] x = {0.0, 0.1};
    final Pair<double[][][], double[][][]> dx2ddcfComputed =
        MODEL_G2PP.swapRateDdcfDx2(
            x, DCF_FIXED, alphaFixed, tau2Fixed, DCF_IBOR, alphaIbor, tau2Ibor);
    final double[][][] dx2DdcffExpected = new double[DCF_FIXED.length][2][2];
    for (int loopcf = 0; loopcf < DCF_FIXED.length; loopcf++) {
      final double[] dsf_bumped = DCF_FIXED.clone();
      dsf_bumped[loopcf] += shift;
      final double[] d1Plus = new double[2];
      final double[][] d2Plus = new double[2][2];
      MODEL_G2PP.swapRate(
          x, dsf_bumped, alphaFixed, tau2Fixed, DCF_IBOR, alphaIbor, tau2Ibor, d1Plus, d2Plus);
      dsf_bumped[loopcf] -= 2 * shift;
      final double[] d1Minus = new double[2];
      final double[][] d2Minus = new double[2][2];
      MODEL_G2PP.swapRate(
          x, dsf_bumped, alphaFixed, tau2Fixed, DCF_IBOR, alphaIbor, tau2Ibor, d1Minus, d2Minus);
      for (int loopd1 = 0; loopd1 < 2; loopd1++) {
        for (int loopd2 = loopd1; loopd2 < 2; loopd2++) {
          dx2DdcffExpected[loopcf][loopd1][loopd2] =
              (d2Plus[loopd1][loopd2] - d2Minus[loopd1][loopd2]) / (2 * shift);
          assertEquals(
              "Hull-White model: swap rate",
              dx2DdcffExpected[loopcf][loopd1][loopd2],
              dx2ddcfComputed.getFirst()[loopcf][loopd1][loopd2],
              TOLERANCE_RATE_DELTA2);
        }
      }
    }
    final double[][][] dx2DdcfiExpected = new double[DCF_IBOR.length][2][2];
    for (int loopcf = 0; loopcf < DCF_IBOR.length; loopcf++) {
      final double[] dsf_bumped = DCF_IBOR.clone();
      dsf_bumped[loopcf] += shift;
      final double[] d1Plus = new double[2];
      final double[][] d2Plus = new double[2][2];
      MODEL_G2PP.swapRate(
          x, DCF_FIXED, alphaFixed, tau2Fixed, dsf_bumped, alphaIbor, tau2Ibor, d1Plus, d2Plus);
      dsf_bumped[loopcf] -= 2 * shift;
      final double[] d1Minus = new double[2];
      final double[][] d2Minus = new double[2][2];
      MODEL_G2PP.swapRate(
          x, DCF_FIXED, alphaFixed, tau2Fixed, dsf_bumped, alphaIbor, tau2Ibor, d1Minus, d2Minus);
      for (int loopd1 = 0; loopd1 < 2; loopd1++) {
        for (int loopd2 = loopd1; loopd2 < 2; loopd2++) {
          dx2DdcfiExpected[loopcf][loopd1][loopd2] =
              (d2Plus[loopd1][loopd2] - d2Minus[loopd1][loopd2]) / (2 * shift);
          assertEquals(
              "Hull-White model: swap rate",
              dx2DdcfiExpected[loopcf][loopd1][loopd2],
              dx2ddcfComputed.getSecond()[loopcf][loopd1][loopd2],
              TOLERANCE_RATE_DELTA2);
        }
      }
    }
  }