## Libor.LiborDerivatives Class Caplet

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

public class Caplet
extends LiborDerivative

Caplet `cplt([T_i,T_{i+1}],k)` pays off `h=delta_i*(L_i(T_i)-k)^+`, where `k` is the strike rate. No log-normal `LiborVector` implemented for fast valuation of this caplet (there is an exact analytic formula for the price).

 Constructor Summary ```Caplet(LiborProcess LP, int i, double kappa)```           Libors `L_j` needed for `j>=i` and until time `min(T_{i+1},T_{n-1})` (for forward transporting the payoff from time `T_{i+1}`).

 Method Summary ` double` `analyticForwardPrice(int t)`           Black caplet price (this is the martingale price in the LMM). ` 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 forward transported Libor `L_i(T_i)*B_{i+1}(T_i)/B_n(T_i)`. ` double` `currentForwardPayoff()`           Payoff from current Libor path transported forward from time `T_{i+1}` to time `T_n`. `static void` `main(java.lang.String[] args)`           Test program. ` double` `Sigma(int t)`           The square root of the quadratic variation ```_{T_t}^{T_i}= int_{T_t}^{T_i}sigma_i^2(s)ds.``` Think of this as the aggregate volatility of Libor `L_i` until caplet expiration `T_i`.

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

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

 Constructor Detail

### Caplet

```public Caplet(LiborProcess LP,
int i,
double kappa)```
Libors `L_j` needed for `j>=i` and until time `min(T_{i+1},T_{n-1})` (for forward transporting the payoff from time `T_{i+1}`).

Parameters:
`LP` - underlying Libor process.
`i` - caps Libor on `[T_i,T_{i+1}]`.
`kappa` - strike rate.
 Method Detail

### Sigma

`public double Sigma(int t)`

The square root of the quadratic variation
```<log(L_i)>_{T_t}^{T_i}= int_{T_t}^{T_i}sigma_i^2(s)ds.```
Think of this as the aggregate volatility of Libor `L_i` until caplet expiration `T_i`. This quantity is used in the Black caplet formula.

Parameters:
`t` - current discrete time.

### currentForwardPayoff

`public double currentForwardPayoff()`
Payoff from current Libor path transported forward from time `T_{i+1}` 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 `L_i(t)*B_{i+1}(t)/B_n(t)` (a `P_n`-martingale), see LiborProcess.ps.

Overrides:
`controlVariateMean` in class `LiborDerivative`
Parameters:
`t` - current discrete time (continuous time `T_t`).

### currentControlledForwardPayoff

`public double[] currentControlledForwardPayoff()`
Control variate is forward transported Libor `L_i(T_i)*B_{i+1}(T_i)/B_n(T_i)`. See LiborProcess.ps

Overrides:
`currentControlledForwardPayoff` in class `LiborDerivative`

### analyticForwardPrice

`public double analyticForwardPrice(int t)`
Black caplet price (this is the martingale price in the LMM).

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) caplet `cplt([T_12,T_13],0.04)`.

The Monte Carlo forward price of this caplet at time `T_n` is compared to the analytic price. The correlation of the payoff with the control variate is also computed. The forward transporting and discounting involves all Libors `L_j, j>=13`.