Integracin numrica

Hay muchas situaciones en la que es preciso aplicar procedimientos numricos

para obtener la integral definida de una funcin. En este captulo se explicarn
dos procedimientos:

Mtodo del punto medio

El procedimiento del trapecio

El procedimiento de Simpson

Concepto de integral definida

Para introducir el concepto de integral definida vamos a resolver el siguiente
problema de cinemtica.
http://www.sc.ehu.es/sbweb/fisica_/cinematica/rectilineo/rectilineo/rectilineo_
3.html
Dada la velocidad de un mvil en funcin del tiempo v(t) calcular el
desplazamiento x-x0 de dicho mvil entre los instantes t0 y t.

Dividimos el intervalo t0 a t en pequeos intervalos de tiempo ti=ti-ti-1

En el instante ti-1 la velocidad del mvil es vi-1, en el instante ti la velocidad del
mvil es vi. La velocidad media <vi> en el intervalo de tiempo ti=ti-ti1 comprendido entre ti-1 y ti es
<vi>=v(ti)+v(ti1)2

El desplazamiento del mvil durante el intervalo de tiempo ti=ti-ti1 comprendido entre ti-1 y ti es aproximadamente el rea del rectngulo <vi>ti.
El desplazamiento total x-x0 entre el instante inicial t0, y el instante
final t=tn es, aproximadamente
xx0i=1n<vi>ti

donde n es el nmero de intervalos

Si v=-t2+14t+21 (m/s) y tomamos n=10 intervalos iguales, entre el
instante t0=0 y t=10 s el desplazamiento aproximado vale
ti-1

ti

0
1
2
3
4
5
6
7
9
0

1
2
3
4
5
6
7
8
10
10

<vi>
27.5
39.5
49.5
57.5
63.5
67.5
69.5
67.5
63.5

<vi>ti
27.5
39.5
49.5
57.5
63.5
67.5
69.5
67.5
63.5
575.0

Cuando el nmero de intervalos en los que se ha dividido un intervalo dado

(t0, t) es muy grande ti-->0, la velocidad media <vi> en el intervalo
comprendido entre ti-1 y ti es la velocidad v en cada instante t. En el lmite, el
desplazamiento se expresa como
xx0=t0tvdt

Si v=-t2+14t+21 (m/s), el desplazamiento entre el instante t0=0 y t=10 s vale

xx0=t0t(t2+14t+21)dt=t33+7t2+21t100=17303=576.6667m

Se ha de tener en cuenta que los ndices en MATLAB comienzan en uno no en

cero. Creamos un funcin denominada integral_1 que realice las siguientes
tareas:
1.

Calcular la velocidad en el instante ti

2.

Calcular la velocidad en el instante ti+1

3.

Calcular la velocidad media vm del mvil en el intervalo de tiempo ti=ti+1ti

4.

Calcular el desplazamiento aproximado en dicho intervalo de

tiempo, vmti.

5.

Calcular el desplazamiento total aproximado x-x0 de dicho mvil entre los

instantes t0 y t.
function suma=integral_1(f,t)
suma=0;
v1=f(t(1));
for i=1:length(t)-1
v2=f(t(i+1));
vm=(v1+v2)/2;
suma=suma+vm*(t(i+1)-t(i));
v1=v2;
end
end

En el script (ms abajo), el vector t1 contiene n+1 datos comprendidos entre el

tiempo inicial t0 y la final tfambos incluidos, si el nmero de intervalos es n.
t0=input('tiempo inicial, t0: ');
tf=input('tiempo final, tf: ');
n=input('nmero intervalos, n: ');
vel=@(t) -t.^2+14*t+21; %funcin velocidad
t1=linspace(t0,tf,n+1);
res=integral_1(vel,t1); %calcula la integral
fprintf('El desplazamiento es %3.2f: \n',res)

En la ventana de comandos corremos el script velocidad

>> velocidad
tiempo inicial, t0: 0
tiempo final, tf: 10
nmero intervalos, n: 10
El desplazamiento es: 575.00

Mtodo del punto medio

El mtodo del punto medio es muy fcil de entender, ya que aproxima la
integral definida
abf(x)dx

por la suma de pequeos rectngulos. Como se ve en la figura el rea de cada

rectngulo es f(xm) xi, donde xm=(xi+1+xi)/2 es la posicin intermedia
entre xi y xi+1.

Definimos la funcin integral_2 para que realice las siguientes tareas:

1.

Calcula la posicin intermedia xm=(xi+1+xi)/2 entre xi y xi+1

2.

Calcula el rea del rectngulo f(xm) xi, donde xi=xi+1-xi

3.

Calcula el rea total aproximada en el intervalo a, b.

function suma=integral_2(f,x)
suma=0;
for i=1:length(x)-1
xm=(x(i+1)+x(i))/2;
suma=suma+f(xm)*(x(i+1)-x(i));
end
end

Escribimos el script velocidad_1

t0=input('tiempo inicial, t0: ');
tf=input('tiempo final, tf: ');
n=input('nmero intervalos, n: ');
vel=@(t) -t.^2+14*t+21; %funcin velocidad
t1=linspace(t0,tf,n+1);
res=integral_2(vel,t1); %calcula la integral
fprintf('El desplazamiento es: %3.2f\n',res)

En la ventana de comandos corremos el script velocidad_1

>> velocidad_1
tiempo inicial, t0: 0
tiempo final, tf: 10
nmero intervalos, n: 10
El desplazamiento es: 577.50

Frmula del trapecio

Para calcular la integral definida de la funcin f(x) en el intervalo comprendio
entre x0 y x, dividimos este intervalo en pequeos intervalos de longitud h=xi+1xi. Sustituimos la funcin por la recta que une los puntos (xi,yi) y (xi+1, yi+1). El
rea sombreada en la figura es la suma del rea de un rectngulo ms el rea
de un tringulo, vale

hyi+12h(yi+1yi)=12h(yi+1+yi)

El rea total aproximada bajo la curva es

h2(y1+y2)+h2(y2+y3)+h2(y3+y4)+...

+h2(yn2+yn1)+h2(yn1+yn)=h2(y1+2y2+2y3+2y4+...+2yn2+2yn1+yn)

Definimos en la funcin trapecio el procedimiento. Donde f es la funcin

integrando, y x el vector de n+1 datos comprendidos entre la abscisa
inicial x0 y la final xf ambas incluidas, si el nmero de intervalos es n.
function sum=trapecio(f,x0, xf, nInterv)
%el nmero de puntos es n intervalos ms uno
x=linspace(x0,xf,nInterv+1);
n=length(x);
sum=(f(x(1))+f(x(n)))/2;
for i=2:n-1
sum=sum+f(x(i));
end
sum=sum*(x(2)-x(1));
end

Dada la funcin integrando f(x), calculamos la aproximacin a la integral

definida en el intervalo comprendido entre x0 y x, escribiendo el
script velocidad_2.
x0=input('abscisa inicial, x0: ');

xf=input('abscisa final, xf: ');

n=input('nmero intervalos, n: ');
deriv=@(x) -x^2+14*x+21; %definicin del integrando
res=trapecio(deriv,x0,xf,n); %calcula la integral
fprintf('El valor aproximado de la integral: %3.2f\n',res)

En la ventana de comandos corremos el script velocidad_2

>> velocidad_2
abscisa inicial, x0: 0
abscisa final, xf: 10
nmero intervalos, n: 10
El valor aproximado de la integral: 575.00

El mtodo de Simpson (1/3)

En este procedimiento, se toma el intervalo de anchura 2h, comprendido
entre xi y xi+2, y se sustituye la funcin f(x) por la parbola que pasa por tres
puntos (xi, yi), (xi+1, yi+1), y (xi+2, yi+2).

Calculamos la contribucin a la integral del primer intervalo (x0, x0+2h) y

generalizaremos para el resto de los intervalos.
La ecuacin de la parbola y=ax2+bx+c que pasa por los puntos (x0, y0), (x0+h,
y1), (x0+2h, y2) es
y0=ax20+bx0+cy1=a(x0+h)2+b(x0+h)+cy2=a(x0+2h)2+b(x0+2h)+c

Este sistema de tres ecuaciones con tres incgnitas, se reduce a

y1=y0+2ax0h+ah2+bhy2=y0+4ax0h+4ah2+2bh

Despejamos el coeficiente a, y 2ax0+b

a=y22y1+y02h22ax0+b=4y13y0y22h

Sustituimos la curva por la porcin de parbola en el intervalo (x0, x0+2h). La

integral vale.
I=x0x0+2h(ax2+bx+c)dx=a3(6x20+12x0h2+8h3)+b2(4x0h+4h2)+c(2h)=2h(
ax20+bx0+c)+2(2ax0+b)h2+83ah3=h3(y0+4y1+y2)

En general, el valor del rea aproximada, en el intervalo (xi, xi+2h) sombreada

en la figura, es
h3(yi+4yi+1+yi+2)

El rea aproximada en el intervalo (a, b) es

abf(x)dxh3(y0+4y1+y2)+h3(y2+4y3+y4)+....+h3(yn2+4yn1+yn)

o bien, agrupando trminos

abf(x)dxh3((y0+yn)+4(y1+y3+....yn1)+2(y2+y4+....yn2))

El primer parntesis, contiene la suma de los extremos, el segundo, la suma de

los trminos de ndice impar, y el tercero la suma de los trminos de ndice
par. En el mtodo de Simpson, el nmero de divisiones n debe de ser par.
Definimos en la funcin simpson el procedimiento. Donde f es la funcin
integrando, y x el vector de n+1 datos comprendidos entre la abscisa
inicial x0 y la final xf ambas incluidas, si el nmero de intervalos es n que tiene
que ser un nmero PAR.
function suma=simpson(f,x0,xf,n)
%n nmero par de intervalos, n+1 nmero de puntos en el vector
x=linspace(x0,xf,n+1);
h=x(2)-x(1);
suma=f(x(1))+f(x(n+1));
for i=2:2:n
suma=suma+4*f(x(i));
end
for i=3:2:n-1
suma=suma+2*f(x(i));
end
suma=suma*h/3;
end

Dada la funcin integrando f(x), calculamos la aproximacin a la integral

definida en el intervalo comprendido entre x0 y x, escribiendo el
script velocidad_3
x0=input('abscisa inicial, x0: ');

xf=input('abscisa final, xf: ');

n=input('nmero intervalos (par), n: ');
if rem(n,2)==1
disp('El nmero intervalos tiene que ser par ');
break
end
deriv=@(x) -x^2+14*x+21; %definicin del integrando
res=simpson(deriv,x0,xf,n); %calcula la integral
fprintf('El valor aproximado de la integral: %3.2f\n',res)

En la ventana de comandos corremos el script velocidad_3

>> velocidad_3
abscisa inicial, x0: 0
abscisa final, xf: 10
nmero intervalos, n: 10
El valor aproximado de la integral: 576.67

Apreciamos la mejora en el resultado de la integral con el mtodo de Simpson.

Existe una versin del mtodo de Simpson denominada 3/8 en el que se
emplea una ecuacin cbica para concectar cuatro puntos.

Integracin numrica con funciones

MATLAB
MATLAB dispone de las funciones denominadas quad y dblquad para las
integrales simples y dobles

Integrales simples
La funcin quad(function, a, b);devuelve el resultado aproximado de la
integral cuando se le pasa la funcin a integrar en el primer
parmetro function, los lmites a y b de la integral. Ejemplos:
010(t2+14t+21)dt=t33+7t2+21t100=17303=576.6667m
>> f=@(x) -x.^2+14*x+21;
>> q=quad(f,0,10)
q = 576.6667

Integrales dobles

Queremos calcular una integral doble de la funcin f(x,y) en la regin

rectangular de abscisas a y b y de ordenadas c y d, tal como se muestra en la
figura
badcf(x,y)dydx

MATLAB dispone de la funcin dblquad (se sustituye por integral2 en

versiones ms recientes de MATLAB) que realiza esta tarea. Supongamos que
queremos calcular la integral doble
2130x2ydydx

Creamos el script integral_doble, en el que definimos la funcin

annima f(x,y) y llamamos a dblquad pasndole la funcin, los lmites de
integracin de la variable x, y los lmites de integracin de la variable y.
f=@(x,y) x.^2.*y;
res=dblquad(f,1,2,0,3);
fprintf('El valor de la integral es: %2.3f\n',res)

En la ventana de comandos corremos el script integral_doble

>> integral_doble
El valor de la integral es: 10.500

Como puede comprobarse fcilmente haciendo la integral doble.

Para calcular la integral doble de la funcin f(x,y) en la regin no rectangular
comprendida entre las curvasy=c(x), y=d(x) y las rectas x=a y x=b
[Math Processing Error]

Al integrar la funcin f(x,y) respecto de la variable y entre los lmites c(x)

y d(x) nos queda la funcin g(x) que integramos entre los lmites a y b.
ba(d(x)c(x)f(x,y)dy)dx=bag(x)dx

Utilizamos la funcin MATLAB quad, para resolver ambas integrales, tal

como vemos en el siguiente ejemplo.
20x2+xx3x(x3y4+xy2)dydx=02(x2+xx3x(x3y4+xy2)dy)dx

Definimos la funcin g(x) del siguiente modo

function z=g(x)
n=length(x);
z=zeros(size(x));
for j=1:n
%lmites de y
c=x(j)^3-x(j);
d=x(j)^2+x(j);
%integrando f(x,y)
f=@(y) x(j)^3*y.^4+x(j)*y.^2;
z(j)=quad(f,c,d);
end
end

En el script integral_doble1 llamamos a la funcin quad para resolver la

integral de g(x)
res=quad(@g,0,2);
fprintf('El valor de la integral es: %3.3f\n',res)

En la ventana de comandos corremos el script integral_doble1

>> integral_doble1
El valor de la integral es: 961.181

Comprobar los resultados de las integrales siguientes:

0.10.5x3x2ey/xdydx0.033301x2x(x2+y3)dydx1.0001
Solucin

Integral de pares de datos

Supongamos que en una experiencia hemos medido la velocidad de un mvil
en funcin del tiempo,
t(s) 1 2 3 4 5 6 7 8 9 10
v(m/s) 5.0 6.0 5.5 7.0 8.3 7.6 6.2 6.1 7.0 5.7
calcular el desplazamiento del mvil utilizando la funcin trapz, que emplea
el procedimiento del trapecio.
>> t=[1 2 3 4 5 6 7 8 9 10];
>> v=[5.0 6.0 5.5 7.0 8.3 7.6 6.2 6.1 7.0 5.7];
>> des=trapz(t,v)
des =
59.0500

Solucin numrica de ecuaciones diferenciales (I)

Las leyes que gobiernan los fenmenos de la naturaleza se expresan

habitualmente en forma de ecuaciones diferenciales. Las ecuaciones del
movimiento de los cuerpos (la segunda ley de Newton) es una ecuacin
diferencial de segundo orden, como lo es la ecuacin que describe los sistemas
oscilantes, la propagacin de las ondas, la transmisin del calor, la difusin, el
movimiento de partculas subatmicas, etc.
Pocas ecuaciones diferenciales tienen una solucin analtica sencilla, la mayor
parte de las veces es necesario realizar aproximaciones, estudiar el
comportamiento del sistema bajo ciertas condiciones. As, en un sistema tan
simple como un pndulo, la amplitud de la oscilacin ha de ser pequea y el
rozamiento ha de ser despreciable, para obtener una solucin sencilla que
describa aproximadamente su movimiento peridico.

Se estudia el procedimiento de Runge-Kutta que se aplica de forma directa a

una ecuacin diferencial de primer orden, pero veremos como se extiende a un
sistema de ecuaciones de primer orden, a un ecuacin diferencial de segundo
orden y a un sistema de ecuaciones diferenciales de segundo orden.
El procedimiento de Runge-Kutta se puede programar fcilmente en los
ordenadores y adems, se emplea mucho en la prctica, debido a la su
exactitud relativamente elevada de la solucin aproximada de la ecuacin
diferencial. La justificacin del procedimiento de Runge-Kutta no es sencilla,
el lector interesado puede consultar algn libro de mtodos numricos de
anlisis.
Mtodo de Euler

Vamos aresolver la ecuacin diferencial de primer orden

dxdt=f(t,x)

con con la condicin inicial de que en el instante t0 la posicin es x0

La primera derivada nos permite conocer la posicin xi+1 en el instante ti+1, a

partir de la posicin xi en el instante ti de acuerdo a la frmula siguiente. La
lnea de color rojo es la tangente a la curva en el instante ti
xi+1=xi+f(ti,xi)h
El procedimiento de Euler produce un error que se acumula a cada paso h de
integracin, que es el segmento en color azul que une los dos puntos en la
figura.
Escribimos una funcin denominada euler, a la que le pasaremos:

la funcin f(t,x),

la condicin inicial de que en el instante t0 la posicin es x0,

el instante final tf

el nmero de pasos de integracin n

y nos devolver un vector t y su correspondiente vector x.

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

Supongamos que queremos integrar la ecuacin diferencial

dxdt=cost

con las condicin inicial t=0, x=0.

x0=0tcostdtx=sint

Tomamos un intervalo h=/6, y construimos la siguiente tabla

dxdt=cost

x(Euler)

x=sint

/6

0.866

0.523

0.5

/3

0.5

0.977

0.866

/2

1.239

2/3

-0.5

1.239

0.866

5/6

-0.866

0.977

0.5

0.523

Esta tabla nos ilustra el modo de aplicar el mtodo de Euler a una ecuacin
diferencial de primer orden. Para aplicar el mtodo de Euler precisamos de un
paso h pequeo, incluso as los errores se van acumulando y al cabo de cierto
tiempo la diferencia entre el valor exacto y el calculado es grande.
Escribimos en script euler_script en el que definiremos la funcin f(t,x), las
condiciones iniciales y llamaremos a la funcin euler. Finalmente,
representaremos grficamente la solucin exacta y la obtenida aplicando el
mtodo de Euler
tf=input('tiempo final, tf: ');
n=input('nmero 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=cost')
hold off

En la ventana de comandos corremos el script euler_script

>> euler_script
tiempo final, tf: pi
nmero de pasos, n: 40

Hay diferencia entre la solucin exacta y la obtenida mediante integracin

numrica por el mtodo de Euler
Mtodo de Runge-Kutta

En esta seccin vamos a estudiar la aplicacin del mtodo de Runge-Kutta a:

Una ecuacin diferencial de primer orden

Un sistema de dos ecuaciones diferenciales de primer
orden
Una ecuacin difrencial de segundo orden
Un sistema de dos ecuaciones diferenciales de segundo
orden

Ecuacin diferencial de primer orden

Sea una ecuacin diferencial de primer orden, con la condicin inicial de que
en el instante t0 el valor inicial de xes x0
Se elige una anchura de paso h y se calculan cuatro nmeros k1, k2, k3, k4 de
acuerdo con el procedimiento esquematizado en la tabla adjunta. Segn 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 mediante la frmula que
figura en la ltima fila de dicha tabla.

dxdt=f(t,x)

k1=hf(t,x)k2=hf(t+12h,x+12k1)k3=hf(t+12h,x+12k2)k4=hf(t+h,x+k3)

x(t+h)=x(t)+16(k1+2k2+2k3+k4)

Definimos la funcin rk_1 que resuelve la ecuacin diferencial de primer

orden, cuando le pasamos:

la funcin f(t,x),
la condicin inicial de que en el instante t0el valor inicial
es x0,
el instante final tf
el nmero de pasos de integracin n comprendidos entre el
instante inical t0 y final tf.

y nos devolver un vector t y su correspondiente vector x.

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

Considrese el circuito en serie de la figura. Inicialmente el condensador est

descargado. Si se cierra el interruptor I la carga empieza a fluir produciendo
corriente en el circuito, el condensador se empieza a cargar. Una vez que el
condensador adquiere la carga mxima, la corriente cesa en el circuito.

Rdqdt=VqC0qdqCVq=1RC0tdtq=CV(1exp(tRC))

Escribimos el script carga para que realice las siguientes tareas:

1.

2.

Establezca, mediante comandos input:

o

La resistencia R del circuito

La capacidad C del condensador

El tiempo final, tf

el nmero de pasos, n.

Fije las condiciones iniciales, en el instante inicial t=0, el

condensador est descargado x=0.

3.

Defina la funcin f(t,x),

4.

Llame al procedimiento numrico rk_1

5.
6.

Mediante el comando plot realice una representacin

grfica de la solucin numrica
Realice una representacin grfica de la solucin exacta

Ejemplo: R=2.0, C=0.8, y tf=10.

V0=10;
R=input('Resistencia R: ');
C=input('Capacidad C: ');
tf=input('tiempo final, tf: ');
n=input('nmero 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

En la ventana de comandos corremos el script carga

>> carga
Resistencia R: 2
Capacidad C: 0.8
tiempo final, tf: 10
nmero de pasos, n: 50

No se aprecia diferencia entre la solucin exacta y la numrica, aplicando el

procedimiento de Runge_Kutta.
Sistema de dos ecuaciones diferenciales de primer orden

El procedimiento de Runge-Kutta es igualmente efectivo en la resolucin de

un sistema de dos ecuaciones diferenciales de primer orden.
dxdt=f(t,x,y)dydt=g(t,x,y)

El procedimiento de aplicacin del mtodo de Runge-Kutta a cada una de las

ecuaciones diferenciales, con las condicin inicial siguiente, en el instante t0

el valor inicial de x es x0

el valor inicial de y es y0

se esquematiza en la tabla adjunta. Como vemos adems de los cuatro

nmeros k1, k2, k3, k4 para la primera ecuacin diferencial precisamos otros
cuatro nmeros l1, l2, l3, l4 para la segunda ecuacin diferencial. A partir del
valor de x en el instante t, se determina el valor de x en el instante t+h, y a
partir del valor de y en el instante t se determina el valor de y en el
instante t+h mediante las frmulas de la ltima fila de la tabla.

dxdt=f(t,x,y)

dydt=g(t,x,y)

k1=hf(t,x,y)k2=hf(t+12h,x+12k1,y+1

l1=hg(t,x,y)l2=hg(t+12h,x+12k1,y+

l1,)k3=hf(t+12h,x+12k2,y+12l2)k4=hf

l1)l3=hg(t+12h,x+12k2,y+12l2)l4=hg

12

(t+h,x+k3,y+l3)

(t+h,x+k3,y+l3)

x(t+h)=x(t)+16(k1+2k2+2k3+k4)

y(t+h)=y(t)+16(l1+2l2+2l3+l4)

Definimos la funcin rk_2_1 que resuelve el sistema de dos ecuaciones

diferenciales de primer orden, cuando le pasamos:

las funciones f (t,x,y) y g(t,x,y)

las condiciones iniciales (x0,y0) en el instante t0

el nmero n de pasos de integracin entre t0 y el tiempo

final tf

Nos devuelve los vectores x e y para cada instante que se guarda en el

vector t comprendido entre el instante inicial t0 y el final tf.
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

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. Las ecuaciones diferenciales que gobiernan el proceso y sus
soluciones analticas son, respectivamente,
dxdt=axx=x0exp(at)dydt=axbyy=abax0(exp(at)exp(bt))

La solucin analtica que aparece a la derecha, se ha obtenido con las

condiciones iniciales t=0, x=x0 e y=0. La segunda solucin se obtiene siempre
que a sea distinto de b. En el caso de que a sea igual a b, la solucin analtica
para y es
y=x0aexp(at)

La interpretacin del sistema de ecuaciones diferenciales no es complicada. En

la unidad de tiempo, desaparecenax ncleos de la sustancia A al desintegrarse
(primera ecuacin). En la unidad de tiempo, se producen ax ncleos de la
sustancia B y a su vez desaparecen bx ncleos de la sustancia B, que al
desintegrarse se transforman en ncleos de la sustancia C estable (segunda
ecuacin).
Escribimos el script radioactivo en el que definiremos las
funciones f(t,x,y), g(t,x,y), las condiciones iniciales y llamaremos a la
funcin rk_2_1
a=input('parmetro a: ');
b=input('parmetro b: ');
x0=input('valor inicial de x: ');
y0=input('valor inicial de y: ');
tf=input('tiempo final, tf: ');

n=input('nmero 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 la ventana de comandos corremos el script radioactivo

>> radioactivo
parmetro a: 0.1
parmetro b: .2
valor inicial de x: 100
valor inicial de y: 0
tiempo final, tf: 10
nmero de pasos, n: 40

Ecuacin diferencial de segundo orden

Existen muchas situaciones en las que es necesario resolver una ecuacin

diferencial de segundo orden.
d2xdt2=f(t,x,v)

con las condiciones iniciales

x(t0)=x0(dxdt)t0=v0

Una ecuacin diferencial de segundo orden es equivalente a un sistema de dos

ecuaciones diferenciales de primer orden, por lo que aplicaremos el mismo
esquema.

dxdt=v

dvdt=f(t,x,v)

k1=hvk2=h(v+12l1)k3=

l1=hf(t,x,v)l2=hf(t+12h,x+12k1,v+12l1)l3=hf(t+12

h(v+12l2)k4=h(v+l3)

h,x+12k2,v+12l2)l4=hf(t+h,x+k3,v+l3)

x(t+h)=x(t)
+16(k1+2k2+2k3+k4)

v(t+h)=v(t)+16(l1+2l2+2l3+l4)

Definimos la funcin rk_2 que resuelve la ecuacin diferencial de segundo

orden, cuando le pasamos:

la funcin f (t,x,v)

las condiciones iniciales: posicin inicial x0 y velocidad

inicial v0 en el instante t0

el nmero n de pasos de integracin entre t0 y el tiempo

final tf

Nos devuelve los vectores de las posiciones x y las velocidades v para cada
instante que se guarda en el vector tcomprendido entre el instante inicial t0 y el
final tf.
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 element(i)os del
vect(i)or 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

La ecuacin diferencial que describe un oscilador armnico amortiguado y su

solucin para unas condiciones iniciales fijadas es
d2xdt2+2dxdt+20x=0=202x=exp(t)(Asin(t)

+Bcos(t))v=dxdt=exp(t)(Asin(t)+Bcos(t))+exp(t)(Acos(t)
Bsin(t))

Condiciones iniciales: en el instante t=0, la posicin inicial es x0 y la velocidad

inicial v0.
t=0{x0=Bv0=B+Ax=exp(t)(v0+x0sin(t)+x0cos(t))

Escribimos el script oscilador en el que definiremos la funcin f(t,x,v), las

condiciones iniciales y llamaremos a la funcin rk_2
w0=input('frecuencia angular w0: ');
g=input('rozamiento, gamma: ');
x0=input('posicin inicial, x0: ');
v0=input('velocidad inicial,v0: ');
tf=input('tiempo final, tf: ');
n=input('nmero de pasos, n: ');
f=@(t,x,v) -2*g*v-w0*w0*x;
%condiciones iniciales
t0=0;
hold on
%solucin numrica
[t,x,v]=rk_2(f,t0,tf,x0,v0,n);
plot(t,x,'b')
%solucin analtica
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
>> oscilador
frecuencia angular, w0: 2
rozamiento, gamma: 0.5
posicin inicial, x0: 1.5
velocidad inicial, v0: 0
tiempo final, tf: 8
nmero de pasos, n: 100

No se aprecia tampoco diferencia entre la solucin exacta y la numrica,

aplicando el procedimiento de Runge_Kutta.

Solucin numrica de ecuaciones diferenciales (II)

En esta pgina continuamos con el estudio de un sistema de dos ecuaciones

diferenciales de segundo orden por el procedimiento de Runge-Kutta
Sistema de dos ecuaciones diferenciales de segundo orden

El procedimiento numrico de Runge-Kutta puede aplicarse para resolver un

sistema de dos ecuaciones diferenciales de segundo orden.
d2xdt2=f(t,x,vx,y,vy)d2ydt2=g(t,x,vx,y,vy)

con las condiciones iniciales

x(t0)=x0(dxdt)t0=vx0y(t0)=y0(dydt)t0=vy0

Este sistema, se puede transformar en un sistema equivalente formado por

cuatro ecuaciones diferenciales de primer orden. Aplicando dos veces el
esquema descrito para una ecuacin diferencial de segundo orden, obtenemos
el esquema descrito en la siguiente tabla

dxdt=vx

dvxdt=f(t,x,vx,y,vy)

k1=hvxk2=h(vx+12l1)

l1=hf(t,x,vx,y,vy)l2=hf(t+12h,x+12k1,vx+12l1,y+12q1,vy+12m1)l3=h

k3=h(vx+12l2)k4=h(vx

f(t+12h,x+12k2,vx+12l2,y+12q2,vy+12m2)l4=hf(t+h,x+k3,vx+l3,y+q3,

+l3)

vy+m3)

x(t+h)=x(t)
+16(k1+2k2+2k3+k4)

dydt=vy

vx(t+h)=vx(t)+16(l1+2l2+2l3+l4)

dvydt=g(t,x,vx,y,vy)

q1=hvyq2=h(vy+12m1

m1=hg(t,x,vx,y,vy)m2=hg(t+12h,x+12k1,vx+12l1,y+12q1,vy+12m1)

)q3=h(vy+12m2)q4=h

m3=hg(t+12h,x+12k2,vx+12l2,y+12q2,vy+12m2)m4=hg(t+h,x+k3,vx

(vy+m3)

+l3,y+q3,vy+m3)

y(t+h)=y(t)
+16(q1+2q2+2q3+q4)

vy(t+h)=vy(t)+16(m1+2m2+2m3+m4)

Definimos la funcin rk_2_2 que resuelve el sistema de dos ecuaciones

diferenciales de segundo orden, cuando le pasamos:

las funciones f(t,x,vx,y,vy) y g(t,x,vx,y,vy)

las condiciones iniciales: posicin inicial (x0,y0) y velcidad

inicial (vx0,vy0) en el instante t0

el nmero n de pasos de integracin entreel instante

inicial t0 y el final tf

Nos devuelve los vectores posicin (x,y) y velocidad (vx,vy) para cada instante
que se guarda en el vector tcomprendido entre el instante inicial t0 y el final tf.
function [t,x,vx,y,vy]=rk_2_2(f,g,t0,tf,x0,vx0,y0,vy0,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);
vx=zeros(n+1,1);
vy=zeros(n+1,1);
x(1)=x0; vx(1)=vx0;
y(1)=y0; vy(1)=vy0;
for i=1:n
k1=h*vx(i);
l1=h*f(t(i),x(i),vx(i),y(i),vy(i));
q1=h*vy(i);
m1=h*g(t(i),x(i),vx(i),y(i),vy(i));
k2=h*(vx(i)+l1/2);
l2=h*f(t(i)+h/2,x(i)+k1/2,vx(i)+l1/2,y(i)+q1/2,vy(i)+m1/2);
q2=h*(vy(i)+m1/2);
m2=h*g(t(i)+h/2,x(i)+k1/2,vx(i)+l1/2,y(i)+q1/2,vy(i)+m1/2);

k3=h*(vx(i)+l2/2);
l3=h*f(t(i)+h/2,x(i)+k2/2,vx(i)+l2/2,y(i)+q2/2,vy(i)+m2/2);
q3=h*(vy(i)+m2/2);
m3=h*g(t(i)+h/2,x(i)+k2/2,vx(i)+l2/2,y(i)+q2/2,vy(i)+m2/2);
k4=h*(vx(i)+l3);
l4=h*f(t(i)+h,x(i)+k3,vx(i)+l3,y(i)+q3,vy(i)+m3);
q4=h*(vy(i)+m3);
m4=h*g(t(i)+h,x(i)+k3,vx(i)+l3,y(i)+q3,vy(i)+m3);
x(i+1)=x(i)+(k1+2*k2+2*k3+k4)/6;
vx(i+1)=vx(i)+(l1+2*l2+2*l3+l4)/6;
y(i+1)=y(i)+(q1+2*q2+2*q3+q4)/6;
vy(i+1)=vy(i)+(m1+2*m2+2*m3+m4)/6;
end
end

Uno de los ejemplos ms interesantes de resolucin de un sistema de

ecuaciones diferenciales de segundo orden es la descripcin del movimiento
de los cuerpos celestes, el cual tiene una solucin analtica sencilla en
coordenadas polares. La trayectoria seguida por un planeta es una cnica, una
elipse en particular, en uno de cuyos focos est el centro fijo de fuerzas, el Sol.
En la figura, se muestra la fuerza que ejerce el Sol sobre un planeta,
inversamente proporcional al cuadrado de las distancias que separan sus
centros y tambin, se muestran sus componentes rectangulares

Teniendo en cuenta que la fuerza que ejerce el Sol sobre un planeta viene
descrita por la ley de la Gravitacin Universal
F=GMmr2

donde M es la masa del Sol, m la masa del planeta y r la distancia entre el

centro del Sol y del planeta. Las componentes de la aceleracin del planeta
sern
ax=Fxm=Fcosm=GMr3xay=Fym=Fsinm=GMr3y

Uno de los problemas del tratamiento numrico con ordenador, es la de reducir

el problema a nmeros simples e inteligibles por el usuario de un vistazo. Las
masa de los planetas y del Sol son nmeros muy grandes: la masa de la Tierra
es 5.98 1024 kg., y 1.98 1030 kg. la del Sol. La distancia media entre la Tierra y
el Sol es tambin muy grande 1.49 1011 m, y la constante G es muy pequea
6.67 10-11 en el Sistema Internacional de Unidades.
Escalas

Antes de resolver el sistema de ecuaciones diferenciales por procedimientos

numricos, es conveniente prepararlas para que el ordenador no maneje
nmeros excesivamente grandes o pequeos.
Establecemos un sistema de unidades en el que la longitud se mide en
unidades astronmicas, la distancia media entre el Sol y la Tierra. L=una
UA=1.4961011 m y el tiempo en unidades de ao, P=un ao= 365.26
das=3.156107 s.
En el nuevo sistema de unidades x=Lx, t=Pt, la primera ecuacin diferencial
se escribe
d2xdt'2LP2=GM(x'2+y'2)3/2x'LL3d2xdt'2=GMP2L3x'(x'2+y'2)3/2

Como L es el semieje mayor de la rbita de la Tierra alrededor del Sol, P es el

periodo o tiempo que tarda en dar una vuelta completa, y M es la masa del Sol.
Por la tercera ley de Kepler, el trmino
GMP2L3=42

Volviendo a la notacin x e y para la posicin y t para el tiempo en el nuevo

sistema de unidades. El sistema de ecuaciones diferenciales se escribe
d2xdt2=42x(x2+y2)3/2d2ydt2=42y(x2+y2)3/2

Se resuelve por procedimientos numricos con las condiciones iniciales

siguientes: en el instante t=0, x=x0, y=0,vx=0, vy=v0y.
Principio de conservacin de la energa

La energa total de la partcula es una constante del movimiento. La energa de

la partcula de masa m en el instante inicial t=0 es
E0=12mv20GmMr0

Cuando E0<0 la partcula permanece confinada en el espacio que rodea a los

dos cuerpos. Cuando E00 la partcula escapa al infinito
La energa de la partcula en el instante t es igual a
E=12m(v2x+v2y)GmMx2+y2

En el nuevo sistema de unidades establecido

v=vL/P, x=xL, y=yL, d=dL
Em=12v'2L2P2GM1L1x'2+y'2Em=12v'2L2P242L2P21x'2+y'2e=EmP2L2=12v'2421x'2+y'2

Volviendo a la notacin previa. Definimos una nueva energa e por unidad de

masa en este sistema de unidades
e=12(v2x+v2y)421x2+y2

El programa evala el cociente

ee0e0100

que denominaremos tanto por ciento de error. Cuando la energa e difiere

apreciablemente de e0, la trayectoria calculada puede que se desve
significativamente de la real, y esto suele ocurrir cuando la partcula est muy
cerca del centro de fuerzas
Elaboramos el script orbita, para describir el movimiento de un cuerpo celeste.

x0=input('posicin inicial x: ');

vx0=input('velocidad incial x: ');
y0=0;
vy0=input('velocidad incial y: ');
tf=input('tiempo final, tf: ');
n=input('nmero de pasos, n: ');
f=@(t,x,vx,y,vy) -4*pi*pi*x/(sqrt(x*x+y*y))^3;
g=@(t,x,vx,y,vy) -4*pi*pi*y/(sqrt(x*x+y*y))^3;
%condiciones iniciales
t0=0;
e0=(vx0*vx0+vy0*vy0)/2-4*pi*pi/sqrt(x0*x0+y0*y0); %energa inicial
[t,x,vx,y,vy]=rk_2_2(f,g,t0,tf,x0,vx0,y0,vy0,n);
plot(x,y,'r')
xlabel('x')
ylabel('y');
title('rbita de un planeta')
%energa final
m=length(t);
ef=(vx(m)*vx(m)+vy(m)*vy(m))/2-4*pi*pi/sqrt(x(m)*x(m)+y(m)*y(m));
%error relativo
fprintf('Error en energia %1.4f\n',abs((ef-e0)/e0))

En la ventana de comandos corremos el script orbita

>> orbita
posicin inicial x: 1
velocidad incial x: 0
velocidad incial y: 6.27
tiempo final, tf: 1
nmero de pasos, n: 40
Error en energia 0.0000

Solucin numrica de ecuaciones diferenciales mediante ode45

MATLAB dispone de varias funciones para resolver mediante procedimientos

numricos ecuaciones diferenciales: ode23, ode45, ode113, etc, (vase en el
sistema de ayuda para qu tipos de problemas es ms adecuado cada uno de
los procedimientos). Eligiremos ode45 para resolver la mayor parte de los
problemas.
La funcin ode45

Su sintaxis es la siguiente
[t,x]=ode45(odefun,tspan,x0, options, params)

x es una matriz donde cada columna corresponde a las

variables dependientes y t es el vector tiempo.
odefun es el nombre de la funcin,
tspan especifica el intervalo de tiempo, un vector de dos
nmeros tspan=[ti,tf], tiempo inicial y final. Para obtener
valores de las variables dependientes en instantes
concretos t0, t1, t2, ... tn. se escribe tspan=[t0,t1....tn];
x0 es un vector que contiene los valores iniciales.

options es una estructura que se crea con la

funcin odeset, que explicaremos al final de esta pgina ya
que es un asunto bastante complicado.

params son parmetros que queremos pasar a la

funcin odefun

En la mayor parte de los ejemplos, utilizaremos los tres primeros parmetros:

llamaremos a la funcin ode45 y le pasaremos la funcin odefunc, los
instantes inicial y final en el vector tspan y las condiciones iniciales en el
vector x0.
Vamos a volver a resolver los problemas planteados en este captulo mediante
la funcin MATLAB ode45.
Ecuacin diferencial de primer orden

Elaboramos el script titulado carga_1 para integrar la ecuacin diferencial de

primer orden que describe la carga de un condensador.
dqdt=VRqRC
V0=10;
R=input('Resistencia R: ');
C=input('Capacidad C: ');
tf=input('tiempo final, tf: ');
f=@(t,x) V0/R-x/(R*C);
tspan=[0 tf];
x0=0;
[t,x]=ode45(f,tspan,x0);
plot(t,x,'r')
xlabel('t')

ylabel('q');
title('carga del condensador')

En la ventana de comandos corremos el script carga_1

>> carga_1
Resistencia R: 2
Capacidad C: 0.8
tiempo final, tf: 10

Sistema de dos ecuaciones diferenciales de primer orden

Elaboramos el script titulado radiactivo_1 para integrar el sistema de dos

ecuaciones diferenciales de primer orden que describe la serie de
desintagracin radioactiva. A-->B-->C donde C es un elemento estable.
{dxdt=axdydt=axby

En la matriz x que devuelve la funcin ode45, x(1) representar los sucesivos

valores de la variable x y x(2) representar a la variable y. El mismo criterio se
emplear para determinar el vector x0 de las condiciones iniciales.
La definicin de las funciones f (t,x,y) y g(t,x,y) aparecen en un vector
columna, separadas por ; (punto y coma)
fg=@(t,x) [-a*x(1);a*x(1)-b*x(2)]; % x(1) es x, x(2) es y

El script radiactivo_1 ser el siguiente:

a=input('parmetro a: ');
b=input('parmetro b: ');
%condiciones iniciales en el vector x0
x0=zeros(1,2);
x0(1)=input('valor inicial de x: ');
x0(2)=input('valor inicial de y: ');
tf=input('tiempo final, tf: ');
tspan=[0 tf];
fg=@(t,x) [-a*x(1);a*x(1)-b*x(2)];
[t,x]=ode45(fg,tspan,x0);
plot(t,x)
xlabel('t')
ylabel('x,y');

title('dx/dt=-ax, dy/dt=ax-by')

En la ventana de comandos corremos el script radiactivo_1

>> radioactivo_1
parmetro a: 0.1
parmetro b: 0.2
valor inicial de x: 100
valor inicial de y: 0
tiempo final, tf: 20

Alternativamente, vamos a definir las funciones f (t,x,y) y g(t,x,y) en un

fichero .M y le pasamos los valores de los parmetros a y b.
function z=func_radioactivo(t,x,a,b)
z=[-a*x(1);a*x(1)-b*x(2)]; % x(1) es x, x(2) es y
end

Elaboramos el script radioactivo_2 para establecer los valores de los

parmetros a y b, las condiciones iniciales y llamar a la funcin que realiza la
integracin numrica ode45. El primer parmetro de ode45 es el handler
(manejador de la funcin) a integrar que se especifica del siguiente modo
@nombre_funcion.
[t,x]=ode45(@func_radioactivo,tspan,x0);

Ahora bien, func_radioactivo precisa de los valores de los parmetros a y b.

Hay dos formas de hacerlo. La ms sencilla es definir una funcin
annima fg en trminos de func_radioactivo. En el problema 3 "Sistemas de
ecuaciones de Lorentz" describimos el segundo procedimiento.
fg=@(t,x) func_radioactivo_1(t,x,a,b);

Vase la misma situacin en la llamada a funcin fzero al final de la

pgina Races de una ecuacin
a=input('parmetro a: ');
b=input('parmetro b: ');
%condiciones iniciales
x0=zeros(1,2);
x0(1)=input('valor inicial de x: ');
x0(2)=input('valor inicial de y: ');
tf=input('tiempo final, tf: ');
tspan=[0 tf];
fg=@(t,x) func_radioactivo(t,x,a,b);
[t,x]=ode45(fg,tspan,x0);

plot(t,x)
xlabel('t')
ylabel('x,y');
title('dx/dt=-ax, dy/dt=ax-by')

En la ventana de comandos corremos el script radioactivo_2

>> radioactivo_2
parmetro a: 0.1
parmetro b: 0.2
valor inicial de x: 100
valor inicial de y: 0
tiempo final, tf: 20

Ecuacin diferencial de segundo orden

Una vez que se ha entendido como resolver un sistema de dos ecuaciones

diferenciales de primer orden es posible entender la resolucin de cualquier
ecuacin diferencial o sistema. Podemos definir las funciones de forma
annima o explcitamente en un fichero .M

dxdt=v

dvdt=f(t,x,v)

En este sistema de dos ecuaciones diferenciales de primer orden x(1)

representar los sucesivos valores de la variable x y x(2) representar a la
variable v. El mismo criterio se emplear para determinar el vector x0 de las
condiciones iniciales.
Como ejemplo, estudiamos las oscilaciones amortiguadas, que hemos descrito
en la pgina anterior.
d2xdt2+2dxdt+20x=0{dxdt=vdvdt=2v20x

Las funciones a integrar v, y f (t,x,v) aparecen en un vector columna, separadas

por ; (punto y coma)
f=@(t,x) [x(2);-2*g*x(2)-w0*w0*x(1)]; % x(1) es x, x(2) es v

Elaboramos el script oscilador_1 para resolver la ecuacin de segundo grado

que describe las oscilaciones amortiguadas
w0=input('frecuencia angular, w0: ');
g=input('rozamiento, gamma: ');
%condiciones iniciales
x0=zeros(1,2);
x0(1)=input('posicin inicial, x0: ');
x0(2)=input('velocidad inicial, v0: ');
tf=input('tiempo final, tf: ');
f=@(t,x) [x(2);-2*g*x(2)-w0*w0*x(1)];
tspan=[0 tf];
[t,x]=ode45(f,tspan,x0);
plot(t,x(:,1),'r')
grid on
xlabel('t')
ylabel('x');
title('oscilador amortiguado')

Si en el comando plot ponemos plot(t,x), se representa la posicin x(1) y la

velocidad x(2) en funcin del tiempo (en dos colores asignados por
MATLAB). Si solamente queremos representar la posicin x(1) en funcin del
tiempo t, se escribe plot(t,x(:,1)). Vase la pgina Vectores y matrices
En la ventana de comandos corremos el script oscilador_1
>> oscilador_1
frecuencia angular w0: 2
rozamiento, gamma: 0.5
posicin inicial, x0: 0
velocidad inicial,v0: 10
tiempo final, tf: 10

Sistema de dos ecuaciones diferenciales de segundo orden

En este caso tenemos un sistema de cuatro ecuaciones difrenciales de primer

orden

dxdt=vx

dvxdt=f(t,x,vx,y,vy)

dydt=vy

dvydt=g(t,x,vx,y,vy)

En este sistema x(1) representar los sucesivos valores de la variable x y x(2)

representar a la variable vx, x(3) a la variable y y x(4) a la variable vy. El
mismo criterio se emplear para determinar el vector x0 de las condiciones
iniciales.
Como ejemplo, estudiamos el movimiento de un planeta alrededor del Sol o de
un satlite artificial alrededor de la Tierra.
d2xdt2=42x(x2+y2)3/2dxdt=vxdvxdt=42x(x2+y2)3/2d2ydt2=42y(x2+y2)3/2

dydt=vydvydt=42y(x2+y2)3/2

Elaboramos el script orbita_1 para resolver el sistema de dos ecuaciones de

segundo grado que describe el movimiento de un cuerpo celeste.
%condiciones iniciales
x0=zeros(1,4);
x0(1)=input('posicin inicial x: ');
x0(2)=input('velocidad incial x: ');
x0(3)=0;
x0(4)=input('velocidad incial y: ');
tf=input('tiempo final, tf: ');
tspan=[0 tf];
fg=@(t,x)[x(2);-4*pi*pi*x(1)/(sqrt(x(1)*x(1)+x(3)*x(3)))^3; x(4);
-4*pi*pi*x(3)/(sqrt(x(1)*x(1)+x(3)*x(3)))^3];
[t,x]=ode45(fg,tspan,x0);
plot(x(:,1),x(:,3),'r')
xlabel('x')
ylabel('y');
title('rbita de un planeta')

En Figure Window representamos la trayectoria, es decir, los puntos de

abscisas x(1) que guardan los valores x y las ordenadas x(3) que guardan los
valores y, en funcin del tiempo t, se escribe plot(t,x(:,1),x(:,3)).
En la ventana de comandos corremos el script orbita_1
>> orbita_1
posicin inicial x: 1
velocidad incial x: 0
velocidad incial y: 6.27
tiempo final, tf: 1

Opciones de ode45

Imaginemos que estudiamos el movimiento de cada de un cuerpo, no sabemos

cuanto tiempo tardar en llegar al suelo, desconocemos el valor del
elemento tf en el vector tspan. Sin embargo, queremos detener el proceso de
integracin numrica de la ecuacin diferencial que describe el movimiento
cuando la posicin del mvil sea cero. La funcin MATLAB ode45 dispone de
un parmetro adicional options donde podemos indicarlo, pero es bastante
lioso e intentaremos explicarlo mediante ejemplos.
Volvemos a resolver la ecuacin diferencial que describe las oscilaciones
amortiguadas y detendremos el proceso de integracin cuando el mvil
alcance la posicin mxima, su velocidad es nula.
Supongamos que el oscilador amortiguado estudiado anteriormente, de
frecuencia natural 0=2, constante de amortiguamiento =0.25, parte de la
posicin x0=2.5 con velocidad nula, queremos detener el proceso de
integracin cuando el mvil alcance la posicin mxima, cuando su velocidad
es nula, tal como se muestra en la figura, con lo que se completa un periodo.

Los pasos a seguir son los siguientes:

1.-Definimos la funcin cuyo nombre es opcion_ode45
function [detect,stopin,direction]=opcion_ode45(t,x)
detect=[x(1) x(2)]; %[posicin, velocidad]
stopin=[0 1]; % 1 indice que detiene la integracin cuando la
velocidad se hace cero
direction=[0 -1]; % 1 crece, -1 decrece, 0 no importa
end

2.-Creamos la estructura opts con la llamada a la funcin odeset

opts=odeset('events',@opcion_ode45);
Cuando se utiliza options la funcin ode45 devuelve los tiempos te en los
cuales ocurren los 'eventos' y los correspondientes valores de las variables

dependientes (posicin, velocidad) en el vector xe. Finalmente, ie es un ndice

que es til cuando se vigilan varios eventos.
3.-Le pasamos opts a la funcin ode45 en su cuarto parmetro
[t,x,te,xe,ie]=ode45(odefunc,tspan,x0,opts);
Escribimos el script oscilador_2 para resolver la ecuacin diferencial de
segundo orden y detener el proceso de integracin de acuerdo con lo
estipulado en el parmetro opts.
w0=2;
g=0.25;
x0=[2.5 0];
tf=10;
f=@(t,x) [x(2);-2*g*x(2)-w0*w0*x(1)];
tspan=[0 10];
opts=odeset('events',@opcion_ode45);
[t,x,te,xe,ie]=ode45(f,tspan,x0,opts);
te,xe,ie
plot(t,x(:,1),'r')
grid on
xlabel('t')
ylabel('x');
title('oscilador amortiguado')

Cuando corremos el script oscilador_2 en la ventana de comandos se imprime

los siguientes datos relativos a los eventos.
Tiempo, Posicin
te
x(1)

Velocidad Indice
x(2)
ie

0.0000

2.5000

-0.0000

2.4378

0.0000

2.7173

3.1662

1.1322

-0.0000

Cuando parte de la posicin inicial x(1)=2.5 la velocidad es

cero x(2)=0, detecta velocidad (ndice ie=2).

Cuando pasa por el origen x(1)=0 detecta posicin

(ndice ie=1), pero no se detiene ya que en stopin se ha
puesto un cero.

Cuando la posicin es x(1)=1.1322 detecta velocidad

nula x(2)=0, (ndice ie=2) y la integracin numrica se
detiene ya que en stopin se ha puesto un uno y la velocidad
decrece en direction se ha puesto un -1.

La columna de tiempos nos porporciona el periodo de la oscilacin, te=3.1662.

Se sugiere al lector, cambiar en la funcin opcion_ode45
direction=[0 1];
Vamos ahora a marcar en la representacin grfica de la oscilacin
amortiguada, las posiciones de mxima amplitud x(2)=0 y cuando pasa por el
origen x(1)=0 sin detener el proceso de integracin numrica.

Definimos una nueva versin de la funcin opcion1_ode45

function [detect,stopin,direction]=opcion1_ode45(t,x)
detect=[x(1) x(2)]; %[posicin, velocidad]
stopin=[0 0];
direction=[0 0];
end

Creamos la estructura opts mediante odeset y se la pasamos al procedimiento

de integracin ode45.
w0=2;
g=0.25;
x0=[2.5 0];
tf=10;
f=@(t,x) [x(2);-2*g*x(2)-w0*w0*x(1)];
tspan=[0 7];
opts=odeset('events',@opcion1_ode45);
[t,x,te,xe,ie]=ode45(f,tspan,x0,opts);
hold on
plot(t,x(:,1),'r')
plot(te(ie==1),xe(ie==1),'o','markersize',6,'markerfacecolor','k')
plot(te(ie==2),xe(ie==2),'o','markersize',6,'markerfacecolor','b')
grid on
xlabel('t')
ylabel('x');
title('oscilador amortiguado')
hold off

Si solamente estamos interesados en los mximos definimos una nueva

versin de la funcin opcion2_ode45
function [detect,stopin,direction]=opcion2_ode45(t,x)
detect=x(2);
stopin=0;
direction=-1;
end

Modificamos el script oscilador_4

w0=2;
g=0.25;
x0=[2.5 0];
tf=10;
f=@(t,x) [x(2);-2*g*x(2)-w0*w0*x(1)];
tspan=[0 7];
opts=odeset('events',@opcion1_ode45);
[t,x,te,xe,ie]=ode45(f,tspan,x0,opts);
te,xe,ie
hold on
plot(t,x(:,1),'r')
plot(te(ie==1),xe(ie==1),'o','markersize',6,'markerfacecolor','b')
grid on
xlabel('t')

ylabel('x');
title('oscilador amortiguado')
hold off

Corremos el script oscilador_4 en la ventana de comandos y observamos los

resultados
Paso de parmetros a la funcin

Como hemos visto, a ode45 se le pasa la funcin (handle) a integrar en su

primer argumento. Si la funcin contiene parmetros como la frecuencia
angular 0, no hay problema si la funcin se define como annima, tal como
se ha mostrado en los ejemplos previos. Si la funcin se define en un fichero
entonces a la funcin se le pasan los valores de los parmetros en el quinto
argumento params de ode45. Los pasos se explican en el siguiente ejemplo:
El sistema de ecuaciones de Lorentz es un sistema de tres ecuaciones
diferenciales de primer orden
dxdt=x+ydydt=xyxzdzdt=z+xy

donde =10, =8/3 y =28

Vamos a resolver el sistema de tres ecuaciones diferenciales con las
condiciones iniciales siguientes: en el instante t=0, x0=-8, y0=8 z0=27.
1.

Escribir una funcin denominada lorentz(t,x,p) como

fichero.M que contenga las tres ecuaciones y dependa de los
tres parmetros =p(1), =p(2) y =p(3). Observar que la
variable x se guarda en el primer elemento x(1), la
variable y en el segundo x(2) y la variable z en el tercer x(3)
elemento del vector x.

2.

Escribir un script denominado lorentz_script que llame a la

funcin MATLAB ode45, para resolver el sistema de
ecuaciones diferenciales para las condiciones iniciales
especificadas.

3.

Pasar los parmetros , y como elementos de un

vector p a la funcin ode45 para que a su vez se los pase a la
funcin lorentz.

4.

Dibujar el atractor de Lorentz de z en funcin de x hasta el

instante tf=20 en una primera ventana grfica.

5.

Dibujar x, y y z en funcin del tiempo en tres zonas de una

segunda ventana grfica.

6.

Examinar el comportamiento del sistema para otras

condiciones iniciales, t=0, x0=1, y0=2 z0=3.

Definimos la funcin lorentz como fichero .M

function fg=lorentz(t,x,p)
%x(1) es x, x(2) es y y x(3) es z
% p(1) es sigma, p(2) es beta y p(3) es rho
fg=[-p(1)*x(1)+p(1)*x(2); p(3)*x(1)-x(2)-x(1)*x(3);
-p(2)*x(3)+x(1)*x(2)];
end

Elaboramos el script lorentz_script

x0=[-8 8 27]; %valores iniciales
tspan=[0 20];
p=[10 8/3 28]; %parmetros
%no pasamos nada [] en el parmetro options de ode45
[t,x]=ode45(@lorentz,tspan,x0,[],p);
figure
plot(x(:,1),x(:,3),'r')
xlabel('x')
ylabel('z');
title('Atractor de Lorentz')
figure
subplot(3,1,1)
plot(t,x(:,1))
ylabel('x');
subplot(3,1,2)
plot(t,x(:,2))
ylabel('y');
subplot(3,1,3)
plot(t,x(:,3))
ylabel('z');
xlabel('t')

En la ventana de comandos corremos el script lorentz_script

>> lorentz_script

Aparecen dos ventanas grficas, la primera con el atractor de Lorentz, la

representacin z(x) y la segunda ventana dividida en tres regiones que
muestran x(t), y(t) y z(t)

Interpolacin
En este captulo se estudia la interpolacin y la regresin.
La regresin es el ajuste de los datos experiementales a una funcin que
describe el modelo fsico particular. Por ejemplo, en un experiemento de
movimiento rectilneo uniforme, los datos experimentales (tiempo, posicin
del mvil) se ajustan a una lnea recta, ya que la ecuacin que describe el
movimiento rectilneo uniforme esx=x0+vt.
En la interpolacin la funcin pasa por todos los puntos.
Este pequeo programa muestra la diferencia
%datos experiementales
x=0.5:0.5:3;
y=[0.7,1.2,1.3,1.2,0.8,0.3];
hold on
plot(x,y,'ro','markersize',4,'markerfacecolor','r')
xx=linspace(0,3.1,100);
%regresin
p=polyfit(x,y,2); %polinomio de segundo grado
yy=polyval(p,xx);
plot(xx,yy,'b')
%interpolacin
yy=spline(x,y,xx);
plot(xx,yy,'r')
hold off
grid on
legend('datos','regresin','interpolacin')
xlabel('x')
ylabel('y');
title('Interpolacin, regresin')

En esta pgina, comenzamos el estudio de la interpolacin lineal, continuamos

por el mtodo de Lagrange, pero veremos que la interpolacin mediante
"splines" es mucho ms adecuada.

Interpolacin lineal
La interpolacin lineal es muy sencilla. Disponemos de pares de datos
(xk,yk) k=1,2...n. Queremos conocer el valor de y para un valor cualesquiera
de x en el intervalo x1 a xn. Supongamos que x est en el intervalo (xk,xk+1) tal
como se muestra en la figura. Trazamos la recta que pasa por los puntos ( xk,yk)
y (xk+1,yk+1), cuya ecuacin es
y=(xxk)yk+1(xxk+1)yk(xk+1xk)

Creamos la funcin interpola_lineal para obtener el valor de y cuando se

proporciona el valor de x.
function y0 = interpola_lineal(x,y,x0)
y0=zeros(length(x0),1);
for j=1:length(x0)
indice=find(x>x0(j));
k=indice(1)-1;
y0(j)=((x0(j)-x(k))*y(k+1)-(x0(j)-x(k+1))*y(k))/(x(k+1)-x(k));
end
end

Probamos la funcin para interpolar linealmente los siguientes pares de datos

(0,0), (/3, sin(/3)), (2/3, sin(2/3)),(, 0). Podemos comprobar que
obtenemos los mismos resultado utilizando la funcin MATLAB interp1,
pasndole la opcin linear en el ltimo parmetro.
x=[0,pi/3,2*pi/3,pi]; %datos
y=sin(x);
xx=0:pi/90:pi; %funcin
yy=sin(xx);
x0=[pi/6,pi/2,5*pi/6]; %interpolacin lineal
y0=interpola_lineal(x,y,x0);
%y0=interp1(x,y,x0,'linear'); %esta es una funcin MATLAB
hold on
plot(xx,yy,'b')
plot(x,y,'r')
plot(x,y,'bo','markersize',4,'markerfacecolor','b')
plot(x0,y0,'ro','markersize',6,'markerfacecolor','r')
hold off
xlabel('x');
ylabel('y')
title('Interpolacin lineal')

Discutiremos en la siguiente seccin, la interpolacin mediante un polinomio

de mayor grado. Podemos calcular los coeficientes de un polinomio de tercer
grado y=a1x3+a2x2+a3x+a4 que pase por los cuatro puntos. Obtenemos un
sistema de cuatro ecuaciones con cuatro incgnitas.
a1x31+a2x21+a3x1+a4=y1a1x32+a2x22+a3x2+a4=y2a1x
33+a2x23+a3x3+a4=y3a1x34+a2x24+a3x4+a4=y4x31x32x33x34x21x22x23x2
4x1x2x3x41111a1a2a3a4=y1y2y3y4

x=[0,pi/3,2*pi/3,pi]; %datos
y=sin(x);
xx=0:pi/90:pi; %funcin
yy=sin(xx);
x0=[pi/6,pi/2,5*pi/6]; %interpolacin lineal
A=vander(x);
p=A\y'; %coeficientes del polinomio
hold on
plot(xx,yy,'b') %datos y funcin
plot(x,y,'bo','markersize',4,'markerfacecolor','b')
yy=polyval(p,xx); %polinomio

plot(xx,yy,'r')
y0=polyval(p,x0); %valores interpolados
plot(x0,y0,'ro','markersize',6,'markerfacecolor','r')
hold off
xlabel('x');
ylabel('y')
title('Interpolacin con un polinomio de tercer gardo')

Interpolacin de Lagrange
Queremos encontrar los coeficientes de un polinomio de grado N
a1xN+a2xN-1+...+aNx+aN+1

que pase por todos los pares de datos (x1,y1), (x2,y2), ...(xN+1,yN+1). Los
coeficientes se pueden obtener resolviendo el sistema de ecuaciones:
a1xN1+a2xN11+aNx1+aN+1=y1a1xN2+a2xN12+aNx2+aN+1
=y2.....a1xNN+1+a2xN1N+1+aNxN+1+aN+1=yN+1

En forma matricial
xN1xN2...xNN+1xN11xN12...xN1N+1............x1x2...xN+111...1
a1a2...aN+1=y1y2...yN+1

Esta matriz se conoce con el nombre de Vandermonde y se construye con el

comando vander(x), como podemos leer en el sistema de ayuda de
MATLAB, A=vander(v) devuelve una matriz de Vandermonde cuyas columnas
son las potencias del vector v, esto es A(i,j)=v(i)^(n-j)
Sea la siguiente tabla de datos tomada de una experiencia
x 0.97 1.12 2.92 3.00 3.33 3.97 6.10 8.39 8.56 9.44
y 2.58 0.43 0.06 5.74 7.44 8.07 6.37 2.51 1.44 0.52

Cuando el nmero N+1 de datos es relativamente pequeo, las primeras

columnas de la matriz A pueden guardar nmeros muy grandes, los efectos del
redondeo pueden afectar al valor de los coeficientes ai del polinomio.
Los valores del polinomio se puede obtener tambin utilizando la
funcin polyfit que emplearemos ms adelante en el ajuste por el procedimiento
de mnimos cuadrados.
x=[0.97 1.12 2.92 3.00 3.33 3.97 6.10 8.39 8.56 9.44];
y=[2.58 0.43 0.06 5.74 7.44 8.07 6.37 2.51 1.44 0.52];
n=length(x); %nmero de pares de datos
%A=vander(x);
A=zeros(n); %lneas equivalentes a utilizar vander(x)
for j=1:n
A(:,j)=(x').^(n-j);
end
p=A\y'; %sistema de ecuaciones lineales, y' es vector columna
p=polyfit(x,y,n-1) %n-1 es el grado del polinomio
xx=linspace(0.97,9.44,50); %interpolacin
yy=polyval(p,xx);
hold on
plot(x,y,'o','markersize',4,'markerfacecolor','r')
plot(xx,yy,'b')
xlabel('x')
ylabel('y')
title('Interpolacin de Lagrange');
hold off

Corremos el script interpola-1 en la ventana de comandos, obtenemos un aviso,

los coeficientes del polinomio y la representacin grfica de los datos y del
polinomio que pasa por dichos puntos.
Warning: Polynomial is badly conditioned.
p = 1.0e+004 *

0.0000
-5.2142
3.9256

-0.0003

0.0057

-0.0595

0.3782

-1.4951

3.6430

-1.1823

Un polinomio de Lagrange LN(x) de grado N es la expresin

LN(x)=(xx2)(xx3)...(xxN+1)(x1x2)(x1x3)...(x1xN+1)y1+(xx1)(xx3)...(xxN+1)(x2x1)(x2x3)...
(x2xN+1)y2+...+(xx1)(xx2)...(xxN)(xN+1x1)(xN+1x2)...(xN+1xN)yN+1

Como puede probarse fcilmente este polinomio pasa por todos los puntos
(xi,yi).
Podemos elaborar una funcin denominada lagrange_3 que devuelva el valor
interpolado yy de xx cuando se le pasa los vectores x e y que guardan las
abscisas y ordenadas (xi,yi) de los datos
function yy = lagrange_3(x,y,xx)
n = length(x);
for i=1:n
w(i)=prod(xx-x([1:i-1 i+1:n]))*y(i)/prod( x(i)-x([1:i-1 i+1:n]) )
;

end
yy=sum(w);
end

Llamamos a la funcin lagrange_3 para conocer los valores interpolados

de xx=1.0 y xx=2.0
>>
>>
>>
yy
>>
yy

x=[0.97 1.12 2.92 3.00 3.33 3.97 6.10 8.39 8.56 9.44];
y=[2.58 0.43 0.06 5.74 7.44 8.07 6.37 2.51 1.44 0.52];
yy=lagrange_3(x,y,1.0)
=
10.0725
yy=lagrange_3(x,y,2.0)
= -203.7000

Alternativamente, podemos elaborar una funcin denominada lagrange_p que

devuelva los coeficientes del polinomio. El polinomio de Lagrange es la suma
de N+1 trminos. El numerador de cada trmino es el producto de N binomios
(x-xi)
function p=lagrange_p(x,y)
n=length(x); %n-1 es el grado del polinomio
if length(y)~=n
error('x e y tienen que tener la misma longitud')
end
p=zeros(1,n);
for i=1:n
pol=[y(i)];
for j=1:n
if(i~=j)
pol=conv([1 -x(j)],pol)/(x(i)-x(j)); %multiplica un
polinomio por un binomio
end
end
p=p+pol;
end
end

Para obtener el producto de los binomios del numerador de cada trmino,

utilizamos la funcin conv, vase la pgina Polinomios. Por ejemplo, queremos
multiplicar los polinomios p1=x3-2x-4 y p2=x2+3x+4
>> p1=[1 0 -2 -4];
>> p2=[1 3 4];
>> p=conv(p1,p2)
p =
1
3

-10

-20

-16

Utilizamos la funcin lagrange_p para obtener los coeficientes del polinomio

de Lagrange con los datos del ejemplo anterior.
>> x=[0.97 1.12 2.92 3.00 3.33 3.97 6.10 8.39 8.56 9.44];
>> y=[2.58 0.43 0.06 5.74 7.44 8.07 6.37 2.51 1.44 0.52];
>> p=lagrange_p(x,y)
p = 1.0e+004 *

0.0000
-0.0003
0.0057
-5.2142
3.9256
-1.1823

-0.0595

0.3782

-1.4951

3.6430

Obtenemos el mismo resultado, que resolviendo el sistema de N+1 ecuaciones

lineales.
Una vez obtenido el polinomio de Lagrange podemos calcular el valor
de y para valores de x que no estn en la tabla.
>> xx=[1.0 2.0 3.5];
>> yy=polyval(p,xx)
yy =
10.0725 -203.7000

1.8338

Para estos datos, la interpolacin de Lagrange parece que no produce buenos

resultados

Splines
Vamos a explicar mediante un ejemplo el procedimiento de interpolacin
denominado "splines", para generalizarlo despus a cualquier conjunto de
pares de datos.

Dado el conjunto de pares de datos (x1,y1), (x2,y2), (x3,y3), (x4,y4), (x5,y5) puntos
de color rojo en la fihgura. Definimos la funcin S(x)
S(x)=s1(x)x1x<x2s2(x)x2x<x3s3(x)
x3x<x4s4(x)x4x<x5si(x)=ai(xxi)3+bi(xxi)2+ci(xxi)+dii=1,2,3,4

Cada una de las funciones si(x) en color azul en la figura, es un polinomio de

tercer grado, cuya primera y segunda derivada es
dsidx=3ai(xxi)2+2bi(xxi)+cid2sidx2=6ai(xxi)+2bii=1,2,3,4

Para calcular las 44=16 incgnitas a1,a2,a3,a4, b1,b2,b3,b4, c1,c2,c3,c4, d1,d2,d3,d4,

se imponen las siguientes condiciones:
1.

La funcin S(x) pasa por todos los puntos (xi,yi) i=1,2,3,4,5

si(xi)=yid1=y1d2=y2d3=y3d4=y4a4(x5x4)3

2.

+b4(x5x4)2+c4(x5x4)+d4=y5
La funcin S(x) es continua en x2, x3, x4.
si1(xi)=si(xi)a1(x2x1)3+b1(x2x1)2+c1(x2x1)+d1=d2a2(x
3x2)3+b2(x3x2)2+c2(x3x2)+d2=d3a3(x4x3)3+b3(x4x3)2+c3(x4x3)

+d3=d4

3.

La derivada primera de la funcin S(x) es continua en x2, x3, x4.

s'i1(xi)=s'i(xi)3a1(x2x1)2+2b1(x2x1)+c1=c23a2(x3x2)2+

2b2(x3x2)+c2=c33a3(x4x3)2+2b3(x4x3)+c3=c4
4.
Denominamos m1, m2, m3, m4, m5 al valor de la derivada segunda de si(x) en
los puntos x1, x2, x3, x4, x5.
s''i(xi)=mi2b1=m12b2=m22b3=m32b4=m46a4(
x5x4)+2b4=m5

5.

La derivada segunda de S(x) es continua en los puntos x2, x3, x4

s''i1(xi)=s''i(xi)6a1(x2x1)+2b1=2b26a2(x3x2)+2b2=2b36a3(x
4x3)+2b3=2b4

Supongamos que el espaciado entre dos puntos consecutivos es constante h=xixi-1, i=2,3,4,5.
Vamos a expresar las incgnitas a1,a2,a3,a4, b1,b2,b3,b4, c1,c2,c3,c4, d1,d2,d3,d4, en
trminos de h, el valor de las ordenadas yi y el valor de la derivada segunda
de S(x), mi en cada punto xi, i=1,2,3,4,5.
De (4) y (5) expresamos a1,a2, a3, a4 en trminos de m1, m2, m3, m4, m5.
a1=m2m16ha2=m3m26ha3=m4m36ha4=m5m46h

Teniendo en cuenta (1) y (4), las ecuaciones (2) se expresan

m2m16hh3+m12h2+c1h+y1=y2m3m26hh3+m22h2+c2h+y2=y3m4m36h
h3+m32h2+c3h+y3=y4

Que nos permite despejar c1, c2, c3 en trminos de m1, m2, m3, m4, y1, y2, y3, y4

c1=y2y1hm2+2m16hc2=y3y2hm3+2m26hc3=y4y3hm4+2m36h

La ltima ecuacin de (1) nos permite despejar c4

m5m46hh3+m42h2+c4h+y4=y5c4=y5y4hm5+2m46h

Las ecuaciones (3) se expresan

3m2m16hh2+m1h+y2y1hm2+2m16h=y3y2hm3+2m26h3m3m26hh2
+m2h+y3y2hm3+2m26h=y4y3hm4+2m36h3m4m36hh2+m3h+y4y3hm4+2m36h=y5
y4hm5+2m46hm1+4m2+m3=6h2(y12y2+y3)m2+4m3+m4

=6h2(y22y3+y4)m3+4m4+m5=6h2(y32y4+y5)

Tenemos tres ecuaciones y cinco incgnitas m1, m2, m3, m4, m5

Fijamos los valores de la derivada segunda m1 y m5 en los puntos extremos.
Supongamos que m1=0 y m5=0.
Hay otras posibilidades que se pueden consultar en el
documentohttp://online.redwoods.edu/instruct/darnold/laproj/Fall98/SkyMeg/
Proj.PDF
Despejamos m2, m3, m4 del sistema de tres ecuaciones
m1+4m2+m3=6h2(y12y2+y3)m2+4m3+m4=6h2(y22y3+
y4)m3+4m4+m5=6h2(y32y4+y5)410141014m2m3m4=6h2y1
2y2+y3y22y3+y4y32y4+y5

Caso general
En general, con n pares de datos tendremos el sistema
4100....01410...00141...00014.....................10000...4
m2m3m4m5...mn1=6h2y12y2+y3y22y3+y4y
32y4+y5y42y5+y6....yn22yn1+yn

Fijamos los valores de los extremos del vector de las incgnitas m: m1=0, mn1=0, a continuacin, obtenemos mediante el operador divisin por la izquierda
los valores de m2, m3, ...mn-2, finalmente, se calculan:

los coeficientes a1,a2,a3,...an-1.

a1=m2m16ha2=m3m26ha3=m4m36h.... an1=mnmn16h

los coeficientes b1,b2,b3,...bn-1.

b1=m12b2=m22b3=m32.... bn1=mn12

los coeficientes c1,c2,c3,...cn-1.

c1=y2y1hm2+2m16hc2=y3y2hm3+2m26hc3=y4y3hm4+2m36h.....cn1=ynyn1hmn
+2mn16h

los coeficientes d1,d2,d3,...dn-1.

d1=y1d2=y2d3=y3.... dn1=yn1

Codificacin
En primer lugar, vamos a entender como trabaja la funcin diag de MATLAB.
La funcin diag extrae vectores diagonales de la matriz A.
>> A=[1,2,3;4,5,6;7,8,9]
A =
1
2
3
4
5
6
7
8
9
>> diag(A) %diagonal principal
ans =
1
5
9
>> diag(A,1) %diagonal superior
ans =
2
6
>> diag(A,-1) %diagonal inferior
ans =
4
8

La funcin diag nos permite crear una matriz a partir de los vectores de sus
diagonales
A=diag(4*ones(3,1))+diag(ones(2,1),1)+diag(ones(2,1),-1)
A =
4
1
0
1
4
1
0
1
4

La funcin diff calcula la diferencia entre dos elementos consecutivos del

vector y
y=[y1,y2,y3,y4,y5]d1=dif(y)=[y2y1,y3y2,y4y3,y5y4]d2=dif(d1)=[y32y
2y1,y42y3y2,y52y4y3]

El vector de los trminos independientes se calcula aplicando dos veces la

funcin diff al vector y de las ordenadas.
Estamos en condiciones de crear un script que calcule las
incgnitas m2, m3, ... mn-1, aplicando el operador divisin por la izquierda.
x=-4:4;
y=sin(x)./(1+x.^2);
h=x(2)-x(1); %espaciado constante
n=length(x); %nmero de pares de datos
A=diag(4*ones(n-2,1))+diag(ones(n-3,1),1)+diag(ones(n-3,1),-1); %matriz
de dimensin n-2
s=diff(diff(y))*6/h^2; %vector de los trminos indpendientes
mm=A\s'; %vector de las incgnitas
m=[0;mm;0]; %ceros en los extremos
for i=1:n-1
a(i)=(m(i+1)-m(i))/(6*h);
b(i)=m(i)/2;
c(i)=(y(i+1)-y(i))/h-(m(i+1)+2*m(i))*h/6;
d(i)=y(i);
end
%dibuja los puntos
hold on
plot(x,y,'o','markersize',4,'markeredgecolor','b','markerfacecolor','b')
for i=1:n-1
xx=x(i):h/50:x(i+1);
yy=a(i)*(xx-x(i)).^3+b(i)*(xx-x(i)).^2+c(i)*(xx-x(i))+d(i);
plot(xx,yy,'r')
end
xx=linspace(-4,4,300); %funcin
yy=sin(xx)./(1+xx.^2);;
plot(xx,yy,'g')
hold off
grid on
xlabel('x')
ylabel('y')
title('Interpolacin por splines')

Si superponemos la funcin (en color verde)

y=sin(x)x2+1

con los nueve puntos unidos mediante polinomios de tercer grado (en color
rojo) veremos que la curva interpolada y la exacta estn prximas.

Los puntos de color azul, son los nueve pares de datos, cada una de las curvas
de color rojo entre dos puntos azules consecutivos es un polinomio de tercer
grado que pasa por dichos puntos y cumple las condiciones de continuidad de
su derivada primera y segunda.

Comparacin
Funcin spline de MATLAB
Utilizamos la funcin spline de MATLAB, pero es posible que las condiciones
en los extremos que en el ejemplo anterior se han establecido en m1=0, mn-1=0,
sean ahora diferentes.
x=-4:4;
y=sin(x)./(1+x.^2);
%dibuja los puntos
hold on
plot(x,y,'o','markersize',4,'markeredgecolor','b','markerfacecolor','b')

xx=linspace(-4,4,300);
yy=spline(x,y,xx); %interpolacin
plot(xx,yy, 'r')
yy=sin(xx)./(1+xx.^2);
plot(xx,yy,'g') %funcin
hold off
grid on
xlabel('x')
ylabel('y')
title('Interpolacin por splines de MATLAB')

Interplacin de Lagrange
Ahora interpolamos mediante un polinomio de grado n-1 que pasa por los
nueve puntos (xi,yi) del ejemplo anterior
x=-4:4;
y=sin(x)./(1+x.^2);
%dibuja los puntos
hold on

plot(x,y,'o','markersize',4,'markeredgecolor','b','markerfacecolor','b')
n=length(x);
p=polyfit(x,y,n-1); %polinomio que pasa por los puntos
%p=lagrange_p(x,y); %se obtiene el mismo resultado
xx=linspace(-4,4,300); %superposicin de la curva
yy=polyval(p,xx);
plot(xx,yy, 'r')
yy=sin(xx)./(1+xx.^2);
plot(xx,yy,'g')
hold off
grid on
xlabel('x')
ylabel('y')
title('Interpolacin por Lagrange')

El resultado deja mucho que desear principalmente, en el primer y ltimo

intervalo.

Aproximacin de funciones

Muchas funciones matemticas tales como sin(x), exp(x), se pueden representar

cerca de x=0 por un desarrollo en serie de Taylor. Si el desarrollo en serie
converge rpidamente, tomando los primeros trminos se puede aproximar la
funcin f(x) por un polinomio de grado n no muy elevado.
Tomamos n valores de la funcin yi=f(xi) con i=1...n. y determinamos el
polinomio de grado n-1 que pasa a travs de los puntos (xi,yi). Sea la funcin
y=1x2+1

Tomamos diez abscisas xi espaciadas 0.8 en el intervalo [-4,4]. Representamos

la funcin (en color rojo), los puntos (xi,yi) y el polinomio que pasa por dichos
puntos (en color azul). Dado que la funcin es simtrica solamente
representamos la parte positiva.
f=@(x) 1./(x.^2+1);
n=10;
a=-4;
b=4;
xx=linspace(a,b,n+1);
yy=f(xx);
p=polyfit(xx,yy,n);
x1=linspace(0,b,100);
y1=polyval(p,x1) %aproximacin mediante el polinomio p
y2=f(x1);
%funcin
hold on
plot(x1,y1,'b')
plot(x1,y2,'r')
plot(xx(xx>=0),yy(xx>=0),'ro','markersize',2,'markerfacecolor','r')
hold off
xlabel('x')
ylabel('y')
title('Interpolacin de una funcin')

Sorprendentemente, si los puntos no estn igualmente espaciados, podemos

obtener una mejor aproximacin. Si tomamos los puntos en el intervalo [ a,b]
espaciados de acuerdo a la frmula denominada puntos de Chebyshev, que se
estudiar en la prxima pgina.
xi=a+b2+ab2cos(n(i12))1in

La funcin linspace, nos crea un vector de abscisas xi igualmente espaciados

entre a y b. La funcin que hemos denominado lincheby crea un vector de
abscisas xi, espaciados de acuerdo a la frmula anterior.
f=@(x) 1./(x.^2+1);
lincheby=@(a,b,n) (a+b)/2+(a-b)/2*cos(pi/n*(1/2:n));
n=10;
a=-4;
b=4;
xx=lincheby(a,b,n+1);
yy=f(xx);

p=polyfit(xx,yy,n);
x1=linspace(0,b,100);
y1=polyval(p,x1); %aproximacin mediante el polinomio p
y2=f(x1);
%funcin
hold on
plot(x1,y1,'b')
plot(x1,y2,'r')
plot(xx(xx>=0),yy(xx>=0),'ro','markersize',2,'markerfacecolor','r')
hold off
xlabel('x')
ylabel('y')
title('Interpolacin de una funcin')

Como podemos apreciar la mejora es importante