[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
25.1 Definições para Arrays |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
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.
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.
Retorna informações sobre o array A. O argumento 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, arrayinfo
retorna uma lista
compreendendo o átomo 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 listarray
.
Para arrays não declarados (arrays que sofreram um hash),
arrayinfo
retorna uma lista compreendendo o átomo 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 listarray
.
Para funções de array,
arrayinfo
retretorna uma lista compreendendo o átomo 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 listarray
.
Para funções que possuem subscritos,
arrayinfo
retorna uma lista compreendendo o átomo 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 listarray
.
Examples:
arrayinfo
e listarray
aplicado a um 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
e listarray
aplicado a um array não declarado (no qual foi aplicado um hash).
(%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
e listarray
aplicado a uma função de 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
e listarray
aplicadas a funções com subscritos.
(%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 )] |
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.
Valor padrão: []
arrays
é uma lista dos arrays que tiverem sido alocados.
Essa lista compreende arrays declarados através de 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 :=
e define
.
Arrays definidos por meio de make_array
não estão incluídos.
Veja também
array
, arrayapply
, arrayinfo
, arraymake
,
fillarray
, listarray
, e rearray
.
Exemplos:
(%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] |
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.
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.
Retorna uma lista dos elementos do array A. O argumento 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 sequüência de ordenação por meio dos valores dos índices é a mesma ordem estabelecida por meio de 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 arrayinfo
.
Elemetos não associados de arrays genéricos declarados (isto é, não fixnum
e não flonum
)
são retornados como #####
.
Elementos não associados de arrays declarados fixnum
ou 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:
listarray
e arrayinfo
aplicados a um 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
e arrayinfo
aplicadas a arrays não declarados (hashed - desordenados).
(%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
e arrayinfo
aplicada a uma função de 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
e arrayinfo
aplicadas a funções com subscritos.
(%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]] |
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.
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.
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.
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.
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) + |
- 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.
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 translate_fast_arrays
para ser
true
.
[ << ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
This document was generated by root on Novembro, 10 2006 using texi2html 1.76.