Grid cBot¶

Descripción general de la estrategia ¶

Grid cBot implementa una estrategia de operaciones en cuadrícula donde se colocan múltiples órdenes de compra o venta de un símbolo a intervalos regulares de precio o "pasos", formando una "cuadrícula" de posiciones. A medida que cambia el precio del símbolo, se abren constantemente nuevas posiciones para aprovechar las fluctuaciones.

Grid cBot utiliza una combinación de comprobaciones aritméticas y lógicas simples para abrir posiciones, calcular beneficios y gestionar sus operaciones de negociación. Es más efectivo en mercados laterales o con rangos definidos. También funciona bien en condiciones de baja volatilidad y mercados con niveles conocidos de resistencia y soporte.

Creación de cBot ¶

Aprenda cómo crear cBots, usando C# o Python, en nuestras guías paso a paso.

El código de Grid cBot está disponible en nuestros repositorios públicos de C# y Python. El mismo código se proporciona como plantilla en el asistente de creación de algoritmos en cTrader Windows o Mac, o simplemente puede copiar y usar el fragmento a continuación:

 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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class Grid : Robot
    {
        [Parameter("Volume (lots)", DefaultValue = 0.01, MinValue = 0.01, Step = 0.01)]
        public double VolumeInLots { get; set; }

        [Parameter("Trade Side")]
        public TradeType TradeType { get; set; }

        [Parameter("Step (pips)", DefaultValue = 5, MinValue = 0.1, Step = 0.1)]
        public double StepPips { get; set; }

        [Parameter("Target Profit", DefaultValue = 20)]
        public double TargetProfit { get; set; }

        private bool enoughMoney = true;

        protected override void OnStart()
        {
            if (GridPositions.Length == 0)
                OpenPosition();
        }

        protected override void OnTick()
        {
            if (GridPositions.Sum(p => p.NetProfit) >= TargetProfit)
            {
                Print("Target profit is reached. Closing all grid positions");
                CloseGridPositions();
                Print("All grid positions are closed. Stopping cBot");
                Stop();
            }
            if (GridPositions.Length > 0 && enoughMoney)
            {
                var lastGridPosition = GridPositions.OrderBy(p => p.Pips).Last();
                var distance = CalculateDistanceInPips(lastGridPosition);

                if (distance >= StepPips)
                    OpenPosition();
            }
        }

        private Position[] GridPositions
        {
            get
            {
                return Positions
                    .Where(p => p.SymbolName == SymbolName && p.TradeType == TradeType)
                    .ToArray();
            }
        }

        private double CalculateDistanceInPips(Position position)
        {
            if (position.TradeType == TradeType.Buy)
                return (position.EntryPrice - Symbol.Ask) / Symbol.PipSize;
            else
                return (Symbol.Bid - position.EntryPrice) / Symbol.PipSize;
        }

        private void OpenPosition()
        {
            var result = ExecuteMarketOrder(TradeType, SymbolName, Symbol.QuantityToVolumeInUnits(VolumeInLots), "Grid");
            if (result.Error == ErrorCode.NoMoney)
            {
                enoughMoney = false;
                Print("Not enough money to open additional positions");
            }
        }

        private void CloseGridPositions()
        {
            while (GridPositions.Length > 0)
            {
                foreach (var position in GridPositions)
                {
                    ClosePosition(position);
                }
            }
        }
    }
}

 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

import clr

clr.AddReference("cAlgo.API")

# Import cAlgo API types
from cAlgo.API import *

# Import trading wrapper functions
from robot_wrapper import *

class GridSample():
    def on_start(self):
        self.volumeInUnits = api.Symbol.QuantityToVolumeInUnits(api.VolumeInLots)
        self.enoughMoney = True
        if len(self.get_grid_positions()) == 0:
            self.open_position()

    def on_tick(self):
        grid_positions = self.get_grid_positions()
        net_profit_sum = sum([p.NetProfit for p in grid_positions])
        if net_profit_sum >= api.TargetProfit:
            api.Print("Target profit is reached. Closing all grid positions")
            self.close_grid_positions()
            api.Print("All grid positions are closed. Stopping cBot")
            api.Stop()

        if len(grid_positions) > 0 and self.enoughMoney == True:
            position_with_highest_pips = sorted(grid_positions, key=lambda pos: pos.Pips, reverse=True)[0]
            distance = self.get_distance_in_pips(position_with_highest_pips)          
            if distance >= api.StepPips:
                self.open_position()

    def get_grid_positions(self):
        return [pos for pos in api.Positions if pos.SymbolName == api.SymbolName and pos.TradeType == api.TradeType]

    def open_position(self):
        result = api.ExecuteMarketOrder(api.TradeType, api.SymbolName, self.volumeInUnits, "Grid")
        if result.Error == ErrorCode.NoMoney:
            self.enoughMoney = False
            api.Print("Not enough money to open additional positions")

    def close_grid_positions(self):
        for position in self.get_grid_positions():
            position.Close()

        if len(self.get_grid_positions()) > 0:
            self.close_grid_positions()

    def get_distance_in_pips(self, position):
        return (position.EntryPrice - api.Symbol.Ask if position.TradeType == TradeType.Buy else api.Symbol.Bid - position.EntryPrice) / api.Symbol.PipSize

Integración de indicadores ¶

Grid cBot no depende de ningún indicador para definir su estrategia de cuadrícula; no intenta predecir si el precio de un símbolo subirá o bajará. En su lugar, busca operaciones rentables a partir de movimientos de precio en cualquier dirección.

El cBot ejecuta operaciones basándose en esta simple regla: Si el precio del símbolo se mueve más allá de un número específico de pips (definido por el parámetro StepPips), el cBot abre una nueva posición.

Cálculo y lógica ¶

Ejecución inicial de operaciones ¶

Cuando el cBot se inicia, comprueba si hay posiciones abiertas en la cuadrícula. Si no hay posiciones abiertas, el cBot abre la primera posición inmediatamente a través del método OpenPosition(). Este primer paso asegura que la cuadrícula comience con una operación inicial basada en el lado de operación especificado (TradeType).

Monitorización del beneficio ¶

En cada tick (por ejemplo, cada actualización de precio), el cBot comprueba si el beneficio neto acumulado de todas las posiciones abiertas de la cuadrícula alcanza o supera el beneficio objetivo especificado (TargetProfit). Si se ha alcanzado el beneficio objetivo, se cierran todas las posiciones abiertas y el cBot deja de ejecutarse.

El beneficio objetivo es la suma del beneficio neto de cada posición en la cuadrícula.

\(n\) – número de posiciones abiertas en la cuadrícula

\(\text{NetProfit}(p_i)\) – beneficio neto de la posición \(i\)

Apertura de posiciones ¶

Si no se ha alcanzado el beneficio objetivo y hay posiciones abiertas, el cBot calcula la distancia (en pips) entre la última posición abierta de la cuadrícula y el precio actual del mercado.

Para posiciones de compra:

Para posiciones de venta:

\(D_b\) – distancia en pips entre el precio de entrada y el precio de demanda actual.

\(D_s\) – distancia en pips entre el precio de oferta actual y el precio de entrada.

\(P_e\) – precio al que se abrió la última posición de compra para el símbolo.

\(P_a\) – precio de demanda actual para el símbolo.

\(P_b\) – precio de oferta actual para el símbolo.

\(S\) – valor de un pip para el símbolo.

Si la distancia calculada es mayor o igual que el tamaño del paso definido (StepPips), se abre una nueva posición utilizando el método OpenPosition().

Cada vez antes de abrir una nueva posición, el cBot comprueba y confirma que hay fondos suficientes para la operación. Si los fondos son insuficientes, el cBot deja de intentar abrir nuevas posiciones y registra el mensaje "No hay suficiente dinero para abrir posiciones adicionales".

Cierre de posiciones ¶

Una vez que se alcanza el TargetProfit, el cBot registra el mensaje "Se ha alcanzado el beneficio objetivo. Cerrando todas las posiciones de la cuadrícula".

El método CloseGridPositions() entonces recorre todas las posiciones abiertas en la cuadrícula, las cierra y luego el cBot registra el mensaje "Se han cerrado todas las posiciones de la cuadrícula. Deteniendo el cBot". El cBot se detiene entonces.

Parámetros ¶

Aplicación ¶

Mercados laterales o de rango ¶

Grid cBot es más efectivo en mercados con rango definido donde el precio oscila entre niveles de soporte y resistencia. En estos mercados, como los precios se mueven frecuentemente hacia arriba y abajo dentro de un rango definido, el cBot abre posiciones regularmente y capitaliza las fluctuaciones.

Mercados de baja volatilidad ¶

En mercados de baja volatilidad, los movimientos de precio tienden a ser lentos y menos pronunciados. A medida que el precio se mueve gradualmente, Grid cBot tiene tiempo suficiente para abrir múltiples posiciones sin enfrentarse al riesgo de movimientos de mercado grandes y rápidos.

Mercados con niveles conocidos ¶

Grid cBot puede funcionar bien en mercados con niveles de soporte y resistencia fuertes y bien definidos. Esos niveles actúan como barreras de precio y hacen que el mercado rebote frecuentemente, resultando en un rango que el cBot puede explotar.

Mercados no direccionales ¶

Ciertos pares de divisas exhiben un movimiento no direccional con frecuentes fluctuaciones de precio, pero su precio no muestra una fuerte tendencia a largo plazo. Grid cBot funciona bien en tales mercados porque puede capturar fluctuaciones frecuentes sin el riesgo de quedar atrapado en una tendencia a largo plazo.

Resumen ¶

Grid cBot opera bajo la suposición de que durante los mercados alcistas y bajistas, habrá retrocesos o retrocesos. Compra bajo y vende alto en mercados alcistas y vende alto y compra bajo en mercados bajistas; el cBot captura beneficios cuando el mercado reanuda la tendencia principal después de los retrocesos.

Dado que el cBot no utiliza indicadores, no puede evaluar si el mercado está en tendencia o en rango. Simplemente abre posiciones basándose únicamente en el movimiento del precio, ignorando el sentimiento del mercado o la fuerza de la tendencia.

La ausencia de indicadores hace que el proceso de operación sea puramente mecánico; el cBot se basa únicamente en reglas predefinidas para abrir posiciones a intervalos regulares. Si bien este enfoque puede ser rentable en mercados limitados por rangos, tiende a sufrir en mercados con tendencia, altamente volátiles o que cambian rápidamente.

Además de configurar el cBot para aplicar sus estrategias personales, los operadores pueden considerar introducir indicadores para filtrar operaciones basadas en las condiciones del mercado:

• Las Moving Averages (MA) pueden ayudar a identificar la tendencia del mercado, permitiendo que el cBot opere solo en la dirección de la tendencia.
• El Relative Strength Index (RSI) puede señalar condiciones de sobrecompra o sobreventa, ayudando al cBot a evitar abrir nuevas posiciones cuando el mercado está estirado en una dirección.
• Las Bollinger Bands pueden proporcionar información sobre la volatilidad del precio, permitiendo que el cBot ajuste el espaciado de la cuadrícula o se abstenga de operar durante períodos de alta volatilidad.