640 lines
22 KiB
MQL5
640 lines
22 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| EconometricsA.mqh |
| |||
//| Copyright 2000-2026, MetaQuotes Ltd. |
| |||
//| www.mql5.com |
| |||
//+------------------------------------------------------------------+
| |||
#include <Math\Stat\T.mqh>
| |||
#include <Math\Stat\ChiSquare.mqh>
| |||
#include <Math\Stat\F.mqh>
| |||
#include <Math\Stat\Math.mqh>
| |||
#include <Graphics\Graphic.mqh>
| |||
//---
| |||
//+------------------------------------------------------------------+
| |||
//| Computation of parameters and residuals |
| |||
//| for regression on a constant |
| |||
//+------------------------------------------------------------------+
| |||
void regression0(double& y[], double& a, double& c, double& e[])
| |||
{
| |||
//--- Initialization and input data validation
| |||
a = c = 0.0;
| |||
ArrayResize(e, 0);
| |||
int ny = ArraySize(y);
| |||
if(ny < 1)
| |||
{
| |||
Print("no data for regression0()");
| |||
return;
| |||
}
| |||
ArrayResize(e, ny);
| |||
//--- Parameters computation
| |||
a = MathMean(y);
| |||
c = MathStandardDeviation(y);
| |||
//--- Residuals computation
| |||
for(int i = 0; i < ny; ++i)
| |||
e[i] = y[i] - a;
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Calculation of confidence interval for parameter A |
| |||
//| in regression on a constant |
| |||
//+------------------------------------------------------------------+
| |||
void Aconf0(double a, double c, int n, double conf_level)
| |||
{
| |||
//--- Initialization and input data validation
| |||
if(c <= 0.0)
| |||
{
| |||
Print("c must be positive in Aconf0()");
| |||
return;
| |||
}
| |||
if(n < 2)
| |||
{
| |||
Print("n must be greater 1 in Aconf0()");
| |||
return;
| |||
}
| |||
if(conf_level <= 0.0 || conf_level >= 1.0)
| |||
{
| |||
Print("conf_level must be between 0 and 1 in Aconf0()");
| |||
return;
| |||
}
| |||
int err = 0;
| |||
//--- t-statistic calculation
| |||
//--- double t = MathQuantileT((1.0 - conf_level) / 2.0, n - 1, err); // faulty library function
| |||
double t = MathQuantileT_TMP((1.0 - conf_level) / 2.0, n - 1, err); // custom implementation
| |||
if(err != 0)
| |||
{
| |||
Print("in MathQuantileT() error ", err);
| |||
return;
| |||
}
| |||
t *= c / MathSqrt(n);
| |||
//--- Print result
| |||
PrintFormat("A between %.4f and %.4f with confidence level %.3f", a + t, a - t, conf_level);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Test of hypothesis H₀: A = 0 vs H₁: A > 0 |
| |||
//| for regression on a constant |
| |||
//+------------------------------------------------------------------+
| |||
void Aeq0_test0(double a, double c, int n)
| |||
{
| |||
Print("test H0: A = 0 vs H1: A > 0 (for regession on constant) result:");
| |||
//--- Input data validation
| |||
if(c <= 0.0)
| |||
{
| |||
Print("c must be positive in Aeq0_test0()");
| |||
return;
| |||
}
| |||
if(n < 2)
| |||
{
| |||
Print("n must be greater 1 in Aeq0_test0()");
| |||
return;
| |||
}
| |||
//--- t-statistic calculation
| |||
double t = a * MathSqrt(n) / c;
| |||
int err = 0;
| |||
//--- p-value calculation
| |||
double p_value = MathCumulativeDistributionT(t, n - 1, false, false, err);
| |||
if(err != 0)
| |||
{
| |||
Print("in MathCumulativeDistributionT() error ", err);
| |||
return;
| |||
}
| |||
//--- Print result if success
| |||
PrintFormat("t = %.3f, p-value = %.3f", t, p_value);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Calculation of prediction interval for Y |
| |||
//| in regression on a constant |
| |||
//+------------------------------------------------------------------+
| |||
void prognose_interval0(double a, double c, int n, double conf_level)
| |||
{
| |||
//--- Input data validation
| |||
if(c <= 0.0)
| |||
{
| |||
Print("c must be positive in prognose_interval0()");
| |||
return;
| |||
}
| |||
if(n < 2)
| |||
{
| |||
Print("n must be greater 1 in prognose_interval0()");
| |||
return;
| |||
}
| |||
if(conf_level <= 0.0 || conf_level >= 1.0)
| |||
{
| |||
Print("conf_level must be between 0 and 1 in prognose_interval0()");
| |||
return;
| |||
}
| |||
int err = 0;
| |||
//--- t-statistic calculation
| |||
//--- double t = MathQuantileT((1.0 - conf_level) / 2.0, n - 1, err); // faulty library function
| |||
double t = MathQuantileT_TMP((1.0 - conf_level) / 2.0, n - 1, err); // custom implementation
| |||
if(err != 0)
| |||
{
| |||
Print("in MathQuantileT() error ", err);
| |||
return;
| |||
}
| |||
t *= c * MathSqrt(1.0 + 1.0 / n);
| |||
//--- Print result if success
| |||
PrintFormat("Y between %.4f and %.4f with confidence level %.3f", a + t, a - t, conf_level);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Computation of parameters and residuals for |
| |||
//| simple linear regression |
| |||
//+------------------------------------------------------------------+
| |||
void regression1(double& y[], double& x[], double& a, double& b, double& c, double& e[])
| |||
{
| |||
//--- Initialization and input data validation
| |||
a = b = c = 0.0;
| |||
ArrayResize(e, 0);
| |||
int ny = ArraySize(y);
| |||
if(ny < 3)
| |||
{
| |||
Print("no data for regression1()");
| |||
return;
| |||
}
| |||
if(ny != ArraySize(x))
| |||
{
| |||
Print("arrays y[] and x[] have different lengths in regression1()");
| |||
return;
| |||
}
| |||
//--- Check x[] is not constant
| |||
double Sx = MathStandardDeviation(x);
| |||
if(Sx <= DBL_MIN)
| |||
{
| |||
Print("x[]==const, use regression0()");
| |||
return;
| |||
}
| |||
//--- Parameters A and B estimation
| |||
if(!MathCorrelationPearson(y, x, b))
| |||
{
| |||
Print("MathCorrelationPearson() error in regression1()");
| |||
return;
| |||
}
| |||
ArrayResize(e, ny);
| |||
b *= MathStandardDeviation(y) / Sx;
| |||
a = MathMean(y) - b * MathMean(x);
| |||
//--- Residuals computation
| |||
for(int i = 0; i < ny; ++i)
| |||
e[i] = y[i] - a - b * x[i];
| |||
//--- Parameter C estimation
| |||
c = MathStandardDeviation(e) * MathSqrt(1.0 + 1.0 / (ny - 2.0));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Test of hypothesis H₀: B = 0 vs H₁: B ≠ 0 for |
| |||
//| simple linear regression |
| |||
//+------------------------------------------------------------------+
| |||
void Beq0_test1(double b, double c, double var_x, int n)
| |||
{
| |||
Print("test H0: B = 0 vs H1: B != 0 (for pair regession) result:");
| |||
//--- Input data validation
| |||
if(c <= 0.0)
| |||
{
| |||
Print("c must be positive in Beq0_test1()");
| |||
return;
| |||
}
| |||
if(var_x <= 0.0)
| |||
{
| |||
Print("var_x must be positive in Beq0_test1()");
| |||
return;
| |||
}
| |||
if(n < 3)
| |||
{
| |||
Print("n must be 3 or greater in Beq0_test1()");
| |||
return;
| |||
}
| |||
//--- t-statistic calculation
| |||
double t = MathAbs(b * MathSqrt(var_x * (n - 1)) / c);
| |||
int err = 0;
| |||
//--- p-value computation
| |||
double p_value = 2.0 * MathCumulativeDistributionT(t, n - 2, false, false, err);
| |||
if(err != 0)
| |||
{
| |||
Print("in MathCumulativeDistributionT() error ", err);
| |||
return;
| |||
}
| |||
//--- Print result if success
| |||
PrintFormat("t = %.3f, p-value = %.3f", t, p_value);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Calculation of prediction interval for Y in |
| |||
//| simple linear regression |
| |||
//+------------------------------------------------------------------+
| |||
void prognose_interval1(double x_new, double a, double b, double c, double var_x, double mean_x, int n, double conf_level)
| |||
{
| |||
//--- Input data validation
| |||
if(c <= 0.0)
| |||
{
| |||
Print("c must be positive in prognose_interval1()");
| |||
return;
| |||
}
| |||
if(n < 2)
| |||
{
| |||
Print("n must be greater 2 in prognose_interval1()");
| |||
return;
| |||
}
| |||
if(conf_level <= 0.0 || conf_level >= 1.0)
| |||
{
| |||
Print("conf_level must be between 0 and 1 in prognose_interval1()");
| |||
return;
| |||
}
| |||
int err = 0;
| |||
//--- t-statistic calculation
| |||
//--- double t = MathQuantileT((1.0 - conf_level) / 2.0, n - 1, err); // faulty library function
| |||
double t = MathQuantileT_TMP((1.0 - conf_level) / 2.0, n - 1, err); // custom implementation
| |||
if(err != 0)
| |||
{
| |||
Print("in MathQuantileT() error ", err);
| |||
return;
| |||
}
| |||
t *= c * MathSqrt(1.0 + 1.0 / n + MathPow((x_new - mean_x), 2) * (n - 1) / var_x);
| |||
//--- Print result if success
| |||
PrintFormat("Y between %.4f and %.4f with confidence level %.3f", a + b * x_new + t, a + b * x_new - t, conf_level);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Residuals plot vs. price bar index |
| |||
//+------------------------------------------------------------------+
| |||
void t_residuals_plot(double& residuals[])
| |||
{
| |||
int n_residuals = ArraySize(residuals);
| |||
//--- Input data validation
| |||
if(n_residuals < 1)
| |||
{
| |||
Print("no data for t_residuals_plot()");
| |||
return;
| |||
}
| |||
//--- Array T[] as x on plot
| |||
double T[];
| |||
if(!MathSequenceByCount(1, n_residuals, n_residuals, T))
| |||
{
| |||
Print("MathSequenceByCount() error");
| |||
return;
| |||
}
| |||
//--- Plot construction
| |||
ChartSetInteger(0, CHART_SHOW, false);
| |||
CGraphic graphic;
| |||
graphic.Create(0, "G", 0, 0, 0, 750, 300);
| |||
graphic.CurveAdd(T, residuals, CURVE_LINES, "Residuals");
| |||
graphic.CurvePlotAll();
| |||
graphic.Update();
| |||
MessageBox("Press OK to close graph", "Close graph");
| |||
ChartSetInteger(0, CHART_SHOW, true);
| |||
graphic.Destroy();
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| EPDF of residuals vs. normal density with residual SD |
| |||
//| nofx - number of points on plot |
| |||
//+------------------------------------------------------------------+
| |||
void epdf_vs_normalpdf(double& residuals[], int nofx = 30)
| |||
{
| |||
int n_residuals = ArraySize(residuals);
| |||
//--- Input data validation
| |||
if(n_residuals < 1)
| |||
{
| |||
Print("no data for epdf_vs_normalpdf()");
| |||
return;
| |||
}
| |||
//--- Array for x
| |||
double x[];
| |||
if(!MathSequenceByCount(MathMin(residuals), MathMax(residuals), nofx, x))
| |||
{
| |||
Print("sequence error");
| |||
return;
| |||
}
| |||
//--- Array for EPDF
| |||
double epdf[];
| |||
if(!MathProbabilityDensityEmpirical(residuals, nofx, x, epdf))
| |||
{
| |||
Print("MathProbabilityDensityEmpirical() error");
| |||
return;
| |||
}
| |||
//--- Array for theoretical PDF
| |||
double normal_pdf[];
| |||
if(!MathProbabilityDensityNormal(x, 0.0, MathStandardDeviation(residuals), normal_pdf))
| |||
{
| |||
Print("MathProbabilityDensityNormal() error");
| |||
return;
| |||
}
| |||
//--- Plot construction
| |||
ChartSetInteger(0, CHART_SHOW, false);
| |||
CGraphic graphic;
| |||
graphic.Create(0, "G", 0, 0, 0, 750, 400);
| |||
graphic.CurveAdd(x, epdf, CURVE_LINES, "Residuals");
| |||
graphic.CurveAdd(x, normal_pdf, CURVE_LINES, "Normal");
| |||
graphic.CurvePlotAll();
| |||
graphic.Update();
| |||
MessageBox("Press OK to close graph", "Close graph");
| |||
ChartSetInteger(0, CHART_SHOW, true);
| |||
graphic.Destroy();
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| QQ-plot of residuals vs. normal distribution with residual SD |
| |||
//+------------------------------------------------------------------+
| |||
void qq_plot(double& residuals[])
| |||
{
| |||
int n_residuals = ArraySize(residuals);
| |||
//--- Input data validation
| |||
if(n_residuals < 1)
| |||
{
| |||
Print("no data for qq_plot()");
| |||
return;
| |||
}
| |||
//--- Copy input array and sort this copy
| |||
double residuals_copy[];
| |||
ArrayResize(residuals_copy, n_residuals);
| |||
ArrayCopy(residuals_copy, residuals);
| |||
ArraySort(residuals_copy);
| |||
//--- Probability sequence
| |||
double pseq[];
| |||
if(!MathSequenceByCount(0.5 / n_residuals, 1.0 - 0.5 / n_residuals, n_residuals, pseq))
| |||
{
| |||
Print("MathSequenceByCount() error");
| |||
return;
| |||
}
| |||
//--- Theoretical quantiles
| |||
double normal_qs[];
| |||
if(!MathQuantileNormal(pseq, 0.0, MathStandardDeviation(residuals_copy), normal_qs))
| |||
{
| |||
Print("MathQuantileNormal() error");
| |||
return;
| |||
}
| |||
//--- Plot construction
| |||
ChartSetInteger(0, CHART_SHOW, false);
| |||
CGraphic graphic;
| |||
graphic.Create(0, "G", 0, 0, 0, 750, 550);
| |||
graphic.CurveAdd(normal_qs, residuals_copy, CURVE_LINES, "QQ-plot");
| |||
graphic.CurveAdd(residuals_copy, residuals_copy, CURVE_LINES, "Y=X");
| |||
graphic.CurvePlotAll();
| |||
graphic.Update();
| |||
MessageBox("Press OK to close graph", "Close graph");
| |||
ChartSetInteger(0, CHART_SHOW, true);
| |||
graphic.Destroy();
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Correlogram of residuals |
| |||
//+------------------------------------------------------------------+
| |||
void correlogram(double& residuals[])
| |||
{
| |||
int n_residuals = ArraySize(residuals);
| |||
//--- Input data validation
| |||
if(n_residuals < 2)
| |||
{
| |||
Print("no data for correlogram()");
| |||
return;
| |||
}
| |||
//--- Number of lags
| |||
int ncg = (int)MathSqrt(n_residuals);
| |||
//--- Significance levels
| |||
double bound = 1.96 / MathSqrt(n_residuals);
| |||
double cg0 = 0.0, xb[2] = {0, ncg + 1}, upb[2] = {bound, bound}, lowb[2] = {-bound, -bound};
| |||
//--- Lags array creation
| |||
double lags[];
| |||
if(!MathSequenceByCount(1, ncg, ncg, lags))
| |||
{
| |||
Print("MathSequenceByCount() error");
| |||
return;
| |||
}
| |||
//--- ACF array calculation
| |||
double cg[];
| |||
ArrayResize(cg, ncg);
| |||
ArrayFill(cg, 0, ncg, 0.0);
| |||
for(int i = 0; i < n_residuals; ++i)
| |||
cg0 += residuals[i] * residuals[i];
| |||
for(int k = 1; k <= ncg; ++k)
| |||
{
| |||
for(int i = 0; i < n_residuals - k; ++i)
| |||
cg[k - 1] += residuals[i] * residuals[i + k];
| |||
cg[k - 1] /= cg0;
| |||
}
| |||
//--- Plot construction
| |||
ChartSetInteger(0, CHART_SHOW, false);
| |||
CGraphic graphic;
| |||
graphic.Create(0, "G", 0, 0, 0, 750, 300);
| |||
graphic.CurveAdd(lags, cg, CURVE_HISTOGRAM, "Correlogram");
| |||
graphic.CurveAdd(xb, upb, CURVE_LINES, "Upper bound");
| |||
graphic.CurveAdd(xb, lowb, CURVE_LINES, "Lower bound");
| |||
graphic.CurvePlotAll();
| |||
graphic.Update();
| |||
MessageBox("Press OK to close graph", "Close graph");
| |||
ChartSetInteger(0, CHART_SHOW, true);
| |||
graphic.Destroy();
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Scatter plot of (x, y) points with line y = a * x + b |
| |||
//+------------------------------------------------------------------+
| |||
void scatter_plot(double& x[], double& y[], bool add_line = false, double a = 0.0, double b = 0.0)
| |||
{
| |||
int ny = ArraySize(y);
| |||
//--- Input data validation
| |||
if(ny < 1)
| |||
{
| |||
Print("no data for regression1()");
| |||
return;
| |||
}
| |||
if(ny != ArraySize(x))
| |||
{
| |||
Print("arrays y[] and x[] have different lengths in scatter_plot()");
| |||
return;
| |||
}
| |||
//--- Regression line points calculation
| |||
double xreg[2] = {MathMin(x), MathMax(x)};
| |||
double yreg[2] = {a + b*xreg[0], a + b*xreg[1]};
| |||
//--- Plot construction
| |||
ChartSetInteger(0, CHART_SHOW, false);
| |||
CGraphic graphic;
| |||
graphic.Create(0, "G", 0, 0, 0, 750, 550);
| |||
graphic.CurveAdd(x, y, CURVE_POINTS, "scatter plot");
| |||
if(add_line)
| |||
graphic.CurveAdd(xreg, yreg, CURVE_LINES, "y = a * x + b");
| |||
graphic.CurvePlotAll();
| |||
graphic.Update();
| |||
MessageBox("Press OK to close graph", "Close graph");
| |||
ChartSetInteger(0, CHART_SHOW, true);
| |||
graphic.Destroy();
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Ljung-Box test for autocorrelation in residuals |
| |||
//| m - lags number, pq - sum of p and q in ARMA(p,q) model |
| |||
//+------------------------------------------------------------------+
| |||
void Ljung_Box_test(double& residuals[], int m = 10, int pq = 0)
| |||
{
| |||
Print("Ljung-Box test result:");
| |||
//--- Input data validation
| |||
if(pq < 0)
| |||
{
| |||
Print("pq must be nonnegative");
| |||
return;
| |||
}
| |||
if(m <= pq)
| |||
{
| |||
Print("m must be greater pq");
| |||
return;
| |||
}
| |||
int n_residuals = ArraySize(residuals);
| |||
if(n_residuals < m + 1)
| |||
{
| |||
Print("not enough data");
| |||
return;
| |||
}
| |||
//--- Initialization
| |||
double Q = 0.0, cov0 = 0.0, cov, ro;
| |||
//--- Test statistic calculation
| |||
for(int i = 0; i < n_residuals; ++i)
| |||
cov0 += residuals[i] * residuals[i];
| |||
for(int k = 1; k <= m; ++k)
| |||
{
| |||
cov = 0.0;
| |||
for(int i = 0; i < n_residuals - k; ++i)
| |||
cov += residuals[i] * residuals[i + k];
| |||
ro = cov / cov0;
| |||
Q += ro * ro / (n_residuals - k);
| |||
}
| |||
Q *= n_residuals * (n_residuals + 2);
| |||
//--- p-value computation
| |||
int err = 0;
| |||
double p_value = MathCumulativeDistributionChiSquare(Q, m - pq, false, false, err);
| |||
if(err != 0)
| |||
{
| |||
Print("MathCumulativeDistributionChiSquare() error: ", err);
| |||
return;
| |||
}
| |||
//--- Print result
| |||
PrintFormat("Q = %.3f, p-value = %.3f", Q, p_value);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Jarque-Bera test for normality of distribution |
| |||
//+------------------------------------------------------------------+
| |||
void Jarque_Bera_test(double& residuals[])
| |||
{
| |||
Print("Jarque-Bera test result:");
| |||
//--- Input data validation
| |||
int n_residuals = ArraySize(residuals);
| |||
if(n_residuals < 1)
| |||
{
| |||
Print("not enough data");
| |||
return;
| |||
}
| |||
//--- Skewness calculation
| |||
double S = MathSkewness(residuals);
| |||
//--- Kurtosis calculation
| |||
double K = MathKurtosis(residuals);
| |||
//--- Test statistic calculation
| |||
double JB = n_residuals * (S * S + K * K / 4.0) / 6.0;
| |||
//--- p-value computation
| |||
double p_value = MathExp(-JB / 2.0);
| |||
//--- Print result
| |||
PrintFormat("JB = %.3f, p-value = %.3f", JB, p_value);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Pettitt test for structural break (abrupt change in mean) |
| |||
//+------------------------------------------------------------------+
| |||
void Pettitt_test(double& residuals[])
| |||
{
| |||
Print("Pettitt test result:");
| |||
//--- Input data validation
| |||
int n_residuals = ArraySize(residuals);
| |||
if(n_residuals < 2)
| |||
{
| |||
Print("not enough data");
| |||
return;
| |||
}
| |||
//--- Initialization
| |||
double K = 0.0, U, W = 0.0;
| |||
int t_change = 0;
| |||
//--- Sample ranking computation
| |||
double rank[];
| |||
MathRank(residuals, rank);
| |||
//--- Test statistic calculation
| |||
for(int t = 1; t < n_residuals; ++t)
| |||
{
| |||
W += rank[t - 1];
| |||
U = MathAbs(2.0 * W - t * (n_residuals + 1.0));
| |||
if(U > K)
| |||
{
| |||
K = U;
| |||
t_change = t;
| |||
}
| |||
}
| |||
//--- p-value computation
| |||
double p_value = MathMin(2.0 * MathExp(-6.0 * K * K / (n_residuals * n_residuals * (n_residuals + 1.0))), 1.0);
| |||
//--- Print result
| |||
PrintFormat("K = %.3f, p-value = %.3f, change-point = %d", K, p_value, t_change);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Student's t-distribution quantile |
| |||
//| (custom implementation replacing faulty library function) |
| |||
//| JUST A TEMPORARY REPLACEMENT! (Based on library variant) |
| |||
//+------------------------------------------------------------------+
| |||
double MathQuantileT_TMP(const double prob, const double nu, int &error_code)
| |||
{
| |||
if(!MathIsValidNumber(prob) || !MathIsValidNumber(nu))
| |||
{
| |||
error_code = ERR_ARGUMENTS_NAN;
| |||
return QNaN;
| |||
}
| |||
if(nu <= 0.0 || nu != MathRound(nu))
| |||
{
| |||
error_code = ERR_ARGUMENTS_INVALID;
| |||
return QNaN;
| |||
}
| |||
if(prob < 0.0 || prob > 1.0)
| |||
{
| |||
error_code = ERR_ARGUMENTS_INVALID;
| |||
return QNaN;
| |||
}
| |||
error_code = ERR_RESULT_INFINITE;
| |||
if(prob == 0.0)
| |||
return QNEGINF;
| |||
if(prob == 1.0)
| |||
return QPOSINF;
| |||
error_code = ERR_OK;
| |||
if(prob == 0.5)
| |||
return 0.0;
| |||
if(nu == 1.0)
| |||
return MathTan(M_PI * (prob - 0.5));
| |||
int err_code = 0;
| |||
double x_low = -1.0;
| |||
double x_high = 1.0;
| |||
while(MathCumulativeDistributionT(x_low, nu, err_code) > prob && x_low > -1e6)
| |||
x_low *= 2.0;
| |||
while(MathCumulativeDistributionT(x_high, nu, err_code) < prob && x_high < 1e6)
| |||
x_high *= 2.0;
| |||
double x = 0.0;
| |||
int max_iterations = 100;
| |||
double precision = 1e-12; // Высокая точность
| |||
for(int i = 0; i < max_iterations; i++)
| |||
{
| |||
x = (x_low + x_high) / 2.0;
| |||
double cdf = MathCumulativeDistributionT(x, nu, err_code);
| |||
if(MathAbs(x_high - x_low) < precision)
| |||
break;
| |||
if(cdf < prob)
| |||
x_low = x;
| |||
else
| |||
x_high = x;
| |||
if(i == max_iterations - 1)
| |||
error_code = ERR_NON_CONVERGENCE;
| |||
}
| |||
return x;
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Helper function to export array to text file |
| |||
//| (for data analysis in other programs) |
| |||
//+------------------------------------------------------------------+
| |||
void array2csv(double& a[], string fldr, string fnm)
| |||
{
| |||
//--- Initialization and input data validation
| |||
int ftxt = FileOpen(fldr + "\\" + fnm, FILE_WRITE | FILE_TXT | FILE_ANSI | FILE_COMMON);
| |||
if(ftxt == INVALID_HANDLE)
| |||
{
| |||
Print("FileOpen() error");
| |||
return;
| |||
}
| |||
int na = ArraySize(a);
| |||
if(na < 1)
| |||
{
| |||
Print("No data for array2csv()");
| |||
return;
| |||
}
| |||
//--- Writing array to file
| |||
FileWriteString(ftxt, DoubleToString(a[0]));
| |||
for(int i = 1; i < na; ++i)
| |||
FileWriteString(ftxt, "\n" + DoubleToString(a[i]));
| |||
FileClose(ftxt);
| |||
}
| |||
//+------------------------------------------------------------------+
|