Símbolos, funciones y asignaciones,
globales y locales

 

 

indice

Constantes y símbolos usuales

 

indice

Funciones conocidas

  1. sqrt(3),numer; devuelve 1.732050807568877
  2. entier(sqrt(3)); devuelve 1
  3. entier(-sqrt(3)); devuelve -2
  4. round(sqrt(3)); devuelve 2
  5. abs(1+%i); devuelve sqrt(2)
  6. abs(entier(-sqrt(3))); devuelve 2
  7. random(6); puede producir cualquier entero entre 0 y 6
  8. random(10.0); puede producir cualquier número decimal entre 0 y 10
  9. sqrt(x^2); devuelve abs(x)
  10. factor(120);
  11. divisors(120);
  12. polarform(1/2+\sqrt(3)/2*%i);
  13. rectform(%e^(%pi*%i/3));

Conviene aclarar que el comando random genera números pseudoaleatorios, en el sentido de que generada una serie de aleatorios, si reiniciamos Maxima y los volvemos a generarla, obtenemos la misma serie.
Random.wxmx
Para evitar que tal cosa ocurra podemos hacer uso de los comandos

que cambian la "semilla inicial" que se utiliza para generar los pseudoaleatorios (de forma ordenada y preestablecida).

 

indice

Polinomios

Maxima puede realizar divisiones polinomiales, hacer máximo común divisor y mínimo común múltiplo de polinomios, entre otras operaciones.

  1. gcd( (x+1)*(x-1)^2*(x^2+1), x^2+2*x+1);
  2. /* Atención requiere primero load(functs); */ lcm( (x+1)*(x-1)^2*(x^2+1), x^2+2*x+1 );
  3. divide( x^4-x^3+7*x^2-1, x^2+2*x+1, x );

Otro comando que puede ser útil para eliminar variables en un sistema de ecuaciones es

block( exp1: 2*x^2 + y*x + z, exp2: 3*x + 5*y - z - 1, exp3: z^2 + x - y^2 + 5, eliminate ([exp3, exp2, exp1], [y, z]) );

 

indice

Asignar de valores. Definir nuevas funciones

Con frecuencia es necesario reutilizar en otro lugar el resultado de un cálculo ya realizado. Pero más eficiente que las operaciones de copiar/pegar resulta el hacer uso de la posibilidad que Maxima ofrece de asignar un Nombre a ese resultado y poderlo llamar del mismo en cualquier otro lugar.

Otro tanto ocurre con la utilización de funciones construidas en base a las que Maxima conoce: igualmente resulta de utilidad asignarles un Nombre y poder utilizarla sin necesidad de volver a escribir la fórmula. Describimos a continuación los comandos que gestionan esas tareas.

Vamos a ilustrar con algunos ejemplos el funcionamiento y las diferencias entre las diferentes formas de definir una función

  1. a: 2$ b:3$ a*b;
  2. /* anulamos el valor asignado */ kill(a)$ F1(x):=a*x^2+1;
  3. /* derivamos la función */ diff(F1(x),x);
  4. /* asignamos valor al parámetro */ a:2$
  5. /* calculamos de nuevo la derivada tras la asignación */ diff(F1(x),x);
  6. F2(x):=x^2+1;
  7. F2(3);
  8. /* dibuja F2 en el intervalo [-1,1] */ plot2d(F2(x),[x,-1,1]);
  9. /* dibuja F3 en los intervalos seƱalados */ F3(x,y):=x^2-y^2; plot3d(F3(x,y),[x,-1,1],[y,-1,1]);
  10. /* ahora tendremos dos nombres para la misma función */ alias(sen,sin)$
  11. sen(%pi/2); sin(2*%pi);

En la asignación de valores, como hemos seƱalado, se utiliza   :   y no =. El símbolo de igualdad se emplea fundamentalmente con las ecuaciones, si bien también aparece en las operaciones de sustitución y evaluación de expresiones.

Por otra parte, la asignación de valores tiene un ámbito de aplicación más amplio que establecer el valor de una constante en una fórmula, tal y como ha sido utilizado más arriba. Por ejemplo es posible utilizar el comando   :   para definir una función, (incluso sin declarar explícitamente la variable) como hacemos a continuación. y .

  1. kill(all)$ F1 : x^2+1;
  2. F2 : diff(F1,x);
  3. ev(F2, x=3);
  4. subst(x=3,F2);

Como ya hemos comentado en otras ocasiones

? : ;
proporciona información sobre otros posibles usos del comando

Otros ejemplos que ilustran la diferencia entre las dos formas de definir una función:

  1. kill(f,g,h,k)$
  2. expr : cos(y) - sin(x);
  3. f(x,y):=expr;
  4. define(g(x,y),expr);
    Desde un punto de vista abstracto parece que las funciones f y g anteriormente definidas coinciden. Sin embargo f y g tienen un comportamiento diferente en Maxima, como muestran los resultados siguientes.
  5. f(a,b);
    devuelve algo diferente de lo que se está esperando.
  6. g(a,b);
    devuelve lo que se espera como resultado.
  7. h(x,y) := cos(y) - sin(x);
    funciona como cabía esperar
    h(a,b);
  8. Un resultado similar puede obtenerse si en la definición de la función se fuerza la evaluación previa, como ocurre con la función k que aparece a continuación
    k(x,y):=ev(expr);
    y ahora sí se obtiene el resultado esperado
    k(a,b);
  9. Otra manifestación de las diferencias es la siguiente (vea el resultado de la ejecución en la consola) kill(all)$ f(x):=cos(x); g(x):=diff(f(x),x); g(x); g(0);
    La última no funciona.
  10. Repetimos los cálculos usando ahora el comando define y ahora todo funciona como cabría esperar (vea el resultado de la ejecución en la consola)
    kill(all)$ f(x):=cos(x); define(g(x),diff(f(x),x)); g(x); g(0);

La clave para interpretar los resultados anteriores está en que define evalua siempre su segundo argumento, a menos que se indique lo contrario con el operador de comilla simple; por el contrario := no hace esa evaluación. Para más detalles, y variaciones sobre esta cuestión puede ejecutar

? define;
y ver la información proporcionada al respecto en la consola de Maxima.

 

Funciones definidas a trozos: uso de condicionales

Maxima permite construcciones del tipo siguiente:

La condición debe ser evaluable como true o false y las expresión1, expresion2 son expresiones válidas de Maxima, incluidas expresiones if anidadas. Si la condición es cierta entonces se ejecuta expresion1 y en otro caso se ejecuta expresión2

  1. F(x):=if x<0 then 0 else x^2;
  2. plot2d( F(x), [x,-1,1], [y,-1,1] )$

Un ejemplo de anidamiento de condicionales

  1. kill(all)$
    F(x):=if x<0 then 0 else (if x<1 then x^2 else 1) ;
  2. plot2d( F(x), [x,-1,2], [y,-1,2] );

Una construcción diferente con idéntico resultado

  1. kill(all)$
    F(x):=if (x<0) then 0 elseif (x>0 and x<1) then x^2 else 1;
  2. plot2d( F(x), [x,-1,2], [y,-1,2] );

 

indice

Conocer o desasignar valores y funciones

Cada función definida, o cada asignación realizada, permanece activa, salvo que se haya realizado con caracter local en un bloque hasta que se desactiva.

Ejecute el comando

? kill;
para más información y otros usos del mismo.

También posible realizar las definiciones y asignaciones dentro de un bloque, en cuyo caso al salir del bloque se olvidan tales definiciones y asignaciones.

  1. G:x^2+1$ H:y+1$
  2. G*H;
  3. kill(G,H);
  4. G*H;

 

Asumir algo y olvidarse de ello después

Cuando Maxima tiene dudas sobre algún dato que puede influir en cual sea su respuesta, antes de darla hace preguntas.

Copie y pegue este texto en la consola y responda a la pregunta formulada, no se olvide de poner el ; al final de su respuesta

integrate(exp(a*x),x,0,inf);

Los siguientes comandos resultan de utilidad porque permite evitar las preguntas dando de antemano las respuestas.

  1. assume(a<0); integrate(exp(a*x),x,0,inf);
  2. facts(); forget(a<0); assume(a>0); integrate(exp(a*x),x,0,inf); forget(a>0);

Si, por ejemplo, el primero lo ejecuta dos veces verá que Maxima le responde que la suposición es redundante, porque obviamente se le dijo anteriormente. Esto significa que Maxima se acuerda de las suposiciones realizadas, que podrían llegar a ser contradictorias. En consecuencia puede ser necesario anular las suposiciones previas antes de realizar una nueva.

 

indice

Bloques

Las asignaciones se realizan, por defecto, globalmente y afectan a todas las sentencias que se se ejecuten después de la asignación y que tengan que ver con ella. El comando block, entre otras cosas, permite limitar el campo de acción de una asignación a un bloque de código.

block([v_1,...,v_n], expr_1,...,expr_m) o bien
block(expr_1,...,expr_m)

El efecto del comando es evaluar las expresiones secuencialmente y devolver el valor de la última expresión evaluada.

En caso de usarse, las variables v_1,...,v_n son locales en el bloque y se distinguen de las globales que tengan el mismo nombre. Si no se declaran variables locales entonces se puede omitir la lista. Dentro del bloque, cualquier otra variable distinta de v_1,...,v_n se considera global. Al iniciarse, block guarda los valores actuales de las variables v_1,...,v_n y los recupera al finalizar, olvidando en cambio los valores que con carácter local dentro del bloque hayan tenido éstas.

Los comandos block pueden anidarse. Las variables locales se inicializan cada vez que se entra dentro de un nuevo bloque. Las variables locales de un bloque se consideran globales dentro de otro anidado dentro del primero. Si una variable es no local dentro de un bloque, su valor es el que le corresponde en el bloque superior. Este criterio se conoce con el nombre de "alcance dinámico". El valor del bloque es el de la última sentencia o el argumento de la función return, que puede utilizarse para salir del bloque.

Lea el manual para más información:

? block;

Una primera ilustración del uso del comando:

  1. x:5$ y:6$ x*y;
  2. block([x,y],x:9, y:3, x*y);
  3. x*y;

En el ejemplo que sigue, creado por J. Rafael Rodríguez Galván, se realiza una utilización más elaborada del comando block para obtener los ceros aproximados de una función que cambia de signo en un intervalo. Aparecen en él otros comandos como condicionales y similares propios de programación más avanzada. El lector que conozca el método de bipartición será capaz de comprender la estructura del código.

  1. /* creación del comando biparticion */ biparticion(f_objetivo,a,b,epsilon) := block( if( sign(f_objetivo(a)) = sign(f_objetivo(b)) ) then ( print("ERROR, f tiene el mismo signo en a y en b"), return(false) ) else do ( c:(a+b)/2, if( abs(f_objetivo(c))<epsilon) then return(c), if( sign(f_objetivo(a)) = sign(f_objetivo(c)) ) then a:c else b:c ) )$
  2. /* cero de una función en un intervalo usando biparticion */ f(x):=(2*x)^2-exp(-x)$ biparticion(f,0,1,0.01), numer;
Funciones.wxmx