Basé sur une stratégie de trading en grille dynamique


Date de création: 2024-01-23 10:53:05 Dernière modification: 2024-01-23 10:53:05
Copier: 0 Nombre de clics: 832
avatar of ChaoZhang ChaoZhang
1
Suivre
1617
Abonnés

Basé sur une stratégie de trading en grille dynamique

Aperçu

Cette stratégie permet de réaliser des transactions de grille en plaçant plusieurs ordres de vente et d’achat parallèles dans une fourchette de prix, en ajustant la fourchette et les lignes en fonction des fluctuations du marché, pour réaliser des gains.

Principe de stratégie

  1. La limite supérieure et inférieure de la grille peut être définie manuellement ou calculée automatiquement en fonction des hauts et bas des prix de la période la plus récente.
  2. Calculer la largeur de la grille en fonction du nombre de grilles mises en place.
  3. Générer un nombre correspondant d’arrangements de prix de lignes de grille.
  4. Quand le prix est inférieur à une ligne de grille, il est ouvert sous cette ligne; quand le prix est supérieur à une ligne de grille, il est ouvert en blanc au-dessus de cette ligne.
  5. Adapter dynamiquement les prix des bornes supérieures et inférieures de la grille, de la largeur des espaces et des lignes de la grille pour les adapter aux changements du marché.

Analyse des avantages

  1. Il est possible d’obtenir des bénéfices stables sur les marchés horizontaux et fluctuants, sans être affecté par des actions unilatérales.
  2. La prise en charge des réglages manuels permet également de calculer automatiquement la distance entre les grilles, ce qui est très adapté.
  3. Les revenus peuvent être optimisés en ajustant le nombre de grilles, la largeur de la grille et le nombre de commandes.
  4. Le contrôle de position intégré permet de contrôler les risques.
  5. Prise en charge de l’ajustement dynamique de la portée de la grille pour une plus grande adaptabilité des stratégies.

Analyse des risques

  1. Il est possible que les pertes soient plus importantes lorsque la tendance est forte.
  2. Le nombre de grilles et les positions incorrectes peuvent augmenter le risque.
  3. Le calcul automatique de l’intervalle de grille peut ne pas fonctionner dans des cas extrêmes.

Les solutions au risque:

  1. Optimiser les paramètres de la grille et contrôler strictement la position totale.
  2. Il est important d’éviter de faire des erreurs et d’arrêter la stratégie avant qu’il ne se produise quelque chose de grave.
  3. Il est possible d’utiliser des indicateurs de tendance pour évaluer la situation et, le cas échéant, pour arrêter la stratégie.

Direction d’optimisation

  1. Choisir le nombre de grilles optimal en fonction des caractéristiques du marché et de la taille des fonds.
  2. Test des paramètres de calcul automatique de la grille d’optimisation pour différentes périodes de temps.
  3. Optimiser le calcul du nombre de missions pour obtenir des revenus plus stables.
  4. Les conditions de clôture de la stratégie sont définies en combinaison avec d’autres indicateurs permettant de juger de l’ampleur de la situation.

Résumer

Cette stratégie de négociation de grille dynamique permet de réaliser des bénéfices dans les plates-formes horizontales et les plates-formes environnantes en ajustant dynamiquement les paramètres de la grille intermédiaire pour s’adapter aux changements du marché. Le contrôle de position approprié permet de contrôler les risques. La stabilité de la stratégie peut être encore améliorée en optimisant les paramètres de la grille et en combinant des indicateurs de jugement de tendance.

Code source de la stratégie 
/*backtest
start: 2023-12-23 00:00:00
end: 2024-01-22 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("sarasa srinivasa kumar", overlay=true, pyramiding=14, close_entries_rule="ANY", default_qty_type=strategy.cash, initial_capital=100.0, currency="USD", commission_type=strategy.commission.percent, commission_value=0.1)
i_autoBounds    = input(group="Grid Bounds", title="Use Auto Bounds?", defval=true, type=input.bool)                             // calculate upper and lower bound of the grid automatically? This will theorhetically be less profitable, but will certainly require less attention
i_boundSrc      = input(group="Grid Bounds", title="(Auto) Bound Source", defval="Hi & Low", options=["Hi & Low", "Average"])     // should bounds of the auto grid be calculated from recent High & Low, or from a Simple Moving Average
i_boundLookback = input(group="Grid Bounds", title="(Auto) Bound Lookback", defval=250, type=input.integer, maxval=500, minval=0) // when calculating auto grid bounds, how far back should we look for a High & Low, or what should the length be of our sma
i_boundDev      = input(group="Grid Bounds", title="(Auto) Bound Deviation", defval=0.10, type=input.float, maxval=1, minval=-1)  // if sourcing auto bounds from High & Low, this percentage will (positive) widen or (negative) narrow the bound limits. If sourcing from Average, this is the deviation (up and down) from the sma, and CANNOT be negative.
i_upperBound    = input(group="Grid Bounds", title="(Auto) Upper Boundry", defval=0.285, type=input.float)                      // for manual grid bounds only. The upperbound price of your grid
i_lowerBound    = input(group="Grid Bounds", title="(Auto) Lower Boundry", defval=0.225, type=input.float)                      // for manual grid bounds only. The lowerbound price of your grid.
i_gridQty       = input(group="Grid Lines",  title="Grid Line Quantity", defval=8, maxval=15, minval=3, type=input.integer)       // how many grid lines are in your grid

f_getGridBounds(_bs, _bl, _bd, _up) =>
    if _bs == "Hi & Low"
        _up ? highest(close, _bl) * (1 + _bd) : lowest(close, _bl)  * (1 - _bd)
    else
        avg = sma(close, _bl)
        _up ? avg * (1 + _bd) : avg * (1 - _bd)

f_buildGrid(_lb, _gw, _gq) =>
    gridArr = array.new_float(0)
    for i=0 to _gq-1
        array.push(gridArr, _lb+(_gw*i))
    gridArr

f_getNearGridLines(_gridArr, _price) =>
    arr = array.new_int(3)
    for i = 0 to array.size(_gridArr)-1
        if array.get(_gridArr, i) > _price
            array.set(arr, 0, i == array.size(_gridArr)-1 ? i : i+1)
            array.set(arr, 1, i == 0 ? i : i-1)
            break
    arr

var upperBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true) : i_upperBound  // upperbound of our grid
var lowerBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false) : i_lowerBound // lowerbound of our grid
var gridWidth       = (upperBound - lowerBound)/(i_gridQty-1)                                                       // space between lines in our grid
var gridLineArr     = f_buildGrid(lowerBound, gridWidth, i_gridQty)                                                 // an array of prices that correspond to our grid lines
var orderArr        = array.new_bool(i_gridQty, false)                                                              // a boolean array that indicates if there is an open order corresponding to each grid line

var closeLineArr    = f_getNearGridLines(gridLineArr, close)                                                        // for plotting purposes - an array of 2 indices that correspond to grid lines near price
var nearTopGridLine = array.get(closeLineArr, 0)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line above current price
var nearBotGridLine = array.get(closeLineArr, 1)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line below current price
strategy.initial_capital = 50000
for i = 0 to (array.size(gridLineArr) - 1)
    if close < array.get(gridLineArr, i) and not array.get(orderArr, i) and i < (array.size(gridLineArr) - 1)
        buyId = i
        array.set(orderArr, buyId, true)
        strategy.entry(id=tostring(buyId), long=true, qty=(strategy.initial_capital/(i_gridQty-1))/close, comment="#"+tostring(buyId))
    if close > array.get(gridLineArr, i) and i != 0
        if array.get(orderArr, i-1)
            sellId = i-1
            array.set(orderArr, sellId, false)
            strategy.close(id=tostring(sellId), comment="#"+tostring(sellId))

if i_autoBounds
    upperBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true)
    lowerBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false)
    gridWidth   := (upperBound - lowerBound)/(i_gridQty-1)
    gridLineArr := f_buildGrid(lowerBound, gridWidth, i_gridQty)

closeLineArr    := f_getNearGridLines(gridLineArr, close)
nearTopGridLine := array.get(closeLineArr, 0)
nearBotGridLine := array.get(closeLineArr, 1)
Forums
PINE Language FAQ Summary MyLanguage Web3 About Us
Product
Robot Strategy Node Platforms Tickets
API
Syntax guide User guide Trading api Blockchain Indicator

© 2015 - ∞ INVENTOR PTE LTD (SG)