👩‍🌾 😽 🥪 एक ऑटोमेटन एक घटना है? 🤛🏾 👇🏿 👇🏼

1. परिचय

आधिकारिक होठों से सुना है कि "ऑटोमेटा एक घटना है" [3], मुझे एहसास हुआ कि परिमित ऑटोमेटा पूरी तरह से ब्रांडेड हैं। खुद के लिए न्यायाधीश: क्यूटी लाइब्रेरी में, ऑटोमेटा [1] का एक इवेंट मॉडल लागू किया गया है, यूएमएल में वे भी हैं [2], हम MATLAB प्रणाली के सिमुलिंक-स्टेटफ्लो एक्सटेंशन पैकेज के ऑटोमैटा को देखते हैं (4) (इसके बाद केवल स्टेटफ्लो के रूप में संदर्भित किया जाता है) और घटनाओं, आदि के बारे में। आदि इस संदर्भ में, पीएच.डी. ए.ए. यह एक अलग तरीके से व्याख्या करने के लिए शरारती है, क्योंकि और कुछ नहीं हो सकता, क्योंकि यह नहीं हो सकता।

लेकिन, यदि आप परिमित ऑटोमेटा (TCA) के सिद्धांत को याद करते हैं, तो इसमें इवेंट ऑटोमेटा के बारे में एक शब्द नहीं है! लेकिन सिद्धांत का खंडन करने के लिए, वजनदार तर्कों की आवश्यकता होती है। क्या डी। हरेल की व्यावसायिकता पर संदेह करने का कोई कारण है, जो संकेतन के निर्माता के रूप में है, जिस पर यूएमएल भाषा, स्टेटफ्लो पैकेज, उसके विचारों का आधार है? Shalyto? दरअसल, UML, Stateflow, SWITCH प्रोग्रामिंग, और अन्य स्वचालित प्रोग्रामिंग विकल्प मौजूद हैं और, एक डिग्री या किसी अन्य के लिए, सफलतापूर्वक काम करते हैं।

तो क्या यह संभव है कि "स्टेट्स ऑफ इवेंट्स" को "स्टेटलेट्स ऑफ़ द फ़्लिप" से अलग करके "स्टेट" इवेंट के मॉडल को हटा दिया जाए? यानी डी। हरेल के मॉडल के समान ऑटोमेटा और कम्प्यूटेशनल मॉडल के सिद्धांत को अलग करें। और यह विचार करने के लिए कि उत्तरार्द्ध, हालांकि ऑटोमेटा के सिद्धांत की शब्दावली का उपयोग करते हुए, उनके कार्यान्वयन द्वारा प्रतिनिधित्व करते हैं, कार्यक्रमों के ब्लॉक आरेखों के एक मॉडल का विकास।

टिप्पणी 1. इस मामले में, हम कार्यक्रम प्रबंधन मॉडल के बारे में बात कर रहे हैं, न कि कार्यक्रम मॉडल के बारे में ही (मॉडल के बारे में अधिक जानकारी के लिए, [5] देखें)।

इसलिए, याद रखें, क्यूटी पुस्तकालय एक परिमित राज्य मशीन के एक घटना मॉडल को लागू करता है, जिसे यूएमएल से उधार लिया गया था। एक ही मॉडल Stateflow द्वारा कार्यान्वित किया जाता है। यानी घटनाओं का स्रोत यूएमएल है, जहां ऑटोमेटा डी। हरेल द्वारा प्रस्तावित संकेतन पर आधारित है। लेकिन इस तरह की स्वचालित प्रोग्रामिंग बनाने के लिए उत्तरार्द्ध को दोष देना भी सही नहीं होगा, क्योंकि "Eventfulness" सॉफ्टवेयर मॉडल के कार्यान्वयन के लिए आधुनिक दृष्टिकोण की एक प्रवृत्ति है। यह आधिकारिक रायों पर आधारित है जैसे कि उल्लेखित "मशीनें एक घटना है", और यूएमएल जैसी भाषाओं और प्रौद्योगिकियों की उच्च लोकप्रियता। एक शक के बिना, यह ऑपरेटिंग सिस्टम के संचालन के मौजूदा सिद्धांतों के तहत मशीनों की नकल का परिणाम है।

लेकिन, हम दोहराते हैं, क्योंकि यह अजीब नहीं लगता है, लेकिन कुछ के लिए यह समाचार भी हो सकता है, ऑटोमेटा के सिद्धांत में एक परिमित ऑटोमेटन का कोई घटना मॉडल नहीं है। कम से कम इसके उस हिस्से में जिसे शास्त्रीय माना जाता है (अधिक विवरण के लिए देखें, उदाहरण के लिए, [6] या [7])। सिद्धांत और व्यवहार के बीच एक स्पष्ट विरोधाभास है। ऐसी स्थिति में, आपको सिद्धांत के साथ कुछ करने की जरूरत है या किसी तरह अभ्यास को प्रभावित करें। लेकिन, शायद, प्रोग्रामर [8, 9] में "इवेंट" की अवधारणा को शामिल करके एक परिमित राज्य मशीन के मॉडल को अंतिम रूप देने की इच्छा रखते हैं?

लेकिन प्रोग्रामरों की इच्छाओं को इस तथ्य से कैसे जोड़ा जाए कि "ऑटोमेटन दृष्टिकोण का उपयोग करने में सबसे बड़ी कठिनाइयां इवेंट सिस्टम में ऑटोमेटा के कामकाज की सुविधाओं को समझने के साथ जुड़ी हुई हैं" (देखें [8])। मैं इस तरह की समस्याओं के कारणों को समझना चाहूंगा और इस संदर्भ में, घटना मशीनों और / या उनके एनालॉग को लागू करूंगा। इस उद्देश्य के लिए, बारीकियों के लिए, हम क्यूटी में ऑटोमेटा के कार्यान्वयन को लेते हैं और एक शास्त्रीय परिमित ऑटोमेटन के मॉडल का उपयोग करके उन्हें दोहराते हैं।

घटना ऑटोमेटा का ऐसा कार्यान्वयन उल्लेखित "सुविधाओं" का मूल्यांकन और / या दूर करने के लिए आवश्यक है। शास्त्रीय मॉडल का उपयोग करके "इवेंट प्रोग्रामिंग" के अभ्यास के लिए ऑटोमेटा के सिद्धांत का विस्तार होगा। और, अंत में, एक अन्य मॉडल पर आधारित एक एनालॉग केवल सीमित राज्य मशीन मॉडल के आवेदन के क्षेत्र का विस्तार करेगा।

2. ऑटोमेटा की घटनाएँ, संकेत और लिंग पहचान

यूएमएल में, एक घटना "एक महत्वपूर्ण घटना है जो समय और स्थान में एक निश्चित स्थान रखती है ... और कुछ परिणामों को जोर देती है" [10]। ऑटोमेटा के सिद्धांत में एक घटना इनपुट वर्णों का एक सबसेट है जिसे आउटपुट वर्णमाला के पात्रों द्वारा दर्शाया गया है (TCA में घटनाओं के बीजगणित की अवधारणा भी है) [6]। एक ही चीज जो एक ऑटोमेटन के संक्रमण का कारण बनती है, उसे ऑटोमेटा के सिद्धांत में इनपुट सिग्नल कहा जाता है। वे परिणाम और "कारण हैं, एक राज्य से दूसरे राज्य में ऑटोमेटन का संक्रमण। इस स्थिति में, आउटपुट सिग्नल "इनपुट संकेतों के लिए ऑटोमेटन की प्रतिक्रिया" होते हैं। ये दोनों "ऑटोमेटन के संबंधित बदलावों द्वारा निर्धारित समय उदाहरणों को संदर्भित करते हैं" [6]। यूएमएल में, सिग्नल (सिग्नल) एक नामित इकाई है जो संचार के साधन के रूप में कार्य करता है। वस्तुओं के बीच "[10]।

इस प्रकार, पदों के नाम समान हैं, लेकिन उनमें निवेश किए गए अर्थ अलग हैं। यद्यपि, यदि आप उन्हें पुनर्व्यवस्थित करते हैं, तो आप एक समानता पा सकते हैं: यह स्पष्ट हो जाता है कि यूएमएल की घटनाएं टीसीए में परिमित राज्य मशीनों के संकेतों के अनुरूप हैं। लेकिन, शायद, अलग-अलग संस्थाएं भी "परिमित राज्य मशीन" शब्द के तहत छिपी हुई हैं? आइए इसे जानने की कोशिश करते हैं, घटनाओं से शुरू ...

इवेंट ऑटोमेटन एक निष्क्रिय ऑटोमेटन है, क्योंकि घटनाओं के आगमन के समय ही कार्य करता है। इसके विपरीत, क्लासिक ऑटोमेटन सक्रिय मॉडल का प्रतिनिधित्व करता है। यह किसी भी चीज़ के संदर्भ के बिना कार्य करता है (निष्क्रिय और सक्रिय ऑटोमेटा पर अधिक विवरण के लिए, देखें [9])। यहां दो धावकों के साथ जुड़ाव होता है, जहां पहला किक (घटनाओं) द्वारा संचालित होता है, और दूसरा अपने आप चलता है।

[Contrast] के विपरीत, हम ऑटोमेटन की शुरुआत के साथ घटनाओं की घटना के क्षणों को पहले संबद्ध नहीं करेंगे। इसलिए हम ऑटोमेटा के सिद्धांत के ढांचे में बने रहेंगे, जो बाहरी वातावरण के संबंध में ऑटोमेटा के कामकाज की अतुल्यकालिक प्रकृति को निर्धारित करता है। यह केवल असतत समय की बात करता है, जिसमें राज्यों का परिवर्तन एक मनमाने ढंग से छोटे के लिए किया जाता है, लेकिन शून्य, वास्तविक समय अवधि के बराबर नहीं। और संक्रमण का कारण मशीन की वर्तमान स्थिति और इनपुट संकेत हैं, जहां परिणाम एक नए राज्य की स्थापना और मशीन के आउटपुट सिग्नल के मूल्यों (मशीनों की परिभाषा पर अधिक विवरण के लिए [6] देखते हैं) हैं।

ऑटोमेटा सिद्धांत असतत समय का निर्धारण करने में लचीला है, जो एक वास्तविक समय मॉडल है। तो, एक असतत समय चक्र में वास्तविक समय अंतराल का एक निश्चित या अस्थायी मान हो सकता है, और इसके अनुसार, मशीनों को सिंक्रोनस या एसिंक्रोनस कहा जाता है। इसी समय, घड़ी के साथ जुड़े समय अंतराल का कोई भी मूल्य हो सकता है, जिसमें असीम रूप से छोटा भी शामिल है, लेकिन शून्य के बराबर नहीं, मूल्य।

टिप्पणी 2. एक परिमित राज्य मशीन मॉडल कुछ औपचारिक मॉडलों में से एक है जो इसकी परिभाषा में स्पष्ट रूप में एक वास्तविक समय मॉडल शामिल है।

नतीजतन, सक्रिय ऑटोमेटन की औपचारिक रूप से "अनंत" गति किसी भी घटना को संभावित इनपुट सिग्नल (यूएमएल के संदर्भ में, स्थिति [11] से मेल खाती है) के रूप में व्यवहार करने की अनुमति देती है। मशीन को केवल ऐसी घटनाओं / संकेतों को "पकड़ने" की जरूरत होगी और उनके बीच में ठहराव होगा। यह सब वास्तव में माध्यम और ऑटोमेटन के संयुक्त कार्य के लिए प्रोटोकॉल को परिभाषित करता है। प्रोटोकॉल को क्रमिक रूप से प्राप्त समान घटनाओं को पहचानने की समस्या को भी हल करना चाहिए। इसके बिना, उदाहरण के लिए, एक के बाद एक प्राप्त किए गए दो समान प्रतीकों को एक के रूप में माना जा सकता है।

औपचारिक रूप से, घटना प्रसंस्करण की बारीकियां महत्वपूर्ण नहीं हैं (समान सार ऑटोमेटा देखें), लेकिन इवेंट मॉडल के प्रकार द्वारा निर्मित एल्गोरिदम के व्यावहारिक कार्यान्वयन में, उन्हें ध्यान में रखा जाना चाहिए। क्यूटी लाइब्रेरी के मामले में, उनका लेखांकन ऑटोमेटन के कार्यान्वयन वर्गों में छिपा हुआ है। इसके अलावा, हम [1] से सबसे सरल कैलकुलेटर के कार्यान्वयन के उदाहरण का उपयोग करके घटना और शास्त्रीय ऑटोमेटा के बीच के अंतरों को ध्यान में रखेंगे, जहां इसका "इवेंट कार्यान्वयन" दिया गया है। इस समाधान के विपरीत, शास्त्रीय परिमित राज्य मशीन के आधार पर समतुल्य मॉडल बनाए जाएंगे।

3. कैलकुलेटर मॉडल

तो, चलिए शुरू करते हैं ... हम ईवेंट सिग्नल, साधारण ऑटोमेटा इवेंट ... या रिवर्स ऑर्डर और / या इसके विपरीत कहते हैं? ओह! उलझन में। संक्षेप में, पूरा "ग्लॉसी कुज्ड्रा शेटको बुडलानुला" और कुछ "कर्ल"। यह पता लगाने के लिए कि कौन, क्या और किसको कॉल करना है, सबसे सुरक्षित तरीका एक विशिष्ट "बोकरा" और "इसे टक्कर" चुनना है ... "स्वचालित कैलकुलेटर" प्रोग्राम इस तरह के "पक्ष" के रूप में जारी रहेगा।

3.1। सक्रिय कैलकुलेटर मॉडल

अंजीर में। 1 [1] से वर्ग कैलकुलेटर का मूल मॉडल दिखाता है। उपस्थिति में, यह एक क्लासिक सार मशीन जैसा दिखता है जिसमें कोई रास्ता नहीं है। अंतर यह है कि क्यूटी एक राज्य में प्रवेश करने और बाहर निकलने पर कार्रवाई को रोक देता है। आउटपुट पर, उन्हें बाहर () सिग्नल द्वारा ट्रिगर किया जाता है, और एंटर () सिग्नल द्वारा राज्य में प्रवेश करने पर। लेकिन, हम ध्यान दें, इन कार्यों को किसी भी तरह से ग्राफ में दर्शाया नहीं गया है।

अगर हम अंजीर में मॉडल की तुलना करते हैं। 1, एक सार राज्य के साथ एक ऑटोमेटन के साथ (इसके अन्य नाम संरचनात्मक, तार्किक ऑटोमेटन हैं), कोई भी आसानी से देख सकता है कि राज्य से बाहर निकलने पर होने वाली क्रियाएं मेयली ऑटोमेटन के संकेतों के अनुरूप होती हैं, और इसके प्रवेश द्वार पर कार्य मूर ऑटोमेटन के संकेतों के अनुरूप होते हैं।
टिप्पणी 3. आगे, मॉडल के सॉफ्टवेयर कार्यान्वयन पर विचार करते हुए, हम संकेतों, घटनाओं, स्थितियों आदि के बारे में बात नहीं करेंगे, लेकिन ऑटोमेटा के कार्यों के बारे में, यह मानते हुए कि कार्यक्रम के स्तर पर वे कुछ प्रोग्राम क्रियाओं से जुड़े हैं, जो सामान्य स्थिति में हैं सॉफ्टवेयर कार्यों द्वारा प्रतिनिधित्व किया।

तथाकथित संयुक्त मिलि-मूर ऑटोमैटन (या एक अलग मिश्रित ऑटोमेटन [12]), अंजीर में ऑटोमेटन के बराबर। 1, चित्र 2 में दिखाया गया है, जहां ऑटोमेटन के इनपुट और आउटपुट सिग्नल के अनुरूप कार्य भी ग्राफ के दाईं ओर दिखाए जाते हैं।

चित्र 1। कैलकुलेटर घटना मशीन आरेख

अंजीर। २। काउंट माइली-मूर ऑटोमैटॉन क्लास कैलकुलेटर

अंजीर में एक automaton के समान एक मॉडल के लिए। 2, इनपुट / आउटपुट क्रियाओं से हमारा मतलब है कि [ऑटोमेटन] कक्षाओं के प्रोग्राम फ़ंक्शंस-मेथड और क्रियाएं हैं। भविष्यवाणी स्मृति तत्वों (चर, वर्ग गुणों) की वर्तमान स्थिति का विश्लेषण किसी भी तरह से नहीं करती है (यह महत्वपूर्ण है!) उन्हें प्रभावित किए बिना, लेकिन उनके मूल्य के आधार पर, बूलियन मान लौटाते हैं। एक मान के कार्य वापस नहीं आते हैं, लेकिन स्मृति तत्वों को बदलते हैं।
अंजीर से। 2 यह अनुसरण करता है कि कैलकुलेटर मॉडल, "ब्लैक बॉक्स" की तरह, चार इनपुट चैनल और सात आउटपुट चैनल हैं जो कि विधेय और क्रियाओं की संख्या के संदर्भ में हैं। यह देखना आसान है कि एक अमूर्त ऑटोमेटन की तुलना में, जिसकी परिभाषा में एक से अधिक इनपुट और एक आउटपुट चैनल नहीं है, एक संरचनात्मक ऑटोमेटन के पास कई चैनल अधिक सार्वभौमिक, लचीले और सुविधाजनक हैं।

अंजीर में मॉडल। 2 को "gluing" 1 और 2 द्वारा सरल किया जा सकता है। ऐसा करने के लिए, आपको सबसे पहले मूल ऑटोमेटन को एक मेयली ऑटोमेटन में बदलना होगा। हम इसे मूर ऑटोमैटन के कोने के संकेतों द्वारा दर्शाए गए संकेतों के साथ संकेतों की स्थिति में प्रवेश करने वाले आर्क को लोड करके प्राप्त करते हैं। इसके बाद, ग्लूइंग ऑपरेशन स्पष्ट हो जाता है। राज्य के लिए gluing राज्यों का परिणाम, जो अब प्रारंभिक हो जाता है, अंजीर में दिखाया गया है। 3।

चित्र 3। अंजीर में ऑटोमेटन के राज्यों के परिवर्तन और gluing का परिणाम। 2

कार्रवाई y1 और चर nTypeButtons बताएं। कुल मिलाकर, वे एक प्रोटोकॉल लागू करते हैं जो घटनाओं का अनुकरण करता है। चर nTypeButtons डिजिटल प्रतीकों, ऑपरेशन प्रतीकों, "रीसेट" प्रतीक और "बराबर" प्रतीक में विभाजित करके ऑटोमेटन के इनपुट प्रतीकों के प्रकार को निर्धारित करता है। शून्य के बराबर इसका मूल्य इनपुट वर्णों की अनुपस्थिति (कैलकुलेटर कुंजी में से एक नहीं दबाया जाता है) का मतलब है। प्रतीक को संसाधित करने के बाद, इसका मतलब यह भी है कि इनपुट प्रतीक स्वचालित रूप से माना जाता है। यह इनपुट चरित्र की प्रतिक्रिया को अवरुद्ध करता है।

स्वचालित दृश्य घटक प्रोग्रामिंग (VKPa) पर्यावरण [5] के ढांचे में बनाए गए कैलकुलेटर के वर्ग के लिए कोड 1, 2 की सूची में दिखाया गया है।

लिस्टिंग 1. FCalculator वर्ग हेडर

#include "lfsaappl.h" enum Buttons { digit0 = 0, digit1, digit2, digit3, digit4, digit5, digit6, digit7, digit8, digit9, opPlus, opMinus, opCancel, opEqual, opNone }; class FCalculator : public LFsaAppl { public: void MooreAction(); LFsaAppl* Create(CVarFSA *pCVF) { Q_UNUSED(pCVF)return new FCalculator(pTAppCore, nameFsa, pCVarFsaLibrary); } FCalculator(TAppCore *pInfo, string strNam, CVarFsaLibrary *pCVFL); virtual ~FCalculator(void); public: void digitButtonPressed(int button); void operationButtonPressed(int button); private: void s1Entered(); void s2Entered(); void s3Entered(); void s3Exited(); void s5Entered(); void s5Exited(); private: int Rf, Rb; Buttons transitionButton, Op; int nTypeButtons; // 0 - none; 1 - digit button; 2 - operation button; void doOp(Buttons op); protected: int x1(); int x2(); int x3(); int x4(); void y1(); void y3(); void y5(); void y6(); void y7(); void y8(); void y9(); void y10(); int nState{2}; };

आइए बताते हैं। VKPa में, कोई भी ऑटोमेटन वर्ग बेस ऑटोमेटन वर्ग LFsaAppl के गुणों को विरासत में देता है। बनाएँ () विधि स्वचालित प्रक्रियाओं के गतिशील पुस्तकालयों में शामिल वर्गों की प्रतियां बनाता है। वर्चुअल मूरएक्शन () विधि ओवरलैप हो जाती है जब एक मूर ऑटोमैटन मॉडल का चयन किया जाता है, जो ऑटोमेटन के राज्यों से जुड़ी क्रियाओं को परिभाषित करता है। विधियों x [n] और y [n] ऑटोमेटन के इनपुट / आउटपुट चैनलों के साथ जुड़ी हुई विधेय और क्रियाएं हैं। [आटोमेटन] वर्ग का व्यवहार एल्गोरिथ्म एक संक्रमण तालिका (लिस्टिंग 2 देखें) द्वारा दर्शाया गया है, जिसमें LA LA प्रकार के तार शामिल हैं। बाकी कोड स्रोत वर्ग कैलकुलेटर के कोड को दोहराता है।

लिस्टिंग 2. FCalculator वर्ग का कार्यान्वयन

 #include "stdafx.h" #include "FCalculator.h" #include "DlgCalculator.h" #include "ui_cdlgcalculator.h" static LArc TBL_Calculator[] = { //* LArc("1", "2","x1", "y1"), // [0-9] LArc("2", "1","x3", "y1"), // [c] LArc("2", "2","x1", "y1"), // [0-9] LArc("2", "3","x2", "y1"), // [+][-] LArc("3", "1","x3", "y3"), // [c] LArc("3", "3","x2", "y3"), // [+][-] LArc("3", "4","x1", "y3"), // [0-9] LArc("3", "5","x4", "y3"), // [=] LArc("4", "1","x3", "y1"), // [c] LArc("4", "3","x2", "y1"), // [+][-] LArc("4", "4","x1", "y1"), // [0-9] LArc("4", "5","x4", "y1"), // [=] LArc("5", "1","x3", "y5"), // [c] LArc("5", "2","x1", "y5"), // [0-9] LArc("5", "3","x2", "y5"), // [+][-] //*/ /* LArc("2", "2","x1", "y1y7"), // [0-9] LArc("2", "2","x3", "y1y6"), // [c] LArc("2", "3","x2", "y1y8"), // [+][-] LArc("3", "2","x3", "y3y6"), // [c] LArc("3", "3","x2", "y3y8"), // [+][-] LArc("3", "4","x1", "y3y7"), // [0-9] LArc("3", "5","x4", "y3y9"), // [=] LArc("4", "2","x3", "y1y6"), // [c] LArc("4", "3","x2", "y1y8"), // [+][-] LArc("4", "4","x1", "y1y7"), // [0-9] LArc("4", "5","x4", "y1y9"), // [=] LArc("5", "2","x3", "y5y6"), // [c] LArc("5", "2","x1", "y5y7"), // [0-9] LArc("5", "3","x2", "y5y8"), // [+][-] */ // LArc("1", "1","--", "y10"), // SWITCH LArc() }; FCalculator::FCalculator(TAppCore *pInfo, string strNam, CVarFsaLibrary *pCVFL): LFsaAppl(TBL_Calculator, strNam, nullptr, pCVFL) { pTAppCore = pInfo; Rf= 0; Rb = 0; Op = opNone; } FCalculator::~FCalculator(void) { } //   int FCalculator::x1() { if (nTypeButtons != 1) return false; else return true; } //   +, - int FCalculator::x2() { if (nTypeButtons == 0 || nTypeButtons != 2) return false; if (transitionButton != opCancel && transitionButton != opEqual ) return true; else return false; } //  Cancel int FCalculator::x3() { if (nTypeButtons == 0 || nTypeButtons != 2) return false; if (transitionButton == opCancel) return true; else return false; } //  opEqual int FCalculator::x4() { if (nTypeButtons == 0 || nTypeButtons != 2) return false; if (transitionButton == opEqual) return true; else return false; } void FCalculator::y1() { nTypeButtons = 0; } void FCalculator::y3() { s3Exited(); } void FCalculator::y5() { s5Exited(); } void FCalculator::y6() { s1Entered(); } // 1 void FCalculator::y7() { s2Entered(); } // 2, 4 void FCalculator::y8() { s3Entered(); } // 3 void FCalculator::y9() { s5Entered(); } // 5 void FCalculator::y10() { switch(nState) { case 2: if (x1()) { y1();y7(); } if (x3()) { y1();y6(); } if (x2()) { y1();y8(); nState = 3; } break; case 3: if (x3()) { y3();y6(); nState = 2; } if (x2()) { y3();y8(); } if (x1()) { y3();y7(); nState = 4; } if (x4()) { y3();y9(); nState = 5; } break; case 4: if (x3()) { y1();y6(); nState = 2; } if (x2()) { y1();y8(); nState = 3; } if (x1()) { y1();y7(); } if (x4()) { y1();y9(); nState = 5; } break; case 5: if (x3()) { y5();y6(); nState = 2; } if (x1()) { y5();y7(); nState = 2; } if (x2()) { y5();y8(); nState = 3; } break; } } void FCalculator::MooreAction() { // return; string strState = FGetState(); if (strState=="1") { y6(); } else if (strState=="2") { y7(); } else if (strState=="3") { y8(); } else if (strState=="4") { y7(); } else if (strState=="5") { y9(); } } /////////////////////////////////////////////////////////////////////////// void FCalculator::digitButtonPressed(int button) { transitionButton = static_cast<Buttons>(button); nTypeButtons = 1; } void FCalculator::operationButtonPressed(int button) { transitionButton = static_cast<Buttons>(button); nTypeButtons = 2; } void FCalculator::s1Entered() { Rf = 0; Rb = 0; Op = opNone; static_cast<CDlgCalculator*>(this->pCVarFSA->pVFsaDialog)->ui->lcdNumber->display(Rf); } void FCalculator::s2Entered() { if (Rf < 9999999) { Rf = Rf*10 + transitionButton; static_cast<CDlgCalculator*>(this->pCVarFSA->pVFsaDialog)->ui->lcdNumber->display(Rf); } } void FCalculator::s3Entered() { if (Rb != 0) { doOp(Op); static_cast<CDlgCalculator*>(this->pCVarFSA->pVFsaDialog)->ui->lcdNumber->display(Rf); } Rb = Rf; Op = transitionButton; } void FCalculator::s3Exited() { nTypeButtons = 0; if (transitionButton > digit9 && transitionButton < opCancel ) { doOp(transitionButton); Rb = 0; Op = transitionButton; static_cast<CDlgCalculator*>(this->pCVarFSA->pVFsaDialog)->ui->lcdNumber->display(Rf); } else { Rf = 0; } } void FCalculator::s5Entered() { doOp(Op); Op = opNone; Rb = Rf; // added by me static_cast<CDlgCalculator*>(this->pCVarFSA->pVFsaDialog)->ui->lcdNumber->display(Rf); } void FCalculator::s5Exited() { nTypeButtons = 0; if (transitionButton <= 9) { Rb = 0; Rf = 0; } } void FCalculator::doOp(Buttons op) { switch (op) { case opPlus: Rf = Rf + Rb; break; case opMinus: Rf = Rb - Rf; break; default: break; } }

सूचना सूची 2 में तीन जंप टेबल हैं (दो पर टिप्पणी की गई है)। इस प्रकार, समर्पित नियंत्रण की क्षमताओं का एहसास होता है, जब टिप्पणी को हटा दिया जाता है, तो कक्षा के व्यवहार को उसके तरीकों और गुणों को प्रभावित किए बिना "क्लिक करके" बदला जा सकता है। Y10 विधि और ट्रांज़िशन टेबल में संबंधित लाइन (टिप्पणी SWICH के साथ चिह्नित लाइन देखें) VKPA प्रौद्योगिकी के ढांचे के भीतर SWITCH तकनीक (अधिक विवरण के लिए [9] देखें) मॉडलिंग के लिए पेश की गई थी। इस मामले में, किसी भी ऑटोमेटन के व्यवहार को SWITCH ऑपरेटर को चक्रीय कॉल द्वारा मॉडल किया जाता है, जो ऑटोमेटन के व्यवहार की नकल करता है (यहाँ VKPa automaton बाहरी वातावरण के रूप में कार्य करता है)।

3.2। निष्क्रिय कैलकुलेटर मॉडल

सक्रिय कैलकुलेटर मॉडल लगातार इनपुट चैनलों को स्कैन करता है। जैसे ही चर nTypeButtons का मूल्य नॉनजरो हो जाता है, यह ऑटोमोटिव के इनपुट के लिए अगले प्रतीक के आगमन के संकेत के रूप में कार्य करता है। परिणामस्वरूप, संक्रमण और क्रिया y1 ट्रिगर होते हैं, nTypeButtons चर को रीसेट करना, उसी मशीन द्वारा स्वचालित मशीन को फिर से ट्रिगर करना अवरुद्ध करना।
"सक्रिय कैलकुलेटर" मॉडल के विपरीत, एक ईवेंट ऑटोमेटन परिभाषा के अनुसार, इनपुट प्रतीक को पुन: प्रस्तुत नहीं कर सकता है। अब यह स्पष्ट है कि "ऑटोमेटन दृष्टिकोण का उपयोग करने में सबसे बड़ी कठिनाई ... इवेंट सिस्टम में" एक सक्रिय ऑटोमेटन की गतिविधि को दबाने और इसके कामकाज को घटनाओं से जोड़ने के लिए नीचे आती है। हम सिर्फ "सक्रिय कैलकुलेटर" के उदाहरण का उपयोग करके निष्क्रिय ऑटोमेटोन पर स्विच करने की प्रक्रिया दिखाते हैं।
VKPa परिवेश में स्वचालित प्रक्रियाओं को डीबग करने के लिए प्रारंभ की गई चरण-दर-चरण विधि होती है। लेकिन इसका उपयोग इवेंट मशीनों को अनुकरण करने के लिए किया जा सकता है। ऐसा करने के लिए, 1) ऑटोमेटन स्पेस सेट करें, जिसमें ऑटोमेटन को एक स्टेप-बाय-स्टेप मोड ऑफ ऑपरेशन रखा गया है (नोट, एक अलग ऑटोमेटन नहीं, बल्कि पूरी ऑटोमेटा स्पेस जिसमें ऑटोमेटा हो), और 2) स्पेस के संचालन के एक असतत कदम के निष्पादन के साथ घटनाओं के होने के क्षणों से संबंधित है। सूची 3 यह दर्शाता है कि यह कैसे करना है, केवल मॉडल में किए गए परिवर्तनों (कक्षा शीर्ष लेख अपरिवर्तित रहता है) को दर्शाता है।

लिस्टिंग 3. FCalculator वर्ग का एक अंतिम संस्करण

 static LArc TBL_Calculator[] = { LArc("st", "st","^x12", "y12"), // LArc("st", "1","x12", "y11"), // // ... }; ... //   bool FCalculator::FCreationOfLinksForVariables() { pNet = GetPointerToNet(); //    if (pNet) { string str = pNet->strName; //    //  -  pSV = this->pTAppCore->pSetVarSetting->GetAddressVar(const_cast<char*>(str.c_str())); } return true; } ... // int FCalculator::x12() { if (!pNet) return false; if (!pSV) return false; return true; } ... //    step-by-step void FCalculator::y11() { pSV->bIfStepByStep = true; } //   void FCalculator::y12() { FCreationOfLinksForVariables(); } // ... ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// void FCalculator::digitButtonPressed(int button) { ... pSV->bIfStopAllTasks = false; //     } void FCalculator::operationButtonPressed(int button) { ... pSV->bIfStopAllTasks = false; //     } ...

यहां, सबसे पहले, एक अतिरिक्त [प्रारंभिक] राज्य पेश किया जाता है, जिसमें मशीन जहां स्थित है उस स्थान का संदर्भ, और उस वस्तु का लिंक जो अंतरिक्ष के गुणों को निर्धारित करता है (इसके संचालन मोड सहित) की जाँच की जाती है। एह 12 y की क्रिया बनाता है। जब लिंक सेट हो जाते हैं, तो ऑटोमेटन स्पेस के चरण-दर-चरण ऑपरेशन मोड की स्थापना के साथ कैलकुलेटर मॉडल के [पूर्व] प्रारंभिक अवस्था में संक्रमण होता है।

इसके अलावा, मॉडल अंतरिक्ष ऑपरेशन के चरण-दर-चरण मोड में काम करता है। एक कदम की शुरूआत अगले चरित्र के इनपुट से जुड़े घटना संचालकों में डाले गए कोड को लागू करती है (देखें डिजिट 3 को डिजिटबटनप्रेन्ड और ऑपरेशनबटनपार्ट किए गए तरीकों से किए गए परिवर्तनों के लिए)।

4. क्यों?

कुछ का आविष्कार क्यों, अगर वहाँ है, जैसा कि माना जा सकता है, डी। हरेल का एक और अधिक उन्नत घटना मॉडल। और यूएमएल, स्टेटफ्लो, क्यूटी लाइब्रेरी, आदि में इसे कैसे चलाया जाए, यह अलग तरह से सोचा जाए। आदि और इसके दोषों के बारे में ज्यादा आतंक नहीं है। खैर, उन्होंने सिग्नल की घटनाओं को बुलाया, और सक्रिय मशीन को निष्क्रिय में बदल दिया ... और अगर मॉडल, जैसा कि वे कहते हैं, औपचारिक रूप से क्लासिक मिलि / मूर मशीनों के बराबर है, तो इसमें विश्वास कैसे नहीं किया जाए? और इसलिए यह है, अगर इन सभी बयानों को केवल विश्वास पर लिया जाता है ...

घटना की शुरुआत के लिए ले लो (यह वही है जो हमने ऊपर किया था)। उदाहरण के लिए, एक क्लासिक संरचनात्मक ऑटोमेटन में कई इनपुट चैनल होते हैं, जिनमें से प्रत्येक एक सिग्नल से जुड़ा होता है, और उन्हें एक साथ / समानांतर में संसाधित किया जा सकता है। लेकिन यूएमएल का कहना है कि "प्रत्येक वस्तु एक समय में केवल एक घटना को संसाधित कर सकती है" और यहां तक कि अगर "दो घटनाएं एक साथ होती हैं, तो भी वस्तु उन्हें एक समय में संसाधित करेगी" [10]। इस प्रकार, परिभाषा के स्तर पर, संकेत और घटनाएं बराबर हैं, लेकिन आदर्श मॉडल के बदलावों को लागू करने की प्रक्रिया में गिर जाता है।

उस उदाहरण पर विचार करें जिसके साथ मैं किसी भी भाषा या प्रौद्योगिकी का परीक्षण / सीखना शुरू करता हूं। यह तत्व मॉडल और नहीं के सॉफ्टवेयर कार्यान्वयन के बारे में है। संरचनात्मक स्तर पर, यह "ब्लैक बॉक्स" से मेल खाता है, जिसमें दो इनपुट चैनल और एक आउटपुट है, और एल्गोरिदम पर एक, आटोमेटन को अंजीर में दिखाया गया है। 4।

अंजीर। 4. तत्व और नहीं के automaton मॉडल

एक नियमित प्रक्रियात्मक मॉडल (सूची 4 देखें) कैसे बनाएं या वीकेपीए में ऑटोमेटन कैसे लागू करें (देखें लिस्ट 5 देखें) समझ में आता है, लेकिन ईवेंट के आधार पर इसे कैसे दोहराना है क्यूटी लाइब्रेरी के ऑटोमोबेटन राज्य से संक्रमण को लागू करने की समस्या के कारण बहुत स्पष्ट नहीं है "1"। "0", जो कई घटनाओं के साथ-साथ विश्लेषण की आवश्यकता है।

लिस्टिंग 4. AND-NOT प्रक्रियात्मक मॉडल का ऑब्जेक्ट कार्यान्वयन

लिस्टिंग 4. AND-NOT प्रक्रियात्मक मॉडल का ऑब्जेक्ट कार्यान्वयन

 class INE { public: INE() {} ~INE(void); bool bX1, bX2, bY; bool f() { return bY = !(bX1&&bX2); } };

लिस्टिंग 5. एंड-नहीं ऑटोमेटन मॉडल का ऑब्जेक्ट कार्यान्वयन

 LArc T_INE[] = { LArc("s1", "s0", "x1x2", "y1"), LArc("s0", "s1", "^x1", "y2"), LArc("s0", "s1", "^x2", "y2"), }; class Ine : public LFsaAppl { public: Ine(string strNam = "-"): LFsaAppl(T_INE, strNam) {} ~Ine(void); bool bX1, bX2; protected: int x1() { return bX1; } int x2() { return bX2; } };

इस प्रकार, QT ऑटोमेटन वर्गों के ढांचे के भीतर NAND तत्व के ईवेंट मॉडल के कार्यान्वयन को हैबरोन्स के लिए "होमवर्क" होने दें। मैं केवल "केक पर चेरी" के रूप में स्टेटफ्लो में उसके फैसले का हवाला दे सकता हूं। यह अंजीर में दिखाया गया है। 5. स्टेटफ्लो राहत का उपयोग यहां किया जाता है, जो किसी घटना के साथ संक्रमण को चिह्नित नहीं करने देता है: यदि घटना का नाम निर्दिष्ट नहीं है, तो संक्रमण तब होगा जब कोई भी घटना होती है (उदाहरण के लिए [13] में संक्रमण लेबल देखें)।

अंजीर। 5. स्टेटफ्लो में AND-NOT तत्व का एक ऑटोमेटन मॉडल

इस प्रकार, राज्य मशीन एक मशीन का एक संकर (सक्रिय-निष्क्रिय) मॉडल है। सच है, यह स्पष्ट नहीं है कि मशीन किसी भी घटना के अभाव में कैसे व्यवहार करेगी। यह माना जा सकता है कि यह घटनाओं की प्रत्याशा में "फ्रीज" करेगा। और अगर वे नहीं होंगे? यानी अंत में, यह अभी भी एक सक्रिय मशीन मॉडल की तुलना में एक निष्क्रिय संभावना है। यद्यपि केवल उपस्थिति में इसे बाद के लोगों से अलग करना मुश्किल है।

5. निष्कर्ष

घटनाओं के संबंध में, हम कह सकते हैं कि, गतिविधि के कारण, ऑटोमेटा के शास्त्रीय मॉडल का कार्यान्वयन तुल्यकालिक ऑटोमेटा के मॉडल के लिए बेहतर लगता है। अगर हम सामान्य रूप से स्वचालित प्रोग्रामिंग के बारे में बात करते हैं, तो स्टेटफ्लो एक्सटेंशन पैकेज दर्शाता है कि पूरी तरह से अलग तरह की प्रोग्रामिंग क्या हो सकती है। लेकिन, दुर्भाग्य से, अभी तक केवल परिप्रेक्ष्य में, क्योंकि राज्यप्रवाह कम्प्यूटेशनल मॉडल के कारण समस्याएं बनी हुई हैं, जो अनिवार्य रूप से एक ब्लॉक आरेख है। ऐसा लगता है कि इन कारणों से, ऑटोमेटा के साथ, स्टेटफ़ो में दृश्य प्रोग्रामिंग फ्लोचार्ट्स के अंकन द्वारा दर्शाया गया है।

यह पता लगाने के लिए कि वास्तविक स्वचालित प्रोग्रामिंग कहां है, और इसकी नकल कहां है, हमारे मुख्य लक्ष्यों में से एक है। पिछले लेख [5] में, हमने एक मूल कार्य को हल किया था - हमने ऑटोमेटन कार्यक्रमों की अवधारणा तैयार की। अगला, आपको प्रोग्राम प्रबंधन मॉडल की परिभाषा से निपटने की आवश्यकता है, जो परिमित-ऑटोमेटन होना चाहिए और प्रोग्रामर के लिए प्रभावी और सुविधाजनक होना चाहिए।

घटनाओं से निपटने के बाद, हमने इस तरह के काम की नींव रखी। आगे के लेखों में, हम पहले से ही डी। हरेल द्वारा प्रस्तावित मॉडल के विवरण को समझेंगे। थोड़ा आगे बढ़ते हुए, हम कहते हैं कि, इसे स्पष्ट रूप से रखने के लिए, उसने ऑटोमेटा की समझ को विकृत कर दिया। लेकिन, दूसरी ओर, यहां हमें इसे इसकी वजह से देना चाहिए, उसने उन समस्याओं का खुलासा किया जो उसके बिना, शास्त्रीय मॉडल के ढांचे के भीतर एक प्रभावी स्वचालित प्रोग्रामिंग बनाने की अनुमति नहीं देगी जो प्रोग्रामर को आकर्षित करेगी।

हमने पाया कि ऊपर, कम से कम, घटना स्तर पर, शास्त्रीय ऑटोमेटा को कोई समस्या नहीं है। हम आगे समझेंगे ... इस बीच, यह केवल शुरुआत है। हम बहुत सी दिलचस्प चीजों की प्रतीक्षा कर रहे हैं, और, ध्यान दें, ऑटोमेटा के शास्त्रीय सिद्धांत से परे नहीं। यह महत्वपूर्ण है अगर हम वास्तव में स्वचालित प्रोग्रामिंग चाहते हैं। हम आपको सफलता की कामना करते हैं! :)

संदर्भ

1. बोरोव्स्की ए.एन. Qt4.7। प्रैक्टिकल सी ++ प्रोग्रामिंग। - एसपीबी ।: बीएचवी-पीटर्सबर्ग, 2012 ।-- 496 पी।
2. बुच जी, रैमबो जे।, जेकोबसन आई। यूएमएल। उपयोगकर्ता मैनुअल। दूसरा संस्करण। अकादेमी आईटी: मॉस्को, 2007 ।-- 493 पी।
3. शाओली ए। ए। स्वचालित प्रोग्रामिंग पर एक नया व्याख्यान है। 2019, [इलेक्ट्रॉनिक संसाधन], एक्सेस मोड : www.youtube.com/watch?v=PPWTxceMutk&feature=youtu.be , मुफ्त। Jaz। रस। (उपचार की तारीख 5 दिसंबर, 2019)।
4. राज्यप्रवाह। www.mathworks.com/products/stateflow.html , मुफ्त। Jaz। अभियांत्रिकी। (प्रचलन दिनांक 7.01.2020)।
5. ट्यूरिंग मशीन, ऑटोमेटन कार्यक्रमों के एक मॉडल के रूप में। habr.com/en/post/481998 , मुफ्त। Jaz। रस। (प्रचलन दिनांक 7.01.2020)।
6. मेलिखोव ए.एन. ओरिएंटेड रेखांकन और परिमित राज्य मशीनें। - एम ।: नौका, 1971. - 416 पी।
7. कुडवेटसवीवी वीबी, एलशिन एस.वी., पोडकोलिन ए.एस. ऑटोमेटा के सिद्धांत का परिचय - एम ।: विज्ञान। अ। एड। विज्ञान। लिट।, 1985 ।-- 320 पी।
8. तुक्केल एन.आई., शाल्टो ए.ए. प्रोग्रामिंग इवेंट सिस्टम जब ऑटोमेटा का कार्यान्वयन। "प्रोग्रामर", 2002. नंबर 4। C.74-80।
9. पोलिकारपोवा एन।, ए। शाल्टो ए। ऑटोमेटन प्रोग्रामिंग। 2 एड।, सेंट पीटर्सबर्ग ।: पीटर, 2011 ।-- 176 पी।
10. रेम्बो जे।, जैकबसन ए।, बुच जी। यूएमएल: विशेष संदर्भ। - सेंट पीटर्सबर्ग: पीटर, 2002 ।-- 656 पी।
11. गोमा एच। यूएमएल। वास्तविक समय प्रणाली, समानांतर और वितरित अनुप्रयोगों का डिजाइन: प्रति। अंग्रेजी से - एम ।: डीएमके प्रेस, 2002। - 2002। - 704 पी।
12. SHALYTO ए.ए. SWITCH तकनीक। तर्क नियंत्रण कार्यों का एल्गोरिदम और प्रोग्रामिंग। सेंट पीटर्सबर्ग: नाका, 1998.628 एस।
13. रोजचेव जी.एन. स्टेटफ़्लो सूचनाएं। bourabai.kz/cm/stateflow13.htm , मुफ्त। Jaz। रस। (अपील की तारीख 01.10.2020)।

एक ऑटोमेटन एक घटना है?