
La estrategia de codificación de posiciones dinámicas de línea uniforme de múltiples señales es una estrategia de negociación cuantitativa diseñada específicamente para el mercado de criptomonedas, que combina indicadores de análisis técnico con un sistema de gestión de posiciones dinámicas. La idea central es utilizar señales cruzadas de promedios móviles rápidos y lentos y un indicador aleatorio relativamente fuerte y débil (RSI estocástico) para determinar la dirección de la tendencia del mercado y el momento de entrada, mientras se utiliza un método de alza de posición piramidal para responder a la retroalimentación de los precios.
La estrategia se basa en los siguientes componentes tecnológicos centrales:
Sistema de doble media móvilLa estrategia utiliza el cruce de dos medias móviles (rápido y lento) como la principal señal de entrada. El usuario puede elegir entre el promedio móvil simple (SMA), el promedio móvil indexado (EMA) o el promedio móvil de Hull (HMA), y puede optar por cruzar la mediana hacia arriba o hacia abajo según la situación del mercado.
Indicador aleatorio de fuerza y debilidad (RSI estocástico)Como condición de entrada auxiliar, se activa una señal de compra cuando el RSI estocástico lleva el nivel 5 en la línea K, mientras que el promedio móvil rápido está en una tendencia ascendente (aumento de 5 ciclos consecutivos).
Sistema de orden de seguridad dinámica: Después de la entrada inicial, la estrategia establece varias órdenes de seguridad por debajo del nivel de precio predeterminado. Estos niveles de precio se calculan según el parámetro de desviación de precio y el factor de escala de longitud de paso.
Ajuste dinámico del tamaño de las posiciones: El tamaño de cada orden de seguridad aumenta gradualmente según el factor de escala de la escala de la orden de seguridad, formando una estructura de acumulación progresiva.
Mecanismos para equilibrar las ganancias objetivo: La estrategia establece un nivel de beneficio objetivo basado en el precio promedio de la posición, y todas las posiciones serán liquidadas cuando el precio suba a ese nivel.
El proceso de ejecución de la política es el siguiente:
Señales de entrada multidimensionalesCombina el indicador de tendencia (MVA) y el indicador de dinámica (RSI estocástico) para mejorar la precisión de entrada y reducir las señales falsas.
Altamente adaptableLos parámetros de la estrategia son altamente personalizables, y el usuario puede ajustar el tipo de media móvil, el período, la dirección cruzada, el porcentaje de desviación de precios, etc., según los diferentes entornos de mercado y las preferencias de riesgo personales.
Efectos de la media de los costosA través de un sistema de pedidos de seguridad predeterminado, aumenta automáticamente la posición cuando el precio baja, lo que reduce el costo promedio de la posición y mejora la probabilidad de ganancias finales.
Optimización de la eficiencia financieraEl diseño de la escala incremental de los pedidos de seguridad hace que la asignación de fondos sea más eficiente, ya que más fondos se asignan a pedidos de menor precio, en consonancia con la idea de inversión de valor.
Ejecución automáticaUna vez configurados los parámetros, las estrategias se ejecutan de forma totalmente automática, sin necesidad de intervención humana, lo que reduce la toma de decisiones comerciales emocionales.
Adaptabilidad al mercado flexibleLa estrategia puede adaptarse a diferentes condiciones de mercado (bull market o bear market) mediante el ajuste de la dirección de la intersección de las medias móviles.
Riesgo de no hacer daño: La estrategia no tiene un mecanismo de stop loss claramente diseñado, lo que puede causar grandes pérdidas en una situación de caída continua. En condiciones extremas de mercado, como la caída de los precios de los activos o la reducción a cero, puede causar graves pérdidas de capital.
Necesidad de capitalDebido a que la estrategia requiere reservar fondos para varios pedidos de seguridad, y a que el tamaño de cada pedido aumenta, los fondos reales requeridos pueden ser mucho más que la inversión inicial, los inversores deben asegurarse de tener suficiente capital en movimiento.
¿Qué es el prejuicio?El diseño de la estrategia actual sólo apoya el uso de múltiples direcciones y no es muy eficaz en la tendencia bajista a largo plazo. Se recomienda aplicar esta estrategia en activos que en general se ven bien.
Sensibilidad de los parámetrosEl rendimiento de la estrategia depende en gran medida de la configuración de los parámetros, los parámetros incorrectos pueden provocar órdenes de seguridad prematuras o exceso de acumulación.
La trampa del costo promedioAunque la estrategia reduce los costos promedio mediante la acumulación de riesgos, si el valor de los activos continúa cayendo y no se recupera, puede provocar un “retroceso” y un bloqueo de fondos.
Los métodos para mitigar el riesgo incluyen: aplicar la estrategia en activos que en general se ven bien; reservar fondos suficientes para responder a las órdenes de seguridad; revisar periódicamente la coincidencia de los parámetros de la estrategia con el entorno del mercado; establecer un límite en el número máximo de órdenes de seguridad; considerar la adición de un mecanismo de stop loss global en la estrategia.
Aumentar el mecanismo de suspensión de pérdidasLa falta más evidente de la estrategia es la ausencia de un mecanismo de stop loss. Se recomienda la adición de un parámetro de stop loss global, que obliga a cerrar todas las posiciones cuando las pérdidas alcanzan una cierta proporción, para proteger la seguridad de los fondos.
Unirse al filtro de tendencias del mercadoSe puede agregar indicadores de tendencia de períodos más largos, como las medias móviles a largo plazo o el indicador ADX, ejecutando la estrategia solo cuando la dirección de la tendencia principal es consistente, evitando la adición innecesaria de posiciones en un mercado bajista evidente.
Optimización de la lógica de activación de órdenes de seguridadLos ordenes de seguridad actuales se basan únicamente en el disparo de la desviación de precios. Se puede considerar la combinación de volumen de negocios, volatilidad u otros indicadores técnicos para que el disparo de las órdenes de seguridad sea más inteligente.
Ajuste dinámico del objetivo de gananciasSe puede ajustar el nivel de ganancias objetivo en función de la volatilidad del mercado o la dinámica del comportamiento de los precios después de la entrada, y se puede establecer un objetivo de ganancias más alto en un entorno de mercado de alta volatilidad.
Añadida la función de vacíoLa estrategia de expansión apoya la dirección de la inversión en divisas, lo que la hace igualmente efectiva en una tendencia a la baja y mejora la adaptabilidad de la estrategia a todo el mercado.
Añadir control de retrocesoSe establecen límites máximos de retiro, se suspende la negociación o se restablecen los parámetros cuando la estrategia de retiro supera el umbral, para evitar pérdidas continuas en condiciones de mercado desfavorables.
Optimización de parámetros periódicos: Aumentar la función de optimización automática de parámetros y ajustar periódicamente los parámetros en función de los datos recientes del mercado para que la estrategia se adapte a los cambios en las características del mercado.
Estas orientaciones de optimización tienen como objetivo mejorar la capacidad de gestión de riesgos, la adaptabilidad al mercado y la estabilidad a largo plazo de las estrategias, para que puedan obtener un rendimiento relativamente estable en diversos entornos de mercado.
La estrategia de codificación de posiciones dinámicas de línea uniforme de múltiples señales auto-adaptadas ofrece un método de negociación sistematizado para el mercado de criptomonedas mediante la combinación de señales de entrada de medias móviles y indicadores aleatorios relativamente fuertes, junto con un sistema de órdenes de seguridad dinámica. Su principal ventaja es la capacidad de aumentar gradualmente las posiciones de forma automática cuando los precios se reajustan, reducir el costo promedio de la posición y obtener ganancias cuando los precios se recuperan.
Sin embargo, la estrategia también conlleva riesgos evidentes, especialmente la falta de mecanismos de alto riesgo y la pérdida de capital que puede ocasionar en condiciones de desaceleración continua. Al usar esta estrategia, los inversores deben conocer bien sus características de riesgo, asegurarse de tener suficientes reservas de capital y considerar aumentar las medidas adicionales de control de riesgo.
Con la configuración razonable de los parámetros y la dirección de optimización de las recomendaciones, la estrategia puede ser una herramienta poderosa para los inversores a largo plazo en criptomonedas, especialmente para aquellos inversores que creen en el valor a largo plazo de un activo criptográfico en particular, pero que desean optimizar el costo de entrada. En la aplicación práctica, se recomienda que se pruebe a fondo en un entorno simulado y que se ajusten y optimicen los parámetros de la estrategia en función del rendimiento real del mercado.
/*backtest
start: 2024-08-19 00:00:00
end: 2025-08-18 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_OKX","currency":"BTC_USDT","balance":5000}]
*/
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
//
//@version=6
strategy(title = 'PEPE- DCA Strategy', overlay = true, pyramiding = 11, process_orders_on_close = true, commission_value = 0.1)
Base_order_size = input.int(1500, 'Base order Size')/close
Safety_order_size = input.int(350, 'Save order')/close
Triger_Type = input.string('Over', 'Entry at Cross Over / Under', options = ['Over', 'Under'], group = 'Deal start condition > Trading View custom signal', inline = '1', tooltip = 'Deal start condition decision')
Short_Moving_Average = input.string('SMA', 'Short Moving Average', group = 'Deal start condition > Trading View custom signal', inline = '2', options = ['SMA', 'EMA', 'HMA'])
Short_Period = input.int(17, 'Period', group = 'Deal start condition > Trading View custom signal', inline = '2')
Long_Moving_Average = input.string('HMA', 'Long Moving Average', group = 'Deal start condition > Trading View custom signal', inline = '3', options = ['SMA', 'EMA', 'HMA'])
Long_Period = input.int(26, 'Period', group = 'Deal start condition > Trading View custom signal', inline = '3')
Target_profit = input.float(1.9, 'Target profit (%)', step = 0.05, group = 'Take profit / Stop Loss', inline = '1') * 0.01
Max_safety_trades_count = input.int(5, 'Max safety trades count', maxval = 10, group = 'Safety orders', inline = '1')
Price_deviation = input.float(2.45, 'Price deviation to open safety orders (% from initial order)', step = 0.01, group = 'Safety orders', inline = '2') * 0.01
Safety_order_volume_scale = input.float(1.85, 'Safety order volume scale', step = 0.01, group = 'Safety orders', inline = '3')
Safety_order_step_scale = input.float(1.61, 'Safety order step scale', step = 0.01, group = 'Safety orders', inline = '3')
// Position status
status_none = strategy.opentrades == 0
status_long = strategy.position_size[1] == 0 and strategy.position_size > 0
/////////// Moving_Averages
Short_Moving_Average_Line = Short_Moving_Average == 'SMA' ? ta.sma(close, Short_Period) : Short_Moving_Average == 'EMA' ? ta.ema(close, Short_Period) : Short_Moving_Average == 'HMA' ? ta.sma(close, Short_Period) : na
Long_Moving_Average_Line = Long_Moving_Average == 'SMA' ? ta.sma(close, Long_Period) : Long_Moving_Average == 'EMA' ? ta.ema(close, Long_Period) : Long_Moving_Average == 'HMA' ? ta.sma(close, Long_Period) : na
///////////// Moving_Averages long condition
Base_order_Condition = Triger_Type == 'Over' ? ta.crossover(Short_Moving_Average_Line, Long_Moving_Average_Line) : ta.crossunder(Short_Moving_Average_Line, Long_Moving_Average_Line) // Buy when close crossing lower band
//////////////////// Savety order deviation
safety_order_deviation(index) =>
Price_deviation * math.pow(Safety_order_step_scale, index - 1)
pd = Price_deviation
ss = Safety_order_step_scale
//////// Cal of deviation steps
step(i) =>
i == 1 ? pd : i == 2 ? pd + pd * ss : i == 3 ? pd + (pd + pd * ss) * ss : i == 4 ? pd + (pd + (pd + pd * ss) * ss) * ss : i == 5 ? pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss : i == 6 ? pd + (pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss) * ss : i == 7 ? pd + (pd + (pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss) * ss) * ss : i == 8 ? pd + (pd + (pd + (pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss) * ss) * ss) * ss : i == 9 ? pd + (pd + (pd + (pd + (pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss) * ss) * ss) * ss) * ss : i == 10 ? pd + (pd + (pd + (pd + (pd + (pd + (pd + (pd + (pd + pd * ss) * ss) * ss) * ss) * ss) * ss) * ss) * ss) * ss : na
long_line(i) =>
close[1] - close[1] * step(i)
////////// Savety order Triger
Safe_order_line(i) =>
i == 0 ? ta.valuewhen(status_long, long_line(0), 0) : i == 1 ? ta.valuewhen(status_long, long_line(1), 0) : i == 2 ? ta.valuewhen(status_long, long_line(2), 0) : i == 3 ? ta.valuewhen(status_long, long_line(3), 0) : i == 4 ? ta.valuewhen(status_long, long_line(4), 0) : i == 5 ? ta.valuewhen(status_long, long_line(5), 0) : i == 6 ? ta.valuewhen(status_long, long_line(6), 0) : i == 7 ? ta.valuewhen(status_long, long_line(7), 0) : i == 8 ? ta.valuewhen(status_long, long_line(8), 0) : i == 9 ? ta.valuewhen(status_long, long_line(9), 0) : i == 10 ? ta.valuewhen(status_long, long_line(10), 0) : na
l1 = Safe_order_line(1)
l2 = Safe_order_line(2)
l3 = Safe_order_line(3)
l4 = Safe_order_line(4)
l5 = Safe_order_line(5)
l6 = Safe_order_line(6)
l7 = Safe_order_line(7)
l8 = Safe_order_line(8)
l9 = Safe_order_line(9)
l10 = Safe_order_line(10)
//// take profit
TP_line = strategy.position_avg_price * (1 + Target_profit)
//Size of safety orders
safety_order_size(i) =>
Safety_order_size * math.pow(Safety_order_volume_scale, i - 1)
///plots
plot(Short_Moving_Average_Line, 'Short MA', color = color.new(color.red, 0), style = plot.style_line)
plot(Long_Moving_Average_Line, 'Long MA', color = color.new(color.green, 0), style = plot.style_line)
plot(strategy.opentrades == 1 ? l1 : na, 'Safety order1',color = color.red, style = plot.style_linebr)
plot(strategy.opentrades == 2 ? l2 : na, 'Safety order2', color = color.red, style = plot.style_linebr)
plot(strategy.opentrades == 3 ? l3 : na, 'Safety order3', color = color.red, style = plot.style_linebr)
plot(strategy.opentrades == 4 ? l4 : na, 'Safety order4', color =color.red, style = plot.style_linebr)
plot(strategy.opentrades == 5 ? l5 : na, 'Safety order5', color = color.red, style = plot.style_linebr)
plot(strategy.opentrades == 6 ? l6 : na, 'Safety order5', color = color.red, style = plot.style_linebr)
plot(strategy.opentrades == 7 ? l7 : na, 'Safety order6', color = color.red, style = plot.style_linebr)
plot(strategy.opentrades == 8 ? l8 : na, 'Safety order7', color = color.red, style = plot.style_linebr)
plot(strategy.opentrades == 9 ? l9 : na, 'Safety order8', color = color.red, style = plot.style_linebr)
plot(strategy.opentrades == 10 ? l10 : na, 'Safety order9', color = color.red, style = plot.style_linebr)
plot(strategy.position_size > 0 ? TP_line : na, 'Take Profit', color = color.green, style = plot.style_linebr)
///////////////SToch-Rsi
smoothK = input.int(1, "ST_RSI -K settings for long", minval=1)
smoothD = input.int(3, "ST_RSI-D settings for long", minval=1)
lengthRSI = input.int(14, "RSI Length", minval=1)
lengthStoch = input.int(9, "Stochastic Length", minval=1)
src = input(close, title="RSI Source")
rsi1 = ta.rsi(src, lengthRSI)
k = ta.sma(ta.stoch(rsi1, rsi1, rsi1, lengthStoch), smoothK)
////////buy cond- ST_RSI
bk = ta.crossover(k,5)
r = ta.rising(Short_Moving_Average_Line,5)
buy = bk and r
//Stradegy mod
if Base_order_Condition or buy
if (Base_order_Condition or buy ) and strategy.opentrades == 0
strategy.entry('Base order', strategy.long, qty = Base_order_size )
for i = 1 to Max_safety_trades_count by 1
i_s = str.tostring(i)
if strategy.opentrades <= i and strategy.position_size > 0 and not(strategy.position_size == 0)
strategy.entry('Safety order' + i_s, strategy.long, qty = safety_order_size(i) , limit = Safe_order_line(i))
for i = 1 to Max_safety_trades_count by 1
i_s = str.tostring(i)
if status_none
strategy.cancel('Safety order' + i_s)
strategy.exit('TP/SL', 'Base order', limit = TP_line)
strategy.exit('TP/SL', 'Safety order' + i_s, limit = TP_line)
//