समय और पिछली कैंडल

पिछले अध्याय में एक कैंडल से गणना की थी। क्लोज़ का बदलाव निकालने के लिए दो कैंडल चाहिए: अभी की और पिछली। यहाँ उनके बीच संबंध बनाएँगे।

प्रोग्राम वही रहता है, कैंडल बदलती है link

डेमो डेटा पर प्रोग्राम चलाने पर PyneCore समय के क्रम में कैंडल पर जाता है। main() पहली, फिर दूसरी और आगे की कैंडल पर काम करता है। हर बार close अभी प्रोसेस हो रही कैंडल की अंतिम कीमत है।

इसीलिए एक plot(close, "Close") पूरी लाइन बना सकता है। एक निष्पादन एक बिंदु देता है; कैंडल की श्रृंखला पूरी लाइन बनाती है।

पिछले अध्याय की midpoint = (high + low) / 2 भी हर कैंडल पर फिर चलती है। असाइनमेंट उस कैंडल का मध्य दोबारा निकालता है। नाम वही रहता है, वैल्यू बदल सकती है।

प्रोसेसिंग का क्रम रनटाइम संभालता है। पूरे ग्राफ़ पर जाने के लिए अपना लूप नहीं लिखना है।

स्क्वेयर ब्रैकेट से पिछली वैल्यू लें link

close[1] एक कैंडल पहले की क्लोज़ है। ब्रैकेट का अंक बताता है कि कितना पीछे जाएँ।

दैनिक डेटा में लगातार तीन क्लोज़ 100, 103 और 101 हों, तो तीसरी पर close = 101, close[1] = 103 और close[2] = 100।

यहाँ close - close[1], यानी 101 - 103, का नतीजा −2 है। यह लगातार दो क्लोज़ का अंतर है। close - open एक ही कैंडल की ओपन-क्लोज़ तुलना है। दोनों गणनाएँ अलग सवाल का जवाब देती हैं।

पीछे जाना कैंडल में मापा जाता है, कैलेंडर के दिनों में नहीं। दैनिक बाज़ार डेटा में सप्ताहांत या छुट्टी के कारण पिछली कैंडल कई दिन पुरानी हो सकती है।

अपनी वैल्यू की भी हिस्ट्री हो सकती है link

बिल्ट-इन कीमतों का इतिहास पहले से उपलब्ध है। अपनी गणना का पिछला नतीजा चाहिए, तो Series वेरिएबल बनाएँ:

midpoint: Series[float] = (high + low) / 2

कोलन के बाद टाइप चिह्न है। float दशमलव वाला नंबर भी स्वीकार करता है। Series[float] रनटाइम से हर कैंडल की वैल्यू का इतिहास बचाने को भी कहता है।

असाइनमेंट हर कैंडल पर चलता रहता है। midpoint अभी का नतीजा है; midpoint[1] पिछली कैंडल पर बचा नतीजा। Series को pynecore से इंपोर्ट करना है।

ग्राफ़ पर दो तरह के बदलाव link

प्रोजेक्ट के scripts में history_change.py बनाएँ:

"""
@pyne edge
"""
from pynecore import Series
from pynecore.lib import close, color, high, low, plot, script


@script.indicator("Changes Between Candles", overlay=False)
def main():
    midpoint: Series[float] = (high + low) / 2
    close_change = close - close[1]
    midpoint_change = midpoint - midpoint[1]
    plot(close_change, "Close change", color=color.blue)
    plot(midpoint_change, "Midpoint change", color=color.orange)

सेव करें और Run Pyne code तथा demo चुनें। अलग पैनल में दो लाइनें आएँगी। नीली क्लोज़ का बदलाव और नारंगी मध्य कीमत का बदलाव है। धनात्मक बिंदु का अर्थ पिछली कैंडल से बढ़ी हुई वैल्यू है।

किसी कैंडल पर माउस ले जाएँ। ग्राफ़ की वैल्यू माउस वाले समय की होती हैं; फ़ाइल में अलग से समय चुनना नहीं है।

पहली कैंडल पर क्या होता है? link

डेटा फ़ाइल में पहली कैंडल से पहले कोई कैंडल नहीं। वहाँ close[1] अनुपलब्ध वैल्यू na है। यह “not available” का संक्षेप है।

गायब कीमत शून्य नहीं है। close - close[1] भी गायब है, इसलिए पहली कैंडल पर वैध बदलाव नहीं दिखता। यह सही है: एक कैंडल से दो कैंडल का अंतर नहीं निकाल सकते।

na(value) जाँचता है कि वैल्यू गायब है या नहीं। शर्तें और संकेत में शर्त संभालना सीखेंगे। तब तक शुरुआत के गायब बिंदु को शून्य कीमत मानकर न सुधारें।

यह तरीका भविष्य की कैंडल नहीं देता। close[-1] भी अगली क्लोज़ नहीं है। निर्णय में केवल उस निष्पादन के समय उपलब्ध डेटा इस्तेमाल कर सकते हैं।

स्वयं करके देखें link

नीली लाइन बदलें ताकि क्लोज़ को पाँच कैंडल पहले की क्लोज़ से मिलाए। लाइन के शीर्षक में भी पाँच कैंडल की दूरी बताएँ।

पहले तय करें: शुरू की कितनी कैंडल पर नतीजा नहीं होगा?

close_change = close - close[5]
plot(close_change, "Five-candle change", color=color.blue)

गणना जाँचें link

तीन लगातार कैंडल चुनें। क्लोज़ लिखकर दूसरी और तीसरी का एक-कैंडल बदलाव हाथ से निकालें। नीली लाइन वही दिखाए। अंतर हो तो पहले चुने हुए समय और पीछे जाने की संख्या देखें।

अतिरिक्त अभ्यास: हिस्ट्री के बजाय वैल्यू बचाएँ link

एक पिछली वैल्यू को अगली कैंडल तक बचाकर भी इस्तेमाल कर सकते हैं। इसके लिए Persistent है, जिसे प्रोग्राम क्या याद रखता है में सीखेंगे। वह पढ़कर यह अभ्यास कर सकते हैं।

history_change.py को बिना close[1] और midpoint[1] के लिखें। दो पर्सिस्टेंट वेरिएबल पिछली क्लोज़ और मध्य कीमत रखें। दोनों लाइनें मूल जैसी वैल्यू दिखाएँ और पहली कैंडल का बदलाव गायब रहे।

क्रम सोचें: बची वैल्यू कब पढ़ें और वर्तमान से कब बदलें?

from pynecore import Persistent

def main():
    previous_close: Persistent[float] = na
    previous_midpoint: Persistent[float] = na
    midpoint = (high + low) / 2
    close_change = close - previous_close
    midpoint_change = midpoint - previous_midpoint
    plot(close_change, "Close change", color=color.blue)
    plot(midpoint_change, "Midpoint change", color=color.orange)
    previous_close = close
    previous_midpoint = midpoint