| blob | c873f88bc1e4455195d997385d3687627982278d |
1 @c English version 2011-12-03
2 @page
3 @node Listas, Arrays, Constantes, Tipos de datos y estructuras
4 @section Listas
6 @menu
7 * Introducción a las listas::
8 * Funciones y variables para listas::
9 @end menu
11 @node Introducción a las listas, Funciones y variables para listas, Listas, Listas
12 @subsection Introducción a las listas
14 Las listas son bloques de construcción básica para Maxima y Lisp. Todos los tipos de datos
15 diferentes a los arreglos, tablas mixtas o números son representados como listas Lisp,
16 estas listas Lisp tienen la forma
18 @example
19 ((MPLUS) $A 2)
20 @end example
22 @noindent
23 para indicar la expresión @code{a+2}. Al nivel de Maxima se observará
24 la notación infija @code{a+2}. Maxima también tiene listas con el formato
26 @example
27 [1, 2, 7, x+y]
28 @end example
30 @noindent
31 para una lista de 4 elementos. Internamente esto se corresponde con una lista Lisp
32 de la forma
34 @example
35 ((MLIST) 1 2 7 ((MPLUS) $X $Y ))
36 @end example
38 @noindent
39 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
41 @example
42 ((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))
43 @end example
46 @node Funciones y variables para listas, , Introducción a las listas, Listas
47 @subsection Funciones y variables para listas
51 @defvr {Operador} [
52 @defvrx {Operador} ]
53 @ifinfo
54 @fnindex Acotador de listas
55 @fnindex Operador para subíndices
56 @end ifinfo
58 @code{[} y @code{]} marcan, respectivamente, el comienzo y el final de una lista.
60 @code{[} y @code{]} también se utilizan para indicar los subíndices
61 de una lista o de un array.
63 Ejemplos:
65 @c ===beg===
66 @c x: [a, b, c];
67 @c x[3];
68 @c array (y, fixnum, 3);
69 @c y[2]: %pi;
70 @c y[2];
71 @c z['foo]: 'bar;
72 @c z['foo];
73 @c g[k] := 1/(k^2+1);
74 @c g[10];
75 @c ===end===
76 @example
77 @group
78 (%i1) x: [a, b, c];
79 (%o1) [a, b, c]
80 @end group
81 @group
82 (%i2) x[3];
83 (%o2) c
84 @end group
85 @group
86 (%i3) array (y, fixnum, 3);
87 (%o3) y
88 @end group
89 @group
90 (%i4) y[2]: %pi;
91 (%o4) %pi
92 @end group
93 @group
94 (%i5) y[2];
95 (%o5) %pi
96 @end group
97 @group
98 (%i6) z['foo]: 'bar;
99 (%o6) bar
100 @end group
101 @group
102 (%i7) z['foo];
103 (%o7) bar
104 @end group
105 @group
106 (%i8) g[k] := 1/(k^2+1);
107 1
108 (%o8) g := ------
109 k 2
110 k + 1
111 @end group
112 @group
113 (%i9) g[10];
114 1
115 (%o9) ---
116 101
117 @end group
118 @end example
120 @end defvr
125 @deffn {Función} append (@var{lista_1}, ..., @var{lista_n})
127 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)}.
129 Tecléese @code{example(append);} para ver un ejemplo.
131 @end deffn
133 @deffn {Función} assoc (@var{clave}, @var{lista}, @var{valor_por_defecto})
134 @deffnx {Function} assoc (@var{clave}, @var{lista})
136 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}.
138 @end deffn
141 @deffn {Función} cons (@var{expr}, @var{lista})
143 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)}.
145 @end deffn
147 @deffn {Función} copylist (@var{lista})
149 Devuelve una copia de la @var{lista}.
151 @end deffn
154 @deffn {Función} create_list (@var{form}, @var{x_1}, @var{list_1}, ..., @var{x_n}, @var{list_n})
155 Crea una lista mediante la evaluación de @var{form} con @var{x_1} tomando cada uno de los
156 valores de @var{list_1}, para cada uno de estos valores liga @var{x_2} con cada elemento de
157 @var{list_2}, .... El número de elementos en el resultado será el producto del número de elementos
158 en cada lista. Cada variable @var{x_i} debe ser un símbolo y no será evaluado.
159 La lista de argumentos será evaluada una vez al comienzo de la iteración.
161 Ejemplos:
163 @c ===beg===
164 @c create_list (x^i, i, [1, 3, 7]);
165 @c ===end===
166 @example
167 @group
168 (%i1) create_list (x^i, i, [1, 3, 7]);
169 3 7
170 (%o1) [x, x , x ]
171 @end group
172 @end example
174 @noindent
175 Con una doble iteración:
177 @c ===beg===
178 @c create_list ([i, j], i, [a, b], j, [e, f, h]);
179 @c ===end===
180 @example
181 @group
182 (%i1) create_list ([i, j], i, [a, b], j, [e, f, h]);
183 (%o1) [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]
184 @end group
185 @end example
187 En lugar de @var{list_i} se pueden suministrar dos argumentos cada uno de los cuales
188 debería poder evaluarse a un número, los cuales serán los límites inferior
189 y superior, ambos inclusive, para cada iteración.
191 @c ===beg===
192 @c create_list ([i, j], i, [1, 2, 3], j, 1, i);
193 @c ===end===
194 @example
195 @group
196 (%i1) create_list ([i, j], i, [1, 2, 3], j, 1, i);
197 (%o1) [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]
198 @end group
199 @end example
201 Nótese que los límites o lista para la variable @code{j} pueden depender
202 del valor actual de @code{i}.
203 @end deffn
206 @deffn {Función} delete (@var{expr_1}, @var{expr_2})
207 @deffnx {Función} delete (@var{expr_1}, @var{expr_2}, @var{n})
209 @code{delete(@var{expr_1}, @var{expr_2})}
210 elimina de @var{expr_2} cualesquiera argumentos del operador
211 del nivel superior que sean iguales a @var{expr_1}.
212 Nótese que los argumentos de las subexpresiones no se ven
213 afectados por esta función.
215 @var{expr_1} puede ser un átomo o una expresión no
216 atómica. @var{expr_2} puede ser cualquier expresión no
217 atómica. La función @code{delete} devuelve una
218 nueva expresión sin modificar @var{expr_2}.
220 @code{delete(@var{expr_1}, @var{expr_2}, @var{n})}
221 elimina de @var{expr_2} los primeros @var{n} argumentos
222 del operador del nivel superior que sean iguales a @var{expr_1}.
223 Si hay menos de @var{n} argumentos iguales, entonces se
224 eliminan todos ellos.
226 Ejemplos:
228 Eliminando elementos de una lista.
230 @c ===beg===
231 @c delete (y, [w, x, y, z, z, y, x, w]);
232 @c ===end===
233 @example
234 @group
235 (%i1) delete (y, [w, x, y, z, z, y, x, w]);
236 (%o1) [w, x, z, z, x, w]
237 @end group
238 @end example
240 Eliminando términos de una suma.
242 @c ===beg===
243 @c delete (sin(x), x + sin(x) + y);
244 @c ===end===
245 @example
246 @group
247 (%i1) delete (sin(x), x + sin(x) + y);
248 (%o1) y + x
249 @end group
250 @end example
252 Eliminando factores de un producto.
254 @c ===beg===
255 @c delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
256 @c ===end===
257 @example
258 @group
259 (%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
260 (%o1) (u - w) (u - y) (u - z)
261 @end group
262 @end example
264 Eliminando argumentos de una expresión arbitraria.
266 @c ===beg===
267 @c delete (a, foo (a, b, c, d, a));
268 @c ===end===
269 @example
270 @group
271 (%i1) delete (a, foo (a, b, c, d, a));
272 (%o1) foo(b, c, d)
273 @end group
274 @end example
276 Limitando el número de argumentos a eliminar.
278 @c ===beg===
279 @c delete (a, foo (a, b, a, c, d, a), 2);
280 @c ===end===
281 @example
282 @group
283 (%i1) delete (a, foo (a, b, a, c, d, a), 2);
284 (%o1) foo(b, c, d, a)
285 @end group
286 @end example
288 Los argumentos se comparan respecto de "=".
289 Aquellos argumentos que verifiquen la condición @code{equal},
290 pero no "=" no serán eliminados.
292 @c ===beg===
293 @c [is (equal (0, 0)), is (equal (0, 0.0)), is (equal (0, 0b0))];
294 @c [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
295 @c delete (0, [0, 0.0, 0b0]);
296 @c is (equal ((x + y)*(x - y), x^2 - y^2));
297 @c is ((x + y)*(x - y) = x^2 - y^2);
298 @c delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
299 @c ===end===
300 @example
301 @group
302 (%i1) [is (equal (0, 0)), is (equal (0, 0.0)), is (equal (0, 0b0))];
303 rat: replaced 0.0 by 0/1 = 0.0
304 `rat' replaced 0.0B0 by 0/1 = 0.0B0
305 (%o1) [true, true, true]
306 @end group
307 @group
308 (%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
309 (%o2) [true, false, false]
310 @end group
311 @group
312 (%i3) delete (0, [0, 0.0, 0b0]);
313 (%o3) [0.0, 0.0b0]
314 @end group
315 @group
316 (%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
317 (%o4) true
318 @end group
319 @group
320 (%i5) is ((x + y)*(x - y) = x^2 - y^2);
321 (%o5) false
322 @end group
323 @group
324 (%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
325 2 2
326 (%o6) [x - y ]
327 @end group
328 @end example
329 @end deffn
331 @deffn {Función} eighth (@var{expr})
333 Devuelve el octavo elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.
335 @end deffn
337 @deffn {Función} endcons (@var{expr}, @var{lista})
339 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)}.
341 @end deffn
343 @deffn {Función} fifth (@var{expr})
345 Devuelve el quinto elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.
347 @end deffn
349 @deffn {Función} first (@var{expr})
351 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.
353 @end deffn
355 @deffn {Función} fourth (@var{expr})
357 Devuelve el cuarto elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.
359 @end deffn
364 @deffn {Función} join (@var{l}, @var{m})
365 Crea una nueva lista con los elementos de las listas @var{l} y @var{m} alternados.
366 El resultado tiene como elementos @code{[@var{l}[1], @var{m}[1], @var{l}[2], @var{m}[2], ...]}.
367 Las listas @var{l} y @var{m} pueden contener cualquier tipo de elementos.
369 Si las listas son de diferente longitud, @code{join} ignora los elementos sobrantes de la lista más larga.
371 Maxima da error si o bien @var{l} o @var{m} no son listas.
373 Ejemplos:
375 @c ===beg===
376 @c L1: [a, sin(b), c!, d - 1];
377 @c join (L1, [1, 2, 3, 4]);
378 @c join (L1, [aa, bb, cc, dd, ee, ff]);
379 @c ===end===
380 @example
381 @group
382 (%i1) L1: [a, sin(b), c!, d - 1];
383 (%o1) [a, sin(b), c!, d - 1]
384 @end group
385 @group
386 (%i2) join (L1, [1, 2, 3, 4]);
387 (%o2) [a, 1, sin(b), 2, c!, 3, d - 1, 4]
388 @end group
389 @group
390 (%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
391 (%o3) [a, aa, sin(b), bb, c!, cc, d - 1, dd]
392 @end group
393 @end example
395 @end deffn
398 @deffn {Función} last (@var{expr})
400 Devuelve la última parte (término, fila, elemento, etc.) de @var{expr}.
402 @end deffn
404 @deffn {Función} length (@var{expr})
406 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}).
408 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}).
410 @end deffn
412 @defvr {Variable opcional} listarith
413 Valor por defecto: @code{true}
415 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.
417 @end defvr
419 @deffn {Función} listp (@var{expr})
421 Devuelve el valor @code{true} si @var{expr} es una lista, y @code{false} en caso contrario.
423 @end deffn
427 @deffn {Función} makelist ()
428 @deffnx {Función} makelist (@var{expr}, @var{n})
429 @deffnx {Función} makelist (@var{expr}, @var{i}, @var{i_max})
430 @deffnx {Función} makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_max})
431 @deffnx {Función} makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_max}, @var{step})
432 @deffnx {Función} makelist (@var{expr}, @var{x}, @var{list})
434 El primer formato, @code{makelist ()}, crea una lista vacía. El
435 segundo formato, @code{makelist (@var{expr})}, crea una lista con @var{expr}
436 como único elemento. @code{makelist (@var{expr}, @var{n})} crea una lista
437 de @var{n} elementos generados a partir de @var{expr}.
439 El formato más general, @code{makelist (@var{expr}, @var{i}, @var{i_0},
440 @var{i_max}, @var{step})}, devuelve la lista de elementos obtenidos al
441 aplicar @code{ev (@var{expr}, @var{i}=@var{j})} a los elementos @var{j}
442 de la secuencia @var{i_0}, @var{i_0} + @var{step}, @var{i_0} +
443 2*@var{step}, ..., siendo @var{|j|} menor o igual que @var{|i_max|}.
445 El incremento @var{step} puede ser un número (positivo o negativo) o una
446 expresión. En caso de omitirse, se utilizará 1 como valor por defecto.
447 Si se omiten @var{i_0} y @var{step}, se le asignará a ambos 1 como valor
448 por defecto.
450 @code{makelist (@var{expr}, @var{x}, @var{list})} devuelve una lista, cuyo
451 @code{j}-ésimo elemento es igual a
452 @code{ev (@var{expr}, @var{x}=@var{list}[j])} tomando @code{j} valores desde
453 1 hasta @code{length (@var{list})}.
456 Ejemplos:
458 @c ===beg===
459 @c makelist (concat (x,i), i, 6);
460 @c makelist (x=y, y, [a, b, c]);
461 @c makelist (x^2, x, 3, 2*%pi, 2);
462 @c makelist (random(6), 4);
463 @c flatten (makelist (makelist (i^2, 3), i, 4));
464 @c flatten (makelist (makelist (i^2, i, 3), 4));
465 @c ===end===
466 @example
467 @group
468 (%i1) makelist (concat (x,i), i, 6);
469 (%o1) [x1, x2, x3, x4, x5, x6]
470 @end group
471 @group
472 (%i2) makelist (x=y, y, [a, b, c]);
473 (%o2) [x = a, x = b, x = c]
474 @end group
475 @group
476 (%i3) makelist (x^2, x, 3, 2*%pi, 2);
477 (%o3) [9, 25]
478 @end group
479 @group
480 (%i4) makelist (random(6), 4);
481 (%o4) [2, 0, 2, 5]
482 @end group
483 @group
484 (%i5) flatten (makelist (makelist (i^2, 3), i, 4));
485 (%o5) [1, 1, 1, 4, 4, 4, 9, 9, 9, 16, 16, 16]
486 @end group
487 @group
488 (%i6) flatten (makelist (makelist (i^2, i, 3), 4));
489 (%o6) [1, 4, 9, 1, 4, 9, 1, 4, 9, 1, 4, 9]
490 @end group
491 @end example
493 @end deffn
495 @deffn {Función} member (@var{expr_1}, @var{expr_2})
497 Devuelve @code{true} si @code{is(@var{expr_1} = @var{a})}
498 para algún elemento @var{a} de @code{args(@var{expr_2})},
499 en caso contrario devuelve @code{false}.
501 Normalmente, @code{expr_2} será una lista,
502 en cuyo caso @code{args(@var{expr_2}) = @var{expr_2}},
503 y la comprobación será si @code{is(@var{expr_1} = @var{a})} para
504 algún elemento @var{a} de @code{expr_2}.
506 La función @code{member} no inspecciona las partes de los argumentos de @code{expr_2},
507 por lo que puede devolver @code{false} si @code{expr_1} es parte de alguno de los argumentos de @code{expr_2}.
509 Véase también @code{elementp}.
511 Ejemplos:
513 @c ===beg===
514 @c member (8, [8, 8.0, 8b0]);
515 @c member (8, [8.0, 8b0]);
516 @c member (b, [a, b, c]);
517 @c member (b, [[a, b], [b, c]]);
518 @c member ([b, c], [[a, b], [b, c]]);
519 @c F (1, 1/2, 1/4, 1/8);
520 @c member (1/8, %);
521 @c member ("ab", ["aa", "ab", sin(1), a + b]);
522 @c ===end===
523 @example
524 @group
525 (%i1) member (8, [8, 8.0, 8b0]);
526 (%o1) true
527 @end group
528 @group
529 (%i2) member (8, [8.0, 8b0]);
530 (%o2) false
531 @end group
532 @group
533 (%i3) member (b, [a, b, c]);
534 (%o3) true
535 @end group
536 @group
537 (%i4) member (b, [[a, b], [b, c]]);
538 (%o4) false
539 @end group
540 @group
541 (%i5) member ([b, c], [[a, b], [b, c]]);
542 (%o5) true
543 @end group
544 @group
545 (%i6) F (1, 1/2, 1/4, 1/8);
546 1 1 1
547 (%o6) F(1, -, -, -)
548 2 4 8
549 @end group
550 @group
551 (%i7) member (1/8, %);
552 (%o7) true
553 @end group
554 @group
555 (%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
556 (%o8) true
557 @end group
558 @end example
559 @end deffn
563 @deffn {Función} ninth (@var{expr})
565 Devuelve el noveno elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.
566 @end deffn
570 @deffn {Función} pop (@var{list})
572 Borra el primer elemento de la lista @var{list} y devuelve este
573 mismo elemento.
575 Si el argumento @var{list} es una lista vacía, o
576 simplemente no es una lista, Maxima devuelve un mensaje de error.
578 Véase @code{push} para los ejemplos.
580 Ejecútese @code{load("basic")} antes de utilizar esta función.
581 @end deffn
586 @deffn {Función} push (@var{item}, @var{list})
588 Añade al comienzo de la lista @var{list} el elemento @var{item},
589 devolviendo este mismo elemento. El argumento @var{list} debe ser necesariamente
590 una lista, mientras que @var{item} puede ser cualquier símbolo
591 o expresión.
593 Si el argumento @var{list} no es una lista, Maxima devuelve un
594 mensaje de error.
596 Véase @code{pop} para eliminar el primer elemento de una lista.
598 Ejecútese @code{load("basic")} antes de utilizar esta función.
600 Ejemplos:
602 @c ===beg===
603 @c load ("basic")$
604 @c ll: [];
605 @c push (x, ll);
606 @c push (x^2+y, ll);
607 @c a: push ("string", ll);
608 @c pop (ll);
609 @c pop (ll);
610 @c pop (ll);
611 @c ll;
612 @c a;
613 @c ===end===
614 @example
615 (%i1) load ("basic")$
616 @group
617 (%i2) ll: [];
618 (%o2) []
619 @end group
620 @group
621 (%i3) push (x, ll);
622 (%o3) [x]
623 @end group
624 @group
625 (%i4) push (x^2+y, ll);
626 2
627 (%o4) [y + x , x]
628 @end group
629 @group
630 (%i5) a: push ("string", ll);
631 2
632 (%o5) [string, y + x , x]
633 @end group
634 @group
635 (%i6) pop (ll);
636 (%o6) string
637 @end group
638 @group
639 (%i7) pop (ll);
640 2
641 (%o7) y + x
642 @end group
643 @group
644 (%i8) pop (ll);
645 (%o8) x
646 @end group
647 @group
648 (%i9) ll;
649 (%o9) []
650 @end group
651 @group
652 (%i10) a;
653 2
654 (%o10) [string, y + x , x]
655 @end group
656 @end example
657 @end deffn
660 @deffn {Función} rest (@var{expr}, @var{n})
661 @deffnx {Función} rest (@var{expr})
663 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.
665 @end deffn
667 @deffn {Función} reverse (@var{lista})
669 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}.
671 @end deffn
673 @deffn {Función} second (@var{expr})
675 Devuelve el segundo elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.
677 @end deffn
679 @deffn {Función} seventh (@var{expr})
681 Devuelve el séptimo elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.
683 @end deffn
685 @deffn {Función} sixth (@var{expr})
687 Devuelve el sexto elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.
689 @end deffn
694 @deffn {Función} sort (@var{L}, @var{P})
695 @deffnx {Función} sort (@var{L})
697 @code{sort(@var{L}, @var{P})} ordena la lista @var{L} de acuerdo con el predicado @code{P}
698 de dos argumentos, el cual define un preorden total sobre los elementos de @var{L}.
699 Si @code{@var{P}(a, b)} vale @code{true}, entonces @code{a} aparece antes que @code{b} en
700 el resultado. Si ninguna de las expresiones @code{@var{P}(a, b)} y @code{@var{P}(b, a)}
701 valen @code{true}, entonces @code{a} y @code{b} son equivalentes y aparecen en el
702 resultado en el mismo orden que a la entrada; esto es, @code{sort} es un orden estable.
704 Si tanto @code{@var{P}(a, b)} como @code{@var{P}(b, a)} valen ambos @code{true} para
705 algunos elementos de @var{L}, entonces @var{P} no es un predicado de orden correcto,
706 siento entonces el resultado indefinido. Si @code{@var{P}(a, b)} toma un valor diferente
707 a @code{true} o @code{false}, entonces @code{sort} devuelve un error.
709 El predicado puede especificarse como el nombre de una función, de una operación binaria
710 infija o como una expresión @code{lambda}. Si se especifica con el nombre de un operador,
711 dicho nombre debe encerrarse con comillas dobles.
713 La lista ordenada se devuelve como un nuevo objeto, no modificándose el argumento @var{L}.
715 @code{sort(@var{L})} equivale a @code{sort(@var{L}, orderlessp)}.
717 La ordenación por defecto es ascendente, tal como queda determinada por @code{orderlessp}.
718 El predicado @code{ordergreatp} ordena las listas en orden descendente.
720 Todos los átomos y expresiones de Maxima son comparables respecto de los predicados
721 @code{orderlessp} y @code{ordergreatp}.
723 Los operadores @code{<} y @code{>} ordenan números, constantes y expresiones constantes por
724 magnitud. Nótese que @code{orderlessp} y @code{ordergreatp} no ordenan números,
725 constantes y expresiones constantes por magnitud.
727 @code{ordermagnitudep} ordena números, constantes y expresiones constantes de igual modo
728 que lo hace @code{<}, y cualesquiera otros elementos lo hace igual que @code{orderlessp}.
730 Ejemplos:
732 @code{sort} ordena una lista respecto de un predicado de dos argumentos que define un
733 preorden total en los elementos de la lista.
735 @c ===beg===
736 @c sort ([1, a, b, 2, 3, c], 'orderlessp);
737 @c sort ([1, a, b, 2, 3, c], 'ordergreatp);
738 @c ===end===
739 @example
740 @group
741 (%i1) sort ([1, a, b, 2, 3, c], 'orderlessp);
742 (%o1) [1, 2, 3, a, b, c]
743 (%i2) sort ([1, a, b, 2, 3, c], 'ordergreatp);
744 (%o2) [c, b, a, 3, 2, 1]
745 @end group
746 @end example
748 El predicado puede especificarse con el nombre de una función, de un
749 operador binario infijo o una expresión @code{lambda}. Si se especifica
750 con el nombre de un operador, dicho nombre debe encerrarse con comillas dobles.
752 @c ===beg===
753 @c L : [[1, x], [3, y], [4, w], [2, z]];
754 @c foo (a, b) := a[1] > b[1];
755 @c sort (L, 'foo);
756 @c infix (">>");
757 @c a >> b := a[1] > b[1];
758 @c sort (L, ">>");
759 @c sort (L, lambda ([a, b], a[1] > b[1]));
760 @c ===end===
761 @example
762 @group
763 (%i1) L : [[1, x], [3, y], [4, w], [2, z]];
764 (%o1) [[1, x], [3, y], [4, w], [2, z]]
765 (%i2) foo (a, b) := a[1] > b[1];
766 (%o2) foo(a, b) := a > b
767 1 1
768 (%i3) sort (L, 'foo);
769 (%o3) [[4, w], [3, y], [2, z], [1, x]]
770 (%i4) infix (">>");
771 (%o4) >>
772 (%i5) a >> b := a[1] > b[1];
773 (%o5) a >> b := a > b
774 1 1
775 (%i6) sort (L, ">>");
776 (%o6) [[4, w], [3, y], [2, z], [1, x]]
777 (%i7) sort (L, lambda ([a, b], a[1] > b[1]));
778 (%o7) [[4, w], [3, y], [2, z], [1, x]]
779 @end group
780 @end example
782 @code{sort(@var{L})} equivale a @code{sort(@var{L}, orderlessp)}.
784 @c ===beg===
785 @c L : [a, 2*b, -5, 7, 1 + %e, %pi];
786 @c sort (L);
787 @c sort (L, 'orderlessp);
788 @c ===end===
789 @example
790 @group
791 (%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi];
792 (%o1) [a, 2 b, - 5, 7, %e + 1, %pi]
793 (%i2) sort (L);
794 (%o2) [- 5, 7, %e + 1, %pi, a, 2 b]
795 (%i3) sort (L, 'orderlessp);
796 (%o3) [- 5, 7, %e + 1, %pi, a, 2 b]
797 @end group
798 @end example
800 La ordenación por defecto es ascendente, tal como queda determinada por @code{orderlessp}.
801 El predicado @code{ordergreatp} ordena las listas en orden descendente.
803 @c ===beg===
804 @c L : [a, 2*b, -5, 7, 1 + %e, %pi];
805 @c sort (L);
806 @c sort (L, 'ordergreatp);
807 @c ===end===
808 @example
809 @group
810 (%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi];
811 (%o1) [a, 2 b, - 5, 7, %e + 1, %pi]
812 (%i2) sort (L);
813 (%o2) [- 5, 7, %e + 1, %pi, a, 2 b]
814 (%i3) sort (L, 'ordergreatp);
815 (%o3) [2 b, a, %pi, %e + 1, 7, - 5]
816 @end group
817 @end example
819 Todos los átomos y expresiones de Maxima son comparables respecto de los predicados
820 @code{orderlessp} y @code{ordergreatp}.
822 @c ===beg===
823 @c L : [11, -17, 29b0, 9*c, 7.55, foo(x, y), -5/2, b + a];
824 @c sort (L, orderlessp);
825 @c sort (L, ordergreatp);
826 @c ===end===
827 @example
828 @group
829 (%i1) L : [11, -17, 29b0, 9*c, 7.55, foo(x, y), -5/2, b + a];
830 5
831 (%o1) [11, - 17, 2.9b1, 9 c, 7.55, foo(x, y), - -, b + a]
832 2
833 (%i2) sort (L, orderlessp);
834 5
835 (%o2) [- 17, - -, 7.55, 11, 2.9b1, b + a, 9 c, foo(x, y)]
836 2
837 (%i3) sort (L, ordergreatp);
838 5
839 (%o3) [foo(x, y), 9 c, b + a, 2.9b1, 11, 7.55, - -, - 17]
840 2
841 @end group
842 @end example
844 Los operadores @code{<} y @code{>} ordenan números, constantes y expresiones constantes por
845 magnitud. Nótese que @code{orderlessp} y @code{ordergreatp} no ordenan números,
846 constantes y expresiones constantes por magnitud.
848 @c ===beg===
849 @c L : [%pi, 3, 4, %e, %gamma];
850 @c sort (L, ">");
851 @c sort (L, ordergreatp);
852 @c ===end===
853 @example
854 @group
855 (%i1) L : [%pi, 3, 4, %e, %gamma];
856 (%o1) [%pi, 3, 4, %e, %gamma]
857 (%i2) sort (L, ">");
858 (%o2) [4, %pi, 3, %e, %gamma]
859 (%i3) sort (L, ordergreatp);
860 (%o3) [%pi, %gamma, %e, 4, 3]
861 @end group
862 @end example
864 @code{ordermagnitudep} ordena números, constantes y expresiones constantes de igual modo
865 que lo hace @code{<}, y cualesquiera otros elementos lo hace igual que @code{orderlessp}.
867 @c ===beg===
868 @c L : [%i, 1+%i, 2*x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0, 1.0b0];
869 @c sort (L, ordermagnitudep);
870 @c sort (L, orderlessp);
871 @c ===end===
872 @example
873 @group
874 (%i1) L : [%i, 1+%i, 2*x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0, 1.0b0];
875 (%o1) [%i, %i + 1, 2 x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0,
876 1.0b0]
877 (%i2) sort (L, ordermagnitudep);
878 (%o2) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
879 %i + 1, 2 x]
880 (%i3) sort (L, orderlessp);
881 (%o3) [0, 1, 1.0, 2, 3, %e, %i, %i + 1, inf, minf, sin(1),
882 1.0b0, 2 x]
883 @end group
884 @end example
885 @end deffn
890 @deffn {Función} sublist (@var{list}, @var{p})
891 Devuelve la lista de elementos de @var{list} para los cuales el predicado @code{p} retorna @code{true}.
893 Ejemplo:
895 @c ===beg===
896 @c L: [1, 2, 3, 4, 5, 6];
897 @c sublist (L, evenp);
898 @c ===end===
899 @example
900 @group
901 (%i1) L: [1, 2, 3, 4, 5, 6];
902 (%o1) [1, 2, 3, 4, 5, 6]
903 @end group
904 @group
905 (%i2) sublist (L, evenp);
906 (%o2) [2, 4, 6]
907 @end group
908 @end example
910 @end deffn
915 @deffn {Función} sublist_indices (@var{L}, @var{P})
917 Devuelve los índices de los elementos @code{x} de la
918 lista @var{L} para la cual el predicado @code{maybe(@var{P}(x))}
919 devuelve @code{true}, lo que excluye a @code{unknown} y a @code{false}.
920 @var{P} puede ser el nombre de una función o de una expresión lambda.
921 @var{L} debe ser una lista literal.
923 Ejemplos:
925 @c ===beg===
926 @c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
927 @c lambda ([x], x='b));
928 @c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
929 @c sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
930 @c identity);
931 @c assume (x < -1);
932 @c map (maybe, [x > 0, x < 0, x < -2]);
933 @c sublist_indices ([x > 0, x < 0, x < -2], identity);
934 @c ===end===
935 @example
936 @group
937 (%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
938 lambda ([x], x='b));
939 (%o1) [2, 3, 7, 9]
940 @end group
941 @group
942 (%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
943 (%o2) [1, 2, 3, 4, 7, 9]
944 @end group
945 @group
946 (%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
947 identity);
948 (%o3) [1, 4, 5]
949 @end group
950 @group
951 (%i4) assume (x < -1);
952 (%o4) [x < - 1]
953 @end group
954 @group
955 (%i5) map (maybe, [x > 0, x < 0, x < -2]);
956 (%o5) [false, true, unknown]
957 @end group
958 @group
959 (%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
960 (%o6) [2]
961 @end group
962 @end example
964 @end deffn
967 @deffn {Función} unique (@var{L})
969 Devuelve la lista @var{L} sin redundancias, es decir, sin
970 elementos repetidos
972 Cuando ninguno de los elementos de @var{L} está repetido,
973 @code{unique} devuelve una réplica de @var{L}, no la
974 propia @var{L}.
976 Si @var{L} no es una lista, @code{unique} devuelve @var{L}.
978 Ejemplo:
980 @c ===beg===
981 @c unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
982 @c ===end===
983 @example
984 @group
985 (%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
986 (%o1) [1, 2, %e, %pi, [1], b + a]
987 @end group
988 @end example
989 @end deffn
993 @deffn {Función} tenth (@var{expr})
995 Devuelve el décimo elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.
997 @end deffn
999 @deffn {Función} third (@var{expr})
1001 Devuelve el tercer elemento de la lista o expresión @var{expr}. Véase @code{first} para más detalles.
1003 @end deffn