Maple vr3

(6&8(/$ 683(5,25 '( ,1*(1,(526 ,1'8675,$/(6
81,9(56,'$' '( 1$9$55$
,1'8675, ,1-,1(58(1 *2,0$,/$.2 (6.2/$
1$)$552$.2 81,%(576,7$7($

Aprenda Maple V Release 3
como si estuviera en Primero
San Sebastián, 6 de Marzo de 1996
Colección preparada por:
Javier García de Jalón de la Fuente
Rufino Goñi Lasheras
Omar Aguirre Suárez
José María Sarriegui Domínguez
Iñigo Girón Legorburu
Alfonso Brazález Guerra

ÍNDICE
1. INTRODUCCIÓN A MAPLE V Y AL CÁLCULO SIMBÓLICO
1.1. ¿Qué es Maple V?
1.2. Algunos Ejemplos Introductorios
1.2.1. Formatos de entrada y de salida
1.2.2. Fin de sentencia y comentarios
1.2.3. Recuperación de los últimos resultados del programa
1.2.4. Algunos ejemplos sencillos

1
1
1
2
2
2
3

2. DESCRIPCIÓN GENERAL DE MAPLE V
2.1. El Help de Maple
2.2. Núcleo, librerías e interface de usuario
2.3. Hoja de trabajo
2.3.1. Regiones de una hoja de trabajo. Grupos de regiones
2.3.2. Edición de hojas de trabajo
2.3.3. Modos de trabajo
2.3.4. Estado interno del programa
2.3.5. Sistema de ventanas de Maple V
2.3.6. Librerías
2.4. Objetos de Maple
2.4.1. Números y variables
2.4.2. Cadenas de caracteres
2.4.3. Operador de concatenación (.)
2.4.4. Constantes predefinidas
2.4.5. Expresiones y ecuaciones
2.4.6. Secuencias
2.4.7. Conjuntos (sets)
2.4.8. Listas (lists)
2.5. Funciones member, sort, subsop y subs
2.6. Funciones convert y map
2.7. Variables evaluadas y no-evaluadas

8
8
9
9
10
11
11
11
12
12
13
13
14
14
14
14
15
16
17
17
18
19

3. POLINOMIOS Y FRACCIONES RACIONALES
3.1. Polinomios de una y más variables
3.1.1. Polinomios de una variable
3.1.2. Polinomios de varias variables
3.2. Funciones racionales
3.3. Transformaciones de polinomios y expresiones racionales

24
24
24
26
27
28

4. ECUACIONES Y SISTEMAS DE ECUACIONES
4.1. Resolución simbólica de ecuaciones
4.2. Resolución numérica.

29
29
30

5. PROBLEMAS DE CÁLCULO DIFERENCIAL E INTEGRAL
5.1. Cálculo de límites
5.2. Diferenciación de expresiones
5.3. Integración de expresiones
5.4. Desarrollos en serie
5.5. Integración de ecuaciones diferenciales ordinarias

31
31
32
33
34
34

6. OPERACIONES CON EXPRESIONES
6.1. Simplificación de expresiones
6.1.1. Función expand
6.1.2. Función combine
6.1.3. Función simplify
6.2. Manipulación de expresiones
6.2.1. Función normal
6.2.2. Función factor
6.2.3. Función convert
6.2.4. Función sort

35
36
36
36
37
37
37
38
38
39

Copyright © 1996 Javier García de Jalón, Rufino Goñi, Omar Aguirre, José María Sarriegui, Iñigo Girón, Alfonso Brazález. Todos los derechos
reservados. Está prohibida la reproducción total o parcial con fines comerciales y por cualquier medio del contenido de estas páginas. Sólo esta
permitida su impresión y ut ilización con fines personales.

7. FUNCIONES DE ÁLGEBRA LINEAL
7.1. Librería linalg
7.2. Vectores y matrices
7.3. Función evalm y operador matricial &*
7.4. Inversa y potencias de una matriz
7.5. Copia de matrices
7.6. Funciones básicas de Álgebra Lineal.
7.6.1. Función add
7.6.2. Función charmat
7.6.3. Función charpoly
7.6.4. Funciones colspace y rowspace
7.6.5. Función crossprod
7.6.6. Función det
7.6.7. Función dotprod
7.6.8. Función eigenvals
7.6.9. Función eigenvects
7.6.10. Función gausselim
7.6.11. Función inverse
7.6.12. Función iszero
7.6.13. Función linsolve
7.6.14. Función multiply
7.6.15. Función randmatrix

39
39
40
43
43
44
44
44
45
45
45
46
46
46
46
46
47
47
47
47
47
48

8. GRÁFICOS EN 2 Y 3 DIMENSIONES
8.1. Gráficos bidimensionales
8.1.1. Expresiones de una variable
8.1.2. Funciones paramétricas
8.1.3. Dibujo de líneas poligonales
8.1.4. Otras funciones de la librería plots
8.1.5. Colores y otras opciones de plot
8.2. Gráficos tridimensionales
8.2.1. Ventanas 3-D
8.2.2. Otros tipos de gráficos 3-D
8.3. Animaciones

48
48
48
49
49
49
50
51
51
52
53

9. FUNCIONES EN MAPLE. PROGRAMACIÓN
9.1. Estructuras de programación
9.1.1. Bifurcaciones: sentencia if
9.1.2. Bucles: sentencia while
9.1.3. Bucles: sentencia for
9.1.4. Sentencias break y next
9.2. Funciones y procedimientos
9.3. Funciones definidas mediante el operador flecha (–>)
9.3.1. Funciones de una variable
9.3.2. Funciones de dos variables
9.4. Procedimientos en Maple V
9.5. Conversión de expresiones en funciones
9.6. Operaciones sobre funciones
9.7. Funciones anónimas

54
54
54
54
54
55
55
55
55
56
57
58
59
60

10. COMANDOS DE ENTRADA/SALIDA
10.1. Control de la información de salida
10.2. Las librerías de Maple
10.3. Guardar y recuperar el estado de una hoja de trabajo
10.4. Lectura y escritura de ficheros
10.5. Ficheros formateados
10.6. Generación de código

61
61
61
61
62
63
63


Introducción a MAPLE V Release 3

1.

página 1

INTRODUCCIÓN A MAPLE V Y AL CÁLCULO SIMBÓLICO

El programa que se describe en este manual es probablemente muy diferente a todo los que se ha visto
hasta ahora, en relación con el cálculo y las matemáticas. En algunos aspectos, Maple se parece a
MATLAB, pero en otros resulta muy diferente. La principal diferencia está en que Maple es capaz de
realizar cálculos simbólicos, es decir, operaciones similares a las que se llevan a cabo por ejemplo
cuando, intentando realizar una demostración matemática, se despeja una variable de una expresión, se
sustituye en otra expresión matemática, se agrupan términos, se simplifica, se deriva y/o se integra, etc.
También en estas tareas puede ayudar el ordenador, y Maple es una de las herramientas que existen para
ello. Pronto se verá, aunque no sea más que por encima, lo útil que puede ser este programa.
1.1.

¿QUÉ ES M APLE V?

Maple es un programa desarrollado desde 1980 por el grupo de Cálculo Simbólico de la Universidad de
Waterloo (Ontario, CANADÁ). Su nombre proviene de las palabras MAthematical PLEasure. Existen
versiones para los ordenadores más corrientes del mercado, y por supuesto para los PCs que corren bajo
Windows de Microsoft. La primera versión que se instaló en las salas de PCs de la ESIISS en Octubre de
1994 fue la Release 3. En el último trimestre de 1995 apareció la Release 4, con algunas mejoras respecto
a la versión anterior.
Para arrancar Maple desde Windows 3.1 hay que abrir en el Program Manager el grupo
de iconos correspondiente, y clicar dos veces en el icono del programa, que coincide con la hoja
de arce (el símbolo nacional canadiense). Con Windows 95 se puede utilizar el menú Start, del
modo habitual. También puede arrancarse clicando dos veces sobre un fichero producido con Maple en
una sesión anterior, que tendrá la extensión *.ms. En cualquier caso, el programa arranca y aparece la
ventana de trabajo (ver figura 1), que es similar a la de muchas otras aplicaciones de Windows. En la
primera línea aparece el prompt de Maple: el carácter "mayor que" (>). Esto quiere decir que el programa
está listo para recibir instrucciones.
Maple no es un programa fácil de manejar.
Pronto se comprueba que es bastante más
complejo que MATLAB. En general, cuando un
problema se puede resolver con los dos
programas, es mejor y más sencillo utilizar
MATLAB. Sin embargo, Maple puede llegar
mucho más lejos, y resolver una gama más amplia
de problemas, en particular los basados en el uso
de métodos simbólicos. A lo largo de las páginas
de este manual es posible llegar a hacerse una idea
bastante ajustada de qué programa es más
adecuado para cada tipo de problema.
1.2.

Figura 1. Ventana principal de Maple V.

ALGUNOS EJEMPLOS INTRODUCTORIOS

Maple tiene bastantes peculiaridades (como ya se ha dicho, quizás muchas más que MATLAB). Antes de
empezar a exponerlas con un cierto detalle, es conveniente presentar algunos ejemplos sencillos que den
una idea de qué es y para qué sirve este programa. De todas formas, antes de ver estos ejemplos, se van a
dar unas breves explicaciones sobre cómo funciona esta aplicación. Aunque no es estrictamente necesario,


página 2

se recomienda leer las secciones siguientes junto a un PC con Maple instalado en el que se puedan
reproducir los distintos ejemplos.
1.2.1. Formatos de entrada y de salida
La ventana que se abre al arrancar Maple se conoce
con el nombre de worksheet (hoja de trabajo). En
esta hoja se permite disponer de zonas o regiones
de entrada, de salida y de texto. Para cada tipo de
región se puede elegir un color y tipo de letra
diferente, con objeto de distinguirla claramente de
las demás. Con el menú Format/Fonts se pueden
controlar estas opciones. Antes de empezar a
trabajar puede ser conveniente establecer unos
formatos para cada tipo de región. Con
Format/Fonts/Input se abre la caja de diálogo
mostrada en la figura 2; en ella se puede elegir Arial
Figura 2. Selección del tipo de letra para la región de
12, Bold y color rojo. De forma análoga, en
entrada (input region).
Format/Fonts/Output se puede elegir Courier
New 12, Regular y color azul; y en Format/Fonts/Text Times New Roman 12, Regular y color negro.
Es también conveniente que en Format/Math Style esté seleccionada la opción Medium. Para
guardar estos formatos, se debe elegir el comando Save Settings en el menú File.
1.2.2. Fin de sentencia y comentarios
En Maple todas las sentencias terminan con un carácter punto y coma (;). En esto Maple se parece más a
C que a MATLAB. De hecho, si no se pone el carácter de terminación y se pulsa Intro, el programa
seguirá esperando a que se complete la instrucción, que Maple permite escribir en varias líneas. Si alguna
vez sucede eso, se puede poner el carácter (;) en la línea en la que se esté y volver a pulsar Intro.
También se puede utilizar el carácter dos puntos (:) como terminación de línea, pero en este caso no
se imprime ninguna salida en la pantalla. Siempre que interese ver qué es lo que hace el programa, se debe
utilizar el punto y coma (;) como terminación de línea. Cuando se está aprendiendo a manejar el programa
es útil disponer de toda la información de salida, que además en Maple está especialmente cuidada.
Pueden introducirse comentarios en una línea o región de entrada con el carácter (#). A partir de
este carácter todo lo que aparece en el resto de la línea es considerado como un comentario. Por
supuesto, el carácter de terminación –(;) o (:)– deberá aparecer antes del carácter (#).
1.2.3. Recuperación de los últimos resultados del programa
El último resultado o salida obtenido del programa puede recuperarse para ser utilizado en una instrucción
posterior por medio del carácter comilla doble ("). De forma análoga, ("") representa el penúltimo
resultado y (""") el antepenúltimo resultado. Esto es muy útil para poder utilizar un resultado en el comando
siguiente sin haber tenido que asignarlo a ninguna variable.



página 3

1.2.4. Algunos ejemplos sencillos
Para empezar diremos que Maple puede actuar como una simple calculadora numérica. Teclee la siguiente
sentencia (a continuación incluimos el resultado que debe aparecer):
> sin(5.34*Pi/2);

Vemos que en realidad no ha hecho lo que esperábamos que hiciera. Esto es porque Maple intenta
siempre no cometer errores numéricos (errores de redondeo en las operaciones aritméticas), y la más
segura forma de evitarlo es dejar para más adelante el realizar las operaciones aritméticas (la división de
5.34 entre 2 sí ha sido realizada pues no introduce errores). Las operaciones aritméticas serán realizadas
cuendo el usuario lo decida, por ejemplo mediante el comando evalf:
> evalf(sin(5.34*Pi/2));

Con Maple se puede controlar fácilmente la precisión de los cálculos (por defecto se calcula con 10
cifras decimales). Por ejemplo, ejecute los siguientes comandos:
> Digits := 20;

> evalf(sin(5.34*Pi/2));

> Digits := 10;

donde el último comando devuelve la precisión a su valor por defecto. El poder trabajar con cualquier
número de cifras decimales implica que Maple no utilice el procesador de coma flotante que tiene el PC,
sino que realiza esas operaciones por software, con la consiguiente pérdida de eficiencia. En Maple el
operador de asignación es (:=). Como ya se ha dicho, todas las sentencias de Maple deben terminar con
(;) ó (:). Recuerde que con (:) se suprime la línea o líneas de salida correspondientes. Se pueden poner
varios comandos o sentencias en la misma línea de entrada; cada comando debe finalizar con (;) o (:).
> 100/3: 100/6; (24+7/3);

donde se puede observar que el comando 100/3: no produce salida. Maple abre líneas de continuación
hasta que se teclea el carácter de terminación (;). Observe el siguiente ejemplo:
> (2.4*13)+
> 15;

Con números enteros, Maple utiliza "matemáticas exactas", es decir, mantiene las divisiones en forma
de cociente, las raíces en forma de raíz, etc. y trata de simplificar al máximo las expresiones aritméticas que
se le proporcionan:


página 4

> 2^8/5+3^(1/2);

Como ya se ha visto, para forzar la obtención de un resultado numérico en coma flotante se utiliza la
función evalf:
> evalf(2^8/5+3^(1/2));

Se van a ver ahora algunos ejemplos de cálculo simbólico, que es la verdadera especialidad de
Maple: Teclee los siguientes comandos, ahorrándose si lo desea la parte de comentarios:
> ec := a*x^2 + b*x + c;

# se define una ecuación de segundo grado

> sols := solve(ec, x);

# se llama a una función que resuelve la ecuación

> sols[1];

# se hace referencia a la primera de las dos soluciones

> subs(x=sols[2], ec);

> normal(");

# se sustituye la segunda solución en la ecuación

# se simplifica el resultado anterior representado por (")

> int(1+y+4*y^2, y) := int(1+y+4*y^2, y);

# integral de un polinomio

Este resultado merece una pequeña explicación: en el comando ejecutado para obtener este
resultado, la integral figura a ambos lados del operador de asignación, aunque sólo se ha ejecutado la parte
de la derecha. El ponerlo también a la izquierda sirve para mejorar el aspecto del resultado, pues la integral
sin efectuar se imprime como primer miembro de la asignación. Véanse los ejemplos siguientes:
> diff(", y);

# derivando para comprobar la respuesta anterior

> diff(", y);

# volviendo a derivar respecto a y

A continuación se presentan algunos otros ejemplos de interés. Se anima al lector a que teclee los
siguientes comandos y compruebe los consiguientes resultados:



página 5

> f := arctan((2*x^2-1)/(2*x^2+1));

> derivada := diff(f, x); # derivada de f respecto a x

> normal(derivada); # simplificación del cociente

> int(", x); # integral del resultado anterior respecto a x

> diff(", x);

> integrate(f, x); # integrate es sinónimo de int

> diff(", x);

> normal(");

Como se ve en los ejemplos anteriores, Maple permite manejar y simplificar expresiones algebraicas
verdaderamente complicadas.
Una de las posibilidades más interesantes de Maple es la de generar ficheros fuente de C (y/o
FORTRAN) para evaluar las expresiones resultantes. Ejecute los siguientes ejemplos y observe los
resultados:


página 6

> res := integrate(f, x);

> precision := double;

> fortran(res, 'optimized');
t1 = x**2
t16 = x*datan((2*t1-1)/(2*t1+1))-dlog(2*t1-2*x+1)/4-datan(2*x-1)/2
#+dlog(2*t1+2*x+1)/4-datan(2*x+1)/2
> readlib(cost) (res);

> readlib(C);
proc() ... end
> C(res);
t0 = x*atan((2.0*x*x-1.0)/(2.0*x*x+1.0))-log(2.0*x*x-2.0*x+1.0)/4-atan(
2.0*x-1.0)/2+log(2.0*x*x+2.0*x+1.0)/4-atan(2.0*x+1.0)/2;
> C(res, 'optimized');
t1 = x*x;
t16 = x*atan((2.0*t1-1.0)/(2.0*t1+1.0))-log(2.0*t1-2.0*x+1.0)/4atan(2.0*x-1.0)/2+log(2.0*t1+2.0*x+1.0)/4-atan(2.0*x+1.0)/2;

Maple tiene también la posibilidad de escribir el código FORTRAN o C resultante en un fichero de
disco. Considérese un ejemplo un poco más complicado:
> ecuacion := x^3 - 5*a*x^2 = 1;

> solucion := solve(ecuacion, x);

Ejecutando ahora la siguiente instrucción, Maple crea un fichero llamado file.c en el directorio temp
del disco c:. Es fácil de comprobar que dicho fichero contine el código C necesario para la primera de las
soluciones de la ecuación anterior (es necesario poner una doble barra invertida porque la primera es
interprestada como un carácter de escape que afecta al carácter que le sigue).
> C(solucion[1], filename = `c:tempfile.c`);



página 7

El código puede ser optimizado, por ejemplo:
> C(solucion[2], optimized);
t1 = a*a;
t2 = t1*a;
t4 = sqrt(81.0+1500.0*t2);
t6 = pow(1.0/2.0+125.0/27.0*t2+t4/18,1.0/3.0);
t8 = t1/t6;
t9 = sqrt(3.0);
t12 = -t6/2-25.0/18.0*t8+5.0/3.0*a+sqrt(-1.0)*t9*(t6-25.0/9.0*t8)/2;

y, como antes, guardado en un fichero de disco con este formato:
> C(solucion[1], filename = `c:tempfile2.c`);

Se pueden calcular las operaciones necesarias para evaluar la expresión anterior, sin y con
optimización:
> readlib(cost) (solucion[1]);

> cost(optimize(solucion[1]));

Maple tiene también grandes capacidades gráficas, en algunos aspectos superiores a las de
MATLAB. A continuación se van a ver dos ejemplos con funciones que aparecen en el estudio de las
vibraciones de sistemas con un grado de libertad. Se incluyen las ventanas gráficas resultantes (figuras 3 y
4).
–

Dibujo en dos dimensiones:
> xi:= 0.2: formula := beta -> 1/((1-beta^2)^2 + (2*xi*beta)^2)^0.5;

> plot(formula, 0.0..5.0);

–

Dibujo en tres dimensiones:
> form := (beta, xi) -> 1/((1-beta^2)^2 + (2*xi*beta)^2)^0.5;



página 8

> plot3d(form, 0..5, 0.05..1);

Figura 3. Función plana.

Figura 4. Función tridimensional.

De forma análoga, Maple puede trabajar también con matrices de modo simbólico. Se presenta a
continuación un ejemplo muy sencillo. Ejecute los siguientes comandos y observe los resultados:
> with(linalg): # se carga la librería de funciones de álgebra lineal
> A := matrix( 3, 3, [[1-x, 0, x], [0,-x, 1+x], [0, 1, x]] );

> B := inverse(A);

> d := det(A);

Seguro que estos ejemplos le habrán servido para empezar a ver qué cosas Maple es capaz de
realizar. Maple es un programa que puede ser una gran utilidaden las áreas más diversas de la ingeniería.

2.

DESCRIPCIÓN GENERAL DE MAPLE V

2.1.

EL HELP DE M APLE

El help de Maple se parece al de las demás aplicaciones de Windows, aunque tiene también algunas
peculiaridades que conviene conocer. Además de poder explorar el menú Help de la ventana principal del
programa, se puede pedir ayuda sobre un comando concreto desde la hoja de trabajo tecleando:
?comando


página 9

El método anterior abre una ventana
con toda la información disponible sobre
dicho comando. Otra forma de abrir la
misma ventana es colocar el cursor sobre el
nombre del comando y ver que en el menú
Help se ha activado la opción de pedir
información sobre ese comando en
particular. Si se está interesado en una
información más específica, se pueden
utilizar los comandos siguientes:
info(comando)
usage(comando)
related(comando)
example(comando)

Figura 3. Ventana del Browser de Maple V.

que dan información particular sobre para qué sirve, cómo se usa, qué otros comandos relacionados
existen y algunos ejemplos sobre su uso, respectivamente.
Particular interés tiene el llamado browser o sistema de exploración del Help. Con él, se puede
examinar cualquier función, las distintas librerías, etc. Pruebe a abrir el browser a partir del menú Help de
la ventana principal.
2.2.

NÚCLEO , LIBRERÍAS E INTERFACE DE USUARIO

Maple consta de tres partes principales: el núcleo o kernel, que es la parte central del programa (escrita
en lenguaje C), encargada de realizar las operaciones matemáticas fundamentales; las librerías, que son
conjuntos de funciones relacionadas que residen en el disco y son llamadas cuando se las necesita; y la
interface de usuario, que se encarga de todas las operaciones de entrada/salida, y en general, de la
comunicación con el exterior.
Como consecuencia, Maple tiene dos tipos de comandos: los que afectan al núcleo y los comandos
que se refieren a la interface de usuario.
2.3.

HOJA DE TRABAJO

Cuando se arranca Maple aparece la ventana principal, que corresponde a una hoja de trabajo
(worksheet). En una hoja de trabajo hay que distinguir entre las regiones de entrada, salida y texto.
Puede aparecer un cuarto tipo de región –de gráficos– si con el comando Paste se pegan sobre ella
gráficos copiados de otras ventanas.
A medida que se van ejecutando comandos en la hoja de trabajo, Maple va creando variables,
almacenando resultados intermedios, etc. Al estado del programa en un determinado momento del trabajo
se le llama estado interno del programa, que contiene las variables definidas por el usuario,
modificaciones de los valores por defecto, resultados anteriores e intermedios, etc. Se puede volver en
cualquier momento al estado interno inicial tecleando el comando restart.
A diferencia de MATLAB (en el que se podían recuperar sentencias anteriores con las flechas, pero
no ejecutar directamente en la línea en que habían sido escritas), en Maple el usuario puede moverse por
toda la hoja de trabajo, situando el cursor en cualquier línea, ejecutando comandos en cualquier orden,
editando y volviendo a ejecutar sentencias anteriores, insertando otras nuevas, etc. Es evidente que eso


página 10

puede modificar el estado interno del programa, y por tanto afectar al resultado de alguna de esas
sentencias que dependa de ese estado. El usuario es responsable de hacer un uso inteligente de esa
libertad que Maple pone a su disposición.
En Maple no se pueden utilizar las flechas para recuperar comandos anteriores. Sin embargo se
puede hacer uso de la barra de desplazamiento vertical de la ventana para ir a donde está el comando,
colocar el cursor sobre él, editarlo si se desea, y volverlo a ejecutar pulsando la tecla intro. También
puede utilizarse el Copy y Paste entre distintas regiones de la hoja de trabajo.
En Maple no pueden mantenerse abiertas varias hojas de trabajo a la vez. Puede trabajarse sobre
varias hojas de trabajo por el procedimiento de tener abiertos varios ejecutables de Maple
simultáneamente. Se puede hacer Copy y Paste entre dichas hojas de trabajo. Por supuesto, los estados
internos de dichas hojas de trabajo son completamente independientes.
2.3.1. Regiones de una hoja de trabajo. Grupos de regiones
Las hojas de trabajo tienen cuatro tipos de regiones o zonas, que se comportan de un modo muy
diferente. Son las siguientes:
1.–

región de entrada

2.–

región de salida

3.–

región de texto

4.–

región de gráficos

De ordinario, estas regiones se visualizan con colores y tipos de letra diferentes, de forma que son
muy fáciles de distinguir. Con el comando Format/Font se pueden modificar los tipos de letra de las tres
primeras regiones citadas.
Existen también los llamados grupos de regiones. El agrupar varias regiones tiene ciertas ventajas,
como por ejemplo el poder ejecutar conjuntamente todas las regiones de entrada del grupo pulsando la
tecla Intro o haciendo doble clic sobre cualquier punto del grupo. Para ver y distinguir los distintos grupos,
se pueden hacer aparecer unas líneas de separación en la pantalla con el comando View/Separator
Lines, o clicando sobre el icono correspondiente (ver al margen). Es bastante útil ver estas líneas
de separación.
En Maple existen comandos para partir un grupo (comando Format/Split Group) y para unir dos
grupos contiguos (comando Format/Join Group). El primero de ellos parte un grupo por encima de la
línea en la que está el cursor. El segundo de ellos une el grupo en el que está el cursor con el grupo
anterior.
En Maple hay que distinguir entre pulsar Intro y Mayus+Intro. En el primer caso se envía a evaluar
directamente el comando introducido (si tiene el carácter de terminación: punto y coma o dos puntos) y
pasa a la zona de entrada del grupo siguiente (si no existe, la crea). La segunda supone que el usuario va a
seguir escribiendo otro comando del mismo grupo en la línea siguiente y amplía la zona de entrada del
grupo actual en el que está el cursor. Recuerde que Maple permite escribir varios comandos en una misma
línea (cada uno con su carácter de terminación). Realice algunas pruebas.
Maple permite interrumpir los cálculos, una vez iniciados: si el usario decide cancelar un
comando que ha comenzado ya a ejecutarse, basta clicar sobre el botón Stop en la barra de
herramientas de la ventana principal, o pulsar las teclas Control+Pausa.



página 11

Por otra parte, existen varias formas de salir de Maple: se pueden teclear los comandos quit, done,
y stop; se puede utilizar el menú File/Exit o simplemente teclear Alt+F4.
2.3.2. Edición de hojas de trabajo
Toda la hoja de trabajo es accesible y puede ser editada. Esto lleva a que un mismo comando pueda
ejecutarse en momentos diferentes con estados internos muy diferentes, y dar por ello resultados
completamente distintos. Es importante tener esto en cuenta para no verse implicado en efectos
completamente imprevisibles. Para eliminar efectos de este tipo, puede ser útil recalcular completamente la
hoja de trabajo, empezando desde el primer comando. Esto se hace desde el menú Format con la opción
Execute Worksheet. Cuando se recalcula una hoja de trabajo, los gráficos se recalculan, pero los que
están empastados en la región de gráficos de la hoja no se actualizan. Antes de ejecutar el comando
Execute Worksheet conviene cerciorarse de que en el menú Options están seleccionadas las opciones
Replace Mode y Continuous Mode. Estos modos serán vistos con más detalle en la sección siguiente.
2.3.3. Modos de trabajo
Maple dispone de varios modos de trabajo, que se seleccionan en el menú Options. Dichos modos son
los siguientes:
–

Options/Replace Mode. Si está activado, cada resultado o salida sustituye al anterior en la región
de salida correspondiente. Si este modo no está activado, cada resultado se inserta antes del
resultado previo en la misma región de salida, con la posibilidad de ver ambos resultados a la vez y
compararlos.

–

Options/Continuous Mode. Después de ejecutar un comando en la región de entrada de un
grupo, el cursor se desplaza a la región de entrada del grupo siguiente. Como se ha dicho antes, ésta
opción debe estar seleccionada para recalcular una hoja.

–

Options/Insert Mode. Al pulsar Intro en una línea de entrada de un grupo se crea una nueva
región de entrada y un nuevo grupo, inmediatamente a continuación.

–

Options/Insert At End Mode. Al pulsar Intro se crea una nueva región de entrada y un nuevo
grupo al final de la hoja de trabajo y se mueve el cursor a esa nueva región.
Lo ordinario es trabajar con las opciones Replace Mode y Continuous Mode activadas.

2.3.4. Estado interno del programa
El estado interno de Maple consiste en todas las variables e información que el programa tiene
almacenados en un determinado momento de la ejecución. Si por algún motivo hay que interrumpir la
sesión de trabajo y salir de la aplicación, pero se desea reanudarla más tarde, hay que ser capaces de
guardar este estado interno, o al menos de guardar la información que permita reconstruirlo. Recuérdese
que con el comando restart se puede volver en cualquier momento al estado inicial, anulando todas las
definiciones y cambios que se hayan hecho en el espacio de trabajo.
Con el comando Save del menú File se almacenan los resultados externos de la sesión de
trabajo (regiones de entrada, salida, texto y gráficos) en un fichero con extensión *.ms. Este fichero no es
un fichero de texto, y por tanto no es visible ni editable con Notepad o Word. Para guardar un fichero de
texto con la misma información del fichero *.ms hay que elegir Save As, y en la caja de diálogo que se
abre elegir Text File en la lista desplegable Save File As Type. Si se quiere almacenar también el estado


página 12

interno de la sesión, hay que activar la opción Save Kernel State, del menú Options. En este caso, junto
con el fichero *.ms resultante se crea otro fichero del mismo nombre con la extensión *.m que contiene el
estado interno y por tanto ocupa mucha más memoria. En este caso, al abrir posteriormente el fichero
*.ms se cargará automáticamente el estado interno de Maple a partir del fichero *.m (no hay que confundir
los ficheros *.m de Maple con los de MATLAB: ¡No tienen nada que ver!).
Recuerde también que cuando se abre una hoja de trabajo almacenada previamente sin guardar el
estado interno, y se desea seguir trabajando sobre ella, es posible reconstruir el estado interno
recalculándola sentencia por sentencia desde el principio, bien manualmente, bien de modo automático con
el comando Format/Execute Worhsheet. Para ello puede ser conveniente eliminar previamente todas las
regiones de salida (menú Format, comando Remove All/Output).
2.3.5. Sistema de ventanas de Maple V
Maple tiene 5 tipos diferentes de ventanas:
1.–

ventana principal (hoja de trabajo). Comos hemos dicho, sólo puede haber una hoja de trabajo
abierta al mismo tiempo. Es posible sin embargo ejecutar dos sesiones de Maple simultáneamente,
cada una con sus variables y su hoja de trabajo independiente.

2.–

ventana de ayuda. Se activa al solicitar la ayuda del Help, bien desde el menú, bien desde la línea de
comandos de la hoja de trabajo.

3.–

ventanas gráficas 2-D. Se abre una ventana nueva cada vez que se ejecuta un comando de dibujo 2D. Estas ventanas tienen sus propios menús, que permiten modificar de modo interactivo algunas
características del dibujo (tipo de línea, de ejes, etc. En este sentido Maple es más versátil y fácil de
utilizar que MATLAB).

4.–

ventanas gráficas 3-D. Se abre también una ventana nueva cada vez que se ejecuta un comando de
dibujo 3-D. Estas ventanas tienen también sus propios menús, diferentes de los de las ventanas
gráficas 2-D.

5.–

ventana de animaciones (movies). Éste es el último tipo de ventanas gráficas, diferentes también de
las dos anteriores. Disponen de unos mandos similares a los de un equipo de video, para poder ver
de diversas formas la animación producida.

2.3.6. Librerías
Maple dispone de más de 2000 comandos. Sólo los más importantes se cargan en memoria cuando el
programa comienza a ejecutarse. La mayor parte de los comandos están agrupados en distintas librerías
temáticas, que están en el disco del ordenador. Para poder ejecutarlos, hay que cargarlos primero. Puede
optarse por cargar un comando o función aislado o cargar toda una librería. Esta segunda opción es la más
adecuada si se van a utilizar varios f
unciones de la misma a lo largo de la sesión de trabajo. También el
usuario puede crear sus propias librerías.
El comando readlib(namefunc) carga en memoria la función solicitada como argumento. Por su
parte, el comando with(library) carga en memoria toda la librería especificada. Con el Browser de maple
(figura 3) se pueden ver las librerías disponibles en Maple y las funciones de que dispone cada librería.
Maple dispone de funciones de librería que se cargan automáticamente al ser llamadas (para el
usuario son como las funciones o comandos del núcleo, que están siempre cargados). La lista de estas
funciones se puede obtener con el comando index[external]. Las restantes funciones deben ser cargadas


página 13

explícitamente por el usuario antes de ser utilizadas. Ésta es una fuente importante de dificultades para los
usuarios que comienzan.
2.4.

OBJETOS DE M APLE

Los objetos de Maple son los tipos de datos y operadores con los que el programa es capaz de trabajar.
A continuación se explican los más importantes de estos objetos.
2.4.1. Números y variables
Maple trabaja con números enteros con un número de cifras arbitrario. Por ejemplo, no hay ninguna
dificultad en calcular números muy grandes como factorial de 100, o 3 elevado a 50. Si el usuario lo desea,
puede hacer la prueba.
Maple tiene también una forma particular de trabajar con números racionales e irracionales,
intentando siempre evitar operaciones aritméticas que introduzcan errores. Ejecute por ejemplo los
siguientes comandos, observando los resultados obtenidos (se pueden poner varios comandos en la misma
línea separados por comas, siempre que no sean sentencias de asignación y que un comando no necesite
de los resultados de los anteriores):
> 3/7, 3/7+2, 3/7+2/11, 2/11+sqrt(2), sqrt(9)+5^(1/3);

Si en una sentencia del estilo de las anteriores, uno de los números tiene un punto decimal, Maple
calcula todo en aritmética de punto flotante. Por defecto se utiliza una precisión de 10 cifras decimales.
Observe el siguiente ejemplo, casi análogo a uno de los hechos previamente:
> 3/7+2./11;

La precisión en los cálculos de punto flotante se controla con la variable Digits, que como se ha
dicho, por defecto vale 10. En el siguiente ejemplo se trabajará con 25 cifras decimales exactas:
> Digits := 25;

Se puede forzar la evaluación en punto flotante de una expresión por medio de la función evalf.
Observe el siguiente resultado:
> sqrt(9)+5^(1/3);

> evalf(");

La función evalf admite como segundo argumento opcional el número de dígitos. Por ejemplo para
evaluar la expresión anterior con 40 dígitos sin cambiar el número de dígitos por defecto, se puede hacer:
> evalf(sqrt(9)+5^(1/3), 40);



página 14

Maple permite una gran libertad para definir nombres de variables. Se puede crear una nueva
variable en cualquier momento. A diferencia de C y d otros lenguajes, no se declaran previamente.
e
Tampoco tienen un tipo fijo: el tipo de una misma variable puede cambiar varias veces a lo largo de la
sesión. No existe límite práctico en el número de caracteres del nombre (sí que existe un límite, pero es del
orden de 500). En los nombres de las variables se distinguen las mayúsculas y las minúsculas. Dichos
nombres deben empezar siempre por una letra o un número, y pueden contener caracteres (_). También
puede ser un nombre de variable una cadena de caracteres encerrada entre comillas inversas (`comillas
inversas`), tal como se define en la siguiente sección.
2.4.2. Cadenas de caracteres
Las cadenas de caracteres van encerradas entre comillas inversas (acento grave francés). Véanse algunos
ejemplos:
> nombre := `Bill Clinton`;
> duda := `¿es más fácil segundo que primero?`;

Dentro de una cadena, una doble comilla inversa equivale a una única comilla inversa. Los caracteres
especiales que van dentro de una cadena no son evaluados por Maple.
2.4.3. Operador de concatenación (.)
Un punto separando dos nombres, o un nombre y número, actúa como operador de concatenación, esto
es, el resultado es un único nombre con el punto eliminado. Véanse algunos ejemplos:
> a.1, diga.33;

> fichero.doc; `fichero.doc`;

# ojo con los nombres de ficheros

Como se indica en el ejemplo anterior, este operador exige tomar precauciones especiales con los
nombres de ficheros que tienen extensión. Para evitar que elimine el punto, se deben poner entre comillas
inversas.
2.4.4. Constantes predefinidas
Maple dispone de una serie de constantes predefinidas, entre las que están el número Pi, la unidad
imaginaria I, los valores infinity y -infinity, y las constantes booleanas true y false.
2.4.5. Expresiones y ecuaciones
Una expresión en Maple es una combinación de números, variables y operadores. Los más importantes
operadores binarios de Maple son los siguientes:
+
*
/
^

suma
resta
producto
división
potencia

>
>=
=
<>
:=

mayor que
mayor o igual que
igual
no igual
operador de asignación



**
!
mod
<
<=

potencia
factorial
módulo
menor que
menor o igual que

página 15

and
or
union
intersect
minus

and lógico
or lógico
unión de conjuntos
intersección de conjuntos
diferencia de conjuntos

Las reglas de precedencia de estos operadores son similares a las de C. En caso de duda, es
conveniente poner paréntesis.
2.4.6. Secuencias
Maple tiene algunos tipos de datos compuestos o estructurados que no existen en otros lenguajes y a los
que hay que prestar especial atención. Entre estos tipos están las secuencias, los conjuntos y las listas.
Una secuencia es un conjunto de varias expresiones o datos de cualquier tipo separados por
comas. Por ejemplo, se puede crear una secuencia de palabras y números en la forma:
> sec0 := enero, febrero, marzo, 22, 33;

Las secuencias son muy importantes en Maple. Existen algunas formas o métodos especiales para
crear secuencias automáticamente. Por ejemplo, el operador dólar ($) crea una secuencia repitiendo un
nombre un número determinado de veces:
> sec1 := trabajo$5;

De modo complementario, el operador dos puntos seguidos (..) permite crear secuencias
especificando rangos de variación de variables. Por ejemplo:
> sec2 := $1..10;

> sec3 := 'i'^2$'i'=1..8;

donde es necesario poner los apóstrofos para evitar errores en el caso de que la variable i estuviese
evaluada a algo distinto de su propio nombre (es decir tuviera un valor numérico o simbólico previo).
Existe también una función llamada seq específicamente diseñada para crear secuencias. Véase el
siguiente ejemplo:
> sec4 := seq(i!/i^2,i=1..8);

Puede comprobarse que utilizando la función seq no hace falta poner apóstrofos en la variable i,
aunque esté evaluada a cualquier otra cosa.
¿Qué operaciones permite Maple hacer con secuencias? Al ser una clase de datos tan general, las
operaciones son por fuerza muy elementales. Una posibilidad es crear una secuencia concatenando otras
secuencias, como en el siguiente ejemplo:


página 16

> sec5 := sec0, sec1;

Maple permite acceder a los elementos de una secuencia por medio de los corchetes [ ], dentro de
los cuales se puede especificar un elemento (empezando a contar por 1, no por 0 como en C) o un rango
de elementos. Por ejemplo:
> sec5[3]; sec5[3..7];

Maple dispone de la función whattype que permite saber qué tipo de dato es la variable que se le
pasa como argumento. Pasándole una secuencia, la respuesta de esta función es exprseq.
2.4.7. Conjuntos (sets)
En Maple se llama conjunto o set a una colección no ordenada de expresiones diferentes. Para evitar
la ambigüedad de la palabra castellana conjunto, en lo sucesivo se utilizará la palabra inglesa set. La forma
de definir un set en Maple es mediante una secuencia encerrada entre llaves { }. Observe los siguientes
ejemplos:
> set1 := {1,3,2,1,5,2};

> set2 := {rojo,verde,azul};

Se puede observar que Maple elimina los elementos repetidos y cambia el orden dado por el usuario
(el programa ordena la salida con sus propios criterios). Un set de Maple es pues un tipo de datos en el
que no importa el orden y en el que no tiene sentido que haya elementos repetidos. Más adelante se verán
algunos ejemplos. Una vez que Maple ha establecido un orden de salida, utilizará siempre ese mismo
orden. Existen tres operadores que actúan sobre los sets: union, intersect y minus, que se corresponden
con las operaciones algebraicas de unión, intersección y diferencia de conjuntos. Observe la salida del
siguiente ejemplo:
> set3 := {rojo,verde,negro} union {amarillo,rojo,azul};

Al igual que con las secuencias, a los elementos de los sets se accede con el corchete [ ]. Existen
además otras funciones que actúan sobre sets (pero no sobre secuencias), como son la función op que
devuelve todos o algunos de los elementos del set, nops que devuelve el número de elementos. Véanse los
siguientes ejemplos:
> op(set3); op(5,set3); op(2..4, set3); nops(set3);



página 17

Hay que señalar que los datos devueltos por la función op son una secuencia. Si se pasa un set
como argumento a la función whattype la respuesta es set.
2.4.8. Listas (lists)
Una lista es un conjunto ordenado de expresiones o de datos contenido entre corchetes [ ]. En las
listas se respeta el orden definido por el usuario y puede haber elementos repetidos. En este sentido se
parecen más a las secuencias que a los sets. Los elementos de una lista pueden ser también listas y/o sets.
Observe lo que pasa al definir la siguiente lista de sets de letras:
> lista1 := [{p,e,r,r,o},{g,a,t,o},{p,a,j,a,r,o}];

Como se ha visto, a las secuencias, sets y listas se les puede asignar un nombre cualquiera, aunque
no es necesario hacerlo. Al igual que con las secuencias y sets, se puede acceder a un elemento particular
de una lista por medio del nombre seguido de un índice entre corchetes. También se pueden utilizar sobre
listas las funciones op y nops, de modo semejante que sobre los sets. La respuesta de la función whattype
cuando se le pasa una lista como argumento es list.
Los operadores union, intersect y minus no operan sobre listas. Tampoco se pueden utilizar
operadores de asignación o aritméticos pues pueden no tener sentido según el tipo de los elementos de la
lista.
Es muy importante distinguir, en los comandos de Maple que se verán más adelante, cuándo el
programa espera recibir una secuencia, un set o una lista. Algo análogo sucede con la salida del
comando.
La función type responde true o false según el tipo de la variable que se pasa como argumento
coincida o no con el nombre del tipo que se le pasa como segundo argumento. Por ejemplo:
> type(set1,`set`);

> type(lista1,`set`);

2.5.

FUNCIONES MEMBER, SORT, SUBSOP Y SUBS

La función member actúa sobre sets y listas, pero no sobre secuencias. Su objeto es averiguar si un
determinado dato o expresión pertenece a un set o a una lista y, en caso afirmativo, qué posición ocupa.
Esta función tiene tres argumentos: la expresión o dato, el set o la lista, y una variable no evaluada en la
que se pueda devolver la posición. Considérese el siguiente ejemplo:
> set3; member(verde,set3,'pos'); pos;

> member(blanco,set3,'pos');



página 18

La función sort se aplica a listas, no a secuencias o sets. Su objetivo es ordenar la lista de acuerdo
con un determinado criterio, normalmente alfabético o numérico (sort se aplica también a polinomios, y
entonces hay otros posibles criterios de ordenación). Por ejemplo, las siguientes sentencias convierten un
set en una lista (pasando por una secuencia, que es el resultado de la función op) y luego la ordenan
alfabéticamente:
> lista2 := [op(set3)];

> sort(lista2);

Un elemento de una lista no se puede cambiar por medio de un operador de asignación. Por
ejemplo, para cambiar “negro” por “blanco” en lista2 no se puede hacer:
> lista2[3] := blanco;

sino que hay que utilizar la función subsop que realiza la sustitución de un elemento por otro en la forma:
> subsop(3=blanco, lista2);

Si en vez de reemplazar por la posición se desea reemplazar por el propio valor, puede utilizarse la
función subs, como en el ejemplo siguiente:
> lista3 := [op(lista2),negro];

> subs(negro=blanco, lista3);

donde los dos elementos “negro” han sido sustituidos por “blanco”. Para más información sobre las
funciones introducidas en este apartado puede consultarse el Help.
2.6.

FUNCIONES CONVERT Y MAP

En muchas ocasiones hay que convertir datos de un tipo a otro tipo distinto. La función convert permite
convertir unos tipos de datos en otros, y en concreto permite realizar conversiones entre sets y listas.
Recuérdese que cualquier secuencia puede convertirse en un set encerrándola entre llaves { } o en una
lista encerrándola entre corchetes [ ]. Recíprocamente, cualquier set o lista se puede convertir en una
secuencia por medio de la función op.
Para convertir una lista en un set por medio de la función convert hay que hacer lo siguiente:
> convert(lista3, set);

mientras que convertir un set en una lista se puede hacer de la forma:
> set4 := set3 union {violeta,naranja,verde};



página 19

> convert(set4, list);

La función map permite aplicar una misma función a todos los elementos o expresiones de una lista
o conjunto. Por ejemplo, en el caso siguiente se crea una lista de dos funciones a las que luego se aplica la
función derivada diff mediante la función map. En este caso es necesario pasar como argumento adicional
la variable respecto a la que se quiere derivar, necesaria para aplicar la función diff.
> lista4 := [x^2-1, x^3+2*x^2+5];

> map(diff, lista4, x);

2.7.

VARIABLES EVALUADAS Y NO-EVALUADAS

Una de las características más importantes de Maple es la de poder trabajar con variables sin valor
numérico, o lo que es lo mismo, variables no-evaluadas. En MATLAB o en C una variable siempre
tiene un valor (o bien contiene basura informática, si no ha sido inicializada). En Maple una variable puede
ser simplemente una variable, sin ningún valor asignado, al igual que cuando una persona trabaja con
ecuaciones sobre una hoja de papel. Es con este tipo de variables con las que se trabaja en cálculo
simbólico. Suele decirse que estas variables se evalúan a su propio nombre. A continuación se verán
algunos ejemplos. En primer lugar se va a resolver una ecuación de segundo grado, en la cual ni los
coeficientes (a, b y c) ni la incógnita x tienen valor concreto asignado. A la función solve hay que
especificarle que la incógnita es x (también podrían ser a, b o c):
> solve(a*x**2 + b*x + c, x);

# a,b,c parámetros; x incógnita

La respuesta anterior se explica por sí misma: es una secuencia con l s dos soluciones de la
a
ecuación dada.
En Maple una variable puede tener asignado su propio nombre (es decir estar sin asignar o
unassigned), otro nombre diferente o un valor numérico. Considérese el siguiente ejemplo:
> polinomio := 9*x**3 - 37*x**2 + 47*x - 19;

Ahora se van a calcular las raíces de este polinomio, con su orden de multiplicidad correspondiente.
Obsérvense los resultados de los siguientes comandos con los comentarios incluidos con cada comando:
> roots(polinomio);

> factor(polinomio);

# cálculo de las raíces (una simple y otra doble)

# factorización del polinomio



> subs(x=19/9, polinomio);

> x; polinomio;

página 20

#comprobar la raíz simple

# no se ha hecho una asignación de x o polinomio

La función subs realiza una substitución de la variable x en polinomio, pero no asigna ese valor a la
variable x. La siguiente sentencia sí realiza esa asignación:
> x:= 19/9; polinomio; #ahora sí se hace una asignación a x y polinomio

Ahora la variable x tiene asignado un valor numérico. Véase el siguiente cambio de asignación a otro
nombre de variable:
> x:= variable; polinomio;

> variable := 10; x; polinomio; # cambio indirecto de asignación

Para que x vuelva a estar asignada a su propio nombre (en otras palabras, para que esté
desasignada) se le asigna su nombre entre apóstrofos:
> x := 'x'; polinomio; # para desasignar x dándole su propio nombre

Los apóstrofos 'x' hacen que x se evalúe a su propio nombre, suspendiendo la evaluación al valor
anterior que tenía asignado. La norma de Maple es que todas las variables se evalúan tanto o tan lejos
como sea posible, según se ha visto en el ejemplo anterior, en el que a x se le asignaba un 10 porque
estaba asignada a variable y a variable se le había dado un valor 10. Esta regla tiene algunas excepciones
como las siguientes:
–

Las expresiones entre apóstrofos no se evalúan.

–

El nombre a la izquierda del operador de asignación (:=) no se evalúa.

y por ello la expresión x := 'x'; hace que x se vuelva a evaluar a su propio nombre:
Otra forma de desasignar una variable es por medio la función evaln, como por ejemplo:
> x := 7; x := evaln(x); x;


página 21

La función evaln es especialmente adecuada para desasignar variables subindicadas a[i] o nombres
concatenados con números a.i. Considérese el siguiente ejemplo:
> i:=1; a[i]:=2; a.i:=3;

Supóngase que ahora se quiere desasignar la variable a[i],
> a[i] := 'a[i]'; # no es esto lo que se quiere hacer: i tiene que valer 1

> a[i] := evaln(a[i]); a[i]; # ahora si lo hace bien

> a.i; a.i:='a.i'; a.i := evaln(a.i); # con nombres concatenados

En Maple hay comandos o funciones para listar las variables asignadas y sin asignar, y para
chequear si una variable está asignada o no. Por ejemplo:
–

anames; muestra las variables asignadas (assigned names)

–

unames; muestra las variables sin asignar (unassigned names)

–

assigned; indica si una variable está asignada o no a algo diferente de su propio nombre

A los resultados de estas funciones se les pueden aplicar filtros, con objeto de obtener exactamente
lo que se busca. Observe que los comandos del ejemplo siguiente,
> unames(): nops({"}); # no imprimir la salida de unames()

permiten saber cuántas variables no asignadas hay. La salida de unames es una secuencia –puede ser
muy larga– que se puede convertir en set con las llaves {}. En el siguiente ejemplo se extraen por medio
de la función select los nombres de variable con un solo carácter:
> select(s->length(s)=1, {unames()}): # se omite el resultado

Como resultado de los siguientes comandos se imprimirían respectivamente todos los nombres de
variables y funciones asignados, y los que son de tipo entero,


página 22

> anames(); # se imprimen todas las funciones cargadas en esta sesión
> anames('integer');

El siguiente ejemplo (se omiten los resultados del programa) muestra cómo se puede saber si una
variable está asignada o no:
> x1; x2 := gato; assigned(x1); assigned(x2);

Otras dos excepciones a la regla de evaluación completa de variables son las siguientes:
–

el argumento de la función evaln no se evalúa (aunque esté asignado a otra variable, no se pasa
a la función evaluado a dicha variable).

–

el argumento de la función assigned no se evalúa.

Existen también las funciones assign y unassign. La primera de ellas, que tiene la forma
assign(name, expression); equivale a name := expression; excepto en que en el primer argumento de
assign la función se evalúa completamente (no ocurre así con el miembro izquierdo del operador de
asignación :=). Esto es importante, por ejemplo, en el caso de la función solve, que devuelve un conjunto
de soluciones que no se asignan. Por su parte, la función unassign puede desasignar varias variables a la
vez. Considérese el siguiente ejemplo, en el que se comienza definiendo un conjunto de ecuaciones y otro
de variables:
> ecs := {x + y = a, b*x -1/3*y = c}; variables := {x, y};

A continuación se resuelve el conjunto de ecuaciones respecto al de variables, para hallar un
conjunto de soluciones1:
> soluciones := solve(ecs, variables);

El resultado anterior no hace que se asignen las correspondientes expresiones a x e y. Para hacer
esta asignación hay que utilizar la función assign en la forma:
> x, y; assign(soluciones); x, y; # para que x e y se asignen realmente

> unassign('x', 'y'); x, y;

# si se desea desasignar x e y:

En Maple es muy importante el concepto de evaluación completa (full evaluation): Cuando
Maple encuentra un nombre de variable en una expresión, busca hacia donde apunta ese nombre, y así
sucesivamente hasta que llega a un nombre que apunta a sí mismo o a algo que no es un nombre de
variable, por ejemplo un valor numérico. Considérense los siguientes ejemplos:
1

Es lógico que tanto las ecuaciones como las variables sean sets o conjuntos, pues no es importante el orden, ni tiene
sentido que haya elementos repetidos.



página 23

> a:=b; b:=c; c:=3;

> a;

# a se evalúa hasta que se llega al valor de c, a través de b

La función eval permite controlar con su segundo argumento el nivel de evaluación de una variable:
> eval(a,1); eval(a,2); eval(a,3);

> c:=5: a;

# ahora, a se evalúa a 5

Muchas veces es necesario pasar algunos argumentos de una función entre apóstrofos, para evitar
una evaluación distinta de su propio nombre (a esto se le suele llamar evaluación prematura del nombre,
pues lo que se desea es que dicho nombre se evalúe dentro de la función, después de haber sido pasado
como argumento e independientemente del valor que tuviera asignado antes de la llamada). Por ejemplo, la
función que calcula el resto de la división entre polinomios devuelve el polinomio cociente como parámetro:
> x:='x': cociente := 0; rem(x**3+x+1, x**2+x+1, x, 'cociente'); cociente;

Si la variable cociente está desasignada, se puede utilizar sin apóstrofos en la llamada a la función.
Sin embargo, si estuviera previamente asignada, no funcionaría:
> cociente:=evaln(cociente):
> rem(x**3+x+1, x**2+x+1, x, cociente); cociente;

> cociente := 1; rem(x**3+x+1, x**2+x+1, x, cociente);
Error, (in rem) Illegal use of a formal parameter

Otro punto en el que la evaluación de las variables tiene importancia es en las variables internas de
los sumatorios. Si han sido asignadas previamente a algún valor puede haber problemas. Por ejemplo:
> i:=0: sum(ithprime(i), i=1..5);
Error, (in ithprime) argument must be a positive integer
> sum('ithprime(i)', i=1..5); # esto sólo no arregla el problema
Error, (in sum) summation variable previously assigned,
second argument evaluates to, 0 = 1 .. 5


página 24

> sum('ithprime(i)', 'i'=1..5); # ahora sí funciona

Considérese finalmente otro ejemplo de supresión de la evaluación de una expresión por medio de
los apóstrofos:
> x:=1; x+1;

> 'x'+1; 'x+1';

> '''x'+1''; "; "; "; # cada "último resultado" requiere una evaluación

3.

POLINOMIOS Y FRACCIONES RACIONALES

3.1.

POLINOMIOS DE UNA Y MÁS VARIABLES

3.1.1. Polinomios de una variable
Se llama forma canónica de un polinomio a la forma siguiente:
a n x n + a n−1 x n−1 +...+a 1 x + a 0
donde n es el grado, an el primer coeficiente y a0 el último.
Se llama forma agrupada (collected form) de un polinomio, a la forma en la que todos los
coeficientes de cada potencia de x están agrupados. Los términos no tienen por qué estar necesariamente
ordenados por grado descendente. Introduzca el siguiente ejemplo:
> p1 := -3*x + 7*x^2 -3*x^3 + 7*x^4;

Existen comandos para preguntar por el tipo de estructura, grado, etc. Ejecute los siguientes
comandos para preguntar si p1 es un polinomio, cuál es el último coeficiente y qué grado tiene dicho
polinomio:
> type( p1, 'polynom' );



página 25

> lcoeff(p1), degree(p1);

Se pueden realizar operaciones de suma y producto de polinomios como con cualquier otro tipo de
variables:
> p2 := 5*x^5 + 3*x^3 + x^2 -2*x + 1;

> 2*p1 + 4*p2 + 3;

> p1 * p2;

> expand(");

En el resultado anterior puede verse que Maple no ordena los términos de modo automático. Para
que lo haga, hay que utilizar el comando sort:
> sort(");

La función sort implica un cambio en la estructura interna del polinomio, más en concreto en la
llamada tabla de simplificación, que es una tabla de subexpresiones que Maple crea para almacenar
factores comunes, expresiones intermedias, etc., con objeto de ahorrar tiempo en los cálculos.
Considérense los ejemplos siguientes:
> p := 1 + x + x^3 + x^2;

> x^3 + x^2 + x + 1;

# términos desordenados

# los ordenará igual que en caso anterior

> q := (x - 1)*(x^3 + x^2 + x + 1);

Puede verse que en este último ejemplo Maple aprovecha la entrada anterior en la tabla de
simplificación. Si se ordena p el resultado afecta al segundo factor de q:
> sort(p);

> q;

# cambia el orden de p

# el orden del 2º factor de q ha cambiado también

Maple dispone de numerosas funciones para manipular polinomios. Para utilizar las funciones coeff y
degree, el polinomio debe estar en forma agrupada (collected form). A continuación se muestran
algunos otros ejemplos, sin mostrar los resultados:


>
>
>
>
>
>

página 26

'p1' = p1, 'p2' = p2;
coeff( p2, x^3 ); # para determinar el coeficiente de x^3 en p2
coeff( p2, x, 3 ); # equivalente a la anterior
lcoeff(p2), tcoeff(p2); # leading and trailing coefficients
coeffs(p2, x);
coeffs(p2, x, 'powers'); powers;

Una de las operaciones más importantes con polinomios es la división, es decir el cálculo del
cociente y del resto de la división. Para ello existen las funciones quo y rem:
> q := quo(p2, p1, x, 'r'); r;

> testeq(p2=expand(q*p1+r));

> rem(p2, p1, x, 'q'); q;

# comprobación del resultado anterior

# se calcula el resto y también el cociente

Para calcular el máximo común divisor de dos polinomios se utiliza la función gcd:
> gcd(p1, p2);

Finalmente, se puede añadir que la función factor factoriza los polinomios como producto de
factores irreducibles con coeficientes racionales:
> poli := expand(p1*p2);
> factor(poli);

3.1.2. Polinomios de varias variables
Maple trabaja también con gran facilidad con polinomios de varias variables. Por ejemplo, se va a definir
un polinomio llamado poli, en dos variables x e y:
> poli := 6*x*y^5 + 12*y^4 + 14*x^3*y^3 - 15*x^2*y^3 +
>
9*x^3*y^2 - 30*x*y^2 - 35*x^4*y + 18*y*x^2 + 21*x^5;

Se pueden ordenar los términos de forma alfabética (en inglés, pure lexicographic ordering):
> sort(poli, [x,y], 'plex');

o con la ordenación por defecto, que es según el grado de los términos:
> sort(poli);



página 27

Para ordenar según las potencias de x:
> collect(poli, x);

o según las potencias de y:
> collect(poli, y);

Otros ejemplos de manipulación de polinomios de dos variables son los siguientes (no se incluyen los
resultados):
> coeff(poli, x^3), coeff(poli, x, 3);
> coeffs(poli, x, 'powers'); powers;

3.2.

FUNCIONES RACIONALES

Las funciones racionales son funciones que se pueden expresar como cociente de dos polinomios, tales
que el denominador es distinto de cero. A continuación se van a definir dos polinomios f y g, y su cociente:
> f := x^2 + 3*x + 2; g := x^2 + 5*x + 6; f/g;

Para acceder al numerador y al denominador de una función racional existen los comandos numer y
denom:
> numer("), denom(");

Por defecto, Maple no simplifica las funciones racionales. Las simplificaciones sólo se llevan a
cabo cuando Maple reconoce factores comunes. Considérese el siguiente ejemplo:
> ff := (x-1)*f; gg := (x-1)^2*g;

> ff/gg;

Para simplificar al máximo y explícitamente, se utiliza la función normal:
> f/g, normal(f/g);


página 28

> ff/gg, normal(ff/gg);

Existen varios motivos para que las expresiones racionales no se simplifiquen automáticamente. En
primer lugar, porque los resultados no siempre son más simples; además, se gastaría mucho tiempo en
simplificar siempre, y finalmente, al usuario le puede interesar otra cosa, por ejemplo hacer una
descomposición en fracciones simples.
Puede haber también expresiones racionales en varias variables, por ejemplo (no se incluyen ya los
resultados):
>
>
>
>
>
>

3.3.

f := 161*y^3 + 333*x*y^2 + 184*y^2 + 162*x^2*y + 144*x*y
+ 77*y + 99*x + 88;
g := 49*y^2 + 28*x^2*y + 63*x*y +147*y + 36*x^3 + 32*x^2
+ 117*x + 104;
racexp := f/g;
normal(racexp);

TRANSFORMACIONES DE POLINOMIOS Y EXPRESIONES RACIONALES

A continuación se verá cómo se puede transformar un polinomio. En primer lugar se va a ver lo que se
puede hacer con la regla de Horner. Se utilizará un polinomio definido anteriormente:
> p1, readlib(cost)(p1);

# para evaluar el nº de operaciones aritméticas

> convert(p1, 'horner');

> cost(");

Las expresiones racionales se pueden transformar en fracciones continuas:
> fraccion := (x^3 + x^2 - x + 1)/p1;

> cost(fraccion);

> convert(fraccion, 'confrac', x);



página 29

> cost(");

También se puede realizar la transformación en fracciones parciales (no se incluyen los resultados):
> convert("", 'parfrac', x);
> convert(fraccion, 'parfrac', x);

Ahora, después de realizar la transformación, es mas fácil realizar ciertas operaciones matemáticas,
como por ejemplo la integración indefinida:
> integrate(", x);

# integrate es sinónimo de int

Un último ejemplo con más de una variable o constante indeterminada es el siguiente:
> ratfun := (x-a)/(x^5 + b*x^4 - c*x^2 - b*c*x);
> convert(ratfun, 'parfrac', x);

4.

ECUACIONES Y SISTEMAS DE ECUACIONES

4.1.

RESOLUCIÓN SIMBÓLICA DE ECUACIONES

Maple tiene la posibilidad de resolver ecuaciones con una sola incógnita, con varias incógnitas e incluso la
de resolver simbólicamente sistemas de ecuaciones. La solución de una ecuación simple es una expresión o
una secuencia de expresiones, y la solución a un sistema de ecuaciones es un sistema de expresiones con
las incógnitas despejadas.
Es posible controlar el número de soluciones (en el caso de soluciones múltiples), mediante el
parámetro _MaxSols. Por otra parte, si el comando de resolución espera que se le envíe una ecuación,
pero lo que se introduce es una expresión expr, Maple supone una ecuación en la forma expr=0.
Si Maple es incapaz de encontrar la solución o ésta no existe, se devuelve el valor NULL. Se
pueden asignar las soluciones a variables mediante el comandos de asignación assign.
A continuación se presentan algunos ejemplos de ecuaciones con su solución correspondiente:
> solve(cos(x) + y = 9, x); # despeja la variable x en función de y

> solve({cos(x) + y = 9}, {x}); x; # "sets" de ecuaciones e incógnitas



página 30

En el ejemplo anterior, se despeja la variable x en función de y, y -aparentemente- se asigna la
solución a la misma variable x. En realidad no se ha producido tal asignación, como se comprueba al
escribir la variable x. Para que se produzca la asignación a x hay que utilizar el operador assign:
> x:='x'; res:=solve({cos(x) + y = 9}, {x});

> assign(res): x;

Recuerde que las llaves indican conjuntos o sets de ecuaciones o de variables.
> solve(x^3 - 6*x^2 + 11*x - 6, x); # solución exacta

> restart; solve({x+y=1, 2*x+y=3}, {x,y}); # solución única

> solve({a*x^2*y^2, x-y-1}, {x,y}); # soluciones múltiples

> _MaxSols := 1:
> solve({a*x^2*y^2, x-y-1}, {x,y}); # encuentra una única solución

4.2.

RESOLUCIÓN NUMÉRICA.

En algunos casos puede interesar (o incluso no haber más remedio) resolver las ecuaciones o los sistemas
de ecuaciones numéricamente, desechando la posibilidad de hacerlo simbólicamente. Esto es posible con
la función fsolve. Esta función intenta encontrar una raíz real en una ecuación no lineal de tipo general, pero
en el caso de las ecuaciones polinómicas es capaz de encontrar todas las posibles soluciones. Si se desea
obtener también las raíces complejas, hay que utilizar el parámetro complex, como en el siguiente
ejemplo:
> fsolve(x^2+1, x, complex);

A continuación se pueden ver algunos ejemplos del uso y soluciones de esta función:
> fsolve(tan(sin(x))=1, x);



página 31

> poly := 23*x^5+105*x^4-10*x^2+17*x;

> fsolve(poly, x, -1..1); # halla las raíces en el intervalo dado.

> fsolve(poly, x, maxsols=3); # 3 soluciones

> q := 3*x^4-16*x^3-3*x^2+13*x+16;

> fsolve(q, x, complex); # halla todas las raíces

Considérese finalmente un ejemplo de sistema de ecuaciones no lineales:
> f := sin(x+y)-exp(x)*y = 0;

> g := x^2-y = 2;

> fsolve({f,g},{x,y},{x=-1..1, y=-2..0});

5.

PROBLEMAS DE CÁLCULO DIFERENCIAL E INTEGRAL

5.1.

CÁLCULO DE LÍMITES

Maple tiene la posibilidad de hallar límites de expresiones (o de funciones). El comando limit tiene 3
argumentos. El primer argumento es una expresión, el segundo es una variable igualada a un punto límite,
mientras que el tercer parámetro –que es opcional– es la dirección en la que se calcula el límite. Si no se
indica la direción, Maple calcula el límite bidireccional.
Si el límite en cuestión no existe Maple devuelve "
undefined" como respuesta; si existe pero no lo
puede calcular devuelve una forma no evaluada de la llamada al límite. En algunos casos, a pesar de no
existir el límite bidireccional en un punto dado, puede existir alguno de los límites direccionales en ese
punto. Utilizando el tercer argumento en la llamada a limit se pueden calcular estos límites direccionales.
Un ejemplo típico es la función tangente:
> limit(cos(x)/x, x=Pi/2);

# devuelve el límite cuando x tiende a Pi/2.

> limit((-x^2+x+1)/(x+4), x=infinity);

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



página 32

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

El tercer argumento también puede ser "complex" o "real", para indicar en cual de los dos planos se
quiere calcular el límite.
5.2.

DIFERENCIACIÓN DE EXPRESIONES

El comando diff ofrece la posibilidad de diferenciar una expresión respecto a una variable dada. El
primer argumento de esta función es la expresión que se quiere diferenciar y el segundo es la variable
respecto a la cual se diferencia. Debe darse al menos una variable de diferenciación y los parámetros
siguientes se entienden como parámetros de diferenciación de más alto nivel. Si la expresión que se va a
derivar contiene más de una variable, se pueden conseguir diferenciaciones parciales indicando
simplemente las correspondientes variables de diferenciación.
He aquí algunos ejemplos:
> diff(x^2, x); # se diferencia un función de una sola variable.

> diff(x^3, x, x); # se diferencia dos veces una función.

> diff(x^3*y^2, y); # diferenciación parcial de una función de 2 variables.

Para diferenciaciones de orden superior se puede utilizar el carácter de repetición $, tal como se
muestra en los siguientes ejemplos:
> diff(x^6/6!,x$6); # se diferencia 6 veces respecto de x.

> diff((s^3+2*s-5)/(t^2-3*t), s$2, t); # se diferencia 2 veces respecto de
s y una respecto de t.

La diferenciación parcial de funciones de varias variables puede hacerse del siguiente modo (hay
que incluir los argumentos a continuación del nombre de la función):
> F:=(x,y)->1+x^2-x*y^3;

> diff(F(x,y),x,y);



página 33

Es interesante conocer dos funciones estrechamente relacionadas con la anterior: Diff y D. La
función Diff es interesante a la hora de imprimir, ya que devuelve los signos de derivación y hace que la
presentación quede más elegante:
> Diff(ln(x),x)= diff(ln(x),x);

Por su parte, el operador D no necesita de variables respecto de las que derivar y por esa razón,
sólo puede aplicarse a funciones de una única variable (no se aplica ni a expresiones ni a funciones de más
de una variable).
> D(exp+ln+Pi+tan);

5.3.

INTEGRACIÓN DE EXPRESIONES

Maple realiza la integración definida y la indefinida con el comando int. En el caso de la integración
indefinida esta función necesita dos argumentos: una expresión y la variable de integración. Si se encuentra
respuesta, ésta es devuelta sin la constante de integración, con objeto de facilitar su uso en posteriores
cálculos. Análogamente a como sucedía en el caso de los límites, si Maple no puede integrar devuelve una
llamada sin evaluar.
Estos son algunos ejemplos de integración indefinida:
> int(2*x*exp(x^2), x);

> int(sin(y)*cos(y), y);

> int(1/exp(x^2)+x, x);

En el caso de que se desee realizar una integración definida es suficiente con definir un intervalo de
integración como segundo argumento del comando:
> int(1/x, x=2..4);

> int((1-x^2)^(172), x=0..1); # resultado exacto

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



página 34

En el caso de integrales definidas se puede añadir una opción "
continous" para forzar a Maple a
ignorar las posibles discontinuidades que se presenten en el intervalo. A diferencia del comando diff, ahora
no se pueden añadir variables extras al final de la instrucción para indicar integración múltiple. Una manera
de intentarlo, aunque el éxito no esté garantizado, es encerrar unas integraciones dentro de otras:
> int(int((x^2*y^3),x),y); # integra respecto de x y luego respecto de y.

> int(int(int(x^2*y^2*z^2, x=1..2), y=1..2), z=1..2); # realiza la integral
definida respecto de las tres variables

5.4.

DESARROLLOS EN SERIE

La función taylor permite calcular el desarrollo en serie de una función en un punto determinado y con una
precisión también determinada. La forma general de esta función es la siguiente:
> taylor(expresion, variable=punto, n);

donde punto es el valor de la variable en el que se hace el desarrollo en serie, y n es el grado hasta el que
se desea calcular los términos.
Considérese un ejemplo de cómo se usa esta función:
> taylor(1/x, x=1, 7);

El resultado del desarrollo en serie puede convertirse en polinomio con la función convert. A
continuación se presenta un nuevo ejemplo:
> p := taylor(sin(x), x, 9);

> p := convert(p, polynom);

5.5.

INTEGRACIÓN DE ECUACIONES DIFERENCIALES ORDINARIAS

Maple permite resolver ecuaciones diferenciales ordinarias con el comando dsolve. La forma de utilizar
este comando es la siguiente:
> dsolve(ecuacion, variable, opciones);

Una de las claves de la utilización de este comando es la forma en la que se escribe la ecuación
diferencial. Considérese la siguiente ecuación diferencial:
y ′ (x ) = a * y (x )
Con Maple, esta ecuación diferencial se escribe del siguiente modo:


página 35

> restart; ec := diff(y(x), x)= a*y(x);

Ahora se puede llamar a la función dsolve de la siguiente forma:
> dsolve(ec, y(x));

La constante de integración debe ser calculada en función de las condiciones iniciales. Éstas pueden
ser incluidas en la función dsolve entre llaves { }, en la forma:
> dsolve({ec, y(0)=1}, y(x));

Para más información sobre este importante tema consultar el Help de Maple, o mejor aún, un libro
especializado.

6.

OPERACIONES CON EXPRESIONES

Maple dispone de muchas herramientas para modificar o, en general, para manipular expresiones
matemáticas. Al intentar simplificar o, simplemente, modificar una expresión existen dos opciones: la
primera es modificar la expresión como un todo y otra es intentar modificar ciertas partes de la expresión.
A las primeras se les podría denominar simplificaciones y a las segundas manipulaciones. Se
comenzará por las primeras.
Los procedimientos de simplificación afectan de manera distinta a las expresiones dependiendo de si
las partes constitutivas de la expresión a modificar son trigonométricas, exponenciales, logarítmicas,
potencias, etc.
Es muy importante tener en cuenta que no todas las simplificaciones que Maple realiza
automáticamente son del todo correctas. Considérese el siguiente ejemplo:
> sum(a[k]*x^k, k=0..10);

> eval(subs(x=0, "));

El resultado que da Maple es aparentemente correcto, pero esto es debido a que ha tomado 00 = 0
y esto no es del todo cierto. Teniendo esto en cuenta (que no siempre se cumple que 0*x = 0 o que x-x
=0), se verán a continuación algunas formas de simplificar expresiones.



6.1.

página 36

SIMPLIFICACIÓN DE EXPRESIONES

6.1.1. Función expand
En general, el comando expand hace honor a su nombre y expande la función a la forma de suma o
producto de otras funciones más sencillas.
> cos(2*x): " = expand("); # expansión de una función trigonométrica

> cos(x*(y+z)) : " = expand ("); # expansión de una función más complicada

> ln(x/y): " = expand (");

# expansión de una función logarítmica

> (x^y)^z: " = expand ("); # expansión de una potencia

> (n+1)!: " = expand ("); # expansión de un factorial

También se pueden expandir expresiones de un modo parcial, dando como argumento la parte de la
expresión que no se quiere expandir. Observe la diferencia que hay entre los resultados de la función
expand en el siguiente ejemplo:
> expresion := sin(x+y) + exp(x+y);

> expand(expresion), expand(expresion, sin);

6.1.2. Función combine
Es el comando que realiza la tarea inversa a la que hace expand. La función combine combina varias
expresiones para conseguir una más compacta o reducida. Al utilizar combine es necesario indicar como
argumento qué tipo de elementos son los que se desean combinar, para que Maple tenga en cuenta las
reglas apropiadas en cada caso. Los posibles tipos de combinación son: trig, exp, ln, power, y Psi
(función poligamma ¡sin acento!). Las reglas de combinación que se aplican en cada caso son las
siguientes:
trig:
sin x sin y = 1/2 cos(x-y)-1/2 cos(x+y)
sin x cos y = 1/2 sin(x-y)+1/2 sin(x+y)
cos x cos y = 1/2 cos(x-y)+1/2 cos(x+y)

exp, ln:
exp x exp y = exp (x+y);
exp (x + ln y) = yn exp(x), para n ∈ Z


página 37

(exp x)y = exp (x*y)
a ln x = ln(xa)
ln x + ln y = ln (x*y)

powers:
x^y = xy+z
(xy)z = xyz

A continuación se presentan algunos ejemplos de aplicación práctica de la función combine:
> ln(x)-ln(y): " = combine(", 'ln');

> sin(x)^2: " = combine(", 'trig');

> x^y/x^(2/3): " = combine(", 'power');

6.1.3. Función simplify
Es el comando general de simplificación de Maple. En el caso de las funciones trigonométricas tiene unas
reglas propias, pero para funciones exponenciales, logarítmicas y potencias produce los mismos
resultados que la función expand en casi todos los casos:
> sinh(x)^3: " = simplify(");

> (-x)^y: " = simplify(");

> exp(x)*exp(y)+cos(x)^2+sin(x)^2: " = simplify(");

6.2.

M ANIPULACIÓN DE EXPRESIONES

Se verán ahora los comandos que al principio de la sección se denominaban manipulaciones.
6.2.1. Función normal
El comando normal permite simplificar numerador y denominador de expresiones algebraicas, hasta lo
que se denominan formas normales factorizadas, que son polinomios primos (indivisibles) con
coeficientes enteros.
> normal((x^2-y^2)/(x-y)^3);



página 38

> normal((ft(x)^2-1)/(ft(x)-1));

6.2.2. Función factor
Este comando permite descomponer un polinomio en factores. Observe los siguientes ejemplos:
> p := x^5-3*x^4-x^3+3*x^2-2^x+6;

> factor(p); # no consigue hacer nada

> factor((x^3-y^3)/(x^4-y^4));

También puede descomponerse en factores un número entero o racional, mediante el comando
ifactor:
> ifactor(90288);

> ifactor(324/952);

6.2.3. Función convert
Se puede descomponer una fracción algebraica en fracciones simples con el comando convert. Éste
comando necesita 3 argumentos: el primero es la fracción a descomponer, el segundo indica el tipo de
descomposición y el tercero corresponde a la variable respecto de la cual se realiza la descomposición. El
segundo argumento puede tomar los siguientes valores:
`+`

`*`

D

array

base

binary

confrac

decimal

degrees

diff

double

eqnlist

equality

exp

expln

expsincos

factorial

float

fraction

GAMMA

hex

horner

hostfile

hypergeom

lessthan

lessequal

list

listlist

ln

matrix

metric

mod2

multiset

name

octal

parfrac

polar

polynom

radians

radical

rational

ratpoly

RootOf

series

set

sincos

sqrfree

tan



trig

página 39

vector

Considérese el ejemplo siguiente:
> (x^2-x-3)/(x^3-x^2): convert(", parfrac, x);

Esta función, que se utiliza para transformar desarrollos en serie en funciones polinómicas o de otro
tipo, también sirve para convertir funciones trigonométricas o hiperbólicas a formas diversas:
> cos(x): " = convert(", exp); # tercer argumento opcional

> sinh(x): " = convert(", exp);

6.2.4. Función sort
El comando sort se utiliza para ordenar los términos de un polinomio dependiendo del exponente de las
variables de mayor a menor. Si no se le indica lo contrario, Maple realiza la suma de exponentes antes de
la ordenación.
> p := y^3+y^2*x^2+x^3+x^5;

> sort(p, [x,y]); # ordena según la suma de exponentes

> sort(p, y); # ordena según el exponente de y

> sort(p,[x,y], plex); # ordena alfabéticamente

7.

FUNCIONES DE ÁLGEBRA LINEAL

7.1.

LIBRERÍA LINALG

Casi todas las funciones de Álgebra Lineal están en una librería que se llama linalg. Si se intenta utilizar
alguna función de esta librería sin cargarla previamente, Maple se limita a repetir el nombre de la función sin
realizar ningún cálculo.
Para cargar todas las funciones de esta librería, se teclea el comando siguiente (si se pone : se evitará
ver una nutrida lista de funciones):


página 40

> with(linalg);

Algunos de esos nombres resultan familiares (como inverse, det, etc.) y otros no tanto. En cualquier
caso, poniendo el cursor sobre uno cualquiera de esos nombres, en el menú Help se tiene a disposición un
comando para obtener información sobre esa función concreta. Además, con el comando:
> ?linalg;

se obtiene información general sobre linalg. Para obtener información sobre una función particular:
> ?function_name;

Si sólo se desea utilizar una función concreta de toda la librería linalg, se la puede llamar sin cargar
toda la librería, dando al programa las "pistas" para encontrarla. Esto se hace con el comando siguiente:
> linalg[funcion](argumentos);

Por ejemplo, para calcular el determinante de una matriz A, basta teclear:
> linalg[det](A);

7.2.

VECTORES Y MATRICES

Es importante tener en cuenta que todos los argumentos (de datos, numéricos y/o simbólicos) de las
funciones de linalg deben ser matrices y/o vectores. Se pueden también utilizar arrays definidos de la
forma habitual, por medio de listas. Téngase en cuenta que los arrays son una estructura de datos algo
más general que los vectores y matrices, pues pueden tener subíndices negativos. Para que un array sea
equivalente a una matriz, los índices tienen que empezar en uno. Véase un ejemplo de array, en el que se
ve que los elementos de la matriz se forman a partir de listas de números:
> A := array([[1,2,3],[4,5,6],[7,8,9]]);

Es posible también definir una matriz o array sin asignar ningún valor a sus elementos, o asignando
sólo algunos elementos (esto se hace incluyendo los índices entre paréntesis, como se muestra a
continuación en la matriz C):
> B:=array(1..2, 1..3); C:=array(1..2,1..2,[(1,1)=s,(2,1)=3]);



página 41

Se puede acceder a los elementos de un array con sus índices de fila y columna separados por una
coma, y encerrados entre corchetes. Por ejemplo:
> B[1,2]:=1; B[2,1]:=0;

Ahora se puede tratar de ver los elementos de la matriz B. Obsérvese la salida de los siguientes
comandos:
> B; print(B); evalm(B);

Se puede ver que el nombre de las matrices (y de los vectores) no siguen las reglas normales en
Maple. El nombre de una matriz se evalúa a sí mismo, y no a sus elementos. Para ver los elementos de la
matriz se puede recurrir a las funciones print y evalm. Aunque en este caso el resultado haya sido el
mismo, dichas funciones son diferentes. Como se verá más adelante, la función evalm tiene una gran
importancia en cálculo matricial.
Las reglas para definir vectores en Maple son similares a las de las matrices, pero teniendo en
cuenta que hay un solo subíndice. El siguiente ejemplo forma un vector a partir de una lista de tres valores:
> u:= array([1,2,3]);

> v:= array(1..5);

En Maple los vectores fila son arrays de 1 fila y n columnas, mientras que los vectores columna
son arrays de n filas y 1 columna. Esto debe ser tenido en cuenta a la hora de ciertas operaciones
vectoriales y matriciales.
Los arrays de una o dos dimensiones constituyen una forma general de definir vectores y matrices.
Sin embargo, en la librería linalg existen unas funciones llamadas vector y matrix que son algo más
sencillas de utilizar con dicha finalidad, como se ve por ejemplo en los casos siguientes:
> a:=vector([5,4,6,3]);

> V:=matrix(2, 3, [1, 2, 3, 4, 5, 6]); # una unica lista de valores



página 42

Los vectores definidos con la función vector son siempre vectores columna, y lo mismo sucede
con los arrays de una sola dimensión. Obsérvese la salida de los siguientes comandos:
> vcol:=array(1..3,[1,2,3]); type(vcol,'vector'); type(vcol,'matrix');

Los vectores definidos con la función matrix pueden ser vectores fila (si son 1xn) y vectores
columna (si son nx1). Obsérvense los siguientes ejemplos, de los que se saca la conclusión de que sólo
los vectores columna son verdaderos vectores. Los vectores fila son matrices particulares.
> vfil:=matrix(1,3,[1, 2, 3]); type(vfil, 'matrix'), type(vfil, 'vector');

> vcol:=matrix(3,1,[1, 2, 3]); type(vcol, 'matrix'), type(vcol, 'vector');

> vcol2:=vector([1, 2, 3]); type(vcol2, 'matrix'), type(vcol2, 'vector');

Los elementos de los vectores y matrices se pueden definir también por medio de una función de
los índices de fila y/o columna. Véase el siguiente ejemplo:
> f := i -> i^2; v := vector(4,f);

Así pues, la función vector(n,f) produce un vector cuyos n elementos son el resultado de aplicar la
función f al índice del vector. Dicho de otra forma, la función vector(n,f) define el vector [f(1), f(2), ...,
f(n)].
Los elementos de las matrices pueden definirse por medio de una función en la llamada a matrix:
> f := (i,j) -> x^(i+j-1); A := matrix(2,2,f);



página 43

Otra forma de definir matrices es por medio de la función entermatrix, que pregunta al usuario por
el valor de los elementos de una matriz cuyo tamaño ha sido previamente definido:
> B:=array(1..2,1..2): # definición de una matriz (2x2) vacía
> entermatrix(B);
Note: each matrix entry entered MUST BE FOLLOWED BY A SEMICOLON
enter element 1,1 > 10;

La función entermatrix se puede utilizar también para modificar el valor de algunos elementos de
una matriz, o para especificar ciertas propiedades de la matriz (
simétrica, antisimétrica, etc.). Para
obtener más información sobre esta función teclee ?entermatrix.
7.3.

FUNCIÓN EVALM Y OPERADOR MATRICIAL &*

No se puede operar con matrices y vectores como con variables escalares. Por ejemplo, considérense las
matrices siguientes:
> A:=matrix(2,2,[x,y,z,t]): B:=matrix(2,2,[1,2,3,4]):
> A+B, A*B, A&*B; evalm(A+B), evalm(A&*B);

Lo primero que se observa en estos ejemplos es que los operadores normales no actúan
correctamente cuando los operandos son matrices (o vectores). Algunos operadores -como como los de
suma (*) o resta(-)- actúan correctamente como argumentos de la función evalm.
El operador producto (*) no actúa correctamente sobre matrices, ni siquiera dentro de evalm.
Maple dispone de un operador producto -no conmutativo, y que tiene en cuenta los tamaños- especial
para matrices: es el operador &*. El ejemplo anterior muestra que este operador, en conjunción con
evalm, calcula correctamente el producto de matrices. También se emplea este operador en el producto
de matrices por vectores. En la ventana de la función evalm puede ponerse cualquier expresión matricial.
La función evalm permite mexclar en una expresión matrices y escalares. En Maple el producto de
una matriz por un escalar se realiza mediante el producto de cada elemento de la matriz por el escalar. Por
el contrario, la suma o resta de una matriz y un escalar se realiza sumando o restando ese escalar a los
elementos de la diagonal (aunque la matriz no sea cuadrada).
7.4.

INVERSA Y POTENCIAS DE UNA MATRIZ

Una matriz puede ser elevada a una potencia entera –positiva o negativa– con el operador (^), al igual que
las variables escalares. Por supuesto, debe aplicarse a través de la función evalm. Por otra parte, la
matriz inversa es un caso particular de una matriz elevada a (-1). Considérese el siguiente ejemplo:
> A:=matrix(2,2,[x,y,z,t]); A2:=evalm(A^2); AINV:=evalm(A^(-1));



7.5.

página 44

COPIA DE MATRICES

Tampoco las matrices y vectores se pueden copiar como las variables ordinarias de Maple. Obsérvese lo
que sucede con el siguiente ejemplo:
> A:=matrix(2,2,[x,y,z,t]): B:=A; print(B);

Aparentemente todo ha sucedido como se esperaba. Sin embargo, la matriz B no es una copia de
A, sino un "alias", es decir, un nombre distinto para referirse a la misma matriz. Para comprobarlo, basta
modificar un elemento de B e imprimir A:
> B[1,1]:=0; evalm(B), evalm(A);

Si se quiere sacar una verdadera copia de la matriz A hay que utilizar la función copy, en la forma:
> B := copy(A);

Es fácil comprobar que si se modifica ahora esta matriz B, la matriz A no queda modificada.
7.6.

FUNCIONES BÁSICAS DE ÁLGEBRA LINEAL.

A continuación se describen algunas de las funciones más importantes de la librería linalg. Esta librería
dispone de un gran número de funciones para operar con matrices, algunas de las cuáles se describen a
continuación. Además, existen otras funciones para casi cualquier operación que se pueda pensar sobre
matrices y vectores: extraer submatrices y subvectores, eliminar o añadir filas y columnas, etc.
7.6.1. Función add
Esta función permite sumar matrices de las mismas dimensiones (no se pueden sumar con el operador +).
Las matrices pueden también estar multiplicadas por sendos valores escalares, que se dan como
parámetros adicionales de la función. Defina las matrices A y B (si no lo están) e introduzca el siguiente
ejemplo:
> A:= array([[1,2,3],[2,3,4],[3,4,5]]):


página 45

> B:= array([[1,0,0],[0,1,0],[0,0,1]]):
> add(A, B);

Para calcular la suma de 3*A y 4*B, hay que utilizar el comando add en la forma siguiente:
> add(A, B, 3, 4):

Como último ejemplo de esta función, teclee las líneas siguientes:
> add(A, B, 1, 10);

7.6.2. Función charmat
Esta función permite construir la matriz característica de la matriz A (es decir, lambda*I–A, siendo I la
matriz identidad). Por ejemplo, teclee los comandos siguientes y observe la respuesta de Maple:
> charmat(A, lambda); charmat(A, x);

7.6.3. Función charpoly
Esta función calcula el polinomio característico de la matriz A (es decir, (-1)^n*det(A-lambda*I), donde
I es la matriz identidad y n es la dimensión de A). Considérese el siguiente ejemplo:
> X := array([[1,2,3],[1,2,3],[1,5,6]]);

> eqn:=charpoly(X, y); # se utiliza y como variable

Ahora se podría utilizar la función solve para calcular los valores propios de la matriz.
7.6.4. Funciones colspace y rowspace
Estas funciones calculan, respectivamente, una base del subespacio de columnas y de filas de la matriz, que
es pasada como argumento. Los elementos de la matriz tienen que estar definidos numéricamente. Véase
un ejemplo y la respuesta que da Maple:


página 46

> C := array([[1,2,3],[2,3,4],[3,4,5]]);

> colspace(C), rowspace(C);

7.6.5. Función crossprod
Esta función calcula el producto vectorial de dos vectores:
> crossprod(u,v):

7.6.6. Función det
Esta función calcula el determinante de una matriz definida de forma numérica o simbólica. Se utiliza en la
forma siguiente:
> det(A):

7.6.7. Función dotprod
Esta función calcula el producto escalar de dos vectores, que pueden ser reales o complejos. Se utiliza en
la forma siguiente:
> dotprod(u,v):

7.6.8. Función eigenvals
Esta función calcula los valores propios de una matriz cuadrada, calculando las raíces del polinomio
característico det(A–lambda*I)=0. Por ejemplo, con la matriz A definida anteriormente:
> eigenvals(A);

Si la dimensión de la matriz es mayor que 4, Maple puede no ser capaz de calcular los valores
propios simbólicamente. Sin embargo, siempre se pueden intentar calcular de modo numérico mediante la
función evalf(eigenvals(A)), que utiliza un algoritmo numérico más general.
7.6.9. Función eigenvects
Esta función calcula los vectores propios resolviendo el sistema de ecuaciones lineales:
(A-lambda*I)*c = 0

en el que Maple calcula el vector c para cada valor propio de A. Por cada valor propio se devuelve un
conjunto de la forma siguiente:
{valor propio, multiplicidad, vectores propios, ...}
donde multiplicidad puede estar o no estar presente. (Para más información teclear ?eigenvects).
Considérese a continuación el siguiente ejemplo:


página 47

> mat:= array([[1,-3,3], [3,-5,3], [6,-6,4]]):
> eigenvects(mat);

7.6.10. Función gausselim
Esta función realiza la triangularización de una matriz m por n con pivotamiento por filas. El resultado es
una matriz triangular superior:
> A1:= array([[x,1,0],[0,0,1],[1,y,1]]);

> gausselim(A1);

7.6.11. Función inverse
Esta función invierte una matriz cuadrada. Si la inversa no existe, se imprime un mensaje de error. Su forma
es la siguiente:
> inverse(A);

7.6.12. Función iszero
La función iszero(A) comprueba que todos los elementos de A son cero. Si es así, el resultado es true y
en caso contrario false.
7.6.13. Función linsolve
Esta función sirve para resolver sistemas de ecuaciones lineales, con una matriz que puede ser
rectangular. Se llama de la forma siguiente:
> linsolve(A, b);

donde A es una matriz mxn y b un vector de m elementos. Si no existe solución, Maple devuelve un
NULL. Si hay muchas soluciones, se imprimen de forma paramétrica utilizando los parámetros t1, t2, t3,
etc.
Si b es también una matriz, se supone que se trata de un sistema de ecuaciones con varios segundos
miembros.
7.6.14. Función multiply
Sirve para multiplicar varias matrices y vectores (en el orden en que aparecen como argumentos). Las
dimensiones tienen que ser coherentes. Veamos un ejemplo:
> A2:= array([[1,2],[3,4]]):


página 48

> B2:= array([[0,1],[1,0]]):
> C2:= array([[1,2],[4,5]]):
> multiply(A2,B2,C2);

7.6.15. Función randmatrix
Esta función genera una matriz de números aleatorios entre -99 y +99. Por ejemplo, la sentencia:
> randmatrix(4,5);

genera una matriz de tamaño (4x5).

8.

GRÁFICOS EN 2 Y 3 DIMENSIONES

La visualización de resultados es una de las capacidades más utilizadas del álgebra computacional. Poder
ver en gráficos los resultados de expresiones de una o dos variables ayuda mucho a entender los
resultados. Para ver estos gráficos, Maple dispone de una gran variedad de comandos.
El concepto básico de todo comando gráfico de Maple es representar una expresión de una o
dos variables en un determinado rango de éstas. Maple abre una nueva ventana gráfica por cada comando
de dibujo, por lo que es muy conveniente ir cerrando las ventanas gráficas a medida que se van viendo,
para no cargar excesivamente la memoria del ordenador.
8.1.

GRÁFICOS BIDIMENSIONALES

8.1.1. Expresiones de una variable
Las expresiones de una sola variable se pueden
representar mediante el comando plot. Para
poder visualizar una función en la forma más
sencilla, es suficiente con informar a plot de la
expresión de la función y del rango de la variable
independiente que se quiere representar. He aquí
un primer ejemplo, cuyo resultado se puede ver
en la figura 6:
> plot(x^2-3, x=-4..4);

Las ventanas gráficas de Maple permiten
Figura 6. Representación de una función parabólica.
modificar algunas de las características del dibujo
sin más que clicar en alguno de sus botones. Por ejemplo, puede hacerse que la función aparezca
representada con trazo continuo o por medio puntos, se pueden dibujar ejes de distinto tipo, y se puede
obligar a que la escala sea la misma en ambos ejes. Clicando sin soltar el botón izquierdo del ratón sobre
cualquiera de los botones de la ventana gráfica, aparece en la barra inferior una corta descripción de la
función del botón correspondiente. En general, las ventanas gráficas de Maple son muy fáciles de manejar.
El ejemplo anterior puede resolverse también de otra forma, definiendo una función y utilizándola en
plot en vez de la expresión anterior. Esto se haría en la forma (obsérvese que en esta caso no hace falta
poner la variable x, ni en la función ni en la definición del rango):
> f:=(x)->x^2-3; plot(f, -4..4);


página 49

Un segundo ejemplo (ya no se incluye la figura) puede ser el siguiente:
> plot(x*sin(x), x=-3*Pi..3*Pi);

Existe la posibilidad de imprimir varias funciones con un solo comando, en una misma ventana y
con unos mismos ejes, de las dos formas que se indican a continuación (atención a las llaves { }, que
indican conjuntos o sets y que contienen todas las expresiones que se van a dibujar):
> plot({x^2, exp(x), x}, x=0..3, y=0..10); # tres funciones
> plot({seq(cos(x*i), i=-1..4)}, x=-Pi..Pi); # cuatro funciones

8.1.2. Funciones paramétricas
Se pueden representar también funciones paramétricas (dos ecuaciones, función de un mismo
parámetro) definiéndolas en forma de lista (atención a los corchetes [ ], que engloban tanto a las
expresiones como al parámetro y su rango de valores):
> plot([sin(t), cos(t), t=0..2*Pi]);

# circunferencia

8.1.3. Dibujo de líneas poligonales
Se pueden dibujar asimismo líneas poligonales, es decir, conjuntos de puntos unidos por líneas rectas, de
la siguiente manera: las dos coordenadas de cada punto se indican de forma consecutiva (en forma de
lista), y los puntos correspondientes aparecen unidos por una línea poligonal. De modo opcional se puede
indicar también el rango de x e/o y en los ejes de coordenadas. Obsérvese el siguiente ejemplo, en el que
se dibuja un cuadrilátero:
> plot([1, 1, 2, 4, 8, 5, 9, 0, 1, 1], x=0..10, y=0..6);

8.1.4. Otras funciones de la librería plots
La librería plots contiene funciones para realizar otros gráficos que no son tan habituales como los
anteriores. Aunque no sea necesario probar todas, sí se recomienda intentar utilizar algunas capacidades
más de las que aquí se han explicado. Para ello se puede recurrir al help tecleando ?plots[nombre de la
función que interese]. La lista completa de funciones es la siguiente (se incluyen tanto gráficos planos
como tridimensionales):
animate

animate3d

conformal

contourplot

cylinderplot

densityplot

display

display3d

fieldplot

fieldplot3d

gradplot

gradplot3d

implicitplot

implicitplot3d

loglogplot

logplot

matrixplo

odeplot

pointplot

polarplot

polygonplot

polygonplot3d

polyhedraplot

replot

setoptions

setoptions3d

spacecurve

sparsematrixplot

sphereplot

surfdata

textplot

textplot3d

tubeplot

Se pueden cargar todas estas funciones de una vez con el comando:
> with(plots);

o bien se puede utilizar (es decir, ejecutar) cada una de estas funciones por separado (sin cargarlas todas)
en la forma:


página 50

> plots[nombre_funcion](argumentos);

A continuación se incluyen algunos ejemplos de los usos y utilidades de algunas de las funciones de
la lista anterior. Recuerde que las coordenadas polares son aquellas que definen un punto mediante su
distancia r al origen de los ejes de coordenadas, y el ángulo ϕ entre la línea que une el punto con dicho
origen y la horizontal. En el siguiente ejemplo (en coordenadas polares) se representa, para cada ángulo,
un radio de longitud doble al valor del ángulo en radianes:
> plots[polarplot](2*t);

donde se supone que t es el ángulo, que por defecto varía entre -π y π. Se pueden dibujar también curvas
polares paramétricas, con el radio, el ángulo y el parámetro encerrados entre corchetes, en forma de
lista, como en el siguiente ejemplo:
> polarplot([cos(t),sin(t),t=0..4*Pi],color=blue);

Para imprimir un campo vectorial hay que hacer lo siguiente:
> plots[fieldplot]([sin(y), cos(x)], x=-10..10, y=-10..10, arrows=SLIM);

donde se han representado del orden de 400 vectores. La primera componente de cada uno de ellos es el
seno de su coordenada y (en radianes) y su componente en y es el coseno de su coordenada x.
También se pueden representar funciones implícitas, esto es, expresiones en las que ninguna de sus
variables está despejada. Obsérvese como se dibuja una elipse:
> implicitplot(x^2/25+y^2/9=1,x=-6..6,y=-6..6, scaling=CONSTRAINED);

8.1.5. Colores y otras opciones de plot
Además de las opciones hasta ahora mencionadas, en las gráficas de Maple se pueden controlar otros
aspectos para ajustar las salidas a las necesidades reales de cada momento. Por ejemplo, estos son los
colores predefinidos de Maple, aunque el usuario tiene completa libertad para crear los nuevos colores
que desee (Para ello, usar el help tecleando ?color)
aquamarine

black

blue

navy

coral

cyanbrown

gold

green

gray

grey

khaki

magenta

maroon

orange

pink

plum

red

sienna

tan

turquoise

violet

wheat

white

yellow

Con la opción style se decide si en la gráfica van a aparecer sólo puntos (opción POINT) o si éstos
van a ir unidos mediante líneas (opción LINE). En el caso de los polígonos, se puede hacer que el interior
de ellos aparezca coloreado con la opción PATCH.
Para añadir títulos a las gráficas existe la opción title. Se puede determinar el tipo de ejes con la
opción axes. Los posibles valores de esta última son: FRAME, BOXED, NORMAL y NONE. Se
pueden probar estas opciones para establecer las diferencias entre todas ellas.
La opción scaling puede tener los valores CONSTRAINED y UNCONSTRAINED; esta última
opción es la que toma por defecto. Indica si la escala es la misma en ambos ejes o si es diferente.
Seguidamente se proponen dos ejemplos para practicar con estas opciones:
> plot([sin(2*x), cos(x), x=0..2*Pi], color=Blue, title='Azul');
> plot(x^3+2*x^2-3*x-1, x=-3..3, axes =FRAME, style=POINT);


8.2.

página 51

GRÁFICOS TRIDIMENSIONALES

Los gráficos tridimensionales no presentan grandes diferencias respecto a los bidimensionales, aunque son
más “aparentes” y disponen de un tipo especial de ventanas. Al existir, en este caso; dos variables
independientes, hay que indicar a la función gráfica plot3d el rango de ambas variables:
> plot3d((x^2-y^2)/(x^2+y^2), x=-2..2, y=-3..3);
> plot3d(exp(x+y), x=-0..2, y= -2..2);

También se pueden dibujar con Maple funciones propiamente dichas (en lugar de expresiones), y en
ese caso no es necesario poner las variables en la función y en los rangos). Por ejemplo, la primera de las
funciones anteriores se puede dibujar también en la forma:
> f3 := (x,y)->(x^2-y^2)/(x^2+y^2); plot3d(f3, -2..2, -3..3);

8.2.1. Ventanas 3-D
En la figura 7 aparece el resultado del comando
anterior. Las ventana 3-D tienen sus propios
botones, diferentes de los vistos en los gráficos
planos.
En primer lugar aparecen, de izquierda a
derecha, 2 botones para imprimir la figura o
copiar su contenido. Después aparecen 7
botones que permiten controlar cómo se dibuja
la superficie 3-D correspondiente. Se puede
dibujar con polígonos, con líneas de nivel, en hilo
de alambre (wireframe), simplemente con
colores, o en algunas combinaciones de las
formas anteriores. Cuando se cambia el modo de
representación, aparece un paralelepípedo en la
Figura 7. Ventana gráfica tridimensional.
ventana. Para que se redibuje la imagen en el
nuevo modo, hay que pulsar Intro o clicar sobre el botón R (a la derecha de la barra). A continuación
aparecen 4 botones que permiten controlar la forma en la que aparecen los ejes de coordenadas.
Finalmente hay un botón para controlar el que se dibuje con la misma escala según los tres ejes.
Maple dispone de un medio interactivo muy fácil de utilizar para cambiar el punto de vista en los
gráficos 3-D. Cuando se clica sobre la figura -sin soltar el botón del ratón- aparece el paralelepípedo antes
mencionado, y si se arrastra en cualquier dirección dicho paralelepípedo cambia reflejando el cambio en la
orientación de la superficie respecto al observador. Para volver a ver la superficie hay que pulsar Intro o
clicar sobre el botón R.
En los menús de las ventanas gráficas 3 aparecen nuevas e interesantes posibilidades, como
-D
cambiar los criterios de color utilizados, pasar de perspectiva paralela a cónica, etc. La mejor forma de
conocer estas capacidades de Maple es practicar sobre ellas, observando con atención los resultados de
cada opción. Por supuesto, estas opciones pueden también introducirse directamente en el comando
plot3d con el que se realiza el dibujo.



página 52

8.2.2. Otros tipos de gráficos 3-D
Se pueden mostrar funciones paramétricas (dependientes de dos parámetros) análogamente a como se
hacía en el caso bidimensional (obsérvese que en este caso los rangos se definen fuera de los corchetes [
]):
> plot3d([x*sin(x), x*cos(x), x*sin(y)], x=0..2*Pi, y=0..Pi);

También se puede representar varias funciones en la misma ventana y con los mismos ejes,
definiéndolas como set entre llaves { }:
> plot3d({x+y^2, -x-y^2}, x=0..3, y=0..3);

Algunas de las funciones de la librería plots citadas en el apartado anterior están especialmente
indicadas para las funciones tridimensionales. Así, para utilizar coordenadas esféricas hay que hacer lo
siguiente (en las coordenadas esféricas se utilizan dos ángulos y la distancia al origen de coordenadas, para
definir la posición de un punto en el espacio):
> sphereplot((1.3)^z*sin(theta), z=-1..2*Pi, theta=0..Pi);

Para dibujar una curva en el espacio (una hélice de radio creciente):
> spacecurve([t*cos(t), t*sin(t), t], t=0..7*Pi);

y para dibujar una función implícita (un elipsoide):
> implicitplot3d(x^2+2*y^2+3*z^2=1, x=-1..1, y=-1..1, z=-1..1);

En el caso de las gráficas tridimensionales aumenta notablemente el número de opciones o
parámetros de Maple que puede controlar el usuario. Aquí sólo se van a citar dos, pero para más
información se puede teclear ?plot3d[options].
La opción shading permite controlar el coloreado de las caras. Sus posibles valores son: XYZ,
XY, Z, Z_GREYSCALE, Z_HUE o NONE.
Con la opción light se controlan las luces que enfocan a la figura. Los dos primeros valores son los
ángulos de enfoque en coordenadas esféricas, y los tres siguientes definen el color de la luz,
correspondiendo los coeficientes –entre 0 y 1– al rojo, verde y azul, respectivamente. A continuación se
presentan dos ejemplos para practicar, pudiendo el usuario modificar en ellos lo que le parezca.
> plot3d((x^2-y^2)/(x^2+y^2), x=-2..2, y=-2..2, shading=XYZ,
title='saddle');
> plot3d(sin(x*y), x=-2..2, y=-2..2, color=BLUE, style=PATCH, light=[45,
45, 0, 1, 0.4]);



Figura 8. Ventana de animaciones 2-D.

8.3.

página 53

Figura 9. Ventana de animaciones 3-D.

ANIMACIONES

Maple realiza animaciones con gran facilidad. En las animaciones se representa una función que varía en el
tiempo o con algún parámetro. Este parámetro es una nueva variable que hace falta introducir. Las
animaciones bidimensionales tienen una variable espacial y otra variable temporal, y ambas son
independientes. Para obtener una animación hay que definir los rangos de esas dos variables. Para realizar
animaciones en 2D se dispone de la función animate, en la libraría plots.
Las animaciones de Maple tienen sus propias ventanas, con controles similares a los de un
magnetoscopio. Considérese el siguiente ejemplo, cuyos resultados aparecen en la figura 8.
> animate(sin(x*t), x=-10..10, t=1..2, frames=50);

Para que la animación comience hay que pulsar el botón Start. Considérese otro ejemplo:
> animate([sin(x*t), x, x=-4..4], t=1..4, coords=polar, numpoints=100,
frames=100);

Con estas dos representaciones se ha podido ver cómo varía la función seno en coordenadas
cartesianas y polares. Por defecto el número de imágenes (frames) que se genera es 16.
Las animaciones tridimensionales son aún más espectaculares. También ellas tienen su propio tipo de
ventanas (figura 9). Se realizan con la función animate3d. Ahora, las variables espaciales independientes
son dos y por eso hay que indicar el rango de tres variables independientes, las dos espaciales y la
temporal. Aquí se presentan algunos ejemplos para poder practicar (por defecto, el número de frames es
8):
> animate3d(cos(t*x)*sin(t*y), x=-Pi..Pi, y=-Pi..Pi, t=1..2);
> animate3d((1.3)^x*sin(u*y), x=-1..2*Pi, y=0..Pi, u=1..8,
coords=spherical);
> animate3d(sin(x)*cos(t*u), x=1..3, t=1..4, u=1/4..7/2,
coords=cylindrical);

Recuerde que en coordenadas cilíndricas se utilizan, para definir la posición de un punto, la
coordenada cartesiana z, la distancia r al eje z y el ángulo ϕ respecto al eje x.


9.

FUNCIONES EN MAPLE. PROGRAMACIÓN

9.1.

página 54

ESTRUCTURAS DE PROGRAMACIÓN

Maple dispone de un lenguaje de programación propio con bifurcaciones y bucles similares a los de otros
lenguajes. A continuación se revisará brevemente estas construcciones, que tienen una sintaxis algo
diferente a la de C y MATLAB. A semejanza de este último programa, Maple dispone de palabras clave
para indicar la terminación del bloque (en lugar de las llaves { } de C).
9.1.1. Bifurcaciones: sentencia if
La forma más sencilla de la sentencia condicional if es la siguiente:
if condicion then sentencias fi;

donde si la condicion es true, se ejecutan las sentencias. Si la condicion es false, se saltan. La forma
general de la sentencia if es la siguiente:
if condicion1 then
sentencias1
elif condicion2 then
sentencias2
else
sentencias3
fi;

donde se pueden incluir tantas etapas elif (else if) como se desee. Obsérvese que sólo la sentencia fi, que
marca el final del bloque, lleva el carácter de terminación de línea (; o :).
La distribución en varias líneas que se presenta aquí no es necesaria. De hecho, en Maple es muy
corriente encontrar todo escrito en una única línea (si la sentencia no es muy larga, por supuesto).
9.1.2. Bucles: sentencia while
La forma general del bucle while es la siguiente:
while condicion
do
sentencias
od;

Las sentencias se repiten mientras la condicion sea true. La palabra clave od indica el fin del bucle,
y es la única que lleva el carácter de terminación (; o :).
9.1.3. Bucles: sentencia for
La forma general de la sentencia de repetición for es la siguiente:
for var from inicio by salto to final
do
sentencias
od;



página 55

La variable var comienza tomando el valor inicio, y luego el bucle se repite incrementando var de
salto en salto hasta que llega a final. La variable salto puede omitirse y en ese caso se supone que vale
1. El final del bucle se indica con la palabra od.
También en este caso sólo se pone el carácter de terminación al final del bucle, y se pueden poner
toda la construcción for en una sola línea.
9.1.4. Sentencias break y next
La sentencia break hace que se salga inmediatamente del bucle en el que está. La sentencia next hace que
se salte hasta el final del bucle (sentencia od), comenzándose una nueva ejecución del bloque si la
condicion así lo exige.
9.2.

FUNCIONES Y PROCEDIMIENTOS

Maple puede definir funciones de dos formas distintas:
–

por medio del operador flecha o arrow (->)

–

por medio de procedimientos (procedures), que son similares a las funciones de C

Con el comando ?inifcns se obtiene información sobre las funciones que Maple tiene definidas al
comienzo de la sesión. Muchas de estas funciones pueden ser de gran utilidad. Se aconseja ver cuáles son
estas funciones:
> ?inifcns;

De modo similar, con ?ininame se obtiene información sobre los nombres que el programa
reconoce en el momento de arrancar.
9.3.

FUNCIONES DEFINIDAS MEDIANTE EL OPERADOR FLECHA (–>)

9.3.1. Funciones de una variable
Con Maple, las relaciones funcionales se pueden definir de dos modos:
–

mediante una expresión o fórmula

–

mediante una función matemática propiamente dicha

A continuación se verá, con un ejemplo definido de ambas formas, la diferencia entre una expresión
y una función. En primer lugar, se va a definir la temperatura T como una expresión en la que interviene la
variable tiempo t:
> T := T0*exp(-c*t);

En la expresión anterior, a la variable t se le puede dar otro valor, por ejemplo asignando a t otra
expresión en dicha ecuación. Para ello hay que utilizar el comando subs, o bien cambiar el valor de las
variables que intervienen en esa expresión. Obsérvense los resultados de los siguientes comandos:
> subs(t=1/c, T);



página 56

> t:=1/c; T;

> t:='t'; c:=2/t; T;

Aunque el método anterior ha funcionado de modo correcto, T no es una verdadera función del
tiempo (t interviene en la misma forma que T0 ó c). Ahora se va a definir T como verdadera función del
tiempo t. Para ello se va a utilizar el operador flecha (->). Observe bien la sintaxis de este ejemplo (los
espacios en blenco son opcionales):
> T := t -> T0*exp(-c*t);

Ahora es mucho más fácil obtener el valor de T para cualquier valor de la variable t (que ya
interviene en la función de un modo diferente que c ó T0). Por ejemplo:
> T(1/c), T(0);

Las funciones definidas con el operador flecha se evalúan a su propio nombre. Sin embargo, si se
escribe la función seguida de la variable entre paréntesis, se obtiene la expresión de la función completa:
> T, T(t);

La representación gráfica de las funciones definidas de esta forma es también más sencilla (ver
apartado de Gráficos). Otra ventaja importante de las funciones definidas mediante el operador flecha es
que se les puede aplicar la función solve:
> c:='c'; solve(T(t)=100, t);

9.3.2. Funciones de dos variables
Las funciones de dos variables se pueden definir utilizando de nuevo el operador flecha ->. Véase un
ejemplo, con gráfico incluido (se omite la figura por motivos de espacio):
> f := (x,y) -> x**3-3*x*y**2;



página 57

> f(3,2); # evaluación de la función para valores de las variables

> plot3d(f, -1..1, -1..1, numpoints= 500, style=PATCH, axes=FRAME);

Se va a definir ahora una función llamada multipl que acepta una entrada (primer argumento), y la
repite n veces (segundo argumento):
> multipl := (x,n) -> seq(x, j=1..n); # repetir x n veces

> multipl(estudia,9); # repetir "estudia" 9 veces (son pocas veces...)

> multipl(no,9);

En la función anterior, la variable j ha sido implícitamente definida como local (existe de m
odo
independiente en la función) y por eso está desasignada. Esto se puede comprobar ejecutando los
siguientes comandos:
> j; n;
> n := 4; multipl(x,n);

9.4.

PROCEDIMIENTOS EN M APLE V

La definición de procedimientos en Maple (lo equivalente a las subrutinas de Fortran, o las funciones de
C y MATLAB) tiene la siguiente forma:
proc(parameter_sequence)
[local name_sequence;]
[options name_sequence;]
statements
end

donde name_sequence es una secuencia de nombres de Maple separados por comas;
parameter_sequence suele ser también una secuencia de nombres, pero si se utiliza chequeo dinámico
del tipo de los argumentos, cada nombre debe ir seguido por su tipo separado por el carácter (:).
Considérese por ejemplo un procedimiento llamado par que determina si una variable entera es par
o impar. La definición de este procedimiento se hace en la forma:
> par := proc(n:integer) (-1)^n end;

Esta función puede ser comprobada con los siguientes ejemplos:
> par(2), par(-3);

> par(Pi);

Como Pi no es de tipo integer, se obtiene un mensaje de error que lo indica. Se puede eliminar el
chequeo del tipo de los argumentos y se evitará el mensaje de error, pero tal como está construida la
función el resultado será incorrecto.
> par2 := proc(n)

(-1)^n

end; # ahora no se chequea el tipo



página 58

> par2(Pi); # no da error, pero tampoco hace lo que debía hacer

El valor de retorno o valor que devuelve un procedimiento es de ordinario el valor calculado en la
última sentencia, a no ser que haya un return explícito. Ahora se va a definir un procedimiento llamado
elemento, en varias líneas. Este procedimiento comprueba si un determinado dato (de cualquier tipo)
pertenece a una lista que se da como argumento. Si la respuesta es positiva, indica también en qué
posición aparece
> elemento := proc(x:anything, L:list, pos:name) local i;
>
for i to nops(L) do
>
if L[i] = x then pos := i; RETURN(true)
fi
>
od:
>
false
> end;

Ahora se puede ya probar la función elemento que se acaba de definir:
> elemento(2, [2,1,3,2], 'position'), position;

> elemento(4, [2,1,3,2], 'position'), position;

Considérese un nuevo ejemplo, en el que se va a utilizar una variable local y para evitar
interferencias con variables globales. El procedimiento se llama ff e implementa una expresión complicada:
> ff := proc(x)
local y;
>
y := 1 + sin(x);
>
y^2 + y +1/y + 1/y^2;
> end;
> ff(t);

Dos consideraciones finales acerca de los procedimientos y las funciones:
1.
2.
9.5.

El chequeo dinámico de tipos sólo está disponible en los procedimientos, no con el operador
flecha.
A diferencia del operador flecha, los procedimientos pueden tener varias sentencias.

CONVERSIÓN DE EXPRESIONES EN FUNCIONES

Ya se ha visto que Maple maneja expresiones y funciones de manera intercambiable a veces, y muy
diferente en otras. Las funciones son un poco más complicadas de definir, pero tienen ventajas en muchos
casos. En Maple existe el operador unapply, que puede convertir una expresión o fórmula en una función.
Considérese cómo se comporta Maple con un ejemplo concreto:
> formula := (b^2*x^2*sin(b*x)-2*sin(b*x)+2*b*x*cos(b*x)*a*t)/b^3;

> F := unapply(formula, x, t);



página 59

> F(0, 1), F(Pi/b, 5);

Este tipo de conversión no puede hacerse directamente, con el operador flecha. Pruebe a ejecutar
las sentencias siguientes y observe el resultado:
> G := (x, t) -> formula;

> F(u, v); G(u, v);

# la u y la v no aparecen por ninguna parte en G

La única alternativa para obtener el mismo resultado que con la función unapply está basada en la
función subs, y es la siguiente:
> H := subs( body=formula, (x, t) -> body);

> H(u, v);

9.6.

# ahora sí funciona

OPERACIONES SOBRE FUNCIONES

Es fácil realizar con Maple operaciones tales como suma, multiplicación y composición de funciones.
Considérense los siguientes ejemplos:
> f := x -> ln(x)+1;

> h := f+g;

h(z);

> h := f*g;

g := y -> exp(y)-1;

h(z);



página 60

La siguiente función define una función de función (composición de funciones) por medio del
operador @ (el resultado es f(g)):
> h := f@g;

h(z);

Considérese ahora el siguiente ejemplo, en el que el resultado es g(f):
> h := g@f; h(z);

> simplify(");

> (f@@4)(z);

# equivalente a f(f(f(f(z))));

El operador @ junto, con los alias y las macros, es una forma muy potente de introducir
abreviaturas en Maple.
Si se desea evaluar el resultado de la sustitución, ejecútese el siguiente ejemplo:
> n:='n'; Zeta(n); subs(n=2, Zeta(n)); # versión estándar de subs()
> macro(subs = eval@subs); # nueva versión de subs definida como macro
> subs(n=2, Zeta(n));

9.7.

FUNCIONES ANÓNIMAS

Las funciones de Maple pueden no tener nombre, es decir, ser anónimas Estas funciones son útiles cuando
hay algo que se quiere ejecutar una sola vez y no se quiere desperdiciar un nombre para ello. Considérese
el siguiente ejemplo:
> map( x -> x^2, a+b+c);

En el ejemplo siguiente se calcula el logaritmo del 2º elemento de cada entrada:
> data := [[1,1.0],[2, 3.8],[3,5.1]];

> map( x -> subsop(2=ln(op(2,x)), x), data);

> sum('x^i', 'i'=0..6);

> select(t -> degree(t)<3, ");



10.

COMANDOS DE ENTRADA/SALIDA

10.1.

página 61

CONTROL DE LA INFORMACIÓN DE SALIDA

La información de salida de Maple se puede controlar con el parámetro prettyprint, en la función
interface. De ordinario este parámetro tiene por valor 1. Para que la salida sea en una sola línea hay que
hacer prettyprint=0. Por ejemplo, ejecute los siguientes comandos y observe el resultado:
> interface(prettyprint=0):
> a*x + b**x = c;
a*x+b^x = c
> interface(prettyprint=2):

10.2.

LAS LIBRERÍAS DE M APLE

La librería de Maple tiene 4 partes:
1.- standard library,
2.- miscellaneous library,
3.- packages,
4.- share library (librería de funciones desarrolladas por usuarios).
Cuando se utiliza una función o routina de la standard library, el sistema la carga automáticamente
en la memoria principal. Por el contrario, la miscellaneous library contiene funciones menos
frecuentemente utilizadas y hay que cargarlas explícitamente con el comando readlib.
Hay también paquetes de funciones para operaciones más especializadas. Para cargar estas routinas
hay que hacer mención también al paquete correspondiente. Véanse algunos ejemplos:
> a; a:=evaln(a); f := exp(a*z)/(1+exp(z)); # una fórmula cualquiera
> residue(f, z=Pi*I); # para calcular el residuo en un punto
> readlib(residue); # esta routina está en la miscellaneous library
proc(f,a) ... end
> residue(f, z=Pi*I); # ahora sí lo va a calcular bien
> residue(1/(z**2+a**2), z=a*I);

Por ejemplo, el paquete orthopoly contiene funciones para varios tipos de polinomios ortogonales.
Para llamar a una de estas funciones:
> orthopoly[T](4,x); # polinomios de Chebyshev
> with(orthopoly, T); with(orthopoly);

para indicar a Maple que cargue parte o todo el paquete, aunque en realidad se cargan sólo los nombres y
no los códigos fuente.
10.3.

GUARDAR Y RECUPERAR EL ESTADO DE UNA HOJA DE TRABAJO

El estado y los comandos de una hoja de trabajo se puede guardar desde dicha hoja con el comando
save. Dos formas posibles de este comando son las siguientes:
> save `c:tempmifile.m`; # fichero no legible con Notepad
> save `c:1inf2maplemifile.m`;
> save A,B,C,`mifile.txt`; # fichero legible con Notepad


página 62

Si el nombre del fichero termina en *.m se almacena en formato interno de Maple. En otro caso, se
almacena en forma de texto (el formato de la salida del comando lprint) con las sentencias de entrada.
Para recuperar el fichero guardado se utiliza el comando read:
> read `c:1inf2maplemifile.m`;
> evaln(A), evaln(B), evaln(C); read `c:tempmifile.txt`;

Puede guardarse también todo el estado interno de una hoja de trabajo activando el comando Save
Kernel State en el menú Options, y luego ejecutando Save As en el menú File. Al utilizar esta opción,
junto con el fichero *.ms creado por el usuario, se crea otro fichero con el mismo nombre y extensión *.m
que contiene el estado interno de la hoja de trabajo. Al cargar posteriormente desde el menú File el
fichero *.ms creado, se carga también el estado interno a partir del fichero *.m.
10.4.

LECTURA Y ESCRITURA DE FICHEROS

En Maple hay que distinguir entre varios tipos de ficheros:
1.- Ficheros que contienen código objeto para Maple,
2.- Ficheros que contienen código para Maple en formato legible por el usuario,
3.- Ficheros de resultados de Maple, pero que no pueden ser reutilizados como entrada del
programa en una sesión posterior,
4.- Ficheros de input/output formateados, que pueden ser leídos o escritos por otros programas.
Comenzaremos viendo la forma de crear ficheros de resultados de Maple, que no pueden ser
reutilizados como entrada. Esto se puede conseguir redireccionando la salida de la pantalla mediante los
comandos writeto o appendto para que dicha salida se escriba en un fichero llamado por ejemplo outfile
> writeto(outfile): # o bien,
> appendto(outfile):

Para que la salida se vuelva a escribir en la pantalla basta ejecutar el comando:
> writeto(terminal):

Hay que tener en cuenta que el fichero outfile se escribirá en el directorio principal de Maple. Para
que este fichero se pudiera utilizar como entrada, habría que hacer ciertos retoques. Sin embargo, no hay
inconveniente en hacer copy y paste de ciertas cosas entre este fichero y la hoja de trabajo.
Como ya se ha visto, con el siguiente comando:
> save filename;

pueden guardarse los cálculos realizados de modo que se pueden utilizar de nuevo en una sesión posterior,
o en un momento posterior de la misma sesión. Los ficheros guardados con save pueden leerse
posteriormente desde Maple por medio de la función read en la forma:
> read filename;

Una vez leído el fichero, sus variables y resultados son utilizables inmediatamente.
Si el fichero guardado con save termina en *.m se utiliza el formato objeto de Maple, no legible
directamente por el usuario. En caso contrario el fichero es legible por el usuario. Si el nombre del fichero
termina en *.m –y siempre que tenga extensión– hay que encerrarlo entre apóstrofos para evitar que
Maple confunda el punto con el operador de concatenación. Si se da el path absoluto de un fichero, las
barras invertidas hay que ponerlas dos veces ().


página 63

Los ficheros legibles pueden prepararse con cualquier editor de textos.
El siguiente ejemplo habría que ejecutarlo en una sesión nueva de Maple:
>
>
>
>

restart; polinomio:= x**2+2*x+1; `numero cuatro` := 4;
save `c:tempfilepufo.m`;
restart; polinomio; `numero cuatro`;
read `c:tempfilepufo.m`; polinomio; `numero cuatro`;

Cuando el fichero que se lee está en formato *.m su contenido no se vuelca en la pantalla al
cargarse, mientras que sí se vuelca si es un fichero legible que tiene una extensión diferente.
Puede salvarse selectivamente parte del contenido de una sesión, por ejemplo:
> save `numero cuatro`, polinomio, `c:tempfilepuf2`;
> `numero cuatro`:=3; polinomio:= x**5; # se cambia el valor de lo salvado
> read `c:tempfilepuf2`; # ahora se recupera el fichero

La función readlib puede utilizarse para leer una función de una librería. Además en la misma
llamada a readlib para leer una función, se le pueden pasar los parámetros a esa función, como en el
ejemplo siguiente:
> readlib(mtaylor)(sin(x+y), [x, y]);
> sort(simplify(",{z=x+y}, [x,y,z]));
> subs(z=x+y, ");

10.5.

FICHEROS FORMATEADOS

Se verán ahora los ficheros de Input/Output formateados. Maple puede leer/escribir ficheros creados por,
o para ser leídos por otras aplicaciones. En principio escribe en la pantalla, pero se puede redireccionar la
salida con writeto. Las funciones de entrada/salida que se van a ver ahora son similares a las de C. La
forma general de la función de escritura es:
> printf(format, arg1, arg2, ...)

que imprime sus argumentos con el formato indicado. Véase un ejemplo:
> printf(`%015.8f`, 5/3);
000001.66666667

Por otra parte, también se pueden leer ficheros con la función sscanf, que tiene la siguiente forma
general:
> sscanf(string, format)

Esta sentencia es similar a la de C, pero aquí devuelve una lista de los objetos leídos. Posibles
ejemplos serían los siguientes:
> sscanf(`x = 123.45, y = 6.7E-8, 9.10`, `x = %f, y = %g, %d.%d`);
> sscanf(`f = x/(1+x**2)`, `f = %a`);

10.6.

GENERACIÓN DE CÓDIGO

Una de las aplicaciones más interesantes de Maple es la generación de ficheros con código C o Fortran (el
código de MATLAB se parece bastante al de Fortran) correspondiente a las expresiones desarrolladas en
el programa. Considérense los siguientes ejemplos:
> x:= evaln(x); ecuacion := x**3 - 5*a*x**2 = 1;
> soluciones := solve(ecuacion, x);


>
>
>
>
>
>

página 64

sol1 := soluciones[1];
precision := double; # se va a generar código Fortran de doble precision
fortran(sol1, 'optimized');
readlib(cost)(sol1); # para saber el costo en operaciones aritméticas
cost(optimize(sol1));
fortran(sol1, 'optimized', filename = `c:tempfilepuf3.f`);

La sentencia anterior produce salida a fichero. Si el fichero ya existe lo añade a continuación de lo
que hay (append).
> readlib(C); # para generar código en C
> C(sol1,'optimized');
> C(sol1);

La forma general de la función C es la siguiente:
> C(s, filename=`g:nombre.c`)

donde s es una expresión, un array de expresiones con un nombre, o una lista de ecuaciones en la forma
name = algebraic, entendiendo algebraic como una secuencia de sentencias de asignación.
Puede utilizarse también el argumento adicional optimized, y la variable global precision puede ser
asignada a double. Los subíndices se traducen directamente, sin tener en cuanta que en C se empieza a
contar por cero.
Considérese un ejemplo adicional:
> readlib(C):
> s := ln(x)+2*ln(x)^2-ln(x)^3;
> C(s);
t0 = log(x)+2.0*pow(log(x),2.0)-pow(log(x),3.0);
> C(s,optimized);
t1 = log(x);
t2 = t1*t1;
t4 = t1+2.0*t2-t2*t1;



página 65

Varios
Medida de tiempos de cálculo
Para medir los tiempos de cálculo de Maple
> settime := time();
> factor (poli );
> cpu_time := (time()-settime) * segundos;

Salida en una sola línea
Para que la salida sea en una sola línea hay que hacer prettyprint=0
> interface(prettyprint=0);
> a*x + b**x = c;
a*x+b^x = c

Alias y macros
El paquete orthopoly contiene routinas para varios tipos de polinomios ortogonales. Para llamar a
una de estas routinas:
> orthopoly[T](4,x); #polinomios de Chebyshev
> alias(T=orthopoly[T]); T(4,x); para hacer más cómoda la llamada
> alias(T=T); T; para eliminar el alias definido anteriormente

En vez de un alias puede utilizarse un macro, en la forma:
> macro(T=orthopoly[T]); T(5,x);

La diferencia es que la macro es una simple abraviación que actúa sólo en el input, mientras que el
alias afecta tanto al input como al output.
> 'T(6,x)';
> macro(T=T); T; para eliminar la definición de macro
> with(orthopoly, T); with(orthopoly);

para indicar a Maple que cargue parte o todo el paquete, aunque en realidad se cargan sólo los nombres y
no los códigos fuente.


Maple vr3

Más contenido relacionado

Similar a Maple vr3 (20)

Último (20)

Maple vr3