Matrices (F#)

  • Artikel

Matrices zijn op nul gebaseerde, veranderlijke verzamelingen van opeenvolgende gegevenselementen die allemaal van hetzelfde type zijn.

Matrices maken

U kunt matrices op verschillende manieren maken. U kunt een kleine matrix maken door opeenvolgende waarden tussen [| en |] gescheiden door puntkomma's weer te geven, zoals wordt weergegeven in de volgende voorbeelden.

let array1 = [| 1; 2; 3 |]

U kunt elk element ook op een afzonderlijke regel plaatsen. In dat geval is het scheidingsteken voor puntkomma's optioneel.

let array1 =
    [|
        1
        2
        3
     |]

Het type matrixelementen wordt afgeleid van de letterlijke gegevens die worden gebruikt en moet consistent zijn.

// This is an array of 3 integers.
let array1 = [| 1; 2; 3 |]
// This is an array of a tuple of 3 integers.
let array2 = [| 1, 2, 3 |]

De volgende code veroorzaakt een fout omdat 3.0 een float is en 1 en 2 gehele getallen zijn.

// Causes an error. The 3.0 (float) cannot be converted to integer implicitly.
// let array3 = [| 1; 2; 3.0 |]

De volgende code veroorzaakt ook een fout omdat 1,2 dit een tuple is en 3 een geheel getal is.

// Causes an error too. The 3 (integer) cannot be converted to tuple implicitly.
// let array4 = [| 1, 2; 3 |]

U kunt ook reeksexpressies gebruiken om matrices te maken. Hieronder volgt een voorbeeld waarmee een matrix van kwadraten van gehele getallen van 1 tot 10 wordt gemaakt.

let array3 = [| for i in 1 .. 10 -> i * i |]

Als u een matrix wilt maken waarin alle elementen worden geïnitialiseerd tot nul, gebruikt u Array.zeroCreate.

let arrayOfTenZeroes : int array = Array.zeroCreate 10

Toegangselementen

U kunt toegang krijgen tot matrixelementen met behulp van vierkante haken ([ en ]). De oorspronkelijke puntsyntaxis (.[index]) wordt nog steeds ondersteund, maar wordt niet meer aanbevolen vanaf F# 6.0.

array1[0]

Matrixindexen beginnen bij 0.

U kunt ook toegang krijgen tot matrixelementen met behulp van slice-notatie, waarmee u een subbereik van de matrix kunt opgeven. Voorbeelden van slice-notatie volgen.

// Accesses elements from 0 to 2.

array1[0..2]

// Accesses elements from the beginning of the array to 2.

array1[..2]

// Accesses elements from 2 to the end of the array.

array1[2..]

Wanneer slice-notatie wordt gebruikt, wordt er een nieuwe kopie van de matrix gemaakt.

Matrixtypen en -modules

Het type van alle F#-matrices is het .NET Framework-type System.Array. Daarom ondersteunen F#-matrices alle functionaliteit die beschikbaar is in System.Array.

De Array module ondersteunt bewerkingen op eendimensionale matrices. De modules Array2D, Array3Den Array4D bevatten functies die bewerkingen op matrices van respectievelijk twee, drie en vier dimensies ondersteunen. U kunt matrices met een rangorde van meer dan vier maken met behulp van System.Array.

Eenvoudige functies

Array.get krijgt een element. Array.length geeft de lengte van een matrix. Array.set stelt een element in op een opgegeven waarde. Het volgende codevoorbeeld illustreert het gebruik van deze functies.

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)

De uitvoer is als volgt.

0 1 2 3 4 5 6 7 8 9

Functies die matrices maken

Verschillende functies maken matrices zonder dat hiervoor een bestaande matrix nodig is. Array.empty maakt een nieuwe matrix die geen elementen bevat. Array.create maakt een matrix van een opgegeven grootte en stelt alle elementen in op opgegeven waarden. Array.init maakt een matrix, op basis van een dimensie en een functie om de elementen te genereren. Array.zeroCreate maakt een matrix waarin alle elementen worden geïnitialiseerd tot de nulwaarde voor het type van de matrix. De volgende code demonstreert deze functies.

let myEmptyArray = Array.empty
printfn "Length of empty array: %d" myEmptyArray.Length



printfn "Array of floats set to 5.0: %A" (Array.create 10 5.0)


printfn "Array of squares: %A" (Array.init 10 (fun index -> index * index))

let (myZeroArray : float array) = Array.zeroCreate 10

De uitvoer is als volgt.

Length of empty array: 0
Area of floats set to 5.0: [|5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0|]
Array of squares: [|0; 1; 4; 9; 16; 25; 36; 49; 64; 81|]

Array.copy maakt een nieuwe matrix die elementen bevat die uit een bestaande matrix worden gekopieerd. Houd er rekening mee dat de kopie een ondiepe kopie is, wat betekent dat als het elementtype een verwijzingstype is, alleen de verwijzing wordt gekopieerd, niet het onderliggende object. In het volgende codevoorbeeld ziet u dit.

open System.Text

let firstArray : StringBuilder array = Array.init 3 (fun index -> new StringBuilder(""))
let secondArray = Array.copy firstArray
// Reset an element of the first array to a new value.
firstArray[0] <- new StringBuilder("Test1")
// Change an element of the first array.
firstArray[1].Insert(0, "Test2") |> ignore
printfn "%A" firstArray
printfn "%A" secondArray

De uitvoer van de voorgaande code is als volgt:

[|Test1; Test2; |]
[|; Test2; |]

De tekenreeks Test1 wordt alleen weergegeven in de eerste matrix omdat de bewerking voor het maken van een nieuw element de verwijzing firstArray overschrijft, maar niet van invloed is op de oorspronkelijke verwijzing naar een lege tekenreeks die nog aanwezig is in secondArray. De tekenreeks Test2 wordt weergegeven in beide matrices omdat de Insert bewerking voor het System.Text.StringBuilder type van invloed is op het onderliggende System.Text.StringBuilder object, waarnaar wordt verwezen in beide matrices.

Array.sub genereert een nieuwe matrix op basis van een subbereik van een matrix. U geeft de subbereik op door de beginindex en de lengte op te geven. De volgende code demonstreert het gebruik van Array.sub.

let a1 = [| 0 .. 99 |]
let a2 = Array.sub a1 5 10
printfn "%A" a2

In de uitvoer ziet u dat de submaarray begint bij element 5 en dat deze 10 elementen bevat.

[|5; 6; 7; 8; 9; 10; 11; 12; 13; 14|]

Array.append maakt een nieuwe matrix door twee bestaande matrices te combineren.

De volgende code demonstreert Array.append.

printfn "%A" (Array.append [| 1; 2; 3|] [| 4; 5; 6|])

De uitvoer van de voorgaande code is als volgt.

[|1; 2; 3; 4; 5; 6|]

Array.choose selecteert elementen van een matrix die u wilt opnemen in een nieuwe matrix. De volgende code demonstreert Array.choose. Het elementtype van de matrix hoeft niet overeen te komen met het type van de waarde die wordt geretourneerd in het optietype. In dit voorbeeld is int het elementtype en de optie het resultaat van een polynomiale functie, elem*elem - 1als een drijvendekommagetal.

printfn "%A" (Array.choose (fun elem -> if elem % 2 = 0 then
                                            Some(float (elem*elem - 1))
                                        else
                                            None) [| 1 .. 10 |])

De uitvoer van de voorgaande code is als volgt.

[|3.0; 15.0; 35.0; 63.0; 99.0|]

Array.collect voert een opgegeven functie uit op elk matrixelement van een bestaande matrix en verzamelt vervolgens de elementen die door de functie worden gegenereerd en combineert deze in een nieuwe matrix. De volgende code demonstreert Array.collect.

printfn "%A" (Array.collect (fun elem -> [| 0 .. elem |]) [| 1; 5; 10|])

De uitvoer van de voorgaande code is als volgt.

[|0; 1; 0; 1; 2; 3; 4; 5; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10|]

Array.concat neemt een reeks matrices en combineert deze in één matrix. De volgende code demonstreert Array.concat.

Array.concat [ [|0..3|] ; [|4|] ]
//output [|0; 1; 2; 3; 4|]

Array.concat [| [|0..3|] ; [|4|] |]
//output [|0; 1; 2; 3; 4|]

Array.filter gebruikt een booleaanse voorwaardefunctie en genereert een nieuwe matrix die alleen die elementen van de invoermatrix bevat waarvoor de voorwaarde waar is. De volgende code demonstreert Array.filter.

printfn "%A" (Array.filter (fun elem -> elem % 2 = 0) [| 1 .. 10|])

De uitvoer van de voorgaande code is als volgt.

[|2; 4; 6; 8; 10|]

Array.rev genereert een nieuwe matrix door de volgorde van een bestaande matrix om te draaien. De volgende code demonstreert Array.rev.

let stringReverse (s: string) =
    System.String(Array.rev (s.ToCharArray()))

printfn "%A" (stringReverse("!dlrow olleH"))

De uitvoer van de voorgaande code is als volgt.

"Hello world!"

U kunt eenvoudig functies in de matrixmodule combineren die matrices transformeren met behulp van de pijplijnoperator (|>), zoals wordt weergegeven in het volgende voorbeeld.

[| 1 .. 10 |]
|> Array.filter (fun elem -> elem % 2 = 0)
|> Array.choose (fun elem -> if (elem <> 8) then Some(elem*elem) else None)
|> Array.rev
|> printfn "%A"

De uitvoer is

[|100; 36; 16; 4|]

Multidimensionale matrices

Er kan een multidimensionale matrix worden gemaakt, maar er is geen syntaxis voor het schrijven van een letterlijke multidimensionale matrix. Gebruik de operator array2D om een matrix te maken op basis van een reeks reeksen matrixelementen. De reeksen kunnen letterlijke waarden voor matrix of lijst zijn. Met de volgende code wordt bijvoorbeeld een tweedimensionale matrix gemaakt.

let my2DArray = array2D [ [ 1; 0]; [0; 1] ]

U kunt de functie Array2D.init ook gebruiken om matrices van twee dimensies te initialiseren en vergelijkbare functies zijn beschikbaar voor matrices van drie en vier dimensies. Deze functies hebben een functie die wordt gebruikt om de elementen te maken. Als u een tweedimensionale matrix wilt maken die elementen bevat die zijn ingesteld op een initiële waarde in plaats van een functie op te geven, gebruikt u de Array2D.create functie, die ook beschikbaar is voor matrices tot vier dimensies. In het volgende codevoorbeeld ziet u eerst hoe u een matrix met matrices maakt die de gewenste elementen bevatten en vervolgens gebruikt Array2D.init om de gewenste tweedimensionale matrix te genereren.

let arrayOfArrays = [| [| 1.0; 0.0 |]; [|0.0; 1.0 |] |]
let twoDimensionalArray = Array2D.init 2 2 (fun i j -> arrayOfArrays[i][j])

Syntaxis voor matrixindexering en segmentering wordt ondersteund voor matrices tot rang 4. Wanneer u een index in meerdere dimensies opgeeft, gebruikt u komma's om de indexen te scheiden, zoals wordt geïllustreerd in het volgende codevoorbeeld.

twoDimensionalArray[0, 1] <- 1.0

Het type van een tweedimensionale matrix wordt geschreven als <type>[,] (bijvoorbeeld int[,]double[,], ) en het type van een driedimensionale matrix wordt geschreven als <type>[,,], enzovoort voor matrices van hogere dimensies.

Alleen een subset van de functies die beschikbaar zijn voor eendimensionale matrices, is ook beschikbaar voor multidimensionale matrices.

Matrixslicing en multidimensionale matrices

In een tweedimensionale matrix (een matrix) kunt u een submatrix extraheren door bereiken op te geven en een jokerteken (*) te gebruiken om hele rijen of kolommen op te geven.

// Get rows 1 to N from an NxM matrix (returns a matrix):
matrix[1.., *]

// Get rows 1 to 3 from a matrix (returns a matrix):
matrix[1..3, *]

// Get columns 1 to 3 from a matrix (returns a matrix):
matrix[*, 1..3]

// Get a 3x3 submatrix:
matrix[1..3, 1..3]

U kunt een multidimensionale matrix opstrekken in submatrixen van dezelfde of lagere dimensie. U kunt bijvoorbeeld een vector verkrijgen uit een matrix door één rij of kolom op te geven.

// Get row 3 from a matrix as a vector:
matrix[3, *]

// Get column 3 from a matrix as a vector:
matrix[*, 3]

U kunt deze segmentsyntaxis gebruiken voor typen die de operatoren voor elementtoegang en overbelaste GetSlice methoden implementeren. Met de volgende code wordt bijvoorbeeld een matrixtype gemaakt dat de F# 2D-matrix verpakt, een itemeigenschap implementeert ter ondersteuning van matrixindexering en drie versies van GetSlice. Als u deze code als sjabloon voor uw matrixtypen kunt gebruiken, kunt u alle segmentbewerkingen gebruiken die in deze sectie worden beschreven.

type Matrix<'T>(N: int, M: int) =
    let internalArray = Array2D.zeroCreate<'T> N M

    member this.Item
        with get(a: int, b: int) = internalArray[a, b]
        and set(a: int, b: int) (value:'T) = internalArray[a, b] <- value

    member this.GetSlice(rowStart: int option, rowFinish : int option, colStart: int option, colFinish : int option) =
        let rowStart =
            match rowStart with
            | Some(v) -> v
            | None -> 0
        let rowFinish =
            match rowFinish with
            | Some(v) -> v
            | None -> internalArray.GetLength(0) - 1
        let colStart =
            match colStart with
            | Some(v) -> v
            | None -> 0
        let colFinish =
            match colFinish with
            | Some(v) -> v
            | None -> internalArray.GetLength(1) - 1
        internalArray[rowStart..rowFinish, colStart..colFinish]

    member this.GetSlice(row: int, colStart: int option, colFinish: int option) =
        let colStart =
            match colStart with
            | Some(v) -> v
            | None -> 0
        let colFinish =
            match colFinish with
            | Some(v) -> v
            | None -> internalArray.GetLength(1) - 1
        internalArray[row, colStart..colFinish]

    member this.GetSlice(rowStart: int option, rowFinish: int option, col: int) =
        let rowStart =
            match rowStart with
            | Some(v) -> v
            | None -> 0
        let rowFinish =
            match rowFinish with
            | Some(v) -> v
            | None -> internalArray.GetLength(0) - 1
        internalArray[rowStart..rowFinish, col]

module test =
    let generateTestMatrix x y =
        let matrix = new Matrix<float>(3, 3)
        for i in 0..2 do
            for j in 0..2 do
                matrix[i, j] <- float(i) * x - float(j) * y
        matrix

    let test1 = generateTestMatrix 2.3 1.1
    let submatrix = test1[0..1, 0..1]
    printfn $"{submatrix}"

    let firstRow = test1[0,*]
    let secondRow = test1[1,*]
    let firstCol = test1[*,0]
    printfn $"{firstCol}"

Booleaanse functies op matrices

De functies Array.exists en Array.exists2 testelementen in respectievelijk een of twee matrices. Deze functies nemen een testfunctie en retourneren true als er een element (of elementpaar voor Array.exists2) is dat voldoet aan de voorwaarde.

De volgende code demonstreert het gebruik van Array.exists en Array.exists2. In deze voorbeelden worden nieuwe functies gemaakt door slechts één van de argumenten toe te passen, in deze gevallen, het functieargument.

let allNegative = Array.exists (fun elem -> abs (elem) = elem) >> not
printfn "%A" (allNegative [| -1; -2; -3 |])
printfn "%A" (allNegative [| -10; -1; 5 |])
printfn "%A" (allNegative [| 0 |])


let haveEqualElement = Array.exists2 (fun elem1 elem2 -> elem1 = elem2)
printfn "%A" (haveEqualElement [| 1; 2; 3 |] [| 3; 2; 1|])

De uitvoer van de voorgaande code is als volgt.

true
false
false
true

Op dezelfde manier test de functie Array.forall een matrix om te bepalen of elk element voldoet aan een Booleaanse voorwaarde. De variatie Array.forall2 doet hetzelfde met behulp van een Booleaanse functie die elementen van twee matrices met gelijke lengte omvat. De volgende code illustreert het gebruik van deze functies.

let allPositive = Array.forall (fun elem -> elem > 0)
printfn "%A" (allPositive [| 0; 1; 2; 3 |])
printfn "%A" (allPositive [| 1; 2; 3 |])


let allEqual = Array.forall2 (fun elem1 elem2 -> elem1 = elem2)
printfn "%A" (allEqual [| 1; 2 |] [| 1; 2 |])
printfn "%A" (allEqual [| 1; 2 |] [| 2; 1 |])

De uitvoer voor deze voorbeelden is als volgt.

false
true
true
false

Matrices zoeken

Array.find gebruikt een Booleaanse functie en retourneert het eerste element waarvoor de functie retourneert true, of genereert een System.Collections.Generic.KeyNotFoundException als er geen element is gevonden dat voldoet aan de voorwaarde. Array.findIndex is hetzelfde Array.find, behalve dat het de index van het element retourneert in plaats van het element zelf.

De volgende code gebruikt Array.find en Array.findIndex zoekt een getal dat zowel een perfecte vierkant als een perfecte kubus is.

let arrayA = [| 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) arrayA
let index = Array.findIndex (fun elem -> isPerfectSquare elem && isPerfectCube elem) arrayA
printfn "The first element that is both a square and a cube is %d and its index is %d." element index

De uitvoer is als volgt.

The first element that is both a square and a cube is 64 and its index is 62.

Array.tryFind is als Array.findvolgt, behalve dat het resultaat een optietype is en het retourneert None als er geen element wordt gevonden. Array.tryFind moet worden gebruikt in plaats van Array.find wanneer u niet weet of een overeenkomend element zich in de matrix bevindt. Het is vergelijkbaar, Array.tryFindIndexArray.findIndex behalve dat het optietype de retourwaarde is. Als er geen element wordt gevonden, is Nonede optie .

De volgende code demonstreert het gebruik van Array.tryFind. Deze code is afhankelijk van de vorige code.

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 lookForCubeAndSquare array1 =
    let result = Array.tryFind (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1
    match result with
    | Some x -> printfn "Found an element: %d" x
    | None -> printfn "Failed to find a matching element."

lookForCubeAndSquare [| 1 .. 10 |]
lookForCubeAndSquare [| 100 .. 1000 |]
lookForCubeAndSquare [| 2 .. 50 |]

De uitvoer is als volgt.

Found an element: 1
Found an element: 729
Failed to find a matching element.

Gebruik Array.tryPick dit wanneer u een element moet transformeren, naast het vinden ervan. Het resultaat is het eerste element waarvoor de functie het getransformeerde element retourneert als een optiewaarde of None als er geen dergelijk element wordt gevonden.

De volgende code toont het gebruik van Array.tryPick. In dit geval worden in plaats van een lambda-expressie verschillende lokale helperfuncties gedefinieerd om de code te vereenvoudigen.

let findPerfectSquareAndCube array1 =
    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
    // intFunction : (float -> float) -> int -> int
    // Allows the use of a floating point function with integers.
    let intFunction function1 number = int (round (function1 (float number)))
    let cubeRoot x = System.Math.Pow(x, 1.0/3.0)
    // testElement: int -> (int * int * int) option
    // Test an element to see whether it is a perfect square and a perfect
    // cube, and, if so, return the element, square root, and cube root
    // as an option value. Otherwise, return None.
    let testElement elem =
        if isPerfectSquare elem && isPerfectCube elem then
            Some(elem, intFunction sqrt elem, intFunction cubeRoot elem)
        else None
    match Array.tryPick testElement array1 with
    | Some (n, sqrt, cuberoot) -> printfn "Found an element %d with square root %d and cube root %d." n sqrt cuberoot
    | None -> printfn "Did not find an element that is both a perfect square and a perfect cube."

findPerfectSquareAndCube [| 1 .. 10 |]
findPerfectSquareAndCube [| 2 .. 100 |]
findPerfectSquareAndCube [| 100 .. 1000 |]
findPerfectSquareAndCube [| 1000 .. 10000 |]
findPerfectSquareAndCube [| 2 .. 50 |]

De uitvoer is als volgt.

Found an element 1 with square root 1 and cube root 1.
Found an element 64 with square root 8 and cube root 4.
Found an element 729 with square root 27 and cube root 9.
Found an element 4096 with square root 64 and cube root 16.
Did not find an element that is both a perfect square and a perfect cube.

Berekeningen uitvoeren op matrices

De Array.average functie retourneert het gemiddelde van elk element in een matrix. Het is beperkt tot elementtypen die exacte verdeling ondersteunen door een geheel getal, dat drijvendekommatypen bevat, maar geen integrale typen. De Array.averageBy functie retourneert het gemiddelde van de resultaten van het aanroepen van een functie op elk element. Voor een matrix van integraal type kunt u elk element gebruiken Array.averageBy en converteren naar een drijvendekommatype voor de berekening.

Gebruik Array.max of om het maximum- Array.min of minimumelement op te halen als het elementtype dit ondersteunt. En sta toe Array.maxByArray.minBy dat een functie eerst kan worden uitgevoerd, misschien om te transformeren naar een type dat vergelijking ondersteunt.

Array.sum voegt de elementen van een matrix toe en Array.sumBy roept een functie aan op elk element en voegt de resultaten samen.

Als u een functie wilt uitvoeren op elk element in een matrix zonder de retourwaarden op te slaan, gebruikt u Array.iter. Gebruik voor een functie met twee matrices met gelijke lengte Array.iter2. Als u ook een matrix van de resultaten van de functie wilt behouden, gebruikt Array.map of Array.map2, die op twee matrices tegelijk werkt.

De variaties Array.iteri en Array.iteri2 maken het mogelijk dat de index van het element betrokken is bij de berekening; hetzelfde geldt voor Array.mapi en Array.mapi2.

De functiesArray.fold, Array.foldBack, Array.reduce, , en Array.reduceBackArray.scanArray.scanBack voeren algoritmen uit die betrekking hebben op alle elementen van een matrix. Op dezelfde manier worden de variaties Array.fold2 uitgevoerd en Array.foldBack2 worden berekeningen uitgevoerd op twee matrices.

Deze functies voor het uitvoeren van berekeningen komen overeen met de functies van dezelfde naam in de lijstmodule. Zie Lijsten voor gebruiksvoorbeelden.

Matrices wijzigen

Array.set stelt een element in op een opgegeven waarde. Array.fill stelt een bereik van elementen in een matrix in op een opgegeven waarde. De volgende code bevat een voorbeeld van Array.fill.

let arrayFill1 = [| 1 .. 25 |]
Array.fill arrayFill1 2 20 0
printfn "%A" arrayFill1

De uitvoer is als volgt.

[|1; 2; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 23; 24; 25|]

U kunt een Array.blit subsectie van de ene matrix naar een andere matrix kopiëren.

Converteren naar en van andere typen

Array.ofList maakt een matrix op basis van een lijst. Array.ofSeq maakt een matrix op basis van een reeks. Array.toList en Array.toSeq converteer naar deze andere verzamelingstypen van het matrixtype.

Matrices sorteren

Hiermee Array.sort kunt u een matrix sorteren met behulp van de algemene vergelijkingsfunctie. Gebruik Array.sortBy deze functie om een functie op te geven die een waarde genereert, aangeduid als een sleutel, om te sorteren met behulp van de algemene vergelijkingsfunctie op de sleutel. Gebruik Array.sortWith deze optie als u een aangepaste vergelijkingsfunctie wilt opgeven. Array.sort, Array.sortByen Array.sortWith alle items retourneren de gesorteerde matrix als een nieuwe matrix. De variaties Array.sortInPlace, Array.sortInPlaceByen Array.sortInPlaceWith wijzig de bestaande matrix in plaats van een nieuwe te retourneren.

Matrices en tuples

De functies Array.zip en Array.unzip converteren matrices van tupleparen naar tuples van matrices en vice versa. Array.zip3 en Array.unzip3 zijn vergelijkbaar, behalve dat ze werken met tuples van drie elementen of tuples van drie matrices.

Parallelle berekeningen op matrices

De module Array.Parallel bevat functies voor het uitvoeren van parallelle berekeningen op matrices. Deze module is niet beschikbaar in toepassingen die gericht zijn op versies van .NET Framework vóór versie 4.

Zie ook