Stratégie de trading de moyenne mobile avec stop suiveur
Date de création:
2024-02-01 10:59:06
Dernière modification:
2024-02-01 10:59:06
Copier:
0
Nombre de clics:
322
ChaoZhang
1
Suivre
1179
Abonnés
Aperçu
Cette stratégie est une stratégie de trading stop-loss basée sur une moyenne mobile. Elle utilise la moyenne EMA de deux périodes différentes pour juger des fourches dorées, faire plus en cas de fourche dorée et faire vide en cas de fourche morte. De plus, la stratégie utilise des pourcentages ou des points fixes pour trailing stop-loss et stop-loss.
Principe de stratégie
Cette stratégie utilise deux lignes moyennes EMA rapides et lentes. Les lignes rapides sont de courte durée et sont sensibles à la réaction; les lignes lentes sont de longue durée et sont stables à la réaction. Les lignes qui se croisent vers le haut génèrent un signal d’achat de la fourche dorée; celles qui se croisent vers le bas génèrent un signal de vente de la fourche morte.
Sur cette base, la stratégie utilise le trailing pour déplacer les points d’arrêt et les arrêts. Plus précisément, les points d’arrêt et les arrêts post-transaction se déplacent continuellement dans la direction favorable avec la course du prix pour bloquer les bénéfices tout en contrôlant les risques. La largeur du mouvement peut être définie en pourcentage ou en points fixes.
Avantages stratégiques
- L’utilisation de deux EMA pour former un signal de négociation, avec un rendement stable.
- trailing Le mécanisme de freinage des pertes permet de verrouiller les bénéfices et de contrôler efficacement les risques.
- Le trailing peut être effectué en pourcentage ou en points fixes, avec une grande flexibilité.
- Le suivi des gains et des pertes est bon sur de longues périodes.
Risques stratégiques et optimisation
- Dans une situation de choc, il peut y avoir des arrêts de perte trop fréquents qui affectent les bénéfices. Il est possible d’assouplir de manière appropriée les arrêts de perte ou d’augmenter la fréquence de démarrage des arrêts mobiles.
- L’EMA moyenne est en soi un indicateur de retard, qui peut laisser passer certaines opportunités de trading. La sensibilité de la stratégie d’amélioration des indicateurs tels que Momentum peut être envisagée.
- Des données de détection insuffisantes peuvent conduire à une suradaptation. Il convient de vérifier suffisamment dans des délais plus longs et dans plus de variétés.
Résumer
Cette stratégie utilise l’intégration de deux avantages techniques pour la formation de signaux de négociation et le suivi de tendances sur une ligne moyenne mobile. Elle présente une excellente stabilité sur les lignes longues et est l’une des stratégies quantitatives ayant une valeur de combat réelle.
Code source de la stratégie
/*backtest
start: 2023-01-31 00:00:00
end: 2024-01-31 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Sharad_Gaikwad
//@version=5
strategy("Traling.SL.Target", overlay=true, process_orders_on_close = true, max_labels_count = 500)
// << Parameters section {
_1 = input.bool(title = "━━━━━━━ ↓ Pivot parameters for trade ↓ ━━━━━━━", defval = false)
fast_len = input.int(title = 'Fast len', defval = 20)
slow_len = input.int(title = 'Slow len', defval = 50)
label_bg_color = input.color(title = 'BG color for ongoing trade SL/Target label', defval=color.white)
sl_target_method = input.string(title = 'Method to be used for SL/Target trailing', defval='% Based Target and SL', options = ['% Based Target and SL','Fix point Based Target and SL'])
_2 = input.bool(title = "━━━━━━━ ↓ % Based Target and SL ↓ ━━━━━━━", defval = true)
initial_profit_percent = input.float(title = 'Inital profit %', defval = 1) / 100
initial_sl_percent = input.float(title = 'Inital SL %', defval = 1) / 100
initiate_trailing_percent = input.float(title = 'Initiate trailing %', defval = 0.5, tooltip = 'Initiate trailing of target and SL after change in price in % after taking trade') / 100
trail_profit_percent = input.float(title = 'Trail profit by %', defval = 0.3) / 100
trail_sl_percent = input.float(title = 'Trail SL by %', defval = 0.3) / 100
_3 = input.bool(title = "━━━━━━━ ↓ Fix point Based Target and SL ↓ ━━━━━━━", defval = false)
initial_profit_points = input.float(title = 'Inital profit target points', defval = 100)
initial_sl_points = input.float(title = 'Inital SL points', defval = 50)
initiate_trailing_points = input.float(title = 'Initiate trailing points', defval = 60, tooltip = 'Initiate trailing of target and SL after change in price in points after taking trade')
trail_profit_points = input.float(title = 'Trail profit by points', defval = 25)
trail_sl_points = input.float(title = 'Trail SL by %', defval = 30)
// } Parameters section >>
// } << Common function {
tab = table.new(position=position.bottom_right, columns=7, rows=200,frame_color = color.yellow, frame_width = 1)
msg(int row, int col, string msg_str, clr=color.blue) =>
table.cell(table_id=tab, column=col, row=row, text=msg_str, text_color=clr)
getVal(val) =>
ret_val = na(val) ? 0 : val
t(val) => str.tostring(val, "0.00")
timeToString(int _t) =>
str.tostring(dayofmonth(_t), '00') + '/' +
str.tostring(month(_t), '00') + '/' +
str.tostring(year(_t), '0000') + ' ' +
str.tostring(hour(_t), '00') + ':' +
str.tostring(minute(_t), '00') + ':' +
str.tostring(second(_t), '00')
// } Common functions>>
// Variable declarations {
percent_based = sl_target_method == '% Based Target and SL' ? true : false
var initial_long_entry_price = float(na)
var initial_short_entry_price = float(na)
var long_target = float(na)
var long_sl = float(na)
var short_target = float(na)
var short_sl = float(na)
var long_entry_price = float(na)
var short_entry_price = float(na)
var initial_long_percent_target = float(na)
var initial_long_percent_sl = float(na)
var initial_long_point_target = float(na)
var initial_long_point_sl = float(na)
var initial_short_percent_target = float(na)
var initial_short_percent_sl = float(na)
var initial_short_point_target = float(na)
var initial_short_point_sl = float(na)
var is_long = bool(na)
var is_short = bool(na)
var trail_long_iteration = int(na)
var trail_short_iteration = int(na)
// }
// derive important variable values
// Strategy logic
fast_ema = ta.ema(close, fast_len)
slow_ema = ta.ema(close, slow_len)
plot(fast_ema, color = color.red)
plot(slow_ema, color = color.green)
go_long = ta.crossover(fast_ema, slow_ema) and strategy.position_size == 0
go_short = ta.crossunder(fast_ema, slow_ema) and strategy.position_size == 0
// barcolor(ph ? color.purple : na, offset = -lb)
// barcolor(pl ? color.yellow : na, offset = -lb)
// barcolor(ph ? color.white : na)
// barcolor(pl ? color.blue : na)
// //trailing logic for long
long_trailing_point = percent_based ? (close >= long_entry_price + (long_entry_price * initiate_trailing_percent)) :
(close >= long_entry_price + initiate_trailing_points)
short_trailing_point = percent_based ? (close <= short_entry_price - (short_entry_price * initiate_trailing_percent)) :
(close >= short_entry_price - initiate_trailing_points)
if(is_long and long_trailing_point)
// initial_long_percent_target = initial_long_percent_target + (initial_long_percent_target * trail_profit_percent)
// initial_long_percent_sl = initial_long_percent_sl - (initial_long_percent_sl * trail_sl_percent)
// initial_long_point_target = initial_long_point_target + trail_profit_points
// initial_long_point_sl = initial_long_point_sl - trail_sl_points
trail_long_iteration := trail_long_iteration + 1
long_target := percent_based ? (long_target + (long_target * trail_profit_percent)) :
(long_target + trail_profit_points)
long_sl := percent_based ? (long_sl + (long_sl * trail_sl_percent)) :
(long_sl + trail_sl_points)
long_entry_price := percent_based ? (long_entry_price + (long_entry_price * initiate_trailing_percent)) :
(long_entry_price + initiate_trailing_points)
if(is_short and short_trailing_point)
// initial_short_percent_target = initial_short_percent_target - (initial_short_percent_target * trail_profit_percent)
// initial_short_percent_sl = initial_short_percent_sl + (initial_short_percent_sl * trail_sl_percent)
// initial_short_point_target = initial_short_point_target - trail_profit_points
// initial_short_point_sl = initial_short_point_sl + trail_sl_points
trail_short_iteration := trail_short_iteration + 1
short_target := percent_based ? (short_target - (short_target * trail_profit_percent)) :
(short_target - trail_profit_points)
short_sl := percent_based ? (short_sl - (short_sl * trail_sl_percent)) :
(short_sl - trail_sl_points)
short_entry_price := percent_based ? (short_entry_price - (short_entry_price * initiate_trailing_percent)) :
(short_entry_price - initiate_trailing_points)
if(go_long)
is_long := true
is_short := false
trail_long_iteration := 0
trail_short_iteration := 0
initial_long_entry_price := close
long_entry_price := close
initial_long_percent_target := close + (close * initial_profit_percent)
initial_long_percent_sl := close - (close * initial_sl_percent)
initial_long_point_target := close + initial_profit_points
initial_long_point_sl := close - initial_sl_points
long_target := percent_based ? initial_long_percent_target : initial_long_point_target
long_sl := percent_based ? initial_long_percent_sl : initial_long_point_sl
strategy.entry(id = 'Long', direction = strategy.long)
if(go_short)
is_long := false
is_short := true
trail_long_iteration := 0
trail_short_iteration := 0
initial_short_entry_price := close
short_entry_price := close
initial_short_percent_target := close - (close * initial_profit_percent)
initial_short_percent_sl := close + (close * initial_sl_percent)
initial_short_point_target := close - initial_profit_points
initial_short_point_sl := close + initial_sl_points
short_target := percent_based ? initial_short_percent_target : initial_short_point_target
short_sl := percent_based ? initial_short_percent_sl : initial_short_point_sl
strategy.entry(id = 'Short', direction = strategy.short)
method = percent_based ? '% Based' : 'Fixed Points'
long_tooltip = 'Long @ ' + timeToString(time) + '\n' +
'Method : ' + method + '\n' +
'Initial Trade Price: ' + t(initial_long_entry_price) + '\n' +
'Inital Target : ' + t(long_target) + '\n' +
'Inital SL : ' + t(long_sl)
short_tooltip = 'Short @ ' + timeToString(time) + '\n' +
'Method : ' + method + '\n' +
'Initial Trade Price: ' + t(initial_short_entry_price) + '\n' +
'Inital Target : ' + t(short_target) + '\n' +
'Inital SL : ' + t(short_sl)
label.new(go_long ? bar_index : na, go_long ? bar_index : na,
style = label.style_diamond, yloc = yloc.belowbar, color = color.green, size=size.tiny, tooltip = long_tooltip)
label.new(go_short ? bar_index : na, go_short ? bar_index : na,
style = label.style_diamond, yloc = yloc.abovebar, color = color.red, size=size.tiny, tooltip = short_tooltip)
trail_long_tooltip = 'Trail @ ' + timeToString(time) + '\n' +
'Iteration no : ' + t(trail_long_iteration) + '\n' +
'New Target : ' + t(long_target) + '\n' +
'New SL : ' + t(long_sl)
trail_short_tooltip = 'Trail @ ' + timeToString(time) + '\n' +
'Iteration no : ' + t(trail_short_iteration) + '\n' +
'New Target : ' + t(short_target) + '\n' +
'New SL : ' + t(short_sl)
label.new(is_long and long_trailing_point and strategy.position_size > 0 ? bar_index : na, is_long and long_trailing_point and strategy.position_size > 0 ? bar_index : na,
text = str.tostring(trail_long_iteration), style = label.style_circle, textcolor = color.white, yloc = yloc.belowbar, color = color.green, size=size.tiny, tooltip = trail_long_tooltip)
label.new(is_short and short_trailing_point and strategy.position_size < 0 ? bar_index : na, is_short and short_trailing_point and strategy.position_size < 0 ? bar_index : na,
text = str.tostring(trail_short_iteration), style = label.style_circle, textcolor = color.white, yloc = yloc.abovebar, color = color.red, size=size.tiny, tooltip = trail_short_tooltip)
strategy.close(id = 'Long', when = close <= long_sl, comment = 'SL')
strategy.close(id = 'Short', when = close >= short_sl, comment = 'SL')
strategy.close(id = 'Long', when = close >= long_target, comment = 'Target')
strategy.close(id = 'Short', when = close <= short_target, comment = 'Target')
// no_of_labels = 1
// label_q(_array, _val) =>
// array.push(_array, _val)
// _return = array.shift(_array)
// var target_label = float(na)
// var sl_label = float(na)
// if(strategy.position_size > 0)
// target_label := long_target
// sl_label := long_sl
// else if(strategy.position_size < 0)
// target_label := short_target
// sl_label := short_sl
// else
// target_label := float(na)
// sl_label := float(na)
// var label[] target_array = array.new_label(no_of_labels)
// label.delete(label_q(target_array, label.new(bar_index, target_label, "Target:"+t(target_label), style = label.style_label_down, color = label_bg_color, size=size.small, textcolor = color.green)))
// var label[] sl_array = array.new_label(no_of_labels)
// label.delete(label_q(sl_array, label.new(bar_index, sl_label, "SL:"+t(sl_label), style = label.style_label_up, color = label_bg_color, size=size.small, textcolor = color.red)))