Cette stratégie utilise des indicateurs techniques interpériodiques pour identifier l'orientation de la tendance, combinés au filtrage de la tendance et au filtrage de la volatilité, afin d'obtenir un trading de suivi de tendance à faible risque.
Utilisez les percées de point bas élevé pour déterminer les signaux d'achat et de vente.
L'indicateur Trendflex détermine la direction de la tendance principale. Cet indicateur combine des techniques de doublement de lissage et peut identifier efficacement les sections moyennes de la tendance. Une valeur supérieure à 1 indique une tendance à la hausse, tandis qu'une valeur inférieure à -1 indique une tendance à la baisse. Ici, nous avons besoin de Trendflex > 1 pour les longs et < -1 pour les courts, filtrant ainsi les états de consolidation.
Utilisez les bandes de Bollinger pour identifier les plages d'oscillation. Évitez les longs et les shorts lorsque le prix de clôture est dans la bande.
Utilisez le stop loss et le profit pour gérer les positions.
Les indicateurs interpériodiques combinés à des techniques de doubles lissage permettent d'identifier efficacement les tendances et d'éviter les fluctuations des marchés.
En tenant compte à la fois de la direction de la tendance et des modèles de volatilité, les signaux de trading sont plus fiables.
Les paramètres raisonnables de stop loss et de prise de bénéfices bloquent les bénéfices et empêchent les pertes de s'étendre.
La stratégie est relativement simple et facile à mettre en œuvre.
Les signaux de rupture peuvent avoir de fausses ruptures, ce qui entraîne des transactions erronées.
Les paramètres de cycle fixe ne peuvent pas s'adapter aux changements du marché. Une optimisation dynamique des paramètres peut être envisagée.
L'absence d'arrêt des prix ne permet pas d'éviter d'énormes pertes dues à des conditions de marché extrêmes.
Les points de prise de profit et de stop-loss fixes ne peuvent pas être ajustés intelligemment en fonction de la volatilité du marché.
Considérez l'ajout d'autres indicateurs de jugement de tendance pour former une combinaison de stratégies afin d'améliorer la précision du jugement.
Ajouter des modules d'identification des oscillations pour mettre en pause la négociation lorsque les oscillations sont sévères afin de réduire les risques.
Introduire des algorithmes d'apprentissage automatique pour obtenir une optimisation dynamique des paramètres.
Ajouter des modules d'arrêt des pertes pour arrêter les pertes lorsque les pertes atteignent un certain seuil.
Calculer les ratios de prise de profit et de stop loss basés sur la volatilité du marché pour obtenir un ajustement intelligent de la prise de profit et du stop loss.
Dans l'ensemble, cette stratégie est relativement stable et fiable, tout en ayant une marge d'amélioration. L'idée principale est de déterminer la direction de la tendance à travers les cycles, puis de filtrer en utilisant des indicateurs de force de tendance et des indicateurs de volatilité pour générer des signaux de haute qualité. Cette stratégie simple et pratique est très adaptée au suivi des tendances à moyen et long terme.
/*backtest
start: 2023-08-27 00:00:00
end: 2023-09-26 00:00:00
period: 4h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("Eltrut", shorttitle="Eltrut Strat", overlay=true, pyramiding=0, default_qty_type= strategy.percent_of_equity,calc_on_order_fills=false, slippage=25,commission_type=strategy.commission.percent,commission_value=0.075)
testStartYear = input(2016, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(2030, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(30, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
// R E F L E X / T R E N D F L E X
f_supersmoother(_src,_len)=>
pi = 2 * asin(1)
_a = exp(-sqrt(2) * pi / _len)
_c2 = 2 * _a * cos(sqrt(2) * pi / _len)
_c3 = -_a * _a
_c1 = 1 - _c2 - _c3
_out = 0.0
_out := _c1 * _src + _c2 * nz(_out[1],nz(_src[1],_src)) + _c3 * nz(_out[2],nz(_src[2],nz(_src[1],_src)))
f_IQIFM(_src1,_max)=>
_src = _src1 < 0.001 ? _src1 * 10000 : _src1
_imult = 0.635, _qmult = 0.338 , _inphase = 0.0, _quad = 0.0
_re = 0.0, _im = 0.0, _deltaphase = 0.0, _instper = 0.0, _per = 0.0, _v4 = 0.0
_v1 = _src - nz(_src[7])
_inphase := 1.25 * (nz(_v1[4]) - _imult * _v1[2]) + _imult * nz(_inphase[3])
_quad := _v1[2] - _qmult * _v1 + _qmult * nz(_quad[2])
_re := 0.2 * (_inphase * _inphase[1] + _quad * _quad[1]) + 0.8 * nz(_re[1])
_im := 0.2 * (_inphase * _quad[1] - _inphase[1] * _quad) + 0.8 * nz(_im[1])
if _re != 0.0
_deltaphase := atan(_im / _re)
for i = 0 to _max
_v4 := _v4 + _deltaphase[i]
if _v4 > 4 * asin(1) and _instper == 0.0
_instper := i
if _instper == 0.0
_instper := nz(_instper[1])
_per := 0.25 * _instper + 0.75 * nz(_per[1])
_per
f_flex(_src1, _fixed_len, _reflex) =>
_src = _src1
_len = _fixed_len
_ss1 = f_supersmoother(_src, _len)
_ss = _ss1
_slope = (_ss[_len] - _ss) / _len
_sum = 0.0
for _i = 1 to _len
_c1 = _reflex ? _ss + _i * _slope - _ss[_i] : _ss - _ss[_i]
_sum := _sum + _c1
_sum := _sum / _len
_ms = 0.0
_ms := 0.04 * pow(_sum,2) + 0.96 * nz(_ms[1])
_flex1 = _ms != 0 ? _sum / sqrt(nz(_ms)) : 0.0
_flex = _flex1
_flex
rflx = f_flex(close, 20, true)
trndflx = f_flex(close, 20, false)
// S I G N A L
hi7 = highest(7)
lo7 = lowest(7)
long_cond = crossunder(close, lo7[1])
short_cond = crossover(close, hi7[1])
// F I L T E R S
long_filter1 = trndflx < 1
short_filter1 = trndflx > -1
basis = sma(close, 35)
dev = 3 * stdev(close, 35)
long_filter2 = close > basis - dev
short_filter2 = close < basis + dev
// S T R A T E G Y
long = long_cond and long_filter1 and long_filter2
short = short_cond and short_filter1 and short_filter2
if( true)
strategy.entry("Long", strategy.long, when = long)
strategy.entry("Long", strategy.long, when = short)
// User Options to Change Inputs (%)
stopPer = input(3, title='Stop Loss %', type=input.float) / 100
takePer = input(9, title='Take Profit %', type=input.float) / 100
// Determine where you've entered and in what direction
longStop = strategy.position_avg_price * (1 - stopPer)
shortStop = strategy.position_avg_price * (1 + stopPer)
shortTake = strategy.position_avg_price * (1 - takePer)
longTake = strategy.position_avg_price * (1 + takePer)
if strategy.position_size > 0
strategy.exit(id="Exit Long", stop=longStop, limit=longTake)
if strategy.position_size < 0
strategy.exit(id="Exit Short", stop=shortStop, limit=shortTake)
// P L O T
plotshape(long, color = #1e90ff, text = "", style=shape.triangleup, location=location.belowbar, size=size.tiny)
plotshape(short, color = #ff69b4, text = "", style=shape.triangledown, location=location.abovebar, size=size.tiny)
alertcondition(long, "Long", "Enter Long")
alertcondition(short, "Short", "Enter S")