Creates an Analytic Double-Exponential Jump Diffusion with Deterministic Jump Intensity Engine for pricing vanilla structures.

This engine is an extension of the Heston model and thus utilises the five main heston parameters (v0, kappa, theta, sigma and rho contained within a HestonProcess() or HestonProcess2() object via the 'hestonProcess' parameter.

During a calibration of this model, CalibBatesDblExpDetJump() you can choose to freeze the five Heston parameters and just calibrate the parameters pertaining to this model) The Bates model engine is based on Fourier transform.

This is a Jump-Diffusion with Stochastic Volatility model that prices european options under the following processes [ dS(t,S)=(r-d-lambda*m)*S*dt+sqrt{v}*S*dW_1+(e^J - 1)*S*dN, dv(t,S)=kappa*(theta-v)*dt+sigma*sqrt{v}*dW_2, dlambda(t)=kappaL*(thetaL-lambda)*dt, dW_1*dW_2=rho*dt ]. The function N() is a Poisson process with the intensity lambda.

When a jump occurs the magnitude J has the probability distribution function omega(J).

The jump size has an asymmetric double exponential distribution and the omega(J) function is defined as [ omega(J)=p*(1/nu_d)*e^(-(1/nu_d)*J)*I(J GreaterThan 0)+q*(1/nu_d)*e^((1/nu_d)*J)*I(J lessThan 0), I() is the indicator function and p+q=1 ]. The string 'Key' resulting from a successful construction of this engine object can be passed to the VanillaOption() function in order to create an VanillaOption object that can be priced via the PrcObjVanillaOption() function.

Be advised that the corresponding stochastic process object that is to be passed to the VanillaOption() function ('stochProcess' parameter) to support this engine has to be a Heston process object ( HestonProcess() or HestonProcess2() ).

In fact the same heston process object passed to this function's 'hestonProcess' parameter should also be passed to the VanillaOption() function.

This function creates an object and returns a string-key value to represent this created object.
The TAG value of the string-key returned (second part of the key) is : "BATE2EXPJENG"

String CTEngine.BatesDblExpDetJumpEng( _
String Key, _
Long Reload, _
String hestonProcess, _
Long integrationOrder, _
Double lambda, _
Double nu_u, _
Double nu_d, _
Double prob, _
Double kappaL, _
Double thetaL)

=CT.ENG.BatesDblExpDetJumpEng(
Excel String Cell Key,
Excel Numeric Cell Reload,
Excel String Cell hestonProcess,
Excel Numeric Cell integrationOrder,
Excel Numeric Cell lambda,
Excel Numeric Cell nu_u,
Excel Numeric Cell nu_d,
Excel Numeric Cell prob,
Excel Numeric Cell kappaL,
Excel Numeric Cell thetaL)

static std::string BatesDblExpDetJumpEng(
std::string Key,
long Reload,
std::string hestonProcess,
long integrationOrder,
double lambda,
double nu_u,
double nu_d,
double prob,
double kappaL,
double thetaL);

System.String CTEngineSA.BatesDblExpDetJumpEng(
System.String Key,
System.Int32 Reload,
System.String hestonProcess,
System.Int32 integrationOrder,
System.Double lambda,
System.Double nu_u,
System.Double nu_d,
System.Double prob,
System.Double kappaL,
System.Double thetaL);

The C# example below contains all the sub-function calls leading up to this function call. As a result, the example can contain a lot of code.

The VB.NET, J#, C++.NET, Java, Excel VBA, Visual Basic 6 (via COM) and C++ examples below contain function code stubs for the calls leading up to this function call. However, the function call for this function is displayed.
You can easily reproduce the stub functions code from the C# example.