Estrategia de media móvil con avance en espiral ascendente
ChaoZhang
Descripción general
La estrategia combina un indicador de espiral y un indicador de tasa de diferencia para generar una señal de compra cuando el precio rompe la línea de la órbita superior y la línea media. Por otro lado, una señal de venta se genera cuando el precio rompe la línea de la órbita inferior y la línea media. La estrategia utiliza la espiral para determinar la dirección de la tendencia del precio y utiliza el indicador de tasa de diferencia para detectar la energía del precio y genera una señal de negociación en base a la confirmación simultánea de los dos indicadores, lo que genera una mejor ganancia.
Principio de estrategia
La estrategia se basa principalmente en dos indicadores:
Los canales espirales: calculan las líneas descendentes para determinar la dirección de la tendencia del precio. Cuando el precio se eleva, se eleva, y cuando se baja, se baja.
Indicador de la tasa de diferencia ((ROC): detecta si el precio se está acelerando y se utiliza para determinar la dinámica de los precios. Si el ROC es mayor que un valor positivo, el precio se acelera hacia arriba, y si es menor que un valor negativo, el precio se acelera hacia abajo.
La lógica para generar una señal de venta es similar. Cuando la espiral y el indicador de diferencia de velocidad emiten una señal de compra simultánea. Es decir, el precio debe romper la vía al mismo tiempo y mostrar signos de aceleración ascendente.
Esta combinación puede mejorar la fiabilidad de las señales y evitar el comercio a ciegas sin una clara tendencia.
Ventajas estratégicas
En términos generales, las señales son más confiables y tienen una mayor probabilidad de éxito.
A través de la optimización de parámetros, se puede ajustar la frecuencia de negociación de la estrategia. Por ejemplo, ajustar los parámetros del indicador de la tasa de diferencia, para controlar la sensibilidad de la apertura de posiciones.
Los parámetros se pueden configurar de forma personalizada.
El mecanismo de reingreso puede seguir la tendencia y mejorar aún más la rentabilidad.
Riesgo estratégico
La mayoría de las compañías de seguros están en la misma situación que las compañías de seguros, pero la mayoría de las compañías de seguros están en la misma situación.
Las estrategias de ruptura son fáciles de atrapar. Cuando el precio se invierte, puede generar grandes pérdidas.
La configuración incorrecta de los parámetros puede causar señales de transacción demasiado frecuentes o poco frecuentes.
El cierre de pérdidas porcentual fijo no puede evitar por completo la ocurrencia de pérdidas individuales más grandes.
Dirección de optimización de la estrategia
Prueba de los parámetros de la tasa de diferencia para encontrar la combinación óptima de parámetros.
Prueba de diferentes niveles de pérdidas y equilibrio de ganancias y pérdidas.
Añadir filtros de otros indicadores, como indicadores de potencia, indicadores de vibración, etc., para mejorar la calidad de la señal.
Probar diferentes mercados para encontrar las variedades que mejor se ajusten a la estrategia.
Optimización de la estrategia de gestión de posiciones, utilizando diferentes posiciones en diferentes condiciones de mercado.
Resumir
La estrategia combina el uso de la espiral y el indicador de la tasa de diferencia para determinar la tendencia y la dinámica de los precios, y la capacidad de mantener la rentabilidad a través de la reentrada y la optimización de los parámetros, al tiempo que se garantiza la calidad de las señales de negociación. El control del riesgo se basa en un porcentaje fijo de pérdidas, que se puede optimizar aún más. En general, la estrategia es completa y adecuada como un marco básico para el comercio cuantitativo.
/*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)