मत्स्य जाल की बेहतर रणनीति
यह रणनीति क्लासिक फिश नेट रणनीति में सुधार करती है, जिसमें अधिक पूर्ण ट्रेंड फॉलोइंग सिस्टम बनाने के लिए खरीद/बिक्री सिग्नल की सीमाएं और ट्रेलिंग स्टॉप लॉस जोड़े जाते हैं।
फिश नेट रणनीति कीमत और मात्रा के बीच संबंध को दर्शाती कीमत सेंट्रॉयड बल की गणना करके बाजार के रुझानों का आकलन करती है। बढ़ते सेंट्रॉयड बल से तेजी की शक्ति को मजबूत करने का संकेत मिलता है, जबकि गिरने से मंदी की ताकत का प्रतिनिधित्व होता है, इसलिए व्यापार संकेत तदनुसार उत्पन्न किए जा सकते हैं।
मध्यवर्ती बल की गणना करने की कुंजी मूल्य और समय के बीच के संबंध में निहित है। सरल शब्दों में, हाल के मूल्य परिवर्तनों में समग्र प्रवृत्ति निर्णय को प्रभावित करने में अधिक वजन होता है, जबकि पुरानी कीमतों में छोटे वजन होते हैं। इसलिए गणना करते समय, एक समय-विघटित वजन गुणा किया जाता है। इससे उच्च स्तरों पर होने वाले लेनदेन कुल निर्णय को अधिक प्रभावित करते हैं।
लेकिन मूल फिश नेट केवल सेंट्रोइड वक्र की दिशा के आधार पर लंबे / छोटे का न्याय करता है, आसानी से साइडवेज आंदोलनों में फंस जाता है। यह बेहतर संस्करण परिभाषित खरीद / बिक्री संकेत सीमाओं को जोड़ता है, केवल संकेत उत्पन्न करता है जब सेंट्रोइड बल एक निश्चित परिमाण से अधिक होता है, बहुत शोर को फ़िल्टर करता है।
इसके अलावा, सुधारित संस्करण में ट्रेलिंग स्टॉप लॉस और एक्जिट्स के लिए फिक्स्ड स्टॉप लॉस के संयुक्त तंत्र को लागू किया गया है। एक प्रवृत्ति में प्रवेश करने के बाद, ट्रेलिंग स्टॉप लॉस मूल्य कार्रवाई के साथ समायोजन कर सकता है, गतिशील जोखिम नियंत्रण प्राप्त कर सकता है। फिक्स्ड स्टॉप लॉस अचानक घटनाओं से नुकसान को अधिक विश्वसनीय रूप से रोक सकता है।
बेशक, सेंट्रोइड फोर्स इंडिकेटर की जटिल बाजारों में सीमित क्षमताएं हैं, और यदि अनुचित रूप से सेट किया जाता है तो ट्रेलिंग स्टॉप भी घुस सकते हैं, इसलिए व्यापारियों को सतर्क रहने और समय पर मापदंडों को अनुकूलित करने की आवश्यकता होती है। लेकिन कुल मिलाकर, इस बेहतर फिश नेट रणनीति का बढ़ाया तंत्र अधिक व्यापक है, और सभ्य स्थिर रिटर्न उत्पन्न कर सकता है।
/*backtest
start: 2023-09-04 00:00:00
end: 2023-09-11 00:00:00
period: 30m
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
// Copyright nilux: https://www.tradingview.com/u/nilux/
// Based on the original of dasanc: https://www.tradingview.com/u/dasanc/
strategy("FSCG-TSSL", "FSCG-TSSL Mod Backtest", default_qty_type = strategy.percent_of_equity, default_qty_value = 100, initial_capital = 100000, slippage = 5)
Price = input.source(close, "Source")
Length = input(20,"Period")
transform = input("Inphase-Quadrature","Use Transform?",options=["Hilbert","Inphase-Quadrature","False"])
min = input(108,"Min. Period")
buyTreshold = input(-2.41, title = "Buy Treshold (-)", type = float, defval=-2.0, minval = -2.50, maxval = -0.01, step = 0.01)
sellTreshold = input(2.43, title = "Sell Treshold (+)", type = float, defval=2.0, minval = 0.01, maxval = 2.50, step = 0.01)
// === TSSL ===
fixedSL = input(title="SL Activation", defval=300)
trailSL = input(title="SL Trigger", defval=1)
fixedTP = input(title="TP Activation", defval=150)
trailTP = input(title="TP Trigger", defval=50)
// === BACKTEST RANGE ===
FromMonth = input(defval = 1, title = "From Month", minval = 1, maxval = 12)
FromDay = input(defval = 1, title = "From Day", minval = 1, maxval = 31)
FromYear = input(defval = 2019, title = "From Year", minval = 2015)
ToMonth = input(defval = 1, title = "To Month", minval = 1, maxval = 12)
ToDay = input(defval = 1, title = "To Day", minval = 1, maxval = 31)
ToYear = input(defval = 9999, title = "To Year", minval = 2015)
start = timestamp(FromYear, FromMonth, FromDay, 00, 00)
finish = timestamp(ToYear, ToMonth, ToDay, 23, 59)
window() => time >= start and time <= finish ? true : false
getIQ(src,min,max) =>
PI = 3.14159265359
P = src - src[7]
lenIQ = 0.0
lenC = 0.0
imult = 0.635
qmult = 0.338
inphase = 0.0
quadrature = 0.0
re = 0.0
im = 0.0
deltaIQ = 0.0
instIQ = 0.0
V = 0.0
inphase := 1.25*(P[4] - imult*P[2]) + imult*nz(inphase[3])
quadrature := P[2] - qmult*P + qmult*nz(quadrature[2])
re := 0.2*(inphase*inphase[1] + quadrature*quadrature[1]) + 0.8*nz(re[1])
im := 0.2*(inphase*quadrature[1] - inphase[1]*quadrature) + 0.8*nz(im[1])
if (re!= 0.0)
deltaIQ := atan(im/re)
for i=0 to max
V := V + deltaIQ[i]
if (V > 2*PI and instIQ == 0.0)
instIQ := i
if (instIQ == 0.0)
instIQ := nz(instIQ[1])
lenIQ := 0.25*instIQ + 0.75*nz(lenIQ[1],1)
length = lenIQ<min ? min : lenIQ
getHT(src) =>
Price = src
Imult = .635
Qmult = .338
PI = 3.14159
InPhase = 0.0
Quadrature = 0.0
Phase = 0.0
DeltaPhase = 0.0
InstPeriod = 0.0
Period = 0.0
Value4 = 0.0
if(n > 5)
//Detrend Price
Value3 = Price - Price[7]
//Compute InPhase and Quadrature components
InPhase := 1.25*(Value3[4] - Imult*Value3[2]) + Imult*nz(InPhase[3])
Quadrature := Value3[2] - Qmult*Value3 + Qmult*nz(Quadrature[2])
//Use ArcTangent to compute the current phase
if(abs(InPhase + InPhase[1]) > 0)
Phase := 180/PI * atan(abs((Quadrature + Quadrature[1]) / (InPhase + InPhase[1])))
//Resolve the ArcTangent ambiguity
if(InPhase < 0 and Quadrature > 0)
Phase := 180 - Phase
if(InPhase < 0 and Quadrature < 0)
Phase := 180 + Phase
if(InPhase > 0 and Quadrature < 0)
Phase := 360 - Phase
//Compute a differential phase, resolve phase wraparound, and limit delta phase errors
DeltaPhase := Phase[1] - Phase
if(Phase[1] < 90 and Phase > 270)
DeltaPhase := 360 + Phase[1] - Phase
if(DeltaPhase < 1)
DeltaPhase := 1
if(DeltaPhase > 60)
DeltaPhase := 60
//Sum DeltaPhases to reach 360 degrees. The sum is the instantaneous period.
for i = 0 to 50
Value4 := Value4 + DeltaPhase[i]
if(Value4 > 360 and InstPeriod == 0)
InstPeriod := i
//Resolve Instantaneous Period errors and smooth
if(InstPeriod == 0)
InstPeriod = nz(InstPeriod[1])
Period := .25*(InstPeriod) + .75*Period[1]
Period
//Get highest val in period
getHighest(src, len)=>
H = src[len]
for i=0 to len
if src[i]>H
H := src[i]
H
//Get lowest val in period
getLowest(src, len)=>
L = src[len]
for i=0 to len
if src[i]<L
L := src[i]
L
if transform == "Hilbert"
Length := round(getHT(Price)/2)
if transform == "Inphase-Quadrature"
Length := round(getIQ(Price,min,50)/2)
if Length<min
Length := min
Num = 0.0
Denom = 0.0
CG = 0.0
MaxCG = 0.0
MinCG = 0.0
Value1 = 0.0
Value2 = 0.0
Value3 = 0.0
for i = 0 to Length - 1
Num := Num + (1 + i)*(Price[i])
Denom := Denom + (Price[i])
if(Denom != 0)
CG := -Num/Denom + (Length + 1) / 2
MaxCG := getHighest(CG, Length)
MinCG := getLowest(CG, Length)
if(MaxCG != MinCG)
Value1 := (CG - MinCG) / (MaxCG - MinCG)
Value2 := (4*Value1 + 3*Value1[1] + 2*Value1[2] + Value1[3]) / 10
Value3 := .5*log((1+1.98*(Value2-.5))/(1-1.98*(Value2-.5)))
plot(Value3, "CG",orange, linewidth=2)
plot(Value3[1], "Trigger",green, linewidth=2)
hline(0,color=color(black,60))
hline(2,linestyle=hline.style_solid,color=color(black,70))
hline(-2,linestyle=hline.style_solid,color=color(black,70))
sell = crossover(Value3[1],Value3) and Value3 > sellTreshold
buy = crossunder(Value3[1],Value3) and Value3 < buyTreshold
strategy.entry("Long", strategy.long, when= buy and window())
strategy.exit("Exit", loss=fixedSL, trail_offset=trailTP, trail_points=fixedTP)
strategy.exit("Exit", when= sell)
strategy.entry("Short", strategy.short, when= sell and window())
strategy.exit("Exit", loss=fixedSL, trail_offset=trailTP, trail_points=fixedTP)
strategy.exit("Exit", when= buy)