Libor.LiborDerivatives
Class BermudanSwaption

java.lang.Object
  extended byLibor.LiborDerivatives.BermudanSwaption

public class BermudanSwaption
extends java.lang.Object

Bermudan Swaption. Limited functionality. Intended to support some experiments. The underlying swap is assumed to end at the terminal date of the underlying Libor process.


Field Summary
 int n
           
 int p
           
 
Constructor Summary
BermudanSwaption(LiborProcess LP, int p, double kappa)
          Constructor, underlying swap ends at the terminal date of the underlying Libor process.
 
Method Summary
 Trigger convexTrigger(double alpha, double beta)
          The pure exercise trigger which exercises as soon as h(t)>g(t,Q(t)), where g(t,x)=beta(x/beta)^alpha with alpha,beta depending on t and increasing to one, respectively decreasing to zero as the end of the swap approaches.
 double currentForwardPayoff(int t)
          Forward transported exercise payoff at time t computed from the current Libor path.
 double currentForwardPayoff(int t, Trigger exercise)
          The forward option payoff h(rho_t) based on a given exercise strategy rho=(rho_t) computed from the current path of the Libor process at time t, that is, the option has not been exercised before time t.
 RandomVariable ForwardPayoff(Trigger exercise)
          The forward option payoff based on a given exercise policy as a random variable.
 double g(double x, double alpha, double beta, int t, int n)
          Function applied to Q(int) to approximate the true continuation value CV(t).
 double getKappa()
          Swaption strike
 LiborProcess getLP()
          Reference to the underlying Libor process.
 int getp()
          Swaption exercise begins T_p
static void main(java.lang.String[] args)
          Test program.
 double monteCarloForwardPrice(int t, int nPath, Trigger exercise)
          Monte Carlo price at time t dependent on a given exercise policy computed as a conditional expectation conditioned on information available at time t and computed from a sample of nPath (branches of) the price path of the underlying.
 double monteCarloForwardPrice(int nPath, Trigger exercise)
          Monte Carlo option price at time t=0.
 Trigger pureTrigger()
          Triggers as soon as h_t> Q(t)
 double Q(int t)
          The approximation Q(t)=max{ E_t(h_{t+1}), E_t(h_{t+2}),..., E_t(h_T) } for the continuation value CV(t) computed from the current Libor path.
 Trigger shiftTrigger(double alpha)
          Triggers as soon as h_t> Q(t)+alpha(t)
 double swapAnalyticForwardPrice(int t, int j)
          Analytic forward price of the payer swap swpn_t(kappa,[T_j,T_n]).
 double swaptionAnalyticForwardPrice(int t, int j)
          Analytic approximation to the price of the payer swaption swpn_t(kappa,[T_j,T_n]).
 double wpq(int p, int q, int j, int t)
          The weight w^{p,q}_j(t) in the representation of the swap rate S_pq(t) as a convex combination of Libors.
 ColtVector xpq(int p, int q, int t)
          The vector x_pq(t) used in the computation of the approximation of the volatility of the swap rate S_pq.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

n

public int n

p

public int p
Constructor Detail

BermudanSwaption

public BermudanSwaption(LiborProcess LP,
                        int p,
                        double kappa)

Constructor, underlying swap ends at the terminal date of the underlying Libor process.

Parameters:
LP - the underlying LiborProcess.
p - first exercise date at T_p.
Method Detail

getLP

public LiborProcess getLP()
Reference to the underlying Libor process.


getp

public int getp()
Swaption exercise begins T_p


getKappa

public double getKappa()
Swaption strike


wpq

public double wpq(int p,
                  int q,
                  int j,
                  int t)

The weight w^{p,q}_j(t) in the representation of the swap rate S_pq(t) as a convex combination of Libors. See LiborProcess.ps.

Parameters:
p - swap begins
q - swap ends
j - Libor index in [p,q).
t - current discrete time.

xpq

public ColtVector xpq(int p,
                      int q,
                      int t)

The vector x_pq(t) used in the computation of the approximation of the volatility of the swap rate S_pq. See LiborProcess.ps.

Parameters:
p - swap begins
q - swap ends
t - current discrete time.

swaptionAnalyticForwardPrice

public double swaptionAnalyticForwardPrice(int t,
                                           int j)

Analytic approximation to the price of the payer swaption swpn_t(kappa,[T_j,T_n]). See Swaption.analyticForwardPrice(int). Correct only for t.

Parameters:
t - current discrete time.
j - swap begins at T_j

swapAnalyticForwardPrice

public double swapAnalyticForwardPrice(int t,
                                       int j)

Analytic forward price of the payer swap swpn_t(kappa,[T_j,T_n]). See Swap.analyticForwardPrice(int). Correct only for t.

Parameters:
t - current discrete time.
j - swap begins at T_j

currentForwardPayoff

public double currentForwardPayoff(int t)
Forward transported exercise payoff at time t computed from the current Libor path.

Parameters:
t - time of exercise

currentForwardPayoff

public double currentForwardPayoff(int t,
                                   Trigger exercise)
The forward option payoff h(rho_t) based on a given exercise strategy rho=(rho_t) computed from the current path of the Libor process at time t, that is, the option has not been exercised before time t. The current path is given up to time t. From there the method computes a new path forward until the time of exercise.

This is the quantity h(rho_t) in the terminology of AmericanOption.tex.

Parameters:
t - current time.
exercise - exercise strategy rho=(rho_t).

ForwardPayoff

public RandomVariable ForwardPayoff(Trigger exercise)
The forward option payoff based on a given exercise policy as a random variable.

Parameters:
exercise - exercise policy.

g

public double g(double x,
                double alpha,
                double beta,
                int t,
                int n)

Function applied to Q(int) to approximate the true continuation value CV(t).

Parameters:
x - positive real
alpha - parameter
beta - parameter
t - current time
n - number of Libors

Q

public double Q(int t)

The approximation Q(t)=max{ E_t(h_{t+1}), E_t(h_{t+2}),..., E_t(h_T) } for the continuation value CV(t) computed from the current Libor path. Note that all the conditional expectations are European swaption prices.

Parameters:
t - current time

pureTrigger

public Trigger pureTrigger()

Triggers as soon as h_t> Q(t)

.


convexTrigger

public Trigger convexTrigger(double alpha,
                             double beta)

The pure exercise trigger which exercises as soon as h(t)>g(t,Q(t)), where g(t,x)=beta(x/beta)^alpha with alpha,beta depending on t and increasing to one, respectively decreasing to zero as the end of the swap approaches.

Parameters:
alpha - smaller than 1, try 0.75 at t=20 years from expiry, 1 at expiry and linear in between.
beta - try 10 times the most expensive European swaption.

shiftTrigger

public Trigger shiftTrigger(double alpha)

Triggers as soon as h_t> Q(t)+alpha(t)

where alpha(t) decreases linearly from alpha to zero as the end of the swaption approaches.

Parameters:
alpha - parameter, should be chosen >0 very small.

monteCarloForwardPrice

public double monteCarloForwardPrice(int t,
                                     int nPath,
                                     Trigger exercise)

Monte Carlo price at time t dependent on a given exercise policy computed as a conditional expectation conditioned on information available at time t and computed from a sample of nPath (branches of) the price path of the underlying.

Parameters:
t - current time (determines information to condition on).
nPath - number of path branches used to compute the option price.
exercise - exercise policy

monteCarloForwardPrice

public double monteCarloForwardPrice(int nPath,
                                     Trigger exercise)

Monte Carlo option price at time t=0.

Parameters:
nPath - number of asset price paths used to compute the option price.

main

public static void main(java.lang.String[] args)

Test program. Allocates a Libor process of dimension n=20 and a semiannual 10 non call 2 Bermudan swaption. Then computes the exercise boundary from the naive exercise strategy at time t=8.