private void assertPriceEquals(
     final PoweredOptionDefinition poweredDefinition,
     final EuropeanVanillaOptionDefinition vanillaDefinition,
     final double sigma) {
   final StandardOptionDataBundle bundle = getBundle(sigma);
   final GreekResultCollection actual =
       POWERED_MODEL.getGreeks(poweredDefinition, bundle, REQUIRED_GREEKS);
   final GreekResultCollection expected =
       BSM.getGreeks(vanillaDefinition, bundle, REQUIRED_GREEKS);
   assertEquals(expected.get(Greek.FAIR_PRICE), actual.get(Greek.FAIR_PRICE), SMALL_EPS);
 }
 @Test
 public void greekTest() {
   final LatticeSpecification[] lattices =
       new LatticeSpecification[] {
         new CoxRossRubinsteinLatticeSpecification(),
         new JarrowRuddLatticeSpecification(),
         new TrigeorgisLatticeSpecification(),
         new JabbourKraminYoungLatticeSpecification(),
         new TianLatticeSpecification()
       };
   final boolean[] tfSet = new boolean[] {true, false};
   for (final LatticeSpecification lattice : lattices) {
     for (final boolean isCall : tfSet) {
       for (final double strike : STRIKES) {
         for (final double interest : INTERESTS) {
           for (final double vol : VOLS) {
             final int[] choicesSteps = new int[] {31, 112, 301};
             for (final int nSteps : choicesSteps) {
               for (final double dividend : DIVIDENDS) {
                 final OptionFunctionProvider1D function =
                     new EuropeanVanillaOptionFunctionProvider(strike, TIME, nSteps, isCall);
                 final GreekResultCollection resDiv =
                     _model.getGreeks(lattice, function, SPOT, vol, interest, dividend);
                 final double priceDiv =
                     BlackScholesFormulaRepository.price(
                         SPOT, strike, TIME, vol, interest, interest - dividend, isCall);
                 final double refPriceDiv = Math.max(Math.abs(priceDiv), 1.) / Math.sqrt(nSteps);
                 assertEquals(resDiv.get(Greek.FAIR_PRICE), priceDiv, refPriceDiv);
                 final double deltaDiv =
                     BlackScholesFormulaRepository.delta(
                         SPOT, strike, TIME, vol, interest, interest - dividend, isCall);
                 final double refDeltaDiv = Math.max(Math.abs(deltaDiv), 1.) / Math.sqrt(nSteps);
                 assertEquals(resDiv.get(Greek.DELTA), deltaDiv, refDeltaDiv);
                 final double gammaDiv =
                     BlackScholesFormulaRepository.gamma(
                         SPOT, strike, TIME, vol, interest, interest - dividend);
                 final double refGammaDiv = Math.max(Math.abs(gammaDiv), 1.) / Math.sqrt(nSteps);
                 assertEquals(resDiv.get(Greek.GAMMA), gammaDiv, refGammaDiv);
                 final double thetaDiv =
                     BlackScholesFormulaRepository.theta(
                         SPOT, strike, TIME, vol, interest, interest - dividend, isCall);
                 final double refThetaDiv = Math.max(Math.abs(thetaDiv), 1.) / Math.sqrt(nSteps);
                 assertEquals(resDiv.get(Greek.THETA), thetaDiv, refThetaDiv);
               }
             }
           }
         }
       }
     }
   }
 }
 private void assertPriceEquals(
     final PoweredOptionDefinition poweredDefinition, final double sigma, final double price) {
   final StandardOptionDataBundle bundle = getBundle(sigma);
   final GreekResultCollection actual =
       POWERED_MODEL.getGreeks(poweredDefinition, bundle, REQUIRED_GREEKS);
   assertEquals(price, actual.get(Greek.FAIR_PRICE), BIG_EPS * price);
 }
  @Test
  public void greekLeisenReimerTest() {
    final LatticeSpecification lattice = new LeisenReimerLatticeSpecification();

    final boolean[] tfSet = new boolean[] {true, false};
    for (final boolean isCall : tfSet) {
      for (final double strike : STRIKES) {
        for (final double interest : INTERESTS) {
          for (final double vol : VOLS) {
            final int[] choicesSteps = new int[] {31, 109, 301};
            for (final int nSteps : choicesSteps) {
              for (final double dividend : DIVIDENDS) {
                final OptionFunctionProvider1D function =
                    new EuropeanVanillaOptionFunctionProvider(strike, TIME, nSteps, isCall);
                final GreekResultCollection resDiv =
                    _model.getGreeks(lattice, function, SPOT, vol, interest, dividend);
                final double priceDiv =
                    BlackScholesFormulaRepository.price(
                        SPOT, strike, TIME, vol, interest, interest - dividend, isCall);
                final double refPriceDiv = Math.max(Math.abs(priceDiv), 1.) / nSteps;
                assertEquals(resDiv.get(Greek.FAIR_PRICE), priceDiv, refPriceDiv);
                final double deltaDiv =
                    BlackScholesFormulaRepository.delta(
                        SPOT, strike, TIME, vol, interest, interest - dividend, isCall);
                final double refDeltaDiv = Math.max(Math.abs(deltaDiv), 1.) / nSteps;
                assertEquals(resDiv.get(Greek.DELTA), deltaDiv, refDeltaDiv);
                final double gammaDiv =
                    BlackScholesFormulaRepository.gamma(
                        SPOT, strike, TIME, vol, interest, interest - dividend);
                final double refGammaDiv = Math.max(Math.abs(gammaDiv), 1.) / nSteps;
                assertEquals(resDiv.get(Greek.GAMMA), gammaDiv, refGammaDiv);
                final double thetaDiv =
                    BlackScholesFormulaRepository.theta(
                        SPOT, strike, TIME, vol, interest, interest - dividend, isCall);
                final double refThetaDiv = Math.max(Math.abs(thetaDiv), 1.) / nSteps;
                assertEquals(resDiv.get(Greek.THETA), thetaDiv, refThetaDiv * 10.);
              }
            }
          }
        }
      }
    }
  }
Exemplo n.º 5
0
 @Test
 public void testPricing() {
   GreekResultCollection fftPrice = FFT_MODEL.getGreeks(ITM_CALL, BLACK_DATA, GREEKS);
   GreekResultCollection bsmPrice = BSM_MODEL.getGreeks(ITM_CALL, BSM_DATA, GREEKS);
   assertEquals(fftPrice.size(), 1);
   assertEquals(fftPrice.get(Greek.FAIR_PRICE), bsmPrice.get(Greek.FAIR_PRICE), EPS);
   fftPrice = FFT_MODEL.getGreeks(OTM_CALL, BLACK_DATA, GREEKS);
   bsmPrice = BSM_MODEL.getGreeks(OTM_CALL, BSM_DATA, GREEKS);
   assertEquals(fftPrice.size(), 1);
   assertEquals(fftPrice.get(Greek.FAIR_PRICE), bsmPrice.get(Greek.FAIR_PRICE), EPS);
   fftPrice = FFT_MODEL.getGreeks(OTM_PUT, BLACK_DATA, GREEKS);
   bsmPrice = BSM_MODEL.getGreeks(OTM_PUT, BSM_DATA, GREEKS);
   assertEquals(fftPrice.size(), 1);
   assertEquals(fftPrice.get(Greek.FAIR_PRICE), bsmPrice.get(Greek.FAIR_PRICE), EPS);
   fftPrice = FFT_MODEL.getGreeks(ITM_PUT, BLACK_DATA, GREEKS);
   bsmPrice = BSM_MODEL.getGreeks(ITM_PUT, BSM_DATA, GREEKS);
   assertEquals(fftPrice.size(), 1);
   assertEquals(fftPrice.get(Greek.FAIR_PRICE), bsmPrice.get(Greek.FAIR_PRICE), EPS);
 }
  /** non-constant volatility and interest rate */
  @Test
  public void timeVaryingVolTest() {
    final LatticeSpecification lattice1 = new TimeVaryingLatticeSpecification();
    final double[] time_set = new double[] {0.5, 1.2};
    final int steps = 701;
    final double[] vol = new double[steps];
    final double[] rate = new double[steps];
    final double[] dividend = new double[steps];
    final int stepsTri = 661;
    final double[] volTri = new double[stepsTri];
    final double[] rateTri = new double[stepsTri];
    final double[] dividendTri = new double[stepsTri];
    final double constA = 0.01;
    final double constB = 0.001;
    final double constC = 0.1;
    final double constD = 0.05;

    final boolean[] tfSet = new boolean[] {true, false};
    for (final boolean isCall : tfSet) {
      for (final double strike : STRIKES) {
        for (final double time : time_set) {
          for (int i = 0; i < steps; ++i) {
            rate[i] = constA + constB * i * time / steps;
            vol[i] = constC + constD * Math.sin(i * time / steps);
            dividend[i] = 0.005;
          }
          for (int i = 0; i < stepsTri; ++i) {
            rateTri[i] = constA + constB * i * time / steps;
            volTri[i] = constC + constD * Math.sin(i * time / steps);
            dividendTri[i] = 0.005;
          }
          final double rateRef = constA + 0.5 * constB * time;
          final double volRef =
              Math.sqrt(
                  constC * constC
                      + 0.5 * constD * constD
                      + 2. * constC * constD / time * (1. - Math.cos(time))
                      - constD * constD * 0.25 / time * Math.sin(2. * time));

          final OptionFunctionProvider1D functionVanilla =
              new EuropeanVanillaOptionFunctionProvider(strike, time, steps, isCall);
          final double resPrice = _model.getPrice(functionVanilla, SPOT, vol, rate, dividend);
          final GreekResultCollection resGreeks =
              _model.getGreeks(functionVanilla, SPOT, vol, rate, dividend);

          final double resPriceConst =
              _model.getPrice(lattice1, functionVanilla, SPOT, volRef, rateRef, dividend[0]);
          final GreekResultCollection resGreeksConst =
              _model.getGreeks(lattice1, functionVanilla, SPOT, volRef, rateRef, dividend[0]);
          assertEquals(resPrice, resPriceConst, Math.max(Math.abs(resPriceConst), .1) * 1.e-1);
          assertEquals(
              resGreeks.get(Greek.FAIR_PRICE),
              resGreeksConst.get(Greek.FAIR_PRICE),
              Math.max(Math.abs(resGreeksConst.get(Greek.FAIR_PRICE)), 0.1) * 0.1);
          assertEquals(
              resGreeks.get(Greek.DELTA),
              resGreeksConst.get(Greek.DELTA),
              Math.max(Math.abs(resGreeksConst.get(Greek.DELTA)), 0.1) * 0.1);
          assertEquals(
              resGreeks.get(Greek.GAMMA),
              resGreeksConst.get(Greek.GAMMA),
              Math.max(Math.abs(resGreeksConst.get(Greek.GAMMA)), 0.1) * 0.1);
          assertEquals(
              resGreeks.get(Greek.THETA),
              resGreeksConst.get(Greek.THETA),
              Math.max(Math.abs(resGreeksConst.get(Greek.THETA)), 0.1));

          final OptionFunctionProvider1D functionTri =
              new EuropeanVanillaOptionFunctionProvider(strike, time, stepsTri, isCall);
          final double resPriceTrinomial =
              _modelTrinomial.getPrice(functionTri, SPOT, volTri, rateTri, dividendTri);
          assertEquals(
              resPriceTrinomial, resPriceConst, Math.max(Math.abs(resPriceConst), .1) * 1.e-1);
          final GreekResultCollection resGreeksTrinomial =
              _modelTrinomial.getGreeks(functionTri, SPOT, volTri, rateTri, dividendTri);
          assertEquals(
              resGreeksTrinomial.get(Greek.FAIR_PRICE),
              resGreeksConst.get(Greek.FAIR_PRICE),
              Math.max(Math.abs(resGreeksConst.get(Greek.FAIR_PRICE)), 0.1) * 0.1);
          assertEquals(
              resGreeksTrinomial.get(Greek.DELTA),
              resGreeksConst.get(Greek.DELTA),
              Math.max(Math.abs(resGreeksConst.get(Greek.DELTA)), 0.1) * 0.1);
          assertEquals(
              resGreeksTrinomial.get(Greek.GAMMA),
              resGreeksConst.get(Greek.GAMMA),
              Math.max(Math.abs(resGreeksConst.get(Greek.GAMMA)), 0.1) * 0.1);
          assertEquals(
              resGreeksTrinomial.get(Greek.THETA),
              resGreeksConst.get(Greek.THETA),
              Math.max(Math.abs(resGreeksConst.get(Greek.THETA)), 0.1));
        }
      }
    }
  }
  /** The dividend is cash or proportional to asset price */
  @Test
  public void greeksDiscreteDividendLatticeTest() {
    final LatticeSpecification[] lattices =
        new LatticeSpecification[] {
          new CoxRossRubinsteinLatticeSpecification(),
          new JarrowRuddLatticeSpecification(),
          new TrigeorgisLatticeSpecification(),
          new JabbourKraminYoungLatticeSpecification(),
          new TianLatticeSpecification(),
          new LeisenReimerLatticeSpecification()
        };

    final double[] propDividends = new double[] {0.01, 0.01, 0.01};
    final double[] cashDividends = new double[] {5., 10., 8.};
    final double[] dividendTimes = new double[] {TIME / 420., TIME / 203., TIME / 2.};

    final boolean[] tfSet = new boolean[] {true, false};
    for (final LatticeSpecification lattice : lattices) {
      for (final boolean isCall : tfSet) {
        for (final double strike : STRIKES) {
          for (final double interest : INTERESTS) {
            for (final double vol : VOLS) {
              final int nSteps = 401;
              final double resSpot =
                  SPOT
                      * (1. - propDividends[0])
                      * (1. - propDividends[1])
                      * (1. - propDividends[2]);
              final double modSpot =
                  SPOT
                      - cashDividends[0] * Math.exp(-interest * dividendTimes[0])
                      - cashDividends[1] * Math.exp(-interest * dividendTimes[1])
                      - cashDividends[2] * Math.exp(-interest * dividendTimes[2]);
              final double exactPriceProp =
                  BlackScholesFormulaRepository.price(
                      resSpot, strike, TIME, vol, interest, interest, isCall);
              final double exactDeltaProp =
                  BlackScholesFormulaRepository.delta(
                      resSpot, strike, TIME, vol, interest, interest, isCall);
              final double exactGammaProp =
                  BlackScholesFormulaRepository.gamma(
                      resSpot, strike, TIME, vol, interest, interest);
              final double exactThetaProp =
                  BlackScholesFormulaRepository.theta(
                      resSpot, strike, TIME, vol, interest, interest, isCall);

              final double appPriceCash =
                  BlackScholesFormulaRepository.price(
                      modSpot, strike, TIME, vol, interest, interest, isCall);
              final double appDeltaCash =
                  BlackScholesFormulaRepository.delta(
                      modSpot, strike, TIME, vol, interest, interest, isCall);
              final double appGammaCash =
                  BlackScholesFormulaRepository.gamma(
                      modSpot, strike, TIME, vol, interest, interest);
              final double appThetaCash =
                  BlackScholesFormulaRepository.theta(
                      modSpot, strike, TIME, vol, interest, interest, isCall);

              final OptionFunctionProvider1D function =
                  new EuropeanVanillaOptionFunctionProvider(strike, TIME, nSteps, isCall);
              final DividendFunctionProvider cashDividend =
                  new CashDividendFunctionProvider(dividendTimes, cashDividends);
              final DividendFunctionProvider propDividend =
                  new ProportionalDividendFunctionProvider(dividendTimes, propDividends);
              final GreekResultCollection resProp =
                  _model.getGreeks(lattice, function, SPOT, vol, interest, propDividend);
              final GreekResultCollection resCash =
                  _model.getGreeks(lattice, function, SPOT, vol, interest, cashDividend);

              assertEquals(
                  resProp.get(Greek.FAIR_PRICE),
                  exactPriceProp,
                  Math.max(1., Math.abs(exactPriceProp)) * 1.e-2);
              assertEquals(
                  resProp.get(Greek.DELTA),
                  exactDeltaProp,
                  Math.max(1., Math.abs(exactDeltaProp)) * 1.e-1);
              assertEquals(
                  resProp.get(Greek.GAMMA),
                  exactGammaProp,
                  Math.max(1., Math.abs(exactGammaProp)) * 1.e-1);
              assertEquals(
                  resProp.get(Greek.THETA),
                  exactThetaProp,
                  Math.max(1., Math.abs(exactThetaProp)) * 1.e-1);

              assertEquals(
                  resCash.get(Greek.FAIR_PRICE),
                  appPriceCash,
                  Math.max(1., Math.abs(appPriceCash)) * 1.e-2);
              assertEquals(
                  resCash.get(Greek.DELTA),
                  appDeltaCash,
                  Math.max(1., Math.abs(appDeltaCash)) * 1.e-1);
              assertEquals(
                  resCash.get(Greek.GAMMA),
                  appGammaCash,
                  Math.max(1., Math.abs(appGammaCash)) * 1.e-1);
              assertEquals(
                  resCash.get(Greek.THETA), appThetaCash, Math.max(1., Math.abs(appThetaCash)));

              if (lattice instanceof CoxRossRubinsteinLatticeSpecification
                  || lattice instanceof JarrowRuddLatticeSpecification
                  || lattice instanceof TrigeorgisLatticeSpecification
                  || lattice instanceof TianLatticeSpecification) {
                final GreekResultCollection resPropTrinomial =
                    _modelTrinomial.getGreeks(lattice, function, SPOT, vol, interest, propDividend);
                final GreekResultCollection resCashTrinomial =
                    _modelTrinomial.getGreeks(lattice, function, SPOT, vol, interest, cashDividend);

                assertEquals(
                    resPropTrinomial.get(Greek.FAIR_PRICE),
                    resProp.get(Greek.FAIR_PRICE),
                    Math.max(1., Math.abs(resProp.get(Greek.FAIR_PRICE))) * 1.e-2);
                assertEquals(
                    resPropTrinomial.get(Greek.DELTA),
                    resProp.get(Greek.DELTA),
                    Math.max(1., Math.abs(resProp.get(Greek.DELTA))) * 1.e-2);

                assertEquals(
                    resPropTrinomial.get(Greek.GAMMA),
                    resProp.get(Greek.GAMMA),
                    Math.max(1., Math.abs(resProp.get(Greek.GAMMA))) * 1.e-2);
                assertEquals(
                    resPropTrinomial.get(Greek.THETA),
                    resProp.get(Greek.THETA),
                    Math.max(1., Math.abs(resProp.get(Greek.THETA))) * 1.e-1);

                assertEquals(
                    resCashTrinomial.get(Greek.FAIR_PRICE),
                    resCash.get(Greek.FAIR_PRICE),
                    Math.max(1., Math.abs(resCash.get(Greek.FAIR_PRICE))) * 1.e-2);
                assertEquals(
                    resCashTrinomial.get(Greek.DELTA),
                    resCash.get(Greek.DELTA),
                    Math.max(1., Math.abs(resCash.get(Greek.DELTA))) * 1.e-2);
                assertEquals(
                    resCashTrinomial.get(Greek.GAMMA),
                    resCash.get(Greek.GAMMA),
                    Math.max(1., Math.abs(resCash.get(Greek.GAMMA))) * 1.e-2);
                assertEquals(
                    resCashTrinomial.get(Greek.THETA),
                    resCash.get(Greek.THETA),
                    Math.max(1., Math.abs(resCash.get(Greek.THETA))) * 1.e-1);
              }
            }
          }
        }
      }
    }
  }
 private void assertPriceEquals(
     final LogOptionDefinition definition, final double sigma, final double price) {
   final StandardOptionDataBundle bundle = getBundle(sigma);
   final GreekResultCollection actual = MODEL.getGreeks(definition, bundle, REQUIRED_GREEKS);
   assertEquals(actual.get(Greek.FAIR_PRICE), price, EPS);
 }