MacClane

program VOLNA; { ‚®«*л ** Ї®ўҐае*®бвЁ жЁбвҐа*л }
uses Crt,Matfunc,Service;
const
N = 2; { Љ®*бв**в* ®ЇаҐ¤Ґ«пҐв Ї®а冷Є бЁб⥬л }
type
N1 = 1..N;
ar = array[N1] of extended;
var { ЏҐаҐ¬Ґ**лҐ ¤«п аҐ*«Ё§*жЁЁ ¬Ґв®¤* Љ - Њ }
J1: N1;
X,XP,XK,HP,E: extended;
U,PU: ar;

Procedure URAV(X: extended;U: ar; var PU: ar); forward;
Procedure PRODUCT; forward;

Procedure KM(var X: extended;U: ar); { Ѓ«®Є ¬Ґв®¤* Љгвв* - ЊҐаб®** }
type
N2 = 1..5;
arr = array[N1,N2] of extended;
var { ЏҐаҐ¬Ґ**лҐ ¤«п аҐ*«Ё§*жЁЁ ¬Ґв®¤* Љ - Њ }
J2: N2;
JJ: boolean;
K: arr;
Xi_1,H: extended;
Ui_1,UU,G,D: ar;
Procedure KOEFF(H: extended;PU: ar; var K: arr);
begin { ђ*бзҐв Є®нддЁжЁҐ*в®ў - Kj,i }
for J1:=1 to N do
K[J1,J2]:= H*PU[J1]/3;
end;
begin
XP:=HP;
H:=HP;
Xi_1:=X;
for J1:=1 to N do
Ui_1[J1]:=U[J1];
while XK > X do { –ЁЄ« - гб«®ўЁҐ ®Є®*з**Ёп а*бзҐв* }
begin
repeat { Ќ*з*«® жЁЄ«* ¤а®Ў«Ґ*Ёп и*Ј* }
JJ:=true;
X:=Xi_1;
for J1:=1 to N do
U[J1]:=Ui_1[J1];
URAV(X,U,PU);
J2:=1; { ЋЇаҐ¤Ґ«Ґ*ЁҐ Kj,1 }
KOEFF(H,PU,K);
X:=Xi_1+H/3;
for J1:=1 to N do
U[J1]:=Ui_1[J1]+K[J1,1];
URAV(X,U,PU);
J2:=2; { ЋЇаҐ¤Ґ«Ґ*ЁҐ Kj,2 }
KOEFF(H,PU,K);
X:=Xi_1+H/3;
for J1:=1 to N do
U[J1]:=Ui_1[J1]+(K[J1,1]+K[J1,2])/2;
URAV(X,U,PU);
J2:=3; { ЋЇаҐ¤Ґ«Ґ*ЁҐ Kj,3 }
KOEFF(H,PU,K);
X:=Xi_1+H/2;
for J1:=1 to N do
U[J1]:=Ui_1[J1]+(3*K[J1,1]+9*K[J1,3])/8;
URAV(X,U,PU);
J2:=4; { ЋЇаҐ¤Ґ«Ґ*ЁҐ Kj,4 }
KOEFF(H,PU,K);
X:=Xi_1+H; { ђ*бзҐв *аЈг¬Ґ*в* ў i-®© в®зЄҐ }
for J1:=1 to N do
begin
UU[J1]:=Ui_1[J1]+(3*K[J1,1]-9*K[J1,3])/2+6*K[J1,4];
U[J1]:=UU[J1];
end;
URAV(X,U,PU);
J2:=5; { ЋЇаҐ¤Ґ«Ґ*ЁҐ Kj,5 }
KOEFF(H,PU,K);
for J1:=1 to N do { ђ*бзҐв j-®© ЇҐаҐ¬Ґ**®© ў i-®© в®зЄҐ }
U[J1]:=Ui_1[J1]+(K[J1,1]+4*K[J1,4]+K[J1,5])/2;
for J1:=1 to N do { ђ*бзҐв Ї®ЈаҐи*®бвЁ }
D[J1]:=(abs(UU[J1]-U[J1]))/5;
for J1:=1 to N do
begin { ‚лЎ®а в®з*®бвЁ }
if abs(U[J1]) > 1
then G[J1]:=E*abs(U[J1])
else G[J1]:=E;
end;
for J1:=1 to N do { “б«®ўЁҐ ¤а®Ў«Ґ*Ёп и*Ј* }
if D[J1] > G[J1] then JJ:=false;
H:=H/2;
until JJ; { Љ®*Ґж жЁЄ«* ¤а®Ў«Ґ*Ёп и*Ј* }
H:=2*H;
URAV(X,U,PU); { ђ*бзҐв Їа®Ё§ў®¤*ле ў i-®© в®зЄҐ }
PRODUCT;
for J1:=1 to N do { “б«®ўЁҐ г¤ў®Ґ*Ёп и*Ј* }
if G[J1] < 32*D[J1] then JJ:=false;
if JJ = true then H:=2*H;
if H > HP then H:=HP; { ЋЈа**ЁзҐ*ЁҐ ** 㢥«ЁзҐ*ЁҐ и*Ј* }
Xi_1:=X;
for J1:=1 to N do
Ui_1[J1]:=U[J1];
end; { Љ®*Ґж жЁЄ«* ®Є®*з**Ёп а*бзҐв* }
end;




как я понимаю это метод Рунге-Кутта. С ним я решал уравнение 2-го порядка. Подскажите что то нужно менять чтобы решать уравнение 4-го порядка

Vladimir_S

Лучше не менять, а написать заново. Проще. А алгоритм - записать уравнение в виде системы четырех линейных ДУ, каковую и решать.