source - source précédente, puis prend la valeur absolue de son changement et la normalise avec la source.
Calcul de la longueur dynamique: utilise la méthode de calcul de la longueur dynamique de BlackCat1402
Analyse composite: Combine les lectures du VAWSI, de la persistance de la tendance et de l'ATR pour générer un indicateur composite.
L'indicateur composite et la direction de tendance actuelle permettent de calculer les niveaux dynamiques d'arrêt-perte et de prise de profit.
Signals de négociation: confirme les croisements et génère des signaux de négociation lorsque le prix franchit complètement la ligne de seuil calculée.
Analyse multidimensionnelle: en combinant plusieurs indicateurs, la stratégie peut analyser le marché sous différents angles, améliorant ainsi la précision des décisions.
Adaptabilité: le calcul dynamique de la longueur permet à la stratégie de s'adapter aux différentes conditions du marché, ce qui accroît sa flexibilité.
Gestion des risques: les paramètres dynamiques de stop-loss et de take-profit aident à mieux contrôler les risques et à s'adapter aux changements du marché.
Indicateurs originaux: les indicateurs VAWSI et de persistance de tendance fournissent des informations uniques sur le marché qui pourraient capturer des signaux négligés par les indicateurs traditionnels.
Anti-Repainting: l'utilisation de barstate.isconfirmed garantit que les signaux ne sont pas repeints, améliorant ainsi la précision du backtesting.
Personnalisabilité: les multiples paramètres réglables permettent d'adapter la stratégie à différents instruments de négociation et délais.
Sur-optimisation: le grand nombre de paramètres peut entraîner une sur-optimisation, ce qui peut entraîner de mauvaises performances dans le trading en direct.
Adaptabilité au marché: Bien qu'elle fonctionne bien sur certains marchés, elle peut ne pas convenir à toutes les conditions du marché, en particulier sur les marchés à faible volatilité.
Complexité: la complexité de la stratégie peut rendre difficile sa compréhension et sa maintenance, ce qui augmente le risque d'erreurs opérationnelles.
Intensif en calcul: plusieurs indicateurs personnalisés et calculs dynamiques peuvent entraîner une charge de calcul élevée, ce qui affecte la vitesse d'exécution.
S'appuyer sur des données historiques: la stratégie utilise une grande quantité de données historiques pour les calculs, ce qui peut entraîner un retard dans certaines situations.
Optimisation des paramètres: utiliser des algorithmes d'apprentissage automatique pour optimiser divers paramètres de poids et de longueur afin d'améliorer les performances de la stratégie dans différentes conditions de marché.
Reconnaissance de l'état du marché: ajouter un module de reconnaissance de l'état du marché pour ajuster automatiquement les paramètres de stratégie dans différents environnements de marché.
Filtrage des signaux: introduire des mécanismes de filtrage supplémentaires, tels que des seuils de force de tendance, pour réduire les faux signaux.
Analyse du volume: approfondir l'analyse du volume, éventuellement en introduisant la reconnaissance des modèles de volume pour améliorer la fiabilité du signal.
Analyse de plusieurs délais: intégrer des signaux provenant de plusieurs délais pour améliorer la robustesse des décisions de négociation.
Optimisation de la gestion des risques: mettre en œuvre des stratégies de gestion des risques plus sophistiquées, telles que la dimensionnement dynamique des positions et le stop-loss à plusieurs niveaux.
Efficacité de calcul: Optimiser le code pour améliorer l'efficacité du calcul, en particulier lors du traitement de grandes quantités de données historiques.
Le VAWSI et la stratégie d'inversion de la persistance de tendance est un système de trading complexe et complet qui combine plusieurs indicateurs innovants et des ajustements de paramètres dynamiques. Ses atouts résident dans l'analyse de marché multidimensionnelle et l'adaptabilité, lui permettant de rechercher des opportunités d'inversion potentielles dans diverses conditions de marché. Cependant, la complexité de la stratégie pose également des défis en termes d'optimisation et d'adaptabilité excessives.
Grâce à une optimisation supplémentaire, en particulier dans l'ajustement des paramètres, la reconnaissance de l'état du marché et la gestion des risques, cette stratégie a le potentiel de devenir un outil de trading puissant. Cependant, les utilisateurs doivent noter qu'aucune stratégie n'est parfaite, et une surveillance et un ajustement continus sont nécessaires.
/*backtest
start: 2024-05-21 00:00:00
end: 2024-06-20 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=5
strategy("VAWSI and Trend Persistance Reversal", overlay=true, max_bars_back = 4999, process_orders_on_close = true)
//INPUTS
sltp = input.float(title = "Minimum SL/TP", defval = 5.0)
rsi_weight = input.float(title = "Wawsi weight", defval = 100.0)
half_weight= input.float(title = "Trend Persistence Weight", defval = 79.0)
atr_weight = input.float(title = "ATR Weight", defval = 20.0)
com_mult = input.float(title = "Combination Mult", defval = 1, step = .001)
smoothing = input.int(title = "Trend Persistence smooth length", defval = 3)
CycPart = input.float(1.1, step = .001, title = "Length Cycle Decimal")
src = close
hclose = request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, src)
//BlackCat1402's Dynamic Length Calculation
EhlersHoDyDC(Price, CycPart) =>
// Vars:
Smooth = 0.00
Detrender = 0.00
I1 = 0.00
Q1 = 0.00
jI = 0.00
jQ = 0.00
I2 = 0.00
Q2 = 0.00
Re = 0.00
Im = 0.00
Period = 0.00
SmoothPeriod = 0.00
pi = 2 * math.asin(1)
DomCycle = 0.0
//Hilbert Transform
Smooth := bar_index > 5 ? (4 * Price + 3 * nz(Price[1]) + 2 * nz(Price[2]) + nz(Price[3])) / 10 : Smooth
Detrender := bar_index > 5 ? (.0962 * Smooth + .5769 * nz(Smooth[2]) - .5769 * nz(Smooth[4]) - .0962 * nz(Smooth[6])) * (.075 * nz(Period[1]) + .54) : Detrender
//Compute InPhase and Quadrature components
Q1 := bar_index > 5 ? (.0962 * Detrender + .5769 * nz(Detrender[2]) - .5769 * nz(Detrender[4]) - .0962 * nz(Detrender[6])) * (.075 * nz(Period[1]) + .54) : Q1
I1 := bar_index > 5 ? nz(Detrender[3]) : I1
//Advance the phase of I1 and Q1 by 90 degrees
jI := (.0962 * I1 + .5769 * nz(I1[2]) - .5769 * nz(I1[4]) - .0962 * nz(I1[6])) * (.075 * nz(Period[1]) + .54)
jQ := (.0962 * Q1 + .5769 * nz(Q1[2]) - .5769 * nz(Q1[4]) - .0962 * nz(Q1[6])) * (.075 * nz(Period[1]) + .54)
//Phasor addition for 3 bar averaging
I2 := I1 - jQ
Q2 := Q1 + jI
//Smooth the I and Q components before applying the discriminator
I2 := .2 * I2 + .8 * nz(I2[1])
Q2 := .2 * Q2 + .8 * nz(Q2[1])
//Homodyne Discriminator
Re := I2 * nz(I2[1]) + Q2 * nz(Q2[1])
Im := I2 * nz(Q2[1]) - Q2 * nz(I2[1])
Re := .2 * Re + .8 * nz(Re[1])
Im := .2 * Im + .8 * nz(Im[1])
Period := Im != 0 and Re != 0 ? 2 * pi / math.atan(Im / Re) : Period
Period := Period > 1.5 * nz(Period[1]) ? 1.5 * nz(Period[1]) : Period
Period := Period < .67 * nz(Period[1]) ? .67 * nz(Period[1]) : Period
//Limit Period to be within the bounds of 6 bar and 50 bar cycles
Period := Period < 6 ? 6 : Period
Period := Period > 50 ? 50 : Period
Period := .2 * Period + .8 * nz(Period[1])
SmoothPeriod := .33 * Period + .67 * nz(SmoothPeriod[1])
//it can add filter to Period here
DomCycle := math.ceil(CycPart * SmoothPeriod) > 34 ? 34 : math.ceil(CycPart * SmoothPeriod) < 1 ? 1 : math.ceil(CycPart * SmoothPeriod)
DomCycle
wma(src, length) =>
wma = 0.0
sum = 0.0
norm = length * (length + 1) / 2
for i = 0 to length - 1
sum := sum + src[i] * (length - i)
wma := sum / norm
length = math.round(math.ceil(EhlersHoDyDC(hclose,CycPart)))
// Traditional Function initialization
highest_custom(src, length) =>
x = src
for i = 0 to math.min(length, 4999)
if src[i] > x
x := src[i]
x
lowest_custom(src, length) =>
x = src
for i = 0 to math.min(length, 4999)
if src[i] < x
x := src[i]
x
rma(src, len) =>
sum = 0.0
for i = 0 to len - 1
math.min(1, len)
sum += src[i]
rma = sum / len
rma := nz(rma[1]) * (len - 1) / len + src / len
sma(src, length) =>
math.sum(src, length) / length
hln(src, length) =>
TR = math.max(math.abs(src - src[1]), high - low)
TR := src / math.abs(ta.change(rma(TR, length)))
TR := (1 / TR) * 100
vawma(src, length) =>
atr = ta.atr(1)
aavg = sma(atr, length)
vavg = sma(volume, length)
weighted_sum = 0.0
sum_weights = 0.0
weighted = 0.0
for i = 0 to length
weight = ((volume[i] / vavg + (atr[i]) / aavg) / 2)
weighted_sum += src[i] * weight
sum_weights += weight
a = (weighted_sum / sum_weights)
vawsi(src, len) =>
rmaUp = vawma(math.max(ta.change(src), 0), len)
rmaDown = vawma(-math.min(ta.change(src), 0), len)
rsi = 100 - (100 / (1 + rmaUp / rmaDown))
trendPersistence(src, length, smoothing) =>
trendu = math.abs(src - highest_custom(src, length))
trendd = math.abs(src - lowest_custom(src, length))
trendu := wma(trendu, smoothing)
trendd := wma(trendd, smoothing)
trendu := ta.change(ta.cum(trendu))
trendd := ta.change(ta.cum(trendd))
trend = wma(math.max(trendu, trendd), smoothing)
rmaUp = rma(math.max(ta.change(trend), 0), length)
rmaDown = rma(-math.min(ta.change(trend), 0), length)
rsi = 100 - (100 / (1 + rmaUp / rmaDown))
//Strategy Calculations
sl = ((100 - sltp) / 100) * close
tp = ((100 + sltp) / 100) * close
var bool crossup = na
var bool crossdown = na
var float dir = na
var float BearGuy = 0
BullGuy = ta.barssince(crossup or crossdown)
if na(BullGuy)
BearGuy += 1
else
BearGuy := math.min(BullGuy, 4999)
rsiw = rsi_weight / 100
cew = half_weight / 100
atrw = atr_weight / 100
atr = hln(hclose, length) * atrw
ce = 1 / trendPersistence(hclose, length, smoothing)
com = 1 / math.max(math.abs(vawsi(hclose, length) - 50) * 2, 20)
comfin = (((com * rsiw) + (ce * cew) - atr)) * com_mult
lower = highest_custom(math.min((math.max(highest_custom(src, BearGuy) * (1 - comfin), sl)), src[1]), BearGuy)
upper = lowest_custom(math.max((math.min(lowest_custom(src, BearGuy) * (1 + comfin), tp)), src[1]), BearGuy)
var float thresh = na
if na(thresh)
thresh := lower
if na(dir)
dir := 1
if crossdown
dir := -1
if crossup
dir := 1
if dir == 1
thresh := lower
if dir == -1
thresh := upper
crossup := ta.crossover(hclose, thresh) and barstate.isconfirmed
crossdown := ta.crossunder(hclose, thresh) and barstate.isconfirmed
//STRATEGY
if crossup
strategy.entry("long", strategy.long)
if crossdown
strategy.entry("Short", strategy.short)
//PLOTTING
col = hclose > thresh ? color.lime : color.red
plot(thresh, linewidth = 2, color = color.new(col[1], 0))