optSensByBatesFFT

Option price and sensitivities by Bates model using FFT and FRFT

Syntax

[PriceSens,StrikeOut] = optSensByBatesFFT(Rate,AssetPrice,Settle,Maturity,OptSpec,Strike,V0,ThetaV,Kappa,SigmaV,RhoSV,MeanJ,JumpVol,JumpFreq)

[PriceSens,StrikeOut] = optSensByBatesFFT(___,Name,Value)

Description

[PriceSens,StrikeOut] = optSensByBatesFFT(Rate,AssetPrice,Settle,Maturity,OptSpec,Strike,V0,ThetaV,Kappa,SigmaV,RhoSV,MeanJ,JumpVol,JumpFreq) computes vanilla European option price and sensitivities by Bates model, using Carr-Madan FFT and Chourdakis FRFT methods.

Note

Alternatively, you can use the Vanilla object to calculate price or sensitivities for vanilla options. For more information, see Get Started with Workflows Using Object-Based Framework for Pricing Financial Instruments.

example

[PriceSens,StrikeOut] = optSensByBatesFFT(___,Name,Value) adds optional name-value pair arguments.

example

Examples

collapse all

Workflow for Plotting an Option Sensitivity Surface Using the Bates Model

Open Live Script

Use optSensByBatesFFT to calibrate the FFT strike grid for sensitivities, compute option sensitivities, and plot option sensitivity surfaces.

Define Option Variables and Bates Model Parameters

AssetPrice = 80;
Rate = 0.03;
DividendYield = 0.02;
OptSpec = 'call';

V0 = 0.04;
ThetaV = 0.05;
Kappa = 1.0;
SigmaV = 0.2;
RhoSV = -0.7;
MeanJ = 0.02;
JumpVol = 0.08;
JumpFreq = 2;

Compute the Option Sensitivities for the Entire FFT (or FRFT) Strike Grid, Without Specifying "Strike"

Compute option sensitivities and also output the corresponding strikes. If the Strike input is empty ( [] ), option sensitivities will be computed on the entire FFT (or FRFT) strike grid. The FFT (or FRFT) strike grid is determined as exp(log-strike grid), where each column of the log-strike grid has NumFFT points with LogStrikeStep spacing that are roughly centered around each element of log(AssetPrice). The default value for NumFFT is 2^12. In addition to the sensitivities in the first output, the optional last output contains the corresponding strikes.

Settle = datetime(2017,6,29);
Maturity = datemnth(Settle, 6);
Strike = []; % Strike is not specified (will use the entire FFT strike grid)

% Compute option sensitivities for the entire FFT strike grid
[Delta, Kout] = optSensByBatesFFT(Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, ...
    V0, ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'OutSpec', "delta");

% Show the lowest and highest strike values on the FFT strike grid
format
MinStrike = Kout(1) % Lowest possible strike in the current FFT strike grid

MinStrike = 
2.9205e-135

MaxStrike = Kout(end) % Highest possible strike in the current FFT strike grid

MaxStrike = 
1.8798e+138

% Show a subset of the strikes and corresponding option sensitivities
Range = (2046:2052);
[Kout(Range) Delta(Range)]

ans = 7×2

   50.4929    0.9846
   58.8640    0.9585
   68.6231    0.8498
   80.0000    0.5630
   93.2631    0.1955
  108.7251    0.0319
  126.7505    0.0033

Change the Number of FFT (or FRFT) Points and Compare with optSensByBatesNI

Try a different number of FFT (or FRFT) points, and compare the results with numerical integration. Unlike optSensByBatesFFT, which uses FFT (or FRFT) techniques for fast computation across the whole range of strikes, the optSensByBatesNI function uses direct numerical integration and it is typically slower, especially for multiple strikes. However, the values computed by optSensByBatesNI can serve as a benchmark for adjusting the settings for optSensByBatesFFT.

% Try a smaller number of FFT points 
% (e.g. for faster performance or smaller memory footprint)
NumFFT = 2^10; % Smaller than the default value of 2^12
Strike = []; % Strike is not specified (will use the entire FFT strike grid)
[Delta, Kout] = optSensByBatesFFT(Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, ...
    V0, ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'OutSpec', "delta", 'NumFFT', NumFFT);

% Compare with numerical integration method
Range = (510:516);
Strike = Kout(Range);
DeltaFFT = Delta(Range);
DeltaNI = optSensByBatesNI(Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, V0, ...
    ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'OutSpec', "delta");
Error = abs(DeltaFFT-DeltaNI);
table(Strike, DeltaFFT, DeltaNI, Error)

ans=7×4 table
    Strike     DeltaFFT      DeltaNI        Error   
    ______    __________    __________    __________

    12.696        0.9265       0.99002      0.063524
    23.449       0.95153       0.99002      0.038497
    43.312       0.95928       0.98928      0.029994
        80        0.5355       0.56303      0.027531
    147.76     0.0016267    0.00025691     0.0013698
    272.93    0.00058267    1.8942e-09    0.00058267
    504.11    0.00017752    8.7099e-10    0.00017752

Make Further Adjustments to FFT (or FRFT)

If the values in the output DeltaFFT are significantly different from those in DeltaNI, try making adjustments to optSensByBatesFFT settings, such as CharacteristicFcnStep, LogStrikeStep, NumFFT, DampingFactor, and so on. Note that if (LogStrikeStep * CharacteristicFcnStep) is 2*pi/ NumFFT, FFT is used. Otherwise, FRFT is used.

Strike = []; % Strike is not specified (will use the entire FFT or FRFT strike grid)
[Delta, Kout] = optSensByBatesFFT(Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, ...
    V0, ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...    
    'DividendYield', DividendYield, 'OutSpec', "delta", 'NumFFT', NumFFT, ...
    'CharacteristicFcnStep', 0.065, 'LogStrikeStep', 0.001);

% Compare with numerical integration method
Strike = Kout(Range);
DeltaFFT = Delta(Range);
DeltaNI = optSensByBatesNI(Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, V0, ...
    ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'OutSpec', "delta");
Error = abs(DeltaFFT-DeltaNI);
table(Strike, DeltaFFT, DeltaNI, Error)

ans=7×4 table
    Strike    DeltaFFT    DeltaNI      Error   
    ______    ________    _______    __________

    79.76     0.57037     0.57037    6.3042e-09
    79.84     0.56793     0.56793     7.156e-09
    79.92     0.56548     0.56548     7.975e-09
       80     0.56303     0.56303    8.7573e-09
    80.08     0.56057     0.56057    9.4992e-09
    80.16     0.55811     0.55811    1.0197e-08
    80.24     0.55564     0.55564    1.0847e-08

% Save the final FFT (or FRFT) strike grid for future reference. For
% example, it provides information about the range of Strike inputs for
% which the FFT (or FRFT) operation is valid.
FFTStrikeGrid = Kout;
MinStrike = FFTStrikeGrid(1) % Strike cannot be less than MinStrike

MinStrike = 
47.9437

MaxStrike = FFTStrikeGrid(end) % Strike cannot be greater than MaxStrike

MaxStrike = 
133.3566

Compute the Option Sensitivity for a Single Strike

Once the desired FFT (or FRFT) settings are determined, use the Strike input to specify the strikes rather than providing an empty array. If the specified strikes do not match a value on the FFT (or FRFT) strike grid, the outputs are interpolated on the specified strikes.

Settle = datetime(2017,6,29);
Maturity = datemnth(Settle, 6);
Strike = 80; 

Delta = optSensByBatesFFT(Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, ...
    V0, ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'OutSpec', "delta", 'NumFFT', NumFFT, ...
    'CharacteristicFcnStep', 0.065, 'LogStrikeStep', 0.001)

Delta = 
0.5630

Compute the Option Sensitivities for a Vector of Strikes

Use the Strike input to specify the strikes.

Settle = datetime(2017,6,29);
Maturity = datemnth(Settle, 6);
Strike = (76:2:84)';

Delta = optSensByBatesFFT(Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, ...
    V0, ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'OutSpec', "delta", 'NumFFT', NumFFT, ...
    'CharacteristicFcnStep', 0.065, 'LogStrikeStep', 0.001)

Delta = 5×1

    0.6807
    0.6234
    0.5630
    0.5011
    0.4392

Compute the Option Sensitivities for a Vector of Strikes and a Vector of Dates of the Same Lengths

Use the Strike input to specify the strikes. Also, the Maturity input can be a vector, but it must match the length of the Strike vector if the ExpandOutput name-value pair argument is not set to "true".

Settle = datetime(2017,6,29);
Maturity = datemnth(Settle, [12 18 24 30 36]); % Five maturities
Strike = [76 78 80 82 84]'; % Five strikes

Delta = optSensByBatesFFT(Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, ...
    V0, ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'OutSpec', "delta", 'NumFFT', NumFFT, ...
    'CharacteristicFcnStep', 0.065, 'LogStrikeStep', 0.001) % Five values in vector output

Delta = 5×1

    0.6625
    0.6232
    0.5958
    0.5748
    0.5577

Expand the Outputs for a Surface

Set the ExpandOutput name-value pair argument to "true" to expand the outputs into NStrikes-by-NMaturities matrices. In this case, they are square matrices.

[Delta, Kout] = optSensByBatesFFT(Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, ...
    V0, ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'OutSpec', "delta", 'NumFFT', NumFFT, ...
    'CharacteristicFcnStep', 0.065, 'LogStrikeStep', 0.001, ...
    'ExpandOutput', true) % (5 x 5) matrix output

Delta = 5×5

    0.6625    0.6556    0.6515    0.6483    0.6455
    0.6222    0.6232    0.6239    0.6241    0.6238
    0.5805    0.5900    0.5958    0.5996    0.6019
    0.5381    0.5564    0.5674    0.5748    0.5798
    0.4954    0.5225    0.5389    0.5499    0.5577

Kout = 5×5

    76    76    76    76    76
    78    78    78    78    78
    80    80    80    80    80
    82    82    82    82    82
    84    84    84    84    84

Compute the Option Sensitivities for a Vector of Strikes and a Vector of Dates of Different Lengths

When ExpandOutput is "true", NStrikes do not have to match NMaturities. That is, the output NStrikes-by-NMaturities matrix can be rectangular.

Settle = datetime(2017,6,29);
Maturity = datemnth(Settle, 12*(0.5:0.5:3)'); % Six maturities
Strike = (76:2:84)'; % Five strikes

Delta = optSensByBatesFFT(Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, ...
    V0, ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'OutSpec', "delta", 'NumFFT', NumFFT, ...
    'CharacteristicFcnStep', 0.065, 'LogStrikeStep', 0.001, ...
    'ExpandOutput', true) % (5 x 6) matrix output

Delta = 5×6

    0.6807    0.6625    0.6556    0.6515    0.6483    0.6455
    0.6234    0.6222    0.6232    0.6239    0.6241    0.6238
    0.5630    0.5805    0.5900    0.5958    0.5996    0.6019
    0.5011    0.5381    0.5564    0.5674    0.5748    0.5798
    0.4392    0.4954    0.5225    0.5389    0.5499    0.5577

Compute the Option Sensitivities for a Vector of Strikes and a Vector of Asset Prices

When ExpandOutput is "true", the output can also be a NStrikes-by-NAssetPrices rectangular matrix by accepting a vector of asset prices.

Settle = datetime(2017,6,29);
Maturity = datemnth(Settle, 12); % Single maturity
ManyAssetPrices = [70 75 80 85]; % Four asset prices
Strike = (76:2:84)'; % Five strikes

Delta = optSensByBatesFFT(Rate, ManyAssetPrices, Settle, Maturity, OptSpec, ...
    Strike, V0, ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'OutSpec', "delta", 'NumFFT', NumFFT, ...
    'CharacteristicFcnStep', 0.065, 'LogStrikeStep', 0.001, ...
    'ExpandOutput', true) % (5 x 4) matrix output

Delta = 5×4

    0.4350    0.5579    0.6625    0.7457
    0.3881    0.5124    0.6222    0.7120
    0.3432    0.4670    0.5805    0.6763
    0.3010    0.4223    0.5381    0.6390
    0.2619    0.3789    0.4954    0.6002

Plot Option Sensitivity Surfaces

Use the Strike input to specify the strikes. Increase the value for NumFFT to support a wider range of strikes. Also, the Maturity input can be a vector. Set ExpandOutput to "true" to output the surfaces as NStrikes-by-NMaturities matrices.

Settle = datetime(2017,6,29);
Maturity = datemnth(Settle, 12*[1/12 0.25 (0.5:0.5:3)]');
Times = yearfrac(Settle, Maturity);
Strike = (2:2:200)';

% Increase 'NumFFT' to support a wider range of strikes
NumFFT = 2^13;

[Delta, Gamma, Rho, Theta, Vega, VegaLT] = optSensByBatesFFT(...
    Rate, AssetPrice, Settle, Maturity, OptSpec, Strike, ...
    V0, ThetaV, Kappa, SigmaV, RhoSV, MeanJ, JumpVol, JumpFreq, ...
    'DividendYield', DividendYield, 'NumFFT', NumFFT, ...
    'CharacteristicFcnStep', 0.065, 'LogStrikeStep', 0.001, ...
    'OutSpec', ["delta", "gamma", "rho", "theta", "vega", "vegalt"], ...
    'ExpandOutput', true);

[X,Y] = meshgrid(Times,Strike);

figure;
surf(X,Y,Delta);
title('Delta');
xlabel('Years to Option Expiry');
ylabel('Strike');
view(-112,34);
xlim([0 Times(end)]);

Figure contains an axes object. The axes object with title Delta, xlabel Years to Option Expiry, ylabel Strike contains an object of type surface.

figure;
surf(X,Y,Gamma)
title('Gamma')
xlabel('Years to Option Expiry')
ylabel('Strike')
view(-112,34);
xlim([0 Times(end)]);

Figure contains an axes object. The axes object with title Gamma, xlabel Years to Option Expiry, ylabel Strike contains an object of type surface.

figure;
surf(X,Y,Rho)
title('Rho')
xlabel('Years to Option Expiry')
ylabel('Strike')
view(-112,34);
xlim([0 Times(end)]);

Figure contains an axes object. The axes object with title Rho, xlabel Years to Option Expiry, ylabel Strike contains an object of type surface.

figure;
surf(X,Y,Theta)
title('Theta')
xlabel('Years to Option Expiry')
ylabel('Strike')
view(-112,34);
xlim([0 Times(end)]);

Figure contains an axes object. The axes object with title Theta, xlabel Years to Option Expiry, ylabel Strike contains an object of type surface.

figure;
surf(X,Y,Vega)
title('Vega')
xlabel('Years to Option Expiry')
ylabel('Strike')
view(-112,34);
xlim([0 Times(end)]);

Figure contains an axes object. The axes object with title Vega, xlabel Years to Option Expiry, ylabel Strike contains an object of type surface.

figure;
surf(X,Y,VegaLT)
title('VegaLT')
xlabel('Years to Option Expiry')
ylabel('Strike')
view(-112,34);
xlim([0 Times(end)]);

Figure contains an axes object. The axes object with title VegaLT, xlabel Years to Option Expiry, ylabel Strike contains an object of type surface.

Input Arguments

collapse all

`Rate` — Continuously compounded risk-free interest rate
decimal

Continuously compounded risk-free interest rate, specified as a scalar decimal value.

Data Types: double

`AssetPrice` — Current underlying asset price
numeric

Current underlying asset price, specified as numeric value using a scalar or a NINST-by-1 or NColumns-by-1 vector.

For more information on the proper dimensions for AssetPrice, see the name-value pair argument ExpandOutput.

Data Types: double

`Settle` — Option settlement date
datetime array | string array | date character vector

Option settlement date, specified as a NINST-by-1 or NColumns-by-1 vector using a datetime array, string array, or date character vectors. The Settle date must be before the Maturity date.

To support existing code, optSensByBatesFFT also accepts serial date numbers as inputs, but they are not recommended.

For more information on the proper dimensions for Settle, see the name-value pair argument ExpandOutput.

`Maturity` — Option maturity date
datetime array | string array | date character vector

Option maturity date, specified as a NINST-by-1 or NColumns-by-1 vector using a datetime array, string array, or date character vectors.

To support existing code, optSensByBatesFFT also accepts serial date numbers as inputs, but they are not recommended.

For more information on the proper dimensions for Maturity, see the name-value pair argument ExpandOutput.

`OptSpec` — Definition of option
cell array of character vector with values `'call'` or `'put'` | string array with values `"call"` or `"put"`

Definition of the option, specified as a NINST-by-1 or NColumns-by-1 vector using a cell array of character vectors or string arrays with values 'call' or 'put'.

For more information on the proper dimensions for OptSpec, see the name-value pair argument ExpandOutput.

Data Types: cell | string

`Strike` — Option strike price value
numeric

Option strike price value, specified as a NINST-by-1, NRows-by-1, NRows-by-NColumns vector of strike prices.

If this input is an empty array ([]), option prices are computed on the entire FFT (or FRFT) strike grid, which is determined as exp(log-strike grid). Each column of the log-strike grid has 'NumFFT' points with 'LogStrikeStep' spacing that are roughly centered around each element of log(AssetPrice).

For more information on the proper dimensions for Strike, see the name-value pair argument ExpandOutput.

Data Types: double

`V0` — Initial variance of underlying asset
numeric

Initial variance of the underling asset, specified as a scalar numeric value.

Data Types: double

`ThetaV` — Long-term variance of underlying asset
numeric

Long-term variance of the underling asset, specified as a scalar numeric value.

Data Types: double

`Kappa` — Mean revision speed for the variance of underlying asset
numeric

Mean revision speed for the underling asset, specified as a scalar numeric value.

Data Types: double

`SigmaV` — Volatility of the variance of underlying asset
numeric

Volatility of the variance of the underling asset, specified as a scalar numeric value.

Data Types: double

`RhoSV` — Correlation between Wiener processes for underlying asset and its variance
numeric

Correlation between the Wiener processes for the underlying asset and its variance, specified as a scalar numeric value.

Data Types: double

`MeanJ` — Mean of the random percentage jump size
decimal

Mean of the random percentage jump size (J), specified as a scalar decimal value where log(1+J) is normally distributed with mean (log(1+MeanJ)-0.5*JumpVol^2) and the standard deviation JumpVol.

Data Types: double

`JumpVol` — Standard deviation of `log`(1+J)
decimal

Standard deviation of log(1+J) where J is the random percentage jump size, specified as a scalar decimal value.

Data Types: double

`JumpFreq` — Annual frequency of Poisson jump process
numeric

Annual frequency of Poisson jump process, specified as a scalar numeric value.

Data Types: double

Name-Value Arguments

Specify optional pairs of arguments as Name1=Value1,...,NameN=ValueN, where Name is the argument name and Value is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Before R2021a, use commas to separate each name and value, and enclose Name in quotes.

Example: [PriceSens,StrikeOut] = optSensByBatesFFT(Rate,AssetPrice,Settle,Maturity,OptSpec,Strike,V0,ThetaV,Kappa,SigmaV,RhoSV,MeanJ,JumpVol,JumpFreq,'Basis',7)

`Basis` — Day-count basis of instrument
`0` (default) | numeric values: `0`,`1`, `2`, `3`, `4`, `6`, `7`, `8`, `9`, `10`, `11`, `12`, `13`

Day-count of the instrument, specified as the comma-separated pair consisting of 'Basis' and a scalar using a supported value:

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

For more information, see Basis.

Data Types: double

`DividendYield` — Continuously compounded underlying asset yield
`0` (default) | numeric

Continuously compounded underlying asset yield, specified as the comma-separated pair consisting of 'DividendYield' and a scalar numeric value.

Data Types: double

`VolRiskPremium` — Volatility risk premium
`0` (default) | numeric

Volatility risk premium, specified as the comma-separated pair consisting of 'VolRiskPremium' and a scalar numeric value.

Data Types: double

`LittleTrap` — Flag indicating Little Heston Trap formulation
`true` (default) | logical with values `true` or `false`

Flag indicating Little Heston Trap formulation by Albrecher et al, specified as the comma-separated pair consisting of 'LittleTrap' and a logical:

true — Use the Albrecher et al formulation.
false — Use the original Heston formation.

Data Types: logical

`OutSpec` — Define outputs
`["price"]` (default) | string array with values `"price"`, `"delta"`, `"gamma"`, `"vega"`, `"rho"`, `"theta"`, and `"vegalt"` | cell array of character vectors with values `'price'`, `'delta'`, `'gamma'`, `'vega'`, `'rho'`, `'theta'`, and `'vegalt'`

Define outputs, specified as the comma-separated pair consisting of 'OutSpec' and a NOUT- by-1 or a 1-by-NOUT string array or cell array of character vectors with supported values.

Note

"vega" is the sensitivity with respect the initial volatility sqrt(V0). In contrast, "vegalt" is the sensitivity with respect to the long-term volatility sqrt(ThetaV).

Example: OutSpec = ["price","delta","gamma","vega","rho","theta","vegalt"]

Data Types: string | cell

`NumFFT` — Number of grid points in the characteristic function variable
`4096` (default) | numeric

Number of grid points in the characteristic function variable and in each column of the log-strike grid, specified as the comma-separated pair consisting of 'NumFFT' and a scalar numeric value.

Data Types: double

`CharacteristicFcnStep` — Characteristic function variable grid spacing
`0.01` (default) | numeric

Characteristic function variable grid spacing, specified as the comma-separated pair consisting of 'CharacteristicFcnStep' and a scalar numeric value.

Data Types: double

`LogStrikeStep` — Log-strike grid spacing
`2*pi/NumFFT/CharacteristicFcnStep` (default) | numeric

Log-strike grid spacing, specified as the comma-separated pair consisting of 'LogStrikeStep' and a scalar numeric value.

Note

If (LogStrikeStep*CharacteristicFcnStep) is 2*pi/NumFFT, FFT is used. Otherwise, FRFT is used.

Data Types: double

`DampingFactor` — Damping factor for Carr-Madan formulation
`1.5` (default) | numeric

Damping factor for Carr-Madan formulation, specified as the comma-separated pair consisting of 'DampingFactor' and a scalar numeric value.

Data Types: double

`Quadrature` — Type of quadrature
`"simpson"` (default) | character vector with values:`'simpson'` or `'trapezoidal'` | string array with values: `"simpson"` or `"trapezoidal"`

Type of quadrature, specified as the comma-separated pair consisting of 'Quadrature' and a single character vector or string array with a value of 'simpson' or 'trapezoidal'.

Data Types: char | string

`ExpandOutput` — Flag to expand the outputs
`false` (outputs are `NINST`-by-`1` vectors) (default) | logical with value of `true` or `false`

Flag to expand the outputs, specified as the comma-separated pair consisting of 'ExpandOutput' and a logical:

true — If true, the outputs are NRows-by- NColumns matrices. NRows is the number of strikes for each column and it is determined by the Strike input. For example, Strike can be a NRows-by-1 vector, or a NRows-by-NColumns matrix. If Strike is empty, NRows is equal to NumFFT. NColumns is determined by the sizes of AssetPrice, Settle, Maturity, and OptSpec, which must all be either scalar or NColumns-by-1 vectors.
false — If false, the outputs are NINST-by-1 vectors. Also, the inputs Strike, AssetPrice, Settle, Maturity, and OptSpec must all be either scalar or NINST-by-1 vectors.

Data Types: logical

Output Arguments

collapse all

`PriceSens` — Option prices or sensitivities
numeric

Option prices or sensitivities, returned as a NINST-by-1, or NRows-by-NColumns, depending on ExpandOutput. The name-value pair argument OutSpec determines the types and order of the outputs.

`StrikeOut` — Strikes corresponding to `Price`
numeric

Strikes corresponding to Price, returned as a NINST-by-1, or NRows-by-NColumns, depending on ExpandOutput.

More About

collapse all

Vanilla Option

A vanilla option is a category of options that includes only the most standard components.

A vanilla option has an expiration date and straightforward strike price. American-style options and European-style options are both categorized as vanilla options.

The payoff for a vanilla option is as follows:

For a call: $\max (S t - K, 0)$
For a put: $\max (K - S t, 0)$

where:

St is the price of the underlying asset at time t.

K is the strike price.

For more information, see Vanilla Option.

Bates Stochastic Volatility Jump Diffusion Model

The Bates model (Bates (1996)) is an extension of the Heston model, where, in addition to stochastic volatility, the jump diffusion parameters similar to Merton (1976) were also added to model sudden asset price movements.

The stochastic differential equation is:

$\begin{array}{l} d S_{t} = (r - q - λ_{p} μ_{J}) S_{t} d t + \sqrt{v_{t}} S_{t} d W_{t} + J S_{t} d P_{t} \\ d v_{t} = κ (θ - v_{t}) d t + σ_{v} \sqrt{v_{t}} d W_{t} \\ E [d W_{t} d W_{t}^{v}] = p d t \\ prob(d P_{t} = 1) = λ_{p} d t \end{array}$

where

r is the continuous risk-free rate.

q is the continuous dividend yield.

S_t is the asset price at time t.

v_t is the asset price variance at time t.

J is the random percentage jump size conditional on the jump occurring, where ln(1+J) is normally distributed with mean $\ln (1 + μ_{J}) - \frac{δ^{2}}{2}$ and the standard deviation δ, and (1+J) has a lognormal distribution:

$\frac{1}{(1 + J) δ \sqrt{2 π}} \exp {{\frac{- [\ln (1 + J) - (\ln (1 + μ_{J}) - \frac{δ^{2}}{2}]}{2 δ^{2}}}^{2}}$

v₀ is the initial variance of the asset price at t = 0 (v₀> 0).

θ is the long-term variance level for (θ > 0).

κ is the mean reversion speed for (κ > 0).

σ_v is the volatility of variance for (σ_v > 0).

p is the correlation between the Wiener processes W_t and $W_{t}^{v}$ for (-1 ≤ p ≤ 1).

μ_J is the mean of J for (μ_J > -1).

δ is the standard deviation of ln(1+J) for (δ ≥ 0).

$λ_{p}$ is the annual frequency (intensity) of Poisson process P_t for ( $λ_{p}$ ≥ 0).

The characteristic function $f_{B a t e s_{j} (ϕ)}$ for j = 1 (asset price mean measure) and j =2 (risk-neutral measure) is:

$\begin{array}{l} f_{B a t e s (ϕ)} = \exp (C_{j} + D_{j} v_{0} + i ϕ \ln S_{t}) \exp {(λ_{p} τ (1 + μ_{J})}^{m_{j} + \frac{1}{2}} [{(1 + μ_{j})}^{i ϕ} e^{δ^{2} (m_{j} i ϕ + \frac{{(i ϕ)}^{2}}{2})} - 1] - λ_{p} τ μ_{J} i ϕ) \\ m_{j} = {\begin{cases} m_{1} = \frac{1}{2} \\ m_{2} = - \frac{1}{2} \end{cases}} \\ C_{j} = (r - q) i ϕ τ + \frac{κ θ}{σ_{v}^{2}} [(b_{j} - p σ_{v} i ϕ + d_{j}) τ - 2 \ln (\frac{1 - g_{j} e^{d_{j} τ}}{1 - g_{j}})] \\ D j = \frac{b_{j} - p σ_{v} i ϕ + d_{j}}{σ_{v}^{2}} (\frac{1 - e^{d_{j} τ}}{1 - g_{j} e^{d_{j} τ}}) \\ g_{j} = \frac{b_{j} - p σ_{v} i ϕ + d_{j}}{b_{j} - p σ_{v} i ϕ - d_{j}} \\ d_{j} = \sqrt{{(b_{j} - p σ_{v} i ϕ)}^{2} - σ_{v}^{2} (2 u_{j} i ϕ - ϕ^{2})} \\ where for j = 1, 2 : \\ u_{1} = \frac{1}{2}, u_{2} = - \frac{1}{2}, b_{1} = κ + λ_{V o l R i s k} - p σ_{v}, b_{2} = κ + λ_{V o l R i s k} \end{array}$

where

ϕ is the characteristic function variable.

ƛ_VolRisk is the volatility risk premium.

τ is the time to maturity for (τ = T - t).

i is the unit imaginary number for (i²= -1).

The definitions for C_j and D_j under “The Little Heston Trap” by Albrecher et al. (2007) are:

$\begin{array}{l} C_{j} = (r - q) i ϕ τ + \frac{κ θ}{σ_{v}^{2}} [(b_{j} - p σ_{v} i ϕ - d_{j}) τ - 2 \ln (\frac{1 - ε_{j} e^{- d_{j} τ}}{1 - ε_{j}})] \\ D j = \frac{b_{j} - p σ_{v} i ϕ - d_{j}}{σ_{v}^{2}} (\frac{1 - e^{- d_{j} τ}}{1 - ε_{j} e^{- d_{j} τ}}) \\ ε_{j} = \frac{b_{j} - p σ_{v} i ϕ - d_{j}}{b_{j} - p σ_{v} i ϕ + d_{j}} \end{array}$

Carr-Madan Formulation

The Carr and Madan (1999) formulation is a popular modified implementation of Heston (1993) framework.

Rather than computing the probabilities P₁ and P₂ as intermediate steps, Carr and Madan developed an alternative expression so that taking its inverse Fourier transform gives the option price itself directly.

$\begin{array}{l} C a l l (k) = \frac{e^{- α k}}{π} \int_{0}^{\infty} Re [e^{- i u k} ψ (u)] d u \\ ψ (u) = \frac{e^{- r τ} f_{2} (ϕ = (u - (α + 1) i))}{α^{2} + α - u^{2} + i u (2 α + 1)} \\ P u t (K) = C a l l (K) + K e^{- r τ} - S_{t} e^{- q τ} \end{array}$

where

r is the continuous risk-free rate.

q is the continuous dividend yield.

S_t is the asset price at time t.

τ is time to maturity (τ = T-t).

Call(K) is the call price at strike K.

Put(K) is the put price at strike K.

i is a unit imaginary number (i²= -1).

ϕ is the characteristic function variable.

α is the damping factor.

u is the characteristic function variable for integration, where ϕ = (u - (α+1)i).

f₂(ϕ) is the characteristic function for P₂.

P₂ is the probability of S_t > K under the risk-neutral measure for the model.

To apply FFT or FRFT to this formulation, the characteristic function variable for integration, u, is discretized into NumFFT(N) points with the step size CharacteristicFcnStep (Δu), and the log-strike k is discretized into N points with the step size LogStrikeStep(Δk).

The discretized characteristic function variable for integration, u_j(for j = 1,2,3,…,N), has a minimum value of 0 and a maximum value of (N-1) (Δu), and it approximates the continuous integration range from 0 to infinity.

The discretized log-strike grid, k_n(for n = 1, 2, 3, N) is approximately centered around ln(S_t), with a minimum value of

$\ln (S_{t}) - \frac{N}{2} Δ k$

and a maximum value of

$\ln (S_{t}) + (\frac{N}{2} - 1) Δ k$

Where the minimum allowable strike is

$S_{t} \exp (- \frac{N}{2} Δ k)$

and the maximum allowable strike is

$S_{t} \exp [(\frac{N}{2} - 1) Δ k]$

As a result of the discretization, the expression for the call option becomes

$C a l l (k_{n}) = Δ u \frac{e^{- α k_{n}}}{π} \sum_{j = 1}^{N} Re [e^{- i Δ k Δ u (j - 1) (n - 1) e^{i u_{j}} [\frac{N Δ k}{2} - \ln (S_{t})]} ψ (u_{j})] w_{j}$

where

Δu is the step size of discretized characteristic function variable for integration.

Δk is the step size of discretized log-strike.

N is the number of FFT/FRFT points

w_j is the weights for quadrature used for approximating the integral.

FFT is used to evaluate the above expression if Δk and Δu are subject to the following constraint:

$Δ k Δ u = (\frac{2 π}{N})$

otherwise, the functions use the FRFT method described in Chourdakis (2005).

References

[1] Albrecher, H., Mayer, P., Schoutens, W., and Tistaert, J. "The Little Heston Trap." Working Paper, Linz and Graz University of Technology, K.U. Leuven, ING Financial Markets, 2006.

[2] Bates, D. S. “Jumps and Stochastic Volatility: Exchange Rate Processes Implicit in Deutsche Mark Options.” The Review of Financial Studies. Vol 9. No. 1. 1996.

[3] Carr, P. and D.B. Madan. “Option Valuation Using the Fast Fourier Transform.” Journal of Computational Finance. Vol 2. No. 4. 1999.

[4] Chourdakis, K. “Option Pricing Using Fractional FFT.” Journal of Computational Finance. 2005.

[5] Heston, S. L. “A Closed-Form Solution for Options with Stochastic Volatility with Applications to Bond and Currency Options.” The Review of Financial Studies. Vol 6. No. 2. 1993.

Version History

Introduced in R2018a

expand all

R2022b: Serial date numbers not recommended

Although optSensByBatesFFT supports serial date numbers, datetime values are recommended instead. The datetime data type provides flexible date and time formats, storage out to nanosecond precision, and properties to account for time zones and daylight saving time.

To convert serial date numbers or text to datetime values, use the datetime function. For example:

t = datetime(738427.656845093,"ConvertFrom","datenum");
y = year(t)

y =

        2021

There are no plans to remove support for serial date number inputs.

optSensByBatesFFT

Syntax

Description

Examples

Workflow for Plotting an Option Sensitivity Surface Using the Bates Model

Input Arguments

Rate — Continuously compounded risk-free interest rate decimal

AssetPrice — Current underlying asset price numeric

Settle — Option settlement date datetime array | string array | date character vector

Maturity — Option maturity date datetime array | string array | date character vector

OptSpec — Definition of option cell array of character vector with values 'call' or 'put' | string array with values "call" or "put"

Strike — Option strike price value numeric

V0 — Initial variance of underlying asset numeric

ThetaV — Long-term variance of underlying asset numeric

Kappa — Mean revision speed for the variance of underlying asset numeric

SigmaV — Volatility of the variance of underlying asset numeric

RhoSV — Correlation between Wiener processes for underlying asset and its variance numeric

MeanJ — Mean of the random percentage jump size decimal

JumpVol — Standard deviation of log(1+J) decimal

JumpFreq — Annual frequency of Poisson jump process numeric

Name-Value Arguments

Basis — Day-count basis of instrument 0 (default) | numeric values: 0,1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13

DividendYield — Continuously compounded underlying asset yield 0 (default) | numeric

VolRiskPremium — Volatility risk premium 0 (default) | numeric

LittleTrap — Flag indicating Little Heston Trap formulation true (default) | logical with values true or false

OutSpec — Define outputs ["price"] (default) | string array with values "price", "delta", "gamma", "vega", "rho", "theta", and "vegalt" | cell array of character vectors with values 'price', 'delta', 'gamma', 'vega', 'rho', 'theta', and 'vegalt'

NumFFT — Number of grid points in the characteristic function variable 4096 (default) | numeric

CharacteristicFcnStep — Characteristic function variable grid spacing 0.01 (default) | numeric

LogStrikeStep — Log-strike grid spacing 2*pi/NumFFT/CharacteristicFcnStep (default) | numeric

DampingFactor — Damping factor for Carr-Madan formulation 1.5 (default) | numeric

Quadrature — Type of quadrature "simpson" (default) | character vector with values:'simpson' or 'trapezoidal' | string array with values: "simpson" or "trapezoidal"

ExpandOutput — Flag to expand the outputs false (outputs are NINST-by-1 vectors) (default) | logical with value of true or false

Output Arguments

PriceSens — Option prices or sensitivities numeric

StrikeOut — Strikes corresponding to Price numeric

More About

Vanilla Option

Bates Stochastic Volatility Jump Diffusion Model

Carr-Madan Formulation

References

Version History

R2022b: Serial date numbers not recommended

See Also

Topics

`Rate` — Continuously compounded risk-free interest rate
decimal

`AssetPrice` — Current underlying asset price
numeric

`Settle` — Option settlement date
datetime array | string array | date character vector

`Maturity` — Option maturity date
datetime array | string array | date character vector

`OptSpec` — Definition of option
cell array of character vector with values `'call'` or `'put'` | string array with values `"call"` or `"put"`

`Strike` — Option strike price value
numeric

`V0` — Initial variance of underlying asset
numeric

`ThetaV` — Long-term variance of underlying asset
numeric

`Kappa` — Mean revision speed for the variance of underlying asset
numeric

`SigmaV` — Volatility of the variance of underlying asset
numeric

`RhoSV` — Correlation between Wiener processes for underlying asset and its variance
numeric

`MeanJ` — Mean of the random percentage jump size
decimal

`JumpVol` — Standard deviation of `log`(1+J)
decimal

`JumpFreq` — Annual frequency of Poisson jump process
numeric

`Basis` — Day-count basis of instrument
`0` (default) | numeric values: `0`,`1`, `2`, `3`, `4`, `6`, `7`, `8`, `9`, `10`, `11`, `12`, `13`

`DividendYield` — Continuously compounded underlying asset yield
`0` (default) | numeric

`VolRiskPremium` — Volatility risk premium
`0` (default) | numeric

`LittleTrap` — Flag indicating Little Heston Trap formulation
`true` (default) | logical with values `true` or `false`

`OutSpec` — Define outputs
`["price"]` (default) | string array with values `"price"`, `"delta"`, `"gamma"`, `"vega"`, `"rho"`, `"theta"`, and `"vegalt"` | cell array of character vectors with values `'price'`, `'delta'`, `'gamma'`, `'vega'`, `'rho'`, `'theta'`, and `'vegalt'`

`NumFFT` — Number of grid points in the characteristic function variable
`4096` (default) | numeric

`CharacteristicFcnStep` — Characteristic function variable grid spacing
`0.01` (default) | numeric

`LogStrikeStep` — Log-strike grid spacing
`2*pi/NumFFT/CharacteristicFcnStep` (default) | numeric

`DampingFactor` — Damping factor for Carr-Madan formulation
`1.5` (default) | numeric

`Quadrature` — Type of quadrature
`"simpson"` (default) | character vector with values:`'simpson'` or `'trapezoidal'` | string array with values: `"simpson"` or `"trapezoidal"`

`ExpandOutput` — Flag to expand the outputs
`false` (outputs are `NINST`-by-`1` vectors) (default) | logical with value of `true` or `false`

`PriceSens` — Option prices or sensitivities
numeric

`StrikeOut` — Strikes corresponding to `Price`
numeric