Skip to content

Indicator Code Samples

Simple Indicators

The High Minus Low Indicator calculates the difference between the current bar’s High and Low prices and displays it in an output series, which is drawn on the chart as a line connecting the values at each bar.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    [Indicator(IsOverlay = false, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None, ScalePrecision = 5)]
    public class HighMinusLow : Indicator
    {
        [Output("Main", LineColor = "Orange")]
        public IndicatorDataSeries Result { get; set; }

        public override void Calculate(int index)
        {
            Result[index] = Bars.HighPrice[index] - Bars.LowPrices[index];
        }
    }
}

The IndicatorAttribute is applied to the class to indicate certain characteristics such as:

  • IsOverlay: if it will be overlayed on the chart or on a separate panel (IsOverlay = true/false);
  • TimeZone: The time zone of indicator data and server time
  • AccessRights: The indicator code access rights
  • ScalePrecision: the scale precision on the chart (ScalePrecision = 5 in the present example).

Note

Check the Indicator Attribute section for the complete list.

The IndicatorAttribute is required even if the properties in parenthesis are omitted (for example [Indicator()]).

As mentioned in the previous section the indicator must be an Indicator derived class:

1
public class HighMinusLow : Indicator

The Output Attribute is applied to mark an IndicatorDataSeries as output to the chart.

The property that is marked with the output attribute should be public so that it can be referenced from other classes.

As with the Indicator attribute, the Output attribute allows specifying characteristics such as:

  • the name given to the output (Main in the present example);
  • the color (LineColor = "Orange" in the present example), you can also use hexadecimal color codes.

Note

Check the OutputAttribute section for the complete list.

The name will be displayed in the small panel that is displayed when you add an instance.

From this panel, you can change the other characteristics of the output, such as the color, thickness, and line type.

IndicatorDataSeries is a list of doubles that can be indexed like an array.

Hence, the value at each [index] in the list Result is assigned in the Calculate method as follows:

1
2
3
4
public override void Calculate(int index)
{
       Result[index] = Bars.HighPrice[index] - Bars.LowPrices[index];
}

To find the total number of elements in a series use the Count property as follows: Bars.HighPrices.Count.

If you type Bars.HighPrices in the editor followed by a period (dot), Intellisense will populate the list.

Image title

As you might have noticed, Bars.HighPrices[index] and Bars.LowPrices[index] are also indexed in the same fashion.

They are of type DataSeries which is also a list of doubles but this type is read-only (values can be retrieved but not assigned).

The Bars interface contains the following series:

  • OpenPrices
  • HighPrices
  • LowPrices
  • ClosePrices
  • MedianPrices
  • TypicalPrices
  • WeightedPrices
  • TickVolumes
  • OpenTimes

It also has SymbolName and TimeFrame properties of the relevant instance.

In other words, it will retrieve the above values of whichever symbol and Timeframe you choose when you create a new instance.

If you type Bars in the editor followed by a period (dot), Intellisense will populate the list.

Image title

Bars itself is also a collection, and you can access each bar by passing it's index, and it will return a bar object:

1
2
3
4
5
public override void Calculate(int index)
{
       var bar = Bars[index];
       Print($"{bar.Open} | {bar.High} | {bar.Low} | {bar.Close}");
}

Indicators with Parameters

In most cases, the indicators can vary according to the user input.

The Simple Moving Average is designed to accept the price source and the period for the calculation as the input parameters.

Input must be preceded by the Parameter attribute as it is shown in the code below - the Source and the Periods properties are preceded by the [Parameter()] attribute.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
    [Indicator("Simple Moving Average", IsOverlay = false, ScalePrecision = 5)]
    public class SimpleMovingAverage : Indicator
    {
        [Parameter("Price")]
        public DataSeries Source { get; set; }

        [Parameter("MA Type", DefaultValue = MovingAverageType.Exponential)]
        public MovingAverageType MaType { get; set; }

        [Parameter("MA Periods", DefaultValue = 14, MinValue = 1, MaxValue = 20)]
        public int Periods { get; set; }

        [Parameter("Message", DefaultValue = true)]
        public bool DisplayChartMessage { get; set; }

        [Output("Main", Color = Colors.Turquoise)]
        public IndicatorDataSeries Result { get; set; }

        public override void Calculate(int index)
        {
            double sum = 0;

            for (var i = index - Periods + 1; i <= index; i++)
            {
                sum += Source[i];
            }
            Result[index] = sum / Periods;
        }
    }
}

The Indicator instance panel with the parameters as set above will look as follows (click cog to open the parameters dropdown):

Image title

Like the Indicator and Output attributes discussed earlier, the [Parameter()] attribute can define certain characteristics to the input:

1
[Parameter("MA Periods", DefaultValue = 14, MinValue = 1, MaxValue = 20)]
  • The name that is displayed in the input panel of an instance (MA Periods).
  • The default value of an input which is the initial value before it can be changed by the user (DefaultValue = 14).
  • The minimum and maximum values in case of numbers (MinValue = 1, MaxValue = 20).

Note

Check the ParameterAttribute section for the complete list.

Currently, the supported types of input are:

  • DataSeries
  • int
  • double
  • string
  • bool
  • MovingAverageType
  • Enums
  • TimeFrame

If the input is a price source such as Open, High, Low or Close, then make the property a DataSeries type:

1
2
[Parameter("Price")]
public DataSeries Source { get; set; }

The default value for the DataSeries type is Closed and it cannot be set.

If you need multi option parameter use .NET enums:

1
2
3
4
5
6
7
8
9
public enum Option
{
    First,
    Second,
    Third
}

[Parameter("Option", DefaultValue = Option.Third)]
public Option SelectedOption { get; set; }

If the input needs to be a number, then int (integer) or double (decimal) can be used:

1
2
[Parameter("MA Periods", DefaultValue = 14, MinValue = 1, MaxValue = 20)]
public int Periods { get; set; }

Declare a bool for a yes/no type input. The values “Yes” and “No” correspond to “true” or “false” respectively:

1
2
[Parameter("Message", DefaultValue = true)]
public bool DisplayChartMessage { get; set; }

Nested Indicators

In certain occasions, it is necessary to use Nested indicators.

The Nested indicator is an indicator which value depends on the value of other indicators.

Such is the case with the Sample DeMarker indicator which is located in the Indicators tab by default.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
    [Indicator(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class SampleDeMarker : Indicator
    {
        [Parameter(DefaultValue = 14)]
        public int Periods { get; set; }

        [Output("DMark", Color = Colors.Turquoise)]
        public IndicatorDataSeries DMark { get; set; }

        private IndicatorDataSeries deMin;
        private IndicatorDataSeries deMax;
        private MovingAverage deMinMA;
        private MovingAverage deMaxMA;

        protected override void Initialize()
        {
            deMin = CreateDataSeries();
            deMax = CreateDataSeries();
            deMinMA = Indicators.MovingAverage(deMin, Periods, MovingAverageType.Simple);
            deMaxMA = Indicators.MovingAverage(deMax, Periods, MovingAverageType.Simple);
        }

        public override void Calculate(int index)
        {
            deMin[index] = Math.Max(Bars.LowPrices[index - 1] - Bars.LowPrices[index], 0);
            deMax[index] = Math.Max(Bars.HighPrices[index] - Bars.HighPrices[index - 1], 0);

            var min = deMinMA.Result[index];
            var max = deMaxMA.Result[index];

            DMark[index] = max / (min + max);
        }
    }

In the example above deMinMA and deMaxMA are indicators which are used for the calculation of the DeMark indicator.

Nested indicators need to be defined in the Initialize() method.

For example, deMinMA is defined as the simple moving average of the series deMin.

1
deMinMA = Indicators.MovingAverage(deMin, Periods, MovingAverageType.Simple);

deMin in its turn is defined in the Calculate method as the max of the last two Low price values.

1
deMin[index] = Math.Max(Bars.LowPrices[index - 1] - Bars.LowPrices[index], 0);

The IntelliSense will populate the list of all built-in indicators once you type Indicators. (followed by a period (dot) in the editor.

The IntelliSense also shows the list of the input parameters to the referenced indicator once the indicator has been selected from the list.

Image title

Custom Indicators

A custom indicator is any indicator you create in cTrader Automate. The Sample Indicators provided in the Indicators tab by default are custom indicators.

Follow these steps to reference a custom indicator:

1. Click Manage References to the upper left of the code editor.

Image title

2. In Indicators section of the Reference Manager pop-up check the required indicators and click Apply. Alternatively, use the advanced search to find the required indicator.

Image title

Referenced Custom Indicators are defined in the Initialize() method just like the nested built-in indicators, but the syntax is slightly different.

The name of the custom indicator should be enclosed in angle brackets following the GetIndicator directive.

The parameters of the referenced indicator follow enclosed in parenthesis just like with built-in indicators, as follows:

1
sma = Indicators.GetIndicator(Source, SmaPeriod);

Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC)]
    public class SampleReferenceSMA : Indicator
    {
        [Parameter("Source")]
        public DataSeries Source { get; set; }

        [Parameter(DefaultValue = 14)]
        public int SmaPeriod { get; set; }

        [Output("Referenced SMA Output")]
        public IndicatorDataSeries refSMA { get; set; }

        private SampleSMA sma;

        protected override void Initialize()
        {
            sma = Indicators.GetIndicator(Source, SmaPeriod);
        }

        public override void Calculate(int index)
        {
            refSMA[index] = sma.Result[index];
        }
    }

Oscillators and the Levels Attribute

The Indicators that oscillate around a constant value belong to the category of the Oscillators.

When creating Oscillators it is useful to draw a horizontal or “level” line at that constant value around which the indicator oscillates. In many cases, this value is zero.

The momentum oscillator typically oscillates around 100, so we will add a level line at that value using the Levels attribute.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    [Levels(100)]
    [Indicator("Momentum Oscillator")]
    public class MomentumOscillator : Indicator
    {
        [Parameter()]
        public DataSeries Source { get; set; }

        [Parameter(DefaultValue = 14, MinValue = 1)]
        public int Periods { get; set; }

        [Output("Main", LineColor = "Green")]
        public IndicatorDataSeries Result { get; set; }

        public override void Calculate(int index)
        {
            Result[index] = 100 * Source[index] / Source[index - Periods];
        }
    }
}

Note that the levels can only be used when the indicator is not overlayed on the chart.

That is, the property IsOverlay is not set to true in the Indicator attribute as follows: [Indicator("Momentum Oscillator", IsOverlay = false)].

This will not work. IsOverlay is false by default so if it is omitted like in the following example, the indicator will be displayed below the chart and the Levels will be displayed properly.

If multiple lines are necessary, then add a comma-separated list of the values within the parenthesis. For example:

1
[Levels(0, 50, 100)] 

1
[Levels(50.5, 50.75)] 

1
[Levels(0.001, 0.002)]

IsLastBar Property

In certain cases, we may need an indicator that requires to be calculated at the last bar.

Then, the IsLastBar property can be checked, to determine if as the name suggests, the index parameter of the Calculate method, is that of the last bar.

The following indicator displays the last open time in New York and Tokyo while the indicator is based on UTC time.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC)]
    public class TimeInDifferentParts : Indicator
    {
        public override void Calculate(int index)
        {
            if (IsLastBar)
                DisplayTime(index);
        }

        protected void DisplayTime(int index)
        {
            DateTime nyDateTime = Bars.OpenTimes[index].AddHours(-5);
            DateTime tokyoDateTime = Bars.OpenTimes[index].AddHours(7);

            string nyTime = nyDateTime.ToShortTimeString();
            string tokyoTime = tokyoDateTime.ToShortTimeString();

            Chart.DrawStaticText("Title", "Last Bar OpenTime ", StaticPosition.TopLeft, Colors.Lime);
            Chart.DrawStaticText("NY", "NY " + nyTime, StaticPosition.TopLeft, Colors.Lime);
            Chart.DrawStaticText("Tokyo", "Tokyo " + tokyoTime, StaticPosition.TopLeft, Colors.Lime);
        }
    }
}

Combining Indicators

In case you want to have many indicators displayed on the same panel that are not overlayed on the chart you may combine them in one custom indicator.

The following indicator combines the Aroon, RSI and Directional Movement System Indicators in one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
    [Indicator(IsOverlay = false, TimeZone = TimeZones.UTC, ScalePrecision = 5)]
    public class Aroon_RSI_DMS : Indicator
    {
        private Aroon aroon;
        private RelativeStrengthIndex rsi;
        private DirectionalMovementSystem dms;

        [Parameter()]
        public DataSeries Source { get; set; }

        [Parameter(DefaultValue = 14)]
        public int Periods { get; set; }

        [Output("Aroon Up", LineColor = "LightSkyBlue")]
        public IndicatorDataSeries AroonUp { get; set; }

        [Output("Aroon Down", LineColor = "Red")]
        public IndicatorDataSeries AroonDn { get; set; }

        [Output("Rsi", LineColor = "Green")]
        public IndicatorDataSeries Rsi { get; set; }

        [Output("DI Plus", LineColor = "DarkGreen")]
        public IndicatorDataSeries DmsDIPlus { get; set; }

        [Output("DI Minus", LineColor = "DarkRed")]
        public IndicatorDataSeries DmsDIMinus { get; set; }

        [Output("ADX", LineColor = "Blue")]
        public IndicatorDataSeries DmsADX { get; set; }

        protected override void Initialize()
        {
            // Initialize and create nested indicators
            aroon = Indicators.Aroon(Periods);
            rsi = Indicators.RelativeStrengthIndex(Source, Periods);
            dms = Indicators.DirectionalMovementSystem(Periods);
        }

        public override void Calculate(int index)
        {
            AroonUp[index] = aroon.Up[index];
            AroonDn[index] = aroon.Down[index];

            Rsi[index] = rsi.Result[index];

            DmsADX[index] = dms.ADX[index];
            DmsDIMinus[index] = dms.DIMinus[index];
            DmsDIPlus[index] = dms.DIPlus[index];
        }
    }

Multiple Timeframes

Example 1: Using multiple timeframes.

The following example displays a moving average on different timeframes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC)]
    public class MultiTF_MA : Indicator
    {
        [Parameter(DefaultValue = 50)]
        public int Period { get; set; }

        [Output("MA", LineColor = "Yellow")]
        public IndicatorDataSeries MA { get; set; }

        [Output("MA5", LineColor = "Orange")]
        public IndicatorDataSeries MA5 { get; set; }

        [Output("MA10", LineColor = "Red")]
        public IndicatorDataSeries MA10 { get; set; }

        private Bars bars5;
        private Bars bars10;

        private MovingAverage ma;
        private MovingAverage ma5;
        private MovingAverage ma10;

        protected override void Initialize()
        {
            bars5 = MarketData.GetBars(TimeFrame.Minute5);
            bars10 = MarketData.GetBars(TimeFrame.Minute10);

            ma = Indicators.MovingAverage(Bars.ClosePrices, Period, MovingAverageType.Triangular);
            ma5 = Indicators.MovingAverage(bars5.Close, Period, MovingAverageType.Triangular);
            ma10 = Indicators.MovingAverage(bars10.Close, Period, MovingAverageType.Triangular);
        }

        public override void Calculate(int index)
        {
            MA[index] = ma.Result[index];

            var index5 = bars5.OpenTimes.GetIndexByTime(Bars.OpenTimes[index]);
            if (index5 != -1)
                MA5[index] = ma5.Result[index5];

            var index10 = bars10.OpenTimes.GetIndexByTime(Bars.OpenTimes[index]);

            if (index10 != -1)
                MA10[index] = ma10.Result[index10];
        }
    }

Example 2: Using Multiple timeframes and Symbols.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC)]
    public class MultiSymbolMA : Indicator
    {
        private MovingAverage ma1, ma2, ma3;
        private Bars bars2, bars3;
        private Symbol symbol2, symbol3;

        [Parameter(DefaultValue = "EURCHF")]
        public string Symbol2 { get; set; }

        [Parameter(DefaultValue = "EURCAD")]
        public string Symbol3 { get; set; }

        [Parameter(DefaultValue = 14)]
        public int Period { get; set; }

        [Parameter(DefaultValue = MovingAverageType.Simple)]
        public MovingAverageType MaType { get; set; }

        [Output("MA Symbol 1", LineColor = "Magenta")]
        public IndicatorDataSeries Result1 { get; set; }

        [Output("MA Symbol 2", LineColor = "Magenta")]
        public IndicatorDataSeries Result2 { get; set; }

        [Output("MA Symbol 3", LineColor = "Magenta")]
        public IndicatorDataSeries Result3 { get; set; }

        protected override void Initialize()
        {
            symbol2 = MarketData.GetSymbol(Symbol2);
            symbol3 = MarketData.GetSymbol(Symbol3);

            bars2 = MarketData.GetBars(symbol2, TimeFrame);
            bars3 = MarketData.GetBars(symbol3, TimeFrame);

            ma1 = Indicators.MovingAverage(Bars.ClosePrices, Period, MaType);
            ma2 = Indicators.MovingAverage(bars2.ClosePrices, Period, MaType);
            ma3 = Indicators.MovingAverage(bars3.ClosePrices, Period, MaType);
        }

        public override void Calculate(int index)
        {
            ShowOutput(Symbol, Result1, ma1, Bars, index);
            ShowOutput(symbol2, Result2, ma2, bars2, index);
            ShowOutput(symbol3, Result3, ma3, bars3, index);
        }

        private void ShowOutput(Symbol symbol, IndicatorDataSeries result, MovingAverage movingAverage, Bars bars, int index)
        {
            var index2 = bars.OpenTimes.GetIndexByTime(Bars.OpenTime[index]);
            result[index] = movingAverage.Result[index2];

            string text = string.Format("{0} {1}", symbol.Code, Math.Round(result[index], symbol.Digits));
            Chart.DrawStaticText(symbol.Code, text, index, result[index], VerticalAlignment.Top, HorizontalAlignment.Right, Colors.Yellow);
        }
    }
Last update: July 1, 2022

Comments