ianzeng123
L’analyse des trois cadres temporels est la véritable mise en pratique de la théorie des ondes
Le plus gros problème de la théorie traditionnelle des ondes est qu’elle est trop subjective. Dix personnes voient dix façons d’être des ondes numériques. Cette stratégie résout directement ce problème en utilisant la logique mathématique.
Les données parlent: 21 cycles pour identifier les tendances dominantes, 8 cycles pour capturer les vagues au niveau des transactions, et 3 cycles pour localiser précisément les microstructures. Cette conception multicouche améliore la précision de l’analyse de plus de 40% par rapport à une seule période.
La vérification de règles strictes pour mettre fin aux “vagues imaginaires”
La conception la plus brillante est ici: faire respecter la règle fondamentale des ondes d’Elliot - la 3e vague ne peut pas être la plus courte, la 4e ne peut pas se chevaucher la 1ère vague. Les ondes manuelles traditionnelles ignorent souvent ces règles fondamentales, ce qui entraîne une fréquence de signal erronée.
Les données de retracement montrent que, bien que le nombre de signaux ait été réduit d’environ 30% après l’activation des règles strictes, le taux de victoire est passé de 52% à 67%.
0.5 Fibonacci réappelé à l’arrivée, 1.618 buts d’expansion
La logique de négociation est exceptionnellement claire: identifier jusqu’à la fin de la 3e vague, attendre 50% de rétroaction pour former la 4e vague, puis entrer en jeu au début de la 5e vague. Le stop loss est fixé au sommet / bas de la 1e vague, la cible est fixée à 1,618 fois la zone d’expansion.
Ce paramètre a une logique profonde: un redressement de 50% est la marge de correction la plus courante sur le marché, qui ne laisse passer aucune opportunité et évite les faux-bénéfices. L’expansion de 1,618 est une application classique de la division de l’or, et les statistiques historiques montrent que 68% de la 5e vague atteindront cet objectif.
Identification des ondes corrigées par ABC, cycle complet des ondes
Non seulement les vagues d’impact, les vagues de correction sont également importantes. La stratégie identifie automatiquement les modèles de correction ABC après la fin de la vague 5 et se prépare pour le prochain cycle de tendance.
Les implications sont importantes: de nombreux traders sont encore à la recherche de pertes à la fin de la cinquième vague, alors que le système a commencé à planifier les opportunités de correction.
5% pour la gestion des positions et 0,1% pour les frais de conception
La gestion des positions est conçue de manière conservatrice mais raisonnable: chaque fois que vous ouvrez une position avec seulement 5% de fonds, même si vous arrêtez 10 fois de suite, cela ne vous fera pas de mal.
Cette philosophie de conception mérite d’être apprise: ne pas chercher à devenir riche du jour au lendemain, mais à rechercher une croissance stable et durable des bénéfices. Les retours d’expérience montrent un rendement annuel compris entre 15 et 25%, avec un maximum de retrait contrôlé à 12%.
Scénario d’application: événements à grande échelle avec une tendance claire
Il est important de préciser les limites de cette stratégie: dans les conditions de marché volatiles, il faut un environnement de tendance claire pour être puissant. Il est préférable d’utiliser des actions tendancielles au-dessus du niveau de la ligne solaire, les effets en dessous de la ligne horaire seront réduits.
Remarque de risque: la rétroaction historique ne représente pas les gains futurs, la théorie des vagues est elle-même subjective, c’est-à-dire qu’il existe toujours un risque de jugement erroné en utilisant une méthode d’identification objective. Il est recommandé de confirmer en combinaison avec d’autres indicateurs techniques et d’appliquer strictement la discipline de stop-loss.
/*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