Strategi Penjejakan Aliran Untung Berbilang Lapisan Indeks Pergerakan Dinamik Purata Pembolehubah

Tarikh penciptaan: 2025-09-10 11:14:13 Akhirnya diubah suai: 2025-11-21 11:55:25

Salin: 0 Bilangan klik: 29

ianzeng123

fokus pada mesej peribadi

fokus pada

319

Pengikut

Strategi Penjejakan Aliran Untung Berbilang Lapisan Indeks Pergerakan Dinamik Purata Pembolehubah

Gambaran keseluruhan

Strategi ini adalah sistem trend-tracking yang menggabungkan indikator Variable Index Moving Average (VIDYA) dengan Bollinger Bands (Bollinger Bands) dan mengintegrasikan mekanisme penghentian bertingkat. Berbeza dengan strategi trend tradisional, sistem ini menggunakan cara keuntungan yang lebih adaptif untuk membezakan kedudukan kosong melalui penanda aras ATR dan sasaran peratusan yang unik. Inovatifnya adalah dengan menggunakan pendekatan penghentian bertingkat yang dinamik, terutamanya dengan peratusan yang lebih radikal untuk perdagangan kosong, fleksibiliti ini membantu untuk mengoptimumkan pengurusan perdagangan dan pengagihan keuntungan berdasarkan ketidakstabilan pasaran dan kekuatan trend.

Prinsip Strategi

Inti strategi adalah menggunakan kedua-dua penunjuk VIDYA cepat dan lambat untuk menganalisis trend harga, sambil mempertimbangkan turun naik pasaran. Rumus pengiraan penunjuk VIDYA adalah: Faktor kelancaran (α) = 2/ (perbuatan + 1) VIDYA (t) = α * k * harga (t) + (1 - α * k) * VIDYA (t-1) Di mana k = pendorong momentum Chand (MO) 100

Brinband sebagai penapis kadar lonjakan: Laluan atas = MA + (K * perbezaan piawai) Laluan bawah = MA - (K * perbezaan standard)

Syarat penyertaan:

Bulat: Harga menembusi Vidya perlahan dan Vidya pantas ke atas, sementara harga menembusi Brin ke atas
Blank: harga turun ke bawah pada slowVIDYA dan fastVIDYA turun ke bawah, sementara harga turun ke bawah pada Brin

Mekanisme penangguhan pelbagai lapisan termasuk:

Penangguhan berasaskan ATR
Penangguhan berdasarkan peratus
Perdagangan kosong menggunakan penggandaan untuk meningkatkan peratusan hentian

Kelebihan Strategik

Dinamik dan mudah disesuaikan: Indeks Vidya dapat menyesuaikan diri secara automatik dengan turun naik pasaran, lebih sensitif daripada garis purata tradisional
Pengurusan risiko yang sempurna: mekanisme penangguhan berlapis dapat mengunci keuntungan pada tahap harga yang berbeza
Pemprosesan yang berbeza: menggunakan strategi penangguhan yang berbeza untuk kedudukan kosong, lebih sesuai dengan ciri-ciri pasaran
Penapisan kadar lonjakan: Penggunaan Brinband untuk menapis isyarat pecah palsu
Fleksibiliti parameter: parameter boleh disesuaikan dengan keadaan pasaran yang berbeza

Risiko Strategik

Risiko pasaran goyah: Isyarat palsu mungkin muncul di pasaran setapak
Kesan slippage: Pelbagai hentian mungkin menyebabkan penyimpangan harga pelaksanaan akibat slippage
Bergantung kepada parameter: parameter mungkin perlu disesuaikan dengan kerap dalam keadaan pasaran yang berbeza
Kerumitan sistem: mekanisme penangguhan berlapis menambah kerumitan strategi
Tekanan untuk menguruskan dana: Pelbagai penutupan boleh menyebabkan kesukaran untuk menguruskan kedudukan

Arah pengoptimuman strategi

Penyesuaian parameter dinamik: sistem parameter yang boleh disesuaikan boleh dibangunkan, menyesuaikan secara automatik mengikut keadaan pasaran
Pengenalan keadaan pasaran: menambah modul penilaian keadaan pasaran, menggunakan parameter yang berbeza dalam keadaan pasaran yang berbeza
Optimasi Hentikan Kerosakan: meningkatkan mekanisme Hentikan Kerosakan Dinamik dan meningkatkan keupayaan kawalan risiko
Penapisan isyarat: penambahan penunjuk tambahan seperti jumlah lalu lintas, meningkatkan kebolehpercayaan isyarat
Pengurusan kedudukan: membangunkan algoritma pengagihan kedudukan yang lebih pintar

ringkaskan

Strategi ini mewujudkan sistem pemantauan trend yang komprehensif dengan menggabungkan penyesuaian dinamik indikator VIDYA dan penapisan kadar turun naik dalam Brin Belt. Mekanisme penangguhan bertingkat dan pengendalian pelbagai ruang yang berbeza menjadikannya mempunyai kemampuan keuntungan dan kawalan risiko yang baik. Walau bagaimanapun, pengguna perlu memperhatikan perubahan keadaan pasaran, menyesuaikan parameter yang sesuai, dan membina sistem pengurusan wang yang baik.

Kod sumber strategi

/*backtest
start: 2025-01-01 00:00:00
end: 2025-09-08 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT","balance":500000}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © PresentTrading

// This strategy, "VIDYA ProTrend Multi-Tier Profit," is a trend-following system that utilizes fast and slow VIDYA indicators 
// to identify entry and exit points based on the direction and strength of the trend. 
// It incorporates Bollinger Bands as a volatility filter and features a multi-step take profit mechanism, 
// with adjustable ATR-based and percentage-based profit targets for both long and short positions. 
// The strategy allows for more aggressive take profit settings for short trades, making it adaptable to varying market conditions.

//@version=5
strategy("VIDYA ProTrend Multi-Tier Profit", overlay=true)


// User-defined inputs
tradeDirection = input.string(title="Trading Direction", defval="Both", options=["Long", "Short", "Both"])
fastVidyaLength = input.int(10, title="Fast VIDYA Length", minval=1)
slowVidyaLength = input.int(30, title="Slow VIDYA Length", minval=1)
minSlopeThreshold = input.float(0.05, title="Minimum VIDYA Slope Threshold", step=0.01)

// Bollinger Bands Inputs
bbLength = input.int(20, title="Bollinger Bands Length", minval=1)
bbMultiplier = input.float(1.0, title="Bollinger Bands Multiplier", step=0.1)

// Multi-Step Take Profit Settings
group_tp = "Multi-Step Take Profit"
useMultiStepTP = input.bool(true, title="Enable Multi-Step Take Profit", group=group_tp)
tp_direction = input.string(title="Take Profit Direction", defval="Both", options=["Long", "Short", "Both"], group=group_tp)
atrLengthTP =  input.int(14, title="ATR Length", group=group_tp)


// ATR-based Take Profit Steps
atrMultiplierTP1 = input.float(2.618, title="ATR Multiplier for TP 1", group=group_tp)
atrMultiplierTP2 = input.float(5.0, title="ATR Multiplier for TP 2", group=group_tp)
atrMultiplierTP3 = input.float(10.0, title="ATR Multiplier for TP 3", group=group_tp)

// Short Position Multiplier for Take Profit Percentages
shortTPPercentMultiplier = input.float(1.5, title="Short TP Percent Multiplier", group=group_tp)

// Percentage-based Take Profit Steps (Long)
tp_level_percent1 = input.float(title="Take Profit Level 1 (%)", defval=3.0, group=group_tp)
tp_level_percent2 = input.float(title="Take Profit Level 2 (%)", defval=8.0, group=group_tp)
tp_level_percent3 = input.float(title="Take Profit Level 3 (%)", defval=17.0, group=group_tp)

// Percentage-based Take Profit Allocation (Long)
tp_percent1 = input.float(title="Take Profit Percent 1 (%)", defval=12.0, group=group_tp)
tp_percent2 = input.float(title="Take Profit Percent 2 (%)", defval=8.0, group=group_tp)
tp_percent3 = input.float(title="Take Profit Percent 3 (%)", defval=10.0, group=group_tp)

// ATR-based Take Profit Percent Allocation (Long)
tp_percentATR1 = input.float(title="ATR TP Percent 1 (%)", defval=10.0, group=group_tp)
tp_percentATR2 = input.float(title="ATR TP Percent 2 (%)", defval=10.0, group=group_tp)
tp_percentATR3 = input.float(title="ATR TP Percent 3 (%)", defval=10.0, group=group_tp)

// Short position percentage allocations using the multiplier
tp_percent1_short = tp_percent1 * shortTPPercentMultiplier
tp_percent2_short = tp_percent2 * shortTPPercentMultiplier
tp_percent3_short = tp_percent3 * shortTPPercentMultiplier

tp_percentATR1_short = tp_percentATR1 * shortTPPercentMultiplier
tp_percentATR2_short = tp_percentATR2 * shortTPPercentMultiplier
tp_percentATR3_short = tp_percentATR3 * shortTPPercentMultiplier

// VIDYA Calculation Function
calcVIDYA(src, length) =>
    alpha = 2 / (length + 1)
    momm = ta.change(src)
    m1 = momm >= 0.0 ? momm : 0.0
    m2 = momm < 0.0 ? -momm : 0.0
    sm1 = math.sum(m1, length)
    sm2 = math.sum(m2, length)
    chandeMO = nz(100 * (sm1 - sm2) / (sm1 + sm2))
    k = math.abs(chandeMO) / 100
    var float vidya = na
    vidya := na(vidya[1]) ? src : (alpha * k * src + (1 - alpha * k) * vidya[1])
    vidya

// Calculate VIDYAs
fastVIDYA = calcVIDYA(close, fastVidyaLength)
slowVIDYA = calcVIDYA(close, slowVidyaLength)

// Bollinger Bands Calculation
[bbUpper, bbBasis, bbLower] = ta.bb(close, bbLength, bbMultiplier)

// Manual Slope Calculation (price difference over time)
calcSlope(current, previous, length) =>
    (current - previous) / length

// Slope of fast and slow VIDYA (comparing current value with value 'length' bars ago)
fastSlope = calcSlope(fastVIDYA, fastVIDYA[fastVidyaLength], fastVidyaLength)
slowSlope = calcSlope(slowVIDYA, slowVIDYA[slowVidyaLength], slowVidyaLength)

// Conditions for long entry with Bollinger Bands filter
longCondition = close > slowVIDYA and fastSlope > slowSlope and fastSlope > minSlopeThreshold and slowSlope > 1/2*minSlopeThreshold and close > bbUpper

// Conditions for short entry with Bollinger Bands filter
shortCondition = close < slowVIDYA and fastSlope < slowSlope and fastSlope < -minSlopeThreshold and slowSlope < -1/2*minSlopeThreshold and close < bbLower

// Exit conditions (opposite crossovers or flat slopes)
exitLongCondition = fastSlope < -minSlopeThreshold and slowSlope < -1/2*minSlopeThreshold or shortCondition
exitShortCondition = fastSlope > minSlopeThreshold and slowSlope > 1/2*minSlopeThreshold or longCondition

// Entry and Exit logic with trading direction
if (longCondition) and (strategy.position_size == 0) and (tradeDirection == "Long" or tradeDirection == "Both")
    strategy.order("Long", strategy.long)

if (exitLongCondition) and strategy.position_size > 0 and (tradeDirection == "Long" or tradeDirection == "Both")
    strategy.close("Long")

if (shortCondition) and (strategy.position_size == 0) and (tradeDirection == "Short" or tradeDirection == "Both")
    strategy.order("Short", strategy.short)

if (exitShortCondition) and strategy.position_size < 0 and (tradeDirection == "Short" or tradeDirection == "Both")
    strategy.close("Short")


if useMultiStepTP
    if strategy.position_size > 0 and (tp_direction == "Long" or tp_direction == "Both")
        // ATR-based Take Profit (Long)
        tp_priceATR1_long = strategy.position_avg_price + atrMultiplierTP1 * ta.atr(atrLengthTP)
        tp_priceATR2_long = strategy.position_avg_price + atrMultiplierTP2 * ta.atr(atrLengthTP)
        tp_priceATR3_long = strategy.position_avg_price + atrMultiplierTP3 * ta.atr(atrLengthTP)
        
        // Percentage-based Take Profit (Long)
        tp_pricePercent1_long = strategy.position_avg_price * (1 + tp_level_percent1 / 100)
        tp_pricePercent2_long = strategy.position_avg_price * (1 + tp_level_percent2 / 100)
        tp_pricePercent3_long = strategy.position_avg_price * (1 + tp_level_percent3 / 100)

        // Execute ATR-based exits for Long
        strategy.exit("TP ATR 1 Long", from_entry="Long", qty_percent=tp_percentATR1, limit=tp_priceATR1_long)
        strategy.exit("TP ATR 2 Long", from_entry="Long", qty_percent=tp_percentATR2, limit=tp_priceATR2_long)
        strategy.exit("TP ATR 3 Long", from_entry="Long", qty_percent=tp_percentATR3, limit=tp_priceATR3_long)
        
        // Execute Percentage-based exits for Long
        strategy.exit("TP Percent 1 Long", from_entry="Long", qty_percent=tp_percent1, limit=tp_pricePercent1_long)
        strategy.exit("TP Percent 2 Long", from_entry="Long", qty_percent=tp_percent2, limit=tp_pricePercent2_long)
        strategy.exit("TP Percent 3 Long", from_entry="Long", qty_percent=tp_percent3, limit=tp_pricePercent3_long)

    if strategy.position_size < 0 and (tp_direction == "Short" or tp_direction == "Both")
        // ATR-based Take Profit (Short) - using the same ATR levels as long
        tp_priceATR1_short = strategy.position_avg_price - atrMultiplierTP1 * ta.atr(atrLengthTP)
        tp_priceATR2_short = strategy.position_avg_price - atrMultiplierTP2 * ta.atr(atrLengthTP)
        tp_priceATR3_short = strategy.position_avg_price - atrMultiplierTP3 * ta.atr(atrLengthTP)
        
        // Percentage-based Take Profit (Short) - using the same levels, but more aggressive percentages
        tp_pricePercent1_short = strategy.position_avg_price * (1 - tp_level_percent1 / 100)
        tp_pricePercent2_short = strategy.position_avg_price * (1 - tp_level_percent2 / 100)
        tp_pricePercent3_short = strategy.position_avg_price * (1 - tp_level_percent3 / 100)

        // Execute ATR-based exits for Short (using the percentage multiplier for short)
        strategy.exit("TP ATR 1 Short", from_entry="Short", qty_percent=tp_percentATR1_short, limit=tp_priceATR1_short)
        strategy.exit("TP ATR 2 Short", from_entry="Short", qty_percent=tp_percentATR2_short, limit=tp_priceATR2_short)
        strategy.exit("TP ATR 3 Short", from_entry="Short", qty_percent=tp_percentATR3_short, limit=tp_priceATR3_short)
        
        // Execute Percentage-based exits for Short
        strategy.exit("TP Percent 1 Short", from_entry="Short", qty_percent=tp_percent1_short, limit=tp_pricePercent1_short)
        strategy.exit("TP Percent 2 Short", from_entry="Short", qty_percent=tp_percent2_short, limit=tp_pricePercent2_short)
        strategy.exit("TP Percent 3 Short", from_entry="Short", qty_percent=tp_percent3_short, limit=tp_pricePercent3_short)
// Plot VIDYAs
plot(fastVIDYA, color=color.green, title="Fast VIDYA")
plot(slowVIDYA, color=color.red, title="Slow VIDYA")

Forums

PINE Language FAQ Summary MyLanguage Web3 About Us

Product

Robot Strategy Node Platforms Tickets

API

Syntax guide User guide Trading api Blockchain Indicator