Cómo utilizar MATLAB para escribir programas para el algoritmo de interpolación lagrangiana, el método de Runge-Kutta de segundo orden y el método de iteración SOR

Función de Lagrange y=lagrange(x0,y0,x)

n=longitud(x0);m=longitud(x);

para i= 1:m

z=x(i);

s=0.0;

para k=1:n

p= 1.0;

para j=1:n

si j~=k

p=p*(z-x0(j))/ (x0( k)-x0(j));

fin

fin

s=p*y0(k)+s;

end

y(i)=s;

fin del programa Matlab del método iterativo SOR

función [x]=SOR_iterative(A,b)

% Utilice SOR para resolver iterativamente un sistema de ecuaciones lineales. La matriz A es una matriz cuadrada

x0=zeros(1,length(b)); p > tol=10^(-2); % dado límite de error

N=1000; % dado número máximo de iteraciones

[n,n]=size(A); % Determinar el orden de la matriz A

w=1; % Dar el factor de relajación

k=1;

% Proceso iterativo

mientras k<=N

x(1)=(b(1)-A(1,2:n)*x0(2:n)')/A(1,1);< / p>

para i=2:n

x(i)=(1-w)*x0(i)+w*(b(i)-A(i,1:i - 1)*x(1:i-1)'-A(i,i+1:n)*x0(i+1:n)')/A(i,i);

fin

if max(abs(x-x0))<=tol

fid = fopen('SOR_iter_result.txt', 'wt');

fprintf (fid,'\n********El resultado de salida de usar la iteración SOR para resolver un sistema de ecuaciones lineales********\n\n');

fprintf(fid, 'Número de iteraciones: %d veces\n\n',k);

fprintf(fid,'valor de x\n\n');

fprintf(fid, ' %12.8f \n', x);

descanso;

fin

k=k+1;

x0=x ;

fin

si k==N+1

fid = fopen('SOR_iter_result.txt', 'wt') ;

fprintf(fid,'\n*******El resultado de salida de usar SOR para resolver iterativamente un sistema de ecuaciones lineales********\n\n' );

fprintf (fid,'Número de iteraciones: %

d veces\n\n',k);

fprintf(fid,'¡Se superó el número máximo de iteraciones, la solución falló!');

fclose(fid);

end Principio e implementación del método Runge-Kutta en Matlab El método Runge-Kutta es un algoritmo de un solo paso de alta precisión ampliamente utilizado en ingeniería. Dado que este algoritmo tiene una alta precisión y se toman medidas para suprimir errores, su principio de implementación también es relativamente complejo. El algoritmo se basa en una base matemática. La base teórica del método de Runge-Kutta proviene de la fórmula de Taylor y el uso de la aproximación de pendientes para expresar diferenciales. Precalcula las pendientes de varios puntos en el intervalo de integración y luego realiza un promedio ponderado como base para el siguiente punto. construir un método de cálculo de alta integración numérica más preciso. Si se encuentra la pendiente de dos puntos de antemano, es el método de Runge-Kutta de segundo orden. Si se calculan cuatro puntos de antemano, es el método de Runge-Kutta de cuarto orden. Una ecuación diferencial ordinaria de primer orden se puede escribir como: y'=f(x,y), utilizando el concepto de diferencia.

(Yn+1-Yn)/h= f(Xn,Yn) derivación (aproximadamente igual, el límite es Yn')

Yn+1=Yn+h*f ( Xn,Yn)

Además, según el teorema del valor medio diferencial, existe 0

Yn+1=Yn+h*f( Xn+th,Y(Xn +th))

Aquí K=f(Xn+th,Y(Xn+th)) se llama pendiente promedio, y el método de Runge-Kutta es un algoritmo para encontrando a k.

Usando este principio y mediante una derivación matemática compleja (omitida porque es demasiado complicada), podemos obtener la fórmula de Runge-Kutta de cuarto orden con un error de truncamiento de O(h^5):

K1＝f(Xn,Yn);

K2=f(Xn+h/2,Yn+(h/2)*K1);

K3=f (Xn+ h/2,Yn+(h/2)*K2);

K4=f(Xn+h,Yn+h*K3);

Yn+1=Yn +h *(K1+2K2+2K3+K4)*(1/6);

Entonces, para comprender mejor y con mayor precisión la relación temporal, debes escribirla tú mismo basándose en tu comprensión de Runge. -Principio de Kutta. La función Runge-Kutta de paso fijo, después de aprender su principio, ha completado la función Runge-Kutta unidimensional.

Después de pensar detenidamente, descubrí que si necesitas resolver múltiples ecuaciones diferenciales, puedes imaginar que el tiempo y el tamaño del paso se resuelven en paralelo. Primero, el An predeterminado. Se le da un valor inicial al primer paso de cada ecuación diferencial y luego, en cada paso, se resuelven múltiples ecuaciones diferenciales simultáneamente. Después de pensarlo, descubrí que todo el proceso es en realidad muy intuitivo, es solo una cuestión de cálculos de aproximación constante.

La función de cálculo escrita de Runge-Kutta de paso fijo:

función [x,y]=runge_kutta1(ufunc,y0,h,a,b)% El orden de la lista de parámetros es la función del diferencial sistema de ecuaciones Nombre, vector de valor inicial, tamaño de paso, punto de inicio de tiempo, punto de finalización de tiempo (la forma del parámetro se refiere a la función ode45)

n=floor((b-a)/h);% encuentra el número de pasos

x(1)=a;% punto de inicio del tiempo

y(:,1)=y0;%Asignar valor inicial, que puede ser un vector, pero paga atención a la dimensión

para ii =1:n

x(ii+1)=x(ii)+h;

k1=ufunc(x (ii),y(:,ii));

k2=ufunc(x(ii)+h/2,y(:,ii)+h*k1/2);

k3=ufunc(x(ii)+h /2,y(:,ii)+h*k2/2);

k4=ufunc(x(ii)+h,y( :,ii)+h*k3);

y(:,ii+1)=y(:,ii)+h*(k1+2*k2+2*k3+k4)/6 ;

%Según el método Tower de la biblioteca Longge para solución numérica

fin

La subfunción llamada y su declaración de llamada:

función dy=test_fun(x,y)

dy = zeros(3,1);%Inicializar vector de columna

dy(1) = y(2) * y(3) ;

dy(2) = - y(1) + y(3);

dy(3) = -0,51 * y(1) * y(2);

Utilice ode45 y La función Runge-Kutta autoescrita se utiliza para comparar y se llama de la siguiente manera:

[T,F] = ode45(@test_fun,[0 15], [1 1 3]);

subplot(121)

plot(T,F)%Efecto de función ode45 propio de Matlab

title('efecto de función ode45 ')

[T1 ,F1]=runge_kutta1(@test_fun,[1 1 3],0.25,0,15);%Cambie la dimensión de la función de test_fun al realizar la prueba, no olvide cambiar la dimensión del valor inicial

subplot(122)

plot(T1,F1)%El efecto de la función autoescrita de Runge-Kutta

title( 'Función Runge-Kutta autoescrita')