Stratégie de bloc de tendance
ChaoZhang
Aperçu
La stratégie de bloc de tendance est une stratégie de négociation basée sur le pourcentage de variation des prix ou sur le nombre de points de rebond. Elle permet d’afficher clairement les tendances locales et les points de basculement sur le graphique. C’est un outil très utile pour suivre la direction des prix.
Le principe
La stratégie est calculée sur la base du pourcentage de variation des prix ou de l’écart des points de fluctuation (indiqué dans le paramètre de l’écart de la courbe) et affichée sur le graphique sous la forme d’une ligne diagonale.
Chaque ligne est composée d’une ligne moyenne, d’une ligne supérieure et d’une ligne inférieure de référence:
La ligne médiane de référence est égale à la limite supérieure ou inférieure de la ligne précédente ou suivante (si le prix change rapidement sur une période de temps, la ligne médiane de référence de la ligne actuelle sera plus grande que la limite supérieure de la ligne précédente ou plus petite que la limite inférieure de la ligne suivante, un nombre équivalent de variations, en fonction de la direction de la variation des prix). Au début du calcul, la ligne médiane de référence est égale à la valeur initiale de la première ligne.
Le paramètre de la quantité d’acier détermine la quantité de déviation en fonction de la limite supérieure ou inférieure de la direction de la variation des prix. Le paramètre de la courbe de renversement de l’acier détermine la quantité de déviation qui change la direction de la variation des prix.
Règles pour créer une nouvelle ligne:
Si le prix de clôture est supérieur à la limite supérieure et que le prix de clôture est supérieur au prix d’ouverture, la limite supérieure s’élève progressivement et la limite inférieure s’élève progressivement, mais avec une plus petite amplitude.
Si le prix minimum est ≤ le seuil inférieur et le prix de clôture est < le prix d’ouverture, le seuil inférieur se déplace progressivement vers le bas, et le seuil supérieur se déplace également, mais de manière moins marquée.
En ajustant les écarts, on peut voir clairement les tendances locales et les points de basculement sur le graphique. C’est un outil très utile pour suivre les mouvements des prix.
Analyse des avantages
Les tendances de variation des prix sont visualisées et les résistances de soutien sont clairement identifiées.
La diagonale montre clairement la force de la rupture et l’étendue de la régression.
Les tendances de différentes intensités peuvent être identifiées en fonction de la nécessité d’ajuster la pente de la ligne angulaire.
Il est possible de trouver des résistances de soutien plus importantes et de les franchir.
Il est facile de voir le rythme des variations de prix et d’ajuster la position.
Analyse des risques
La diagonale ne peut pas prédire avec précision les mouvements ultérieurs des prix.
Il faut être attentif aux déviations de la tendance, qui peuvent se produire entre la courbe et le prix réel.
Les tendances ne peuvent pas être utilisées comme une stratégie isolée et doivent être évaluées en combinaison avec d’autres indicateurs.
Attention: une mauvaise régulation des paramètres peut entraîner des transactions trop fréquentes.
La possibilité d’un renversement d’alarme lors d’un rappel, qui ne peut pas être suivi à l’aveuglette par des machines.
Il est possible de réduire la taille de la position de manière appropriée, tout en se référant à d’autres indicateurs comme jugement auxiliaire, pour opérer sous une grande tendance.
Direction d’optimisation
Un module de gestion des positions peut être ajouté pour ajuster dynamiquement les positions à différents stades de la tendance.
Il peut être combiné avec un indicateur de volatilité pour réduire la position lorsque la volatilité augmente.
Il est possible de régler un stop loss en fonction du taux de rétractation pour contrôler les pertes individuelles.
Il est possible d’ajouter des filtres pour suspendre la négociation en cas de déviation.
On peut diviser la pente diagonale en plusieurs niveaux pour identifier les variations de tendance de différentes intensités.
Il est possible de suivre les tendances des prix de manière plus stable en ajustant dynamiquement les positions, en définissant les conditions de stop loss et de filtrage.
Résumer
La stratégie en blocs de tendance utilise la ligne diagonale pour afficher intuitivement les changements de tendance des prix, permettant d’identifier clairement les points de résistance et les points de rupture. Cependant, elle ne peut pas s’appuyer sur un jugement indépendant de la ligne diagonale. Elle doit être complétée par d’autres indicateurs pour une analyse globale, tout en contrôlant les risques.
/*backtest
start: 2023-10-06 00:00:00
end: 2023-11-05 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=5
// **********************************************************************************
// This code is invented and written by @StCogitans.
// The idea presented in this code and the rights to this code belong to @StCogitans.
// © https://www.tradingview.com/u/StCogitans
//
// Description.
// Sizeblock - a price change strategy in the form of diagonal rows.
// **********************************************************************************
// STRATEGY
string NAME = 'Sizeblock'
string ACRONYM = 'SB'
bool OVERLAY = true
int PYRAMIDING = 0
string QTY_TYPE = strategy.percent_of_equity
float QTY_VALUE = 100
float CAPITAL = 100
string COM_TYPE = strategy.commission.percent
float COM_VALUE = 0.1
bool ON_CLOSE = false
bool BAR_MAGNIFIER = false
bool OHLC = true
strategy(NAME, ACRONYM, OVERLAY, pyramiding=PYRAMIDING, default_qty_type=QTY_TYPE, default_qty_value=QTY_VALUE, initial_capital=CAPITAL, commission_type=COM_TYPE, commission_value=COM_VALUE, process_orders_on_close=ON_CLOSE, use_bar_magnifier=BAR_MAGNIFIER, fill_orders_on_standard_ohlc=OHLC)
// ARGUMENTS
// Datetime
DTstart = input(timestamp("01 Jan 2000 00:00 +0000"), 'Start time', group='Datetime')
DTfinish = input(timestamp("01 Jan 2080 23:59 +0000"), 'Finish time', group='Datetime')
DTperiod = true
// Main
dev_source = input.string('Close', title='Source', options=["Close", "HighLow"], tooltip='Price data for settlement.', group='Main')
dev_type = input.string('Percentage', title='Deviation', options=['Percentage', 'Ticks'], tooltip='The type of deviation to calculate.', group='Main')
dev_value = input.float(1, title='Quantity', minval=0.001, step=0.01, tooltip='Quantity to be calculated.', group='Main')
dev_back = input.float(2, title='U-turn', minval=0.001, step=0.01, tooltip='Quantity for reversal.', group='Main')
mode = input.string('Limit', title='Positions', options=['Limit', 'Market'], tooltip='Limit or market orders.', group='Main')
direct = input.string('All', title='Direction', options=['All', 'Buy', 'Sell'], tooltip='The type of positions to be opened.', group='Main')
swapping = input.bool(false, title='Swapping', tooltip='Swap points to open a new position.', group='Main')
// CALCULATION SYSTEM
Assembling(s, t, v, vb) =>
float a = open
float b = close
float c = s == "HighLow" ? math.round_to_mintick(high) : math.round_to_mintick(b)
float d = s == "HighLow" ? math.round_to_mintick(low) : math.round_to_mintick(b)
float x = math.round_to_mintick(a)
x := nz(x[1], x)
float _v = t == "Ticks" ? syminfo.mintick * v : v
float _vb = t == "Ticks" ? syminfo.mintick * vb : vb
float h = t == "Ticks" ? math.round_to_mintick(x + _v) : math.round_to_mintick(x * (1 + _v / 100))
float l = t == "Ticks" ? math.round_to_mintick(x - _v) : math.round_to_mintick(x * (1 - _v / 100))
h := nz(h[1], h)
l := nz(l[1], l)
if t == "Ticks"
if c >= h and b > a
while c >= h
x := h
h := math.round_to_mintick(h + _v)
l := math.round_to_mintick(x - _vb)
if d <= l and b < a
while d <= l
x := l
l := math.round_to_mintick(l - _v)
h := math.round_to_mintick(x + _vb)
else if t == "Percentage"
if c >= h and b > a
while c >= h
x := h
h := math.round_to_mintick(h * (1 + _v / 100))
l := math.round_to_mintick(x * (1 - _vb / 100))
if d <= l and b < a
while d <= l
x := l
l := math.round_to_mintick(l * (1 - _v / 100))
h := math.round_to_mintick(x * (1 + _vb / 100))
[x, h, l]
[lx, lh, ll] = Assembling(dev_source, dev_type, dev_value, dev_back)
// PLOT
// Lines
plot_up = plot(lh, color=color.new(color.green, 50), style=plot.style_line, linewidth=1)
plot_main = plot(lx, color=color.new(color.silver, 50), style=plot.style_line, linewidth=1)
plot_down = plot(ll, color=color.new(color.red, 50), style=plot.style_line, linewidth=1)
// Areas
fill(plot_up, plot_main, lh, lx, color.new(color.teal, 80), color.new(color.teal, 80))
fill(plot_main, plot_down, lx, ll, color.new(color.maroon, 80), color.new(color.maroon, 80))
// TRADING
// Alert variables
int Action = -1
int PosType = -1
int OrderType = -1
float Price = -1.0
// Direction variables
bool ifBuy = direct == "All" or direct == "Buy" ? true : false
bool ifSell = direct == "All" or direct == "Sell" ? true : false
// Market entries
if (strategy.closedtrades + strategy.opentrades == 0 or mode == "Market") and DTperiod
if ((swapping and lx < nz(lx[1], lx)) or (not swapping and lx > nz(lx[1], lx))) and ifBuy
Action := 1
PosType := 1
OrderType := 1
Price := math.round_to_mintick(close)
strategy.entry('Long', strategy.long)
if ((swapping and lx > nz(lx[1], lx)) or (not swapping and lx < nz(lx[1], lx))) and ifSell
Action := 2
PosType := 2
OrderType := 1
Price := math.round_to_mintick(close)
strategy.entry('Short', strategy.short)
// Closing positions by market
if DTperiod and mode == "Market"
if direct == "Buy" and strategy.position_size > 0
if swapping and lx > nz(lx[1], lx)
Action := 2
PosType := 3
OrderType := 1
Price := math.round_to_mintick(close)
strategy.close('Long', comment='Close')
if not swapping and lx < nz(lx[1], lx)
Action := 2
PosType := 3
OrderType := 1
Price := math.round_to_mintick(close)
strategy.close('Long', comment='Close')
if direct == "Sell" and strategy.position_size < 0
if swapping and lx < nz(lx[1], lx)
Action := 1
PosType := 3
OrderType := 1
Price := math.round_to_mintick(close)
strategy.close('Short', comment='Close')
if not swapping and lx > nz(lx[1], lx)
Action := 1
PosType := 3
OrderType := 1
Price := math.round_to_mintick(close)
strategy.close('Short', comment='Close')
// Limit entries and exits
if swapping and DTperiod and mode == "Limit"
if strategy.position_size < 0
Action := 1
PosType := 1
OrderType := 2
Price := ll
if ifBuy
strategy.entry('Long', strategy.long, limit=ll)
else
PosType := 3
strategy.exit('Exit', limit=ll)
if strategy.position_size > 0
Action := 2
PosType := 2
OrderType := 2
Price := lh
if ifSell
strategy.entry('Short', strategy.short, limit=lh)
else
PosType := 3
strategy.exit('Exit', limit=lh)
if strategy.closedtrades + strategy.opentrades > 0 and strategy.position_size == 0
if ifBuy
Action := 1
PosType := 1
OrderType := 2
Price := ll
strategy.entry('Long', strategy.long, limit=ll)
if ifSell
Action := 2
PosType := 2
OrderType := 2
Price := lh
strategy.entry('Short', strategy.short, limit=lh)
if not swapping and DTperiod and mode == "Limit"
if strategy.position_size < 0
Action := 1
PosType := 1
OrderType := 2
Price := lh
if ifBuy
strategy.entry('Long', strategy.long, stop=lh)
else
PosType := 3
strategy.exit('Exit', stop=lh)
if strategy.position_size > 0
Action := 2
PosType := 2
OrderType := 2
Price := ll
if ifSell
strategy.entry('Short', strategy.short, stop=ll)
else
PosType := 3
strategy.exit('Exit', stop=ll)
if strategy.closedtrades + strategy.opentrades > 0 and strategy.position_size == 0
if ifBuy
Action := 1
PosType := 1
OrderType := 2
Price := lh
strategy.entry('Long', strategy.long, stop=lh)
if ifSell
Action := 2
PosType := 2
OrderType := 2
Price := ll
strategy.entry('Short', strategy.short, stop=ll)
// Everything is closed and canceled
if not DTperiod
strategy.cancel_all()
strategy.close_all(comment='Close')
// Alerts
// Convert to string variables
string Action_Txt = Action == 1 ? "Buy" : Action == 2 ? "Sell" : na
string PosType_Txt = PosType == 1 ? "Long" : PosType == 2 ? "Short" : PosType == 3 ? "Flat" : na
string OrderType_Txt = OrderType == 1 ? "Market" : OrderType == 2 ? "Limit" : na
string Price_Txt = Price > 0 ? str.tostring(Price) : na
// Output
if not (Action == nz(Action[1], Action) and Price == nz(Price[1], Price) and OrderType == nz(OrderType[1], OrderType)) and DTperiod
alert('{"pair": "' + syminfo.ticker + '", "direction": "' + Action_Txt + '", "entertype": "' + OrderType_Txt + '", "position": "' + PosType_Txt + '", "price": "' + Price_Txt + '"}')
// *********************
// Good job, Soldier! ;>
// *********************