9. Matrices

9.1 Inleiding

PowerShell ondersteunt matrices van een of meer dimensies met elke dimensie met nul of meer elementen. Binnen een dimensie worden elementen genummerd in oplopende gehele getallen, beginnend bij nul. Elk afzonderlijk element is toegankelijk via de operator voor matrixsubscripts [] (7.1.4). Het aantal dimensies in een matrix wordt de rangschikking genoemd.

Een element kan een waarde van elk type bevatten, inclusief een matrixtype. Een matrix met een of meer elementen waarvan de waarden van een matrixtype zijn, wordt een gekartelde matrix genoemd. Een multidimensionale matrix heeft meerdere dimensies. In dat geval is het aantal elementen in elke rij van een dimensie hetzelfde. Een element van een gekartelde matrix kan een multidimensionale matrix bevatten en vice versa.

Multidimensionale matrices worden opgeslagen in de volgorde van de belangrijkste rijen. Het aantal elementen in een matrix wordt de lengte van die matrix genoemd, wat vast staat wanneer de matrix wordt gemaakt. Als zodanig zijn de elementen in een 1-dimensionale matrix A met lengte N toegankelijk (dat wil zeggen, in subscripts) met behulp van de expressies A[0], A[1], ..., A[N-1]. De elementen in een 2-dimensionale matrix B met M-rijen , met elke rij met N kolommen, zijn toegankelijk met behulp van de expressies B[0,0], B[0,1], ..., B[0,N-1], B[1,0], B[1,1], ..., B[1,N-1], ..., B[M-1,0], B[M-1,1], ..., B[M-1,N-1]. En voor matrices met drie of meer dimensies.

Een matrix is standaard polymorf; Dat wil zeggen dat de elementen niet allemaal hetzelfde type hoeven te hebben. Bijvoorbeeld:

$items = 10,"blue",12.54e3,16.30D # 1-D array of length 4
$items[1] = -2.345
$items[2] = "green"

$a = New-Object 'object[,]' 2,2 # 2-D array of length 4
$a[0,0] = 10
$a[0,1] = $false
$a[1,0] = "red"
$a[1,1] = $null

Een 1-dimensionale type[]matrix heeft het type , een 2-dimensionale matrix heeft het type type[,], een 3-dimensionale matrix heeft het type type[,,], en meer, waarbij type object is voor een niet-getrainde type matrix of het beperkte type voor een beperkte matrix (9,4).

Alle matrixtypen zijn afgeleid van het type Matrix (*4.3.2).

9.2 Matrix maken

Een matrix wordt gemaakt via een expressie voor het maken van een matrix, die de volgende vormen heeft: unaire komma-operator (#7.2.1) , matrix-expression (*7.1.7), binaire komma-operator (#7.3), bereikoperator (7.4) of new-object-cmdlet .

Hier volgen enkele voorbeelden van het maken en gebruiken van een matrix:

$values = 10, 20, 30
for ($i = 0; $i -lt $values.Length; ++$i) {
    "`$values[$i] = $($values[$i])"
}

$x = , 10                         # x refers to an array of length 1
$x = @(10)                        # x refers to an array of length 1
$x = @()                          # x refers to an array of length 0

$a = New-Object 'object[,]' 2, 2  # create a 2x2 array of anything
$a[0, 0] = 10                     # set to an int value
$a[0, 1] = $false                 # set to a boolean value
$a[1, 0] = "red"                  # set to a string value
$a[1, 1] = 10.50D                 # set to a decimal value
foreach ($e in $a) {              # enumerate over the whole array
    $e
}

Het volgende wordt naar de pijplijn geschreven:

$values[0] = 10
$values[1] = 20
$values[2] = 30

10
False
red
10.50

De standaardwaarde van een element dat niet expliciet is initialiseerd, is de standaardwaarde voor het type van dat element (dat wil zeggen, $false, nul of $null).

9.3 Matrix-samenvoeging

Matrices van een willekeurig type en een willekeurige lengte kunnen worden samenvoegd via + de operators en += , die beide resulteren in het maken van een nieuwe niet-getrainde 1-dimensionale matrix. De bestaande matrices zijn ongewijzigd. Zie voor meer informatie en .9.4 voor een discussie over het toevoegen aan een matrix van beperkt type.

9.4 Typen elementen beperken

Een 1-dimensionale matrix kan worden gemaakt zodat deze beperkt is tot het type door de expressie voor het maken van een matrix vooraf te laten gaan door een cast-matrixtype. Bijvoorbeeld:

$a = [int[]](1,2,3,4)   # constrained to int
$a[1] = "abc"           # implementation-defined behavior
$a += 1.23              # new array is unconstrained

De syntaxis voor het maken van een multidimensionale matrix vereist de specificatie van een type en dat type wordt het beperkingstype voor die matrix. Door het type op te object[]geven, is er echter geen beperking omdat een waarde van elk type kan worden toegewezen aan een element van een matrix van dat type.

Het samenvoegen van twee matrices (7.7.3) resulteert altijd in een nieuwe matrix die niet is getraind, zelfs als beide matrices door hetzelfde type worden beperkt. Bijvoorbeeld:

$a = [int[]](1,2,3)    # constrained to int
$b = [int[]](10,20)    # constrained to int
$c = $a + $b           # constraint not preserved
$c = [int[]]($a + $b)  # result explicitly constrained to int

9.5 Matrices als verwijzingstypen

Omdat matrixtypen verwijzingstypen zijn, kan een variabele die een matrix aanmaak, worden gemaakt om te verwijzen naar elke matrix van een rangschikking, lengte en elementtype. Bijvoorbeeld:

$a = 10,20                     # $a refers to an array of length 2
$a = 10,20,30                  # $a refers to a different array, of length 3
$a = "red",10.6                # $a refers to a different array, of length 2
$a = New-Object 'int[,]' 2,3   # $a refers to an array of rank 2

Toewijzing van een matrix omvat een kleine kopie; Dat wil zeggen dat de variabele die is toegewezen aan verwijst naar dezelfde matrix. Er wordt geen kopie van de matrix gemaakt. Bijvoorbeeld:

$a = 10,20,30
">$a<"
$b = $a         # make $b refer to the same array as $a
">$b<"

$a[0] = 6       # change value of [0] via $a
">$a<"
">$b<"          # change is reflected in $b

$b += 40        # make $b refer to a new array
$a[0] = 8       # change value of [0] via $a
">$a<"
">$b<"          # change is not reflected in $b

Het volgende wordt naar de pijplijn geschreven:

>10 20 30<
>10 20 30<
>6 20 30<
>6 20 30<
>8 20 30<
>6 20 30 40<

9.6 Matrices als matrixelementen

Elk element van een matrix kan zelf een matrix zijn. Bijvoorbeeld:

$colors = "red", "blue", "green"
$list = $colors, (,7), (1.2, "yes") # parens in (,7) are redundant; they
                                    # are intended to aid readability
"`$list refers to an array of length $($list.Length)"
">$($list[1][0])<"
">$($list[2][1])<"

Het volgende wordt naar de pijplijn geschreven:

$list refers to an array of length 3
>7<
>yes<

$list[1] verwijst naar een matrix van 1 element, het gehele getal 7, dat toegankelijk is via $list[1][0], zoals wordt weergegeven. Vergelijk dit met de volgende subtubtly different case:

$list = $colors, 7, (1.2, "yes") # 7 has no prefix comma
">$($list[1])<"

Hier verwijst $list[1] naar een scalaire waarde, het gehele getal 7, dat toegankelijk is via $list[1].

Kijk eens naar het volgende voorbeeld:

$x = [string[]]("red","green")
$y = 12.5, $true, "blue"
$a = New-Object 'object[,]' 2,2
$a[0,0] = $x               # element is an array of 2 strings
$a[0,1] = 20               # element is an int
$a[1,0] = $y               # element is an array of 3 objects
$a[1,1] = [int[]](92,93)   # element is an array of 2 ints

9.7 Negatieve subscripting

Dit wordt besproken in :7.1.4.1.

9.8 Controle van grenzen

Dit wordt besproken in :7.1.4.1.

9.9 Matrixsegmenten

Een matrixsegment is een ongeconstrainde 1-dimensionale matrix waarvan de elementen kopieën zijn van nul of meer elementen uit een verzameling. Er wordt een matrixsegment gemaakt via de subscriptoperator [] (7.1.4.5).

9.10 Een matrix kopiëren

Een aaneengesloten set elementen kan worden gekopieerd van de ene matrix naar de andere met behulp van de methode [Array]::Copy. Bijvoorbeeld:

$a = [int[]](10,20,30)
$b = [int[]](0,1,2,3,4,5)
[Array]::Copy($a, $b, 2)        # $a[0]->$b[0],
$a[1]->$b[1]
[Array]::Copy($a, 1, $b, 3, 2)  # $a[1]->$b[3],
$a[2]->$b[4]

9.11 Een matrix opsnoemen

Hoewel het mogelijk is om een matrix te herhalen die toegang heeft tot elk van de elementen via de operator voor subscripts, kunnen we de elementen van die matrix opsnoemen met behulp van de foreach-instructie. Voor een multidimensionale matrix worden de elementen in de volgorde van de rij verwerkt. Bijvoorbeeld:

$a = 10, 53, 16, -43
foreach ($elem in $a) {
    # do something with element via $e
}

foreach ($elem in -5..5) {
    # do something with element via $e
}

$a = New-Object 'int[,]' 3, 2
foreach ($elem in $a) {
    # do something with element via $e
}

9.12 Multidimensionale matrix plat maken

Voor sommige bewerkingen op een multidimensionale matrix (zoals replicatie (7.6.3) en samenvoeging (7.7.3)) moet die matrix plat worden gemaakt; dat wil zeggen, om te worden omgezet in een 1-dimensionale matrix van een niet-getraind type. De resulterende matrix neemt alle elementen op in de volgorde van de belangrijkste rij.

Kijk eens naar het volgende voorbeeld:

$a = "red",$true
$b = (New-Object 'int[,]' 2,2)
$b[0,0] = 10
$b[0,1] = 20
$b[1,0] = 30
$b[1,1] = 40
$c = $a + $b

De matrix die is aangewezen door $c bevat de elementen 'red', $true, 10, 20, 30 en 40.