Generalidades:

Maple es un poderoso manipulador de expresiones algebraicas que no se limita solo al algebra basica, sino que ademas es capaz de resolver ecuaciones, derivar, integrar, graficar y mucho mas.
Generalmente, Maple es usado en forma interactiva, en que el usuario le va indicando a cada paso lo que se quiere desarrollar. La instruccion mas sencilla es la de asignacion, la cual se realiza de la siguiente manera:

                a := 1;

Con esta instruccion se asigna el valor 1 a la variable a, el signo ';' (punto y coma) al final de la linea es el terminador de instruccion, si no se encuentra este signo, el comando puede continuar en la linea siguiente. Otro terminador de comando es el signo ':', con la diferencia que el resultado no se muestra en la pantalla.
Las expresiones dadas, Maple las evalua lo mas lejos que pueda, es decir, si le damos ahora la asignacion:

                x := a + b;

se le asigna el valor 1+b a la variable x, ya que a vale 1. Si ahora le damos las instrucciones:

                b := -1 ; f := sin(x) ;

entonces evalua x a 0 y f queda con el valor 0, que corresponde al valor de sin(0). Finalmente, si damos las asignaciones:

                b := 0 ; g := sin(x) ;

entonces evalua x a 1, y a g le asigna el valor sin(1), el cual no es simplificado, ya que no se puede simplificar o evaluar en un contexto de expresiones simbolicas. Para obtener la evaluacion de esta expresion podemos usar la funcion evalf(expr,ndigits), donde expr representa la expresion a ser evaluada y ndigit es el numero de digitos con que queremos que se represente dicha evaluacion. Si ahora damos el comando evalf(g,20); nos da:

                evalf(g,20);

                     .84147098480789650665

Pero, en general, el argumento ndigit puede ser omitido y se asume como valor por defecto el de la variable Digit, por ejemplo:

     
                Digit;

                     Digit = 10

                evalf(g);

                     .8414709848

Si uno se encuentra en problemas y no conoce sobre algun comando o su sintaxis puede dar el comando help();.
Como salir:
Para salir se pueden utilizar uno de los siguientes comandos:

quit

done

stop

Notese que estos comandos no necesitan del ';' o ':' al final.

Operadores:

Ademas de los operadore tradicionales ( + , - , * , / , ^ ** , < , > , = , <= , >= , <> ) existen los operadores '!' para factorial, '@' para composicion de funciones y los operadores sin parametros:

" : ultima expresion.

"" : penultima expresion.

""" : antepenultima expresion.

Algunas funciones importantes:

                evalf(expr,n);

Evalua una expresion a su valor en representacion de punto flotante, el parametro n indica el numero de digitos con que queremos representar dicho numero, el cual puede ser omitido, es decir, ocupar la funcion de la forma evalf(expr); con lo que se asume como evalf(expr,Digits); donde Digits es una variable de Maple, inicialialmente con valor 10, el cual se puede cambiar con la asignacion: Digits := 20;.

 
           evalf(Pi);                       da  3.141592654\\ 

           evalf(5/3*exp(-2)*sin(Pi/4),15)  da  .159494160850685\\ 

           evalf(cos(1)+sin(1)*I)           da  .5403023059 + .8414709848*I\\ 
 
           evalc(expr);\\

Evalua y simplifica la expresion en numeros complejos de la forma expr1 + expr2*I con I representando la unidad compleja:

           evalc((3+5*I)*(7+4*I))           da  1 + 47*I\\ 

           evalc(Im("))                     da  47\\ 

           evalc(exp(I))                    da  cos(1) + sin(1)*I\\ 
 
           solve(expr,var);\\ 

           solve({expr1,expr2,...},{var1,var2,...});\\

Resuelve una ecuacion o sistema de ecuaciones:

           solve( x\^2-1 = 0 , x)            da  x=1 , x=-1

           solve({a*x^2,b*y^2,x-y-1},{x,y})   da  {x=1,y=0} , {x=0,y=-1}
 
           diff(expr,var1,var2,...);

Extrae la derivada de la expresion con respecto a las variable var1, var2, etc.

           diff(sin(x)*cos(x),x);      da cos(x)\^2 - sin(x)\^2A

           diff(exp(x),x,x);         da exp(x)

           q := x\^2 - 3*x + y\^3;

           diff(q,x);                  da  2*x - 3A

           diff(q,y);                  da  3*y

           diff(q,x,y);                da  0
 
 
           int(expr,var);

Calcula la integral indefinida ( int(expr,x) ) o definida ( int(expr,x=a..b) )

           int(tan(x),x);              da  -ln(cos(x))

           int(sin(x)\^2,x=0..Pi)       da  1/2 Pi
 
           rsolve(ecuaciones(s),funciones(s));

Resuelve ecuaciones de recurrencia, las condiciones de borde se agregan como una ecuacion mas.

           rsolve( f(n) = -3*f(n-1) - 2*f(n-2) , f );
                    (f(1)+2*f(0))*(-1)\^n+(-f(1)-f(0))*(-2)^n

           rsolve({f(n)=-3*f(n-1)-2*f(n-2),f(1)=1,f(2)=1}, f );
                       -3(-1)\^n + (-2)\^n
 
           taylor(expr,x=a,n);

Genera la expansion de taylor de expr en torno a x=a hasta el grado n.

           taylor(sin(x),x,5);        da  x - 1/6 x\^3 + O(x\^5)

           taylor(1/x,x=1,3);         da  1-(x-1)+(x-1)\^2+O((x-1)\^3)

Gráficos:

Para graficar existe el comando plot, pero antes que esto se recomienda "setear" el terminal con el comando:

                interface(plotdevice=regis)      ( VT340 )

                interface(plotdevice=vt100)      ( VT320 )
 
                plot(f,h,v,...);

             f  :  funcion a graficar

             h  :  rango horizontal      ( -10..10 por defecto )

             v  :  rango vertical        ( por defecto se calcula )

             ...:  opciones
 
           plot(cos(x),x=0..Pi);

           plot({sin(t),cos(t)},t=0..2*Pi);   ( Grafica ambas funciones )

Referencia:
Maple Reference Manual, 5th edition
( I.1.3 CHAR88 Biblioteca DCC )

Grupo de Consultoría
Centro de Computación, Universidad de Chile