Sumber daya yang dimuat... Pemuatan...
  1. Persegi
  2. Strategi Perdagangan Osilator Pelangi

Strategi Perdagangan Osilator Pelangi

Penulis:ChaoZhang, Tanggal: 2024-02-23 14:57:43
Tag:

img

Gambaran umum

Strategi perdagangan Rainbow Oscillator terutama menggunakan beberapa rata-rata bergerak halus dan indikator osilasi untuk membangun saluran osilasi multi-lapisan dan menghasilkan sinyal panjang / pendek yang jelas. Strategi ini termasuk dalam kategori strategi trend-mengikuti. Strategi ini menggabungkan indikator komposit RSI, CCI, Stochastic dan MA untuk menentukan tren pasar secara keseluruhan dan area overbought / oversold. Ini adalah strategi peringkat multi-faktor.

Prinsip-prinsip

  1. Menghitung rata-rata tertimbang dari RSI, CCI dan Stochastic untuk membangun indikator osilasi gabungan yang disebut Magic;
  2. Menerapkan pemerataan eksponensial ke Magic beberapa kali untuk menghasilkan dua garis yang disebut sampledMagicFast dan sampledMagicSlow;
  3. sampledMagicFast mewakili garis EMA cepat, sampledMagicSlow mewakili garis EMA lambat;
  4. Sinyal beli dihasilkan ketika sampledMagicFast melintasi sampledMagicSlow;
  5. Sinyal jual dihasilkan ketika sampledMagicFast melintasi di bawah sampledMagicSlow;
  6. Menghitung arah bar terakhir sampel MagicFast relatif terhadap bar sebelumnya untuk menentukan tren saat ini;
  7. Tentukan titik masuk dan keluar berdasarkan arah tren dan situasi persimpangan antara sampel MagicFast dan sampel MagicSlow.

Keuntungan

  1. Menggabungkan beberapa indikator untuk menentukan tren pasar secara keseluruhan meningkatkan akurasi sinyal;
  2. MA halus menyaring kebisingan secara efektif;
  3. Sinyal osilasi multi-lapisan memberikan panduan operasi yang jelas;
  4. Dapat dikonfigurasi untuk mengikuti tren atau membalikkan rata-rata dengan mengaktifkan/menonaktifkan filter tren;
  5. Kekuatan overbought / oversold yang dapat disesuaikan untuk fleksibilitas.

Risiko

  1. kurva yang terlalu halus dapat menyebabkan hilangnya titik masuk terbaik;
  2. Pengaturan area overbought/oversold yang tidak tepat dapat membuat posisi ditutup terlalu lama;
  3. Kegagalan beberapa faktor dalam model rating dapat melemahkan sinyal.

Solusi:

  1. Mengoptimalkan parameter untuk tingkat pelembab yang tepat;
  2. Sesuaikan kekuatan area overbought/oversold untuk mengurangi waktu di posisi datar;
  3. Uji dan timbang setiap indikator dengan kekuatan prediktifnya.

Arahan Optimasi

  1. Mengatur parameter indikator secara dinamis berdasarkan kondisi pasar;
  2. Memperkenalkan metode pembelajaran mesin untuk mengoptimalkan kombinasi indikator secara otomatis;
  3. Tambahkan faktor seperti volume dan volatilitas filter untuk sinyal masuk.

Kesimpulan

Strategi Rainbow Oscillator menggabungkan sinyal dari beberapa indikator dan menggunakan perataan eksponensial untuk meningkatkan stabilitas. Ini dapat dikonfigurasi untuk pasar tren dan samping, atau untuk produk tertentu. Perbaikan lebih lanjut dapat dilakukan dengan penyesuaian parameter dan perluasan indikator. Secara keseluruhan ini adalah strategi yang jelas dan mudah digunakan.

// 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)
Lebih banyak

2019 FMZ - Semua hak dilindungi