Maple

Métodos Teóricos en Ingeniería A (Dpto. de Ing. Qca., UNS)‐ Probabilidad y estadística.
2013
MAPLE V: PROGRAMA DE MATEMATICA SIMBÓLICA
Introducción
Los programas o sistemas de cómputo simbólico tienen la habilidad de manipular la información de
manera algebraica o simbólica. Los programas convencionales requieren valores numéricos para
todas las variables. En cambio los programas de matemática simbólica como MAPLE,
MATHEMATICA o MATLAB, mantienen y manipulan los símbolos y expresiones. De esta forma se
pueden obtener soluciones analíticas exactas de muchos problemas matemáticos, como integrales,
sistemas de ecuaciones, ecuaciones diferenciales y problemas de álgebra lineal.
Además de las operaciones simbólicas estos programas contienen una serie de facilidades gráficas
que permiten visualizar los resultados; algoritmos de precisión arbitraria para solución numérica de
problemas cuya solución exacta no existe, combinados con un lenguaje de programación que
permite al usuario desarrollar funciones y aplicaciones de acuerdo a sus necesidades.

Presentación de MAPLE V
MAPLE es un programa de cálculo simbólico o algebraico que trabaja bajo Windows. Este programa
posee la habilidad para trabajar con la información de la misma manera que lo haríamos nosotros
cuando llevamos a cabo cálculos matemáticos analíticos.
MAPLE posee un conjunto de librerías o Paquetes, donde se encuentra la mayoría de los comandos,
y que están escritas en su propio lenguaje de programación, lenguaje que permite al usuario crear
sus propios comandos y añadirlos a la librería estándar (es por tanto un sistema extensible).

La hoja de trabajo de MAPLE
Para iniciar el programa se debe buscar en el menú Inicio (o Start) ‐> Programas (o Programs)‐>
Maple 14‐> Maple 14
Una vez que se invoca el programa aparece la ventana siguiente:

1
Métodos Teóricos en Ingeniería A (Dpto. de Ing. Qca., UNS)‐ Probabilidad y estadística. 2013

En la parte superior se encuentra la barra de Menú, con menús tales como File (Archivo) o Edit
(Edición), parecidos a los de cualquier otra aplicación. Debajo se encuentra la barra de
herramientas, que contiene botones para tareas comunes de edición y otras específicas de Maple
Para salir de Maple
En el Menú File ‐> Exit (Salir)
Para guardar la hoja de trabajo
En el Menú File ‐> Save o Save As (guardar o guardar como)
Para recuperar una hoja de trabajo anterior
En el Menú File ‐> Open (Abrir)

Debajo de estas tres barras hay un área en blanco en la que se desplegará la hoja de trabajo: es la
región donde el usuario va a introducir comando de Maple, texto, etc. La hoja de trabajo es un
entorno en el que se resuelven problemas y se documenta el trabajo. El contenido de la hoja de
trabajo se puede guardar en un archivo con extensión mws, asignándole el siguiente icono:

Paquetes o bibliotecas.
El sistema Maple dispone de cerca de 3000 comandos. Mantenerlos disponibles simultáneamente
requeriría una cantidad de memoria enorme. Por ello, al iniciar Maple, sólo se carga el denominado
núcleo (kernel), que contiene los comandos y funciones de más uso. El resto se guarda en paquetes
y bibliotecas que se van cargando según sean necesarios.
Para obtener el listado de paquetes de Maple, así como información sobre los mismos, basta
escribir
[> ?index,packages
Si lo que se desea es cargar un determinado paquete, por ejemplo "plots", que sirve para dibujar
gráficas, se debe escribir:
[> with(plots);
Una vez cargados, los comandos del paquete pueden ya ser utilizados.

2
Generalidades del lenguaje
Maple es un software interactivo que espera que le demos una orden ("input") y nos devuelve un
resultado ("output"). En pantalla aparece el símbolo ">" (prompt) como una indicación de que
Maple está esperando nuestras instrucciones. Cualquier cosa que se escriba a continuación
aparecerá en rojo, color reservado a los comandos, mientras que el texto utiliza el color negro. Las
instrucciones de Maple (escritas con la sintaxis adecuada) han de finalizar con ; o con :. La
diferencia entre ambas opciones es que la primera genera una salida en la pantalla (en azul)
mientras que la segunda evita que ésta aparezca aunque, por supuesto, en ambos casos el
comando se ejecuta cuando se pulsa la tecla ENTER.
[> 105459/23;
105459/23
La ejecución sólo se realiza al apretar ENTER, o si el usuario elige del menú Edit ‐> Execute
Worksheet (así se ejecutan todos los comandos ingresados en la hoja de trabajo). Por lo tanto al
abrir una hoja de trabajo anterior hay que volver a ejecutar los comandos.
Se pueden ingresar varios comandos en la misma línea (separados por ; o :), los cuales se ejecutan
sucesivamente luego de apretar ENTER.
[> exp(1); sin(Pi/2); cos(Pi); 105459/23;
e
1
‐1
105459/23
Existe la posibilidad de escribir texto en la hoja de trabajo. El texto aparece en negro y para cambiar
de modo comando a modo texto y viceversa. Se pueden utilizar los botones de la barra de
herramientas . El botón con una T, cambia de modo comando a modo texto mientras que
el botón, con [>, hace aparecer un prompt en el momento que se pincha. Otra manera de ingresar
texto en la hoja de trabajo es utilizar el operador # de la siguiente manera:
[> #comando;
[>
El operador # indica que los caracteres que siguen son comentarios.

La ayuda de Maple
El sistema de ayuda (Help) permite explorar los comandos de Maple, así como las características del
sistema, por nombre o materia. Las páginas de ayuda relacionadas están unidas mediante
hipervínculos, lo que permite investigar cualquier tópico de forma sencilla.
Si se conoce el nombre de un comando determinado, es posible pedir ayuda sobre el mismo desde
la
línea de comandos utilizando el símbolo ? seguido del nombre. Así la ejecución de la instrucción
[> ?factor despliega la hoja de ayuda
En la ayuda aparecerá la sintaxis a utilizar y ejemplos de utilización de la palabra o comando.
La consulta del manual de referencia se puede realizar también desde el menú desplegable de Help
en el que aparecen varias opciones. Si se desea ayuda sobre una palabra escrita en la hoja de
trabajo, basta situar el cursor sobre dicha palabra y seleccionar en el menú Help la opción Help on
word (donde word es la palabra sobre la que se encuentra el cursor).

3

Operaciones matemáticas elementales. Aritmética.
Maple opera como una calculadora convencional con enteros y números en punto flotante. Además
es capaz de realizar cálculos exactos con números racionales, expresiones, variables, conjuntos,
listas, sucesiones, polinomios, matrices y muchos otros objetos matemáticos.
Los cálculos se llevan a cabo utilizando los llamados operadores aritméticos que son +, ‐, *, /,^ (**).
[> 2+2;
4
[> 1+1/2;
3/2
[> 12/6;
2
[> 2*3;
6
[> 4.5/2;
2.250000000
[> 4^2;
16
[> 4**2;
16
[> a+a;
2a
[> 4*b^3/(2*b);
2b2
4
[> Pi; sqrt(2); exp(1)
π

e
Con sencillas operaciones podemos ilustrar el hecho de que Maple trabaja con cantidades exactas:
[> 12/8;
3/2
[> 12/8 * 2/3;
1
Utilizando una calculadora, es muy posible que esta última operación se hubiera realizado en la
siguiente forma aproximada: 12/8= 1.5, 2/3= 0.6666667, y por tanto el producto es 1.0000005. Por
supuesto que Maple permite utilizar aproximaciones de un número. Esto se hace así:
[> evalf(11/43);
.2558139535
Ya vamos viendo la sintaxis de Maple. Generalmente las órdenes son expresiones bastante
significativas (¡en inglés!), encerrando entre paréntesis los argumentos.
Para una mejor aproximación, hacemos
[> evalf[50](11/43);
.25581395348837209302325581395348837209302325581395
Hemos indicado entre corchetes [ ] que queremos 50 cifras decimales. Volviendo a lo anterior,
parece más interesante que Maple trabaje con números exactos. De hecho, opera y simplifica:
[> 3/7 * 5/9; (2^(1/3))^6;
5/21
4
Sintaxis del lenguaje.
Define cuál entrada constituye una expresión, sentencia o procedimiento válido para MAPLE. Define
cuestiones como:
z
♦ Si quiero calcular xy , ¿necesito utilizar paréntesis?. Veamos qué nos muestra Maple en
cada caso:
[> x^(y^z);
x(yz)
[> x^y^z;
Error, `^` unexpected
♦ ¿Cómo se ingresa el número de punto flotante: 2.00 x 10‐3?
[> 2.e‐3;
Error, missing operator or `;`
[> 2.0e‐3;
0.0020
[> 2e‐3;
0.002
Si una entrada no es sintácticamente correcta, MAPLE reporta un error de sintaxis y en general
señala dónde ocurre el error.
[> ‐‐1;
Error, `‐` unexpected
5
Semántica: La semántica de un lenguaje especifica cómo las expresiones, sentencias y programas se
ejecutan. Define cuestiones cómo:
♦ ¿Es x/2*z lo mismo que x / (2*z) o (x/2)*z ?, Veamos qué nos muestra MAPLE
[> x/2*z; x/(2*z); (x/2)*z;
½ x z
x/2z
½ x z
♦ ¿Si x = 0 qué pasa si quiero calcular sin(x)/x ?
[> x:=0;
x:= 0
[> sin(x)/x;
Error, numeric exception: division by zero

Funciones matemáticas.
Maple conoce todas las funciones matemáticas estándar, las más básicas son:
Funciones trigonométricas: sin, cos, tan,
Funciones hiperbólicas: sinh, cosh, tanh,
Función exponencial: exp y logaritmos: ln (neperiano), log[10] (base 10).
Función raíz cuadrada: sqrt.
Redondeo al entero más próximo: round, truncación a la parte entera: trunc, parte fraccionaria:
frac.

Variables y su asignación.
var:= entrada; Se utiliza para asignar el resultado de una entrada o comando (del lado izquierdo) a
una variable (var), que luego puede utilizarse en entradas posteriores
[> x:=3; x^2+1;
x:= 3
10
Eliminar asignación: Consiste en vaciar el contenido de una variable o nombre.
[> a:=6;
a:= 6
[> a;
6
[> a:=evaln(a);
a:= a
[> a:=’a’;
a:= a
[> a;
a

restart: Permite limpiar de la memoria de MAPLE todo lo asignado

6
Funciones relacionadas con la asignación de variables: Para chequear si un nombre tiene un valor
asignado se usa el comando assigned
[> assigned(a);
false
Para asignar una variable:
[> assign(a = b);
[> assigned(a);
true
[> a;
b
MAPLE asigna todos los argumentos del comando assign, por ejemplo:
[> assign(a = 2);
Entonces b también pasó a valer 2, debido al assign anterior.
[> b;
2
Pero si cambio el valor de a de la forma que sigue, b no cambia
[> a:=3;
a:= 3
[> b;
2
var= entrada; No tiene efectos de asignación, la variable var no se conservará en la memoria y por
lo tanto no tendrá un valor asignado cuando se la utilice en comandos posteriores
[> b = 2;
b= 2
[> b;
b
Conjunto de caracteres.
Consiste en 26 letras (MAPLE distingue entre mayúsculas y minúsculas), 10 dígitos (del 0 al 9) y
caracteres especiales. Algunos ejemplos de caracteres se ven en la tabla siguiente.
+ suma / división > mayor ? ayuda ‐ resta
= igualdad * multiplicación := asignación # empieza ^ potenciación
comentario
( ) paréntesis, se _ forma parte [ ] corchetes, se : para ejecutar ; para ejecutar
usan en de nombres. Si usan para comando y no comando y ver
expresiones está al principio subíndices y listas mostrar resultado resultado
matemáticas, y del nombre es
para ingresar un nombre
argumentos de reservado de
comandos Maple
! función factorial < menor { } llaves, indican $ generador de || concatenación
conjuntos secuencias
% invoca %% invoca la %%% invoca “” define una ` ` cadena nula
sentencia penúltima antepenúltima cadena de caracteres
anterior sentencia sentencia caracteres
ejecutada ejecutada
7
Uso de estos caracteres:
\ : Cuando estoy utilizando “strings” o números de muchos dígitos entonces se puede utilizar una
barra \ para indicar que continúa en la otra línea:
[> `La entrada debe ser una lista de \
[> números o un conjunto de números`;
La entrada debe ser una lista de números o un conjunto de números
[> G:= 0.57721566\334565\
[> 234565\45656\656778;
G:= .5772156633456523456545656656778
||: Dos barras verticales corresponden al operador concatenación, permite formar una secuencia
de caracteres, evaluando la expresión después del punto. El primer término debe ser una string.
[> p||n;
pn
[> n:= 4; p||n;
n:= 4
p4
[> x||(1..5);
x1, x2, x3, x4, x5
El comando cat también permite concatenar strings:
[> cat(a,b,c);
abc
[ ]: Los corchetes sirven para indicar subíndices y para seleccionar componentes de objetos
agregados como arreglos, tablas, conjuntos y listas. En general, se denomina nombres indexados, a
los que tienen la siguiente estructura: nombre [arg1, arg2, arg3, ...]
[> a3[1];
a31
[> f[Cu] := 1.512;
fCu := 1.512
[> A[1,2];
A1,2
[> A[i,3*j‐1];
Ai,3j‐1
[> b[1][1];
b11
El tipo de un nombre subindicado es indexed
[> x:= A[1][2,3];
x:= A12,3
Se puede verificar el tipo de la variable x usando la sentencia type:
[> type(x, indexed);
true

8
Palabras claves o reservadas: La siguiente tabla presenta algunas de las cadenas de caracteres
reservadas de MAPLE, que tienen un significado especial y por lo tanto no pueden ser utilizadas por
el usuario para nombrar sus variables
Palabra clave Propósito
if, then, elif, else, fi Condicional
for, from, in, by, to while, do, od lazos for y while
read, save leer y guardar
quit, done, stop terminar la sesión de MAPLE
union, minus, intersect operadores de conjuntos
and, or, not operadores Booleanos
sin, cos, tan funciones

No puede haber espacios en blanco dentro de una palabra reservada, tampoco en una variable
creada por el usuario. A estos nombres no se les puede asignar valor, aunque se puede utilizar la
sentencia unprotect para anular su función y así utilizarlos como variables de usuario (no
aconsejable). A su vez cualquier nombre puede ser protegido con la sentencia protect y a partir de
ese momento no se puede cambiar su valor.
[> unprotect(sin);
[> sin:= alpha;
sin:= α
[> cuadrado:= x ‐>x^2;
cuadrado:= x ‐> x2
[> protect(‘cuadrado’);
[> cuadrado:= 10;
Error, attempting to assign to `cuadrado` which is protected

Enteros: Un entero natural es cualquier secuencia de uno o más dígitos. MAPLE ignora los ceros a la
izquierda. Un entero con signo implica +natural o ‐natural.
[> +0012345, ‐12345;
12345, ‐12345
El tipo (type) de un entero es integer. Los subtipos son: negint (entero negativo), posint (entero
positivo), nonnegint (entero no negativo), even (entero par), odd (entero impar), prime (entero
primo).
[> x := 23;
x := 23
[> type(x,integer); type(x,even); type(x,odd); type(x,prime);
true
false
true
true

9
Números de puntos flotantes o decimales: La forma puede ser natural.natural o ‐natural.natural;
natural o –natural; .natural o ‐.natural, natural exponente, natural.natural exponente, .natural
exponente
El sufijo del exponente es la letra e o E seguido por un entero con signo sin espacios entre medio. Si
es negativo debe anteponerse el signo. Si es positivo el signo es opcional.
[> 1.2, ‐2, +2.3e+2;
1.2, ‐2, 230.
El tipo de estos números es float. Si un operando o un argumento es un número de punto flotante,
entonces MAPLE utiliza aritmética de punto flotante automáticamente.

Digits: determina el número de dígitos que utiliza MAPLE para realizar este tipo de cálculos, tiene
un valor de 10 por defecto.
[> x:=2.3: y:=3.7:
[> 1 ‐ x/y;
.3783783784
Para evaluar la expresión anterior sólo con dos dígitos se usa el comando evalf (la f significa punto
flotante):
[> evalf(%,2);
.38
Para evaluar con 50 dígitos:
[> evalf(1‐x/y,50);
.37837837837837837837837837837837837837837837837838

Constantes numéricas complejas: I indica la unidad compleja (raíz cuadrada de ‐1):
[> sqrt(‐1), I, (‐1)^(1/2);
I, I, I
Un número complejo a + b*i debe entrarse así:
[> z:=2+4*I;
z:= 2 + 4 I
La parte real del número complejo z se puede obtener con el comando Re y la imaginaria con Im
[> Re(z), Im(z);
2, 4
El tipo de un número complejo es complex (numeric). Otras posibilidades de tipos de números
complejos son:
Complex (integer).........Parte real e imaginarias son enteras y también pueden ser 0.
Complex (rational)......Parte real e imaginarias son racionales
complex (float)..............Parte real e imaginarias son números de puntos flotantes.
La aritmética de los números complejos se realiza automáticamente.
[> exp(2+3*I);
exp(2 + 3 I)
[> exp(2+3.0*I);
‐7.315110095 + 1.042743656 I

10
[> 1/(a‐I);
1

Para evaluar expresiones donde aparecen números complejos utilizamos el comando evalc (la letra
c indica complejos):
[> evalc(%);

1 1

Tipos de objetos: expresiones, sucesiones, conjuntos, listas y funciones

Expresiones
Estas son las entidades fundamentales del lenguaje. Las expresiones incluyen constantes, nombres
de variables e incógnitas, fórmulas, expresiones de lógica, series y otras estructuras de datos.

Sucesiones.
,: Sirve para formar una secuencia, para separar los argumentos de un llamado a una función, para
separar elementos de una lista o conjunto
[> sin(Pi), 0, a8+b8;
0, 0, a8 + b8
Secuencias: Tiene la siguiente sintaxis: expresion_1, expresion_2, .........., expresion‐n
Si alguna de las expresiones es una secuencia, finalmente queda incluida en una sola secuencia
final.
[> a:= A,B,C;
a := A, B, C
[> a,b,a;
A, B, C, b, A, B, C
El comando "seq" (sequence o sucesión) permite definir sucesiones finitas cuyos elementos siguen
una ley lógica de formación. La sintaxis es: seq(f, i=a..b) o seq(f,i=x). Algunos ejemplos son los
siguientes:
[> seq(i^2,i=1..4);
1, 4, 9, 16
[> seq(x[i],i=1..4);
x1, x2, x3, x4
[> a:=x^3+3*x^2+3*x+1;
a := x3 + 3 x2 + 3 x + 1
[> seq(i,i=a);
x3 , 3 x2 , 3 x, 1
[> seq((‐1)^n,n=0..10);
1,‐1,1,‐1,1,‐1,1,‐1,1,‐1,1
Si deseamos escribir subíndices en los elementos de una sucesión, se pondrán entre corchetes:
[> seq(a[i]*x^i, i=1..8);
a1 x, a2 x2, a3 x3, a4 x4, a5 x5, a6 x6, a7 x7, a8 x8

11
Operador $: Es un operador para formar secuencias
[> x$3;
x, x, x

Conjuntos.
{ }: forman conjuntos. Un conjunto es una secuencia sin orden de elementos únicos. La sintaxis del
conjunto es: {elem1, elem2, elem3, …}.
Los conjuntos finitos pueden definirse enumerando sus elementos o, si siguen una ley lógica de
formación, utilizando el signo "$", como veremos ahora:
[> A:={3,6,9,12,15,18,21,24};
A:= {3, 6, 9, 12, 15, 18, 21, 24}
[> B:={3*n $ n=1..8};
B:= {3, 6, 9, 12, 15, 18, 21, 24}
[> C:={3*(‐1)^n $ n=0..10};
C:= {‐3, 3}
Para conocer el número de elementos del conjunto A utilizamos el comando “nops”:
[> nops(A);
8
Listas.
Los [ ] forman listas. Las listas se definen introduciendo los elementos en el orden deseado,
colocándolos entre corchetes. La sintaxis de las listas es la siguiente: [expr1, expr2, expr3,……]:
[> L:=[a,b,c,c,b,e,f];
L:= [a, b, c, c, b, e, f]
Al contrario de lo que ocurre con los conjuntos, aquí se respeta el orden y la repetición de los
elementos. Para obtener el número de elementos de L, el elemento tercero o los elementos entre
las posiciones segunda y quinta de L, se utilizan, respectivamente, los siguientes comandos:
[> nops(L);
7
[> op(3,L);
c
[> L[3];
c
[> op(2..5,L);
b,c,c,b
[> L[2..5];
[b,c,c,b]

Funciones.
Un llamado a una función f cualquiera tiene la forma f (arg1, arg2, arg3,…..);
[> sin(x);
sin(x)
[> min(2,10,4);
2
12
[> G();
G()
[> a(X);
a(X)
[> x:= 1;
x:= 1
[> f(x);
f(1)
[> s:=2,3;
s:= 2, 3
[> f(x,s);
f(1, 2, 3)
Para definir una función se puede utilizar la flecha formada por un guión y el signo mayor ‐>:
[> f:=x‐>6*x^3+5;
f:= x → 6 x3+5
[> phi:= t ‐> t^2;
φ := t → t2
[> g:=(a,b,c) ‐> a+b+c;
g:= (a, b, c) → a + b + c
Para utilizarlas se procede igual que con las funciones autodefinidas en Maple:
[> f(7);
2063
[> phi(5);
25
[> g(2,1,1);
5

Para definir funciones por trozos utilizamos la orden piecewise.

[> g:=x‐>piecewise(x<0,sin(x),x<1,exp(x+1),7);
g := x → piecewise(x < 0, sin(x), x < 1, e (x +1 ) , 7)

Estamos definiendo la función de la siguiente manera:
1) Si x<0, vale sen(x).
2) Si x>=0 y x<1, es decir para 0<=x<1, vale e(x + 1)
3) Si x>=1 vale 7.
Pidamos el valor en algunos puntos:
[> g(‐1);g(1/2);g(3);
sin(1)
e
(3/2)
7
13
¿Y si pedimos el valor en a, por ejemplo?
[> g(a);
0
1
7

Manipulación de expresiones y polinomios

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.
[> convert(cos(x),exp);

[> convert(1/2*exp(x) + 1/2*exp(‐x),trig);
cosh(x)
También puede convertir matrices/arreglos a lista de listas y viceversa
[> A:= array(1..2,1..2,[[a,b],[c,d]]);

[> H:= convert(A, listlist);
H:=[[a, b], [c, d]]
[> C:= convert(H,array);

Puede convertir a una matriz o arreglo en un conjunto
[> convert(A,set);
{b, a, d, c}
Puede convertir un conjunto en una lista;
[> convert(%,list);
[b, a, d, c]
También cualquier secuencia puede convertirse en un set encerrándola entre llaves {} o en una lista
encerrándola entre corchetes [].
[> s:= 1,3,5,7;
s:= 1,3,5,7
[> L:= [s];
L:= [1,3,5,7]
[> type(L, list);
true
[> C:= {s};
C:= {1,3,5,7}
[> type(C, set);
true
14
La función map permite aplicar una misma función a todos los elementos o expresiones de una lista
o conjunto. Permite trabajar con soluciones múltiples o para aplicar una operación a cada elemento
de un arreglo.
[> map(f, [a,b,c]);
[f(a), f(b), f(c)]
[> L1:= [0,Pi/2,3*Pi/2,2*Pi];
L1 := [0, 1/2 Pi, 3/2 Pi, 2 Pi]
[> map(sin,L1);
[0, 1, ‐1, 0]
[> map(f, [a,b,c],x,y);
[f(a, x, y), f(b, x, y), f(c, x, y)]
[> map(x ‐>x^2, [‐1,0,1,2,3]);
[1, 0, 1, 4, 9]

Manipulación de polinomios
El comando simplify presenta una forma simplificada de una expresión; normalmente suele ser el
resultado que se espera si se hubiera simplificado “a mano”, pero no siempre es así. Se aplican
reglas de simplificación a cualquier expresión.
[> expr1:= cos(x)^5+sin(x)^4 + 2*cos(x)^2 ‐ 2*sin(x)^2 ‐ cos(2*x);
expr1:= cos(x)5 + sin(x)4 + 2 cos(x)3 ‐ 2 sin(x)2 ‐ cos(2 x)
[> simplify(expr1);
cos5(x) + cos4(x)
[> simplify(sin(x)^2+ln(2*y)+cos(x)^2);
1 + ln(2) + ln(y)
Para que simplifique sólo la parte trigonométrica:
[> simplify(sin(x)^2+ln(2*y)+cos(x)^2,'trig');
1 + ln(2 y)

El comando factor se utiliza para factorizar expresiones polinomiales
[> factor(x^5‐x^4‐7*x^3+x^2+6*x);
x (x ‐ 1) (x ‐ 3) (x + 2) (x + 1)
[> factor((x^3‐y^3)/(x^4‐y^4));

El comando expand realiza la operación esencialmente contraria de factor.
[> expand((x+1)*(x+2));
x2 + 3 x + 2
[> expand(sin(x+y));
sin(x) cos(y) + cos(x) sin(y)

15
Si expand se utiliza con dos o más argumentos, se expande el primer argumento sin expandir las
expresiones subsiguientes:
[> expand((x+1)*(y+z),x+1);
(x + 1) y + (x + 1) z

normal: Este comando permite simplificar numerados y denominador de expresiones algebraicas,
hasta lo que se denomina forma factoreada normal: numerador/denominador, donde el numerador
y denominador son polinomios primos entre sí (indivisibles).
[> e2:= (x^2‐y^2)/(x‐y)^3;
:
[> normal(e2);
:
Si se quiere expandir esta expresión:
[> normal(e2,expanded);

El comando combine realiza la tarea inversa al comando expand. Combina varias expresiones para
conseguir una más compacta o reducida. Al utilizar el comando combine es necesario indicar como
argumento que tipo de elementos son los que se desean combinar, los posibles tipos de
combinación son: trig, exp, ln, power.
[> combine(exp(x)^2*exp(y),exp);
e(2 x + y)
[> combine((x^a)^2,power);
x(2 a)

Una igualdad o ecuación también puede ser almacenada en una variable. Los lados izquierdo y
derecho de la igualdad se pueden manipular posteriormente aludiendo a sus nombres, que son lhs
y rhs respectivamente.
[> eq1:= x+y = z+3;
eq1:= x + y = z + 3
[> lhs(eq1);
x + y
[> rhs(eq1);
z + 3

numer y denom: Extraen el numerador y denominador de una expresión cualquiera
[> numer((x+y)/(z+3));
x+y
[> denom((x+y)/(z+3));
z+3
16
nops y ops: Permiten desglosar una expresión en diferentes partes. nops nos dice cuantas partes

tiene una expresión y op cuáles son sus elementos:
[> nops(x^2);
2
[> nops(x+y+z);
3
[> op(x^2);
x, 2

sort y collect: El comando sort se utiliza para ordenar los términos de un polinomio dependiendo
del exponente de las variables de mayor a menor. El comando collect une coeficientes de potencias
iguales en un polinomio.
[> poly:= x+x^2+x^3+1‐x^4;
poly := x + x2 + x3 + 1 ‐ x4
[> sort(poly);
‐x4 + x3 + x2 + x + 1
[> pol2:= x*y+z*x*y + y*x^2 ‐ z*y*x^2+x+z*x;
pol2:= x y + z x y + y x2 ‐ z y x2 + x + z x
[> collect(pol2,x);
(y ‐ z y) x2 + (y + z y + 1 + z) x
[> collect(pol2,z);
(x y ‐ y x2 + x) z + x y + y x2 + x

quo y rem: Son las funciones que calculan el cociente y resto de la división entera de dos
polinomios.
[> r:=rem(x^3+x+1,x^2+x+1,x);
r:= 2 + x
[> q:=quo(x^3+x+1,x^2+x+1,x);
q:= x ‐ 1

divide: Sirve para saber si un polinomio divide a otro:
[> divide(x^3‐y^3,x‐y);
true

subs: La función subs realiza una substitución de la variable en un polinomio, pero no asigna ese
valor a la variable.
[> pol3:= x^2+3*x‐4;
pol3:= x2 + 3 x ‐ 4
[> subs(x=2, pol3);
6
degree: determina el grado de un polinomio.
[> degree(pol3);
2
17
En combinación con seq, el comando degree sirve para ver la secuencia de potencias que aparecen
en el polinomio.
[> a:= x^3+2*x^2+x:
[> seq(degree(i,x),i=a);
3, 2, 1

coeff y coeffs: El comando coeff extrae el coeficiente de uno de los términos de un polinomio, y el
comando coeffs extrae los coeficientes de cada termino que forman el polinomio.
[> coeff(pol3,x^2);
1
[> coeffs(pol3);
1,3,‐4

Resolución de ecuaciones y sistemas

El comando solve se usa para resolver ecuaciones, que se escriben utilizando el signo “=”, y
sistemas de ecuaciones, que se denotan encerrando entre llaves “{}” por un lado las ecuaciones y
por otro las incógnitas que lo componen. Permite encontrar raíces de polinomios y resolver
ecuaciones, intenta resolver en forma exacta devolviendo cada posible solución como un conjunto.
Si no se especifican las incógnitas MAPLE trata de resolver para todas.
[> solve({x^2=‐1},{x});
{x = I}, {x = ‐I}
[> solve({x^2=4},{x});
{x = 2}, {x = ‐2}
[> solve({a*x^2 + b*x+c=0}, {x});
⎧⎪ 1 − b + b − 4a c ⎫⎪⎧⎪
2
1 − b − b − 4a c ⎫⎪
2
⎨ x = ⎬⎨ x = ⎬
⎪⎩ 2 a ⎪⎭⎪⎩ 2 a ⎪⎭
[> solve(x+y=0);
{x = ‐y, y = y}
Si el dato es una expresión sin igualar, MAPLE asume que la expresión está igualada a cero.
[> solve(x+y);
{x = ‐y, y = y}
Al usar las llaves en las expresiones y variables, se fuerza a MAPLE a retornar un conjunto como
solución.
[> eqns:= {x+2*y = 3,y+1/x=1};
eqns:= {x + 2 y = 3, y + 1/x = 1}
[> soln:= solve(eqns, {x,y});
soln:= {y= 2, x= ‐1}, {x= 2, y= 1/2}
[> soln[1];
{y= 2, x= ‐1}
[> soln[2];
{x= 2, y= 1/2}

18
Para restringir las soluciones se pueden especificar condiciones en el comando solve:
[> solve({x^2=y^2},{x,y});
{y = y, x = y}, {x = ‐y, y = y}
Si queremos ver sólo las soluciones donde x es distinto de y:
[> solve({x^2=y^2, x<>y},{x,y});
{x = ‐y, y = y}

Comando RootOf: A veces MAPLE da soluciones en función de RootOf, cuando no puede
expresarlas en forma exacta. Por ejemplo:
[> r1:=solve({x^5‐2*x+3 =0},{x});
r1:= {x= RootOf(_Z^5‐2*_Z+3, index= 1)}, {x= RootOf(_Z^5‐2*_Z+3, index= 2)}, {x= RootOf(_Z^5‐
2*_Z+3, index= 3)}, {x= RootOf(_Z^5‐2*_Z+3, index= 4)}, {x =RootOf(_Z^5‐2*_Z+3, index= 5)}
Las soluciones son las raíces del polinomio en _Z.

El comando evalf puede utilizarse para ver las soluciones:
[> evalf(r1);
{x = .9585321812+.4984277790*I}, {x = ‐.2467292569+1.320816347*I}, {x = ‐1.423605849}, {x = ‐
.2467292569‐1.320816347*I}, {x = .9585321812‐.4984277790*I}

El comando fsolve (resolución numérica) es el equivalente numérico de solve. Utiliza una variación
del método de Newton, obteniendo soluciones aproximadas. Busca las raíces reales, por defecto.
[> pol:= 3*x^4‐16*x^3‐3*x^2+13*x+16;
pol:= 3 x4 ‐ 16 x3 ‐ 3 x2 + 13 x + 16
[> fsolve({pol},{x});
{x = 1.324717957}, {x = 5.333333333}
Para ver todas las soluciones:
[> fsolve({pol},{x},complex);
{x = ‐.6623589786 ‐ .5622795121 I}, {x = ‐.6623589786 + .5622795121 I}, {x = 1.324717957}, {x =
5.333333333}
Para ver sólo algunas de las soluciones:
[> fsolve({pol},{x},maxsols = 1);
{x = 1.324717957}
También se puede especificar el rango donde se quieren encontrar las soluciones:
[> fsolve({cos(x)},{x},Pi..2*Pi);
{x = 4.712388980}

Resolución de un sistema de ecuaciones
Ejemplo: Resolver un sistema de 3 ecuaciones con 3 incógnitas:
[> E1:= X + 2*Y + 3*Z =41:
[> E2:= 5*X + 5*Y + 4*Z =20:
[> E3:= 3*Y + 4*Z =125:
[> s2:=solve({E1,E2,E3},{X,Y,Z});
s2 := {Z = ‐70/13, X = ‐527/13, Y = 635/13}
19
evalf: Sirve para evaluar las soluciones en punto flotante:
[> evalf(s2);
{Z = ‐5.384615385, X = ‐40.53846154, Y = 48.84615385}
Se puede resolver para un subconjunto:
[> s3:=solve({E1,E2},{X,Y});
s3:= {Y = ‐11/5*Z+37, X = 7/5*Z‐33}
Luego se puede explorar el efecto de distintos valores de Z utilizando el comando subs.
[>subs({Z=1}, s3);
{Y = 174/5, X = ‐158/5}

El comando assign puede utilizarse para asignar valores a incógnitas.
[> assign(s2);
[> X,Y,Z;
‐527/13, 635/13, ‐70/13
Para aumentar la precisión de la solución se puede aumentar el número de dígitos.
Además de las vistas, MAPLE contiene otras funciones que se aplican a expresiones y polinomios.
Para verlas se puede consultar la ayuda del programa.

Gráficos
En MAPLE se pueden realizar gráficos bidimensionales, tridimensionales e incluso animaciones que
se pueden observar desde cualquier ángulo. MAPLE puede trabajar con formas explícitas, implícitas
o paramétricas, en varios sistemas de coordenadas. Por otra parte, el sistema otorga al usuario
control total sobre el resultado de modo que, por ejemplo, es posible cambiar desde los colores de
los distintos objetos hasta las fuentes utilizadas en los títulos o las etiquetas de los ejes.

Antes de graficar, se debe cargar el paquete de gráficos:
[> with(plots):

Gráficos en dos dimensiones.
El comando básico para la representación de funciones en el plano es plot. En el siguiente ejemplo
se muestra la sintaxis básica: el primer argumento es la función que deseamos representar, el
segundo argumento especifica la variable independiente y su rango de variación.
[> plot (sin(x)+exp(‐x),x=‐2*Pi..2*Pi);

20
De la misma manera se pueden graficar funciones definidas por el usuario.
[> f:= x‐> 7*sin(x) + sin(7*x);
f := x ‐> 7 sin(x) + sin(7 x)
[> plot(f(x), x=0..10);

El menú del gráfico permite modificar varias características, o se pueden utilizar las opciones del
comando de plots que se encuentran en una lista que se puede acceder con la ayuda:
[> ?plot,options;
Por ejemplo, para acotar el eje de las absisas y de las ordenadas:
[> plot(f(x),x=0..10,y=4..8);

Se pueden graficar dominios infinitos
[> plot (sin(x)/x,x=0..infinity);

21
Se pueden realizar gráficos múltiples
[> plot({x, x^2, x^3, x^4}, x=‐10..10, y=‐10..10);

También se puede elegir los colores de las curvas, poner títulos al gráfico y a los ejes.
[> plot({f1(x),f2(x)},x=‐3*Pi..3*Pi, color=[blue,black], title= TRIGONOMETRICA,
labels=[time,senocoseno]);

Elegir el estilo de las líneas como linestyle=n Determina si la línea es continua o a trazos. (n=1:
línea llena; n=2: línea de puntos; n=3: con guiones; n=4: guión y puntos)
Elegir el grosor de las líneas como thickness=n ‐ grosor de las curvas en el gráfico (n es 0 (defecto),
1, 2, o 3).
[> with (plots): f:= x‐> sin(x)*cos(x):
[> plot(f(x),x=‐4*Pi..4*Pi, axes= NONE, linestyle= 3, thickness=3, color= black);
22
Si el gráfico contiene puntos, se puede elegir el tipo de símbolo como symbol=s (s= BOX, CROSS,
CIRCLE, POINT, y DIAMOND).
[> plot(f(x),x=‐4*Pi..4*Pi, axes= BOXED, style= POINT,symbol= CIRCLE, color=black);

Gráficos paramétricos
Para realizar gráficos paramétricos, la sentencia básica es la siguiente:
[> plot([x(t),y(t),t=range of t],h,v,options), donde h es el rango horizonal, v es el rango vertical. El
primer argumento es ahora una lista con tres elementos: los dos primeros constituyen la expresión
paramétrica de la curva y el tercero especifica el parámetro y su rango de variación. El resto de los
argumentos que aparecen en la expresión son optativos y simplemente especifican opciones que
modifican el aspecto de la gráfica. Así, la opción scaling con el valor CONSTRAINED especifica que
deben usarse las mismas unidades en los dos ejes.
[> plot([cos(t), sin(t), t=0..2*Pi], scaling= constrained);

[> plot([(t^3‐1)/(t^2+1),2*t/(t^2+1), t=‐infinity..infinity], labels =[x,y]);

23
Funciones con discontinuidades:
Ejemplo:
⎧ − 1 si x < 1
⎪
f ( x) = ⎨1 si 1 < x ≤ 2
⎪ 3 si x > 2
⎩
[> f:= x‐> piecewise (x<1,‐1,x<2,1,3);
f := x ‐> piecewise(x < 1, ‐1, x < 2, 1, 3)
[> plot(f(x), x = 0..3);

Para que no dibuje las líneas verticales, agregar la opción discont = true

Graficar datos numéricos
Para graficar datos numéricos, estos deben estar en una lista de listas de la forma:
L:=[[x1,y1],...,[x2,y2],.......[xn,yn]];
[> L:=[[‐2,4],[‐1,1],[0,0],[1,1],[2,4],[3,9],[4,16]];
L := [[‐2, 4], [‐1, 1], [0, 0], [1, 1], [2, 4], [3, 9], [4, 16]]
[> plot(L, style=point, symbol=circle);

Mostrar varios gráficos a la vez
Se usa el comando display de la librería plots. Por ello, antes de usarlo debe cargarse la librería
[> with(plots):
El primer paso consiste en construir cada una de las gráficas asignándoselas a una variable
finalizando la sentencia de asignación con dos puntos :. El segundo paso es visualizar los dibujos con
el comando display.
24
[> a:= plot ([sin(t), exp(t)/20, t=‐Pi..Pi]):
[> b:= polarplot ([sin(t), exp(t), t=‐Pi..Pi]):
[> display([a,b]);

Maple también realiza gráficos en 3 dimensiones, animaciones de gráficos en 2 y 3 dimensiones,
etc.. Para enterarse de las opciones disponibles y su forma de utilización, invocar la ayuda de Maple
para plots
[> ?plots
25

Maple

Cargado por

Copyright:

Formatos disponibles

Maple

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Maple

Cargado por

Copyright:

Formatos disponibles

Métodos Teóricos en Ingeniería A (Dpto. de Ing. Qca., UNS)‐ Probabilidad y estadística.

nops y ops: Permiten desglosar una expresión en diferentes partes. nops nos dice cuantas partes

También podría gustarte