Manual de Maxima 5.39.0: 5. Tipos de datos y estructuras

[ < ] | [ > ] |  | [ << ] | [ 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 Viktor T. Toth on diciembre, 11 2016 using texi2html 1.76.