# capbybdt

Price cap instrument from Black-Derman-Toy interest-rate tree

## Syntax

``````[Price,PriceTree] = capbybdt(BDTTree,Strike,Settle,Maturity)``````
``````[Price,PriceTree] = capbybdt(___,CapReset,Basis,Principal,Options)``````

## Description

example

``````[Price,PriceTree] = capbybdt(BDTTree,Strike,Settle,Maturity)``` computes the price of a cap instrument from a Black-Derman-Toy interest-rate tree. `capbybdt` computes prices of vanilla caps and amortizing caps.```

example

``````[Price,PriceTree] = capbybdt(___,CapReset,Basis,Principal,Options)``` adds optional arguments.```

## Examples

collapse all

Load the file `deriv.mat`, which provides `BDTTree`. The `BDTTree` structure contains the time and interest-rate information needed to price the cap instrument.

`load deriv.mat;`

Set the required values. Other arguments will use defaults.

```Strike = 0.03; Settle = '01-Jan-2000'; Maturity = '01-Jan-2004';```

Use `capbybdt` to compute the price of the cap instrument.

`Price = capbybdt(BDTTree, Strike, Settle, Maturity)`
```Price = 28.4001 ```

Set the required arguments for the three specifications required to create a BDT tree.

```Compounding = 1; ValuationDate = '01-01-2000'; StartDate = ValuationDate; EndDates = ['01-01-2001'; '01-01-2002'; '01-01-2003'; '01-01-2004'; '01-01-2005']; Rates = [.1; .11; .12; .125; .13]; Volatility = [.2; .19; .18; .17; .16];```

Create the specifications.

```RateSpec = intenvset('Compounding', Compounding,... 'ValuationDate', ValuationDate,... 'StartDates', StartDate,... 'EndDates', EndDates,... 'Rates', Rates); BDTTimeSpec = bdttimespec(ValuationDate, EndDates, Compounding); BDTVolSpec = bdtvolspec(ValuationDate, EndDates, Volatility);```

Create the BDT tree from the specifications.

`BDTTree = bdttree(BDTVolSpec, RateSpec, BDTTimeSpec)`
```BDTTree = struct with fields: FinObj: 'BDTFwdTree' VolSpec: [1x1 struct] TimeSpec: [1x1 struct] RateSpec: [1x1 struct] tObs: [0 1 2 3 4] dObs: [730486 730852 731217 731582 731947] TFwd: {[5x1 double] [4x1 double] [3x1 double] [2x1 double] [4]} CFlowT: {[5x1 double] [4x1 double] [3x1 double] [2x1 double] [5]} FwdTree: {1x5 cell} ```

Set the cap arguments. Remaining arguments will use defaults.

```CapStrike = 0.10; Settlement = ValuationDate; Maturity = '01-01-2002'; CapReset = 1;```

Use `capbybdt` to find the price of the cap instrument.

```Price= capbybdt(BDTTree, CapStrike, Settlement, Maturity,... CapReset)```
```Price = 1.7169 ```

Define the `RateSpec`.

```Rates = [0.03583; 0.042147; 0.047345; 0.052707; 0.054302]; ValuationDate = '15-Nov-2011'; StartDates = ValuationDate; EndDates = {'15-Nov-2012';'15-Nov-2013';'15-Nov-2014' ;'15-Nov-2015';'15-Nov-2016'}; Compounding = 1; RateSpec = intenvset('ValuationDate', ValuationDate,'StartDates', StartDates,... 'EndDates', EndDates,'Rates', Rates, 'Compounding', Compounding)```
```RateSpec = struct with fields: FinObj: 'RateSpec' Compounding: 1 Disc: [5x1 double] Rates: [5x1 double] EndTimes: [5x1 double] StartTimes: [5x1 double] EndDates: [5x1 double] StartDates: 734822 ValuationDate: 734822 Basis: 0 EndMonthRule: 1 ```

Define the cap instrument.

```Settle ='15-Nov-2011'; Maturity = '15-Nov-2015'; Strike = 0.04; CapReset = 1; Principal ={{'15-Nov-2012' 100;'15-Nov-2013' 70;'15-Nov-2014' 40;'15-Nov-2015' 10}};```

Build the BDT Tree.

```BDTTimeSpec = bdttimespec(ValuationDate, EndDates); Volatility = 0.10; BDTVolSpec = bdtvolspec(ValuationDate, EndDates, Volatility*ones(1,length(EndDates))'); BDTTree = bdttree(BDTVolSpec, RateSpec, BDTTimeSpec)```
```BDTTree = struct with fields: FinObj: 'BDTFwdTree' VolSpec: [1x1 struct] TimeSpec: [1x1 struct] RateSpec: [1x1 struct] tObs: [0 1 2 3 4] dObs: [734822 735188 735553 735918 736283] TFwd: {[5x1 double] [4x1 double] [3x1 double] [2x1 double] [4]} CFlowT: {[5x1 double] [4x1 double] [3x1 double] [2x1 double] [5]} FwdTree: {1x5 cell} ```

Price the amortizing cap.

```Basis = 0; Price = capbybdt(BDTTree, Strike, Settle, Maturity, CapReset, Basis, Principal)```
```Price = 1.4042 ```

## Input Arguments

collapse all

Interest-rate tree structure, specified by using `bdttree`.

Data Types: `struct`

Rate at which cap is exercised, specified as a `NINST`-by-`1` vector of decimal values.

Data Types: `double`

Settlement date for the cap, specified as a `NINST`-by-`1` vector of serial date numbers or date character vectors. The `Settle` date for every cap is set to the `ValuationDate` of the BDT tree. The cap argument `Settle` is ignored.

Data Types: `double` | `char` | `cell`

Maturity date for the cap, specified as a `NINST`-by-`1` vector of serial date numbers or date character vectors.

Data Types: `double` | `char` | `cell`

(Optional) Reset frequency payment per year, specified as a `NINST`-by-`1` vector.

Data Types: `double`

(Optional) Day-count basis representing the basis used when annualizing the input forward rate, specified as a `NINST`-by-`1` vector of integers.

• 0 = actual/actual

• 1 = 30/360 (SIA)

• 2 = actual/360

• 3 = actual/365

• 4 = 30/360 (PSA)

• 5 = 30/360 (ISDA)

• 6 = 30/360 (European)

• 7 = actual/365 (Japanese)

• 8 = actual/actual (ICMA)

• 9 = actual/360 (ICMA)

• 10 = actual/365 (ICMA)

• 11 = 30/360E (ICMA)

• 12 = actual/365 (ISDA)

• 13 = BUS/252

Data Types: `double`

(Optional) Notional principal amount, specified as a `NINST`-by-`1` of notional principal amounts, or a `NINST`-by-`1` cell array, where each element is a `NumDates`-by-`2` cell array where the first column is dates and the second column is associated principal amount. The date indicates the last day that the principal value is valid.

Use `Principal` to pass a schedule to compute the price for an amortizing cap.

Data Types: `double` | `cell`

(Optional) Derivatives pricing options structure, specified using `derivset`.

Data Types: `struct`

## Output Arguments

collapse all

Expected price of the cap at time 0, returned as a `NINST`-by-`1` vector.

Tree structure with values of the cap at each node, returned as a MATLAB® structure of trees containing vectors of instrument prices and a vector of observation times for each node:

• `PriceTree.PTree` contains cap prices.

• `PriceTree.tObs` contains the observation times.

collapse all

### Cap

A cap is a contract that includes a guarantee that sets the maximum interest rate to be paid by the holder, based on an otherwise floating interest rate.

The payoff for a cap is:

$\mathrm{max}\left(CurrentRate-CapRate,0\right)$