MAPLE Manual

Introduccion al uso del paquete computacional
Maple
Dr. Horacio Martnez Alfaro
hma@itesm.mx
http://www-cia.mty.itesm.mx/~hma
Centro de Inteligencia Articial

Instituto Tecnologico y de Estudios Superiores de Monterrey
Campus Monterrey
Enero de 1997
i
Indice General
1 Algunas habilidades de Maple 1
2 Uso interactivo de Maple 5
3 Maple un poco menos simple 25
4 El lenguaje de programacion de Maple 51
5 Gracas avanzadas 63
c Dr. Horacio Martnez Alfaro, ITESM.

1
Captulo 1
Algunas habilidades de Maple
1.1 Maple: un sistema para computacion matematica
Collage de comandos de Maple

Suma de los cubos del 1 al 1234567890987
> S := sum(i^3, i=1..1234567890987);
S := 580764308853803529746462848150892628716236806084
y ahora expresar la suma en sus factores
> ifactor(S);
( 2 )2 ( 3 )2 ( 31 )2 ( 103 )2 ( 449 )2 ( 128882753 )2 ( 687398603 )2
Resolver un sistema de ecuaciones lineales en tres incognitas

> solve({a*x+3*y+3*z=10, x-y+a*z=2, 3*x-2*y+z=6},{x,y,z});

a5 19 a 5 3 a2 16 a + 5
z= ,x = ,y =
a(4 + a) a(4 + a) a(4 + a)
Declarar una ecuacion diferencial y almacenarla (o etiquetarla)

> de := diff(y(x),x,x) + 2*diff(y(x),x) + y(x) = exp(-x);
2

de := y( x ) + 2 y( x ) + y( x ) = e( x )
x2 x
y ahora resolver la ecuacion diferencial anterior con condiciones iniciales
> soln := dsolve({de, y(0)=1, D(y)(0)=0}, y(x));
1
soln := y( x ) = x2 e( x ) + e( x ) + e( x ) x
2
Ahora, gracamos la solucion

> plot(rhs(soln),x=0..8);

Captulo 1. Algunas habilidades de Maple 2
0.8
0.6
0.4
0.2
00 2 4 6 8
Resolver una ecuacion con 40 dgitos de precision

> Digits := 40;
Digits := 40
> fsolve(cot(x+ Pi/8)=x, x);

.6218013732036774103273149629860812356122
> Digits := 10:

Resolver una ecuacion de recurrencia con condiciones iniciales
> reqn := 6*f(n+3) - 103*f(n+2) + 144*f(n+1) = 47*f(n);
reqn := 6 f( n + 3 ) 103 f( n + 2 ) + 144 f( n + 1 ) = 47 f( n )
> rsolve({reqn,f(0)=1,f(1)=2,f(2)=4},f(n));
n n
123 164 1 27 47
+
44 91 2 4004 3
Calcular la integral indenida de

> integrand :=(8*x^3+7*x^2-3)/(6*x^4+5*x^3-60*x^2-20*x-21);
8 x3 + 7 x2 3
integrand :=
6 x + 5 x3 60 x2 20 x 21
4
> int(integrand,x);
276 1041 815
ln( x 3 ) + ln( 2 x + 7 ) + ln( 3 x2 + x + 1 )
403 1781 25482
4387 1
+ 11 arctan ( 6 x + 1 ) 11
140151 11
Calcular un integral denida impropia

> int(exp(-x^2)*ln(x), x=0..infinity);
1 1
ln( 2 )
4 2

Denicion de una matriz con elementos numericos

> with(linalg):
> A := matrix(4,4,[ -26, -28, 89, -456, 104, 258, -770, 3132,
> 40, 88, -266,1109, 2, 1, -4, 26]);

26 28 89 456

104 258 770 3132

A :=

40 88 266 1109

2 1 4 26
Calcular la matriz exponencial

> evalf(matrixexp(A));

36.63075000 100.0804420 294.4444646 1171.710326

7.668999383 20.02962192 59.63774815 240.4005748

14.84176939 40.80358790 119.8619492 476.1546382

5.503634852 15.02221644 44.20952586 175.9809800
Denicion de una matriz Toeplitz con elementos simbolicos

> T := toeplitz([a,b,c]);

a b c

T := b a b

c b a
Calcular sus valores caractersticos

> eigenvals(T);
1 1 2 1 1 2
a c, a + c+ c + 8 b2 , a + c c + 8 b2
2 2 2 2
Graca de una supercie en 3D

> plot3d(x^2+3*BesselJ(0,y^2)*exp(1-x^2-y^2),x=-2..2, y=-2..2, axes=FRAME);
0
-2 -2
-1 -1
0 0
y x
1 1
2 2
Gracas de dos tubos mediante supercies en 3D

> with(plots):
> tubeplot({[10*cos(t),10*sin(t),0,t=0..2*Pi,radius=2+cos(7*t),
> numpoints=120, tubepoints=24],[0, 10+ 5*cos(t), 5*sin(t), t=0..2*Pi,
> radius=1.5, numpoints=50, tubepoints=18]},scaling=CONSTRAINED);

6
4
2
0
-2
-4
-6
-10
-10
-5
-5
0
0
5
5
10
10
15

5
Captulo 2
Uso interactivo de Maple
2.1 Ejecucion de Maple
Normalmente sera con maple o xmaple para DOS, Unix o XWindows, o dando doble click sobre la
aplicacion en Mac, NeXT, o Windows.
2.2 Como terminar una sesion de Maple
quit Termina una sesion de Maple

done
stop
Si se tiene una ambiente de ventanas, por menu.
2.3 Arimetica simple en Maple
Tabla 2.1: Operaciones aritmeticas en Maple
Operacion Smbolo Ejemplo

suma + 2 + 2
resta - 10 -x
multiplicacion * 3 * y * z
division / x /2
division truncada iquo(..) iquo(17,3)
residuo entero irem(...) irem(10,7)
exponenciacion ^ o ** x^2, x**2
valor absoluto abs(...) abs(-4)
factorial ! 10!
> 2 + abs(-2);
4

Captulo 2. Uso interactivo de Maple 6
> (4 + (" * 6))/(999999-32516);

28
967483
> 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 *
> 10 * 11 * 12 * 13 * 14 * 15 * 16 * 17 * 18:
> " - 18!;
0
> 2 * * 4 * 5 * 6 -;
syntax error:
2 * * 4 * 5 * 6 -;
^
> 2 * 3 * 4 * 5 * 6 -;
syntax error:
2 * 3 * 4 * 5 * 6 -;
^
2.4 Ayuda en lnea
?topico Da informacion sobre topico

?topico,subtopico
?topico[subtopico]
help(topico)
El uso de las opciones anteriores suponen un conocimiento sobre lo que se esta buscando. Sin embargo,
si no se sabe el nombre de la funcion o comando, se puede consultar el ndice con el coamando ?index.
Si en lugar de utilizar una sola ? utilizamos dos, ??, Maple desplegara la sintaxis del comando/funcion
y la descripcion de los parametros que utiliza.
Si utilizamos tres ?, ???, Maple desplegara solo los ejemplos del comando/funcion que se invoque.
2.5 Variables en Maple
variable := expresion; Asigna un valor a una variable
Una variable matematica o una variable sin asignar es una variable que no tiene un valor asignado.
Una variable comienza con una letra y le pueden seguir hasta 498 letras, dgitos o guiones infere-
riores.
Si se desea que una variable contenga otros caracteres, el nombre debe de ir entre comillas
izquierdas sencillas ().
expr1 x T
Formula_47 d2DYDX nombre raro?
La respuesta es= SesionLog.m

> fuerza := masa * aceleracion;

fuerza := masa aceleracion
> masa := 3000;

masa := 3000
> aceleracion := 9.8;

aceleracion := 9.8
> fuerza;
29400.0
> masa := 3500;

masa := 3500
> fuerza;
34300.0
> distancia1 := 10;

distancia1 := 10
> distancia2 := 50;

distancia2 := 50
> Energia\:total := fuerza * (distancia2 - distancia1);

Energia total := .13720000 107
2.6 Comandos y funciones predenidas
Tabla 2.2: Constantes matematicas conocidas por Maple
Constante Nombre en Maple

enteros -47,1,2
numeros racionales 3/5,-1/3
numeros de punto otante 1.0,.002,Float(314,-2)
verdadero, falso true, false
Pi
e (base del logaritmo
natural) exp(1), E
1 I,(-1)^(1/2)
infinity
Constante de Euler gamma
Constante Catalan Catalan

> expr1 := (x + y + x + x*x*x + x) / 2;

3 1 1
expr1 := x + y + x3
2 2 2
> expr2 := ((4*expr1) - 2*y) / x;

6 x + 2 x3
expr2 :=
x
> exprgrande := sin( expr1 ) / ln ( expr2 ^ 2);

3 1 1
sin x + y + x3
2 2 2
exprgrande :=
( 6 x + 2 x3 )2
ln
x2
2.7 Introduccion a los comandos matematicos
2.7.1 Uso de solve
solve(ecuacion,variable) Resuelve una ecuacion en una variable

solve(conj-ecs, conj-vars) Resuelve un conj. de ecs. en un conj. de vars.
> solve(3*x + 4 = 5*x);
2
> solve(ln(x^2 - 1) = a, x);

ea + 1, ea + 1
> solve(q^3-k, q);

1 1/3 1 1/3 1 1
k 1/3 , k + I 3 k , k 1/3 I 3 k 1/3
2 2 2 2
> soluciones:=";
1 1/3 1 1/3 1 1
soluciones := k 1/3 , k + I 3 k , k 1/3 I 3 k 1/3
2 2 2 2
> soluciones[1];
k 1/3
> soluciones[3];
1 1/3 1 1/3
k I 3k
2 2
Soluciones de sistemas de ecuaciones

> ecnconjunto := {x+y=b, a*x-2/3*y = k};

2
ecnconjunto := x + y = b, a x y = k
3

> varconjunto := {x,y};

varconjunto := { x, y }
> Solconjunto := solve(ecnconjunto, varconjunto);

3k + 2b ab k
Solconjunto := x = ,y = 3
3a + 2 3a + 2
La funcion predenida assign tomara el conjunto solucion que regreso solve y asignara los valores
correspondientes
> assign(Solconjunto);
> x;
3k + 2b
3a + 2
> y;
ab k
3
3a + 2
> ecnconjunto;

3k + 2b ab k a(3k + 2b) ab k
+3 = b, 2 =k
3a + 2 3a + 2 3a + 2 3a + 2
> simplify(ecnconjunto);
{ k = k, b = b }
Para que las variables x y y retomen valores desconocidos, se tiene que eliminar sus valores asignados
asignandoles sus propios nombres entre comillas simples:
> x := x; y := y;
x := x
y := y
> ecnconjunto;

2
x + y = b, a x y = k
3
> solve({y^2+1=x, x+2=y},{x,y});

{ y = RootOf( Z 2 + 3 Z ), x = 2 + RootOf( Z 2 + 3 Z ) }
Cuando no se puede encontrar una solucion, Maple respnde con nada

> solve( x=x+1, x );
> solve({cos(x*Pi)=0, cot(x*Pi/3)=0}, {x} );
Maple no siempre da todas las soluciones
> solve(cos(x*Pi)=0,x);
1
2

Si no se le proporcionan variables (incognitas), Maple tratara de resolver para todas las incognitas
> solve( a*x^2 + b*x + c = 0 );
{ b = b, c = a x2 b x, a = a, x = x }
2.8 Sustitucion de expresiones
subs(var = sust,expr) Sustitucion de una variable en una expresion

subs(var1 = sust1 , var2 = sust2 , expr) Sustitucion de una variable en una expresion
> soln:= solve(3*x-y=x,x);
1
soln := y
2
> subs(x=soln, 3*x-y=x);

1 1
y= y
2 2
> msol := solve( e=m*c^2,m);

e
msol :=
c2
> subs(m=msol, a=9.8, c=300000, f = m * a);

f = .1088888889 109 e
La sustitucion se realiza en orden de izquierda a derecha

> subs(c=300000, m=msol, a=9.8, f = m * a);
e
f = 9.8 2
c
> expr2 := cos(x)^2 + tan(x)^2;

expr2 := cos( x )2 + tan( x )2
> subs(tan(x)=sin(x)/cos(x), cos(x)^2=1-sin(x)^2, expr2);

sin( x )2
1 sin( x )2 +
cos( x )2
> subs(cos(x)^(-2)=1/(1-sin(x)^2),");
sin( x )2
1 sin( x )2 +
1 sin( x )2
El siguiente ejemplo muestra una sustitucion simultanea

> f := x*y^2 + z;
f := x y 2 + z
> subs( x=y, y=x, f );

x3 + z

> subs({x=y, y=x}, f );

y x2 + z
2.9 Maple como una calculadora para operaciones numericas
evalf(expresion) Encontrar una aproximacion numerica

evalf(expresion, dgitos) Encontrar una aproximacion numerica calculada
con mas dgitos
> 1.0 + 3/5;
1.600000000
> 3.0*10^20 - 2.99*10^13;

.2999999701 1021
> 1.0/3.0 + 1.0/3.0 + 1.0/3.0;

.9999999999
> " - 1;
.1 109
> sum(1/(2*i-1),i=1..10);
31037876
14549535
> sum(1.0/(2*i-1),i=1..10);
2.133255530
La variable Digits controla la precision de los calculos de punto otante

> Digits;
10
> Digits := 5:
> 2.0/3.0 + 5;
5.6667
> Digits := 40:

> 2.0^(1/3);
1.259921049894873164767210607278228350570
> Digits := 10:

Se pueden hacer aproximaciones a resultados exactos mediante la funcion evalf
> expr1 :=tan(1.0) + tan(2);
expr1 := 1.557407725 + tan( 2 )

> evalf(expr1);
.627632138
> Digits := 20:

> evalf(expr1);
.6276321382615189916
> evalf(sqrt(2), 40);

1.414213562373095048801688724209698078570
> {solve( (x^3+1)* (x^6+3*x+1), x )};

6 1 1 1 1
1, RootOf( Z + 3 Z + 1 ), I 3, + I 3
2 2 2 2
> evalf(");
{1.1644839172258724765, .50000000000000000000 + .86602540378443864675 I,
.50000000000000000000 .86602540378443864675 I, 1.}
2.9.1 Solucion numerica de ecuaciones
fsolve(expresion) Resolver ecuaciones numericamente

fsolve(conj-ecs, conj-vars)
fsolve(conj-ecs, conj-vars, opciones)
Tabla 2.3: Opciones para fsolve
Cuando opcion fsolve calcula

complex Una raz compleja. Si la expresion es un polinomio, se encuentran
todas las races complejas.
a..b Si expresion contiene una sola variable, se buscaran races solo en
el intervalo abierto (a, b).
x = a..b, y = c..d, . . . Limita la busqueda cuando expresion contiene mas de una varia-
ble.
maxsols=n Encuentra a lo mucho n races de un polinomio.
fulldigits Por default para ahorrar tiempo y memoria, fsolve utiliza menos
de los dgitos de precision cuando Digits es grande. Esta opcion
hace que folve si utilice todos los dgitos de precision en los
calculos internos con un mayor costo en tiempo y memoria.
> fsolve(cos(x)=x);
.7390851332
En ocasiones, fsolve se comportara como solve (que da como respuesta nada) o como int o sum
que dan como resultado la expresion que se le dio a Maple de entrada
> fsolve({x^2+y^2=1,x^3*y+2*x*y=3}, {x,y});

> fsolve(sin(x)^2+cos(x)^2=2, x);

fsolve sin( x )2 + cos( x )2 = 2, x
Si la solucion no contiene un valor real, fsolve dara como resultado nada

> fsolve(x^2+1=0, x);
> fsolve(x^4-x^3-x^2-x-2, x);
1., 2.
Si el problema es muy sensible a errores de redondeo, fsolve no podra encontrar todas las races de
una manera precisa.
> poly := 23*x^5 + 105*x^4 - 10*x^2 + 17*x:
> fsolve(poly, x);
0, 4.536168981, .6371813185
> fsolve(poly, x, complex);

0, 4.536168981, .6371813185, .3040664543 .4040619058 I,
.3040664543 + .4040619058 I
> fsolve(poly, x, x=-1..0);

0, .6371813185
> fsolve(poly, x, maxsols=2);

0, 4.536168981
> fsolve(poly, x, x=-5..-.5, maxsols=1);

4.536168981
> f := sin(a+b) - log10(a)*b = 0;

f := sin( a + b ) log10( a ) b = 0
> g := a - b^2 = 1;
g := a b2 = 1
> fsolve({f,g}, {a,b}, {a=-1..1,b=-2..2});
2.10 Uso de plot
plot(expr, var=rangoH) Gracar una sola funcion

plot(expr, rangoH)
plot(expr, rangoH, rangoV)
plot(conj-exprs, var=rangoH) Desplegar varias funciones en la misma graca
Una forma tpica de ejecutar la funcion plot es plot(f(x),x=a..b), donde f es una funcion
real en x y a..b especica el rango real horizontal en el que f se gracara.

La funcion plot proporciona soporte para gracas en dos dimensiones de una o mas funciones
especicadas como expresiones, procedimientos, funciones parametricas o listas de puntos (cuando
se graca un procedimiento, la notacion de operador se debe de utilizar). Se puede consultar
?plot[function] para mayor informacion. Para gracas en tres dimensiones, ver ?plot3d. La
ejecucion de plot produce una estructura de datos PLOT wue posteriormente se despliega. Para
mayor informacion, ver ?plot[structure].
Los argumentos para los rangos horizontal y vertical, rangoH y rangoV, denen las etiquetas de
los ejes y los rangos en que se desplegara la funciones (o funciones). La forma de los rangos puede
ser una de las siguientes: string,a..b, o string=a..b, donde a y b son constantes reales. Para
mayor informacion, ver ?plot[range].
Los argumentos restantes se interpretan como opciones que se especican como ecuaciones en
la forma de opcion=valor. En particular, la opcion style permite gracar los puntos como
puntos solamente, o interpolarlos utilizando el modo de line. Para mayor informacion, ver
?plot[options].
Deniendo la variable global plotdevice (va el comando interface) con uno de los valores lis-
tados bajo ?plot[device], controla el tipo de graca que se producira. Para mayor informacion,
ver ?plot[device] y ?plot[setup].
> plot(sin(1/x)*exp(-x),x=.15..1.5); > plot({sin(x),x-x^3/6+x^5/120},

> > x=-4..4);
1.5
1
0.4
0.5
0.2
x -4 -2 00 2 4
0.2 0.4 0.6 0.8 1 1.2 1.4 x
0
-0.5
-0.2
-1
-0.4 -1.5
-0.6
-0.8

Tabla 2.4: Opciones para plot.
Opcion Descripcion
scaling Controla la escala de la graca. Puede ser CONSTRAINED o UNCONSTRAINED.
El default es UNCONSTRAINED.
axes Especica el tipo de ejes, a escoger uno de: FRAME, BOXED, NORMAL y NONE.
coords=polar Indica que una graca parametrica esta en coordenadas polares. El primer
parametro es el radio y el segundo parametro es el angulo.
numpoints=n Especica el mnimo numero de puntos que se generaran. Nota: plot
emplea un algoritmo adaptable para gracar que automaticamente hace
mas trabajo cuando los valores de la funcion no caen cercanos a una lnea
recta. Por lo tanto, plot comunmente generara mas puntos que el numero
mnimo.
resolution=n Dene la resolucion horizontal de despligue del disposivo en pixeles (el de-
fault es 200). El valor de n es usado para determinar cuando el esquema
adaptable de gracado ha terminado. Un valor mayor resultara en mas
evaluaciones de la funcion cuando esta no es suave.
color=n Permite al usuario especicar el color de las curvas que se van a gracar.
Ver ?plot,color para detalles.
xtickmarks=n Indica que un numero razonable no menor que n que debera marcarse sobre
el eje horizontal; n debera ser un netero positivo. Tambien existe una opcion
ytickmarks=m, que corresponde al eje vertical.
style=s El estilo de interpolacion debera ser uno de los siguientes (el default es
LINE): POINT solo puntos, LINE interpolacion lineal, y PATCH estilo de par-
ches para polgonos.
discont=s Para grecado con expresiones solamente. Si s es true, primero se llama a
discont de la biblioteca de rutinas para determinar las discontinuidades de
la funcion de entrada y posteriormente parte el eje horizontal en intervalos
apropiados donde la expresion es continua.
title=t El ttulo de la graca. t debera ser un string. El default es sin ttulo.
thickness=n Grosor de las lneas en la graca. n debera ser 0, 1, 2 o 3. El default es 0.
linestyle=n Controla el patron de guionado utilizado para generar las lneas en la graca.
Los estilos 0 y 1 dan lneas solidas mientras que valores mayores varan el
patron de guionado.
symbol=s Smbolo para puntos en la graca. s es uno de BOX, CROSS, CIRCLE, POINT
y DIAMOND.
font=l Font para los objetos tipo texto en la graca. l es una lista de la for-
ma [familia, estilo, tama~ no], donde familia es una de TIMES, COURIER,
HELVETICA, y SYMBOL. Para TIMES el estilo podra ser uno de ROMAN, BOLD,
ITALIC o BOLDITALIC. Para HELVETICA y COURIER, estilo podra omitirse
o ser uno de BOLD, OBLIQUE o BOLDOBLIQUE. SYMBOL no acepta la opcion
estilo. El ultimo parametro, tamano, debera ser el tamano en puntos a
utilizar.
continua en la siguiente pagina

Opcion Descripcion
titlefont=l Font para el ttulo de la graca y se especica en la misma forma que font.
axesfont=l Font para las etiquetas en la marcas de los ejes. Se especica en la misma
forma que font.
labelfont=l Font para las etiquetas (nombres) de los ejes en la graca. Se especica de
la misma forma que font.
view= Indica el mnimo y maximo que se desplegara en ambos ejes. El default es
[xmin..xmax, que sea la totalidad de la curva.
ymin..ymax]
Graca de unos puntos dados como una lista, los Graca de una serie de puntos generados a partir
elementos nones son las x y los pares las y. de la evaluacion de una funcion
> plot([0,0,1,1,2,2,3,3,4,4,5,5], > plot([[n,sin(n/Pi)] $n=1..20],
> x=0..5,y=0..5,style=point); > x=0..20,style=point,
> > symbol=circle);
5 1
4
0.5
y
00 5 10 15 20
2 x
1 -0.5
00 1 2 3 4 5 -1
2.11 Denicion de funciones simples en Maple

> f := y -> y^2;
f := y y 2
> sin(f(x+1)) * f(f(5))/sqrt(f(Pi+y));

sin ( x + 1 )2
625
( + y )2
> diff(f(z),z);
2z
Denicion de una funcion con varios parametros

> hyperg := (R,B,D,r) -> binomial(R,r)*binomial(B,D-r)/binomial(R+B,D);
binomial( R, r ) binomial( B, D r )
hyperg := ( R, B, D, r )
binomial( R + B, D )

> hyperg(10,10,2,0), hyperg(10,10,2,1), hyperg(10,10,2,2),

> hyperg(10,10,2,0) + hyperg(10,10,2,1) + hyperg(10,10,2,2);
9 10 9
, , ,1
38 19 38
Muchas veces se ha calculado alguna expresion y posteriormente se desea declarar una funcion con dicha
expresion. Para esos casos, se utiliza el comando unapply
> expr1 := tan(t):
> expr2 := diff(tan(t),t):
> f := unapply(expr2,t);
f := t 1 + tan( t )2
El comando unapply puede tener argumentos adicionales que permiten la declaracion de funciones de
mas de una variable
> expr3 := subs(t=s*t,expr2):
> g := unapply(expr3,s,t);
g := ( s, t ) 1 + tan( s t )2
2.12 Simplicacion de expresiones con simplify
simplify(expresion) Simplica una expresion

simplify(expresion, regla) Usa regla de simplicacion
> expr := 2*(cos(2*y))^2 + 3*(sin(2*y))^2 + exp(x)^(5/2)*(1 + 2*x + x^2)^(1/2) +
> 2^(5/2);

expr := 2 cos( 2 y )2 + 3 sin( 2 y )2 + ( ex )5/2 1 + 2 x + x2 + 4 2
> simplify(expr);

cos( 2 y )2 + 3 + e( 5/2 x ) csgn( 1 + x ) + e( 5/2 x ) csgn( 1 + x ) x + 4 2
> simplify(expr,power);

2 cos( 2 y )2 + 3 sin( 2 y )2 + e( 5/2 x ) csgn( 1 + x ) + e( 5/2 x ) csgn( 1 + x ) x + 4 2
> simplify(expr,trig);

cos( 2 y )2 + 3 + ( ex )5/2 ( 1 + x )2 + 4 2
> -1/2*(-64/27)^(1/6)-1/2 * (-1)^(1/3) * (-64/27)^(1/6) + 4 +

> (-3)^(1/2) * 1/2 * ((-64/27)^(1/6) - (-1)^(1/3) * (-64/27)^(1/6));
1 1
( 64 )1/6 275/6 ( 1 )1/3 ( 64 )1/6 275/6 + 4
54 54
1 1 1/6 5/6 1 1/3 1/6 5/6
+ 3 ( 64 ) 27 ( 1 ) ( 64 ) 27
2 27 27
> simplify(");
4

Tabla 2.5: Reglas de transformaciones disponibles con simplify.
Regla Simpicacion que involucre

atsign Operadores funcionales
GAMMA La funcion
hypergeom Funciones hipergeometricas
power Potencias, exponenciales, logaritmos
radical Expresiones que involucren radicales (potencias fraccionales)
RootOf Expresiones que incluyan la funcion RootOf
sqrt Races cuadradas o potencias de estas
trig Potencias de funciones trigonometricas
2.13 Comandos para calculo
2.13.1 Diferenciacion
> diff( sin(ln(x^2 + 1) / 3), x);
1 2
cos ln( x + 1 ) x
2 3
3 x2 + 1
> (t^2 - s) / (s^3 - 1):

> diff(", t, s);
t s2
6
( s3 1 )2
2.13.2 Integracion
> Int(x^3*cos(x), x) = int(x^3*cos(x), x);

x3 cos( x ) dx = x3 sin( x ) + 3 x2 cos( x ) 6 cos( x ) 6 x sin( x )
> Int((x^3)*sqrt(x^2 - a^2), x=a..2*a) = int( (x^3)*sqrt(x^2-a^2), x=a..2*a);

2a
14 2
x3 x2 a2 dx = a 3 ( a2 )3/2
a 5
> Int((x^2)/sqrt(1-x^2), x) = int((x^2)/sqrt(1-x^2), x);

x2 1 1
dx = x 1 x2 + arcsin( x )
1 x2 2 2
> Int(cos(theta)^3, theta=0..Pi/2) = int(cos(theta)^3, theta=0..Pi/2);

1/2
2
cos( )3 d =
0 3
> Int( 1/(1+x^2), x=0..infinity) = int( 1/(1+x^2), x=0..infinity);

1 1
2
dx =
0 x +1 2

En ocasiones, Maple no podra calcular una solucion de forma cerrada y respondera con el comando que
se ejecuto
> int( 1/(x+exp(x)), x=0..1);
1
1
dx
0 x + ex
La respuesta es solo la version de alta resolucion del comando original

> lprint(");
int(1/(x+exp(x)),x = 0 .. 1)
Sin embargo, se puede utilizar evalf para aproximar la solucion

> evalf(");
.5163007634
2.13.3 Solucion de ecuaciones diferenciales con dsolve
dsolve(ec., vardep(varind)) Resuelve una ecuacion diferencial

dsolve(conj-ec y cond-inic, vardep(varin)) Resuelve un problema con valor inicial
dsolve(conj-ecs. y cond-inic, conj-vars) Resuelve un conj. de ecs. diferenciales
dsolve(conj-ecs. y cond-inic, conj-vars, opcion)
Tabla 2.6: Opciones para dsolve
Opcion dsolve calcula

laplace Una solucion utilizando el metodo de transformada de Laplace.
series Una solucion en series de potencia (el valor de la variable global Order, con un
valor default de 6, determina el numero de terminos).
explicit Una solucion utilizando solve para forzar que la solucion sea expresada en
terminos de la variable dependiente.
numeric Solucion numerica de problemas de valor inicial.
Al declarar la ecuacion diferencial, se tiene que declarar que la funcion y depende explcitamente de la
variable x, es decir y(x). Lo anterior permite utilizar diff para denir la deriva de y(x) con respecto
a x.
> deq := diff(y(x),x)*x^2+y(x)=0;

deq := y( x ) x2 + y( x ) = 0
x
La solucion de la ecuacion diferencial se obtiene mediante el comando dsolve, siendo los parametros
la ecuacion diferencial a resolver y la funcion que se desea encontrar.
> dsolve(deq, y(x));
y( x ) = e( x ) C1
1

Un problema de valor inicial se dene como un conjunto de ecuaciones formado por la ecuacion diferencial
y las condiciones iniciales
> dsolve({deq, y(1)=a},y(x));
e( x ) a
1
y( x ) =
e
Como parte de la programacion de dsolve, se incluye el algoritmo de Kovacic para resolver ecuaciones
diferenciales lineales homogeneas de segundo orden con coecientes racionales.
> dsolve(x^2*diff(y(x),x,x) + 5*diff(y(x),x) = 0,y(x));

( 1
5x ) 1
y( x ) = C1 + C2 x e + 5 Ei 1, 5
x
Sin embargo, no siempre puede encontrar una solucion; en cuyo caso, se puede aproximar la solucion
mediante series (el orden default es 6)
> dsolve( diff(f(x),x) + f(x)^5*x = sin(x), f(x));
> dsolve( {f(0)=1/2, diff(f(x),x) + f(x)^5*x = sin(x)},f(x), series);
1 31 2 977 4
f( x ) = + x x + O( x6 )
2 64 12288
Tambien se pueden resolver sistemas de ecuaciones diferenciales con condiciones iniciales para un con-
junto de funciones.
> sys := { diff(y(x),x) = z(x), diff(z(x),x) = y(x), y(0) = 0, z(0) = 2};

sys := y( x ) = z( x ), z( x ) = y( x ), y( 0 ) = 0, z( 0 ) = 2
x x
> fcns := {y(x), z(x)};

fcns := { z( x ), y( x ) }
> dsolve(sys, fcns);

{ z( x ) = ex + e( x ) , y( x ) = ex e( x ) }
2.13.4 Series de Potencia
Se calculan los primeros terminos de la serie de Taylor para la funcion sin(x) al rededor de x = 0. El
default es que Maple calcule los terminos hasta de orden 6.
> t1 := series(sin(x), x=0);
1 3 1 5
t1 := x x + x + O( x6 )
6 120
> t2 := series(ln(x), x=1, 4);

1 1
t2 := x 1 ( x 1 )2 + ( x 1 )3 + O ( x 1 )4
2 3
La informacion sobre el orden en resultados de series se utiliza cuando se realizan operaciones

aritmeticas en ellas mismas. En este ejemplo, el resultado solo es hasta O(x7 ) dado que t1 es solamente

O(x6 ).
> S := series(t1*t1, x=0, 10);
1 4 2 6
S := x2 x + x + O( x7 )
3 45
Para evaluar una serie en un valor dado, se tiene que primero calcular la serie y luego convertirla a
un polinomio mediante la eliminacion de los terminos de orden. Lo anterior se logra con la funcion
predenida convert:
> P := convert(", polynom);
1 4 2 6
P := x2 x + x
3 45
> subs(x=2, P);

68
45
> subs(x=2, S);

Error, invalid substitution in series
Para eliminar los terminos de orden superior de un polinomio de una serie, se puede dividir por la
potencia de menor orden que se desea eliminar utilizando la funcion predenida rem:
> rem(P,x^6, x);
1 4
x2 x
3
Los polinomios tienen una expansion en series que son correctas exactamente si el orden de expansion
es mayor que el grado del polinomio
> series(x^10 + 1, x=0, 20);
1 + x10
> series("*", x=0, 25);

1 + 2 x10 + x20
> series(x^10+1, x=0,5);

1 + O( x10 )
> series("*", x=0, 25);

1 + O( x10 )
> series(GAMMA(x), x=0,2);

1 2 1 2
x1 + + x + O( x2 )
12 2
> series(sqrt(cos(x)), x=0, 4);

1 2
1 x + O( x4 )
4

2.13.5 Lmites
> r := (x^2 - 1) / (11*x^2 - 2*x -9):
> limit( sqrt(r), x=1 );
1
10
10
> limit( sin(x)/x, x=0 );

1
> limit( sin(1/x^2), x=0 );

1..1
> limit( sin(1/x)/x, x=0 );

undefined
> intsin01 := sum( sin(i/n)*1/n,

i=1..n
);
n+1 1 n+1 1 1 1
sin sin cos sin sin cos
1 n 1 n n 1 n 1 n n
intsin01 := + +
2 n 2 1 2 n 2 1
n 1 + cos n 1 + cos
n n
> limit( intsin01, n=infinity );
cos( 1 ) + 1
> limit( c*x, x=infinity );

signum( c )
Lmites con direccon de aproximamiento

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

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

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

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

> limit(-x, x=infinity);

> limit(-x, x=-infinity);


> limit(-x, x=infinity, real);

undefined
> limit(-x, x=infinity, complex);

2.14 Calculo de sumas

> sum( i, i=1..100);
5050
> sum( i^2, i=1..n);

1 1 1 1
( n + 1 )3 ( n + 1 )2 + n +
3 2 6 6
> sum(2^j, j=m..n);

2( n+1 ) 2m
> sum(1/(i^2),i);
( 1, i )
> sum(1/(1-i),i=0..n);
n
1
i=0
1i
> lprint(");
sum(1/(1-i),i = 0 .. n)
2.15 Solucion de relaciones de recurrencia con rsolve

> rsolve(f(n) = -3*f(n-1) - 2*f(n-2), f);
( 2 f( 0 ) + f( 1 ) ) ( 1 )n + ( f( 0 ) f( 1 ) ) ( 2 )n
Encontrar una solucion de forma cerrada la recurrencia de Fibonacci

> Fib_soln:= rsolve({F(n) = F(n-1) + F(n-2), F(1..2)=1}, F );
n
1
1 + 5 5 2 n
1 1 5 1 1
Fib soln := 5 2
5 1 5 5 1+ 5
> [seq( simplify(subs(n=i, Fib_soln)), i=1..10 )];

1 1 1
4 , 16 2 2 , 128 3 3 ,
1 + 5 1 + 5 1+ 5 1 + 5 1+ 5 1 + 5
1 1
768 4 4 , 5120 5 5 ,
1+ 5 1 + 5 1+ 5 1 + 5

1 1
32768 6 6 , 212992 7 7 ,
1+ 5 1 + 5 1+ 5 1 + 5
1 1
1376256 8 8 , 8912896 9 9 ,
1+ 5 1 + 5 1+ 5 1 + 5

1
57671680 10 10
1+ 5 1 + 5
> evalf(");
[.9999999992, .9999999989, 1.999999996, 2.999999992, 4.999999984, 7.999999967,
12.99999994, 20.99999989, 33.99999981, 54.99999964]
El comando rsolve puede tomar un tercer parametro ztrans, el cual hace que rsolve utilice el metodo
de transformada Z
> rsolve( {y(n+1) + f(n) = 2*2^n + n, f(n+1) - y(n) = n- 2^n + 3,
> y(1)=1, f(5)=6}, {y,f}, ztrans );
{ y( n ) = 1 + 2n , f( n ) = n + 1 }

25
Captulo 3
Maple un poco menos simple
Tabla 3.1: Resumen de comandos para este captulo
expand Distribuye las multiplicaciones sobre adiciones. Tambien, aplica varias

reglas de angulos para funciones trigonometricas, suma de reglas de ar-
gumentos para exponenciales, etc.
combine Agrupa terminos de expresiones.
normal Pone a una expresion en la forma de numerador sobre denominador y
obtiene el maximo comun divisor del numerador y denominador.
collect Organiza una expresion con respecto a una variable o variables.
sort Ordena terminos en forma ascendente o descendente. Con opciones, se
puede denir si el ordenamiento es alfabetico, por grado o de acuerdo a
otro criterio.
convert Convierte funciones trigonometricas, exponenciales, binomiales u otras
funciones a formas alternativas. Puede tambien convertir expresiones a
fracciones parciales, fractiones continuas, radicales, RootOfs y muchas
otras formas.
factor Factoriza polinomios de una o varias variables o terminos.
3.1 Mas sobre simplicacion

> expr1 := (x+y+z)^2 - (x+y)^2;
expr1 := ( x + y + z )2 ( x + y )2
> expand(expr1);
2 x z + 2 y z + z2
> expr2 := cos(a+b)-exp(a+b)+ (n+1)!^2/(n!^2);

( ( n + 1 )! )2
expr2 := cos( a + b ) e( a+b ) +
( n! )2

Captulo 3. Maple un poco menos simple 26
Tabla 3.2: Forma en que combine simplica expresiones
combine(expr , trig) Elimina productos y potencias de cos, sin, cosh, y sinh en expr utilizando
varias reglas para angulos como:
a+b ab
sin(a) cos(b) sin + sin
2 2
a+b ab
sinh(a) sinh(b) cosh cosh
2 2
combine(expr , exp) Simplica productos y potencias de exponentes en expr utilizando reglas:

a
ex ey ex+y ex exa ex+n ln(y) ex y n
combine(expr , ln) Simplica sumas y productos de expresiones logartmicas y no logartmicas en

expr utilizando reglas:
a ln(x) ln(xa ln(x) + ln(y) ln(xy)
combine(expr , power) Simplica expresiones que contengan productos de potencias (incluyendo expo-
nenciales) utilizando reglas:
xy xz xy+z (xy )z xyz
ex ey ex+y (ex )y exy

a i a
para x, y, z arbitrarias y a entera 1.
combine(expr , Psi) Simplica expr con respecto a sumas de funciones n utilizando:
n (z + 1) n (z) + (1)n n!z n1
dn
n (1 z) (1)n ( n (z) + cot z)
dz n
para n entera positiva.
combine(expr ) Combina sumas de terminos en expr que involucren los operadores inertes Int,
Sum y Limit:
c1 lim f (x) + c2 lim g(x) lim c1 f (x) + c2 g(x)

xa xa xa
b b b
c1 f (x)dx + c2 g(x)dx c1 f (x) + c2 g(x)dx
a a a
b
b
b

c1 f (i) + c2 g(i) c1 f (i) + c2 g(i)
i=a i=a i=a
para la variable arbitraria x, c1 y c2 son expresiones arbitrarias independientes

de x, y f (x), g(x) ason funciones arbitrarias que dependen de x.

> expan(expr2);

( a+b ) ( ( n + 1 )! )2
expan cos( a + b ) e +
( n! )2
3.1.1 Uniendo terminos de expresiones: combine

> e1 := 2*cos(x/2)^2-1;
2
1
e1 := 2 cos x 1
2
> combine(e1, trig);

cos( x )
> e2 := cos(x)^2 + 2*sin(x)^2 + tan(x)^2;

e2 := cos( x )2 + 2 sin( x )2 + tan( x )2
> combine(e2, trig);

1 3
cos( 2 x ) + + tan( x )2
2 2
> e3 := (exp(x))^2*exp(y) + 2*ln(x)-ln(y) + (xâ)^2;

e3 := ( ex )2 ey + 2 ln( x ) ln( y ) + ( xa )2
> combine(e3, exp);

e( 2 x+y ) + 2 ln( x ) ln( y ) + ( xa )2
> combine(e3, ln);

x 2 y a 2 x2
( e ) e + ( x ) + ln
y
> combine(e3, power);

e( 2 x+y ) + 2 ln( x ) ln( y ) + x( 2 a )
> combine([e1,e3],{exp,ln,trig});
2
( 2 x+y ) a 2 x
cos( x ), e + ( x ) + ln
y
3.1.2 Simplicacion de funciones racionales: normal

> (2*x+4*y)*(x^2-y^2)/(x+y)^2;
( 2 x + 4 y ) ( x2 y 2 )
( x + y )2
> normal(");
(x + 2y)(x y)
2
x+y

> normal( (x^2-y^2) - (x+y)*(x-y) );

0
> 2*x/(x+y)^3 + x/(x+y)^2 + y/(x+y) + y/(x+y)^0;

x x y
2 + + +y
( x + y )3 ( x + y )2 x+y
> normal(");
2 x + x2 + x y + y x2 + 2 x y 2 + y 3 + y x3 + 3 y 2 x2 + 3 x y 3 + y 4
( x + y )3
3.1.3 Organizacion de una expresion con respecto a una variable: collect

> expr := r^2*x^2 - 2*x^2*r + x^2+8*z*y*r^2 - 2*z*y*r*s - 6*z*y*s^2 + t^2*z^2 +
> 3*r^2*s*y*t*x - r*x*s*y + s^2*y^2 + r*s*y^2 + r^3*z*x - r*z*x*t^2;
expr := r2 x2 2 x2 r + x2 + 8 z y r2 2 z y r s 6 z y s2 + t2 z 2 + 3 r2 s y t x r x s y + s2 y 2
+ r s y 2 + r 3 z x r z x t2
> collect(expr, [x,y,z]);

( 2 r + 1 + r2 ) x2 + ( ( r s + 3 r2 s t ) y + ( r t2 + r3 ) z ) x + ( s2 + r s ) y 2
+ ( 2 r s 6 s2 + 8 r2 ) z y + t2 z 2
> collect(expr, [x,y,z], distributed);

t2 z 2 + ( 2 r s 6 s2 + 8 r2 ) z y + ( s2 + r s ) y 2 + ( r t2 + r3 ) x z + ( r s + 3 r2 s t ) x y
+ ( 2 r + 1 + r2 ) x2
> collect(expr,[x,y,z], distributed, factor);

t2 z 2 + 2 ( 4 r + 3 s ) ( r s ) y z + s ( s + r ) y 2 + r ( r t ) ( r + t ) x z + r s ( 1 + 3 r t ) x y
+ ( r 1 )2 x2
3.1.4 Ordenacion de terminos con sort

> a := y+z+x;
a := x + y + z
> b := x^3 + y + sin(x+y+z) +

> factor(x^2 + 2*x*y + 2*x*z + y^2 + 2*y*x + z^2) + z;
b := x3 + y + sin( x + y + z ) + x2 + 4 x y + 2 x z + y 2 + z 2 + z
> c := expand((x^2+x+1)^5);
c := 5 x + 1 + 30 x3 + 30 x7 + 15 x8 + x10 + 5 x9 + 51 x5 + 45 x6 + 45 x4 + 15 x2

> sort(c);
x10 + 5 x9 + 15 x8 + 30 x7 + 45 x6 + 51 x5 + 45 x4 + 30 x3 + 15 x2 + 5 x + 1
> sort([z,u,w,s,u,v,w,y,t]);
[ s, t, u, u, v, w, w, y, z ]
> sort(t*s*u);
sut
> sort(t+s+u);
s+u+t
> sin(t+s+u);
sin( s + u + t )
> e := 1+x^4*y*z+y^5*z^2*x+x*y^2*z^3;
e := 1 + x4 y z + y 5 z 2 x + x y 2 z 3
> sort(e, [x,y,z], plex);

x4 y z + x y 5 z 2 + x y 2 z 3 + 1
> sort(e, [x,y,z], tdeg);

x y 5 z 2 + x4 y z + x y 2 z 3 + 1
> expand(cos(x+y)-sin(x+y)^2);
cos( x ) cos( y ) sin( x ) sin( y ) sin( x )2 cos( y )2 2 sin( x ) cos( y ) cos( x ) sin( y )
cos( x )2 sin( y )2
> sort(", [cos(x),sin(x),cos(y),sin(y)], tdeg);

cos( x )2 sin( y )2 2 cos( x ) sin( x ) cos( y ) sin( y ) sin( x )2 cos( y )2 + cos( x ) cos( y )
sin( x ) sin( y )
> sort(", [cos(x),sin(x),cos(y),sin(y)], plex);

cos( x )2 sin( y )2 2 cos( x ) sin( x ) cos( y ) sin( y ) + cos( x ) cos( y ) sin( x )2 cos( y )2
sin( x ) sin( y )
3.1.5 Conversion entre formas funcionales: convert

> expr := cos(a)^2*cos(b)^2 - 2*cos(a)*cos(b)*sin(a)*sin(b) + sin(a)^2*sin(b)^2;
expr := cos( a )2 cos( b )2 2 cos( a ) cos( b ) sin( a ) sin( b ) + sin( a )2 sin( b )2

Tabla 3.3: Variedades de transformaciones disponibles con convert
exp Convierte todas las funciones trigonometricas en formas equivalentes que

involucran exponenciales.
ln Convierte funciones trigonometricas inversas a formas que solamente in-
volucran logaritmos.
expln Combinacion de las opciones exp y ln.
expsincos Convierte todas las funciones trigonometricas a formas que involucren
siny cos y todas las funciones trigonometricas hiperbolicas a formas
que involucran exp.
sincos Convierte funciones trigonometricas a formas que solamente involucran
sin, cos, sinh y cosh.
tan Convierte todas las funciones trigonometricas a formas que solamente
involucran tan.
trig Convierte todas las exponenciales a formas que involucran sin, cos,
sinh y cosh va igualdades de Euler.
factorial Convierte coecientes GAMMA, binomial y multinomial a factoriales.
GAMMA Convierte expresiones factoriales, binomiales y multinomiales para utilizar
la funcion .
hypergeom Convierte expresiones que involucran sum o Sum a expresiones que invo-
lucran funciones hipergeometricas.
> simplify(expr);
2 cos( a )2 cos( b )2 2 cos( a ) cos( b ) sin( a ) sin( b ) + 1 cos( b )2 cos( a )2
Simplicacion a traves de una ruta inderecta

> combine(expr, trig);
1 1
cos( 2 a + 2 b ) +
2 2
> convert(", tan);

1 1 tan( a + b )2 1
+
2 1 + tan( a + b )2 2
> simplify(");
cos( a + b )2
Uso del comando alias para utilizar una forma abreviada de la funcion binomial
> alias( C = binomial );
I, C
> hyperg := (R,B,D,r) -> C(R,r) * C(B,D-r) / C(R+B,D);

C( R, r ) C( B, D r )
hyperg := ( R, B, D, r )
C( R + B, D )

> hyperg1 := (R,B,D,r) -> C(D,r)*C(R+B-D,R-r) / C(R+B,R);

C( D, r ) C( R + B D, R r )
hyperg1 := ( R, B, D, r )
C( R + B, R )
> DebeSerCero := (R,B,D,r) -> (hyperg(R,B,D,r) - hyperg1(R,B,D,r));

DebeSerCero := ( R, B, D, r ) hyperg( R, B, D, r ) hyperg1( R, B, D, r )
> DebeSerCero(10, 10, 5, 1);

0
> DebeSerCero(25, 16, 6, 2);

0
> simplify( DebeSerCero(R,B,D,r) );

( C( R, r ) C( B, D r ) C( R + B, R ) C( D, r ) C( R + B D, R r ) C( R + B, D ) ) (
C( R + B, D ) C( R + B, R ) )
> convert(", factorial);

0
Otro ejemplo: simplicacion de una recurrencia va rsolve

> rsolve( {T(n) = T(n/2) + n^3, T(1)=0},
n ) T(n) );
1 ln( +1 8
8 ln( 2 )
7 7
> simplify(");

1 ln( nln()+ln( 2) 8
8 2)

7 7
> convert(", exp);

( ln( n )+ln( 2 ) ) ln( 8 )
1 8
e ln( 2 )

7 7
> simplify(");
8 3 8
n
7 7
3.2 Factorizacion de expresiones polinomiales

> p := x^3 + 3*x^2 + 3*x + 1;
p := x3 + 3 x2 + 3 x + 1
> diff(p, x);

3 x2 + 6 x + 3

> factor(");
3 ( x + 1 )2
Compare ahora la forma factorizada de la derivada con la derivada del factorizado original
> factor(p);
( x + 1 )3
> diff(", x);

3 ( x + 1 )2
La factorizacion sobre los numeros racionales signica que solamente numeros racionales, no complejos,
aparecen en los factores. El polinomio q es irreducible sobre los numeros racionales.
> q := x^2 + 9/4;
9
q := x2 +
4
> factor(q);
9
x2 +
4
> x^4*sin(y)^4 + x^4*sin(y)^3 + x^2 * sin(y) + x^2;

x4 sin( y )4 + x4 sin( y )3 + x2 sin( y ) + x2
> factor(");
x2 ( sin( y ) + 1 ) x2 sin( y )3 + 1
> factor(q, I);

1
(2x + 3I )(2x 3I )
4

Factores cuyos coecientes son racionales multiplos de 2.
> alias( alpha = RootOf(z^2 +2) );
I, C,
> factor(x^2+1/8, alpha);

1
(4x + )(4x )
16
3.3 Obtencion de partes de expresiones

> s := x+2*y+sin(3*z^2);
s := x + 2 y + sin( 3 z 2 )

> whattype(s);
+
> whattype(t);
string
> type(1/2, integer);

false
> type(5, constant);

true
> type(x, name);

true
Numero de operandos en una expresion
> nops(s);
3
op(i,expr) da como resultado el i-esimo operando de expr.
> op(1, s);
x
> nops(op(3,s));
1
El operando 0 de una funcion es el nombre de la misma
> op(0, op(3, s));
sin
> op(1, op(3, s));

3 z2
> op(2, op(3, s));

Error, improper op or subscript selector
Los cocientes se representan como productos. Los productos siempre tienen la constante racional como
primer operando (excepto cuando la constante es 1)
> q := x/(6*y);
1 x
q :=
6 y
> type(q,*);
true
> op(1,q);
1
6

> op(2,q);
x
> r := op(3,q);
1
r :=
y
> type(r,^);
true
> op(1,r);
y
> op(2,r);
1
> producto sin constante racional := x*y;

producto sin constante racional := x y
> op(1,producto sin constante racional);

x
> op(2,producto sin constante racional);

y
3.4 Secuencias, conjuntos y listas
3.4.1 Secuencias
seq(f(i), i=a..b) Construye una secuencia variando sobre un rango

entero
seq(f(x), x=expr) Construye una secuencia variando sobre partes de
una expresion
> seq(12-i, i=0..12);
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
> seq1 := sin(x), x=0;

seq1 := sin( x ), x = 0
> seq1 := seq1, 5;

seq1 := sin( x ), x = 0, 5
> t := taylor(seq1);
1 3
t := x x + O( x5 )
6

> seq(op(i,t), i = 0..nops(t));

1
x, 1, 1, , 3, O( 1 ), 5
6
> seq(op(2*i,t), i = 0..2);

x, 1, 3
> op( x + y + z);

x, y, z
> op(1..4, t);

1
1, 1, ,3
6
3.4.2 Conjuntos y listas
Maple maneja el concepto de conjuntos tal y como lo conocemos, es decir, solo desplegara una instancia
de cada elemento aun cuando el conjunto tenga mas de una.
> set1 := {a, b};
set1 := { a, b }
> set2 := {a, d, e};

set2 := { a, e, d }
> set3 := {b, e};

set3 := { b, e }
> u := set1 union set2;

u := { a, b, e, d }
> i := set2 intersect set3;

i := { e }
> d := set1 minus set3;

d := { a }
Las listas en Maple se declaran con corchetes ([. . . ]) y para accesar alguno de los elementos de la
lista, solo se tiene que indicar la posicion que ocupan en la lista. La numeracion de las posiciones en
una lista siempre comienza en 1.
> list1 := [1, 2, 3];
list1 := [ 1, 2, 3 ]
> list2 := [4, 5, 6];

list2 := [ 4, 5, 6 ]

> list3 := [op(list1), op(list2)];

list3 := [ 1, 2, 3, 4, 5, 6 ]
> n := nops(list3);
n := 6
> list4 := [seq( op(n-i, list3), i=0..(n-1)) ];

list4 := [ 6, 5, 4, 3, 2, 1 ]
> list5 :=[seq( list3[n-i+1], i=1..n )];

list5 := [ 6, 5, 4, 3, 2, 1 ]
> set6 := {list5[1..4]} intersect {op(list1)};

set6 := { 3 }
El comando subsop se utiliza para cambiar el valor de un elemento de una lista
> list6 := subsop(5=47, list5);
list6 := [ 6, 5, 4, 3, 47, 1 ]
> list6[5] := 48;

Error, cannot assign to a list
> print(list6);
[ 6, 5, 4, 3, 47, 1 ]
3.5 Tablas y arreglos
3.5.1 Tablas
> LongitudDeOnda := table([rojo=610, azul=480, violeta=450, verde=520, negro=0]);
LongitudDeOnda := table([
rojo = 610
azul = 480
violeta = 450
verde = 520
negro = 0
])
> LongitudDeOnda[rojo];
610
> LongitudDeOnda[naranja] := 600;

LongitudDeOnda naranja := 600
> LongitudDeOnda[rojo] := 640;

LongitudDeOnda rojo := 640

> LongitudDeOnda[negro] := LongitudDeOnda[negro];

LongitudDeOnda negro := LongitudDeOnda negro
> LongitudDeOnda;
LongitudDeOnda
> print(LongitudDeOnda);
table([
rojo = 640
azul = 480
violeta = 450
verde = 520
naranja = 600
])
> indices(LongitudDeOnda);
[ rojo ], [ azul ], [ violeta ], [ verde ], [ naranja ]
> entries(LongitudDeOnda);
[ 640 ], [ 480 ], [ 450 ], [ 520 ], [ 600 ]
> Memo[Lunes] := Cumplea~nos de Pooh:

> Memo[1,2] := Abrocharse un zapato:
> Memo[e=mc^2] := Formula de Einstein:
> Memo[G]:= [constante gravitacional, 9.8, 32]:
> print(Memo);
table([
Lunes = Cumpleanos de Pooh
( 1, 2 ) = Abrocharse un zapato
( e = mc 2 ) = F ormula de Einstein
G = [ constante gravitacional , 9.8, 32 ]
])
> LongitudDeOnda := table([rojo=610,azul=480,violeta=450,verde=520,negro=0]);

LongitudDeOnda := table([
rojo = 610
azul = 480
violeta = 450
verde = 520
negro = 0
])
> W12 := LongitudDeOnda: W13:=W12:

> W12;
LongitudDeOnda
> W13;
LongitudDeOnda

Se utiliza eval para obtener la tabla

> eval(W13);
table([
rojo = 610
azul = 480
violeta = 450
verde = 520
negro = 0
])
print(nombredetabla) desplegara la tabla, aunque el resultado de la funcion print es NULL, y no la

tabla en si.
> print(W13);
table([
rojo = 610
azul = 480
violeta = 450
verde = 520
negro = 0
])
Copias de tablas
> Fibonnaci_table[1] := 1: Fibonnaci_table[2] := 1:
> b := eval(Fibonnaci_table):
> c := copy(Fibonnaci_table):
> b[6] := 8;
b6 := 8
> Fibonnaci_table[6];
8
> c[6];
9
3.5.2 Arreglos
A diferencia de las listas, la numeracion de las posiciones de un arreglo las dene el usuario y no esta
restringida a que siempre comience en 1. De tal forma que se puede tener un arreglo cuya numeracion
de sus posiciones comience en -1 (como se ve en un ejemplo posteriormente) y termina en 3. El numero
total de elementos de ese arreglo sera de 5 (-1, 0, 1, 2, 3).
> a := array(1..2, 1..2);
a := array( 1..2, 1..2, [ ] )

> a[1,1]:=1: a[1,2]:=2: a[2,2]:=4:

> a;
a
> print(a);

1 2

a2,1 4
> i := i;
i := i
> b := a[i+1,i];
b := ai+1,i
> c := 2*b;
c := 2 ai+1,i
> i := 1;
i := 1
> b;
a2,1
> b := array( -1..3, [-1=t]);

b := array( 1..3, [
( 1 ) = t
( 0 ) = b0
( 1 ) = b1
( 2 ) = b2
( 3 ) = b3
])
> b[-1] + b[1];

t + b1
3.5.3 Esquemas especiales de ordenamiento para arreglos y tablas

> List := [x,y,x,z,x,z,a,z,x,x,y,b,a,z];
List := [ x, y, x, z, x, z, a, z, x, x, y, b, a, z ]
> F := table(sparse);
F := table(sparse, [
])

Tabla 3.4: Funciones predenidas para arreglos y tablas

sparse Se asume que los elementos son cero a menos que se indique lo contrario
symmetric Todos los elementos cuyos ndices son iguales en permutaciones son los
mismos elementos.
antisymmetric Todos los elementos cuyos ndices son permutaciones pares de cada uno,
son los mismos. Todos los elementos cuyos ndices son permutaciones
impares de cada uno, son recprocos aditivos. Elementos con ndices
iguales, son iguales a cero.
identity Todos los elementos sobre la diagonal se asume que su valor es uno.
Todos los demas elementos, son iguales a cero.
> for i in List do F[i] := F[i] + 1 od:

> F[a],F[c],F[x];
2, 0, 5
> indices(F);
[ b ], [ a ], [ x ], [ y ], [ z ]
> entries(F);
[ 1 ], [ 2 ], [ 5 ], [ 2 ], [ 4 ]
3.6 Conversion de una estructura a otra

> testscores := [99,88,76,37,92,96,88,92];
testscores := [ 99, 88, 76, 37, 92, 96, 88, 92 ]
> convert(testscores, +);

668
> "/nops(testscores);
167
2
> evalf(");
83.50000000
> nops( convert(testscores, set) );

6
> a := convert([x,y,z], array);

a := [ x y z ]

> alist := convert(a, list);

alist := [ x, y, z ]
> A := array(1..3,1..3, identity);

A := array( identity, 1..3, 1..3, [ ] )
> Alist := convert(A, listlist);

Alist := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]
3.7 Mapeo de funciones

> L := [ 3/5, Pi/2, ln(3)];
3 1
L := , , ln( 3 )
5 2
> map(sin, L);

3
sin , 1, sin( ln( 3 ) )
5
> s := {3*Pi/4, Pi, 11*Pi/4};

3 11
s := , ,
4 4
> s2 := map(sin, s);

1
s2 := 0, 2
2
> expr := 1 + ln(3) + exp(4);

expr := 1 + ln( 3 ) + e4
> map(sin, expr);

sin( 1 ) + sin( ln( 3 ) ) + sin( e4 )
> evalf(L);
[ .6000000000, 1.570796327, 1.098612289 ]
> evalf(s2);
{ 0, .7071067810 }
Maple un poco mas avanzado

> f := x -> x^2;
f := x x2

> g := proc(x) RETURN(x,x^2) end;

g := proc(x) RETURN(x,x^2) end
> L2 := [1,2,3,4];
L2 := [ 1, 2, 3, 4 ]
> s2 := {op(L2)};
s2 := { 1, 2, 3, 4 }
> A2 := convert(L2, array);

A2 := [ 1 2 3 4 ]
> L3 := map(f, L2);

L3 := [ 1, 4, 9, 16 ]
> map(g, L2);

[ 1, 1, 2, 4, 3, 9, 4, 16 ]
> map(g, s2);

{ 1, 2, 3, 4, 9, 16 }
> map(f, A2);

[ 1 4 9 16 ]
zip aplica una funcion a pares de componentes

> zip( (x,y) -> sqrt(x*y), L2, L3 );

1, 2 2, 3 3, 8
> map( int, [exp(t), ln(t), tan(t)], t );

[ et , t ln( t ) t, ln( cos( t ) ) ]
> map(solve, {x^2-1=0, 5*x=4}, x);

4
1, 1,
5
3.8 Algebra lineal con Maple
3.8.1 Uso de evalm para operaciones simples con matrices y vectores
Maple asume que un vector es un arreglo de la forma array(1..n) y una matriz es un arreglo de la
forma array(1..m,1..n), para valores positivos enteros de m y n.
Para realizar operaciones aritmeticas vectoriales o matriciales con Maple, el comando evalm permite
hacerlo de una manera muy sencilla.

Se denen los valores de una matriz A

> A := array([ [1,2,3], [x,x,5], [1/2,4,-1]]);

1 2 3

A := x x 5

1
4 1
2
y ahora calculamos su inversa (mathbf A1 )
> Ainv := evalm(A^(-1));
x + 20 1 10 + 3 x
2 28 2
23 x 30 23 x 30 23 x 30

2x + 5 1 5 + 3 x
Ainv :=
5 2

23 x 30 23 x 30 23 x 30

x 1 x
7 6 2
23 x 30 23 x 30 23 x 30
y vericamos que la inversa este correcta
> evalm( A &* Ainv );
1 0 0

0 1 0

0 0 1
Ahora, denimos a v como un vector que solamente tiene denidos los primeros dos elementos
> v := array(1..3): v[1] := 23: v[2]:=-y:
> print(v);
[23 y v3 ]
Si desearamos realizar el producto punto
> A &* v;
A & v
la expresion anterior tpica de Maple no nos servira. Es necesario que utilicemos evalm
> evalm(A &* v);
23
23 2 y + 3 v3 23 x x y + 5 v3 4 y v3
2
El uso de evalm para producto punto entre dos vectores no funciona.

> evalm(v &* v);
Error, (in linalg[multiply]) vector dimensions incompatible
Los vectores (arreglos unidimensionales) se manejan de la misma forma que matrices con una sola
columna (con el mismo numero de las). La multiplicacion escalar es la misma.
> w := array(1..3,1..1, [[v[1]], [v[2]], [v[3]]]);

23

w := y

v3

> evalm( v - 2*w);

23

y

v3
> evalm(A &* w - A &* v);

0

0

0
> evalm( w &* v);

Error, (in linalg[multiply]) matrix/vector dimensions incompatible
Para exponenciacion de matrices, se utiliza ^.

> A_result := evalm( 2 * A^2 );
5 + 4x 28 + 4 x 20

A result := 2 x + 2 x2 + 5 4 x + 2 x2 + 40 16 x 10

8x 6 + 8 x 45
3.8.2 El paquete de algebra lineal linalg
La biblioteca de Maple contiene varios paquetes, cada uno es una conjunto de funciones relacionadas.
En esta seccion se presenta al paquete linalg. Este paquete es un conjunto de funciones que trabajan
con arreglos que representan vectores y matrices. El comando with(linalg) dene nombres mas
cortos que pueden ser utilizados para ejecutar estas rutinas. Por ejemplo, despues de haber ejecutado
el comando with(linalg), podemos ejecutar jacobian en lugar de linalg[jacobian].
La tabla 3.5 muestra las funciones contenidas en este paquete.
Tabla 3.5: Funciones denidas en el paquete linalg.
BlockDiagonal GramSchmidt JordanBlock Wronskian add

addcol addrow adj adjoint angle
augment backsub band basis bezout
blockmatrix charmat charpoly col coldim
colspace colspan companion concat cond
copyinto crossprod curl denite delcols
delrows det diag diverge dotprod
eigenvals eigenvects entermatrix equal exponential
extend gausselim bonacci frobenius gausselim
gaussjord genmatrix grad hadamard hermite
hessian hilbert htranspose ihermite indexfunc
innerprod intbasis inverse ismith iszero
continua en la siguiente pagina

jacobian jordan kernel laplacian leastsqrs

linsolve matrix minor minpoly mulcol
mulrow multiply norm normalize nullspace
orthog permanent pivot potential randmatrix
randvector rank ratform row rowdim
rowspace rowspan rref scalarmul singularvals
smith stack submatrix subvector sumbasis
swapcol swaprow sylvester toeplitz trace
transpose vandermonde vecpotent vectdim vector
> with(linalg):
Denimos una matriz de 33
> A := array( [[1,2,3], [3,-1,6], [4,8,12]] );

1 2 3

A := 3 1 6

4 8 12
y ahora, denimos a u como un vector de 3 elementos
> u := array( [ -1, 3-s, -4 ] );
u := [ 1 3 s 4 ]
Con el vector y matriz anteriormente denidos, podemos resolver el sistema Ax = u. Si existe mas de
una solucion, linsolve utiliza los parametros t1 , t2 , t3 , etc. para describir parametricamente las
soluciones.
> linsolve(A,u);
7 1
5 t1 + 5 s t1 t1 2 + s
3 3
Podemos calcular el determinante
> det(A);
0
o el polinomio caracterstico
> cpoly := charpoly(A,lambda);
cpoly := 3 12 2 67
Podemos vericar el teorema de CayleyHamilton mediante la evaluacion del polinomio caracterstico
en lambda=A y vericar que produce una matriz de ceros.
> subs(lambda=A, cpoly);
A3 12 A2 67 A
> evalm(");
0 0 0

0 0 0

0 0 0
Tambien podemos calcular los valores caractersticos
> eigenvals(A);

0, 6 + 103, 6 103
y mediante la factorizacion del polinomio caracterstico, podemos vericar que son los mismos valores

que se obtuvieron con eigenvals.

> factor(cpoly);

2 12 67
> a := matrix([[0, x], [-x, 0]]);

0 x
a :=
x 0
La exponencial de una matriz esta denida como ea y no es lo mismo que mapear la funcion exp a los
elementos de a.
> exponential(a);

cos( x ) sin( x )

sin( x ) cos( x )
3.8.3 Diferenciacion de matrices y vectores

> with(linalg):
> f := 4*x*z - 5*y*x^3;
f := 4 x z 5 y x3
> gradf := grad(f, [x,y,z]);

gradf := [ 4 z 15 y x2 5 x3 4 x ]
> v := vector(3, [ 4*x-3*x^3*y, 7*x*y*z^2+5*y^3, 4*x^2*y^2+2*x ]);

v := [ 4 x 3 y x3 7 x y z 2 + 5 y 3 4 x2 y 2 + 2 x ]
> curlv := curl(v, [x,y,z]);

curlv := [ 8 y x2 14 x y z 8 x y 2 2 7 y z 2 + 3 x3 ]
> jacobian(v, [x,y,z]);

4 9 y x2 3 x3 0

7 y z2 7 x z 2 + 15 y 2 14 x y z

8 x y2 + 2 8 y x2 0
> lapf := laplacian(f, [x,y,z]);

lapf := 30 y x
> evalb(lapf = diverge(gradf, [x,y,z]));

true
> vectlapv:= map(laplacian, v, [x,y,z]);

vectlapv := [ 18 y x 30 y + 14 y x 8 y 2 + 8 x2 ]

> graddivv := grad(divv, [x,y,z]);

graddivv := [ 0 0 0 ]
> curlcurlv := curl(curlv, [x,y,z]);

curlcurlv := [ 7 z 2 14 y x 9 x2 8 y 2 8 x2 + 14 x z ]
> evalm(vectlapv - (graddivv-curlcurlv));

[ 18 y x + 7 z 2 30 y 9 x2 14 x z ]
3.8.4 Operaciones estructurales en matrices y vectores

> with(linalg):
> A := matrix( 3,3, [19,-50,88, 53,85,-49,78,17,72]
);
19 50 88

A := 53 85 49

78 17 72
> B := addrow( A, 1, 2, -A[2,1]/A[1,1] );

19 50 88
4265 5595

B := 0
19 19

78 17 72
> C := swaprow( B, 3, 2 );

19 50 88

C := 78 17 72

4265 5595
0
19 19
> D1 := mulrow( C, 3, 19 );
19 50 88

D1 := 78 17 72

0 4265 5595
> submatrix( A, 2..3, 1..3 );

53 85 49

78 17 72
> stack( B, row(C,1) );


19 50 88
4265 5595

0
19 19

78 17 72

19 50 88
> b1 := vector( 3, [3,5,-2] ):

> b2 := vector( 3, [4,-5,9] ):
> b3 := vector( 3, [21,4,7] ):
> augment( A, b1, b2, b3 );

19 50 88 3 4 21

53 85 49 5 5 4

78 17 72 2 9 7
> gaussjord(");
56399 42938 43729
1 0 0
9855 9855 3285

20528 15761 15913
0 1 0
3285 3285 1095

46832 36584 35782
0 0 1
9855 9855 3285
3.8.5 Llamado de funciones especcas de paquetes sin utilizar with

> I := array(1..3,1..3, identity);
Error, Illegal use of an object as a name
> Id := array(1..3,1..3, identity);

Id := array( identity, 1..3, 1..3, [ ] )
> linalg[add](Id,Id);

2 0 0

0 2 0

0 0 2
> with(linalg,randmatrix);
[ randmatrix ]
> R := randmatrix(2,2);
85 55
R :=
37 35

> rref(R);
1 0

0 1
> linalg[rref](R);

1 0

0 1
3.9 Como guardar el estado de una sesion de Maple

> a := 47;
a := 47
> b := x^4;
b := x4
Guardar todos los valores (variables y deniciones) en el archivo ArchTodo.m

> save /home/soporte/hma/Cursos/Maple/ArchTodo.m;
Guardar el valor de a en el archivo ArchAlgo.m
> save a,/home/soporte/hma/Cursos/Maple/ArchAlgo.m;
> quit;
> read /home/soporte/hma/Cursos/Maple/ArchTodo.m;
> a*b;
47 x4
> read /home/soporte/hma/Cursos/Maple/ArchAlgo.m;

> a*b;
47 x4
> quit;
3.10 Acceso a bibliotecas de procedimientos adicionales

> iroot(103900,3);
iroot( 103900, 3 )
> readlib(iroot):
> iroot(103900,3);
47

3.11 Otras formas de fomateo de resultados

> expr1 := arcsin(x) + 1/3*ln(x)^2 - ln(x)^3:
> fortran([a = expr1, b = expand(expr1^2)]);
a = asin(x)+alog(x)**2/3-alog(x)**3
b = asin(x)**2+2.E0/3.E0*asin(x)*alog(x)**2-2*asin(x)*alog(x)**3+a
#log(x)**4/9-2.E0/3.E0*alog(x)**5+alog(x)**6
> precision := double;
precision := double
> fortran(expr1, optimized);

t2 = dlog(x)
t3 = t2**2
t5 = dasin(x)+t3/3-t3*t2
> readlib(C):
> C(a + expr1, optimized);
t2 = log(x);
t3 = t2*t2;
t5 = a+asin(x)+t3/3-t3*t2;
> a := (4 + (x^2+1)/(sin(x)^2+x^2))/(3/(sqrt(x)+1/(y+1)) + binomial(3,n)):
> latex(a); latex(a,latex.out);
\left(4+{\frac {{x}^{2}+1}{\left(\sin(x)\right )^{2}+{x}^{2}}}\right)
\left({\frac {3}{\sqrt {x}+\left (y+1\right)^{-1}}}+{3\choose n}\right)^{-1}

51
Captulo 4
El lenguaje de programacion de Maple
4.1 Ciclos con while
while condicion do
instrucciones
od;
> a := 20; b := 12; > a := 35;
a := 35
a := 20
b := 12
> b:= 15;
>
b := 15
while b<>0 do
> d := irem(a,b);
> a := b; > while b<>0 do
> b := d; > d := irem(a,b);
> od; > a := b;
d := 8 > b := d;
a := 12 > od;
b := 8 d := 5
d := 4 a := 15
a := 8 b := 5
b := 4 d := 0
d := 0 a := 5
a := 4 b := 0
b := 0
> lprint(
> lprint( > El mayor comun denominador es,a);
> El mayor comun denominador es ,a); El mayor comun denominador es 5
El mayor comun denominador es 4
4.2 Ciclos con for
for var from inicio by incremento to lmite do

instrucciones
od;
> for i from 2 by 2 to 6 do
> lprint(suma de ,jî, j = 1..n es:);

Captulo 4. El lenguaje de programacion de Maple 52
> print( expand(sum(jî,j=1..n)) );

> od;
suma de j^2 j = 1..n es:
1 3 1 2 1
n + n + n
3 2 6
1 5 1 4 1 3 1
n + n + n n
5 2 3 30
1 1 1 1 1
n n3 + n5 + n6 + n7
42 6 2 2 7
> i;
8
Dos formas de utilizar ciclos con listas

> aList := [1,2,3,4,5]: >
> s := 0: > s := 0:
> for i to nops(aList) do > for n in aList do
> if irem(op(i,aList),2)=0 then > if irem(n,2)=0 then
> s := s + op(i,aList)^2 > s := s + n^2
> fi > fi
> od: > od:
> s; > s;
20 20

4.3 Ejecucion condicional con if--then--else--fi
if condicion
then instrucciones cuando la condicion es verdadera
else instrucciones cuando la condicion es falsa
fi;
> isprime(37); true > A := array(1..4, 1..4 ):
>
> isprime(6); false >
for i to 4 do
for j to 4 do
> for i to 8 do > if i > j then A[i,j] := j
> es_primo := 2^(2*i+1)-1; > elif i < j then A[i,j] := i
> if isprime(es_primo) > else A[i,j] := 1
> then print(es_primo, es primo); > fi
> else print(es_primo, no es primo) > od;
> fi; > od:
> od: > print(A);

7, es primo 1 1 1 1
31, es primo

127, es primo 1 1 2 2

511, no es primo 1 2 1 3

2047, no es primo
1 2 3 1
8191, es primo
32767, no es primo
131071, es primo
4.4 break y next: control dentro de ciclos con for--while

> for i from 3 by 2 do
> if isprime(2î-1)
> then print(2î-1, es primo)
> else break
> fi;
> od;
7, es primo
31, es primo
127, es primo
> print(i=i, el primer numero no primo en la secuencia es, 2î-1);

i = 9, el primer numero no primo en la secuencia es, 511

4.5 Denicion de procedimientos sencillos
proc( lista de variables );

instrucciones
end;
> f := proc( x, y ) > f;
> x + y; f
> end;
f := proc(x,y) x+y end > g;
> f(3,5); f
8
> h;
> f(w,z+1); f
w+z+1
> op(f);
> g:= f;
g := f proc(x,y) x+y end
> print(h);
> h:= g;
h := f proc(x,y) x+y end
> h(3,5);
8
4.6 Denicion de procedimientos: estatutos multiples, variables loca-

les, RETURN
> max3 := proc (a, b, c);
> print(Encontrando el maximo de, a, b, c);
> if a<b then
> if b<c then c else b fi
> elif a<c then c
> else a
> fi;
> end:
> max3(3, 2, 1);
Encontrando el maximo de, 3, 2, 1
3
> max3(1, 1, 9);

Encontrando el maximo de, 1, 1, 9
9
local lista de variables locales para un procedimiento;

global lista de variables globales para un procedimiento;
La instruccion local permite la denicion de variales locales para un procedimiento. La instruccion

global (misma sintaxis que local) permite el uso de variables denidas en una sesion de Maple fuera
del procedimiento que se esta deniendo (variables globales).
> maxN := proc ()
> local result, i;
> if not(type([args], list(numeric)) )
> then procname(args);
> elif nargs>0 then
> result := args[1];
> for i from 2 to nargs do
> if args[i] > result then result := args[i]; fi;
> od;
> result;
> fi;
> end:
> maxN(25/7, 525/149);
25
7
> maxN( 25/7, 525/149, 9/2);

9
2
> maxN();
> maxN(25/7,z,525/149);
25 525
maxN , z,
7 149
> result;
result
4.6.1 Uso de RETURN
La instruccion RETURN() da por terminada la ejecucion de un procedimiento y regresa el valor de una

variable o una secuencia, lista, tabla o arreglo. Pueden existir mas de una instruccion RETURN en cada
procedimiento.
> Chebyshev := proc (n)
> local p,k;
> p[0]:=1; p[1]:=x;
> if n<=1 then RETURN( eval(p) ) fi;
> for k from 2 to n do
> p[k] := expand( 2*x*p[k-1] - p[k-2] )
> od;
> RETURN( eval(p) )
> end:
> a := Chebyshev(5):
> seq(a[i], i = 0..5);
1, x, 2 x2 1, 4 x3 3 x, 8 x4 8 x2 + 1, 16 x5 20 x3 + 5 x
> x := 1/4:
> seq(a[i], i = 0..5);
1 7 11 17 61
1, , , , ,
4 8 16 32 64

> x := x;
x := x
> plot({seq(a[i],i=0..5)},x=-1..1);
4.6.2 Procedimientos denidos dentro de otros procedimientos

> f := proc(x)
> local y;
> y := x + 1;
> g := proc(a) a-y end;
> g(x);
> end:
Warning, g is implicitly declared local
> f(5);
5y
> y := 47;
y := 47
> f(5);
42
> h := proc(x)
> local w;
> w := x + 1;
> i(x);
> end:
> i := proc(a) a-w end:
> h(5);
5w
> w := 47;
w := 47
> h(5);
42
4.7 Comandos para depuracion de procedimientos
4.7.1 Uso de ERROR salida de varios procedimientos instantaneamente

> maxN := proc ()
> local result, i;
> if nargs=0 then ERROR(no arguments ) fi;
> if not(type([args],list(numeric)))
> then RETURN(procname(args));
> fi;
> result := args[1];

> for i from 2 to nargs do

> if args[i] > result then result := args[i] fi;
> od;
> result;
> end:
> maxN( 25/7, 525/149, 9/2);
9
2
> maxN( 25/7, z+1, 9/2);

25 9
maxN , z + 1,
7 2
> maxN();
Error, (in maxN) no arguments
4.7.2 Uso de lasterror y traperror

> (1/3) mod 12;
Error, the modular inverse does not exist
> lasterror;
the modular inverse does not exist
> u := traperror((1/4) mod 12);

u := the modular inverse does not exist
> v := traperror((1/5) mod 12);

v := 5
Atrapando un error esperado

> f := u -> (u^2-1)/(u-1);
u2 1
f := u
u1
> printlevel := 3:
> for x in [0, 1, 2] do
> r := traperror( f(x) );
> if r = lasterror then
> if r = division by zero then
> r := limit(f(u), u=x)
> else
> ERROR(lasterror)
> fi
> fi;
> lprint(Resultado: x =, x, f(x) =, r)
> od;
r := 1
Resultado: x = 0 f(x) = 1
r := division by zero

r := 2
r := 3
Utilizando ERROR/trapeerror para regresar de procedimientos no locales

> List := [7,13,-8,2,-4,-9,5];
List := [ 7, 13, 8, 2, 4, 9, 5 ]
> err_neg := proc(x) if x<0 then ERROR(x) else x fi end :

> primer_neg := proc(a) local r;
> r := traperror(map(err_neg,a));
> if r=lasterror then r else 0 fi
> end:
> primer_neg(List);
8
4.8 Tipos anidados y tipos estructurados

> type( i=2..9, name=integer..integer );
true
> type( {f(1)=2,g(1)=3}, set(anyfunc(numeric)=numeric) );

true
> 1-(Pi+f(2))^2;
1 ( + f( 2 ) )2
> type(", constant);

true
> p:=-x^2*y^6-4*x^2*z^4-2*x^2*y*z^4+3*x^5*y^2*z^2;
p := x2 y 6 4 x2 z 4 2 x2 y z 4 + 3 x5 y 2 z 2
> type(p, polynom(integer,[x,y,z]));

true
4.9 Recordando valores de funciones

> f := x -> sin(x)/x;
sin( x )
f := x
x

> f(0) := 1;
f( 0 ) := 1
> f(infinity) := 0;
f( ) := 0
> [f(0), f(1), f(Pi/2), f(Pi), f(infinity)];

1
1, sin( 1 ), 2 , 0, 0

4.9.1 Funciones con la opcion remember

> Chebyshev := proc(v,n)
> local cpoly;
> cpoly := Chebyshev2(XX_,n);
> RETURN(subs(XX_=v,cpoly));
> end:
> Chebyshev2 := proc(x,n)
> option remember;
> if n=0 then RETURN(1)
> elif n=1 then RETURN(x)
> else RETURN(normal(2*x*Chebyshev2(x,n-1)-Chebyshev2(x,n-2)))
> fi;
> end:
> trace(Chebyshev2);
> printlevel:=10:
> Chebyshev(y,3);
{--> enter Chebyshev, args = y, 3
{--> enter Chebyshev2, args = XX_, 3
<-- exit Chebyshev2 (now in Chebyshev2) = 2*XX_^2-1}
<-- exit Chebyshev2 (now in Chebyshev) = 4*XX_^3-3*XX_}
3
cpoly := 4 XX 3 XX
<-- exit Chebyshev (now at top level) = 4*y^3-3*y}

4 y3 3 y
> Chebyshev(x,5);
{--> enter Chebyshev, args = x, 5
<-- exit Chebyshev2 (now in Chebyshev2) = 8*XX_^4-8*XX_^2+1}
<-- exit Chebyshev2 (now in Chebyshev) = 16*XX_^5-20*XX_^3+5*XX_}
5 3
cpoly := 16 XX 20 XX + 5 XX
<-- exit Chebyshev (now at top level) = 16*x^5-20*x^3+5*x}

16 x5 20 x3 + 5 x

> L := proc(n,x)
> option remember;
> if n<2 then x^n
> else normal( (2*n-1)/n*x * L(n-1,x) - (n-1)/n*L(n-2,x) );
> fi;
> end:
> L(4, t);
35 4 15 2 3
t t +
8 4 8
> L(5, 4.33);

11284.20508
> Digits := 15;

Digits := 15
> L(5, 4.33);

11284.20508
> Digits := 10:

Puede modicarse el procedimiento anterior para que recuerde valores solamente cuando x es simbolico
> L := proc(n,x)
> local result;
> if n<2 then
> result := x^n;
> else
> result := normal( (2*n-1)/n*x*L(n-1,x) - (n-1)/n*L(n-2,x) );
> fi;
> if not type(x,numeric) then
> L(n,x) := result;
> fi;
> RETURN(result);
> end:
> L(4, y);
35 4 15 2 3
y y +
8 4 8
> L(5, 4.33);

11284.20508
> Digits := 15;

Digits := 15
> L(5, 4.33);

11284.2050659470
4.10 Operadores funcionales

> D(sin);
cos

> f := x ->x^2;
f := x x2
> df := D(f);
df := x 2 x
> df(3);
6
> (D@@2)(g);
D( 2 ) ( g )
> d2gAt1 := "(1);

d2gAt1 := D( 2 ) ( g )( 1 )
> g := log@tan + f;
g := log@tan + f
> d2gAt1;
2
D( 2 ) ( log )( tan( 1 ) ) 1 + tan( 1 )2 + 2 D( log )( tan( 1 ) ) 1 + tan( 1 )2 tan( 1 ) + 2
4.10.1 Denicion de un operador funcional
Dencion del operador de diferencias utilizando el metodo de forma funcional para crear una nueva
funcion.
> Shift := proc(f)
> local x;
> option operator;
> unapply( simplify(f(x+1) - f(x)), x);
> end:
> SSin := Shift( sin );
SSin := x sin( x + 1 ) sin( x )
> SSin(Pi);
sin( 1 )
> SSin(1.0);
.0678264420
> SSin(x^2);
sin( x2 + 1 ) sin( x2 )
> Shift( (x) -> x^2);

x 2x + 1

> Shift(");
2
> "(3.5);
2
4.11 Paquetes en Maple
El acceso a las funciones y/o comandos de un paquete en Maple, se puede tener mediante el comando
with(paquete). Adicionalmente, se puede crear un archivo .m y utilizar el comando read para utilizarlo
en una sesion de Maple.
> read quaternion.m;
> ?quaternion
> a := quat(2,3,1,5): b := quat(9,4,7,6):
> quaternion[qmul](a,b);
> quaternion[qadd](a,b);

63
Captulo 5
Gracas avanzadas
5.1 Mas acerca de plot
Mediante la denicion del plotdevice y plotoutput, se puede almacenar cualquier graca que se
genere con los comandos plot y plot3d. El siguiente ejemplo muestra como se puede generar un
archivo Postscript de una serie de puntos, as como la estructura que se genera para dicha graca.
> interface( plotdevice=postscript, plotoutput=display1.ps );
> listadatos := [ [1950,18.6], [1960,19.3], [1970,20.4], [1980,21.6], [1990,25.4] ]:
> PointPlot := plot( listadatos, style=POINT, title=Grafica de puntos):
> lprint( PointPlot );
PLOT(CURVES([[1950., 18.6], [1960., 19.3], [1970., 20.4], [1980., 21.6],
[1990., 25.4]], COLOUR(RGB,0,0,0)),TITLE(Gr\char"E1fica de puntos,
FONT(TIMES,ROMAN,18)),STYLE(POINT),AXESLABELS(,,FONT(TIMES,ROMAN,18)),
AXESTICKS(DEFAULT,DEFAULT,FONT(TIMES,ROMAN,18)),FONT(TIMES,ROMAN,18),
VIEW(DEFAULT,DEFAULT))
Mediante el uso de convert, podemos separar los valores de x y de y de listadatos que estaban
acomodados como una lista de 5 elementos y cada elemento era una lista de 2 elementos (pares de
x, y).
> ldatos:=convert(transpose(convert(listadatos,matrix)),listlist);
ldatos := [ [ 1950, 1960, 1970, 1980, 1990 ], [ 18.6, 19.3, 20.4, 21.6, 25.4 ] ]
Podemos hacer un ajuste polinomial por mnimos cuadrados mediante el paquete stat[fit]
> with(stats,fit):
> fit[leastsquare[[t,y], y=a + b*t + c*t^2, {a,b,c}]](ldatos);
y = 17252.83118 17.65409727 t + .004521089495 t2
> y:=rhs(");
y := 17252.83118 17.65409727 t + .004521089495 t2
Ahora, gracamos la funcion ajustada y posteriormente desplegamos ambas gracas: la de los puntos y
la de la funcion.
> CurvaPlot := plot(y,t=1950..1990):
> with(plots):
> display( [PointPlot, CurvaPlot],
> title=Datos y curva ajustada mediante mnimos cuadrados);

Captulo 5. Gracas avanzadas 64
25
24
23
22
21
20
19
1950 1960 1970 1980 1990
Figura 5.1: Datos y curva ajustada mediante mnimos cuadrados.
5.2 Manejo de la estructura PLOT
El siguiente ejemplo muestra como se puede generar un histograma manipulando la estructura PLOT. El
procedimiento torre genera los rectangulos que denen al histograma. El procedimiento histograma
necesita como entrada una lista de datos y el ttulo que llevara la graca del histograma.
> torre := proc(xnlist)
> local xleft, xright, n;
> n := xnlist[2];
> xleft := xnlist[1]-1/2;
> xright := xnlist[1]+1/2;
> RETURN([xleft,0,xright,0,xright,n,xleft,n,xleft,0]);
> end:
> histograma := proc( List, Title )
> local histolist, plotset, count, el, zipproc, palette;
> count := table(sparse);
> for el in List do count[el] := count[el]+1; od;
> zipproc := (x,y) -> [op(x),op(y)];
> histolist := zip( zipproc, [indices(count)],[entries(count)] );
> plotset := convert( map(torre,histolist), set ) union
> { [0, 0, max(op(List))+1, 0] };
> plotstructure := plot(plotset,style=LINE,title=Title,xtickmarks=8):
> palette := [ RED, WHITE, YELLOW, GREEN, BLUE, CYAN, MAGENTA ];
> subs( map(((x) -> x=BLACK), palette), plotstructure );
> end:
> lvals := [1,3,1,7,1,3,7,7,4,6,4,4,2,7,3,3,3]:
> histograma(lvals,Ejemplo de un histograma);
5.3 Supercies: Gracas en 3D
El siguiente ejemplo muestra el uso del paquete plots[sphereplot]

> interface( plotdevice=postscript, plotoutput=spherharm.ps );
> m := 3; n:=7;

0 1 2 3 4 5 6 7 8
Figura 5.2: Ejemplo de un histograma.
m := 3
n := 7
> Legendre7 := orthopoly[P](n,x);

429 7 693 5 315 3 35
Legendre7 := x x + x x
16 16 16 16
> diff(Legendre7 ,x$m);

45045 4 10395 2 945
x x +
8 4 8
> Y := subs(x=cos(phi),") * cos(m*theta)*(-sin(phi))^m;

45045 4 10395 2 945
Y := cos( ) cos( ) + cos( 3 ) sin( )3
8 4 8
> plots[sphereplot]( 5+Y/200, theta=0..2*Pi, phi=0..Pi,grid=[51,31],

> scaling=CONSTRAINED );

z 0
-2
-4
-4 -4
-2 -2
0 0
y x
2 2
4 4
Figura 5.3: Esfera generada mediante una funcion parametrica.

MAPLE Manual

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

MAPLE Manual

Uploaded by

Copyright:

Available Formats

Introduccion al uso del paquete computacional

Centro de Inteligencia Articial

1 Algunas habilidades de Maple 1

2 Uso interactivo de Maple 5

3 Maple un poco menos simple 25

4 El lenguaje de programacion de Maple 51

c Dr. Horacio Martnez Alfaro, ITESM.

Algunas habilidades de Maple

1.1 Maple: un sistema para computacion matematica

Collage de comandos de Maple

Resolver un sistema de ecuaciones lineales en tres incognitas

Declarar una ecuacion diferencial y almacenarla (o etiquetarla)

Ahora, gracamos la solucion

c Dr. Horacio Martnez Alfaro, ITESM.

Resolver una ecuacion con 40 dgitos de precision

> fsolve(cot(x+ Pi/8)=x, x);

> Digits := 10:

Calcular la integral indenida de

Calcular un integral denida impropia

c Dr. Horacio Martnez Alfaro, ITESM.

Denicion de una matriz con elementos numericos

Calcular la matriz exponencial

Denicion de una matriz Toeplitz con elementos simbolicos

Calcular sus valores caractersticos

Graca de una supercie en 3D

Gracas de dos tubos mediante supercies en 3D

c Dr. Horacio Martnez Alfaro, ITESM.

c Dr. Horacio Martnez Alfaro, ITESM.

Uso interactivo de Maple

2.1 Ejecucion de Maple

2.2 Como terminar una sesion de Maple

quit Termina una sesion de Maple

2.3 Arimetica simple en Maple

Tabla 2.1: Operaciones aritmeticas en Maple

Operacion Smbolo Ejemplo

c Dr. Horacio Martnez Alfaro, ITESM.

> (4 + (" * 6))/(999999-32516);

2.4 Ayuda en lnea

?topico Da informacion sobre topico

2.5 Variables en Maple

variable := expresion; Asigna un valor a una variable

c Dr. Horacio Martnez Alfaro, ITESM.

> fuerza := masa * aceleracion;

> masa := 3000;

> aceleracion := 9.8;

> masa := 3500;

> distancia1 := 10;

> distancia2 := 50;

> Energia\:total := fuerza * (distancia2 - distancia1);

2.6 Comandos y funciones predenidas

Tabla 2.2: Constantes matematicas conocidas por Maple

Constante Nombre en Maple

c Dr. Horacio Martnez Alfaro, ITESM.

> expr1 := (x + y + x + x*x*x + x) / 2;

> expr2 := ((4*expr1) - 2*y) / x;

> exprgrande := sin( expr1 ) / ln ( expr2 ^ 2);

2.7 Introduccion a los comandos matematicos

2.7.1 Uso de solve

solve(ecuacion,variable) Resuelve una ecuacion en una variable

> solve(ln(x^2 - 1) = a, x);

> solve(q^3-k, q);

Soluciones de sistemas de ecuaciones

c Dr. Horacio Martnez Alfaro, ITESM.

> varconjunto := {x,y};

> expr1 := (x + y + x + xxx + x) / 2;

> expr2 := ((4expr1) - 2y) / x;

> 3.010^20 - 2.9910^13;

> -1/2(-64/27)^(1/6)-1/2 (-1)^(1/3) * (-64/27)^(1/6) + 4 +

> Int((x^3)sqrt(x^2 - a^2), x=a..2a) = int( (x^3)sqrt(x^2-a^2), x=a..2a);