reemplazar el valor de x en la expresión expr

Asignación a variables: r:= expr

:= , unassign , restore, assume asigna a la variable r la expresión dada.

var := comando maple; subs( {x=a},expr)

Se evalua el comando maple y la expresión que resulta es asignada a la variable var retorna la expresión expr donde x es reemplazado por el valor de a.

assume(x>a); assume(n,integer); assume(z,real) subs( {x=a,y=b},expr)

Son ejemplos de assume. Para mayor información ejecute ?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.
retorna la expresión expr donde x es reemplazado por el valor de a, y es reemplazado por el
valor de b
subs( {eq1,eq2,.., eqk}, expresion);
donde eq1, eq2, ... eqk, son reglas de substitución.
unapply(expr,x) retorna el procedimiento x->expr
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:

Aproximaciones decimales: Podemos definir el procedimiento maple

f:= x-> x^2;
Para evaluar f en x=2 hacemos:
evalf
f(2);
Si tenemos una expresión
Digits:= N;
r:= x^2;
Define que de ahora en adelante se ocupa aritmética decimal con N dígitos significativos.
e intentamos r(2) resulta un sin sentido
Al iniciar Maple Digits vale 10
r(2);
Para reemplazar x por x=2 en una expresión usamos el comando subs (por substitute)
evalf( expr)
subs({x=2},r);
Evalúa la expresión en artimética decimal con N dígitos sgniticativos, donde N es el valor
r;
que tiene la variable Digits.
El comando subs(), permite entonces reemplazar variables por valores sin alterar el valor de
la expresión original.
evalf(expr,N)
Podemos reemplazar más de una variable el mismo tiempo,
Evalua la expresión expr en aritmética decimal con N dígitos significativos.
subs({x=2,y=1},x^2+y^2);

Algebra: Una alternativa a substituir es construir un procedimiento con unapply y luego usar el
procedimiento:
g:= unapply(r,x);
los comandos expand, combine, simplify, factor, normal, coeff, quo, rem. g(2);

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
Si el procedimiento que define a una función es muy complicado es preferible definirlo
usando proc().
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;

simplify(expresion); func(0.367879441);
aplica las reglas de simplificación que cumplen las funciones típicas trigonométricas, exp(-1.0);
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); Gráfico de funciones y

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
curvas en el plano
flotante.
plot( f(x), x=a..b);
factor(polinomio,complex); Grafica a y=f(x) en el intervalo [a,b]. El rango y escala del eje Y se ajusta automáticamente
factoriza el polinomio en factores lineales complejos usando aritmética de punto flotante.
plot ( f(x) , x=a..b, scaling=constrained);
normal(expresion); Idem que el anterior pero las escalas en los ejes X a Y están en relación 1:1.
obtiene una expresión en la forma denominador/numerador, con términos comunes
simplificados. plot ( f(x) , x=a..b, y=c..d);
Muestra la porción del gráfico de y=f(x) que yace en el rectángulo a <= x <= b, c<= y <= d.
coeff( expresion ,x^k);
obtiene el coeficiente de x^k en la expresion, siempre que ésta sea una suma de pontencias plot( f(x), x=a..b, view=[x1..x2,y1..y2])
de x. Muestra la porción del gráfico de y=f(x) para a <= x <= b pero enmarcado en una ventana
con x1 < x < x2, y1 < y < y2.
q:= rem(a,b,x); r:= rem(a,b,x);
plot ( f(x) , x=a..b, y=c..d, discont=true);
Si a,b son polinomios, q es el cuociente de a dividido por b y r es el resto de a dividido por Idem que el anterior, pero se usa cuando f es discontínua (y f no toma valores complejos)
b. El resto y el couciente satisfacen a= b*q+r, donde grado(r) < grado (b)

plot( f(x), x=a..b, y=c..d, discont=true, color=COLOR);

Idem que el anterior donde y=f(x) se grafica con color COLOR, donde COLOR puede ser

Expresiones versus red, blue, green, cyan, magenta, etc...

plot( [f(x),g(x), h(x)] , x=a..b, y=c..d,discont=true, color=[red,blue,cyan]);

procedimientos: Idem que en el anterior pero se grafican las tres funciones f,g,h al mismo tiempo en colores
red,blue, cyan respectivamente.

->, proc(), subs(), unapply() plot( [x(t), y(t) , t=a..b], color=red );

grafica los puntos (x(t),y(t)) en el plano XY cuando t varía desde a hasta b.
Las funciones matemáticas pueden representarse en Maple mediante expresiones y/o
procedimientos. plot( [x(t), y(t) , t=a..b], color=red, scaling=constrained) );
Idem que el anterior, pero las escalas en los ejes X,Y están en relación 1:1. (equivalente a
f:= x -> expr presionar el botón 1:1 en la barra de menú del gráfico).
define un procedimiento que asigna a cada x (input) su valor f(x) (output) que se obtiene al
 soluciones existentes de un sistema de ecuaciones no lineales.

Más Gráficos: Ejemplos

with(plots), implicitplot, animate, animatecurve, display. regla:=solve({y=x+2,y=2*x-4},{x,y});

Podemos ocupar la solución con el comando subs
with(plots) Activa al paquete plots donde se encuentran las rutinas, display, implicitplot, x0:=subs(regla,x);
textplot, etc.... y0:= subs(regla,y);
subs(regla, (x^2+y^2+1)/ (x+y));
implicitplot( f(x,y)=g(x,y), x=a..b,y=a..b,numpoints=N) Grafica la porción de la curva Podemos determinar los puntos de intersección de la recta y=x+2, con la
definida implicitamente por la ecuación f(x,y)=g(x,y) que yace en el rectángulo a<=x <=b, circunferencia x^2+y^2=4
c<=y<=d.. N es el número de veces que resuelve la ecuación implícita para construir el suc_reglas:=solve( {y=x+2,x^2+y^2=4},{x,y});
gráfio. La primera solución es
x1:=subs(suc_regla[1],x);
animate( { f(x), g(x,h)}, x=a..b, h=h1..h2, nframes); Crea una animación donde en cada y1:= subs(suc_regla[1],y);
cuadro se grafica a las funciones f(x), g(x,h) en el intervalo [a,b], con h variando desde h1 Podemos evaluar expresiones que involucaran a cualquiera de las soluciones directamente
hasta h2 con un incremento de subs(suc_regla[2],x^2-y^2);
h2 - h1
----------- Para resolver un sistema de 3 ecuaciones con 3 incongnitascomo este x+y+z=1, x-y-z=2,
nframes - 1 2*x+3*y-2*z=3
. En total hay nframes cuadros. hacemos:
regla3:=solve({x+y+z=1, x-y-z=2, 2*x+3*y-2*z=3},{x,y,z});
animatecurve( [x(t), y(t),t=t1 .. t2], view=[a..b , c..d], color=red); Podemos reemplazar estos valores en cualquiera expresión
Crea una animación que genera una curva a partir de una parametrización x(t), y(t) de ella subs( regla3,x^2-y+z);
cuando el parámetro t varía desde t1 hasta t2.

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.
Estructuras de datos,
display(p1,p2,p3); Grafica los gráficos guardados en las variables p1,p2,p3
(expresión) sucesión, lista,
display( sucesión o lista de de variables con gráficos); Muestra en un mismo gráfico los
gráficos guardados en las variables.

display( sucesión o lista de de variables con gráficos, insequence=true); Muestra cuadro a

conjunto, tabla:
[ s], {s}, nops(s) , op(s) , seq(s) , s[n] , map(f,s)
cuadro los gráficos en la lista creando una animación.

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.

Gráficos 3D 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
Comandos genéricos para curvas y superficies ser de distintos tipos.

with(plots); Inicializa el paquete plots que permite ocupar varias rutinas para despliegue de [s] Es la lista formada por los elementos de la sucesión s. En general, si s es una sucesión
gráficos. entonces [s] es una lista.

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].
{s} Es el conjunto formado por los elementos de la sucesión s. En general, si s es una
sucesión. entonces {s} es un conjunto. En maple un conjunto emula al concepto matemático
de conjunto: elementos repetidos se eliminan y el orden de los elementos no importa. .
T[algo]:=valor; Si T no es una lista , crea la tabla T con una entrada. Con asignaciones
adicionales del tipo T[indice]=valor se agregan elementos a la tabla T.

s[k] el elemento k-ésimo de la lista o conjunto s,

Solución de ecuaciones, T[algo] Si T es una tabla, valor asociado a "algo" en la tabla.

sistemas de ecuaciones: fsolve,solve

nops(s) el número de elementos de la lista o conjunto s.

fsolve( f(x)=g(x), x=a..b);
Calcula por métodos numéricos UNA solución de f(x)=g(x) en el intervalo [a,b], CON LA
EXCEPCION del caso en que f(x), g(x) sean polinomios, donde encuentra TODAS las
raices reales en el intervalo [a,b]
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 sucesión a(n1), a(n1+1), a(n1+2), .... a(n2).
[ seq ( (a(n), n=n1..n2 ) ] la lista con los elementos a(n1), a(n1+1), ... , a(n2)

fsolve( f(x)=g(x), x=a) { seq ( (a(n), n=n1..n2 ) } el conjunto con los elementos a(n1), a(n1+1), ... , a(n2).
busca por métodos numéricos UNA solución de Elementos repetidos se eliminan.
f(x) = g(x)
comenzando la búsqueda en x=a. No necesariamente encuentra la solución más cercana a map(f,s) la lista o conjunto que se obtiene de aplicar una función f a cada elemento de la
x=a. lista o conjunto s

fsolve( p(x),x); Ejemplos:

Determina aproximaciones decimales a todas las raices reales del polinomio p(x).
sucesion:=1,4,2,10,9,1,-4;
fsolve( p(x),x,complex); lista:= [sucesion];
Determina aproximaciones decimales a todas las raices, incluyendo las complejas, del conjunto:= {sucesion};
polinomio p(x) op(conjunto); op(lista);
nops(lista) , nops(conjunto);
solve( f(x)=g(x), x). f:= x-> x^2; map(f,lista);map(f,conjunto);
Si f, g son polinomios, encuentra todas las raices, en otros casos intenta encontrar tantas seq( k^2,k=1..5);
soluciones como pueda mediante reducciones algebraicas. Si no encuentra soluciones ya sea datos:= [ [1,2], [3,4], [5,6]];
por que no hay o por que no pudo encontrar, retorna NULL, es decir "nada". datos[2];
datos[2][1];
solve( f(x)< g(x), x) Intenta resolver la inecuación mediante reducciones algebraicas
(cálculo simbólico). Una tabla consiste en una asociación entre valores de un índice y expresiones. Las tablas se
definen en forma dinámica.
solve( conjunto de ecuaciones, conjunto de variables) T[1]:= 3;
intenta resolver mediante manipulaciones algebraicas el sistema de ecuaciones con respecto T[4]:= 2;
a las variables indicadas. Cuando tiene éxito, retorna una sucesión de reglas de substitución T[cabeza_de_pescado]:= cola_de_pescado;
(para ser ocupadas con el comando subs) . CUIDADO: solve puede no encontrar todas las op(T);
 f(2);

Control de flujo: En general para a>0,

for loops, while loops, if assume(a,positive);
limit(f(x),x=a,left);
for i from n1 to n2 do blabla... od ejecuta las instrucciones en el bloque blabla para i=n1, limit(f(x),x=a,right);
n1+1, etc.. hasta i=n2 limit(f(x),x=a);
f(a);
for i from n1 to n2 by salto do blabla... od ejecuta las instrucciones en el bloque blabla para
i=n1, n1+salto, etc.. hasta el mayor valor de n1+k*salto menor o igual a n2. En general para a<0,
assume(a,negative);
for k in S do blabla ... od. Ejecuta las instucciones en el bloque blabla para cada elemento k limit(f(x),x=a,left);
en la lista o conjunto S. limit(f(x),x=a,right);
limit(f(x),x=a);
while ( condicion) do blabla od: Ejecuta las instucciones en el bloque blabla mientras la f(a);
condición sea verdadera.

for k from n1 to n2 while ( condicion) do blabla od: Ejecuta las instucciones en el bloque
blabla mientras la condición sea verdadera y k esté entre n1 y n2 (inclusives)
Derivadas:
D(), diff()
if ( COND ) then BLOQUE fi Si la condición COND es verdadera se ejecuta el BLOQUE.
D(f) Si f es una función entonces D(f) es la función f ' y entonces D(f)(x) es f'(x).
if ( COND ) then BLOQUE1 else BLOQUE2 fi Si la condición COND es verdadera se
ejecuta el BLOQUE1, en caso contrario se ejecuta el BLOQUE2. (D @@2) (f) Si f es una función entonces (D@@2)(f) es la función f '', que es la segunda
derivada de f .
if ( COND ) then BLOQUE1 elif COND1 then BLOQUE2 else BLOQUE3 fi Si la
condición COND es verdadera se ejecuta el BLOQUE1 en caso contrario, si COND1 es diff(expr,x) Si expr es una expresión en la variable x entonces diff(expr,x) es la derivada de
verdadero se ejecuta el BLOQUE2, en otros casos se ejecuta BLOQUE3 expr con respecto a x.

Ejemplos: diff( expr,x$2) Es la segunda derivada de expr con respecto a la variable x.

for i from 2 to 10 by 2 do i^2; od; diff( expr,x$3) Es la tercera derivada de expr con respecto a la variable x.

S:= [2,4,5,7,11,-10]; diff( expr,x$n) Es la n-ésima derivada de expr con respecto a la variable x.
Suma de los cuadrados de los elementos en S:
total:=0; for i in S do total:=total+i^2; od;

Suma los cuadrados de los elementos de S hasta que la suma total exceda 100
Integración:
k:=0; suma:=0; while( suma < 100) do k:= k+1; suma:=suma+k^2;od; int(), Int(). Integración numérica evalf(Int () )

Otra alternativa para el cálculo anterior es: int( f(x), x=a..b) Intenta calcularla mediante métodos simbólicos.
suma:=0; for k from 1 to 100 while( suma < 100) do suma:=suma+k^2; od;
Int( f(x), x=a..b) Es la expresión NO EVALUADA. Es decir, es la expresión que al ser
x:=4; if (x >0) then r:=x^2 else r:=x fi; evaluada se obtiene la integral de f(x) en [a,b]

evalf ( Int (f(x),x=a..b) Estima el valor de la integral mediante métodos numéricos (parecido
a sumas de Riemann pero mucho más sofisticado y de alta precisión). Los límities de
Límites, límites por la integración a,b deben ser números.

value( Int( f(x), x=a..b) ) Intenta evaluar mediante métodos simbólicos la integral de f(x) en

izquierda y por la derecha: el intervalo [a,b]. Es equivalente a int(f(x), x=a..b).

limit(f(x),x=a,left) que es el límite de f(x) cuando x tiende a a por la izquierda. Ejemplos:

limit(f(x),x=a,right) es el límite de f(x) cuando x tiende a a por la derecha. int( x^2,x=a..b);

int(x^2,x=1..2);
limit(f(x),x=a) el cual existe sólo cuando limit(f(x),x=a,left)=limit(f(x),x=a,right). Si los Int( x^2,x=1..2);
límites por la izquierda o por derecha no existieran o no fueran iguales entonces el límite no evalf( Int(x^2,x=1..2));
existe y maple responde undefined
La siguiente integral no se puede evaluar mediante una fórmula explícita. La única opción
Ejemplos: es la integración numérica.
plot( x^x,x=1..2,color=red);
Considere a la función definida por tramos int( x^x,x=1..2);
f:= x-> piecewise( x<0, x+2, x>=0, x^2-x+1); evalf( Int( x^x,x=1..2));
f(x);
plot(f(x), x=-2..2, discont=true,color=red); Para mayor información vea en:
?int[numeric]
Vemos que
cuando x tiende a cero con x <0, f(x) tiende a 2
cuando x tiende a cero con x>0, f(x) tiende a 1

Es decir
limit(f(x), x = 0, left) = 2
,
limit(f(x), x = 0, right) = 1
Interpolación de datos:
Maple puede calcular estos límites interp, splineinterp(xdatos ,ydatos ,x) Calcula el polinomio de P(x) grado n que resuelve el
problema de interpolación P(xdatos) = ydatos[i], i=1,1,2, ..., n+1. xdatos, ydatos son listas
limit(f(x), x=0); cada con n+1 números.
limit(f(x), x=0,right);
limit(f(x), x=0,left);

Para nuestra función, para

a <> 0
los límites por la izquierda y por la derecha son iguales a f(a) y el límite existe. Por ejemplo,
para a=2,

L1:=limit( f(x),x=2,left);
L2:= limit( f(x),x=2,right);
L:= limit(f(x),x=2);