Tutorial Matlab - Diplomado de Medicina y Complejidad

PRÓLOGO
MATLAB es un programa que nos permite desarrollar numerosas aplicaciones
al cálculo, la representación y la programación. En este manual, inspirado en el
libro A MAT LAB companion f or Multivariable Calculus, de Jeffery M. Cooper,
pretendemos complementar la asignatura de Cálculo Diferencial tratando la mayoría
de los puntos del temario desde un punto de vista informático, para que el alumno
pueda desarrollar en el ordenador los resultados que ha visto en clase.
Este trabajo está dividido en seis secciones en las que se exponen los principios
básicos para el manejo del programa sobre tratamiento de vectores: representación,
posición relativa de dos planos, introducción a dimensión superior; curvas en el plano:
curvas paramétricas, tangencias a curvas paramétricas, giros; funciones de dos y tres
variables: declaración, representación, funciones polares, superficies de funciones de
tres variables; resolución de ecuaciones: método de Newton, intersección de curvas
y superficies y por último problemas de optimización.
Además hemos apoyado las explicaciones con numerosos ejemplos y figuras generadas por MATLAB para que ilustren y ayuden a la hora de reproducir casos
similares.
Hemos utilizado algunas funciones no predeterminadas cuyo código puede encontrarse en la página web:
http : //www.math.umd.edu/˜jec/matcomp/matcompmf iles/mf iles.html
Esperamos que este trabajo sea de utilidad a la hora de introducirse en MATLAB
como herramienta aplicable al campo del cálculo multivariable y que anime a los
compañeros a ver el ordenador como una máquina capaz de ayudarnos en el trabajo
matemático.
Por último, agradecemos a nuestro tutor, el profesor José María Martínez Ansemil, la ayuda prestada para realizar este trabajo.
Mario Díaz-Romeral Ruiz y Juan Jesús Tebar Moreno
Alumnos de Matemáticas becarios de excelencia de la CAM
CURSO 2005/06
1
1.
1.1.
VECTORES RECTAS Y PLANOS
Vectores en dimensiones dos y tres.
Los vectores se escriben en MATLAB de la siguiente forma: v = [a, b, c], y la
norma usada en principio es la norma euclídea .
Podemos destacar los siguientes comandos para pintar vectores con punto de
aplicación común, es decir, si tenemos dos vectores v, w y el punto p0 , utilizamos el
comando arrow y arrow3 (para dimensión 3)
%EJEMPLO 1.1
%nos muestra gráficamente la resta (lo mismo pasaría con la suma)
%de dos vectores en el plano
p0=[1,1];
v=[1 0];
arrow(p0,v)
hold on %para pintar sobre el dibujo creado
%con el arrow (sin borrarlo)
w=[2,3];
arrow(p0,w)
arrow(p0,v-w,’r’)
%la ’r’ es para que la solución (v-w) salga en rojo
axis equal %son los ejes coordenados
hold off %anula hold on
4
3
2
1
0
-1
-2
-2
-1
0
1
2
3
4
5
Resta de vectores
Tenemos también las funciones dot(v, w) o también v ∗ w0 para hacer el producto
escalar de dos vectores; y para el producto vectorial (en tres dimensiones) está la
función cross(v, w).
2
%EJEMPLO 1.2
%producto escalar y vectorial de dos vectores en tres dimensiones
%producto vectorial
SYMS a b c x y z %declaración de variables simbólicas
v=[a b c];
w=[x y z];
cross(v,w)
ans =
[ b*z-c*y, c*x-a*z, a*y-b*x]
%producto escalar
v*w’
ans =
a*conj(x)+b*conj(y)+c*conj(z)
dot(v,w)
ans =
conj(a)*x+conj(b)*y+conj(c)*z
1.2.
Dibujar rectas en dos y tres dimensiones
Se pueden dibujar tan sólo sabiendo dos puntos ( P0 = (x0 , y0 ) y P1 = (x1 , y1 ) )
con el comando plot([x0 , x1 ], [y0 , y1 ]). Idem en tres dimensiones pero con el comando
plot3. (Para una recta poligonal daremos los cinco puntos necesarios.)
También podemos pintar los puntos de las rectas con plot3(x, y, z, 0 ∗ 0).
Obsérvese en los dibujos:
%EJEMPLO 1.3
%una recta poligonal
x=[1,1,1,1,1];
y=[2,2,4,5,2];
z=[1,4,3,4,2];
plot3(x,y,z)
%o con plot3(x,y,z,’*’) para que salga con asteriscos
3
4
3.5
3
2.5
2
1.5
1
5
2
4
1.5
1
3
0.5
2
0
Otro comando muy usado que sirve para hacer figuras es f ill (idem en 3 dimensiones.)
%EJEMPLO 1.4
%si coinciden las coordenadas x0 con x4,saldrá un triángulo
%en caso contrario une los vértices del punto (xo,yo),(x4,y4)
x=[1,7,5,3,1];y=[2,-1,4,6,2];
fill(x,y,’r’)%para que salga dibujada en rojo
6
5
4
3
2
1
0
-1
1.3.
1
2
3
4
5
6
Planos
Formas de determinar los planos en tres dimensiones:
1) por un punto del plano y su vector normal.
2) con tres puntos del plano.
3) un punto y dos vectores.
4
7
En este ejemplo damos dos vectores y un punto para construir el plano :
%EJEMPLO 1.5
p0=[1 1 1];
v=[1 0 0];
w=[1 3 5];
for s=-1:.5:1
for t=-1:.5:1
arrow(p0,s*v+t*w)
hold on
end
end
1
0.5
0
-0.5
-1
-1
0
1
2
3
-2
-1
0
1
2
3
4
Otra manera es con la función predefinida plane(p0 , N) en la que p0 es un punto
y N el vector normal al plano, donde sale dibujado mejor el plano, e incluso está
dibujado el vector normal.
%EJEMPLO 1.6
%aquí dibujaremos un plano apoyándonos en la función plane
%realizada por el autor del libro
p0=[1 1 2];
N=[1 0 3];
plane(p0,N)
5
2.8
2.6
2.4
2.2
2
2
1.5
1.8
1
0.5
0.5
1
1.5
0
Podemos dibujar la intersección de dos planos, siempre y cuando éstos se corten.
%EJEMPLO 1.7
%dibujamos dos planos que al tener un punto en común
%y los vectores normales a ambos son diferentes, se cortan
%a lo largo de una recta
p0=[1 3 6];
%punto común
N1=[0 3 3];
N2=[1 2 1];
plane(p0,N1)
%dibuja primer plano
hold on
plane(p0,N2)
L=cross(N1,N2);
%vector normal a N1 y N2
arrow3(p0,L)
%simula la recta intersección de ambos planos
hold off
6
6.8
6.6
6.4
6.2
6
5.8
5.6
5.4
5.2
3.5
1.4.
3
2.5
2
1.5
1
0.5
0
Gráficos tridimensionales
Es usual cambiar el punto de vista en gráficos tridimensionales, en MATLAB se
hace dando dos ángulos, (azimut y elevación). Para cambiar dicho punto de vista,
por ejemplo a 40 grados de azimut y 50 de elevación, lo que hacemos es:
1)Poner view(40, 50), para revisar dicho punto de vista; [az, el] = view .
2)Dar un vector view([1 2 1]).
3)Con el comando rotate3don. Pinchando en la figura con el botón izquierdo
y rotando la figura, la elevación y el azimut van apareciendo en la pantalla. Con
rotate3dof f se finaliza el comando.
7
2.
CURVAS EN EL ESPACIO
2.1.
Representación paramétrica de curvas.
MATLAB reconoce y permite representar curvas dadas en forma paramétrica,
esto es, funciones sobre cada una de las componentes del vector salida por un parámetro real t.
%EJEMPLO 2.1
%División del intervalo [0,2*pi] en 1000 partes iguales y,
%por expresión paramétrica y representación de la circunferencia unidad
%centrada en el origen.
t=linspace(0,2*pi,1000);
x=cos(t);
y=sin(t);
plot(x,y)
%También podemos declarar las funciones del parámetro
%para las variables empleando el comando ’inline’.
t=linspace(0,2*pi,1000);
x=inline(’cos(t)’,’t’);
y=inline(’sin(t)’,’t’);
plot(x(t),y(t))
%Si declaramos el parámetro como una incógnita simbólica
syms t
x=cos(t);
y=sin(t);
ezplot(x,y)
%El comando ezplot viene con un argumento que es
%el intervalo de definición del parámetro.
%MATLAB toma por defecto t en [0,2*pi]
8
1
0.5
0
1
0
-0.5
-1
-1
-0.5
0
0.5
1
-1
También en el caso tridimensional podemos representar curvas paramétricas de
la forma (x(t), y(t), z(t)) con t el parámetro real con el que venimos trabajando. Un
ejemplo clásico es la hélice circular.
%EJEMPLO 2.2
%Se define el rango del parámetro. Se declaran
%las variables en función del mismo y, por la
%instrucción ’plot3’
%dibuja la hélice circular sobre el espacio.
t=linspace(0,4*pi,1000);
x=cos(t);
y=sin(t);
z=t/(2*pi);
plot3(x,y,z)
%Declarando el parámetro simbólicamente podemos
%representar la hélice circular a través de la
%instruccién ’ezplot3’
syms t
x=cos(t);
y=sin(t);
z=t/(2*pi);
ezplot3(x,y,z,[0,4*pi])
%Se explicita el dominio del parámetro, ya que
%por defecto MATLAB hubiese tomado el intervalo [0,2*pi]
9
2
1.5
1
0.5
0
1
0.5
0
-0.5
-1
2.2.
-1
-0.5
0
0.5
1
Vectores tangentes a una curva paramétrica.
Nos planteamos ahora el problema de las tangencias a curvas paramétricas, y
cómo MATLAB lo trabaja.
Podemos conseguir representar conjuntamente la curva y los vectores tangentes
en los puntos que nos interesen, así como obtener otras aplicaciones curiosas, como
se explica a continuación:
%EJEMPLO 2.3
%Declaramos la hélice circular como hemos visto
%anteriormente y tras ello (por medio de ’hold on’
%para sobreescribir en la misma imagen), toma un nuevo
%parámetro ’s’ que divide el dominio, de forma que
%calculamos los vectores tangentes a la hélice
%en esos puntos. Para ello, haciendo uso de un bucle ’for’,
%introduce en ’p’ el punto en que se aplicará el vector,
%y en v la dirección. Con la instrucción ’arrow3’ se representa
t=linspace (0,4*pi,101);
x=inline(’cos(t)’);
y=inline(’sin(t)’);
z=inline(’t/(2*pi)’);
plot3(x(t),y(t),z(t))
hold on
10
for s=linspace(0,4*pi,17);
p=[x(s),y(s),z(s)];
v=[-sin(s),cos(s),1/(2*pi)];
arrow3(p,v,’r’)
end
view(135,40)
%La instrucción view cambia el punto de vista.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Dibujamos la hélice circular con un punto rojo recorriéndola
%a una velocidad proporcional al módulo del vector velocidad
%en el punto por el que pasa.
syms t
x=cos(t);
y=sin(t);
z=t/(2*pi);
ezplot3(x,y,z,[0,4*pi],’animate’);
2.5
2
1.5
1
0.5
0
-2
-1
0
1
2
-1.5
-1
-0.5
0
0.5
1
1.5
También resulta representativo el estudio de algún caso en el que la derivada se
anule.
%EJEMPLO 2.4
%En este ejemplo vemos una curva paramétrica con
11
%un punto en que la derivada no es continua. Viene
%representada junto con unos vectores tangentes por
%algunos puntos.
t=linspace(-1,1,101);
x=inline(’t.^3’);
y=inline(’t.^2’);
plot(x(t),y(t),’c’)
hold on
for j=linspace(-1,1,4);
p=[x(j),y(j)];
v=[3*j^2,2*j];
arrow(p,v,’r’)
end
3
2.5
2
1.5
1
0.5
0
-0.5
-1
-1
0
1
2
3
4
Para la comprensión de estos códigos será necesario conocer las funciones arrow
y arrow3 que se definen en los archivos del mismo nombre y que fueron programadas
por el autor.
2.3.
Longitud de arcos.
El cálculo de la longitud de un segmento recto no plantea excesivas complicaciones. Basta con calcular el módulo del vector que une los puntos extremos del mismo.
Tampoco es muy complejo calcular la longitud de un segmento poligonal, lo que se
reduce a sumar las longitudes de cada uno de los lados que conforman el polígono.
12
Ahora bien, cuando se trata de calcular la longitud de una curva entre dos extremos
definidos el problema no es en absoluto trivial. MATLAB lo tratará de varias formas
Será útil también conocer la expresión de la longitud de una curva paramétrica
que aporta el cálculo integral:
Z
a
b
Z bp
kv(t)k dt =
x0 (t)2 + y 0 (t)2 + z 0 (t)2 dt
a
%EJEMPLO 2.5
%Resolveremos el problema de calcular el valor
%de la longitud de una curva usando la aproximación
%por segmentos rectos.
%Hallamos la longitud de la curva C(t)=[t^2,2*t,exp(t)]
%1<=t<=2
n=input(’£En cuantos segmentos se quiere dividir la curva?’)
t=1:(1/n):2;
x=t.^2; y=2*t; z=exp(t);
sum = 0;
%Calculamos en un bucle ’for’ el vector que separa dos puntos
%consecutivos de la partición de la curva.
for j=1:n
dx=x(j+1)-x(j);
dy=y(j+1)-y(j);
dz=z(j+1)-z(j);
dr=[dx,dy,dz];
%usando el contador ’sum’ inicializado al principio,
%sumamos las normas de los vectores que hemos calculado.
sum=sum+norm(dr);
end
disp(’Este es el valor de la longitud de la curva’);
sum
disp(’La hemos dividido en’);
n
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Otra forma de resolver el problema es empleando la fórmula
%Aproximamos la curva del ejemplo anterior.
normderiv=inline(’sqrt((2*t).^2+4+(exp(t)).^2)’,’t’);
quad8(normderiv,1,2)
%el comando quad8 calcula aproximaciones numéricas
%de integrales entre los extremos de la variable indicados.
%OBSERVACIÓN:Usar ’help quad8’ para considerar una
13
%diferencia de sintaxis según definamos la función
%en línea o por un archivo *.m
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Por último podemos emplear un algoritmo simbólico.
%Consideramos un límite de integración (el superior
%en este caso), como una variable simbólica.
%Empleamos la fórmula de la integral.
syms t b
r=[t.^2 2*t exp(t)];
v=diff(r)
normderiv=sqrt(v(1)^2+v(2)^2+v(3)^2);
longitud=int(normderiv, t, 1, b)
pretty(longitud)
%empleamos en este código dos comandos nuevos:
%int(S,a,b) calcula la integral de la expresión simbólica S
%entre ’a’ y ’b’. pretty(S) da a la expresión simbólica S
%un formato matemático mas inteligible.
2.4.
Geometría de las curvas.
Estudiaremos en este apartado la definición de tres vectores característicos a
la curva paramétrica en un punto donde exista diferencial, que surgen a partir del
vector tangente a la curva en el punto en cuestión. Forman lo que se llama cuadro
de F renet, y se definen:
T (t) =
v(t)
[x0 (t), y 0 (t), z 0 (t)]
=p
kv(t)k
x0 (t)2 + y 0 (t)2 + z 0 (t)2
El vector tangente unitario (simplemente el vector velocidad dividido por su
módulo)
N(t) =
T 0 (t)
kT 0 (t)k
Vector unitario ortogonal a T (t) y que se denomina normal principal
B(t) = N(t) × T (t)
14
El vector que completa la referencia.
Se ha desarrollado una función f renet, que nos dibuja sobre una curva paramétrica lo que es el cuadro de Frenet sobre cuatro valores del parámetro.
2.5.
Rotaciones en el plano.
Las rotaciones en el plano euclídeo son una herramienta muy valiosa en geometría. Aplicándolas al estudio de curvas paramétricas, podemos usar MATLAB para
calcular la imagen de una de ellas por una rotación respecto a cualquier punto y con
cualquier argumento usando técnicas similares a las empleadas en álgebra.
Si tenemos un punto (x, y) del plano y queremos realizar una rotación de centro
el origen y argumento 0 ≤ θ ≤ 2π, la matriz
·
¸
cos θ − sin θ
R=
sin θ cos θ
Es lo que se llama una matriz de rotación, y si consideramos ahora la imagen
por esa matriz de un vector de R2
w = Rv = [x cos θ − y sin θ, x sin θ + y cos θ]
Podemos considerar en el caso paramétrico:
q(s) = Rr(s) = [x(s) cos θ − y(s) sin θ, x(s) sin θ + y(s) cos θ]
Donde s es el parámetro que define la curva sobre el plano. De esta forma,
podemos trabajar en MATLAB con estos conceptos:
% EJEMPLO 2.6
%Rotamos una curva paramétrica en el plano, por ejemplo la elipse
%(x^2/16)+(y^2/9)=1
arg=input(’Dame el argumento de giro’);
t=linspace(0,2*pi,101);
x0=4*cos(t);y0=3*sin(t);
%así representamos la elipse en primer término.
plot(x0,y0);
hold on
15
x=cos(arg)*x0-sin(arg)*y0;
y=sin(arg)*x0+cos(arg)*y0;
%dibujamos el giro sobre el mismo gráfico.
plot(x,y,’r’); axis equal
4
3
2
1
0
-1
-2
-3
-4
-5
0
16
5
3.
FUNCIONES DE DOS VARIABLES
3.1.
Funciones de dos variables. Representación.
Hay dos formas de definir funciones en MATLAB.
a) Programándola como un archivo ∗.m
%EJEMPLO 3.1.1
function z=f(x,y)
z=x.^2+y;
b) Introduciéndola directamente sobre la pantalla de ejecución.
%EJEMPLO 3.1.2
f=inline(’x.^2+y’,’x’,’y’)
f =
Inline function:
f(x,y) = x.^2+y
%ahora podemos utilizar f de la forma habitual, por ejemplo :
f(3,5)
ans =
14
Por el primer método también es sencillo programar funciones de mayor complejidad
%EJEMPLO 3.2
% vamos a programar la función f1(x,y)=exp(u-2v)*cos(3u), donde:
% u=3x^2+5y y v=3x+2y
function z=f1(x,y)
u=3*x.^2+5*y;
v=3*x+2*y;
z=exp(u-2*v)*cos(3*u);
Para representar funciones de dos variables sobre un rectángulo en el plano x, y
con a < x < b, c < y < d
MATLAB divide el rectángulo en las partes indicadas mediante el comando
meshgrid.
17
%EJEMPLO 3.3.1
%-1<=x<=2 ; 2<=y<=4 con separación 0.5
x=-1:.5:2;y=2:.5:4;
[X,Y]= meshgrid (x,y)
X =
-1.0000
-0.5000
0
0.5000
1.0000
1.5000
-1.0000
-0.5000
0
0.5000
1.0000
1.5000
-1.0000
-0.5000
0
0.5000
1.0000
1.5000
-1.0000
-0.5000
0
0.5000
1.0000
1.5000
-1.0000
-0.5000
0
0.5000
1.0000
1.5000
Y =
2.0000
2.0000
2.0000
2.0000
2.0000
2.0000
2.5000
2.5000
2.5000
2.5000
2.5000
2.5000
3.0000
3.0000
3.0000
3.0000
3.0000
3.0000
3.5000
3.5000
3.5000
3.5000
3.5000
3.5000
4.0000
4.0000
4.0000
4.0000
4.0000
4.0000
%Tenemos el rectángulo dividido, ahora representamos la función
f2=inline(’x+exp(y.^2)’,’x’,’y’)
f2 =
Inline function:
f2(x,y) = x+exp(y.^2)
Z=f2(X,Y)
Z =
1.0e+006 *
0.0001
0.0001
0.0001
0.0001
0.0001
0.0001
0.0005
0.0005
0.0005
0.0005
0.0005
0.0005
0.0081
0.0081
0.0081
0.0081
0.0081
0.0081
0.2090
0.2090
0.2090
0.2090
0.2090
0.2090
8.8861
8.8861
8.8861
8.8861
8.8861
8.8861
%ahora el gráfico se hace con el comando SURF
surf(X,Y,Z)
18
2.0000
2.0000
2.0000
2.0000
2.0000
2.0000
2.5000
3.0000
3.5000
4.0000
0.0001
0.0005
0.0081
0.2090
8.8861
x 10
6
10
8
6
4
2
0
4
3.5
2
3
1
2.5
0
2
-1
Se puede omitir el paso de crear el rectángulo para representar dichas funciones
programando una aplicación específica.
%EJEMPLO 3.3.2
function salida=representacion(f, vertices)
%vamos a dar los elementos del vector corners que son cada uno de los
%puntos que el usuario ha dado como esquinas
a=vertices(1);
b=vertices(2);
c=vertices(3);
d=vertices(4);
%dividimos como antes el rectángulo en subrrectángulos
x=linspace(a,b,41);
y=linspace(c,d,31);
[X,Y]=meshgrid(x,y);
%utilizamos el comando feval para evaluar la función en X,Y
Z=feval(f,X,Y);
surf(X,Y,Z)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Un ejemplo de aplicación en la pantalla de ejecución sería
%f(x,y)=2*x*y^2/exp(x)
f=input(’2*x.*y.^2./exp(x)’,’x’,’y’);
representacion(f,[[0 0] [0 1] [1 0] [1 1]])
3.2.
Representación de funciones polares
19
El único cambio significativo es que en la representación nos interesara un dominio circular en vez de rectangular.
%EJEMPLO 3.4
%primero hacemos un rectángulo en r,t
r=linspace(0,2,16);
t=linspace(0,2*pi,16);
[R,T]=meshgrid(r,t);
%ahora "curvamos" el rectángulo en coordenadas x,y
X=R.*cos(T);
Y=R.*sin(T);
Z=f(X,Y);
surf(X,Y,Z)
%tomamos una f genérica.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%En la pantalla de ejecución
f=input(’2*x.*y./exp(x)’,’x’,’y’);
ejemplo3_4
20
10
0
-10
-20
2
1
2
1
0
0
-1
-1
-2
3.3.
-2
Curvas de nivel
MATLAB sabe representar la curva que define la intersección entre la gráfica de
una función de dos variables y un plano de la forma z = c
20
%EJEMPLO 3.5
%para representar unas líneas de contorno podemos utilizar el
%comando contour(X,Y,f(X,Y)),a función definida. Usando la función
%contour con otros argumentos, contour(X,Y,f(X,Y),n) nos da
%las líneas de contorno de n puntos equiespaciados en el
%intervalo (min(f),max(f)), por último, podemos sustituir
%el argumento n por un vector con las coordenadas que nos interesen
x=-2:.05:2;
y=-2:.05:3;
[X,Y]=meshgrid(x,y);
f=inline(’4*exp(x)+y.^2’,’x’,’y’);
Z=f(X,Y);
plot3(X,Y,Z);
hold on
contour(X,Y,Z,10)
hold off
40
30
20
10
0
4
2
2
1
0
0
-1
-2
3.4.
-2
Técnicas gráficas para funciones simbólicas
MATLAB incluye una serie de comandos para la representación de funciones
simbólicas de dos variables, entre ellos destacan: ezsurf , ezmesh y ezcontour. Por
ejemplo:
21
%EJEMPLO 3.6
%declaramos como variables simbólicas ’x’ e ’y’
syms x y
f=sin(x)*exp(y^2)
f =
sin(x)*exp(y^2)
ezsurf(f,[[1 1][2 1] [1 2] [2 2]])
2
sin(x) exp(y )
3
2
1
0
-1
-2
-3
1
0.5
1
0.5
0
0
-0.5
y
-0.5
-1
-1
x
Los otros dos comandos funcionan de forma similar, sólo que para funciones de
mayor complejidad.
3.5.
Derivadas parciales y direccionales.
Para medir la variación de una función, se considera la restricción de f a rectas
paralelas a los ejes x e y , sobre las que se estudia el incremento en la otra variable,
que queda fija.
La definición precisa de derivadas parciales es:
∂f
f (x, y0 ) − f (x0 , y0 )
(x0 , y0 ) = lı́m
x→x0
∂x
x − x0
22
y forman el gradiente
∂f
f (x0 , y) − f (x0 , y0 )
(x0 , y0 ) = lı́m
y→y0
∂y
y − y0
·
¸
∂f
∂f
∇f (x, y) =
(x, y),
(x, y)
∂x
∂y
Las aplicaciones xslice e yslice (programadas por el autor) intersecan la función
con el plano y = y0 (xslice) y con un plano x = x0 (yslice)
%EJEMPLO 3.7
f=inline(’6*x.^2+8*y.^3+.5’,’x’,’y’);
qsurf(f,[0 2 0 2]); shading flat
%shading flat elimina la "redecilla" de la superficie.
hold on
x=linspace(0,2,51);
xslice(f,x,1)
hold off
100
80
60
40
20
0
2
1.5
2
1.5
1
1
0.5
0.5
0
3.6.
0
Derivadas direccionales
De forma más general, tomamos en vez de v = [1, 0] y u = [0, 1] otro vector
w = [w1 , w2 ]
23
para realizar una derivada direccional según la definición:
f (x0 + hw1 , y0 + hw2 ) − f (x0 , y0 )
h→0
h
Du f (x0 , y0 ) = lı́m
La función mslice funciona con dos argumentos mslice(f, P ), donde f es una
función definida en línea y P es un punto a partir del cual se define un vector (haciendo click en otro punto del plano) y MATLAB nos devuelve la derivada direccional
del punto en la dirección del vector.
%EJEMPLO 3.8
f
f =
Inline function:
f(x,y) = x+y.^2
P
P =
1
2
mslice(f,P)
This is a chance to enlarge the window, and rotate the figure
When you are finished, enter return
u1
u2
Duf
ans =
-0.9681
-0.2507
-1.9709
ans =
0.8904
-0.4552
-0.9305
ans =
0.9623
0.2718
2.0497
ans =
-0.8165
0.5773
1.4928
ans =
0.0104
0.9999
4.0102
24
z axis
20
10
0
3
2.5
2
1.5
1
y axis
2
1.5
1
0.5
0
x axis
y axis
2.5
P
2
1.5
-0.5
0
0.5
1
x axis
1.5
2
2.5
Observamos que el vector gradiente en un punto es ortogonal a la curva de nivel
que pasa por él.
3.7.
Aproximación por un plano tangente
Es de gran utilidad aproximar por una expresión lineal (afín) una curva en dos
variables en el entorno de un punto (x0 , y0 ). El plano tangente a la curva en un
punto nos sirve a tal efecto. Viene dado por la expresión
f (x, y) = f (x0 , y0 ) + fx (x0 , y0 )(x − x0 ) + fy (x0 , y0 )(y − y0 ) + E
Donde E es una expresión que tiende a cero cuando (x, y) → (x0 , y0 ) y fx , fy
son las derivadas parciales.
%EJEMPLO 3.9
f=inline(’x.^2+sin(y)’,’x’,’y’);
fx=inline(’2*x’,’x’,’y’);
fy=inline(’cos(y)’,’x’,’y’);
%fx y fy con las parciales de f
p(f,fx,fy,1,0)
ans =
-1+2*x+y
%mirar definición de p después de la figura que sigue.
25
qsurf(f,[-1,1 -1,1])
hold on
g=inline(’-1+2*x+y’,’x’,’y’);
qsurf(g,[-.3,.7,-.9,.1])
2
0
-2
-4
-1
-0.5
0
0.5
1
1
0.5
0
-0.5
-1
Sólo queda por explicar la función que se ha definido p.m y que nos da el plano
tangente a la curva por un punto dándole la función, las derivadas parciales y el
punto. La transcripción del código es:
%funcion p
function salida=p(f,fx,fy,x0,y0)
syms x y
salida=feval(f,x0,y0)+feval(fx,x0,y0)*(x-x0)+feval(fy,x0,y0)*(y-y0);
3.8.
Reconversión de escala
En algunas ocasiones para pequeñas surperficies en el pano xy , la imagen toma
valores extremos. Cuando esto ocurre la escala del gráfico hace que se pierda detalle
de cómo es en realidad la gráfica.Para solventarlo se pueden seccionar los valores de
la función ganando precisión. Por ejemplo:
%EJEMPLO 3.10
f=inline(’(x.^4+y.^2).^(-1)+cos(x).*sin(y)’,’x’,’y’)
26
f =
Inline function:
f(x,y) = (x.^4+y.^2+.01).^(-1)+cos(x).*sin(y)
[X,Y]=meshgrid(-2*pi:.1:2*pi);
Z=f(X,Y);
%esta función tiene un máximo muy elevado en (0,0).
%seccionamos la gráfica usando la función característica siguiente
W=(Z-4<0).*(Z-4)+4;
surf(X,Y,W);
4
3
2
-10
1
-5
0
0
5
-1
-8
3.9.
-6
-4
-2
0
2
4
6
8
10
El comando subplot
El comando subplot de MATLAB sirve para introducir en una misma ventana
varios gráficos distintos. El comando subplot funciona con tres argumentos: los dos
primeros indican la dimensión del array, y el tercero la posición particular de cada
uno de los gráficos.
%EJEMPLO 3.11
f=inline(’c*cos(3*x)+c*sin(2*y)’,’x’,’y’,’c’)
f =
Inline function:
f(x,y,c) = c*cos(3*x)+c*sin(2*y)
27
[X,Y]=meshgrid(-2:.2:2);
subplot(2,2,1)
%para c=1
surf(X,Y,f(X,Y,1))
subplot(2,2,2)
%para c=.4
surf(X,Y,f(X,Y,.4))
subplot(2,2,3)
%para c=pi
surf(X,Y,f(X,Y,pi))
subplot(2,2,4)
%para c=10^(-4)
surf(X,Y,f(X,Y,.0001))
%obsérvese la diferencia de escala
2
1
0
0
-2
2
0
-2
-2
0
2
-1
2
0
-2
x 10
10
2
0
0
-10
2
0
-2
-2
0
2
0
2
-4
-2
2
0
-2
28
-2
-2
0
2
4.
4.1.
FUNCIONES DE TRES VARIABLES Y SUPERFICIES PARAMÉTRICAS
Definición de funciones tridimensionales. Niveles.
Las funciones de tres variables f : R3 → R pueden definirse en MATLAB de
forma análoga a como se han venido definiendo en el caso unidimensional y bidimensional. Así, por ejemplo, tenemos:
%EJEMPLO 4.1,
%(a)definimos función de tres variables sobre la pantalla de ejecución.
F=inline(’(x.^2-exp(y)).*z’,’x’,’y’,’z’)
F =
Inline function:
F(x,y,z) = (x.^2-exp(y)).*z
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%(b)definimos funcion de tres variables sobre archivo *.m
function u=f(x,y,z)
u=x.^2/(sqrt(y.^2+z.^2+1));
El gráfico de una función de tres variables sería una superficie tridimensional
contenida en un espacio en cuatro dimensiones, lo que no puede ser visualizado. Sin
embargo, contamos con una herramienta: superficies tridimensionales de nivel. Estas
son, conjuntos de la forma
Sc = {(x, y, z) ∈ R3 : f (x, y, z) = c}
Así, podremos considerar la representación gráfica de z = g(x, y) = x2 + y 2 − c
Un ejemplo particular interesante de trabajar es el de las cuádricas, superficies
de nivel de una función cuadrática en x y z:
(a): f (x, y, z) = z − x2 − y 2 ⇒ z = g(x, y) = x2 + y 2 + c
%EJEMPLO 4.2.1
%Representamos un paraboloide, superficie de nivel de una función
%como la del ejemplo (a). Se representan para c=1, c=5.
29
f=inline(’x.^2+y.^2+c’,’x’,’y’,’c’);
[X,Y]=meshgrid(-2:.2:2);
surf(X,Y,f(X,Y,1))
hold on
surf(X,Y,f(X,Y,5))
15
10
5
0
2
1
2
1
0
0
-1
-1
-2
-2
(b): f (x, y, z) = z − x2 + y 2 ⇒ z = g(x, y) = x2 − y 2 + c
%EJEMPLO 4_2_2
%Paraboloide hiperbólico, superficie de nivel de una función
%como la del ejemplo (b). Se representa para c=1, c=10.
f=inline(’x.^2-y.^2+c’,’x’,’y’,’c’);
[X,Y]=meshgrid(-2:.2:2);
surf(X,Y,f(X,Y,1))
hold on
surf(X,Y,f(X,Y,10))
30
15
10
5
0
-5
2
1
2
1
0
0
-1
-1
-2
-2
½
p
c ≥ 0, una rama
2
2
(c): f (x, y, z) = −z +x +y ⇒ z = g(x, y) = ± x + y − c ⇒
c < 0, dos ramas
2
2
2
%EJEMPLO 4.2.3
%Un hiperboloide es la superficie de nivel de una función
%como la del ejemplo (c). Se representan para c=1, c=-1.
f=inline(’sqrt(x.^2+y.^2-c)’,’x’,’y’,’c’);
[X,Y]=meshgrid(-2:.2:2);
plot3(X,Y,f(X,Y,1))
hold on
plot3(X,Y,-f(X,Y,1))
hold off
plot3(X,Y,f(X,Y,-1))
hold on
plot3(X,Y,-f(X,Y,-1))
31
3
2
1
0
-1
-2
-3
2
1
2
1
0
0
-1
-1
-2
-2
sµ
¶
x2 y 2
x2 y 2 z 2
(d): f (x, y, z) = 2 + 2 + 2 ⇒ z = ±
+ 2 − d (−c2 )
a
b
c
a2
b
%EJEMPLO 4.2.4
%Un elipsoide es la superficie de nivel de una función
%como la del ejemplo (d). Para k=1,k=2 (caso a=2,b=3,c=1)
f=inline(’sqrt(-x.^2/4-y.^2/9+k)’,’x’,’y’,’k’);
[X,Y]=meshgrid(-2:.2:2);
plot3(X,Y,f(X,Y,1))
hold on
plot3(X,Y,f(X,Y,2))
32
1.5
1
0.5
0
2
0
-2
-1
0
1
2
Muchas veces, sin embargo, será difícil o incluso imposible despejar una variable
en función de las otras dos en una ecuación del tipo f (x, y, z) = c. El autor del
libro nos deja la función impl.m, que tomará valores z = z0 y trazará, empleando el
comando contour, curvas de nivel de la superficie de nivel que buscamos intesecada
con el plano z = z0 .
4.2.
Secciones planas de un sólido.
Supongamos una función f : R3 → R que asigna a cada punto del espacio
una característica numérica (por ejemplo temperatura, densidad, presión). Podemos
dibujar planos paralelos a los coordenados que representarán mediante un índice
de color el valor de la imagen. Esta representación es muy útil en casos donde no
se pueda despejar una variable como anteriormente. Nos aportará una información
comparativa muy ilustrativa, y será también válida para detectar extremos relativos.
Será clave en este apartado el uso del comando slice, que precisamente realiza la
tarea anteriormente descrita.
%EJEMPLO 4.3
f=inline(’log(x.^2+0.1)+sin(y).*cos(z)’,’x’,’y’,’z’);
x=0:.2:2;
y=0:.2:2;
z=0:.2:4;
[X,Y,Z]=meshgrid(x,y,z);
W=f(X,Y,Z);
slice(X,Y,Z,W,1,1,2)
colormap(hot)
33
colorbar
2
1.5
4
1
3
0.5
0
2
-0.5
1
-1
-1.5
0
2
-2
1.5
2
1.5
1
1
0.5
0.5
0
4.3.
-2.5
-3
0
El espacio vectorial gradiente.
Podemos definir el espacio vectorial gradiente como el conjunto de los vectores
gradiente en cada punto del espacio por una función f : R3 → R . Por ejemplo,
programamos para la función
f (x, y, z) = −
x3 3y 2 3z
+
+
3
2
2
%EJEMPLO 4.4
[X,Y]=meshgrid(0:.5:2);
U=-X.^2;
V=Y*3;
W=3/2+0*X;
for z=[-1,0,1]
Z=1.5*z+0*X;
quiver3(X,Y,Z,U,V,W)
end
34
2
1
5
0
-1
0
-2
-0.5
0
0.5
1
1.5
Vectores gradiente
35
2
-5
5.
RESOLUCIÓN DE ECUACIONES
Veremos cómo resolver sistemas no lineales de dos ecuaciones con dos incógnitas
½
5.1.
f (x, y) = 0
g(x, y) = 0
Soluciones simbólicas
Explicaremos con un ejemplo el procedimiento a seguir para resolver la intersección de dos curvas:
½
f (x, y) = x2 + y 2 − 2
g(x, y) = x2 − y
Nos apoyaremos en las gráficas de nivel :
f (x, y) = 0
g(x, y) = 0
%EJEMPLO 5.1
syms x y
f=x^2-2*y;
g=x^2+3*y;
[a,b]=solve(f,g);
double([a,b])
ans =
0 0
0 0
Estas gráficas tienen una intersección doble en el (0, 0).
36
2
1.5
1
0.5
0
-0.5
-1
-1.5
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
Doble intersección
5.2.
Soluciones de ecuaciones de una variable
Un algoritmo muy conocido para la resolución de ecuaciones es el método de
Newton
0
xn+1 = xn − f (xn )/f (xn )
0
Esta sucesión converge bien a la solución buscada cuando f (xn ) 6= 0 aunque
0
también es utilizada para encontrar las raíces f (x) = 0 con f (x) = 0 (en este caso,
si converge, será lentamente). Vamos a escribir un programa para obtener las raíces
de una función basándonos en éste algoritmo
%EJEMPLO 5.2
valorinicial=input(’introduce el valor inicial’)
N=input(’introduce el número de iteraciones deseadas’)
x=zeros(N,1) %vector de ceros
x(1)=valorinicial;
for n=1:n-1
x(n+1)=x(n)-f(x(n))/df(x(n));
end
[x,f(x)]
Donde f es la función deseada y df , su derivada, son dos funciones que se tienen
que programar en MATLAB, devolviendo ambas un valor.
37
Si tenemos una situación en la que hay dos raíces y damos un valor más cercano
a una (sin que éste sea un máximo o un mínimo relativo), el método de Newton
convergerá a la raíz, si por el contrario es un máximo (o mínimo), no convergerá
En MATLAB el comando f zero también sirve para encontrar raíces de la forma
f (x) = 0 ; la forma de usarlo es la siguiente:
%EJEMPLO 5.3
f=inline(’cos(3*x)+.5*x’,’x’);
raiz=fzero(f,[-2,2])
%encontraremos las raíces en el intervalo [-2 2]
Zero found in the interval: [-2, 2].
raiz =
-0.4483
5.3.
Resolución de una ecuación de dos variables
Si no se puede resolver la ecuación planteada, podemos dar una aproximación.
Si tenemos un punto (x0 , y0 ) tal que f (x0 , y0 ) = 0 y fy (x0 , y0 ) 6= 0 por el teorema
de la función implícita sabemos que para los x cercanos a x0 la curva de nivel
f (x, y) = 0 es la gráfica de una función y = g(x), ahora sí podemos encontrar los
valores de la y en función de los de las x .
Hay que tener en cuenta que el comando f zero sólo se utiliza en funciones de una
variable ; si queremos que evalúe más de una variable lo que haremos será considerar
todas las variables menos una como parámetros.
Vamos a ver un ejemplo con la función:
f (x, y) = 3 sin(x) + exp(y 2 ) en el intervalo [0, 1] × [1, 3]
%EJEMPLO 5.4
function z=f(y,x) %hemos intercambiado f(y,x)
z=3*sin(x)+y.*exp(y^2);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
x=-.2:.05:1.05;
y=zeros(size(x));
y(1)=fzero(’f’,exp(1),[],-.2);
for n=2:120
y(n)=fzero(’f’,y(n-1),[],x(n));
end
38
0.5
0
-0.5
-1
-0.2
0
0.2
0.4
39
0.6
0.8
1
1.2
6.
6.1.
OPTIMIZACIÓN.
Puntos críticos. Evaluación de la segunda derivada.
Un punto crítico de una función bidimensional f (x, y) es un punto (x0 , y0 ) del
dominio en el que f es diferenciable y en el que su diferencial es nula. Un punto
crítico puede ser extremo local de f o no.
Para encontrar los puntos críticos de una función debemos resolver el sistema:
½
fx (x, y) = 0
fy (x, y) = 0
donde fx fy son las derivadas parciales de f . Hay diversos caminos para encontrar
soluciones a estas ecuaciones.
Una vez que el gradiente es nulo, debemos observar las derivadas de orden mayor,
para discutir el comportamiento de f en un entorno de los puntos críticos (recordar
los resultados al respecto en funciones de una variable).
0
-0.5
-2
-1
-1.5
-1
-2
2
0
1
1
0
-1
-2
f (x, y) = xy
2
p
3 − x 2 − y2
Para extender el concepto de evaluación de un punto crítico por la segunda
derivada del cálculo de variable real, se introduce la matriz hessiana,
¶
µ
fxx (x, y) fxy (x, y)
H(x, y) =
fyx (x, y) fyy (x, y)
Esta matriz será simétrica cuando f ∈ C 2 .
Ahora, el resultado que determinará la naturaleza del punto crítico será:
40
Si
Si
Si
Si
det(H(x0 , y0 ))
det(H(x0 , y0 ))
det(H(x0 , y0 ))
det(H(x0 , y0 ))
>
>
<
=
0
0
0
0
y fxx (x0 , y0 ) > 0 ⇒ (x0 , y0 ) es un mínimo local.
y fxx (x0 , y0 ) < 0 ⇒ (x0 , y0 ) es un máximo local.
⇒ (x0 , y0 ) es un punto de ensilladura.
⇒ No podemos llegar a una conclusión.
Como curiosidad notamos que en los puntos de ensilladura, al hacer intersecciones con planos horizontales, se tiende hacia un comportamiento hiperbólico en
el punto en cuestión.
1.5
1
0.5
0
-0.5
-1
-1.5
-2
-2
-1.5
-1
-0.5
0
f (x, y) = xy
0.5
1
1.5
p
3 − x 2 − y2
%EJEMPLO 6.1
f=inline(’x.*y.*sqrt(3-x.^2-y.^2)’,’x’,’y’);
x=-2:.4:2;
y=-2:.4:2;
[X,Y]=meshgrid(x,y);
Z=f(X,Y);
contour(X,Y,Z,25);
Este es el código MATLAB que lleva al resultado gráfico superior.
41
6.2.
Estimación de máximos y mínimos.
MATLAB tiene algunas herramientas que nos ayudarán en el cálculo de extremos
en un intervalo del dominio. Veamos un ejemplo en una variable:
%EJEMPLO 6.2
f=inline(’(x.^(-2)+.01).*sin(x)’,’x’);
[M,i]=max(f(x))
M =
14.2747
i =
24
xmax=x(i)
xmax =
0.0700
[m,j]=min(f(x))
m =
-49.9969
j =
23
xmin=x(j)
xmin =
-0.0200
Los comandos máx f (x) y mı́n f (x) funcionan dándonos los extremos que ha
obtenido evaluando en f los valores de x que le hemos especificado. En el índice nos
dan la posición de la muestra en que se encuentra este valor de la variable, y por
último le pedimos que nos dé cuál es el valor de x para el que obtenemos el extremo.
Un caso multivariable:
%EJEMPLO 6.3
f=inline(’x.^4-exp(.05*y)’,’x’,’y’);
x=-2:.09:2;
y=-2:.09:2;
[X,Y]=meshgrid(x,y);
[fila,col]=max(f(X,Y));
%Guardamos los máximos de cada columna
[maxf,j]=max(fila)
%Hallamos el máximo del vector de máximos
maxf =
42
15.0952
j =
1
x0=x(j)
x0 =
-2
y0=y(col(j))
y0 =
-2
Así, tenemos que f (−2, −2) ≥ f (xj , yj ) para cualquier punto (xj , yj ) de la matriz.
Vamos por último a realizar un ejemplo de búsqueda de extremos en una función
bidimensional.
%EJEMPLO 6.4
f=inline(’x.^2+y.^2’,’x’,’y’);
x=-2:.09:2;
y=-2:.09:2;
[X,Y]=meshgrid(x,y);
surf(X,Y,f(X,Y))
syms x y
fx=2*x;
fy=2*y;
[a,b]=solve(fx,fy)
a =
0
b =
0
double([a,b])
ans =
0
0
fxx=diff(fx,x);
fxy=diff(fx,y);
fyy=diff(fy,y);
D=fxx*fyy-fxy^2
D =
4
subs(D,[x,y],[a,b])
ans =
4
%’subs’ sustituye variables simbólicas por números.
43
subs(fxx,[x,y],[a,b])
ans =
2
%det(H(0,0))>0,fxx(0,0)>0 -------> f tiene un mínimo en (0,0).
8
6
4
2
0
2
1
2
1
0
0
-1
-1
-2
6.3.
-2
Funciones de tres variables.
Como en el caso bidimensional, los puntos críticos son aquellos del dominio en
los que f es diferenciable y
∇f (x0 , y0 , z0 ) = (0, 0, 0).
Las soluciones de este sistema son candidatos a extremos relativos de la función.
Para hacernos una idea, como se explicó anteriormente; podemos emplear la instrucción slice. Será fácil intuir posibles extremos a la luz de la representación por
planos paralelos a los coordenados que han sido coloreados según la imagen de cada
punto. Por ejemplo.
%EJEMPLO 6.5
f=inline(’exp(sqrt(abs(x-y+z)))’,’x’,’y’,’z’);
x=linspace(-2,2,43);
y=linspace(-2,2,43);
z=linspace(-2,2,43);
[X,Y,Z]=meshgrid(x,y,z);
44
W=f(X,Y,Z);
slice(X,Y,Z,W,[-1 0 1],0,0);
colorbar
2
11
1
10
0
9
-1
8
-2
7
2
6
5
1
4
0
3
-1
-2
2
-2
0
-1
1
2
Podemos intuir que habrá un mínimo en (0, 0, 0), que valdrá aproximadamente 1. Efectivamente,
%EJEMPLO 6.6
corners=[-2,2,-2,2,-2,2];
subplot(2,2,1)
impl(f,corners,1.75)
title(’c=1.75’)
subplot(2,2,2)
impl(f,corners,1.45)
title(’c=1.45’)
subplot(2,2,3)
impl(f,corners,1.20)
title(’c=1.20’)
subplot(2,2,4)
impl(f,corners,1.000000000000000000001)
title(’c=1.000000000000000000001’)
45
c=1.75
c=1.45
2
0
z
z
2
0
-2
2
-2
2
0
y
-2
-2
x
y
c=1.2
x
-2
-2
c=1.000000000000000000001
2
2
0
z
z
0
0
2
0
2
-2
2
2
0
0
y
-2
-2
0
-2
2
0
y
x
-2
-2
0
2
x
Cada vez nos acercamos más al valor del mínimo, por lo tanto, el par de
planos que representan la superficie de nivel para un valor de c cualquiera, van
estando más próximos. En el valor límite, los planos serán coincidentes.
46
47