Funciones y variables para listas (Manual de Maxima 5.44.0)

Anterior: Introducción a las listas, Subir: Listas [Índice general][Índice]

#### 5.4.2 Funciones y variables para listas

Operador: [
Operador: ]

  `[` y `]` marcan, respectivamente, el comienzo y el final de una lista.

  `[` y `]` también se utilizan para indicar los subíndices de una lista o de un array.

  Ejemplos:

      (%i1) x: [a, b, c];
      (%o1)                       [a, b, c]

      (%i2) x[3];
      (%o2)                           c

      (%i3) array (y, fixnum, 3);
      (%o3)                           y

      (%i4) y[2]: %pi;
      (%o4)                          %pi

      (%i5) y[2];
      (%o5)                          %pi

      (%i6) z['foo]: 'bar;
      (%o6)                          bar

      (%i7) z['foo];
      (%o7)                          bar

      (%i8) g[k] := 1/(k^2+1);
                                        1
      (%o8)                     g  := ------
                                 k     2
                                      k  + 1

      (%i9) g[10];
                                      1
      (%o9)                          ---
                                     101

Función: append (lista_1, ..., lista_n)

  Devuelve una lista cuyos elementos son los de la lista lista_1 seguidos de los de lista_2, ... La función `append` también opera con expresiones generales, como la llamada `append (f(a,b), f(c,d,e));`, de la que se obtiene `f(a,b,c,d,e)`.

  Tecléese `example(append);` para ver un ejemplo.

Función: assoc (clave, lista, valor_por_defecto)
Function: assoc (clave, lista)

  Esta función busca la clave en el lado derecho de la lista, la cual es de la forma `[x,y,z,...]`, donde cada elemento es una expresión formada por un operador binario y dos elementos. Por ejemplo, `x=1`, `2^3`, `[a,b]` etc. La clave se compara con el primer operando. La función `assoc` devuelve el segundo operando si se encuentra con que la `clave` coincide. Si la `clave` no coincide entonces devuelve el valor valor_por_defecto. El argumento valor_por_defecto es opcional; en caso de no estar presente, se devolverá `false`.

Función: cons (expr, lista)

  Devuelve una nueva lista en la que el elemento expr ocupa la primera posición, seguido de los elementos de lista. La función `cons` también opera con otro tipo de expresiones, como `cons(x, f(a,b,c));` -> `f(x,a,b,c)`.

Función: copylist (lista)

  Devuelve una copia de la lista.

Función: create_list (form, x_1, list_1, ..., x_n, list_n)

  Crea una lista mediante la evaluación de form con x_1 tomando cada uno de los valores de list_1, para cada uno de estos valores liga x_2 con cada elemento de list_2, .... El número de elementos en el resultado será el producto del número de elementos en cada lista. Cada variable x_i debe ser un símbolo y no será evaluado. La lista de argumentos será evaluada una vez al comienzo de la iteración.

  Ejemplos:

      (%i1) create_list (x^i, i, [1, 3, 7]);
                                      3   7
      (%o1)                      [x, x , x ]

  Con una doble iteración:

      (%i1) create_list ([i, j], i, [a, b], j, [e, f, h]);
      (%o1)   [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]

  En lugar de list_i se pueden suministrar dos argumentos cada uno de los cuales debería poder evaluarse a un número, los cuales serán los límites inferior y superior, ambos inclusive, para cada iteración.

      (%i1) create_list ([i, j], i, [1, 2, 3], j, 1, i);
      (%o1)   [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]

  Nótese que los límites o lista para la variable `j` pueden depender del valor actual de `i`.

Función: delete (expr_1, expr_2)
Función: delete (expr_1, expr_2, n)

  `delete(expr_1, expr_2)` elimina de expr_2 cualesquiera argumentos del operador del nivel superior que sean iguales a expr_1. Nótese que los argumentos de las subexpresiones no se ven afectados por esta función.

  expr_1 puede ser un átomo o una expresión no atómica. expr_2 puede ser cualquier expresión no atómica. La función `delete` devuelve una nueva expresión sin modificar expr_2.

  `delete(expr_1, expr_2, n)` elimina de expr_2 los primeros n argumentos del operador del nivel superior que sean iguales a expr_1. Si hay menos de n argumentos iguales, entonces se eliminan todos ellos.

  Ejemplos:

  Eliminando elementos de una lista.

      (%i1) delete (y, [w, x, y, z, z, y, x, w]);
      (%o1)                  [w, x, z, z, x, w]

  Eliminando términos de una suma.

      (%i1) delete (sin(x), x + sin(x) + y);
      (%o1)                         y + x

  Eliminando factores de un producto.

      (%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
      (%o1)                (u - w) (u - y) (u - z)

  Eliminando argumentos de una expresión arbitraria.

      (%i1) delete (a, foo (a, b, c, d, a));
      (%o1)                     foo(b, c, d)

  Limitando el número de argumentos a eliminar.

      (%i1) delete (a, foo (a, b, a, c, d, a), 2);
      (%o1)                    foo(b, c, d, a)

  Los argumentos se comparan respecto de "=". Aquellos argumentos que verifiquen la condición `equal`, pero no "=" no serán eliminados.

      (%i1) [is (equal (0, 0)), is (equal (0, 0.0)), is (equal (0, 0b0))];
      rat: replaced 0.0 by 0/1 = 0.0
      `rat' replaced 0.0B0 by 0/1 = 0.0B0
      (%o1)                  [true, true, true]

      (%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
      (%o2)                 [true, false, false]

      (%i3) delete (0, [0, 0.0, 0b0]);
      (%o3)                     [0.0, 0.0b0]

      (%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
      (%o4)                         true

      (%i5) is ((x + y)*(x - y) = x^2 - y^2);
      (%o5)                         false

      (%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
                                    2    2
      (%o6)                       [x  - y ]

Función: eighth (expr)

  Devuelve el octavo elemento de la lista o expresión expr. Véase `first` para más detalles.

Función: endcons (expr, lista)

  Devuelve una nueva lista formada por los elementos de `lista` seguidos de los de expr. La función `endcons` también opera con expresiones generales, por ejemplo `endcons(x, f(a,b,c));` -> `f(a,b,c,x)`.

Función: fifth (expr)

  Devuelve el quinto elemento de la lista o expresión expr. Véase `first` para más detalles.

Función: first (expr)

  Devuelve la primera parte de expr, que puede consistir en el primer elemento de una lista, la primera fila de una matriz, el primer término de una suma, etc. Nótese que tanto `first` como sus funciones relacionadas, `rest` y `last`, operan sobre la forma en la que expr es mostrada por Maxima, no sobre la forma en la que es introducida la expresión. Sin embargo, cuando la variable `inflag` toma el valor `true` estas funciones tendrán en cuenta el formato interno de expr. Téngase en cuenta que el simplificador reordena las expresiones. Así, `first(x+y)` devolverá `x` si `inflag` vale `true` y `y` cuando `inflag` tome el valor `false` (`first(y+x)` devuelve el mismo resultado). Las funciones `second` ... `tenth` devuelven desde el segundo hasta el décimo elemento del argumento de entrada.

Función: fourth (expr)

  Devuelve el cuarto elemento de la lista o expresión expr. Véase `first` para más detalles.

Función: join (l, m)

  Crea una nueva lista con los elementos de las listas l y m alternados. El resultado tiene como elementos `[l[1], m[1], l[2], m[2], ...]`. Las listas l y m pueden contener cualquier tipo de elementos.

  Si las listas son de diferente longitud, `join` ignora los elementos sobrantes de la lista más larga.

  Maxima da error si o bien l o m no son listas.

  Ejemplos:

      (%i1) L1: [a, sin(b), c!, d - 1];
      (%o1)                [a, sin(b), c!, d - 1]

      (%i2) join (L1, [1, 2, 3, 4]);
      (%o2)          [a, 1, sin(b), 2, c!, 3, d - 1, 4]

      (%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
      (%o3)        [a, aa, sin(b), bb, c!, cc, d - 1, dd]

Función: last (expr)

  Devuelve la última parte (término, fila, elemento, etc.) de expr.

Función: length (expr)

  Devuelve (por defecto) el número de partes de que consta expr en la versión correspondiente a la que muestra. En el caso de listas, se devuelve el número de elementos, si se trata de matrices el número de filas y se se trata de sumas el número de términos o sumandos (véase `dispform`).

  La función `length` se ve afectada por el valor de la variable `inflag`. Así, `length(a/(b*c));` devuelve 2 si `inflag` vale `false` (dando por hecho que `exptdispflag` vale `true`), pero devuelve 3 si `inflag` vale `true` (ya que la representación interna es `a*b^-1*c^-1`).

Variable opcional: listarith

  Valor por defecto: `true`

  Cuando vale `false` provoca que no se realicen operaciones aritméticas con listas; cuando vale `true`, las operaciones con listas y matrices son contagiosas, en el sentido de que las listas se transforman en matrices, retornando resultados de este último tipo. Sin embargo, operaciones que involucren listas con listas devolverán también listas.

Función: listp (expr)

  Devuelve el valor `true` si expr es una lista, y `false` en caso contrario.

Función: makelist ()
Función: makelist (expr, n)
Función: makelist (expr, i, i_max)
Función: makelist (expr, i, i_0, i_max)
Función: makelist (expr, i, i_0, i_max, step)
Función: makelist (expr, x, list)

  El primer formato, `makelist ()`, crea una lista vacía. El segundo formato, `makelist (expr)`, crea una lista con expr como único elemento. `makelist (expr, n)` crea una lista de n elementos generados a partir de expr.

  El formato más general, `makelist (expr, i, i_0, i_max, step)`, devuelve la lista de elementos obtenidos al aplicar `ev (expr, i=j)` a los elementos j de la secuencia i_0, i_0 + step, i_0 + 2*step, ..., siendo |j| menor o igual que |i_max|.

  El incremento step puede ser un número (positivo o negativo) o una expresión. En caso de omitirse, se utilizará 1 como valor por defecto. Si se omiten i_0 y step, se le asignará a ambos 1 como valor por defecto.

  `makelist (expr, x, list)` devuelve una lista, cuyo `j`-ésimo elemento es igual a `ev (expr, x=list[j])` tomando `j` valores desde 1 hasta `length (list)`.

  Ejemplos:

      (%i1) makelist (concat (x,i), i, 6);
      (%o1)               [x1, x2, x3, x4, x5, x6]

      (%i2) makelist (x=y, y, [a, b, c]);
      (%o2)                 [x = a, x = b, x = c]

      (%i3) makelist (x^2, x, 3, 2*%pi, 2);
      (%o3)                        [9, 25]

      (%i4) makelist (random(6), 4);
      (%o4)                     [2, 0, 2, 5]

      (%i5) flatten (makelist (makelist (i^2, 3), i, 4));
      (%o5)        [1, 1, 1, 4, 4, 4, 9, 9, 9, 16, 16, 16]

      (%i6) flatten (makelist (makelist (i^2, i, 3), 4));
      (%o6)         [1, 4, 9, 1, 4, 9, 1, 4, 9, 1, 4, 9]

Función: member (expr_1, expr_2)

  Devuelve `true` si `is(expr_1 = a)` para algún elemento a de `args(expr_2)`, en caso contrario devuelve `false`.

  Normalmente, `expr_2` será una lista, en cuyo caso `args(expr_2) = expr_2`, y la comprobación será si `is(expr_1 = a)` para algún elemento a de `expr_2`.

  La función `member` no inspecciona las partes de los argumentos de `expr_2`, por lo que puede devolver `false` si `expr_1` es parte de alguno de los argumentos de `expr_2`.

  Véase también `elementp`.

  Ejemplos:

      (%i1) member (8, [8, 8.0, 8b0]);
      (%o1)                         true

      (%i2) member (8, [8.0, 8b0]);
      (%o2)                         false

      (%i3) member (b, [a, b, c]);
      (%o3)                         true

      (%i4) member (b, [[a, b], [b, c]]);
      (%o4)                         false

      (%i5) member ([b, c], [[a, b], [b, c]]);
      (%o5)                         true

      (%i6) F (1, 1/2, 1/4, 1/8);
                                     1  1  1
      (%o6)                     F(1, -, -, -)
                                     2  4  8

      (%i7) member (1/8, %);
      (%o7)                         true

      (%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
      (%o8)                         true

Función: ninth (expr)

  Devuelve el noveno elemento de la lista o expresión expr. Véase `first` para más detalles.

Función: pop (list)

  Borra el primer elemento de la lista list y devuelve este mismo elemento.

  Si el argumento list es una lista vacía, o simplemente no es una lista, Maxima devuelve un mensaje de error.

  Véase `push` para los ejemplos.

  Ejecútese `load(basic)` antes de utilizar esta función.

Función: push (item, list)

  Añade al comienzo de la lista list el elemento item, devolviendo este mismo elemento. El argumento list debe ser necesariamente una lista, mientras que item puede ser cualquier símbolo o expresión.

  Si el argumento list no es una lista, Maxima devuelve un mensaje de error.

  Véase `pop` para eliminar el primer elemento de una lista.

  Ejecútese `load(basic)` antes de utilizar esta función.

  Ejemplos:

      (%i1) load ("basic")$

      (%i2) ll: [];
      (%o2)                          []

      (%i3) push (x, ll);
      (%o3)                          [x]

      (%i4) push (x^2+y, ll);
                                       2
      (%o4)                      [y + x , x]

      (%i5) a: push ("string", ll);
                                           2
      (%o5)                  [string, y + x , x]

      (%i6) pop (ll);
      (%o6)                        string

      (%i7) pop (ll);
                                        2
      (%o7)                        y + x

      (%i8) pop (ll);
      (%o8)                           x

      (%i9) ll;
      (%o9)                          []

      (%i10) a;
                                           2
      (%o10)                 [string, y + x , x]

Función: rest (expr, n)
Función: rest (expr)

  Devuelve expr sin sus primeros n elementos si n es positivo, o sus últimos `- n` elementos si n es negativo. En caso de que n tome el valor 1 puede ser omitido. La expresión expr puede ser una lista, una matriz o cualquier otra expresión.

Función: reverse (lista)

  Invierte el orden de los elementos de la lista (no los propios elementos). La función `reverse` también opera sobre expresiones generales, como en `reverse(a=b);` gives `b=a`.

Función: second (expr)

  Devuelve el segundo elemento de la lista o expresión expr. Véase `first` para más detalles.

Función: seventh (expr)

  Devuelve el séptimo elemento de la lista o expresión expr. Véase `first` para más detalles.

Función: sixth (expr)

  Devuelve el sexto elemento de la lista o expresión expr. Véase `first` para más detalles.

Función: sort (L, P)
Función: sort (L)

  `sort(L, P)` ordena la lista L de acuerdo con el predicado `P` de dos argumentos, el cual define un preorden total sobre los elementos de L. Si `P(a, b)` vale `true`, entonces `a` aparece antes que `b` en el resultado. Si ninguna de las expresiones `P(a, b)` y `P(b, a)` valen `true`, entonces `a` y `b` son equivalentes y aparecen en el resultado en el mismo orden que a la entrada; esto es, `sort` es un orden estable.

  Si tanto `P(a, b)` como `P(b, a)` valen ambos `true` para algunos elementos de L, entonces P no es un predicado de orden correcto, siento entonces el resultado indefinido. Si `P(a, b)` toma un valor diferente a `true` o `false`, entonces `sort` devuelve un error.

  El predicado puede especificarse como el nombre de una función, de una operación binaria infija o como una expresión `lambda`. Si se especifica con el nombre de un operador, dicho nombre debe encerrarse con comillas dobles.

  La lista ordenada se devuelve como un nuevo objeto, no modificándose el argumento L.

  `sort(L)` equivale a `sort(L, orderlessp)`.

  La ordenación por defecto es ascendente, tal como queda determinada por `orderlessp`. El predicado `ordergreatp` ordena las listas en orden descendente.

  Todos los átomos y expresiones de Maxima son comparables respecto de los predicados `orderlessp` y `ordergreatp`.

  Los operadores `<` y `>` ordenan números, constantes y expresiones constantes por magnitud. Nótese que `orderlessp` y `ordergreatp` no ordenan números, constantes y expresiones constantes por magnitud.

  `ordermagnitudep` ordena números, constantes y expresiones constantes de igual modo que lo hace `<`, y cualesquiera otros elementos lo hace igual que `orderlessp`.

  Ejemplos:

  `sort` ordena una lista respecto de un predicado de dos argumentos que define un preorden total en los elementos de la lista.

      (%i1) sort ([1, a, b, 2, 3, c], 'orderlessp);
      (%o1)                  [1, 2, 3, a, b, c]
      (%i2) sort ([1, a, b, 2, 3, c], 'ordergreatp);
      (%o2)                  [c, b, a, 3, 2, 1]

  El predicado puede especificarse con el nombre de una función, de un operador binario infijo o una expresión `lambda`. Si se especifica con el nombre de un operador, dicho nombre debe encerrarse con comillas dobles.

      (%i1) L : [[1, x], [3, y], [4, w], [2, z]];
      (%o1)           [[1, x], [3, y], [4, w], [2, z]]
      (%i2) foo (a, b) := a[1] > b[1];
      (%o2)                 foo(a, b) := a  > b
                                          1    1
      (%i3) sort (L, 'foo);
      (%o3)           [[4, w], [3, y], [2, z], [1, x]]
      (%i4) infix (">>");
      (%o4)                          >>
      (%i5) a >> b := a[1] > b[1];
      (%o5)                   a >> b := a  > b
                                         1    1
      (%i6) sort (L, ">>");
      (%o6)           [[4, w], [3, y], [2, z], [1, x]]
      (%i7) sort (L, lambda ([a, b], a[1] > b[1]));
      (%o7)           [[4, w], [3, y], [2, z], [1, x]]

  `sort(L)` equivale a `sort(L, orderlessp)`.

      (%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi];
      (%o1)             [a, 2 b, - 5, 7, %e + 1, %pi]
      (%i2) sort (L);
      (%o2)             [- 5, 7, %e + 1, %pi, a, 2 b]
      (%i3) sort (L, 'orderlessp);
      (%o3)             [- 5, 7, %e + 1, %pi, a, 2 b]

  La ordenación por defecto es ascendente, tal como queda determinada por `orderlessp`. El predicado `ordergreatp` ordena las listas en orden descendente.

      (%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi];
      (%o1)                    [a, 2 b, - 5, 7, %e + 1, %pi]
      (%i2) sort (L);
      (%o2)                    [- 5, 7, %e + 1, %pi, a, 2 b]
      (%i3) sort (L, 'ordergreatp);
      (%o3)                    [2 b, a, %pi, %e + 1, 7, - 5]

  Todos los átomos y expresiones de Maxima son comparables respecto de los predicados `orderlessp` y `ordergreatp`.

      (%i1) L : [11, -17, 29b0, 9*c, 7.55, foo(x, y), -5/2, b + a];
                                                       5
      (%o1)  [11, - 17, 2.9b1, 9 c, 7.55, foo(x, y), - -, b + a]
                                                       2
      (%i2) sort (L, orderlessp);
                      5
      (%o2)  [- 17, - -, 7.55, 11, 2.9b1, b + a, 9 c, foo(x, y)]
                      2
      (%i3) sort (L, ordergreatp);
                                                        5
      (%o3)  [foo(x, y), 9 c, b + a, 2.9b1, 11, 7.55, - -, - 17]
                                                        2

  Los operadores `<` y `>` ordenan números, constantes y expresiones constantes por magnitud. Nótese que `orderlessp` y `ordergreatp` no ordenan números, constantes y expresiones constantes por magnitud.

      (%i1) L : [%pi, 3, 4, %e, %gamma];
      (%o1)                [%pi, 3, 4, %e, %gamma]
      (%i2) sort (L, ">");
      (%o2)                [4, %pi, 3, %e, %gamma]
      (%i3) sort (L, ordergreatp);
      (%o3)                [%pi, %gamma, %e, 4, 3]

  `ordermagnitudep` ordena números, constantes y expresiones constantes de igual modo que lo hace `<`, y cualesquiera otros elementos lo hace igual que `orderlessp`.

      (%i1) L : [%i, 1+%i, 2*x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0, 1.0b0];
      (%o1) [%i, %i + 1, 2 x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0,
                                                                 1.0b0]
      (%i2) sort (L, ordermagnitudep);
      (%o2) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
                                                           %i + 1, 2 x]
      (%i3) sort (L, orderlessp);
      (%o3) [0, 1, 1.0, 2, 3, %e, %i, %i + 1, inf, minf, sin(1),
                                                            1.0b0, 2 x]

Función: sublist (list, p)

  Devuelve la lista de elementos de list para los cuales el predicado `p` retorna `true`.

  Ejemplo:

      (%i1) L: [1, 2, 3, 4, 5, 6];
      (%o1)                  [1, 2, 3, 4, 5, 6]

      (%i2) sublist (L, evenp);
      (%o2)                       [2, 4, 6]

Función: sublist_indices (L, P)

  Devuelve los índices de los elementos `x` de la lista L para la cual el predicado `maybe(P(x))` devuelve `true`, lo que excluye a `unknown` y a `false`. P puede ser el nombre de una función o de una expresión lambda. L debe ser una lista literal.

  Ejemplos:

      (%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
                             lambda ([x], x='b));
      (%o1)                     [2, 3, 7, 9]

      (%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
      (%o2)                  [1, 2, 3, 4, 7, 9]

      (%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
                             identity);
      (%o3)                       [1, 4, 5]

      (%i4) assume (x < -1);
      (%o4)                       [x < - 1]

      (%i5) map (maybe, [x > 0, x < 0, x < -2]);
      (%o5)                [false, true, unknown]

      (%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
      (%o6)                          [2]

Función: unique (L)

  Devuelve la lista L sin redundancias, es decir, sin elementos repetidos

  Cuando ninguno de los elementos de L está repetido, `unique` devuelve una réplica de L, no la propia L.

  Si L no es una lista, `unique` devuelve L.

  Ejemplo:

      (%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
      (%o1)              [1, 2, %e, %pi, [1], b + a]

Función: tenth (expr)

  Devuelve el décimo elemento de la lista o expresión expr. Véase `first` para más detalles.

Función: third (expr)

  Devuelve el tercer elemento de la lista o expresión expr. Véase `first` para más detalles.

Anterior: Introducción a las listas, Subir: Listas [Índice general][Índice]