Criar um indicador técnico no cTrader

Este artigo descreve os passos para criar indicadores técnicos personalizados, incluindo ferramentas para negociação algorítmica ou ações manuais no cTrader.

No separador Indicadores da aplicação Algo, clique no botão Novo para abrir o assistente de criação de algoritmos.

WindowsMac

Introduza um nome para o seu indicador e, em seguida, selecione uma linguagem de programação entre C# e Python.

WindowsMac

Elija un método de creación entre:

• Do zero – o novo indicador irá conter apenas um modelo básico.

• Utilizando um modelo – poderá selecionar um algoritmo pré-concebido a partir de uma lista de modelos Python# ou C#, abrangendo uma vasta gama de tipos de indicadores, ferramentas de análise técnica e muito mais.

WindowsMac

Depois de clicar em Criar, o editor de código abre e pode começar a editar o código do indicador.

WindowsMac

Edite el código

Dependendo do seu método de criação, a amostra de código do indicador deve conter um ou mais dos seguintes elementos:

 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

[Indicator(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
public class SimpleIndicator : Indicator
{
    [Parameter(DefaultValue = "Hello world!")]
    public string Message { get; set; }

    [Output("Main")]
    public IndicatorDataSeries Result { get; set; }

    protected override void Initialize()
    {
    // Called once when the indicator is launched
    // Initialise variables, nested indicators or series

        Print(Message);
    }

    public override void Calculate(int index)
    {
    // Called automatically on each historical bar
    // Also called in real-time on each tick
    // Place the indicator formula and logic here
    }

    // === Custom Methods ===
    // Add helper methods below to structure your indicator logic

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class SimpleIndicator:
    def initialize(self):
        # Called once when the indicator is launched
        # Initialise variables, nested indicators or series
        api.Print(api.Message)

    def calculate(self, index):
        # Called automatically on each historical bar
        # Also called in real-time on each tick
        # Place the indicator formula and logic here
        api.Result[index] = 100 # Example calculation

    # === Custom Methods ===
    # Add helper methods below to structure your indicator logic

Guardar e compilar

WindowsMac

Guarde o seu código clicando no botão Guardar na parte superior do editor de código ou utilize o atalho Ctrl+S.

Antes de poder utilizar o seu indicador, precisa de validar o seu código compilando o projeto do indicador. Clique no botão Compilar na parte superior do editor de código ou prima Ctrl+B.

Guarde o seu código clicando no ícone Guardar na parte superior do editor de código ou utilize o atalho Cmd+S.

Antes de poder utilizar o seu indicador, precisa de validar o seu código compilando o projeto do indicador. Clique no ícone Compilar na parte superior do editor de código ou prima Cmd+B.

Quando a compilação é bem-sucedida, verá uma mensagem de confirmação em Resultado da compilação. Se a compilação falhar, aparece um resumo de todos os erros encontrados.

Se houver alterações no código desde a última compilação, aparece um asterisco junto ao ícone Compilar. Neste caso, deve compilar o indicador novamente antes de adicionar uma instância do mesmo a qualquer gráfico.

Para utilizar ou apresentar o indicador num gráfico, adicione uma instância do mesmo, ou pode continuar a modificar o código do indicador conforme explicado nas secções.

Utilizar aritmética NaN

Os indicadores realizam cálculos para produzir visuais específicos, e é essencial que o seu código lide corretamente com casos extremos e condições de limite durante estes cálculos.

Considere o seguinte excerto de um indicador que produz um oscilador de preço sem tendência:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

private MovingAverage movingAverage;

protected override void Initialize()
{
    movingAverage = Indicators.SimpleMovingAverage(Source, Periods);
}

public override void Calculate(int index)
{
    Result[index] = Source[index] - movingAverage.Result[index - Periods / 2 - 1];
}

O código acima define regras gerais de cálculo, mas omite condições de limite. Por exemplo, se Periods for definido como 10 e index estiver no intervalo 0–9, o cálculo retornará NaN (Not a Number). Este problema ocorre porque o indicador não pode calcular valores para um gráfico de barras com um índice negativo.

Para resolver o problema, pode adicionar uma condição como mostrado abaixo:

1
2
3
4
5
6
7

public override void Calculate(int index)
{
    if (index >= Periods + Periods / 2 + 1)
    {
        Result[index] = Source[index] - movingAverage.Result[index - Periods / 2 - 1];
    }
}

O código para a média móvel simples também deve verificar se index >= Periods. Se utilizar um indicador aninhado, como outro tipo de média móvel, a condição será diferente para ter em conta cálculos adicionais.

Embora possa definir condições de limite explícitas, o C# oferece uma forma conveniente de evitar estes problemas através da aritmética NaN. Especificamente, o tipo de dados double suporta totalmente cálculos NaN. Por exemplo:

1
2
3
4
5

double result = double.NaN + 1.4; 
// result will be NaN

bool isNaN = double.IsNaN(result); 
// isNaN will be true

No entanto, quando qualquer operando num cálculo é NaN, o resultado também será NaN. Como os indicadores personalizados do cTrader operam no tipo DataSeries, se tentar aceder a um elemento DataSeries com um índice negativo, ele retornará NaN, e o valor não será desenhado no gráfico de negociação. Este comportamento permite que o indicador continue a funcionar sem lançar exceções. Na maioria dos casos, pode ignorar com segurança as condições de limite e focar-se apenas na lógica geral de cálculo.

Adicionar verificações explícitas

Embora a aritmética NaN simplifique o tratamento de condições de limite, alguns casos ainda requerem verificações NaN explícitas. Os indicadores recursivos são um exemplo comum. Um indicador recursivo calcula o seu valor atual com base no valor previamente calculado.

Considere a seguinte implementação de uma média móvel exponencial:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public override void Calculate(int index)
{
    var previousValue = Result[index - 1];

    if (double.IsNaN(previousValue))
    {
        Result[index] = Source[index];
    }
    else
    {
        Result[index] = Source[index] * _exp + previousValue * (1 - _exp);
    }
}

Quando o indicador calcula o primeiro período, o valor inicial deve ser explicitamente definido como um tipo não-NaN. Caso contrário, todos os cálculos subsequentes retornarão NaN, tornando o indicador inútil.

No código acima, isto é tratado com o método double.IsNaN(previousValue). O operador == não pode ser usado para esta verificação (previousValue == double.NaN) porque qualquer comparação de NaN com outro valor, incluindo ele próprio, sempre avalia como false.

Quando estiver satisfeito com o código do indicador, compile-o e depois use-o adicionando uma instância a um gráfico.