API Documentation

Complete reference for every function, class, and strategy in FxMath GaussEnsemble. Both MQL5 and MQL4 versions share the same API — differences are noted inline.

Core Math

All Gaussian math is implemented from scratch — zero external dependencies. The approximations use Abramowitz & Stegun formulas for the error function and its inverse, which are accurate to ~1.5e-7 absolute error.

Erf — Error Function

Computes the Gauss error function using Abramowitz & Stegun 7.1.26 approximation (Hastings polynomial).

The error function is defined as:

The implementation uses a rational approximation with 5 coefficients. The sign is preserved, so the function works correctly for negative x. The maximum absolute error is ~1.5e-7 across the entire domain.

ErfInv — Inverse Error Function

Computes the inverse error function, used to construct confidence intervals and convert probabilities to z-scores. Uses a piecewise rational approximation:

• For x near 0 (p < 5): uses a 19-coefficient rational polynomial in transformed variable p = 2·x − 2
• For x near 1 (p ≥ 5): uses a 20-coefficient rational polynomial in transformed variable p = sqrt(p − 5)

GaussPDF — Probability Density Function

Computes the standard Gaussian PDF:

If sigma ≤ 0, returns 0.0 to prevent division-by-zero.

GaussCDF — Cumulative Distribution Function

Computes the Gaussian CDF using the relationship CDF(x) = 0.5 · (1 + erf((x−μ) / (σ·√2))). The result is the probability that a random sample from N(μ, σ²) is ≤ x.

GaussZScore — Z-Score Calculation

Computes the z-score: z = (x − μ) / σ. A measure of how many standard deviations the observation x is from the mean.

GaussEntropy — Differential Entropy

Computes the differential entropy of a univariate Gaussian: H = 0.5 · ln(2π·e·σ²). Used internally by GMM for regime detection — higher entropy implies higher uncertainty / volatility.

Linear Algebra

Matrix operations use flat 1D arrays stored in row-major order: element A[i][j] is at index i·n+j. The Cholesky decomposition is the workhorse for GPR training. MQL5 uses native matrix/vector types; MQL4 uses the flat array pattern.

CholeskyDecompFlat

Computes the Cholesky decomposition of a symmetric positive-definite matrix K: K = L · Lᵀ, where L is lower triangular. Uses the standard Cholesky-Crout algorithm with O(n³/3) operations.

SolveCholeskyFlat

Solves the linear system L·Lᵀ·x = b for x, given the Cholesky factor L. Uses forward substitution (L·y = b) followed by backward substitution (Lᵀ·x = y).

SolveForwardFlat — Forward Substitution

Solves L·x = b where L is lower triangular. For i = 0..n−1: x[i] = (b[i] − Σⱼ₌₀ⁱ⁻¹ L[i][j]·x[j]) / L[i][i]

SolveBackwardFlat — Backward Substitution

Solves Lᵀ·x = b where L is lower triangular. For i = n−1..0: x[i] = (b[i] − Σⱼ₌ᵢ₊₁ⁿ⁻¹ L[j][i]·x[j]) / L[i][i]

Data & Filtering

PriceBuffer

Thread-safe OHLCV ring buffer that stores the most recent maxBars (default 200) bars. Updated on every tick from OnTick(). Provides indexed access to price components and common derived values.

CalcATR / GetATR

Computes the Average True Range (ATR) for the given period using:

• TR = max(High − Low, |High − Closeₚᵣₑᵥ|, |Low − Closeₚᵣₑᵥ|)
• ATR is computed via a modified Wilder's smoothing with EMA

Convenience wrapper: allocates the array, calls CalcATR, returns the current ATR value (index 0).

GaussFilter

Static utility class for one-dimensional Gaussian filtering. Used by Strategy 1 (Filter Trend) and Strategy 5 (Volatility Bands).

GaussFilter::Kernel

Generates a 1D Gaussian kernel: k[i] = exp(−x² / (2·σ²)) where x = i − length/2. The kernel is normalized so its elements sum to 1.

GaussFilter::Filter

Combines Kernel + Convolve in one call: generates a Gaussian kernel of length kLen with the given sigma, then convolves it with src, producing the smoothed output in dst.

GaussFilter::Convolve

Performs discrete 1D convolution with boundary clamping. For each output position i, the weighted average of valid kernel-overlapping src samples is computed. Edge positions automatically use fewer kernel taps (weight renormalized).

Machine Learning Models

GPR — Gaussian Process Regression

Implements Gaussian Process Regression for time-series prediction. Uses a squared-exponential (RBF) kernel: K(xᵢ, xⱼ) = σ² · exp(−(xᵢ−xⱼ)² / (2·ℓ²)). The implementation follows the standard GPR formulation (Rasmussen & Williams).

GPR::Train

Trains the GP on n training points. The algorithm:

1. Build covariance matrix K: K[i][j] = kernel(x[i], x[j]) + δᵢⱼ · noise² where noise = 0.01 · σ_y
2. Cholesky decomposition: L = chol(K) — factorizes K into L·Lᵀ
3. Compute α: Solve L·Lᵀ·α = y via forward/backward substitution
4. Store L and α for efficient prediction

GPR::Predict

Predicts at a test point x* using the stored GP posterior:

• Mean: k(x*)ᵀ · α — where k(x*) is the kernel vector between x* and all training points
• Variance: k(x*, x*) − k(x*)ᵀ · (Lᵀ \ (L \ k(x*))) — the posterior uncertainty

GMM — Gaussian Mixture Model

Fits a 2-component univariate Gaussian Mixture Model using Expectation-Maximization (EM). Designed to detect high-volatility vs low-volatility regimes in return series.

GMM::Fit

Runs the EM algorithm for up to 100 iterations (or until convergence):

1. E-Step: Compute responsibility γᵢₖ = πₖ · N(xᵢ | μₖ, σₖ²) / Σⱼ πⱼ · N(xᵢ | μⱼ, σⱼ²) for each component k and data point i
2. M-Step: Update parameters — Nₖ = Σᵢ γᵢₖ, πₖ = Nₖ / n, μₖ = Σᵢ γᵢₖ·xᵢ / Nₖ, σₖ² = Σᵢ γᵢₖ·(xᵢ−μₖ)² / Nₖ
3. Check: if max parameter change < 1e-6, stop early

Initialization: k-means with 2 iterations. Component 0 is initialized with the lower-variance cluster (sorted by sigma after fitting).

GMM::Predict

Assigns a data point to the most likely component (maximum posterior responsibility). Returns the component index (0 or 1).

GMM::GetHighVolRegime

Returns the component index with the higher standard deviation — i.e., the high-volatility regime. The model internally sorts components so that component 1 is always the high-vol regime after fitting.

GMM::Accessors

Retrieve the fitted parameters. Returns safe defaults (0.0, 1.0, 0.0 respectively) if the model hasn't been fitted or the index is out of range.

GNB — Gaussian Naive Bayes

Implements a binary Gaussian Naive Bayes classifier using three features: return, log-volume-ratio, and high-low spread. Used to predict whether the next bar closes up vs down.

GNB::Fit

Fits the model on n training samples. For each class (up/down):

• Prior: P(up) = n_up / n, P(down) = n_down / n
• For each feature j: μⱼ = mean of feature in class, σⱼ = std of feature in class (clamped to a minimum of 1.0 to prevent zero-variance)
• Requires at least 3 samples per class

GNB::PredictProbUp

Computes P(up | features) using Bayes' rule under the Naive assumption (conditional independence):

Returns 0.5 if the model hasn't been fitted.

Strategies

IStrategy Interface (Abstract Class)

Base class that all six strategies implement. In MQL5 this is an interface; in MQL4 it's an abstract class with pure virtual methods.

Strategy 1 — Gaussian Filter Trend

Applies two Gaussian convolutions with different kernel sizes (fast period, slow period). Compares the smoothed lines:

• Bullish crossover: fast just crossed above slow → Buy (confidence 0.8)
• Bearish crossover: fast just crossed below slow → Sell (confidence 0.8)
• Level bias: fast above slow = Buy (0.3), fast below slow = Sell (0.3)
• All signals are weighted by InpWeightFilter

Strategy 2 — GPR Mean Reversion

Trains a Gaussian Process on InpGPRLookback bars. Computes the z-score of current price vs the GP's predictive distribution:

• If z > InpGPRStdThresh → Sell (price is unusually high, expect reversion)
• If z < −InpGPRStdThresh → Buy (price is unusually low)
• Confidence scales as min(|z| / 5.0, 1.0)
• The GP is retrained every tick (stored as α and L for O(n) prediction)

Strategy 3 — GMM Regime Adaptive

Fits a 2-component GMM on return series (updated every 10 bars). Dynamically switches behavior based on detected regime:

• High-vol regime: looks for momentum continuation (returns beyond 0.5·σ_HV)
• Low-vol regime: looks for mean reversion (returns beyond 0.3·σ_HV)
• The high-vol component's sigma is used as the reference scale in both modes
• Signal confidence is fixed at 0.5 − 0.6 to keep the strategy as a moderate contributor

Strategy 4 — GNB Probability

Trains a Gaussian Naive Bayes classifier on three features:

• f0: return = (Close[i] − Close[i+1]) / Close[i+1]
• f1: log-volume-ratio = log(Volume[i] / Volume[i+1])
• f2: high-low spread = (High[i] − Low[i]) / Close[i]

If P(up) > InpGNBProbThresh → Buy. If P(up) < 1 − InpGNBProbThresh → Sell. Confidence = |P(up) − 0.5| × 2 (maps [0.5, 1.0] → [0, 1.0]).

Strategy 5 — Volatility Bands

Computes a Gaussian-weighted rolling mean and standard deviation over the last 30 bars. The kernel (length 15, σ=4.0) gives higher weight to recent prices. If current price is beyond InpVolBandMultiplier × σ from the mean, the market is considered overextended:

• Price above upper band → Sell
• Price below lower band → Buy
• Confidence = min((z − multiplier) / 3.0, 1.0) — scales with distance from the band edge

Strategy 6 — Z-Score Channel

Calculates the rolling z-score of current price relative to the mean of the last period bars (default 20). Pure statistical mean reversion:

• If z > InpZScoreEntry → Sell (overbought, fade)
• If z < −InpZScoreEntry → Buy (oversold, fade)
• The exit threshold InpZScoreExit is reserved for future position-exit logic
• Confidence = min(|z| / 5.0, 1.0)

Ensemble Voting

The core voting engine. Maintains an array of up to 6 strategy pointers and their associated weights.

Ensemble::AddStrategy

Registers a strategy with the given weight. Maximum 6 strategies (no-op beyond that).

Ensemble::Vote

Iterates all registered strategies, calls Update() then GetSignal(), and aggregates votes:

The normalization ensures that having more strategies agree amplifies the signal, while a single dissenting strategy has limited impact.

TradeSignal Struct

SignalVote Struct

Risk Management

ATR-Based SL/TP

At order creation:

• SL = entry_price − sign × InpATRSLMultiplier × ATR(14)
• TP = entry_price + sign × InpATRTPMultiplier × ATR(14)
• Where sign = +1 for Buy, −1 for Sell

Because ATR adapts to volatility, SL/TP automatically widen in high-volatility markets and tighten in calm markets.

Breakeven

Once price reaches InpBEActivatePct% of the TP distance, SL is moved to entry price + buffer (0.1 × ATR). Fires only once per position (tracked via the TrackedPos array).

Trailing Stop

Once price reaches InpTrailActivatePct% of TP distance, the EA tracks the peak price. When price retraces by InpTrailStepPct% of the TP distance from the peak, SL is tightened to the new level. Continues until exit or stop-out.

TrackedPos Structure

ModifySL

Helper that selects an order by ticket, verifies it belongs to this EA (magic number + symbol check), then calls OrderModify (MQL4) / PositionModify (MQL5) with the new SL. The return value is checked and errors are logged.

Chart Panel

When InpShowPanel = true, an info panel draws on the chart using OBJ_LABEL and OBJ_RECTANGLE_LABEL. The panel displays:

• EA name and version
• Current ensemble signal, vote sum, and breakdown (buy/sell counts)
• ATR(14) value in price terms
• Current bid price and spread
• Position info (if open): type, profit, entry, pips, SL, TP, trailing/BE status

Labels use the "Consolas" monospace font with color-coded signal (green = Buy, red = Sell, gray = Neutral). Extra labels from previous frames are cleaned up each tick.

Input Parameters

MQL4 vs MQL5 Differences