[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5. Tipos de datos y estructuras


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1 Números


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1.1 Introducción a los números

Números enteros y racionales

Los cálculos aritméticos con números enteros y racionales son exactos. En principio, los números enteros y racionales admiten una cantidad arbitraria de cifras, con la única limitación que impongan las capacidades de memoria del sistema.

(%i1) 1/3+5/4+3;
                               55
(%o1)                          --
                               12
(%i2) 100!;
(%o2) 9332621544394415268169923885626670049071596826438162146859\
2963895217599993229915608941463976156518286253697920827223758251\
185210916864000000000000000000000000
(%i3) 100!/101!;
                                1
(%o3)                          ---
                               101

Funciones disponibles para los números enteros y racionales:

   integerp       numberp       nonnegintegerp     
   oddp           evenp
   ratnump        rationalize

Números decimales en coma flotante

Maxima hace los cálculos con números decimales en coma flotante en doble precisión. Además, Maxima puede hacer cl'culos con números decimales grandes en coma flotante (bigfloats, en inglés), que, en principio, admiten precisión arbitraria.

La coma de los números decimales en coma flotante se escribe con un punto y el exponente se puede indicar con "f", "e" o "d". Por defecto, Maxima hace los cálculos en doble precisión y muestra el exponente como "e" en el resultado, mientras que representa el exponente con la letra "b" en el caso de decimales grandes de precisión arbitraria. Maxima no distingue si la letra del exponente se escribe en minúscula o mayúscula.

(%i1) [2.0,1f10,1,e10,1d10,1d300];
(%o1)        [2.0, 1.e+10, 1, e10, 1.e+10, 1.e+300]
(%i2) [2.0b0,1b10,1b300];
(%o2)               [2.0b0, 1.0b10, 1.0b300]

Si en un cálculo aritmético aparece un número decimal en coma flotante, se producirá un efecto de contagio que hará que el resultado se devuelva también como decimal. Esto también es cierto para el caso de decimales grandes de precisión arbitraria.

(%i1) 2.0+1/2+3;
(%o1)                                 5.5
(%i2) 2.0b0+1/2+3;
(%o2)                                5.5b0

Con las funciones float y bfloat se puede convertir un número en decimal de doble precisión, o de precisión arbitraria, respectivamente:

(%i1) float([2,1/2,1/3,2.0b0]);
(%o1)          [2.0, 0.5, .3333333333333333, 2.0]
(%i2) bfloat([2,1/2,1/3,2.0b0]);
(%o2)     [2.0b0, 5.0b-1, 3.333333333333333b-1, 2.0b0]

Funciones y variables disponibles para números decimales:

   float        floatnump     
   bfloat       bfloatp       fpprec
   float2bf     bftorat       ratepsilon

   number_pbranch 
   m1pbranch

Números complejos

Maxima no tiene un tipo de dato especíco para números complejos; éstos se representan internamente como la suma de la parte real y la imaginaria multiplicada por el símbolo %i, que hace las veces de unidad imaginaria. Por ejemplo, las raíces de la ecuación x^2 - 4*x + 13 = 0 se representan como 2 + 3*%i y 2 - 3*%i.

Maxima no simplifica automáticamente productos, cocientes, raíces y otras expresiones con números complejos. Por ejemplo, para hacer la multiplicación de números complejos se puede utilizar la función expand.

Funciones disponibles para los números complejos:

   realpart     imagpart      rectform     polarform
   cabs         carg          conjugate    csign

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1.2 Funciones y variables para los números

Función: bfloat (expr)

Convierte todos los números y funciones numéricas a números decimales de punto flotante grandes ("bigfloats"). El número de dígitos significativos de los "bigfloats" resultantes se especifica mediante la variable global fpprec.

Si float2bf vale false se mostrará un mensaje de aviso cuando un número en punto flotante se convierte a decimal de tipo "bigfloats", puesto que tal transformación puede conllevar pérdida de precisión.

Función: bfloatp (expr)

Devuelve true si expr es un número decimal en punto flotante grande ("bigfloats"), en caso contrario devuelve false.

Variable optativa: bftorat

Valor por defecto: false

La variable bftorat controla la conversión de números decimales de punto flotante grandes ("bigfloats") a números racionales. Si bftorat vale false, se utilizará ratepsilon para controlar la conversión (lo cual resulta en números racionales relativamente pequeños). Si bftorat vale true, el número racional generado representará exactamente al número decimal de punto flotante grande ("bigfloat").

Variable optativa: bftrunc

Valor por defecto: true

La variable bftrunc provoca la eliminación de ceros en números decimales grandes no nulos para que no se muestren. Así, si bftrunc vale false, bfloat (1) se muestra como 1.000000000000000B0. En otro caso, se mostrará como 1.0B0.

Función: evenp (expr)

Devuelve true si expr es un entero par y false en cualquier otro caso.

Función: float (expr)

Convierte los enteros, números racionales y los decimales de punto flotante grandes ("bigfloats") que están presentes en expr a números de punto flotante. También actúa como símbolo evflag.

Variable optativa: float2bf

Valor por defecto: true

Si float2bf vale false se mostrará un mensaje de aviso cuando un número en punto flotante se convierte a decimal de tipo "bigfloats", puesto que tal transformación puede conllevar pérdida de precisión.

Función: floatnump (expr)

Devuelve true si expr es un número de punto flotante, en caso contario retorna false.

Variable optativa: fpprec

Valor por defecto: 16

La variable fpprec guarda el número de dígitos significativos en la aritmética con números decimales de punto flotante grandes ("bigfloats"). La variable fpprec no afecta a los cálculos con números decimales de punto flotante ordinarios.

Véanse también bfloat y fpprintprec.

Variable optativa: fpprintprec

Valor por defecto: 0

La variable fpprintprec guarda el número de dígitos a imprimir de los números decimales en coma flotante, tanto los ordinarios como los de precisión ilimitada (bigfloats).

En el caso de los decimales ordinarios, si fpprintprec toma un valor entre 2 y 16 (inclusive), el número de dígitos que se imprimen es igual a fpprintprec. En caso contrario, fpprintprec es 0 o mayor que 16, siendo el número de dígitos a imprimir en todos loa casos igual a 16.

En el caso de los decimales de precisión ilimitada (bigfloats), si fpprintprec toma un valor entre 2 y 16 (inclusive), el número de dígitos que se imprimen es igual a fpprintprec. En caso contrario, fpprintprec es 0 o mayor que fpprec, siendo el número de dígitos a imprimir igual a fpprec.

La variable fpprintprec no admite el valor 1.

Función: integerp (expr)

Devuelve true si expr es un número entero y false en cualquier otro caso.

La función integerp devuelve false si su argumento es un símbolo, incluso cuando éste ha sido declarado como entero.

Ejemplos:

(%i1) integerp (0);
(%o1)                         true
(%i2) integerp (1);
(%o2)                         true
(%i3) integerp (-17);
(%o3)                         true
(%i4) integerp (0.0);
(%o4)                         false
(%i5) integerp (1.0);
(%o5)                         false
(%i6) integerp (%pi);
(%o6)                         false
(%i7) integerp (n);
(%o7)                         false
(%i8) declare (n, integer);
(%o8)                         done
(%i9) integerp (n);
(%o9)                         false
Variable opcional: m1pbranch

Valor por defecto: false

La variable m1pbranch es la rama principal de -1 elevado a una potencia. Cantidades como (-1)^(1/3) (esto es, un exponente racional impar) y (-1)^(1/4) (esto es, un exponente racional par) son tratados como sigue:

              dominio real
                            
(-1)^(1/3):      -1         
(-1)^(1/4):   (-1)^(1/4)   

             dominio complejo              
m1pbranch:false          m1pbranch:true
(-1)^(1/3)               1/2+%i*sqrt(3)/2
(-1)^(1/4)              sqrt(2)/2+%i*sqrt(2)/2
Función: nonnegintegerp (n)

Devuelve true si y solo si n >= 0, siendo n un entero.

Función: numberp (expr)

Devuelve true si expr es un enúmero entero, racional, de coma flotante o "bigfloat", en caso contrario devuelve false.

La función numberp devuelve false si su argumento es un símbolo, incluso cuando el argumento es un número simbólico como %pi o %i, o aunque haya sido declarado como even (par), odd (impar), integer (entero), rational (racional), irrational (irracional), real (real), imaginary (imaginario) o complex (complejo).

Ejemplos:

(%i1) numberp (42);
(%o1)                         true
(%i2) numberp (-13/19);
(%o2)                         true
(%i3) numberp (3.14159);
(%o3)                         true
(%i4) numberp (-1729b-4);
(%o4)                         true
(%i5) map (numberp, [%e, %pi, %i, %phi, inf, minf]);
(%o5)      [false, false, false, false, false, false]
(%i6) declare (a, even, b, odd, c, integer, d, rational,
     e, irrational, f, real, g, imaginary, h, complex);
(%o6)                         done
(%i7) map (numberp, [a, b, c, d, e, f, g, h]);
(%o7) [false, false, false, false, false, false, false, false]
Variable opcional: numer

La variable numer hace algunas funciones matemáticas con argumentos numéricos se evalúen como decimales de punto flotante. También hace que las variables de una expresión a las cuales se les ha asignado un número sean sustituidas por sus valores. Además, activa la variable float.

Véase también %enumer.

Ejemplos:

(%i1) [sqrt(2), sin(1), 1/(1+sqrt(3))];
                                               1
(%o1)                   [sqrt(2), sin(1), -----------]
                                          sqrt(3) + 1
(%i2) [sqrt(2), sin(1), 1/(1+sqrt(3))],numer;
(%o2) [1.414213562373095, .8414709848078965, .3660254037844387]
Variable opcional: numer_pbranch

Valor por defecto: false

La variable opcional numer_pbranch controla la evaluación numérica de las potencias de números enteros, racionales y decimales negativos. Si numer_pbranch vale true y el exponente es decimal o la variable opcional numer vale true, Maxima evalúa el resultado numérico utilizando la rama principal. En caso contrario, se devuleve un resultado simplificado pero no evaluado.

Ejemplos:

(%i1) (-2)^0.75;
(%o1) (-2)^0.75

(%i2) (-2)^0.75,numer_pbranch:true;
(%o2) 1.189207115002721*%i-1.189207115002721

(%i3) (-2)^(3/4);
(%o3) (-1)^(3/4)*2^(3/4)

(%i4) (-2)^(3/4),numer;
(%o4) 1.681792830507429*(-1)^0.75

(%i5) (-2)^(3/4),numer,numer_pbranch:true;
(%o5) 1.189207115002721*%i-1.189207115002721
Función: numerval (x_1, expr_1, ..., var_n, expr_n)

Declara las variables x_1, ..., x_n asignándoles los valores numéricos expr_1, ..., expr_n. El valor numérico se evalúa y sustituye a la variable en cualquier expresión en la que ésta aparezca si numer toma el valor true. Véase también ev.

Las expresiones expr_1, ..., expr_n pueden ser expresiones no necesariamente numéricas.

Función: oddp (expr)

Devuelve true si expr es un entero impar y false en caso contrario.

Variable opcional: ratepsilon

Valor por defecto: 2.0e-8

La variable ratepsilon guarda la tolerancia utilizada en la conversión de números decimales en coma flotante a números racionales.

Función: rationalize (expr)

Convierte todos los números en coma flotante de doble precisión y grandes (big float) presentes en una expresión expr de Maxima a sus formas racionales exactas equivalentes. Si el usuario no está familiarizado con la representación binaria de números en coma flotante, le puede extrañar que rationalize (0.1) no sea igual que 1/10. Este comportamiento no es único de Maxima, ya que el número 1/10 en su forma binaria es periódico y no exacto.

(%i1) rationalize (0.5);
                                1
(%o1)                           -
                                2
(%i2) rationalize (0.1);
                               1
(%o2)                          --
                               10
(%i3) fpprec : 5$
(%i4) rationalize (0.1b0);
                             209715
(%o4)                        -------
                             2097152
(%i5) fpprec : 20$
(%i6) rationalize (0.1b0);
                     236118324143482260685
(%o6)                ----------------------
                     2361183241434822606848
(%i7) rationalize (sin (0.1*x + 5.6));
                              x    28
(%o7)                     sin(-- + --)
                              10   5
Función: ratnump (expr)

Devuelve true si expr es un entero literal o una fracción de enteros literales, en caso contrario devuelve false.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2 Cadenas de texto


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2.1 Introducción a las cadenas de texto

Las cadenas de caracteres deben ir acotadas por comillas dobles (") al ser introducidas en Maxima, siendo luego mostradas con o sin ellas, dependiendo del valor de la variable global stringdisp.

Las cadenas pueden contener todo tipo de caracteres, incluyendo tabulaciones, caracteres de nueva línea y de retorno. La secuencia \" se reconoce literalmente como una comilla doble, al tiempo que \\ se interpreta como una barra invertida. Cuando la barra invertida aparece al final de una línea, tanto la barra como el final de línea (representado éste bien por el carácter de nueva línea o el de retorno) son ignorados, de forma que la cadena continúa en el siguiente renglón. No se reconocen más combinaciones especiales de la barra invertida con otros caracteres aparte de las comentadas; de modo que si la barra invertida aparece antes de cualquier otro carácter distinto de ", \, o de un final de línea, dicha barra será ignorada. No hay manera de representar los caracteres especiales (tabulación, nueva línea o retorno) de otra forma que no sea incluyéndolos literalmente en la cadena.

No existe en Maxima el tipo de variable carácter, debiéndose representar un carácter simple como una cadena de un solo carácter.

El paquete adicional stringproc contiene muchas funciones que permiten trabajar con cadenas.

Ejemplos:

(%i1) s_1 : "This is a string.";
(%o1)               This is a string.
(%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters.";
(%o2) Embedded "double quotes" and backslash \ characters.
(%i3) s_3 : "Embedded line termination
in this string.";
(%o3) Embedded line termination
in this string.
(%i4) s_4 : "Ignore the \
line termination \
characters in \
this string.";
(%o4) Ignore the line termination characters in this string.
(%i5) stringdisp : false;
(%o5)                         false
(%i6) s_1;
(%o6)               This is a string.
(%i7) stringdisp : true;
(%o7)                         true
(%i8) s_1;
(%o8)              "This is a string."

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2.2 Funciones y variables para las cadenas de texto

Función: concat (arg_1, arg_2, ...)

Concatena sus argumentos, que deben ser todos átomos. El valor devuelto es un símbolo si el primer argumento es a su vez un símbolo, o una cadena en caso contrario.

La función concat evalúa sus argumentos. El apátrofo ' evita la evaluación.

(%i1) y: 7$
(%i2) z: 88$
(%i3) concat (y, z/2);
(%o3)                          744
(%i4) concat ('y, z/2);
(%o4)                          y44

A un símbolo construido por concat se le puede asignar un valor y ser utilizado posteriormente en expresiones. La asignación con el operador :: evalúa su expresión izquierda.

(%i5) a: concat ('y, z/2);
(%o5)                          y44
(%i6) a:: 123;
(%o6)                          123
(%i7) y44;
(%o7)                          123
(%i8) b^a;
                               y44
(%o8)                         b
(%i9) %, numer;
                               123
(%o9)                         b

Nótese que aunque concat (1, 2) parezca un número, se trata de una cadena.

(%i10) concat (1, 2) + 3;
(%o10)                       12 + 3
Función: sconcat (arg_1, arg_2, ...)

Concatena sus argumentos para producir una cadena. Al contrario que concat, sus argumentos no necesitan ser átomos.

El resultado es una cadena.

(%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
(%o1)               xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
Función: string (expr)

Convierte expr a la notación lineal de Maxima, tal como si fuese tecleada.

El valor que retorna la función string es una cadena, por lo que no puede ser utilizada en los cálculos.

Variable opcional: stringdisp

Valor por defecto: false

Si stringdisp vale true, las cadenas alfanuméricas se muestran encerradas entre comillas dobles. En caso contrario, no se nuestran las comillas.

La variable stringdisp vale siempre true cuando se muestra la definición de una función.

Ejemplos:

(%i1) stringdisp: false$
(%i2) "This is an example string.";
(%o2)              This is an example string.
(%i3) foo () :=
      print ("This is a string in a function definition.");
(%o3) foo() := 
              print("This is a string in a function definition.")
(%i4) stringdisp: true$
(%i5) "This is an example string.";
(%o5)             "This is an example string."

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.3 Constantes


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.3.1 Funciones y variables para Constantes

Constante: %e

El símbolo %e representa a la base de los logaritmos naturales, también conocido como número de Euler. El valor numérico de %e es el número decimal en coma flotante 2.718281828459045d0.

Constante: %i

El símbolo %i representa la unidad imaginaria, sqrt(- 1).

Constante: false

El símbolo false representa al valor lógico "falso". Maxima implementa false con el valor NIL de Lisp.

Constante: %gamma

Es la constante de Euler-Mascheroni, 0.5772156649015329 ....

Constante: ind

ind representa un resultado acotado indeterminado.

Véase también limit.

Ejemplo:

(%i1) limit (sin(1/x), x, 0);
(%o1)                          ind
Constante: inf

El símbolo inf representa al infinito real positivo.

Constante: infinity

El símbolo infinity representa al infinito complejo.

Constante: minf

El símbolo minf representa al infinito real negativo.

Constante: %phi

El símbolo %phi representa a la llamada razón áurea, (1 + sqrt(5))/2. El valor numérico de %phi es el número decimal en coma flotante 1.618033988749895d0.

La función fibtophi expresa los números de Fibonacci fib(n) en términos de %phi.

Por defecto, Maxima desconoce las propiedades algebraicas de %phi. Tras evaluar tellrat(%phi^2 - %phi - 1) y algebraic: true, ratsimp puede simplificar algunas expresiones que contengan %phi.

Ejemplos:

fibtophi expresa el número de Fibonacci fib(n) en términos de %phi.

(%i1) fibtophi (fib (n));
                           n             n
                       %phi  - (1 - %phi)
(%o1)                  -------------------
                           2 %phi - 1
(%i2) fib (n-1) + fib (n) - fib (n+1);
(%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
(%i3) fibtophi (%);
            n + 1             n + 1       n             n
        %phi      - (1 - %phi)        %phi  - (1 - %phi)
(%o3) - --------------------------- + -------------------
                2 %phi - 1                2 %phi - 1
                                          n - 1             n - 1
                                      %phi      - (1 - %phi)
                                    + ---------------------------
                                              2 %phi - 1
(%i4) ratsimp (%);
(%o4)                           0

Por defecto, Maxima desconoce las propiedades algebraicas de %phi. Después de evaluar tellrat (%phi^2 - %phi - 1) y algebraic: true, ratsimp puede simplificar algunas expresiones que contengan %phi.

(%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1));
                 2                      2
(%o1)        %phi  A - %phi A - A + %phi  - %phi - 1
(%i2) ratsimp (e);
                  2                     2
(%o2)        (%phi  - %phi - 1) A + %phi  - %phi - 1
(%i3) tellrat (%phi^2 - %phi - 1);
                            2
(%o3)                  [%phi  - %phi - 1]
(%i4) algebraic : true;
(%o4)                         true
(%i5) ratsimp (e);
(%o5)                           0
Constante: %pi

El símbolo %pi representa la razón entre la longitud de una circunferencia y su radio. El valor numérico de %pi es el número decimal en coma flotante 3.141592653589793d0.

Constante: true

El símbolo true representa al valor lógico "verdadero". Maxima implementa true con el valor T de Lisp.

Constante: und

und representa un resultado indefinido.

Véase también limit.

Ejemplo:

(%i1) limit (x*sin(x), x, inf);
(%o1)                          und
Constante: zeroa

zeroa representa un infinitesimal mayor que cero. zeroa puede utilizarse en expresiones. limit simplifica expresiones que contienen infinitesimales.

Véanse también zerob y limit.

Ejemplo:

limit simplifica expresiones que contienen infinitesimales:

(%i1) limit(zeroa);
(%o1)                                  0
(%i2) limit(x+zeroa);
(%o2)                                  x
Constante: zerob

zerob representa un infinitesimal menor que cero. zerob puede utilizarse en expresiones. limit simplifica expresiones que contienen infinitesimales.

Véanse también zeroa y limit.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.4 Listas


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.4.1 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

((MPLUS) $A 2)

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

[1, 2, 7, x+y]

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

((MLIST) 1  2  7  ((MPLUS)  $X $Y ))

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

((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

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.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.5 Arrays


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.5.1 Introducción a los arrays

Los arrays más flexibles son aquellos que no necesitan ser declarados, llamados también, en inglés, hashed-arrays, y se basan en que a una variable subindicada se le puede asignar un valor cualquiera. Los índices no necesitan ser números enteros, admitiéndose símbolos o expresiones. Los arrays no declarados crecen dinámicamente según se le van asignando valores a sus elementos. En el siguiente ejemplo se muestra cómo se va construyendo un array no declarado a. Para obtener un listado de los elementos de un array se utiliza la función listarray.

(%i1) a[1,2]: 99;
(%o1)                          99
(%i2) a[x,y]: x^y;
                                y
(%o2)                          x
(%i3) listarray(a);
                                  y
(%o3)                       [99, x ]

Otro tipo de arrays son los declarados, los cuales admiten hasta cinco dimensiones y pueden guardar valores de un tipo concreto, como fixnum para enteros o flonum para reales de coma flotante. Maxima distingue dos tipos de arrays declarados; los primeros se pueden definir declarando un símbolo como array, haciendo uso de la función array; los segundos son arrays de Lisp, en los que un símbolo se declara como tal con la función make_array.

En el primer ejemplo se declara el símbolo a como array, mientras que en el segundo se declara b como array de Lisp.

(%i1) array(a, fixnum, 2, 2);
(%o1)                           a
(%i2) b: make_array(fixnum, 2, 2);
(%o2)              {Array:  #2A((0 0) (0 0))}

Cuando a la variable opcional use_fast_arrays se le asigna el valor true, la función array también generará un array de Lisp. Tal es lo que sucede en el ejemplo siguiente, en el que el símbolo c queda declarado como array de Lisp. Téngase en cuenta que por este método no se puede asignar el tipo de array, ya que al introducirle el tipo fixnum se genera un mensaje de error.

(%i3) use_fast_arrays: true;
(%o3)                         true
(%i4) array(c, 2, 2);
(%o4)    #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
(%i5) c;
(%o5)    #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
(%i6) array(c, fixnum, 2, 2);

make_array: dimensions must be integers; found [fixnum + 1, 3, 3]
 -- an error. To debug this try: debugmode(true);

Maxima también dispone de funciones array, que pueden almacenar valores de funciones, y de funciones subindicadas.

Se puede encontrar más información en las descripciones de las funciones. Los siguientes símbolos y funciones de Maxima permiten trabajar con arrays:

   array         arrayapply     arrayinfo   
   arraymake     arrays         fillarray
   listarray     make_array     rearray
   remarray      subvar         subvarp
   use_fast_arrays

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.5.2 Funciones y variables para los arrays

Función: array (nombre, dim_1, ..., dim_n)
Función: array (nombre, type, dim_1, ..., dim_n)
Función: array ([nombre_1, ..., nombre_m], dim_1, ..., dim_n)

Crea un array de dimensión n, que debe ser menor o igual que 5. Los subíndices de la i-ésima dimensión son enteros que toman valores entre 0 y dim_i.

La llamada array (nombre, dim_1, ..., dim_n) crea un array de tipo general.

La llamada array (nombre, type, dim_1, ..., dim_n) crea un array con sus elementos del tipo especificado. El tipo type puede ser fixnum para enteros de tamaño limitado o flonum para números decimales en coma flotante.

La llamada array ([nombre_1, ..., nombre_m], dim_1, ..., dim_n) crea m arrays, todos ellos de igual dimensión.

Si el usuario asigna un valor a una variable subindicada antes de declarar el array correspondiente, entonces se construye un array no declarado. Los arrays no declarados, también conocidos por el nombre de "arrays de claves" (hashed arrays), son más generales que los arrays declarados. El usuario no necesita declarar su tamaño máximo y pueden ir creciendo de forma dinámica. Los subíndices de los arrays no declarados no necesitan ser necesariamente números. Sin embargo, a menos que un array tenga sus elementos dispersos, probablemente sea más eficiente declararlo siempre que sea posible antes que dejarlo como no declarado. La función array puede utilizarse para transformar un array no declarado a a uno declarado.

Función: arrayapply (A, [i_1, ..., i_n])

Evalúa A [i_1, ..., i_n], donde A es un array y i_1, ..., i_n son enteros.

Esto es como apply, excepto por el hecho de que el primer argumento es un array en lugar de una función.

Función: arrayinfo (A)

Devuelve información sobre el arrayA. El argumento A puede ser un array declarado o no declarado, una función array o una función subindicada.

En el caso de arrays declarados, arrayinfo devuelve una lista que contiene el átomo declared, el número de dimensiones y el tamaño de cada dimensión. Los elementos del array, tanto los que tienen valores asignados como los que no, son devueltos por listarray.

En el caso de arrays no declarados (hashed arrays), arrayinfo devuelve una lista que contiene el átomo hashed, el número de subíndices y los subíndices de aquellos elementos que guarden un valor. Los valores son devueltos por listarray.

En el caso de funciones array, arrayinfo devuelve una lista que contiene el átomo hashed, el número de subíndices y los subíndices para los que la función tiene valores almacenados. Los valores almacenados de la función array son devueltos por listarray.

En el caso de funciones subindicadas, arrayinfo devuelve una lista que contiene el átomo hashed, el número de subíndices y los subíndices para los que hay expresiones lambda. Las expresiones lambda son devueltas por listarray.

Ejemplos:

arrayinfo y listarray aplicadas a una array declarado.

(%i1) array (aa, 2, 3);
(%o1)                          aa
(%i2) aa [2, 3] : %pi;
(%o2)                          %pi
(%i3) aa [1, 2] : %e;
(%o3)                          %e
(%i4) arrayinfo (aa);
(%o4)                 [declared, 2, [2, 3]]
(%i5) listarray (aa);
(%o5) [#####, #####, #####, #####, #####, #####, %e, #####, 
                                        #####, #####, #####, %pi]

arrayinfo y listarray aplicadas a una array no declarado (hashed arrays).

(%i1) bb [FOO] : (a + b)^2;
                                   2
(%o1)                       (b + a)
(%i2) bb [BAR] : (c - d)^3;
                                   3
(%o2)                       (c - d)
(%i3) arrayinfo (bb);
(%o3)               [hashed, 1, [BAR], [FOO]]
(%i4) listarray (bb);
                              3         2
(%o4)                 [(c - d) , (b + a) ]

arrayinfo y listarray aplicadas a una función array.

(%i1) cc [x, y] := y / x;
                                     y
(%o1)                      cc     := -
                             x, y    x
(%i2) cc [u, v];
                                v
(%o2)                           -
                                u
(%i3) cc [4, z];
                                z
(%o3)                           -
                                4
(%i4) arrayinfo (cc);
(%o4)              [hashed, 2, [4, z], [u, v]]
(%i5) listarray (cc);
                              z  v
(%o5)                        [-, -]
                              4  u

arrayinfo y listarray aplicadas a una función subindicada.

(%i1) dd [x] (y) := y ^ x;
                                     x
(%o1)                     dd (y) := y
                            x
(%i2) dd [a + b];
                                    b + a
(%o2)                  lambda([y], y     )
(%i3) dd [v - u];
                                    v - u
(%o3)                  lambda([y], y     )
(%i4) arrayinfo (dd);
(%o4)             [hashed, 1, [b + a], [v - u]]
(%i5) listarray (dd);
                         b + a                v - u
(%o5)      [lambda([y], y     ), lambda([y], y     )]
Función: arraymake (name, [i_1, ..., i_n])

El resultado es una referencia a array no evaluada.

Devuelve la expresión name [i_1, ..., i_n].

Esta función es similar a funmake, excepto que el valor retornado es referencia a un array no evaluado, en lugar de una llamada a una función no evaluada.

Ejemplos:

(%i1) arraymake (A, [1]);
(%o1)                          A
                                1
(%i2) arraymake (A, [k]);
(%o2)                          A
                                k
(%i3) arraymake (A, [i, j, 3]);
(%o3)                       A
                             i, j, 3
(%i4) array (A, fixnum, 10);
(%o4)                           A
(%i5) fillarray (A, makelist (i^2, i, 1, 11));
(%o5)                           A
(%i6) arraymake (A, [5]); 
(%o6)                          A
                                5
(%i7) ''%;
(%o7)                          36
(%i8) L : [a, b, c, d, e];
(%o8)                    [a, b, c, d, e]
(%i9) arraymake ('L, [n]);
(%o9)                          L
                                n
(%i10) ''%, n = 3;
(%o10)                          c
(%i11) A2 : make_array (fixnum, 10);
(%o11)          {Array:  #(0 0 0 0 0 0 0 0 0 0)}
(%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o12)          {Array:  #(1 2 3 4 5 6 7 8 9 10)}
(%i13) arraymake ('A2, [8]);
(%o13)                         A2
                                 8
(%i14) ''%;
(%o14)                          9
Variable del sistema: arrays

Valor por defecto: [] La variable arrays es una lista con todos los arrays que han sido alojados, lo que comprende a los arrays declarados por array, a los no declarados (hashed arrays) construidos implícitamente (asignando algo al elemento de un array) y a las funciones array definidas mediante := y define. Los arrays definidos mediante make_array no se incluyen en este grupo.

Véanse también array, arrayapply, arrayinfo, arraymake, fillarray, listarray y rearray.

Ejemplos:

(%i1) array (aa, 5, 7);
(%o1)                          aa
(%i2) bb [FOO] : (a + b)^2;
                                   2
(%o2)                       (b + a)
(%i3) cc [x] := x/100;
                                   x
(%o3)                      cc  := ---
                             x    100
(%i4) dd : make_array ('any, 7);
(%o4)       {Array:  #(NIL NIL NIL NIL NIL NIL NIL)}
(%i5) arrays;
(%o5)                     [aa, bb, cc]
Función: arraysetapply (A, [i_1, …, i_n], x)

Asigna x a A[i_1, ..., i_n], siendo A un array y i_1, …, i_n enteros.

arraysetapply evalúa sus argumentos.

Función: fillarray (A, B)

Rellena el array A con los valores de B, que puede ser una lista o array.

Si se ha declarado A de un determinado tipo en el momento de su creación, sólo podrá contener elementos de ese tipo, produciéndose un error en caso de intentar asignarle un elemento de tipo distinto.

Si las dimensiones de los arrays A y B son diferentes, A se rellena según el orden de las filas. Si no hay suficientes elementos en B el último elemento se utiliza para cubrir el resto de A. Si hay demasiados, los elementos sobrantes son ignorados.

La función fillarray devuelve su primer argumento.

Ejemplos:

Creación de un array de 9 elementos y posterior relleno a partir de una lista.

(%i1) array (a1, fixnum, 8);
(%o1)                          a1
(%i2) listarray (a1);
(%o2)              [0, 0, 0, 0, 0, 0, 0, 0, 0]
(%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
(%o3)                          a1
(%i4) listarray (a1);
(%o4)              [1, 2, 3, 4, 5, 6, 7, 8, 9]

Si no hay suficientes elementos para cubrir el array, se repite el último elemento. Si hay demasiados, los elementos sobrantes son ignorados.

(%i1) a2 : make_array (fixnum, 8);
(%o1)             {Array:  #(0 0 0 0 0 0 0 0)}
(%i2) fillarray (a2, [1, 2, 3, 4, 5]);
(%o2)             {Array:  #(1 2 3 4 5 5 5 5)}
(%i3) fillarray (a2, [4]);
(%o3)             {Array:  #(4 4 4 4 4 4 4 4)}
(%i4) fillarray (a2, makelist (i, i, 1, 100));
(%o4)             {Array:  #(1 2 3 4 5 6 7 8)}

Arrays multidimensionales se rellenan según el orden de las filas.

(%i1) a3 : make_array (fixnum, 2, 5);
(%o1)        {Array:  #2A((0 0 0 0 0) (0 0 0 0 0))}
(%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o2)        {Array:  #2A((1 2 3 4 5) (6 7 8 9 10))}
(%i3) a4 : make_array (fixnum, 5, 2);
(%o3)     {Array:  #2A((0 0) (0 0) (0 0) (0 0) (0 0))}
(%i4) fillarray (a4, a3);
(%o4)     {Array:  #2A((1 2) (3 4) (5 6) (7 8) (9 10))}
Función: listarray (A)

Devuelve una lista con los elementos del array A. El argumento A puede ser un array declarado o no declarado, una función array o una función subindicada.

Los elementos se ordenan en primera instancia respecto del primer índice, después respecto del segundo índice y así sucesivamente. La ordenación de los índices es la misma que la establecida por orderless.

En el caso de arrays no declarados, funciones array y funciones subindicadas, los elementos corresponden a los índices devueltos por arrayinfo.

Los elementos de los arrays declarados que no tienen valores asignados (excepto fixnum y flonum) se devuelven como #####. Los elementos sin valores asignados de los arrays fixnum y flonum son devueltos como 0 y 0.0, respectivamente. Los elementos sin valor asignado de los arrays no declarados, funciones array y funciones subindicadas no son devueltos.

Ejemplos:

listarray y arrayinfo aplicadas a un array declarado.

(%i1) array (aa, 2, 3);
(%o1)                          aa
(%i2) aa [2, 3] : %pi;
(%o2)                          %pi
(%i3) aa [1, 2] : %e;
(%o3)                          %e
(%i4) listarray (aa);
(%o4) [#####, #####, #####, #####, #####, #####, %e, #####, 
                                        #####, #####, #####, %pi]
(%i5) arrayinfo (aa);
(%o5)                 [declared, 2, [2, 3]]

listarray y arrayinfo aplicadas a un array no declarado (hashed array).

(%i1) bb [FOO] : (a + b)^2;
                                   2
(%o1)                       (b + a)
(%i2) bb [BAR] : (c - d)^3;
                                   3
(%o2)                       (c - d)
(%i3) listarray (bb);
                              3         2
(%o3)                 [(c - d) , (b + a) ]
(%i4) arrayinfo (bb);
(%o4)               [hashed, 1, [BAR], [FOO]]

listarray y arrayinfo aplicadas a una función array.

(%i1) cc [x, y] := y / x;
                                     y
(%o1)                      cc     := -
                             x, y    x
(%i2) cc [u, v];
                                v
(%o2)                           -
                                u
(%i3) cc [4, z];
                                z
(%o3)                           -
                                4
(%i4) listarray (cc);
                              z  v
(%o4)                        [-, -]
                              4  u
(%i5) arrayinfo (cc);
(%o5)              [hashed, 2, [4, z], [u, v]]

listarray y arrayinfo aplicadas a una función subindicada.

(%i1) dd [x] (y) := y ^ x;
                                     x
(%o1)                     dd (y) := y
                            x
(%i2) dd [a + b];
                                    b + a
(%o2)                  lambda([y], y     )
(%i3) dd [v - u];
                                    v - u
(%o3)                  lambda([y], y     )
(%i4) listarray (dd);
                         b + a                v - u
(%o4)      [lambda([y], y     ), lambda([y], y     )]
(%i5) arrayinfo (dd);
(%o5)             [hashed, 1, [b + a], [v - u]]
Función: make_array (tipo, dim_1, ..., dim_n)

Construye y devuelve un array de Lisp. El argumento tipo puede ser any, flonum, fixnum, hashed o functional. Hay n índices, y el índice i-ésimo va de 0 a dim_i - 1.

La ventaja de make_array sobre array estriba en que el valor retornado no tiene nombre, y una vez que un puntero deja de referenciarlo, el valor desaparece. Por ejemplo, si y: make_array (...) entonces y apunta a un objeto que ocupa cierto espacio en la memoria, pero después de y: false, y ya no apunta al objeto, por lo que éste puede ser considerado basura y posteriormente eliminado.

Ejemplos:

(%i1) A1 : make_array (fixnum, 10);
(%o1)           {Array:  #(0 0 0 0 0 0 0 0 0 0)}
(%i2) A1 [8] : 1729;
(%o2)                         1729
(%i3) A1;
(%o3)          {Array:  #(0 0 0 0 0 0 0 0 1729 0)}
(%i4) A2 : make_array (flonum, 10);
(%o4) {Array:  #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i5) A2 [2] : 2.718281828;
(%o5)                      2.718281828
(%i6) A2;
(%o6) 
     {Array:  #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i7) A3 : make_array (any, 10);
(%o7) {Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)}
(%i8) A3 [4] : x - y - z;
(%o8)                      - z - y + x
(%i9) A3;
(%o9) {Array:  #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
 -1 $Y) ((MTIMES SIMP) -1 $Z))
  NIL NIL NIL NIL NIL)}
(%i10) A4 : make_array (fixnum, 2, 3, 5);
(%o10) {Array:  #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
0 0 0) (0 0 0 0 0) (0 0 0 0 0)))}
(%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
(%o11) {Array:  #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
    ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))}
(%i12) A4 [0, 2, 1];
(%o12)                         12
Función: rearray (A, dim_1, ..., dim_n)

Cambia las dimensiones de un array. El nuevo array será rellenado con los elementos del viejo según el orden de las filas. Si el array antiguo era demasiado pequeño, los elementos restantes se rellenan con false, 0.0 o 0, dependiendo del tipo del array. El tipo del array no se puede cambiar.

Función: remarray (A_1, ..., A_n)
Función: remarray (all)

Borra los arrays y las funciones relacionadas con ellos, liberando el espacio de memoria ocupado. Los argumentos pueden ser arrays declarados, arrays no declarados (hashed arrays), funciones array y funciones subindicadas.

La llamada remarray (all) borra todos los elementos de la lista global arrays.

La función remarray devuelve la lista de los arrays borrados.

La función remarray no evalúa sus argumentos.

Función: subvar (x, i)

Evalúa la expresión subindicada x[i].

La función subvar evalúa sus argumentos.

La instrucción arraymake (x, [i]) construye la expresión x[i], pero no la evalúa.

Ejemplos:

(%i1) x : foo $

(%i2) i : 3 $

(%i3) subvar (x, i);
(%o3)                         foo
                                 3
(%i4) foo : [aa, bb, cc, dd, ee]$

(%i5) subvar (x, i);
(%o5)                          cc
(%i6) arraymake (x, [i]);
(%o6)                         foo
                                 3
(%i7) ''%;
(%o7)                          cc
Función: subvarp (expr)

Devuelve true si expr es una variable subindicada, como a[i].

Variable opcional: use_fast_arrays

Valor por defecto: false

Si use_fast_arrays vale true entonces tan solo se reconocen dos tipos de arrays.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.6 Estructuras


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.6.1 Introducción a las estructuras

Maxima dispone de estructuras para la agregación de datos. Una estructura es una expresión en la que los argumentos se definen con un nombre (nombre del campo) y la estructura en su conjunto se define por medio de su operador (nombre de la estructura). Los valores dados a los campos pueden ser expresiones cualesquiera.

Una estructura se define con la función defstruct, guardando la variable structures la lista de todas las estructuras definidas por el usuario. El operador @ permite hacer referencias a los campos de la estructura. Con kill(S) se borra la estructura S completa y kill(x@ a) elimina la asignación actual del campo a en la estructura x.

En la impresión por consola (con display2d igual a true), las estructuras se representan con las asignaciones de los campos en forma de ecuación, con el nombre del campo a la izquierda y su valor asociado a la derecha. En la impresión unidimensional (mediante grind o dándole a display2d el valor false), las estructuras se escriben sin los nombres de los campos.

No es posible utilizar el nombre de un campo como nombre de función, pero el valor de un campo sí puede ser una expresión lambda. Tampoco es posible restringir los valores de los campos a tipos de datos concretos, siendo el caso que a cada campo se le puede asignar cualquier tipo de expresión. Por último, no es posible hacer que ciertos campos sean o no accesibles desde determinados contextos, ya que todos los campos son siempre visibles.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.6.2 Funciones y variables para las estructuras

Variable global: structures

structures es la lista que contiene las estructuras definidas por el usuario con defstruct.

Función: defstruct (S(a_1, ..., a_n))
Función: defstruct (S(a_1 = v_1, ..., a_n = v_n))

Define una estructura, la cual es una lista de nombres de campos a_1, ..., a_n asociados a un símbolo S. Todo individuo de una estructura dada consiste en una expresión con operador S y exactamente n argumentos. La sentencia new(S) crea un nuevo individuo con estructura S.

Un argumento consistente en un símbolo a especifica el nombre de un campo. Un argumento consistente en una ecuación a = v especifica el nombre del campo a junto con su valor por defecto v. El valor por defecto puede ser cualquier tipo de expresión.

La llamada a defstruct añade S a la lista de estructuras definidas por el usuario, structures.

La sentencia kill(S) borra S de la lista de estructuras definidas por el usuario y elimina la definición de la estructura.

Ejemplos:

(%i1) defstruct (foo (a, b, c));
(%o1)                    [foo(a, b, c)]
(%i2) structures;
(%o2)                    [foo(a, b, c)]
(%i3) new (foo);
(%o3)                     foo(a, b, c)
(%i4) defstruct (bar (v, w, x = 123, y = %pi));
(%o4)             [bar(v, w, x = 123, y = %pi)]
(%i5) structures;
(%o5)      [foo(a, b, c), bar(v, w, x = 123, y = %pi)]
(%i6) new (bar);
(%o6)              bar(v, w, x = 123, y = %pi)
(%i7) kill (foo);
(%o7)                         done
(%i8) structures;
(%o8)             [bar(v, w, x = 123, y = %pi)]
Función: new (S)
Función: new (S (v_1, ..., v_n))

new crea nuevos individuos de estructuras declaradas.

La sentencia new(S) crea un nuevo individuo de estructura S en el que cada campo toma su valor por defecto, si este fue definido, o sin valor alguno en caso de que no se haya fijado un valor por defecto en la definición de la estructura.

La sentencia new(S(v_1, ..., v_n)) crea un nuevo individuo de estructura S en el que los campos adquieren los valores v_1, ..., v_n.

Ejemplos:

(%i1) defstruct (foo (w, x = %e, y = 42, z));
(%o1)              [foo(w, x = %e, y = 42, z)]
(%i2) new (foo);
(%o2)               foo(w, x = %e, y = 42, z)
(%i3) new (foo (1, 2, 4, 8));
(%o3)            foo(w = 1, x = 2, y = 4, z = 8)
Operador: @

@ es el operador para acceder a los campos de las estructuras.

La expresión x@ a hace referencia al valor del campo a del individuo x de una estructura dada. El nombre del campo no se evalúa.

Si el campo a de x no tiene valor asignado, x@ a se evalúa a sí mismo; es decir, devuelve la propia expresión x@ a tal cual.

La sentencia kill(x@ a) elimina el valor del campo a de x.

Ejemplos:

(%i1) defstruct (foo (x, y, z));
(%o1)                    [foo(x, y, z)]
(%i2) u : new (foo (123, a - b, %pi));
(%o2)           foo(x = 123, y = a - b, z = %pi)
(%i3) u@z;
(%o3)                          %pi
(%i4) u@z : %e;
(%o4)                          %e
(%i5) u;
(%o5)            foo(x = 123, y = a - b, z = %e)
(%i6) kill (u@z);
(%o6)                         done
(%i7) u;
(%o7)              foo(x = 123, y = a - b, z)
(%i8) u@z;
(%o8)                          u@z

El nombre del campo no se evalúa.

(%i1) defstruct (bar (g, h));
(%o1)                      [bar(g, h)]
(%i2) x : new (bar);
(%o2)                       bar(g, h)
(%i3) x@h : 42;
(%o3)                          42
(%i4) h : 123;
(%o4)                          123
(%i5) x@h;
(%o5)                          42
(%i6) x@h : 19;
(%o6)                          19
(%i7) x;
(%o7)                    bar(g, h = 19)
(%i8) h;
(%o8)                          123

[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Jaime Villate on octubre, 13 2014 using texi2html 1.76.