26. Arrays e Tabelas

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Índice]

[ ? ]

26.1 Definições para Arrays e Tabelas

Função: array (name, dim_1, ..., dim_n)

Função: array (name, type, dim_1, ..., dim_n)

Função: array ([name_1, ..., name_m], dim_1, ..., dim_n)

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

array (name, dim_1, ..., dim_n) cria um array genérico.

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

array ([name_1, ..., name_m], dim_1, ..., dim_n) cria m arrays, todos da mesma dimensão.

Se o usuário 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 usuário 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, exceto para um array um tanto quanto esparso, é provavelmente mais eficiente declarar isso quando possível que deixar não declarado. A função array pode ser usada para transformar um array não declarado em um array declarado.

Função: arrayapply (A, [i_1, ..., i_n])

Avalia A [i_1, ..., i_n], quando A for um array e i_1, ..., i_n são inteiros.

Ela é remanescente de apply, exceto o primeiro argumento que é um array ao invés de uma função.

Função: arrayinfo (A): Retorna uma lista de informações sobre o array A. Para arrays desordenados ela retorna uma lista de hashed, o números de subscritos, e os subscritos de cada elemento que tem um valor. Para arrays declarados ela retorna uma lista de declared, o número de subscritos, e os limites que foram dados à função array quando ela foi chamada sobre A. Fazer example(arrayinfo); por exemplo.

Função: arraymake (name, [i_1, ..., i_n])

Retorna a expressão name [i_1, ..., i_n].

Isso é um código remanescente de funmake, exceto o valor retornado é um array de referência não avaliado ao invés de uma chamada de função não avaliada.

Variável de sistema: arrays

Valor padrão: []

arrays é uma lista de todas os arrays que foram alocadas, tanto declarados como não declarados.

Veja também array, arrayapply, arrayinfo, arraymake, fillarray, listarray, and rearray.

Função: bashindices (expr): Transforma a expressão expr dando a cada somatório e a cada produto um único índice. Isso dá a changevar grande precisão quando se está trabalhando com somatórios e produtos. A forma do único índice é jnumber. A quantidade number é determindad por referência a gensumnum, que pode ser alterada pelo usuário. Por exemplo, gensumnum:0$ reseta isso.

Função: fillarray (A, B)

Preenche o array A com B, que é uma lista ou um array.

Se A for um array de ponto flutuante (inteiro) então B poderá ser ou uma lista de números (inteiros) em ponto flutuante ou outro array em ponto flutuante (inteiro).

Se as dimensões do array forem diferentes A é preenchida na ordem da maior linha. Se não existem elementos livres em B o último elemento é usado para preencher todo o resto de A. Se existirem muitos os restantes serão descartados.

fillarray retorna esse primeiro argumento.

Função: listarray (A): Retorna uma lista dos elementos de um array declarado ou desordenado A. A ordem é da maior-linha. Elementos que não estão ainda definidos são representados por #####.

Função: make_array (type, dim_1, ..., dim_n)

Cria e retorna um array de Lisp. type pode ser any, flonum, fixnum, hashed ou functional. Existem n indices, e o i'enésimo indice está no intervalo de 0 a dim_i - 1.

A vantagem de make_array sobre 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 y: make_array (...) então y aponta para um objeto que ocupa espaço, mas depois de y: false, y não mais aponta para aquele objeto, então o objeto pode ser descartado.

y: make_array ('functional, 'f, 'hashed, 1) - o segundo argumento para make_array nesse caso é a função que chama o cálculo dos elementos do array, e os argumentos restantes são passados recursivamente a make_array para gerar a "memoria" para a função array objeto.

Função: rearray (A, dim_1, ..., 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 false, 0.0 ou 0, dependendo do tipo do array. O tipo do array não pode ser alterado.

Função: remarray (A_1, ..., A_n)

Função: remarray (all)

Remove arrays e funções associadas a arrays e libera o espaço ocupado.

remarray (all) remove todos os ítens na lista global arrays.

Isso pode ser necessário para usar essa função se isso é desejado para redefinir os valores em um array desordenado.

remarray retorna a lista dos arrays removidos.

Função: subvar (x, i)

Avalia a expressão subscrita x[i].

subvar avalia seus argumentos.

arraymake (x, [i] constrói a expressão x[i], mas não a avalia.

Exemplos:

(%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) +(%i6) arraymake (x, [i]);
(%o6) foo
 3
(%i7) ''%;
(%o7) +

Variável de pção: use_fast_arrays

- Se 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 objeto do Lisp ou do Maxima como uma entrada. Para construir assim um array, insira a:make_array(any,3,4); então 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 b[x+1]:y^2 (e b não é ainda um array, uma lista, ou uma matriz - se isso ou um desses ocorrer um erro pode ser causado desde 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 objetos. Isso somente pega uma chave por vez a cada vez (b[x+1,u]:y ignorará o u). A referência termina em b[x+1] ==> y^2. Certamente a chave poe ser uma lista , e.g. b[[x+1,u]]:y poderá ser válido. Isso é incompatível com os arrays antigos do Maxima, mas poupa recursos.