162 lines
7.3 KiB
MQL5
162 lines
7.3 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| BlackScholes.mqh |
| |||
//| MMQ — Muhammad Minhas Qamar |
| |||
//| www.mql5.com/en/articles/23410 |
| |||
//+------------------------------------------------------------------+
| |||
#property copyright "MMQ — Muhammad Minhas Qamar"
| |||
#property link "https://www.mql5.com/en/articles/23410"
| |||
#property version "1.00"
| |||
| |||
#ifndef GEX_BLACKSCHOLES_MQH
| |||
#define GEX_BLACKSCHOLES_MQH
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Option right, matching MQL5's ENUM_SYMBOL_OPTION_RIGHT so both |
| |||
//| data providers can pass the value straight through. |
| |||
//+------------------------------------------------------------------+
| |||
enum ENUM_OPT_RIGHT
| |||
{
| |||
OPT_CALL = 0, // right to buy
| |||
OPT_PUT = 1 // right to sell
| |||
};
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Standard normal CDF, via the Abramowitz & Stegun 7.1.26 |
| |||
//| approximation of erf. Accurate to about 1e-7, far tighter than |
| |||
//| option-quote noise. |
| |||
//+------------------------------------------------------------------+
| |||
double NormCDF(const double x)
| |||
{
| |||
double t = 1.0 / (1.0 + 0.2316419 * MathAbs(x));
| |||
double d = 0.3989422804014327 * MathExp(-x * x / 2.0); // 1/sqrt(2pi) * e^(-x^2/2)
| |||
double p = d * t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
| |||
return((x > 0.0) ? 1.0 - p : p);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Standard normal PDF. |
| |||
//+------------------------------------------------------------------+
| |||
double NormPDF(const double x)
| |||
{
| |||
return(0.3989422804014327 * MathExp(-x * x / 2.0));
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Black-Scholes price of a European option. |
| |||
//| S spot price of the underlying |
| |||
//| K strike price |
| |||
//| r risk-free rate (annual, continuous) |
| |||
//| q dividend / carry yield (annual, continuous) |
| |||
//| sigma volatility (annual) |
| |||
//| T time to expiry in years |
| |||
//+------------------------------------------------------------------+
| |||
double BSPrice(const ENUM_OPT_RIGHT right, const double S, const double K,
| |||
const double r, const double q, const double sigma, const double T)
| |||
{
| |||
if(T <= 0.0 || sigma <= 0.0)
| |||
{
| |||
//--- at/after expiry, value is pure intrinsic
| |||
double intrinsic = (right == OPT_CALL) ? MathMax(S - K, 0.0) : MathMax(K - S, 0.0);
| |||
return(intrinsic);
| |||
}
| |||
double sqrtT = MathSqrt(T);
| |||
double d1 = (MathLog(S / K) + (r - q + 0.5 * sigma * sigma) * T) / (sigma * sqrtT);
| |||
double d2 = d1 - sigma * sqrtT;
| |||
double disc_r = MathExp(-r * T);
| |||
double disc_q = MathExp(-q * T);
| |||
if(right == OPT_CALL)
| |||
return(S * disc_q * NormCDF(d1) - K * disc_r * NormCDF(d2));
| |||
else
| |||
return(K * disc_r * NormCDF(-d2) - S * disc_q * NormCDF(-d1));
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Vega (price sensitivity to a 1.00 change in sigma). Used both as |
| |||
//| the Newton step denominator and to reject near-worthless options |
| |||
//| whose IV is numerically meaningless. |
| |||
//+------------------------------------------------------------------+
| |||
double BSVega(const double S, const double K, const double r, const double q,
| |||
const double sigma, const double T)
| |||
{
| |||
if(T <= 0.0 || sigma <= 0.0)
| |||
return(0.0);
| |||
double sqrtT = MathSqrt(T);
| |||
double d1 = (MathLog(S / K) + (r - q + 0.5 * sigma * sigma) * T) / (sigma * sqrtT);
| |||
return(S * MathExp(-q * T) * NormPDF(d1) * sqrtT);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Gamma: the rate of change of delta per 1.0 move in the spot, and |
| |||
//| the Greek this whole tool is built on. Both a call and a put on |
| |||
//| the same strike/expiry share the same gamma, so the sign that |
| |||
//| turns it into dealer exposure is applied later, not here. |
| |||
//| Same expiry/volatility guard as the pricer: gamma is undefined |
| |||
//| at or past expiry, so we return zero there. |
| |||
//+------------------------------------------------------------------+
| |||
double BSGamma(const double S, const double K, const double r, const double q,
| |||
const double sigma, const double T)
| |||
{
| |||
if(T <= 0.0 || sigma <= 0.0 || S <= 0.0)
| |||
return(0.0);
| |||
double sqrtT = MathSqrt(T);
| |||
double d1 = (MathLog(S / K) + (r - q + 0.5 * sigma * sigma) * T) / (sigma * sqrtT);
| |||
return(MathExp(-q * T) * NormPDF(d1) / (S * sigma * sqrtT));
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Implied volatility by inverting the Black-Scholes price. Uses |
| |||
//| Newton-Raphson (fast) and falls back to bisection whenever a |
| |||
//| Newton step leaves the bracket, which keeps the solver robust for|
| |||
//| deep in/out-of-the-money quotes where vega is tiny. |
| |||
//| |
| |||
//| Returns the implied volatility, or a negative value if no valid |
| |||
//| IV exists for the given inputs (e.g. price below intrinsic). |
| |||
//+------------------------------------------------------------------+
| |||
double ImpliedVol(const ENUM_OPT_RIGHT right, const double price, const double S,
| |||
const double K, const double r, const double q, const double T)
| |||
{
| |||
if(price <= 0.0 || S <= 0.0 || K <= 0.0 || T <= 0.0)
| |||
return(-1.0);
| |||
| |||
//--- price must sit above intrinsic value or no positive sigma solves it
| |||
double intrinsic = (right == OPT_CALL) ? MathMax(S * MathExp(-q * T) - K * MathExp(-r * T), 0.0)
| |||
: MathMax(K * MathExp(-r * T) - S * MathExp(-q * T), 0.0);
| |||
if(price < intrinsic - 1e-8)
| |||
return(-1.0);
| |||
| |||
double loVol = 1e-4, hiVol = 5.0; // 0.01% .. 500% brackets the search
| |||
double sigma = 0.2; // a sensible starting guess (20%)
| |||
| |||
for(int i = 0; i < 100; i++)
| |||
{
| |||
double model = BSPrice(right, S, K, r, q, sigma, T);
| |||
double diff = model - price;
| |||
if(MathAbs(diff) < 1e-6)
| |||
return(sigma);
| |||
| |||
//--- shrink the bracket using the sign of the error (price rises monotonically with sigma)
| |||
if(diff > 0.0)
| |||
hiVol = sigma;
| |||
else
| |||
loVol = sigma;
| |||
| |||
double vega = BSVega(S, K, r, q, sigma, T);
| |||
double next;
| |||
if(vega > 1e-8)
| |||
next = sigma - diff / vega; // Newton step
| |||
else
| |||
next = 0.5 * (loVol + hiVol); // vega too small: bisect
| |||
| |||
//--- if Newton jumped outside the bracket, fall back to bisection
| |||
if(next <= loVol || next >= hiVol)
| |||
next = 0.5 * (loVol + hiVol);
| |||
| |||
if(MathAbs(next - sigma) < 1e-8)
| |||
return(next);
| |||
sigma = next;
| |||
}
| |||
return(sigma);
| |||
}
| |||
| |||
#endif // GEX_BLACKSCHOLES_MQH
| |||
//+------------------------------------------------------------------+
|