Crear un indicador técnico en cTrader

Este artículo describe los pasos para crear indicadores técnicos personalizados, incluyendo herramientas para operaciones con algoritmos o acciones manuales en cTrader.

En la pestaña Indicadores de la aplicación Algo, haga clic en el botón Nuevo para abrir el asistente de creación de algoritmos.

WindowsMac

Introduzca un nombre para su indicador, luego seleccione un lenguaje de programación entre C# y Python.

WindowsMac

Elija un método de creación entre:

• Desde cero – el nuevo indicador contendrá solo una plantilla básica.

• Usando una plantilla – podrá seleccionar un algoritmo prediseñado de una lista de plantillas de Python# o C#, que cubren una amplia gama de tipos de indicadores, herramientas de análisis técnico y más.

WindowsMac

Después de hacer clic en Crear, se abre el editor de código y puede comenzar a editar el código del indicador.

WindowsMac

Editar el código

Dependiendo de su método de creación, la muestra de código del indicador debe contener uno o más de los siguientes 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 y compilar

WindowsMac

Guarde su código haciendo clic en el botón Guardar en la parte superior del editor de código o utilice el atajo Ctrl+S.

Antes de poder usar su indicador, necesita validar su código compilando el proyecto del indicador. Haga clic en el botón Compilar en la parte superior del editor de código o pulse Ctrl+B.

Guarde su código haciendo clic en el icono Guardar en la parte superior del editor de código o utilice el atajo Cmd+S.

Antes de poder usar su indicador, necesita validar su código compilando el proyecto del indicador. Haga clic en el icono Compilar en la parte superior del editor de código o pulse Cmd+B.

Cuando la compilación tiene éxito, verá un mensaje de confirmación en Resultado de la compilación. Si la compilación falla, aparecerá en su lugar un resumen de todos los errores encontrados.

Si hay cambios en el código desde la última compilación, aparecerá un asterisco junto al icono Compilar. En este caso, debe compilar el indicador nuevamente antes de agregar una instancia del mismo a cualquier gráfico.

Para usar o mostrar el indicador en un gráfico, agregue una instancia del mismo, o puede continuar modificando el código del indicador como se explica en las secciones.

Usar aritmética NaN

Los indicadores realizan cálculos para generar visualizaciones específicas, y es esencial que su código maneje correctamente los casos extremos y las condiciones límite durante estos cálculos.

Considere el siguiente fragmento de un indicador que genera un oscilador de precio sin tendencia:

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

El código anterior define reglas de cálculo generales pero omite las condiciones límite. Por ejemplo, si Periods se establece en 10 y index cae dentro del rango 0–9, el cálculo devolverá NaN (Not a Number). Este problema ocurre porque el indicador no puede calcular valores para un gráfico de barras con un índice negativo.

Para abordar el problema, puede agregar una condición como se muestra a continuación:

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

El código para el promedio móvil simple también debe verificar que index >= Periods. Si utiliza un indicador anidado, como otro tipo de promedio móvil, la condición será diferente para tener en cuenta cálculos adicionales.

Aunque puede definir condiciones límite explícitas, C# ofrece una forma conveniente de evitar estos problemas mediante la aritmética NaN. Específicamente, el tipo de datos double admite completamente los cálculos NaN. Por ejemplo:

1
2
3
4
5

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

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

Sin embargo, cuando cualquier operando en un cálculo es NaN, el resultado también será NaN. Como los indicadores personalizados de cTrader operan con el tipo DataSeries, si intenta acceder a un elemento DataSeries con un índice negativo, devolverá NaN, y el valor no se dibujará en el gráfico de operaciones. Este comportamiento permite que el indicador continúe operando sin lanzar excepciones. En la mayoría de los casos, puede ignorar de manera segura las condiciones límite y centrarse solo en la lógica de cálculo general.

Agregar comprobaciones explícitas

Aunque la aritmética NaN simplifica el manejo de condiciones límite, algunos casos aún requieren comprobaciones NaN explícitas. Los indicadores recursivos son un ejemplo común. Un indicador recursivo calcula su valor actual basándose en el valor calculado previamente.

Considere la siguiente implementación de un promedio móvil 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);
    }
}

Cuando el indicador calcula el primer período, el valor inicial debe establecerse explícitamente en un tipo no NaN. De lo contrario, todos los cálculos posteriores devolverán NaN, haciendo que el indicador sea inútil.

En el código anterior, esto se maneja con el método double.IsNaN(previousValue). El operador == no se puede usar para esta comprobación (previousValue == double.NaN) porque cualquier comparación de NaN con otro valor, incluido él mismo, siempre se evalúa como false.

Cuando esté satisfecho con el código del indicador, compílelo, luego úselo agregando una instancia a un gráfico.