F # - Matrici
Gli array sono raccolte di dimensioni fisse, in base zero e modificabili di elementi di dati consecutivi che sono tutti dello stesso tipo.
Creazione di array
È possibile creare array utilizzando varie sintassi e modi o utilizzando le funzioni dal modulo Array. In questa sezione, discuteremo la creazione di array senza utilizzare le funzioni del modulo.
Esistono tre modi sintattici per creare array senza funzioni:
- Elencando valori consecutivi compresi tra [| e |] e separati da punto e virgola.
- Mettendo ogni elemento su una riga separata, nel qual caso il separatore punto e virgola è facoltativo.
- Utilizzando espressioni di sequenza.
È possibile accedere agli elementi dell'array utilizzando un operatore punto (.) E parentesi ([e]).
L'esempio seguente mostra la creazione di array:
//using semicolon separator
let array1 = [| 1; 2; 3; 4; 5; 6 |]
for i in 0 .. array1.Length - 1 do
printf "%d " array1.[i]
printfn" "
// without semicolon separator
let array2 =
[|
1
2
3
4
5
|]
for i in 0 .. array2.Length - 1 do
printf "%d " array2.[i]
printfn" "
//using sequence
let array3 = [| for i in 1 .. 10 -> i * i |]
for i in 0 .. array3.Length - 1 do
printf "%d " array3.[i]
printfn" "Quando compili ed esegui il programma, restituisce il seguente output:
1 2 3 4 5 6
1 2 3 4 5
1 4 9 16 25 36 49 64 81 100Operazioni di base sugli array
Il modulo libreria Microsoft.FSharp.Collections.Array supporta operazioni su array unidimensionali.
La tabella seguente mostra le operazioni di base sugli array:
| Valore | Descrizione |
|---|---|
| aggiungi: 'T [] →' T [] → 'T [] | Crea un array che contiene gli elementi di un array seguito dagli elementi di un altro array. |
| media: ^ T [] → ^ T | Restituisce la media degli elementi in una matrice. |
| mediaBy: ('T → ^ U) →' T [] → ^ U | Restituisce la media degli elementi generati applicando una funzione a ogni elemento di un array. |
| blit: 'T [] → int →' T [] → int → int → unit | Legge un intervallo di elementi da un array e li scrive in un altro. |
| scegli: (opzione 'T → U) →' T [] → 'U [] | Applica una funzione fornita a ogni elemento di un array. Restituisce un array che contiene i risultati x per ogni elemento per il quale la funzione restituisce Some (x). |
| raccogliere: ('T →' U []) → T [] → 'U [] | Applica la funzione fornita a ogni elemento di una matrice, concatena i risultati e restituisce la matrice combinata. |
| concat: seq <'T []> →' T [] | Crea un array che contiene gli elementi di ciascuna sequenza di array fornita. |
| copia: 'T →' T [] | Crea un array che contiene gli elementi dell'array fornito. |
| creare: int → 'T →' T [] | Crea un array i cui elementi sono tutti inizialmente il valore fornito. |
| vuoto: "T [] | Restituisce un array vuoto del tipo specificato. |
| esiste: ('T → bool) →' T [] → bool | Verifica se qualsiasi elemento di un array soddisfa il predicato fornito. |
| esiste2: ('T1 →' T2 → bool) → 'T1 [] →' T2 [] → bool | Verifica se qualsiasi coppia di elementi corrispondenti di due array soddisfa la condizione fornita. |
| riempimento: 'T [] → int → int →' T → unit | Riempie un intervallo di elementi di una matrice con il valore fornito. |
| filtro: ('T → bool) →' T [] → 'T [] | Restituisce una raccolta che contiene solo gli elementi della matrice fornita per cui restituisce la condizione fornita true. |
| trova: ('T → bool) →' T [] → 'T | Restituisce il primo elemento per il quale restituisce la funzione fornita true. Genera KeyNotFoundException se non esiste alcun elemento di questo tipo. |
| findIndex: ('T → bool) →' T [] → int | Restituisce l'indice del primo elemento in una matrice che soddisfa la condizione fornita. Genera KeyNotFoundException se nessuno degli elementi soddisfa la condizione. |
| fold: ('State →' T → 'State) →' State → 'T [] →' State | Applica una funzione a ogni elemento di un array, inserendo un argomento dell'accumulatore attraverso il calcolo. Se la funzione di input è f e gli elementi dell'array sono i0 ... iN, questa funzione calcola f (... (fs i0) ...) iN. |
| fold2: ('State →' T1 → 'T2 →' State) → 'State →' T1 [] → 'T2 [] →' State | Applica una funzione a coppie di elementi da due array forniti, da sinistra a destra, inserendo un argomento dell'accumulatore attraverso il calcolo. I due array di input devono avere la stessa lunghezza; in caso contrario, viene generata ArgumentException. |
| foldBack: ('T →' State → 'State) →' T [] → 'State →' State | Applica una funzione a ogni elemento di un array, inserendo un argomento dell'accumulatore attraverso il calcolo. Se la funzione di input è f e gli elementi dell'array sono i0 ... iN, questa funzione calcola f i0 (... (f iN s)). |
| foldBack2: ('T1 →' T2 → 'State →' State) → 'T1 [] →' T2 [] → 'State →' State | Applica una funzione a coppie di elementi da due array forniti, da destra a sinistra, inserendo un argomento dell'accumulatore attraverso il calcolo. I due array di input devono avere la stessa lunghezza; in caso contrario, viene sollevata ArgumentException. |
| forall: ('T → bool) →' T [] → bool | Verifica se tutti gli elementi di un array soddisfano la condizione fornita. |
| forall2: ('T1 →' T2 → bool) → 'T1 [] →' T2 [] → bool | Verifica se tutti gli elementi corrispondenti di due array forniti soddisfano una condizione fornita. |
| ottieni: 'T [] → int →' T | Ottiene un elemento da una matrice. |
| init: int → (int → 'T) →' T [] | Utilizza una funzione fornita per creare un array della dimensione fornita. |
| isEmpty: 'T [] → bool | Verifica se un array contiene elementi. |
| iter: ('T → unit) →' T [] → unit | Applica la funzione fornita a ogni elemento di un array. |
| iter2: ('T1 →' T2 → unità) → 'T1 [] →' T2 [] → unità) | Applica la funzione fornita a una coppia di elementi da indici corrispondenti in due matrici. I due array devono avere la stessa lunghezza; in caso contrario, viene sollevata ArgumentException. |
| iteri: (int → 'T → unit) →' T [] → unit | Applica la funzione fornita a ogni elemento di un array. L'intero passato alla funzione indica l'indice dell'elemento. |
| iteri2: (int → 'T1 →' T2 → unit) → 'T1 [] →' T2 [] → unit | Applica la funzione fornita a una coppia di elementi da indici corrispondenti in due matrici, passando anche l'indice degli elementi. I due array devono avere la stessa lunghezza; in caso contrario, viene generata un'eccezione ArgumentException. |
| lunghezza: 'T [] → int | Restituisce la lunghezza di un array. La proprietà Length fa la stessa cosa. |
| mappa: ('T →' U) → 'T [] →' U [] | Crea un array i cui elementi sono il risultato dell'applicazione della funzione fornita a ciascuno degli elementi di un array fornito. |
| map2: ('T1 →' T2 → 'U) →' T1 [] → 'T2 [] →' U [] | Crea un array i cui elementi sono il risultato dell'applicazione della funzione fornita agli elementi corrispondenti di due array forniti. I due array di input devono avere la stessa lunghezza; in caso contrario, viene sollevata ArgumentException. |
| mapi: (int → 'T →' U) → 'T [] →' U [] | Crea un array i cui elementi sono il risultato dell'applicazione della funzione fornita a ciascuno degli elementi di un array fornito. Un indice intero passato alla funzione indica l'indice dell'elemento trasformato. |
| mapi2: (int → 'T1 →' T2 → 'U) →' T1 [] → 'T2 [] →' U [] | Crea un array i cui elementi sono il risultato dell'applicazione della funzione fornita agli elementi corrispondenti delle due collezioni a coppie, passando anche l'indice degli elementi. I due array di input devono avere la stessa lunghezza; in caso contrario, viene sollevata ArgumentException. |
| max: 'T [] →' T | Restituisce il più grande di tutti gli elementi di un array. Operators.max viene utilizzato per confrontare gli elementi. |
| maxBy: ('T →' U) → 'T [] →' T | Restituisce il più grande di tutti gli elementi di un array, confrontato tramite Operators.max sul risultato della funzione. |
| min: ('T [] →' T | Restituisce il più piccolo di tutti gli elementi di un array. Operators.min viene utilizzato per confrontare gli elementi. |
| minBy: ('T →' U) → 'T [] →' T | Restituisce il più piccolo di tutti gli elementi di un array. Operators.min viene utilizzato per confrontare gli elementi. |
| ofList: 'T list →' T [] | Crea un array dall'elenco fornito. |
| ofSeq: seq <'T> →' T [] | Crea un array dall'oggetto enumerabile fornito. |
| partizione: ('T → bool) →' T [] → 'T [] *' T [] | Divide un array in due array, uno contenente gli elementi per i quali restituisce la condizione fornita true, e l'altra contenente quelli per cui ritorna false. |
| permuto: (int → int) → 'T [] →' T [] | Permuta gli elementi di un array in base alla permutazione specificata. |
| scegli: (opzione 'T →' U) → 'T [] →' U | Applica la funzione fornita agli elementi successivi di un array fornito, restituendo il primo risultato in cui la funzione restituisce Some (x) per alcuni x. Se la funzione non restituisce mai Some (x), viene generata KeyNotFoundException. |
| ridurre: ('T →' T → 'T) →' T [] → 'T | Applica una funzione a ogni elemento di un array, inserendo un argomento dell'accumulatore attraverso il calcolo. Se la funzione di input è f e gli elementi dell'array sono i0 ... iN, questa funzione calcola f (... (f i0 i1) ...) iN. Se la matrice ha dimensione zero, viene generata ArgumentException. |
| reduceBack: ('T →' T → 'T) →' T [] → 'T | Applica una funzione a ogni elemento di un array, inserendo 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 la matrice ha dimensione zero, viene generata ArgumentException. |
| rev: 'T [] →' T [] | Inverte l'ordine degli elementi in una matrice fornita. |
| scansione: ('State →' T → 'State) →' State → 'T [] →' State []) | Si comporta come la piega, 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. |
| impostare: 'T [] → int →' T → unità | Imposta un elemento di un array. |
| ordina: 'T [] →' T [] | Ordina gli elementi di un array e restituisce un nuovo array. Operators.compare viene utilizzato per confrontare gli elementi. |
| sortBy: ('T →' Key) → 'T [] →' T [] | Ordina gli elementi di un array utilizzando la funzione fornita per trasformare gli elementi nel tipo su cui si basa l'operazione di ordinamento e restituisce un nuovo array. Operators.compare viene utilizzato per confrontare gli elementi. |
| sortInPlace: 'T [] → unit | Ordina gli elementi di un array modificando l'array in posizione, utilizzando la funzione di confronto fornita. Operators.compare viene utilizzato per confrontare gli elementi. |
| sortInPlaceBy: ('T →' Key) → 'T [] → unit | Ordina gli elementi di un array modificando l'array in posizione, utilizzando la proiezione fornita 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 per modificare la matrice in posizione. |
| sortWith: ('T →' T → int) → 'T [] →' T [] | Ordina gli elementi di un array utilizzando la funzione di confronto fornita e restituisce un nuovo array. |
| sub: 'T [] → int → int →' T [] | Crea un array che contiene il sottointervallo fornito, specificato dall'indice iniziale e dalla lunghezza. |
| somma: '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 un array. |
| toList: 'T [] →' T list | Converte la matrice fornita in un elenco. |
| toSeq: 'T [] → seq <' T> | Visualizza l'array fornito come una sequenza. |
| tryFind: ('T → bool) →' T [] → 'T opzione | Restituisce il primo elemento dell'array fornito per il quale restituisce la funzione fornita true. ritornaNone se tale elemento non esiste. |
| tryFindIndex: ('T → bool) →' T [] → int opzione | Restituisce l'indice del primo elemento in una matrice che soddisfa la condizione fornita. |
| tryPick: (opzione 'T →' U) → 'T [] → opzione' U | Applica la funzione fornita agli elementi successivi dell'array fornito e restituisce il primo risultato in cui la funzione restituisce Some (x) per alcuni x. Se la funzione non restituisce mai Some (x),None viene restituito. |
| decomprimere: ('T1 *' T2) [] → 'T1 [] *' T2 [] | Divide un array di coppie di tuple in una tupla di due array. |
| unzip3: ('T1 *' T2 * 'T3) [] →' T1 [] * 'T2 [] *' T3 [] | Divide una matrice di tuple di tre elementi in una tupla di tre matrici. |
| zeroCreate: int → 'T [] | Crea un array i cui elementi sono inizialmente impostati sul valore predefinito Unchecked.defaultof <'T>. |
| zip: "T1 [] →" T2 [] → ("T1 *" T2) [] | Combina due array in un array di tuple che hanno due elementi. I due array devono avere la stessa lunghezza; in caso contrario, viene sollevata ArgumentException. |
| zip3: 'T1 [] →' T2 [] → 'T3 [] → (' T1 * 'T2 * 113' T3) [] | Combina tre array in un array di tuple che hanno tre elementi. I tre array devono avere lunghezze uguali; in caso contrario, viene sollevata ArgumentException. |
Nella sezione seguente vedremo gli usi di alcune di queste funzionalità.
Creazione di array utilizzando le funzioni
Il modulo Array fornisce diverse funzioni che creano un array da zero.
Il Array.empty la funzione crea un nuovo array vuoto.
Il Array.create funzione crea un array di una dimensione specificata e imposta tutti gli elementi su valori dati.
Il Array.init funzione crea un array, data una dimensione e una funzione per generare gli elementi.
Il Array.zeroCreate la funzione crea un array in cui tutti gli elementi vengono inizializzati al valore zero.
Il Array.copy funzione crea un nuovo array che contiene elementi che vengono copiati da un array esistente.
Il Array.sub la funzione genera un nuovo array da un sottointervallo di un array.
Il Array.append funzione crea un nuovo array combinando due array esistenti.
Il Array.choose la funzione seleziona gli elementi di un array da includere in un nuovo array.
Il Array.collect funzione esegue una funzione specificata su ogni elemento di array di un array esistente e quindi raccoglie gli elementi generati dalla funzione e li combina in un nuovo array.
Il Array.concat funzione prende una sequenza di array e li combina in un singolo array.
Il Array.filter funzione accetta una funzione di condizione booleana e genera un nuovo array che contiene solo quegli elementi dell'array di input per i quali la condizione è vera.
Il Array.rev la funzione genera un nuovo array invertendo l'ordine di un array esistente.
I seguenti esempi dimostrano queste funzioni:
Esempio 1
(* using create and set *)
let array1 = Array.create 10 ""
for i in 0 .. array1.Length - 1 do
Array.set array1 i (i.ToString())
for i in 0 .. array1.Length - 1 do
printf "%s " (Array.get array1 i)
printfn " "
(* empty array *)
let array2 = Array.empty
printfn "Length of empty array: %d" array2.Length
let array3 = Array.create 10 7.0
printfn "Float Array: %A" array3
(* using the init and zeroCreate *)
let array4 = Array.init 10 (fun index -> index * index)
printfn "Array of squares: %A" array4
let array5 : float array = Array.zeroCreate 10
let (myZeroArray : float array) = Array.zeroCreate 10
printfn "Float Array: %A" array5Quando compili ed esegui il programma, restituisce il seguente output:
0 1 2 3 4 5 6 7 8 9
Length of empty array: 0
Float Array: [|7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0; 7.0|]
Array of squares: [|0; 1; 4; 9; 16; 25; 36; 49; 64; 81|]
Float Array: [|0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0|]Esempio 2
(* creating subarray from element 5 *)
(* containing 15 elements thereon *)
let array1 = [| 0 .. 50 |]
let array2 = Array.sub array1 5 15
printfn "Sub Array:"
printfn "%A" array2
(* appending two arrays *)
let array3 = [| 1; 2; 3; 4|]
let array4 = [| 5 .. 9 |]
printfn "Appended Array:"
let array5 = Array.append array3 array4
printfn "%A" array5
(* using the Choose function *)
let array6 = [| 1 .. 20 |]
let array7 = Array.choose (fun elem -> if elem % 3 = 0 then
Some(float (elem))
else
None) array6
printfn "Array with Chosen elements:"
printfn "%A" array7
(*using the Collect function *)
let array8 = [| 2 .. 5 |]
let array9 = Array.collect (fun elem -> [| 0 .. elem - 1 |]) array8
printfn "Array with collected elements:"
printfn "%A" array9Quando compili ed esegui il programma, restituisce il seguente output:
Sub Array:
[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19|]
Appended Array:
[|1; 2; 3; 4; 5; 6; 7; 8; 9|]
Array with Chosen elements:
[|3.0; 6.0; 9.0; 12.0; 15.0; 18.0|]
Array with collected elements:
[|0; 1; 0; 1; 2; 0; 1; 2; 3; 0; 1; 2; 3; 4|]Ricerca di array
Il Array.find function accetta una funzione booleana e restituisce il primo elemento per il quale la funzione restituisce true, altrimenti genera un'eccezione KeyNotFoundException.
Il Array.findIndex la funzione funziona in modo simile tranne per il fatto che restituisce l'indice dell'elemento invece dell'elemento stesso.
Il seguente esempio lo dimostra.
Microsoft fornisce questo interessante esempio di programma, che trova il primo elemento nell'intervallo di un dato numero che è sia un quadrato perfetto che un cubo perfetto -
let array1 = [| 2 .. 100 |]
let delta = 1.0e-10
let isPerfectSquare (x:int) =
let y = sqrt (float x)
abs(y - round y) < delta
let isPerfectCube (x:int) =
let y = System.Math.Pow(float x, 1.0/3.0)
abs(y - round y) < delta
let element = Array.find (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1
let index = Array.findIndex (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1
printfn "The first element that is both a square and a cube is %d and its index is %d." element indexQuando compili ed esegui il programma, restituisce il seguente output:
The first element that is both a square and a cube is 64 and its index is 62.