protected double blackPrice(
      final double spot,
      final double strike,
      final double expiry,
      final double rate,
      final double carry,
      final double vol,
      final boolean isCall) {

    final Function1D<Double, Double> intCon = ICP.getEuropeanPayoff(strike, isCall);
    final ConvectionDiffusionPDE1DStandardCoefficients pde =
        PDE.getBlackScholes(rate, rate - carry, vol);

    double sMin = 0.0;
    double sMax = spot * Math.exp(_z * Math.sqrt(expiry));
    BoundaryCondition lower;
    BoundaryCondition upper;
    if (isCall) {
      lower = new DirichletBoundaryCondition(0.0, sMin);
      Function1D<Double, Double> upperValue =
          new Function1D<Double, Double>() {
            @Override
            public Double evaluate(Double tau) {
              return Math.exp(-rate * tau) * (spot * Math.exp(carry * tau) - strike);
            }
          };
      upper = new DirichletBoundaryCondition(upperValue, sMax);
    } else {
      Function1D<Double, Double> lowerValue =
          new Function1D<Double, Double>() {
            @Override
            public Double evaluate(Double tau) {
              return Math.exp(-rate * tau) * strike;
            }
          };
      lower = new DirichletBoundaryCondition(lowerValue, sMin);
      upper = new DirichletBoundaryCondition(0.0, sMax);
    }

    final MeshingFunction tMesh = new ExponentialMeshing(0, expiry, _nTNodes, _lambda);
    final MeshingFunction xMesh = new HyperbolicMeshing(sMin, sMax, spot, _nXNodes, _bunching);
    final PDEGrid1D grid = new PDEGrid1D(tMesh, xMesh);
    PDE1DDataBundle<ConvectionDiffusionPDE1DCoefficients> pdeData =
        new PDE1DDataBundle<ConvectionDiffusionPDE1DCoefficients>(pde, intCon, lower, upper, grid);

    PDEResults1D res = SOLVER.solve(pdeData);
    // for now just do linear interpolation on price. TODO replace this with something more robust
    final double[] xNodes = grid.getSpaceNodes();
    final int index = SurfaceArrayUtils.getLowerBoundIndex(xNodes, spot);
    final double w = (xNodes[index + 1] - spot) / (xNodes[index + 1] - xNodes[index]);
    return w * res.getFunctionValue(index) + (1 - w) * res.getFunctionValue(index + 1);
  }
  /**
   * Computes the price of a one-touch out barrier option in the Black-Scholes world by solving the
   * BS PDE on a finite difference grid. If a barrier is hit at any time before expiry, the option
   * is cancelled (knocked-out) and a rebate (which is often zero) is paid <b>immediately</b>. If
   * the barrier is not hit, then a normal European option payment is made.
   *
   * <p>If the barrier is above the spot it is assumed to be an up-and-out barrier (otherwise it
   * would expire immediately) otherwise it is a down-and-out barrier As there are exact formulae
   * for this case (see {@link BlackBarrierPriceFunction}), this is purely for testing purposes.
   *
   * @param spot The current (i.e. option price time) of the underlying
   * @param barrierLevel The barrier level
   * @param strike The strike of the European option
   * @param expiry The expiry of the option
   * @param rate The interest rate.
   * @param carry The cost-of-carry (i.e. the forward = spot*exp(costOfCarry*T) )
   * @param vol The Black volatility.
   * @param isCall true for call
   * @param rebate The rebate amount.
   * @return The price.
   */
  public double outBarrier(
      final double spot,
      final double barrierLevel,
      final double strike,
      final double expiry,
      final double rate,
      final double carry,
      final double vol,
      final boolean isCall,
      final double rebate) {

    final Function1D<Double, Double> intCon = ICP.getEuropeanPayoff(strike, isCall);
    final ConvectionDiffusionPDE1DStandardCoefficients pde =
        PDE.getBlackScholes(rate, rate - carry, vol);
    final boolean isUp = barrierLevel > spot;

    final double adj = 0.0; // _lambda == 0 ? ZETA * vol * Math.sqrt(expiry / (_nTNodes - 1)) : 0.0;
    // System.out.println("adjustment: " + adj);

    double sMin;
    double sMax;
    BoundaryCondition lower;
    BoundaryCondition upper;
    if (isUp) {
      sMin = 0.0;
      sMax =
          barrierLevel
              * Math.exp(-adj); // bring the barrier DOWN slightly to adjust for discrete monitoring
      if (isCall) {
        lower = new DirichletBoundaryCondition(0.0, sMin);
      } else {
        Function1D<Double, Double> lowerValue =
            new Function1D<Double, Double>() {
              @Override
              public Double evaluate(Double tau) {
                return Math.exp(-rate * tau) * strike;
              }
            };
        lower = new DirichletBoundaryCondition(lowerValue, sMin);
      }
      upper = new DirichletBoundaryCondition(rebate, sMax);
    } else {
      sMin =
          barrierLevel
              * Math.exp(adj); // bring the barrier UP slightly to adjust for discrete monitoring
      sMax = spot * Math.exp(_z * Math.sqrt(expiry));
      lower = new DirichletBoundaryCondition(rebate, sMin);

      if (isCall) {
        Function1D<Double, Double> upperValue =
            new Function1D<Double, Double>() {
              @Override
              public Double evaluate(Double tau) {
                return Math.exp(-rate * tau) * (spot * Math.exp(carry * tau) - strike);
              }
            };
        upper = new DirichletBoundaryCondition(upperValue, sMax);
      } else {
        upper = new DirichletBoundaryCondition(0.0, sMax);
      }
    }

    final MeshingFunction tMesh = new ExponentialMeshing(0, expiry, _nTNodes, _lambda);
    final MeshingFunction xMesh = new HyperbolicMeshing(sMin, sMax, spot, _nXNodes, _bunching);
    final PDEGrid1D grid = new PDEGrid1D(tMesh, xMesh);
    PDE1DDataBundle<ConvectionDiffusionPDE1DCoefficients> pdeData =
        new PDE1DDataBundle<ConvectionDiffusionPDE1DCoefficients>(pde, intCon, lower, upper, grid);

    PDEResults1D res = SOLVER.solve(pdeData);
    // for now just do linear interpolation on price. TODO replace this with something more robust
    final double[] xNodes = grid.getSpaceNodes();
    final int index = SurfaceArrayUtils.getLowerBoundIndex(xNodes, spot);
    final double w = (xNodes[index + 1] - spot) / (xNodes[index + 1] - xNodes[index]);
    return w * res.getFunctionValue(index) + (1 - w) * res.getFunctionValue(index + 1);
  }