Inicio

Inicio
MATLAB
Numrico
Races de ecuaciones
Sistemas de ecuaciones
Valores y vectores propios
Integracin numrica
Ecuaciones diferenciales
Interpolacin, regresin

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 t
0
la
posicin es x
0

La primera derivada nos permite conocer la
posicin x
i+1
en el instante t
i+1
, a partir de la
posicin x
i
en el instante t
i
de acuerdo a la frmula
siguiente. La lnea de color rojo es la tangente a la
curva en el instante t
i

x
i+1
=x
i
+f(t
i
,x
i
)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 t
0
la posicin
es x
0
,
el instante final t
f

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
t dxdt=cost x(Euler) x=sin t
0 1 0 0
/6 0.866 0.523 0.5
/3 0.5 0.977 0.866
/2 0 1.239 1
2/3 -0.5 1.239 0.866
5/6 -0.866 0.977 0.5
0.523 0
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 t
0
el valor inicial
de x es x
0

Se elige una anchura de paso h y se calculan cuatro
nmeros k
1
, k
2
, k
3
, k
4
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 instantet 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 t
0
el valor
inicial es x
0
,
el instante final t
f

el nmero de pasos de integracin n comprendidos
entre el instante inical t
0
y final t
f
.
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=1RC0tdt
q=CV(1exp(tRC))
Escribimos el script carga para que realice las
siguientes tareas:
1. Establezca, mediante comandos input:
o La resistencia R del circuito
o La capacidad C del condensador
o El tiempo final, tf
o el nmero de pasos, n.
2. 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. Mediante el comando plot realice una representacin
grfica de la solucin numrica
6. 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: ');

f=@(t,x) V0/R-x/(R*C);
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','Southe
ast')
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

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 t
0

el valor inicial de x es x
0

el valor inicial de y es y
0

se esquematiza en la tabla adjunta. Como vemos
adems de los cuatro nmeros k
1
, k
2
, k
3
, k
4
para la
primera ecuacin diferencial precisamos otros cuatro
nmeros l
1
, l
2
, l
3
, l
4
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 dey 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+12l1,)k3=hf(t+12h,x+12k2,y+12l2)k4=hf(t+h,x+k3,y+l3) l1=hg(t,x,y)l2=hg(t+12h,x+12k1,y+12l1)l3=hg(t+12h,x+12k2,y+12l2)l4=hg(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 (x
0
,y
0
) en el instante t
0

el nmero n de pasos de integracin entre t
0
y el
tiempo final t
f

Nos devuelve los vectores x e y para cada instante que
se guarda en el vector t comprendido entre el instante
inicial t
0
y el final t
f
.
function [t,x,y] =rk_2_1(f,g,t0,tf,x0,y0,n)
h=(tf-t0)/n;
t=t0:h:tf;
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=ax x=x0exp(at)dydt=axby
y=abax0(exp(at)exp(bt))
La solucin analtica que aparece a la derecha, se ha
obtenido con las condiciones iniciales t=0, x=x
0
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 yes
y=x0aexp(at)
La interpretacin del sistema de ecuaciones
diferenciales no es complicada. En la unidad de
tiempo, desaparecen axncleos 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: ');
f=@(t,x,y) -a*x;
g=@(t,x,y) a*x-b*y;
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
script radioactivo
>> radioactivo
parmetro a: 0.1
parmetro b: .2
valor inicial de x: 100
valor inicial de y: 0

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=h(v+12l2)k4=h(v+l3) l1=hf(t,x,v)l2=hf(t+12h,x+12k1,v+12l1)l3=hf(t+12h,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 x
0
y
velocidad inicial v
0
en el instante t
0

el nmero n de pasos de integracin entre t
0
y el
tiempo final t
f

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 t
0
y el
final t
f
.
function [t,x,v] =rk_2(f,t0,tf,x0,v0,n)
h=(tf-t0)/n;
t=t0:h:tf;
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 x
0
y la velocidad inicial v
0
.
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 funcinrk_2
w0=input('frecuencia angular w0: ');
g=input('rozamiento, gamma: ');
x0=input('posicin inicial, x0: ');
v0=input('velocidad inicial,v0: ');
f=@(t,x,v) -2*g*v-w0*w0*x;
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
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

No se aprecia tampoco diferencia entre la solucin
exacta y la numrica, aplicando el procedimiento de
Runge_Kutta.

Energas Renovables EUITI de Eibar

Inicio
MATLAB
Numrico
Races de ecuaciones
Integracin numrica

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=vx0 y(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)k3=h(vx+12l2)k4=h(vx+l3) l1=hf(t,x,vx,y,vy)l2=hf(t+12h,x+12k1,vx+12l1,y+12q1,vy+12m1)l3=hf(t+12h,x+12k2,vx+12l2,y+12q2,vy+12m2)l4=hf(t+h,x+k3,vx+l3,y+q3,vy+m3)
x(t+h)=x(t)+16(k1+2k2+2k3+k4) vx(t+h)=vx(t)+16(l1+2l2+2l3+l4)
dydt=vy dvydt=g(t,x,vx,y,vy)
q1=hvyq2=h(vy+12m1)q3=h(vy+12m2)q4=h(vy+m3) m1=hg(t,x,vx,y,vy)m2=hg(t+12h,x+12k1,vx+12l1,y+12q1,vy+12m1)m3=hg(t+12h,x+12k2,vx+12l2,y+12q2,vy+12m2)m4=hg(t+h,x+k3,vx+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,v
x
,y,v
y
) y g(t,x,v
x
,y,v
y
)
las condiciones iniciales: posicin inicial (x
0
,y
0
) y
velcidad inicial (v
x0
,v
y0
) en el instante t
0

el nmero n de pasos de integracin entreel instante
inicial t
0
y el final t
f

Nos devuelve los vectores posicin (x,y) y velocidad
(v
x
,v
y
) para cada instante que se guarda en el
vector tcomprendido entre el instante inicial t
0
y el
final t
f
.
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;
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 ladescripcin 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 10
24
kg., y 1.98
10
30
kg. la del Sol. La distancia media entre la Tierra y
el Sol es tambin muy grande 1.49 10
11
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.496 10
11
m y el tiempo en unidades de
ao, P=un ao= 365.26 das=3.156 10
7
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=x
0
, y=0, v
x
=0,v
y
=v
0y
.
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 inicialt=0 es
E0=12mv20GmMr0
Cuando E
0
<0 la partcula permanece confinada en el
espacio que rodea a los dos cuerpos. Cuando E
0
0 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'2L2P242
L2P21x'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 e
0
, 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: ');

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;
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
Error en energia 0.0000


Inicio
MATLAB
Numrico
Races de ecuaciones
Integracin numrica
Ejercicios

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 t
0
, t
1
, t
2
, ... t
n
. 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: ');
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
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:
%condiciones iniciales en el vector x0
x0=zeros(1,2);
x0(1)=input('valor inicial de x: ');
x0(2)=input('valor inicial de y: ');

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');
script radiactivo_1
>> radioactivo_1
parmetro a: 0.1
parmetro b: 0.2
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
x0=zeros(1,2);
x0(1)=input('valor inicial de x: ');
x0(2)=input('valor inicial de y: ');
tspan=[0 tf];
fg=@(t,x) func_radioactivo(t,x,a,b);
plot(t,x)
xlabel('t')
ylabel('x,y');
script radioactivo_2
>> radioactivo_2
parmetro a: 0.1
parmetro b: 0.2
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 xy 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: ');
x0=zeros(1,2);
x0(1)=input('posicin inicial, x0: ');
x0(2)=input('velocidad inicial, v0: ');

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');
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
script oscilador_1
>> oscilador_1
frecuencia angular w0: 2
rozamiento, gamma: 0.5
posicin inicial, x0: 0
velocidad inicial,v0: 10
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 v
x
, x(3)
a la variable y y x(4) a la variable v
y
. 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/2
dxdt=vxdvxdt=42x(x2+y2)3/2d2ydt2=42y(x
2+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.
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: ');

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];
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 x
0
=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');
Cuando corremos el script oscilador_2 en la ventana
de comandos se imprime los siguientes datos relativos
a los eventos.
Tiempo, te Posicin x(1) Velocidad x(2) Indice ie
0.0000 2.5000 -0.0000 2
2.4378 0.0000 2.7173 1
3.1662 1.1322 -0.0000 2
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
amplitudx(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);

hold on
plot(t,x(:,1),'r')
plot(te(ie==1),xe(ie==1),'o','markersize',6,'ma
rkerfacecolor','k')
rkerfacecolor','b')
grid on
xlabel('t')
ylabel('x');
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);
te,xe,ie
hold on
plot(t,x(:,1),'r')
rkerfacecolor','b')
grid on
xlabel('t')
ylabel('x');
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,x
0
=-8, y
0
=8 z
0
=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 t
f
=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, x
0
=1, y
0
=2 z
0
=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')
script lorentz_script
>> lorentz_script

Inicio
MATLAB
Numrico
Races de ecuaciones
Integracin numrica

Ajuste de datos
En esta pgina, estudiaremos la regresin lineal, es
decir la determinacin de la ecuacin de la recta que
mejor ajusta a una distribucin bidimensional de datos.
Se explicar el mtodo de los mnimos cuadrados para
aproximar un polinomio a un conjunto de datos
experimentales.
Regresin lineal
http://www.sc.ehu.es/sbweb/fisica_/cinematica/rectilin
eo/regresion/regresion.html
Abordaremos en esta pgina las distribuciones
bidimensionales. Las observaciones se dispondrn en
dos columnas, de modo que en cada fila figuren la
abscisa x y su correspondiente ordenada y. La
importancia de las distribuciones bidimensionales
radica en investigar como influye una variable sobre la
otra. Esta puede ser una dependencia causa efecto, por
ejemplo, la cantidad de lluvia (causa), da lugar a un
aumento de la produccin agrcola (efecto). O bien, el
aumento del precio de un bien, da lugar a una
disminucin de la cantidad demandada del mismo.
Si utilizamos un sistema de coordenadas cartesianas
para representar la distribucin bidimensional,
obtendremos un conjunto de puntos conocido con el
diagrama de dispersin, cuyo anlisis permite estudiar
cualitativamente, la relacin entre ambas variables. El
siguiente paso, es la determinacin de la dependencia
funcional entre las dos variables x e y que mejor ajusta
a la distribucin bidimensional. Se denomina regresin
lineal cuando la funcin es lineal, es decir, requiere la
determinacin de dos parmetros: la pendiente y la
ordenada en el origen de la recta de
regresin, y=ax+b.
La regresin nos permite adems, determinar el grado
de dependencia de las series de valores X e Y,
prediciendo el valor y estimado que se obtendra para
un valor x que no est en la distribucin.
Vamos a determinar la ecuacin de la recta que mejor
ajusta a los datos representados en la figura. Se
denomina error
i
a la diferencia y
i
-y, entre el valor
observado y
i
, y el valor ajustado y= ax
i
+b, tal como se
ve en la figura inferior. El criterio de ajuste se toma
como aqul en el que la desviacin cuadrtica media
sea mnima, es decir, debe de ser mnima la suma
E=1n2i=1n(yi(axi+b))2

El extremos de una funcin: mximo o mnimo se
obtiene cuando las derivadas de E respecto de a y
de b sean nulas. Lo que da lugar a un sistema de dos
ecuaciones con dos incgnitas del que se despeja a y b.
Ea=0
Eb=0a=n1nxiyi(1nxi)(1nyi)n1nx2i(1nxi)2
b=1nyia1nxin
Expresiones ms elaboradas nos permiten determinar
el error de a, a y el error de b, b
a=nn1nx2i(1nxi)2
=1n(yiaxib)2n2 b=a
1nx2in
La pendiente de la recta se escribir aa, y la
ordenada en el origen bb. Vase las reglas para
expresar una medida y su error de una magnitud.
El coeficiente de correlacin es otro parmetro para el
estudio de una distribucin bidimensional, que nos
indica el grado de dependencia entre las variables X e
Y. El coeficiente de correlacin r es un nmero que se
obtiene mediante la frmula.
r=1n(xi<x>)(yi<y>)1n(xi<x>)21n(
yi<y>)2
El numerador es el producto de las desviaciones de los
valores X e Y respecto de sus valores medios. En el
denominador tenemos las desviaciones cuadrticas
medias de X y de Y.
El coeficiente de correlacin puede valer cualquier
nmero comprendido entre -1 y +1.
Cuando r=1, la correlacin lineal es perfecta, directa.
Cuando r=-1, la correlacin lineal es perfecta,
inversa
Cuando r=0, no existe correlacin alguna,
independencia total de los valores X e Y
Ejemplo
Un vehculo que se mueve supuestamente con
velocidad constante. Los datos de las medidas del
tiempo en cuatro posiciones separadas 900 m son las
siguientes
Tiempo t (s) Posicin x (m)
17.6 0
40.4 900
67.7 1800
90.1 2700
Ajustar los datos a la lnea recta
x=x
0
+vt
y estimar el mejor valor de la velocidad v aplicando el
procedimiento de mnimos cuadrados
Utilizando el applet de la pgina Regresin
lineal, obtenemos los siguientes valores: la pendiente
es a=36.71 y el error de la pendiente a=1.001. La
velocidad se escribe (vase la pgina Errores en las
medidas)
v=371 m/s
function [a b]=regresion(x,y)
n=length(x);
a=zeros(2,1);
b=zeros(2,1);

%pendiente de la recta de regresin, a
a(1)=(n*sum(x.*y)-
sum(x)*sum(y))/(n*sum(x.^2)-sum(x)*sum(x));
%ordenada en el origen, b
b(1)=(sum(y)-a(1)*sum(x))/n;

% errores de a y de b
sd2=sum((y-a(1)*x-b(1)).^2);
a(2)=sqrt(sd2/(n-2))/sqrt(sum(x.^2)-
sum(x)*sum(x)/n);
b(2)=sqrt(sum(x.^2)/n)*a(2);
end
En el vector a de dimensin 2 hemos guardado la
pendiente en a(1) y su error en a(2)
En el vector b de dimensin 2 hemos guardado la
ordenada en b(1) y su error en b(2)
Escribimos el script datos_1 para calcular la
pendiente a de la recta de regresin, su error a, la
ordenada en el origen by su error b.
t=[17.6 40.4 67.7 90.1];
x=[0 900 1800 2700];
[a b]=regresion(t,x);
fprintf('pendiente a= %2.3f, error
%1.3f\n',a(1),a(2));
fprintf('ordenada b= %3.3f, error
%3.3f\n',b(1),b(2));

%grfica
plot(t,x,'ro','markersize',8,'markerfacecolor',
'r')
tmin=min(t);
xmin=a(1)*tmin+b(1);
tmax=max(t);
xmax=a(1)*tmax+b(1);
line([tmin tmax],[xmin xmax]); %recta
xlabel('t')
ylabel('x')
title('Regresin lineal')
En la ventana de comandos corremos el script datos_1
>> datos_1
pendiente a= 36.710, error 1.001
ordenada b= -630.509, error 60.580

Queda como trabajo al lector calcular el coeficiente de
correlacin. Solucin r=0.99926
La funcin potencial
y=cx
a

Se puede trasformar en
log y=alog x+log c
Si usamos las nuevas variables X=log x e Y=log y,
obtenemos la relacin lineal
Y=aX+b.
Donde b=log c
Ejemplo:
x 10 20 30 40 50 60 70 80
y 1.06 1.33 1.52 1.68 1.81 1.91 2.01 2.11
Representamos estos datos en un diagrama doblemente
logartmico mediante el comando loglog
x=[10 20 30 40 50 60 70 80];
y=[1.06 1.33 1.52 1.68 1.81 1.91 2.01 2.11];
loglog(x,y,'ro','markersize',2,'markerfacecolor
','r')
xlabel('x')
ylabel('y')
title('Funcin potencial')

Para determinar la recta de regresin, se transforma
esta tabla de datos en esta otra
X=log x 1.0 1.30 1.477 1.60 1.699 1.778 1.845 1.903
Y=log y 0.025 0.124 0.182 0.225 0.258 0.281 0.303 0.324
Calculamos mediante la funcin regresion los
parmetros a y c.
Escribimos el script datos_2
x=[10 20 30 40 50 60 70 80];
y=[1.06 1.33 1.52 1.68 1.81 1.91 2.01 2.11];
[a b]=regresion(log10(x),log10(y));
fprintf('exponente a= %2.3f\n',a(1));
fprintf('coeficiente c= %3.3f\n',10^b(1));

%grfica
hold on
plot(x,y,'ro','markersize',8,'markerfacecolor',
'r')
z=(10^b(1))*x.^a(1);
plot(x,z,'b')
xlabel('x')
ylabel('y')
title('Regresin potencial')
hold off
Corremos el script datos_2 en la ventana de comandos
>> datos_2
exponente a= 0.331
coeficiente c = 0.495

Funcin exponencial
y=ce
ax

Tomando logaritmos neperianos en los dos miembros
resulta
ln y=ax+ln c
Si ponemos ahora X=x, e Y=ln y, obtenemos la
relacin lineal
Y=aX+b
Donde b=ln c.
Ejemplo:
x 12 41 93 147 204 264 373 509 773
y 930 815 632 487 370 265 147 76 17
Representamos estos datos en un diagrama
semilogartmico mediante el comando semilogy
x=[12 41 93 147 204 264 373 509 773];
y=[930 815 632 487 370 265 147 76 17];
semilogy(x,y,'ro','markersize',2,'markerfacecol
or','r')
xlabel('x')
ylabel('y')
title('Funcin exponencial')
grid on

Para determinar la recta de regresin, se transforma
esta tabla de datos en esta otra
X= x 12 41 93 147 204 264 373 509 773
Y=ln y 6.835 6.703 6.449 6.188 5.913 5.580 4.990 4.330 2.833
x=[12 41 93 147 204 264 373 509 773];
y=[930 815 632 487 370 265 147 76 17];
[a b]=regresion(x,log(y));
fprintf('exponente a= %2.3f\n',a(1));
fprintf('coeficiente c = %3.3f\n',exp(b(1)));

%grficos
hold on
'r')
x=linspace(min(x),max(x),100);
y=exp(b(1))*exp(x*a(1));
plot(x,y,'b')
xlabel('x')
ylabel('y')
title('Regresin exponencial')
hold off
>> datos_3
exponente a= -0.005

Polinomio aproximador
Supongamos que hemos medido un conjunto de pares
de datos (x
i
, y
i
) en una experiencia, por ejemplo, la
posicin de un mvil en ciertos instantes de tiempo.
Queremos obtener una funcin y=f(x) que se ajuste lo
mejor posible a los valores experimentales. Se pueden
ensayar muchas funciones, rectas, polinomios,
funciones potenciales o logartmicas.
Una vez establecido la funcin a ajustar se determinan
sus parmetros, en el caso de un polinomio, sern los
coeficientes del polinomio de modo que los datos
experimentales se desven lo menos posible de la
frmula emprica. La funcin ms sencilla es la
funcin lineal y=ax+b, que hemos descrito en la
seccin anterior
Queremos aproximar un polinomio de grado n, a un
conjunto de m pares de datos (x
i
, y
i
) de modo que n<m.
Sea el polinomio
P(x)=a
1
x
n
+a
2
x
n-1
+...a
n
x+a
n+1

Se calcula la cantidad
S=j=1m(P(xi)yi)2=j=1m(a1xnj+a2xn1j+anxj+an+1yi)2
Para obtener los valores de los coeficientes del
polinomio aproximador se tienen que determinar los
valores de los coeficientes a
1
, a
2
, a
3
, ...a
n
, a
n+1
de
forma que la cantidad S tome un valor mnimo.
Hagamos las derivadas parciales de S respecto de a
1
,
a
2
, a
3
, ...a
n
, a
n+1
iguales a cero
12Sa1=j=1m(a1xnj+a2xn1j+anxj+an+1yi)xnj12Sa2=j=1m(
a1xnj+a2xn1j+anxj+an+1yi)xn1j....................................12Sa
n=j=1m(a1xnj+a2xn1j+anxj+an+1yi)xj12San+1=j=1m(a1xnj+
a2xn1j+anxj+an+1yi)
Obtenemos un sistema de n+1 ecuaciones con n+1
incgnitas, a
1
, a
2
, a
3
, ...a
n
, a
n+1

j=1mx2nja1+j=1mx2n1ja2+...+j=1mxn+1j
an+j=1mxnjan+1=j=1myjxnjj=1mx2n1ja1+
j=1mx2n2ja2+...+j=1mxnjan+j=1mxn1jan+
1=j=1myjxn1j.........j=1mxnja1+j=1mxn1ja2+...
+j=1mxjan+man+1=j=1myj
que podemos escribir, altenativamente
s1a1+s2a2+....snan+sn+1an+1=t1s2a1+s3a2+....s
n+1an+sn+2an+1=t2.......sn+1a1+sn+2a2+....s2nan+s2n+1an+1=tn+1sk=
j=1mx2n+1kj k=1...2n+1tk=j=1myjxn+1kj k=1...n+1
function p=pol_regresion(x,y,n)
s=zeros(2*n+1,1);
t=zeros(n+1,1);
A=zeros(n+1);
for k=1:2*n+1
s(k)=sum(x.^(2*n+1-k));
end
%vector de los trminos independientes
for k=1:n+1
t(k)=sum(y.*x.^(n+1-k));
end
%elementos de la matriz A de las incgnitas
for i=1:n+1
for j=1:n+1
A(i,j)=s(i+j-1);
end
end
%coeficientes del polinomio a1, a2... an,
an+1
p=A\t;
end
A la funcin pol_regresion se le pasa los
vectores x e y de datos el grado n del polinomio
aproximador y devuelve los coeficientes del polinomio
en el vector columna p.
La funcin calcula los elementos de la matriz A de las
incgnitas, el vector t de los trminos independientes y
resuelve el sistema de n+1 ecuaciones con n+1
incgnitas mediante el operador divisin por la
izquierda.
Ejemplo
Una experiencia que se puede llevar a cabo con la
ayuda de un cronmetro es la de establecer una
relacin entre la lectura n del contador del reproductor
de la casete y el tiempo t transcurrido. Vamos a
comprobar que esta relacin no es lineal
Se sugiere al lector que analice el comportamiento de
su reproductor de casete y complete una tabla como la
siguiente, y represente los datos en una grfica
semejante a la figura ms abajo
http://www.sc.ehu.es/sbweb/fisica_/cinematica/circula
r/casete/casete1.html
n t (s)
0 0
100 242
200 487
300 854
400 1220
500 1626
600 2072
700 2558
744 2786
n/100 t(min)
0 0
1 4.03
2 8.12
3 14.23
4 20.33
5 27.1
6 34.53
7 42.63
7.44 46.43
Ajustar el conjunto de pares de datos de la tabla de la
derecha a un polinomio de segundo grado a
1
x
2
+a
2
x+a
3
.
Creamos el script datos_5 con los datos y llamamos a
la funcin pol_regresion
x=[0 1 2 3 4 5 6 7 7.44];
y=[0 4.03 8.12 14.23 20.33 27.1 34.53 42.63
46.43];
p=pol_regresion(x,y,2)

%grficos
hold on
'r')
y=polyval(p,x);
plot(x,y,'b')
xlabel('x')
ylabel('y')
title('Polinomio aproximador')
hold off
En la ventana de comandos corremos el script datos_5,
y nos aparece el vector p que contiene los
coeficientes a
1,
a
2
, a
3
del polinomio
>> datos_5
p =
0.3446
3.7004
-0.1188



Inicio
MATLAB
Numrico
Races de ecuaciones
Integracin numrica

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 es x=x
0
+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
'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 (x
k
,y
k
) k=1,2...n. Queremos conocer
el valor de ypara un valor cualesquiera de x en el
intervalo x
1
a x
n
. Supongamos que x est en el intervalo
(x
k
,x
k+1
) tal como se muestra en la figura. Trazamos la
recta que pasa por los puntos (x
k
,y
k
) y (x
k+1
,y
k+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=a
1
x
3
+a
2
x
2
+a
3
x+a
4
que pase por los cuatro
puntos. Obtenemos un sistema de cuatro ecuaciones
con cuatro incgnitas.
a1x31+a2x21+a3x1+a4=y1a1x32+a2x22+a3
x2+a4=y2a1x33+a2x23+a3x3+a4=y3a1x34+a2x24+a3x4+a4=y4
x31x32x33x34x21x22x23x24x1x2x3x41111
a1a2a3a4=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
a
1
x
N
+a
2
x
N-1
+...+a
N
x+a
N+1

que pase por todos los pares de datos (x
1
,y
1
), (x
2
,y
2
),
...(x
N+1
,y
N+1
). Los coeficientes se pueden obtener
resolviendo el sistema de ecuaciones:
a1xN1+a2xN11+aNx1+aN+1=y1a1xN2+a2xN1
2+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...1a1a2...aN+1=y
1y2...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 a
i
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 -0.0003 0.0057 -0.0595
0.3782 -1.4951 3.6430 -5.2142
3.9256 -1.1823

Un polinomio de Lagrange L
N
(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 (x
i
,y
i
).
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
(x
i
,y
i
) 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
>> 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)
yy = 10.0725
>> yy=lagrange_3(x,y,2.0)
yy = -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-x
i
)
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 pginaPolinomios. Por ejemplo,
queremos multiplicar los polinomios p
1
=x
3
-2x-4
y p
2
=x
2
+3x+4
>> p1=[1 0 -2 -4];
>> p2=[1 3 4];
>> p=conv(p1,p2)
p = 1 3 2 -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 -0.0595
0.3782 -1.4951 3.6430 -5.2142
3.9256 -1.1823
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 (x
1
,y
1
), (x
2
,y
2
),
(x
3
,y
3
), (x
4
,y
4
), (x
5
,y
5
) 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)+di
i=1,2,3,4
Cada una de las funciones s
i
(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 a
1
,a
2
,a
3
,a
4
, b
1
,b
2
,b
3
,b
4
, c
1
,c
2
,c
3
,c
4
, d
1
,d
2
,d
3
,d
4
, se imponen las siguientes condiciones:
1. La funcin S(x) pasa por todos los puntos (x
i
,y
i
)
i=1,2,3,4,5
si(xi)=yid1=y1d2=y2d3=y3d4
=y4a4(x5x4)3+b4(x5x4)2+c4(x5x4)+d4=y5
2. La funcin S(x) es continua en x
2
, x
3
, x
4
.
si1(xi)=si(xi)a1(x2x1)3+b1(x2x1)2+c1(x2x1
)+d1=d2a2(x3x2)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 x
2
, x
3
, x
4
.
s'i1(xi)=s'i(xi)3a1(x2x1)2+2b1(x2x1)+c1=c2
3a2(x3x2)2+2b2(x3x2)+c2=c33a3(x4x3)2+2b3(x4x3)+c
3=c4
4. Denominamos m
1
, m
2
, m
3
, m
4
, m
5
al valor de la
derivada segunda de s
i
(x) en los
puntos x
1
, x
2
, x
3
, x
4
, x
5
.
s''i(xi)=mi2b1=m12b2=m22b3=m
32b4=m46a4(x5x4)+2b4=m5
5. La derivada segunda de S(x) es continua en los
puntos x
2
, x
3
, x
4

s''i1(xi)=s''i(xi)6a1(x2x1)+2b1=2b26a2(x3x2)+2
b2=2b36a3(x4x3)+2b3=2b4
Supongamos que el espaciado entre dos puntos
consecutivos es constante h=x
i
-x
i-1
, i=2,3,4,5.
Vamos a expresar las
incgnitas a
1
,a
2
,a
3
,a
4
, b
1
,b
2
,b
3
,b
4
, c
1
,c
2
,c
3
,c
4
, d
1
,d
2
,d
3
,d
4
, en trminos de h, el valor de las ordenadas y
i
y el
valor de la derivada segunda de S(x), m
i
en cada
punto x
i
, i=1,2,3,4,5.
De (4) y (5) expresamos a
1
,a
2
, a
3
, a
4
en trminos
de m
1
, m
2
, m
3
, m
4
, m
5
.
a1=m2m16h a2=m3m26h a3=m4m36h a4=m5m46h
Teniendo en cuenta (1) y (4), las ecuaciones (2) se
expresan
m2m16hh3+m12h2+c1h+y1=y2m3
m26hh3+m22h2+c2h+y2=y3m4m36hh3+m32h2+c3h+y3=y4
Que nos permite despejar c
1
, c
2
, c
3
en trminos
de m
1
, m
2
, m
3
, m
4
, y
1
, y
2
, y
3
, y
4

c1=y2y1hm2+2m16hc2=y3y2hm3+2m26hc3=y4y3hm4+
2m36h
La ltima ecuacin de (1) nos permite despejar c
4

m5m46hh3+m42h2+c4h+y4=y5c4=y5y4hm5+2m46h
Las ecuaciones (3) se expresan
3m2m16hh2+m1h+y2y1hm2+
2m16h=y3y2hm3+2m26h3m3m26hh2+m2h+y3y2hm3+2
m26h=y4y3hm4+2m36h3m4m36hh2+m3h+y4y3hm4+2m
36h=y5y4hm5+2m46hm1+4
m2+m3=6h2(y12y2+y3)m2+4m3+m4=6h2(y22y3+y4)m3+4m4
+m5=6h2(y32y4+y5)
Tenemos tres ecuaciones y cinco
incgnitas m
1
, m
2
, m
3
, m
4
, m
5

Fijamos los valores de la derivada segunda m
1
y m
5
en
los puntos extremos. Supongamos que m
1
=0 y m
5
=0.
Hay otras posibilidades que se pueden consultar en el
documentohttp://online.redwoods.edu/instruct/darnold/
laproj/Fall98/SkyMeg/Proj.PDF
Despejamos m
2
, m
3
, m
4
del sistema de tres ecuaciones
m1+4m2+m3=6h2(y12y2+y3)
m2+4m3+m4=6h2(y22y3+y4)m3+4m4+m5=6h2(y32y4+y5)
410141014m2m3m4=6h2y12y2+y3
y22y3+y4y32y4+y5
Caso general
En general, con n pares de datos tendremos el sistema
4100....01410...00141...00014....................
.10000...4m2m3m4m5...
mn1=6h2y12y2+y3y2
2y3+y4y32y4+y5y42y5+y6....yn22yn1+yn

Fijamos los valores de los extremos del vector de las
incgnitas m: m
1
=0, m
n-1
=0, a continuacin, obtenemos
mediante el operador divisin por la izquierda los
valores de m
2
, m
3
, ...m
n-2
, finalmente, se calculan:
los coeficientes a
1
,a
2
,a
3
,...a
n-1.

a1=m2m16h a2=m3m26h a3=m4m36h
.... an1=mnmn16h
los coeficientes b
1
,b
2
,b
3
,...b
n-1.

b1=m12 b2=m22 b3=m32 .... bn1=mn12
los coeficientes c
1
,c
2
,c
3
,...c
n-1.

c1=y2y1hm2+2m16hc2=y3y2hm3+2m26hc3=y4y3hm4+
2m36h.....cn1=ynyn1hmn+2mn16h
los coeficientes d
1
,d
2
,d
3
,...d
n-1.

d1=y1 d2=y2 d3=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=diff(y)=[y2y1,y3y2,y4y3,y5y4]d2=dif
f(d1)=[y32y2y1,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 m
2
, m
3
, ... m
n-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 m
1
=0, m
n-1
=0,
sean ahora diferentes.
x=-4:4;
y=sin(x)./(1+x.^2);
%dibuja los puntos
hold on

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 (x
i
,y
i
) del
ejemplo anterior
x=-4:4;
y=sin(x)./(1+x.^2);
%dibuja los puntos
hold on
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 funcinf(x)
por un polinomio de grado n no muy elevado.
Tomamos n valores de la funcin y
i
=f(x
i
) con i=1...n. y
determinamos el polinomio de grado n-1 que pasa a
travs de los puntos (x
i
,y
i
). Sea la funcin
y=1x2+1
Tomamos diez abscisas x
i
espaciadas 0.8 en el
intervalo [-4,4]. Representamos la funcin (en color
rojo), los puntos (x
i
,y
i
) 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,'m
arkerfacecolor','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 x
i
igualmente espaciados entre a y b. La
funcin que hemos denominado lincheby crea un
vector de abscisas x
i
, 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,'m
arkerfacecolor','r')
hold off
xlabel('x')
ylabel('y')
title('Interpolacin de una funcin')

Como podemos apreciar la mejora es importante


Inicio
MATLAB
Numrico
Races de ecuaciones
Integracin numrica

Ajuste de datos con
MATLAB
MATLAB dispone de la funcin polyfit para ajustar
datos a un polinomio de grado n. Tambin tiene la
posibilidad de ajustar los datos de forma interactiva en
la ventana grfica (Figure Windows) seleccionado en
el men Tools/Basic Fitting.
Ajuste de datos con el operador,
divisin por la izquierda \.
Conocidos los n pares de datos
(x
i
,y
i
) i=1,2...n resolvemos el sistema de n ecuaciones
para determinar las incgnitas, los
coeficientes a
1,
a
2
, a
3
del polinomio que mejor ajusta
y=a1x2+a2x+a3y1y2...yn=x21
x22...x2nx1x2...xn11...1a1a2a3
Tenemos n=9 pares de datos (x
i
,y
i
). Por lo que tenemos
un sistema de nueve ecuaciones con tres incgnitas,
que podemos resolver con el operador \ (divisin por
la izquierda)
x=[0,1,2,3,4,5,6,7,7.44]';
y=[0,4.03,8.12,14.23,20.33,27.1,34.53,42.63,46.
43]';
M=[x.^2,x,ones(size(x))];
a=M\y %coeficientes del polinomio

hold on
'r')
x=(0:0.1:max(x))';
y=[x.^2,x,ones(size(x))]*a; %evala el
polinomio para cada valor de x
plot(x,y,'b')
xlabel('x')
ylabel('y')
hold off
En la ventana de comandos vemos los
coeficientes a
1,
a
2
, a
3
como elementos del vector a. En
la ventana grfica se obtiene una figura similar.
a =
0.3446
3.7004
-0.1188
Ajuste de datos con polyfit
Para el ajuste de datos a un polinomio se utiliza la
funcin MATLAB polifit, cuya sintaxis es la
siguiente:
p=polyfit(x,y,n)
x, y son los vectores de las abscisas y de las
ordenadas de los datos, respectivamente
n, es el grado del polinomio al que se quieren ajustar
los datos
p, es el vector de los coeficientes de dicho polinomio.
Para n=1 tenemos la regresin lineal. Si m es el
nmero de datos, el polinomio pasa a travs de todos
los puntos si n=m-1. El grado n del polinomio no
puede ser mayor que m-1.
Renombramos el script datos_5 como datos_6, para
cambiar la llamada a la funcin MATLAB polyfit en
vez de apol_regresion
x=[0 1 2 3 4 5 6 7 7.44];
y=[0 4.03 8.12 14.23 20.33 27.1 34.53 42.63
46.43];
p=polyfit(x,y,2)

%grficos
hold on
'r')
y=polyval(p,x);
plot(x,y,'b')
xlabel('x')
ylabel('y')
hold off
En la ventana de comandos corremos el script datos_6,
y nos aparece el vector p que contiene los
coeficientes a
1,
a
2
, a
3
del polinomio
>> datos_6
p =
0.3446 3.7004 -0.1188
Tambin se puede utilizar polyfit para realizar ajustes a
una funcin potencial, exponencial, logartmica, etc,
tal como se muestra en el siguiente cuadro
Funcin Llamada a polyfit
y=cx
a
p=polyfit(log(x), log(y),1)
y=ce
ax
p=polyfit(x, log(y),1)
y=a ln(x)+c p=polyfit(log(x),y,1)
y=1ax+c p=polyfit(x,1./y,1)
El primer elemento del vector p devuelto
por polyfit, p(1) guarda el parmetro a y el segundo
elemento, p(2) guarda el parmetro c.
Renombramos el script datos_2 como datos_7 para
vez deregresion.
x=[10 20 30 40 50 60 70 80];
y=[1.06 1.33 1.52 1.68 1.81 1.91 2.01 2.11];
p=polyfit(log10(x),log10(y),1);
fprintf('exponente a= %2.3f\n',p(1));
fprintf('coeficiente c = %3.3f\n',(10^p(2)));
hold on
'r')
z=(10^p(2))*x.^p(1);
plot(x,z,'b')
xlabel('x')
ylabel('y')
title('Regresin potencial')
hold off
>> datos_7
exponente a= 0.331
Renombramos el script datos_3 como datos_8 para
vez deregresion.
x=[12 41 93 147 204 264 373 509 773];
y=[930 815 632 487 370 265 147 76 17];
p=polyfit(x,log(y),1);
fprintf('exponente a= %2.3f\n',p(1));
fprintf('coeficiente c = %3.3f\n',exp(p(2)));
hold on
'r')
z=exp(p(2))*exp(x*p(1));
plot(x,z,'b')
xlabel('x')
ylabel('y')
title('Regresin exponencial')
hold off
>> datos_8
exponente a= -0.005
Ajuste de forma interactiva
Determinar la recta de regresin para la siguiente tabla
de datos, tomadas de una experiencia
x 0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4
y 0.25 0.42 0.58 0.72 0.85 0.98 1.10 1.12
x=[0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4];
y=[0.25 0.42 0.58 0.72 0.85 0.98 1.1 1.12];
p=polyfit(x,y,1)
xp=linspace(min(x),max(x),20);
yp=polyval(p,xp);
plot(x,y,'r+',xp,yp)
axis([min(x)-0.05,max(x)+.05, min(y)-0.1,
max(y)+.1])
grid on
xlabel('x'), ylabel('y'), title('ajuste con
polyfit')
legend('datos originales','mejor
ajuste','Location','SouthEast')
Corremos el script en la ventana de comandos
>> datos_9
p =
2.5762 0.1729
Vamos a realizar el ajuste de datos de forma
interactiva en la ventana Figure Window. En la
ventana de comandos escribimos
>> x=[0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4];
>> y=[0.25 0.42 0.58 0.72 0.85 0.98 1.1 1.12];
>> plot(x,y,'+')
Aparece la representacin grfica de los puntos con el
smbolo +

Seleccionamos en el men Tools/Basic Fitting, y
activamos la casilla linear (polinomio de grado 1)
yquadratic(polinomio de grado dos) en el primer
panel titulado Plot fits. Observamos en la ventana
Figure 1 que el polinomio de segundo grado en color
verde parece que se ajusta mejor a los datos
experimentales

Ampliamos el cuadro de dilogo pulsando en el botn
con la flecha inferior derecha --> nos aprece los
coeficientes del polinomio de ajuste:
Seleccionamos en el segundo panel
titulado Numerical results Fit/ linear y nos aparece
y = p1*x + p2
Coefficients:
p1 = 2.5762
p2 = 0.17286
Norm of residuals =
0.1187
Seleccionamos en el segundo panel
titulado Numerical results Fit/quadratic y nos
aparece
y = p1*x^2 + p2*x + p3
Coefficients:
p1 = -3.381
p2 = 4.0976
p3 = 0.046071
Norm of residuals =
0.045696
Pulsamos el botn con la flecha --> para ampliar otra
vez el cuadro de dilogo, podemos introducir un valor
o una expresin para ser evaluada pulsando el
botn Evaluate en el tercer panel titulado Find y=f(x).

El ajuste de datos de forma interactiva en la ventana
Figure Window admite muchas posibilidades, que se
pueden consultar en el sistema de ayuda (Help).


Inicio
Aspectos bsicos
Procedimientos Numricos
Anlisis de los datos
Expresiones matemticas
Recurso solar
Vibraciones
Transferencia de calor
Nmeros complejos
Funciones especiales
Temas diversos
Interfaz grfico de usuario

MATLAB para el Grado
en Ingeniera de Energas
Renovables

Contenidos
1.-Aspectos bsicos
2.-Procedimientos Numricos
3.-Anlisis de los datos
4.-Operaciones con expresiones matemticas (Math
Symbolic)
5.-Recurso solar
6.-Vibraciones
7.-Transferencia de calor
8.-Nmeros complejos
9.-Funciones especiales
10.-Otros temas
La ecuacin de van der Waals
Problemas de Fsica
10.-Interfaz grfico de usuario
Introduccin
En el Grado en Ingeniera de Energas Renovables, el
alumnado adquiere una formacin especfica centrada
en:
Las fuentes de energa renovable: hidrulica, elica,
fotovoltaica, geotrmica, solar trmica, solar
termoelctrica, marina, biomasa.
La generacin de electricidad y su adecuacin para la
conexin a la Red.
La distribucin y el almacenamiento de la energa
elctrica.
Las medidas para el ahorro y el uso eficiente de la
energa.
La evolucin y el desarrollo de las energas renovables
han estado determinados por los avances tecnolgicos
y la innovacin. La consecucin de mejores
rendimientos, el desarrollo de nuevas tecnologas a
partir de la actividad de I+D, la disminucin de costes,
entre otras muchas fuerzas motrices, son los
impulsores del proceso de innovacin. Esta constante
bsqueda hace que las exigencias en conocimiento de
las distintas materias sean muy elevadas, precisndose
de titulados universitarios para cubrir la mayor parte
de los puestos de trabajo generados en este sector.
Los futuros titulados se tendrn que enfrentar a
problemas tcnicos y de ingeniera de lo ms
interesantes y relevantes hoy en da, pensemos en el
vehculo elctrico, centrales termoelctricas o la
extraccin de energa de las olas del mar, etc.
Para resolver las distintas situaciones que
previsiblemente se van a dar en el lugar de trabajo, se
precisarn conocimientos de materias bsicas, de
ingeniera y especficas combinados con las destrezas
en el manejo de herramientas informticas de clculo y
simulacin. Por lo que, durante la elaboracin del Plan
de Estudios (en el curso 2009/10) se consider que los
estudiantes deberan aprender MATLAB desde el
primer curso, por ser una potente herramienta de
clculo, de representacin grfica y simulacin, que
ayudara a los estudiantes a resolver problemas
incluidos aquellos que no tienen solucin analtica o
que es muy complicado obtenerla. La resolucin de
problemas es una tarea prioritaria en los programas de
los grados de ciencias e ingeniera.
La utilizacin de MATLAB desde el primer curso del
Grado en Ingeniera de Energas Renovables podra
ayudar a establecer y/o reforzar metodologas activas
en la enseanza de las distintas asignaturas y su
orientacin hacia la resolucin de problemas.
MATLAB
MATLAB, acrnimo que significa MAtrix
LABoratory, es un software extraordinariamente
potente para la realizacin de clculos numricos,
representaciones grficas y tratamiento de datos.
Permite la resolucin de un amplio espectro de
problemas de forma analtica o numrica utilizando
mtodos basados en el clculo matricial. Proporciona
un conjunto numeroso de procedimientos codificados
en forma de llamadas a funciones y comandos que nos
permiten resolver problemas complejos con gran
facilidad y flexibilidad. MATLAB proporciona:
Un entorno formado por varias ventanas relacionadas
que permiten una gran facilidad de uso.
Algoritmos avanzados para la resolucin de
problemas
Enorme capacidad para el trabajo con datos
Potentes herramientas de programacin
Dado que MATLAB integra el clculo, visualizacin y
programacin en un entorno sencillo de usar y que los
problemas y sus soluciones se pueden expresar de una
forma flexible, entendible por los estudiantes sin los
estrictos requerimientos de los lenguajes clsicos
como Java, C++, etc; la utilizacin de MATLAB tiene
las siguientes ventajas:
1. Potencia. Se pueden resolver problemas ms
complejos en menos tiempo y con menos esfuerzo
2. Facilidad de aprendizaje. Se tarda mucho menos
tiempo en aprender los fundamentos de MATLAB
que con cualquier otro lenguaje. Por tanto, los
estudiantes pueden empezar a resolver problemas por
ellos mismos sin la ayuda del profesor mucho antes
que con otro lenguaje.
3. Enfasis en la resolucin del problema ms que en las
dificultades del lenguaje de programacin o del
entorno de desarrollo de aplicaciones. Los
estudiantes disponen de ms tiempo para reflexionar
sobre el problema y analizar las soluciones en vez de
emplear el esfuerzo en buscar o descubrir trucos para
resolverlos.
4. Se comenten muchos menos errores, y no es
necesario en la mayor parte de los casos emplear
herramientas de depuracin. Los errores se muestran
y las ayudas se proporcionan segn se va escribiendo
el cdigo.
5. Se consigue en menos tiempo el objetivo final
consistente en que el estudiante, plantee el problema,
lo analice dividindolo en partes, traduzca cada parte
en lneas de cdigo y organice el cdigo en forma de
funciones, script o llamadas a comandos.
6. MATLAB se est convirtiendo en un estndar en
carreras de ingeniera en universidades de todo el
mundo, reflejando el hecho del incremento notable
de la utilizacin de MATLAB en la industria.
Conclusiones
Casi todas las asignaturas del Grado en Ingeniera de
Energas Renovables se pueden beneficiar en mayor o
menor medida de la utilizacin de esta herramienta
para conseguir una enseanza ms activa y ms
orientada a la resolucin de problemas.
Sin un uso sistemtico y repetido de MATLAB a
travs de todos los cursos del Grado los estudiantes
pierden el tiempo volviendo a aprender repetidamente
la herramienta para resolver los problemas, en vez de
esforzarse en la tarea de resolverlos.
La utilizacin de MATLAB inspirar y motivar a los
estudiantes y les ayudar a relacionar conceptos
aprendidos en clase con el mundo real. Facilitar el
establecimiento de mejores y ms eficaces vas de
coordinacin vertical y horizontal entre las distintas
asignaturas.
Nuestro objetivo es la formacin de estudiantes de
ingeniera que puedan contribuir activamente al
desarrollo de las Energas Renovables. La integracin
de MATLAB como herramienta de clculo y
simulacin en la mayor parte de las asignaturas del
Grado, posibilitar un cambio hacia metodologas ms
activas y como consecuencia, una mejora sustancial en
el proceso de enseanza-aprendizaje. Facilitar la
transferencia de conocimientos y destrezas entre las
materias y ms all, en el puesto de trabajo en la
empresa.
El Plan de Estudios que hemos diseado que se
caracteriza por la ponderada combinacin de
asignaturas bsicas, comunes y especficas permitir a
los futuros graduados abordar el complemento en su
formacin mediante un mster o su integracin en el
mercado laboral en condiciones de xito.

Angel Franco Garca
Dpto. Fsica Aplicada I
http://www.sc.ehu.es/sbweb/fisica_/
Eibar, 11 de abril de 2013
Escuela de Ingeniera de Eibar
Universidad del Pas Vasco

Inicio
MATLAB
Bsico
Clculos aritmticos
Variables escalares
Vectores y matrices
Entrada/salida
Grficos bidimensionales
Funciones
Sentencias condicionales
Sentencias iterativas
Ejemplos

Clculos aritmticos
En la figura se muestra el Entorno de Desarrollo
formado por varias ventanas:
Command Window, es la ventana principal, cuyo
propsito es realizar clculos, correr programas
(scripts), asignar valores a variables.
Figure Window, se representan funciones de
diversos modos en 2D y en 3D.
Editor Window, crea y depura los ficheros script y
funcin, se obtiene seleccionado en el
men File/New, o en el icono debajo de File
Command History Window, guarda los comandos
que se han introducido en Command Window
Workspace Window, proporciona informacin
acerca de las variables que se estn utilizando.
Current Folder Window, muestra los ficheros
creados y guardados en el subdirectorio
Help Window, proporciona ayuda

Operaciones aritmticas
Una vez que se introduce el comando despus del
smbolo >> y se pulsa la tecla Retorno, el comando se
ejecuta
Introducimos 55/16 y pulsamos Retorno
>> 55/16
ans = 3.4375
para calcular el cociente entre 55 y 16, tal como se
muestra en la figura

Como ocurre en las calculadoras reutilizamos el
ltimo resultado para el siguiente clculo. Por
ejemplo, calculamos el discriminante de una ecuacin
de segundo grado y lo utilizamos para calcular una de
las races reales.
MATLAB utiliza la variable ans para guardar el
resultado del clculo. Ms adelante veremos el
concepto de variable.
Podemos sumar al resultado 11 y al
pulsar Retorno despus de 11, obtenemos una nueva
respuesta.
>> ans+11
ans = 14.4375
Comentarios
Cuando ponemos el smbolo % al comienzo de la
lnea, se trata de una lnea de comentarios.
>> %esto es un comentario
Los comentarios vienen precedidos por el
carcter % (tanto por ciento) aparecen en color verde
en MATLAB y no se procesan. Los comentarios
sirven para explicar un comando o una porcin de
cdigo.
El punto y coma ;
Cuando se pulsa Retorno despus del comando se
muestra la respuesta del clculo o del contenido de la
variable. Pero si se termina el comando con punto y
coma ; y se pulsa Retorno, la respuesta no se muestra.
>> 3*4;
El comando clc
Limpia la ventana de comandos. Este comando no
cambia nada, no borra las variables de la memoria
>> clc
Operaciones aritmticas
Suma + 6+2=8
Diferencia - 6-2=4
Multiplicacin * 6*2=12
Divisin / 6/2=3
Elevado a la potencia ^ 6^2=36
Los comandos nos permiten realizar operaciones
aritmticas combinadas como:
>> 5^2+3*4+9/3+8*(5+2)
ans = 96
Parntesis y precedencia de las operaciones
Las operaciones producto * y el cociente / tienen
precedencia sobre la suma + y la diferencia -, tal como
podemos ver en el siguiente cuadro. Utilizamos
parntesis para cambiar el orden en el que se efectan
las operaciones
>> 2*3+4
ans = 10
>> 2*(3+4)
ans = 14
>> 2/3+4
ans = 4.6667
>> 2/(3+4)
ans = 0.2857
Hay que tener cuidado a la hora de realizar las
operaciones, ya que a veces obtenemos un resultado
distinto al esperado, al no estar acostumbrados a
escribir las operaciones en una sola lnea y no utilizar
de modo adecuado los parntesis.
Funciones elementales
MATLAB dispone de numerosas funciones
predefinidas, algunas de ellas son las siguientes:
abs(x) Valor absoluto de x
sqrt(x) Raz cuadrada de x
nthroot(x,n) Raz n de x. Si n=3 sera la raz cbica de x
sign(x) Devuelve -1 si x es menor que 0, 0 si x es igual a 0, y 1 en el otro caso
rem(x,y) Devuelve el resto de la divisin x/y . Por ejemplo, rem(26,4) devuelve 2
exp(x) Calcula e
x

log(x) Calcula lnx, logaritmo natural
log10(x) Calcula log
10
x, logaritmo en base 10 de x
sin(x)
sind(x)
Calcula el seno de x, x en radianes (o grados)
cos(x)
cosd(x)
Calcula el coseno de x, x en radianes (o grados)
tan(x)
tand(x)
Calcula la tangente de x, x en radianes (o grados)
asin(x)
asind(x)
Calcula el arco seno, donde x ha de ser un nmero comprendido entre -1 a 1. La funcin
devuelve el ngulo en radianes entre -/2 y +/2 (o grados)
acos(x)
acosd(x)
Calcula el arco coseno, donde x ha de ser un nmero comprendido entre -1 a 1. La
funcin devuelve el ngulo en radianes entre 0 y (o grados)
atan(x)
atand(x)
Calcula el arco tangente. La funcin devuelve el ngulo en radianes entre -/2 y +/2 (o
grados)
atan2(y,x)
Calcula el arco tangente de y/x. Devuelve el ngulo en radianes entre - y +,
dependiendo del signo de x e y
sinh(x) Calcula exex2
cosh(x) Calcula ex+ex2
tanh(x) Calcula exexex+ex
asinh(x) Calcula ln(x+x2+1)
acosh(x) Calcula ln(x+x21)
atanh(x) Calcula ln1+x1x para |x|1
Para calcular la raz cuadrada de un nmero
positivo 144, escribimos
>> sqrt(144)
ans = 12
La raz cuadrada de un nmero negativo -4,
escribimos
>> sqrt(-4)
ans = 0 + 2.0000i
nos da un nmero complejo
Calculamos la raz cuarta de un nmero
positivo, 65614
>> nthroot(6561,4)
ans = 9
No podemos calcular la raz cuarta de un nmero
negativo, solamente calcula la raz n de un nmero
negativo si el resultado es real, es decir, si n es impar.
Para calcular el seno de 30 grados se escribe
>> sind(30)
ans = 0.5000
Los ngulos se expresan tambin en radianes. Para
calcular el seno de 30=/6 se escribe
>> sin(pi/6)
ans = 0.5000
El ngulo cuyo coseno es -0.5 se calcula del siguiente
modo
>> acos(-0.5)
ans = 2.0944 (respuesta en radianes)
O bien,
>> acosd(-0.5)
ans = 120 (respuesta en grados)
Resto de la divisin entre dos nmeros x e y:
14=43+2
>> rem(14,4)
ans = 2
Formatos
Representacin de los nmeros en MATLAB
Nmero Mantisa-exponente MATLAB
2412.6 2.412610
3
2.4126e3
0.00002 210
-5
2e-5
20000 210
4
2e4
Podemos representar un nmero como 0.00002 o bien,
2e-5
Si queremos mostrar un resultado con muchos
decimales, escribimos
>> format long
>> pi
ans = 3.141592653589793
Si queremos mostrar menos decimales
>> format short
>> pi
ans = 3.1416
format
short
4 decimales
>> 351/7
ans=50.1429
format long 15 decimales
>> 351/7
ans = 50.142857142857146
format
short e
Notacin cientfica con 4
decimales
>> 351/7
ans = 5.0143e+001
format long
e
Notacin cientfica con 14
decimales
>> 351/7
ans =
5.014285714285715e+001
format
bank
2 decimales
>> 351/7
ans = 50.14
Fracciones
Podemos operar con fracciones y obtener el resultado
de la operacin como una fraccin simplificada,
estableciendo el formato rat
>> format rat
>> 12/18
ans = 2/3
>> 1/2+2/3
ans = 7/6
>> 1/2*2/3
ans = 1/3
>> (2/3)/(4/5)
ans = 5/6
Volvemos al formato por defecto
>> format short
Aproximacin a nmeros enteros
La funcin round aproxima un nmero decimal al
entero ms prximo.
>> round(2.52)
ans = 3
>> round(2.49)
ans = 2
>> round(2.5)
ans = 3
La funcin ceil redondea hacia arriba, la
funcin floor redondea hacia abajo
>> floor(2.51)
ans = 2
>> ceil(2.4)
ans = 3
La funcin fix elimina la parte decimal
>> fix(2.49)
ans = 2
>> fix(-2.4)
ans = -2
Ayuda
Obtenemos informacin acerca de una palabra
reservada por MATLAB (comando, funcin, etc)
mediante helpseguido de dicha palabra. Por ejemplo,
queremos tener informacin sobre la funcin que
calcula el seno (sin) de un ngulo.
>> help sin
SIN Sine of argument in radians.
SIN(X) is the sine of the elements of X.

See also asin, sind.

Reference page in Help browser
doc sin
MATLAB, como herramienta de
clculo

MATLAB es una buena herramienta para realizar los
clculos que solemos hacer con una calculadora
cientfica, pero hace muchas ms como vamos a ver a
lo largo de estas pginas.
v

Inicio
MATLAB
Bsico
Clculos aritmticos
Variables escalares
Vectores y matrices
Entrada/salida
Funciones
Ejemplos

Vectores
La matriz (array) es el tipo fundamental de dato en
MATLAB. La variable escalar que hemos estudiado en
la pgina anterior es un caso particular de matriz de
dimensin 11. Los vectores son las matrices ms
simples: un vector fila de melementos es una matriz de
dimensin m1, un vector columna de n elementos es
una matriz de dimension 1n. En esta pgina, vamos a
ver como se crean vectores, como se realizan
operaciones con estas entidades y cmo se accede a
sus elementos.
En muchos lenguajes, el primer elemento de un vector
(array) tiene ndice cero, en MATLAB tiene ndice
uno.
Vectores
Un vector x es un conjunto de n nmeros reales
[x
1
, x
2
, ....x
n
]
Geometricamente, representa un punto en el espacio
R
n
, especificado por las n coordendas x
1
, x
2
, ....x
n
.
En Fsica representamos un vector r en el espacio
R
3
respecto a un Sistema de Referencia Ortonormal
formado por el origen O y tres vectores unitarios
mutuamente perpendiculares. Las direcciones de estos
vectores se denominan, ejes X, Y y Z,
respectivamente.
r =5i+3j5k
Los coeficientes de los vectores unitarios (las
proyecciones del vector r sobre los ejes coordenados)
son las coordendas (x, y, z) del punto P.

En MATLAB representamos un vector del siguiente
modo
>> r=[5 3 -5]
r = 5 3 -5
>> r=[5,3,-5]
r = 5 3 -5
Para crear un vector fila se escribe sus elementos unos
a continuacin de los otros separados por espacios o
comas, y entre parntesis cuadrados, tal como se
muestra en el cuadro. Para crear un vector columna se
escribe los elementos unos a continuacin de los otros
separados por puntos y comas o bien, en forma
columna tal como se indica en el cuadro.
>> r=[5; 3; -5];
>> r=[5
3
-5]
r =
5
3
-5
Podemos convertir un vector fila en columna mediante
el operador transpuesto '
>> r=[1,2,3]'
r = 1
2
3
Un vector con un espaciado constante x entre el
primer trmino, x
i
y el ltimo trmino, x
f
., se crea del
siguiente modo:
vector=xi:x:xf
>> x=3:2:15
x = 3 5 7 9 12 15
>> y=2:-0.2:1
y = 2.0000 1.8000 1.6000 1.4000 1.2000 1.0000
>> z=-5:3 % el espaciado por defecto es 1
y = -5 -4 -3 -2 -1 0 1 2 3
Creamos el vector
>> x=[0,0.38,0.71,0.92,1.00,0.92,0.71,0.38,0];
En la ventana Workspace vemos la variable x debajo
de Name y los valores que guarda, debajo Value.
Seleccionado la variable x, podemos cambiar los
valores que guarda mediante el Variable Editor, que
se abre pulsando el botn del
men Workspace denominado Open selection o
haciendo doble-clic en el nombre de la variable.

Podemos hacer una representacin grfica pulsando en
el botn plot(x)

Acceso a los elementos de un vector
Cuando se crea un vector, por
ejemplo x=[3,6,9,12,15,18]; la tabla muestra los
indices del x y los valores que guardan los elementos
del vector.
Indice 1 2 3 4 5 6
Valor 3 6 9 12 15 18
En general, un vector fila tiene la forma [r
1
r
2
r
3
....r
n
].
Para acceder a un elemento i del vector r, r
i
se
escribe r(i). Para acceder la primer elemento se
escribe r(1). Para acceder al ltimo se escribe r(end).
La funcin length devuelve el nmero de elementos
del vector
>> r=[5 3 -5];
>> r(1)
ans =5
>> r(end)
ans =-5
>> length(r)
ans = 3
Con el operador : podemos acceder a ms de un
elemento del vector. Cuando escribimos v(m:n) se
accede a los elementos del vector v desde las
posiciones m hasta n. Es la forma de extraer un vector
de otro vector. Por ejemplo, creamos un vector u con
los elementos comprendidos entre las posiciones 3 y 7
ambas incluidas, de un vector v que tiene 10 elementos
>> v=[4 10 -3 7 -1 0 8 13 -7 0];
>> u=v(3:7)
u = -3 7 -1 0 8
Creamos un vector u con los elementos de ndice par
del vector v.
>> v=[4 10 -3 7 -1 0 8 13 -7 0];
>> u=v(2:2:end)
u = 10 7 0 13 0
Podemos tambin crear un vector u a partir de otro
vector de subndices. Por ejemplo, crear un
vector u tomando el elemento quinto, primero, cuarto y
octavo elemento del vector v, en este orden.
>> v=[4 10 -3 7 -1 0 8 13 -7 0];
>> u=v([5 1 4 8])
u = -1 4 7 13
Se pueden aadir elementos a un vector de la siguiente
forma
>> v=1:4
v = 1 2 3 4
>> v(5:10)=7:3:22
v = 1 2 3 4 7 10 13
16 19 22
>> v(12)=-1
v = 1 2 3 4 7 10 13
16 19 22 0 -1
Si se sobrapasa la dimensin del vector que era 10, se
le aade el elemento de ndice 12, al elemento de
ndice 11 se le asigna automticamente cero.
Creamos un vector a partir de otros dos vectores,
insertamos un escalar (vector de dimensin 1) al
principio de un vector o en medio del vector
>> a=[1 2 3];
>> b=[4 5 6 7];
>> c=[a b]
c = 1 2 3 4 5 6 7
>> d=[-1 a]
d = -1 1 2 3
>> e=[d(1:2) -5 d(3:4)]
e = -1 1 -5 2 3
Se pueden eliminar elementos de un vector
>> e
e = -1 1 -5 2 3
>> e(2:4)=[]
e = -1 3
Ms adelante veremos como se accede a los elementos
de un vector mediante los operadores relacionales
Operaciones con vectores
Suma de un escalar y un vector
>> x=[1,2,3];
>> x+5
ans = 6 7 8
Producto de un escalar por un vector
El producto de un vector u por un escalar es otro
vector v de la misma direccin, se multiplica cada
elemento por el escalar
v=u=[u1u2....un]
>> u=[1,2,3];
>> u*3
ans = 3 6 9
Se pueden realizar ms operaciones con un vector, por
ejemplo calcular la raz cuadrada de un conjunto de
datos
>> x=[4 9 16 25];
>> u=sqrt(x)
u = 2 3 4 5
>> 3*u-2
ans = 4 7 10 13
Suma de dos vectores
Los vectores con el mismo nmero de elementos se
pueden sumar o restar.
u=[u1u2....un] v=[v1v2....vn]u+v=[u1+v1u2+v2....un+vn]
>> u=[1,2,3];
>> v=[4,5,6];
>> u+v
ans = 5 7 9
Producto escalar de dos vectores
uv=uvcosuv=u1v1+u2v2+....+unvn
El producto escalar se obtiene multiplicando el vector
fila u por el vector columna v
(u1u2...un)v1v2...vn=u1v1+u2v2+...+unvn
MATLAB dispone de la funcin dot(u,v) para calcular
el producto escalar de dos vectores u y v.
>> u = [5 6 7];
>> v = [4 3 2];
>> dot(u,v)
ans = 52
>> u*v'
ans = 52
Cuando el vector u y v coinciden, calculamos el
mdulo del vector u.
uu=u2=u21+u22+....+u2n
MATLAB dispone de la funcin norm que calcula el
mdulo de un vector.
>> u = [5 6 7];
>> norm(u)
ans = 10.4881
>> sqrt(u*u')
ans = 10.4881
A partir de la definicin del producto escalar podemos
calcular el ngulo entre los vectores u y v
cos=u1v1+u2v2+....+unvnuv
Escribimos la ventana de comandos
>> u = [5 6 7];
>> v = [4 3 2];
>> ang=acosd(dot(u,v)/(norm(u)*norm(v))
ang = 22.9745
Dos vectores u y v son perpendiculares si el producto
escalar es cero.
La proyeccin de un vector u a lo largo de la direccin
del vector v se calcula del siguiente modo: se
multiplica escalarmente el vector u por el vector
unitario v/v cuya direccin y sentido son los del
vector v.
uv=ucos=uvv=u1v1+u2v2+....+unvnv

Por ejemplo, el ngulo que forma el vector u con el eje
Z se calcula
u=uxi+uyj+uzkcos=uzu
Otras formas de crear vectores
En MATLAB hay otras formas alternativas de crear un
vector, que como veremos son muy tiles para el
clculo y representacin grfica de funciones.
Para crear un vector con espaciado constante
especificando el primer trmino, x
i
, el ltimo
trmino x
f
. y el nmero de trminos, n llamamos a la
funcin linspace
vector=linspace(xi,xf,n)
>> x=linspace(0,6,5)
x = 0 1.5000 3.0000 4.5000 6.0000
El espaciado constante entre dos valores consecutivos
x es
x=xfxin1
Por lo que son equivalentes los vectores definidos por
>> x=0:2:20
>> x=linspace(0,20,11)
Creamos una tabla de valores de la funcin seno en el
intervalo (0, 2) del siguiente modo:
>> x=0:pi/5:2*pi
x =0 0.6283 1.2566 1.8850 2.5133 3.1416
3.7699 4.3982 5.0265 5.6549 6.2832
>> y=sin(x)
y =0 0.5878 0.9511 0.9511 0.5878 0.0000 -
0.5878 -0.9511 -0.9511 -0.5878 -0.0000
Creamos una tabla de logaritmos de la siguiente forma
>> x=(1:0.1:1.5)'; %vector columna
>> logs=[x log10(x)]
logs =
1.0000 0
1.1000 0.0414
1.2000 0.0792
1.3000 0.1139
1.4000 0.1461
1.5000 0.1761
La funcin logspace es similar a linspace pero genera
un conjunto de elementos espaciados
logartmicamente. Por ejemplo, para crear el
vector x=[10,100,1000,10000] escribimos
>> x=logspace(1,4,4)
x = 10 100 1000
10000
Operaciones elemento a elemento
Existen muchas situaciones en las que se requieren
operaciones elemento a elemento similares a las que se
lleva a cabo con la suma o la diferencia de dos
vectores de las mismas dimensiones
Sean dos vectores a=[a
1
a
2
a
3
] y b=[b
1
b
2
b
3
]
Las operaciones de multiplicacin, divisin y
exponenciacin elemento a elemento de dos
vectores a y b se definen del siguiente modo:
a.*b=[a1b1a2b2a3b3]a./b=[a1/b1a2/b2a3/b3]a.^b=[(a1)b1(a2)b2(
a3)b3]
>> u=[1,2,3];
>> v=[4,5,6];
>> u.*v
ans = 4 10 18
Evaluamos una funcin y=f(x) cuando le
proporcionamos el valor de la variable x.
>> x=2;
>> y=2*x^2-3
y = 5
En MATLAB, podemos utilizar las operaciones
elemento a elemento para evaluar una funcin para un
conjunto de valores de la variable x, y esto nos va a ser
de mucha utilidad en las representaciones grficas.
>> x=[0,1,-1,2,-3,4];
>> y=2*x.^2-3
y = -3 -1 -1 5 15 29
Obtener una tabla de valores de la funcin y=x2x3+1 en
el intervalo (0.5, 2) tomando un espaciado x=0.1
>> x = 0.5:0.1:2;
>> f = x.^2;
>> g = x.^3+1;
>> y = f./g
Obtener una tabla de valores de la
funcin y=(2x+3)
2
(x
3
+2) en el intervalo (-1, +1)
tomando un espaciado x=0.1
>> x = -1:0.1:1;
>> f = 2*x+3;
>> g = x.^3+2;
>> y = (f.^2).*g
o bien, en una sola lnea
>> x=-1:0.1:1;
>> y=((2*x+3).^2).*(x.^3+2)
Funciones que operan con vectores
mean(u) Valor medio de los elementos del vector u
>> u = [3 7 2 16];
>> mean(A)
ans = 7
max(u) c es el mayor elemento del vector u
>> u = [3 7 2 16 9 5 18 13 0 4];
>> c = max(u)
c = 18
min(u) El ms pequeo elemento del vector u
>> u = [3 7 2 16];
>> min(u)
ans = 2
sum(u)
Devuelve la suma de todos los elementos del
vector
>> u = [3 7 2 16];
>> sum(u)
ans = 28
sort(u)
Ordena los elementos del vector en orden
ascendente
>> u = [3 7 2 16];
>> sort(u)
ans = 2 3 7 16
std(u) Devuelve la desviacin estndar
>> u = [3 7 2 16];
>> std(u)
ans = 6.3770
dot(u,v)
Calcula el producto escalar u v de los
vectores u y v
>> u = [5 6 7];
>> v = [4 3 2];
>> dot(u,v)
ans = 52
cross(u,v)
Calcula el producto vectorial uv de los
vectores u y v.
>> u = [5 6 7];
>> v = [4 3 2];
>> cross(u,v)
ans = -9 18 -9
Suma de los elementos de un vector
La suma sum(u) de los elementos de un vector u es un
escalar. La suma acumulada cumsum(u) de un
vector u es otro vector s cuyos elementos
son s(k) k=1...N
s=n=1Nx(n)=x(1)+x(2)+....x(N)s(k)=n=1kx(n)=x(1)+x(2)+...
.x(k)
Producto de los elementos de un vector
El producto prod(u) de los elementos de un vector u es
un escalar. El producto acumulado cumprod(u) de un
vector ues otro vector p cuyos elementos
son p(k) k=1...N
p=n=1Nx(n)=x(1)x(2)....x(N)p(k)=n=1kx(n)=x(1)x(2)....x(
k)
Probar que
n=1Nn=N(N+1)2n=1Nn=123...N=N!
>> s=sum(1:5)
s = 15
>> fact=prod(1:5)
fact = 120
>> cumsum(1:5)
ans = 1 3 6 10 15
>> cumprod(1:5)
ans = 1 2 6 24 120
Calcular el valor de las expresin para N=8.
n=1N(1+3n)
>> n=1:8;
>> u=1+3./n;
>> p=prod(u)
p = 165
Mximo y mnimo
Para obtener el mximo valor de los elementos de un
vector
>> x=[0,0.38,0.71,0.92,1.00,0.92,0.71,0.38,0];
>> [xmax, nmax]=max(x)
xmax = 1
nmax = 5
>> x(5)
ans = 1
La funcin max nos devuelve dos datos, el valor
mximo xmax y el ndice nmax del elemento del vector
que guarda el mximo. Vemos que el quinto elemento
del vector x guarda el mximo valor 1.0.
Cadena de caracteres (strings)
Una cadena de caracteres es una secuencia de
cualquier nmero de caracteres encerrados entre
comillas simples: 'hola'.
Se puede crear una cadena de caracteres a partir de
otras, tal como se hace con los nmeros
>> texto='hola'
texto=
hola
>> saludo='cmo ests?';
>> mas_texto=[texto,' - ',saludo]
mas_texto=
hola - cmo ests?
Los valores numricos se pueden convertir a cadenas
de caracteres mediante las
funciones num2str (nmeros en general )
o int2str (enteros)
>> tF=50; %grado Fahrenheit
>> tC=(tF-32)*5/9; %grado Celsius
>> texto=['La temperatura es ',num2str(tC),'
C']
texto =
La temperatura es 10 C
La funcin strcat concatena cadenas de caracteres lo
que como veremos ms adelante es muy til para
trabajar con ecuaciones. Por ejemplo:
1=2t2=2+4t12t21=2+2k
>> eq1='2*pi*t';
>> eq2='pi/2+4*pi*t-(pi/12)*t^2';
>> eq=strcat(eq1,'=',eq2,'+k*2*pi')
eq =2*pi*t=pi/2+4*pi*t-(pi/12)*t^2+k*2*pi


Inicio
MATLAB
Bsico
Clculos aritmticos
Variables escalares
Vectores y matrices
Entrada/salida
Funciones
Ejemplos

Matrices
Una matriz A de m filas y n columnas o de
dimensin mn se representa por
A=a11a21...am1a12a22...am2............a1na2n...amn
Para acceder a un elemento situado en la fila i y en la
columna j, A
ij
, se escribe A(i,j). La
funcin size devuelve dos nmeros que corresponden a
las dimensiones de la matriz.
La matriz traspuesta A' de la matriz A consiste en
intercambiar filas por columnas: La primera columna
de la matriz A es la primera fila de la matriz
traspuesta A', la segunda columna de la matriz A se
convierte en segunda fila de la matriz A', y as
sucesivamente. La dimensin de la matriz
tarspuesta A' es nm, es decir n filas y m columnas
A'=a11a12...a1na21a22...a2n............am1am2...amn
Creacin de una matriz
Se puede crear una matriz de 32, y asignar a la
variable A de dos formas distintas
>> A=[1 2 3
4 5 6];
>> A=[1 2 3; 4 5 6]
A =
1 2 3
4 5 6
>> A(2,2) %accede al elemento situado en la
fila 2 columna 2
ans = 5
>> size(A) %dimensiones de la matriz A (2
filas, 3 columnas)
ans = 2 3
>> B=A' % B es la matriz traspuesta de A
B =
1 4
2 5
3 6
>> size(B)
ans = 3 2
Se puede crear una matriz a partir de vectores o a
partir de otras matrices
>> x1=[1,2,3]; %vectores fila
>> x2=[4,5,6];
>> A=[x1;x2]
A =
1 2 3
4 5 6
>> x1=[1;2;3]; %vectores columna
>> x2=[4;5;6];
>> A=[x1,x2]
A =
1 4
2 5
3 6

>> X=[1,2,3;4,5,6]
X =
1 2 3
4 5 6
>> Y=[7,8,9;10,11,12;13,14,15]
Y =
7 8 9
10 11 12
13 14 15
>> A=[X;Y]
A =
1 2 3
4 5 6
7 8 9
10 11 12
13 14 15
La funcion repmat crea una matriz B compuesta de la
repeticin de nm copias de A.
>> A=[1,2;3,4];
>> B=repmat(A,3,2)
B =
1 2 1 2
3 4 3 4
1 2 1 2
3 4 3 4
1 2 1 2
3 4 3 4
Una matriz se puede convertir en un vector columna
>> A=[1,2,3;4,5,6];
>> X=A(:)
X =
1
4
2
5
3
6
Un vector se puede convertir en una matriz diagonal
mediante diag.
>> x=[1,2,3];
>> A=diag(x)
A =
1 0 0
0 2 0
0 0 3
Matrices predefinidas
La funcin zeros(m,n) crea una matriz de
dimensin mn cuyos elementos son todos ceros
La funcin ones(m,n) crea una matriz de
dimensin mn cuyos elementos son todos unos
La funcin eye(n) crea una matriz cuadrada de
dimensin nn en la cual, los elementos de la
diagonal son unos y el resto de los elementos son
ceros, es decir, crea la matriz identidad de
dimensin n.
Por ejemplo, zeros(n) reserva espacio para una matriz
cuadrada de dimensin nn.Lo mismo ocurre
con ones(n)
>> y=zeros(3)
y =
0 0 0
0 0 0
0 0 0
>> y=zeros(3,1)
y =
0
0
0
>> eye(3)
ans =
1 0 0
0 1 0
0 0 1
Acceso a los elementos de una
matriz
Existen tambin varias formas de acceder a ms de un
elemento de una matriz mediante el operador dos
puntos :. Sea la matriz A.
15913261014371115481216
A(:,2) se accede a los elementos de la columna 2
A(:,end) se accede a los elementos de la ltima
columna
A(3,:) se accede a los elementos de la fila 3
A(1:3,2:4) se refiere a la submatriz de filas de la 1 a la
3 y de columnas de la 2 a la 4
>> A=[1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15
16]
A =
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
>> A(:,2)
ans =
2
6
10
14
>> A(3,:)
ans =
9 10 11 12
>> A(1:3,2:4)
ans =
2 3 4
6 7 8
10 11 12
Para acceder a los elementos de la matriz sobreados en
la figura escribiremos

>> A=[1,2,3,4;5,6,7,8;9,10,11,12];
>> A([1,2],3)
ans =
3
7
>> A(2,[2,3,4])
ans =
6 7 8
>> A([2,3],2:4)
ans =
6 7 8
10 11 12
Se pueden eliminar elementos a una matriz A y luego
volverlos a aadir
>> A(4,:)=[]
A =
1 2 3 4
5 6 7 8
9 10 11 12

>> A(4,:)=13:16
A =
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Se puede crear una matriz a partir de vectores
columna, por ejemplo para crear una tabla de valores
(abscisa, ordenada) de una funcin. Se puede calcular
la suma de valores, el valor mximo, mnimo, etc de
cada columna, tal como lo hicimos con los vectores en
la pgina anterior.
>> x=0:5; %vector fila
>> y=3*x.^2-5; %vector fila
>> tabla=[x' y']
tabla =
0 -5
1 -2
2 7
3 22
4 43
5 70
>> size(tabla) %matriz de 6 filas y 2 columnas
ans = 6 2
>> max(tabla(:,2))
ans = 70
>> min(tabla(:,2))
ans = -5
>> sum(tabla(:,2))
ans = 135
Creamos una tabla de cuadrados del nmero
entero n, n
2
y de potencias de 2 elevado a la n, 2
n
del
siguiente modo
>> n=[0:5]';
>> potencias=[n n.^2 2.^n]
potencias =
0 0 1
1 1 2
2 4 4
3 9 8
4 16 16
5 25 32
En la pgina titulada Valores y vectores
propios tendremos ocasin de practicar con matrices,
vectores, extraer una matriz o un vector de otra matriz,
crear una matriz a partir de vectores, etc
Operaciones con matrices
Suma de matrices de la misma dimensin
A=[a11a21a12a22a13a23]
B=[b11b21b12b22b13b23]A+B=[(a11+b11)(a21+b21)(a12+b12)(a22
+b22)(a13+b13)(a23+b23)]
Como ejercicio se sugiere comprobar el resultado de la
suma de dos matrices
Producto de dos matrices
Se pueden multiplicar matrices de dimensiones (m, k)
(k, n) para obtener una matriz de dimensin (m, n).
A=[a11a21a12a22a13a23]
B=b11b21b31b12b22b32A*B=[(a11b11+a12b21+a13b31)(a21b1
1+a22b21+a23b31)(a11b12+a12b22+a13b32)(a21b12+a22b22+a23b32)]
>> A=[1 2 3;4 5 6]
A =
1 2 3
4 5 6
>> B=[1 2; 3 4; 5 6]
B =
1 2
3 4
5 6
>> A*B
ans =
22 28
49 64
Producto escalar de dos vectores
Dos vectores se pueden multiplicar si tienen el mismo
nmero de elementos n, uno de ellos es un vector fila
de dimensin 1n y el otro es un vector columna de
dimensin n1, el resultado es una matriz de
dimensin 11, es decir un escalar.
A=[a1a2a3] B=b1b2b3A*B=[a1b1+a2b2+a3b3]
Como vemos esta operacin corresponde al producto
escalar de dos vectores, que MATLAB puede realizar
tambin con la funcin dot.
El producto de un vector columa m1 por un vector
fila 1m, del mismo nmero de elementos m nos da
una matriz cuadrada de dimensin mm.
Como ejercicio se sugiere comprobar el resultado del
producto A*B y B*A, siendo A un vector fila y B un
vector columna del mismo nmero de elementos.
Producto de un escalar por una matriz
Cuando una matriz se multiplica por un nmero, cada
elemento de la matriz se multiplica por dicho nmero
A=[a11a21a12a21a13a23]k*A=[ka11ka21ka12ka21ka13ka23]
La operacin kA es commutativa, se obtiene el mismo
resultado haciendo el producto Ak
Operaciones elemento a elemento
Existen muchas situaciones en las que se requieren
operaciones elemento a elemento similares a las que se
lleva a cabo con la suma o la diferencia de dos
matrices de las mismas dimensiones.

Inicio
MATLAB
Bsico
Clculos aritmticos
Variables escalares
Vectores y matrices
Entrada/salida
Funciones
Ejemplos

Entrada/salida
Cuando vamos a reservar un vuelo introducimos en el
programa la fecha y las ciudades de origen y destino.
El programa informtico nos proporciona las horas de
partida del avin de la ciudad de origen y otra
informacin relevante para el viajero. Se selecciona la
fecha en un control del tipo date y las ciudades de
origen y destino en un control de tipo listdesplegable
ordenadas alfabticamente.
En MATLAB podemos cambiar el valor de los
parmetros de entrada con el editor de script, guardar
de nuevo el script modificado y correrlo. Pero es
mucho ms fcil utilizar el comado input tal como
hemos visto al final de la pginaVariables.
a=input('primer coeficiente, a: ');
str=input('mensaje: ','s');
MATLAB imprime los resultados de los clculos y los
guarda bien en una variable o en ans, si no se
especifica. En muchos casos esto es suficiente, pero en
programas ms largos es necesario identificar o
describir el resultado de un determinado clculo.
MATLAB dispone de una funcin fprintf muy verstil
para mostrar distintos datos con formato,
alternativamente se puede utilizar la funcin disp.
La funcin disp
La funcin disp de MATLAB se utiliza para mostrar
un escalar, un mensaje (string), un vector o una
matriz.
En la lnea de comandos escribimos
>> disp('resultado')
resultado
>> y=22;
>> disp(y)
22
>> x=1:0.5:3;
>> disp(x)
1.0000 1.5000 2.0000 2.5000
3.0000
>> A=[1 2 3; 4 5 6; 7 8 9];
>> disp(A)
1 2 3
4 5 6
7 8 9
La funcin disp imprime una matriz A, vamos a ver
ahora como imprime una tabla de valores (abscisa,
ordenada). Creamos el script prueba.
x=0:5 %vector fila
y=3*x.^2-5 %vector fila
res(:,1)=x'; %columna 1 de la matriz
res(:,2)=y'; %columna 2 de la martiz
%esto es equivalente a poner res=[x' y']
disp('tabla funcin')
disp('abscisa ordenada')
disp(res)
En la ventana de comandos corremos el script prueba
>> prueba
x =
0 1 2 3 4 5
y =
-5 -2 7 22 43 70
tabla funcin
abscisa ordenada
0 -5
1 -2
2 7
3 22
4 43
5 70
La funcin fprintf
Es otra funcin para mostrar un mensaje o un
resultado, pero que permite mezclar texto y valores
numricos de las variables y tambin se puede ajustar
el formato de los nmeros. Esta funcin tiene muchas
posibilidades por lo que empezaremos con las ms
sencillas.
fprintf('texto %5.2f texto adicional', variable)
En medio del texto se ha intercalado un valor
numrico que contiene una variable con el formato %-
5.2f,
% es el smbolo que indica formato
-, alinea el nmero hacia la izquierda
+, imprime el signo (+ si es positivo y - si es
negativo)
0, aade ceros
5, indica cinco caracteres que es el ancho del campo
donde ese imprime el valor numrico, si el nmero es
ms corto se aaden espacios o ceros delante del
nmero.
2, indica la precisin, indica el nmero de dicimales
que se mostrarn a la derecha del punto decimal
f, indica que se utilizar la notacin (entero.decimal)
por ejemplo 17.09
e, indica que se utilizar la notacin exponencial, por
ejemplo1.709e+001
i, indica entero
g, formato corto
Vamos a calcular el alcance de un proyectil disparado
con velocidad de 46.325 m/s haciendo un ngulo de
32 mediante la siguiente frmula.
x=v20sin(2)g
Escribimos el script prueba para probar la
funcin fprintf
ang=32;
v0=46.325;
x=v0*v0*sind(2*ang)/9.8;
fprintf('velocidad %2.4f m/s, ngulo de tiro
%i, alcance %5.2f m\n',v0,ang,x)
El carcter \n al final del texto en la
funcin fprintf indica una nueva lnea, probar el efecto
al quitarlo. Las variables que guardan los
datos v0, ang y x se ponen al final en el mismo orden
que se citan en el texto separadas por comas. Se
sugiere al lector que pruebe otros formatos
Corremos el script en la ventana de comandos
>> prueba
velocidad 46.3250 m/s, ngulo de tiro 32,
alcance 196.82 m
La funcin sprintf
La funcin sprintf es similar a printf salvo que
imprime en una variable. Se utiliza en combinacin
con la funcin grficatext para mostrar valores de una
variable en un grfico
%cdigo para dibujar un grfico
plot(Vr,Pr,'r')
text(1,1.35,sprintf('presin %1.3f',p))
Vamos a ver como funciona en la ventana de
comandos. Guardamos el valor que imprime sprintf en
la variable str.
>> str=sprintf('el valor de pi es %1.3f',pi)
str =
el valor de pi es 3.142
Al final de fprintf se pone el carcter \n que indica una
nueva lnea, no es necesario en la funcin sprintf


Inicio
MATLAB
Bsico
Clculos aritmticos
Variables escalares
Vectores y matrices
Entrada/salida
Funciones
Ejemplos

MATLAB permite crear complejos grficos
bidimensionales y tridimensionales.
En la pgina dedicada al estudio de los vectores vimos
como se poda obtener la representacin grfica de un
vector de datos directamente en la
ventana Workspace.
En la ventana de comandos podemos obtener la misma
representacin proporcionando el vector de datos y
llmando al comando plot.
>> y=[0,0.38,0.71,0.92,1.00,0.92,0.71,0.38,0];
>> plot(y)
El comando plot(x,y) se utiliza para crear una
representacin grfica bidimensional, donde x e y son
vectores. Si se pasa el vector y de los datos, plot(y)
MATLAB entiende que x es el vector de los
ndices x=[1,2,3...];. Sea ahora,
>> x=[0 10 20 30 40 50 60 70 80];
>> y=[0 0.73 1.10 1.29 1.40 1.46 1.50 1.52
1.53];
>> plot(x,y)
Esto es todo lo que se precisa para hacer
representacin grfica en la ventana
denominada Figure Window: Proporcionar los
vectores de datos x e y (que tienen que tener el mismo
nmero de elementos) y la llamada al comandoplot.
Las decoraciones del grfico (etiquetas en el eje X y
en el eje Y, ttulo, etc.) se pueden hacer mediante
llamadas a comandos (xlabel, ylabel, title, etc.) o en la
propia ventana grfica, seleccionando los elementos
apropiados del men, en particular Tools->Edit Plot.
(Ms abajo, explicaremos brevemente esta opcin)
El comando plot tiene parmetros adicionales que nos
permiten especificar el color y tipo de lnea o los
smbolos utilizados como marcadores. Por ejemplo
plot(x,y,'-
mo','linewidth',2,'markersize',12, 'markeredgecolor','g','
markerfacecolor','y')
Los dos primeros parmetros de plot son las
coordenadas de los puntos (x
i
, y
i
) contenidos
vectores x e y. El tercer parmetro es el especificador
de lnea que puede contener tres datos '-mo' entre
comillas simples:
Estilo de lnea (- significa slido, por defecto)
Color de lnea (m significa magenta)
Marcador (o significa crculo)
Las posibles opciones son:
Color Smbolo Estilo de lnea Smbolo
Azul (defecto) b Slido(defecto) -
Verde g A puntos :
Rojo r raya-punto -.
Cian c rayas --
Magenta m
Amarillo y
Negro k
Blanco w
Opciones de smbolos para marcar puntos en la
grfica
o crculo v Tringulo (hacia abajo)
. punto X Tringulo (hacia arriba)
x marca X < Tringulo (hacia la izquierda)
+ ms > Tringulo (hacia la derecha)
* estrella p pentagrama
s cuadrado h hexagrama
d diamante
Se pueden tambin especificar las siguientes
propiedades entre comillas simples y a continuacin,
sus valores:
linewidth, especifica la anchura de lnea su valor por
defecto es 0.5
markersize, especifica el tamao del smbolo que
marca los puntos
markeredgecolor, especifica el color de borde del
smbolo que marca los puntos
markerfacecolor, especifica el color de relleno del
smbolo que marca los puntos
Ejemplos de plot:
plot(x,y), una lnea azul slida concecta los puntos (x
i
,
y
i
)
plot(x,y,'r'), una lnea roja slida conecta los puntos
(x
i
, y
i
)
plot(x, y,':g'), una lnea de puntos de color verde
conecta los puntos (x
i
, y
i
)
plot(x,y,'--ro','linewidth',2,'markersize',8), ejemplo
ms abajo
Vectores de datos
En un experimento de carga de un condensador se ha
medido la diferencia de potencial V entre las placas del
condensador en funcin del tiempo t, desde que se
conecta la batera.
t (s) 0 10 20 30 40 50 60 70 80
V (V) 0.0 0.73 1.10 1.29 1.40 1.46 1.50 1.52 1.53
>> t=[0 10 20 30 40 50 60 70 80];
>> V=[0 0.73 1.10 1.29 1.40 1.46 1.50 1.52
1.53];
>> plot(t,V,'--
ro','linewidth',2,'markersize',6,'markeredgecol
or','b','markerfacecolor','b')
>> title('Carga de un condensador')
>> xlabel('t(s)')
>> ylabel('d.d.p (V)')

En un experimento de descarga de un condensador se
ha medido la diferencia de potencial V entre las placas
del condensador en funcin del tiempo t.
t (s) 10 20 30 40 50 60 70
V (V) 0.82 0.45 0.26 0.15 0.08 0.05 0.03
Crear una tabla de datos y un grfico, similar al de la
figura anterior.
Grfica de una funcin, plot
Vamos a obtener una tabla de datos de la funcin
coseno, utilizando como argumento grados, cosd(x) y
representarla en el intervalo de 0 a 360, tomando un
intervalo de 10
>> x=0:10:360;
>> y=cosd(x);
>> plot(x,y)
>> grid on %rejilla
>> title('y=cos(x)')
>> xlabel('x')
>> ylabel('y')

Funcin definida en forma paramtrica
Representaremos las denominadas figuras de
Lissajous, que se observan en la pantalla de un
osciloscopio, cuando se introducen seales senoidales
de la misma o de distinta frecuencia por las entradas X
e Y.
x=Asin(
x
t)
y=Asin(
y
t+)
wx=input('Frecuencia angular X: ');
wy=input('Frecuencia angular Y: ');
delta=input('Desfase (grados): ');
t=0:360;
x=sind(wx*t);
y=sind(wy*t+delta);
plot(x,y,'r');
text(0,0.2,'\omega_x/\omega_y=2/1')
xlabel('x');
ylabel('y')
title('Figuras de Lissajous')

Introducimos los valores de las frecuencias
angulares
x
,
y
y del desfase
Frecuencia angular X: 2
Frecuencia angular Y: 1
Desfase (grados): 90
El comando text permite escribir un mensaje
(caracteres entre comillas simples) en las
coordendas x e y especificadas. En este caso, el
mensaje consiste en el cociente de frecuencias
angulares
x
/
y
.
Para escribir una letra griega se antepone el carcter \.
Por ejemplo, es \alpha, es \omega, etc. Para poner
un subndice se antepone el caracter _. Por ejemplo
para que aprezca x
1
se escribe x_1
Varias grficas en la misma
ventana, hold
La ecuacin de una oscilacin amortiguada es
x=Bexp(-t) sin(t+)
donde B y se determinan a partir de las condiciones
iniciales
Sea la oscilacin amortiguada
x=5.0 exp(-7 t) sin(100 t+1.5)
Queremos representar a la vez,
El desplazamiento x en funcin del tiempo t
La amplitud A=5.0 exp(-7 t), en funcin del tiempo t
Ulizamos el comando hold on para representar varias
grficas en la misma ventana. Escribimos el
script amortiguadasque guardamos un fichero .M
t=linspace(0,0.7,100);
x=5*exp(-7*t).*sin(100*t+1.5);
A=5*exp(-7*t);
hold on
plot(t,x,'r')
plot(t,A,'b')
plot(t,-A,'b')
hold off
legend('desplazamiento','amplitud')
title('Oscilaciones amortiguadas')
xlabel('t')
ylabel('x')

Una forma alternativa utilizando el comando plot
x=5*exp(-7*t).*sin(100*t+1.5);
A=5*exp(-7*t);
plot(t,x,'r',t,A,'b',t,-A) % (t,x) en rojo
'r', (t,A) en azul 'b', (t,-A) sigue en azul
xlabel('t')
ylabel('x')
O bien, guardando los datos de la oscilacin
amortiguada x y de la amplitud A (positiva y negativa)
en un vector z.
z=[5*exp(-7*t).*sin(100*t+1.5);5*exp(-7*t);-
5*exp(-7*t)];
plot(t,z)
xlabel('t')
ylabel('x')
Otra forma, utilizando el comando line
x=5*exp(-7*t).*sin(100*t+1.5);
A=5*exp(-7*t);
plot(t,x,'r')
line(t,A,'color','b') %propiedad: 'color',
valor: 'b' (azul)
line(t,-A)
xlabel('t')
ylabel('x')
Los dos primeros parmetros del comando line son los
vectores x e y de datos. Los siguientes son propiedad
entre comillas simples, seguido del valor de la
propiedad, por ejemplo:
line(x,y,'linestyle','--','color','r','marker','o')
La diferencia principal entre plot y line, es
que plot abre una ventana grfica cada vez que es
ejecutado, mientas que lineaade grficas a la ventana
abierta previamente con plot, como en el script
anterior
Rellenando reas de color, fill
El comando fill rellena reas del color especificado
>> x=0:pi/40:2*pi;
>>
fill(sin(x),cos(x),'g',0.7*sin(x),0.7*cos(x),'y
')
>> axis equal

Decorando las grficas
Ya hemos visto el efecto
de xlabel, ylabel, title y legend en el ejemplo anterior
para poner un ttulo a la grfica (title), identificar el eje
X (xlabel) el eje Y (ylabel) y cada una de las grficas
en la misma ventana (legend)
legend
El comando legend es ms complejo que los otros
comandos y admite la forma siguiente:
legend('grafica1','grafica2', ..... ,pos)
El orden en el que se ponen las etiquetas corresponde
al que se crean las grficas. En el ejemplo anterior,
primero se crea la grfica de la posicin (t,x) y despus
las dos grficas de la amplitud (t,A)
El ltimo parmetro pos es un nmero opcional que
especifica la posicin de legend en la ventana. Sus
posibles valores son: -1, 0, 1, 2 3, 4. El valor pos=1 es
el valor por defecto y es el que aparece en la figura
anterior. Se sugiere al lector que pruebe el efecto de
los otros cinco valores.
axis
Cuando se ejecuta el comando plot(x,y) MATLAB
crea un eje X y un eje Y cuyos lmites se deducen a
partir de los valores mximo y mnimo de cada uno de
los vectores x e y.
El comando axis permite cambiar el rango y la
apariencia de los ejes
axis([xmin,xmax,ymin,ymax]), establece nuevos lmites
a los ejes X e Y
axis equal, establece la misma escala para ambos ejes
axis square, regin cuadrada
axis tight, ajusta los lmites de los ejes al rango de los
datos
Probamos el aspecto de una elipse de semieje mayor 2
y semieje menor 1 segn los ejes
>> t=0:pi/40:2*pi;
>> plot(2*sin(t),cos(t))
>> xlabel('2sin(t)')
>> ylabel('cos(t)')
>> axis equal
>> axis square
>> axis equal tight

Autoescalado

En la figura de la izquierda no hemos utilizado el
comando axis, lmites a los ejes, MATLAB los
establece a partir de los valores mximo y mnimo de
X y de Y. Sin embargo, en la figura de la derecha
hemos establecido lmites a los ejes:ymin=0.5
e ymax=1.5, el lmite xmax=6, pero no hemos
establecido un xmin concreto. Poniendo xmin=-
Inf (menos infinito) dejamos a MATLAB que escale
la figura. El efecto lo vemos comparando ambas
figuras.
g=0.25;
t=linspace(0,15,100);
w=sqrt(1-g^2);
x=1-exp(-g*t).*(g*sin(w*t)/w+cos(w*t));
plot(t,x,'r')
axis([-Inf,6,0.5,1.5])
title('Escaln')
xlabel('\omega_0t')
ylabel('x(t)')
grid on
xlim, ylim
Establece los lmites en el eje horizontal X y en el
vertical Y. Por ejemplo, xlim([0 12]) indica el valor
mnimo y mximo de la abscisa que se va a representar
en la ventana grfica.
grid
grid on,aade una rejilla a la grfica como en la
primera figura
grid off, (por defecto) no aade la rejilla
text
Para poner un texto en la figura en la posicin
especificada por las coordendas x e y.
text(x,y,'mensaje')
El primer carcter del texto que se le pasa a text entre
comillas simples se pone en el punto de coordendas
(x,y)
El texto que se le pasa a los
comandos xlabel, ylabel, title y text, puede contener
caracteres de distinta fuente de texto y tamao, letra en
negrita, cursiva; subndices y superndices, caracteres
griegos. El texto incluso se puede rotar para que
aparezca vertical o en otra orientacin. Consultar en el
sistema de ayuda (Help Window) Text y Text
Properties para ver el efecto de las distintas opciones.
Por ejemplo, para cambiar la fuente de texto por
defecto a otra de mayor tamao, 18 puntos, se
escribe
text(x,y,'mensaje','FontSize',18)
La funcin stem
Se ha analizado una seal peridica y los
coeficientes b
n
(seno) del desarrollo en serie de Fourier
tienen la expresin
bn=2(1)nn
Representamos mediante stem la contribucin de cada
uno de los armnicos (n=1,2,3...) al desarrollo en serie
de Fourier de la funcin.
n=1:11;
bn=(-1).^n*2./(n*pi);
stem(bn)
title('Espectro de frecuencias')
xlabel('n')
ylabel('b_n')
xlim([0 12])

Diagrama de barras, bar
Se han realizado las siguientes observaciones de la
velocidad del viento en una estacin meteorolgica.
Medimos el nmero de horas en las que la velocidad
del viento tena un valor medio comprendido entre 0 y
1 m/s, entre 1 y 2, ... entre 22 y 23.
Velocid
ad
0.
5
1.
5
2.
5
3.
5
4.
5
5.
5
6.
5
7.
5
8.
5
9.
5
10.
5
11.
5
12.
5
13.
5
14.
5
15.
5
16.
5
17.
5
18.
5
19.
5
20.
5
21.
5
Horas 6 31 30 50 69 75 60 59 69 61 43 44 54 43 21 11 7 4 2 1 1 3
Vamos a representar las frecuencias mediante un
diagrama de barras.
x=0.5:21.5;
horas=[6,31,30,50,69,75,60,59,69,61,43,44,54,43
,21,11,7,4,2,1,1,3];

frec=horas/sum(horas);
bar(frec,'c');
title('Distribucin Weibull')
xlabel('Observacin')
ylabel('Frecuencia')

Histogramas, hist
El intervalo (a, b) que abarca todos los datos, se divide
en subintervalos. El histograma es un diagrama de
barras verticales en el que la anchura de cada barra se
corresponde con el tamao del subintervalo y la altura
con el nmero de datos en dicho subintervalo.
Por defecto, MATLAB divide el intervalo (a,b) en 10
subintervalos de la misma anchura. Es posible cambiar
este valor por defecto. Se le puede suministrar a la
funcin hist un vector x, cuyos valores son los centros
de cada uno de los subintervalos tal como vemos en la
figura, los subintervalos pueden tener distinta anchura.

Se miden las temperaturas a lo largo de un periodo de
30 das en una ciudad. La temperatura mnima es a=5
grados y la mxima b=35 grados. Dividimos el
intervalo en tres subintervalos centrados en 10, 20 y 30
grados que nos indican el nmero de das con
temperatura fra, templada y clida.
Las temperaturas se generan de forma aleatoria
mediante la funcin rand
a=5; %temperatura mnima
b=35; %temperatura mxima
T=round(a+(b-a)*rand(30,1)); %30 temperaturas
al azar
x=a+5:10:b;
hist(T,x)
hg=findobj(gca,'Type','patch'); %color
set(hg,'FaceColor','c','EdgeColor','k')
xlabel('Temperatura')
ylabel('n. de das')
title('Temperatura en una ciudad')

Grficos semilogartmicos, semilog
Son tiles cuando hacemos representaciones grficas
de funciones exponenciales o potenciales.
Representamos la funcin 10 exp(-2 x) utilizando el
comando semilogy.
x=linspace(0,3);
y=10*exp(-2*x);
semilogy(x,y)
grid on

Grficas polares, polar
Las coordenadas polares
especifican un punto en trminos de la distancia
(radio) al origenr y el ngulo que forma con el eje X.
La espiral logartmica es una de las curvas notables
junto a la catenaria, la cicloide, etc. La ecuacin de la
espiral logartmica en coordenadas polares es
r=r
0
exp(b )
Donde r
0
es el radio inicial, b es un parmetro, y es el
ngulo en radianes.
Creamos el script espiral y lo guardamos en el fichero
.m para examinar el papel de los parmetros: radio
inicial r
0
, yparmetro b.
r0=0.4;
b=0.05;
ang=0:pi/18:9*pi/2;
r=r0*exp(b*ang);
polar(ang,r,'r')
title('Espiral logartmica')

Utilizando la funcin pol2cart, que convierte
coordendas polares a coordenadas rectangulares,
obtenemos un resultado similar mediante el
comando plot en vez del comando polar
r0=0.4;
b=0.05;
ang=0:pi/18:9*pi/2;
r=r0*exp(b*ang);
[x,y]=pol2cart(ang,r);
plot(x,y,'r')
axis equal
title('Espiral logartmica')
grid on
En Internet se pueden encontrar las ecuaciones de
curvas polares como las cardiodes
r=b+a cos
r=b+a sin
en los siguientes casos: b<a, a<b<2a, 2ab. El primero
es el ms interesante.
Otra curva es la denominada ptalos de una rosa
r=a cos(n)
donde n es el nmero entero: 2, 3, 4, 6...
La lemniscata de Bernoulli
r
2
=2a
2
cos(2)
Varias zonas grficas en la misma
ventana, subplot
El comando subplot(m,n,p) divide la ventana grfica
Figure Window en mn ventanas rectangulares
grficas ms pequeas dispuestas en forma de matriz
en m filas y n columnas. Cada ventana est numerada
de 1 a mn tal como se indica en la figura.

Por ejemplo el comando subplot(2,3,2) crea seis reas
rectangulares ordenadas en dos filas y tres columnas
como se muestra en la figura y hace el rea marcada
en amarillo p=2 como actual.
La posicin velocidad y energa de un oscilador
amortiguado son, respectivamente.
x=Aexp(t)sin(t+)
2=202v=dxdt=Aexp(t)sin(t+)+Aexp(t)cos(t
+)E=12mv2+12m20x2=12m20A2exp(2t)(10sin(2(0
t+)))
Sea un oscilador amortiguado de amplitud A=5.01,
fase inicial =1.5 rad, frecuencia angular
natural
0
=100 rad/s y constante de amortiguamiento
=7 s
-1

Creamos el script amortiguadas_1 para
1. Crear cuatro zonas grficas en la misma ventana con
el comando subplot
2. Representar en la primera zona, la posicin x en
funcin del tiempo t
3. Representar en la segunda, la energa e del oscilador
en funcin del tiempo t
4. Representar en la tercera, la velocidad v del mvil en
funcin del tiempo t
5. Respresentar en la cuarta, la velocidad del mvil v en
funcin de su posicin x (espacio de las fases)
g=7; %amortiguamiento
w0=100; %frecuencia angular natural
fi=1.5; %fase
A=5.01; %amplitud
w=sqrt(w0*w0-g*g);
x=A*exp(-g*t).*sin(w*t+fi);
v=-g*A*exp(-g*t).*sin(w*t+fi)+w*A*exp(-
g*t).*cos(w*t+fi);
e=(v.^2+w0*w0*x.^2)/2;
subplot(2,2,1)
plot(t,x)
grid on
xlabel('tiempo (s)')
ylabel('posicin (m)')
subplot(2,2,2)
plot(t,e)
grid on
ylabel('energa (J)')
subplot(2,2,3)
plot(t,v)
grid on
ylabel('velocidad (m/s)')
subplot(2,2,4)
plot(x,v)
grid on
xlabel('posicin (m)')
script amortiguadas_1
>> amortiguadas_1

Varias ventanas grficas, figure
Es posible abrir varias ventanas grficas mediante el
comando figure. MATLAB nombra cada ventana
como Figure 1, Figure 2, Figure 3, etc.
Las ventanas grficas se pueden cerrar con el
comando close que cierra la ventana activa, close(n)
cierra la ventana n yclose all cierra todas las ventanas
grficas
Creamos el script amortiguadas_2 para abrir cuatro
ventanas grficas
1. Representar en la primera, la posicin x en funcin
del tiempo t
2. Representar en la segunda, la energa e del oscilador
en funcin del tiempo t
3. Representar en la tercera, la velocidad v del mvil en
funcin del tiempo t
4. Respresentar en la cuarta, la velocidad del mvil v en
funcin de su posicin x (espacio de las fases)
g=7; %amortiguamiento
w0=100; %frecuencia angular natural
fi=1.5; %fase
A=5.01; %amplitud
w=sqrt(w0*w0-g*g);
x=A*exp(-g*t).*sin(w*t+fi);
v=-g*A*exp(-g*t).*sin(w*t+fi)+w*A*exp(-
g*t).*cos(w*t+fi);
e=(v.^2+w0*w0*x.^2)/2;
plot(t,x)
grid on
ylabel('posicin (m)')
figure
plot(t,e)
grid on
ylabel('energa (J)')
figure
plot(t,v)
grid on
figure
plot(x,v)
grid on
xlabel('posicin (m)')
script amortiguadas_2
>> amortiguadas_2
nos aparecen cuatro ventanas grficas: Figure 1,
Figure 2, Figure 3 y Figure 4.

Una vez examinadas, cerramos todas las ventanas
grficas
>> close all
Manejadores de los grficos
Siempre que MATLAB crea un grfico, crea un
manejador (handle) para este grfico. Vamos a ver
mediante ejemplos como se pueden cambiar las
propiedades del grfico mediante manejadores.
La funcin plot devuelve el manejador del grfico
actual, mediante la funcin set se pueden cambiar sus
propiedades.
>> x=0:pi/30:2*pi;
>> hg=plot(x,sin(x));
>> set(hg,'color','r','linewidth',3)
El grfico que inicialmente tena color azul (por
defecto) cambia a color rojo. La anchura de lnea
inicial que es por defecto de un punto cambia a tres.
gca es una referencia (handle) que identifica los ejes
de la grfica y a travs de este manejador podemos
cambiar el aspecto d elos ejes. xTick es la propiedad
(divisin del eje horizontal) y a continuacin, se pone
el nuevo valor de dicha propiedad 0:pi/2:2*pi.
x = 0:.02:2*pi;
y = cos(x);
plot(x,y)
set(gca,'XTick',0:pi/2:2*pi)
set(gca,'XTickLabel',{'0','pi/2','pi','3pi/2','
2pi'})
set(gca,'YTick',-1:0.25:1)

De esta forma, podemos cambiar la divisin por
defecto de los ejes X e Y.
Combinando ejes lineales y logartmicos
Podemos utilizar plotyy para comparar dos grficas
que tinene distintas escalas
a=1000;b=0.005;
t=0:900;
y1=a*exp(-b*t);
y2=sin(b*t);
[ha,h1,h2] =
plotyy(t,y1,t,y2,'semilogy','plot');
axes(ha(1)) %eje de la izquierda
ylabel('Semilogartmico')
axes(ha(2)) %eje de la derecha
ylabel('Lineal')
set(h2,'linewidth',1.5) %grfica 2
Dibujamos la primera funcin y1 a escala
semilogartmica y la segunda funcin y2 a escala
normal. El comando plotyydevuelve una referencia
(handle) a los ejes en ha, una referencia al primer
grfico en h1 y una referencia al segundo enh2. Como
hay dos ejes ha es un vector de dos elementos, ha(1) es
una referencia al eje izquierdo y ha(2) al eje derecho.
Modificamos la anchura de lnea del segundo
grfico h2 con la funcin set.

Edicin en la ventana de los grficos
Escribimos en la ventana de comandos
>> x=0:pi/40:2*pi;
>> plot(x,cos(x))
En la ventana de los grficos (Figure Window)
podemos cambiar las propiedades de un grfico.
Seleccionamos Tools->Edit Plot
Se selecciona el grfico con el cursor, aparecen
cuadrados de color negro (handles), se pulsa el botn
derecho del ratn estando el grfico seleccionado,
aparece el men de la figura, que nos permite cambiar
varias propiedades del grfico: color, anchura y estilo
de lnea, marcador, etc.

Se puede utilizar el men Insert para establecer las
etiquetas de los ejes (xlabel, ylabel), el ttulo
(title), legend, etc. Dibujar lneas, elipses, rectngulos,
insertar textos, etc.
Seleccionando Show Property Editor, o bien, en el
men View->Property Editor o en el men Edit-
>(Figure Properties, Axes properties, Current
Object Properties, Colormap) aparece una ventana
que nos permite cambiar las propiedades del grfico de
forma interactiva. Pulsamos en el botn More
properties... aparece una tabla (Inspector) de
propiedades del objeto seleccionado que podemos
modificar.
La edicin interactiva en la ventana de los
grficos, nos permite prepararlos para presentaciones,
pero escasamente se utilizar en los clculos, por lo
que queda al lector la tarea de explorar sus numerosas
opciones, consultando el extenso
documento MATLAB Graphics


Inicio
MATLAB
Bsico
Clculos aritmticos
Variables escalares
Vectores y matrices
Entrada/salida
Funciones
Ejemplos

Funciones
Estamos acostumbrados a trabajar con funciones del
tipo y=f(x) donde f(x) es una expresin matemtica en
trminos de la variable x. Se calcula un valor
de y (salida) cuando se proporciona un valor
de x (entrada) en la expresin. MATLAB define
muchas funciones como sin(x), sqrt(x), etc.
Podemos definir nuestras propias funciones guardarlas
en un fichero y usarlas de un modo semejante a las
funciones predefinidas. En muchos casos las funciones
son los componentes bsicos dentro de un programa de
ordenador. Habitualmente, un programa se subdivide
en tareas y cada una de ellas es llevada a cabo por una
funcin, a esta forma de resolver los problemas se
denomina programacin estructurada.
La principal ventaja de las funciones es la posibilidad
de reutilizar el cdigo en otros programas distintos al
cual fueron definidas.
La entrada y la salida puede ser una o varias variables,
cada una de ellas puede ser un escalar, un vector o una
matriz de cualquier tamao.

Definicin de una funcin
Las funciones se crean del mismo modo que un script
seleccionado en el men File/New/Function y se
guardan en un fichero que tiene el mismo nombre que
la funcin y extensin .m

La primera lnea en el editor es la definicin de la
funcin que comienza con la palabra clave function
function
variables_salida=nombre_funcion(variables_entra
da)
sentencias
end
nombre_funcion, es el nombre significativo que se le
asigna a la funcin y coincide con el nombre del
fichero de extensin .m en el que se guarda el cdigo
de dicha funcin. Las reglas para nombrar un funcin
son las mismas que para las variables, los nombres
no deben de incluir espacios, ni se pueden utilizar
plabras reservadas por MATLAB.
variables_entrada, es el conjunto de parmetros que
se le pasa a la funcin. Los nombres de las variables
van entre parntesis y separadas por coma.
variabales_salida, es el valor o conjunto de valores
de las variables devueltos por la funcin. Las
variables de salida van despus de la palabra
reservada function entre corchetes cuadrados y
separados por comas si hay varios.
sentencias, lneas de cdigo que tomando los valores
de los parmetros de entrada calculan mediante
expresiones los valores que devuelve la funcin.
end, marca el final de la funcin es opcional (salvo
en las funciones anidadas) pero es conveniente
acostumbrarse a ponerlo al finalizar la funcin.
Opcionalmente, en la segunda lnea se pone un
comentario, en el que se explica la tarea que realiza la
funcin. A continuacin, una explicacin detallada
sobre las variables de entrada y de salida
Cuando una funcin no devuelve ningn valor, se
define
function nombre_funcion(variables_entrada)
Cuando una funcion no precisa de variables de
entrada se define
function variables_salida=nombre_funcion
Cuando una funcin devuelve una solo resultado y se
puede escribir, de dos maneras
function [y]=nombre_funcion(a,b,c)
function y=nombre_funcion(a,b,c)
En general, definiremos una funcin del siguiente
modo:
function [y1,y2]=nombre_funcion(a,b,c)
con tres argumentos a, b y c variables de entrada y
que devuelve dos resultados en las variables y1
e y2.
Una funcin se llama del mismo modo que las
funciones predefinidas. Las funciones se pueden
llamar desde la ventana de comandos, desde un fichero
script o desde otra funcin.
Todas las variables en una funcin son locales a dicha
funcin, incluyendo las de entrada y las de salida.
Vamos a ver unos cuantos ejemplos en esta pgina de
funciones.
Ejemplos
Suma de dos nmeros
Empezaremos por una funcin suma que realiza la
siguiente tarea, suma de dos nmeros x e y y devuelve
la suma z=x+y
Definicin de la funcin
function [z] = suma (x,y)
%Esta funcin suma dos nmeros x e y
%y devuelve el resultado de la suma en z

z=x+y; %efecta la suma
end
A la funcin suma se le pasan dos datos en las
variables x e y, y devuelve el resultado en la variable z.
La funcin se guarda en un fichero
El fichero que guarda la funcin tiene el mismo
nombre que la funcin, tal como vemos al seleccionar
en el EditorFile/Save as...

Llamada a la funcin
La llamada a la funcin se puede hacer desde la
ventana de comandos
>> suma(2,3)
ans = 5

Se puede hacer desde un script
a=3;
b=2;
res=suma(a,b);
disp(res)
En la llamada a la funcin suma su
parmetro x adquiere el valor del primer argumento a,
el segundo parmetro y toma el valor del argumento b,
se efecta la suma en el cuerpo de la funcin, se
guarda el resultado en la variable z que devuelve la
funcin. El valor que guarda z se copia en la
variable res. Las variables x, y y z son locales a la
funcin y por tanto, no aparecen en la
ventana Workspace, no se puede acceder a ellas desde
la ventana de comandos.
Como hemos visto hay que pasar los valores que
guardan las variables a y b a la funcin suma por que
una funcin no tiene acceso a las variables declaradas
en un script o en la ventana de comandos.

Sistema de ayuda
En la ventana de comandos escribimos
>> help suma
Esta funcin suma dos nmeros x e y
y devuelve el resultado de la suma en z
aparecen los comentarios que hemos puesto al
principio de la funcin, pero no aparecen el
comentario "efecta la suma", que hemos puesto en la
tercera lnea.
Movimiento de cada de los cuerpos

Las ecuaciones que describen el movimiento de cada
de los cuerpos son:
v=v0+gtx=x0+v0t+12gt2
Donde v
0
y x
0
es la velocidad inicial y la posicin
inicial, respectivamente.
Vamos a crear una funcin
denominada caida_libre que admita como parmetros
el tiempo t y devuelva la posicin x y velocidad v de un
mvil que se lanza desde 200 m de altura con
velocidad de 40 m/s. La aceleracin constante de la
gravedadg=-10 m/s
2

v=40-10 t
x=200+40 t-5 t
2

Seleccionamos File/New/Function para abrir el editor
de funciones.
1. Definimos la funcin:
o La palabra clave function
o Las variables de salida entre corchetes cuadrados
[x,v]
o El operador asignacin =
o El nombre de la funcin, caida_libre
o Entre parntesis la variable de entrada (t)
2. Escribimos el cuerpo de la funcin con dos
sentencias que calculan la velocidad v y la
posicin x cuando se proporciona el dato del tiempo t
3. Finalizamos con end.
4. Seleccionamos File/Save As.. para guardar la
funcin en el fichero caida_libre.m con el mismo
nombre que la funcin.
function [x,v] = caida_libre(t)
v=40-10*t;
x=200+40*t-5*t^2;
end
En la ventana de comandos se llama a esta
funcin caida_libre, pasndole un tiempo t=2 s, del
siguiente modo
>> [pos,vel]=caida_libre(2)
pos = 240
vel = 20
Que calcula y muestra, la velocidad v=20 m/s y la
posicin x=240 m en el instante t=2 s
En la llamada a la funcin caida_libre el
parmetro t adquiere el valor de 2, en las dos
sentencias se calcula la velocidad y posicin y se
guardan en las variables locales v y x. La funcin
devuelve estos dos valores que se copian en las
variables vel y pos de la ventana de comandos. En la
ventana de comandos no tenemos acceso a las
variables t, v y xpor ser locales a la
funcin caida_libre y desaparecen cuando termina de
ejecutarse, pero si tenemos acceso a las
variables vel y pos que guardan los resultados del
clculo realizado en el cuerpo de la funcin.
Si intentamos acceder a la variable x o t obtendremos
un mensaje de error
>> x,t
??? Undefined function or variable 'x'.
Si queremos que la funcin caida_libre calcule la
posicin y velocidad del mvil para una secuencia
(vector) de tiempost, tendremos que modificar la
definicin de dicha funcin
function [x,v] = caida_libre(t)
v=40-10*t;
x=200+40*t-5*t.^2;
end
En la ventana de comandos se llama a esta
funcin caida_libre, pasndole los
tiempos t=[0,2,4,6,8,10] o bien, t=0:2:10 , del
siguiente modo
>> t=0:2:10;
>> [pos,vel]=caida_libre(t)
pos = 200 260 280 260 200 100
vel = 40 20 0 -20 -40 -60
Media y desviacin estndar de un conjunto de
datos
La definicin de media y desviacin estndar es la
siguiente
<x>=1nxin =1n(xix)2n1
Creamos una funcin denominada estadistica a la que
se le pasa un vector x de datos y devuelve la
media med y la desviacin, des, y la guardamos en un
fichero con el mismo nombre que la funcin
function [med,des]=estadistica(x)
n=length(x);
med=sum(x)/n;
des=sqrt(sum((x-med).^2/(n-1)));
end
La funcin sum calcula la suma de los elementos de
un vector x
La funcin length, calcula el nmero de elementos
del vector x.
Calcular la media y la desviacin estndar de la altura
de los 10 alumnos de una clase:
1.65, 1.82, 1.72, 1.75, 1.73, 1.85, 1.90, 1.74, 1.76,
1.77.
Escribimos el nombre de la funcin estadistica en la
ventana de comandos y le pasamos el vector de datos
>> [media, desviacion]=estadistica([1.65 1.82
1.72 1.75 1.73 1.85 1.90 1.74 1.76 1.77])
media = 1.7690
desviacion = 0.0713
MATLAB dispone de dos funciones que calculan la
media mean y la desviacin estndar, std.
>> x=[1.65 1.82 1.72 1.75 1.73 1.85 1.90 1.74
1.76 1.77];
>> mean(x)
ans = 1.7690
>> std(x)
ans = 0.0713
Funciones definidas en el mismo
fichero
Un fichero funcin puede contener ms de una
funcin. Las funciones se definen una a continuacin
de la otra. La primera funcin es la primaria y tiene el
mismo nombre que el fichero, las otras funciones son
secundarias y se denominan subfunciones y pueden
estar en cualquier orden dentro del fichero. Solamente
se puede llamar a la funcin primaria en la ventana de
comandos o por otras funciones. Cada funcin tiene
sus propias variables que son locales a la funcin, no
se puede acceder a las variables de una subfuncin
desde la funcin primaria o desde otra subfuncin. No
se puede acceder a las variables de la funcin primaria
desde una subfuncin.
Las subfunciones permiten organizar tareas grandes en
otras ms pequeas.
Ms adelante veremos la utilidad de estas funciones
cuando los programas sean ms largos y complejos, de
momento vamos a ver un ejemplo que nos permita
vislumbrar como se definen y llaman las subfunciones.
Ecuacin de segundo grado
ax
2
+bx+c=0
Las races son x
1
y x
2
y tienen las siguientes
propiedades:
x1=b+b24ac2a
x2=bb24ac2ax1+x2=ba x1x2=ca
Vamos a crear una funcin que nos permita comprobar
las propiedades de las races de una ecuacin de
segundo grado, y dos subfunciones, la primera calcula
la raz x
1
y la segunda la raz x
2
.
En el editor de funciones creamos la
funcin comprobar_raices, a la que se le pasa los
coeficientes a, b y c de la ecuacin de segundo grado y
devuelve los cocientes -b/a y c/a de la suma y
producto de las dos races x
1
y x
2
. Guardamos el
cdigo de la funcin primaria comprobar_raices y de
las subfunciones calcula_raiz1 y calcula_raiz2 en el
fichero comprobar_raices.m
function [r1,r2]=comprobar_raices(a,b,c)
x1=calcula_raiz1(a,b,c);
x2=calcula_raiz2(a,b,c);
r1=x1+x2;
r2=x1*x2;
end

function raiz=calcula_raiz1(a,b,c)
raiz=(-b+sqrt(b*b-4*a*c))/(2*a);
end

function raiz = calcula_raiz2(a,b,c)
raiz=(-b-sqrt(b*b-4*a*c))/(2*a);
end
Para comprobar las races de la ecuacin de segundo
grado x
2
-x-6=0, llamamos a la
funcin comprobar_raices y le pasamos los
coeficientes 1,-1,-6 y nos devolver -b/a=1 y c/a=-6
>> [b_a,c_a]=comprobar_raices(1,-1,-6)
b_a = 1
c_a = -6
Funciones anidadas
Una funcin anidada es una funcin definida dentro de
otra funcin. Las funcin primaria y las anidadas
deben obligatoriamente terminar con end
Las funciones anidadas tiene acceso a las variables de
la funcin primaria y la funcin primaria tiene acceso
a las variables definidas por la funcin anidada.
Una funcin anidada puede contener otra y as
sucesivamente, pero este proceso puede llevar a
confusin. Existen reglas para llamar a una funcin
anidada dentro de otra pero no tiene por el momento
inters para el lector.
En el editor de funciones creamos la
funcin comprobar_raices1, a la que se le pasa los
coeficientes a, b y c de la ecuacin de segundo grado y
devuelve los cocientes -b/a y c/a de la suma y
producto de las dos races x
1
y x
2
. Guardamos el
cdigo de la funcin primaria comprobar_raices1 y de
las subfunciones calcula_raiz1 y calcula_raiz2 en el
fichero comprobar_raices1.m
function [r1,r2]=comprobar_raices1(a,b,c)
dis=sqrt(b*b-4*a*c);
calcula_raiz1;
calcula_raiz2;
r1=x1+x2;
r2=x1*x2;
function calcula_raiz1
x1=(-b+dis)/(2*a);
end
function calcula_raiz2
x1=(-b-dis)/(2*a);
end
end
Vemos que las funciones anidadas calcula_raiz1
y calcula_raiz2 tienen acceso a los
parmetros a, b y c de la funcin primaria, que son
variables locales a la funcin comprobar_raices y
tambin, a la variable local dis, que guarda el
discriminante de la ecuacin de segundo grado. Por
otra parte, la funcin primaria tiene acceso a las
variables x1 y x2 declaradas en cada una de las
funciones anidadas.
Estas funciones anidadas no precisan de variables de
entrada y no devuelven nada.
Para comprobar las races de la ecuacin de segundo
grado x
2
-x-6=0, llamamos a la
funcin comprobar_raices1 y le pasamos los
coeficientes 1,-1,-6 y nos devolver -b/a=1 y c/a=-6
>> [b_a,c_a]=comprobar_raices(1,-1,-6)
b_a = 1
c_a = -6
Como ejercicio se porpone al lector crear la
funcin estadistica_1, que devuelva la media y la
desviacin estndar, cuando se le pasa un vector de
datos. El valor medio se calcular mediante la funcin
anidada media y la desviacin estndar mediante la
funcin anidada desviacion.
Solucin
Funciones annimas
Las funciones annimas nos permiten definir una
funcin simple sin necesidad de crearla y guardarla en
un fichero .m. Se pueden definir en la ventana de
comandos, en un fichero script o dentro de otra
funcin, con la siguiente sintaxis:
variable=@(lista_argumentos) expresion
expresion consiste en una nica y vlida expresin,
puede tener una o ms variables de entrada que se
especifican en la lista de argumentos separadas por
comas. Puede incluir variables que se han definido
previamente
Las funciones se pueden asignar a variables y estas
variables se pueden pasar a otras funciones como se
pasan escalares o vectores. Ms adelante veremos
cmo se llama a una funcin dentro de otra funcin
que se le pasa en uno de sus parmetros.
Comparamos la definicin de una funcin func que se
guarda en un fichero func.m y su equivalente annima
function y=func(x)
y=cos(x)-x;
end
Llamada a la funcin
>> z=func(0.5)
z = 0.3776
Su equivalente annima se escribe en la ventana de
comandos sin necesidad de guardarla en un fichero y
se llama del mismo modo que cualquier otra funcin
>> f=@(x) cos(x)-x;
>> z=f(0.5)
z = 0.3776
f guarda un valor asociado a una funcin que
denominaremos manejador ( function handle)

En la ventana Workspace, vemos que aprece una
variable f de distinto tipo que guarda la referencia a la
funcin annima.
Teorema del coseno

Podemos calcular el lado c del tringulo si conocemos
los lados a y b y el ngulo comprendido , mediante el
teorema del coseno
c=a2+b22abcos
>> c=@(a,b,gamma) sqrt(a^2+b^2-
2*a*b*cosd(gamma));
>> lado=c(3,4,30)
lado = 2.0531
Llamada a una funcin desde otra
funcin
Existen mucha situaciones en las que una
funcin f1 utiliza otra funcin f2. Por ejemplo,
MATLAB tiene una funcinfzero que se utiliza para
calcular las races de una ecuacin f(x)=0. La
funcin f se le pasa a fzero cuando se llama para
encontrar las races de f(x). Hay varias formas de pasar
una funcin f a otra funcin para su uso.
Ya hemos visto el significado de manejador para una
funcin annima, un valor que guarda una
variable f o c y que est asociado a una funcin.
Si definimos una funcin de forma explcita en un
fichero por ejemplo, la funcin func, obtenemos el
manejador anteponiendo el carcter @ al nombre de la
funcin
La derivada de una funcin
Vamos ahora, a ver como se le pasa una funcin a otra
funcin en uno de sus parmetros.
La derivada primera dy/dx, de una funcin y=f(x) en
un punto x
0
, se puede calcular aproximadamente
mediante la frmula
dydx=f(x02h)8f(x0h)+8f(x0+h)f(x0+2h)12h
donde h un un nmero pequeo en comparacin
con x
0
. Escribir una funcin denominada derivada,
cuyos parmetros sean la funcin f, y la abscisa x
0
y
devuelva el valor de la derivada de la funcin f(x)
en x
0
.Tomar h=10
-5
. Utilizar la funcin derivada para
calcular las derivadas de las siguientes funciones,
comparando con los resultados exactos.
y=2x3x2+3 x0=1y=x2ex x0=0.25
function yp= derivada(f,x0)
h=1e-5;
yp=(f(x0-2*h)-8*f(x0-h)+8*f(x0+h)-
f(x0+2*h))/(12*h);
end
En la ventana de comandos, definimos la funcin
(annima) que queremos derivar y llamamos a la
funcin derivada.
>> f1=@(x) x^2*exp(x);
>> derivada(f1,0.25)
ans = 0.7223
Podemos calcular tambin la derivada segunda de una
funcin en un punto del siguiente modo
>> f1=@(x) x^3-6*x^2+3;
>> derivada(f1,2)
ans = -12.0000
>> f2=@(x) derivada(f1,x);
>> derivada(f2,2)
ans = 9.8686e-007
Podemos representar la funcin (en color azul), su
derivada primera (en color rojo) y su derivada segunda
(en color verde)
y=x36x2+3dydx=3x212xd2ydx2=6x12
x=-3:0.05:7;
f1=@(x) x.^3-6*x.^2+3;
y=f1(x); %funcin
yp=derivada(f1,x); %derivada primera
f2=@(x) derivada(f1,x);
ypp=derivada(f2,x); %derivada segunda
plot(x,y,'b',x,yp,'r',x,ypp,'g')
xlabel('x')
ylabel('y')
title('funcin y derivadas')
ylim([-50,50])
grid on

Representacin grfica de una funcin
Definimos una funcin denominada grafica y le
pasamos el manejador de la funcin cuya grfica
queremos representar en un determinado intervalo a, b.
La funcin no devuelve ningn valor.
function grafica(f, a, b)
x=linspace(a,b,50);
y=f(x);
plot(x,y,'r')
grid on
xlabel('x')
ylabel('y')
title('grfica de una funcin')
end
En la ventana de comando creamos una funcin
annima cuyo manejador es func y llamamos a la
funcin grafica, pasndole el manejador, el intervalo
(a,b) en el cual queremos representar la funcin
>> func=@(x) x-cos(x);
>> grafica(func,0,pi/2)
Aparece la ventana grfica

Definimos una funcin similar func1 y la guardamos
en un fichero func1.m
function y=func1(x)
y=cos(x)-x;
end
En la ventana de comandos llamamos a la
funcin grafica, pasndole el manejador de la
funcin func1, @func1 y el intervalo (a,b) en el cual
queremos representar la funcin.
>> grafica(@func1,0,pi/2)
Se obtiene la misma grfica
La funcin fplot
La funcin fplot dibuja una grfica si se le pasa la
funcin f en el primer parmetro y el intervalo [x
min
,
x
max
] en el segundo
>> f=@(x) x-5*(1-exp(-x));
>> fplot(f,[0 6]);
Alternativamente, fplot devuelve una tabla de valores
[x, y] que pueden ser utilizadas por la funcin plot(x,y)
para dibujar grfica, superponer una rejilla (grid),
poner ttulo (title) y etiquetas (xlabel, ylabel), etc. tal
como se muestra en el siguiente script
f=@(x) x-5*(1-exp(-x));
[x,y]=fplot(f,[0 6]);
plot(x,y)
grid on
xlabel('x')
ylabel('y')
title('grfica de una funcin')
Hay diferencias significativas entre plot y fplot. La
primera evala la funcin para valores
de x igualmente espaciados. Como vemos hay que
especificar el intervalo x o el nmero de puntos,
mientras que en la segunda no es necesario
especificarlo. fplot evala internamente la funcin ms
frecuentemente en aquellas regiones en las que cambia
rpidamente. En el siguiente ejemplo se dibuja la
siguiente funcin en el intervalo [0.01 0.1]
y=sin(1x)
>> x=0.01:0.001:0.1;
>> y=sin(1./x);
>> plot(x,y)
Tomando x=0.001, se obtiene una figura con baja
resolucin . Sin embargo,
>> f=@(x) sin(1/x);
>> fplot(f,[0.01 0.1])
Obtenemos una figura con mejor resolucin sin tener
que probar distintos valores de x o del nmero de
puntos.


Inicio
MATLAB
Bsico
Clculos aritmticos
Variables escalares
Vectores y matrices
Entrada/salida
Funciones
Ejemplos

La sentencia if

La sentencia if, acta como cabra esperar. Si la
condicin es verdadera, la sentencia se ejecuta, de otro
modo, se salta dicha sentencia, continuando la
ejecucin del programa con otras sentencias a
continuacin de sta. La forma general de la
sentencia if es:
if condicion
sentencias
end
Ejemplos
if a < b
if a >= 3
if b ~= 0
if (x>=2) & (x<10)
La sentencia if...else

La sentencia if...else completa la sentencia if, para
realizar una accin alternativa
if condicion
sentencias_1
else
sentencias_2
end
Las dos primeras lneas indican que si la condicin es
verdadera se ejecuta las sentencias 1. La palabra
clave else, significa que si la condicin no es
verdadera se ejecuta las sentencias 2, tal como se ve en
la figura.
Definicin de funciones
La funcin que calcula el signo de un nmero se
define de la siguiente forma: sign(x) devuelve -1 si x es
menor que 0, 1 six es mayor que 0, y 0 en el otro caso.
Creamos nuestra propia funcin que
denominaremos signo(x)que se comporta igual que la
funcin MATLAB sgn(x)
Creamos una funcion denominada signo, a la que se le
pasa un escalar como argumento en su parmetro x y
devuelve 1, 0 -1. La guardamos en el fichero
signo.m
function sgn = signo(x)
if x > 0
sgn = 1;
elseif x < 0
sgn = -1;
else
sgn = 0;
end
end
Probamos la funcin signo en la ventana de comandos
>> signo(-2)
ans = -1
>> signo(0)
ans = 0
>> signo(4)
ans = 1
Definimos la siguiente funcin
f(x)=0 x<0x 0x12x
1<x20 x>2
Vamos a trasladar la definicin matemtica a
cdigo,escribiendo en el editor de funciones
function y=f(x)
if x>=0 & x<=1
y=x;
elseif x>1 & x<=2
y=2-x;
else
y=0;
end
end
Probamos la funcin en la ventana de comandos
>> f(-1)
ans = 0
>> f(0.5)
ans = 0.5000
>> f(1.8)
ans = 0.2000
Sistemas de ecuaciones lineales
En la pgina Matrices consideramos un sistema de
ecuaciones lineales que podemos escribir Ax=b,
donde A es una matriz de dimensin mn, y x y b son
dos vectores columna de
longitudes n y m respectivamente. Tenemos un sistema
de m ecuaciones con n incgnitas.
1. El sistema tiene solucin si y solo si el rango de la
matriz A es igual al rango de la matriz
aumentanda A|b.
2. Si el rango es igual al nmero n de incgnitas el
sistema tiene una solucin nica.
3. Si el rango es menor que el nmero n de incgnitas
entonces hay un nmero infinito de soluciones
Vamos a escribir una funcin
denominada sistema_ecuaciones, al cual le pasamos
las matrices A y b y nos imprime un mensaje si el
sistema de ecuaciones no tiene solucin o hay un
nmero infinito de soluciones y nos devuelve la
solucin si es nica.
function x =sistema_ecuaciones(A,b)
rango_A=rank(A);
rango_Ab=rank([A b]);
[m,n]=size(A);
fprintf('Sistema de %i ecuaciones con %i
incgnitas\n',m,n);
if rango_A~=rango_Ab
disp('El sistema no tiene solucin')
elseif rango_A==n
disp('Hay una solucin nica')
x=A\b;
elseif rango_A<n
disp('Hay infinitas soluciones');
end
end
En la ventana de comandos probamos la
funcin sistema_ecuaciones, con los mismos ejemplos
utilizados en la pgina Matrices.
>> A=[2 1; 2 -1; 1 -2];
>> b=[3;0;4];
>> sistema_ecuaciones(A,b)
Sistema de 3 ecuaciones con 2 incgnitas
El sistema no tiene solucin
>> A=[2 1; 2 -1; 1 -2];
>> b=[3;5;4];
Hay una solucin nica
ans =
2.0000
-1.0000
>> A=[2 1; 4 2; 6 3];
>> b=[3;6;9];
Hay infinitas soluciones
La sentencia switch
Como podemos ver en la figura del apartado anterior,
la sentencia if...elseif...else tiene varias ramas, el
programa va por una u otra rama dependiendo del
valor verdadero o falso de la expresin evaluada. A
veces, es necesario, elegir entre varias alternativas,
como se muestra en la siguiente figura

Por ejemplo, considrese las siguientes series de
sentencias if...else
if condicion_1
sentencias_1
elseif condicion_2
sentencias_2
elseif condicion_3
sentencias_3
else
sentencias_4
end
El cdigo resultante puede ser difcil de seguir y
confuso incluso para el programador avanzado.
MATLAB proporciona una solucin elegante a este
problema mediante la sentencia
condicional switch para agrupar a un conjunto de
sentencias if...else.
switch expresion
case valor1
sentencias_1
case valor2
sentencias_2
case valor3
sentencias_3
otherwise
sentencias_4
end
En la sentencia switch, se compara el valor de una
variable o el resultado de evaluar una expresin, con
un conjunto de valores valor1, valor2, valor3, ..,
cuando coinciden se ejecuta el bloque de sentencias
que estn asociadas. Si el compilador no encuentra
coincidencia, se ejecuta la sentencia otherwise, si es
que est presente en el cdigo.
En el script meses, se introduce el nombre del mes y se
guarda en la variable nMes. Cuando se especifica en el
comandoinput 's' no es necesario introducir el nombre
entre comillas simples.
A continuacin, se utiliza solamente los tres primeros
caracteres que se convierten con la funcin lower a
minsculas. Si se introduce el mes de febrero pregunta
si es o no bisiesto. De nuevo, tomamos la primera letra
en minscula como respuesta s o n y la guardamos en
la variable bi. Se presentan tres posibilidades, que el
mes tenga 31 das, que el mes tenga 30 o que el mes
sea febrero con dos posibilidades si es bisiesto tiene 29
das en caso contrario tiene 28 das.
nMes=input('Introduce el nombre del mes):
','s');
mes=lower(nMes(1:3)); %utiliza las tres
primeras letras del mes
if mes=='feb' %utilizar strcmp(mes,'feb') para
comparar strings
bisiesto=input('Es ao bisiesto?:','s');
bi=lower(bisiesto(1)); %utiliza la primera
letra
end
switch mes
case{'sep','abr','jun','nov'}
dias=30
case 'feb'
if bi=='s'
dias=29
else
dias=28
end
otherwise
dias=31
end
Cuando se comparan cadenas de caracteres (string) es
conveniente utilizar la funcin strcmp de modo que la
sentencia if mes=='feb' se sustituye por if
strcmp(mes,'feb'), de este modo el compilador de
MATLAB elimina el aviso (raya de color anaranjado
en la parte derecha de la ventana del Editor)
>> meses
Introduce el nombre del mes: febrero
Es ao bisiesto? (s/n):No
dias = 28
>> meses
Introduce el nombre del mes: Julio
dias = 31
Meses y das de cada mes
Ahora un ejemplo ms complicado, escribir un
programa que calcule el nmero de das de un mes
determinado cuando se proporciona el ao.
Anotar primero, los meses que tienen 31 das y los que
tienen 30 das. El mes de Febrero (2 mes) es el ms
complicado ya que tiene 28 das excepto en los aos
que son bisiestos que tiene 29. Son bisiestos los aos
mltiplos de cuatro, que no sean mltiplos de 100,
pero si son bisiestos los mltiplos de 400.
Escribimos el siguiente script
mes=input('introduce un nmero (1-12): ');
anho=input('introduce el ao: ');
numDias=30;
switch mes
case {1,3,5,7,8,10,12}
numDias = 31;
case {4,6,9,11}
numDias = 30;
case 2
if ( (rem(anho,4) == 0 &
~(rem(anho,100) == 0)) | rem(anho,400) == 0 )
numDias = 29;
else
numDias = 28;
end
otherwise
disp('Este mes no existe')
end
fprintf('El mes %i del ao %i tiene %i
das\n',mes,anho,numDias)
rem(a,b) devuelve el resto de la divisin entre dos
nmeros a y b. Por ejemplo
>> rem(23,4)
ans = 3
Podemos convertir el cdigo del script en una funcin
denominada calendario de modo que al pasarle el mes
y el ao nos devuelva el nmero de das
function numDias=calendario(mes, anho)
switch mes
case {1,3,5,7,8,10,12}
numDias = 31;
case {4,6,9,11}
numDias = 30;
case 2
if ( (rem(anho,4) == 0 &
~(rem(anho,100) == 0)) | rem(anho,400) == 0 )
numDias = 29;
else
numDias = 28;
end
otherwise
disp('Este mes no existe')
end
end
Probamos la funcin calendario en la ventana de
comandos
>>calendario(2,1900)
ans = 28
>>calendario(2,2000)
ans = 29
calendario(10,2013)
ans = 31


Inicio

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Inicio

Uploaded by

Copyright:

Available Formats

Inicio

You might also like