
यह रणनीति रेन्को चार्ट पर आधारित एक नॉन-रिग्राफिंग क्वांटिटेटिव ट्रेडिंग सिस्टम है, जो रेन्को ब्लॉक के व्यवहार को मानक समय के चार्ट पर अनुकरण करके पारंपरिक रेन्को रणनीति में रिग्राफिंग की समस्या को हल करती है। यह रणनीति बाजार के शोर को फ़िल्टर करने के लिए एक निश्चित आकार के मूल्य ब्लॉक का उपयोग करती है, केवल सार्थक मूल्य परिवर्तनों पर ध्यान देती है, जबकि यह सुनिश्चित करती है कि ऐतिहासिक संकेत अपरिवर्तित रहें। यह रणनीति विशेष रूप से ट्रेंड ट्रैकिंग और ट्रेंड रिवर्स ट्रेडिंग के लिए उपयुक्त है, जो ब्लॉक की दिशा में परिवर्तन की तुलना करके कई चरणों के माध्यम से व्यापार निर्णय लेता है।
मुख्य विशेषताएं:
इस रणनीति का मुख्य सिद्धांत मानक समय सारिणी पर रेन्को ब्लॉक की कार्यक्षमता को लागू करना है, जबकि पारंपरिक रेन्को सारिणी में पुनर्चित्रण की समस्याओं को हल करना है। इसके कार्य सिद्धांत इस प्रकार हैंः
पैरामीटर विन्यास और आरंभिकरण:
brickSize: ब्लॉक आकार को परिभाषित करें, यह निर्धारित करें कि नए ब्लॉक बनाने के लिए कीमत कितनी आगे बढ़नी चाहिएrenkoPriceरेन्को ब्लॉक के अंतिम समापन मूल्य को संग्रहीत करनाprevRenkoPriceस्टोरेजः पिछले रेन्को ब्लॉक मूल्य स्तरbrickDir: ब्लॉक की दिशा को ट्रैक करें (१ = ऊपर, -१ = नीचे)newBrick: बुल चिन्ह, नए ब्लॉकों के गठन का संकेत देता हैbrickStart: वर्तमान ब्लॉक के प्रारंभ के स्तंभ सूचकांक को संग्रहीत करेंरेन्को ब्लॉक की पहचान न करें:
समय सारिणी पर रेन्को का दृश्य:
मल्टी-स्टेप ट्रेंड रिवर्स जज:
कोड के गहन विश्लेषण के बाद, इस रणनीति के निम्नलिखित प्रमुख फायदे हैंः
पुनर्चित्रण की समस्या का समाधान:
शोर फ़िल्टरिंग और स्पष्ट प्रवृत्ति पहचान:
मल्टी-स्टेप सिग्नल सत्यापन:
brickDir[brickSize]वर्तमानbrickDirऔर ऐतिहासिक मूल्य स्तर संबंधलेनदेन का आधार:
लचीलापन और अनुकूलन:
हालांकि इस रणनीति ने पुनर्निर्माण की समस्या को हल कर दिया है, फिर भी निम्नलिखित जोखिम कारक मौजूद हैंः
सिग्नल विलंब जोखिम:
जोखिम के आकार का चयन:
ट्रेंड रिवर्स और झूठे संकेतों का खतरा:
वापस लेने का जोखिम:
संसाधन जोखिम की गणना:
कोड विश्लेषण के आधार पर, इस रणनीति के कुछ प्रमुख अनुकूलन हैंः
गतिशील ब्लॉक आकार अनुकूलन:
लेनदेन फ़िल्टर जोड़ें:
स्टॉप लॉस और प्रॉफिट में सुधार:
strategy.exit()आदेश, एटीआर या ब्लॉक आकार के आधार पर स्टॉपलॉस सेट करेंमल्टी-स्टेप वेरिफिकेशन को बेहतर बनाना:
brickSizeइतिहास की तुलना करने के लिए गुणांकदृश्यता और अलार्म सिस्टम में सुधार:
label.new()औरalert()फ़ंक्शन उपयोगकर्ता अनुभव को बढ़ाता हैमल्टी-स्टेप नॉन-रिवर्स रेन्को सिमुलेशन ट्रेंड रिवर्स क्वांटिफाइंग ट्रेडिंग रणनीति ने पारंपरिक रेन्को रणनीति में रिवर्सिंग की समस्या को सफलतापूर्वक हल किया, जिससे व्यापारियों को मानक समय चार्ट पर रेन्को लॉजिक लागू करने की अनुमति मिलती है, जबकि ऐतिहासिक संकेतों की स्थिरता को बनाए रखा जाता है। रणनीति ने ट्रेंड रिवर्स की पहचान करने के लिए एक बहु-चरण सत्यापन तंत्र का उपयोग किया, जिससे संकेत की गुणवत्ता में सुधार हुआ और बाजार संरचना को ग्राफिकल तरीके से प्रदर्शित किया गया।
रणनीतियों के मुख्य लाभ यह है कि यह overmapping समस्या को हल करता है, बाजार के शोर को फ़िल्टर करता है, कई स्तरों पर सिग्नल सत्यापन करता है और ग्राफिक्स को स्पष्ट रूप से दर्शाता है। हालांकि, सिग्नल विलंब, ब्लॉक आकार विकल्प और झूठे सिग्नल जैसे जोखिम अभी भी मौजूद हैं। भविष्य में गतिशील ब्लॉक आकार को लागू करने, ट्रेड फ़िल्टर को बढ़ाने, स्टॉप-लॉस तंत्र में सुधार करने, सत्यापन चरणों को अनुकूलित करने और दृश्यता प्रणाली को बढ़ाने के माध्यम से आगे अनुकूलित किया जा सकता है।
रेन्को चार्ट के लाभों को संयोजित करने और उनके नुकसानों से बचने का यह तरीका विशेष रूप से ट्रेंड फॉलोइंग और ट्रेंड रिवर्स ट्रेडिंग रणनीतियों के लिए उपयुक्त है, जो व्यापारियों को एक विश्वसनीय तकनीकी विश्लेषण उपकरण प्रदान करता है, जो रिवर्सिंग सटीकता को बनाए रखते हुए स्थिर रियल-टाइम प्रदर्शन प्रदान करने में सक्षम है।
//@version=5
strategy("Non-Repainting Renko Emulation Strategy [PineIndicators]", overlay=true, calc_on_every_tick=false, max_boxes_count = 500, max_labels_count = 500, max_lines_count = 500, initial_capital = 10000, default_qty_value = 100, default_qty_type = strategy.percent_of_equity, commission_value = 0.01, slippage = 2)
// Parameter: Brick-Größe (z.B. 10 Punkte)
brickSize = input.float(3.0, "Brick Size", step=0.1)
// Persistente Variablen
var float renkoPrice = na // Aktueller Renko-Level (Schlusswert des letzten Bricks)
var float prevRenkoPrice = na // Vorheriger Renko-Level (für Box-Berechnung)
var int brickDir = 0 // 1 = Aufwärts, -1 = Abwärts
var bool newBrick = false // Signalisiert, dass ein neuer Brick abgeschlossen wurde
var int brickStart = bar_index // Beginn des aktuellen Bricks (x-Achse)
// Berechnungen nur auf abgeschlossenen Candles
if barstate.isconfirmed
newBrick := false
// Initialisierung: Beim ersten Candle setzen wir den Renko-Level
if na(renkoPrice)
renkoPrice := close
brickStart := bar_index
// Berechne die Differenz zum letzten Renko-Level
diff = close - renkoPrice
// Prüfen, ob der Unterschied mindestens der Brick-Größe entspricht
if math.abs(diff) >= brickSize
// Anzahl kompletter Bricks (kann > 1 sein)
numBricks = math.floor(math.abs(diff) / brickSize)
prevRenkoPrice := renkoPrice
// Aktualisieren des Renko-Levels
renkoPrice := renkoPrice + numBricks * brickSize * math.sign(diff)
// Brick-Richtung (konvertiere math.sign-Ergebnis in int)
brickDir := int(math.sign(diff))
newBrick := true
// Bestimme die obere und untere Grenze des abgeschlossenen Bricks:
lowLevel = brickDir == 1 ? prevRenkoPrice : renkoPrice
highLevel = brickDir == 1 ? renkoPrice : prevRenkoPrice
// Setze den Start für den nächsten Brick
brickStart := bar_index
// Handelslogik: Einstieg/Ausstieg nur, wenn ein neuer Brick abgeschlossen wurde
if barstate.isconfirmed and newBrick
// Bei Aufwärts-Brick: Long-Signal
if brickDir[brickSize] < brickDir and renkoPrice[brickSize] < renkoPrice[brickSize*2] and renkoPrice < renkoPrice[brickSize] and renkoPrice[brickSize*2] < renkoPrice[brickSize*3] and strategy.position_size <= 0
// Bestehende Short-Position schließen, falls vorhanden
strategy.entry("Long", strategy.long)
// Bei Abwärts-Brick: Short-Signal
else if brickDir[brickSize] > brickDir and renkoPrice[brickSize] > renkoPrice[brickSize*2] and renkoPrice > renkoPrice[brickSize] and renkoPrice[brickSize*2] > renkoPrice[brickSize*3] and strategy.position_size >= 0
// Bestehende Long-Position schließen, falls vorhanden
strategy.entry("Short", strategy.short)
if barstate.isconfirmed and newBrick
if brickDir[brickSize] < brickDir
strategy.close("Short")
else if brickDir[brickSize] > brickDir
strategy.close("Long")