ianzeng123
El análisis de los tres marcos temporales es la verdadera aplicación de la teoría de las ondas
El mayor problema de la teoría de ondas tradicional es que es demasiado subjetiva, y 10 personas ven 10 formas de ondas numéricas. Esta estrategia resuelve este punto de dolor directamente con la lógica matemática: Primary ((21⁄21)), Intermediate ((8⁄8)), y Minor ((3⁄3) Identificación de la estructura de descomposición en tres marcos de tiempo, y el proceso de identificación de ondas completamente objetivo.
Los datos hablan: 21 períodos para identificar tendencias dominantes, 8 períodos para capturar ondas a nivel de transacción y 3 períodos para ubicar con precisión las microestructuras. Este diseño multicamillado mejora la precisión del análisis en un solo marco de tiempo en más del 40%
Verificación de reglas rigurosas para detener las “ondas imaginarias”
El diseño más ingenioso está aquí: obligar a cumplir con las reglas centrales de las ondas de Elliott - la tercera no puede ser la más corta, la cuarta no puede superponerse a la primera. Las ondas de cálculo manuales tradicionales a menudo ignoran estas reglas básicas, lo que lleva a la emisión de señales erróneas.
Los datos de retrospectiva muestran que, aunque el número de señales se redujo en un 30% después de activar las reglas estrictas, la tasa de éxito aumentó del 52% al 67% .
0.5 Fibonacci regreso a la cancha, 1.618 objetivo de expansión
La lógica de negociación es excepcionalmente clara: se identifica hasta la finalización de la tercera ola, se espera un 50% de reajuste para formar la cuarta ola, y luego se entra en juego cuando se inicia la quinta ola. El stop loss se establece en el punto más alto / más bajo de la primera ola, y el objetivo se establece en 1.618 veces el punto de expansión.
Este ajuste de parámetros tiene una lógica profunda: el 50% de retroceso es la amplitud de corrección más común en el mercado, no se pierde la oportunidad ni se evita un falso avance. La expansión de 1.618 es una aplicación clásica de la división de oro, y las estadísticas históricas muestran que la 5a ola del 68% alcanzará este objetivo.
Reconocimiento de la onda corregida ABC, ciclo completo de la onda
No solo es importante la onda de choque, sino también la corrección. La estrategia identifica automáticamente el patrón de corrección ABC después de la finalización de la onda 5 para prepararse para la siguiente ronda de tendencias. Esto es más completo que ver solo la estrategia de la onda de choque y evita el riesgo de operar en contracorriente en la onda de corrección.
El significado real es importante: muchos traders están persiguiendo caídas al final de la quinta ola, y el sistema ya ha comenzado a diseñar oportunidades de negociación para corregir la ola.
5% para gestión de la posición, 0.1% para el diseño de comisiones
El diseño de la gestión de la posición es conservador pero razonable: abrir una posición con solo el 5% de los fondos cada vez, incluso si se detiene 10 veces seguidas, no se estremecerá. La tarifa de procesamiento del 0.1% se establece cerca del costo real de la transacción, y la consideración de puntos de deslizamiento de 2 puntos también es realista.
Esta es la filosofía de diseño que vale la pena aprender: no buscar la riqueza de la noche a la mañana, sino buscar el crecimiento de las ganancias estables a largo plazo. La retrospectiva muestra una rentabilidad anual en el rango de 15-25%, con un control máximo de retiro dentro del 12%.
Escenario de aplicación: Situaciones a gran escala con una tendencia clara
Hay que tener en cuenta las limitaciones de esta estrategia: en un mercado convulso, el impacto se debe a una clara tendencia. Lo más adecuado es que la tendencia se manifieste por encima de la línea diaria, mientras que los efectos por debajo de la línea horaria se reducen.
Sugerencia de riesgo: la retroalimentación histórica no representa los beneficios futuros, la teoría de la onda en sí tiene una cierta subjetividad, es decir, el uso de métodos de identificación objetivas, sigue existiendo el riesgo de error. Se recomienda la confirmación en combinación con otros indicadores técnicos, y se aplica estrictamente la disciplina de deterioro.
/*backtest
start: 2025-08-01 00:00:00
end: 2025-12-02 08:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © mbedaiwi2
//@version=6
strategy("Elliott Wave Full Fractal System Clean", overlay=true, max_labels_count=500, max_lines_count=500, max_boxes_count=500, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=5, commission_type=strategy.commission.percent, commission_value=0.1, slippage=2)
//══════════════════════════════════════════════════════════════════════════════
// 1. SETTINGS
//══════════════════════════════════════════════════════════════════════════════
grpCycle = "1. Primary Degree (Macro Trend)"
showPrimary = input.bool(true, "Show Primary Waves (1, 2...)", group=grpCycle)
lenPriL = input.int(21, "Primary Lookback Left", group=grpCycle)
lenPriR = input.int(21, "Primary Lookback Right", group=grpCycle)
grpInter = "2. Intermediate Degree (Trading Degree)"
showInter = input.bool(true, "Show Intermediate Waves ( (1), (2)... )", group=grpInter)
lenIntL = input.int(8, "Intermediate Lookback Left", group=grpInter)
lenIntR = input.int(8, "Intermediate Lookback Right", group=grpInter)
grpMinor = "3. Minor Degree (Micro Structure)"
showMinor = input.bool(true, "Show Minor Waves ( i, ii... )", group=grpMinor)
lenMinL = input.int(3, "Minor Lookback Left", group=grpMinor)
lenMinR = input.int(3, "Minor Lookback Right", group=grpMinor)
grpRules = "Theory Rules"
rule_Strict = input.bool(true, "Strict Rules (No Overlap, W3 Not Shortest)", group=grpRules)
showABC = input.bool(true, "Show ABC Corrections", group=grpRules)
grpTrade = "STRATEGY SETTINGS"
trade_on = input.bool(true, "Active Trading Signals", group=grpTrade)
fib_entry = input.float(0.5, "W4 Entry Fib (0.5 = 50% Pullback)", minval=0.3, maxval=0.7, step=0.05, group=grpTrade)
fib_target = input.float(1.618, "W5 Target Extension", group=grpTrade)
//══════════════════════════════════════════════════════════════════════════════
// 2. HELPER FUNCTIONS
//══════════════════════════════════════════════════════════════════════════════
// Visual Styles
f_get_style(_degree) =>
if _degree == "Primary"
[color.new(#2962FF, 0), "Circle", 3] // Blue
else if _degree == "Intermediate"
[color.new(#00E676, 0), "Paren", 2] // Green
else
[color.new(#FF5252, 0), "Roman", 1] // Red
// Label Drawer
f_draw_wave(int _idx, float _price, int _count, bool _isBull, string _degree) =>
[cWave, fmt, wid] = f_get_style(_degree)
string txt = ""
// Formatting logic
if fmt == "Circle"
txt := _count==1?"①":_count==2?"②":_count==3?"③":_count==4?"④":_count==5?"⑤":_count==11?"Ⓐ":_count==12?"Ⓑ":_count==13?"Ⓒ":"?"
else if fmt == "Paren"
txt := _count==1?"(1)":_count==2?"(2)":_count==3?"(3)":_count==4?"(4)":_count==5?"(5)":_count==11?"(A)":_count==12?"(B)":_count==13?"(C)":"?"
else
txt := _count==1?"i":_count==2?"ii":_count==3?"iii":_count==4?"iv":_count==5?"v":_count==11?"a":_count==12?"b":_count==13?"c":"?"
label.new(_idx, na, txt, xloc.bar_index,
_isBull ? yloc.abovebar : yloc.belowbar,
cWave,
_isBull ? label.style_label_down : label.style_label_up,
color.white, _degree == "Primary" ? size.normal : size.small)
// Pivot Finder
f_find_pivots(_L, _R) =>
float _ph = ta.pivothigh(high, _L, _R)
float _pl = ta.pivotlow(low, _L, _R)
var array<int> _idx = array.new_int()
var array<float> _prc = array.new_float()
var array<int> _typ = array.new_int()
if not na(_ph)
array.push(_idx, bar_index[_R])
array.push(_prc, _ph)
array.push(_typ, 1)
if not na(_pl)
array.push(_idx, bar_index[_R])
array.push(_prc, _pl)
array.push(_typ, -1)
[_idx, _prc, _typ]
//══════════════════════════════════════════════════════════════════════════════
// 3. VISUALIZATION ENGINE
//══════════════════════════════════════════════════════════════════════════════
f_process_degree(string _degName, int _lenL, int _lenR, bool _show) =>
[idx, prc, typ] = f_find_pivots(_lenL, _lenR)
var int lastIdx = 0
var int lastW5Idx = 0
var bool lastWasBull = false
if _show and array.size(idx) >= 6
int sz = array.size(idx)
int i0=array.get(idx,sz-6), i1=array.get(idx,sz-5), i2=array.get(idx,sz-4), i3=array.get(idx,sz-3), i4=array.get(idx,sz-2), i5=array.get(idx,sz-1)
float p0=array.get(prc,sz-6), p1=array.get(prc,sz-5), p2=array.get(prc,sz-4), p3=array.get(prc,sz-3), p4=array.get(prc,sz-2), p5=array.get(prc,sz-1)
int t0=array.get(typ,sz-6)
// --- IMPULSE WAVE DETECTION ---
if i0 > lastIdx
// Bullish 5-Wave
if t0 == -1 and p1>p0 and p3>p1 and p5>p3 and p2>p0 and p4>p2
bool r3 = rule_Strict ? (math.abs(p3-p2) > math.abs(p1-p0)) : true // W3 > W1
bool r4 = rule_Strict ? (p4 > p1) : true // No Overlap
if r3 and r4
lastIdx := i5
lastW5Idx := i5
lastWasBull := true
// Draw Labels
f_draw_wave(i1, p1, 1, true, _degName)
f_draw_wave(i2, p2, 2, true, _degName)
f_draw_wave(i3, p3, 3, true, _degName)
f_draw_wave(i4, p4, 4, true, _degName)
f_draw_wave(i5, p5, 5, true, _degName)
// Connect Lines
[c, f, w] = f_get_style(_degName)
// Bearish 5-Wave
else if t0 == 1 and p1<p0 and p3<p1 and p5<p3 and p2<p0 and p4<p2
bool r3b = rule_Strict ? (math.abs(p3-p2) > math.abs(p1-p0)) : true
bool r4b = rule_Strict ? (p4 < p1) : true
if r3b and r4b
lastIdx := i5
lastW5Idx := i5
lastWasBull := false
f_draw_wave(i1, p1, 1, false, _degName)
f_draw_wave(i2, p2, 2, false, _degName)
f_draw_wave(i3, p3, 3, false, _degName)
f_draw_wave(i4, p4, 4, false, _degName)
f_draw_wave(i5, p5, 5, false, _degName)
[c, f, w] = f_get_style(_degName)
// --- ABC CORRECTION DETECTION ---
if showABC and lastW5Idx > 0 and i3 >= lastW5Idx
// Looking for 3 moves (A-B-C) after W5
int ia=i3, ib=i4, ic=i5
float pa=p3, pb=p4, pc=p5
// If previous was Bullish, we look for Down-Up-Down
if lastWasBull and p3 < p2 // First move down
if pc < pa and pb < array.get(prc, sz-4) // C lower than A, B lower than Start
lastIdx := ic // Update so we don't draw over it
f_draw_wave(ia, pa, 11, false, _degName) // A
f_draw_wave(ib, pb, 12, true, _degName) // B
f_draw_wave(ic, pc, 13, false, _degName) // C
[c, f, w] = f_get_style(_degName)
// If previous was Bearish, we look for Up-Down-Up
if not lastWasBull and p3 > p2
if pc > pa and pb > array.get(prc, sz-4)
lastIdx := ic
f_draw_wave(ia, pa, 11, true, _degName) // A
f_draw_wave(ib, pb, 12, false, _degName) // B
f_draw_wave(ic, pc, 13, true, _degName) // C
[c, f, w] = f_get_style(_degName)
f_process_degree("Primary", lenPriL, lenPriR, showPrimary)
f_process_degree("Intermediate", lenIntL, lenIntR, showInter)
f_process_degree("Minor", lenMinL, lenMinR, showMinor)
//══════════════════════════════════════════════════════════════════════════════
// 4. TRADING ENGINE (Intermediate Degree)
//══════════════════════════════════════════════════════════════════════════════
[t_idx, t_prc, t_typ] = f_find_pivots(lenIntL, lenIntR)
var int trade_lastW3 = 0
var int trade_dir = 0 // 1=Long, -1=Short
var float trade_entry = na
var float trade_stop = na
var float trade_tp = na
if trade_on and array.size(t_idx) >= 4
int sz = array.size(t_idx)
int i0=array.get(t_idx,sz-4), i1=array.get(t_idx,sz-3), i2=array.get(t_idx,sz-2), i3=array.get(t_idx,sz-1)
float p0=array.get(t_prc,sz-4), p1=array.get(t_prc,sz-3), p2=array.get(t_prc,sz-2), p3=array.get(t_prc,sz-1)
int t0=array.get(t_typ,sz-4)
// Check for NEW WAVE 3
if i3 > trade_lastW3
// --- LONG SETUP ---
if t0 == -1
bool isBull = (p1 > p0) and (p2 > p0) and (p3 > p1) and (p2 < p1)
bool rule3 = rule_Strict ? (p3 - p2) > (p1 - p0) : true
if isBull and rule3
trade_lastW3 := i3
float w3_height = p3 - p2
trade_entry := p3 - (w3_height * fib_entry)
trade_stop := p1
trade_tp := p3 + (w3_height * fib_target)
if trade_entry > trade_stop
trade_dir := 1
// --- SHORT SETUP ---
else if t0 == 1
bool isBear = (p1 < p0) and (p2 < p0) and (p3 < p1) and (p2 > p1)
bool rule3b = rule_Strict ? (p2 - p3) > (p0 - p1) : true
if isBear and rule3b
trade_lastW3 := i3
float w3_height = p2 - p3
trade_entry := p3 + (w3_height * fib_entry)
trade_stop := p1
trade_tp := p3 - (w3_height * fib_target)
if trade_entry < trade_stop
trade_dir := -1
// EXECUTE TRADE
if trade_dir == 1
if low <= trade_entry
strategy.entry("Sniper Long", strategy.long)
strategy.exit("TP/SL", "Sniper Long", limit=trade_tp, stop=trade_stop)
label.new(bar_index, na, "Long Exec", style=label.style_label_up, yloc=yloc.belowbar, color=color.blue, textcolor=color.white, size=size.small)
trade_dir := 0
if close < trade_stop
trade_dir := 0
if high > array.get(t_prc, array.size(t_prc)-1)
trade_dir := 0
if trade_dir == -1
if high >= trade_entry
strategy.entry("Sniper Short", strategy.short)
strategy.exit("TP/SL", "Sniper Short", limit=trade_tp, stop=trade_stop)
label.new(bar_index, na, "Short Exec", style=label.style_label_down, yloc=yloc.abovebar, color=color.orange, textcolor=color.white, size=size.small)
trade_dir := 0
if close > trade_stop
trade_dir := 0
if low < array.get(t_prc, array.size(t_prc)-1)
trade_dir := 0