Moving Average Slope and Crossovers

A moving average by itself is a picture. To do anything with it — scan for it, count it, test it — you have to convert it into one of two things: a state, which is true across a span of bars, or an event, which is true on exactly one bar. Almost every mistake people make with crossovers comes from confusing the two, and the distinction is important enough that Part 9 devotes a whole lesson to it. This is the preview, using the tools you already have.

Slope: how you turn a curve into a number

“The average is rising” needs a definition before a computer can evaluate it. There are two sensible ones, and they behave very differently.

The one-bar difference. Compare the average to its own value on the previous bar:

Fragment — not a complete formula

Trend = MA( Close, 50 );
Rising = Trend > Ref( Trend, -1 );

Ref( array, -1 ) shifts the array one bar into the past; the negative sign means backwards, which is the opposite of the convention you might expect from array indexing. This is exact and cheap, and it is extremely twitchy: a 50-bar average that is climbing steadily can still tick down for a single bar, and Rising flips to false for that bar.

The regression slope. Fit a least-squares straight line through the last n values and take its gradient. AmiBroker provides this directly:

Fragment — not a complete formula

Slope = LinRegSlope( Close, 20 );          // gradient of the fitted line
EndPoint = LinearReg( Close, 20 );         // where that fitted line ends today

LinRegSlope( ARRAY, periods ) requires both arguments — there is no default period — and it is a rolling fit: the value at each bar is the gradient of a line fitted to the last periods bars ending at that bar. Using twenty bars to decide the direction rather than two makes it far steadier than the one-bar difference.

!Important

The slope comes back in price units per bar. On a share priced at 400 a slope of 0.5 is a gentle drift; on a share priced at 4 the same 0.5 is a violent advance. Comparing LinRegSlope across instruments is meaningless until you normalise it. Dividing by the close turns it into a fraction of price per bar, which is comparable:

Fragment — not a complete formula

PercentPerBar = 100 * LinRegSlope( Close, 20 ) / Close;

Two more documented details. LinearReg returns the end point of the fitted line, not the whole line and not its midpoint — it is frequently mistaken for a regression channel, which AmiBroker has no single built-in function for. And to draw one static regression line across a chart rather than a rolling one, the official example freezes the coefficients with LastValue() first, because the rolling version gives you a different line at every bar.

The crossover as an event

Cross is the operator that converts a comparison into an event. AmiBroker’s definition is short and worth quoting exactly: Cross( ARRAY1, ARRAY2 ) gives 1 on the bar where ARRAY1 crosses above ARRAY2, and 0 otherwise. For the other direction you swap the arguments: Cross( ARRAY2, ARRAY1 ). There is no third argument and no “cross either way” version.

State versus event on the same data

The state is true for three bars. Each event is true for exactly one. A rule built on the state fires on every bar of the move; a rule built on the event fires once.

Bar	1	2	3	4	5	6	7
Fast	9.8	9.9	10.1	10.4	10.6	10.2	9.9
Slow	10.0	10.0	10.0	10.1	10.2	10.3	10.3
Fast > Slow (state)	0	0	1	1	1	0	0
Cross(Fast, Slow) (event)	0	0	1	0	0	0	0
Cross(Slow, Fast) (event)	0	0	0	0	0	1	0

The state is true for three bars. Each event is true for exactly one. A rule built on the state fires on every bar of the move; a rule built on the event fires once.

That table is the whole idea. Fast > Slow describes a condition that persists. Cross( Fast, Slow ) marks the single bar on which the condition began. You need both, for different jobs:

• Filtering a universe for “instruments currently in an uptrend” wants the state.
• Generating an entry signal wants the event, or you buy the same instrument on every bar for the next four months.
• Measuring “what happened after the crossover” wants the event, because otherwise you are measuring the middle of the move as well as its start and calling both the same thing.

✕Common mistake

Writing Buy = Fast > Slow; and then wondering why the backtest reports hundreds of trades in a symbol that trended for a year. The state was true on every one of those bars. AmiBroker’s own language examples use the event form: Buy = Cross( MACD(), 0 );.

Fast and slow pairs

A crossover of two averages is algebraically the same thing as one line crossing zero:

Fragment — not a complete formula

Fast = EMA( Close, 12 );
Slow = EMA( Close, 26 );
Difference = Fast - Slow;
// These two are the same event, written two ways.
CrossA = Cross( Fast, Slow );
CrossB = Cross( Difference, 0 );

Hold on to that. The difference between a fast and a slow exponential average, treated as an oscillator in its own right, is exactly the construction of MACD — which is the next lesson. A “moving average crossover system” and a “MACD zero-line system” with matching periods are the same rule wearing different clothes.

Choosing the pair introduces two free parameters where the single average had one. That is not a small thing. Every additional parameter is another axis you can slide until the history looks agreeable, and Part 31 shows how quickly that becomes self-deception. Note also that the pair is roughly scale-invariant: 10 and 20 produce a similar-looking chart to 20 and 40, just slower. If you find yourself tuning both numbers independently, you are usually tuning one thing — the ratio — plus one thing you did not mean to tune.

Whipsaws are not a defect of the indicator

In a sideways range the fast and slow averages interleave, and every interleaving is a crossover. This is not the indicator failing. It is the indicator faithfully reporting that the last twenty bars and the last fifty bars have nearly the same mean, which is what a range is.

You can count them rather than eyeball them:

Fragment — not a complete formula

Fast = EMA( Close, 20 );
Slow = EMA( Close, 50 );
AnyCross = Cross( Fast, Slow ) OR Cross( Slow, Fast );
Crossings = Cum( AnyCross );
Title = "Crossings so far: " + NumToStr( LastValue( Crossings ), 1.0 );

Cum() runs a cumulative total from the first bar loaded, so Crossings at the last bar is the number of crossings in the whole loaded history. Run that on a trending instrument and on a range-bound one and compare. The number you get is the honest cost of the method.

∴Research note

A crossover count is only interpretable next to the length of the history that produced it. “Forty-one crossings” means nothing; “forty-one crossings in 3,200 daily bars” is a rate you can compare against another symbol or another period. Get into the habit of writing down the denominator, every time.

Marking crossovers on the chart

Fragment — not a complete formula

Fast = EMA( Close, 20 );
Slow = EMA( Close, 50 );

Plot( Close, "Close",  colorDefault, styleCandle );
Plot( Fast,  "EMA 20", colorBlue,    styleLine | styleThick );
Plot( Slow,  "EMA 50", colorRed,     styleLine | styleThick );

Up   = Cross( Fast, Slow );
Down = Cross( Slow, Fast );

// Odd shape values are drawn below the anchor, even ones above. The anchor here
// is the Low array; the default offset of -12 is in screen pixels, not price.
PlotShapes( Up * shapeUpArrow + Down * shapeDownArrow,
            IIf( Up, colorGreen, colorRed ), 0, IIf( Up, Low, High ) );

GraphXSpace = 5;

Two documented details are doing work there. PlotShapes positions shapes by the yposition argument, which defaults to the first plotted line; passing Low or High anchors them to the bar instead. Its offset argument is in screen pixels, not price, and negative values move shapes down — the default is -12. And GraphXSpace adds vertical head- and foot-room to the pane as a percentage; without it, arrows near the top or bottom get clipped. Despite the “X” in its name it controls vertical space.

The Up * shapeUpArrow + Down * shapeDownArrow idiom works because shapeNone is zero, so a bar with no event contributes nothing. It is safe here because Fast cannot cross above and below Slow on the same bar. In general, if two shape conditions can be true together, their constants add to a third, unintended shape — use nested IIf in that case.

Turning this into a testable question

Here is a question about crossovers you can actually answer, and it is not “do they work”.

On this instrument, over this history, what fraction of fast/slow crossovers were reversed by an opposite crossover within ten bars?

That is a reversal rate. It needs no forward-return assumption, no cost model and no trading rule — it is a property of the indicator on that data, and it tells you directly how much of what you are seeing is the range-market interleaving described above. You could compute it by counting crossings, counting those followed by an opposite crossing within ten bars, and dividing.

Notice what the question does not ask. It does not ask whether crossovers are profitable. That question needs entry prices, exit rules, costs, position sizing and a portfolio, all of which arrive in Part 28. Asking a smaller question that your current tools can answer honestly is better practice than asking the big one badly.

Recap

Slope is how you turn a curve into a number, and LinRegSlope gives you a steadier answer than a one-bar difference — in price units per bar, so normalise before comparing symbols. Cross( A, B ) marks the single bar on which A moved above B; swap the arguments for the other direction. A state persists, an event does not, and using the wrong one is the most common structural bug in a first trading rule. A crossover of two averages is the same event as their difference crossing zero, which is the bridge to MACD. Whipsaws in a range are the method working, not failing, and you can count them instead of arguing about them.

Check your understanding

Question 1. What does Cross( MA( Close, 50 ), MA( Close, 200 ) ) evaluate to on a bar in the middle of a long uptrend where the 50-bar average has been above the 200-bar average for six months?

• 1, because the 50 is above the 200
• 0, because no crossing happened on that bar
• Null, because the state has not changed
• The distance between the two averages

Show the answer and why

Answer: 0, because no crossing happened on that bar

Cross is an event. It is 1 only on the bar where the first array moves above the second. The persistent condition is the comparison itself, MA(Close,50) > MA(Close,200).

Question 2. You want to scan for symbols currently in an uptrend, defined as the 50-bar average above the 200-bar average. Which expression belongs in the scan?

• Cross( MA( Close, 50 ), MA( Close, 200 ) )
• MA( Close, 50 ) > MA( Close, 200 )
• LinRegSlope( MA( Close, 50 ), 200 )
• Cross( MA( Close, 200 ), MA( Close, 50 ) )

Show the answer and why

Answer: MA( Close, 50 ) > MA( Close, 200 )

"Currently in an uptrend" is a state, so you want the comparison, which is true on every bar of the condition. The Cross forms would report only the symbols that crossed on that exact bar.

Question 3. LinRegSlope( Close, 20 ) returns 0.42 for symbol A and 0.06 for symbol B. What can you conclude?

• A is trending more strongly than B
• Nothing yet — the slope is in price units per bar and the two symbols may trade at very different prices
• A is 7 times more volatile than B
• B is in a downtrend

Show the answer and why

Answer: Nothing yet — the slope is in price units per bar and the two symbols may trade at very different prices

The slope is a gradient in the units of the input array. A share priced at 500 and one priced at 5 cannot be compared on raw slope. Divide by the close, or by ATR, to get something comparable.

Question 4. Which of these are true of a fast/slow moving average pair? Select all that apply.

• Cross( Fast, Slow ) marks the same bars as Cross( Fast - Slow, 0 )
• Frequent crossings in a sideways market indicate the averages are computed incorrectly
• Adding a second period adds a second free parameter to the method
• The construction is the same one MACD uses

Show the answer and why

Answer: Cross( Fast, Slow ) marks the same bars as Cross( Fast - Slow, 0 ), Adding a second period adds a second free parameter to the method, The construction is the same one MACD uses

Frequent crossings in a range are the arithmetic reporting that the short and long means are close together, which is what a range is. Nothing is broken; the behaviour is the cost of the method.

Check my answersClear