|
Structure Array
['ty array] é um array unidimensional com elementos do tipo 'ty, e que pode
ser alterado. Algumas funções trabalham com "um intervalo" (slice) de um array:
- O intervalo (a, i, SOME n) denota o subarray a[i..i+n-1]. Isto é,
a[i] é o primeiro elemento do intervalo, e n é o tamanho do intervalo.
Válido somente se 0 <= i <= i+n <= tamanho de a.
- O intervalo (a, i, NONE) denota o subarray a[i..length a-1]. Isto é,
o intervalo denota o sufixo do array começando em i. Válido somente
se 0 <= i <= tamanho de a. Equivalente a (a, i, SOME(length a - i)).
Intervalo
Significado
-----------------------------------------------------------------------------------------------
(a, 0, NONE) todo o array a[0..len-1]
(a, 0, SOME n) um subarray a esquerda (prefixo) a[0..n-1]
(a, i, NONE) um subarray a direita (sufixo) a[i..len-1]
(a, i, SOME n) um intervalo genérico a[i..i+n-1]
| Nome |
Tipo |
Efeito |
| maxLen |
int |
[maxLen] é o
número máximo de elementos em um array |
| array |
int * '_a -> '_a array |
[array (n,x)]
retorna um novo array de tamanho n cujos elementos são todos x |
| tabulate |
int * (int -> '_a) -> '_a
array |
[tabulate(n,f)]
retorna um novo array de tamanho n cujos elementos são f(0),
f(1),...,f(n-1), criado da esquerda para a direita |
| fromlist |
'_a list -> '_a array |
[fromList xs]
retorna uma array cujos elementos são os mesmos de xs |
| length |
'a array -> int |
[length a]
retorna o número de elementos de a |
| sub |
'a array * int -> 'a |
[sub (a,i)] retorna
o iésimo elemento de a, contando a partir de 0 |
| update |
'a array * int * 'a -> unit |
[update (a,i,x)] substitui o iésimo
elemento de a por x |
| extract |
'a array * int * int option ->
'a Vector.vector |
[extract (a,i,NONE)] retorna
um vetor de elementos a[i..length a-1]de a
[extract (v,i,SOME len)] retorna um vetor de
elementos a[i..i+len-1]de a |
| copy |
{src: 'a array, si: int, len: int option,
dst: 'a array, di: int} -> unit |
[copy(src,si,len,dst,di)] copia
o trecho (src,si,len) para dst, iniciando a partir do índice di; mais precisamente,
se len=NONE e n=length src, ele copia src[si..n-1] para dst[di..di+n-si]; se
len=SOME k, ele copia src[si..si+k-1] para dst[di..di+k-1]
|
| copyVec |
{src: 'a vector, si: int, len: int option,
dst: 'a array, di: int} ->unit |
[copyVec(src,si,len,dst,di)] copia
o trecho (src,si,len) para dst, iniciando a partir do índice di; mais
precisamente, se len=NONE e n=length src, ele copia src[si..n-1] para dst[di..di+n-si];
se len=SOME k, ele copia src[si..si+k-1] para dst[di..di+k-1]
|
| app |
('a -> unit ) -> 'a array
-> unit |
[app f a]
aplica f em a[j] para j variando de 0 a length a-1 |
| foldl |
('a * 'b -> 'b) -> 'b ->
'a array -> 'b |
[foldl f e a] aplica
a função f da esquerda para a direita da seguinte maneira:
f(a[len-1], f(a[len-2], ..., f(a[1], f(a[0], e)) ...)), onde "len" é o tamanho de a |
| foldr |
('a * 'b -> 'b) -> 'b ->
'a array -> 'b |
[foldr f e a]aplica
a função f da direita para a esquerda da seguinte maneira:
f(a[0], f(a[1], ..., f(a[len-2], f(a[len-1], e)) ...)), onde "len" é o tamanho de a |
| modify |
('a -> 'a) ->'a array
->unit |
[modify f a]
aplica f a a[j] e atualiza a[j] com
o resultado f(a[j]), para j=0,1,...,length a-1 |
| appi |
(int * 'a -> unit) -> 'a
array * int * int option -> unit |
[appi f (a, i, SOME n)]
aplica a função f a pares sucessivos(j, a[j]), para j=i,i+1,...,i+n-1
[appi f (a, i, NONE)] aplica a função f a pares
sucessivos (j, a[j]), para j=i,i+1,...,len-1 |
| foldli |
(int * 'a * 'b -> 'b) -> 'b
-> 'a array*int*int option -> 'b |
[foldli f e (a, i, SOME n)]
aplica a função f sobre o subarray a[i..i+n-1] da esquerda para a direita
da seguinte maneira f(i+n-1, a[i+n-1], f(..., f(i+1, a[i+1], f(i, a[i], e)) ...))
[foldli f e (a, i, NONE)] aplica a função f sobre o subarray
a[i..len-1] da esquerda para a direita da seguinte maneira f(len-1, a[len-1], f(..., f(i+1, a[i+1], f(i, a[i], e)) ...)) |
| foldri |
(int * 'a * 'b -> 'b) -> 'b
-> 'a array*int*int option -> 'b |
[foldri f e (a, i, SOME n)]
aplica a função f sobre o subarray a[i..i+n-1] da direita para a esquerda
da seguinte maneira f(i, a[i], f(i+1, a[i+1], ..., f(i+n-1, a[i+n-1], e) ...))
[foldri f e (a, i, NONE)] aplica a função f sobre o
subarray a[i..len-1] da direita para a esquerda da seguinte maneira
f(i, a[i], f(i+1, a[i+1], ..., f(len-1, a[len-1], e) ...)) |
| modifyi |
(int * 'a -> 'a) -> 'a
array * int * int option -> unit |
[modifyi f (a, i, SOME n)]
aplica a função f a (j, a[j]) e atualiza a[j] com o resultado
f(j, a[j]), para j=i,i+1,...,i+n-1
[modifyi f (a, i, NONE)] aplica a função f a (j, a[j])
e atualiza a[j] com o resultado f(j, a[j]), para j=i,i+1,...,len-1 |
[Bibliotecas Moscow ML]
[Manual Mosml]
 Comentários, dúvidas, sugestões, envie um mail para
Juliene ou para Isabel
|