@c English version 2013-08-03
@page
@node Arrays, Estructuras, Listas, Tipos de datos y estructuras
@section Arrays


@menu
* Introducción a los arrays::
* Funciones y variables para los arrays::
@end menu



@node Introducción a los arrays, Funciones y variables para los arrays, Arrays, Arrays
@subsection Introducción a los arrays

Los arrays más flexibles son aquellos que no necesitan ser declarados, llamados
también, en inglés, @i{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 @code{a}. Para obtener un listado de
los elementos de un array se utiliza la función @code{listarray}.

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

Otro tipo de arrays son los declarados, los cuales admiten hasta cinco dimensiones
y pueden guardar valores de un tipo concreto, como @code{fixnum} para enteros o
@code{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 @code{array}; los segundos son arrays
de Lisp, en los que un símbolo se declara como tal con la
función @code{make_array}.

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

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

Cuando a la variable opcional @code{use_fast_arrays} se le asigna el valor
@code{true}, la función @code{array} también generará un array de Lisp.
Tal es lo que sucede en el ejemplo siguiente, en el que el símbolo
@code{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
@code{fixnum} se genera un mensaje de error.

@example
(%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);
@end example

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:

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









@node Funciones y variables para los arrays, , Introducción a los arrays, Arrays
@subsection Funciones y variables para los arrays

@deffn {Función} array (@var{nombre}, @var{dim_1}, ..., @var{dim_n})
@deffnx {Función} array (@var{nombre}, @var{type}, @var{dim_1}, ..., @var{dim_n})
@deffnx {Función} array ([@var{nombre_1}, ..., @var{nombre_m}], @var{dim_1}, ..., @var{dim_n})

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

La llamada @code{array (@var{nombre}, @var{dim_1}, ..., @var{dim_n})} crea un array de tipo general.

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

La llamada @code{array ([@var{nombre_1}, ..., @var{nombre_m}], @var{dim_1}, ..., @var{dim_n})}
crea @math{m} arrays,  todos ellos de igual dimensión.
@c SAME TYPE AS WELL ??

@c THIS DISCUSSION OF UNDECLARED ARRAYS REALLY WANTS TO BE SOMEWHERE ELSE
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 @code{array} puede utilizarse para transformar un array no declarado a a uno declarado.
@c HOW DOES ONE CHANGE AN UNDECLARED ARRAY INTO A DECLARED ARRAY EXACTLY ??

@end deffn

@deffn {Función} arrayapply (@var{A}, [@var{i_1}, ..., @var{i_n}])
Evalúa @code{@var{A} [@var{i_1}, ..., @var{i_n}]}, donde @var{A} es un array y @var{i_1}, ..., @var{i_n} son enteros.

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

@end deffn

@deffn {Función} arrayinfo (@var{A})
Devuelve información sobre el array@var{A}.
El argumento @var{A} puede ser un array declarado o no declarado,
una función array o una función subindicada.

En el caso de arrays declarados, @code{arrayinfo} devuelve una
lista que contiene el átomo @code{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 @code{listarray}.

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

En el caso de funciones array, @code{arrayinfo} devuelve una lista que 
contiene el átomo @code{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 @code{listarray}.

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

Ejemplos:

@code{arrayinfo} y @code{listarray} aplicadas a una array declarado.

@c ===beg===
@c array (aa, 2, 3);
@c aa [2, 3] : %pi;
@c aa [1, 2] : %e;
@c arrayinfo (aa);
@c listarray (aa);
@c ===end===
@example
(%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]
@end example

@code{arrayinfo} y @code{listarray} aplicadas a una array no declarado (@i{hashed arrays}).

@c ===beg===
@c bb [FOO] : (a + b)^2;
@c bb [BAR] : (c - d)^3;
@c arrayinfo (bb);
@c listarray (bb);
@c ===end===
@example
(%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) ]
@end example

@code{arrayinfo} y @code{listarray} aplicadas a una función array.

@c ===beg===
@c cc [x, y] := y / x;
@c cc [u, v];
@c cc [4, z];
@c arrayinfo (cc);
@c listarray (cc);
@c ===end===
@example
(%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
@end example

@code{arrayinfo} y @code{listarray} aplicadas a una función subindicada.

@c ===beg===
@c dd [x] (y) := y ^ x;
@c dd [a + b];
@c dd [v - u];
@c arrayinfo (dd);
@c listarray (dd);
@c ===end===
@example
(%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     )]
@end example

@end deffn

@deffn {Función} arraymake (@var{name}, [@var{i_1}, ..., @var{i_n}])

El resultado es una referencia a array no evaluada.

Devuelve la expresión @code{@var{name} [@var{i_1}, ..., @var{i_n}]}.

Esta función es similar a @code{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:
@c ===beg===
@c arraymake (A, [1]);
@c arraymake (A, [k]);
@c arraymake (A, [i, j, 3]);
@c array (A, fixnum, 10);
@c fillarray (A, makelist (i^2, i, 1, 11));
@c arraymake (A, [5]);
@c ''%;
@c L : [a, b, c, d, e];
@c arraymake ('L, [n]);
@c ''%, n = 3;
@c A2 : make_array (fixnum, 10);
@c fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
@c arraymake ('A2, [8]);
@c ''%;
@c ===end===

@example
(%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
@end example

@end deffn

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

Véanse también
@code{array}, @code{arrayapply}, @code{arrayinfo}, @code{arraymake}, 
@code{fillarray}, @code{listarray} y @code{rearray}.

Ejemplos:

@c ===beg===
@c array (aa, 5, 7);
@c bb [FOO] : (a + b)^2;
@c cc [x] := x/100;
@c dd : make_array ('any, 7);
@c arrays;
@c ===end===
@example
(%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]
@end example

@end defvr


@deffn {Función} arraysetapply (@var{A}, [@var{i_1}, @dots{}, @var{i_n}], @var{x})

Asigna @var{x} a @code{@var{A}[@var{i_1}, ..., @var{i_n}]},
siendo @var{A} un array y @var{i_1}, @dots{}, @var{i_n} enteros.

@code{arraysetapply} evalúa sus argumentos.
@end deffn



@deffn {Función} fillarray (@var{A}, @var{B})
Rellena el array @var{A} con los valores de @var{B}, que puede ser una lista o array.

Si se ha declarado @var{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 @var{A} y @var{B} son diferentes,
@var{A} se rellena según el orden de las filas. Si no hay 
suficientes elementos en @var{B} el último elemento se utiliza 
para cubrir el resto de @var{A}. Si hay demasiados, los elementos 
sobrantes son ignorados.

La función @code{fillarray} devuelve su primer argumento.

Ejemplos:

Creación de un array de 9 elementos y posterior relleno a partir de una lista.
@c ===beg===
@c array (a1, fixnum, 8);
@c listarray (a1);
@c fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
@c listarray (a1);
@c ===end===

@example
(%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]
@end example

Si no hay suficientes elementos para cubrir el array, se repite el
último elemento. Si hay demasiados, los elementos 
sobrantes son ignorados.
@c ===beg===
@c a2 : make_array (fixnum, 8);
@c fillarray (a2, [1, 2, 3, 4, 5]);
@c fillarray (a2, [4]);
@c fillarray (a2, makelist (i, i, 1, 100));
@c ===end===

@example
(%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)@}
@end example

Arrays multidimensionales se rellenan según el orden de las filas.
@c ===beg===
@c a3 : make_array (fixnum, 2, 5);
@c fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
@c a4 : make_array (fixnum, 5, 2);
@c fillarray (a4, a3);
@c ===end===

@example
(%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))@}
@end example

@end deffn


@deffn {Función} listarray (@var{A})
Devuelve una lista con los elementos del array @var{A}.
El argumento @var{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 @code{orderless}.

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

Los elementos de los arrays declarados que no tienen valores asignados
(excepto @code{fixnum} y @code{flonum}) se devuelven como @code{#####}.
Los elementos sin valores asignados de los arrays @code{fixnum} y @code{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:

@code{listarray} y @code{arrayinfo} aplicadas a un array declarado.

@c ===beg===
@c array (aa, 2, 3);
@c aa [2, 3] : %pi;
@c aa [1, 2] : %e;
@c listarray (aa);
@c arrayinfo (aa);
@c ===end===
@example
(%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]]
@end example

@code{listarray} y @code{arrayinfo} aplicadas a un array no declarado (@i{hashed array}).

@c ===beg===
@c bb [FOO] : (a + b)^2;
@c bb [BAR] : (c - d)^3;
@c listarray (bb);
@c arrayinfo (bb);
@c ===end===
@example
(%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]]
@end example

@code{listarray} y @code{arrayinfo} aplicadas a una función array.

@c ===beg===
@c cc [x, y] := y / x;
@c cc [u, v];
@c cc [4, z];
@c listarray (cc);
@c arrayinfo (cc);
@c ===end===
@example
(%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]]
@end example

@code{listarray} y @code{arrayinfo} aplicadas a una función subindicada.

@c ===beg===
@c dd [x] (y) := y ^ x;
@c dd [a + b];
@c dd [v - u];
@c listarray (dd);
@c arrayinfo (dd);
@c ===end===
@example
(%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]]
@end example

@end deffn

@deffn {Función} make_array (@var{tipo}, @var{dim_1}, ..., @var{dim_n})

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

La ventaja de @code{make_array} sobre @code{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 @code{y: make_array (...)} entonces
@code{y} apunta a un objeto que ocupa cierto espacio en la memoria, pero
después de @code{y: false}, @code{y} ya no apunta al objeto, por lo
que éste puede ser considerado basura y posteriormente eliminado.  

Ejemplos:
@c ===beg===
@c A1 : make_array (fixnum, 10);
@c A1 [8] : 1729;
@c A1;
@c A2 : make_array (flonum, 10);
@c A2 [2] : 2.718281828;
@c A2;
@c A3 : make_array (any, 10);
@c A3 [4] : x - y - z;
@c A3;
@c A4 : make_array (fixnum, 2, 3, 5);
@c fillarray (A4, makelist (i, i, 1, 2*3*5));
@c A4 [0, 2, 1];
@c ===end===

@example
(%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
@end example

@end deffn

@c DOES THIS MODIFY A OR DOES IT CREATE A NEW ARRAY ??
@deffn {Función} rearray (@var{A}, @var{dim_1}, ..., @var{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 @code{false}, @code{0.0} o @code{0}, dependiendo del tipo del array. El tipo del array no se puede cambiar.

@end deffn

@deffn {Función} remarray (@var{A_1}, ..., @var{A_n})
@deffnx {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 (@i{hashed arrays}), 
funciones array y funciones subindicadas.

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

La función @code{remarray} devuelve la lista de los arrays borrados.

La función @code{remarray} no evalúa sus argumentos.

@end deffn


@deffn {Función} subvar (@var{x}, @var{i})
Evalúa la expresión subindicada @code{@var{x}[@var{i}]}.

La función @code{subvar} evalúa sus argumentos.

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

Ejemplos:

@c ===beg===
@c x : foo $
@c i : 3 $
@c subvar (x, i);
@c foo : [aa, bb, cc, dd, ee]$
@c subvar (x, i);
@c arraymake (x, [i]);
@c ''%;
@c ===end===
@example
(%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
@end example

@end deffn



@deffn {Función} subvarp (@var{expr})
Devuelve @code{true} si @var{expr} es una variable subindicada, como @code{a[i]}.

@end deffn



@c THIS IS REALLY CONFUSING
@defvr {Variable opcional} use_fast_arrays
Valor por defecto: @code{false}

Si @code{use_fast_arrays} vale @code{true} entonces tan solo se reconocen dos tipos de arrays. 

@c AQUI QUEDAN TRES PARRAFOS SIN TRADUCIR
 
@end defvr



