Դիտել Ռունգե-Կուտտայի մեթոդ էջի վիքիկոդը

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

Ռունգե-Կուտտայի մեթոդների դասին են դասվում Էյլերի ակնհայտ մեթոդը և Էյլերի մոդիֆիկացված մեթոդը վերահաշվարկով, որոնք ներկայացնում են համապատասխանաբար ճշգրտության առաջին և երկրորդ կարգի մեթոդները։ Գոյություն ունեն ճշտության երրորդ կարգի ստանդարտ հստակ մեթոդներ, որոնք չեն ստացել լայն տարածում։ Առավել հաճախ օգտագործվում և տարբեր մաթեմատիկական փաթեթներում (Maple, MathCAD, Maxima) իրագործվել է դասական Ռունգե-Կուտտայի դասական մեթոդը, որն ունի ճշգրտության չորրորդ կարգ։ Բարձր ճշգրտությամբ հաշվարկներ կատարելիս ավելի ու ավելի հաճախ են օգտագործվում ճշգրտության հինգերորդ և վեցերորդ կարգերի մեթոդները<ref>{{книга|автор=Бахвалов Н. С., Жидков Н. П., Кобельков Г. М. |заглавие=Численные методы|место=М.|издательство=Лаборатория Базовых Знаний|год=2001|страниц=630|isbn=5-93208-043-4}} — С. 363—375.</ref><ref>{{книга|автор=Ильина В. А., Силаев П. К. |заглавие=Численные методы для физиков-теоретиков. Ч. 2|место=Москва-Ижевск|издательство=Институт компьютерных исследований|год=2004|страниц=118|isbn=5-93972-320-9}} — С. 16—30.</ref>։ Ավելի բարձր կարգի սխեմաների կառուցումը լի է հաշվարկային մեծ դժվարություններով<ref name="ReferenceA">{{книга|автор=Butcher J. C.|заглавие=Numerical Methods for Ordinary Differential Equations|место=New York|издательство=John Wiley & Sons|год=2008|isbn=978-0-470-72335-7}}</ref>։

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

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

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

: <math>\textbf{y}'=\textbf{f}(x,\textbf{y}), \quad \textbf{y}(x_0)=\textbf{y}_0.</math>

Այդ դեպքում հետևյալ կետերում մոտավոր արժեքը հաշվարկվում է իտերացիոն բանաձևով.

: <math> \textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4) </math>

Նոր արժեքի հաշվարկը տեղի է ունենում չորս փուլով.

: <math> \textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right), </math>
: <math> \textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right), </math>
: <math> \textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right), </math>
: <math> \textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right). </math>

որտեղ  <math>h</math>-ը ցանցի քայլի չափն է <math>x</math>-ով։

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

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

: <math> \textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i, </math>

Որտեղ  h-ն ցանցի քայլի արժեքն է x-ով և նոր արժեքի հաշվարկը տեղի է ունենում s փուլով։

: <math>\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \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} </math>

Կոնկրետ մեթոդը որոշվում է <math>s</math> թվով  և  <math>b_i, a_{ij}</math> և  <math>c_i</math> գործակիցներով։ Այս գործակիցները հաճախ դասակարգվում են աղյուսակում (որը կոչվում է Բուտչերի աղյուսակ)։

: <math>\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} </math>

Ռունգ-Կուտտայի մեթոդի գործակիցները պետք է բավարարեն  <math>\sum_{j=1}^{i-1} a_{ij} = c_i</math> պայմանին <math> i=2, \ldots, s</math> համար։ Եթե պահանջվում է, որ մեթոդն ունենա <math>p</math>  կարգ, ապա պետք է բավարարի հետևյալ պայմանին․

: <math>\bar{\textbf{y}}(h+x_0)- {\textbf{y}}(h+x_0)=O(h^{p+1}),</math>

որտեղ  <math>\bar{\textbf{y}}(h+x_0)</math>-ը Ռունգե-Կուտտայի մեթոդով ստացված մոտեցումն է։ Բազմակի տարբերակումից հետո այս պայմանը վերածվում է բազմաբնույթ հավասարումների համակարգի՝ մեթոդի գործակիցների վերաբերյալ։

== Ռունգե-Կուտտայի ոչ ակնհայտ մեթոդներ ==
Մինչ այժմ նշված Ռունգե-Կուտտայի բոլոր մեթոդներն ակնհայտ մեթոդներ են։ Սակայն Ռունգե-Կուտտայի ակնհայտ մեթոդները, որպես կանոն, պիտանի չեն խիստ հավասարումների լուծման համար` նրանց բացարձակ կայունության փոքր շրջանի պատճառով{{sfn|Süli & Mayers|2003|p=349—351}}։ Պարզ է, որ Ռունգե-Կուտտայի ակնհայտ մեթոդների անկայունությունը նաև լուրջ խնդիրներ է առաջ բերում մասնակի դիֆերենցիալ հավասարումների ածանցյալների լուծման մեջ։

Ռունգե-Կուտտայի մեթոդների անկայունությունը խթանել է ոչ ակնհայտ մեթոդների զարգացումը։ Ռունգե-Կուտտայի ոչ ակնհայտ մեթոդն ունի հետևյալ տեսքը{{sfn|Iserles|1996|p=41}}{{sfn|Süli & Mayers|2003|p=351—352}}։

: <math> y_{n+1} = y_n + h\sum_{i=1}^s b_i k_i, </math>

որտեղ

: <math> 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.</math>

Հստակ մեթոդը բնութագրական է նրանով, որ  <math>a_{ij}</math> գործակիցների մատրիցան նրա համար ունի ցածր եռանկյունաձև տեսք (ներառյալ զրոյական գլխավոր անկյունագիծը), ի տարբերություն ակնհայտ մեթոդի, որտեղ մատրիցան ունի կամայական ձև։ Դա երևում է նաև Բատչերի աղյուսակում․

: <math>
\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}
</math>

Այս տարբերության հետևանքն այն է, որ անհրաժեշտ է ամեն քայլի լուծել հավասարումների համակարգը <math>k_i, i=1,2,...,s</math> համար, որտեղ  <math>s</math>-ը փուլերի քանակն է։ Սա մեծացնում է հաշվարկային արժեքը, բայց բավարար չափով  <math>h</math> դեպքում կարելի է կիրառել սեղմման արտացոլման սկզբունքը և լուծել այս համակարգը պարզ իտերացիայի մեթոդով<ref>[HTTP://WWW.ASTRO.TSU.RU/CHINTODY/TEXT/3_7.HTML Неявные методы Рунге — Кутты] {{Webarchive|url=https://web.archive.org/web/20190306230951/http://www.astro.tsu.ru/CHINTODY/TEXT/3_7.HTML |date=2019-03-06 }}.</ref>։ Մեկ իտերացիայի դեպքում սա մեծացնում է հաշվարկային արժեքն ընդամենը երկու անգամ։

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

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

<math>\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}</math>

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

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

: <math>\tilde \mathbf y_{n+1}=\mathbf y_n+h\mathbf f(x_n,\mathbf y_n)</math>.

Ուղղում.

: <math>\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}</math>.

Երկրորդ բանաձևը հավասարեցման համակարգի լուծման պարզ իտերացիա է  <math>\mathbf y_{n+1}</math> համեմատութույամբ, որը գրվել է սեղմված արտացոլման  տեսքով։  Ճշգրտությունը բարձրացնելու համար իտերացիա-ուղղումը կարելի է կատարել մի քանի անգամ՝ փոխարինելով <math>\tilde\mathbf y_{n+1}=\mathbf y_{n+1}</math>։  Էյլերի «վերահաշվարկով» մոդիֆիկացված մեթոդն ունի ճշգրտության երկրորդ կարգ։

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

: <math> r(z) = 1 + z b^T (I-zA)^{-1} e = \frac{\det(I-zA+zeb^T)}{\det(I-zA)}, </math>

որտեղ <math>e</math>-ն նշանակում միավորների վեկտոր-սյունակ{{sfn|Hairer & Wanner|1996|p=40—41}}։ <math>r</math> ֆունկցիան կոչվում է հաստատունության ֆունկցիա{{sfn|Hairer & Wanner|1996|p=40}}։ Բանաձևը ցույց է տալիս, որ  <math>r</math> <math>s</math>  աստիճանի երկու պոլինոմների հարաբերակցություն է, եթե մեթոդը ունի <math>s</math> փուլ։ Ակնհայտ մեթոդներն ունեն <math>A</math> ցածր եռանկյունաձև խիստ մատրիցա, որտեղից հետևում է, որ <math>\det (I - z A) = 1,</math>, և որ հաստատունության ֆունկցիան բազմանդամ է{{sfn|Iserles|1996|p=60}}։

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

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

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

== Ծրագրավորման ալգորիթմական լեզուներով լուծման օրինակ ==
{{EF|:|<math>y'' + 4y = \cos 3x,\quad y(0) = 0.8,\ y'(0) = 2,\ x \in [0,1],\ h = 0.1</math>}}

կատարելով y '= z փոխարինումը և 4y-ը տեղափոխելով աջ կողմ, ստանում ենք հետևյալ համակարգը.
{{EF|:|<math>\begin{cases}
y' = z = g(x,y,z)\\
z' = \cos(3x) - 4y = f(x,y,z)
\end{cases}
</math>}}
{{Hidden begin
|toggle     = right
|title      =
 title with toggle=right
|titlestyle = background:lightgrey;
|title=Կոդը [[Java]]-ում Ռունգե-Կուտտայի մեթոդով դիֆերենցիալ հավասարումների համակարգը լուծելու համար
}}
<source lang="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);
	}

}
</source>
{{Hidden end}}
{{Hidden begin
|toggle     = right
|title      =
 title with toggle=right
|titlestyle = background:lightgrey;
|title=Կոդ [[C Sharp|C#]] լեզվով
}}
<source lang="csharp">
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();
        }
    }
}
</source>
{{Hidden end}}
C # ծրագրում օգտագործվում է RungeKutta աբստրակտ դասը, որի մեջ պետք է վերափոխվի F վերացական մեթոդը, որը սահմանում է հավասարումների աջ կողմերը։

== MATLAB միջավայրում լուծման օրինակ ==
Դիֆերենցիալ հավասարումների համակարգերի լուծումը Ռունգե-Կուտտայի մեթոդով հանդիսանում է լուծումների ամենատարածված թվային մեթոդներից մեկը տեխնիկայում։ MATLAB-ի միջավայրում իրականացվել է նրա տեսակներից մեկը՝ Դորման-Փրինսի մեթոդը։ Հավասարումների համակարգի լուծման համար անհրաժեշտ է նախ գրել ածանցյալները հաշվող ֆունկցիաները, այսինքն` y = g(x, y, z) և z = cos(3x) − 4y = f(x, y, z) ֆունկցիաները, ինչի մասին նշված է վերևում։ Կատալոգներից մեկում, որը հասանելի է MATLAB համակարգից, պետք է ստեղծել տեքստային ֆայլ runge.m անունով (օրինակ)  և հետևյալ բովանդակությամբ (MATLAB 5.3 տարբերակի համար)։
{{Hider|title=[[MATLAB]], runge.m|content=<source lang="matlab">
function Dy = runge(x, y)
Dy = y(:);
Dy(1) = y(2);
Dy(2) = cos(3*x) - 4*y(1);
</source>}}
Ֆայլի անվանումը և ֆունկցիայի անվանումը պետք է լինեն նույնը, բայց այն կարող է լինել նախկինում չօգտագործված։

Այնուհետև պետք է ստեղծել հիմնական ֆայլ, օրինակ՝ main.m անունով, որը կկատարի հիմնական հաշվարկները։ Այս հիմնական ֆայլը պարունակում է հետևյալ տեքստը՝
{{Hider|title=[[MATLAB]], main.m|content=<source lang="matlab">
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); % Լեգենդ գրաֆիկում
</source>}}
Քանի որ MATLAB-ը կենտրոնացած է մատրիցների հետ աշխատելու համար, Ռունգե-Կուտտայի մեթոդի լուծումը շատ հեշտ է կատարվում մի շարք x-ի համար, ինչպես, օրինակ, ծրագրի բերված օրինակում։ Այստեղ լուծումն է՝ ֆունկցիայի գրաֆիկը 0-ից մինչև x_fin ժամանակների սահմանում.
[[Պատկեր:Runge_plot.jpg|կենտրոն|մինի|650x650փքս|Լուծումը [[MATLAB]] միջավայրում]]
ODE45 ֆունկցիայի արդյունքում ստացված x և y փոփոխականները արժեքային վեկտորներ են։ Ակնհայտ է, որ վերը տրված կոնկրետ օրինակի լուծումը երկրորդ x տարրն է, քանի որ առաջին արժեքը 0 է, ինտեգրման քայլը՝ h = 0.1, իսկ որոնվող արժեքը՝ x = 0.1: MATLAB հրամանի պատուհանում հետևյալ տեքստի մուտքագրումը կտա ցանկալի լուծում.
{{Hider|title=[[MATLAB]], լուծում|content=<source lang="matlab">
y1 = y(find(x == 0.1))
</source>}}''Պատասխան՝ y1 = 0,98768''

== Ծանոթագրություններ ==
{{ծանցանկ|2}}

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

* {{книга|автор=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|ref=Hairer & Wanner}}
* {{книга|автор=Iserles A. |заглавие=A First Course in the Numerical Analysis of Differential Equations|место=Cambridge|издательство=Cambridge University Press|год=1996|isbn=978-0-521-55655-2|ref=Iserles}}
* {{книга|автор=Süli E., Mayers D. |заглавие=An Introduction to Numerical Analysis|место=Cambridge|издательство=Cambridge University Press|год=2003|isbn=0-521-00794-1|ref=Süli & Mayers}}
{{Արտաքին հղումներ}}

{{Կատեգորիա չկա}}