gavindiaz/profitable-expert-advisor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3f75a0884897707ef673c0ee28eb83f2b286e91e
profitable-expert-advisor/lab/EAs/Derivative.mq5
T

1583 lines
31 KiB
Plaintext
Raw Normal View History

Update
2026-05-27 14:59:00 +02:00
//+------------------------------------------------------------------+
//| Derivative.mq5 |
//| EA: finite-difference d1–d3 of price + optional demo signals |
//| (Former indicator — attach as Expert Advisor on chart.) |
//+------------------------------------------------------------------+
#property copyright "Lab"
#property link ""
#property version "3.00"
#property strict
#include <Trade/Trade.mqh>
#include <Canvas/Canvas.mqh>
#property description "DERIVATIVE_CALC EA v3 — derivatives + optional trades; canvas strip or legacy DerivativePlots."
#property description "Canvas mode draws d1/d2/d3 at bottom without indicators; legacy mode optional."
enum ENUM_DERIVATIVE_VIEW
{
DERIVATIVE_ALL = 0,
DERIVATIVE_LEVEL_1 = 1,
DERIVATIVE_LEVEL_2 = 2,
DERIVATIVE_LEVEL_3 = 3
};
input group "=== Instrument ==="
input string InpSymbol = ""; // blank = chart symbol
input group "=== Series ==="
input ENUM_TIMEFRAMES InpSignalTF = PERIOD_CURRENT; // PERIOD_CURRENT = chart TF
input ENUM_APPLIED_PRICE InpAppliedPrice = PRICE_CLOSE;
input group "=== Layout (reporting focus) ==="
input ENUM_DERIVATIVE_VIEW InpWhichDerivative = DERIVATIVE_ALL; // Which values drive Comment / optional trade filter
input group "=== Calculus discretization ==="
input int InpDiffStep = 1;
input bool InpNormalizePoints = true;
input group "=== Smoothing ==="
input int InpSmoothPeriod = 0;
input group "=== On-chart guide (labels on main window) ==="
input bool InpShowHelpPanel = true;
input color InpHelpTitleColor = clrWhite;
input color InpHelpBodyColor = clrSilver;
input group "=== Display ==="
input bool InpShowComment = true; // Status line + d1/d2/d3 on chart
input int InpCommentThrottleMs = 200; // Min real-time ms between Comment() calls (0=off). Visual tester floods redraws without this.
input bool InpDebugTrace = false; // Experts/Journal: derivatives + attach diagnostics
input group "=== Canvas strip (EA draws d1/d2/d3 — no indicator .ex5) ==="
input bool InpUseCanvasPlots = true; // Three stacked strips at bottom (bitmap on main window)
input int InpCanvasPlotBars = 320; // Bars across width (series 0 = current)
input int InpCanvasPanelHeight = 210; // Total pixel height for three strips
input int InpCanvasBottomMargin = 28; // From chart bottom (CORNER_LEFT_LOWER)
input int InpCanvasSideMargin = 4; // Left/right inset
input int InpCanvasRedrawMs = 350; // Min ms between canvas rebuilds
input color InpCanvasBgColor = clrBlack;
input color InpCanvasGridColor = clrDimGray;
input group "=== Legacy: DerivativePlots indicator (optional) ==="
input bool InpAutoAttachDerivativePlots = false; // Requires DerivativePlots.ex5 in Indicators
input bool InpAttachPlotsInTester = false; // Non-visual tester: set true if .ex5 present
input string InpPlotsIndicatorPath = "DerivativePlots"; // .ex5 basename in Indicators folder
input bool InpPlotsSeparateWindows = false; // Three iCustom instances + stacked subwindows
input bool InpPlotsUnifyYScale = true; // DerivativePlots InpUnifyPlotYScale
input group "=== Optional demo trading (off by default) ==="
input bool InpTradeEnabled = false;
input double InpLots = 0.01;
input ulong InpMagic = 931001;
input int InpSlippagePoints = 30;
input int InpAtrPeriod = 14;
input double InpSlAtrMult = 2.0;
input double InpTpAtrMult = 3.0;
CTrade g_trade;
datetime g_lastBarTime = 0;
string g_chartSymbol = "";
bool g_pendingDerivativePlotsAttach = false;
bool g_derivativePlotsFailedToLoad = false;
bool g_derivPlotsAttachDone = false;
uint g_lastCommentWallMs = 0;
CCanvas g_deriv_canvas;
bool g_deriv_canvas_created = false;
uint g_lastCanvasRedrawMs = 0;
const string HELPER_FAMILY = "DerivRead";
const string DERIV_CANVAS_OBJ = "DerivEA_CanvasStrip_v3";
void CommentThrottled(const string text)
{
if(InpCommentThrottleMs <= 0)
{
Comment(text);
return;
}
const uint now = GetTickCount();
if(g_lastCommentWallMs != 0 && (now - g_lastCommentWallMs) < (uint)InpCommentThrottleMs)
return;
g_lastCommentWallMs = now;
Comment(text);
}
string DerivativePlotsMissingHint()
{
if(!g_derivativePlotsFailedToLoad || !InpAutoAttachDerivativePlots)
return "";
const string want = TerminalInfoString(TERMINAL_DATA_PATH) + "\\MQL5\\Indicators\\" + InpPlotsIndicatorPath + ".ex5";
return "\n--- DerivativePlots NOT loaded ---\nPlace compiled file:\n" + want +
"\n(Navigator: Indicators -> right-click -> Open folder -> paste .mq5, Compile.)";
}
string HelpPrefix()
{
return HELPER_FAMILY + "_EA_L" + IntegerToString((int)InpWhichDerivative) + "_";
}
void DeleteOurHelpObjects()
{
const string px = HelpPrefix();
ObjectDelete(0, px + "title");
ObjectDelete(0, px + "body");
ObjectDelete(0, px + "interp");
}
bool LabelCreateMain(const string name, const int corner, const int xd, const int yd,
const string text, const color clr, const int fontSize, const int anchor)
{
if(!ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0))
return false;
ObjectSetInteger(0, name, OBJPROP_CORNER, corner);
ObjectSetInteger(0, name, OBJPROP_ANCHOR, anchor);
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, xd);
ObjectSetInteger(0, name, OBJPROP_YDISTANCE, yd);
ObjectSetString(0, name, OBJPROP_TEXT, text);
ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, fontSize);
ObjectSetString(0, name, OBJPROP_FONT, "Consolas");
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
return true;
}
void TryBuildHelpPanel()
{
if(!InpShowHelpPanel)
{
DeleteOurHelpObjects();
return;
}
const string px = HelpPrefix();
ObjectDelete(0, px + "title");
ObjectDelete(0, px + "body");
ObjectDelete(0, px + "interp");
const int x0 = 8;
string title = "DERIVATIVE_CALC EA — readout\n";
string body = "";
string interp = "";
if(InpWhichDerivative == DERIVATIVE_ALL)
{
body =
"d1 = slope of price / step h (velocity)\n"
"d2 = change of d1 (acceleration)\n"
"d3 = change of d2 (jerk)\n"
"See Experts log + Comment line for numbers.";
interp = "Optional demo trades use Which derivative + sign rules (inputs).";
}
else if(InpWhichDerivative == DERIVATIVE_LEVEL_1)
{
title = "EA focus: d1 only\n";
body = "d1 > 0 : rising over h bars; < 0 falling; cross 0 : flip.";
interp = "Demo buy bias if d1>0 & d2>0 when trade enabled.";
}
else if(InpWhichDerivative == DERIVATIVE_LEVEL_2)
{
title = "EA focus: d2 only\n";
body = "d2 : momentum building (+) or fading (-) vs d1.";
interp = "Use with price context.";
}
else
{
title = "EA focus: d3 only\n";
body = "d3 : noisy; regime / climax hints.";
interp = "Large |d3| → acceleration changing fast.";
}
if(!LabelCreateMain(px + "title", CORNER_LEFT_UPPER, x0, 20, title, InpHelpTitleColor, 10, ANCHOR_LEFT_UPPER))
return;
if(!LabelCreateMain(px + "body", CORNER_LEFT_UPPER, x0, 42, body, InpHelpBodyColor, 8, ANCHOR_LEFT_UPPER))
{
ObjectDelete(0, px + "title");
return;
}
if(!LabelCreateMain(px + "interp", CORNER_LEFT_LOWER, x0, 8, interp, InpHelpBodyColor, 8, ANCHOR_LEFT_LOWER))
{
ObjectDelete(0, px + "title");
ObjectDelete(0, px + "body");
return;
}
}
double AppliedFromRates(const MqlRates &r)
{
switch(InpAppliedPrice)
{
case PRICE_OPEN: return r.open;
case PRICE_HIGH: return r.high;
case PRICE_LOW: return r.low;
case PRICE_CLOSE: return r.close;
case PRICE_MEDIAN: return (r.high + r.low) * 0.5;
case PRICE_TYPICAL: return (r.high + r.low + r.close) / 3.0;
case PRICE_WEIGHTED:return (r.high + r.low + r.close + r.close) / 4.0;
default: return r.close;
}
}
void SmoothPriceArray(const int total, const double &src[], double &dst[])
{
ArrayResize(dst, total);
const int p = InpSmoothPeriod;
if(p <= 1)
{
ArrayCopy(dst, src);
return;
}
const double alpha = 2.0 / (p + 1.0);
const int oldest = total - 1;
double ema = src[oldest];
dst[oldest] = ema;
for(int i = oldest - 1; i >= 0; i--)
{
ema = alpha * src[i] + (1.0 - alpha) * ema;
dst[i] = ema;
}
}
double SrcAt(const int i, const bool useSmooth, const double &smooth[], const double &raw[])
{
return useSmooth ? smooth[i] : raw[i];
}
bool ComputeDerivatives(const string sym, const ENUM_TIMEFRAMES tf,
double &out_d1, double &out_d2, double &out_d3)
{
out_d1 = out_d2 = out_d3 = 0.0;
const int h = MathMax(InpDiffStep, 1);
const int needBars = 50 + h * 6;
MqlRates rates[];
ArraySetAsSeries(rates, true);
const int n = CopyRates(sym, tf, 0, needBars, rates);
if(n < h * 3 + 5)
return false;
double raw[];
ArrayResize(raw, n);
ArraySetAsSeries(raw, true);
for(int i = 0; i < n; i++)
raw[i] = AppliedFromRates(rates[i]);
double smoothed[];
SmoothPriceArray(n, raw, smoothed);
const bool useSmooth = (InpSmoothPeriod > 1);
const double scale = InpNormalizePoints ? SymbolInfoDouble(sym, SYMBOL_POINT) : 1.0;
if(scale <= 0.0)
return false;
const int i = 1;
if(i + h >= n)
return false;
const double d1_i = (SrcAt(i, useSmooth, smoothed, raw) - SrcAt(i + h, useSmooth, smoothed, raw)) / ((double)h * scale);
if(i + 2 * h >= n)
{
out_d1 = d1_i;
return true;
}
const double d1_ip = (SrcAt(i + h, useSmooth, smoothed, raw) - SrcAt(i + 2 * h, useSmooth, smoothed, raw)) / ((double)h * scale);
const double d2_i = (d1_i - d1_ip) / ((double)h * scale);
if(i + 3 * h >= n)
{
out_d1 = d1_i;
out_d2 = d2_i;
return true;
}
const double d1_ip2 = (SrcAt(i + 2 * h, useSmooth, smoothed, raw) - SrcAt(i + 3 * h, useSmooth, smoothed, raw)) / ((double)h * scale);
const double d2_ip = (d1_ip - d1_ip2) / ((double)h * scale);
const double d3_i = (d2_i - d2_ip) / ((double)h * scale);
out_d1 = d1_i;
out_d2 = d2_i;
out_d3 = d3_i;
return true;
}
double CanvasSeriesAt(const int row, const int si,
const double &d1[], const double &d2[], const double &d3[])
{
if(row == 0)
return d1[si];
if(row == 1)
return d2[si];
return d3[si];
}
bool ComputeDerivativeSeries(const string sym, const ENUM_TIMEFRAMES tf,
const int plotBars,
double &d1[], double &d2[], double &d3[])
{
const int h = MathMax(InpDiffStep, 1);
const int need = plotBars + h * 4 + 10;
MqlRates rates[];
ArraySetAsSeries(rates, true);
const int n = CopyRates(sym, tf, 0, need, rates);
if(n < h * 3 + 5)
return false;
double raw[];
ArrayResize(raw, n);
ArraySetAsSeries(raw, true);
for(int i = 0; i < n; i++)
raw[i] = AppliedFromRates(rates[i]);
double smoothed[];
SmoothPriceArray(n, raw, smoothed);
const bool useSmooth = (InpSmoothPeriod > 1);
const double scale = InpNormalizePoints ? SymbolInfoDouble(sym, SYMBOL_POINT) : 1.0;
if(scale <= 0.0)
return false;
ArrayResize(d1, plotBars);
ArrayResize(d2, plotBars);
ArrayResize(d3, plotBars);
ArrayInitialize(d1, EMPTY_VALUE);
ArrayInitialize(d2, EMPTY_VALUE);
ArrayInitialize(d3, EMPTY_VALUE);
const int d1Count = MathMin(plotBars, n - h);
for(int si = 0; si < d1Count; si++)
d1[si] = (SrcAt(si, useSmooth, smoothed, raw) - SrcAt(si + h, useSmooth, smoothed, raw)) / ((double)h * scale);
for(int si = 0; si < plotBars; si++)
{
if(si + 2 * h >= n || si + h >= d1Count)
break;
d2[si] = (d1[si] - d1[si + h]) / ((double)h * scale);
}
for(int si = 0; si < plotBars; si++)
{
if(si + 3 * h >= n)
break;
if(si + h >= plotBars)
break;
if(d2[si] == EMPTY_VALUE || d2[si + h] == EMPTY_VALUE)
continue;
d3[si] = (d2[si] - d2[si + h]) / ((double)h * scale);
}
return true;
}
void UpdateDerivativeCanvasStrip()
{
if(!InpUseCanvasPlots)
return;
ENUM_TIMEFRAMES tf = InpSignalTF;
if(tf == PERIOD_CURRENT)
tf = (ENUM_TIMEFRAMES)Period();
double d1[], d2[], d3[];
if(!ComputeDerivativeSeries(g_chartSymbol, tf, InpCanvasPlotBars, d1, d2, d3))
return;
const int chartW = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
if(chartW < 80)
return;
const int panelW = MathMax(60, chartW - InpCanvasSideMargin * 2);
const int panelH = MathMax(90, InpCanvasPanelHeight);
const int x0 = InpCanvasSideMargin;
const int y0 = InpCanvasBottomMargin;
if(!g_deriv_canvas_created)
{
if(!g_deriv_canvas.CreateBitmapLabel(0, 0, DERIV_CANVAS_OBJ, x0, y0, panelW, panelH, COLOR_FORMAT_ARGB_NORMALIZE))
{
if(InpDebugTrace)
Print("DERIVATIVE_CALC: canvas CreateBitmapLabel failed err=", GetLastError());
return;
}
ObjectSetInteger(0, DERIV_CANVAS_OBJ, OBJPROP_CORNER, CORNER_LEFT_LOWER);
ObjectSetInteger(0, DERIV_CANVAS_OBJ, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);
ObjectSetInteger(0, DERIV_CANVAS_OBJ, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, DERIV_CANVAS_OBJ, OBJPROP_HIDDEN, true);
g_deriv_canvas_created = true;
}
else
{
g_deriv_canvas.Resize(panelW, panelH);
ObjectSetInteger(0, DERIV_CANVAS_OBJ, OBJPROP_XDISTANCE, x0);
ObjectSetInteger(0, DERIV_CANVAS_OBJ, OBJPROP_YDISTANCE, y0);
}
g_deriv_canvas.Erase(ColorToARGB(InpCanvasBgColor, 255));
const int rows = 3;
const int rowH = MathMax(24, panelH / rows);
const uint clrLines[3] = {
ColorToARGB(clrDodgerBlue, 235),
ColorToARGB(clrOrange, 235),
ColorToARGB(clrMagenta, 235)
};
const string tags[3] = { "d1 velocity", "d2 acceleration", "d3 jerk" };
const int nPts = MathMin(InpCanvasPlotBars, ArraySize(d1));
if(nPts < 3)
{
g_deriv_canvas.Update();
return;
}
for(int r = 0; r < rows; r++)
{
const int yBase = r * rowH;
const int midY = yBase + rowH / 2;
g_deriv_canvas.LineAA(0.0, (double)midY, (double)(panelW - 1), (double)midY, ColorToARGB(InpCanvasGridColor, 70));
double vmin = DBL_MAX;
double vmax = -DBL_MAX;
for(int si = 0; si < nPts; si++)
{
const double v = CanvasSeriesAt(r, si, d1, d2, d3);
if(v == EMPTY_VALUE || !MathIsValidNumber(v))
continue;
if(v < vmin)
vmin = v;
if(v > vmax)
vmax = v;
}
if(vmin == DBL_MAX)
continue;
if(MathAbs(vmax - vmin) < 1e-15)
{
vmin -= 1.0;
vmax += 1.0;
}
g_deriv_canvas.FontSet("Consolas", -90);
g_deriv_canvas.TextOut(4, yBase + 2, tags[r], ColorToARGB(clrSilver, 220));
const double denom = (double)MathMax(1, nPts - 1);
for(int si = 0; si < nPts - 1; si++)
{
const double v0 = CanvasSeriesAt(r, si, d1, d2, d3);
const double v1 = CanvasSeriesAt(r, si + 1, d1, d2, d3);
if(v0 == EMPTY_VALUE || v1 == EMPTY_VALUE)
continue;
const double xf0 = (double)(panelW - 1) * (double)(nPts - 1 - si) / denom;
const double xf1 = (double)(panelW - 1) * (double)(nPts - 2 - si) / denom;
const double t0 = (v0 - vmin) / (vmax - vmin);
const double t1 = (v1 - vmin) / (vmax - vmin);
const int py0 = yBase + 3 + (int)((double)(rowH - 6) * (1.0 - t0));
const int py1 = yBase + 3 + (int)((double)(rowH - 6) * (1.0 - t1));
g_deriv_canvas.LineAA(xf0, (double)py0, xf1, (double)py1, clrLines[r]);
}
}
g_deriv_canvas.Update();
ChartRedraw(0);
}
bool HasOurPosition(const string sym)
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
const ulong t = PositionGetTicket(i);
if(t == 0 || !PositionSelectByTicket(t))
continue;
if(PositionGetString(POSITION_SYMBOL) != sym)
continue;
if((ulong)PositionGetInteger(POSITION_MAGIC) != InpMagic)
continue;
return true;
}
return false;
}
double AtrPoints(const string sym, const ENUM_TIMEFRAMES tf)
{
const int h = iATR(sym, tf, InpAtrPeriod);
if(h == INVALID_HANDLE)
return 0.0;
double b[];
ArraySetAsSeries(b, true);
if(CopyBuffer(h, 0, 1, 1, b) != 1)
{
IndicatorRelease(h);
return 0.0;
}
IndicatorRelease(h);
const double pt = SymbolInfoDouble(sym, SYMBOL_POINT);
return (pt > 0.0 ? b[0] / pt : 0.0);
}
void RemoveDerivativePlotsIndicatorsFromChart()
{
const int nw = (int)ChartGetInteger(0, CHART_WINDOWS_TOTAL);
for(int w = nw - 1; w >= 0; w--)
{
const int nc = ChartIndicatorsTotal(0, w);
for(int k = nc - 1; k >= 0; k--)
{
const string nm = ChartIndicatorName(0, w, k);
if(StringFind(nm, "DERIV_") >= 0 ||
StringFind(nm, "DERIV_PLOTS") >= 0 ||
StringFind(nm, InpPlotsIndicatorPath) >= 0 ||
StringFind(nm, "DerivativePlots") >= 0)
ChartIndicatorDelete(0, w, nm);
}
}
}
bool DerivativePlotsAlreadyOnChart()
{
const int nw = (int)ChartGetInteger(0, CHART_WINDOWS_TOTAL);
for(int w = 0; w < nw; w++)
{
const int nc = ChartIndicatorsTotal(0, w);
for(int k = 0; k < nc; k++)
{
const string nm = ChartIndicatorName(0, w, k);
if(StringFind(nm, "DERIV_") >= 0 || StringFind(nm, "DERIV_PLOTS") >= 0 ||
StringFind(nm, InpPlotsIndicatorPath) >= 0)
return true;
}
}
return false;
}
// Pass every DerivativePlots input (same order as .mq5) so each WhichDerivative gets its own handle.
int MakeDerivativePlotsHandle(const string sym, const ENUM_TIMEFRAMES tf,
const ENUM_DERIVATIVE_VIEW which, const bool unifyY)
{
return iCustom(sym, tf, InpPlotsIndicatorPath,
InpAppliedPrice,
which,
unifyY,
InpDiffStep,
InpNormalizePoints,
InpSmoothPeriod,
true,
InpDebugTrace,
false);
}
bool AttachDerivativePlotsIndicator(const string sym, const ENUM_TIMEFRAMES tf)
{
if(!InpAutoAttachDerivativePlots)
return false;
if(g_derivPlotsAttachDone)
return true;
const string wantPath = TerminalInfoString(TERMINAL_DATA_PATH) + "\\MQL5\\Indicators\\" + InpPlotsIndicatorPath + ".ex5";
// ChartIndicatorAdd(chart, subwindow, handle). Subwindow index: use ChartWindowsTotal() before each add
// so new panes are appended below existing windows (ATR etc.). Fixed 1,2,3 collides with other indicators.
const bool unifyPass = InpPlotsSeparateWindows ? false : InpPlotsUnifyYScale;
if(InpPlotsSeparateWindows)
{
ResetLastError();
const int ind1 = MakeDerivativePlotsHandle(sym, tf, DERIVATIVE_LEVEL_1, unifyPass);
if(ind1 == INVALID_HANDLE)
{
g_derivativePlotsFailedToLoad = true;
Print("DERIVATIVE_CALC: iCustom(", InpPlotsIndicatorPath, ", d1) failed err=", GetLastError(),
". Required:\n ", wantPath);
if(InpDebugTrace)
PrintFormat("DERIVATIVE_CALC dbg iCustom d1 sym=%s tf=%s", sym, EnumToString(tf));
return false;
}
ResetLastError();
const int ind2 = MakeDerivativePlotsHandle(sym, tf, DERIVATIVE_LEVEL_2, unifyPass);
if(ind2 == INVALID_HANDLE)
{
IndicatorRelease(ind1);
g_derivativePlotsFailedToLoad = true;
Print("DERIVATIVE_CALC: iCustom(", InpPlotsIndicatorPath, ", d2) failed err=", GetLastError(),
". Required:\n ", wantPath);
return false;
}
ResetLastError();
const int ind3 = MakeDerivativePlotsHandle(sym, tf, DERIVATIVE_LEVEL_3, unifyPass);
if(ind3 == INVALID_HANDLE)
{
IndicatorRelease(ind1);
IndicatorRelease(ind2);
g_derivativePlotsFailedToLoad = true;
Print("DERIVATIVE_CALC: iCustom(", InpPlotsIndicatorPath, ", d3) failed err=", GetLastError(),
". Required:\n ", wantPath);
return false;
}
if(InpDebugTrace)
PrintFormat("DERIVATIVE_CALC dbg triple iCustom handles ind1=%d ind2=%d ind3=%d (should differ)",
ind1, ind2, ind3);
RemoveDerivativePlotsIndicatorsFromChart();
int sw = (int)ChartGetInteger(0, CHART_WINDOWS_TOTAL);
ResetLastError();
const bool ok1 = ChartIndicatorAdd(0, sw, ind1);
const int err1 = GetLastError();
sw = (int)ChartGetInteger(0, CHART_WINDOWS_TOTAL);
ResetLastError();
const bool ok2 = ChartIndicatorAdd(0, sw, ind2);
const int err2 = GetLastError();
sw = (int)ChartGetInteger(0, CHART_WINDOWS_TOTAL);
ResetLastError();
const bool ok3 = ChartIndicatorAdd(0, sw, ind3);
const int err3 = GetLastError();
IndicatorRelease(ind1);
IndicatorRelease(ind2);
IndicatorRelease(ind3);
if(!ok1 || !ok2 || !ok3)
{
g_derivativePlotsFailedToLoad = true;
Print("DERIVATIVE_CALC: ChartIndicatorAdd (3 panes) failed ok=", ok1, ",", ok2, ",", ok3,
" err=", err1, ",", err2, ",", err3, ". File: ", wantPath);
return false;
}
g_derivativePlotsFailedToLoad = false;
g_derivPlotsAttachDone = true;
ChartRedraw(0);
Print("DERIVATIVE_CALC: DerivativePlots attached as three stacked subwindows (indices chosen from CHART_WINDOWS_TOTAL).");
if(InpDebugTrace)
PrintFormat("DERIVATIVE_CALC dbg triple attach OK sym=%s tf=%s", sym, EnumToString(tf));
return true;
}
ResetLastError();
const int ind = MakeDerivativePlotsHandle(sym, tf, InpWhichDerivative, unifyPass);
if(ind == INVALID_HANDLE)
{
g_derivativePlotsFailedToLoad = true;
Print("DERIVATIVE_CALC: iCustom(\"", InpPlotsIndicatorPath, "\") failed err=", GetLastError(),
". MT5 could not read the compiled indicator. Required file:\n ", wantPath,
"\nCopy lab\\\\EAs\\\\DerivativePlots.mq5 into that Indicators folder, open in MetaEditor, press Compile (F7).");
if(InpDebugTrace)
PrintFormat("DERIVATIVE_CALC dbg iCustom sym=%s tf=%s applied=%d which=%d unify=%s h=%d norm=%s sm=%d",
sym, EnumToString(tf), (int)InpAppliedPrice, (int)InpWhichDerivative,
InpPlotsUnifyYScale ? "on" : "off",
InpDiffStep, InpNormalizePoints ? "on" : "off", InpSmoothPeriod);
return false;
}
RemoveDerivativePlotsIndicatorsFromChart();
int sw = (int)ChartGetInteger(0, CHART_WINDOWS_TOTAL);
ResetLastError();
const bool ok = ChartIndicatorAdd(0, sw, ind);
const int errAfterAdd = GetLastError();
IndicatorRelease(ind);
if(!ok)
{
g_derivativePlotsFailedToLoad = true;
Print("DERIVATIVE_CALC: ChartIndicatorAdd failed err=", errAfterAdd,
". Expected file present: ", wantPath);
return false;
}
g_derivativePlotsFailedToLoad = false;
g_derivPlotsAttachDone = true;
ChartRedraw(0);
Print("DERIVATIVE_CALC: subwindow indicator attached (inputs synced from EA).");
if(InpDebugTrace)
PrintFormat("DERIVATIVE_CALC dbg attach OK handle_was_valid ChartIndicatorAdd err=%d sym=%s tf=%s sw=%d",
errAfterAdd, sym, EnumToString(tf), sw);
return true;
}
void TryDemoTrade(const string sym, const ENUM_TIMEFRAMES tf,
const double d1, const double d2, const double d3)
{
if(!InpTradeEnabled || HasOurPosition(sym))
return;
bool wantBuy = false;
bool wantSell = false;
switch(InpWhichDerivative)
{
case DERIVATIVE_ALL:
case DERIVATIVE_LEVEL_1:
wantBuy = (d1 > 0.0 && d2 > 0.0);
wantSell = (d1 < 0.0 && d2 < 0.0);
break;
case DERIVATIVE_LEVEL_2:
wantBuy = (d2 > 0.0);
wantSell = (d2 < 0.0);
break;
default:
wantBuy = (d3 > 0.0);
wantSell = (d3 < 0.0);
break;
}
if(!wantBuy && !wantSell)
return;
MqlTick tick;
if(!SymbolInfoTick(sym, tick))
return;
const double atrPts = AtrPoints(sym, tf);
const double pt = SymbolInfoDouble(sym, SYMBOL_POINT);
const double slPts = MathMax(atrPts * InpSlAtrMult, 10.0);
const double tpPts = MathMax(atrPts * InpTpAtrMult, 10.0);
double sl = 0.0, tp = 0.0;
if(wantBuy)
{
sl = tick.ask - slPts * pt;
tp = tick.ask + tpPts * pt;
g_trade.Buy(InpLots, sym, tick.ask, sl, tp, "DERIVATIVE_CALC demo");
}
else if(wantSell)
{
sl = tick.bid + slPts * pt;
tp = tick.bid - tpPts * pt;
g_trade.Sell(InpLots, sym, tick.bid, sl, tp, "DERIVATIVE_CALC demo");
}
}
int OnInit()
{
g_derivPlotsAttachDone = false;
g_lastCommentWallMs = 0;
g_chartSymbol = InpSymbol;
StringTrimLeft(g_chartSymbol);
StringTrimRight(g_chartSymbol);
if(StringLen(g_chartSymbol) == 0)
g_chartSymbol = _Symbol;
if(!SymbolSelect(g_chartSymbol, true))
{
Print("DERIVATIVE_CALC EA: cannot select symbol ", g_chartSymbol);
return INIT_FAILED;
}
g_trade.SetExpertMagicNumber((long)InpMagic);
g_trade.SetDeviationInPoints(InpSlippagePoints);
g_trade.SetTypeFillingBySymbol(g_chartSymbol);
ENUM_TIMEFRAMES tf = InpSignalTF;
if(tf == PERIOD_CURRENT)
tf = (ENUM_TIMEFRAMES)Period();
Print("DERIVATIVE_CALC EA started on ", g_chartSymbol, " ", EnumToString(tf),
". This is an Expert Advisor — not the Accelerator indicator.");
if(InpDebugTrace)
PrintFormat("DERIVATIVE_CALC dbg chart_TF=%s signal_TF=%s normalize=%s h=%d sm=%d tester=%s visual=%s",
EnumToString((ENUM_TIMEFRAMES)Period()), EnumToString(tf),
InpNormalizePoints ? "on" : "off", InpDiffStep, InpSmoothPeriod,
MQLInfoInteger(MQL_TESTER) ? "yes" : "no",
MQLInfoInteger(MQL_VISUAL_MODE) ? "yes" : "no");
DeleteOurHelpObjects();
TryBuildHelpPanel();
// Do not call iCustom / ChartIndicatorAdd here — Strategy Tester treats failed indicator load in OnInit as a critical error.
// Attachment runs on first OnTick instead (see g_pendingDerivativePlotsAttach).
if(InpUseCanvasPlots)
{
RemoveDerivativePlotsIndicatorsFromChart();
EventSetMillisecondTimer(120);
}
else
EventKillTimer();
if(InpAutoAttachDerivativePlots && !InpUseCanvasPlots)
{
RemoveDerivativePlotsIndicatorsFromChart();
const bool in_tester = (MQLInfoInteger(MQL_TESTER) != 0);
const bool visual = (MQLInfoInteger(MQL_VISUAL_MODE) != 0);
const bool skip_tester_attach = (in_tester && !visual && !InpAttachPlotsInTester);
if(skip_tester_attach)
{
Print("DERIVATIVE_CALC: non-visual Strategy Tester - skipping DerivativePlots attach. ",
"Use visual mode for subwindow plots, or set InpAttachPlotsInTester=true if DerivativePlots.ex5 is in MQL5\\Indicators\\.");
}
else
{
g_pendingDerivativePlotsAttach = true;
Print("DERIVATIVE_CALC: DerivativePlots attach scheduled on first tick (OnInit cannot safely load custom indicators in tester).");
}
}
return INIT_SUCCEEDED;
}
void OnDeinit(const int reason)
{
EventKillTimer();
if(g_deriv_canvas_created)
{
g_deriv_canvas.Destroy();
g_deriv_canvas_created = false;
}
ObjectDelete(0, DERIV_CANVAS_OBJ);
g_derivPlotsAttachDone = false;
DeleteOurHelpObjects();
Comment("");
}
void OnTimer()
{
if(!InpUseCanvasPlots)
return;
const uint now = GetTickCount();
if(InpCanvasRedrawMs > 0 && g_lastCanvasRedrawMs != 0 &&
(now - g_lastCanvasRedrawMs) < (uint)InpCanvasRedrawMs)
return;
g_lastCanvasRedrawMs = now;
UpdateDerivativeCanvasStrip();
}
void OnTick()
{
ENUM_TIMEFRAMES tf = InpSignalTF;
if(tf == PERIOD_CURRENT)
tf = (ENUM_TIMEFRAMES)Period();
if(g_pendingDerivativePlotsAttach && !InpUseCanvasPlots)
{
g_pendingDerivativePlotsAttach = false;
AttachDerivativePlotsIndicator(g_chartSymbol, tf);
}
const datetime barOpen = iTime(g_chartSymbol, tf, 0);
if(barOpen == 0)
return;
if(barOpen == g_lastBarTime)
return;
g_lastBarTime = barOpen;
double d1 = 0.0, d2 = 0.0, d3 = 0.0;
if(!ComputeDerivatives(g_chartSymbol, tf, d1, d2, d3))
{
if(InpDebugTrace)
PrintFormat("DERIVATIVE_CALC dbg ComputeDerivatives FAILED sym=%s tf=%s bar=%s pt=%.12g",
g_chartSymbol, EnumToString(tf), TimeToString(barOpen, TIME_DATE | TIME_MINUTES),
SymbolInfoDouble(g_chartSymbol, SYMBOL_POINT));
if(InpShowComment)
CommentThrottled("DERIVATIVE_CALC: not enough bars yet on " + g_chartSymbol + " " + EnumToString(tf) +
DerivativePlotsMissingHint());
return;
}
if(InpDebugTrace)
PrintFormat("DERIVATIVE_CALC dbg bar=%s sym=%s chart_TF=%s signal_TF=%s | d1=%.8g d2=%.8g d3=%.8g | pt=%.12g norm=%s h=%d",
TimeToString(barOpen, TIME_DATE | TIME_MINUTES), g_chartSymbol,
EnumToString((ENUM_TIMEFRAMES)Period()), EnumToString(tf),
d1, d2, d3, SymbolInfoDouble(g_chartSymbol, SYMBOL_POINT),
InpNormalizePoints ? "on" : "off", InpDiffStep);
if(InpShowComment)
{
string c = "DERIVATIVE_CALC EA | " + g_chartSymbol +
"\nChart TF: " + EnumToString((ENUM_TIMEFRAMES)Period()) +
" Signal TF (inputs): " + EnumToString(tf) +
"\nd1=" + DoubleToString(d1, 4) + " d2=" + DoubleToString(d2, 4) + " d3=" + DoubleToString(d3, 4) +
"\n(InpWhichDerivative=" + IntegerToString((int)InpWhichDerivative) +
" h=" + IntegerToString(InpDiffStep) + " sm=" + IntegerToString(InpSmoothPeriod) + ")" +
(InpUseCanvasPlots
? "\nPlots: EA canvas strip (bottom of chart)."
: ("\nPlots below: DerivativePlots indicator." + DerivativePlotsMissingHint()));
CommentThrottled(c);
}
TryDemoTrade(g_chartSymbol, tf, d1, d2, d3);
}
//+------------------------------------------------------------------+
Reference in New Issue Copy Permalink