Higher order Runge-Kutta Methods - MATLAB Video Lecture | MATLAB Programming for Numerical Computation - Software Development

नमस्कार और न्यूमेरिकल
कम्प्युटशंस के लिए
MATLAB प्रोग्रामिंग
(MATLAB programming for Numerical Computations
) में आपका स्वागत
है। हम सप्ताह संख्या
7 में हैं, इस मॉड्यूल
में हम आर्डिनरी
डिफरेंशियल एक्वेशन्स
(ordinary differential equations) को कवर
कर रहे हैं- इनिशियल
वैल्यू प्रोब्लेम्स
(initial value problems)। इसलिए,
अब तक हमने यूलर (Euler)
के तरीके और रनगे-कुट्टा
(Runge-Kutta) के दूसरे ऑर्डर
(order) के तरीके पर ध्यान
दिया है और हमने उनके
इस्तेमाल से कुछ
समस्याओं को हल किया
है। हमने ode45 एल्गोरिथ्म
(algorithm) को भी देखा है
जो कि MATLAB ode इनिशियल
वैल्यू प्रोब्लेम्स
(initial value problems) को हल करने
के लिए प्रदान करता
है।
इस व्याख्यान में,
हम आगे बढ़ने जा रहे
हैं और उच्च आर्डर
(order) रनगे -कुट्टा (Runge-Kutta)
विधियों का उपयोग
करने जा रहे हैं।
इससे पहले, हम ऐसा
करते हैं, आइए हम RK
-2 ह्यून (Heun) की विधि
पर दोबारा गौर करें।
आज हम जो करने जा रहे
हैं, वह RK -2 ह्यून (Heun)
का तरीका है, जिसे
हमने विकसित किया
था, एक विशिष्ट समस्या
के लिए y’=-2ty। हम इसे
संशोधित करने जा
रहे हैं, एक सामान्य
समस्या के लिए जो
एक आर्गुमेंट (argument)
के रूप में myFun (t, y) लेता
है। तो myFun (t, y), मूल रूप
से, यह f (t, y) उत्पन्न
करता है और इसे RK-2
Heun की विधि पर भेजता
है। हम आगे बढ़ते
हैं और ऐसा करने के
लिए कोड को संशोधित
करते हैं। पहले हम
यह करेंगे, सिस्टम
(system) y’=-2ty के लिए mod तो
हम इसे pfr समस्या के
लिए विस्तारित करेंगे।
हमें MATLAB पर जाएं और
इसे करें ठीक है।
तो, यह RK -2 ह्यून (Heun)
की विधि है, जिसे हमने
व्याख्यान 7 .2 में
लिखा था। तो, हम क्या
करने जा रहे हैं, इस
के बजाय, इस में हार्ड
कोडेड (hard coded) किया
जाए, जो हम इसे बदलने
जा रहे हैं वह एक फ़ंक्शन
(function) myFun के माध्यम
से ठीक है। तो, चलिए
पहले एक फंक्शन (function)
myFun, function dy = myFun (t, y) और dy
= -2 * t * y बनाते हैं।
आइए हम इसे MyFun के रूप
में save करते हैं। तो,
k1 को myFun (t, y) द्वारा
प्रतिस्थापित किया
जाना चाहिए। अभी
k1, मूल रूप से (ti, yi) होने
जा रहा है। इसलिए,
मैं बस (ti, yi) को प्रतिस्थापित
करने जा रहा हूं।
तो k2, f (tNew, yNew) के अलावा
कुछ भी नहीं है। फ़ंक्शन
(function) f, के माध्यम से
फिर से एक ही फ़ंक्शन
(function), myFun प्राप्त किया
जाता है, इसलिए, हम
बस यह करेंगे। और
वह हमारी समस्या
को पूरा करना चाहिए।
अब, हम यह भी करना
चाहते हैं कि हमें
यहाँ पर इस अतिरिक्त
(tNew, yNew) की आवश्यकता
नहीं है। तो, मैं अभी
इसे हटा दूंगा और
सीधे tNew को T (i) + h से
बदल दूंगा और मैं
YNew को Y (i) + hk1 के साथ बदल
दूंगा। और यह हमारा
RK2heuns मेथड बन जाता
है, जो फंक्शन myFun का
उपयोग करता है। हम
इसे save करते है और
हमें run करने दें।
और यह समग्र कर्व
(curve) को दर्शाता है,
जो ठीक उसी तरह दिखता
है जैसा हमने पहले
किया था। तो आइए, हम
भी फिर से देखें, अधिकतम
एरर (error), अधिकतम एरर
(error) 0 .0021 थी जो हमने
पहले व्याख्यान 7.2
में प्राप्त की थी।
ठीक है तो, हमने जो
किया है वह है, हमने
फ़ंक्शन (function) myFun का
उपयोग करने के लिए
RK -2 ह्यून (Heun) की विधि
सामान्यीकृत की है।
अब, हम जो करने जा
रहे हैं, वह PFR समस्या
को ठीक करने के लिए
है। तो, runPFRcode वह कोड
था जिसे हमने पहले
लेक्चर 7.3 में इस्तेमाल
किया था।
अब मैं जो करने जा
रहा हूं, वह ode45 का उपयोग
करने के अलावा है।
मैं हल करूंगा, RK -2
ह्यून (Heun) की विधि
का उपयोग करके। तो,
यह करने के लिए, मैं
जो करने जा रहा हूं,
उसके लिए, ज्यादातर,
मुझे जो चाहिए वह
है यह हिस्सा और यह
हिस्सा। तो, हम इसे
लेते हैं। इसे यहाँ
पर कॉपी और पेस्ट
(Copy and paste) करें ठीक है।
ह्यून (Heun) की विधि
का उपयोग करने से
पहले हल करने के लिए,
हमें इनिशियलाइज़
(initialize) करने की आवश्यकता
है। इनिशियलाइज़ेशन
(initialization), क्या हमें
इस भाग को कॉपी (copy)
करके यहाँ पर पेस्ट
(paste) करने की आवश्यकता
है। तो, t हमारी T, कैपिटल
टी हमारे डिपेंडेंट
वेरिएबल (dependent variable)
हैं, Y हमारा डिपेंडेंट
वेरिएबल (dependent variable)
है। इस मामले में
Y को एकाग्रता C के
साथ बदलना होगा, जो
डिपेंडेंट वेरिएबल
(dependent variable) ठीक हैं।
इसलिए, वे एकमात्र
बदलाव हैं जिन्हें
हमें ठीक करने की
आवश्यकता है। चलो,
अब हम क्या करेंगे,
बस उस विशेष कोड को
run करें। आइए हम इस
कोड को run करते हैं
और हम यहीं से एरर
(error) शुरू करने जा रहे
हैं। इसलिए, हम एरर
(error) के बारे में बहुत
अधिक चिंता किए बिना,
आगे बढ़ें और ऐसा
करें। हम यहाँ पर
क्या करेंगे, बस इस
अंत मात्रा को V = 5
तक कर देंगे। और हम
इसे run करते हैं। हमें
वेरिएबल (variable) t0 की
एक एरर (error), अपरिभाषित
फ़ंक्शन (function) मिला।
ध्यान रखें, कि हमारा
इनडिपेंडेंट वेरिएबल
(independent variable) V या V0 था।
इसलिए, इसे यहां लाने
की जरूरत है। तो, यह
V0 से Vend तक जाएगा। वह
h के चरणों में हमारा
t है। तो, हम यह भी कहते
हैं, कि क्या होने
जा रहा है। h 0.1 होने
जा रहा है। तो, N के
रूप में vVend-V0 हो गया,
h द्वारा विभाजित
है कि हमारे n है । हमारे
पास y के बराबर zeroes(N
+ 1, 1)। और Y1 डिपेंडेंट
वेरिएबल (dependent variable)
है इस मामले में डिपेंडेंट
वेरिएबल (dependent variable)
C0 है। तो मैं बस इस
को बदल दूंगा और मैं
कहूंगा कि इनिशियलाइज़ेशन
(initialization), हल करना है।
और, मैं जो करूंगा
वह प्लाट(plot) है।
प्लॉटिंग (plotting), परिणाम,
plot (VSol, CSol) को ब्लू लाइन
(blue line) और (t, y) को डैश
(dash) लाल लाइन के रूप
में ठीक है। और दूसरी
बात यह है कि, हमें
इसे एक उपयुक्त फ़ंक्शन
(function) pfrFun के साथ ठीक
करने की आवश्यकता
है। आइए हम clear all, close
all करें और सभी को runPFRcode
run करें।
और जैसा कि आप लाल
रेखा को देख सकते
हैं, लाल डैश (dash) रेखा
नीली ठोस रेखा के
ठीक ऊपर या लगभग ऊपर
है। लाल रेखा हमारी
ह्यून (Heun) विधि है।
जबकि, ब्लू लाइन हमारा
ode45 सॉल्वर (solver) है।
इसलिए, जैसा कि आप
यहां देख सकते हैं,
इसलिए यह समग्र कोड
(code) है जो हमारे पास
ठीक है। Ode45 सॉल्वर
(solver) का उपयोग करके
कोड (code) को प्राप्त
करना बहुत सरल था,
RK -2 ह्यून (Heun) की विधि
का उपयोग करते हुए
यदि आप याद करते हैं,
तो यह मुख्य कोड (code)
था जिसे हमने RK -2 ह्यून
(Heun) से कॉपी पेस्ट
(copy paste) किया था, यह मुख्य
कोड (code) था। और इसके
अलावा, हमें कुछ इनिशियलाइज़ेशन
(initialization) करना था, हमें
अपने h को इनिशियलाइज़
(initialize) करना था, हमें
अपने इंडिपेंडेंट
वैरिएबल (independent variable)
T को इनिशियलाइज़
(initialize) करना है, हमें
अपने डिपेंडेंट वेरिएबल
(dependent variable) Y को इनिशियलाइज़
(initialize) करना है।
एक बार जब हमने ऐसा
कर लिया, तो हम इसे
उपयोग कर पाएंगे
RK -2 ह्यून (Heun) का तरीका
ठीक है। ठीक है, इसलिए
हमने जो किया है, उसने
हमारे RK -2 ह्यून (Heun)
की विधि को फिर से
परिभाषित किया है
और इसे सामान्य (generalized)
किया है, एक सामान्य
फ़ंक्शन (function) myFun और
pfr फ़ंक्शन (function) pfrFun
का उपयोग करने के
लिए। आगे, हम इसे RK-4
विधि तक विस्तारित
करने जा रहे हैं।
RK-4 विधि, आमतौर पर
सबसे लोकप्रिय रनगे
-कुट्टा (Runge-Kutta) विधि
है। RK -3 पद्धति तीन
वज़न w1 k1 + w2 K2 + w3 k3 का
उपयोग करती है; RK -4
विधि एक चौथे वजन
+ w4 k4 का भी उपयोग करती
है। RK-3 विधि में लोकल
ट्रंकेशन एरर (local
truncation error) (h ^ 4) है। जबकि,
RK -4 पद्धति में लोकल
ट्रंकेशन एरर (local
truncation error)(h ^ 5) है। सबसे
अच्छी rk5 विधि में
भी एरर (error) है (h ^ 5)।
इसके परिणामस्वरूप,
हमें RK-4 विधि के बजाय
rk5 विधि का उपयोग करके
बड़ा लाभ नहीं मिलता
है। इसलिए RK-4 विधि
यकीनन, सबसे लोकप्रिय
RK पद्धति है, ठीक है।
हम RK-4 विधि का उपयोग
करके पहली समस्या
y` = -2ty को हल करेंगे।
RK-4 पद्धति यहाँ Y (i
+ 1) = Y (i) + h / 6 * k1 + 2k2 + 2k3 + k4
वगैरह, वगैरह ठीक
है। तो, चलिए MATLAB पर
चलते हैं, हम अपने
RK -2 ह्यून (Heun) की विधि
खोलें। और इसे RK-4 मानक
के रूप में save करें।
मानक RK-4 विधि का उपयोग
करके RK-4 का उपयोग करके
ODE-IVP को हल करें। इनिशियलाइज़ेशन
(initialization) भाग वही रहता
है। प्रारंभिक (initialize)
समस्या की परिभाषा
समान है।
आरके -4 पद्धति का
उपयोग कर, इनिशियलाइज़ेशन
(initialization) वही रहता है।
k1 = यह, k2 = myFun का कुछ,
k3 = myFun का कुछ, k4 = myFun का
कुछ और Y (i + 1) = Y (i) + h / 6
* k1। आइए हम यहां जाते
हैं और k1 + 2k2 + 2k3 + k4.k1 +
2 * K2 + 2 * K3 + K4 देखते हैं।
हमारा k2 फंक्शन (function)
था (T (i) + h / 2, Y (i) + h * k1 / 2)
ठीक है। मैं बस इसे
कॉपी (copy) करूँगा और
इसे k3 में पेस्ट (paste)
करूँगा, और हम आवश्यकतानुसार
नए संशोधन करेंगे।
k3 T (i) + h / 2 फिर है लेकिन
Y (i) + h * k2 / 2। K1 / 2 के बजाय,
अब हमारे पास k2 / 2 ठीक
है। तो, हम पेस्ट (paste)
करते हैं और केवल
एक चीज जिसे बदलने
की जरूरत है, इस k1 को
k2 में बदलना है। एक
ही बात, हम k4 के लिए
पेस्ट (paste) करेंगे।
और देखते हैं कि किस
बदलाव की जरूरत है।
k4 के रूप में k1 क्षमा
करें, एक फ़ंक्शन
(function) (T (i) + h, Y (i) + h3) है।
तो, हम T (i) + h / 2 को नहीं
T (i) + h को पेस्ट (paste) करते
हैं। और Y (i) + h * k3 और
2 से विभाजित नहीं
है। इसलिए, k1 को k3 में
बदलेंगे और 2 से विभाजित
को हम हटाएंगे करेंगे।
और यही Y (i) है। आइए
हम इसे save करते है
और हमें पहले सब कुछ
स्पष्ट करने दें
और हमें अपना RK -4 मानक
तरीका को run करने दें।
और हम वही देखते हैं,
वही कर्व (curve) और कर्व
(curve) वही दिखता है जो
हम पहले थे। हम एरर
(error) पर जाँच करते हैं
या अधिकतम एरर (error)
पर जाँच करते हैं,
अधिकतम एरर (error) 7.5 * 10
^ -6 है जैसा कि हम देखते
हैं। जब हम RK -4 मानक
विधि पर गए, तो एरर
(error) में महत्वपूर्ण
गिरावट आई। एरर (error)
के गिरावट लगभग 2 * 10
^ -3 से 7 तक 10 ^ -6 ठीक है।
तो, एक ही स्टेप साइज
(step size) के लिए, RK -4 विधि
RK -2 की तुलना में काफी
अधिक सटीक है। और
यह RK -4 पद्धति की लोकप्रियता
के कारणों में से
एक है।
तो उसके साथ, हम इस
व्याख्यान के अंत
में आते हैं। इस व्याख्यान
में हमने जो बातें
लिखीं, वे दो बातें
थीं। पहले हमने अपने
RK -2 कोड (code) में सुधार
किया। इसलिए, हम कोड
(code) के अंदर ही इसे
कोड (code) करने के बजाय
एक सामान्य फ़ंक्शन
(function) myFun (e, y) का उपयोग
करने में सक्षम हैं।
इसके बाद, हमने अपने
RK -2 ह्यून (Heun) की विधि
को RK -4 मानक विधि तक
बढ़ा दिया। तो इसके
साथ ही मैं व्याख्यान
7.4 के अंत में आता हूं,
और आपको अगले व्याख्यान
में देखूंगा। धन्यवाद
और अलविदा।