Listas

• Generación de listas
• Manipulación de listas

Las listas son elementos básicos para el trabajo interno de Maxima: las soluciones de sistemas de ecuaciones, los ceros de polinomios, los vectores, las matrices... son listas. En esta sección nos ocuparemos sucintamente de la generación y manipulación de listas.

Generación de listas

El usuario puede generar listas con los comandos que se detallan a continuación, sobre los cuales, como siempre, puede obtener más información usando describe(makelist) y describe(create_list).

Los elementos de una lista están separados por comas y la lista se delimita mediante corchetes []. Los elementos de la lista pueden ser cualquier cosa, incluso otra lista. Por ejemplo [1,2,a] y [x^2,[1,b,"hola"],y] son listas. Delimitada por comillas, la palabra hola es interpretada como una cadena, y las restantes son interpretadas como constantes, variables, fórmulas, etc.

Las listas se pueden generar de forma manual o mediante el uso de comandos.

• makelist(Expresión,Variable,Valor_inicial,Valor_final);
  Es el comando básico para construir listas, en las que la variable va tomando un intervalo de valores enteros. En lugar de los valores inicial y final, como recorrido de la variable, puede ponerse una lista. En los ejemplos que vienen después podrá ver el formato de salida de la lista.
1. makelist(a[n], n,1,5);
2. makelist(n^2, n,1,5);
3. makelist(n^2, n,[1,0.5]);
4. Una sucesión recurrente:
   kill(all)$ numer:true$ /* La fórmula de la sucesión recurrente*/ x[1]:(1/8)$ x[n]:= 1/8 +(x[n-1])^2$ /* La lista de los 10 primeros términos */ makelist([n,x[n]],n,1,10);
5. numer:false;
• create_list(Formato,Variable_1,Lista_1...Variable_n,Lista_n);
  Es un comando más flexible que makelist y permite crear listas con cierto formato usando como variables otras listas. Una o varias de las listas correspondientes a una variable pueden sustituirse por una pareja de números enteros o variables con valores enteros, separados por comas; en tal caso, la correspondiente lista para dicha variable será generada por Maxima.
1. create_list(n^2,n,1,5);
2. create_list([n^2,m],n,1,3,m,[1,4,8]);
3. x(n):=1/n$ f(x):= x^2$ create_list([x(n),f(x(n))],n,1,10);
• listp(Expresión)
  Es un comando booleano que permite saber si una Expresión es o no una lista.
  1. L:[x^2,[1,b,"hola"],y];
  2. listp(L);
  3. M:sqrt(2);
  4. listp(M);

Manipulación de listas

Existen varios comandos en Maxima para extraer información contenida en una lista, para construir nuevas listas a partir de listas preexistentes, etc. Puede encontrar la información precisa en la sección «Listas» del manual de Maxima. Aquí nos limitamos a algunos ejemplos que son útiles para las necesidades básicas.

• Cada elemento de la lista viene identificado por un número, pues se trata de una especie de sucesión. Dicho número puede ser utilizado para recuperar el elemento correspondiente. En el ejemplo que sigue creamos una lista y recuperamos los elementos tercero y quinto: el primero de ellos es un «átomo» mientras que el otro es, a su vez, una lista.
  1. L:[1,5,b,[x,y],[x=2+z]]
  2. L[3];
  3. L[5];
• En una lista es posible recuperar el primer elemento y el último de forma especial (también el segundo y algunos otros) mediante los comandos first(Lista) y last(Lista).
  1. L: [1,5,b,[x,y],[x=2+z]]
  2. first(L);
  3. last(L);
  4. second(L);
• flatten(Lista)
  Es un comando que aplicado a una lista genera una nueva lista en la que los elementos, que a su vez eran listas, se descomponen en sus átomos (sirve para más cosas, ? flatten;).
  1. L:[1,5,b,[x,y],[x=2+z]]
  2. flatten(L);
  3. last(%);
  
  Con frecuencia este comando se combina con otros, por ejemplo con rhs, que permite extraer la parte derecha de una expresión con dos miembros, separados entre sí por un operador de relación de Maxima (signo de igualdad o desigualdad) o un operador de asignación.
  Mediante rhs(flatten(L)[6]); obtenemos el miembro de la derecha de la igualdad correspondiente al último elemento de la lista modificada z + 2
  Por supuesto existe un operador lhs gemelo de rhs para obtener el miembro de la izquierda.
  lhs(flatten(L)[6]);
• append(Lista1,Lista2,Lista3...)
  Permite añadir nuevos elementos a una lista preexistente.
  1. L:[1,5,b,[x,y],[x=2+z]];
  2. append(L,[cos(x)]);
• join(Lista1,Lista2)
  Crea una nueva lista con los elementos de Lista1 y Lista2 alternados.
  1. L1:[a,b,c];
  2. L2:[x,y,z];
  3. join(L1,L2);
• Las operaciones aritméticas básicas como sumar, restar, multiplicar y dividir, término a término, cuando tienen la misma longitud pueden ser realizadasen la manera que cabría esperar.
  Con lista1 . lista2 se realiza el producto escalar de las listas 1 y 2.
  1. [1,x,3]+[2,y,z];
  2. [1,x,3]*[2,y,z];
  3. [1,x,3].[2,y,z];
• map(f, expr_1, ..., expr_n)
  Devuelve una expresión cuyo operador principal es el mismo que aparece en las expresiones expr_1, ..., expr_n pero cuyas subpartes son los resultados de aplicar f a cada una de las subpartes de las expresiones; f puede ser tanto el nombre de una función de n argumentos como una expresión lambda de n argumentos. Uno de los usos que tiene map es la de aplicar (o mapear) una función (por ejemplo, partfrac) sobre cada término de una expresión extensa en la que normalmente no se podría utilizar la función debido a insuficiencias en el espacio de almacenamiento durante el curso de un cálculo.
  1. map(sin,[1,x,3]);
  2. Pero su utilización con funciones definidas de forma genérica no funciona y genera un error define(f(z),z^2); map(f(z),[1,x,3]);
  3. No obstante, es posible realizar manipulaciones de este tipo con ayuda de la función lambda definida «sobre la marcha» en cada situación
     map(lambda([z],z^2),[1,x,3]);
  4. map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
  5. map(ratsimp, x/(x^2+x)+(y^2+y)/y);
• apply(Operación,Lista)
  Algunos ejemplos pueden resultar sugerentes
  1. apply("+",[1,x,3]);
  2. apply(max,[1,25,3]);
     Puede usarse también lmax(Lista)
  3. apply(min,[1,25,3]);
     Puede usarse también lmin(Lista)
• sort, reverse, delete, member
  Son otros comandos que resultan de utilidad y cuyo nombre sugiere la tarea que realizan.
  1. sort([3,6,1,z,a])
  2. reverse([3,6,1,z,a])
  3. delete(z,[3,6,1,z,a])
  4. member(r,[3,6,1,z,a])
• length(lista)
  Devuelve la longitud de la lista
• unique(lista)
  Elimina los elementos repetidos