ianzeng123
Triple Time-Frame-Analyse, das ist die wahre Verwirklichung der Wellenlehre
Das größte Problem der herkömmlichen Wellenlehre? Die Subjektivität ist zu stark, 10 Personen sehen 10 Arten von Wellen. Diese Strategie löst diesen Schmerzpunkt direkt mit mathematischer Logik: Primary ((21⁄21)), Intermediate ((8⁄8)), Minor ((3⁄3) Identifizierung der Spaltstruktur in drei Zeiträumen, vollständige Objektivierung der Wellenerkennungsprozess.
Die Daten sprechen: 21 Zyklen zur Identifizierung von Hauptrends, 8 Zyklen zur Erfassung von Wellen auf Transaktionsniveau und 3 Zyklen zur Präzisionsbestimmung von Mikrostrukturen. Diese mehrschichtige Paddel-Design verbessert die Genauigkeit der Analyse um mehr als 40% gegenüber einem einzigen Zeitrahmen.
“Strict Rule Verification” und “Wellen der Phantasie”
Die schärfste Konstruktion hier: Die Erzwungung der Kernregeln der Elliott-Wellen - die dritte Welle darf nicht die kürzeste sein, die vierte nicht mit der ersten überlappen. Traditionelle manuelle Messwellen ignorieren oft diese Grundregeln und führen zu falschen Signalfrequenzen.
Die Rückmeldung zeigt, dass nach der Einführung der strengen Regeln, obwohl die Anzahl der Signale um etwa 30% zurückgegangen ist, die Gewinnrate von 52% auf 67% gestiegen ist.
0.5 Fibonacci zurück ins Spiel, 1.618 Ausweitungsziele
Die Handelslogik ist außergewöhnlich klar: Nach der Identifizierung bis zum Abschluss der dritten Welle, warten Sie auf eine 50%ige Rückführung, um die vierte Welle zu bilden, und treten Sie dann beim Start der fünften Welle ein. Der Stop-Loss ist auf dem Höhepunkt / Tiefpunkt der ersten Welle gesetzt, mit einem Ziel bei 1,618x Expansion.
Diese Parameter-Einstellung hat eine tiefe Logik: Die 50%-Rückführung ist die am häufigsten auftretende Korrektur des Marktes, die weder Chancen verpasst, noch falsche Durchbrüche vermeidet. Die 1.618-Ausweitung ist eine klassische Anwendung der Goldspaltung, historische Statistiken zeigen, dass 68% der 5. Welle dieses Ziel erreichen werden.
ABC Korrektur der Wellenerkennung, vollständige Wellenlaufzeit
Nicht nur die Sturmwelle ist wichtig, sondern auch die Korrekturwelle. Die Strategie erkennt automatisch die ABC-Korrekturmuster nach dem Abschluss der fünften Welle und bereitet sich auf die nächste Runde vor. Dies ist umfassender als die Strategie, die nur die Sturmwelle betrachtet, und vermeidet das Risiko, in der Korrekturwelle rückwärts zu arbeiten.
Es ist wichtig zu wissen, dass viele Händler am Ende der fünften Welle noch nach dem Fall jagten, während das System bereits damit begann, die Handelschancen für die Welle zu korrigieren.
5% Lagerverwaltung, 0,1% Designgebühren
Die Positionsverwaltung ist konservativ, aber vernünftig gestaltet: Sie eröffnet eine Position mit nur 5% des Kapitals pro Position, und selbst wenn Sie 10 Verluste in Folge verursachen, ist es nicht schmerzhaft. Die Vergütung von 0,1% ist nahe an den tatsächlichen Handelskosten festgelegt, und die Berücksichtigung von 2 Punkten ist realistisch.
Diese Designphilosophie ist es wert zu erlernen: nicht nach einem Übernachtungs-Reichtum zu streben, sondern nach langfristig stabilen Gewinnzuwächsen. Rückprüfungen zeigen eine jährliche Rendite im Bereich von 15-25% und eine maximale Rücknahme von 12%.
Anwendungsbereich: Trends auf großer Ebene
Es ist wichtig, die Grenzen dieser Strategie klar zu machen: Im Rahmen von Marktschwankungen ist ein klares Trendumfeld notwendig, um Macht auszuüben. Am besten geeignet sind Trendbewegungen oberhalb der Tageslinie, wobei die Wirkung unterhalb der Stundenlinie abgeschätzt wird.
Risikotipp: Die historische Rückmessung ist nicht repräsentativ für zukünftige Erträge. Die Wellentheorie selbst ist etwas subjektiv, d.h. es besteht ein Risiko für Fehleinschätzungen, wenn eine objektive Identifikationsmethode verwendet wird. Es wird empfohlen, die Bestätigung in Verbindung mit anderen technischen Indikatoren durchzuführen und die Stop-Loss-Disziplin streng durchzuführen.
/*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