Siguiente: Operadores definidos por el usuario, Anterior: Operadores para ecuaciones, Subir: Operadores [Índice general][Índice]
Operador de asignación.
Cuando el miembro de la izquierda es una variable simple (no subindicada),
: evalúa la expresión de la derecha y asigna ese
valor a la variable del lado izquierdo.
Cuando en el lado izquierdo hay un elemento subindicado correspondiente a una lista, matriz, array declarado de Maxima o array de Lisp, la expresión de la derecha se asigna a ese elemento. El subíndice debe hacer referencia a un elemento ya existente, ya que los objetos anteriores no pueden ampliarse nombrando elementos no existentes.
Cuando en el lado izquierdo hay un elemento subindicado correspondiente a un array no declarado de Maxima, la expresión de la derecha se asigna a ese elemento en caso de que ya exista, o a un nuevo elemento, si éste todavía no existe.
Cuando el miembro de la izquierda es una lista de átomos y/o variables subindicadas, el miembro derecho debe evaluar también a una lista, cuyos elementos serán asignados en paralelo a las variables de la lista de la izquierda.
Véanse también kill y remvalue, que deshacen las asociaciones
hechas por el operador :.
Ejemplos:
Asignación a una variable simple.
(%i1) a; (%o1) a (%i2) a : 123; (%o2) 123 (%i3) a; (%o3) 123
Asignación a un elemento de una lista.
(%i1) b : [1, 2, 3]; (%o1) [1, 2, 3] (%i2) b[3] : 456; (%o2) 456 (%i3) b; (%o3) [1, 2, 456]
La asignación crea un array no declarado.
(%i1) c[99] : 789; (%o1) 789 (%i2) c[99]; (%o2) 789 (%i3) c; (%o3) c (%i4) arrayinfo (c); (%o4) [hashed, 1, [99]] (%i5) listarray (c); (%o5) [789]
Asignación múltiple.
(%i1) [a, b, c] : [45, 67, 89]; (%o1) [45, 67, 89] (%i2) a; (%o2) 45 (%i3) b; (%o3) 67 (%i4) c; (%o4) 89
La asignación múltiple se hace en paralelo. Los valores
de a y b se intercambian en este ejemplo.
(%i1) [a, b] : [33, 55]; (%o1) [33, 55] (%i2) [a, b] : [b, a]; (%o2) [55, 33] (%i3) a; (%o3) 55 (%i4) b; (%o4) 33
Operador de asignación.
El operador :: es similar a :, excepto que ::
evalúa ambos miembros, tanto el derecho como el izquierdo.
Ejemplos:
(%i1) x : 'foo; (%o1) foo (%i2) x :: 123; (%o2) 123 (%i3) foo; (%o3) 123 (%i4) x : '[a, b, c]; (%o4) [a, b, c] (%i5) x :: [11, 22, 33]; (%o5) [11, 22, 33] (%i6) a; (%o6) 11 (%i7) b; (%o7) 22 (%i8) c; (%o8) 33
El operador de definición de macros ::= define una función (llamada macro por razones históricas) que no evalúa sus argumentos, siendo la expresión que retorna (llamada "macroexpansión") evaluada dentro del contexto desde el cual se ha invocado la macro. En cualquier otro sentido, una función macro es igual que una función ordinaria.
macroexpand devuelve la expresión que a su vez fue devuelta por una macro (sin evaluar la expresión);
macroexpand (foo (x)) seguida de ''% es equivalente a foo (x) si foo es una función macro.
::= coloca el nombre de la nueva función macro en la lista global macros. Por otro lado, las funciones
kill, remove y remfunction borran las definiciones de las funciones macro y eliminan sus nombres de la lista macros.
Las funciones fundef y dispfun devuelven la definición de una función macro y le asignan una etiqueta, respectivamente.
Las funciones macro normalmente contienen expresiones buildq y splice para construir una expresión, que luego será evaluada.
Ejemplos:
Una función macro no evalúa sus argumentos, por lo que el mensaje (1) muestra y - z, no el valor de y - z.
La macroexpansión (es decir, la expresión no evaluada '(print ("(2) x is equal to", x))) se evalúa en el contexto desde el cual se produjo la llamada a la macro, imprimiendo el mensaje (2).
(%i1) x: %pi$
(%i2) y: 1234$
(%i3) z: 1729 * w$
(%i4) printq1 (x) ::= block (print ("(1) x is equal to", x),
'(print ("(2) x is equal to", x)))$
(%i5) printq1 (y - z);
(1) x is equal to y - z
(2) x is equal to %pi
(%o5) %pi
Una función ordinaria evalúa sus argumentos, por lo que el mensaje (1) muestra el valor de y - z.
El valor de retorno no se evalúa, por lo que el mensaje (2) no se imprime hasta la evaluación explícita ''%.
(%i1) x: %pi$
(%i2) y: 1234$
(%i3) z: 1729 * w$
(%i4) printe1 (x) := block (print ("(1) x is equal to", x),
'(print ("(2) x is equal to", x)))$
(%i5) printe1 (y - z);
(1) x is equal to 1234 - 1729 w
(%o5) print((2) x is equal to, x)
(%i6) ''%;
(2) x is equal to %pi
(%o6) %pi
macroexpand devuelve la macroexpansión;
macroexpand (foo (x)) seguida de ''% es equivalente a foo (x) si foo es una función macro.
(%i1) x: %pi$
(%i2) y: 1234$
(%i3) z: 1729 * w$
(%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$
(%i5) macroexpand (g (y - z));
(%o5) print(x is equal to, y - z)
(%i6) ''%;
x is equal to 1234 - 1729 w
(%o6) 1234 - 1729 w
(%i7) g (y - z);
x is equal to 1234 - 1729 w
(%o7) 1234 - 1729 w
El operador de definición de funciones.
La expresión f(x_1, ..., x_n) := expr
define una función de nombre f con argumentos
x_1, ..., x_n y cuerpo expr.
El operador := no evalúa el cuerpo de la función (a menos que
se indique lo contrario mediante el operador comilla-comilla '').
La función así definida puede ser una función ordinaria
de Maxima (con argumentos encerrados entre paréntesis) o una función
array (con argumentos encerrados entre corchetes).
Cuando el último o único argumento x_n es una lista de un solo
elemento, la función definida por := acepta un número variable
de argumentos. Los valores de los argumentos se asignan uno a uno a los
argumentos formales x_1, ..., x_(n - 1), y cualesquiera otros
valores de argumentos, si existen, se asignan a x_n en forma de lista.
Todas las definiciones de funciones aparecen en el mismo espacio de
nombres; definiendo una función f dentro de otra función g
no limita automáticamente el alcance de f a g.
No obstante, local(f) hace que la función f
sea efectiva solamente dentro del bloque o empaquetado de expresiones en la
que aparece local.
Si un argumento formal x_k es un símbolo afectado por el
operador comilla (expresión nominal), la función definida por := no evalúa el
correspondiente valor de argumento.
En cualquier otro caso, los argumentos que se pasan son evaluados.
Véanse también define y ::=.
Ejemplos:
:= no evalúa el cuerpo de la función (a menos que
se indique lo contrario mediante el operador comilla-comilla '').
(%i1) expr : cos(y) - sin(x); (%o1) cos(y) - sin(x) (%i2) F1 (x, y) := expr; (%o2) F1(x, y) := expr (%i3) F1 (a, b); (%o3) cos(y) - sin(x) (%i4) F2 (x, y) := ''expr; (%o4) F2(x, y) := cos(y) - sin(x) (%i5) F2 (a, b); (%o5) cos(b) - sin(a)
La función así definida puede ser una función ordinaria de Maxima o una función array.
(%i1) G1 (x, y) := x.y - y.x;
(%o1) G1(x, y) := x . y - y . x
(%i2) G2 [x, y] := x.y - y.x;
(%o2) G2 := x . y - y . x
x, y
Cuando el último o único argumento x_n es una lista de un solo
elemento, la función definida por := acepta un número variable
de argumentos.
(%i1) H ([L]) := apply ("+", L);
(%o1) H([L]) := apply("+", L)
(%i2) H (a, b, c);
(%o2) c + b + a
local define una función como local.
(%i1) foo (x) := 1 - x; (%o1) foo(x) := 1 - x (%i2) foo (100); (%o2) - 99 (%i3) block (local (foo), foo (x) := 2 * x, foo (100)); (%o3) 200 (%i4) foo (100); (%o4) - 99
Siguiente: Operadores definidos por el usuario, Anterior: Operadores para ecuaciones, Subir: Operadores [Índice general][Índice]