ianzeng123
Aperçu
La stratégie est un système de négociation intégré combinant un filtre de Gauss Channel et un indicateur RSI aléatoire. Les opportunités de négociation sont déterminées par les variations de direction et de position des prix du canal Gauss, combinées à des signaux de survente et de survente du RSI aléatoire. La stratégie utilise des modèles mathématiques complexes pour construire des canaux d’adaptation qui peuvent filtrer efficacement le bruit du marché et capturer les fluctuations de prix importantes.
Principe de stratégie
La logique fondamentale de la stratégie repose sur les éléments clés suivants :
- Calcul des canaux Gauss: traitement des données de prix HLC3 avec des filtres Gauss multi-pôles pour créer des canaux d’adaptation. Optimisation des effets de filtrage par des paramètres bêta et alpha, et option de réduction de l’arriéré.
- Adaptation de la largeur du canal: Adaptation dynamique de la largeur du canal en fonction de l’amplitude réelle (TR), en utilisant 1.414 comme multiplicateur par défaut.
- Signal RSI aléatoire: combiné avec le RSI à 14 cycles et un indicateur aléatoire, il génère un signal supérieur à 80 ou inférieur à 20
- Conditions d’entrée: il faut satisfaire aux trois conditions suivantes: hausse du canal de Gauss, rupture du cours et déclenchement aléatoire du RSI.
- Logique de sortie: Le prix est à l’arrêt lorsque le canal de Gauss se déplace vers le haut.
Avantages stratégiques
- La fiabilité du signal: le mécanisme de confirmation multi-indicateurs améliore considérablement la fiabilité du signal de transaction.
- Adaptabilité: la largeur du canal de Gauss peut être ajustée automatiquement en fonction des fluctuations du marché.
- Filtrage du bruit: Les filtres Gauss réduisent efficacement l’impact du bruit sur le marché.
- Haute flexibilité: offre plusieurs paramètres réglables, y compris les cycles de passage, le nombre de points polaires et les paramètres RSI.
- Intuition visuelle: Indique intuitivement la direction de la tendance et les signaux de négociation en changeant de couleur.
Risque stratégique
- Sensitivité des paramètres: Le nombre de points et le cycle de sondage de Gauss ont une influence sur la performance de la stratégie.
- Risque de retard: Bien que des options soient offertes pour réduire le retard, l’indicateur lui-même présente un certain retard.
- Risque de fausse rupture: Les signaux de fausse rupture peuvent être fréquents dans les marchés à plat.
- Manque de gestion des fonds: La version actuelle manque d’un mécanisme détaillé de gestion des positions.
Orientation de l’optimisation de la stratégie
- Identification de l’environnement du marché: ajout d’indicateurs de force de tendance pour ajuster les paramètres stratégiques dans différents environnements du marché.
- Optimisation des paramètres dynamiques: réglage automatique des paramètres du canal de Gauss en fonction de la volatilité du marché.
- Amélioration de la gestion des positions: mise en place d’un système de gestion dynamique des positions basé sur la volatilité.
- Amélioration du mécanisme de sortie: augmentation du stop-loss mobile et du mécanisme de clôture partielle des gains.
- Optimisation des délais: Vérification des signaux sur plusieurs délais, amélioration de la stabilité des transactions.
Résumer
La stratégie, combinant un filtre de Gauss avec un indicateur RSI aléatoire, construit un système de négociation doté d’une plus grande adaptabilité. La base mathématique de Gauss assure la fluidité et la fiabilité du signal, tandis que la combinaison d’un RSI aléatoire améliore encore la précision du timing d’entrée. Le principal avantage de la stratégie réside dans son filtrage efficace du bruit du marché et sa maîtrise précise des tendances, mais il faut également prêter attention aux questions d’optimisation numérique et de gestion des risques.
Code source de la stratégie
/*backtest
start: 2024-02-22 00:00:00
end: 2025-02-19 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Binance","currency":"SOL_USDT"}]
*/
//@version=5
strategy(title="Gaussian Channel Strategy v3.0", overlay=true, calc_on_every_tick=false, initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1, slippage=0, fill_orders_on_standard_ohlc=true)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Filter Functions (Must be declared first)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
f_filt9x(_a, _s, _i) =>
var int _m2 = 0, var int _m3 = 0, var int _m4 = 0, var int _m5 = 0, var int _m6 = 0,
var int _m7 = 0, var int _m8 = 0, var int _m9 = 0, var float _f = .0
_x = 1 - _a
_m2 := _i == 9 ? 36 : _i == 8 ? 28 : _i == 7 ? 21 : _i == 6 ? 15 : _i == 5 ? 10 : _i == 4 ? 6 : _i == 3 ? 3 : _i == 2 ? 1 : 0
_m3 := _i == 9 ? 84 : _i == 8 ? 56 : _i == 7 ? 35 : _i == 6 ? 20 : _i == 5 ? 10 : _i == 4 ? 4 : _i == 3 ? 1 : 0
_m4 := _i == 9 ? 126 : _i == 8 ? 70 : _i == 7 ? 35 : _i == 6 ? 15 : _i == 5 ? 5 : _i == 4 ? 1 : 0
_m5 := _i == 9 ? 126 : _i == 8 ? 56 : _i == 7 ? 21 : _i == 6 ? 6 : _i == 5 ? 1 : 0
_m6 := _i == 9 ? 84 : _i == 8 ? 28 : _i == 7 ? 7 : _i == 6 ? 1 : 0
_m7 := _i == 9 ? 36 : _i == 8 ? 8 : _i == 7 ? 1 : 0
_m8 := _i == 9 ? 9 : _i == 8 ? 1 : 0
_m9 := _i == 9 ? 1 : 0
_f := math.pow(_a, _i) * nz(_s) + _i * _x * nz(_f[1]) - (_i >= 2 ? _m2 * math.pow(_x, 2) * nz(_f[2]) : 0) + (_i >= 3 ? _m3 * math.pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ? _m4 * math.pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ? _m5 * math.pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ? _m6 * math.pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ? _m7 * math.pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ? _m8 * math.pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ? _m9 * math.pow(_x, 9) * nz(_f[9]) : 0)
f_pole(_a, _s, _i) =>
_f1 = f_filt9x(_a, _s, 1)
_f2 = _i >= 2 ? f_filt9x(_a, _s, 2) : 0.0
_f3 = _i >= 3 ? f_filt9x(_a, _s, 3) : 0.0
_f4 = _i >= 4 ? f_filt9x(_a, _s, 4) : 0.0
_f5 = _i >= 5 ? f_filt9x(_a, _s, 5) : 0.0
_f6 = _i >= 6 ? f_filt9x(_a, _s, 6) : 0.0
_f7 = _i >= 7 ? f_filt9x(_a, _s, 7) : 0.0
_f8 = _i >= 8 ? f_filt9x(_a, _s, 8) : 0.0
_f9 = _i == 9 ? f_filt9x(_a, _s, 9) : 0.0
_fn = _i == 1 ? _f1 : _i == 2 ? _f2 : _i == 3 ? _f3 : _i == 4 ? _f4 : _i == 5 ? _f5 : _i == 6 ? _f6 : _i == 7 ? _f7 : _i == 8 ? _f8 : _i == 9 ? _f9 : na
[_fn, _f1]
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Inputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel
int poles = input.int(4, "Poles", 1, 9, group="Gaussian Channel")
int period = input.int(144, "Sampling Period", 2, group="Gaussian Channel")
float mult = input.float(1.414, "True Range Multiplier", group="Gaussian Channel")
bool reducedLag = input.bool(false, "Reduced Lag Mode", group="Gaussian Channel")
bool fastResponse = input.bool(false, "Fast Response Mode", group="Gaussian Channel")
// Stochastic RSI
smoothK = input.int(3, "K", 1, group="Stochastic RSI")
smoothD = input.int(3, "D", 1, group="Stochastic RSI")
lengthRSI = input.int(14, "RSI Length", 1, group="Stochastic RSI")
lengthStoch = input.int(14, "Stochastic Length", 1, group="Stochastic RSI")
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Calculations
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Gaussian Channel
beta = (1 - math.cos(4*math.asin(1)/period)) / (math.pow(1.414, 2/poles) - 1)
alpha = -beta + math.sqrt(math.pow(beta, 2) + 2*beta)
lag = (period - 1)/(2*poles)
src = hlc3
srcData = reducedLag ? src + (src - src[lag]) : src
trData = reducedLag ? ta.tr + (ta.tr - ta.tr[lag]) : ta.tr
[filterMain, filter1] = f_pole(alpha, srcData, poles)
[filterTRMain, filterTR1] = f_pole(alpha, trData, poles)
finalFilter = fastResponse ? (filterMain + filter1)/2 : filterMain
finalTR = fastResponse ? (filterTRMain + filterTR1)/2 : filterTRMain
hband = finalFilter + finalTR * mult
lband = finalFilter - finalTR * mult
// Stochastic RSI
rsi = ta.rsi(close, lengthRSI)
k = ta.sma(ta.stoch(rsi, rsi, rsi, lengthStoch), smoothK)
d = ta.sma(k, smoothD)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Trading Logic
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
gaussianGreen = finalFilter > finalFilter[1]
priceAbove = close > hband
stochCondition = k > 80 or k < 20
longCondition = gaussianGreen and priceAbove and stochCondition
exitCondition = ta.crossunder(close, hband)
strategy.entry("Long", strategy.long, when=longCondition)
strategy.close("Long", when=exitCondition)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Visuals
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
filterColor = finalFilter > finalFilter[1] ? #0aff68 : #ff0a5a
plot(finalFilter, "Filter", filterColor, 2)
plot(hband, "High Band", filterColor)
plot(lband, "Low Band", filterColor)
fill(plot(hband), plot(lband), color.new(filterColor, 90), "Channel Fill")