@c /Arrays.texi/1.14/Mon Jan  1 07:26:48 2007/-ko/
@menu
* Definições para Arrays::  
@end menu

@node Definições para Arrays,  , Arrays, Arrays
@section Definições para Arrays

@deffn {Função} array (@var{name}, @var{dim_1}, ..., @var{dim_n})
@deffnx {Função} array (@var{name}, @var{type}, @var{dim_1}, ..., @var{dim_n})
@deffnx {Função} array ([@var{nome_1}, ..., @var{nome_m}], @var{dim_1}, ..., @var{dim_n})

Cria um array @math{n}-dimensional.  
@math{n} pode ser menor ou igual a 5.
Os subscritos para
a @math{i}'ésima dimensão são inteiros no intervalo de 0 a @var{dim_i}.  

@code{array (@var{name}, @var{dim_1}, ..., @var{dim_n})} cria um array genérico.

@code{array (@var{name}, @var{type}, @var{dim_1}, ..., @var{dim_n})} cria
um array, com elementos de um tipo especificado.
@var{type} pode ser @code{fixnum} para
inteiros de tamanho limitado ou @code{flonum} para números em ponto flutuante.

@code{array ([@var{nome_1}, ..., @var{nome_m}], @var{dim_1}, ..., @var{dim_n})}
cria @math{m} arrays, todos da mesma dimensão.
@c SAME TYPE AS WELL ??

@c THIS DISCUSSION OF UNDECLARED ARRAYS REALLY WANTS TO BE SOMEWHERE ELSE
Se o utilizador atribui a uma variável subscrita antes de declarar o
array correspondente, um array não declarado é criado.
Arrays não declarados, também conhecidos como array desordenado (porque
o codigo desordenado termina nos subscritos), são mais gerais que arrays
declarados.  O utilizador não declara seu tamanho máximo, e ele cresce
dinamicamente e desordenadamente à medida que são atribuídos valores a mais elementos.  Os
subscritos de um array não declarado não precisam sempre ser números.  Todavia,
excepto para um array um tanto quanto esparso, é provavelmente mais eficiente
declarar isso quando possível que deixar não declarado.  A função @code{array}
pode ser usada para transformar um array não declarado em um array
declarado.
@c HOW DOES ONE CHANGE AN UNDECLARED ARRAY INTO A DECLARED ARRAY EXACTLY ??

@end deffn

@deffn {Função} arrayapply (@var{A}, [@var{i_1}, ..., @var{i_n}])
Avalia @code{@var{A} [@var{i_1}, ..., @var{i_n}]},
quando @var{A} for um array e @var{i_1}, ..., @var{i_n} são inteiros.

Ela é remanescente de @code{apply}, excepto o primeiro argumento que é um array ao invés de uma função.

@end deffn

@deffn {Função} arrayinfo (@var{A})
Retorna informações sobre o array @var{A}.
O argumento @var{A} pode ser um array declarado, uma array não declarado ( que sofreu um hash),
uma função de array, ou uma função que possui subscrito.

Para arrays declarados, @code{arrayinfo} retorna uma lista
compreendendo o átomo @code{declared}, o n;umero de dimensões, e o tamanho de cada dimensão.
Os elementos do array, ambos associados e não associados, são retornados por @code{listarray}.

Para arrays não declarados (arrays que sofreram um hash),
@code{arrayinfo} retorna uma lista compreendendo o átomo @code{hashed}, o número de subscritos,
e os subscritos de de todo elemento que tiver um valor.
Os valores são retornados por meio de @code{listarray}.

Para funções de array,
@code{arrayinfo} retretorna uma lista compreendendo o átomo @code{hashed}, o número de subscritos,
e quaisquer valores de subscritos para os quais exista valores funcionais armazenados.
Os valores funcionais armazenados são retornados através de @code{listarray}.

Para funções que possuem subscritos,
@code{arrayinfo} retorna uma lista compreendendo o átomo @code{hashed}, o número de subscritos,
e qualquer valores subscritos para os quais existe uma expressões lambda.
As expressões lambda são retornadas por @code{listarray}.

Examples:

@code{arrayinfo} e @code{listarray} aplicado a um 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} e @code{listarray} aplicado a um array não declarado (no qual foi aplicado um hash).

@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} e @code{listarray} aplicado a uma função de 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} e @code{listarray} aplicadas a funções com subscritos.

@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 {Função} arraymake (@var{A}, [@var{i_1}, ..., @var{i_n}])
Retorna a expressão @code{@var{A}[@var{i_1}, ..., @var{i_n}]}.
O resultado é uma referência a um array não avaliado.

@code{arraymake} é remanicência de @code{funmake},
excepto o valor retornado é um array de referência não avaliado
ao invés de uma chamada de função não avaliada.

Exemplos:
@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 {Variável de sistema} arrays
Valor por omissão: @code{[]}

@code{arrays} é uma lista dos arrays que tiverem sido alocados.
Essa lista compreende arrays declarados através de @code{array},
arrays desordenados (hashed) construídos através de definição implícita (atribuindo alguma coisa a um elemento de array),
e funções de array definidas por meio de @code{:=} e @code{define}.
Arrays definidos por meio de @code{make_array} não estão incluídos.

Veja também
@code{array}, @code{arrayapply}, @code{arrayinfo}, @code{arraymake}, 
@code{fillarray}, @code{listarray}, e @code{rearray}.
@c IS THIS AN EXHAUSTIVE LIST ??

Exemplos:

@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 {Função} bashindices (@var{expr})
Transforma a expressão @var{expr} dando a cada
somatório e a cada produto um único índice.  Isso dá a @code{changevar} grande
precisão quando se está trabalhando com somatórios e produtos.  A forma do
único índice é @code{j@var{number}}.  A quantidade @var{number} é determindad por
referência a @code{gensumnum}, que pode ser alterada pelo utilizador.  Por
exemplo, @code{gensumnum:0$} reseta isso.

@end deffn

@deffn {Função} fillarray (@var{A}, @var{B})
Preenche o array @var{A} com @var{B}, que é uma lista ou um array.

Se um tipo específico for declarado para @var{A} no momento de sua criação,
@var{A} somente porde ser preenchido com elementos do tipo especificado;
Constitui um erro alguma tentativa feita para copiar um um elemento de um tipo diferente.
 
Se as dimensões dos arrays @var{A} e @var{B} forem
diferents, @var{A} é preenchido no ordem de maior fileira.  Se não existirem elementos
livres em @var{B} o último elemento é usado para preencher todo o 
resto de @var{A}.  Se existirem muitos , esses restantes seram ignorados.

@code{fillarray} retorna esse primeiro argumento.

Exemplos:

Create an array of 9 elements and fill it from a list.
@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

Quando existirem poucos elementos para preencher o array,
o último elemento é repetido.
Quando houverem muitos elementos,
os elementos extras são 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 multi-dimensionais são preenchidos em ordem de maior fileira.
@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 {Função} listarray (@var{A})
Retorna uma lista dos elementos do array @var{A}.
O argumento @var{A} pode ser um array declarado, um array não declarado (desordenado - hashed),
uma função de array, ou uma função com subscritos.

Elementos são listados em ordem de linha maior.
Isto é, elementos são ordenados conforme o primeiro índice, en seguida conforme o segundo índice, e assim sucessivamente.
A sequuência de ordenação por meio dos valores dos índices é a mesma ordem estabelecida por meio de @code{orderless}.

Para arrays não declarados , funções de arrays, e funções com subscritos,
os elementos correspondem aos valores de índice retornados através de @code{arrayinfo}.

Elemetos não associados de arrays genéricos declarados (isto é, não @code{fixnum} e não @code{flonum})
são retornados como @code{#####}.
Elementos não associados de arrays declarados @code{fixnum} ou @code{flonum}
são retornados como 0 ou 0.0, respectivamente.
Elementos não associados de arrays não declarados, funções de array,
e funções subscritas não são retornados.

Exemplos:

@code{listarray} e @code{arrayinfo} aplicados a um 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} e @code{arrayinfo} aplicadas a arrays não declarados (hashed - desordenados).

@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} e @code{arrayinfo} aplicada a uma função de 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} e @code{arrayinfo} aplicadas a funções com subscritos.

@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

@c NEEDS CLARIFICATION
@deffn {Função} make_array (@var{type}, @var{dim_1}, ..., @var{dim_n})
Cria e retorna um array de Lisp.  @var{type} pode
ser @code{any}, @code{flonum}, @code{fixnum}, @code{hashed} ou
@code{functional}.
Existem @math{n} indices,
e o @math{i}'enésimo indice está no intervalo de 0 a @math{@var{dim_i} - 1}.

A vantagem de @code{make_array} sobre @code{array} é que o valor de retorno não tem 
um nome, e uma vez que um ponteiro a ele vai, ele irá também.
Por exemplo, se @code{y: make_array (...)} então @code{y} aponta para um objecto 
que ocupa espaço, mas depois de @code{y: false}, @code{y} não mais
aponta para aquele objecto, então o objecto pode ser descartado.  

@c NEEDS CLARIFICATION HERE
@c 'FUNCTIONAL ARGUMENT IN MAKE_ARRAY APPEARS TO BE BROKEN
@c EVEN AFTER READING THE CODE (SRC/AR.LISP) I CAN'T TELL HOW THIS IS SUPPOSED TO WORK
@c COMMENTING OUT THIS STUFF TO PREVENT CONFUSION AND HEARTBREAK
@c RESTORE IT WHEN MAKE_ARRAY ('FUNCTIONAL, ...) IS FIXED
@c @code{y: make_array ('functional, 'f, 'hashed, 1)} - the second argument to
@c @code{make_array} in this case is the function to call to calculate array
@c elements, and the rest of the arguments are passed recursively to
@c @code{make_array} to generate the "memory" for the array function object.

Exemplos:
@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 {Função} rearray (@var{A}, @var{dim_1}, ..., @var{dim_n})
Altera as dimenções de um array.  
O novo array será preenchido com os elementos do antigo em
ordem da maior linha.  Se o array antigo era muito pequeno, 
os elementos restantes serão preenchidos com
@code{false}, @code{0.0} ou @code{0},
dependendo do tipo do array.  O tipo do array não pode ser
alterado.

@end deffn

@deffn {Função} remarray (@var{A_1}, ..., @var{A_n})
@deffnx {Função} remarray (all)
Remove arrays e funções associadas
a arrays e libera o espaço ocupado.
Os argumentos podem ser arrays declarados, arrays não declarados (dsordenados - hashed), funções de array functions, e funções com subscritos.

@code{remarray (all)} remove todos os ítens na lista global @code{arrays}.

@c WHAT DOES THIS MEAN EXACTLY ??
Isso pode ser necessário para usar essa função se isso é
desejado para redefinir os valores em um array desordenado.

@code{remarray} retorna a lista dos arrays removidos.

@end deffn
@deffn {Função} subvar (@var{x}, @var{i})
Avalia a expressão subscrita @code{@var{x}[@var{i}]}.

@code{subvar} avalia seus argumentos.

@code{arraymake (@var{x}, [@var{i}]} constrói a expressão @code{@var{x}[@var{i}]},
mas não a avalia.

Exemplos:

@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 $
@group
(%i3) subvar (x, i);
(%o3)                         foo
                                 3
@end group
(%i4) foo : [aa, bb, cc, dd, ee]$
@group
(%i5) subvar (x, i);
(%o5)                          cc
@end group
@group
(%i6) arraymake (x, [i]);
(%o6)                         foo
                                 3
@end group
@group
(%i7) ''%;
(%o7)                          cc
@end group
@end example

@end deffn

@c THIS IS REALLY CONFUSING
@defvr {Variável de pção} use_fast_arrays
- Se @code{true} somente dois tipos de arrays são reconhecidos.  

1) O array art-q (t no Lisp Comum) que pode ter muitas dimensões
indexadas por inteiros, e pode aceitar qualquer objecto do Lisp ou do Maxima como uma
entrada.  Para construir assim um array, insira @code{a:make_array(any,3,4);} 
então @code{a} terá como valor, um array com doze posições, e o 
índice é baseado em zero.

2) O array Hash_table que é o tipo padrão de array criado se um
faz @code{b[x+1]:y^2} (e @code{b} não é ainda um array, uma lista, ou uma
matriz -- se isso ou um desses ocorrer um erro pode ser causado desde
@code{x+1} não poderá ser um subscrito válido para um array art-q, uma lista ou
uma matriz).  Esses índices (também conhecidos como chaves) podem ser quaisquer objectos.  
Isso somente pega uma chave por vez a cada vez (@code{b[x+1,u]:y} ignorará o @code{u}).  
A referência termina em @code{b[x+1] ==> y^2}.  Certamente a chave poe ser uma lista
, e.g.  @code{b[[x+1,u]]:y} poderá ser válido.  Isso é incompatível 
com os arrays antigos do Maxima, mas poupa recursos.

Uma vantagem de armazenar os arrays como valores de símbolos é que as
convenções usuais sobre variáveis locais de uma função aplicam-se a arrays
também.  O tipo Hash_table também usa menos recursos e é mais eficiente
que o velho tipo hashar do Maxima.  Para obter comportamento consistente em
códigos traduzidos e compilados posicione @code{translate_fast_arrays} para ser
@code{true}.
 
@end defvr

