Warrior_EA/Mind/EdgeStats.mqh

//+------------------------------------------------------------------+
//|                                                    EdgeStats.mqh |
//|                                                     AnimateDread |
//|                                                                  |
//| HOW SURE ARE WE, in Lopez de Prado's terms (Advances in Financial |
//| Machine Learning, ch. 8 and 14). Stateless math, no trading.      |
//|                                                                   |
//|   Phi / PhiInv     the normal CDF and its inverse                 |
//|   PSR(SR*)         Probabilistic Sharpe Ratio: the probability    |
//|                    that the true Sharpe exceeds SR*, given the    |
//|                    sample's length, skew and kurtosis. A Sharpe   |
//|                    of 1 on 40 trades with fat tails is far less   |
//|                    certain than the number suggests.              |
//|   DSR(N)           Deflated Sharpe Ratio: PSR against the Sharpe   |
//|                    the BEST of N independent trials would show by |
//|                    luck. N is how many configurations were tried   |
//|                    to arrive at this one - honestly, including the |
//|                    ones that were discarded.                       |
//|                                                                    |
//| The Sharpe here is PER TRADE (mean R / sd R), not annualised: PSR  |
//| is defined on the sampling frequency of the returns it is given.   |
//| The trial-Sharpe variance uses its large-sample form 1/(T-1) - the |
//| caller has one run, not N, to estimate it from. That makes DSR an  |
//| approximation; it is reported as one.                              |
//+------------------------------------------------------------------+
#ifndef WARRIOR_EDGESTATS_MQH
#define WARRIOR_EDGESTATS_MQH

class CEdgeStats
  {
public:
   //--- Abramowitz & Stegun 7.1.26, |error| < 1.5e-7.
   static double     Phi(const double x)
     {
      const double t = 1.0 / (1.0 + 0.2316419 * MathAbs(x));
      const double d = 0.3989422804 * MathExp(-0.5 * x * x);
      const 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;
     }
   //--- Acklam's rational approximation, relative error < 1.2e-9.
   static double     PhiInv(const double p)
     {
      if(p <= 0.0 || p >= 1.0)
         return 0.0;
      static const double a[6] = {-3.969683028665376e+01, 2.209460984245205e+02,
                                  -2.759285104469687e+02, 1.383577518672690e+02,
                                  -3.066479806614716e+01, 2.506628277459239e+00};
      static const double b[5] = {-5.447609879822406e+01, 1.615858368580409e+02,
                                  -1.556989798598866e+02, 6.680131188771972e+01,
                                  -1.328068155288572e+01};
      static const double c[6] = {-7.784894002430293e-03, -3.223964580411365e-01,
                                  -2.400758277161838e+00, -2.549732539343734e+00,
                                  4.374664141464968e+00, 2.938163982698783e+00};
      static const double d[4] = {7.784695709041462e-03, 3.224671290700398e-01,
                                  2.445134137142996e+00, 3.754408661907416e+00};
      const double lo = 0.02425;
      if(p < lo)
        {
         const double q = MathSqrt(-2.0 * MathLog(p));
         return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) /
                ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1.0);
        }
      if(p > 1.0 - lo)
        {
         const double q = MathSqrt(-2.0 * MathLog(1.0 - p));
         return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) /
                 ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1.0);
        }
      const double q = p - 0.5, r = q * q;
      return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q /
             (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1.0);
     }
   //--- Moments of a sample. Kurtosis is the plain (non-excess) fourth standardised moment.
   static bool       Moments(const double &x[], double &mean, double &sd, double &skew, double &kurt)
     {
      const int n = ArraySize(x);
      if(n < 4)
         return false;
      double s = 0.0;
      for(int i = 0; i < n; i++)
         s += x[i];
      mean = s / n;
      double m2 = 0.0, m3 = 0.0, m4 = 0.0;
      for(int i = 0; i < n; i++)
        {
         const double d = x[i] - mean;
         m2 += d * d;
         m3 += d * d * d;
         m4 += d * d * d * d;
        }
      m2 /= n; m3 /= n; m4 /= n;
      if(m2 <= 0.0)
         return false;
      sd = MathSqrt(m2 * n / (n - 1));
      skew = m3 / MathPow(m2, 1.5);
      kurt = m4 / (m2 * m2);
      return true;
     }
   //--- PSR(SR*) for per-trade returns. -1 when the sample is too small to say anything.
   static double     PSR(const double &x[], const double srStar = 0.0)
     {
      double mean, sd, skew, kurt;
      if(!Moments(x, mean, sd, skew, kurt) || sd <= 0.0)
         return -1.0;
      const int n = ArraySize(x);
      const double sr = mean / sd;
      const double den = 1.0 - skew * sr + (kurt - 1.0) / 4.0 * sr * sr;
      if(den <= 0.0)
         return -1.0;
      return Phi((sr - srStar) * MathSqrt(n - 1.0) / MathSqrt(den));
     }
   //--- The Sharpe the best of `trials` unskilled strategies would show (AFML 14.1, eq. 14.1).
   static double     ExpectedMaxSharpe(const int trials, const int n)
     {
      if(trials < 2 || n < 3)
         return 0.0;
      const double g = 0.5772156649;
      const double sigma = 1.0 / MathSqrt(n - 1.0);
      return sigma * ((1.0 - g) * PhiInv(1.0 - 1.0 / trials) +
                      g * PhiInv(1.0 - 1.0 / (trials * M_E)));
     }
   static double     DSR(const double &x[], const int trials)
     {
      return PSR(x, ExpectedMaxSharpe(trials, ArraySize(x)));
     }
  };
#endif // WARRIOR_EDGESTATS_MQH