INTEGRACIÓN NUMÉRICA

Basado en Dn con un set de n+1 puntos dados en el plano (x,y)

Dn = {(xi; yi)| 0 ≤ i ≤n; a = x0 < x1 < …< xn = b; yi = f(xi)}, para alguna función f(x). Basado sobre
Dn, nuestro objetivo básico es buscar aproximación exacta para:
1. f’(xi) y f’’(xi): i= 0,1,…,n (diferenciación numérica),
𝑏
2. I=∫𝑎 𝑓(𝑥)𝑑𝑥 (integración numérica)
Asumimos que los datos x en Dn son {igualmente espaciados, con:
h=xi+1-xi

𝑏
consideramos la aproximación de I = I(a; b ; f) =∫𝑎 𝑓(𝑥)𝑑𝑥.

Distinto de la diferenciación numérica, la (xi) no necesita de equidistancia. No obstante, a

menos que de otra manera asumimos iniciar con:
1. Nodos equidistantes, por ejemplo., h = xi+1 -xi ∀ i, con nh = b - a.
2. Continuidad de la función f se encuentra en el intervalo de integración, por ejemplo,
f ∈ C(a, b).

La regla trapezoidal o método del Trapecio:

clear all;
clc;
fprintf('Cálculo de la integral por el método trapecial\n\n');
f=input('introduce la función:','s');
a=input('límite inferior:');
b=input('límite superior:');
c=input('número de segmentos a dividir:');
h=(b-a)/c;
z=0;
for x=a:h:b
k=eval(f);
if x==a,d=k;
end
if x==b,e=k;
end
z=z+k;
end
z=z-d-e;
z=z*2;
z=z+d+e;
z=z/(2*c);
fprintf('Resultado: ');
z=z*(b-a)

La regla de punto medio.

function I = CompositeMidpoint(x, y)
% Input x = [x(1),...,x(n+1)] with x(1)=a, x(n+1)=b, and y =[y(1),...,y(n+1)]
% Output I = aproximación de la integral usando la regla de punto medio
n=length(x)-1; m= length(y) - 1; a=x(1); b=x(n+1);
if n==m
h= (b-a)/n ;
% Pruebe que n es una integral igual uniforme
if floor(n/2) == ceil(n/2)
Y = y(2:2:n);
I = 2*h*sum(Y);
end
end

La regla de Simpson.
Ejemplo: Utilizando el método de Simpson 1/3 calcular la siguiente integral:
1

𝐼 = ∫ 𝑥 5 𝑑𝑥 ; 𝑥 ∈ [0,1]
0
% Método de simpson 1/3
function [I,E]=met_simpson13(fun,a,b,N)
% fun : Función a ingresar
% a : extremo inicial
% b : extremo final
% N : número de particiones
%%------------------------------------
d4F=diff(diff(diff(diff(fun))));
%%-------------------
%% Integración
h=(b-a)/N;
t=a:h:b;
for k=1:length(t)
x=t(k);
f(k)=eval(fun);
end
I=(h/3)*(f(1)+4*sum(f(2:2:end))+2*sum(f(3:2:end-1))+f(end));
%% Error
d4f=[];
for k=2:length(t)-1
x=t(k);
d4f=['d4f eval(d4F)'];
end
E=abs(-(h^4)*((b-a)/180)*max(d4f));
En command Window:
>> [I,E]=met_simpson13('x^5',0,1,50)
I=
0.1667
E=
1.0489e-07

Del ejemplo anterior y aplicando el script tenemos: Método de Simpson 3/8 con f(x)= x^5, a= 0,
b= 1, #Cifras Signif Exac.= 4

clear;clc;
fprintf('***Metodo de Simpson 3/8***');
fprintf('\n\nIngrese Funcion\n(No es Necesario El Punto)\n\n');
fun=input('f(x)= ','s');
f=inline(fun,'x');
a=input('a= ');
b=input('b= ');
cse=input('#Cifras Signif Exac.= ');
Er=10^-cse;
N=floor(sqrt((b-a)^3)*10^(cse/2));% número de particiones
d2f=diff(diff(diff(diff(fun))));

while 1
h=(b-a)/(N-1);
xh=a:h:b;

%------------------------
% error
x=xh;
d2fx='eval(d2f)';
maxF=max(abs(d2fx));
E=abs(-1*h^5*maxF/90);% Error del metodo.
if E<=Er
for k=1:length(xh)

x=xh(k);
y(k)=eval(fun);
end

n=length(y);
si=0; sp=0; s3=0;
if mod(n-1,3)==0
for i=2:n-1
if mod(i,1)==0
si=si+y(i);
elseif mod(i,2)==0
sp=sp+y(i);
end
end
S=(3*h/8)*(y(1)+y(n)+3*si+3*sp);
break
else
disp('El método no es aplicable');
end
else
N=N+50;
end
end
fprintf('El valor de la integral aproximada es: %.4f\n\n ',S);

El valor real es:

>> syms x
>> double(int(x^5,0,1))
ans =
0.1667

Del ejemplo anterior y aplicando el script tenemos: f(x)= x^5, a= 0, b= 1, #Cifras Signif Exac.= 4

clear all;
clc;
fprintf('Cálculo de la integral por el método de Simpson de 1/3
y 3/8\n\n');
fprintf('Para cualquier cantidad de segmentos par o impar\n\n');
f=input('introduce la función:','s');
a=input('límite inferior:');
b=input('límite superior:');
c=input('número de segmentos a dividir :');
h=(b-a)/c;
qqqqq=0;
if (-1)^c==-1
b=b-(3*h);
c=c-3;
e=b+h;
ff=b+2*h;
g=b+3*h;
ee=g-b;
x=b;
q=eval(f);
x=e;
qq=eval(f);
x=ff;
qqq=eval(f);
x=g;
qqqq=eval(f);
qqqqq=(ee)*((q+3*qq+3*qqq+qqqq)/8);
end
z=0;
x=a;
for i=1:c;
if (-1)^i==1
k=eval(f);
z=z+k;
end
x=h*i;
end
zz=0;
x=a;
for i=2:c;
if (-1)^i==-1
k=eval(f);
zz=zz+k;
end
x=h*i;
end
x=a;
if x==a
d=eval(f);
end
x=b;
if x==b
eee=eval(f);
end
z=z*4;
v=zz*2;
z=z+v+d+eee;
z=z/(3*c);
z=z*(b-a);
fprintf('Resultado: ');
z=z+qqqqq

Ecuaciones diferenciales:

% Método de Euler
function [t,x] =euler(f,t0,tf,x0,n)
h=(tf-t0)/n;
t=t0:h:tf;
x=zeros(n+1,1); %reserva memoria para n+1 elementos del
vector x
x(1)=x0;
for i=1:n
x(i+1)=x(i)+f(t(i),x(i))*h;
end
end

En Command Window:
tf=input('tiempo final, tf: ');
n=input('número de pasos, n: ');
f=@(t,x) cos(t);
%condiciones iniciales
t0=0;
x0=0;
[t,x]=euler(f,t0,tf,x0,n);

hold on
plot(t,x,'b')
y=sin(t);
plot(t,y,'r')
xlabel('t')
ylabel('x');
legend('aproximada','exacta')
title('dx/dt=cos(t)')
hold off
%tiempo final, tf: 5
%número de pasos, n: 50
% Método de Euler-otro
T=25;
tinic=0.0;
tfinal=5.0;
yinic=50.0;
n=100;
f=@(t,y) -2*(y-T);
h=(tfinal-tinic)/n;
t=zeros(1,n+1);
y=zeros(1,n+1);
t(1)=tinic;
y(1)=yinic;
for i=1:n
t(i+1)=t(i)+h;
y(i+1)=y(i)+h*f(t(i),y(i));
end
plot(t,y,'b')
title('Soluciones de dy/dt=-2*(y-T), y(0)=T mediante Euler')
axis([0 5 20 55])
xlabel('Tiempo');
ylabel('Temperatura')
hold on
plot(t,25,'-r')
f=input('\nIngrese la ecuación diferencial de la forma:
dy/dx=f(x,y)\n','s');
x0=input('\nIngrese el primer punto x0:\n');
x1=input('\nIngrese el segundo punto x1:\n');
y0=input('\nIngrese la condición inicial y(x0):\n');
n=input('\nIngrese el número de pasos n:\n');
h=(x1-x0)/n;
xs=x0:h:x1;
y1=y0;
fprintf('\n''it x0 x1 y1');
for i=1:n
it=i-1;
x0=xs(i);
x=x0;
x1=xs(i+1);
y=y0;
y1=y0+h*eval(f);
fprintf('\n%2.0f%10.6f%10.6f%10.6f\n',it,x0,x1,y1);
y0=y1;
end
fprintf('\n El punto aproximado y(x1) es = %10.6f\n',y1);

%Continuando la solución en Command Window:

Ingrese la ecuacion diferencial de la forma: dy/dx=f(x,y)
sqrt(x^2+y^2)

Ingrese el primer punto x0:2

Ingrese el segundo punto x1:2.3

Ingrese la condicion inicial y(x0):0.5

Ingrese el numero de pasos n:3

'it x0 x1 y1
0 2.000000 2.100000 0.706155

1 2.100000 2.200000 0.927710

2 2.200000 2.300000 1.166470

El punto aproximado y(x1) es = 1.166470

Método de Runge-Kutta
En esta sección vamos a estudiar la aplicación del método de Runge-Kutta a:
- Una ecuación diferencial de primer orden
- Un sistema de dos ecuaciones diferenciales de primer orden
- Una ecuación difrencial de segundo orden
- Un sistema de dos ecuaciones diferenciales de segundo orden
Ecuación diferencial de primer orden:
Sea una ecuación diferencial de primer orden, con la condición inicial de que en el
instante t0 el valor inicial de xes x0
Se elige una anchura de paso h y se calculan cuatro números k1, k2, k3, k4 . Según el
procedimiento ordinario de Runge-Kutta, a partir del valor de x en el instante t se determina el
valor de x en el instante t+h.
Ejemplo: Considérese el circuito en serie de la figura, R=2.0, C=0.8, y tf=10.
Vab+Vbc+Vca=0 ; Vca=-Vε , donde Vε es la fem de la batería.
Fuente: http://www.sc.ehu.es/sbweb/fisica_/elecmagnet/condensador/rc/rc.html

function [t,x] =rk_1(f,t0,tf,x0,n)

h=(tf-t0)/n;
t=t0:h:tf;
x=zeros(n+1,1); %reserva memoria para n elementos del vector
x
x(1)=x0;
for i=1:n
k1=h*f(t(i),x(i));
k2=h*f(t(i)+h/2,x(i)+k1/2);
k3=h*f(t(i)+h/2,x(i)+k2/2);
k4=h*f(t(i)+h,x(i)+k3);
 x(i+1)=x(i)+(k1+2*k2+2*k3+k4)/6;
end
end

En Command Window:
V0=10;
R=input('Resistencia R: ');
C=input('Capacidad C: ');
tf=input('tiempo final, tf: ');
n=input('número de pasos, n: ');

f=@(t,x) V0/R-x/(R*C);
%condiciones iniciales
t0=0; x0=0;
[t,x]=rk_1(f,t0,tf,x0,n);

hold on
plot(t,x,'b')
y=C*V0*(1-exp(-t/(R*C)));
plot(t,y,'r')
xlabel('t')
ylabel('q');
legend('aproximada','exacta','Location','Southeast')
title('Carga del condensador')
hold off

% Seguimoss ingresando en Command Window:

Resistencia R: 2
Capacidad C: 0.8
tiempo final, tf: 10
número de pasos, n: 50

No se aprecia diferencia entre la solución exacta y la numérica, aplicando el procedimiento de

Runge_Kutta.

Sistema de dos ecuaciones diferenciales de primer orden

dx dy
= f(t, x, y) = g(t, x, y)
dt dt
% Sistema de dos ecuaciones diferenciales de primer orden
function [t,x,y] =rk_2_1(f,g,t0,tf,x0,y0,n)
h=(tf-t0)/n;
t=t0:h:tf;
x=zeros(n+1,1); %reserva memoria para n+1 element(i)os del
vect(i)or x(i)
y=zeros(n+1,1);
x(1)=x0; y(1)=y0;

for i=1:n
k1=h*f(t(i),x(i),y(i));
l1=h*g(t(i),x(i),y(i));
k2=h*f(t(i)+h/2,x(i)+k1/2,y(i)+l1/2);
l2=h*g(t(i)+h/2,x(i)+k1/2,y(i)+l1/2);
k3=h*f(t(i)+h/2,x(i)+k2/2,y(i)+l2/2);
l3=h*g(t(i)+h/2,x(i)+k2/2,y(i)+l2/2);
k4=h*f(t(i)+h,x(i)+k3,y(i)+l3);
l4=h*g(t(i)+h,x(i)+k3,y(i)+l3);

x(i+1)=x(i)+(k1+2*k2+2*k3+k4)/6;
y(i+1)=y(i)+(l1+2*l2+2*l3+l4)/6;
end
end

Ejemplo: Consideremos una serie radioactiva de tres elementos A-->B-->C en la que, una
sustancia radiactiva A se desintegra y se transforma en otra sustancia radiactiva B, que a su vez
se desintegra y se transforma en una sustancia C estable.
% En Command Window:
a=input('parámetro a: ');
b=input('parámetro b: ');
x0=input('valor inicial de x: ');
y0=input('valor inicial de y: ');
tf=input('tiempo final, tf: ');
n=input('número de pasos, n: ');
f=@(t,x,y) -a*x;
g=@(t,x,y) a*x-b*y;
%condiciones iniciales
t0=0;

[t,x,y]=rk_2_1(f,g,t0,tf,x0,y0,n);
hold on
plot(t,x,'b')
plot(t,y,'r')
xlabel('t')
ylabel('x,y');
legend('x(t)','y(t)')
title('dx/dt=-ax, dy/dt=ax-by')
hold off

% En Command Window se ingresa:

parámetro a: 0.1
parámetro b: 0.2
valor inicial de x: 100
valor inicial de y: 0
tiempo final, tf: 10
número de pasos, n: 40
Ecuación diferencial de segundo orden
Existen muchas situaciones en las que es necesario resolver una ecuación diferencial de
segundo orden.
𝑑2 𝑥
= f(t, x, v)
𝑑𝑡 2
con las condiciones iniciales
𝑑𝑥
𝑥(𝑡0 ) = 𝑥0 ( ) = 𝑣0
𝑑𝑡 𝑡0
Una ecuación diferencial de segundo orden es equivalente a un sistema de dos ecuaciones
diferenciales de primer orden.

Ejemplo: La ecuación diferencial que describe un oscilador armónico amortiguado y su solución

para unas condiciones iniciales fijadas es:

Condiciones iniciales: en el instante t=0, la posición inicial es x0 y la velocidad inicial v0.

% Ecuación diferencial de segundo orden

function [t,x,v] =rk_2(f,t0,tf,x0,v0,n)
h=(tf-t0)/n;
t=t0:h:tf;
x=zeros(n+1,1);%reserva memoria para n+1 elementos del
vector x(i)
v=zeros(n+1,1);
x(1)=x0; v(1)=v0;

for i=1:n
k1=h*v(i);
l1=h*f(t(i),x(i),v(i));
k2=h*(v(i)+l1/2);
l2=h*f(t(i)+h/2,x(i)+k1/2,v(i)+l1/2);
k3=h*(v(i)+l2/2);
l3=h*f(t(i)+h/2,x(i)+k2/2,v(i)+l2/2);
k4=h*(v(i)+l3);
l4=h*f(t(i)+h,x(i)+k3,v(i)+l3);

x(i+1)=x(i)+(k1+2*k2+2*k3+k4)/6;
v(i+1)=v(i)+(l1+2*l2+2*l3+l4)/6;
end
end

% En Command Window se ingresa:

w0=input('frecuencia angular w0: ');
g=input('rozamiento, gamma: ');
x0=input('posición inicial, x0: ');
v0=input('velocidad inicial,v0: ');
tf=input('tiempo final, tf: ');
n=input('número de pasos, n: ');
f=@(t,x,v) -2*g*v-w0*w0*x;
%condiciones iniciales
t0=0;
hold on
%solución numérica
[t,x,v]=rk_2(f,t0,tf,x0,v0,n);
plot(t,x,'b')
%solución analítica
w=sqrt(w0*w0-g*g);
x=((v0+g*x0)*sin(w*t)/w+x0*cos(w*t)).*exp(-g*t);
plot(t,x,'r')
grid on
xlabel('t')
ylabel('x');
legend('aproximado','exacto')
title('oscilador amortiguado')
hold off

% En la ventana de comandos corremos el script oscilador con

distintas condiciones iniciales
frecuencia angular w0: 2
rozamiento, gamma: 0.5
posición inicial, x0: 1.5
velocidad inicial,v0: 0
tiempo final, tf: 8
número de pasos, n: 100

No se aprecia la diferencia entre la solución exacta y la numérica, aplicando el procedimiento de

Runge_Kutta.
…

Ecuación del calor en Matlab

Difusión de calor en las rocas. Considere el problema de determinar las fluctuaciones de la

temperatura de roca del subsuelo como resultado de las variaciones diarias o estacionales de
temperatura. A medida que la superficie se calienta o enfría, el calor se difundirá a través de la
tierra y las rocas. Matemáticamente, la difusión puede ser representada por la ecuación

donde T (t, z) es la temperatura en el tiempo t y la profundidad z, y K es una constante que

mide la "difusividad" en la roca, es decir, cómo el calor rápidamente se mueve a través de la
roca. Un valor típico para K es 10 ^ -6 m ^ 2 / s.

Pregunta 1: Interpretar la ecuación del calor en palabras. ¿Qué es T (t, z)? ¿dT / dt? ¿dT /
dz? ¿d ^ 2T / dz ^ 2? ¿Por qué igualar el lado izquierdo y el lado derecho?

La ecuación anterior puede ser resuelto "analíticamente", es decir, T (t, z) puede ser escrita
exactamente como una ecuación. Matlab es más apropiado, sin embargo, para la solución de
problemas numéricamente, es decir, aproximadamente como (una matriz) de números.

Con el fin de resolver el sistema numérico, debemos elegir primero un "espacio" adecuado
para resolver el problema de. Tendremos dos ejes, los ejes verticales representan la
profundidad, desde 0 m a 100 m por debajo de la superficie, y el eje horizontal
representaremos tiempo de un año.

Las condiciones de contorno: La ecuación del calor es un ejemplo de lo que se conoce como
una "ecuación diferencial parcial." Una ecuación diferencial es cualquier ecuación en la que
una función (de temperatura en el tiempo y el espacio en este caso) no está representada
directamente, sino a través de la derivada. Parcial indica que hay al menos dos variables
(tiempo y espacio) en las derivadas. Una EDO sólo tiene una derivada.

Con el fin de resolver una EDP numéricamente, tenemos que especificar las condiciones de
contorno. Los cuatro límites de nuestro "espacio" son la superficie (0 m), la profundidad del
fondo (100 m), un tiempo de inicio arbitraria, y un año después.

Límite superior: El límite superior es el más simple, vamos a especificar simplemente una
temperatura que varía según la estación, es decir,

Esto tendrá una temperatura promedio anual de 15, una baja anual de 5 y un máximo anual de
25 (el tiempo se mide en meses, y no estamos empezando el 1 de enero).

Límite inferior: La condición límite inferior es fácil, así ... vamos a suponer que no hay calor, no
llega a la parte inferior de la parte superior, es decir,
Esto especifica que el flujo de calor en la parte inferior es 0. Todavía no sabemos cuál será esta
temperatura inferior.

Fronteras izquierdo y derecho: Las condiciones de contorno izquierdo y derecho son un poco
más problemático, ya que requieren de la temperatura en cada profundidad, que es
exactamente lo que estamos tratando de descubrir, pero sí sabemos que la temperatura actual
y exactamente un año a partir de ahora debe ser el mismo.

Aproximaciones de diferencias finitas: El último paso consiste en determinar las diferencias

finitas para evaluar las derivadas. Para la primera derivada de la temperatura con respecto al
tiempo vamos a utilizar la "derivada hacia adelante"

Para la primera derivada de la temperatura con respecto a la profundidad, vamos a utilizar la

"derivada central"

Para la segunda derivada de la temperatura con respecto a la profundidad, utilizaremos

El siguiente pequeño programa implementa este procedimiento en Matlab.

% Script para resolver la ecuación del calor en el suelo con
% la temperatura estacional
% Inicializar variables
dz = .25; % cada paso de profundidad es 1/4 metro
Nz = 400; % Elija el número de pasos de profundidad (debe ir a por lo
menos 100 m)
Nt = 5000; % Elija el número de pasos de tiempo
dt = (365*24*60*60)/Nt; % Duración de cada intervalo de tiempo en
segundos (~ 6.3 * 10 ^ 3 segundos, o ~ 105 minutos)
K = 2*10^-6; % "canónica" K es 10e-6 m^2/s

T = 15*ones(Nz+1,Nt+1); % Crear matriz temperatura con Nz+1 filas, y

Nt+1 columnas
% Suponer que T inicial es 15 en todas partes.
time = [0:12/Nt:12];
T(1,:) = 15-10*sin(2*pi*time/12); % Ajuste la temperatura superficial

maxiter = 500
for iter = 1:maxiter
Tlast = T; % Guardar el último acierto
T(:,1) = Tlast(:,end); % Inicializar la temperatura en t = 0 a la
última temperatura
for i=2:Nt+1,
depth_2D = (T(1:end-2,i-1)-2*T(2:end-1,i-1)+T(3:end,i-
1))/dz^2;
time_1D = K*depth_2D;
T(2:end-1,i) = time_1D*dt + T(2:end-1,i-1);
T(end,i) = T(end-1,i);
% Hacer cumplir las condiciones de contorno inferior
end
 err(iter) = max(abs(T(:)-Tlast(:))); % Encuentra diferencia entre
dos últimas soluciones
if err(iter)<1E-4
break; % Pare si soluciones muy similares, que tienen la
convergencia
end
end
if iter==maxiter;
warning(' No se ha alcanzado la convergencia')
end

maxiter =
500

pseudocódigo

Pregunta 2: Escribir pseudocódigo para el algoritmo anterior y convertirlo en.

Graficar la solución.
figure(1)
plot(log(err)), title('Convergence plot')
figure(2)
imagesc([0 12],[0 100],T); title('Temperature plot (imagesc)')
colorbar
figure(3)
depth = [0:dz:Nz*dz];
contourf(time,-depth,T); title('Temperature plot (contourf)')
colorbar

Trazar la gráfica del calor a profundidades de 0, 5 10, 15 y 20 m.

figure(4)
plot(time,T(1,:),time,T(21,:),time,T(41,:),time,T(61,:),time,T(81,:))
xlabel('Time (months)'); ylabel('Temperature (C)');
legend('0m','5m','10m','15m', '20m')
Complemento de interpolación de polinomios:
Función polyfit de MATLAB
MATLAB se refiere a la guarnición con un polinomio como curva de "regresión polinómica." La
función polyfit devuelve un vector de m + 1 coeficientes que representan el polinomio de ajuste
óptimo de grado m para el (xi, yi) un conjunto de puntos de datos. El orden coeficiente
corresponde a la disminución de potencias de x, es decir,
𝑦𝑐 = 𝑎1 𝑥 𝑚 + 𝑎2 𝑥 𝑚−1 + +𝑎3 𝑥 𝑚−2 + ⋯ + 𝑎𝑚 𝑥 + 𝑎𝑚+1
El vector A = (a1, a2, ..., am, am + 1) que contiene los coeficientes se obtiene mediante la ejecución
de A = polyfit (X, Y, m), donde X = (x1, x2, ..., xn) e Y = (y1, y2, ..., yn).
MATLAB proporciona la polyval (a, x) función para calcular los valores aproximados yc,i en (x1, x2,
..., xn) para los coeficientes empotrados (a1, a2, ..., am + 1):
𝑦𝑐,𝑖 = 𝑎1 𝑥𝑖𝑚 + 𝑎2 𝑥𝑖𝑚−1 + +𝑎3 𝑥𝑖𝑚−1 + ⋯ + 𝑎𝑚 𝑥𝑖 + 𝑎𝑚+1
Para calcular el cuadrado medio del error (MSE), polyval se usa en el siguiente ejemplo.
Ejemplo: Se tiene los siguientes puntos de datos, encontrar el mejor ajuste polinomial de
segundo, tercero, cuarto y quinto grado. Como también calcular el cuadrado medio del error.
(x,y)=(-10,980),(-8,-620),(-6,-70),(-4,80),(-2,100),(0,90),(2,0),(4,-80),(6,-90),(8,10),(10,220)

% Este programa determina la mejor curva de ajuste polinomio pasa

% a través de un conjunto dado de puntos de datos para polinomio
% de grados 2 a 5.
clear; clc;
% Datos suministrados
X = [ -10 -8 -6 -4 -2 0 2 4 6 8 10 ];
Y = [-980 -620 -70 80 100 90 0 -80 -90 10 220 ];
% Ajustar a los polinomios de grado m:
m=2:5;
% Crear un segundo conjunto de puntos x en el mismo intervalo
% con el fin de trazar la curva ajustada
X2 = -10:0.5:10;
% Vector para realizar un seguimiento de MSE (para imprimir al final)
MSE=zeros(length(m));
for i=1:length(m)
fprintf('m = %i \n',m(i));
% un polinomio de orden de grado m tiene m+1 coeficientes:
A = zeros(m(i)+1);
% hacer el ajuste
A = polyfit(X,Y,m(i));
% calcular el MSE (cuadrado medio del error)
Yc = polyval(A,X);
MSE(i) = (1/length(X)) * sum((Y-Yc).^2);
% imprimir tabla
fprintf(' x y yc \n');
fprintf('-----------------------------\n');
for j=1:length(X)
fprintf('%5.0f %5.0f %8.2f \n', ...
X(j),Y(j),Yc(j));
end
fprintf('\n\n');
% plot
subplot(2,2,i);
plot(X2,polyval(A,X2),X,Y,'o');
xlabel('x'); ylabel('y'); grid;
axis([ -10 10 -1500 500]);
title(sprintf(' Ajuste polinomial %d grado ',m(i)));
end
% impresión de MSE calculado
fprintf(' m MSE \n')
fprintf('-------------------\n');
for i=1:length(m)
fprintf(' %g %10.2f \n',m(i),MSE(i))
end

Salida del programa:

m MSE
------------------
2 32842.37
3 2659.97
4 2342.11
5 1502.95

As would be expected, the MSE decreases as the order of the fitted polynomial increases.

Comparación de interpolación:
Observamos que obtenemos la misma respuesta con la interpolación lineal, sino una respuesta
diferente a la interpolación cúbica. Aquí la interpolación cúbica hace mucho mejor trabajo de
montaje. Usted puede ver por qué en esta figura. La interpolación cúbica es mucho más cerca
de la verdadera función de la mayor parte del rango. Aunque tenga en cuenta que sobreestima
en algunas regiones y subestima en otras regiones.
t = [0.5 1 3 6];
f = [0.6065 0.3679 0.0498 0.0025];
figure
hold all
x = linspace(0.25, 6);
plot(t,f,'ko ')
plot(x, interp1(t,f,x),'r-')
plot(x, interp1(t,f,x,'pchip'),'b-')
plot(x,exp(-x),'k--')
xlabel('t')
ylabel('f(t)')
legend('datos en bruto (nodo)','interpolación lineal','interpolación cúbica','exp(-t)')
% exp(-t) es la función verdadera.
% Polinomio de interpolación cúbica de Hermite a trozos(PCHIP:
% Piecewise Cubic Hermite Interpolating Polynomial).