Handelsstrategie für Regenbogenoszillatoren
Erstellungsdatum:
2024-02-23 14:57:43
zuletzt geändert:
2024-02-23 14:57:43
Kopie:
4
Klicks:
706
ChaoZhang
1
konzentrieren Sie sich auf
1617
Anhänger
Überblick
Die Rainbow-Vibrator-Handelsstrategie verwendet hauptsächlich mehrere Indizes, um einen vielschichtigen Schwingungskanal zu erstellen, der einen eindeutigen Mehrraumsignal bildet. Die Strategie verwendet die Kombination von RSI, CCI, Stochastic und MA, um die Gesamtentwicklung des Marktes und die Überkauf-Überverkaufsregion zu bestimmen.
Strategieprinzip
- Berechnen Sie den gewichteten Mittelwert der drei Indikatoren RSI, CCI und Stochastic und erstellen Sie den Komplex-Schockindikator Magic.
- Durch mehrfache Indexglättung des Magic-Wertes werden die beiden Kurven sampledMagicFast und sampledMagicSlow ermittelt.
- sampledMagicFast ist ein schneller Durchschnitt, sampledMagicSlow ein langsamer Durchschnitt;
- Ein Buy-Signal wird erzeugt, wenn ein SampleMagicSlow auf dem SampleMagicFast getragen wird.
- Wenn Sie die MagicSlow unter dem SampleMagicFast durchziehen, erzeugen Sie ein Verkaufssignal.
- Berechnen Sie die Änderung der Richtung des letzten bar der sampledMagicFast in Bezug auf die vorherige Bar, um den aktuellen Trend zu beurteilen;
- Die Ein- und Ausstiegszeiten werden anhand der Trendrichtung und der Kreuzung von sampledMagicFast und sampledMagicSlow beurteilt.
Strategische Vorteile
- Um mehrere Indikatoren zu kombinieren, um die Gesamtentwicklung des Marktes zu beurteilen und die Signalgenauigkeit zu verbessern;
- Aufbauend auf der Smoothed MA-Kennzahl, wirksame Signal- und Geräuschunterdrückung;
- Schwingungssignale werden in Schichten übertragen, klar und einfach zu bedienen.
- In Kombination mit einem Trendfilter kann es als Trendverfolgung oder -umkehrung konfiguriert werden.
- Anpassungsfähige Überkauf- und Überverkaufszonen.
Strategisches Risiko
- Fehler in der Parameter-Einstellung können dazu führen, dass die Kurve zu glatt wird und die optimale Einstiegsmomente verpasst werden.
- Unzureichende Aufstellung von Überkauf- und Überverkaufszonen kann zu zu langen Leerlagen führen.
- Ein Fehlschlag bei bestimmten Kennzahlen im Multi-Faktor-Rating schwächt die Wirksamkeit des Signals.
Entsprechende Lösungen:
- Optimierung der Parameter, so dass die Kurve mittelmäßig glatt ist;
- Die Überkauf- und Überverkaufszonen müssen angepasst werden, um die Leerpositionen zu senken.
- Die Prognosefähigkeit jedes Indikators wird gewichtet getestet.
Richtung der Strategieoptimierung
- Die Parameter des Indikators werden dynamisch angepasst, basierend auf den Merkmalen der Branche.
- Die Einführung einer Methode des maschinellen Lernens zur automatischen Optimierung der Gewichtskombinationen der Indikatoren;
- Erhöhte Volumen und Schwankungen filtern die eingehenden Signale.
Zusammenfassen
Die Rainbow Vibrator-Strategie kombiniert mehrere Indikatoren und erhöht die Stabilität durch eine reibungslose Verarbeitung des Index. Die Strategie kann als Trend- und Schwingungsmarkt konfiguriert werden oder nur für Schwingungsbewegungen bestimmter Sorten verwendet werden. Die Signalqualität kann durch Parameteroptimierung und Indikator-Erweiterung weiter verbessert werden.
Strategiequellcode
// 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)