👩🏼‍🎨 🚊 🍉 मॉडलिका पर एक साधारण युद्ध मॉडल 👲🏿 👩🏾‍🔧 👨🏽‍🚀

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

नोट: लेख की तैयारी के लिए, नवीनतम OpenModelica नाइट बिल्ड (Rev18625) का उपयोग किया गया था। स्थापित करते समय, ध्यान दें कि आपको रिक्त स्थान के बिना एक पथ निर्दिष्ट करना होगा।

कार्य

एक ऐसी प्रक्रिया के रूप में एक युद्ध की कल्पना करें जिसमें दो विरोधी, जिनके पास अलग-अलग ताकतें हैं (अनुपात के मामले में, लेकिन ताकत में नहीं), एक ही लक्ष्य प्राप्त करें - उस पर दुश्मन की सेना को नष्ट करके सबसे बड़े संभावित दुश्मन के इलाके पर कब्जा करना। निश्चितता के लिए, हम मान लेंगे कि इस क्षेत्र पर विजय प्राप्त की गई थी जब पैदल सेना (जमीनी सैनिकों) ने इस पर पैर रखा था। क्षेत्र में समुद्र शामिल नहीं है। जब दुश्मन के पूरे क्षेत्र पर विजय प्राप्त की जाती है तो जीत मायने रखती है।

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

लड़ाई एक वर्ग में होती है, जिसमें सामने की रेखा क्षैतिज रूप से चलती है, और दाईं ओर - समुद्र, जहां जहाजों का संचालन होता है। वर्ग के किनारे की लंबाई को एल द्वारा चिह्नित किया जाता है (निश्चितता के लिए, हम इसे 100 किलोमीटर के रूप में लेते हैं)। तब एक तरफ से जीता गया क्षेत्र ए * एल के बराबर होगा, जो दुश्मन द्वारा जीता गया - (एलए) * एल। ए में परिवर्तन बलों के संतुलन पर निर्भर करेगा। अधिक से अधिक सामने वाले बल प्रबल होते हैं, उतना ही A बदल जाएगा (उन बलों के पक्ष में जो बड़े हैं)। निश्चितता के लिए कहें, एक तरफ एक पैदल सेना की इकाई सामने (यदि एक लड़ाई के बिना) समय की प्रति यूनिट 1 किलोमीटर आगे बढ़ाती है।

मॉडलिका को स्वीकार करता है

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

कक्षाएं विरासत में प्राप्त की जा सकती हैं (कई, और केवल हीरे सहित)। मॉडलिका के लिए, इसका मतलब है कि विरासत में मिली सभी सामग्रियों को समीकरणों सहित विरासत वाले वर्ग में कॉपी किया जाता है। और यहां हमें मॉडलिका के मुख्य नियम का उल्लेख करना चाहिए - चर के समीकरणों की संख्या चर की संख्या के अनुरूप होनी चाहिए। न ज्यादा और न कम।

समस्या को हल करने का एक उदाहरण

वर्ग का सबसे सरल प्रकार - रिकॉर्ड - में समीकरण नहीं हो सकते।
सबसे पहले, हम एक सार प्रकार की लड़ाकू इकाई को परिभाषित करते हैं।

UnitData.mo

record UnitData "Abstract army unit record" parameter Real unitHealth; parameter Real unitAttack; parameter Real supplyTime; parameter Real supplyNumber; end UnitData;

यह कोड चार असिंचित मापदंडों की घोषणा करता है। उद्धरण चिह्नों में, कक्षाओं और चरों की घोषणा करने के बाद, आप प्रलेखन स्ट्रिंग जोड़ सकते हैं। सामान्य तौर पर, मॉडलिका में टिप्पणियां - सी ++ - शैली, अर्थात, या / / * * / (इस तरह की टिप्पणियों को पर्यावरण द्वारा अनदेखा किया जाता है)।

अगला कदम समीकरणों के साथ एक वर्ग घोषित करना होगा, जिनमें से कुछ सैन्य बल होंगे, जो सैन्य इकाइयों या मात्रा के समान होंगे।

Forces.mo

 class Forces "Abstract army forces class" extends UnitData; parameter Real startNumber = 0; Real number (start = startNumber); Boolean destroyed; equation destroyed = number < 0; when destroyed then reinit(number, 0); end when; when sample(supplyTime, supplyTime) then reinit(number, pre(number) + supplyNumber); end when; end Forces;

इस फ़ाइल के उदाहरण का उपयोग करके, आप विरासत का पता लगा सकते हैं, साथ ही साथ मॉडलिका घटनाओं के साथ काम कर सकते हैं।
यदि समीकरण नष्ट हो गया = संख्या <0; प्रश्नों का कारण नहीं होना चाहिए, फिर पहले ब्लॉक के अंदर जब विशेष पुनर्निदेशक ऑपरेटर का उपयोग किया जाता है, जो दूसरे पैरामीटर के रूप में अभिव्यक्ति के परिणाम के लिए चर मान सेट करता है। पूर्व (पिछले चरण का मान) की तरह सुदृढ़ीकरण केवल ब्लॉक के अंदर ही उपयोग किया जा सकता है। प्री का उपयोग किया जाना चाहिए ताकि समीकरण (अर्थात् समीकरण) इस तरह से न हो: x = x + 1।

अंतर्निहित नमूना फ़ंक्शन सही हो जाता है यदि सिमुलेशन समय (समय) पहले पैरामीटर (पहले कॉल) के बराबर है, और फिर दूसरे पैरामीटर के बराबर अंतराल पर (हमारे मामले में वे समान हैं - सप्लाईटाइम की शुरुआत से बराबर अंतराल पर मदद आती है)।

अगला, दुश्मन की सेना का प्रतिनिधित्व करने वाला एक वर्ग काम आएगा:

EnemyForces.mo

 class EnemyForces "Enemy forces references" replaceable Forces enemyAir; replaceable Forces enemySea; replaceable Forces enemyLand; end EnemyForces;

एक परिवर्तनीय को बदले जाने योग्य के रूप में निर्दिष्ट करने से आपको एक दुश्मन के ऑब्जेक्ट की घोषणा करते समय एक चर के प्रकार को फिर से परिभाषित करने की अनुमति मिलती है।

अब हम सबसे महत्वपूर्ण बात पर आते हैं। दरअसल सेना का प्रतिनिधित्व करने वाला वर्ग।

Army.mo

 class Army class LandArmy = Forces(unitHealth = 100, unitAttack = 400, supplyTime = 0.25, supplyNumber = 800); class AirArmy = Forces(unitHealth = 400, unitAttack = 750, supplyTime = 0.5, supplyNumber = 400); class SeaArmy = Forces(unitHealth = 3000, unitAttack = 7000, supplyTime = 1, supplyNumber = 20); SeaArmy seaArmy; AirArmy airArmy; LandArmy landArmy; EnemyForces enemyForces (redeclare Army.AirArmy enemyAir, redeclare Army.SeaArmy enemySea, redeclare Army.LandArmy enemyLand); Real armyForce; equation armyForce = seaArmy.unitHealth * seaArmy.number + airArmy.unitHealth * airArmy.number + landArmy.unitHealth * landArmy.number; der(seaArmy.number) = if not seaArmy.destroyed then -(enemyForces.enemyAir.number * enemyForces.enemyAir.unitAttack + enemyForces.enemySea.number * enemyForces.enemySea.unitAttack) / seaArmy.unitHealth else 0; der(airArmy.number) = if not airArmy.destroyed then -(enemyForces.enemyAir.number * enemyForces.enemyAir.unitAttack + enemyForces.enemySea.number * enemyForces.enemySea.unitAttack + enemyForces.enemyLand.number * enemyForces.enemyLand.unitAttack) / airArmy.unitHealth else 0; der(landArmy.number) = if not landArmy.destroyed then -(enemyForces.enemyAir.number * enemyForces.enemyAir.unitAttack + enemyForces.enemyLand.number * enemyForces.enemyLand.unitAttack) / landArmy.unitHealth else 0; end Army;

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

यदि नौसैनिक सेना को नष्ट नहीं किया जाता है, तो हर समय, सभी कवच से वायु और समुद्री बलों की क्षति कम हो जाती है,
यदि वायु सेना को नष्ट नहीं किया जाता है, तो किसी भी समय, दुश्मन के सैनिकों द्वारा किए गए नुकसान के सभी कवच से घट जाती है,
इसी तरह जमीनी सैनिकों के अलावा, नौसैनिक बल उन्हें नुकसान नहीं पहुंचाते

नोटेशन डेर (var), var (परिवर्तनशील) का समय व्युत्पन्न है।

और अंत में, हम स्वयं सशस्त्र संघर्ष का वर्णन करेंगे।

Conflict.mo

 model Conflict "Conflict of two armies model" parameter Real armyASea = 200; parameter Real armyAAir = 1000; parameter Real armyALand = 4000; parameter Real armyBSea = 100; parameter Real armyBAir = 1800; parameter Real armyBLand = 3600; Army armyA ( seaArmy.startNumber = armyASea, airArmy.startNumber = armyAAir, landArmy.startNumber = armyALand, enemyForces.enemyAir.startNumber = armyBAir, enemyForces.enemySea.startNumber = armyBSea, enemyForces.enemyLand.startNumber = armyBLand ); Army armyB ( seaArmy.startNumber = armyBSea, airArmy.startNumber = armyBAir, landArmy.startNumber = armyBLand, enemyForces.enemyAir.startNumber = armyAAir, enemyForces.enemySea.startNumber = armyASea, enemyForces.enemyLand.startNumber = armyALand ); parameter Real L = 100; parameter Real landArmySpeed = 1; Real A (start = L / 2); equation armyA.enemyForces.enemyAir.number = armyB.airArmy.number; armyA.enemyForces.enemySea.number = armyB.seaArmy.number; armyA.enemyForces.enemyLand.number = armyB.landArmy.number; armyB.enemyForces.enemyAir.number = armyA.airArmy.number; armyB.enemyForces.enemySea.number = armyA.seaArmy.number; armyB.enemyForces.enemyLand.number = armyA.landArmy.number; when A > L then terminate("Army A wins"); end when; when A < 0 then terminate("Army B wins"); end when; der (A) = (armyA.landArmy.number - armyB.landArmy.number) * landArmySpeed / L; end Conflict;

यहां कीवर्ड मॉडल का उपयोग किया जाता है। यह भी एक वर्ग है, लेकिन केवल मॉडल का उपयोग अनुकूलन के लिए किया जा सकता है (जिसके बारे में बाद में)।
युद्धरत दलों की घोषणा करने के अलावा, जिन पर हम वास नहीं करेंगे, ऐसे समीकरण हैं जो कि दुश्मन A को B मानते हैं, और इसके विपरीत। जब स्थिति होती है, तो दो का मतलब है कि क्या हुआ की एक निशान के साथ मॉडलिंग को समाप्त करना।

लॉन्च और परिणाम

मॉडल को चलाने के लिए, आप इसमें निम्न टाइप करके शेल ओपनमोडेलिका का उपयोग कर सकते हैं:

शेल ओपनमोडेलिका कमांड्स

 loadModel(Modelica) loadFile("d:/path/UnitData.mo") loadFile("d:/path/Forces.mo") loadFile("d:/path/EnemyForces.mo") loadFile("d:/path/Army.mo") loadFile("d:/path/Conflict.mo") simulate(Conflict, stopTime = 2) plot({armyA.armyForce, armyB.armyForce}, xRange = {0, 2}) plot({armyA.landArmy.number, armyB.landArmy.number, armyA.seaArmy.number, armyB.seaArmy.number, armyA.airArmy.number, armyB.airArmy.number}, xRange = {0, 2}) plot(A, xRange = {0, 2})

संबंधित निर्माण नीचे दिए गए चित्रों में दिखाए गए हैं।

यह समय में बलों का अनुपात कैसे दिखता है।

यह है कि समय के दौरान सैनिकों के प्रकारों के संदर्भ में बलों का सहसंबंध कैसा दिखता है।

और इसलिए सामने लाइन है। ग्राफ़ से यह स्पष्ट है कि सेना ए पहले जीती, लेकिन फिर सेना बी ने उसे हरा दिया।

OpenModelica के साथ अनुकूलन

मॉडल के अनुसार क्या किया जा सकता है, इसके अलावा, आप मॉडल द्वारा लगाए गए प्रश्नों के उत्तर भी पा सकते हैं। उदाहरण के लिए, यदि आप अपने आप से पूछते हैं कि सेना बी में न्यूनतम न्यूनतम संख्या में कौन सी सेना जीतती है, तो OpenModelica में शामिल OMOptim टूल का उपयोग करके आप निम्नलिखित चित्र प्राप्त कर सकते हैं:

एक निष्कर्ष के बजाय

OpenModelica उन लोगों के लिए अच्छी तरह से प्रलेखित है जो अंग्रेजी से परिचित हैं। सामान्य तौर पर, उपकरण आशाजनक है। अब तक, त्रुटि संदेश बहुत बात नहीं कर रहे हैं, और डिबगिंग जानकारी यह नहीं कहती है कि यह आसानी से व्याख्या की गई है। लेकिन सामान्य तौर पर, पर्याप्त रुचि और समय के साथ - सब कुछ पराजित होता है।

फिर भी एक निष्कर्ष के बजाय

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

उपयोगी लिंक

उत्कृष्ट ट्यूटोरियल (अंग्रेजी में)।
वेब संदर्भ (अंग्रेजी में)।

अद्यतन
कुछ समय बाद, मुझे एहसास हुआ कि अपने "कवच" को बुलाने के लिए इसका कवच कुछ जल्दबाजी है। हालांकि, प्रकाश संशोधन:

सेना। बार-बार बदलती है

 class Army //... Real armyHealth, armyStrength; equation armyHealth = seaArmy.unitHealth * seaArmy.number + airArmy.unitHealth * airArmy.number + landArmy.unitHealth * landArmy.number; armyStrength = seaArmy.unitAttack * seaArmy.number + airArmy.unitAttack * airArmy.number + landArmy.unitAttack * landArmy.number; //... end Army;

आप पहले से बताए गए निष्कर्षों की पुष्टि करेंगे।

समय सारिणी

मॉडलिका पर एक साधारण युद्ध मॉडल