Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Tutorial Maple
Tutorial Maple
Se ha hecho
especial hincapié en los aspectos algebraicos (ecuaciones, sistemas y funciones) que puede
desarrollar MAPLE No obstante, MAPLE tiene muchas otras posibilidades. A pesar de esto,
espero que este manual sea de utilidad.
Puedes hacer consultas o sugerencias en: dmdelrio@hotmail.com
Tengo que agradecer a Ismael su interés en este tipo de sistemas de cálculo simbolico ya que,
sin saberlo, fue el mayor promotor de este trabajo.
INTRODUCCIÓN
HOJAS DE TRABAJO
Cuando inicies una sesión de MAPLE aparecerá una hoja de trabajo(worksheet ) en blanco, en
la que verás un signo mayor que precedido de un corchete abierto([> ). El corchete indica un
área de trabajo y el signo > indica una zona de entrada. Todo lo que teclees ahí aparecerá en rojo
y será interpretado como un comando de MAPLE.
TIPOS DE REGIONES
Hay varios tipos de regiones:
• Región de entrada de texto, como esta que estás leyendo, donde aparecen comentarios en
negro. Puedes activar una zona de comentarios pulsando el icono T en la barra de
comandos. Podrás ecribir con diferentes formatos, tamaños, etc.
• Región de comando(input), como la que aparece al iniciar MAPLE. Se reconoce por el signo >
y en ella el texto escrito aparecerá en rojo. Puedes iniciar una zona de comando pulsando
el icono [> en la barra de comandos. Dentro de una zona de comando se pueden
introducir comentarios aclaratorios. Para ello utilizamos el símbolo #, después se escribe
el comentario.
• Región de salida (output), en la que aparecerá, en azul, la salida producida por un comando
Las diferentes regiones pueden unirse utilizando la tecla F4, y separarse con F3
AYUDAS
Lo primero que debes saber es cómo llamar a la ayuda de MAPLE. Es tan sencillo como
teclear ? en una línea de comando y pulsar [INTRO]
>?
Si lo que ocurre es que tienes dudas sobre cuál es la sintaxis de un determinado comando, teclea
? y detrás el nombre del comando, después pulsa [INTRO], por ejemplo:
> ?factor
nos dará información acerca del comando factor
Se puede obtener una ayuda general de todas las posibilidades de MAPLE con el comando:
> ?index
COMANDOS
SINTAXIS GENERAL DE UN COMANDO
Como norma general un comando consta de un palabra clave seguida de unos argumentos que
se escribirán englobados en un paréntesis separados por comas. Por ejemplo:
> solve(a*b-c,b);
El comando solve resuelve la ecuación del polinomio (igualado a 0) que aparace como primer
argumento en el paréntesis despejando la variable que aparecere como segundo argumento en el
paréntesis. Para ver con más detalle cómo se utiliza este comando teclea:
> ?solve
Hay comandos que no tienen este tipo de sintaxis, como son las operaciones básicas, la
potenciación, el factorial.
FINALIZADOR DE UN COMANDO
Para que el comando sea ejecutado será necesario escribir un finalizador y pulsar [INTRO]. Hay
dos tipos de finalizador de comando:
• el punto y coma (;) ejecutará el comando y producirá una salida que se verá en pantalla en
color azul.
• los dos puntos (:) que ejecuta el comando pero no producirá salida alguna. Es muy útil cuando
sea necesario ejecutar una serie de comandos donde únicamente interese la salida del
último de ellos.
Por ejemplo, el comando para factorizar enteros es ifactor (i por integer y factor por factorizar):
> ifactor(180);
> ifactor(180):
Hay comandos que no tienen este tipo de sintaxis, como son las operaciones básicas, la
potenciación, el factorial. Puedes ver algunos de ellos tecleando:
> ?index,expression
COMANDOS ENCADENADOS
Es posible encadenar los comando en una misma línea utilizando los separadores entre ellos, por
ejemplo:
> 2+3; 5-3;
También podemos separarlos con una coma, en cuyo caso la salida será de esta manera:
> 2+3 , 5-3;
MAYÚSCULAS Y MINÚSCULAS
MAPLE es case sensitive, es decir, distingue entre mayúsculas y minúsculas . Por esto
deberemos tener especial cuidado al escribir variables. Por ejemplo: para MAPLE las variables
Numero y numero son distintas.
En general, los comandos se escriben en minúscula.
Reservaremos las mayúsculas para las funciones y procedimientos definidos por nosotros.
EXPRESIÓN INERTE
MAPLE tiene varios comandos que, según se escriban con la primera letra en mayúscula o
minúscula, hacen diferenetes acciones. Por ejemplo:
Para hallar un límite se utiliza el comando limit, pero si escribimos Limit lo que aparecerá será la
expresión del límite en su notación convencional, que es lo que se denomina expresión inerte:
> Limit(x/(x^2-1),x=infinity);
> limit(x/(x^2-1),x=infinity);
Esta capacidad de MAPLE se puede utilizar para escribir fórmulas de la siguiente manera:
> Limit(x/(x^2-1),x=infinity)=limit(x/(x^2-1),x=infinity);
Otros comandos con capacidad de escribir la expresión inerte son, por ejemplo:
Sum y sum (sumatorio)
Product y product (productorio)
Diff y diff (para el cáculo de derivadas)
Int y int (calcula la integral indefinida de una función).
PAQUETES DE COMANDOS Y LIBRERÍAS
MAPLE guarda en su memoria los comandos más usuales, el resto se guarda en paquetes
(packages) que será preciso cargar cuando vayamos a utilizarlos. Para ver el listado de paquetes
disponibles teclea:
> ?index,packages
CARGANDO UN PAQUETE
Si necesitamos cargar un paquete concreto utilizaremos el comando with indicando el nombre del
paquete. El resultado por pantalla es distinto según el finalizardor: con punto y coma se listan los
comando cargados, con dos puntos el paquete se carga pero no se nos indica nada.
> with(linalg);
> with(linalg):
Si utilizamos un comando de un paquete no cargado MAPLE no hará nada, simplemente
devolverá un eco del comando escrito.
DESCARGANDO UN PAQUETE
Si queremos descargar un paquete (lo que liberará memoria) utilizaremos el comando:
> restart;
LIBRERÍAS
Determinados comandos muy poco usados no están contenidos ni en el núcleo de MAPLE ni en
un paquete determinado. En vez de esto están en una librería general. Se pueden cargar con el
comando readlib.
Por ejemplo, el comando discont, que calcula puntos de discontinuidad de una función, se carga
de la siguiente manera:
> readlib(discont);
> discont(1/(x^2-1),x);
FACTORIALES
El factorial se indica con el signo admiración cerrada< !
> 45!;
NÚMEROS ALEATORIOS
Podemos obtener números aleatorios con el comando rand.
Sin argumento, rand() devuelve un número entero aleatorio de 12 dígitos:
> rand();
Pero podemos elegir el rango entre los que será elegido el número aleatorio:
> n:=rand(50..60):n();
El uso de % se puede reiterar hasta tres veces: %% se referirá al penúltimo resultado y %%% al
antepenúltimo:
> 2+2:
> 5-2:
> 2:
> %+%%+%%%;
VARIABLES
Una variable puede llamarse como queramos, siempre que no utilicemos como nombre de la
variable el de un comando de MAPLE. Tampoco podemos empezar el nombre de la variable con
números e interesa que no incluyamo códigos extraños (acentos, eñe, etc). Recordemos,
también, que MAPLE distingue entre mayúsculas y minúsculas.
ASIGNACIÓN DE VARIABLES
Para asignar valor a una variable se utiliza la combinación dos puntos e igual :=, por ejemlo:
> a:=13;
que devuelve como eco la asignación a la variable a del valor 13.
Si no queremos el eco debemos usar el terminados dos puntos.
> a:=25:
Ahora no hay eco y, además a ha cambiado de valor. Esto podemos comprobarlo preguntando el
valor de a:
> a;
BORRADO DE VARIABLES
Para borar el valor de una variable basta con igualarla a sí misma entre comillas simples:
> a:='a';
Si lo que queremos es borrar todas las variables asignadas podemos utilizar el comando restart
> restart;
EJEMPLO Y COMANDO PRINT
Vamos a calcular el capital final que se retira después de tener 8 años 3000 euros al 4%:
> ci := 3000:
> t := 8:
> redito := 4:
> cf:=ci*(1+redito/100)^t;
Para poner la salida de forma más legible usaremos los comandos print y el ya conocido evalf:
> print(`El capital final es de `,evalf(cf));
El comando print permite poner entre paréntesis lo que va a salir por pantalla. Si queremos que
sea texto se encerrará entre los acentos agudos (^) que aparecen en la tecla a la derecha de la P
(junto con [ y ^). Las diferentes partes de la salida se separan con comas. Como único
inconveniente de print decir que estas comas separadoras aparecen en la salida por pantalla.
CONVERSIÓN DE TIPOS
A veces puede ser útil convertir una variable de un tipo a otro. Esto se realiza con el comando
convert, que recibe dos argumentos: la variable y el tipo final.
Para ver un listado de los tipos de variables teclea:
> ?convert
o, también:
> ?type
Por ejemplo:
> convert(117,binary);
TIPOS DE ESTRUCTURAS
CONJUNTOS (SET)
DEFINICIÓN
Por extensión
Un conjunto se define por extensión enumerando sus elementos entre llaves:
> dias:={lunes,martes,miercoles,jueves,viernes,sabado,domingo};
Por comprensión
Se define un conjunto por comprensión dando una ley de formación. En MAPLE se usa el signo
dolar ($):
> pares:={2*i$i=1..10};
OPERACIONES
Las operaciones básicas con conjuntos son la union, intersección y diferencia, que en MAPLE
se hacen con los operadores union, intersect y minus, respectivamente:
> A:={1,2,3,4,5,6,7,8,9,10} : B:={2,3,5,7,11,13}:
> A union B;
> A intersect B;
> A minus B;
LISTAS
Las listas se indican entre corchetes. Se diferencian de los conjuntos en que en la listas se
respeta el orden. Al igual que los conjuntos, las listas pueden definirs por extensión y por
comprensión (utilizando el signo $)
> vocales:=[a,e,i,o,u];
> pares:=[2*i$i=1..10];
MATRICES
Para definir una matriz (o un vector) utilizamos el comando array, indicando el número de filas y
despés el de columnas:
> A:=array(1..2,1..3);print(A);
MATRICES ESPECIALES
Hay ciertas matrices que pueden definirse de forma directa:
- La matriz nula con el parámetro sparse:
> N:=array(sparse,1..2,1..3);print(N);
- La matriz simétrica con el parámetro symmetric. Basta con llenar la mitad de la matriz, MAPLE
rellenará automáticamente el resto:
> S:=array(symmetric,1..3,1..3): S[1,1]:=1: S[1,2]:=2: S[1,3]:= 3: S[2,2]:=4: S[2,3]:=5:
S[3,3]:=6:print(S);
PROGRAMACIÓN
En MAPLE podemos definir procedimientos que realicen ciertas operaciones y llamarlos cuando
los necesitemos. Vamos a ver un ejemplo sencillo.
Supongamos que en una cierta hoja de trabajo vamos a necesitar calcular constantemente la
velocidad final con la que llega al suelo un cuerpo que cae, en caída libre, desde h metros.
Vamos a definir el procedimiento vfinal:
> vfinal:=proc(h)
> sqrt(2*9.8*h):
> end:
Aquí podemos ver:
1.- hemos asignado al procedimiento el nombre vfinal, ahí el uso de :=
2.- la palabra clave para definir un procedimiento es proc. Después se ponen, entre paréntesis y
separadas por comas las variables que mandamos desde el exterior y que serán usadas dentro
del procedimiento
3.- en este caso concrero el procedimiento consta de una sóla línea que calcula el valor buscado
4.- el procedimiento termina con el comando end:
Para usar este procedimiento, por ejemplço si la altura fuera 10, haríamos:
> vfinal(10);
> TERNAP(2.3,5);
También es posible dejar el procedimiento sin entradas, en cuyo caso se dejan los paréntesis
vacíos.
VARIABLES
Las variables usadas dentro del procedimiento pueden ser locales o globales.
Una variable local se declara con el comando local seguido del nombre de las variables
separados por comas. Una variable local sólo tiene existencia dentro del procedimiento.
Una variable global se declara con el comando global seguido del nombre de las variables
separados por comas. Una variable global tiene validez una vez hayamos salido del
procedimiento.
RECURSIVIDAD
Un procedimiento puede llamar a otro e incluso llamarse a sí mismo. En este último caso es
necesario tener cuidado para poner la condición de salida. Es clásico el ejemplo del factorial de
un número por su elegancia:
> FACT:=proc(n::integer)
> if (n<=0) then 1 else n*FACT(n-1) fi
> end:
> FACT(500);
En el caso de que la recursividad alcance muchos ciclos es posible que se sature le memoria.
Para evitar esto pondremos como segunda línea option remember; que hace que MAPLE
construya una tabla con los valores ya calculados.
CONDICIONALES
if then else fi
La sentencia condicional se inicia con if que probará si se cumple una cierta condición, por
ejemplo a=b. Si esta condición se cumple se ejecutarán los comando escritos después de then,
en caso contrario se ejecutarán los comandos escritos después de else (es parte del condicional
es opcional). El condicional termina con fi (que es if al revés).
> DISCRIM1:=proc(a,b,c)
> if (b^2-4*a*c<0) then print(`Discriminante negativo`) fi
> end:
> DISCRIM1(1,2,3);
> DISCRIM2:=proc(a,b,c)
> local d:
> d:=b^2-4*a*c:
> if d<0 then print(`No tiene soluciones reales`)
> else print(`Si tiene soluciones reales`)
> fi
> end:
> DISCRIM2(3,4,1);
BUCLES
En general la estructura de un bucle es for variable to tope do sentencias do;
En este caso la variable contadora empieza en 1 y va aumentando de 1 en 1 hasta alcanzar el
tope:
> for i to 4 do i^2 od;
NÚMEROS ENTEROS
ARITMÉTICA EXACTA
MAPLE permite trabajar con enteros de enorme tamaño. Por ejemplo: calcular el número de ceros
en los que acaba el factorial de 50:
> 50!;
Para saber el número total de dígitos que tiene este número utilizamos el comando length
> length(%);
Por ejemplo, podemos tratar de ver si Z[4] es un Dominio de Integridad (anillo sin divisores de
cero) hallando su tabla de multiplicación: ([0], [1], [2], [3])x([0],[1],[2],[3])
> A:=[0,1,2,3] ; B:=[0,1,2,3];
> for i to 4 do for j to 4 do print(A[i],B[j],A[i]*B[j] mod 4) od od;
Podemos ver como el producto 2*2 = 0 en Z[4], luego Z[4] no es un Dominio de Integridad
NÚMEROS PRIMOS
MAPLE permite utilizar números primos con gran facilidad.
Podemos saber si un número es primo con el comando booleano isprime:
> isprime(13453);
Podemos obtener los primos anterior y siguiente de un número dado con los comandos
prevprime y nextprime:
> prevprime(13453),nextprime(13453);
También podemos obtener el i-ésimo primo de la tabla de primos con el comando ithprime:
> ithprime(34);
DIVISORES
MAPLE permita hallar todos los divisores de un número entero, para lo cual hay que cargar el
paquete numtheory
> with(numtheory):
> divisors(36);
NÚMEROS REALES
Ya sabemos que los números reales resultan de la unión de los racionales e irracionales.
NÚMEROS RACIONALES
En el caso de operaciones con quebrados se devuelve el resultado más simplificado.
> 36/30;
Si queremos que el quebrado se opere hasta el final podemos hacer dos cosas.
1.- Poner alguno de los números con coma decimal:
> 36/30.0;
NÚMEROS IRRACIONALES
RADICALES
En general, si p no es potencia n-ésima, entonces la raíz n-ésima de p es irracional.
Para obtener la raíz cuadrada de un número utilizamos el comando sqrt (square root). Para que
se evalúe la raíz utilizamos evalf:
> sqrt(13) = evalf(sqrt(13));
Caso de necesitar únicamente la parte entera de la raíz utilizaremos isqrt (integer square root ):
> isqrt(13);
Para raíces de índice superior utilizaremos la expresión potencial (elevando al número racional),
por ejemplo, la raíz quinta de 13 será:
> 13^(1/5) = evalf(13^(1/5));
SIMPLIFICACIÓN DE RADICALES
Como con otras expresiones, los radicales se simplifican con el comando simplify:
> 32^(3/15) = simplify(32^(3/15));
RACIONALIZACIÓN DE DENOMINADORES
Utilizaremos el comando rationalize:
> (a-1)/(sqrt(a)-1) = rationalize((a-1)/(sqrt(a)-1));
EL NÚMERO e
El número e es, posiblemente, el número más importante en matemáticas superiores. Aparece en
muchos procesos de crecimiento, en la desintegración radiactiva, en la fórmula de la catenaria,
etc. Podemos obtenerlo a través del siguiente límite:
> Limit((1+1/n)^n,n=infinity) = evalf(limit((1+1/n)^n,n=infinity));
En MAPLE se escribe con e minúscula y podemos obtenerlo con exp(1) y la precisión que
deseemos:
> e = evalf(exp(1),25);
La parte entera de un número se obtiene con trunc y la parte decimal con frac:
> trunc(5.78);frac(5.78);
Para conseguir todos los decimales que queramos damos, como segundo argumento de evalf, el
número de decimales requerido.
> evalf(1/7,50);
LOGARITMOS Y EXPONENCIALES
MAPLE calcula de forma directa los logaritmos neperianos con ln() ó log(). Para que se evalue
hay que utilizar evalf:
> ln(10) = evalf(ln(10));
Podemos utilizar los comandos expand o simplify para desarrollar expresiones con logaritmos y
potencias:
> simplify(log(3*a/5*b^2));
> L(1)=evalf(L(1));
> L(2)=evalf(L(2));Ln(2)=evalf(ln(2));
> convert(210*degrees,radians);
LÍNEAS TRIGONOMÉTRICAS
Las líneas trigonométricas en MAPLE se corresponden con los comandos: sin, cos y tan, que
reciben como argumento el ángulo en radianes:
> sin(3*Pi/2);cos(Pi/4);tan(Pi/3);
MAPLE conoce todas las relaciones entre líneas trigonométricas. Podemos utilizar los comandos
simplify y expand para desarrollar una expresión trigonométrica:
> sin(alpha-beta) = expand(sin(alpha-beta));
Vamos a calcular la expresión del coseno del ángulo (a-b) entre los vectores u y v, para ello
haremos uso del comando angle del paquete linalg. Este comando devuelve el arccos el ángulo.
Por esto evaluamos su coseno y le pedimos a MAPLE que lo simplifique:
> with(linalg):
> u:=vector([cos(a),sin(a)]);v:=vector([cos(b),sin(b)]);
> cos(a-b):=simplify(cos(angle(u,v)));
Ahora podemos calcular el seno de la resta y coseno y seno de la suma sustituyento el ángulo b
por determinados valores y pidiendo a MAPLE que simplifique la expresión:
> cos(a+b):=simplify(subs(b=-b,cos(a-b)));
> sin(a-b):=simplify(subs(b=b+Pi/2,cos(a-b)));
> sin(a+b):=simplify(subs(b=-b,sin(a-b)));
TRIGONOMETRÍA HIPERBÓLICA
Las funciones hiperbólicas en MAPLE son: sinh, cosh, tanh y sus inversas arcsinh, arccosh y
arctanh.
MAPLE conoce las diferentes relaciones entre las líneas hiperbólicas.
>cosh(alpha)^2-sinh(alpha)^2 = simplify(cosh(alpha)^2-sinh(alpha)^2);
NÚMEROS COMPLEJOS
LA UNIDAD IMAGINARIA I
En MAPLE la unidad imaginaria (raíz cuadrada de -1) se escribe con I mayúscula. Sus potencias
son:
> for i from 0 to 3 do print(`i elevado a`,i,`da`,I^i) od;
Si lo que queremos es pasar un complejo en forma polar a forma binómica usamos evalc (evalue
complex):
> evalc(z);
FORMA EXPONENCIAL-TRIGONOMÉTRICA
Utilizando la Fórmula de Euler (que podemos obtener utilizando series):
> exp(ix) = cos(x) + I*sin(x);
> convert(5*exp(I*4),trig);
EXPRESIONES RootOf
El comando RootOf pemite definir números como raíces de un polinomio. Si deseamos conocer
todos los valores debemos usar el comando allvalues:
> a:=RootOf(x^5+9*x^3-4*x^4-14*x^2+14*x-12);
> allvalues(a);
> (z1*z2)^2;
> z2/z1;
RAÍCES DE UN COMPLEJO
Para hallar todas las raíces de un complejo deberemos obtener todos los valores (allvalues ) de
una expresión RootOf. Para hallar todas las raíces cúbicas de I planteamos la ecuación:
> z:=(-1)^(1/3) ; ec:=convert(z,'RootOf');
> allvalues(ec);
CONJUGADO
Podemos obtener la parte real y la parte imaginaria de un complejo con Re e Im,
respectivamente:
> z:=3-2*I;Re(z),Im(z);
LOGARITMO DE UN COMPLEJO
Para tomar el logaritmo de un complejo utilizaremos éste en forma exponencial:
> z:=r*exp(I*theta);
> lnc(I);
Por ejemplo para calcular i^i (la unidad imaginaria elevada a sí misma) haremos:
> I^I = exp(I*Ln(I));
Por lo tanto:
> I^I = exp(-Pi/2);
Claro que no hace falta tanto proceso: MAPLE realiza este tipo de operaciones con evalc:
> evalc(I^I);
COMBINATORIA
Los comandos relativos a combinatoria están en el paquete combinat.
VARIACIONES
Para calcular el número de variaciones sin repetición de m elementos tomados de n en n
utilizamos el comando numbperm del paquete combinat. Como primer argumento damos el
número de elementos totales y como segundo argumento el tamaño de cada grupo.
> with(combinat):
> V(5,2) = numbperm(5,2);
> restart:
PERMUTACIONES
El comando de MAPLE que permite calcular el número de permutaciones sin repetición de m
elementos es numbperm del paquete combinat. En este caso únicamente se da un argumento:
m
> with(combinat):
> P(5) = numbperm(5);
> restart:
En el caso de ser pocos elementos MAPLE permite listar las permutaciones posibles con el
comando permute:
> with(combinat):permute(4);rstart:
> with(combinat):permute([as,reina,rey]);restart:
Para obtener las permutaciones con repetición podemos recurrir a la fórmula teórica con el uso
de factoriales o al comando multinomial del paquete combinat. Por ejemplo si queremos hallar
las permutaciones con repetición de 10 letras: a,a,a,b,b,c,c,c,c,d haremos:
> with(combinat):multinomial(10,3,2,4,1);restart:
COMBINACIONES
Para hallar el número de combinaciones sin repetición de m elementos tomados de n en n
podemos utilizar el comando numbcomb o el comando binomial, que devuelve el número
combinatorio:
> with(combinat):C(5,2)=numbcomb(5,2);C(5,2)=binomial(5,2);restart:
POLINOMIOS
DEFINICIÓN Y GRADO
Para definir un polinomio basta con asignarlo a una variable:
> q:=3*x^4-2*x*y^2+2*x*y-1;
Incluso podemos pedir a MAPLE que genere un polinomio aleatoriamente con randpoly, basta
con decirle las variables y el número de monomios que deseamos, por ejemplo, un polinomio de 4
monomios en a, b y c:
> p:=randpoly([a,b,c],terms=4);
Si queremos ver el grado del polinomio p podemos hacerlo globalmente o por cada una de sus
variables:
> degree(p),degree(p,a),degree(p,b),degree(p,c);
Podemos pedir a MAPLE que ordene un polinomio en el grado de la variable que deseemos, por
ejemplo:
> sort(q,y);
OPERACIONES BÁSICAS
SUMA, RESTA Y MULTIPLICACIÓN
Basta con usar los operadores habituales. Por ejemplo, sea:
> p:=3*x^4-4*x^2+3*x-1 : q:=3*x^2-2*x+3:
> p+q,p-q;
> 2*p-5*q;
> expand(p*q);
POTENCIA DE POLINOMIOS
Con la potencia ocurre igual que con el producto de polinomios, MAPLE se limita a dejarla
indicada siendo necesario pedirle que la expand a:
> (2*x-3*y)^4,expand((2*x-3*y)^4);
BINOMIO DE NEWTON
Utilizando MAPLE podemos desarrollar diferentes potencias del binomio (a+b) para tratar de
obtener la fórmula de Newton:
> (a+b)^0;(a+b)^1;expand((a+b)^2);expand((a+b)^3);expand((a+b)^4);
Si observamos con detenimiento veremos que la fórmula para obtener la potencia (a+b)^n es:
> (a+b)^n,Sum(binomial(n,i)*a^(n-i)*b^i,i=0..n);
Donde binomial(n.i) es un comando de MAPLE que halla el número combinatorio "n sobre i". Por
ejemplo para n=5 obtendremos el binomio de quinto grado:
> n:=5:sum(binomial(n,i)*a^(n-i)*b^i,i=0..n);
Un detalle de MAPLE: si usas sum, en minúscula, se calcula la suma; pero si usas Sum, en
mayúscula, únicamente se pone la fórmula (es lo que se llama expresión inerte).
FACTOR COMÚN
Para extraer factor común se utiliza el comando collect, indicando sobre qué polinomio actuar y
qué queremos sacar factor común:
> p:=3*x^2+4*y^2-5*x^2*y-4*x^3*y^2;
> collect(p,x);
DIVISIÓN DE POLINOMIOS
Si realizamos la división de polinomios utilizando el operador / no obtendremos los resultados
deseados, por ejemplo sean los polinomios p y q:
> p:=6*x^6-7*x^5+4*x^4-10*x^3-x^2+5*x: q:=2*x^2-x:
Vamos a realizar la operacion p/q e incluso a pedir que la expand a:
> p/q;expand(p/q);
Como podemos ver no hace la división entera de polinomios, para ello tenemos que usar los
comandos quo y rem que nos devolverán el cociente y el resto de la división, respectivamente.
Como parámetros hay que dar el polinomio dividendo, el polinomio divisor y la variable respecto
de la que dividimos:
> quo(p,q,x);rem(p,q,x);
FRACCIONES ALGEBRAICAS
Las fracciones algebraicas son aquellas cuyo numerador y denominador son polinomios. Una de
las operaciones básicas que podemos hacer con ellas es simplificarlas, si es posible. Para ello
utilizamos el comando simplify:
> p:=x^3-x^2-x+1 : q:=x^3+x^2-x-1:p/q;
> simplify(p/q);
Fracciones Simples
MAPLE es capaz de descomponer fracciones algebraica complejas en fracciones más simples.
Esto puede ser muy útil en el cálculo de ciertas integrales. Para hacer esto utlizamos en comando
convert, que recibe como primer parámetro la fracción a simplificar, como segundo parámetro la
palabra clave parfrac y como último parámetro la variable:
> p:=(4*x-2)/(x^3+3*x^2-x-3);
> convert(p,parfrac,x);
> factor(a^3-a^2*b-a*b^2+b^3);
También podemos hallar el MCD y MCM de dos polinomios con los comandos gcd y lcm,
respectivamente:
> p:=x^4-x^3-3*x^2+x+2 : q:=x^5-5*x^4+6*x^3+2*x^2-7*x+3:
> gcd(p,q);
> lcm(p,q);
FACTORIZACIONES EN Z[i]
También podemos factorizar en los anillos Z[i]. En MAPLE la unidad imaginaria se escribe I,
desplegando el menú View>Palettes>Symbol Palette: I es el último símbolo que aperece en la
ventana.
Por ejemplo, podemos factorizar x^2+4 en Z[i]:
> factor(x^2+4,I);
DESARROLLOS DE TAYLOR
Los polinomios de Taylor se utilizan para aproximar funciones en un determinado punto. Para ello
es necesario que la función tenga derivada hasta el orden n (n será el grado del polinomio de
Taylor) en dicho punto.
La expresión del polinomio de Taylor en x=a es:
> P(x)=Sum(D^i*[f(a)]/i!*(x-a)^i,i=0..n);
Si lo que queremos es hallar soluciones reales aproximadas, el comando es fsolve (float solve):
> fsolve(3*x-1=13,x);
ECUACIONES NO ALGEBRAICAS
MAPLE puede resolver diferentes tipos de ecuaciones no algebraicas (recordemos que las
ecuaciones algebraicas son aquellas que se pueden resolver efectuando operaciones
algebracias: suma, resta, multiplicación y división).
ECUACIONES CON RADICALES
En el caso de raíces cuadradas, estas ecuaciones se pueden convertir en algebraicas elevando al
cuadrado ambos miembros las veces que sea necesario. De todas formas MAPLE resuelve estas
ecuaciones sin incluir soluciones falsas (lo que si ocurre al convertirlas en algebraicas). El
comando sqrt indica raíz cuadrada. Por ejemplo:
> solve(sqrt(2*x-3)+1=x,x);
ECUACIONES TRIGONOMÉTRICAS
MAPLE resuelve las ecuaciones trigonométricas dando la solución para el primer periodo. Hay
que recordar que las funciones trigonométricas en MAPLE se escriben: sin(), cos() y tan() para el
seno, coseno y tangente, respectivamente. Por ejemplo:
> solve(sin(x)+cos(x)=1,x);
ECUACIONES EXPONENCIALES
MAPLE resuelve ecuaciones exponenciales recurriendo a logaritmos neperianos.
> solve(2^x=3);
Podemos incluso plantear ecuaciones "curiosas", como: ¿qué número elevado a sí mismo da 2?
> fsolve(x^x=2);
ECUACIONES RECURRENTES
Vamos a resolver el siguiente problema: "Un mono tiene una bolsa de cacahuetes. Cada mañana
su dueño le añade 100 cacahuetes. Luego, durante el día el mono se come la mitad de los
cacahuetes que hay en la bolsa. Una noche, después de varios años haciendo esto, el dueño
contó los cacahuetes ¿cuántos cacahuetes habrá en la bolsa?"
Planteamos la siguiente ecuación recurrente: la noche del día k+1 en la bolsa habrá
x(k+1)=(100+x(k))/2 porque al iniciar el día había x(k) cacahuetes, a los que el dueño añade 100,
pero luego el mono se come la mitad...
¿Cómo resolvemos esta ecuación recurrente? Utilizamos el comando rsolve, en el que los
argumentos son la propia ecuación recurrente y la función incógnita:
> rsolve(x(k+1)=50+x(k)/2,x);
Como pasan muchos años tomas el límite de la función obtenida cuando k tiende a infinito.
> limit(%,k=infinity);
Esto quiere decir que habrá 100 cacahuetes en la bolsa.
Para informate mejor del comando rsolve teclea:
> ?rsolve
ECUACIONES DIOFÁNTICAS
Las ecuaciones diofánticas son aquellas cuyas soluciones son números enteros.
Por ejemplo, si deseamos llevar 430 euros en billetes de 50 y 20 euros.. 1) ¿es posible? 2) en
caso de ser posible ¿cuántos billetes de cada hay que coger?
> isolve(50*x+20*y=430);
Obtenemos un conjunto de soluciones sustituyendo _NI por números enteros, por ejemplo:
> for i from -5 to 5 do print(`x=`,1+2*i,`y=`,19-5*i) od;
donde nos quedaríamos con las parejas de soluciones positivas,por ejemplo (1,19), es decir 1
billete de 50 y 19 de 20, etc.
ECUACIONES DIFERENCIALES
En ingeniería y el ciencias hay muchos problemas que, cuando se formulan en términos
matemáticos, requieren la determinación de una función que debe satisfacer una ecuación que
contiene derivadas de la propia función desconocida. Estas ecuaciones se denominan
ecuaciones diferenciales.
Por ejemplo, para determinar el movimiento de una partícula sobre la que actúa la fuerza de la
gravedad, es necesario determinar una función u(t) que satisfaga la siguiente ecuación:
> ec1:=m*diff(u(t),t$2)=-m*g;
El comando de MAPLE para resolver ecuaciones diferenciales es dsolve, que recive dos
parámetros: la ecuación diferencial y el nombre de la función incógnita:
> dsolve(ec1,u(t));
Como podemos ver, aparecen _C1 y _C2, que son constantes que se pueden determinar si se
conocen las condiciones iniciales.
El paquete DEtools contiene comandos sobre ecuaciones diferenciales. Interesa echarle un
vistazo:
> ?DEtools
También es interesante que veamos la explicación del comando que resuelve ecuaciones
diferenciales:
> ?dsolve
El comando dsolve admite, como tercer argumento, que se le inidique el método de resolución de
la ecuación diferencial:
- poniendo method=laplace, utilizará la transformada de Laplace
- poniendo type=series, se obtendrá una serie como solución aproximada
- poniendo type=numeric, se obtendrá una solución numérica utilizando un Runge-Kutta de
orden 4-5.
CONDICIONES INICIALES
Cuando conocemos las condiciones iniciales podemos hallar una solución particular de la
ecuación diferencial. Las condiciones iniciales se incluyen en el comando dsolve haciendo un
conjunto cuyo primer elemendo es la ecuación a resolver, y después las condiciones iniciales
separadas por comas.
Encontrar la solución de y'=y^2 sabiendo que y(0)=1:
> ec:=diff(y(x),x)=y(x)^2;
> dsolve({ec,y(0)=1},y(x));
Podemos comprobar que la solución obtenida cumple la ecuación planteada. Para ello debemos
coger la parte derecha (comando rhs, right side) de la última salida (comodín %) y sustituirla en la
ecuación:
> y:=unapply(rhs(%),x);
> ec;
Ahora vamos a sustituirla en la ecuación y a simplificar la expresión para ver que, en efecto, se
cumple la ecuación:
> simplify(subs(u(x,t)=rhs(%),ec));
INECUACIONES
Se resuelven utilizando el comando solve. En la solución se indica si el intervalo es abierto con
Open.
> solve(x-1>5);
> solve(x^2+2*x-3>=0);
EIGENVALORES Y EIGENFUNCIONES
La ecuación matricial formada a partir de un sistema de ecuaciones: Ax = y puede imaginarse
como una transformación lineal de un vector dado x en un nuevo vector y.
En este tipo de transformaciones los vectores que se transforman en múltiplos de sí mismos
tienen múltiples aplicaciones (por ejemplo, en el problema de encontrar los ejes principales de los
esfuerzos de un cuerpo elástico, o en el caso de encontrar los modos de vibración libre en un
sistema conservativo con un número finto de grados de libertad).
Para encontrar estos vectores haremos:
> y=lambda*x;
siendo lamda un factor escalar. Por lo tanto buscaremos soluciones de la ecuación:
> A*x=lambda*x;
> with(linalg):Id:=diag(1,1,1):(A-lambda*Id)*x=0;
Los valores de lambda que satisfacen esta ecuación se denominan eigenvalores o valores
propios de la matriz A y las soluciones que se obtienen utilizando estos eigenvalores en la
ecuación Ax=lambda·y se denominan eigenvectores, o vectores propios, asociados a ese
eigenvalor.
Vamos a encontrar los eigenvectores y eigenvalores de la matriz A:
> A:=matrix([[0,1,1],[1,0,1],[1,1,0]]);Id:=matrix([[1,0,0],[0,1,0],[0,0,1]]);
> B:=evalm(A)-lambda*evalm(Id);evalm(B);
> eigenvectores:=eigenvectors(A);restart:
En este tipo de sistemas es más útil pintar las soluciones. Para ello necisatamos cargar el
paquete plots, y utilizar el comando inequal. Este comando tiene como argumentos el conjunto
de inecuaciones, el rango en X, el rango en Y y la posibilidad de indicar el color de las diferentes
zonas. Interesa ver las diferentes opciones del comando:
> ?inequal
> with(plots):
> inequal({2*x-y<=3,2*x+y<3},x=-3..3,y=-
5..5,optionsfeasible=(color=green),optionsopen=(color=blue,thickness=2),optionsclosed=(c
olor=red, thickness=3),optionsexcluded=(color=yellow));
> restart:
En este ejemplo hemos pedido: - La zona solución en color verde; - La zona excluida en color
amarillo; -Las fronteras abiertas en color azul; - Las fronteras cerradas en color rojo.
SISTEMAS DE ECUACIONES DIFERENCIALES ORDINARIAS
Para resolver un sistema de ecuaciones diferenciales MAPLE dispone del comando dsolve, al
que hay que dar el conjunto de las ecuaciones (y condiciones iniciales si las hubiere) y el conjunto
de las funciones incógnita:
> ec1:=diff(x[1](t),t)=x[1](t)+x[2](t);
> ec2:=diff(x[2](t),t)=4*x[1](t)+x[2](t);
> soluciones=dsolve({ec1,ec2},{x[1](t),x[2](t)});
Si conocemos condiciones iniciales los incluímos con las ecuaciones:
> restart:
> ec1:=diff(x(t),t)=x(t)-5*y(t);
> ec2:=diff(y(t),t)=x(t)-3*y(t);
> dsolve({ec1,ec2,x(0)=1,y(0)=1},{x(t),y(t)});
MATRICES Y VECTORES
VECTORES
Para definir un vector utilizamos el comando vector, dando las componentes del vector en forma
de lista:
> v:=vector([1,2,3,4,5]);
En el caso de necesitar que una lista se convierta en vector, podemos usar el comando convert
con la opción vector.
Para transferir el contenido de un vector a otro se utiliza el comando copy:
> w:=copy(v);
> evalm(u-v);
PRODUCTO ESCALAR
El producto escalar se calcula a través del comando dotprod del paquete linalg, que recibe
como parámetros los dos vectores que se multiplican. Está definido considerando que los
vectores pueden ser complejos. Esto quiere decir que dotprod de los vectores u y v, devuelve el
producto escalar de u por el conjugado de v (esto permite calcular el módulo de un complejo):
> u:=vector([u1,u2*I]);v:=vector([v1,v2*I]);
> with(linalg):dotprod(u,v);restart:
Si se necesitara calcular el producto escalar de u por v sin utilizar el conjugado podemos hacerlo
con dotprod del paquete linalg, utilizando como tercer parámetro la opción 'orthogonal':
> u:=vector([u1,u2*I]);v:=vector([v1,v2*I]);
> with(linalg):dotprod(u,v,'orthogonal');restart:
MAPLE tiene el comando norm del paquete linalg. Damos como primer parámetro el vector y
como segundo parámetro el índice de la raíz para calcular el módulo (2).
> with(linalg):v:=vector([I,-2,3*I]):norm(v,2);restart:
De todas formas MAPLE puede normalizar un vector directamente con el comando normalize del
paquete linalg.
> with(linalg):
> V:=([I,1,2*I]);
> U:=normalize(V);
> restart:
De todas formas MAPLE permite hallar el ángulo entre dos vectores con el comando angle del
paquete linalg. El resultado aparece en radianes.
> u:=vector([1,0]);v:=vector([1,1]);
> with(linalg):
> angulorad:=angle(u,v);
> angulograd:=convert(angulorad,degrees);
> restart:
PRODUCTO VECTORIAL
El producto vectorial se consigue con el comando crossprod del paquete linalg.
> with(linalg):
> u:=vector([1,0,0]);v:=vector([0,1,0]);
> uxv:=crossprod(u,v);
> restart:
Como podemos ver, el vector resultante es perpendicular al plano definido por los otros dos
vectores.
Interpretación geométrica
El producto vectorial de dos vectores u y v se puede interpretar como el área del paralelogramo
definido por los dos vectores (tomando el módulo de producto vectorial, naturalmente).
Por ejemplo, si queremos hallar el área del triángulo cuyos vértices tienen por coordenadas A(3,-
1,2), B(0,1,2) y C(2,2,2) haremos lo siguiente:
Hallamos los vectores u=AB y v=AC y obtenemos la mitad del modulo del producto vectorial
(porque el área del triángulo es la mitad del área del paralelogramo):
> u:=vector([0-3,1-(-1),2-2]);v:=vector([2-3,2-(-1),2-2]);
> with(linalg):
> area=1/2*norm(crossprod(u,v),2);
> restart:
ANÁLISIS VECTORIAL
GRADIENTE
El gradiente de una función escalar f(x,y,z), continua y derivable, es una función vectorial que se
obtiene calculando sus derivadas parciales con respecto a cada una de las coordenadas. MAPLE
permite calcular el gradiente de una función escalar con el comando grad del paquete linalg, que
recibe como primer argumento la expresión de la función, y como segundo argumento la lista de
las variables.
> restart:
> `grad`(f)=(Diff(f,x),Diff(f,y),Diff(f,z));
El operador gradiente es comunmente utilizado en Física. Por ejemplo, el campo eléctrico (E) es
una función vectorial que resulta de aplicar el gradiente a la función potencial: E = -grad(V)
> with(linalg):
> V:=x^2+y^2+z^2;E:=-grad(V,[x,y,z]);
> restart:
DIVERGENCIA
El operador divergencia actúa sobre una función vectorial F (Fx,Fy,Fz) devolviendo un escalar. En
coordenadas cartesianas la divergencia se expresa:
> div(F)=Diff(Fx,x)+Diff(Fy,y)+Diff(Fz,z);
En este resultado la divergencia del campo eléctrico es positiva. Tenemos, por lo tanto, una
fuente.
En este otro caso la divergencia resulta ser nula:
> Ex:=6*x*y:Ey:=3*x^2-3*y^2:Ez:=0:
> e:=[Ex,Ey,Ez];
> with(linalg):
> divergencia(E)=diverge(e,[x,y,z]);
> restart:
ROTACIONAL
El operador rotacional actúa sobre una función vectorial y devuelve otra función vectorial. Desde
el punto de vista de la Física el rotacional distinto de cero significa que el campo tiene circulación,
o turbulencia. Por ejemplo, el campo de velocidades del agua al vaciar una bañera adquiere,
generalmente, una circulación. Su rotacional no es cero en la mayor parte de la superficie
(cualquier cuerpo que flote en la superficie gira mientras avanza).
MAPLE dispone del comando curl del paquete linalg para calcular el rotacional. Como
parámetros es necesario dar la función vectorial y la lista de variables.
> with(linalg):
> f1:=x*y*z:f2:=3*x^2*z:f3:=-2*y*z^2:
> F:=[f1,f2,f3];rot(f)=curl(F,[x,y,z]);
> restart:
LAPLACIANA
El operador laplaciana se puede considerar como "la divergencia del gradiente", es decir,
partiendo de una función escalar aplicamos el gradiente, por lo que obtenemos la variación de
dicha función en las tres direcciones del espacio. Ahora aplicamos sobre esta función vectorial
recien hallada el operador divergencia, por lo que volvemos a obtener una función escalar.
En coordenadas cartesianas la laplaciana tiene la siguiente forma:
> laplaciana(f)=Diff(f,x$2)+Diff(f,y$2)+Diff(f,z$2);
El comando de MAPLE que hace de operador laplaciana es laplacian, del paquete linalg. Este
comando recibe como argumentos la función escalar y la lista de variables:
> with(linalg):
> f:=x^2+y^2+z^2:
> laplaciana(f)=laplacian(f,[x,y,z]);
> restart:
Dondequiera que la densidad de carga sea nula (todas las regiones del espacio que no contienen
carga eléctrica) el potencial eléctrico V tiene que satisfacer la ecuación de Laplace:
> laplaciana(V)=0;
Matriz de Vandermonde:
> vandermonde([a,b,c]);
Matriz diagonal:
> diag(a,b,c);
Matriz jacobiana: se aplica sobre funciones vectoriales, evaluándose en cada fila las dereivadas
parciales de cada componente de la función con respecto a cada una de las variables. El
comando es jacobian.
> f=f(fx,fy,fz),jacobiano=matrix([[Diff(fx,x),Diff(fx,y),Diff(fx,z)],[Diff(fy,x),Diff(fy,y),Diff(fy,z)],
[Diff(fz,x),Diff(fz,y),Diff(fz,z)]]);
> f:=[x*y*z,x^2+y^2+z^2,y]:
> funcion=f,jacobiana=jacobian(f,[x,y,z]);
> a+b=evalm(a+b);
> 3*a=evalm(3*a);
> 4*a-2*b=evalm(4*a-2*b);
MULTIPLICACIÓN DE MATRICES
Para multiplicar dos matrices es necesario utilizar la combinación de símbolos &*, dado que este
producto no es conmutativo. Tenemos que recordar que, para que dos matrices se puedan
multiplicar, es necesario que el número de columnas de la primera coincida con el número de filas
de la segunda. Para evaluar el resultado utilizaremos el comando evalm.
> a:=matrix([[a11,a12,a13],[a21,a22,a23]]);b:=matrix([[b11,b12],[b21,b22],[b31,b32]]);
> evalm(a&*b);
Como caso especial comentar que si multiplicamos un vector fila (1xM) por una matriz (MxN)
obtendremos otro vector fila (1xM)
> v:=vector([v1,v2]):
> evalm(v)&*evalm(a)=evalm(v&*a);
Si multiplicamos una matriz (MxN) por un vector columna (Nx1) obtendremos otro vector columna
(Mx1), aunque MAPLE devuelva el resultado en forma de vector fila.
> w:=vector([w1,w2,w3]):
> evalm(a)*evalm(w)=evalm(a&*w);
Si queremos el resultado en forma de vector columna debemos definir el vector como una matriz
de tres filas y una única columna:
> a:=matrix([[1,2,3],[4,5,6]]):v:=matrix([[-1],[0],[1]]):
> evalm(a)*evalm(v)=evalm(a&*v);
POTENCIA DE MATRICES
Elevar una matriz a una potencia significa multiplicarla por sí misma tantas veces como sea
necesario, por lo tanto únicamente podremos calcular la potencia de matrices cuadradas, o de lo
contrario no se podrían multiplicar. Para indicar la potencia utilizamos el operador ^ y el comando
evalm para visualizar el resultado.
> a:=matrix([[1,I],[-I,1]]);
> evalm(a^2);
> evalm(a^4);
MATRIZ TRASPUESTA
La traspuesta At de una matriz A se obtiene intercambiando las filas y las columnas de A. MAPLE
utiliza el comando transpose, del paquete linalg, para obtener la traspuesa de una matriz:
> with(linalg):
> A:=matrix([[3,2-I],[4+3*I,-5+2*I]]);At:=transpose(A);
> restart:
MATRIZ CONJUGADA
La conjugada de una matriz se consigue reemplazando cada elemento de la matriz por su
conjugado. El comando conjugate aplicado sobre una matriz realiza esta tarea. Si queremos
visualizar la matriz debemos utilizar el comando evalm:
> A:=matrix([[3,2-I],[4+3*I,-5+2*I]]);conjugate(A)=evalm(conjugate(A));
MATRIZ ADJUNTA
La matriz adjunta de otra es la traspuesta de su matriz conjugada. Maple obtiene la adjunta de
una matriz con la combinación de los comando conjugate y transpose del paquete linalg:
> with(linalg):
> A:=matrix([[3,2-I],[4+3*I,-5+2*I]]);
> Aadj=transpose(conjugate(A));
> restart:
MATRIZ INVERSA
Se define la matriz inversa de A a otra tal que multiplicada por A da la matriz identidad. No todas
las matrices tienen inversa (en primer lugar hay que decir que únicamente se define la inversa de
matrices cuadradas). En el caso de que una matriz no tenga inversa se denomina singular.
El cálculo de una matriz inversa es largo y tedioso, pero MAPLE puede calcular la inversa de una
matriz de dos formas distintas: evaluando 1/A ó elevando A^(-1)
> A:=matrix([[1,-1,-1],[3,-1,2],[2,2,3]]);
> Ainv:=evalm(1/A);
> Ainv:=evalm(A^(-1));
En el caso de que queramos hallar la inversa de una matriz singular, MAPLE devuelve un error:
> B:=matrix([[1,2],[2,4]]);evalm(1/B);
Para multiplicar todos los elementos de una fila, o de una columna, por un escalar se utilizan los
comando mulrow y mulcol, respectivamente, del paquete linalg. Como argumentos se dan la
matriz, la posición de la fila o columna y el escalar:
> A=evalm(A),fila2por3=mulrow(A,2,3),columna3por_k=mulcol(A,3,k);
También es posible multiplicar todos los elementos de una fila, o columna, por un escalar y sumar
el resultado a otra fila, o columna. Para esto se utilizan los comando addrow y addcol,
respectivamente, del paquete linalg. Como argumentos damos la matriz; la posición de las fila, o
columna, que va a ser multiplicada; la posición de la fila, o columna, a la que vamos a sumar la
anterior; y el valor del escalar:
> A=evalm(A),fila1+fila2_por3=addrow(A,2,1,3),col3+col1_por(-1)=addcol(A,1,3,-1);
Con todos estos comandos podemos triangular una matriz dada. Por ejemplo:
> A=evalm(A);
> A1:=swaprow(A,1,3):A2:=addrow(A1,1,2,1):A3:=addrow(A2,1,3,-2):
> swapfil1y3=evalm(A1),fila2+fila1por(1)=evalm(A2),fila3+fila1por(-2)=evalm(A3);
> A4:=addrow(A3,2,3,3):fila3+fila2por3=evalm(A4);restart:
De todas formas MAPLE es capaz de hacer todo este proceso por sí solo, con el comando
gausselim (eliminación gaussiana) del paquete linalg, que recibe como parámetro la matriz
inicial:
> with(linalg):A:=matrix([[2,-1,-1],[-1,1,-2],[1,-2,3]]);gausselim(A);restart:
RANGO
Podemos obtener el rango de una matriz con el comando rank, del paquete linalg:
> A:=matrix([[1,2,3],[4,5,6],[2,4,6]]):
> with(linalg):
> A=evalm(A),rango=rank(A),eliminacion_gaussiana=gausselim(A);
> restart:
DETERMINANTES
Para calcular el valor de un determinante MAPLE tiene el comando det del paquete linalg. Como
argumento damos la matriz (cuadrada evidentemente) cuyo determinante queremos hallar.
> A:=matrix([[1,0,2],[-2,-4,5],[0,1,-1]]);
> with(linalg):
> Det(A)=det(A);
> restart:
VOLUMEN DE UN TETRAEDRO
Para hallar el volumen de un tetraedro de vértices A(a1,a2,a3), B(b1,b2,b3), C(c1,c2,c3) y
D(d1,d2,d3) podemos utilizar el determinante de la siguiente matriz:
> M:=matrix([[b1-a1,c1-a1,d1-a1],[b2-a2,c2-a2,d2-a2],[b3-a3,c3-a3,d3-a3]]);
Vamos a escribir un procedimiento que devuelva el volumen de un tetraedro dando sus vértices
como argumento:
> voltetra:=proc(a,b,c,d::list)
> local M,A,vol:
> A:=matrix([[1,1,1,1]]);
> with(linalg):
> M:=stackmatrix(A,transpose(matrix([a,b,c,d])));
> #stackmatrix apila dos matrices
> restart:
> vol:=1/6*det(M)
> end:
> vol=voltetra([2,3,1],[4,1,-2],[6,3,7],[-5,-4,8]);
La matriz de coeficientes debe tener rango 2, pues los dos vectores que definen el plano deben
ser linealmente independientes. Por los tanto, el sistema tendrá solución únicamente si el rango
de la matriz del sistema tiene rango 2 (si tuviera rango 3 el sistema sería incompatible). Por lo
tanto el determinante de la matriz del sistema debe ser nulo:
> Det(evalm(S))=0;
Podemos desarrollar este determinante, sacando factor común x,y,z, con el comando collect de
MAPLE:
> d:=det(S)=0:
> collect(d,[x,y,z]);
Podemos escribir un procedimiento que devuelva la ecuación que define un plano dando como
argumentos los vectores directores del plano y un punto del plano:
> ecuplano:=proc(v,w,m::list)
> local X,M,Ind,S;
> X:=matrix([[x,y,z]]):M:=matrix([m]):Ind:=evalm(X-M);
> with(linalg):
> S:=concat(transpose(matrix([v,w])),transpose(Ind)); #concat une matrices del mismo nº
de filas, una a la derecha de otra
> det(S)=0
> end:
> ec:=ecuplano([1,2,3],[2,0,1],[0,1,1]);
FUNCIONES
MAPLE permite dibujar funciones en el plano y en el espacio, para ello utiliza los comandos plot y
plot3d, respectivamente.
FUNCIONES EN EL PLANO
DEFINICIÓN
A PRIORI
Para definir una función a priori se utiliza el operador ->
> f:=x->x^2-2*x+1;
> g:=t->1/2*9.8*t^2;
IMÁGENES
Para obtener la imagen de un cierto valor se hace:
> f:=x->3*x-1;
> f(2);
> g:=(ci,r,t)->ci*(1+r/100)^t;
> g(3000,5,3);
> plot(m3(x),x=-4..4);
COMPOSICIÓN DE FUNCIONES
Para componer dos funciones podemos hacer:
> f:=x->x-1 : g:=x->x^2+1:
> h:=x->g(f(x));
> with(plots):
> p:=plot({f(x),g(x),h(x)},x=-3..3,color=[red,green,blue]):
> t:=textplot([[-3,f(-3),'f(x)'],[-3,g(-3),'g(x)'],[-3,h(-3),'g(f(x))']]):
> display(p,t,title=`Composición de funciones`);
> restart:
TRASLACIÓN DE FUNCIONES
Vamos a tratar aquí cómo podemos trasladar matemáticamente una determinada función
horizontal y verticalmente.
TRASLACIÓN VERTICAL
Para trasladar una función verticalmente basta con sumar, o restar, un valor a la función: g(x)=f(x)
+k
Vamos a ver cómo se traslada verticalmene la función f(x)=x^2-3:
> f:=x->x^2-3:
> with(plots):
> animate(f(x)+t,x=-3..3,t=-3..3);
> restart:
Como podemos ver, el comando animate (que está en el paquete plots) permite ver la secuencia
de movimientos. Como parámetros tiene la función (con dos variables: la x y el paso de tiempo),
el rango del eje x y el rango de tiempo. Si hacemos click sobre la figura aparecerá un menú con
las opciones clásicas de un video. Únicamene tenemos que probar.
TRASLACIÓN HORIZONTAL
Para trasladar una función horizontalmente basta con sumar, o restar, un valor al argumento de la
función: g(x)=f(x+k)
Vamos ver cómo se traslada horizontalmente la función f(x)x^2-3:
> f:=x->x^3:
> with(plots):
> animate(f(x+t),x=-6..6,t=-3..3);
> restart:
INVERSA DE UNA FUNCIÓN
La función inversa de otra dada se puede obtener así:
> f:=x->x^(1/2);solve(y=f(x),x);g:=unapply(%,y);
> plot({f(x),g(x)},x=0..4,y=0..4,scaling=constrained);
Si hacemos click sobre el cuadro de la función veremos cómo se activa un nuevo menú que nos
permitirá colocar los ejes, cambiar el aspecto de la función, etc. Ánimo... la curiosidad es la mejor
baza.
Si lo que queremos es representar varias funciones a la vez también podemos usar el comando
plot, pero ahora debemos pasar un conjunto de funciones (entre llaves, aunque también
podemos pasar una lista de las funciones, entre corchetes). Podemos elegir los colores de cada
una con la opción color y el nombre de los colores en inglés:
> f:=x->x : g:=x->x^2 : h:=x->x^3:
> plot({f(x),g(x),h(x)},x=-2..2,color=[red,green,blue]);
Podemos utilizar más opciones de plot. Lo mejor es acudir a la ayuda y experimentar:
> ?plot
TEXTOS EN LAS GRÁFICAS
Se puede rotular una gráfica utilizando el comando textplot. Como argumentos se dan listas que
se forman con las coordenadas y el texto, entre comilla simple, que queremos escribir:
Para ver el resultado necesitamos el comando display.
> ?textplot
EL COMANDO DISPLAY
El comando display está en el paquete plots, y permite pintar varias gráficas juntas, con rótulos e
incluso título:
> ?plots,display
Si queremos pintar varais gráficas y rotularlas, la mejor opción es ir definiendo cada gráfica con el
comando plot y guardarlas como variables. Los rótulos se definen con textplot y se guardan en
otra variable. El comando display permite recoger todas estas variables y pintar la gráfica.
> with(plots):
> g1:=plot(ln(x),x=0.1..7,color=red):
> g2:=plot(exp(x),x=-5..2,color=blue):
> g3:=plot(x,x=-4..5,color=green):
> t:=textplot([[6,ln(6)-1,'ln(x)'],[3,exp(2),'exp(x)'],[6,5,x]]):
> display(g1,g2,g3,t,title=`Funciones inversas`,scaling=CONSTRAINED);
> restart:
MOVIMIENTO EN LAS GRAFICAS: animate
El comando animate del paquete plots permite animar gráficas. Es necesario dar tres
parámetros: la función, que debe depender de dos variables (la variable independiente normal y
otra variable que indique el paso temporal para la animación), el rango de variación de la variable
independiente y el intervalo de variación del paso temporal. Es recomendable ver qué otras
opciones tiene animate:
> ?plots,animate
Una vez pintada la gráfica, al hacer click sobre ella quedará seleccionada y aparecerá un menú,
parecido al de un video, en la barra de menús: la curiosidad es la mejor recomendación:
> with(plots):animate(sin(t*x),x=-Pi..Pi,t=-10..10);restart:
Haciendo click sobre la figura, ésta queda seleccionada y se activa un menú (en la barra de
menús) con diferentes opciones para probar.
REPRESENTACIÓN PARAMÉTRICA
Para representar una curva en ecuaciones paramétricas se utiliza el comando plot. El conjunto de
ecuaciones paramétricas se le da a plot en forma de lista ordenada: primero x(t), luego y(t), junto
con la variación del parámetro t. El resto de opciones de plot siguen siendo válidas.
Una de las conocidas curvas de Lissajous se puede obtener así:
> plot([5*sin(1/4*t),7*sin(t),t=-2*Pi..8*Pi]);
La curva locura de Stanley S. Miller ilustra de una forma excelente la representación de curvas a
través de ecuaciones parametrizadas:
> plot([sin(0.99*t)-0.7*cos(3.1*t),cos(1.01*t)+0.1*sin(15.03*t),t=0..50],color=blue);
COORDENADAS POLARES
MAPLE puede representar curvas dadas en coordenadas polares utilizando el comando polarplot
del paquete plots. Este comando recibe dos parámetros: la función polar r=r(theta) y el intervalo
de variación del argumento.
> with(plots):polarplot(5,theta=0..Pi/2,scaling=CONSTRAINED);restart:
> with(plots):polarplot(cos(6*alpha),alpha=0..2*Pi,scaling=CONSTRAINED);restart:
También podemos dar el módulo y el argumento en forma paramétrica, utilizando también el
comando polarplot dando una lista ordenada con la ecuación del módulo y la del argumento en
función de un parámetro, y dando el intervalo de variación del parámetro.
> with(plots):polarplot([t,t,t=0..4*Pi],color=blue,scaling=CONSTRAINED);restart:
GRÁFICAS A TRAMOS
Podemos representar una curva poligonal haciendo una lista de los vértices por los que pasa. Los
pares ordenados se ponen entre corchetes, como las listas, para indicar precisamente que están
ordenados.
> p:=[[-3,1],[-1,0],[1,3],[2,4],[4,5],[6,2]]:
> plot(p,x=-4..7);
SUPERFICIES Y CURVAS EN EL ESPACIO
Además de la representación en forma explícita, que se realiza con el comando plot3d. También
podemos representar superficies dadas de modo implícito, en paramétricas y en coordenadas
esféricas y cilíndricas.
EL COMANDO plot3d
MAPLE puede representar superficies en el espacio con el comando plot3d, al que hemos de
darle la función explícita de dos variables y el intervalo de variación de cada una de ellas
> f:=(x,y)->x^2-y^2;
> plot3d(f(x,y),x=-8..8,y=-8..8,grid=[50,50]);
Si hacemos click sobre la imagen se activará un menú en la barra de menús que nos permitirá
elegir el tipo de grid, los ejes y la escala, así como rotar la función alrededor de los ejes. Si
hacemos click sin soltar el botón sobre la función podremos moverla para verla desde diferentes
ángulos.
El comando plot3d tiene muchas opciones con las que podemos cambiar el aspecto de la gráfica
(como la opción grid utilizada en el ejemplo. Es recomendable acudir a la ayuda de MAPLE para
ver estas opciones:
> ?plot3d[option]
Con el comando plot3d podemos pintar varias funciones a la vez, basta con pasar como
parámetro al comando plot3d el conjunto de las funciones a representar.
> f:=(x,y)->sin(x)-cos(x);
> g:=(x,y)-> cos(x*y);
> plot3d({f(x,y),g(x,y)},x=-Pi..Pi,y=0..Pi,axes=BOXED);
SUPERFICIES EN PARAMÉTRICAS
Para representar una superficie dada en forma de ecuaciones paramétricas basta con utilizar el ç
comando plot3d dando como primer argumento la lista de las ecuaciones paramétricas y
después el intervalo de variación de los parámetros:
> x:=-(3+sin(u))*sin(v):y:=(3+sin(u))*cos(v):z:=cos(v):
> plot3d([x(u,v),y(u,v),z(u,v)],u=-Pi..Pi,v=-Pi..Pi,axes=BOXED,orientation=[137,72]);
Si hacemos girar una circunferencia definida en el plano YZ, en torno al eje X, obtendremos un
toro:
> x:=10*cos(u)+3*cos(u)*cos(v):y:=10*sin(u)+3*sin(u)*cos(v):z:=3*sin(v):
>
plot3d([x(u,v),y(u,v),z(u,v)],u=0..2*Pi,v=0..2*Pi,axes=NORMAL,labels=[X,Y,Z],scaling=CONST
RAINED);
CUÁDRICAS
Las llamadas superficies cuadráticas, o simplemente cuádricas, se definen mediante
ecuaciones de la forma:
> f:=Sum(a[ij]*x[i]*x[j],ij=i..3)+Sum(b[i]*x[i],i=1..3)+c=0;
Los casos no triviales se pueden llevar a uno de los seis siguientes:
1.- Elipsoide:
> with(plots):
> ec1:=x^2/a^2+y^2/b^2+z^2/c^2=1;a:=5:b:=4:c:=3:
> implicitplot3d(ec1,x=-5..5,y=-4..4,z=-
3..3,axes=BOXED,scaling=CONSTRAINED,title=`Elipsoide`,orientation=[68,73]);
> restart:
El comando tubeplot, del paquete plots, permite realzar la curva con la opción radius, que
permite dar grosor, en forma de tubería, a la curva. Para ello incluiremos la opción radius=a un
número que será el grosor de la tubería:
> with(plots):
> x:=t->20*cos(t):y:=t->20*sin(t):z:=t->t:
> tubeplot([x(t),y(t),z(t)],t=0..6*Pi,axes=NORMAL,labels=[X,Y,Z],orientation=[-
32,67],radius=2,scaling=UNCONSTRAINED,title=`Tubo en forma de hélice circular`);
> restart:
LÍMITES LATERALES
También podemos evaluar el límite de una función en un punto por la izquierda y por la derecha
con las opciones left y right, respectivamente, del comando limit:
> f:=x->x/(x-1):
> Limit(f(x),x=1,left)=limit(f(x),x=1,left);
> Limit(f(x),x=1,right)=limit(f(x),x=1,right);
> Limit(f(x),x=1)=limit(f(x),x=1);
> plot(f(x),x=-3..3,y=-5..5,discont=true,color=red);
CONTINUIDAD DE UNA FUNCIÓN
Ya sabemos que para que una función sea continua en un punto x=a, el límite de la función en
x=a, por la izquierda y por la derecha, y el valor de la función en el punto, f(a), deben coincidir.
> f:=x->piecewise(x<0,x^2,x<2,x,x>=2,1):
> plot(f(x),x=-2..5,discont=true,color=blue);
En la librería general está el comando iscont, que nos dice si una función es, o no, contínua:
> readlib(iscont):iscont(f(x),x=-2..5);
Y, también en la librería general está el comando discont, que devuelve los valores de abscisa
donde se encuentran puntos anómalos (aunque a veces no son discontinuidades):
> readlib(discont):discont(f(x),x);restart:
ASÍNTOTAS VERTICALES
Una función tiene asíntotas verticales (AV) en x=k si el límite cuando x tiende a k de la función es
infinito (más infinito o menos infinito) o indeterminado.
El comando discont de la librería general devuelve puntos anómalos candidatos a ser AV:
> readlib(discont):
> f:=x->x^2/(x^2-1);
> discont(f(x),x);
> limit(f(x),x=-1);
> limit(f(x),x=1);
> plot(f(x),x=-2..2,y=-10..10,discont=true,color=blue);
ASÍNTOTAS OBLICUAS
Las asíntotas oblicuas (AO) son rectas (y=mx+n) cuya pendiente y ordenada hay que determinar.
Para determinar la pendiente efectuamos el límite:
> restart:
> m=Limit(f(x)/x,x=infinity);
Si este límite se va a infinito no hay AO. Si el límite se anula es probable que haya una AH.
Para determinar la ordenada en el origen (n) de la AO se calcula el siguiente límite:
> n=Limit(f(x)-m*x,x=infinity);
> f:=x->x^2/(x-2);
> m:=limit(f(x)/x,x=infinity);
> n:=limit(f(x)-m*x,x=infinity);
> AO:=x->m*x+n;
> plot([f(x),AO(x)],x=-3..10,y=-5..20,color=[blue,red]);
SUCESIONES Y SERIES
A pesar de que en el lenguaje corriente sucesión y serie sean términos sinónimos, en el lenguaje
matemático son conceptos muy distintos.
Matemáticamente hablando, una sucesión es una aplicacion que asigna a un entero positivo un
número real, o complejo. La sucsión converge si, cuando n tiende a infinito, la difencia entre dos
términos consecutivos de la sucesión tiende a cero.
Se llama serie a la sucesión de las sumas parciales de los términos de sucesión.
SUCESIÓN:
> seq(a[n],n=1..5);
SERIE:
> seq(s[n]=sum(a[i],i=1..n),n=1..5);
SUCESIONES
El comando seq (sequence) define sucesiones finitas a través de su ley de formación. Este
comando recive dos parámetros: la ley de formación expresada con una variable contadora y la
variación de la variable contadora:
> seq(i,i=0..10);
> seq(evalf((1+1/n)^n,5),n=1..10);
Podemos poner subíndices indicándolos entre corchetes:
> seq(a[i],i=1..10);
SERIES
Ya sabemos que la serie es la sucesión de las sumas parciales. Para evaluarla utilizamos el
sumatorio a través del comando sum. Este comando devuelve la expresión inerte si se escribe
Sum, y recibe dos parámetros: la expresión y el rango de variación del contador:
> Sum(2*n+1,n=0..10)=sum(2*n+1,n=0..10);
Sin embargo la serie resultante de sumar los inversos de las potencias de 2 converge:
> Sum(1/2^i,i=0..infinity)=sum(1/2^i,i=0..infinity);
PRODUCTORIOS
De igual forma que los sumatorios, los productorios se evaluan en MAPLE con un comando,
product, que si se escribe Product devuelve la expresion inerte, y que recibe dos parámetros: la
expresión y la variación del contador:
> Product(1/i,i=1..10)=product(1/i,i=1..10);
DERIVADAS
MAPLE es capaz de realizar cualquier cálculo con derivadas: derivación implícita, logarítmica,
derivada parcial, etc. Para ello utiliza los comandos diff y D. El comando diff ofrece la forma
inerte si lo escribimos Diff:
EL COMANDO diff
Para hallar la derivada de una función se utiliza el comando diff, que en su forma Diff da la
expresión inerte de la derivada. diff tiene dos argumentos: la función a derivar y la variable
respecto de la que se deriva.
> f:=x^2*sin(x):
> Diff(f,x) = diff(f,x);
diff puede aplicarse sobre una expresión, como en el caso anterior, o sobre una función:
> f:=x->x^2*sin(x):
> Diff(f(x),x) = diff(f(x),x);
Podemos preguntarle a MAPLE las diferentes reglas de derivación: ¡se las sabe todas! (incluso
con la aplicación de la regla de la cadena):
> restart:
> Diff(sin(x),x)=diff(sin(x),x);
> Diff(cos(f(x)),x)=diff(cos(f(x)),x);
> Diff(arctan(f(x)),x)=diff(arctan(f(x)),x);
DERIVADAS DE ORDEN SUPERIOR
Para hacer una deriva de orden superior ponemos la variable a derivar tantas veces como sea el
orden de la derivada. Por ejemplo, para hallar la derivada quinta de la función f=sin(x^2),
hacemos:
> diff(sin(x^2),x,x,x,x,x);
DERIVADAS PARCIALES
Cuando una función tiene varias variables se deriva respecto de una de ellas, considerando
constante a las demás:
> f:=(x,y,z)->x^2+4*x*y-y^2*z^3+5:
> Diff(f(x,y,x),y,x) = diff(f(x,y,z),y,x);
DERIVACIÓN LOGARÍMICA
Para hacer derivadas de funciones potencial exponenciales recurrimos al logaritmo neperiano.
> y=x^x;
> ln(y(x)) = x*ln(x);
> diff(ln(y(x)),x) = diff(x*ln(x),x);
> diff(y(x),x) = y(x)*diff(x*ln(x),x);
MAPLE no tiene por qué realizar todo este proceso. MAPLE realiza estas deriadas de forma
automática:
> diff(x^x,x);
FUNCIÓN DERIVADA
Para obtener la función derivada (no la expresión de la derivada) se utiliza el operador D. Este
operador únicamente actúa sobre funciones.
> f:=x->x^2;
> F:=D(f);
> plot({f(x),F(x)},x=-3..3,title=`Una función y su función derivada`);
APLICACIONES DE LA DERIVADA
La derivada se utiliza en multitud de cálculos matemáticos, como pueden ser los desarrollos de
Taylor y en serie de potencias, el cálculo de máximos y mínimos, la determinación de ciertos
límites de funciones, etc.
PROBLEMAS DE MÁXIMOS Y MÍNIMOS
Hallar los máximos y mínimos relativos de la función: y = e^x·sen(x)
> y:=x->x^4*exp(-x^2);
> dp:=rhs(%);
> Diff(y(x),x$2)=diff(y(x),x$2);
> ds:=rhs(%);
> p[1],DS(p[1]);
> p[4],DS(p[4]);
> p[5],DS(p[5]);
Si dividimos arriba y abajo por x-a y hacemos el límite cuando x->a obtendremos:
> f(x)/g(x)=Diff(f(a),x)/Diff(g(a),x);
> df:=unapply(diff(f(x),x),x);dg:=unapply(diff(g(x),x),x);
> Limit(df(x),x=0)=limit(df(x),x=0);Limit(dg(x),x=0)=limit(dg(x),x=0);
SERIES DE POTENCIAS
Desarrollar una función en serie de potencias supone encontrar un polinomio que aproxime esa
función tanto como queramos. Esto puede ser muy útil, ya que los polinomios son fáciles de
operar, deivar, integrar, etc.
Se llaman series de potencias a las aproximaciones polinómicas de la forma
> Sum(a[n]*x^n,n=0..infinity);
Estas series son un caso particular de las serier geométricas cuya convergencia está asegurada
si |r|<1, donde r es la razón de la serie. Así, por ejemplo, si x es complejo y |x|<1, la serie
geométrica.
> Sum(x^n,n=0..infinity);
Podemos ver el grado de aproximación pintando las funciones: en rojo el logaritmo, en azul el
polinomio.
> plot({ln(x+1),p(x)},x=-1..1,color=[red,blue]);
INTEGRALES
MAPLE puede calcular integrales con el comando int. Si escribimos el comando Int obtendremos
la expresión interte de la integral.
En el paquete student hay comandos referidos a la integración. Conviene, por lo tanto, mirar la
ayuda:
> ?student
INTEGRAL INDEFINIDA
Podemos integrar expresiones con el comando int dando como primer argumento la expresión, y
como segundo argumento la variable con respecto a la cual integramos:
> int(2*x*sin(x),x);
Para integrar funciones basta con que el primer parámetro sea la función a integrar:
> f:=x->x*exp(x);Int(f(x),x)=int(f(x),x);
MAPLE es capaz de integrar por diferentes métodos: cambio de variable, por partes y por
fracciones simples, aunque para el usuario el procedimiento no se ve, basta con utilizar el
comando int. De todas formas podemos forzar a MAPLE a integrar por partes con el comando
intparts del paquete student, dando como primer parámetro la expresión de la integral y como
segundo parámetro la función u (de int(u·dv) = u·v-int(v·du)):
> with(student):intparts(int(x^4*exp(x),x),x^4);restart:
INTEGRAL DEFINIDA
Para evaluar una integral definida también se utiliza el comando int, dando como primer
parámetro la expresión o la función a integrar, y como segundo argumento el intervalo de
variación de la variable. Recordemos que Int devuelve la expresión inerte:
> Int(x*sin(x),x=0..Pi)=int(x*sin(x),x=0..Pi);
> f:=x->1/sqrt(a^2-x^2):
> Int(f(x),x=0..a)=int(f(x),x=0..a);
> leftbox(f(x),x=0..5,10);Suma3:=evalf(leftsum(f(x),x=0..5,10));
Podemos ver cómo estos tres valores convergen cuando el número de rectángulos crece.
INTEGRALES IMPROPIAS
MAPLE calcula automáticamente integrales impropias, sean de la especie que sean, con el
comando int.Como primer argumento se da la expresión a integrar y como segundo argumento el
intervalo de integración, poniendo el infinito como infinity
> f:=x->x/(sqrt(x^4+1)):
> Int(f(x),x=0..infinity)=int(f(x),x=0..infinity);
> f:=x->exp(-x^2):
> Int(f(x),x=0..infinity)=int(f(x),x=0..infinity);
> Int(f(x),x=-infinity..infinity)=int(f(x),x=-infinity..infinity);
> f:=x->sin(p*x)^2/x^2:
> Int(f(x),x=0..infinity)=int(f(x),x=0..infinity);
> f:=x->exp(-a*x^2):
> assume(a>0):Int(f(x),x=0..infinity)=int(f(x),x=0..infinity);
> assume(a=0):Int(f(x),x=0..infinity)=int(f(x),x=0..infinity);
> assume(a<0):Int(f(x),x=0..infinity)=int(f(x),x=0..infinity);
INTEGRACIÓN NUMÉRICA
El paquete student ofrece métodos numéricos para el cálculo aproximado de integrales, como
son el método de los trapecios y el método de Simpson. Los comandos a utilizar son
trapezoid y simpson, respectivamente. En ambos casos se pasan tres: la función a integrar, el
intervalo de integración y el número de rectángulos (a mayor número mejor aproximación en el
cálculo).
> f:=x->x/(sin(x)):
> Int(f(x),x=0..Pi/2)=evalf(int(f(x),x=0..Pi/2));
> with(student):evalf(simpson(f(x),x=0.00001..Pi/2,10));restart:
INTEGRALES MÚLTIPLES
Podemos hacer integrales múltiples reiterando el comando int.
> f:=(x,y,z)->x^2+y^2+z^2:
> Int(Int(Int(f(x,y,z),z=0..1),y=0..1),x=0..1)=int(int(int(f(x,y,z),z=0..1),y=0..1),x=0..1);
También podemos utilizar los comando Doubleint y Tripleint del paquete student, siendo
necesario evaluar luego la salida de estos comandos:
> with(student):
> f:=(x,y,z)->x*y*z+x^2:
> Tripleint(f(x,y,z),z=0..1,y=-2..2,x=-1..1);
> %=value(%);