Cette stratégie combine l'indicateur du centre de gravité et l'indicateur du canal SSL pour déterminer les tendances des prix et suivre les ruptures, appartenant à la catégorie de stratégie suivante la tendance.
Calculer l'indicateur du centre de gravité, avec les bandes supérieure et inférieure comme limites des tendances à la hausse et à la baisse.
Calculer l'indicateur de canal SSL, à l'intérieur de laquelle est la gamme, à l'extérieur est la direction de la tendance.
Lorsque le prix dépasse la bande supérieure ou le canal, déterminez la tendance haussière et allez long.
Utilisez le stop loss dynamique ATR pour suivre les niveaux de stop loss et éviter les pertes accrues.
Combinez avec la période de backtest pour générer des signaux de trading réels.
La stratégie utilise deux indicateurs pour déterminer les tendances, l'un pour détecter les ruptures et l'autre pour confirmer les tendances, les combiner peut améliorer la précision.
L'utilisation de deux indicateurs améliore la précision de la détermination des tendances.
Le centre de gravité est sensible aux changements de tendance, le canal SSL définit clairement la direction de la tendance.
L'ATR dynamique pour le stop loss s'ajuste de manière flexible en fonction de la volatilité du marché.
Des règles de stratégie simples et claires, faciles à comprendre et à mettre en œuvre.
Un grand espace d'optimisation pour les paramètres, peut être ajusté pour différents marchés.
Fonctionnalité complète de backtest pour vérifier la performance de la stratégie.
Le centre de gravité et le SSL peuvent échouer dans certains cas, ce qui entraîne des signaux erronés.
Le stop-loss dynamique peut être trop agressif, ce qui peut assouplir la plage de stop-loss.
Une mauvaise sélection de la période de backtest peut conduire à de mauvais résultats de stratégie, nécessitant des backtest sur différentes étapes du marché.
Il faut tenir pleinement compte de l'impact des coûts commerciaux.
Testez différentes combinaisons de paramètres pour trouver des paires optimales.
Optimiser la période d'ATR et les paramètres du multiplicateur de stop loss dynamique.
Introduire d'autres indicateurs pour le filtrage des signaux, par exemple MACD, KDJ.
Ajoutez des modèles d'apprentissage automatique pour aider à prédire la direction de la tendance.
Optimiser la gestion de l'argent, définir les règles de taille des positions.
Paramètres de réglage précis pour des produits spécifiques.
Cette stratégie combine le centre de gravité et le canal SSL pour déterminer les tendances et utilise un stop loss ATR dynamique pour contrôler les risques. C'est une stratégie de suivi de tendance exploitable. Des améliorations supplémentaires peuvent être apportées via l'optimisation des paramètres, l'introduction d'autres indicateurs et l'apprentissage automatique, etc. Dans l'ensemble, il s'agit d'une stratégie très pratique et évolutive, servant de référence précieuse pour le trading algorithmique.
/*backtest
start: 2023-08-19 00:00:00
end: 2023-09-13 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Thanks to HPotter for the original code for Center of Gravity Backtest
strategy("CoG SSL BF 🚀", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.075)
/////////////// Time Frame ///////////////
_0 = input(false, "════════ Test Period ═══════")
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
/////////////// SSL Channels ///////////////
_1 = input(false, "═════════ SSL ══════════")
len1=input(title="SMA Length 1", defval=12)
len2=input(title="SMA Length 2", defval=13)
smaHigh = sma(high, len1)
smaLow = sma(low, len2)
Hlv = 0
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh
///////////// Center of Gravity /////////////
_2 = input(false, "═════════ CoG ══════════")
Length = input(25, minval=1)
m = input(5, minval=0)
Percent = input(6, minval=0, title="COG %")
xLG = linreg(close, Length, m)
xLG1r = xLG + ((close * Percent) / 100)
xLG1s = xLG - ((close * Percent) / 100)
pos = 0.0
pos := iff(close > xLG1r, 1, iff(close < xLG1s, -1, nz(pos[1], 0)))
possig = iff(pos == 1, 1, iff(pos == -1, -1, pos))
///////////// Rate Of Change /////////////
_3 = input(false, "══════ Rate of Change ══════")
source = close
roclength = input(2, "ROC Length", minval=1)
pcntChange = input(10, "ROC % Change", minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Srategy ///////////////
long = possig == 1 or (sslUp > sslDown and isMoving())
short = possig == -1 or (sslUp < sslDown and isMoving())
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
/////////////// Dynamic ATR Stop Losses ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
atrLkb = input(1, minval=1, title='ATR Stop Period')
atrMult = input(2, step=0.25, title='ATR Stop Multiplier')
atr1 = atr(atrLkb)
longStop = 0.0
longStop := short_signal ? na : long_signal ? close - (atr1 * atrMult) : longStop[1]
shortStop = 0.0
shortStop := long_signal ? na : short_signal ? close + (atr1 * atrMult) : shortStop[1]
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("L", strategy.long, when=long)
strategy.entry("S", strategy.short, when=short)
strategy.exit("L SL", "L", stop=longStop, when=since_longEntry > 0)
strategy.exit("S SL", "S", stop=shortStop, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
p1 = plot(sslDown, linewidth = 1, color=color.red, title="SSL down")
p2 = plot(sslUp, linewidth = 1, color=color.lime, title="SSL up")
fill(p1, p2, color = not isMoving() ? color.white : sslDown < sslUp ? color.lime : color.red, transp=80)
plot(xLG1r, color=color.lime, title="LG1r")
plot(xLG1s, color=color.red, title="LG1s")
plot(strategy.position_size <= 0 ? na : longStop, title="Long Stop Loss", color=color.yellow, style=plot.style_circles, linewidth=1)
plot(strategy.position_size >= 0 ? na : shortStop, title="Short Stop Loss", color=color.orange, style=plot.style_circles, linewidth=1)
bgcolor(long ? color.green : short ? color.red : not isMoving() ? color.white : na, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=60)