La estrategia del indicador Murphy que viaja a través del tiempo y el espacio
ChaoZhang
Descripción general
Se trata de una simple estrategia de cuantificación de las grandes calambres de peces de mar en el mercado que utiliza el índice de Morpheus. Se aplica en un marco de tiempo de 5 minutos y se utiliza principalmente para el comercio de criptomonedas.
Principio de estrategia
La estrategia utiliza un indicador de Morpheus de longitud 3, con una línea de sobreventa establecida en 100 y una línea de sobreventa establecida en 0. La estrategia espera que el indicador de Morpheus alcance un nivel de sobreventa, lo que indica la presencia de un gran tiburón de peces en el mercado. Si los dos indicadores de Morpheus sobreventa el día anterior y el precio sigue manteniendo la tendencia, esta es una señal de entrada múltiple.
Cuando el índice de amortización es igual a 100 y la línea K subyacente es la línea mayor, se hace una entrada adicional. La línea de parada se establece como el punto más bajo del día de negociación y se detiene dentro de los 60 minutos posteriores a la entrada.
Para el lado de los cortocircuitos, se puede usar la lógica de la imagen. Es decir, cuando el indicador de Morphey alcanza la venta por encima de la línea de la raíz K es la línea de la cola grande, el cortocircuito entrar en el mercado.
Ventajas estratégicas
El uso del índice de morfina puede ser eficaz para identificar el comportamiento de los grandes tiburones en el mercado que acumulan el potencial de acciones, y es probable que sigan subiendo.
Utilizando los puntos de ruptura de la identificación de entidades de la línea K, se pueden filtrar muchas de las falsas rupturas.
La combinación de filtros SMA evita la compra de acciones con tendencia a la baja, lo que reduce el riesgo de negociación.
Con el método de operación de línea súper corta en el día, el parón de 60 minutos puede bloquear rápidamente los beneficios y reducir la probabilidad de retiro.
Riesgo estratégico
Los indicadores de Morpheus pueden generar falsas señales, causando pérdidas innecesarias. Se pueden ajustar adecuadamente los parámetros o añadir otros indicadores para filtrar.
60 minutos de operación de línea ultra corta METHOD Puede ser demasiado radical y no es adecuado para las acciones con un alto índice de volatilidad. Se puede ajustar el tiempo de parada adecuadamente o utilizar el stop loss móvil para optimizar.
No se tiene en cuenta el riesgo de choque de mercado en caso de un evento macroeconómico importante. En este caso, la estrategia debe suspenderse y continuar la negociación hasta que el mercado se estabilice.
Dirección de optimización de la estrategia
Se pueden probar diferentes combinaciones de parámetros, como ajustar la longitud del indicador de Morpheus, optimizar los parámetros del ciclo SMA, etc.
Intenta agregar otros indicadores para combinarlos, como el canal BOLL, el indicador KD, etc., para ver si puedes mejorar la precisión de la señal.
Prueba de que la extensión adecuada de los límites de pérdidas permitirá obtener mayores ganancias individuales
Intentar desarrollar versiones para otros ciclos basadas en el marco de la estrategia, como la versión de 15 minutos o 30 minutos.
Resumir
La estrategia en su conjunto es muy simple y fácil de entender, y la idea básica está en consonancia con la clásica estrategia de seguimiento de la caza de los tiburones. Al identificar los puntos clave de sobrecompra y sobreventa de los indicadores de Morpheus, en combinación con la filtración de las entidades de la línea K, se puede filtrar gran cantidad de ruido. La adición del filtro SMA también mejora aún más la estabilidad de la estrategia.
El método de operación de 60 minutos por encima de la línea de corto alcance puede generar ganancias rápidas, pero también conlleva un alto riesgo operativo. En general, esta es una plantilla de estrategia cuantitativa de gran valor en el campo de batalla, que vale la pena estudiar y optimizar en profundidad, y también nos proporciona ideas valiosas para el desarrollo de estrategias.
/*backtest
start: 2024-01-15 00:00:00
end: 2024-01-22 00:00:00
period: 1m
basePeriod: 1m
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/
// From "Crypto Day Trading Strategy" PDF file.
// * I'm using a SMA filter to avoid buying when the price is declining. Time frame was better at 15 min according to my test.
// 1 - Apply the 3 period Money Flow Index indicator to the 5 minute chart, using 0 and 100 as our oversold and overbought boundaries
// 2 - Wait for the MFI to reach overbought levels, that indicates the presence of "big sharks" in the market. Price needs to hold up
// the first two MFI overbought occurrences of the day to be considered as a bullish entry signal.*
// 3 - We buy when the MFI = 100 and the next candle is a bullish candle with short wicks.
// 4 - We place our Stop Loss below the low of the trading day and we Take Profit during the first 60 minutes after taking the trade.
// The logic above can be used in a mirrored fashion to take short entries, this is a custom parameter that can be modified from
// the strategy Inputs panel.
// © tweakerID
//@version=4
strategy("Money Flow Index 5 min Strategy",
overlay=true )
direction = input(0, title = "Strategy Direction", type=input.integer, minval=-1, maxval=1)
strategy.risk.allow_entry_in(direction == 0 ? strategy.direction.all : (direction < 0 ? strategy.direction.short : strategy.direction.long))
/////////////////////// STRATEGY INPUTS ////////////////////////////////////////
title1=input(true, "-----------------Strategy Inputs-------------------")
i_MFI = input(3, title="MFI Length")
OB=input(100, title="Overbought Level")
OS=input(0, title="Oversold Level")
barsizeThreshold=input(.5, step=.05, minval=.1, maxval=1, title="Bar Body Size, 1=No Wicks")
i_MAFilter = input(true, title="Use MA Trend Filter")
i_MALen = input(80, title="MA Length")
i_timedexit=input(false, title="Use 60 minutes exit rule")
short=input(true, title="Use Mirrored logic for Shorts")
/////////////////////// BACKTESTER /////////////////////////////////////////////
title2=input(true, "-----------------General Inputs-------------------")
// Backtester General Inputs
i_SL=input(true, title="Use Stop Loss and Take Profit")
i_SLType=input(defval="Strategy Stop", title="Type Of Stop", options=["Strategy Stop", "Swing Lo/Hi", "ATR Stop"])
i_SPL=input(defval=10, title="Swing Point Lookback")
i_PercIncrement=input(defval=3, step=.1, title="Swing Point SL Perc Increment")*0.01
i_ATR = input(14, title="ATR Length")
i_ATRMult = input(5, step=.1, title="ATR Multiple")
i_TPRRR = input(2.2, step=.1, title="Take Profit Risk Reward Ratio")
TS=input(false, title="Trailing Stop")
// Bought and Sold Boolean Signal
bought = strategy.position_size > strategy.position_size[1]
or strategy.position_size < strategy.position_size[1]
// Price Action Stop and Take Profit
LL=(lowest(i_SPL))*(1-i_PercIncrement)
HH=(highest(i_SPL))*(1+i_PercIncrement)
LL_price = valuewhen(bought, LL, 0)
HH_price = valuewhen(bought, HH, 0)
entry_LL_price = strategy.position_size > 0 ? LL_price : na
entry_HH_price = strategy.position_size < 0 ? HH_price : na
tp=strategy.position_avg_price + (strategy.position_avg_price - entry_LL_price)*i_TPRRR
stp=strategy.position_avg_price - (entry_HH_price - strategy.position_avg_price)*i_TPRRR
// ATR Stop
ATR=atr(i_ATR)*i_ATRMult
ATRLong = ohlc4 - ATR
ATRShort = ohlc4 + ATR
ATRLongStop = valuewhen(bought, ATRLong, 0)
ATRShortStop = valuewhen(bought, ATRShort, 0)
LongSL_ATR_price = strategy.position_size > 0 ? ATRLongStop : na
ShortSL_ATR_price = strategy.position_size < 0 ? ATRShortStop : na
ATRtp=strategy.position_avg_price + (strategy.position_avg_price - LongSL_ATR_price)*i_TPRRR
ATRstp=strategy.position_avg_price - (ShortSL_ATR_price - strategy.position_avg_price)*i_TPRRR
// Strategy Stop
DayStart = time == timestamp("UTC", year, month, dayofmonth, 0, 0, 0)
plot(DayStart ? 1e9 : na, style=plot.style_columns, color=color.silver, transp=80, title="Trade Day Start")
float LongStop = valuewhen(DayStart,low,0)*(1-i_PercIncrement)
float ShortStop = valuewhen(DayStart,high,0)*(1+i_PercIncrement)
float StratTP = strategy.position_avg_price + (strategy.position_avg_price - LongStop)*i_TPRRR
float StratSTP = strategy.position_avg_price - (ShortStop - strategy.position_avg_price)*i_TPRRR
/////////////////////// STRATEGY LOGIC /////////////////////////////////////////
MFI=mfi(close,i_MFI)
barsize=high-low
barbodysize=close>open?(open-close)*-1:(open-close)
shortwicksbar=barbodysize>barsize*barsizeThreshold
SMA=sma(close, i_MALen)
MAFilter=close > SMA
timesinceentry=(time - valuewhen(bought, time, 0)) / 60000
timedexit=timesinceentry == 60
BUY = MFI[1] == OB and close > open and shortwicksbar and (i_MAFilter ? MAFilter : true)
bool SELL = na
if short
SELL := MFI[1] == OS and close < open and shortwicksbar and (i_MAFilter ? not MAFilter : true)
//Debugging Plots
plot(timesinceentry, transp=100, title="Time Since Entry")
//Trading Inputs
DPR=input(true, "Allow Direct Position Reverse")
reverse=input(false, "Reverse Trades")
// Entries
if reverse
if not DPR
strategy.entry("long", strategy.long, when=SELL and strategy.position_size == 0)
strategy.entry("short", strategy.short, when=BUY and strategy.position_size == 0)
else
strategy.entry("long", strategy.long, when=SELL)
strategy.entry("short", strategy.short, when=BUY)
else
if not DPR
strategy.entry("long", strategy.long, when=BUY and strategy.position_size == 0)
strategy.entry("short", strategy.short, when=SELL and strategy.position_size == 0)
else
strategy.entry("long", strategy.long, when=BUY)
strategy.entry("short", strategy.short, when=SELL)
if i_timedexit
strategy.close_all(when=timedexit)
SL= i_SLType == "Swing Lo/Hi" ? entry_LL_price : i_SLType == "ATR Stop" ? LongSL_ATR_price : LongStop
SSL= i_SLType == "Swing Lo/Hi" ? entry_HH_price : i_SLType == "ATR Stop" ? ShortSL_ATR_price : ShortStop
TP= i_SLType == "Swing Lo/Hi" ? tp : i_SLType == "ATR Stop" ? ATRtp : StratTP
STP= i_SLType == "Swing Lo/Hi" ? stp : i_SLType == "ATR Stop" ? ATRstp : StratSTP
//TrailingStop
dif=(valuewhen(strategy.position_size>0 and strategy.position_size[1]<=0, high,0))
-strategy.position_avg_price
trailOffset = strategy.position_avg_price - SL
var tstop = float(na)
if strategy.position_size > 0
tstop := high- trailOffset - dif
if tstop<tstop[1]
tstop:=tstop[1]
else
tstop := na
StrailOffset = SSL - strategy.position_avg_price
var Ststop = float(na)
Sdif=strategy.position_avg_price-(valuewhen(strategy.position_size<0
and strategy.position_size[1]>=0, low,0))
if strategy.position_size < 0
Ststop := low+ StrailOffset + Sdif
if Ststop>Ststop[1]
Ststop:=Ststop[1]
else
Ststop := na
strategy.exit("TP & SL", "long", limit=TP, stop=TS? tstop : SL, when=i_SL)
strategy.exit("TP & SL", "short", limit=STP, stop=TS? Ststop : SSL, when=i_SL)
/////////////////////// PLOTS //////////////////////////////////////////////////
plot(i_SL and strategy.position_size > 0 and not TS ? SL : i_SL and strategy.position_size > 0 and TS ? tstop : na , title='SL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size < 0 and not TS ? SSL : i_SL and strategy.position_size < 0 and TS ? Ststop : na , title='SSL', style=plot.style_cross, color=color.red)
plot(i_SL and strategy.position_size > 0 ? TP : na, title='TP', style=plot.style_cross, color=color.green)
plot(i_SL and strategy.position_size < 0 ? STP : na, title='STP', style=plot.style_cross, color=color.green)
// Draw price action setup arrows
plotshape(BUY ? 1 : na, style=shape.triangleup, location=location.belowbar,
color=color.green, title="Bullish Setup", size=size.auto)
plotshape(SELL ? 1 : na, style=shape.triangledown, location=location.abovebar,
color=color.red, title="Bearish Setup", size=size.auto)