Академический Документы
Профессиональный Документы
Культура Документы
Aquí se explican las herramientas más importantes que pueden usar en este
excelente programa de matemáticas:
Asignación a variables:
:= , unassign , restore, assume
unassign('var');
"borra" todo lo que se conoce acerca de la variable var, incluyendo las restricciones
impuestas con el comando assume. De este modo, ella puede ser usada sin
restricciones más adelante. Las comillas ' ' son fundamentales.
restore;
reinicializa todas las variables que se hayan ocupado "borrando" todo lo que se
conoce sobre ellas. Es equivalente a aplicar unassign('var') a cada variable var que
se haya ocupado.
Aproximaciones decimales:
evalf
Digits:= N;
Define que de ahora en adelante se ocupa aritmética decimal con N dígitos
significativos. Al iniciar Maple Digits vale 10
evalf( expr)
Evalúa la expresión en artimética decimal con N dígitos sgniticativos, donde N es el
valor que tiene la variable Digits.
evalf(expr,N)
Evalua la expresión expr en aritmética decimal con N dígitos significativos.
Algebra:
los comandos expand, combine, simplify, factor, normal, coeff, quo, rem.
expand( expresion);
Expande la expresión desarrollando potencias de binomios, distribuyendo productos
con sumas, o expandiendo fórmulas trigonométricas, etc..
combine( expresion);
aplicado a ciertas expresiones realiza la operación inversa de expand
simplify(expresion);
aplica las reglas de simplificación que cumplen las funciones típicas
trigonométricas, exponenciación, logaritmos, polinomios, etc.. La noción que Maple
tiene de una expresión simplificada es con toda probabilidad diferente de la que Ud.
tiene, la que es a su vez diferente de la de su vecino.
factor(polinomio);
factoriza el polinomio en factores con coeficientes enteros , racionales.
factor(polinomio,real);
factoriza el polinomio en factores con coeficeintes reales usando aritmética de
punto flotante.
factor(polinomio,complex);
factoriza el polinomio en factores lineales complejos usando aritmética de punto
flotante.
normal(expresion);
obtiene una expresión en la forma denominador/numerador, con términos comunes
simplificados.
r:= expr
asigna a la variable r la expresión dada.
subs( {x=a},expr)
retorna la expresión expr donde x es reemplazado por el valor de a.
subs( {x=a,y=b},expr)
retorna la expresión expr donde x es reemplazado por el valor de a, y es
reemplazado por el valor de b
func:= proc(x) ...... end proc define un procedimiento que asigna a cada x(input) el
resultado func(x) (output) (es alternativo a usar el operador -> )
Ejemplos:
La siguiente función determina los valores de y tal que x*exp(y)=y para un valor de
x dado.
func:= proc(z) local eq1; eq1:=subs(x=z,x*exp(y)=y); solve(eq1,y); evalf(%); end
proc;
func(0.367879441);
exp(-1.0);
Más Gráficos:
with(plots), implicitplot, animate, animatecurve, display.
animate( { f(x), g(x,h)}, x=a..b, h=h1..h2, nframes); Crea una animación donde en
cada cuadro se grafica a las funciones f(x), g(x,h) en el intervalo [a,b], con h
variando desde h1 hasta h2 con un incremento de
h2 - h1
-----------
nframes - 1
. En total hay nframes cuadros.
p1:= plot( f(x), x=a..b): Guarda en la variable p1 el gráfico de y=f(x), el cual puede
ser desplegado mediante el comando display(p1). Note que la única manera en que
el gráfico puede ser desplegado es mediante el comando display. Es conveniente
terminar el comando con : en vez de ; para evitar ouput indeseable.
Gráficos 3D
Comandos genéricos para curvas y superficies
with(plots); Inicializa el paquete plots que permite ocupar varias rutinas para
despliegue de gráficos.
spacecurve( [x(t), y(t), z(t)], t=a..b); Grafica la trayectoria o curva que siguen los
puntos [x(t),y(t),z(t)] cuando t varía desde t=a hasta t=b (requiere el paquete plots)
plot3d( [x(u,v), y(u,v) , z(u,v) ], u=a..b, v=c..d ); Grafica la superficie que generan
los puntos de la forma [x(u,v), y(u,v) , z(u,v) ] cuando u varía en el intervalo [a,b] y
v en el intervalo [c,d].
fsolve( p(x),x);
Determina aproximaciones decimales a todas las raices reales del polinomio p(x).
fsolve( p(x),x,complex);
Determina aproximaciones decimales a todas las raices, incluyendo las complejas,
del polinomio p(x)
Ejemplos
regla:=solve({y=x+2,y=2*x-4},{x,y});
Podemos ocupar la solución con el comando subs
x0:=subs(regla,x);
y0:= subs(regla,y);
subs(regla, (x^2+y^2+1)/ (x+y));
Podemos determinar los puntos de intersección de la recta y=x+2, con la
circunferencia x^2+y^2=4
suc_reglas:=solve( {y=x+2,x^2+y^2=4},{x,y});
La primera solución es
x1:=subs(suc_regla[1],x);
y1:= subs(suc_regla[1],y);
Podemos evaluar expresiones que involucaran a cualquiera de las soluciones
directamente
subs(suc_regla[2],x^2-y^2);
Para resolver un sistema de 3 ecuaciones con 3 incongnitascomo este x+y+z=1, x-
y-z=2, 2*x+3*y-2*z=3
hacemos:
regla3:=solve({x+y+z=1, x-y-z=2, 2*x+3*y-2*z=3},{x,y,z});
Podemos reemplazar estos valores en cualquiera expresión
subs( regla3,x^2-y+z);
Para agrupar varios datos en una misma variable, se puede usar una de las
siguientes estructuras de datos: (expresión) sucesión, lista, conjunto, tabla.
exp1, exp2, ... , expn Es la sucesión formada por las expresiones exp1, exp2, etc.
En general, expresiones separadas por comas definen a un sucesión. Las
expresiones pueden ser de distintos tipos.
op(s) la sucesión con los elementos del conjunto o lista s (le quita los paréntesis a s)
[ seq ( (a(n), n=n1..n2 ) ] la lista con los elementos a(n1), a(n1+1), ... , a(n2)
{ seq ( (a(n), n=n1..n2 ) } el conjunto con los elementos a(n1), a(n1+1), ... , a(n2).
Elementos repetidos se eliminan.
map(f,s) la lista o conjunto que se obtiene de aplicar una función f a cada elemento
de la lista o conjunto s
Ejemplos:
sucesion:=1,4,2,10,9,1,-4;
lista:= [sucesion];
conjunto:= {sucesion};
op(conjunto); op(lista);
nops(lista) , nops(conjunto);
f:= x-> x^2; map(f,lista);map(f,conjunto);
seq( k^2,k=1..5);
datos:= [ [1,2], [3,4], [5,6]];
datos[2];
datos[2][1];
Una tabla consiste en una asociación entre valores de un índice y expresiones. Las
tablas se definen en forma dinámica.
T[1]:= 3;
T[4]:= 2;
T[cabeza_de_pescado]:= cola_de_pescado;
op(T);