**Ռունգե-Կուտտայի մեթոդներ**, թվային մեթոդների մեծ դաս` սովորական դիֆերենցիալ հավասարումների և դրանց համակարգերի համար Կոշիի խնդիրը լուծելու համար։ Այս դասի առաջին մեթոդներն առաջարկվել են մոտ 1900 թվականին գերմանացի մաթեմատիկոսներ Կարլ Ռունգեի և Մարտին Վիլհելմ Կուտտայի կողմից։

Ռունգե-Կուտտայի մեթոդների դասին են դասվում Էյլերի ակնհայտ մեթոդը և Էյլերի մոդիֆիկացված մեթոդը վերահաշվարկով, որոնք ներկայացնում են համապատասխանաբար ճշգրտության առաջին և երկրորդ կարգի մեթոդները։ Գոյություն ունեն ճշտության երրորդ կարգի ստանդարտ հստակ մեթոդներ, որոնք չեն ստացել լայն տարածում։ Առավել հաճախ օգտագործվում և տարբեր մաթեմատիկական փաթեթներում (Maple, MathCAD, Maxima) իրագործվել է դասական Ռունգե-Կուտտայի դասական մեթոդը, որն ունի ճշգրտության չորրորդ կարգ։ Բարձր ճշգրտությամբ հաշվարկներ կատարելիս ավելի ու ավելի հաճախ են օգտագործվում ճշգրտության հինգերորդ և վեցերորդ կարգերի մեթոդները։ Ավելի բարձր կարգի սխեմաների կառուցումը լի է հաշվարկային մեծ դժվարություններով։

Յոթերորդ կարգի մեթոդները պետք է ունենան առնվազն ինը փուլ, իսկ ութերորդ կարգի մեթոդները՝ առնվազն 11 փուլ։ 9-րդ և ավելի բարձր կարգերի (չունենալով, սակայն, մեծ գործնական նշանակություն) մեթոդների համար հայտնի չէ, թե որքան փուլեր են անհրաժեշտ ճշտության համապատասխան կարգի հասնելու համար։

Ռունգե-Կուտտայի չորրորդ կարգի դասական մեթոդ
-------------------------------------------

Ռունգե-Կուտտայի չորրորդ կարգի մեթոդը մշտական ինտեգրման քայլով հաշվարկման ժամանակ այնքան տարածված է, որ այն հաճախ կոչվում է պարզապես Ռունգե-Կուտտայի մեթոդ։

Դիտարկենք Կոշիի խնդիրը սովորական դիֆերենցիալ հավասարումների առաջին կարգի համակարգի համար։ ( հետագայում՝ {\displaystyle \mathbf {y} ,\mathbf {f} ,\mathbf {k} \_{i}\in \mathbb {R} ^{n}}, а {\displaystyle x,h\in \mathbb {R} ^{1}}).

{\displaystyle {\textbf {y}}'={\textbf {f}}(x,{\textbf {y}}),\quad {\textbf {y}}(x\_{0})={\textbf {y}}\_{0}.}
Այդ դեպքում հետևյալ կետերում մոտավոր արժեքը հաշվարկվում է իտերացիոն բանաձևով.

{\displaystyle {\textbf {y}}\_{n+1}={\textbf {y}}\_{n}+{h \over 6}({\textbf {k}}\_{1}+2{\textbf {k}}\_{2}+2{\textbf {k}}\_{3}+{\textbf {k}}\_{4})}
Նոր արժեքի հաշվարկը տեղի է ունենում չորս փուլով.

{\displaystyle {\textbf {k}}\_{1}={\textbf {f}}\left(x\_{n},{\textbf {y}}\_{n}\right),}
{\displaystyle {\textbf {k}}\_{2}={\textbf {f}}\left(x\_{n}+{h \over 2},{\textbf {y}}\_{n}+{h \over 2}{\textbf {k}}\_{1}\right),}
{\displaystyle {\textbf {k}}\_{3}={\textbf {f}}\left(x\_{n}+{h \over 2},{\textbf {y}}\_{n}+{h \over 2}{\textbf {k}}\_{2}\right),}
{\displaystyle {\textbf {k}}\_{4}={\textbf {f}}\left(x\_{n}+h,{\textbf {y}}\_{n}+h\ {\textbf {k}}\_{3}\right).}
որտեղ {\displaystyle h}-ը ցանցի քայլի չափն է {\displaystyle x}-ով։

Այս մեթոդն ունի ճշգրտության չորրորդ կարգ։ Սա նշանակում է, որ սխալը մեկ քայլում ունի {\displaystyle O(h^{5})} կարգ, և վերջավոր ինտեգրման միջակայքում ընդհանուր սխալն ունի {\displaystyle O(h^{4})} կարգը։

Ռունգե-Կուտտայի ակնհայտ մեթոդներ
--------------------------------

Ռունգե-Կուտտայի ակնհայտ մեթոդների ընտանիքը հանդիսանում է ինչպես Էյլերի ակնհայտ մեթոդի, այնպես էլ Ռունգե-Կուտտայի չորրորդ կարգի դասական մեթոդի ընդհանրացումը։ Այն տրվում է հետևյալ բանաձևերով․

{\displaystyle {\textbf {y}}\_{n+1}={\textbf {y}}\_{n}+h\sum \_{i=1}^{s}b\_{i}{\textbf {k}}\_{i},}
Որտեղ h-ն ցանցի քայլի արժեքն է x-ով և նոր արժեքի հաշվարկը տեղի է ունենում s փուլով։

{\displaystyle {\begin{array}{ll}{\textbf {k}}\_{1}=&{\textbf {f}}(x\_{n},{\textbf {y}}\_{n}),\\{\textbf {k}}\_{2}=&{\textbf {f}}(x\_{n}+c\_{2}h,{\textbf {y}}\_{n}+a\_{21}h{\textbf {k}}\_{1}),\\\cdots &\\{\textbf {k}}\_{s}=&{\textbf {f}}(x\_{n}+c\_{s}h,{\textbf {y}}\_{n}+a\_{s1}h{\textbf {k}}\_{1}+a\_{s2}h{\textbf {k}}\_{2}+\cdots +a\_{s,s-1}h{\textbf {k}}\_{s-1})\end{array}}}
Կոնկրետ մեթոդը որոշվում է {\displaystyle s} թվով և {\displaystyle b\_{i},a\_{ij}} և {\displaystyle c\_{i}} գործակիցներով։ Այս գործակիցները հաճախ դասակարգվում են աղյուսակում (որը կոչվում է Բուտչերի աղյուսակ)։

{\displaystyle {\begin{array}{c|ccccc}0&&&&&\\c\_{2}&a\_{21}&&&&\\c\_{3}&a\_{31}&a\_{32}&&&\\\vdots &\vdots &\vdots &\ddots &&\\c\_{s}&a\_{s1}&a\_{s2}&\dots &a\_{ss-1}&\\\hline &b\_{1}&b\_{2}&\dots &b\_{s-1}&b\_{s}\end{array}}}
Ռունգ-Կուտտայի մեթոդի գործակիցները պետք է բավարարեն {\displaystyle \sum \_{j=1}^{i-1}a\_{ij}=c\_{i}} պայմանին {\displaystyle i=2,\ldots ,s} համար։ Եթե պահանջվում է, որ մեթոդն ունենա {\displaystyle p} կարգ, ապա պետք է բավարարի հետևյալ պայմանին․

{\displaystyle {\bar {\textbf {y}}}(h+x\_{0})-{\textbf {y}}(h+x\_{0})=O(h^{p+1}),}
որտեղ {\displaystyle {\bar {\textbf {y}}}(h+x\_{0})}-ը Ռունգե-Կուտտայի մեթոդով ստացված մոտեցումն է։ Բազմակի տարբերակումից հետո այս պայմանը վերածվում է բազմաբնույթ հավասարումների համակարգի՝ մեթոդի գործակիցների վերաբերյալ։

Ռունգե-Կուտտայի ոչ ակնհայտ մեթոդներ
-----------------------------------

Մինչ այժմ նշված Ռունգե-Կուտտայի բոլոր մեթոդներն ակնհայտ մեթոդներ են։ Սակայն Ռունգե-Կուտտայի ակնհայտ մեթոդները, որպես կանոն, պիտանի չեն խիստ հավասարումների լուծման համար` նրանց բացարձակ կայունության փոքր շրջանի պատճառով։ Պարզ է, որ Ռունգե-Կուտտայի ակնհայտ մեթոդների անկայունությունը նաև լուրջ խնդիրներ է առաջ բերում մասնակի դիֆերենցիալ հավասարումների ածանցյալների լուծման մեջ։

Ռունգե-Կուտտայի մեթոդների անկայունությունը խթանել է ոչ ակնհայտ մեթոդների զարգացումը։ Ռունգե-Կուտտայի ոչ ակնհայտ մեթոդն ունի հետևյալ տեսքը։

{\displaystyle y\_{n+1}=y\_{n}+h\sum \_{i=1}^{s}b\_{i}k\_{i},}
որտեղ

{\displaystyle k\_{i}=f{\bigl (}x\_{n}+c\_{i}h,y\_{n}+h\sum \_{j=1}^{s}a\_{ij}k\_{j}{\bigr )},\quad i=1,\ldots ,s.}
Հստակ մեթոդը բնութագրական է նրանով, որ {\displaystyle a\_{ij}} գործակիցների մատրիցան նրա համար ունի ցածր եռանկյունաձև տեսք (ներառյալ զրոյական գլխավոր անկյունագիծը), ի տարբերություն ակնհայտ մեթոդի, որտեղ մատրիցան ունի կամայական ձև։ Դա երևում է նաև Բատչերի աղյուսակում․

{\displaystyle {\begin{array}{c|cccc}c\_{1}&a\_{11}&a\_{12}&\dots &a\_{1s}\\c\_{2}&a\_{21}&a\_{22}&\dots &a\_{2s}\\\vdots &\vdots &\vdots &\ddots &\vdots \\c\_{s}&a\_{s1}&a\_{s2}&\dots &a\_{ss}\\\hline &b\_{1}&b\_{2}&\dots &b\_{s}\\\end{array}}={\begin{array}{c|c}\mathbf {c} &A\\\hline &\mathbf {b^{T}} \\\end{array}}}
Այս տարբերության հետևանքն այն է, որ անհրաժեշտ է ամեն քայլի լուծել հավասարումների համակարգը {\displaystyle k\_{i},i=1,2,...s} համար, որտեղ {\displaystyle s}-ը փուլերի քանակն է։ Սա մեծացնում է հաշվարկային արժեքը, բայց բավարար չափով {\displaystyle h} դեպքում կարելի է կիրառել սեղմման արտացոլման սկզբունքը և լուծել այս համակարգը պարզ իտերացիայի մեթոդով։ Մեկ իտերացիայի դեպքում սա մեծացնում է հաշվարկային արժեքն ընդամենը երկու անգամ։

Մյուս կողմից, Ժան Կունցմանը (1961) Ջոն Բատչերը (1964) ցույց են տվել, որ ցանկացած {\displaystyle s} փուլերի ցանկացած քանակի համար գոյություն ունի Ռունգե-Կուտտայի ոչ ակնհայտ մեթոդ ճշգրտության {\displaystyle p=2s} կարգով։ Սա նշանակում է, օրինակ, որ վերը նկարագրված ակնհայտ քառափուլ չորրորդ կարգի մեթոդի համար գոյություն ունի ոչ ակնհայտ անալոգ ճշգրտության երկու անգամ ավելի մեծ կարգով։

Ռունգե-Կուտտայի երկրորդ կարգի անուղղակի մեթոդ
---------------------------------------------

Ռունգե-Կուտտայի ամենապարզ ոչ ակնհայտ մեթոդն Էյլերի «վերահաշվարկով» մոդիֆիկացված մեթոդն է։ Այն տրվում է հետևյալ բանաձևով.

{\displaystyle \mathbf {y} \_{n+1}=\mathbf {y} \_{n}+h{\frac {\mathbf {f} (x\_{n},\mathbf {y} \_{n})+\mathbf {f} (x\_{n+1},\mathbf {y} \_{n+1})}{2}}}

Նրա իրականացման համար յուրաքանչյուր փուլում անհրաժեշտ է առնվազն երկու իտերացիա (և ֆունկցիայի երկու հաշվարկ)։

Կանխատեսում.

{\displaystyle {\tilde {\mathbf {y} }}\_{n+1}=\mathbf {y} \_{n}+h\mathbf {f} (x\_{n},\mathbf {y} \_{n})}.
Ուղղում.

{\displaystyle \mathbf {y} \_{n+1}=\mathbf {y} \_{n}+h{\frac {\mathbf {f} (x\_{n},\mathbf {y} \_{n})+\mathbf {f} (x\_{n+1},{\tilde {\mathbf {y} }}\_{n+1})}{2}}}.
Երկրորդ բանաձևը հավասարեցման համակարգի լուծման պարզ իտերացիա է {\displaystyle \mathbf {y} \_{n+1}} համեմատութույամբ, որը գրվել է սեղմված արտացոլման տեսքով։ Ճշգրտությունը բարձրացնելու համար իտերացիա-ուղղումը կարելի է կատարել մի քանի անգամ՝ փոխարինելով {\displaystyle {\tilde {\mathbf {y} }}\_{n+1}=\mathbf {y} \_{n+1}}։ Էյլերի «վերահաշվարկով» մոդիֆիկացված մեթոդն ունի ճշգրտության երկրորդ կարգ։

### Հաստատունություն

Ռունգե-Կուտտայի ոչ ակնհայտ մեթոդների առավելությունն ակնհայտների համեմատությամբ նրանց մեծ հաստատունությունն է, ինչը հատկապես կարևոր է խիստ հավասարումների լուծման ժամանակ։ Որպես օրինակ դիտարկենք *y'* = λ*y* գծային հավասարումը։ Ռունգե-Կուտտայի սովորական մեթոդը, որն օգտագործվում է այս հավասարման համար, հանգում է {\displaystyle y\_{n+1}=r(h\lambda )\,y\_{n}}, с *r* իտերացիային, որը հավասար է

{\displaystyle r(z)=1+zb^{T}(I-zA)^{-1}e={\frac {\det(I-zA+zeb^{T})}{\det(I-zA)}},}
որտեղ {\displaystyle e}-ն նշանակում միավորների վեկտոր-սյունակ։ {\displaystyle r} ֆունկցիան կոչվում է հաստատունության ֆունկցիա։ Բանաձևը ցույց է տալիս, որ {\displaystyle r} {\displaystyle s} աստիճանի երկու պոլինոմների հարաբերակցություն է, եթե մեթոդը ունի {\displaystyle s} փուլ։ Ակնհայտ մեթոդներն ունեն {\displaystyle A} ցածր եռանկյունաձև խիստ մատրիցա, որտեղից հետևում է, որ {\displaystyle \det(I-zA)=1,}, և որ հաստատունության ֆունկցիան բազմանդամ է։

Այս օրինակի թվային լուծումը տալիս է զրո հետևյալ պայմանի դեպքում՝ {\displaystyle |r(z)|<1}, {\displaystyle z=h\lambda }։ Այդպիսի r–երի բազմությունը կոչվում է բացարձակ հաստատունության ոլորտ։ Մասնավորապես, մեթոդը կոչվում է *A-հաստատուն*, եթե բոլոր {\displaystyle r}-երը {\displaystyle {\textrm {Re}}(z)<0} գտնվում են բացարձակ հաստատունության ոլորտում։ Ռունգե-Կուտտայի ակնհայտ մեթոդի հաստատունության գործառույթը բազմանդամ է, ուստի Ռունգե-Կուտտայի ակնհայտ մեթոդներն սկզբունքորեն չեն կարող լինել A-հաստատուն։

Եթե մեթոդը ունի {\displaystyle p} կարգ, ապա հաստատունության ֆունկցիան բավարարում է {\displaystyle r(z)={\textrm {e}}^{z}+O(z^{p+1})} при {\displaystyle z\to 0} պայմանը։ Այսպիսով, հետաքրքրություն է ներկայացնում այս աստիճանի բազմանդամների հարաբերությունը, որը լավագույնս է մոտեցնում էքսպոնենցիալ ֆունկցիան։ Այս հարաբերությունները հայտնի են որպես Պադեի ապրոկսիմացիաներ։ {\displaystyle m} աստիճանի համարիչով և {\displaystyle n} աստիճանի հայտարարով Պադեի ապրոկսիմացիան A հաստատուն է միայն այն ժամանակ, երբ {\displaystyle m\leq n\leq m+2}։

{\displaystyle s} փուլ ունեցող Հաուս-Լեժանդրի մեթոդն ունի {\displaystyle 2s} կարգ, այդ պատճառով նրա հաստատունության ֆունկցիան Պադեի մոտեցումն է {\displaystyle m=n=s}։ Հետևում է, որ մեթոդը A-հաստատուն է։ Սա ցույց է տալիս, որ Ռունգե-Կուտտայի A-հաստատուն մեթոդները կարող են լինել կամայականորեն բարձր կարգի։ Ի տարբերություն դրա, Ադամսի մեթոդների A-հաստատունության կարգը չի կարող գերազանցել երկուսը։

Ծրագրավորման ալգորիթմական լեզուներով լուծման օրինակ
---------------------------------------------------


|  |  |
| --- | --- |
| {\displaystyle y''+4y=\cos 3x,\quad y(0)=0.8,\ y'(0)=2,\ x\in [0,1],\ h=0.1} |  |

կատարելով y '= z փոխարինումը և 4y-ը տեղափոխելով աջ կողմ, ստանում ենք հետևյալ համակարգը.


|  |  |
| --- | --- |
| {\displaystyle {\begin{cases}y'=z=g(x,y,z)\\z'=\cos(3x)-4y=f(x,y,z)\end{cases}}} |  |

Կոդը Java-ում Ռունգե-Կուտտայի մեթոդով դիֆերենցիալ հավասարումների համակարգը լուծելու համար 

```
public class MainClass {

 public static void main(String[] args) {
 int k = 2;
 double Xo, Yo, Y1, Zo, Z1;
 double k1, k2, k4, k3, h;
 double q1, q2, q4, q3;
 /\*
 \*Նախնական պայմաններ
 \*/
 Xo = 0;
 Yo = 0.8;
 Zo = 2;

 h = 0.1; // քայլ

 System.out.println("\tX\t\tY\t\tZ");
 for(; r(Xo,2)<1.0; Xo += h){
 
 k1 = h \* f(Xo, Yo, Zo);
 q1 = h \* g(Xo, Yo, Zo);
 
 k2 = h \* f(Xo + h/2.0, Yo + q1/2.0, Zo + k1/2.0);
 q2 = h \* g(Xo + h/2.0, Yo + q1/2.0, Zo + k1/2.0);
 
 k3 = h \* f(Xo + h/2.0, Yo + q2/2.0, Zo + k2/2.0);
 q3 = h \* g(Xo + h/2.0, Yo + q2/2.0, Zo + k2/2.0);
 
 k4 = h \* f(Xo + h, Yo + q3, Zo + k3);
 q4 = h \* g(Xo + h, Yo + q3, Zo + k3);
 
 Z1 = Zo + (k1 + 2.0\*k2 + 2.0\*k3 + k4)/6.0;
 Y1 = Yo + (q1 + 2.0\*q2 + 2.0\*q3 + q4)/6.0;
 System.out.println("\t" + r(Xo + h, k) + "\t\t" + r(Y1,k) + "\t\t" + r(Z1,k));
 Yo = Y1;
 Zo = Z1;
 }
 
 }
 /\*\*
 \* ֆունկցիա կլորացնելու և «պոչը» հեռացնելու համար
 \*/
 public static double r(double value, int k){
 return (double)Math.round((Math.pow(10, k)\*value))/Math.pow(10, k);
 }
 /\*\*
 \* ֆունկցիաներ, որոնք ստացվում են համակարգից
 \*/
 public static double f(double x, double y, double z){
 return (Math.cos(3\*x) - 4\*y);
 }
 public static double g(double x, double y, double z){
 return (z);
 }

}

```

Կոդ C# լեզվով 

```
using System;
using System.Collections.Generic;

namespace PRJ\_RungeKutta
{
 /// <summary>
 ///Ռունգե-Կուտտայի մեթոդի իրականացում սովորական դիֆերենցիալ հավասարման համար
 /// </summary>
 public abstract class RungeKutta
 {
 /// <summary>
 ///Ընթացիկ ժամանակ
 /// </summary>
 public double t; 
 /// <summary>
 /// Պահանջվող որոշում Y [0] - ինքնուրույն որոշում, Y [i] — i-ի ածանցյալ լուծումներ
 /// </summary>
 public double[] Y; 
 /// <summary>
 ///Ներքին փոփոխականներ
 /// </summary>
 double[] YY, Y1, Y2, Y3, Y4;
 protected double[] FY;
 /// <summary>
 /// Конструктор
 /// </summary>
 /// <param name="N">համակարգի չափականություն</param>
 public RungeKutta(uint N) 
 {
 Init(N);
 }
 /// <summary>
 /// Конструктор
 /// </summary>
 public RungeKutta(){}
 /// <summary>
 /// Հիշողության առանձնացում աշխատանքային մասիվների համար
 /// </summary>
 /// <param name="N">Մասիվների չափականություն</param>
 protected void Init(uint N)
 { 
 Y = new double[N];
 YY = new double[N];
 Y1 = new double[N];
 Y2 = new double[N];
 Y3 = new double[N];
 Y4 = new double[N];
 FY = new double[N];
 }
 /// <summary>
 /// Սկզբնական պայմանների սահմանում
 /// </summary>
 /// <param name="t0">Սկզբնական ժամանակ</param>
 /// <param name="Y0">Սկզբնական պայման</param>
 public void SetInit(double t0, double[] Y0) 
 { 
 t = t0;
 if (Y == null) 
 Init((uint)Y0.Length);
 for (int i = 0; i < Y.Length; i++)
 Y[i] = Y0[i];
 }
 /// <summary>
 /// Համակարգի աջ մասերի հաշվարկ
 /// </summary>
 /// <param name="t">ընթացիկ ժամանակ</param>
 /// <param name="Y">լուծման վեկտոր</param>
 /// <returns>աջ մաս</returns>
 abstract public double[] F(double t, double[] Y); 
 /// <summary>
 /// Ռունգե-Կուտտա մեթոդի հաջորդ քայլը
 /// </summary>
 /// <param name="dt">ընթացիկ ժամանակի քայլ (կարող է փոփոխական լինել)</param>
 public void NextStep(double dt)
 {
 int i;

 if (dt < 0) return;

 // հաշվարկել Y1
 Y1 = F(t, Y);

 for (i = 0; i < Y.Length; i++)
 YY[i] = Y[i] + Y1[i] \* (dt / 2.0);
 
 // հաշվարկել Y2
 Y2 = F(t + dt / 2.0, YY);

 for (i = 0; i < Y.Length; i++)
 YY[i] = Y[i] + Y2[i] \* (dt / 2.0);
 
 // հաշվարկել Y3
 Y3 = F(t + dt / 2.0, YY);

 for (i = 0; i < Y.Length; i++)
 YY[i] = Y[i] + Y3[i] \* dt;
 
 // հաշվարկել Y4
 Y4 = F(t + dt, YY);

 // հաշվարկել լուծումը նոր քայլով

 for (i = 0; i < Y.Length; i++)
 Y[i] = Y[i] + dt / 6.0 \* (Y1[i] + 2.0 \* Y2[i] + 2.0 \* Y3[i] + Y4[i]);

 //հաշվարկել ընթացիկ ժամանակը
 t = t + dt; 
 }
 }
 class TMyRK : RungeKutta
 {
 public TMyRK(uint N) : base(N) { }

 /// <summary>
 /// օրինակ մաթեմատիկական փարոս 
 /// y''(t)+y(t)=0
 /// </summary>
 /// <param name="t">Ժամանակ</param>
 /// <param name="Y">Լուծում</param>
 /// <returns>Առաջին մաս</returns>
 public override double[] F(double t, double[] Y)
 {
 FY[0] = Y[1]; 
 FY[1] = -Y[0]; 
 return FY;
 }
 /// <summary>
 ///Օգտագործման օրինակ

 /// </summary>
 static public void Test()
 {
 //Քայլ առ ժամանակ
 double dt = 0.001;
 // Մեթոդի օբյեկտ
 TMyRK task = new TMyRK(2);
 // Սահմանել նախնական պայմանները y (0)=0, y'(0)=1 խնդիր
 double[] Y0 = { 0, 1 }; 
 // Սահմանենք խնդրի սկզբնական պայմանները
 task.SetInit(0, Y0);
 // լուծել մինչև 15 վայրկյան
 while (task.t <= 15) 
 {
 Console.WriteLine("Time = {0:F5}; Func = {1:F8}; d Func / d x = {2:F8}", task.t, task.Y[0], task.Y[1]); // դուրս բերել
t, y, y'
 //հաշվարկել հաջորդ քայլը, քայլ ինտեգրման
 task.NextStep(dt);
 }
 Console.ReadLine();
 }
 }

 class Program
 {
 static void Main(string[] args)
 {
 TMyRK.Test();
 }
 }
}

```

C # ծրագրում օգտագործվում է RungeKutta աբստրակտ դասը, որի մեջ պետք է վերափոխվի F վերացական մեթոդը, որը սահմանում է հավասարումների աջ կողմերը։

MATLAB միջավայրում լուծման օրինակ
---------------------------------

Դիֆերենցիալ հավասարումների համակարգերի լուծումը Ռունգե-Կուտտայի մեթոդով հանդիսանում է լուծումների ամենատարածված թվային մեթոդներից մեկը տեխնիկայում։ MATLAB-ի միջավայրում իրականացվել է նրա տեսակներից մեկը՝ Դորման-Փրինսի մեթոդը։ Հավասարումների համակարգի լուծման համար անհրաժեշտ է նախ գրել ածանցյալները հաշվող ֆունկցիաները, այսինքն` y = g(x, y, z) և z = cos(3x) − 4y = f(x, y, z) ֆունկցիաները, ինչի մասին նշված է վերևում։ Կատալոգներից մեկում, որը հասանելի է MATLAB համակարգից, պետք է ստեղծել տեքստային ֆայլ runge.m անունով (օրինակ) և հետևյալ բովանդակությամբ (MATLAB 5.3 տարբերակի համար)։

MATLAB, runge.m  

```
function Dy = runge(x, y)
Dy = y(:);
Dy(1) = y(2);
Dy(2) = cos(3\*x) - 4\*y(1);

```

Ֆայլի անվանումը և ֆունկցիայի անվանումը պետք է լինեն նույնը, բայց այն կարող է լինել նախկինում չօգտագործված։

Այնուհետև պետք է ստեղծել հիմնական ֆայլ, օրինակ՝ main.m անունով, որը կկատարի հիմնական հաշվարկները։ Այս հիմնական ֆայլը պարունակում է հետևյալ տեքստը՝

MATLAB, main.m  

```
clear; clc; % Մաքրել հիշողությունը և էկրանը
h = 0.1; % Ինտեգրման քայլ
x\_fin = 8; % Ինտեգրման վերջնական ժամանակը
y0 = 0.8; % Ֆունկցիայի սկզբնական արժեքը
Dy0 = 2; % Ածանցյալ ֆունկցիայի նախնական արժեքը
[x, y] = ode45('runge', [0:h:x\_fin], [y0 Dy0]); % Ռունգե-Կուտտայի մեթոդ
plot(x, y, 'LineWidth', 2); grid; %Գրաֆիկայի և ցանցի կառուցում
legend('y(x)', 'y''(x)', 0); % Լեգենդ գրաֆիկում

```

Քանի որ MATLAB-ը կենտրոնացած է մատրիցների հետ աշխատելու համար, Ռունգե-Կուտտայի մեթոդի լուծումը շատ հեշտ է կատարվում մի շարք x-ի համար, ինչպես, օրինակ, ծրագրի բերված օրինակում։ Այստեղ լուծումն է՝ ֆունկցիայի գրաֆիկը 0-ից մինչև x\_fin ժամանակների սահմանում.

Լուծումը(չաշխատող հղում)
 MATLAB միջավայրում
ODE45 ֆունկցիայի արդյունքում ստացված x և y փոփոխականները արժեքային վեկտորներ են։ Ակնհայտ է, որ վերը տրված կոնկրետ օրինակի լուծումը երկրորդ x տարրն է, քանի որ առաջին արժեքը 0 է, ինտեգրման քայլը՝ h = 0.1, իսկ որոնվող արժեքը՝ x = 0.1: MATLAB հրամանի պատուհանում հետևյալ տեքստի մուտքագրումը կտա ցանկալի լուծում.

MATLAB, լուծում  

```
y1 = y(find(x == 0.1))

```

*Պատասխան՝ y1 = 0,98768*

Ծանոթագրություններ
------------------

1. ↑  *Бахвалов Н. С. Жидков Н. П. Кобельков Г. М.* Численные методы. — М.: Лаборатория Базовых Знаний, 2001. — 630 с. — ISBN 5-93208-043-4 — С. 363—375.
2. ↑  *Ильина В. А. Силаев П. К.* Численные методы для физиков-теоретиков. Ч. 2. — Москва-Ижевск: Институт компьютерных исследований, 2004. — 118 с. — ISBN 5-93972-320-9 — С. 16—30.
3. 1 2  *Butcher J. C.* Numerical Methods for Ordinary Differential Equations. — New York: John Wiley & Sons, 2008. — ISBN 978-0-470-72335-7
4. ↑  Süli & Mayers, 2003, էջ 349—351
5. ↑  Iserles, 1996, էջ 41
6. ↑  Süli & Mayers, 2003, էջ 351—352
7. ↑  Неявные методы Рунге — Кутты Archived 2019-03-06 at the Wayback Machine..
8. ↑  Hairer & Wanner, 1996, էջ 40—41
9. ↑  Hairer & Wanner, 1996, էջ 40
10. 1 2  Iserles, 1996, էջ 60
11. ↑  Iserles, 1996, էջ 62—63
12. ↑  Iserles, 1996, էջ 63

Գրականություն
-------------

* *Hairer E. Wanner G.* Solving ordinary differential equations II: Stiff and differential-algebraic problems. 2nd ed. — Berlin, New York: Springer-Verlag, 1996. — ISBN 978-3-540-60452-5
* *Iserles A.* A First Course in the Numerical Analysis of Differential Equations. — Cambridge: Cambridge University Press, 1996. — ISBN 978-0-521-55655-2
* *Süli E. Mayers D.* An Introduction to Numerical Analysis. — Cambridge: Cambridge University Press, 2003. — ISBN 0-521-00794-1

|  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- |
| 

|  |  |
| --- | --- |
|  ⛭   Բառարաններ և հանրագիտարաններ | Մեծ նորվեգական |
|  |
| Չափորոշչային վերահսկողություն | Microsoft: 181582579 |

 |