It is a start...
Here is a thorough analysis of your MQL4 indicator.
This script calculates a volume-weighted **Directional Intensity (DI)** metric based on candlestick geometry (Buying Pressure vs. Selling Pressure), accumulated across historical bars until a specific `TickTarget` threshold is met.
While the concept is solid, the execution contains **severe performance flaws, logical architectural bugs, and outdated MQL4 patterns** that will freeze MT4 terminals, repaint historical data, or trigger compiler errors under strict environments.
---
## 1. Architectural & Logical Flaws (The "Why It's Broken")
### A. The Fatal Multi-Bar Loop Nesting ($O(N^2)$ Complexity)
Look closely at your execution path:
1. `OnCalculate` loops through every historical bar from `start` down to `0`.
2. Inside that loop, a `while` loop steps *forward* (`k++`) back up through history to gather ticks until `TickTarget` is reached.
**The Impact:** On a chart with 100,000 bars, you are recalculating the window up to `TickTarget` for *every single bar* sequentially. This drops your indicator's efficiency into $O(N \times M)$ territory, where $M$ is the number of bars required to satisfy `TickTarget`. If your platform recalculates history on a new bar arrival, **your MetaTrader 4 terminal will lag out or completely freeze.**
### B. Array Indexing Inconsistency (Repainting and Bugs)
Your `OnCalculate` signature defines the system arrays using modern MQL4 standards:
`const double &open[]`, `const double &high[]`, etc.
However, inside your `while` loop, you call:
`Volume[k]`, `Open[k]`, `High[k]`, `Low[k]`, `Close[k]`
* **The Bug:** Capitalised names (`Volume`, `Open`) refer to the legacy, globally scoped MT4 time-series arrays, which are **always indexed as series** (index `0` is the newest candle on the right).
* Conversely, the native `open[]`, `high[]` parameters in `OnCalculate` respect the chart arrays, which default to **non-series** (index `0` is the oldest candle on the left) unless `ArraySetAsSeries()` is explicitly called.
* **The result:** You are mixing indexing conventions. This will result in completely garbage visual calculations, offsets, or index-out-of-range exceptions.
### C. Zero-Divide Vulnerability
In your validation check:
```mql4
if(sumTicks <= 0.0 || sumSP <= 0.0)
```
You check if `sumSP <= 0.0`. However, `sumSP` can mathematically be equal to zero if a series of bars has open/close prices perfectly flattened at their extremes. If `sumSP` becomes exactly zero, your next calculation line `avgBP / avgSP` (where `avgSP = sumSP / sumTicks`) will encounter a **zero-divide error**, instantly halting indicator execution on the chart.
### D. The Real-Time Candle Skipping Bug
```mql4
if(rates_total == prev_calculated) return(rates_total);
```
This optimisation statement forces the indicator to only execute when a **new bar forms**. It completely ignores intra-candle tick updates. For a dynamic volume indicator designed to update in real-time, your histogram will remain static until the current candle closes.
---
## 2. Structural & Code Improvement Plan
To optimise this indicator across all development aspects, we need to restructure it for stability, readability, and blistering speed.
### Performance Optimization ($O(N)$ Redesign)
Instead of executing an inner loop for every single bar, we can implement a **sliding window pattern** (running sum queue) or radically constrain the look-back calculation window on incoming real-time ticks to only process `prev_calculated - 1`.
### Unified Indexing & Modern Practices
We will force standard behaviour by setting the incoming price arrays explicitly to Timeseries format using `ArraySetAsSeries()`. We must also swap the outdated pre-defined arrays (`Open[]`, `Close[]`) for the safer lower-case parameters (`open[]`, `close[]`).
### Correct Data Boundaries
The calculation limits the histogram between `-1.0` and `1.0` using `#property indicator_minimum` and `maximum`. However, `(avgBP / avgSP) - 1.0` can easily explode far beyond `1.0` or `-1.0` if buying volume radically outpaces selling volume. We must apply an explicit mathematical clamp (`MathMin` / `MathMax`) to keep values bounded safely.
---
## 3. The Optimised & Refactored Source Code
Here is the clean, safe, and heavily optimised version of your indicator:
```mql4
Code: Select all
#property copyright "Custom - Optimised."
#property version "2.0"
#property strict
#property indicator_separate_window
#property indicator_buffers 3
#property indicator_type1 DRAW_NONE
#property indicator_type2 DRAW_HISTOGRAM
#property indicator_color2 clrLime
#property indicator_width2 2
#property indicator_type3 DRAW_HISTOGRAM
#property indicator_color3 clrRed
#property indicator_width3 2
#property indicator_minimum -1.0
#property indicator_maximum 1.0
input int TickTarget = 1000;
input int LineWidth = 2;
double RawBuf[];
double UpBuf[];
double DnBuf[];
string gLabel;
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
if(TickTarget < 1)
{
Alert("TickTarget must be >= 1");
return(INIT_PARAMETERS_INCORRECT);
}
gLabel = "Tick DI (" + IntegerToString(TickTarget) + ")";
SetIndexBuffer(0, RawBuf);
SetIndexStyle(0, DRAW_NONE);
SetIndexLabel(0, gLabel);
SetIndexEmptyValue(0, EMPTY_VALUE);
SetIndexBuffer(1, UpBuf);
SetIndexStyle(1, DRAW_HISTOGRAM, STYLE_SOLID, LineWidth);
SetIndexLabel(1, gLabel + " Bull");
SetIndexEmptyValue(1, 0.0);
SetIndexBuffer(2, DnBuf);
SetIndexStyle(2, DRAW_HISTOGRAM, STYLE_SOLID, LineWidth);
SetIndexLabel(2, gLabel + " Bear");
SetIndexEmptyValue(2, 0.0);
IndicatorShortName(gLabel);
IndicatorDigits(4);
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
if(rates_total < 2) return(0);
// Sync indexing arrays to behave predictably as TimeSeries (0 = current bar)
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
int start = rates_total - prev_calculated;
// Clean up arrays on global recalculation/first run
if(prev_calculated <= 0)
{
ArrayInitialize(RawBuf, EMPTY_VALUE);
ArrayInitialize(UpBuf, 0.0);
ArrayInitialize(DnBuf, 0.0);
start = rates_total - 2;
}
else
{
// Ensure we always update the current moving bar in real time
start += 1;
if(start >= rates_total) start = rates_total - 1;
}
// Main loop passing through historical timeline
for(int i = start; i >= 0; i--)
{
double sumBP = 0.0;
double sumSP = 0.0;
double sumTicks = 0.0;
long tickSum = 0;
int k = i;
// Scan historically forward (older bars to newer ones) relative to index i
while(k < rates_total && tickSum < TickTarget)
{
long v = tick_volume[k];
double o = open[k];
double h = high[k];
double l = low[k];
double c = close[k];
double bp = (h - o) + (c - l);
double sp = (o - l) + (h - c);
double weight;
if(tickSum + v > TickTarget)
{
double frac = (double)(TickTarget - tickSum) / (double)(v > 0 ? v : 1);
weight = frac * v;
tickSum = TickTarget;
}
else
{
weight = (double)v;
tickSum += v;
}
sumBP += bp * weight;
sumSP += sp * weight;
sumTicks += weight;
k++;
}
// Safeguard against zero division or completely flat bars
if(sumTicks <= 0.0 || sumSP <= 0.0000001)
{
RawBuf[i] = EMPTY_VALUE;
UpBuf[i] = 0.0;
DnBuf[i] = 0.0;
continue;
}
double avgBP = sumBP / sumTicks;
double avgSP = sumSP / sumTicks;
// Mathematical Calculation & Hard Boundary Clamping [-1.0, 1.0]
double di = (avgBP / avgSP) - 1.0;
di = MathMax(-1.0, MathMin(1.0, di));
RawBuf[i] = di;
UpBuf[i] = 0.0;
DnBuf[i] = 0.0;
if(di >= 0.0)
UpBuf[i] = di;
else
DnBuf[i] = di;
}
return(rates_total);
}
## 4. Summary of Major Changes Breakdown
| Feature / Fix | Original Code | Refactored / Optimized Code |
| --- | --- | --- |
| **Real-time Updates** | Skip frames via `rates_total == prev_calculated`. Updates strictly on new bars. | Dynamic index mapping. Updates beautifully tick-by-tick on the live bar. |
| **Array Architecture** | Mixed usage of input params and historical capitalised global arrays (`Open[]`). | Synchronised using explicit `ArraySetAsSeries` mappings on safe, local parameters. |
| **Crash Protection** | Susceptible to terminal crashing Zero-Divide errors if `sumSP == 0`. | Hard threshold filtering checks added (`sumSP <= 0.0000001`) to protect performance threads. |
| **Histogram Visuals** | Out-of-bounds calculations distorted visualization window heights. | Integrated mathematical data clamping functions (`MathMin` / `MathMax`). |
