@c English version 2011-12-03
@page
@node Listas, Arrays, Constantes, Tipos de datos y estructuras
@section Listas

@menu
* Introducción a las listas::       
* Funciones y variables para listas::       
@end menu

@node Introducción a las listas, Funciones y variables para listas, Listas, Listas
@subsection Introducción a las listas

Las listas son bloques de construcción básica para Maxima y Lisp. Todos los tipos de datos
diferentes a los arreglos, tablas mixtas o números son representados como listas Lisp,
estas listas Lisp tienen la forma

@example
((MPLUS) $A 2)
@end example

@noindent
para indicar la expresión @code{a+2}. Al nivel de Maxima se observará
la notación infija @code{a+2}. Maxima también tiene listas con el formato

@example
[1, 2, 7, x+y]
@end example

@noindent
para una lista de 4 elementos. Internamente esto se corresponde con una lista Lisp
de la forma

@example
((MLIST) 1  2  7  ((MPLUS)  $X $Y ))
@end example

@noindent
El elemento que denota el tipo de expresión en Maxima es también una lista, la cual tras ser analizada y simplificada tomará la forma

@example
((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))
@end example


@node Funciones y variables para listas,  , Introducción a las listas, Listas
@subsection Funciones y variables para listas



@defvr  {Operador} [
@defvrx {Operador} ]
@ifinfo
@fnindex Acotador de listas
@fnindex Operador para subíndices
@end ifinfo

@code{[} y @code{]} marcan, respectivamente, el comienzo y el final de una lista.

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

Ejemplos:

@c ===beg===
@c x: [a, b, c];
@c x[3];
@c array (y, fixnum, 3);
@c y[2]: %pi;
@c y[2];
@c z['foo]: 'bar;
@c z['foo];
@c g[k] := 1/(k^2+1);
@c g[10];
@c ===end===
@example
@group
(%i1) x: [a, b, c];
(%o1)                       [a, b, c]
@end group
@group
(%i2) x[3];
(%o2)                           c
@end group
@group
(%i3) array (y, fixnum, 3);
(%o3)                           y
@end group
@group
(%i4) y[2]: %pi;
(%o4)                          %pi
@end group
@group
(%i5) y[2];
(%o5)                          %pi
@end group
@group
(%i6) z['foo]: 'bar;
(%o6)                          bar
@end group
@group
(%i7) z['foo];
(%o7)                          bar
@end group
@group
(%i8) g[k] := 1/(k^2+1);
                                  1
(%o8)                     g  := ------
                           k     2
                                k  + 1
@end group
@group
(%i9) g[10];
                                1
(%o9)                          ---
                               101
@end group
@end example

@end defvr




@deffn {Función} append (@var{lista_1}, ..., @var{lista_n})

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

Tecléese @code{example(append);} para ver un ejemplo.

@end deffn

@deffn {Función} assoc (@var{clave}, @var{lista}, @var{valor_por_defecto})
@deffnx {Function} assoc (@var{clave}, @var{lista})

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

@end deffn


@deffn {Función} cons (@var{expr}, @var{lista})

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

@end deffn

@deffn {Función} copylist (@var{lista})

Devuelve una copia de la @var{lista}.

@end deffn


@deffn {Función} create_list (@var{form}, @var{x_1}, @var{list_1}, ..., @var{x_n}, @var{list_n})
Crea una lista mediante la evaluación de @var{form} con @var{x_1} tomando cada uno de los
valores de @var{list_1}, para cada uno de estos valores liga @var{x_2} con cada elemento de 
@var{list_2}, .... El número de elementos en el resultado será el producto del número de elementos
en cada lista. Cada variable @var{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:

@c ===beg===
@c create_list (x^i, i, [1, 3, 7]);
@c ===end===
@example
@group
(%i1) create_list (x^i, i, [1, 3, 7]);
                                3   7
(%o1)                      [x, x , x ]
@end group
@end example

@noindent
Con una doble iteración:

@c ===beg===
@c create_list ([i, j], i, [a, b], j, [e, f, h]);
@c ===end===
@example
@group
(%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]]
@end group
@end example

En lugar de @var{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.

@c ===beg===
@c create_list ([i, j], i, [1, 2, 3], j, 1, i);
@c ===end===
@example
@group
(%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]]
@end group
@end example

Nótese que los límites o lista para la variable @code{j} pueden depender
del valor actual de @code{i}.
@end deffn


@deffn {Función} delete (@var{expr_1}, @var{expr_2})
@deffnx {Función} delete (@var{expr_1}, @var{expr_2}, @var{n})

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

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

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

Ejemplos:

Eliminando elementos de una lista.

@c ===beg===
@c delete (y, [w, x, y, z, z, y, x, w]);
@c ===end===
@example
@group
(%i1) delete (y, [w, x, y, z, z, y, x, w]);
(%o1)                  [w, x, z, z, x, w]
@end group
@end example

Eliminando términos de una suma.

@c ===beg===
@c delete (sin(x), x + sin(x) + y);
@c ===end===
@example
@group
(%i1) delete (sin(x), x + sin(x) + y);
(%o1)                         y + x
@end group
@end example

Eliminando factores de un producto.

@c ===beg===
@c delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
@c ===end===
@example
@group
(%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
(%o1)                (u - w) (u - y) (u - z)
@end group
@end example

Eliminando argumentos de una expresión arbitraria.

@c ===beg===
@c delete (a, foo (a, b, c, d, a));
@c ===end===
@example
@group
(%i1) delete (a, foo (a, b, c, d, a));
(%o1)                     foo(b, c, d)
@end group
@end example

Limitando el número de argumentos a eliminar.

@c ===beg===
@c delete (a, foo (a, b, a, c, d, a), 2);
@c ===end===
@example
@group
(%i1) delete (a, foo (a, b, a, c, d, a), 2);
(%o1)                    foo(b, c, d, a)
@end group
@end example

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

@c ===beg===
@c [is (equal (0, 0)), is (equal (0, 0.0)), is (equal (0, 0b0))];
@c [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
@c delete (0, [0, 0.0, 0b0]);
@c is (equal ((x + y)*(x - y), x^2 - y^2));
@c is ((x + y)*(x - y) = x^2 - y^2);
@c delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
@c ===end===
@example
@group
(%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]
@end group
@group
(%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
(%o2)                 [true, false, false]
@end group
@group
(%i3) delete (0, [0, 0.0, 0b0]);
(%o3)                     [0.0, 0.0b0]
@end group
@group
(%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
(%o4)                         true
@end group
@group
(%i5) is ((x + y)*(x - y) = x^2 - y^2);
(%o5)                         false
@end group
@group
(%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
                              2    2
(%o6)                       [x  - y ]
@end group
@end example
@end deffn

@deffn {Función} eighth (@var{expr})

Devuelve el octavo elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.

@end deffn

@deffn {Función} endcons (@var{expr}, @var{lista})

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

@end deffn

@deffn {Función} fifth (@var{expr})

Devuelve el quinto elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.

@end deffn

@deffn {Función} first (@var{expr})

Devuelve la primera parte de @var{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 @code{first} como sus funciones relacionadas, @code{rest} y @code{last}, operan sobre la forma en la que @var{expr} es mostrada por Maxima, no sobre la forma en la que es introducida la expresión. Sin embargo, cuando la variable @code{inflag} toma el valor @code{true} estas funciones tendrán en cuenta el formato interno de @var{expr}. Téngase en cuenta que el simplificador reordena las expresiones.  Así, @code{first(x+y)} devolverá @code{x} si @code{inflag} vale @code{true} y @code{y} cuando @code{inflag} tome el valor @code{false} (@code{first(y+x)} devuelve el mismo resultado). Las funciones @code{second} ... @code{tenth} devuelven desde el segundo hasta el décimo elemento del argumento de entrada.

@end deffn

@deffn {Función} fourth (@var{expr})

Devuelve el cuarto elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.

@end deffn




@deffn {Función} join (@var{l}, @var{m})
Crea una nueva lista con los elementos de las listas @var{l} y @var{m} alternados.
El resultado tiene como elementos @code{[@var{l}[1], @var{m}[1], @var{l}[2], @var{m}[2], ...]}.
Las listas @var{l} y @var{m} pueden contener cualquier tipo de elementos.

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

Maxima da error si o bien @var{l} o @var{m} no son listas.

Ejemplos:

@c ===beg===
@c L1: [a, sin(b), c!, d - 1];
@c join (L1, [1, 2, 3, 4]);
@c join (L1, [aa, bb, cc, dd, ee, ff]);
@c ===end===
@example
@group
(%i1) L1: [a, sin(b), c!, d - 1];
(%o1)                [a, sin(b), c!, d - 1]
@end group
@group
(%i2) join (L1, [1, 2, 3, 4]);
(%o2)          [a, 1, sin(b), 2, c!, 3, d - 1, 4]
@end group
@group
(%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
(%o3)        [a, aa, sin(b), bb, c!, cc, d - 1, dd]
@end group
@end example

@end deffn


@deffn {Función} last (@var{expr})

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

@end deffn

@deffn {Función} length (@var{expr})

Devuelve (por defecto) el número de partes de que consta @var{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 @code{dispform}).

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

@end deffn

@defvr {Variable opcional} listarith
Valor por defecto: @code{true}

Cuando vale @code{false} provoca que no se realicen operaciones aritméticas con listas;  cuando vale @code{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.

@end defvr

@deffn {Función} listp (@var{expr})

Devuelve el valor @code{true} si @var{expr} es una lista, y @code{false} en caso contrario.

@end deffn



@deffn  {Función} makelist ()
@deffnx {Función} makelist (@var{expr}, @var{n})
@deffnx {Función} makelist (@var{expr}, @var{i}, @var{i_max})
@deffnx {Función} makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_max})
@deffnx {Función} makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_max}, @var{step})
@deffnx {Función} makelist (@var{expr}, @var{x}, @var{list})

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

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

El incremento @var{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  @var{i_0} y @var{step}, se le asignará a ambos 1 como valor
por defecto.

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


Ejemplos:

@c ===beg===
@c makelist (concat (x,i), i, 6);
@c makelist (x=y, y, [a, b, c]);
@c makelist (x^2, x, 3, 2*%pi, 2);
@c makelist (random(6), 4);
@c flatten (makelist (makelist (i^2, 3), i, 4));
@c flatten (makelist (makelist (i^2, i, 3), 4));
@c ===end===
@example
@group
(%i1) makelist (concat (x,i), i, 6);
(%o1)               [x1, x2, x3, x4, x5, x6]
@end group
@group
(%i2) makelist (x=y, y, [a, b, c]);
(%o2)                 [x = a, x = b, x = c]
@end group
@group
(%i3) makelist (x^2, x, 3, 2*%pi, 2);
(%o3)                        [9, 25]
@end group
@group
(%i4) makelist (random(6), 4);
(%o4)                     [2, 0, 2, 5]
@end group
@group
(%i5) flatten (makelist (makelist (i^2, 3), i, 4));
(%o5)        [1, 1, 1, 4, 4, 4, 9, 9, 9, 16, 16, 16]
@end group
@group
(%i6) flatten (makelist (makelist (i^2, i, 3), 4));
(%o6)         [1, 4, 9, 1, 4, 9, 1, 4, 9, 1, 4, 9]
@end group
@end example

@end deffn

@deffn {Función} member (@var{expr_1}, @var{expr_2})

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

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

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

Véase también @code{elementp}.

Ejemplos:

@c ===beg===
@c member (8, [8, 8.0, 8b0]);
@c member (8, [8.0, 8b0]);
@c member (b, [a, b, c]);
@c member (b, [[a, b], [b, c]]);
@c member ([b, c], [[a, b], [b, c]]);
@c F (1, 1/2, 1/4, 1/8);
@c member (1/8, %);
@c member ("ab", ["aa", "ab", sin(1), a + b]);
@c ===end===
@example
@group
(%i1) member (8, [8, 8.0, 8b0]);
(%o1)                         true
@end group
@group
(%i2) member (8, [8.0, 8b0]);
(%o2)                         false
@end group
@group
(%i3) member (b, [a, b, c]);
(%o3)                         true
@end group
@group
(%i4) member (b, [[a, b], [b, c]]);
(%o4)                         false
@end group
@group
(%i5) member ([b, c], [[a, b], [b, c]]);
(%o5)                         true
@end group
@group
(%i6) F (1, 1/2, 1/4, 1/8);
                               1  1  1
(%o6)                     F(1, -, -, -)
                               2  4  8
@end group
@group
(%i7) member (1/8, %);
(%o7)                         true
@end group
@group
(%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
(%o8)                         true
@end group
@end example
@end deffn



@deffn {Función} ninth (@var{expr})

Devuelve el noveno elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.
@end deffn



@deffn {Función} pop (@var{list})

Borra el primer elemento de la lista @var{list} y devuelve este
mismo elemento.

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

Véase @code{push} para los ejemplos.

Ejecútese @code{load(basic)} antes de utilizar esta función.
@end deffn




@deffn {Función} push (@var{item}, @var{list})

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

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

Véase @code{pop} para eliminar el primer elemento de una lista.

Ejecútese @code{load(basic)} antes de utilizar esta función.

Ejemplos:

@c ===beg===
@c load ("basic")$
@c ll: [];
@c push (x, ll);
@c push (x^2+y, ll);
@c a: push ("string", ll);
@c pop (ll);
@c pop (ll);
@c pop (ll);
@c ll;
@c a;
@c ===end===
@example
(%i1) load ("basic")$
@group
(%i2) ll: [];
(%o2)                          []
@end group
@group
(%i3) push (x, ll);
(%o3)                          [x]
@end group
@group
(%i4) push (x^2+y, ll);
                                 2
(%o4)                      [y + x , x]
@end group
@group
(%i5) a: push ("string", ll);
                                     2
(%o5)                  [string, y + x , x]
@end group
@group
(%i6) pop (ll);
(%o6)                        string
@end group
@group
(%i7) pop (ll);
                                  2
(%o7)                        y + x
@end group
@group
(%i8) pop (ll);
(%o8)                           x
@end group
@group
(%i9) ll;
(%o9)                          []
@end group
@group
(%i10) a;
                                     2
(%o10)                 [string, y + x , x]
@end group
@end example
@end deffn


@deffn {Función} rest (@var{expr}, @var{n})
@deffnx {Función} rest (@var{expr})

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

@end deffn

@deffn {Función} reverse (@var{lista})

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

@end deffn

@deffn {Función} second (@var{expr})

Devuelve el segundo elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.

@end deffn

@deffn {Función} seventh (@var{expr})

Devuelve el séptimo elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.

@end deffn

@deffn {Función} sixth (@var{expr})

Devuelve el sexto elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.

@end deffn




@deffn {Función} sort (@var{L}, @var{P})
@deffnx {Función} sort (@var{L})

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

Si tanto @code{@var{P}(a, b)} como @code{@var{P}(b, a)} valen ambos @code{true} para
algunos elementos de @var{L}, entonces @var{P} no es un predicado de orden correcto,
siento entonces el resultado indefinido. Si @code{@var{P}(a, b)} toma un valor diferente
a @code{true} o @code{false}, entonces @code{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 @code{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 @var{L}.

@code{sort(@var{L})} equivale a @code{sort(@var{L}, orderlessp)}.

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

Todos los átomos y expresiones de Maxima son comparables respecto de los predicados
@code{orderlessp} y @code{ordergreatp}.

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

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

Ejemplos:

@code{sort} ordena una lista respecto de un predicado de dos argumentos que define un
preorden total en los elementos de la lista.

@c ===beg===
@c sort ([1, a, b, 2, 3, c], 'orderlessp);
@c sort ([1, a, b, 2, 3, c], 'ordergreatp);
@c ===end===
@example
@group
(%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]
@end group
@end example

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

@c ===beg===
@c L : [[1, x], [3, y], [4, w], [2, z]];
@c foo (a, b) := a[1] > b[1];
@c sort (L, 'foo);
@c infix (">>");
@c a >> b := a[1] > b[1];
@c sort (L, ">>");
@c sort (L, lambda ([a, b], a[1] > b[1]));
@c ===end===
@example
@group
(%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]]
@end group
@end example

@code{sort(@var{L})} equivale a @code{sort(@var{L}, orderlessp)}.

@c ===beg===
@c L : [a, 2*b, -5, 7, 1 + %e, %pi];
@c sort (L);
@c sort (L, 'orderlessp);
@c ===end===
@example
@group
(%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]
@end group
@end example

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

@c ===beg===
@c L : [a, 2*b, -5, 7, 1 + %e, %pi];
@c sort (L);
@c sort (L, 'ordergreatp);
@c ===end===
@example
@group
(%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]
@end group
@end example

Todos los átomos y expresiones de Maxima son comparables respecto de los predicados
@code{orderlessp} y @code{ordergreatp}.

@c ===beg===
@c L : [11, -17, 29b0, 9*c, 7.55, foo(x, y), -5/2, b + a];
@c sort (L, orderlessp);
@c sort (L, ordergreatp);
@c ===end===
@example
@group
(%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
@end group
@end example

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

@c ===beg===
@c L : [%pi, 3, 4, %e, %gamma];
@c sort (L, ">");
@c sort (L, ordergreatp);
@c ===end===
@example
@group
(%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]
@end group
@end example

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

@c ===beg===
@c L : [%i, 1+%i, 2*x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0, 1.0b0];
@c sort (L, ordermagnitudep);
@c sort (L, orderlessp);
@c ===end===
@example
@group
(%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]
@end group
@end example
@end deffn




@deffn {Función} sublist (@var{list}, @var{p})
Devuelve la lista de elementos de @var{list} para los cuales el predicado @code{p} retorna @code{true}.

Ejemplo:

@c ===beg===
@c L: [1, 2, 3, 4, 5, 6];
@c sublist (L, evenp);
@c ===end===
@example
@group
(%i1) L: [1, 2, 3, 4, 5, 6];
(%o1)                  [1, 2, 3, 4, 5, 6]
@end group
@group
(%i2) sublist (L, evenp);
(%o2)                       [2, 4, 6]
@end group
@end example

@end deffn




@deffn {Función} sublist_indices (@var{L}, @var{P})

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

Ejemplos:

@c ===beg===
@c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], 
@c                        lambda ([x], x='b));
@c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
@c sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0], 
@c                        identity);
@c assume (x < -1);
@c map (maybe, [x > 0, x < 0, x < -2]);
@c sublist_indices ([x > 0, x < 0, x < -2], identity);
@c ===end===
@example
@group
(%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
                       lambda ([x], x='b));
(%o1)                     [2, 3, 7, 9]
@end group
@group
(%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
(%o2)                  [1, 2, 3, 4, 7, 9]
@end group
@group
(%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
                       identity);
(%o3)                       [1, 4, 5]
@end group
@group
(%i4) assume (x < -1);
(%o4)                       [x < - 1]
@end group
@group
(%i5) map (maybe, [x > 0, x < 0, x < -2]);
(%o5)                [false, true, unknown]
@end group
@group
(%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
(%o6)                          [2]
@end group
@end example

@end deffn


@deffn {Función} unique (@var{L})

Devuelve la lista @var{L} sin redundancias, es decir, sin
elementos repetidos

Cuando ninguno de los elementos de @var{L} está repetido,
@code{unique} devuelve una réplica de @var{L}, no la
propia @var{L}.

Si @var{L} no es una lista, @code{unique} devuelve @var{L}.

Ejemplo:

@c ===beg===
@c unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
@c ===end===
@example
@group
(%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
(%o1)              [1, 2, %e, %pi, [1], b + a]
@end group
@end example
@end deffn



@deffn {Función} tenth (@var{expr})

Devuelve el décimo elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.

@end deffn

@deffn {Función} third (@var{expr})

Devuelve el tercer elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.

@end deffn


