## Libor.LiborDerivatives Class Swaption

```java.lang.Object Libor.LiborDerivatives.LiborDerivative Libor.LiborDerivatives.Swaption
```

public class Swaption
extends LiborDerivative

Forward start payer swaption `swpn(T,[T_p,T_q],k)` pays off `h=B_pq(T)*(S_pq(T)-k)^+` at exercise time `T=T_tau`, where `k` is the strike rate and `S_pq(T)` is the value of the `[T_p,T_q]`-swap rate at time `T`.

Here `B_pq` is the annuity `sum_{k=p}^{q-1}delta_kB_{k+1}` as usual. The time `T=T_tau` of swaption exercise is assumed to be a point on the Libor tenor structure.

 Constructor Summary ```Swaption(LiborProcess LP, int tau, int p, int q, double kappa)```           Libors needed for forward payoff are `L_j, j>=tau` at time `T_tau` (forward transporting from time `T_tau`).

 Method Summary ` double` `analyticForwardPrice(int t)`           Analytic approximation to the swaption price. ` double` `controlVariateMean(int t)`           Mean of the control variate conditioned on the state of the Libor path at time `t`. ` double[]` `currentControlledForwardPayoff()`           Control variate is `(B_p(T)-B_q(T))/B_n(T), T=T_tau`. ` double` `currentForwardPayoff()`           Payoff at time `T_tau` from current Libor path transported forward from time `T_tau` to time `T_n`. ` double` `lognormalForwardPayoffSample()`           The forward transported payoff (as seen from time `t=0`) computed from a new sample of the `LiborVector` object `U=(X^0_tau(T_tau),...,X^0_{n-1}(T_tau))`, a log-normal approximation to the vector of true Libors `U=(X_tau(T_tau),...,X_{n-1}(T_tau))`. `static void` `main(java.lang.String[] args)`           Test program. ` double` `Sigma(int t)`           Conditionally deterministic approximation to the aggregate volatility (square root of the quadratic variation `_t^T`) of the swap rate `S_pq` to expiration conditioned on the state of the Libor process at time `t`. ` double` ```wpq(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 t)`           The vector `x_pq(t)` used in the computation of the approximation of the swap rate volatility.

 Methods inherited from class Libor.LiborDerivatives.LiborDerivative `controlledForwardPayoff, controlledMonteCarloForwardPrice, forwardPayoff, lognormalForwardPayoff, lognormalMonteCarloForwardPrice, monteCarloForwardPrice`

 Methods inherited from class java.lang.Object `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

 Constructor Detail

### Swaption

```public Swaption(LiborProcess LP,
int tau,
int p,
int q,
double kappa)```
Libors needed for forward payoff are `L_j, j>=tau` at time `T_tau` (forward transporting from time `T_tau`).

Parameters:
`LP` - underlying Libor process.
`p` - swap begins at `T_p`.
`q` - swap ends at `T_q`.
`tau` - swaption exercises at time `T_tau<=T_p`.
`kappa` - strike rate.
 Method Detail

### wpq

```public double wpq(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:
`j` - Libor index in `[p,q)`.
`t` - current discrete time.

### xpq

`public ColtVector xpq(int t)`

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

Parameters:
`t` - current discrete time.

### Sigma

`public double Sigma(int t)`

Conditionally deterministic approximation to the aggregate volatility (square root of the quadratic variation `<log(S_pq)>_t^T`) of the swap rate `S_pq` to expiration conditioned on the state of the Libor process at time `t`.

This quantity is used in the analytic approximation to the swaption price `analyticForwardPrice(int)`. See LiborProcess.ps

Parameters:
`t` - current discrete time.

### currentForwardPayoff

`public double currentForwardPayoff()`
Payoff at time `T_tau` from current Libor path transported forward from time `T_tau` to time `T_n`.

Specified by:
`currentForwardPayoff` in class `LiborDerivative`

### controlVariateMean

`public double controlVariateMean(int t)`
Mean of the control variate conditioned on the state of the Libor path at time `t`. This is `(B_p(t)-B_q(t))/B_n(t)` (a `P_n`-martingale), see LiborProcess.ps.

Overrides:
`controlVariateMean` in class `LiborDerivative`
Parameters:
`t` - current discrete time `t<=T`.

### currentControlledForwardPayoff

`public double[] currentControlledForwardPayoff()`
Control variate is `(B_p(T)-B_q(T))/B_n(T), T=T_tau`. See LiborProcess.ps

Overrides:
`currentControlledForwardPayoff` in class `LiborDerivative`

### lognormalForwardPayoffSample

`public double lognormalForwardPayoffSample()`

The forward transported payoff (as seen from time `t=0`) computed from a new sample of the `LiborVector` object `U=(X^0_tau(T_tau),...,X^0_{n-1}(T_tau))`, a log-normal approximation to the vector of true Libors `U=(X_tau(T_tau),...,X_{n-1}(T_tau))`. Recall `X_j(t)=delta_jL_j(t)`, see document LiborProcess.ps.

Overrides:
`lognormalForwardPayoffSample` in class `LiborDerivative`

### analyticForwardPrice

`public double analyticForwardPrice(int t)`

Analytic approximation to the swaption price. Based on a log-normal distribution of the swap rate conditioned on the state of the Libor path at the time `t` of pricing.

Overrides:
`analyticForwardPrice` in class `LiborDerivative`
Parameters:
`t` - current discrete time.

### main

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

Test program. Allocates a Libor process of dimension `n=15` and prices the (at the money) swaption `swpn(T_5,[T_5,T_15],0.04)`.

The Monte Carlo forward price of this swaption at time `T_n` is compared to the analytic price and to the Monte carlo price based on the log-normal Libor approximation `X0` and the correlation of the payoff with the control variate computed. The forward transporting and discounting involves all Libors `L_j, j>=5`.