Relative Moving Average Indicator - MetaTrader 5용 지표

Overview

This is a faithful MetaTrader 5 port of the Relative Moving Average (RMA) framework introduced by Dr. Daniel Alexandre Bloch in A Course on Systematic Trading with RMA. A classical moving average reduces a window of prices to one smoothed number, which tells you the level but not the rarity: a high close may be far from everything around it, or high and yet perfectly ordinary within the window. The RMA answers the second question. It treats the trailing window as a small distribution, ranks the current price inside it, and reports that rank on a [0, 1] scale that means the same thing on every instrument and in every volatility regime.

The framework has three layers, and the code mirrors them exactly:

• The SMA of the trailing window of W closes, treated as the local equilibrium and fixed at zero.
• The RMA family, the deviation of each window landmark from that equilibrium as the pure ratio sma / x - 1, evaluated at the last close, the first close, the middle close, and the window minimum and maximum. Being ratios, they are scale free and comparable across symbols.
• The fractiles, which re-express the window as normalised returns (close / sma - 1) and rank the current, minimum and maximum members inside that distribution. This is the plain empirical CDF, taken verbatim from the paper's appendix definition, and f_w is the series everything downstream actually trades on.

The construction: a sliding window of closes becomes an SMA, the closes are re-expressed as a distribution of normalised returns about that SMA, and the current price's rank inside that distribution becomes its fractile on the [0, 1] scale.

On top of those, two derived readings ship with the engine. A regime detector classifies the spread of normalised returns as expanding, contracting, or in transition, using the paper's Relative Extremum Ratios corroborated by a least-squares slope, a z-score, and a coefficient of variation. An adverse-movement monitor publishes d_med_w, the fractile re-centred on the median, and D_k, the share of recent bar-to-bar steps in it that were upward, which is a directional-consistency reading that makes "this move is going the other way" precise rather than a matter of opinion.

Two programs are included. RMA_Engine computes every series and publishes all nineteen of them as buffers, so an Expert Advisor or another indicator can read the exact numbers on the chart rather than reimplementing the mathematics and drifting out of step. RMA_Panel computes nothing at all: it locates the engine already attached to the chart and mirrors a group of its buffers into a sub-window of their own, because the rma family is measured in fractions of a percent and d_med_w is centred on zero, so neither is readable on the engine's 0-to-1 axis.

What the Engine Draws

The engine opens a separate window with its vertical axis pinned to [0, 1] and draws six plots:

Three horizontal guides are drawn at the two entry thresholds and at the median. They are built from the same inputs the companion Expert Advisor is given rather than hard coded, so retuning the thresholds moves the guides with them instead of leaving the chart quietly disagreeing with the rules.

How to read it. An f_w pressed against the upper guide means the current close is at the top of everything its window has seen, which is where a downward traversal arms; an f_w at the lower guide is the mirror case. The median is the level a traversal has to still be on the right side of, and crossing it is the natural exit. The coloured band gives that reading its context, since the paper's rhythm is to open trades at the onset of an expansion phase and close them during contraction.

Recommended Setup

Key Features

Faithful to the paper

• The fractile is the paper's appendix definition, f_i = (1 / |W_i|) * sum_j I( W_ij <= v_i ), implemented as written. Where the paper's prose and its appendix disagree, the appendix wins and the discrepancy is documented in the source rather than silently patched.
• The regime classification follows the Relative Extremum Ratios, testing contraction first because it is the strictest reading and requires corroboration, while expansion is deliberately easier to reach.
• No smoothing, thresholds, or filters were added that the source does not call for.

Built to be read by other programs

• All nineteen series are exposed as indicator buffers, six plotted and thirteen calculation only, so an EA can read the same numbers the chart shows and the two can never disagree.
• The buffer map lives in a single shared header, so the engine, the panels, and any consumer speak one vocabulary instead of drifting apart with no compile error to warn anyone.
• The mathematics lives entirely in header-only classes with no dependency on charts or orders, so the same code can drive a script or a test harness with nothing stubbed.

Correct incremental recalculation

• Each pass recomputes from prev_calculated-1, not prev_calculated. The bar at that index was still forming on the previous call and its close only became final now; leaving it alone would freeze a half-formed value into every series that depends on it, and the bar-to-bar fractile difference would become a difference between two unfinished numbers.
• Warmup bars carry EMPTY_VALUE rather than zero, so a consumer arriving mid-warmup sees "absent" instead of a plausible number.
• The regime classification is path dependent inside its transition band, so a per-bar history is kept rather than one running field, which is what lets an incremental pass pick the chain back up from the bar before.

Panels that borrow a second axis

• The engine opens the panels it was asked for automatically, checking the chart first so a template that already carries them, or a reinitialisation after an input change, does not stack a second copy behind the first. Panels are removed with the engine, but only on actual removal, so switching timeframe returns you to the layout you left.
• The panel finds the engine by matching its short name on the chart instead of building its own handle, so it can never fork into a second, differently parameterised calculation drawn beside the real one.

Screenshots

The engine window on EURUSD, M30: f_w with its envelope and the smoothed quantile means, over the coloured regime backdrop.

The adverse panel: d_med_w centred on zero with D_k above it, the directional-consistency reading.

The RMA family panel: rma_w with the window minimum and maximum on their own scale, the envelope the current price traverses.

Installation and File Structure

Two indicators and four header files. The layout matters: the engine loads the panel by the relative path RMA\RMA_Panel, and the headers are included as <RMA\...>, so both must sit in their RMA subfolders.

Reading the Buffers from Your Own Code

Acquire a handle with iCustom on RMA\RMA_Engine and read any index below with CopyBuffer. Indices 0 to 6 are the plotted series and 7 to 18 are calculation only, but all nineteen are readable.

Input Parameters

Research Basis

The implementation follows:

• Daniel Alexandre Bloch, A Course on Systematic Trading with RMA, available on SSRN.

One caveat is worth stating plainly, because it comes from the source itself: the paper's Results section is left as future work. It offers a framework and its mechanics, not an empirical track record. What this indicator gives you is a described market state on a scale that means the same thing everywhere, which is a foundation for your own testing rather than a validated edge inherited from the source.

A companion article walks through the mathematics and the implementation of every module, and builds the Expert Advisor that trades on these buffers: Bloch's Relative Moving Average (RMA) Framework Implementation In MQL5.