Modulo Collections.Array (F#)

Articolo
08/11/2011

Fornisce operazioni di base sulle matrici.

Percorso di spazio dei nomi/modulo: Microsoft.FSharp.Collections

Assembly: FSharp.Core (in FSharp.Core.dll)

module Array

Note

Per una panoramica delle matrici in F#, vedere Matrici (F#).

Valori

Value	Oggetto di descrizione
append : 'T [] -> 'T [] -> 'T []	Consente di creare una matrice che contiene gli elementi di una matrice seguita dagli elementi di un'altra matrice.
average : ^T [] -> ^T	Restituisce la media degli elementi in una matrice.
averageBy : ('T -> ^U) -> 'T [] -> ^U	Restituisce la media degli elementi generati applicando la funzione a ogni elemento di una matrice.
blit : 'T [] -> int -> 'T [] -> int -> int -> unit	Legge un intervallo di elementi da una matrice e scrive tale elementi in un'altra.
choose : ('T ->'U option) -> 'T [] -> 'U []	Consente di applicare una funzione specificata a ogni elemento di una matrice. Restituisce una matrice comprensiva dei risultati x per ogni elemento per cui la funzione restituisce Some(x).
collect : ('T -> 'U []) -> 'T [] -> 'U []	Consente di applicare la funzione fornita a ogni elemento di una matrice, concatena i risultati e restituisce la matrice combinata.
concat : seq<'T []> -> 'T []	Consente di creare una matrice che contiene gli elementi di ogni sequenza delle matrici fornite.
copy : 'T -> 'T []	Consente di creare una matrice che contiene gli elementi della matrice fornita.
create : int -> 'T -> 'T []	Crea una matrice i cui elementi sono inizialmente impostati sul valore fornito.
empty : 'T []	Restituisce una matrice vuota del tipo specificato.
exists : ('T -> bool) -> 'T [] -> bool	Verifica se qualche elemento di una matrice soddisfa il predicato fornito.
exists2 : ('T1 -> 'T2 -> bool) -> 'T1 [] -> 'T2 [] -> bool	Verifica se qualche coppia di elementi corrispondenti di due matrici soddisfa la condizione fornita.
fill : 'T [] -> int -> int -> 'T -> unit	Riempie un intervallo di elementi di una matrice con il valore fornito.
filter : ('T -> bool) -> 'T [] -> 'T []	Restituisce un insieme contenente i soli elementi della matrice fornita per cui la condizione fornita restituisce true.
find : ('T -> bool) -> 'T [] -> 'T	Restituisce il primo elemento per cui la funzione fornita restituisce true. Se tale elemento non esiste, viene generata l'eccezione KeyNotFoundException.
findIndex : ('T -> bool) -> 'T [] -> int	Restituisce l'indice del primo elemento in una matrice che soddisfa la condizione fornita. Genera l'eccezione KeyNotFoundException se nessun elemento soddisfa la condizione.
fold : ('State -> 'T -> 'State) -> 'State -> 'T [] -> 'State	Applica una funzione a ogni elemento di una matrice, eseguendo il threading di un argomento dell'accumulatore attraverso il calcolo. Se la funzione di input è f e gli elementi di matrice sono i0...iN, tale funzione calcola f (...(f s i0)...) iN.
fold2 : ('State -> 'T1 -> 'T2 -> 'State) -> 'State -> 'T1 [] -> 'T2 [] -> 'State	Applica una funzione alle coppie di elementi da due matrici fornite, da sinistra a destra, eseguendo il threading di un argomento dell'accumulatore attraverso il calcolo. La lunghezza delle due matrici di input deve essere uguale, altrimenti viene generata l'eccezione ArgumentException.
foldBack : ('T -> 'State -> 'State) -> 'T [] -> 'State -> 'State	Applica una funzione a ogni elemento di una matrice, eseguendo il threading di un argomento dell'accumulatore attraverso il calcolo. Se la funzione di input è f e gli elementi di matrice sono i0...iN, tale funzione calcola f i0 (...(f iN s)).
foldBack2 : ('T1 -> 'T2 -> 'State -> 'State) -> 'T1 [] -> 'T2 [] -> 'State -> 'State	Applica una funzione alle coppie di elementi da due matrici fornite, da destra a sinistra, eseguendo il threading di un argomento dell'accumulatore attraverso il calcolo. La lunghezza delle due matrici di input deve essere uguale, altrimenti viene generata l'eccezione ArgumentException.
forall : ('T -> bool) -> 'T [] -> bool	Verifica se tutti gli elementi di una matrice soddisfano la condizione fornita.
forall2 : ('T1 -> 'T2 -> bool) -> 'T1 [] -> 'T2 [] -> bool	Verifica se tutti gli elementi corrispondenti di due matrici fornite soddisfano una condizione fornita.
get : 'T [] -> int -> 'T	Ottiene un elemento da una matrice.
init : int -> (int -> 'T) -> 'T []	Utilizza una funzione fornita per creare una matrice della dimensione fornita.
isEmpty : 'T [] -> bool	Verifica se una matrice contiene elementi.
iter : ('T -> unit) -> 'T [] -> unit	Consente di applicare la funzione fornita a ogni elemento di una matrice.
iter2 : ('T1 -> 'T2 -> unit) -> 'T1 [] -> 'T2 [] -> unit)	Consente di applicare la funzione fornita a una coppia di elementi che deriva dagli indici corrispondenti in due matrici. La lunghezza delle due matrici deve essere uguale, altrimenti viene generata l'eccezione ArgumentException.
iteri : (int -> 'T -> unit) -> 'T [] -> unit	Consente di applicare la funzione fornita a ogni elemento di una matrice. Il numero intero passato alla funzione indica l'indice dell'elemento.
iteri2 : (int -> 'T1 -> 'T2 -> unit) -> 'T1 [] -> 'T2 [] -> unit	Consente di applicare la funzione fornita a una coppia di elementi che derivano da indici corrispondenti in due matrici, passando inoltre l'indice degli elementi. La lunghezza delle due matrici deve essere uguale, altrimenti viene generata l'eccezione ArgumentException.
length : 'T [] -> int	Restituisce la lunghezza di una matrice. La proprietà Length è analoga.
map : ('T -> 'U) -> 'T [] -> 'U []	Consente di creare una nuova matrice i cui elementi costituiscono il risultato ottenuto applicando la funzione a ciascun elemento della matrice fornita.
map2 : ('T1 -> 'T2 -> 'U) -> 'T1 [] -> 'T2 [] -> 'U []	Consente di creare una nuova matrice i cui elementi costituiscono il risultato ottenuto applicando la funzione fornita agli elementi corrispondenti delle due matrici fornite. La lunghezza delle due matrici di input deve essere uguale, altrimenti viene generata l'eccezione ArgumentException.
mapi : (int -> 'T -> 'U) -> 'T [] -> 'U []	Consente di creare una nuova matrice i cui elementi costituiscono il risultato ottenuto applicando la funzione a ciascun elemento della matrice fornita. Un indice intero passato alla funzione indica l'indice dell'elemento in corso di trasformazione.
mapi2 : (int -> 'T1 -> 'T2 -> 'U) -> 'T1 [] -> 'T2 [] -> 'U []	Crea una nuova matrice i cui elementi costituiscono il risultato ottenuto applicando la funzione fornita agli elementi corrispondenti dei due insiemi a livello pairwise, nonché passando l'indice degli elementi. La lunghezza delle due matrici di input deve essere uguale, altrimenti viene generata l'eccezione ArgumentException.
max : 'T [] -> 'T	Restituisce il più grande degli elementi di una matrice. Operators.max viene utilizzato per confrontare gli elementi.
maxBy : ('T -> 'U) -> 'T [] -> 'T	Restituisce il maggiore di tutti gli elementi della matrice, confrontato tramite Operators.max sul risultato della funzione.
min : ('T [] -> 'T	Restituisce il più piccolo degli elementi di una matrice. Operators.min viene utilizzato per confrontare gli elementi.
minBy : ('T -> 'U) -> 'T [] -> 'T	Restituisce il più piccolo degli elementi di una matrice. Operators.min viene utilizzato per confrontare gli elementi.
ofList : 'T list -> 'T []	Consente di creare una matrice dall'elenco fornito.
ofSeq : seq<'T> -> 'T []	Consente di creare una matrice dall'oggetto enumerabile specificato.
partizione : ('T -> bool) -> 'T [] -> 'T [] * 'T []	Suddivide una matrice in due matrici, una contenente gli elementi per cui la condizione fornita restituisce true e l'altra contenente gli elementi per cui restituisce false
permute : (int -> int) -> 'T [] -> 'T []	Permuta gli elementi di una matrice a secondo della permutazione specificata.
pick : ('T -> 'U option) -> 'T [] -> 'U	Consente di applicare la funzione fornita a elementi consecutivi di una matrice fornita, restituendo il primo risultato in cui la funzione restituisce Some(x) per alcuni valori x. Se la funzione non restituisce mai Some(x), viene generata l'eccezione KeyNotFoundException.
reduce : ('T -> 'T -> 'T) -> 'T [] -> 'T	Applica una funzione a ogni elemento di una matrice, eseguendo il threading di un argomento dell'accumulatore attraverso il calcolo. Se la funzione di input è f e gli elementi di matrice sono i0...iN, tale funzione calcola f (...(f i0 i1)...) iN. Se le dimensioni della matrice sono pari a zero, viene generata una eccezione ArgumentException.
reduceBack : ('T -> 'T -> 'T) -> 'T [] -> 'T	Applica una funzione a ogni elemento di una matrice, eseguendo il threading di un argomento dell'accumulatore attraverso il calcolo. Se la funzione di input è f e gli elementi sono i0...iN, questa funzione calcola f i0 (...(f iN-1 iN)). Se le dimensioni della matrice sono pari a zero, viene generata una eccezione ArgumentException.
rev : 'T [] -> 'T []	Consente di invertire l'ordine degli elementi in una matrice specificata.
scan : ('State -> 'T -> 'State) -> 'State -> 'T [] -> 'State [])	Si comporta come fold, ma restituisce i risultati intermedi insieme ai risultati finali.
scanBack : ('T -> 'State -> 'State) -> 'T [] -> 'State -> 'State []	Si comporta come foldBack, ma restituisce i risultati intermedi insieme ai risultati finali.
set : 'T [] -> int -> 'T -> unit	Imposta un elemento di una matrice.
sort : 'T[] -> 'T []	Ordina gli elementi di una matrice e ne restituisce una nuova. Operators.compare viene utilizzato per confrontare gli elementi.
sortBy : ('T -> 'Key) -> 'T [] -> 'T []	Ordina gli elementi di una matrice utilizzando la funzione fornita per trasformare gli elementi nel tipo sul quale l'operazione di ordinamento si basa e restituendo una nuova matrice. Operators.compare viene utilizzato per confrontare gli elementi.
sortInPlace : 'T [] -> unit	Ordina gli elementi di una matrice utilizzando la funzione di confronto fornita in modo da modificare la matrice sul posto. Operators.compare viene utilizzato per confrontare gli elementi.
sortInPlaceBy : ('T -> 'Key) -> 'T [] -> unit	Ordina gli elementi di una matrice modificando la matrice sul posto tramite la proiezione specificata per le chiavi. Operators.compare viene utilizzato per confrontare gli elementi.
sortInPlaceWith : ('T -> 'T -> int) -> 'T [] -> unit	Ordina gli elementi di una matrice utilizzando la funzione di confronto fornita in modo da modificare la matrice sul posto.
sortWith : ('T -> 'T -> int) -> 'T [] -> 'T []	Ordina gli elementi di una matrice utilizzando la funzione di confronto fornita e restituisce una nuova matrice.
sub : 'T [] -> int -> int -> 'T []	Consente di creare una matrice che contiene l'intervallo secondario fornito specificato dall'indice iniziale e dalla lunghezza.
sum : 'T [] -> ^T	Restituisce la somma degli elementi nella matrice.
sumBy : ('T -> ^U) -> 'T [] -> ^U	Restituisce la somma dei risultati generati applicando una funzione a ogni elemento di una matrice.
toList : 'T [] -> 'T list	Converte la matrice fornita in un elenco.
toSeq : 'T [] -> seq<'T>	Visualizza la matrice fornita come una sequenza.
tryFind : ('T -> bool) -> 'T [] -> 'T option	Restituisce il primo elemento nella matrice fornita per cui la funzione specificata restituisce true. Se tale elemento non esiste, restituisce None.
tryFindIndex : ('T -> bool) -> 'T [] -> int option	Restituisce l'indice del primo elemento in una matrice che soddisfa la condizione fornita.
tryPick : ('T -> 'U option) -> 'T [] -> 'U option	Consente di applicare la funzione fornita a elementi consecutivi della matrice fornita, e restituisce il primo risultato in cui la funzione restituisce Some(x) per alcuni valori x. Se la funzione non restituisce mai Some(x), viene restituito None.
unzip : ('T1 * 'T2) [] -> 'T1 [] * 'T2 []	Suddivide una matrice di coppie di tuple in una tupla di due matrici.
unzip3 : ('T1 * 'T2 * 'T3) [] -> 'T1 [] * 'T2 [] * 'T3 []	Suddivide una matrice di tuple di tre elementi in una tupla di tre matrici.
zeroCreate : int -> 'T []	Consente di creare una matrice i cui elementi sono inizialmente impostati sul valore predefinito Unchecked.defaultof<'T>.
zip : 'T1 [] -> 'T2 [] -> ('T1 * 'T2) []	Consente di combinare due matrici in una matrice di tuple che hanno due elementi. La lunghezza delle due matrici deve essere uguale, altrimenti viene generata l'eccezione ArgumentException.
zip3 : 'T1 [] -> 'T2 [] -> 'T3 [] -> ('T1 * 'T2 * 'T3) []	Consente di combinare tre matrici in una matrice di tuple che hanno tre elementi. La lunghezza delle tre matrici deve essere uguale, altrimenti viene generata un'eccezione ArgumentException.