376 lines
16 KiB
MQL5
376 lines
16 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| GexData.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_GEXDATA_MQH
|
|
#define GEX_GEXDATA_MQH
|
|
|
|
#include <GEX/BlackScholes.mqh>
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| One raw option quote, before it is aggregated into the profile. |
|
|
//| It carries everything the gamma math needs: the strike, the |
|
|
//| right, the time to expiry, and the open interest that scales a |
|
|
//| contract's gamma into a real dealer exposure. The iv field is |
|
|
//| filled by the provider (inverted from the price, or read from |
|
|
//| the server) because gamma is a function of volatility. |
|
|
//+------------------------------------------------------------------+
|
|
struct OptionQuote
|
|
{
|
|
ENUM_OPT_RIGHT right;
|
|
double strike;
|
|
datetime expiry;
|
|
double price; // market mid price
|
|
double spot; // underlying price
|
|
double rate; // risk-free rate
|
|
double open_interest; // contracts outstanding at this strike
|
|
double iv; // filled in by the provider (-1 if invalid)
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| The gamma-exposure profile for a single expiry. It reduces a |
|
|
//| flat option chain to one number per strike: the net dealer gamma |
|
|
//| exposure (GEX) at that strike, positive where dealers are long |
|
|
//| gamma and negative where they are short. From that profile it |
|
|
//| derives the three levels traders actually read: the call wall |
|
|
//| (largest positive GEX), the put wall (largest negative GEX), and |
|
|
//| the zero-gamma "flip" price where total exposure crosses zero. |
|
|
//+------------------------------------------------------------------+
|
|
class CGexProfile
|
|
{
|
|
private:
|
|
double m_strikes[]; // sorted unique strikes for the chosen expiry
|
|
double m_gex[]; // signed dealer GEX per strike (aligned to m_strikes)
|
|
OptionQuote m_quotes[]; // the quotes that survived onto the chosen expiry
|
|
double m_spot;
|
|
double m_multiplier; // contract size (100 for US equity options)
|
|
datetime m_expiry; // the single expiry this profile represents
|
|
|
|
double m_netGex; // sum of m_gex, the headline regime number
|
|
double m_gexMin, m_gexMax; // most-negative / most-positive per-strike GEX
|
|
double m_callWall; // strike of the largest positive GEX
|
|
double m_putWall; // strike of the most-negative GEX
|
|
double m_flip; // zero-gamma price (<0 if none found)
|
|
|
|
public:
|
|
CGexProfile(void) : m_spot(0), m_multiplier(100.0), m_expiry(0),
|
|
m_netGex(0), m_gexMin(0), m_gexMax(0),
|
|
m_callWall(0), m_putWall(0), m_flip(-1.0) {}
|
|
|
|
//--- accessors the renderer reads
|
|
int NStrikes(void) const { return(ArraySize(m_strikes)); }
|
|
double Strike(const int i) const { return(m_strikes[i]); }
|
|
double Gex(const int i) const { return(m_gex[i]); }
|
|
double Spot(void) const { return(m_spot); }
|
|
datetime Expiry(void) const { return(m_expiry); }
|
|
double NetGex(void) const { return(m_netGex); }
|
|
double GexMin(void) const { return(m_gexMin); }
|
|
double GexMax(void) const { return(m_gexMax); }
|
|
double CallWall(void) const { return(m_callWall); }
|
|
double PutWall(void) const { return(m_putWall); }
|
|
double Flip(void) const { return(m_flip); }
|
|
|
|
void Multiplier(const double m) { m_multiplier = (m > 0.0) ? m : 100.0; }
|
|
|
|
//--- build the profile; target is the expiry to use, or 0 for "nearest future"
|
|
bool Build(OptionQuote "es[], const datetime target = 0);
|
|
|
|
private:
|
|
datetime PickExpiry(OptionQuote "es[], const datetime target) const;
|
|
double DealerGammaAtSpot(const double S) const;
|
|
double SolveFlip(void) const;
|
|
int IndexOf(const double &arr[], const double v) const;
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Choose which expiry to profile. A GEX map is always a single |
|
|
//| expiry (near-dated positioning is what pins index price), so we |
|
|
//| either honour the caller's requested expiry or, when none is |
|
|
//| given, take the nearest one still in the future. Expired |
|
|
//| contracts never win here. |
|
|
//+------------------------------------------------------------------+
|
|
datetime CGexProfile::PickExpiry(OptionQuote "es[], const datetime target) const
|
|
{
|
|
datetime now = TimeCurrent();
|
|
if(now == 0)
|
|
now = TimeLocal();
|
|
|
|
datetime best = 0;
|
|
double bestDist = 1e18;
|
|
int n = ArraySize(quotes);
|
|
for(int i = 0; i < n; i++)
|
|
{
|
|
datetime e = quotes[i].expiry;
|
|
if(e <= now)
|
|
continue; // never profile an expired contract
|
|
//--- distance is "closeness to the requested expiry", or "closeness to now"
|
|
double dist = (target > 0) ? MathAbs((double)(e - target)) : (double)(e - now);
|
|
if(dist < bestDist)
|
|
{
|
|
bestDist = dist;
|
|
best = e;
|
|
}
|
|
}
|
|
return(best);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Build the single-expiry profile. Pick the expiry, keep only the |
|
|
//| quotes on it, collect the sorted unique strikes, then sum the |
|
|
//| signed dealer GEX at each strike. The dealer-sign convention is |
|
|
//| the standard one: dealers are assumed short calls and long puts |
|
|
//| against the customer, so a call's gamma adds to exposure and a |
|
|
//| put's subtracts. Per contract the exposure is |
|
|
//| gamma * OI * multiplier * spot^2 * 0.01 |
|
|
//| i.e. dollar gamma per 1% move in the underlying. |
|
|
//+------------------------------------------------------------------+
|
|
bool CGexProfile::Build(OptionQuote "es[], const datetime target)
|
|
{
|
|
int n = ArraySize(quotes);
|
|
if(n == 0)
|
|
return(false);
|
|
|
|
m_spot = quotes[0].spot;
|
|
m_expiry = PickExpiry(quotes, target);
|
|
if(m_expiry == 0)
|
|
{
|
|
Print("CGexProfile: no future expiry to profile");
|
|
return(false);
|
|
}
|
|
|
|
//--- keep only this expiry's usable quotes (valid IV, positive OI)
|
|
ArrayResize(m_quotes, 0);
|
|
ArrayResize(m_strikes, 0);
|
|
for(int i = 0; i < n; i++)
|
|
{
|
|
if(quotes[i].expiry != m_expiry)
|
|
continue;
|
|
if(quotes[i].iv <= 0.0 || quotes[i].open_interest <= 0.0)
|
|
continue; // no gamma or no size means no exposure
|
|
int s = ArraySize(m_quotes);
|
|
ArrayResize(m_quotes, s + 1);
|
|
m_quotes[s] = quotes[i];
|
|
if(IndexOf(m_strikes, quotes[i].strike) < 0)
|
|
{ int k = ArraySize(m_strikes); ArrayResize(m_strikes, k + 1); m_strikes[k] = quotes[i].strike; }
|
|
}
|
|
ArraySort(m_strikes);
|
|
int nk = ArraySize(m_strikes);
|
|
if(nk < 2)
|
|
{
|
|
Print("CGexProfile: fewer than 2 usable strikes on the chosen expiry");
|
|
return(false);
|
|
}
|
|
|
|
//--- sum signed dealer GEX per strike, evaluated at the live spot
|
|
datetime now = TimeCurrent();
|
|
if(now == 0)
|
|
now = TimeLocal();
|
|
ArrayResize(m_gex, nk);
|
|
ArrayInitialize(m_gex, 0.0);
|
|
|
|
int nq = ArraySize(m_quotes);
|
|
for(int i = 0; i < nq; i++)
|
|
{
|
|
double T = (double)(m_quotes[i].expiry - now) / (365.0 * 24 * 3600);
|
|
if(T <= 0.0)
|
|
continue;
|
|
double g = BSGamma(m_spot, m_quotes[i].strike, m_quotes[i].rate, 0.0, m_quotes[i].iv, T);
|
|
double contractGex = g * m_quotes[i].open_interest * m_multiplier * m_spot * m_spot * 0.01;
|
|
double signed_ = (m_quotes[i].right == OPT_CALL) ? contractGex : -contractGex;
|
|
int k = IndexOf(m_strikes, m_quotes[i].strike);
|
|
if(k >= 0)
|
|
m_gex[k] += signed_;
|
|
}
|
|
|
|
//--- derive the headline numbers and the walls from the per-strike profile
|
|
m_netGex = 0.0;
|
|
m_gexMin = 1e18;
|
|
m_gexMax = -1e18;
|
|
m_callWall = m_strikes[0];
|
|
m_putWall = m_strikes[0];
|
|
double maxPos = -1e18, maxNeg = 1e18;
|
|
for(int k = 0; k < nk; k++)
|
|
{
|
|
m_netGex += m_gex[k];
|
|
if(m_gex[k] < m_gexMin)
|
|
m_gexMin = m_gex[k];
|
|
if(m_gex[k] > m_gexMax)
|
|
m_gexMax = m_gex[k];
|
|
if(m_gex[k] > maxPos)
|
|
{ maxPos = m_gex[k]; m_callWall = m_strikes[k]; }
|
|
if(m_gex[k] < maxNeg)
|
|
{ maxNeg = m_gex[k]; m_putWall = m_strikes[k]; }
|
|
}
|
|
|
|
//--- the zero-gamma flip: the spot at which total dealer gamma is zero
|
|
m_flip = SolveFlip();
|
|
PrintFormat("CGexProfile: expiry=%s strikes=%d netGEX=%.3g flip=%.2f callWall=%.2f putWall=%.2f",
|
|
TimeToString(m_expiry, TIME_DATE), nk, m_netGex, m_flip, m_callWall, m_putWall);
|
|
return(true);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Total signed dealer gamma if the underlying were trading at S. |
|
|
//| This is the same aggregation as Build, but with every contract's |
|
|
//| gamma re-evaluated at the hypothetical spot S (each keeps its |
|
|
//| own implied volatility). Sweeping S through this function traces |
|
|
//| the exposure curve whose zero crossing is the flip level. We |
|
|
//| return raw dealer gamma (not the spot^2-scaled dollar figure), |
|
|
//| because only its sign and zero crossing matter here. |
|
|
//+------------------------------------------------------------------+
|
|
double CGexProfile::DealerGammaAtSpot(const double S) const
|
|
{
|
|
datetime now = TimeCurrent();
|
|
if(now == 0)
|
|
now = TimeLocal();
|
|
|
|
double total = 0.0;
|
|
int nq = ArraySize(m_quotes);
|
|
for(int i = 0; i < nq; i++)
|
|
{
|
|
double T = (double)(m_quotes[i].expiry - now) / (365.0 * 24 * 3600);
|
|
if(T <= 0.0)
|
|
continue;
|
|
double g = BSGamma(S, m_quotes[i].strike, m_quotes[i].rate, 0.0, m_quotes[i].iv, T);
|
|
double contrib = g * m_quotes[i].open_interest * m_multiplier;
|
|
total += (m_quotes[i].right == OPT_CALL) ? contrib : -contrib;
|
|
}
|
|
return(total);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Find the zero-gamma flip by scanning dealer gamma across a price |
|
|
//| band around spot and interpolating the first sign change. The |
|
|
//| band spans the strikes we hold, widened a little so a flip just |
|
|
//| outside the quoted strikes is still caught. If dealer gamma |
|
|
//| never changes sign across the band there is no flip (a wholly |
|
|
//| long- or short-gamma book), and we return a negative sentinel. |
|
|
//+------------------------------------------------------------------+
|
|
double CGexProfile::SolveFlip(void) const
|
|
{
|
|
int nk = ArraySize(m_strikes);
|
|
if(nk < 2)
|
|
return(-1.0);
|
|
|
|
double lo = m_strikes[0];
|
|
double hi = m_strikes[nk - 1];
|
|
double pad = 0.15 * (hi - lo); // widen the band by 15% each way
|
|
lo -= pad;
|
|
hi += pad;
|
|
if(lo <= 0.0)
|
|
lo = 0.01 * m_strikes[0];
|
|
|
|
int steps = 400;
|
|
double dx = (hi - lo) / steps;
|
|
double prevS = lo;
|
|
double prevG = DealerGammaAtSpot(lo);
|
|
for(int i = 1; i <= steps; i++)
|
|
{
|
|
double s = lo + i * dx;
|
|
double g = DealerGammaAtSpot(s);
|
|
if((prevG <= 0.0 && g > 0.0) || (prevG >= 0.0 && g < 0.0))
|
|
{
|
|
//--- linear interpolation of the crossing between prevS and s
|
|
double denom = (g - prevG);
|
|
if(MathAbs(denom) < 1e-30)
|
|
return(0.5 * (prevS + s));
|
|
return(prevS - prevG * (s - prevS) / denom);
|
|
}
|
|
prevS = s;
|
|
prevG = g;
|
|
}
|
|
return(-1.0); // no sign change: no flip in this band
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Linear search for a strike in the array. Uses a small tolerance |
|
|
//| so float round-trips still match. |
|
|
//+------------------------------------------------------------------+
|
|
int CGexProfile::IndexOf(const double &arr[], const double v) const
|
|
{
|
|
int n = ArraySize(arr);
|
|
for(int i = 0; i < n; i++)
|
|
if(MathAbs(arr[i] - v) < 1e-6)
|
|
return(i);
|
|
return(-1);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| CSV provider. Reads a chain file from MQL5\Files with columns: |
|
|
//| right,strike,expiry,mid,spot,rate,oi |
|
|
//| where right is C/P and expiry is YYYY.MM.DD. Computes the |
|
|
//| implied volatility for each row via Black-Scholes inversion so |
|
|
//| the gamma aggregation downstream has a sigma to work with. |
|
|
//+------------------------------------------------------------------+
|
|
class CGexProviderCSV
|
|
{
|
|
public:
|
|
bool Load(const string filename, OptionQuote &out[]);
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Parse the CSV chain into a flat quote list, inverting each row's |
|
|
//| price to an implied volatility as it is read. |
|
|
//+------------------------------------------------------------------+
|
|
bool CGexProviderCSV::Load(const string filename, OptionQuote &out[])
|
|
{
|
|
int h = FileOpen(filename, FILE_READ | FILE_CSV | FILE_ANSI, ',');
|
|
if(h == INVALID_HANDLE)
|
|
{
|
|
PrintFormat("CGexProviderCSV: cannot open %s (err %d)", filename, GetLastError());
|
|
return(false);
|
|
}
|
|
ArrayResize(out, 0);
|
|
bool header = true;
|
|
while(!FileIsEnding(h))
|
|
{
|
|
string sRight = FileReadString(h);
|
|
if(FileIsLineEnding(h) && StringLen(sRight) == 0)
|
|
continue;
|
|
string sStrike = FileReadString(h);
|
|
string sExpiry = FileReadString(h);
|
|
string sMid = FileReadString(h);
|
|
string sSpot = FileReadString(h);
|
|
string sRate = FileReadString(h);
|
|
string sOi = FileReadString(h);
|
|
if(header)
|
|
{
|
|
header = false; // skip the column titles
|
|
continue;
|
|
}
|
|
if(StringLen(sStrike) == 0)
|
|
continue;
|
|
|
|
OptionQuote q;
|
|
string rr = sRight;
|
|
StringToUpper(rr);
|
|
q.right = (StringFind(rr, "P") >= 0) ? OPT_PUT : OPT_CALL;
|
|
q.strike = StringToDouble(sStrike);
|
|
q.expiry = StringToTime(sExpiry);
|
|
q.price = StringToDouble(sMid);
|
|
q.spot = StringToDouble(sSpot);
|
|
q.rate = StringToDouble(sRate);
|
|
q.open_interest = StringToDouble(sOi);
|
|
|
|
datetime now = TimeCurrent();
|
|
if(now == 0)
|
|
now = TimeLocal();
|
|
double T = (double)(q.expiry - now) / (365.0 * 24 * 3600);
|
|
q.iv = ImpliedVol(q.right, q.price, q.spot, q.strike, q.rate, 0.0, T);
|
|
|
|
int s = ArraySize(out);
|
|
ArrayResize(out, s + 1);
|
|
out[s] = q;
|
|
}
|
|
FileClose(h);
|
|
PrintFormat("CGexProviderCSV: loaded %d rows from %s", ArraySize(out), filename);
|
|
return(ArraySize(out) > 0);
|
|
}
|
|
|
|
#endif // GEX_GEXDATA_MQH
|
|
//+------------------------------------------------------------------+
|