Operadores de asignación (Manual de Maxima 5.46.0)

Siguiente: Operadores definidos por el usuario, Anterior: Operadores para ecuaciones, Subir: Operadores [Índice general][Índice]

### 6.6 Operadores de asignación

Operador: : ¶

  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: :: ¶

  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

Operador: ::= ¶

  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

Operador: := ¶

  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]