Estrategia de trading bidireccional de posiciones largas y cortas basada en señales largas y cortas de indicadores cuantitativos
ChaoZhang
Descripción general
La estrategia es una estrategia de comercio bidireccional basada en la señal de polvo generada por el oscilador OBV de indicadores cuantitativos y el indicador de canal de precios de Donchain. Utiliza el indicador de canal de precio para determinar las rupturas y reajustes de precios, y combina el indicador cuantitativo para determinar la fuerza de polvo y generar una señal de comercio.
Principio de estrategia
Utiliza el indicador de canal de precios de Donchain para determinar el canal de subida y bajada de los precios. El canal de subida se calcula por el precio más alto y el canal de bajada se calcula por el precio más bajo.
Utiliza el indicador de cuantificación OBV y el indicador EMA para construir un oscilador OBV para determinar la fuerza en vacío. Cuando el oscilador es mayor que 0, se considera que la fuerza en vacío es mayor que la fuerza en vacío, y cuando es menor que 0, viceversa.
Cuando el precio rompe el canal superior, y el oscilador es mayor que 0, se genera una señal de multiplicación; cuando el precio rompe el canal inferior, y el oscilador es menor que 0, se genera una señal de vacío.
Cuando el precio regresa al canal inferior, la posición se cierra y se abre; cuando el precio regresa al canal superior, la posición se cierra y se cierra.
Ventajas estratégicas
Utiliza el canal de precios para juzgar tendencias y evitar ser engañado por la situación de la crisis.
En combinación con indicadores cuantitativos para evaluar la fuerza aérea, asegúrese de que la dirección de las operaciones coincida con la fuerza del mercado.
El uso de operaciones bidireccionales permite obtener ganancias sin importar si el mercado sube o baja.
Establezca una estrategia de alto riesgo para controlar el riesgo de manera efectiva.
Riesgo estratégico
La configuración incorrecta de los parámetros del canal de precios puede causar que el canal sea demasiado amplio o demasiado estrecho, que se pierda una oportunidad de negociación o que se produzca una señal errónea.
La configuración incorrecta de los parámetros del indicador también puede causar un retraso o adelantamiento de la señal.
Los eventos inesperados que provocan un comportamiento anormal rápido pueden desencadenar un seguro de pérdidas.
Las operaciones bidireccionales requieren la administración simultánea de posiciones excedentes y excedentes, y son más difíciles de manejar.
Dirección de optimización de la estrategia
Optimización de los parámetros del canal de precios para encontrar la combinación óptima de parámetros.
Los parámetros de los oscilladores OBV también deben ser optimizados para garantizar una determinación precisa y oportuna de la fuerza aerodinámica.
Se puede considerar la combinación de otros indicadores como MACD, KD y otros para determinar las tendencias del mercado, mejorando la precisión de la señal.
Se puede probar la eficacia de diferentes métodos de detención, como el seguimiento de la detención, el porcentaje de detención, etc.
Se pueden probar diferentes variedades para encontrar las más adecuadas para la estrategia.
Resumir
La estrategia en su conjunto es una estrategia de negociación bidireccional, al mismo tiempo que combina la evolución de los precios y los indicadores cuantitativos para juzgar la tendencia del mercado y la fuerza de la volatilidad, la estrategia es clara y fácil de entender. El espacio de optimización también es relativamente grande, y la estabilidad y la rentabilidad de la estrategia pueden seguir mejorando a través de la optimización de parámetros y la combinación de indicadores.
/*backtest
start: 2022-12-06 00:00:00
end: 2023-12-12 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/
// © ahancock
//@version=4
strategy(
title = "Hancock - Filtered Volume OBV OSC [Strategy]",
initial_capital = 1000,
overlay = false,
commission_type = strategy.commission.percent,
commission_value= 0.075)
// Inputs
source = input(close, title = "Source", type = input.source)
use_volume_filter = input(true, title = "Use Volume Filter", type = input.bool)
vol_filter_length = input(20, title = "Volume Filter - Length", type = input.integer, minval = 1)
vol_filter_multiplier = input(1.2, title = "Volume Filter - Multiplier", type = input.float, minval = 0.1, step = 0.1)
use_osc = input(true, title = "Use Oscillator", type = input.bool)
osc_length = input(40, title = "Oscillator - Signal Length", type = input.integer, minval = 1)
channel_length = input(65, title = "Channel - Slow Length", minval = 5, maxval = 200, step = 5)
channel_percent = input(70, title = "Channel - Fast Length Percent", minval = 5, maxval = 100, step = 5)
trade_both = "Both", trade_long = "Long", trade_short = "Short"
trade_direction = input("Both", title = "Trade - Direction", options = [trade_both, trade_long, trade_short])
trade_leverage = input(2, title = "Trade - Leverage", type = input.integer, minval = 1, maxval = 100)
trade_stop = input(7.5, title = "Trade - Stop Loss %", type = input.float, minval = 0.5, step = 0.5, maxval = 100)
trade_trail_threshold = input(5, title = "Trade - Trail Stop Threshold %", type = input.float, minval = 0.5, step = 0.5, maxval = 100)
trade_trail = input(5, title = "Trade - Trail Stop Minimum %", type = input.float, minval = 0.5, step = 0.5, maxval = 100)
trade_risk = input(100, title = "Trade - Risk %", type = input.integer, step = 1, minval = 1, maxval = 100)
test_year = input(2019, "Test - Year", type = input.integer, minval = 1970, maxval = 2222)
test_month = input(01, "Test - Month", type = input.integer, minval = 1, maxval = 12)
test_day = input(01, "Test - Day", type = input.integer, minval = 1, maxval = 31)
// Functions
get_round(value, precision) => round(value * (pow(10, precision))) / pow(10, precision)
get_obv(values, filter_length, filter_multiplier, use_filter, osc_length, use_osc) =>
threshold = abs(avg(volume, filter_length) - (stdev(volume, filter_length) * filter_multiplier))
obv = 0.0
if (use_filter and volume < threshold)
obv := nz(obv[1])
else
obv := nz(obv[1]) + sign(change(values)) * volume
use_osc ? (obv - ema(obv, osc_length)) : obv
get_dc(high_values, low_values, length) =>
top = highest(high_values, length)
bot = lowest(low_values, length)
mid = bot + ((top - bot) / 2)
[top, mid, bot]
get_dcs(high_values, low_values, length, length_percent) =>
slow_length = length
fast_length = slow_length * length_percent / 100
[slow_top, slow_mid, slow_bot] =
get_dc(high_values, low_values, slow_length)
[fast_top, fast_mid, fast_bot] =
get_dc(high_values, low_values, fast_length)
[slow_top, slow_mid, slow_bot, fast_top, fast_mid, fast_bot]
// Strategy
obv = get_obv(
source,
vol_filter_length,
vol_filter_multiplier,
use_volume_filter,
osc_length,
use_osc)
[slow_top_price, _, slow_bot_price, fast_top_price, _, fast_bot_price] =
get_dcs(high, low, channel_length, channel_percent)
[slow_top_obv, _, slow_bot_obv, fast_top_obv, _, fast_bot_obv] =
get_dcs(obv, obv, channel_length, channel_percent)
enter_long_price = high > slow_top_price[1]
exit_long_price = low < fast_bot_price[1]
enter_short_price = low < slow_bot_price[1]
exit_short_price = high > fast_top_price[1]
enter_long_obv = obv > slow_top_obv[1] and (use_osc ? obv > 0 : true)
enter_short_obv = obv < fast_bot_obv[1] and (use_osc ? obv < 0 : true)
exit_long_obv = obv < slow_bot_obv[1]
exit_short_obv = obv > fast_top_obv[1]
// Trade Conditions
can_trade = true
enter_long_condition = enter_long_obv and enter_long_price
exit_long_condition = exit_long_obv and exit_long_price
enter_short_condition = enter_short_obv and enter_short_price
exit_short_condition = exit_short_obv and exit_short_price
position_signal = 0
position_signal :=
enter_long_condition ? 1 :
enter_short_condition ? -1 :
exit_long_condition or exit_short_condition ? 0 :
position_signal[1]
// Positions
test_time = timestamp(test_year, test_month, test_day, 0, 0)
if (time >= test_time and strategy.opentrades == 0)
contracts = get_round((strategy.equity * trade_leverage / close) * (trade_risk / 100), 4)
if (trade_direction == trade_both or trade_direction == trade_long)
strategy.entry(
"LONG",
strategy.long,
qty = contracts,
when = enter_long_condition)
if (trade_direction == trade_both or trade_direction == trade_short)
strategy.entry(
"SHORT",
strategy.short,
qty = contracts,
when = enter_short_condition)
in_long = strategy.position_size > 0
in_short = strategy.position_size < 0
float long_high = na
float short_low = na
long_high := in_long ? high >= nz(long_high[1], low) ? high : long_high[1] : na
short_low := in_short ? low <= nz(short_low[1], high) ? low : short_low[1] : na
long_change = abs(((long_high - strategy.position_avg_price) / strategy.position_avg_price) * 100)
short_change = abs(((short_low - strategy.position_avg_price) / strategy.position_avg_price) * 100)
threshold_difference = (strategy.position_avg_price / trade_leverage) * (trade_trail_threshold / 100)
long_trail_threshold = in_long ? strategy.position_avg_price + threshold_difference : na
short_trail_threshold = in_short ? strategy.position_avg_price - threshold_difference : na
long_trail = in_long and long_high > long_trail_threshold ?
long_high - (long_high / trade_leverage) * (trade_trail / 100) : na
short_trail = in_short and short_low < short_trail_threshold ?
short_low + (short_low / trade_leverage) * (trade_trail / 100) : na
stop_difference = (strategy.position_avg_price / trade_leverage) * (trade_stop / 100)
long_stop = in_long ? long_high > long_trail_threshold ? long_trail : strategy.position_avg_price - stop_difference : na
short_stop = in_short ? short_low < short_trail_threshold ? short_trail : strategy.position_avg_price + stop_difference : na
strategy.exit("S/L", "LONG",
stop = long_stop,
qty = abs(get_round(strategy.position_size, 4)))
strategy.exit("S/L", "SHORT",
stop = short_stop,
qty = abs(get_round(strategy.position_size, 4)))
strategy.close_all(when = abs(change(position_signal)) > 0)
// Plots
plotshape(enter_long_condition, "Enter Long", shape.diamond, location.top, color.green)
plotshape(exit_long_condition, "Exit Long", shape.diamond, location.top, color.red)
plotshape(enter_short_condition, "Enter Short", shape.diamond, location.bottom, color.green)
plotshape(exit_short_condition, "Exit Short", shape.diamond, location.bottom, color.red)
color_green = #63b987
color_red = #eb3d5c
hline(use_osc ? 0 : na)
plot(use_osc ? obv : na, color = color.silver, style = plot.style_area, transp = 90)
plot(obv, color = color.white, style = plot.style_line, linewidth = 2, transp = 0)
plot_slow_top = plot(slow_top_obv, color = color_green, linewidth = 2, transp = 60)
plot_slow_bot = plot(slow_bot_obv, color = color_green, linewidth = 2, transp = 60)
fill(plot_slow_top, plot_slow_bot, color = color_green, transp = 90)
plot_fast_top = plot(fast_top_obv, color = color_red, linewidth = 2, transp = 60)
plot_fast_bot = plot(fast_bot_obv, color = color_red, linewidth = 2, transp = 60)
fill(plot_fast_top, plot_fast_bot, color = color_red, transp = 90)