EMA/ADX/VOL-CRYPTO قاتل
مصنف:چاؤ ژانگ، تاریخ: 2023-12-05 11:03:37ٹیگز:
ایک مقداری تجارتی حکمت عملی جس میں رجحان کی سمت کا تعین کرنے کے لئے ای ایم اے سسٹم ، رجحان کی طاقت کا تعین کرنے کے لئے اے ڈی ایکس اشارے کا استعمال ہوتا ہے اور اس میں داخلہ کے لئے تجارتی حجم فلٹرنگ شامل ہوتی ہے
اصول
یہ حکمت عملی سب سے پہلے قیمت کی رجحان کی سمت کا فیصلہ کرنے کے لئے مختلف ادوار کے 5 ای ایم اے کا استعمال کرتی ہے۔ جب تمام 5 ای ایم اے بڑھتے ہیں تو ، اس کو تیزی کا رجحان تشکیل دیا جاتا ہے۔ جب تمام 5 ای ایم اے گر جاتے ہیں تو ، اسے bearish رجحان تشکیل دیا جاتا ہے۔
اس کے بعد یہ رجحان کی طاقت کا اندازہ کرنے کے لئے ADX اشارے کا استعمال کرتا ہے۔ جب DI + لائن DI- لائن سے زیادہ ہے اور ADX کی قیمت مقررہ حد سے تجاوز کرتی ہے تو ، اسے ایک مضبوط تیزی کا رجحان سمجھا جاتا ہے۔ جب DI + لائن DI + لائن سے زیادہ ہے اور ADX کی قیمت مقررہ حد سے تجاوز کرتی ہے تو ، اسے bearish رجحان سمجھا جاتا ہے۔
اس کے ساتھ ساتھ ، تجارتی حجم میں پیشرفت کو اضافی تصدیق کے لئے استعمال کیا جاتا ہے ، جس کی ضرورت ہوتی ہے کہ موجودہ K- لائن کا تجارتی حجم ایک مدت میں اوسط حجم کے ایک مخصوص ضرب سے زیادہ ہو ، اس طرح کم حجم کی پوزیشنوں میں غلط اندراجات سے بچنا۔
رجحان کی سمت، رجحان کی طاقت اور تجارتی حجم کے جامع فیصلے کے ساتھ مل کر، اس حکمت عملی کا طویل اور مختصر افتتاحی منطق تشکیل دیا جاتا ہے.
فوائد
-
رجحان کی سمت کا اندازہ کرنے کے لئے ای ایم اے سسٹم کا استعمال ایک واحد ای ایم اے سے زیادہ قابل اعتماد ہے۔
-
رجحان کی طاقت کا اندازہ کرنے کے لئے ADX اشارے کا استعمال غلط اندراجات سے بچتا ہے جب کوئی واضح رجحان نہیں ہوتا ہے۔
-
تجارتی حجم فلٹر میکانزم کافی تجارتی حجم کی حمایت کو یقینی بناتا ہے اور حکمت عملی کی وشوسنییتا کو بڑھاتا ہے۔
-
ایک سے زیادہ حالت جامع فیصلے کھولنے سگنل زیادہ درست اور قابل اعتماد بناتا ہے.
-
حکمت عملی کے پیرامیٹرز کی نسبتا بڑی تعداد پیرامیٹرز کی مسلسل اصلاح کے ذریعے کارکردگی میں بہتری کی اجازت دیتی ہے۔
خطرات اور حل
-
رینج سے منسلک مارکیٹوں میں ، ای ایم اے ، اے ڈی ایکس اور دیگر فیصلے غلط سگنل دے سکتے ہیں ، جس کے نتیجے میں غیر ضروری نقصانات ہوسکتے ہیں۔ پیرامیٹرز کو مناسب طریقے سے ایڈجسٹ کیا جاسکتا ہے یا معاون فیصلے کے لئے دوسرے اشارے شامل کیے جاسکتے ہیں۔
-
تجارتی حجم فلٹر شرائط بہت سخت ہوسکتی ہیں ، مارکیٹ کے مواقع سے محروم ہوسکتے ہیں۔ پیرامیٹرز کو مناسب طریقے سے کم کیا جاسکتا ہے۔
-
حکمت عملی سے پیدا ہونے والی تجارتی تعدد نسبتا high زیادہ ہوسکتی ہے۔ رقم کے انتظام پر توجہ دی جانی چاہئے اور انفرادی پوزیشنوں کے سائز پر مناسب کنٹرول کیا جانا چاہئے۔
اصلاح کی ہدایات
-
حکمت عملی کی کارکردگی کو بہتر بنانے کے لئے زیادہ سے زیادہ پیرامیٹرز تلاش کرنے کے لئے مختلف پیرامیٹر مجموعے کی جانچ کریں.
-
دوسرے اشارے جیسے ایم اے سی ڈی، کے ڈی جے کو ای ایم اے اور اے ڈی ایکس کے ساتھ مل کر مزید طاقتور جامع کھلی پوزیشن کا فیصلہ کرنے کے لئے شامل کریں.
-
مزید خطرات کو کنٹرول کرنے کے لئے سٹاپ نقصان کی حکمت عملی شامل کریں.
-
زیادہ سائنسی سرمایہ کے انتظام کو حاصل کرنے کے لئے پوزیشن مینجمنٹ کی حکمت عملی کو بہتر بنائیں.
خلاصہ
قیمتوں کی رجحان کی سمت ، رجحان کی طاقت اور تجارتی حجم کی معلومات پر جامع طور پر غور کرکے ، یہ حکمت عملی کچھ حد تک کچھ عام جالوں سے بچنے کے لئے افتتاحی اصول تشکیل دیتی ہے اور اس کی نسبتا strong مضبوط وشوسنییتا ہے۔ لیکن کارکردگی کو مزید بہتر بنانے کے لئے پیرامیٹر کی اصلاح ، اشارے کے انتخاب اور رسک کنٹرول کے ذریعہ اسٹریٹیجی سسٹم کو مزید بہتر بنانے کی ضرورت ہے۔ عام طور پر ، اس حکمت عملی کے فریم ورک میں توسیع اور اصلاح کی جگہ کے لئے بڑی صلاحیت ہے۔
/*backtest
start: 2022-11-28 00:00:00
end: 2023-12-04 00:00:00
period: 1d
basePeriod: 1h
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/
// © BabehDyo
//@version=4
strategy("EMA/ADX/VOL-CRYPTO KILLER [15M]", 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.03)
//SOURCE =============================================================================================================================================================================================================================================================================================================
src = input(open, title=" Source")
// Inputs ========================================================================================================================================================================================================================================================================================================
//ADX --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ADX_options = input("MASANAKAMURA", title=" Adx Type", options = ["CLASSIC", "MASANAKAMURA"], group="ADX")
ADX_len = input(21, title=" Adx Length", type=input.integer, minval = 1, group="ADX")
th = input(20, title=" Adx Treshold", type=input.float, minval = 0, step = 0.5, group="ADX")
//EMA--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Length_ema1 = input(8, title=" 1-EMA Length", minval=1)
Length_ema2 = input(13, title=" 2-EMA Length", minval=1)
Length_ema3 = input(21, title=" 3-EMA Length", minval=1)
Length_ema4 = input(34, title=" 4-EMA Length", minval=1)
Length_ema5 = input(55, title=" 5-EMA Length", minval=1)
// Range Filter ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
per_ = input(15, title=" Period", minval=1, group = "Range Filter")
mult = input(2.6, title=" mult.", minval=0.1, step = 0.1, group = "Range Filter")
// Volume ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
volume_f = input(3.2, title=" Volume mult.", minval = 0, step = 0.1, group="Volume")
sma_length = input(20, title=" Volume lenght", minval = 1, group="Volume")
volume_f1 = input(1.9, title=" Volume mult. 1", minval = 0, step = 0.1, group="Volume")
sma_length1 = input(22, title=" Volume lenght 1", minval = 1, group="Volume")
//TP PLOTSHAPE -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
tp_long0 = input(0.9, title=" % TP Long", type = input.float, minval = 0, step = 0.1, group="Target Point")
tp_short0 = input(0.9, title=" % TP Short", type = input.float, minval = 0, step = 0.1, group="Target Point")
// SL PLOTSHAPE ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
sl0 = input(4.2, title=" % Stop loss", type = input.float, minval = 0, step = 0.1, group="Stop Loss")
//INDICATORS =======================================================================================================================================================================================================================================================================================================
//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
//EMA-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
xPrice = close
EMA1 = ema(xPrice, Length_ema1)
EMA2 = ema(xPrice, Length_ema2)
EMA3 = ema(xPrice, Length_ema3)
EMA4 = ema(xPrice, Length_ema4)
EMA5 = ema(xPrice, Length_ema5)
L_ema = EMA1 < close and EMA2 < close and EMA3 < close and EMA4 < close and EMA5 < close
S_ema = EMA1 > close and EMA2 > close and EMA3 > close and EMA4 > close and EMA5 > close
// Range Filter ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var bool L_RF = na, var bool S_RF = na
Range_filter(_src, _per_, _mult)=>
var float _upward = 0.0
var float _downward = 0.0
wper = (_per_*2) - 1
avrng = ema(abs(_src - _src[1]), _per_)
_smoothrng = ema(avrng, wper)*_mult
_filt = _src
_filt := _src > nz(_filt[1]) ? ((_src-_smoothrng) < nz(_filt[1]) ? nz(_filt[1]) : (_src-_smoothrng)) : ((_src+_smoothrng) > nz(_filt[1]) ? nz(_filt[1]) : (_src+_smoothrng))
_upward := _filt > _filt[1] ? nz(_upward[1]) + 1 : _filt < _filt[1] ? 0 : nz(_upward[1])
_downward := _filt < _filt[1] ? nz(_downward[1]) + 1 : _filt > _filt[1] ? 0 : nz(_downward[1])
[_smoothrng,_filt,_upward,_downward]
[smoothrng, filt, upward, downward] = Range_filter(src, per_, mult)
hband = filt + smoothrng
lband = filt - smoothrng
L_RF := high > hband and upward > 0
S_RF := low < lband and downward > 0
// Volume -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Volume_condt = volume > sma(volume,sma_length)*volume_f
Volume_condt1 = volume > sma(volume,sma_length1)*volume_f1
//STRATEGY ==========================================================================================================================================================================================================================================================================================================
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
L_1 = L_adx and Volume_condt and L_RF and L_ema
S_1 = S_adx and Volume_condt and S_RF and S_ema
L_2 = L_adx and L_RF and L_ema and Volume_condt1
S_2 = S_adx and S_RF and S_ema and Volume_condt1
L_basic_condt = L_1 or L_2
S_basic_condt = S_1 or S_2
longCond := L_basic_condt
shortCond := S_basic_condt
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 )
//POSITION PRICE-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var float sum_long = 0.0, var float sum_short = 0.0
var float Position_Price = 0.0
last_open_longCondition := longCondition ? close[1] : nz(last_open_longCondition[1] )
last_open_shortCondition := shortCondition ? close[1] : nz(last_open_shortCondition[1] )
last_longCondition := longCondition ? time : nz(last_longCondition[1] )
last_shortCondition := shortCondition ? 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
nLongs := nLongs + 1
nShorts := 0
sum_long := nz(last_open_longCondition) + nz(sum_long[1])
sum_short := 0.0
if shortCondition
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 ? sum_long/nLongs : shortCondition ? sum_short/nShorts : na
//TP---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var bool long_tp = na, var bool short_tp = na
var int last_long_tp = na, var int last_short_tp = na
var bool Final_Long_tp = na, var bool Final_Short_tp = na
var bool Final_Long_sl0 = na, var bool Final_Short_sl0 = na
var bool Final_Long_sl = na, var bool Final_Short_sl = na
var int last_long_sl = na, var int last_short_sl = na
tp_long = ((nLongs > 1) ? tp_long0 / nLongs : tp_long0) / 100
tp_short = ((nShorts > 1) ? tp_short0 / nShorts : tp_short0) / 100
long_tp := high > (fixnan(Position_Price) * (1 + tp_long)) and in_longCondition
short_tp := low < (fixnan(Position_Price) * (1 - tp_short)) and in_shortCondition
last_long_tp := long_tp ? time : nz(last_long_tp[1])
last_short_tp := short_tp ? time : nz(last_short_tp[1])
Final_Long_tp := (long_tp and last_longCondition > nz(last_long_tp[1]) and last_longCondition > nz(last_long_sl[1]))
Final_Short_tp := (short_tp and last_shortCondition > nz(last_short_tp[1]) and last_shortCondition > nz(last_short_sl[1]))
L_tp = iff(Final_Long_tp, fixnan(Position_Price) * (1 + tp_long) , na)
S_tp = iff(Final_Short_tp, fixnan(Position_Price) * (1 - tp_short) , na)
//TP SIGNALS--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
tplLevel = (in_longCondition and
(last_longCondition > nz(last_long_tp[1])) and
(last_longCondition > nz(last_long_sl[1])) and not Final_Long_sl[1]) ?
(nLongs > 1) ?
(fixnan(Position_Price) * (1 + tp_long)) : (last_open_longCondition * (1 + tp_long)) : na
tpsLevel = (in_shortCondition and
(last_shortCondition > nz(last_short_tp[1])) and
(last_shortCondition > nz(last_short_sl[1])) and not Final_Short_sl[1]) ?
(nShorts > 1) ?
(fixnan(Position_Price) * (1 - tp_short)) : (last_open_shortCondition * (1 - tp_short)) : na
//SL ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Risk = sl0
Percent_Capital = 99
sl = in_longCondition ? min(sl0,(((Risk) * 100) / (Percent_Capital * max(1, nLongs)))) :
in_shortCondition ? min(sl0,(((Risk) * 100) / (Percent_Capital * max(1, nShorts)))) : sl0
Normal_long_sl = ((in_longCondition and low <= ((1 - (sl / 100)) * (fixnan(Position_Price)))))
Normal_short_sl = ((in_shortCondition and high >= ((1 + (sl / 100)) * (fixnan(Position_Price)))))
last_long_sl := Normal_long_sl ? time : nz(last_long_sl[1])
last_short_sl := Normal_short_sl ? time : nz(last_short_sl[1])
Final_Long_sl := Normal_long_sl and last_longCondition > nz(last_long_sl[1]) and last_longCondition > nz(last_long_tp[1]) and not Final_Long_tp
Final_Short_sl := Normal_short_sl and last_shortCondition > nz(last_short_sl[1]) and last_shortCondition > nz(last_short_tp[1]) and not Final_Short_tp
//RE-ENTRY ON TP-HIT-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
if Final_Long_tp or Final_Long_sl
CondIni_long := -1
sum_long := 0.0
nLongs := na
if Final_Short_tp or Final_Short_sl
CondIni_short := 1
sum_short := 0.0
nShorts := na
// Colors ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Bar_color = in_longCondition ? #009688 : in_shortCondition ? #f06292 : color.orange
barcolor (color = Bar_color)
//PLOTS==============================================================================================================================================================================================================================================================================================================
plot(L_tp, title = "TP_L", style = plot.style_cross, color = color.fuchsia, linewidth = 7 )
plot(S_tp, title = "TP_S", style = plot.style_cross, color = color.fuchsia, linewidth = 7 )
//Price plots ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
plot((nLongs > 1) or (nShorts > 1) ? Position_Price : na, title = "Price", color = in_longCondition ? color.aqua : color.orange, linewidth = 2, style = plot.style_cross)
plot(tplLevel, title="Long TP ", style = plot.style_cross, color=color.fuchsia, linewidth = 1 )
plot(tpsLevel, title="Short TP ", style = plot.style_cross, color=color.fuchsia, linewidth = 1 )
//PLOTSHAPES----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
plotshape(Final_Long_tp, title="TP Long Signal", style = shape.triangledown, location=location.abovebar, color=color.red, size=size.tiny , text="TP", textcolor=color.red, transp = 0 )
plotshape(Final_Short_tp, title="TP Short Signal", style = shape.triangleup, location=location.belowbar, color=color.green, size=size.tiny , text="TP", textcolor=color.green, transp = 0 )
plotshape(longCondition, title="Long", style=shape.triangleup, location=location.belowbar, color=color.blue, size=size.tiny , transp = 0 )
plotshape(shortCondition, title="Short", style=shape.triangledown, location=location.abovebar, color=color.red, size=size.tiny , transp = 0 )
// Backtest ==================================================================================================================================================================================================================================================================================================================================
if L_basic_condt
strategy.entry ("LONG", strategy.long )
if S_basic_condt
strategy.entry ("SHORT", strategy.short )
strategy.exit("TP_L", "LONG", profit = (abs((last_open_longCondition * (1 + tp_long)) - last_open_longCondition) / syminfo.mintick), limit = nLongs >= 1 ? strategy.position_avg_price * (1 + tp_long) : na, loss = (abs((last_open_longCondition*(1-(sl/100)))-last_open_longCondition)/syminfo.mintick))
strategy.exit("TP_S", "SHORT", profit = (abs((last_open_shortCondition * (1 - tp_short)) - last_open_shortCondition) / syminfo.mintick), limit = nShorts >= 1 ? strategy.position_avg_price*(1-(tp_short)) : na, loss = (abs((last_open_shortCondition*(1+(sl/100)))-last_open_shortCondition)/syminfo.mintick))
//By BabehDyo
مزید
- اوسیلیشن کی پیشرفت - مارکیٹ کی ساخت میں تبدیلی کی حکمت عملی
- مومنٹم انڈیکس ای ٹی ایف ٹرینڈ فالونگ اسٹریٹجی
- ٹی ٹی ایم فالکن اوسیلیٹر ریورسنگ حکمت عملی قیمت ریورسنگ پر مبنی
- ہائبرڈ حرکت پذیر اوسط بریکآؤٹ ٹرپل ٹریڈنگ کی حکمت عملی
- چلتی اوسط کی حکمت عملی کے بعد کم تعدد فوریر ٹرانسفارمر رجحان
- اسٹارک چینل بیک ٹیسٹ کی حکمت عملی
- فی صد ریورس چینل کی حکمت عملی
- چلتی اوسط کراس اوور حکمت عملی
- حجم سے چلنے والی آسکیلشن کوانٹ حکمت عملی
- کراس منتقل اوسط گولڈن کراس موت کراس حکمت عملی
- سپر ٹرینڈ ملٹی ٹائم فریم بیک ٹسٹ حکمت عملی
- آٹھ دن کی ریورس مومنٹم حکمت عملی
- دوہری حرکت پذیر اوسط توڑ کی حکمت عملی
- گولڈن کراس چلتی اوسط ٹریڈنگ کی حکمت عملی
- ملٹی انڈیکیٹر کوانٹیٹیو ٹریڈنگ حکمت عملی
- مکمل کریپٹو سوئنگ ALMA کراس MACD مقداری حکمت عملی
- دوہری حرکت پذیر اوسط ریورس ٹریڈنگ کی حکمت عملی
- موافقت پذیر قیمت چینل کی حکمت عملی
- کچھی کی بریک آؤٹ حکمت عملی
- اوسط ریورس لفافہ اوسط حرکت پذیر حکمت عملی