Anterior: Introducción a las listas, Subir: Listas [Índice general][Índice]
[ 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
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.
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.
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).
Devuelve una copia de la lista.
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.
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 ]
Devuelve el octavo elemento de la lista o expresión expr. Véase first para más detalles.
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).
Devuelve el quinto elemento de la lista o expresión expr. Véase first para más detalles.
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.
Devuelve el cuarto elemento de la lista o expresión expr. Véase first para más detalles.
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]
Devuelve la última parte (término, fila, elemento, etc.) de 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).
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.
Devuelve el valor true si expr es una lista, y false en caso contrario.
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]
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
Devuelve el noveno elemento de la lista o expresión expr. Véase first para más detalles.
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.
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]
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.
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.
Devuelve el segundo elemento de la lista o expresión expr. Véase first para más detalles.
Devuelve el séptimo elemento de la lista o expresión expr. Véase first para más detalles.
Devuelve el sexto elemento de la lista o expresión expr. Véase first para más detalles.
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]
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]
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]
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]
Devuelve el décimo elemento de la lista o expresión expr. Véase first para más detalles.
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]