এসএমএ বিটিসি খুনি
লেখক:চাওঝাং, তারিখ: ২০২২-০৫-১৭ ১১ঃ২৩ঃ৫৮ট্যাগঃএসএমএএটিআরএডিএক্স
হ্যালো!
আমি লং ও শর্ট অর্ডারের মাধ্যমে অসাধারণ মুনাফা অর্জন করেছি। আচ্ছা, এই কৌশলটি ------->>> BINANCE:
কৌশলগত যুক্তি বেশ সহজ
একটি সঠিক প্রবণতা খুঁজে পেতে 3 টি ভিন্ন এসএমএ (7,21,55) ব্যবহার করে কৌশল অনেক ভুল সংকেত এড়াতে আমি দুটি সূচক যুক্ত করেছি যেমনঃ
এডিএক্স - সবচেয়ে শক্তিশালী এবং সঠিক প্রবণতা সূচকগুলির মধ্যে একটি। এডিএক্স একটি প্রবণতা কতটা শক্তিশালী তা পরিমাপ করে এবং সম্ভাব্য ট্রেডিং সুযোগ আছে কিনা তা সম্পর্কে মূল্যবান তথ্য দিতে পারে। ক্লাউড - এটি আমার ব্যবহৃত নিউজসেট সূচকগুলির মধ্যে একটি। এই সূচকটি কৌশলকে সহায়তা করে, এই সূচকটি সঠিক বাজারের প্রবণতা নির্দেশ করার জন্য ডিজাইন করা হয়েছে। এই সূচকের বড় দৈর্ঘ্য প্রয়োগ করে, আমি কিছুটা পরে প্রবণতার পরিবর্তন লক্ষ্য করতে সক্ষম হয়েছি, তবে আরও সঠিকভাবে।
উপরন্তু আমি সর্বোচ্চ নিরাপত্তার জন্য ট্রেইলিং স্টপ-লস যোগ করেছি
সত্যি কথা বলতে, এই কৌশল সত্যিই ভাল দেখায়, অনেক ট্রেড, উচ্চ মুনাফা এবং সূচক একটি ছোট পরিমাণ, ভবিষ্যতে মুনাফা অনুরূপ হতে পারে
এসএমএ এর এই সংমিশ্রণটি ব্যবহার করে আমাকে আশ্চর্যজনক দ্রুত পরিবর্তন দেয় যখন ট্রেন্ডও দ্রুত পরিবর্তন হয় যেমন এখানেঃ
স্ন্যাপশট
দুর্ভাগ্যবশত আমি ১০০% ভুল সংকেতগুলোকে দূর করতে পারিনি।
স্ন্যাপশট
আমি আশা করি এই কৌশলটি সবার জন্য উপকারী হবে ;)
সবসময়
উপভোগ করুন!
ব্যাকটেস্ট
/*backtest
start: 2022-01-01 00:00:00
end: 2022-02-11 23:59:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
// 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("Sma BTC killer [60MIN]", overlay = true, pyramiding=1,initial_capital = 10000, default_qty_type= strategy.percent_of_equity, default_qty_value = 100, calc_on_order_fills=false, slippage=0,commission_type=strategy.commission.percent,commission_value=0.04)
//SMAs -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Length1 = input(14, title=" 1-SMA Lenght", minval=1)
Length2 = input(28, title=" 2-SMA Lenght", minval=1)
Length3 = input(55, title=" 3-SMA Lenght", minval=1)
xPrice = close
SMA1 = sma(xPrice, Length1)
SMA2 = sma(xPrice, Length2)
SMA3 = sma(xPrice, Length3)
//Indicators Inputs -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ADX_options = input("MASANAKAMURA", title=" Adx Type", options = ["CLASSIC", "MASANAKAMURA"], group="Average Directional Index")
ADX_len = input(29, title=" Adx Lenght", type=input.integer, minval = 1, group="Average Directional Index")
th = input(21, title=" Adx Treshold", type=input.integer, minval = 0, group="Average Directional Index")
len = input(11, title="Cloud Length", group="Cloud")
// ATR Inputs -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
prd = input(18, title=" PP period", group="Average True Range")
Factor = input(5, title=" ATR Factor", group="Average True Range")
Pd = input(6, title=" ATR Period", group="Average True Range")
//Indicators -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
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
ADX_COLOR = L_adx ? color.lime : S_adx ? color.red : color.orange
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]
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
// 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
Long_MA =L_adx and L_cloud and (SMA1 < close and SMA2 < close and SMA3 < close )
Short_MA =S_adx and S_cloud and (SMA1 > close and SMA2 > close and SMA3 > close )
longCond := Long_MA
shortCond := Short_MA
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
ATR_L_STOP = ssignal and in_longCondition
ATR_S_STOP = bsignal and in_shortCondition
// Plots and colors 010101010101010010101010101010101010101001010101010101001010101001010100101100111100101010010100110110010011100101010101010010101010101001011110011010101010101001010100101100110101010001001010101001010101001110110010101010100101010101010100111110101010101010101010100101010101100
colors = (in_longCondition ? color.green : in_shortCondition ? color.red : color.orange)
bgcolor(color=colors)
//barcolor (color = colors)
plotshape(longCondition, title="Long", style=shape.triangleup, location=location.belowbar, color=color.blue, size=size.small , transp = 0 )
plotshape(shortCondition, title="Short", style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small , transp = 0 )
mama_p = plot(mama, title="Cloud A", style= plot.style_stepline, color=colors )
fama_p = plot(fama, title="Cloud B", style= plot.style_stepline, color=colors )
fill (mama_p,fama_p, color=colors )
plot(SMA1, color=color.white,style= plot.style_stepline, title="5", linewidth=1)
plot(SMA2, color=color.gray,style= plot.style_stepline, title="15", linewidth=2)
plot(SMA3, color=color.black,style= plot.style_stepline, title="55", linewidth=3)
plotshape(ATR_L_STOP, title = "ATR LONG CLOSE", style=shape.arrowdown, location=location.abovebar, color=color.red, size=size.small , text="ATR LONG CLOSE", textcolor=color.red, transp = 0 )
plotshape(ATR_S_STOP, title = "ATR SHORT CLOSE", style=shape.arrowup, location=location.belowbar, color=color.blue, size=size.small, text="ATR SHORT CLOSE", textcolor=color.blue, transp = 0 )
// Strategy -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
if Long_MA
strategy.entry ("L", strategy.long)
if Short_MA
strategy.entry ("S", strategy.short)
strategy.close_all( when = ATR_L_STOP or ATR_S_STOP)
// By wielkieef
সম্পর্কিত
- আপনার প্রবণতা পান
- ভলিউম ভিত্তিক ডায়নামিক ডিসিএ কৌশল
- ইলিয়ট ওয়েভ থিওরি 4-9 ইমপলস ওয়েভ স্বয়ংক্রিয় সনাক্তকরণ ট্রেডিং কৌশল
- বিয়ার মার্কেটে স্বাগতম [30 মিনিট]
- ইনট্রা-ডে স্কেলযোগ্য ভোল্টেবিলিটি ট্রেডিং কৌশল
- সুপারট্রেন্ড+৪চলমান
- আলফা ট্রেন্ড
- লাইন নির্দেশক অনুসরণ করুন
- কনসেপ্ট ডুয়াল সুপারট্রেন্ড
- পিভট পয়েন্ট এবং ঢাল উপর ভিত্তি করে রিয়েল টাইম ট্রেন্ডলাইন ট্রেডিং
আরো
- রিসোটো
- ইএমএ ক্লাউড ইনট্রা-ডে স্ট্র্যাটেজি
- পিভট পয়েন্ট সুপারট্রেন্ড
- সুপারট্রেন্ড+৪চলমান
- গতির উপর ভিত্তি করে ZigZag
- ভিউম্যানচু সিফার বি + ডিভার্জেন্স কৌশল
- কনসেপ্ট ডুয়াল সুপারট্রেন্ড
- সুপার স্কালপার
- ব্যাকটেস্টিং- সূচক
- প্রচলিত
- এমএল সতর্কতা টেমপ্লেট
- বিরতি সহ ফিবোনাচি অগ্রগতি
- আরএসআই এমটিএফ ওব+ও
- ফুকুইজ ওক্টা-ইএমএ + ইচিমোকু
- সিসিআই এমটিএফ ওব+ও
- আরও স্মার্ট ম্যাকডি
- ওসিসি কৌশল R5.1
- বিয়ার মার্কেটে স্বাগতম [30 মিনিট]
- সিডবস
- পিভট পয়েন্ট উচ্চ নিম্ন মাল্টি টাইম ফ্রেম