Estrategia de trading con promedio móvil de trailing stop

Fecha de creación: 2024-02-01 10:59:06 Última modificación: 2024-02-01 10:59:06

Copiar: 0 Número de Visitas: 614

ChaoZhang

Seguir Mensajes Privados

Seguir

1617

Seguidores

Estrategia de trading con promedio móvil de trailing stop

Descripción general

Esta estrategia es una estrategia de seguimiento de pérdidas y pérdidas basada en la media móvil. Utiliza la media de EMA de dos períodos diferentes para determinar la horquilla de oro, hacer más cuando ocurre la horquilla de oro y hacer vacío cuando ocurre la horquilla de oro.

Principio de estrategia

Esta estrategia utiliza dos líneas medias EMA rápidas y lentas. La línea rápida tiene un ciclo corto y es sensible a la reacción; la línea lenta tiene un ciclo largo y es estable. Cuando las dos líneas se cruzan hacia arriba, se genera una señal de compra de la horca dorada; cuando se cruzan hacia abajo, se genera una señal de venta de la horca muerta.

Sobre esta base, esta estrategia utiliza la forma de trailing para mover los puntos de parada y los puntos de parada. En concreto, los puntos de parada y los puntos de parada después de la negociación se mueven constantemente en la dirección favorable con el funcionamiento del precio para bloquear los beneficios y controlar el riesgo. La magnitud de los movimientos se puede configurar en porcentajes o puntos fijos. Esto hace que los puntos de parada sean más flexibles e inteligentes.

Ventajas estratégicas

El uso de dos EMAs para formar señales de negociación, con un rendimiento estable.
El trailing es un mecanismo de detención de pérdidas que bloquea las ganancias y controla el riesgo de manera efectiva.
Se puede elegir entre porcentaje o puntuación fija para trailing, con gran flexibilidad.
El seguimiento de los beneficios y pérdidas de detención de pérdidas ha funcionado bien en un marco de tiempo prolongado.

Riesgo y optimización de la estrategia

En situaciones de crisis, puede ocurrir que el stop loss sea demasiado frecuente y afecte a la ganancia. Se puede relajar adecuadamente el punto de stop loss o aumentar la frecuencia de inicio del stop loss móvil.
La EMA promedio en sí tiene un cierto retraso, y puede perder algunas oportunidades de negociación. Se puede considerar la posibilidad de agregar la sensibilidad de la estrategia de mejora de indicadores como Momentum.
Los datos de detección insuficientes pueden conducir a una sobreadaptación. Debería verificarse adecuadamente en un marco de tiempo más largo y en más variedades.

Resumir

Esta estrategia utiliza la integración de señales de transacción de formación de líneas medias móviles y dos ventajas técnicas de seguimiento de tendencias. Es una estrategia cuantitativa de valor real que tiene un excelente rendimiento estable en líneas largas.

Código Fuente de la Estrategia

/*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)))

Forums

PINE Language FAQ Summary MyLanguage Web3 About Us

Product

Robot Strategy Node Platforms Tickets

API

Syntax guide User guide Trading api Blockchain Indicator