Stratégie de moyenne mobile de percée en spirale vers le haut
ChaoZhang
Aperçu
Cette stratégie utilise un ensemble d’indicateurs de la spiral et d’indicateurs de décalage pour générer un signal d’achat lorsque le prix franchit la ligne supérieure et la ligne moyenne. De même, lorsqu’un prix franchit la ligne inférieure et la ligne moyenne, un signal de vente est généré. La stratégie utilise la spiral pour déterminer la direction de la tendance des prix et utilise l’indicateur de décalage pour détecter la dynamique des prix.
Principe de stratégie
La stratégie est basée sur deux indicateurs principaux:
Chaînes spirales: calcul des lignes de descente pour déterminer la direction de la tendance des prix. Les prix sont en hausse quand ils franchissent la trajectoire ascendante et en baisse quand ils franchissent la trajectoire descendante.
Indicateur de la différence de taux ((ROC): détecte si le prix s’accélère et sert à déterminer la dynamique des prix. Si le ROC est supérieur à une valeur positive, le prix augmente et s’il est inférieur à une valeur négative, le prix diminue.
Un signal d’achat est généré lorsque le canal de la spirale et l’indicateur de décalage émettent simultanément des signaux à plusieurs têtes. C’est-à-dire que le prix doit simultanément franchir la trajectoire et montrer des signes d’accélération vers le haut. La logique de génération d’un signal de vente est similaire.
Cette combinaison peut améliorer la fiabilité des signaux et éviter les transactions aveugles en l’absence de tendance claire.
Avantages stratégiques
Les signaux sont plus fiables et les chances de victoire sont plus élevées.
L’optimisation des paramètres permet d’ajuster la fréquence de négociation de la stratégie. Par exemple, l’ajustement des paramètres de l’indicateur de taux de déviation permet de contrôler la sensibilité de l’ouverture de position.
Le stop loss est utilisé pour contrôler les pertes individuelles. Les paramètres peuvent être personnalisés.
Les mécanismes de réintégration permettent de suivre la tendance et d’améliorer encore la rentabilité.
Risque stratégique
Le gouvernement a décidé d’envoyer des milliers de dollars à la banque pour que les investisseurs puissent faire leurs achats.
Les stratégies de rupture sont facilement emprisonnées. Lorsque les prix se retournent, les pertes peuvent être importantes.
Une mauvaise configuration des paramètres peut entraîner des signaux de transaction trop fréquents ou rares.
Les pertes individuelles plus importantes ne sont pas totalement évitées par le stop loss à pourcentage fixe.
Orientation de l’optimisation de la stratégie
Test des paramètres de l’indicateur de décalage pour trouver la combinaison optimale de paramètres
Test de différents niveaux de stop-loss, équilibre des pertes et des gains.
Ajouter des filtres à d’autres indicateurs, tels que l’indicateur de puissance, l’indicateur de vibration, etc., pour améliorer la qualité du signal.
Il s’agit de tester différents marchés pour trouver les variétés qui correspondent le mieux à la stratégie.
Optimisation de la stratégie de gestion des positions, en utilisant des positions différentes selon les conditions du marché.
Résumer
La stratégie utilise des voies en spirale et des indices de décalage pour déterminer la tendance et la dynamique des prix, et la capacité de maintenir la rentabilité par la réentrée et l’optimisation des paramètres, tout en assurant la qualité du signal de négociation. La gestion du risque, basée sur un pourcentage fixe de stop loss, peut être optimisée davantage.
/*backtest
start: 2024-01-07 00:00:00
end: 2024-01-14 00:00:00
period: 45m
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("SSL Chaikin BF 🚀", overlay=true, precision=2, 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
/////////////// Chaikin MF ///////////////
_1 = input(false, "═══════ Chaikin MF ═══════")
length = input(20, minval=1, title = "Chaikin SMA Length")
upperThreshold = input(0.04, step=0.01, title="Upper Threshold")
lowerThreshold = input(0.02, step=0.01, title="Lower Threshold")
ad = close==high and close==low or high==low ? 0 : ((2*close-low-high)/(high-low))*volume
mf = sum(ad, length) / sum(volume, length)
/////////////// SSL Channels ///////////////
_2 = 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
///////////// Rate Of Change /////////////
_3 = input(false, "══════ Rate of Change ══════")
source = close
roclength = input(13, "ROC Length", minval=1)
pcntChange = input(4, "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))
/////////////// Strategy ///////////////
long = sslUp > sslDown and isMoving() or crossover(mf, upperThreshold)
short = sslUp < sslDown and isMoving() or crossunder(mf, lowerThreshold)
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])
//////////////// Stop loss ///////////////
_4 = input(false, "════════ Stop Loss ═══════")
sl_inp = input(2.0, title='Stop Loss %') / 100
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("L", strategy.long, when=long)
strategy.entry("S", strategy.short, when=short)
strategy.exit("L SL", "L", stop=long_sl, when=since_longEntry > 0)
strategy.exit("S SL", "S", stop=short_sl, when=since_shortEntry > 0)
/////////////// Plotting ///////////////
p1 = plot(sslDown, linewidth = 1, color=color.red)
p2 = plot(sslUp, linewidth = 1, color=color.lime)
fill(p1, p2, color = sslDown < sslUp ? color.lime : color.red, transp=80)
bgcolor(isMoving() ? long ? color.green : short ? color.red : na : color.white, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
bgcolor(crossover(mf, upperThreshold) ? color.blue : crossunder(mf, lowerThreshold) ? color.orange : na, transp=30)