コンテンツにスキップ

インジケーターコードサンプル

このページでは、マニュアル取引やアルゴリズム取引に使用されるテクニカルインジケーターを作成するためのPythonおよびC#のコード例をいくつか提供しています。

インジケーターサンプルリポジトリ

各種インジケータータイプやテクニカル分析ツールの実行可能なテンプレートを含む包括的なインジケーターコードサンプルは、GitHubのPythonおよびC#リポジトリで個別に利用可能です。

シンプルなインジケーター

High Minus Lowインジケーターは、現在のバーの高値と安値の差を計算し、それを出力系列として表示します。 この系列は、各バーの結果の値を結ぶ線としてチャート上に描画されます。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
[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.HighPrices[index] - Bars.LowPrices[index];
    }
}

注意

Pythonインジケーターは、.csファイルで宣言されたカスタマイズ可能なパラメーターを使用します。

1
2
3
4
5
6
7
from System import Action

class HighMinusLow():
    def calculate(self, index):
        # In Python you have to declare parameters and outputs in your algo C# file like C# algos
        # So Result here is already declared in C# file of this indicator and here we can use it
        api.Result[index] = api.Bars.HighPrices[index] - api.Bars.LowPrices[index]

[Indicator...]宣言には、以下のように定義されるいくつかのパラメーターが含まれています：

  • IsOverlay - 線がチャート上にオーバーレイされるか、別のUIパネルに表示されるかを定義するブール値。
  • TimeZone - インジケーターデータとサーバー時間のタイムゾーンを指定するTimeZonesクラスのフィールド。
  • AccessRights - インジケーターに割り当てられるアクセス権を決定するAccessRightsクラスのフィールド。
  • ScalePrecision - インジケーター出力のスケール精度を設定するint。

以前に編集したインジケーターコードで学んだように、Output属性は、プロパティをインジケーター出力としてマークするために宣言されます。 このプロパティは、他のクラスから参照できるようにpublicである必要があります。

インジケーター出力は常にIndicatorDataSeriesデータ型である必要があります。これは、配列のようにインデックス付けできるdoubleのリストです。 したがって、リストResultの各[index]の値は、Calculateメソッドで以下のように割り当てることができます。

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

1
2
def calculate(self, index):
    api.Result[index] = api.Bars.HighPrices[index] - api.Bars.LowPrices[index]

パラメーター付きインジケーター

ほとんどの場合、インジケーターの出力はユーザー入力によって異なる場合があります。 インジケーターのカスタマイズ可能なパラメーターの設定方法は、cBotで行われる方法と同様です。

以下のシンプルな移動平均インジケーターは、価格ソースと期間をカスタマイズ可能なパラメーターとして受け入れるように設計されています。 このようなパラメーター（この例ではSourceとPeriods）は、Parameter属性の前に置く必要があります。

前述の[Indicator()]および[Output()]属性と同様に、[Parameter()]属性は、ユーザー入力に適用される特定の特性を定義できます。

1
[Parameter("MA Periods", DefaultValue = 14, MinValue = 1, MaxValue = 20)]

注意

Pythonインジケーターは、.csファイルで宣言されたカスタマイズ可能なパラメーターを使用します。

上記では、以下の特性を指定しています：

  • cTrader UIでこのパラメーターを示すために表示される名前（"MA Periods"）。
  • パラメーターのデフォルト値。インスタンスをカスタマイズする際にユーザーが変更できます（DefaultValue = 14）。
  • パラメーターの最小値と最大値（MinValue = 1, MaxValue = 20）。

以下のスニペットでは、カスタマイズ可能なパラメーターをインジケーターコードに統合する方法を示しています。

 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
[Indicator(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", LineColor = "Red")]
    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;
    }
}

注意

Pythonインジケーターは、.csファイルで宣言されたカスタマイズ可能なパラメーターを使用します。

1
2
3
4
5
6
7
8
class SimpleMovingAverage():
    def calculate(self, index):
        sum = 0
        # Periods, Source and Result are declared in the C# file
        for i in range(index - api.Periods + 1, index):
            sum += api.Source[i]

        api.Result[index] = sum / api.Periods

ネストされたインジケーター

ネストされたインジケーターは、他のインジケーターによって実行される計算結果に依存するインジケーターとして定義されます。 DeMark 9インジケーターなどの特定のタイプの拡張機能を作成する際に役立ちます。 以下のサンプルコードを考えてみましょう：

 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);
    }
}

注意

Pythonインジケーターは、.csファイルで宣言されたカスタマイズ可能なパラメーターを使用します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
class SampleDeMarker():
    def initialize(self):
        self.deMin = api.CreateDataSeries()
        self.deMax = api.CreateDataSeries()
        # Periods is declared in the C# file
        self.deMinMA = api.Indicators.MovingAverage(self.deMin, api.Periods, MovingAverageType.Simple)
        self.deMaxMA = api.Indicators.MovingAverage(self.deMax, api.Periods, MovingAverageType.Simple)

    def calculate(self, index):
        self.deMin[index] = max(api.Bars.LowPrices[index - 1] - api.Bars.LowPrices[index], 0)
        self.deMax[index] = max(api.Bars.HighPrices[index] - api.Bars.HighPrices[index - 1], 0)

        minValue = self.deMinMA.Result[index]
        maxValue = self.deMaxMA.Result[index]

        # DMark Output is declared in the C# file
        api.DMark[index] = maxValue / (minValue + maxValue)

上記の例では、deMinMAとdeMaxMAは、DeMarkerインジケーターの値を計算するために使用される2つの変数です。

ネストされたインジケーターは、Initialize()メソッドで定義する必要があります。 例えば、deMinMAは、系列deMinのシンプルな移動平均として定義されます。

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

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

deMinは、Calculate()メソッドで、最後の2つの安値の最大値として定義されます。

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

1
self.deMin[index] = max(api.Bars.LowPrices[index - 1] - api.Bars.LowPrices[index], 0)

ネストされたインジケーターの作業を簡素化するために、IntelliSenseは、コードエディターにIndicatorsとドットを入力すると、すべての内蔵インジケーターのリストを自動的に表示します。 また、このリストから特定のインジケーターを選択すると、関連するすべての入力パラメーターが表示されます。

Image title

レイジーローディング

cTrader Algoは、参照されたインジケーターを使用する際にレイジーローディングを使用します。 参照されたインジケーターによって提供される値は、コードがそれらを積極的に使用し始めるまで計算されません。

参照されたインジケーターのOutputsデータにアクセスすると、cTraderは過去および将来のバーに対してそのCalculate()メソッドを呼び出すことで、インジケーターデータのロードを開始します。 それ以外の場合、参照されたインジケーターはアイドル状態のままとなり、したがってシステムリソースを消費しません。

これはまた、インジケーターにOutputがない場合や、そのパブリックプロパティのいずれかにアクセスしようとすると、該当するプロパティのデフォルト値が返されることを意味します。 この問題を解決するには、現在のインジケーターのCalculate()メソッドからカスタムインジケーターのCalculate()メソッドを呼び出します。

オシレーターとレベル属性

「オシレーター」という用語は、特定の定数変数の周りで振動するすべてのインジケーターを指します。

オシレーターを作成する際には、まずその定数値に水平または「レベル」線を描画することが有用です。その後、インジケーターはこの線の周りで振動します。 多くの場合、定数値はゼロに等しくなります。

以下の例では、モメンタムオシレーターを定義しています。 これは通常、100の値の周りで振動します。 この値にレベル線を追加するために、インジケーター属性の前に宣言されるLevels属性を使用します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
[Levels(100)]
[Indicator()]
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];
    }
}

注意

Pythonインジケーターは、.csファイルで宣言されたカスタマイズ可能なパラメーターを使用します。

1
2
3
4
class MomentumOscillator():
    def calculate(self, index):
        # Result, Source, and Periods are declared in the C# file
        api.Result[index] = 100 * api.Source[index] / api.Source[index - api.Periods]

Levels属性は、インジケーターがチャート上にオーバーレイされていない場合、つまりIsOverlayプロパティがtrueに設定されていない場合にのみ使用できることに注意してください。 デフォルトでは、IsOverlayの値はfalseです。 この属性がコードから省略されている場合、Levelsは正しく動作するはずです。

複数の「レベル」線を設定する必要がある場合は、以下のように括弧内にカンマ区切りの値リストを追加します。

1
[Levels(0, 50, 100)] 

1
[Levels(50.5, 50.75)] 

1
[Levels(0.001, 0.002)]

Pythonインジケーターのレベル

Pythonでは、C#インジケーターと同じように、インジケーターC#ファイルでレベルを宣言します。

IsLastBarプロパティ

場合によっては、取引チャートの最後のバーに対してのみ計算される必要があるインジケーターを作成したいことがあります。 これを簡素化するために、IsLastBarプロパティを使用して、Calculate()メソッドのインデックスパラメーターが最後のバーのものであるかどうかを確認できます。

以下のインジケーターはUTC時間に基づいていますが、ニューヨークと東京の最後のオープン時間を表示できます。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
[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)
    {
        var nyDateTime = Bars.OpenTimes[index].AddHours(-5);
        var tokyoDateTime = Bars.OpenTimes[index].AddHours(7);

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

        Chart.DrawStaticText("Title", "Last Bar OpenTime \n NY " + nyTime + "\n" + "Tokyo " + tokyoTime, VerticalAlignment.Top, HorizontalAlignment.Left, Color.Lime);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
class TimeInDifferentParts():
    def calculate(self, index):
        if api.IsLastBar:
            self.display_time(index)

    def display_time(self, index):
        nyDateTime = api.Bars.OpenTimes[index].AddHours(-5)
        tokyoDateTime = api.Bars.OpenTimes[index].AddHours(7)

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

        api.Chart.DrawStaticText("Title", f"Last Bar OpenTime\nNY {nyTime}\nTokyo {tokyoTime}", VerticalAlignment.Top, HorizontalAlignment.Left, Color.Lime)

インジケーターの結合

cTraderでは、同じパネル内または同じチャート内で複数のインジケーターを結合することができます。

以下のインジケーターは、Aroon、RSI、Directional Movement Systemインジケーターを1つに結合しています。

 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];
    }
}

注意

Pythonインジケーターは、.csファイルで宣言されたカスタマイズ可能なパラメーターを使用します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
class Aroon_RSI_DMS():
    def initialize(self):
        # Initialize and create nested indicators
        # Periods and Source parameters are declared in the C# file
        self.aroon = api.Indicators.Aroon(Periods)
        self.rsi = api.Indicators.RelativeStrengthIndex(Source, Periods)
        self.dms = api.Indicators.DirectionalMovementSystem(Periods)

    def calculate(self, index):
        # AroonUp, AroonDn, Rsi, DmsADX, DmsDIMinus, and DmsDIPlus
        # outputs are declared in the C# file
        api.AroonUp[index] = self.aroon.Up[index]
        api.AroonDn[index] = self.aroon.Down[index]

        api.Rsi[index] = self.rsi.Result[index]

        api.DmsADX[index] = self.dms.ADX[index]
        api.DmsDIMinus[index] = self.dms.DIMinus[index]
        api.DmsDIPlus[index] = self.dms.DIPlus[index]

複数のタイムフレーム

  • 複数のタイムフレームの使用

    以下の例では、異なる時間枠でのMoving Averageインジケーターを表示しています。

     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.ClosePrices, Period, MovingAverageType.Triangular);
        ma10 = Indicators.MovingAverage(bars10.ClosePrices, 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];
    }
}

    注意

    Pythonインジケーターは、.csファイルで宣言されたカスタマイズ可能なパラメーターを使用します。

     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
    class MultiTF_MA():
    def initialize(self):
        self.bars5 = api.MarketData.GetBars(TimeFrame.Minute5)
        self.bars10 = api.MarketData.GetBars(TimeFrame.Minute10)

        # Period is declared as a parameter in the C# file 
        # We use indicator time frame bars for this moving average
        self.ma = Indicators.MovingAverage(api.Bars.ClosePrices, api.Period, MovingAverageType.Triangular)

        # We use other two time frame bars that we created previously
        # for these two moving averages
        self.ma5 = Indicators.MovingAverage(self.bars5.ClosePrices, api.Period, MovingAverageType.Triangular)
        self.ma10 = Indicators.MovingAverage(self.bars10.ClosePrices, api.Period, MovingAverageType.Triangular)

    def calculate(self, index):
        # MA, MA5, and MA10 are outputs we declared in the C# file
        api.MA[index] = self.ma.Result[index]

        index5 = self.bars5.OpenTimes.GetIndexByTime(api.Bars.OpenTimes[index])

        if index5 > -1:
            api.MA5[index] = self.ma5.Result[index5]

        index10 = self.bars10.OpenTimes.GetIndexByTime(api.Bars.OpenTimes[index])

        if index10 > -1:
            api.MA10[index] = self.ma10.Result[index10]

  • 複数のタイムフレームとシンボルの使用

    以下の例では、複数の時間枠とシンボルでのMoving Averageインジケーターを表示しています。

     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 = Symbols.GetSymbol(Symbol2);
        symbol3 = Symbols.GetSymbol(Symbol3);

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

        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.OpenTimes[index]);
        result[index] = movingAverage.Result[index2];

        string text = string.Format("{0} {1}", symbol.Name, Math.Round(result[index], symbol.Digits));
        Chart.DrawStaticText(symbol.Name, text, VerticalAlignment.Top, HorizontalAlignment.Right, Color.Yellow);
    }
}

    注意

    Pythonインジケーターは、.csファイルで宣言されたカスタマイズ可能なパラメーターを使用します。

     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
    class MultiSymbolMA():
    def initialize(self):
        # Symbol2 and Symbol3 are declared as parameters in the C# file
        self.symbol2 = api.Symbols.GetSymbol(api.Symbol2)
        self.symbol3 = api.Symbols.GetSymbol(api.Symbol3)

        self.bars2 = api.MarketData.GetBars(api.TimeFrame, self.symbol2.Name)
        self.bars3 = api.MarketData.GetBars(api.TimeFrame, self.symbol3.Name)

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

    def calculate(self, index):
        # Result1, Result2, and Result3 are declared as outputs in the C# file
        self.show_output(api.Symbol, api.Result1, self.ma1, api.Bars, index)
        self.show_output(self.symbol2, api.Result2, self.ma2, self.bars2, index)
        self.show_output(self.symbol3, api.Result3, self.ma3, self.bars3, index)

    def show_output(self, symbol, result, movingAverage, bars, index):
        index2 = bars.OpenTimes.GetIndexByTime(api.Bars.OpenTimes[index])

        result[index] = movingAverage.Result[index2]

        text = f"{symbol.Name} {round(result[index], symbol.Digits)}"

        api.Chart.DrawStaticText(symbol.Name, text, VerticalAlignment.Top, HorizontalAlignment.Right, Color.Yellow)

Image title