/// <summary>
/// Calibrate trinomial tree to Black volatilities.
/// <para>
/// {@code timeToExpiry} determines the coverage of the resulting trinomial tree.
/// Thus this should match the time to expiry of the target instrument to price using the calibrated tree.
///
/// </para>
/// </summary>
/// <param name="timeToExpiry"> the time to expiry </param>
/// <param name="currencyPair"> the currency pair </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the trinomial tree data </returns>
public virtual RecombiningTrinomialTreeData calibrateTrinomialTree(double timeToExpiry, CurrencyPair currencyPair, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
validate(ratesProvider, volatilities);
if (timeToExpiry <= 0d)
{
throw new System.ArgumentException("option expired");
}
Currency ccyBase = currencyPair.Base;
Currency ccyCounter = currencyPair.Counter;
double todayFx = ratesProvider.fxRate(currencyPair);
DiscountFactors baseDiscountFactors = ratesProvider.discountFactors(ccyBase);
DiscountFactors counterDiscountFactors = ratesProvider.discountFactors(ccyCounter);
System.Func <double, double> interestRate = (double?t) =>
{
return(counterDiscountFactors.zeroRate(t.Value));
};
System.Func <double, double> dividendRate = (double?t) =>
{
return(baseDiscountFactors.zeroRate(t.Value));
};
System.Func <DoublesPair, double> impliedVolSurface = (DoublesPair tk) =>
{
double dfBase = baseDiscountFactors.discountFactor(tk.First);
double dfCounter = counterDiscountFactors.discountFactor(tk.First);
double forward = todayFx * dfBase / dfCounter;
return(volatilities.volatility(currencyPair, tk.First, tk.Second, forward));
};
ImpliedTrinomialTreeLocalVolatilityCalculator localVol = new ImpliedTrinomialTreeLocalVolatilityCalculator(nSteps, timeToExpiry);
return(localVol.calibrateImpliedVolatility(impliedVolSurface, todayFx, interestRate, dividendRate));
}
//-------------------------------------------------------------------------
// The derivatives are [0] spot, [1] strike, [2] rate, [3] cost-of-carry, [4] volatility, [5] timeToExpiry, [6] spot twice
private ValueDerivatives priceDerivatives(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
validate(option, ratesProvider, volatilities);
SimpleConstantContinuousBarrier barrier = (SimpleConstantContinuousBarrier)option.Barrier;
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
double[] derivatives = new double[7];
if (volatilities.relativeTime(underlyingOption.Expiry) < 0d)
{
return(ValueDerivatives.of(0d, DoubleArray.ofUnsafe(derivatives)));
}
ResolvedFxSingle underlyingFx = underlyingOption.Underlying;
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
Currency ccyBase = currencyPair.Base;
Currency ccyCounter = currencyPair.Counter;
DiscountFactors baseDiscountFactors = ratesProvider.discountFactors(ccyBase);
DiscountFactors counterDiscountFactors = ratesProvider.discountFactors(ccyCounter);
double rateBase = baseDiscountFactors.zeroRate(underlyingFx.PaymentDate);
double rateCounter = counterDiscountFactors.zeroRate(underlyingFx.PaymentDate);
double costOfCarry = rateCounter - rateBase;
double dfBase = baseDiscountFactors.discountFactor(underlyingFx.PaymentDate);
double dfCounter = counterDiscountFactors.discountFactor(underlyingFx.PaymentDate);
double todayFx = ratesProvider.fxRate(currencyPair);
double strike = underlyingOption.Strike;
double forward = todayFx * dfBase / dfCounter;
double volatility = volatilities.volatility(currencyPair, underlyingOption.Expiry, strike, forward);
double timeToExpiry = volatilities.relativeTime(underlyingOption.Expiry);
ValueDerivatives valueDerivatives = BARRIER_PRICER.priceAdjoint(todayFx, strike, timeToExpiry, costOfCarry, rateCounter, volatility, underlyingOption.PutCall.Call, barrier);
if (!option.Rebate.Present)
{
return(valueDerivatives);
}
CurrencyAmount rebate = option.Rebate.get();
ValueDerivatives valueDerivativesRebate = rebate.Currency.Equals(ccyCounter) ? CASH_REBATE_PRICER.priceAdjoint(todayFx, timeToExpiry, costOfCarry, rateCounter, volatility, barrier.inverseKnockType()) : ASSET_REBATE_PRICER.priceAdjoint(todayFx, timeToExpiry, costOfCarry, rateCounter, volatility, barrier.inverseKnockType());
double rebateRate = rebate.Amount / Math.Abs(underlyingFx.BaseCurrencyPayment.Amount);
double price = valueDerivatives.Value + rebateRate * valueDerivativesRebate.Value;
derivatives[0] = valueDerivatives.getDerivative(0) + rebateRate * valueDerivativesRebate.getDerivative(0);
derivatives[1] = valueDerivatives.getDerivative(1);
for (int i = 2; i < 7; ++i)
{
derivatives[i] = valueDerivatives.getDerivative(i) + rebateRate * valueDerivativesRebate.getDerivative(i - 1);
}
return(ValueDerivatives.of(price, DoubleArray.ofUnsafe(derivatives)));
}
/// <summary>
/// Calculates the price of the FX barrier option product.
/// <para>
/// The price of the product is the value on the valuation date for one unit of the base currency
/// and is expressed in the counter currency. The price does not take into account the long/short flag.
/// See <seealso cref="#presentValue"/> for scaling and currency.
/// </para>
/// <para>
/// The volatility used in this computation is the Black implied volatility at expiry time and strike.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the price of the product </returns>
public virtual double price(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
validate(option, ratesProvider, volatilities);
SimpleConstantContinuousBarrier barrier = (SimpleConstantContinuousBarrier)option.Barrier;
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
if (volatilities.relativeTime(underlyingOption.Expiry) < 0d)
{
return(0d);
}
ResolvedFxSingle underlyingFx = underlyingOption.Underlying;
Currency ccyBase = underlyingFx.BaseCurrencyPayment.Currency;
Currency ccyCounter = underlyingFx.CounterCurrencyPayment.Currency;
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
DiscountFactors baseDiscountFactors = ratesProvider.discountFactors(ccyBase);
DiscountFactors counterDiscountFactors = ratesProvider.discountFactors(ccyCounter);
double rateBase = baseDiscountFactors.zeroRate(underlyingFx.PaymentDate);
double rateCounter = counterDiscountFactors.zeroRate(underlyingFx.PaymentDate);
double costOfCarry = rateCounter - rateBase;
double dfBase = baseDiscountFactors.discountFactor(underlyingFx.PaymentDate);
double dfCounter = counterDiscountFactors.discountFactor(underlyingFx.PaymentDate);
double todayFx = ratesProvider.fxRate(currencyPair);
double strike = underlyingOption.Strike;
double forward = todayFx * dfBase / dfCounter;
double volatility = volatilities.volatility(currencyPair, underlyingOption.Expiry, strike, forward);
double timeToExpiry = volatilities.relativeTime(underlyingOption.Expiry);
double price = BARRIER_PRICER.price(todayFx, strike, timeToExpiry, costOfCarry, rateCounter, volatility, underlyingOption.PutCall.Call, barrier);
if (option.Rebate.Present)
{
CurrencyAmount rebate = option.Rebate.get();
double priceRebate = rebate.Currency.Equals(ccyCounter) ? CASH_REBATE_PRICER.price(todayFx, timeToExpiry, costOfCarry, rateCounter, volatility, barrier.inverseKnockType()) : ASSET_REBATE_PRICER.price(todayFx, timeToExpiry, costOfCarry, rateCounter, volatility, barrier.inverseKnockType());
price += priceRebate * rebate.Amount / Math.Abs(underlyingFx.BaseCurrencyPayment.Amount);
}
return(price);
}
