Stratégie de trading Rainbow Oscillator


Date de création: 2024-02-23 14:57:43 Dernière modification: 2024-02-23 14:57:43
Copier: 4 Nombre de clics: 706
avatar of ChaoZhang ChaoZhang
1
Suivre
1617
Abonnés

Stratégie de trading Rainbow Oscillator

Aperçu

La stratégie de négociation de l’oscillateur arc-en-ciel utilise principalement plusieurs indices pour construire des canaux d’oscillation à plusieurs niveaux, en utilisant des moyennes mobiles et des indicateurs d’oscillation pour former des signaux multicolores clairs de niveau. Elle appartient à la stratégie de suivi de tendance.

Principe de stratégie

  1. Calculer la moyenne pondérée des trois valeurs de l’indicateur RSI, CCI et Stochastic pour construire l’indicateur de choc intégré Magic;
  2. Le traitement de l’indicateur de Magic par un multiple de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur de l’indicateur.
  3. sampledMagicFast représente une moyenne rapide, sampledMagicSlow représente une moyenne lente;
  4. Un signal d’achat est généré lors de l’utilisation d’un MagicSlow sur le MagicFast;
  5. Un signal de vente est généré lorsque le MagicFast est passé sous le MagicSlow;
  6. Calculer le changement de direction de la dernière barre de MagicFast échantillonné par rapport à la barre précédente pour déterminer la tendance actuelle;
  7. Les heures d’entrée et de sortie sont déterminées en fonction de la direction de la tendance et du croisement entre le MagicFast échantillonné et le MagicSlow échantillonné.

Avantages stratégiques

  1. L’intégration de plusieurs indicateurs permettant de juger de l’évolution globale du marché et d’améliorer l’exactitude des signaux;
  2. La suppression efficace du signal-bruit, basée sur l’indicateur de MA lissé;
  3. Les signaux de secousse sont transmis par couches de manière claire et facile à utiliser.
  4. Il peut être configuré pour suivre une tendance ou inverser une tendance, en combinaison avec un filtre de tendance.
  5. Une zone de survente et de survente personnalisable, avec une forte capacité d’adaptation

Risque stratégique

  1. Une mauvaise configuration des paramètres peut entraîner une courbe trop lisse et une perte de temps d’entrée optimale.
  2. La mauvaise configuration des zones de survente peut entraîner des heures d’inactivité trop longues;
  3. La défaillance de certains indicateurs dans les évaluations multifonctionnelles affaiblit l’efficacité du signal.

La réponse:

  1. Optimiser les paramètres pour une douceur de courbe modérée;
  2. Il est également important d’adapter l’intensité des zones de survente et de surachat afin de réduire le taux de positions vides.
  3. Tester la capacité prédictive de chaque indicateur, en les ajustant par poids.

Orientation de l’optimisation de la stratégie

  1. Modifier les paramètres de l’indicateur en fonction de la dynamique du marché;
  2. L’introduction d’une méthode d’apprentissage automatique pour optimiser les combinaisons de poids des indicateurs;
  3. Les signaux entrants sont filtrés par des facteurs tels que l’augmentation du volume et de la fluctuation.

Résumer

La stratégie de l’oscillateur Rainbow intègre plusieurs signaux d’indicateurs pour améliorer la stabilité grâce à un traitement de l’indice. La stratégie peut être configurée pour s’adapter aux tendances et aux marchés de choc, ou uniquement pour les mouvements de choc de certaines variétés.

Code source de la stratégie 
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © businessduck

//@version=5
strategy("Rainbow Oscillator [Strategy]", overlay=false, margin_long=100, margin_short=100, initial_capital = 2000)

bool trendFilter = input.bool(true, 'Use trend filter')
float w1 = input.float(0.33, 'RSI Weight', 0, 1, 0.01)
float w2 = input.float(0.33, 'CCI Weight', 0, 1, 0.01)
float w3 = input.float(0.33, 'Stoch Weight', 0, 1, 0.01)
int fastPeriod = input.int(16, 'Ocillograph Fast Period', 4, 60, 1)
int slowPeriod = input.int(22, 'Ocillograph Slow Period', 4, 60, 1)
int oscillographSamplePeriod = input.int(8, 'Oscillograph Samples Period', 1, 30, 1)
int oscillographSamplesCount = input.int(2, 'Oscillograph Samples Count', 0, 4, 1)
string oscillographMAType = input.string("RMA", "Oscillograph Samples Type", options = ["EMA", "SMA", "RMA", "WMA"])
int levelPeriod = input.int(26, 'Level Period', 2, 100)
int levelOffset = input.int(0, 'Level Offset', 0, 200, 10)
float redunant = input.float(0.5, 'Level Redunant', 0, 1, 0.01)
int levelSampleCount = input.int(2, 'Level Smooth Samples', 0, 4, 1)
string levelType = input.string("RMA", "Level MA type", options = ["EMA", "SMA", "RMA", "WMA"])

perc(current, prev) => ((current - prev) / prev) * 100

smooth(value, type, period) =>
    float ma = switch type
        "EMA" => ta.ema(value, period)
        "SMA" => ta.sma(value, period)
        "RMA" => ta.rma(value, period)
        "WMA" => ta.wma(value, period)
        =>
            runtime.error("No matching MA type found.")
            float(na)

getSample(value, samples, type, period) =>
    float ma = switch samples
        0 => value
        1 => smooth(value, type, period)
        2 => smooth(smooth(value, type, period), type, period)
        3 => smooth(smooth(smooth(value, type, period), type, period), type, period)
        4 => smooth(smooth(smooth(smooth(value, type, period), type, period), type, period), type, period)

float takeProfit = input.float(5, "% Take profit", 0.8, 100, step = 0.1)  / 100
float stopLoss = input.float(2, "% Stop Loss", 0.8, 100, step = 0.1) / 100
float magicFast = w2 * ta.cci(close, fastPeriod) + w1 * (ta.rsi(close, fastPeriod) - 50) + w3 * (ta.stoch(close, high, low, fastPeriod) - 50)
float magicSlow = w2 * ta.cci(close, slowPeriod) + w1 * (ta.rsi(close, slowPeriod) - 50) + w3 * (ta.stoch(close, high, low, slowPeriod) - 50)
float sampledMagicFast = getSample(magicFast, oscillographSamplesCount, oscillographMAType, oscillographSamplePeriod)
float sampledMagicSlow = getSample(magicSlow, oscillographSamplesCount, oscillographMAType, oscillographSamplePeriod)
float lastUpperValue = 0
float lastLowerValue = 0

if (magicFast > 0)
    lastUpperValue := math.max(magicFast, magicFast[1])
else 
    lastUpperValue := math.max(0, lastUpperValue[1]) * redunant

    
if (magicFast <= 0)
    lastLowerValue := math.min(magicFast, magicFast[1])
else
    lastLowerValue := math.min(0, lastLowerValue[1]) * redunant

float level1up = getSample( (magicFast >= 0 ? magicFast : lastUpperValue) / 4, levelSampleCount, levelType, levelPeriod) + levelOffset
float level2up = getSample( (magicFast >= 0 ? magicFast : lastUpperValue) / 2, levelSampleCount, levelType, levelPeriod) + levelOffset
float level3up = getSample( magicFast >= 0 ? magicFast : lastUpperValue, levelSampleCount, levelType, levelPeriod) + levelOffset
float level4up = getSample( (magicFast >= 0 ? magicFast : lastUpperValue) * 2, levelSampleCount, levelType, levelPeriod) + levelOffset

float level1low = getSample( (magicFast <= 0 ? magicFast : lastLowerValue) / 4, levelSampleCount, levelType, levelPeriod) - levelOffset
float level2low = getSample( (magicFast <= 0 ? magicFast : lastLowerValue) / 2, levelSampleCount, levelType, levelPeriod) - levelOffset
float level3low = getSample( magicFast <= 0 ? magicFast : lastLowerValue, levelSampleCount, levelType, levelPeriod) - levelOffset
float level4low = getSample( (magicFast <= 0 ? magicFast : lastLowerValue) * 2, levelSampleCount, levelType, levelPeriod) - levelOffset

var transparent = color.new(color.white, 100)
var overbough4Color = color.new(color.red, 75)
var overbough3Color = color.new(color.orange, 75)
var overbough2Color = color.new(color.yellow, 75)

var oversold4Color = color.new(color.teal, 75)
var oversold3Color = color.new(color.blue, 75)
var oversold2Color = color.new(color.aqua, 85)

upperPlotId1 = plot(level1up, 'Upper1', transparent)
upperPlotId2 = plot(level2up, 'Upper2', transparent)
upperPlotId3 = plot(level3up, 'Upper3', transparent)
upperPlotId4 = plot(level4up, 'Upper4', transparent)

fastColor = color.new(color.teal, 60)
slowColor = color.new(color.red, 60)
fastPlotId = plot(sampledMagicFast, 'fast', color = fastColor)
slowPlotId = plot(sampledMagicSlow, 'slow', color = slowColor)

lowerPlotId1 = plot(level1low, 'Lower1', transparent)
lowerPlotId2 = plot(level2low, 'Lower2', transparent)
lowerPlotId3 = plot(level3low, 'Lower3', transparent)
lowerPlotId4 = plot(level4low, 'Lower4', transparent)

fill(upperPlotId4, upperPlotId3, overbough4Color)
fill(upperPlotId3, upperPlotId2, overbough3Color)
fill(upperPlotId2, upperPlotId1, overbough2Color)

fill(lowerPlotId4, lowerPlotId3, oversold4Color)
fill(lowerPlotId3, lowerPlotId2, oversold3Color)
fill(lowerPlotId2, lowerPlotId1, oversold2Color)

upTrend = sampledMagicFast > sampledMagicFast[1]
buySignal = ((upTrend or not trendFilter) and ta.crossunder(sampledMagicSlow, sampledMagicFast)) ? sampledMagicSlow : na
sellSignal = ((not upTrend or not trendFilter) and ta.crossover(sampledMagicSlow, sampledMagicFast)) ? sampledMagicSlow : na
diff = sampledMagicSlow - sampledMagicFast

fill(fastPlotId, slowPlotId, upTrend ? fastColor : slowColor)
plot(buySignal, color = color.aqua, style = plot.style_circles, linewidth = 4)
plot(sellSignal, color = color.red, style = plot.style_circles, linewidth = 4)


// longCondition = upTrend != upTrend[1] and upTrend
long_take_level = strategy.position_avg_price * (1 + takeProfit)
long_stop_level = strategy.position_avg_price * (1 - stopLoss)

short_take_level = strategy.position_avg_price * (1 - takeProfit)
short_stop_level = strategy.position_avg_price * (1 + stopLoss)

strategy.close(id="Long", when=sellSignal, comment = "Exit")
strategy.close(id="Short", when=buySignal, comment = "Exit")

strategy.entry("Long", strategy.long, when=buySignal)
strategy.entry("Short", strategy.short, when=sellSignal)

strategy.exit("Take Profit/ Stop Loss","Long", stop=long_stop_level, limit=long_take_level)
strategy.exit("Take Profit/ Stop Loss","Short", stop=short_stop_level, limit=short_take_level)


// plot(long_stop_level, color=color.red, overlay=true)
// plot(long_take_level, color=color.green)
Forums
PINE Language FAQ Summary MyLanguage Web3 About Us
Product
Robot Strategy Node Platforms Tickets
API
Syntax guide User guide Trading api Blockchain Indicator

© 2015 - ∞ INVENTOR PTE LTD (SG)