Anda di halaman 1dari 10

ECUACIONES EN DERIVADAS PARCIALES 1.

ECUACIÓN DE ONDAS
A) EXTREMOS CONTROLADOS En primer lugar, definimos la ecuación en
derivadas parciales que, en este caso es: u tt(x,t)= cˆ2 * u xx(x,t) , 0<x<L,
t>0 u(0,t)= u(L,t)=0, t>0 (condiciones de contorno) u(x,0)=f(x), u t(x,0)=g(x)
(condiciones iniciales) La solución de esta ecuación, que se puede obtener por
separación de variables, es: u(x,t)= Sum sin(n*pi*x/L)[a n * cos(n*pi*c*t/L) +
b n * sin(n*pi*c*t/L)] donde el sumatorio va de 1 a infinito y los coeficientes a n
y b n vienen dados por: a n=2/L*int[f(x)*sin(n*pi*x/L)dx], n=1,2,... b n=2/(n*pi*c)
* int[g(x)*sin(n*pi*x/L)dx] n=1,2,... donde las integrales se entienden entre 0
y L. En primer lugar, estudiaremos la solución de un problema concreto, que
es: u tt(x,t)= u xx(x,t), 0<x<1, t>0 u(0,t)= u(1,t)=0, t>0 (condiciones de
contorno) u(x,0)=sin(pi*x), u t(x,0)=0 (condiciones iniciales) que, de acuerdo
con lo anterior, tiene por solución: u(x,t)= sin(pi*x)*cos(pi*t) En primer lugar,
definimos las constantes y funciones que definen la ecuación y las condiciones
iniciales

−→ L:1; c:1;
Vamos a introducir una condición inicial sobre la posición en la que sólo inter-
viene la frecuencia fundamental, y la velocidad inicial es nula. De este modo,
en la solución sólo intervendrá el modo fundamental de oscilación.

−→ f(x):=sin(%pi*x); g(x):=0;
Ahora definimos los coeficientes del desarrollo:

−→ a(n):=2/L*integrate(f(y)*sin(n*%pi*y/L), y, 0, L);
b(n):=2/(n*%pi*c)*integrate(g(y)*sin(n*%pi*y/L), y, 0, L);
−→ makelist(a(n),n,1,10); makelist(b(n),n,1,10);
y finalmente definimos la solución:

−→ u(x,t,nmax):=sum( sin(n*%pi*x/L)*[a(n)*cos(n*%pi*c*t/L)+b(n)*sin(n*%pi*c*t/L)],
n, 1, nmax), simpsum;
Si queremos representar gráficamente la solución, tenemos varias opciones, siem-
pre teniendo en cuenta que sumaremos sólo un número finito de elementos de
la serie: i) Representar la solución para un valor dado del tiempo, como una
función dex. ii) Representar en tres dimensiones u(x,t,nmax), para un nmax
dado iii) Realizar una animación, haciendo variar t entre dos valores dados
deltiempo, de modo que se ve cómo evoluciona la solución con el tiempo. En
primer lugar:

−→ plot2d(u(x,0.1,10),[x,0,1]);
o podrı́amos hacer una tabla con distintas gráficas

−→ makelist(wxplot2d(u(x,i*0.1,20),[x,0,1],[y,-1,1]),i,0,10);
o bien representar todas las curvas en los mismos ejes. Si queremos representar
una superficie, podemos usar el comando plot3d

1
−→ plot3d(u(x,t,10)[1],[x,0,1],[t,0,1]);
y también podrı́amos representar la solución con animación:

−→ with slider(n,makelist(i,i,1,20),u(x,n*0.1,20),[x,0,1],[y,-1,1]);
Si ahora en la condición inicial cambiamos la posición, para que intervenga sólo
el segundo armónico, tendremos:

−→ f(x):=sin(2*%pi*x); g(x):=0;
−→ a(n):=2/L*integrate(f(y)*sin(n*%pi*y/L), y, 0, L);
b(n):=2/(n*%pi*c)*integrate(g(y)*sin(n*%pi*y/L), y, 0, L);
−→ makelist(a(n),n,1,10); makelist(b(n),n,1,10);
−→ u(x,t,nmax):=sum( sin(n*%pi*x/L)*[a(n)*cos(n*%pi*c*t/L)+b(n)*sin(n*%pi*c*t/L)],
n, 1, nmax), simpsum;
−→ u(x,t,10);
−→ with slider(n,makelist(i,i,1,20),u(x,n*0.1,20),[x,0,1],[y,-1,1]);
Podemos introducir una condición inicial sobre la posición con tres armónicos,
para ver en qué se traduce sobre la solución final:

−→ f(x):=sin(%pi*x)+0.5*sin(3*%pi*x)+0.25*sin(5*%pi*x); g(x):=0;
−→ a(n):=2/L*integrate(f(y)*sin(n*%pi*y/L), y, 0, L);
b(n):=2/(n*%pi*c)*integrate(g(y)*sin(n*%pi*y/L), y, 0, L);
−→ ratprint:false; makelist(a(n),n,1,10); makelist(b(n),n,1,10);
−→ u(x,t,nmax):=sum( sin(n*%pi*x/L)*[a(n)*cos(n*%pi*c*t/L)+b(n)*sin(n*%pi*c*t/L)],
n, 1, nmax), simpsum;
−→ u(x,t,10);
−→ with slider(n,makelist(i,i,1,20),u(x,n*0.2,20),[x,0,1],[y,-1.5,1.5]);
Al ser una superposición de tres armónicos, el movimiento parece complejo; es
posible ver los armónicos uno a uno:

−→ u1(x,t,nmin,nmax):=sum( sin(n*%pi*x/L)*[a(n)*cos(n*%pi*c*t/L)+b(n)*sin(n*%pi*c*t/L)],
n, nmin,nmax ), simpsum;
−→ with slider(n,makelist(i,i,1,20),u1(x,n*0.2,1,1),[x,0,1],[y,-1,1]);
−→ with slider(n,makelist(i,i,1,20),u1(x,n*0.2,3,3),[x,0,1],[y,-1,1]);
−→ with slider(n,makelist(i,i,1,20),u1(x,n*0.2,5,5),[x,0,1],[y,-1,1]);
y la suma de los tres constituirı́a el movimiento total

−→ with slider(n,makelist(i,i,1,20),u1(x,n*0.2,1,1)+ u1(x,n*0.2,3,3)+u1(x,n*0.2,5,5),[x,0,1],[y,-


1.5,1.5]);
Finalmente, pongamos una condición inicial que involucre infinitos modos nor-
males. Para ello, podemos estudiar el problema de una cuerda de una guitarra,

2
de longitud L, que inicialmente se desplaza hacia arriba por el centro hasta que
alcanza una altura h. En este caso, la función que nos da la posición es: f(x)=
2*h*x/L si 0 <=x <= L/2 f(x)= 2*h*(L-x)/L si L/2 <=x <= L Definamos, en
primer lugar, esta condición inicial

−→ L:1; c:1; h:1;


−→ f(x):= if (0<=x and x<=L/2) then 2*h*x/L else (2*h/L*(L-x)); g(x):=0;
−→ plot2d(f(x),[x,0,1]);
En este caso, será necesario hacer las integrales en dos partes:

−→ a(n):=2/L*(integrate(2*h*y/L*sin(n*%pi*y/L), y, 0, L/2)+
integrate(2*h*(L-y)/L*sin(n*%pi*y/L), y, L/2, L));
b(n):=2/(n*%pi*c)*integrate(g(y)*sin(n*%pi*y/L), y, 0, L);
−→ ratprint:false; makelist(a(n),n,1,10); makelist(b(n),n,1,10);
−→ u(x,t,nmin,nmax):=sum( sin(n*%pi*x/L)*(a(n)*cos(n*%pi*c*t/L)+b(n)*sin(n*%pi*c*t/L)),
n, nmin, nmax), simpsum;
Ahora representaremos el movimiento de la cuerda, y también la suma de var-
ios de los términos de la serie, para ver su contribución. Esto lo veremos para
distintos tiempos y, finalmente, haremos una gráfica animada del movimiento
de la cuerda.

−→ u(x,0,1,2);
Y ahora vemos la contribución de cada sumando para varios tiempos

−→ plot2d(u(x,0,1,30),[x,0,1]);
−→ plot2d([u(x,0,1,30),u(x,0,1,1),u(x,0,3,3),u(x,0,5,5),u(x,0,7,7)],[x,0,1]);
−→ plot2d([u(x,1/4,1,30),u(x,1/4,1,1),u(x,1/4,3,3),u(x,1/4,5,5),u(x,1/4,7,7)],[x,0,1]);
−→ plot2d([u(x,1/2,1,30),u(x,1/2,1,1),u(x,1/2,3,3),u(x,1/2,5,5),u(x,1/2,7,7)],[x,0,1]);
−→ plot2d([u(x,3/4,1,30),u(x,3/4,1,1),u(x,3/4,3,3),u(x,3/4,5,5),u(x,3/4,7,7)],[x,0,1]);
−→ plot2d([u(x,1,1,30),u(x,1,1,1),u(x,1,3,3),u(x,1,5,5),u(x,1,7,7)],[x,0,1]);
Finalmente, veamos un movimiento animado de la cuerda:

−→ with slider(n,makelist(i,i,0,30),u(x,n*0.05,1,30),[x,0,1],[y,-1,1]);
ONDAS VIAJERAS Existe otra forma de interpretar la solución en el caso de
una cuerda sujeta por los extremos, que expondremos en el caso de velocidad
inicial nula. Se trata deuna interpretación en términos de ondas viajeras. En
este caso, la solución se puede poner como: u(x,t)= Sum a n * cos(n*pi*c*t/L)*
sin(n*pi*x/L) donde el sumatorio va de 1 a infinito y los coeficientes a n vienen
dados por: a n=2/L*int[f(x)*sin(n*pi*x/L)dx], n=1,2,... donde las integrales se
entienden entre 0 y L. Los coeficientes bn de la solución general son nulos, puesto
que g(x)=0. Teniendo en cuenta la identidadtrigonométrica: sin(a)*cos(b)=[sin(a+b)+sin(a-
b]/2 se puede escribir la solución como: u(x,t)=1/2 * Sum a n[sin(k n*(x+c*t))

3
+ sin(k n*(x-c*t))] donde k n=n*pi/L. Como, inicialmente, se cumple: u(x,0)=f(x)=
Sum a n * sin(n*pi*x/L) entonces está claro que: f(x+c*t)=Sum a n * sin(k n*(x+c*t))
f(x-c*t)=Sum a n * sin(k n*(x-c*t)) de modo que la solución también se puede
poner como: u(x,t)=1/2*[f(x+c*t)+f(x-c*t)] donde la función f es la posición
inicial. No obstante, necesitamos utilizar la extensión periódica de f, puesto que
f(x+c*t) y f(x-c*t) se pueden salir del intervalo [0,L]. A continuación, veremos
esta interpretación en el caso del problema de lacuerda de una guitarra que
acabamos de ver.

−→ kill(all);
−→ L:1; c:1; h:1;
−→ f(x):= if (0<=x and x<=L/2) then 2*h*x/L else if (L/2<x and x<=L) then
(2*h/L*(L-x));
−→ f(x);
−→ plot2d(f(x),[x,0,1]);
y su extensión periódica serı́a:

−→ fimp(x):=if (0<=x and x<=L) then f(x) else if (-L<x and x<0) then -f(-x);
−→ plot2d(fimp(x),[x,-1,1]);
−→ fper(x):= if (-L<=x and x<=L) then fimp(x) else if (x>L) then fper(x-2*L)
else fper(x+2*L);
−→ fper(x);
−→ plot2d(fper(x),[x,-6,6]);
−→ u(x,t):=(fper(x-c*t)+fper(x+c*t))/2;
−→ u(x,t);
de modo que podremos representar la solución como:

−→ plot2d(u(x,0),[x,-3,3]);
−→ with slider(n,makelist(i,i,0,30),u(x,n*0.05),[x,0,3],[y,-1,1]);
y podemos representar también las dos ondas viajeras, de forma que se vea que
al movimiento de la cuerda corresponde a la semisuma de las dos ondas viajeras.

−→ with slider(n,makelist(i,i,0,30),[fper(x-c*(n*0.05)),fper(x+c*(n*0.05)),u(x,n*0.05)],[x,-
3,3],[y,-1,1]);
B) FUERZA ESPECIFICADA EN LOS EXTREMOS Definimos la ecuación en
derivadas parciales que, en este caso es: u tt(x,t)= cˆ2 * u xx(x,t) , 0<x<L,
t>0 u x(0,t)= g1(t), u x(L,t)=g2(t), t>0 (condiciones de contorno) u(x,0)=f(x),
u t(x,0)=g(x) (condiciones iniciales) Nos centraremos en un caso especial, que
corresponde al movimiento de una cuerda con extremos libres, esto es: g1(t)=g2(t)=0
cuya solución es: u(x,t)= a 10 + a 20*t + Sum cos(n*pi*x/L)[a 1n * cos(n*pi*c*t/L)
+ a 2n * sin(n*pi*c*t/L)] donde el sumatorio va de 1 a infinito y los coeficientes

4
a 10, a 1n, a 20 y a 2n vienen dados por: a 10=1/L*int[f(x)dx], a 1n=2/L *
int[f(x)*cos(n*pi*x/L)dx], n=1,2,... a 20=1/L*int[g(x)dx], a 2n=2/(n*pi*c) *
int[g(x)*cos(n*pi*x/L)dx] n=1,2,... donde las integrales se entienden entre 0
y L. Estudiaremos la solución de un problema concreto, que es: u tt(x,t)=
u xx(x,t), 0<x<1, t>0 u x(0,t)= u x(1,t)=0, t>0 (condiciones de contorno)
u(x,0)=cos(2*pi*x), u t(x,0)=-2*pi*cos(pi*x), 0<x<1 (condición inicial)

−→ kill(all);
−→ L:1; c:1;
−→ f(x):=cos(2*%pi*x); g(x):=-2*%pi*cos(%pi*x);
−→ a10:1/L*integrate(f(y), y, 0, L); a1(n):=2/L*integrate(f(y)*cos(n*%pi*y/L),
y, 0, L); a20:1/L*integrate(g(y), y, 0, L);
a2(n):=2/(n*%pi*c)*integrate(g(y)*cos(n*%pi*y/L), y, 0, L);
−→ makelist(a1(n),n,1,10); makelist(a2(n),n,1,10);
−→ u(x,t,nmax):= a10 + a20*t + sum( cos(n*%pi*x/L)*[a1(n)*cos(n*%pi*c*t/L)
+a2(n)*sin(n*%pi*c*t/L)], n, 1, nmax), simpsum;
−→ u(x,t,10);
y para la representación gráfica:

−→ plot2d(u(x,0,10),[x,0,1]);
−→ with slider(n,makelist(i,i,0,20),u(x,n*0.1,20),[x,0,1],[y,-3,3]);
C) LIGADURAS ELÁSTICAS. No estudiaremos este caso. D) MOVIMIENTO
DE UNA CUERDA INFINITA. SOLUCIÓN DE D’ALEMBERT. Seguimos tra-
bajando con la ecuación de ondas: u tt(x,t)= cˆ2 * u xx(x,t) , -inf < x < inf, t>0
u(x,0)=f(x), u t(x,0)=g(x), -inf < x < inf (condiciones iniciales) y, obviamente,
como la cuerda es infinita, no hay condiciones de contorno. La solución de este
problema es la solución de D’Alembert: u(x,t)= 1/2 * [f(x-c*t) + f(x+c*t)] +
1/(2*c) int[g(y)dy] donde la integral está definida entre los lı́mites x-c*t y x+c*t.
Veremos varios ejemplos de este caso: i) Movimiento de una onda inicial sinu-
soidal, esto es: u(x,0)=sin(x), u t(x,0)=0 que tiene por solución: u(x,t)=1/2 *
[sin(x-c*t)+sin(x+c*t)]

−→ kill(all);
−→ c:1; f(x):=sin(x); g(x):=0;
−→ u(x,t):=1/2*[f(x-c*t)+f(x+c*t)]+ 1/(2*c)*integrate(g(y),y,x-c*t,x+c*t);
−→ u(x,t);
−→ plot2d(u(x,0),[x,-10,10]);
−→ ratprint:false; with slider(n,makelist(i,i,0,40),u(x,n*0.1),[x,-30,30],[y,-1.5,1.5]);
−→ u2(x,t):=sin(x-c*t); u3(x,t):=sin(x+c*t); u4(x,t):=(u2(x,t)+u3(x,t))/2;

5
−→ plot2d([u2(x,1),u3(x,1)],[x,-30,30]);
−→ with slider(n,makelist(i,i,0,40),u2(x,n*0.3),[x,-30,30],[y,-1.5,1.5]);
−→ with slider(n,makelist(i,i,0,40),u3(x,n*0.3),[x,-30,30],[y,-1.5,1.5]);
−→ with slider(n,makelist(i,i,0,40), [u2(x,n*0.3),u3(x,n*0.3)],[x,-30,30],[y,-1.5,1.5]);
−→ with slider(n,makelist(i,i,0,40),u4(x,n*0.3),[x,-30,30],[y,-1.5,1.5]);
ii) Movimiento de una onda cuadrada simple, esto es: u(x,0)=1 , si -1<x<1
u(x,0)=0 , en el resto, u t(x,0)=0

−→ kill(all);
−→ c:1; f(x):=if (abs(x)<1) then 1 else 0; g(x):=0;
−→ plot2d(f(x),[x,-2,2],[y,-1,2]);
−→ u(x,t):=1/2*[f(x-c*t)+f(x+c*t)]+ 1/(2*c)*integrate(g(y),y,x-c*t,x+c*t);
−→ u(x,t);
−→ ratprint:false; with slider(n,makelist(i,i,0,50),u(x,n*0.1),[x,-10,10],[y,-1.5,1.5]);
iii) Velocidad inicial dada. u(x,0)=0 u t(x,0=sin(x)

−→ kill(all);
−→ c:1; f(x):=0; g(x):=sin(x);
−→ u(x,t):=1/2*[f(x-c*t)+f(x+c*t)]+ 1/(2*c)*integrate(g(y),y,x-c*t,x+c*t);
−→ u(x,t);
−→ ratprint:false; with slider(n,makelist(i,i,0,50),u(x,n*0.1),[x,-10,10],[y,-1.5,1.5]);
E) PROBLEMA DE UNA MEMBRANA RECTANGULAR VIBRANTE Defin-
imos la ecuación en derivadas parciales que, en este caso es: u tt(x,y,t)= cˆ2
* [u xx(x,y,t) + u yy(x,y,t)] , 0<x<L, 0<y<K, t>0 u(0,y,t)= u(L,y,t)= 0,
0<y<K, t>0 u(x,0,t)= u(x,K,t)= 0, 0<x<L, t>0 (condiciones de contorno)
u(x,y,0)=f(x,y), u(x,y,0)=g(x,y), 0<x<L, 0<y<K (condiciones iniciales) La solución
de este problema es: u(x,y,t)=Sum Sum [a nm*cos(sqrt(lambda nm)*c*t)+b nm*sen(sqrt(lambda nm)*c*t)]*
*sen(n*pi*x/L)*sen(m*pi*y/K), donde los sumatorios van desde 1 a infinito y:
lambda nm=(n*pi/L)ˆ2 + (m*pi/K)ˆ2, n,m=1,2,... a nm = 4/(L*K) int int
f(x,y)*sin(n*pi*x/L)*sin(m*pi*y/K) , n,m=1,2,... b nm = 4/(L*K*sqrt(lambda nm)*c)
int int g(x,y)*sin(n*pi*x/L)*sin(m*pi*y/K) ,n,m=1,2,... y donde la primera
integral va entre 0 y L y la segunda entre 0 y K. Estudiaremos el caso par-
ticular siguiente: c=1, L=1, K=2 f(x,y)=sen(2*pi*x)*[sen(pi*y/2)-2*sen(pi*y)]
g(x,y)=2*sen(2*pi*x)*sen(pi*y/2)

−→ kill(all);
−→ c:1; L:1; K:2;
−→ landa(n,m):=(n*%pi/L)ˆ2 + (m*%pi/K)ˆ2;

6
−→ makelist(makelist(landa(n,m),m,1,3),n,1,3);
−→ f(x,y):=sin(2*%pi*x)*(sin(%pi*y/2)-2*sin(%pi*y));
g(x,y):=2*sin(2*%pi*x)*sin(%pi*y/2);
−→ a(n,m):=4/(L*K)*integrate((integrate(f(x,y)*sin(n*%pi*x/L)*sin(m*%pi*y/K),y,0,K)),x,0,L);
b(n,m):=4/(L*K*sqrt(landa(n,m))*c)*integrate((integrate(g(x,y)*sin(n*%pi*x/L)*sin(m*%pi*y/K),y
−→ a(n,m); b(n,m);
Veamos algunos coeficientes:

−→ makelist(makelist(a(n,m),m,1,3),n,1,4); makelist(makelist(b(n,m),m,1,3),n,1,4);
Entonces, ya podemos escribir la solución:

−→ u(x,y,t,nmin,nmax,mmin,mmax):=sum((sum((a(n,m)*cos(sqrt(landa(n,m))*c*t)+b(n,m)*sin(sqrt(lan
sin(n*%pi*x/L)*sin(m*%pi*y/K),m,mmin,mmax)),n,nmin,nmax),simpsum;
La solución completa es:

−→ u(x,y,t,1,3,1,3);
y veamos si podemos aislar los modos normales en funciones separadas:

−→ u(x,y,t,1,2,1,1);
y esto corresponde al primer modo normal, de frecuencia sqrt(17)*pi/2, de modo
que definimos una nueva función con este valor:

−→ umod1(x,y,t):=u(x,y,t,1,2,1,1);
−→ umod1(x,y,t);
y para el segundo modo normal:

−→ u(x,y,t,2,2,2,2);
que definimos en una función:

−→ umod2(x,y,t):=u(x,y,t,2,2,2,2);
−→ umod2(x,y,t);
En primer lugar, representamos gráficamente la solución completa, donde sólo
intervienen dos términos de las series dobles que dan la solución general. En
primer lugar, representamos la condición inicial:

−→ u(x,y,0,1,2,1,2);
−→ plot3d(u(x,y,0,1,2,1,2),[x,0,1],[y,0,2]);
y ahora la solución para distintos tiempos, animada:

−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true, ex-


plicit(u(x,y,n*0.3,1,2,1,2),x,0,1,y,0,2), surface hide=true);
En este caso tenemos dos modos normales, y veamos si podemos verlos por sep-
arado.

7
−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true, ex-
plicit(umod1(x,y,n*0.3),x,0,1,y,0,2), surface hide=true, color=blue);
−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true, ex-
plicit(umod2(x,y,n*0.3),x,0,1,y,0,2), surface hide=true);
y el movimiento total será la suma de ambas:

−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true, ex-


plicit(umod1(x,y,n*0.3)+umod2(x,y,n*0.3),x,0,1,y,0,2), surface hide=true);
A continuación estudiaremos un caso en el que es posible ver mejor los modos
normales, aparte de que hay más y no hay velocidad inicial: c=1, L=2, K=1
f(x,y)=x*(x-L)*y*(y-K), g(x,y)=0

−→ kill(all);
−→ c:1; L:2; K:1;
−→ landa(n,m):=(n*%pi/L)ˆ2 + (m*%pi/K)ˆ2;
−→ landa(n,m);
−→ makelist(makelist(landa(n,m),m,1,3),n,1,3);
−→ landa(1,3);
−→ f(x,y):=x*(x-L)*y*(y-K); g(x,y):=0;
−→ plot3d(f(x,y),[x,0,2],[y,0,1]);
−→ a(n,m):=4/(L*K)*integrate((integrate(f(x,y)*sin(n*%pi*x/L)*sin(m*%pi*y/K),y,0,K)),x,0,L);
b(n,m):=4/(L*K*sqrt(landa(n,m))*c)*integrate((integrate(g(x,y)*sin(n*%pi*x/L)*sin(m*%pi*y/K),y
−→ a(n,m); b(n,m);
−→ makelist(makelist(a(n,m),m,1,5),n,1,5); makelist(makelist(b(n,m),m,1,5),n,1,5);
−→ u(x,y,t,nmin,nmax,mmin,mmax):=sum((sum([a(n,m)*cos(sqrt(landa(n,m))*c*t)+b(n,m)*sin(sqrt(land
sin(n*%pi*x/L)*sin(m*%pi*y/K),m,mmin,mmax)),n,nmin,nmax),simpsum;
−→ ratsimp(u(x,y,t,1,nmax,1,mmax));
y ahora se observa que hay infinitos modos normales, de los que intentaremos
extraer los primeros para representarlos gráficamente. Antes representemos el
movimiento de la membrana

−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true, ex-


plicit(u(x,y,n*0.3,1,10,1,10)[1],x,0,2,y,0,1), surface hide=true, color=light-red);
Vamos a extraer los distintos modos normales para verlos por separado. El modo
(1,1) corresponderı́a a:

−→ u(x,y,t,1,1,1,1);
Ya sabemos que no hay modo (1,2) ni (2,1), luego para encontrar otro que con-
tribuya debemos buscar el (1,3) y (3,1), que se encuentran en:

8
−→ u(x,y,t,1,3,1,3);
en donde aparece también el (3,3), lógicamente. Vamos a extraer cada uno por
separado. El primero serı́a:

−→ umod1 1(x,y,t):=u(x,y,t,1,1,1,1)[1];
−→ umod1 1(x,y,t);
Como ya dijimos, a partir de los coeficientes a y b, se sabe que no hay segundo
modo normal, por ser nulos los correspondientes coeficientes:

−→ u(x,y,t,1,2,1,2);
Para que intervenga el tercer modo normal, hay que considerar:

−→ u(x,y,t,1,3,1,3);
o bien cualquiera de los términos:

−→ u(x,y,t,1,2,1,3); u(x,y,t,1,3,1,2);
y para que sólo aparezca el modo (1,3) tendremos que hacer:

−→ umod1 3(x,y,t):=u(x,y,t,1,2,1,3)[1]-u(x,y,t,1,2,1,2)[1];
−→ umod1 3(x,y,t);
o bien, si queremos aislar el modo (3,1)

−→ umod3 1(x,y,t):=u(x,y,t,1,3,1,2)[1]-u(x,y,t,1,2,1,2)[1];
−→ umod3 1(x,y,t);
y, por supuesto, también podremos extraer el (3,3):

−→ umod3 3(x,y,t):=u(x,y,t,1,3,1,3)[1]-umod1 1(x,y,t)-umod1 3(x,y,t)-


umod3 1(x,y,t);
−→ umod3 3(x,y,t);
−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true, ex-
plicit(umod1 1(x,y,n*0.3),x,0,2,y,0,1), surface hide=true, color=light-red);
−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true, ex-
plicit(umod1 3(x,y,n*0.3),x,0,2,y,0,1), surface hide=true, color=light-red);
−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true, ex-
plicit(umod3 1(x,y,n*0.3),x,0,2,y,0,1), surface hide=true, color=light-red);
−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true, ex-
plicit(umod3 3(x,y,n*0.3),x,0,2,y,0,1), surface hide=true, color=light-red);
y ası́ podrı́amos obtener modos normales de orden superior. F) PROBLEMA
DE UNA MEMBRANA CIRCULAR VIBRANTE En primer lugar, calculamos
las raı́ces de la función de Bessel de orden 0:

−→ plot2d(bessel j(0,x),[x,0,16]);

9
−→ ji 01:find root(bessel j(0,x),x,2,3); ji 02:find root(bessel j(0,x),x,5,7);
ji 03:find root(bessel j(0,x),x,8,10); ji 04:find root(bessel j(0,x),x,11,13);
ji 05:find root(bessel j(0,x),x,14,16);
−→ ji 01;
Vamos a interpretar el significado de J 0(ji 0m)

−→ plot2d([bessel j(0,ji 01*x),bessel j(0,ji 02*x),bessel j(0,ji 03*x),bessel j(0,ji 04*x),


bessel j(0,ji 05*x)],[x,0,1]);
Ahora formamos la condición inicial:

−→ u(r,teta,t):=bessel j(0,ji 01*r)*cos(ji 01*t)-0.5*bessel j(0,ji 03*r)*cos(ji 03*t)+


0.25*bessel j(0,ji 05*r)*cos(ji 05*t);
−→ u(r,teta,t);
Veamos si es posible obtener los coeficientes usando la fórmula general:

−→ f(r):=u(r,teta,0);
−→ f(r);
−→ bessel j(1,ji 01);
−→ bessel j(0,ji 01*r);
−→ a1:2/bessel j(1,ji 01)ˆ2*romberg(r*bessel j(0,ji 01*r)*f(r),r,0,1);
a3:2/bessel j(1,ji 03)ˆ2*romberg(r*bessel j(0,ji 03*r)*f(r),r,0,1);
a5:2/bessel j(1,ji 05)ˆ2*romberg(r*bessel j(0,ji 05*r)*f(r),r,0,1);
Representamos la condición inicial:

−→ plot3d(u(r,teta,0),[r,0,1],[teta,-%pi,%pi],[’transform xy, polar to xy]);


Y ahora representamos la solución:

−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true,


parametric surface(r*cos(teta),r*sin(teta),u(r,teta,n),r,0,1,teta,-%pi,%pi));
Ahora vamos a ver los tres modos normales que intervienen

−→ u1(r,teta,t):=bessel j(0,ji 01*r)*cos(ji 01*t); u2(r,teta,t):=-


0.5*bessel j(0,ji 03*r)*cos(ji 03*t); u3(r,teta,t):=0.25*bessel j(0,ji 05*r)*cos(ji 05*t);
−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true,
parametric surface(r*cos(teta),r*sin(teta),u1(r,teta,n),r,0,1,teta,-%pi,%pi));
−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true,
parametric surface(r*cos(teta),r*sin(teta),u2(r,teta,n),r,0,1,teta,-%pi,%pi));
−→ with slider draw3d(n,makelist(i,i,0,20),palette = color,enhanced3d = true,
parametric surface(r*cos(teta),r*sin(teta),u3(r,teta,n),r,0,1,teta,-%pi,%pi));
−→ with slider draw3d(n,makelist(i,i,0,10),palette = color,enhanced3d
= true, parametric surface(r*cos(teta),r*sin(teta),u1(r,teta,n)+
u2(r,teta,n)+u3(r,teta,n),r,0,1,teta,-%pi,%pi));

10