বিয়ার মার্কেটে স্বাগতম [30 মিনিট]
লেখক:চাওঝাং, তারিখ: ২০২২-০৫-১৬ ১৫ঃ৩৯ঃ১৫ট্যাগঃএটিআরএডিএক্স
হ্যালো সবাই,
এটা আমার প্রথম ধারণার কাছাকাছি ভবিষ্যতে ভালুক বাজার আন্দোলন
বট
এই বট এর কোর ট্রেন্ড সংজ্ঞায়িত করার জন্য ATR প্রবণতা ব্যবহার করা হয়, এছাড়াও নতুন সুইংশর্ট খুলতে rsi মান ব্যবহার করে (RSI-VWAP) অথবা একটি নিখুঁত বন্ধ জায়গা খুঁজে (RSI OVERSOLD)
এই বট শুধুমাত্র শর্ট বট 100% বিটকয়েন থেকে নিচে প্রতিটি পদক্ষেপ থেকে মুনাফা সর্বাধিক আমি এই বট জন্য 1-3x লিভারেজ ব্যবহার সুপারিশ, কারণ ভুল ট্রেড উচ্চ পরিমাণ বা ন্যূনতম মুনাফা সঙ্গে বন্ধ এসএল প্রায়ঃ 6% (শুধুমাত্র সমস্ত ব্যাকটেস্টিং সময়ের সেরা পারফরম্যান্সের জন্য)
সুতরাং, সংক্ষিপ্ত কোডিং খোলা হয়ঃ
-
শুধুমাত্র যদি rsi oversold না হয় তবে উভয় ADX এবং S_ATR (ক) এডিএক্স হল সবচেয়ে শক্তিশালী এবং নির্ভুল ট্রেন্ড সূচকগুলির মধ্যে একটি। এডিএক্স একটি প্রবণতা কতটা শক্তিশালী তা পরিমাপ করে এবং সম্ভাব্য ট্রেডিং সুযোগ আছে কিনা তা সম্পর্কে মূল্যবান তথ্য দিতে পারে। (খ) গড় প্রকৃত পরিসীমা (এটিআর) একটি প্রযুক্তিগত বিশ্লেষণ সূচক, যা বাজারের প্রযুক্তিবিদ জে. ওয়েলস ওয়াইল্ডার জুনিয়র তার বইয়ে নতুন ধারণাগুলিতে প্রযুক্তিগত ট্রেডিং সিস্টেমগুলিতে প্রবর্তিত, যা সেই সময়ের জন্য একটি সম্পদের দামের পুরো পরিসীমাকে বিভাজন করে বাজারের অস্থিরতা পরিমাপ করে
-
আরএসআই ভিডাব্লুএপি - ভিডাব্লুএপি প্রতিটি লেনদেনের জন্য লেনদেন করা ডলার যোগ করে গণনা করা হয় (মূল্য লেনদেনকৃত শেয়ারের সংখ্যার দ্বারা গুণিত) এবং তারপরে মোট লেনদেনকৃত শেয়ার দ্বারা বিভক্ত করা হয়। rsi vwwap শুধুমাত্র যদি ক্লাউড, অ্যাডক্স, এটিআর সূচক থেকে কোনও উত্থান সংকেত না থাকে তবেই নতুন পজিশন খুলুন
ব্যাকটেস্ট
/*backtest
start: 2022-04-15 00:00:00
end: 2022-05-14 23:59:00
period: 30m
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © wielkieef
//@version=4
src = close
//strategy("Welcome to the BEARMARKET [30MIN]", overlay=true, initial_capital = 10000, pyramiding = 1, currency = "USD", calc_on_order_fills = false, calc_on_every_tick = false, default_qty_type = strategy.fixed, default_qty_value = 1, commission_value = 0.04)
//Inputs -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
prd = input(2, title="PP period")
Factor = input(10, title = "ATR Factor")
Pd = input(14, title = "ATR Period")
len = input(2, title="Cloud Length")
ADX_options = input("CLASSIC", title="ADX OPTION", options = ["CLASSIC", "MASANAKAMURA"], group = "ADX")
ADX_len = input(17, title="ADX LENGTH", type = input.integer, minval = 1, group = "ADX")
th = input(14, title="ADX THRESHOLD", type = input.float, minval = 0, step = 0.5, group = "ADX")
len_3 = input(51, title="RSI lenght", group = "Relative Strenght Indeks")
src_3 = input(high, title="RSI Source", group = "Relative Strenght Indeks")
RSI_VWAP_length = input(22, title="Rsi vwap lenght")
//INDICATORS -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Cloud -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
PI = 2 * asin(1)
hilbertTransform(src) =>
0.0962 * src + 0.5769 * nz(src[2]) - 0.5769 * nz(src[4]) - 0.0962 * nz(src[6])
computeComponent(src, mesaPeriodMult) =>
hilbertTransform(src) * mesaPeriodMult
computeAlpha(src, fastLimit, slowLimit) =>
mesaPeriod = 0.0
mesaPeriodMult = 0.075 * nz(mesaPeriod[1]) + 0.54
smooth = 0.0
smooth := (4 * src + 3 * nz(src[1]) + 2 * nz(src[2]) + nz(src[3])) / 10
detrender = 0.0
detrender := computeComponent(smooth, mesaPeriodMult)
I1 = nz(detrender[3])
Q1 = computeComponent(detrender, mesaPeriodMult)
jI = computeComponent(I1, mesaPeriodMult)
jQ = computeComponent(Q1, mesaPeriodMult)
I2 = 0.0
Q2 = 0.0
I2 := I1 - jQ
Q2 := Q1 + jI
I2 := 0.2 * I2 + 0.8 * nz(I2[1])
Q2 := 0.2 * Q2 + 0.8 * nz(Q2[1])
Re = I2 * nz(I2[1]) + Q2 * nz(Q2[1])
Im = I2 * nz(Q2[1]) - Q2 * nz(I2[1])
Re := 0.2 * Re + 0.8 * nz(Re[1])
Im := 0.2 * Im + 0.8 * nz(Im[1])
if Re != 0 and Im != 0
mesaPeriod := 2 * PI / atan(Im / Re)
if mesaPeriod > 1.5 * nz(mesaPeriod[1])
mesaPeriod := 1.5 * nz(mesaPeriod[1])
if mesaPeriod < 0.67 * nz(mesaPeriod[1])
mesaPeriod := 0.67 * nz(mesaPeriod[1])
if mesaPeriod < 6
mesaPeriod := 6
if mesaPeriod > 50
mesaPeriod := 50
mesaPeriod := 0.2 * mesaPeriod + 0.8 * nz(mesaPeriod[1])
phase = 0.0
if I1 != 0
phase := (180 / PI) * atan(Q1 / I1)
deltaPhase = nz(phase[1]) - phase
if deltaPhase < 1
deltaPhase := 1
alpha = fastLimit / deltaPhase
if alpha < slowLimit
alpha := slowLimit
[alpha,alpha/2.0]
er = abs(change(src,len)) / sum(abs(change(src)),len)
[a,b] = computeAlpha(src, er, er*0.1)
mama = 0.0
mama := a * src + (1 - a) * nz(mama[1])
fama = 0.0
fama := b * mama + (1 - b) * nz(fama[1])
alpha = pow((er * (b - a)) + a, 2)
kama = 0.0
kama := alpha * src + (1 - alpha) * nz(kama[1])
L_cloud = kama > kama[1]
S_cloud = kama < kama[1]
CLOUD_COLOR = L_cloud ? color.lime : S_cloud ? color.red : na
// ATR -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
float ph = pivothigh(prd, prd)
float pl = pivotlow(prd, prd)
var float center = na
float lastpp = ph ? ph : pl ? pl : na
if lastpp
if na(center)
center := lastpp
else
center := (center * 2 + lastpp) / 3
Up = center - (Factor * atr(Pd))
Dn = center + (Factor * atr(Pd))
float TUp = na
float TDown = na
Trend = 0
TUp := close[1] > TUp[1] ? max(Up, TUp[1]) : Up
TDown := close[1] < TDown[1] ? min(Dn, TDown[1]) : Dn
Trend := close > TDown[1] ? 1: close < TUp[1]? -1: nz(Trend[1], 1)
Trailingsl = Trend == 1 ? TUp : TDown
bsignal = Trend == 1 and Trend[1] == -1
ssignal = Trend == -1 and Trend[1] == 1
L_ATR = Trend == 1
S_ATR = Trend == -1
//RSI------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
up_3 = rma(max(change(src_3), 0), len_3)
down_3 = rma(-min(change(src_3), 0), len_3)
rsi_3 = down_3 == 0 ? 100 : up_3 == 0 ? 0 : 100 - (100 / (1 + up_3 / down_3))
Ob_rsi = (rsi_3 >= 70)
Os_rsi = (rsi_3 <= 30)
RSI_VWAP = rsi(vwap(close), RSI_VWAP_length)
RSI_VWAP_overSold = 13
RSI_VWAP_overBought = 68
L_VAP = (crossover(RSI_VWAP, RSI_VWAP_overSold))
S_VAP = (crossunder(RSI_VWAP, RSI_VWAP_overBought))
//ADX-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
calcADX(_len) =>
up = change(high)
down = -change(low)
plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)
truerange = rma(tr, _len)
_plus = fixnan(100 * rma(plusDM, _len) / truerange)
_minus = fixnan(100 * rma(minusDM, _len) / truerange)
sum = _plus + _minus
_adx = 100 * rma(abs(_plus - _minus) / (sum == 0 ? 1 : sum), _len)
[_plus,_minus,_adx]
calcADX_Masanakamura(_len) =>
SmoothedTrueRange = 0.0
SmoothedDirectionalMovementPlus = 0.0
SmoothedDirectionalMovementMinus = 0.0
TrueRange = max(max(high - low, abs(high - nz(close[1]))), abs(low - nz(close[1])))
DirectionalMovementPlus = high - nz(high[1]) > nz(low[1]) - low ? max(high - nz(high[1]), 0) : 0
DirectionalMovementMinus = nz(low[1]) - low > high - nz(high[1]) ? max(nz(low[1]) - low, 0) : 0
SmoothedTrueRange := nz(SmoothedTrueRange[1]) - (nz(SmoothedTrueRange[1]) /_len) + TrueRange
SmoothedDirectionalMovementPlus := nz(SmoothedDirectionalMovementPlus[1]) - (nz(SmoothedDirectionalMovementPlus[1]) / _len) + DirectionalMovementPlus
SmoothedDirectionalMovementMinus := nz(SmoothedDirectionalMovementMinus[1]) - (nz(SmoothedDirectionalMovementMinus[1]) / _len) + DirectionalMovementMinus
DIP = SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIM = SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX = abs(DIP-DIM) / (DIP+DIM)*100
adx = sma(DX, _len)
[DIP,DIM,adx]
[DIPlusC,DIMinusC,ADXC] = calcADX(ADX_len)
[DIPlusM,DIMinusM,ADXM] = calcADX_Masanakamura(ADX_len)
DIPlus = ADX_options == "CLASSIC" ? DIPlusC : DIPlusM
DIMinus = ADX_options == "CLASSIC" ? DIMinusC : DIMinusM
ADX = ADX_options == "CLASSIC" ? ADXC : ADXM
L_adx = DIPlus > DIMinus and ADX > th
S_adx = DIPlus < DIMinus and ADX > th
// Strategy logic ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var bool longCond = na, var bool shortCond = na
var int CondIni_long = 0, var int CondIni_short = 0
var bool _Final_longCondition = na, var bool _Final_shortCondition = na
var float last_open_longCondition = na, var float last_open_shortCondition = na
var int last_longCondition = na, var int last_shortCondition = na
var int last_Final_longCondition = na, var int last_Final_shortCondition = na
var int nLongs = na, var int nShorts = na
Short_condition = S_ATR and S_adx and not Os_rsi or S_VAP and not Os_rsi and L_cloud and L_ATR and L_adx
Short_close = L_ATR or Os_rsi or L_VAP
longCond := Short_close
shortCond := Short_condition
CondIni_long := longCond[1] ? 1 : shortCond[1] ? -1 : nz(CondIni_long[1] )
CondIni_short := longCond[1] ? 1 : shortCond[1] ? -1 : nz(CondIni_short[1] )
longCondition = (longCond[1] and nz(CondIni_long[1]) == -1 )
shortCondition = (shortCond[1] and nz(CondIni_short[1]) == 1 )
var float sum_long = 0.0, var float sum_short = 0.0
var float Position_Price = 0.0
var bool Final_long_BB = na, var bool Final_short_BB = na
var int last_long_BB = na, var int last_short_BB = na
last_open_longCondition := longCondition or Final_long_BB[1] ? close[1] : nz(last_open_longCondition[1] )
last_open_shortCondition := shortCondition or Final_short_BB[1] ? close[1] : nz(last_open_shortCondition[1] )
last_longCondition := longCondition or Final_long_BB[1] ? time : nz(last_longCondition[1] )
last_shortCondition := shortCondition or Final_short_BB[1] ? time : nz(last_shortCondition[1] )
in_longCondition = last_longCondition > last_shortCondition
in_shortCondition = last_shortCondition > last_longCondition
last_Final_longCondition := longCondition ? time : nz(last_Final_longCondition[1] )
last_Final_shortCondition := shortCondition ? time : nz(last_Final_shortCondition[1] )
nLongs := nz(nLongs[1] )
nShorts := nz(nShorts[1] )
if longCondition or Final_long_BB
nLongs := nLongs + 1
nShorts := 0
sum_long := nz(last_open_longCondition) + nz(sum_long[1])
sum_short := 0.0
if shortCondition or Final_short_BB
nLongs := 0
nShorts := nShorts + 1
sum_short := nz(last_open_shortCondition)+ nz(sum_short[1])
sum_long := 0.0
Position_Price := nz(Position_Price[1])
Position_Price := longCondition or Final_long_BB ? sum_long/nLongs : shortCondition or Final_short_BB ? sum_short/nShorts : na
colors = (in_longCondition ? color.gray : in_shortCondition ? color.red : color.orange)
//barcolor (color = colors)
mama_p = plot(mama, title="Cloud A", color=colors )
fama_p = plot(fama, title="Cloud B", color=colors )
fill (mama_p,fama_p, color=colors )
plotshape(longCondition, title="Long", style=shape.xcross, location=location.belowbar, color=color.green, size=size.small , transp = 0 )
plotshape(shortCondition, title="Short", style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small , transp = 0 )
if Short_condition
strategy.entry("S", strategy.short)
per(pcnt) =>
strategy.position_size != 0 ? round(pcnt / 100 * strategy.position_avg_price / syminfo.mintick) : float(na)
stoploss=input(title=" stop loss", defval=6, minval=0.01)
los = per(stoploss)
q=input(title=" qty percent", defval=100, minval=1)
strategy.exit("SL", qty_percent = q,loss = los)
strategy.close_all(when = Short_close)
//By wielkieef
সম্পর্কিত
- পিভট পয়েন্ট এবং ঢাল উপর ভিত্তি করে রিয়েল টাইম ট্রেন্ডলাইন ট্রেডিং
- এসএমএ বিটিসি খুনি
- আপনার প্রবণতা পান
- ডায়নামিক এটিআর-ভিত্তিক পজিশন ম্যানেজমেন্ট সহ ওপেন-ব্রেকআউটের পর ট্রেডিং কৌশল
- মাল্টি-স্ট্র্যাটেজি অ্যাডাপ্টিভ ট্রেন্ড অনুসরণ এবং ব্রেকআউট ট্রেডিং সিস্টেম
- গাউসিয়ান ক্রস ইএমএ ট্রেন্ড রিট্র্যাক্সিং কৌশল
- প্রবণতা অনুসরণকারী পরিবর্তনশীল অবস্থান গ্রিড কৌশল
- ভলিউম ভিত্তিক ডায়নামিক ডিসিএ কৌশল
- ইলিয়ট ওয়েভ থিওরি 4-9 ইমপলস ওয়েভ স্বয়ংক্রিয় সনাক্তকরণ ট্রেডিং কৌশল
- মিল মেশিন
আরো
- ব্যাকটেস্টিং- সূচক
- প্রচলিত
- এসএমএ বিটিসি খুনি
- এমএল সতর্কতা টেমপ্লেট
- বিরতি সহ ফিবোনাচি অগ্রগতি
- আরএসআই এমটিএফ ওব+ও
- ফুকুইজ ওক্টা-ইএমএ + ইচিমোকু
- সিসিআই এমটিএফ ওব+ও
- আরও স্মার্ট ম্যাকডি
- ওসিসি কৌশল R5.1
- সিডবস
- পিভট পয়েন্ট উচ্চ নিম্ন মাল্টি টাইম ফ্রেম
- ভূত প্রবণতা ট্র্যাকিং কৌশল ডাটাবেস
- ভূত প্রবণতা কৌশলগত ট্রেসিং ব্যবসা পুস্তিকা
- ভূত ট্রেন্ড ট্র্যাকিং কৌশল
- রেইনবো ওসিলেটর
- ইকুইটি কার্ভ পজিশন সাইজিংয়ের উদাহরণ
- KLineChart ডেমো
- ভিলা ডায়নামিক পিভট সুপারট্রেন্ড কৌশল
- ক্রডলের সুপার ট্রেন্ড