@c
@c versao pt_BR baseada no md5sum abaixo:
@c 891f9d709b041d14d27e375d36e1fd01  Arrays.texi
@c
@c -----------------------------------------------------------------------------
@page
@node Arrays, Structures, Lists, Data Types and Structures
@section Arrays
@c -----------------------------------------------------------------------------

@menu
* Functions and Variables for Arrays::  
@end menu

@c -----------------------------------------------------------------------------
@node Functions and Variables for Arrays,  , Arrays, Arrays
@subsection Functions and Variables for Arrays
@c -----------------------------------------------------------------------------

@c -----------------------------------------------------------------------------
@anchor{array}
@deffn  {Fun@,{c}@~{a}o} array @
@fname{array} (@var{name}, @var{dim_1}, @dots{}, @var{dim_n}) @
@fname{array} (@var{name}, @var{type}, @var{dim_1}, @dots{}, @var{dim_n}) @
@fname{array} ([@var{name_1}, @dots{}, @var{name_m}], @var{dim_1}, @dots{}, @var{dim_n})

Cria um vetor est@'{a}tico @math{n}-dimensional.  O valor @math{n} pode ser menor ou equal a 5.
Os subscritos para a @math{i}'@'{e}sima dimens@~{a}o s@~{a}o os inteiros variando de 0 a
@var{dim_i}.

O comando @code{array (@var{nome}, @var{dim_1}, ..., @var{dim_n})} cria um vetor est@'{a}tico
gen@'{e}rico.

O comando @code{array (@var{nome}, @var{tipo}, @var{dim_1}, ..., @var{dim_n})} cria
um vetor est@'{a}tico, com elementos de um tipo espec@'{i}fico.  O @var{tipo} pode ser @code{fixnum}
para inteiros de tamanho limitado ou @code{flonum} para n@'{u}meros em ponto flutuante.

O comando @code{array ([@var{nome_1}, ..., @var{nome_m}], @var{dim_1}, ..., @var{dim_n})}
cria @math{m} vetores est@'{a}ticos, todos de mesma dimens@~{a}o.
@c SAME TYPE AS WELL ??

@c THIS DISCUSSION OF UNDECLARED ARRAYS REALLY WANTS TO BE SOMEWHERE ELSE
Se o usu@'{a}rio coloca um valor em uma vari@'{a}vel de subscrito antes de declarar o
vetor est@'{a}tico que a vai usar, um vetor est@'{a}tico n@~{a}o declarado @'{e} criado.
Vetores est@'{a}ticos n@~{a}o declarados, tamb@'{e}m conhecidos como vetor est@'{a}tico adapt@'{a}vel (por que a adapta@,{c}@~{a}o
@'{e} feita sobre os subscritos), s@~{a}o mais gerais que vetores est@'{a}ticos
declarados.  O usu@'{a}rio n@~{a}o declara seu tamanho m@'{a}ximo, e eles crescem
dinamicamente sendo ajustados @`{a} medida que mais elementos do vetor est@'{a}tico recebem valores.  Os
subscritos de vetores est@'{a}ticos n@~{a}o declarados n@~{a}o precisam nem mesmo ser n@'{u}meros.  Todavia,
a menos que um vetor est@'{a}tico seja muito rarefeito, @'{e} provavelmente mais eficiente
declarar o vetor est@'{a}tico assim que for poss@'{i}vel que continuar o vetor est@'{a}tico como n@~{a}o declarado.  A fun@,{c}@~{a}o
@code{array} pode ser usada para transformar um vetor est@'{a}tico n@~{a}o declarado e um vetor est@'{a}tico
declarado.
@c HOW DOES ONE CHANGE AN UNDECLARED ARRAY INTO A DECLARED ARRAY EXACTLY ??

@opencatbox
@category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{arrayapply}
@deffn {Fun@,{c}@~{a}o} arrayapply (@var{A}, [@var{i_1}, @dots{}, @var{i_n}])

Avalia @code{@var{A} [@var{i_1}, ..., @var{i_n}]},
onde @var{A} @'{e} um vetor est@'{a}tico e @var{i_1}, @dots{}, @var{i_n} s@~{a}o inteiros.

@'{E} um clone de @mrefcomma{apply}
com a exce@,{c}@~{a}o de que o primeiro argumento @'{e} um vetor est@'{a}tico
ao inv@'{e}s de uma fun@,{c}@~{a}o.

@opencatbox
@category{Express@~{o}es} @category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{arrayinfo}
@deffn {Fun@,{c}@~{a}o} arrayinfo (@var{A})

Retorna informa@,{c}@~{o}es sobre o vetor est@'{a}tico @var{A}.
O argumento @var{A} pode ser um vetor est@'{a}tico declarado, um vetor est@'{a}tico n@~{a}o declarado (cresce por ajuste),
uma fun@,{c}@~{a}o de vetor est@'{a}tico, ou uma fun@,{c}@~{a}o de subscrito.

Para vetores est@'{a}ticos declarados, @code{arrayinfo} retorna uma lista compreendendo o @'{a}tomo
@code{declared}, o n@'{u}mero de dimens@~{o}es, e o tamanhode cada dimens@~{a}o.
Os elementos do vetor est@'{a}tico, associados ou n@~{a}o, s@~{a}o retornados atrav@'{e}s de
@code{listarray}.

Para vetores est@'{a}ticos n@~{a}o declarados (hashed arrays), @code{arrayinfo} retorna uma lista
compreendendo o @'{a}tomo @code{hashed}, o n@'{u}mero de subscritos,
e os subscritos de todo elemento que tem um valor.
Os valores s@~{a}o retornados por @code{listarray}.

Quando o argumento de @var{A} for do tipo fun@,{c}@~{a}o de vetor est@'{a}tico, @code{arrayinfo} retorna uma lista que compreende o @'{a}tomo
@code{hashed}, o n@'{u}mero de subscritos,
e quaisquer valores de subscrito para os quais hoverem valores armazenados de fun@,{c}@~{a}o.
Os valores armazenados de fun@,{c}@~{a}o s@~{a}o retornados atrav@'{e}s da @code{listarray}.

Quando o argumento de @var{A} for do tipo fun@,{c}@~{a}o subscrita, @code{arrayinfo} retorna uma lista compreendendo o @'{a}tomo
@code{hashed}, o n@'{u}mero de subscritos,
e quaisquer valores de subscrito para os quais houverem express@~{o}es lambda.
As express@~{o}es lambda s@~{a}o retornadas atrav@'{e}s de @code{listarray}.

Veja tamb@'{e}m @mrefdot{listarray}

Exemplos:

A @code{arrayinfo} e a @code{listarray} aplicadas a um vetor est@'{a}tico 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
@group
(%i1) array (aa, 2, 3);
(%o1)                          aa
@end group
@group
(%i2) aa [2, 3] : %pi;
(%o2)                          %pi
@end group
@group
(%i3) aa [1, 2] : %e;
(%o3)                          %e
@end group
@group
(%i4) arrayinfo (aa);
(%o4)                 [declared, 2, [2, 3]]
@end group
@group
(%i5) listarray (aa);
(%o5) [#####, #####, #####, #####, #####, #####, %e, #####, 
                                        #####, #####, #####, %pi]
@end group
@end example

A @code{arrayinfo} e a @code{listarray} aplicadas a vetor est@'{a}tico n@~{a}o declarado (hashed).

@c ===beg===
@c bb [QUALQUERCOISA] : (a + b)^2;
@c bb [OUTRACOISA] : (c - d)^3;
@c arrayinfo (bb);
@c listarray (bb);
@c ===end===
@example
@group
(%i1) bb [QUALQUERCOISA] : (a + b)^2;
                                   2
(%o1)                       (b + a)
@end group
@group
(%i2) bb [OUTRACOISA] : (c - d)^3;
                                   3
(%o2)                       (c - d)
@end group
@group
(%i3) arrayinfo (bb);
(%o3)               [hashed, 1, [OUTRACOISA], [QUALQUERCOISA]]
@end group
@group
(%i4) listarray (bb);
                              3         2
(%o4)                 [(c - d) , (b + a) ]
@end group
@end example

A @code{arrayinfo} e a @code{listarray} aplicadas a uma fun@,{c}@~{a}o de vetor est@'{a}tico.

@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
@group
(%i1) cc [x, y] := y / x;
                                     y
(%o1)                      cc     := -
                             x, y    x
@end group
@group
(%i2) cc [u, v];
                                v
(%o2)                           -
                                u
@end group
@group
(%i3) cc [4, z];
                                z
(%o3)                           -
                                4
@end group
@group
(%i4) arrayinfo (cc);
(%o4)              [hashed, 2, [4, z], [u, v]]
@end group
@group
(%i5) listarray (cc);
                              z  v
(%o5)                        [-, -]
                              4  u
@end group
@end example

A @code{arrayinfo} e a @code{listarray} aplicadas a uma fun@,{c}@~{a}o de subscrito.

@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
@group
(%i1) dd [x] (y) := y ^ x;
                                     x
(%o1)                     dd (y) := y
                            x
@end group
@group
(%i2) dd [a + b];
                                    b + a
(%o2)                  lambda([y], y     )
@end group
@group
(%i3) dd [v - u];
                                    v - u
(%o3)                  lambda([y], y     )
@end group
@group
(%i4) arrayinfo (dd);
(%o4)             [hashed, 1, [b + a], [v - u]]
@end group
@group
(%i5) listarray (dd);
                         b + a                v - u
(%o5)      [lambda([y], y     ), lambda([y], y     )]
@end group
@end example

@opencatbox
@category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{arraymake}
@deffn {Fun@,{c}@~{a}o} arraymake (@var{A}, [@var{i_1}, @dots{}, @var{i_n}])

Retorna a express@~{a}o @code{@var{A}[@var{i_1}, ..., @var{i_n}]}.
O resultado @'{e} uma refer@^{e}ncia de vetor est@'{a}tico n@~{a}o declarado.

A @code{arraymake} @'{e} semelhante a @mrefcomma{funmake}
exceto que o valor de retorno
@'{e} uma referencia de vetor est@'{a}tico n@~{a}o declarado ao inv@'{e}s de uma chamada de fun@,{c}@~{a}o n@~{a}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
@group
(%i1) arraymake (A, [1]);
(%o1)                          A
                                1
@end group
@group
(%i2) arraymake (A, [k]);
(%o2)                          A
                                k
@end group
@group
(%i3) arraymake (A, [i, j, 3]);
(%o3)                       A
                             i, j, 3
@end group
@group
(%i4) array (A, fixnum, 10);
(%o4)                           A
@end group
@group
(%i5) fillarray (A, makelist (i^2, i, 1, 11));
(%o5)                           A
@end group
@group
(%i6) arraymake (A, [5]);
(%o6)                          A
                                5
@end group
@group
(%i7) ''%;
(%o7)                          36
@end group
@group
(%i8) L : [a, b, c, d, e];
(%o8)                    [a, b, c, d, e]
@end group
@group
(%i9) arraymake ('L, [n]);
(%o9)                          L
                                n
@end group
@group
(%i10) ''%, n = 3;
(%o10)                          c
@end group
@group
(%i11) A2 : make_array (fixnum, 10);
(%o11)          @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
@end group
@group
(%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)@}
@end group
@group
(%i13) arraymake ('A2, [8]);
(%o13)                         A2
                                 8
@end group
@group
(%i14) ''%;
(%o14)                          9
@end group
@end example

@opencatbox
@category{Express@~{o}es} @category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{arrays}
@defvr {Vari@'{a}vel de sistema} arrays
Valor padr@~{a}o: @code{[]}

A vari@'{a}vel de sistema @code{arrays} @'{e} uma lista de vetores est@'{a}ticos que tenha sido alocados.
Essa lista compreende vetores est@'{a}ticos declarados por @code{array}, vetores est@'{a}ticos adapt@'{a}veis constru@'{i}dos por
defini@,{c}@~{a}o inpl@'{i}cita (atribuindo alguma coisa ao elemento do vetor est@'{a}tico),
e fun@,{c}@~{o}es de vetor est@'{a}tico definidas por @code{:=} e por @code{define}.
Vetores est@'{a}ticos definidos por @mref{make_array}
n@~{a}o est@~{a}o incl@'{i}dos.

Veja tamb@'{e}m
@mrefcomma{array} @mrefcomma{arrayapply} @mrefcomma{arrayinfo}
@w{} @mrefcomma{arraymake} @mrefcomma{fillarray} @mrefcomma{listarray}
e @mrefdot{rearray}
@c IS THIS AN EXHAUSTIVE LIST ??

Exemplos:

@c ===beg===
@c array (aa, 5, 7);
@c bb [QUALQUERCOISA] : (a + b)^2;
@c cc [x] := x/100;
@c dd : make_array ('any, 7);
@c arrays;
@c ===end===
@example
@group
(%i1) array (aa, 5, 7);
(%o1)                          aa
@end group
@group
(%i2) bb [QUALQUERCOISA] : (a + b)^2;
                                   2
(%o2)                       (b + a)
@end group
@group
(%i3) cc [x] := x/100;
                                   x
(%o3)                      cc  := ---
                             x    100
@end group
@group
(%i4) dd : make_array ('any, 7);
(%o4)       @{Array:  #(NIL NIL NIL NIL NIL NIL NIL)@}
@end group
@group
(%i5) arrays;
(%o5)                     [aa, bb, cc]
@end group
@end example

@opencatbox
@category{Vetores est@'{a}ticos} @category{Vari@'{a}veis globais}
@closecatbox
@end defvr

@c -----------------------------------------------------------------------------
@anchor{arraysetapply}
@deffn {Fun@,{c}@~{a}o} arraysetapply (@var{A}, [@var{i_1}, @dots{}, @var{i_n}], @var{x})

Atribui o mesmo valor @var{x} a todos do @code{@var{A}[@var{i_1}, ..., @var{i_n}]},
onde @var{A} @'{e} um vetor est@'{a}tico e @var{i_1}, @dots{}, @var{i_n} s@~{a}o inteiros.

A fun@,{c}@~{a}o @code{arraysetapply} avalia seus argumentos.

@opencatbox
@category{Express@~{o}es} @category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{fillarray}
@deffn {Fun@,{c}@~{a}o} fillarray (@var{A}, @var{B})

Preenche o vetor est@'{a}tico @var{A} a partir de @var{B}, que @'{e} uma lista ou um vetor est@'{a}tico.

Se um tipo espec@'{i}fico for declarado para @var{A} quando ele tiver sido criado,
o vetor est@'{a}tico @var{A} pode somente ser preenchido com elementos daquele mesmo tipo especificado durante a cria@,{c}@~{a}o;
Constitui um erro se uma tentativa for feita paa copiar um elemento de tipo diferentes.

Se as dimens@~{o}es dos vetores est@'{a}ticos @var{A} e @var{B} forem
diferentes, @var{A} @'{e} preenchido seguindo a ordem principal por linha 
@footnote{Nota do tradutor: o primeiro elemento de cada linha a partir 
da segunda @'{e} preenchido ap@'{o}s o @'{u}ltimo elemento da linha que a precede ser 
preenchido. Na ordem principal por coluna o primeiro elemento de cada coluna a partir 
da segunda @'{e} preenchido ap@'{o}s o @'{u}ltimo elemento da coluna que a precede ser 
preenchido.}.  Se n@~{a}o ouverem elementos
suficientes em @var{B} o @'{u}ltimo elemento @'{e} usado para preencher o
restante de @var{A}.  Se ouverem elementos demais, os que sobrarem ser@~{a}o igonorados.

A fun@,{c}@~{a}o @code{fillarray} returns its first argument.

Exemplos:

Cria um vetor est@'{a}tico de 9 elementos e preenche-o a partir de uma 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
@group
(%i1) array (a1, fixnum, 8);
(%o1)                          a1
@end group
@group
(%i2) listarray (a1);
(%o2)              [0, 0, 0, 0, 0, 0, 0, 0, 0]
@end group
@group
(%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
(%o3)                          a1
@end group
@group
(%i4) listarray (a1);
(%o4)              [1, 2, 3, 4, 5, 6, 7, 8, 9]
@end group
@end example

Quando ouverem elementos a menos para preencher o vetor est@'{a}tico,
o @'{u}ltimo elemento @'{e} repetido.
Quando ouverem elementos a mais para preencher o vetor est@'{a}tico,
os elementos extras s@~{a}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
@group
(%i1) a2 : make_array (fixnum, 8);
(%o1)             @{Array:  #(0 0 0 0 0 0 0 0)@}
@end group
@group
(%i2) fillarray (a2, [1, 2, 3, 4, 5]);
(%o2)             @{Array:  #(1 2 3 4 5 5 5 5)@}
@end group
@group
(%i3) fillarray (a2, [4]);
(%o3)             @{Array:  #(4 4 4 4 4 4 4 4)@}
@end group
@group
(%i4) fillarray (a2, makelist (i, i, 1, 100));
(%o4)             @{Array:  #(1 2 3 4 5 6 7 8)@}
@end group
@end example

/vetores est@'{a}ticos multidimensionais s@~{a}o preenchidos na ordem principal por linha.

@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
@group
(%i1) a3 : make_array (fixnum, 2, 5);
(%o1)        @{Array:  #2A((0 0 0 0 0) (0 0 0 0 0))@}
@end group
@group
(%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))@}
@end group
@group
(%i3) a4 : make_array (fixnum, 5, 2);
(%o3)     @{Array:  #2A((0 0) (0 0) (0 0) (0 0) (0 0))@}
@end group
@group
(%i4) fillarray (a4, a3);
(%o4)     @{Array:  #2A((1 2) (3 4) (5 6) (7 8) (9 10))@}
@end group
@end example

@opencatbox
@category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{listarray}
@deffn {Fun@,{c}@~{a}o} listarray (@var{A})

Retorna uma lista dos elementos de vetor est@'{a}tico @var{A}.
O argumento @var{A} pode ser um vetor est@'{a}tico declarado, um vetor est@'{a}tico n@~{a}o declarado (desordenado),
uma fun@,{c}@~{a}o de vetor est@'{a}tico, ou uma fun@,{c}@~{a}o de sobrescrito.

Elementos s@~{a}o listados seguindo a ordem principal por linha.
Isto @'{e}, elementos s@~{a}o ordenados conforme o primeiro @'{i}ndice, a seguir conforme
o segundo @'{i}ndice, e assim por diante.  A sequ@^{e}ncia de ordena@,{c}@~{a}o dos valores de @'{i}ndice @'{e} a mesma que
a ordem estabelecida por @mrefdot{orderless}

Para vetores est@'{a}ticos n@~{a}o declarados, fun@,{c}@~{o}es de vetor est@'{a}tico, e fun@,{c}@~{o}es de subscrito,
os elementos correspondem aos valores de @'{i}ndice retornados por @mrefdot{arrayinfo}

Elementos n@~{a}o associados de vetores est@'{a}ticos gerais declarados (isto @'{e}, n@~{a}o @code{fixnum} e n@~{a}o
@code{flonum}) s@~{a}o retornados como @code{#####}.
Elementos n@~{a}o associados de vetores est@'{a}ticos declarados do tipo @code{fixnum} ou @code{flonum} 
s@~{a}o retornados como 0 ou como 0.0, respectivamente.
Elementos n@~{a}o associados de vetores est@'{a}ticos n@~{a}o declarados, fun@,{c}@~{o}es de vetor est@'{a}tico,
e fun@,{c}@~{o}es de subscrito n@~{a}o s@~{a}p retornados.

Exemplos:

A @code{listarray} e a @code{arrayinfo} aplicadas a um vetor est@'{a}tico 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
@group
(%i1) array (aa, 2, 3);
(%o1)                          aa
@end group
@group
(%i2) aa [2, 3] : %pi;
(%o2)                          %pi
@end group
@group
(%i3) aa [1, 2] : %e;
(%o3)                          %e
@end group
@group
(%i4) listarray (aa);
(%o4) [#####, #####, #####, #####, #####, #####, %e, #####, 
                                        #####, #####, #####, %pi]
@end group
@group
(%i5) arrayinfo (aa);
(%o5)                 [declared, 2, [2, 3]]
@end group
@end example

A @code{listarray} e a @code{arrayinfo} aplicadas a vetores est@'{a}ticos n@~{a}o declarados (desordenado).

@c ===beg===
@c bb [QUALQUERCOISA] : (a + b)^2;
@c bb [OUTRACOISA] : (c - d)^3;
@c listarray (bb);
@c arrayinfo (bb);
@c ===end===
@example
@group
(%i1) bb [QUALQUERCOISA] : (a + b)^2;
                                   2
(%o1)                       (b + a)
@end group
@group
(%i2) bb [OUTRACOISA] : (c - d)^3;
                                   3
(%o2)                       (c - d)
@end group
@group
(%i3) listarray (bb);
                              3         2
(%o3)                 [(c - d) , (b + a) ]
@end group
@group
(%i4) arrayinfo (bb);
(%o4)               [hashed, 1, [OUTRACOISA], [QUALQUERCOISA]]
@end group
@end example

A @code{listarray} e a @code{arrayinfo} aplicadas a uma fun@,{c}@~{a}o de vetor est@'{a}tico.

@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
@group
(%i1) cc [x, y] := y / x;
                                     y
(%o1)                      cc     := -
                             x, y    x
@end group
@group
(%i2) cc [u, v];
                                v
(%o2)                           -
                                u
@end group
@group
(%i3) cc [4, z];
                                z
(%o3)                           -
                                4
@end group
@group
(%i4) listarray (cc);
                              z  v
(%o4)                        [-, -]
                              4  u
@end group
@group
(%i5) arrayinfo (cc);
(%o5)              [hashed, 2, [4, z], [u, v]]
@end group
@end example

A @code{listarray} e a @code{arrayinfo} aplicadas a uma fun@,{c}@~{a}o de 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
@group
(%i1) dd [x] (y) := y ^ x;
                                     x
(%o1)                     dd (y) := y
                            x
@end group
@group
(%i2) dd [a + b];
                                    b + a
(%o2)                  lambda([y], y     )
@end group
@group
(%i3) dd [v - u];
                                    v - u
(%o3)                  lambda([y], y     )
@end group
@group
(%i4) listarray (dd);
                         b + a                v - u
(%o4)      [lambda([y], y     ), lambda([y], y     )]
@end group
@group
(%i5) arrayinfo (dd);
(%o5)             [hashed, 1, [b + a], [v - u]]
@end group
@end example

@opencatbox
@category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c NEEDS CLARIFICATION

@c -----------------------------------------------------------------------------
@anchor{make_array}
@deffn {Fun@,{c}@~{a}o} make_array (@var{tipo}, @var{dim_1}, @dots{}, @var{dim_n})

Cria e retorna um vetor est@'{a}tico de Lisp.  O @var{tipo} pode
ser @code{any}, @code{flonum}, @code{fixnum}, @code{hashed} ou 
@code{functional}.
Exitem @math{n} @'{i}ndices,
e o @math{i}'-@'{e}simo @'{i}ndice vai de 0 a @math{@var{dim_i} - 1}.

A vantagem de @code{make_array} sobre @mref{array}
@'{e} que o valor de retorno
n@~{a}o tem um nome, e uma vez que um apontador para @code{make_array} se propaga, @code{make_array} ir@'{a} tambẽm se propagar.
Por exemplo, se @code{y: make_array (...)} ent@~{a}o @code{y} aponta para um objeto 
que ocupa espa@,{c}o, mas ap@'{o}s @code{y: false}, @code{y} n@~{a}o mais
aponta para aquele objeto, ent@~{a}o o objeto pode ser apagado e seu espa@,{c}o de mem@'{o}ria liberado.

@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
@group
(%i1) A1 : make_array (fixnum, 10);
(%o1)           @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
@end group
@group
(%i2) A1 [8] : 1729;
(%o2)                         1729
@end group
@group
(%i3) A1;
(%o3)          @{Array:  #(0 0 0 0 0 0 0 0 1729 0)@}
@end group
@group
(%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)@}
@end group
@group
(%i5) A2 [2] : 2.718281828;
(%o5)                      2.718281828
@end group
@group
(%i6) A2;
(%o6) 
     @{Array:  #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
@end group
@group
(%i7) A3 : make_array (any, 10);
(%o7) @{Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)@}
@end group
@group
(%i8) A3 [4] : x - y - z;
(%o8)                      - z - y + x
@end group
@group
(%i9) A3;
(%o9) @{Array:  #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
 -1 $Y) ((MTIMES SIMP) -1 $Z))
  NIL NIL NIL NIL NIL)@}
@end group
@group
(%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)))@}
@end group
@group
(%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)))@}
@end group
@group
(%i12) A4 [0, 2, 1];
(%o12)                         12
@end group
@end example

@opencatbox
@category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c DOES THIS MODIFY A OR DOES IT CREATE A NEW ARRAY ??

@c -----------------------------------------------------------------------------
@anchor{rearray}
@deffn {Fun@,{c}@~{a}o} rearray (@var{A}, @var{dim_1}, @dots{}, @var{dim_n})

Muda a dimens@~{a}o de um vetor est@'{a}tico.
O novo vetor est@'{a}tico ser@'{a} preenchido com os elementos do antigo na
ordem principal por linha.  Se o antigo for muito pequeno, 
os restantes elementos s@~{a}o preenchidos com
@code{false}, @code{0.0} ou @code{0},
dependendo do tipo de declara@,{c}@~{a}o do veor est@'{a}tico que est@'{a} sendo modificado.  O tipo de vetor est@'{a}tico n@~{a}o pode ser
modificado.

@opencatbox
@category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{remarray}
@deffn  {Fun@,{c}@~{a}o} remarray @
@fname{remarray} (@var{A_1}, @dots{}, @var{A_n}) @
@fname{remarray} (all)

Remove vetores est@'{a}ticos e fun@,{c}@~{o}es associadas a vetores est@'{a}ticos associados e libera o espa@,{c}o de armazenamento usado.
Os argumentos podem ser vetores est@'{a}ticos declarados, n@~{a}o declarados (desordenados), fun@,{c}@~{o}es de vetores
est@'{a}ticos, e fn@,{c}@~{o}es de subscritos.

O comando @code{remarray (all)} remove todos os itens na lista global @mrefdot{arrays}

@c WHAT DOES THIS MEAN EXACTLY ??
Pode ser necess@'{a}rio usar essa fun@,{c}@~{a}o se for
desejado redefinir os valores em um vetor est@'{a}tico desordenado.

A @code{remarray} retorna uma lista dos vetores est@'{a}ticos removidos.

A @code{remarray} n@~{a}o avalia seus argumentos.

@opencatbox
@category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c -----------------------------------------------------------------------------
@anchor{subvar}
@deffn {Fun@,{c}@~{a}o} subvar (@var{x}, @var{i})

Avalia a express@~{a}o de subscrito @code{@var{x}[@var{i}]}.

A @code{subvar} avalia seus argumentos.

O comando @code{arraymake (@var{x}, [@var{i}])} constr@'{o}i a express@~{a}o
@code{@var{x}[@var{i}]}, mas n@~{a}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

@opencatbox
@category{Express@~{o}es} @category{Vetores est@'{a}ticos}
@closecatbox
@end deffn

@c NEEDS EXPANSION AND EXAMPLES

@c -----------------------------------------------------------------------------
@anchor{subvarp}
@deffn {Fun@,{c}@~{a}o} subvarp (@var{expr})

Returna @code{true} se @var{expr} for uma vari@'{a}vel de subscrito, por exemplo
@code{a[i]}.

@opencatbox
@category{Fun@,{c}@~{o}es predicado}
@closecatbox
@end deffn

@c THIS IS REALLY CONFUSING

@c -----------------------------------------------------------------------------
@anchor{use_fast_arrays}
@defvr {Vari@'{a}vel de op@,{c}@~{a}o} use_fast_arrays

Se @code{true} ent@~{a}o somente dois tipos de vetores est@'{a}ticos s@~{a}o reconhecidos:

@enumerate
@item
O vetor est@'{a}tico art-q (t no "Common Lisp") que pode ter muitas dimens@~{o}es
indexadas por inteiros, e pode conter qualquer objeto do Lisp ou do Maxima como uma
entrada.  Para construir tal vetor est@'{a}tico, insira @code{a:make_array(any,3,4);} 
ent@~{a}o @code{a} ter@'{a} como valor, um vetor est@'{a}tico com 12 posi@,{c}@~{o}es, e o 
primeiro @'{i}ndice @'{e} o inteiro zero.

@item
O vetor est@'{a}tico Hash_table que o tipo padr@~{a}o de vetor est@'{a}tico criado ao
se fazer @code{b[x+1]:y^2} (e se @code{b} j@'{a} n@~{a}o for um vetor est@'{a}tico, uma lista, ou uma
matriz -- se @code{b} for um desses um erro pode ser retornado uma vez que
@code{x+1} pode n@~{a}o ser um subscrito v@'{a}lido para um vetor est@'{a}tico art-q, uma lista ou
uma matriz).  Seus @'{i}ndices (tamb@'{e}m conhecidos como chaves) podem ser quaisquer objetos.
O vetor est@'{a}tico Hash_table somente recebe uma chave de cada vez (@code{b[x+1,u]:y} pode ignorar @code{u}).
O referenciamento @'{e} feito por @code{b[x+1] ==> y^2}.  Certamente a chave pode ser
uma lista, e.g. @code{b[[x+1,u]]:y} pode ser v@'{a}lido.  @'{E} incompat@'{i}vel 
com os antigos vetores est@'{a}ticos desordenados do Maxima, mas poupa recursos.
@end enumerate

Uma vantagem de armazenar os vetores est@'{a}ticos como valores do s@'{i}mbolo @'{e} que
as conven@,{c}@~{o}es usuais sobre vari@'{a}veis locais de uma fun@,{c}@~{a}o aplicam-se ao vetor est@'{a}tico
tamb@'{e}m.  O tipo Hash_table tambẽm usa menos recursos e @'{e} mais eficiente
que o tipo antigo de hashar do Maxima.  Para obter comportamento consistente em
c@'{o}digos traduzidos e compilados provenientes das vers@~{o}es antigas ajuste @code{translate_fast_arrays} para
@code{true}.

@opencatbox
@category{Vetores est@'{a}ticos} @category{Global flags}
@closecatbox
@end defvr

