Manual MosML
Juliene Lopes Gonzalez
Orientada por Isabel Harb Manssour
 

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]

 ../Imagens/EMBAN15.GIF (1469 bytes)

../Imagens/E-MAIL.JPG (3237 bytes) Comentários, dúvidas, sugestões, envie um mail para Juliene ou para Isabel

../Imagens/EMBAN15.GIF (1469 bytes)

Última alteração em 12 de Outubro de 2000.