Simples Gráficos

Para generar gráficos 2D usaremos el comando plot.

>	plot(sin(x),x=-2*Pi..2*Pi);

Para modificar los gráficos, podemos usar el menú contextual que aparece al pulsar el botón derecho del ratón o bien al pulsar sobre la ventana gráfica mediante los botones que aparecen en el menú de gráficos. También podemos indicar las distintas opciones dentro del comando plot.

>	?plot[options];

Funciones con Discontinuidades

Para indicar a Maple que la función que vamos a representar presenta discontinuidades usaremos la opción discont=true.

>	plot(tan(x),x=-2*Pi..2*Pi,y=-4..4,discont=true,title=`Representación de Tan(x)`);

Representación Conjunta de distintas funciones

>	plot({x,x^2,x^3,x^4,x^5},x=-10..10,y=-10..10);

Observación: Hemos usado en el gráfico anterior el menú contextual para cambiar el grosor de los gráficos.

Representación Polar de curvas

>	plot(sin(3*t),t=0..Pi,coords=polar);

Representación de Superficies

>	plot3d(sin(x*y),x=-2..2,y=-2..2);

Representación Paramétrica de Superficies

>	plot3d([sin(t),cos(t)*sin(u),sin(u)],t=-Pi..Pi,u=-Pi..Pi);

Representación Esférica de Superficies

>	plot3d(1,t=0..2*Pi,p=0..Pi,coords=spherical);

Introducción

Maple V proporciona al usuario un amplio abanico de paquetes especiales relacionados con Estadística, Teoría de Números, Teoría de Grafos... y uno especialmente diseñado para la enseñanza de Análisis a los estudiantes.

Existen distintos procedimientos para cargar un paquete:

Carga de todas las funciones contenidas en el paquete: with(nombre_paquete);

>	with(stats);

Carga de algunas funciones del paquete: with(nombre_paquete,rutina1,rutina2,...,rutinaN);

>	with(DEtools,odeadvisor);

Carga y uso (a la vez) de una sola rutina: nombre_paquete[rutina](...);

>	finance[cashflows]([100, 200, 50], 0.1);

Uno de los paquetes más usados es el paquete de álgebra lineal, linalg. Este paquete contiene comandos para la manipulación de matrices y vectores.

>	with(linalg);

Warning, the protected names norm and trace have been redefined and unprotected

Operaciones Matriciales

Un array es una generealización de la estructura matricial de datos. La conversión entre arrays y matrices es automática; por ello, cuando creamos un array podemos utilizarlo como una matriz.

Definamos una matriz numérica 3 x 3 mediante el comando array.

>	M1:=array([[1/2,-1/3,2],[-5,14/3,9],[0,11,-5/6]]);

Para mostrar una matriz, usaremos los comandos print o evalm.

>	print(M1);

>	evalm(M1);

Para calcular la inversa tenemos el comando inverse:

>	inverse(M1);

Definimos a continuación una matriz con valores simbólicos. En esta ocasión nos serviremos del comando matrix con una variación sobre la sintaxis habitual:

>	M2:=matrix(3,3,[1/2,0,-2,sin(theta),1,phi^2,0,phi-1,3/4]);

Para multiplicar las matrices M1 y M2 tenemos el comando multiply :

>	M3:=multiply(M1,M2);

Calculemos el determinante de esta última matriz:

>

det(M3);

El paquete linalg contiene definiciones de matrices especiales como la matriz de Hilbert o la matriz de Vandermonde:

>	hilbet(4);

>	vandermonde([s,t,u,v,w]);

Operaciones con Vectores

Veamos a continuación algunos de los comandos para la creación y manipulación de vectores dentro del entorno de Maple V:

>	v1:=vector([1,1,1]);

>	v2:=vector([1,0,0]);

Calculemos el ángulo determinado por los dos vectores anteriores:

>	angle(v1,v2);

También podemos calcular el producto escalar y el producto vectorial de ambos vectores:

>	dotprod(v1,v2);

>	crossprod(v1,v2);

Cuando los elementos del vector son funciones, tenemos la posibilidad de manipular de la misma manera todos los elementos del vector, de la misma manera que haríamos con una función:

>	diff_vector:=vector([sin(x),cos(x),sin(x)*cos(x)]);

>	map(diff,diff_vector,x);

Límites

Calculemos el límite de una función racional cuando x se aproxima al valor 1.

>	f:=(x^2-2*x+1)/(x^4+3*x^3-7*x^2+x+2);

>	Limit(f,x=1);

>

value(%);

Cuando el límite en un punto no se encuentra definido, siempre podemos recurrir al cálculo de límites laterales:

>	limit(tan(x),x=Pi/2);

>	limit(tan(x),x=Pi/2,left);

>	limit(tan(x),x=Pi/2,right);

Derivación e Integración

Maple V, como manipulador algebraico, permite calcular derivadas e integrales de manera simbólica:

>	diff(sin(x)*x,x);

>	int(cos(x),x);

>	int(sin(x),x=0..Pi);

Ahora podemos derivar una expresión, integrar el resultado y comparar la expresión inicial con la final:

>	f:=x*sin(a*x)+b*x^2;

>	df:=diff(f,x);

>	int(df,x);

>	simplify(%);

Podemos realizar integrales definidas:

>	int(df,x=1..2);

E incluso integrales mucho más complejas:

>	f:=exp(-x^2);

>

Int(f,x);

>

value(%);

En caso que Maple V no sepa resolver simbólicamente la integral, podemos usar el comando evalf para obtener una aproximación numérica.

>	int(exp(-x^3),x=0..1);

>

evalf(%);

Estudiemos otro ejemplo:

>	f:=exp(-a*t)*ln(t);

>	int(f,t=0..infinity);

Vemos cómo la solución simbólica consiste en un límite, cuyo valor final depende de los distintos valores que puede tomar el parámetro a. Si asumimos ciertas condiciones sobre el parámetro a, podemos obtener una expresión más concreta:

>	assume(a>0);

>	int(f,t=0..infinity);

Observación: El símbolo ~ indica que el parámetro a tiene en su memoria ciertas suposiciones. Para eliminar las posibles suposiciones que tenga el símbolo a debemos escribir:

>

a:='a';

Ecuaciones Diferenciales

Maple V puede resolver ecuaciones diferenciales ordinarias simbólica y numéricamente:

>	dsolve(diff(y(x),x)=y(x));

>	edsist:=diff(y(x),x)=z(x),diff(z(x),x)=y(x);

>	dsolve({edsist,y(0)=0,z(0)=1},{y(x),z(x)});

Las opciones del comando dsolve permiten especificar tres posibles metodologías para resolver ecuaciones diferenciales: métodos numéricos, métodos de series y métodos de Laplace:

>	ecuac:={diff(y(t),t)=x(t)+y(t),diff(x(t),t)=y(t),x(0)=2,y(0)=1};

>	result:=dsolve(ecuac,{x(t),y(t)},type=numeric);

El resultado es un procedimiento de Maple (es decir, una función implementada con lenguaje de programación de Maple) que puede ser representado gráficamente o evaluado en puntos concretos:

>	result(0);

>	result(1);

>

result;

Desarrollos de Taylor

>

restart;

Vamos a calcular la aproximación de Taylor de orden 8 en x = 0 de cierta función:

>	f:=sin(4*x)*cos(x);

>	fs1:=taylor(f,x=0,8);

Podemos comparar la función inicial con la aproximación gráficamente:

>	plot({f,convert(fs1,polynom)},x=-1..1,-2..2,title=`sin(4x) cos(x) vs. Desarrollo de Taylor`);

El orden del desarrollo de Taylor puede especificarse como opción del comando taylor o bien usando la variable global Order. Cambiaremos el orden, y estudiaremos cómo varía el gráfico con esta nueva aproximación:

>	Order:=12;

>	fs2:=taylor(f,x=0);

>	plot({f,convert(fs2,polynom)},x=-1..1,-2..2,title=`sin(4x) cos(x) vs. Desarrollo de Taylor de orden 12`);

Por último, crearemos una animación para estudiar la aproximación de f por distintos desarrollos de Taylor:

>

taylordisplay:=proc(func,xpoint,n::posint,xrange::range) local x,p,q,i; if type(xpoint,name) then x:=xpoint; elif type(xpoint,name=constant) then x:=lhs(xpoint); fi; p:=plots[display]([seq(plot(convert(taylor(func,xpoint,i),polynom),x=xrange,color=blue,args[5..nargs]),i=1..n)],insequence=true); q:=plot(func,x=xrange,color=red,args[5..nargs]); plots[display]([p,q]); end:

Veamos un par de ejemplos-animaciones. Una vez obtenido el output debemos pulsar sobre él y seleccionar el botón "Play" del menú de animaciones:

>	taylordisplay(exp(x),x=0,10,-6..6);

>	taylordisplay(sin(x),x=2*Pi,26,-3*Pi..3*Pi,view=-2..2);

>

Rectas tangentes

>

restart;

>	with(student);

La pendiente de la recta tangente a una curva en x=a se calcula como el límite del cociente incremental:

>	f:=x->x^2+3;

>	slope([x,f(x)],[a,f(a)]);

>	Limit(%,x=a);

Para calcular el límite, en primir lugar debemos simplificar la expresión racional (dado que presenta una indeterminación), y luego realizar el límite:

>	normal(%);

>

value(%);

En el caso particular que queramos calcular la pendiente de la recta tangente a la curva dada por f en x=3, simplemente debemos sustituir en la expresión anterior a=3.

>	subs(a=3,%);

Para mostrar gráficamente la tangente podemos usar el comando showtangent:

>	showtangent(f(x),x=3,x=0..4);

Ahora podríamos crear un programa que representara las rectas tangentes a f(x) en los puntos x= 0.8+0.2*i, cuando i toma valores enteros de 1 a 11. Usaremos el comando display con la opción insequence=true para obtener la animación:

>	for i to 11 do p||i:=showtangent(f(x),x=0.8+0.2*i,x=0..4,colour=black) od:

>	plots[display]([p||(1..11)],insequence=true);

>

Área bajo la curva

El Student Package contiene un conjunto de funciones que pueden resultar útiles para el aprendizaje de Cálculo Infinitesimal por parte de los alumnos.

>

restart;

>	with(student);

Consideremos el área de la curva y=sin(x), de x=0.1 a x=1. Podemos aproximarla mediante 4 rectángulos usando la función leftbox (contenida en el Student Package).

>	leftbox(sin(x),x=0..1,4);

La parte coloreada representa la aproximación al área bajo la curva. Si aumentamos el número de rectángulos (disminuyendo su base) parece ser que obtendremos mejores aproximaciones. Realicemos algunas pruebas:

>	leftbox(sin(x),x=0..1,8);

>	leftbox(sin(x),x=0..1,16);

Ahora realizaremos las aproximaciones numéricamente. Calcularemos la suma de las áreas de los rectángulos que hemos empleado en cada caso:

>	leftsum(sin(x),x=0..1,4);

>

value(%);

>	leftsum(sin(x),x=0..1,8);

>

value(%);

>	leftsum(sin(x),x=0..1,16);

>

value(%);

Veamos cómo varía el valor aproximado cuando aumentamos el número de rectángulos usados. Para ello usaremos un lazo:

>	for k from 20 to 200 by 20 do print(evalf(leftsum(sin(x),x=0..1,k))); od;

Podemos observar cómo las sumas convergen hacia cierto valor 0.457... Calculemos el límite de la suma de rectángulos para un número indeterminado n de rectángulos:

>	leftsum(sin(x),x=0..1,n);

>	limit(%,n=infinity);

Para comprobar la bondad de esta aproximación, podemos calcular la integral de la curva desde 0.1 hasta 1:

>	Int(sin(x),x=0..1);

>

value(%);

>