- Je voorspelt wanneer twee matrixvormen vermenigvuldigbaar zijn.
- Je bouwt matrixvermenigvuldiging en toont dat AB meestal niet BA is.
Een afbeelding kan eerst draaien en daarna uitrekken. Beide bewerkingen kun je met een matrix uitvoeren, maar kun je ze ook samenvoegen tot één berekening? Dat helpt later om te begrijpen wat opeenvolgende rekenstappen in een model doen.
Noem de eerste machine B en de tweede A. B maakt van twee invoergetallen drie tussengetallen; A gebruikt die drie en maakt twee uitvoergetallen. De aansluiting past omdat A precies ontvangt wat B levert.
1. Eerst controleren of de aansluiting past
B heeft dan vorm (3, 2): drie uitvoerrijen en twee invoerkolommen. A heeft vorm (2, 3). Hun gecombineerde matrix heet AB: de rechter machine B werkt eerst, daarna A; samen ontvangen ze twee en leveren ze twee getallen.
a = (2, 3) # vorm van A
b = (3, 2) # vorm van B
print(a[1] == b[0]) # True
print((a[0], b[1])) # (2, 2)
True betekent dat de vergelijking klopt. Algemeen noemen we het aantal uitvoergetallen m, het aantal tussengetallen k en het aantal invoergetallen n:
Dit schema beschrijft vormen, geen vermenigvuldiging van losse afmetingen. De twee k's moeten gelijk zijn; m en n blijven over. Je kunt dus ook rechthoekige matrices combineren.
Schrijf product_vorm(a, b). Zijn de binnenmaten ongelijk, geef dan None terug: Python gebruikt dat als “geen resultaat”, niet als het getal nul. Met return None in die if stopt de functie meteen; anders geef je de buitenmaten als tuple terug.
2. Een uitvoercel verzamelt alle tussenroutes
Stel A heeft rijen (1, 2) en (3, 4); B heeft rijen (2, 0) en (1, 2). Voor de cel linksboven combineer je rij (1, 2) van A met kolom (2, 1) van B: 1 × 2 + 2 × 1 = 4. De twee producten volgen twee routes via de tussengetallen; beide bijdragen tellen mee.
De cel rechtsboven gebruikt dezelfde rij en de andere kolom: 1 × 0 + 2 × 2 = 4. Onderin krijg je 3 × 2 + 4 × 1 = 10 en 3 × 0 + 4 × 2 = 8. De hele uitkomst is:
Controleer met invoer (1, 0): B maakt daarvan (2, 1); A maakt daar weer (4, 10) van. Ook de gecombineerde matrix geeft (4, 10), haar eerste kolom. Zij vervangt dus de twee opeenvolgende bewerkingen.
De positie in de uitkomst kiest dus een rij links en een kolom rechts. Dit heet matrixvermenigvuldiging (matrix multiplication). In Python bouw je de eerste uitvoerrij zo:
A = [[1, 2], [3, 4]]
B = [[2, 0], [1, 2]]
rij = []
for j in range(len(B[0])):
totaal = 0
for k in range(len(B)):
totaal = totaal + A[0][k] * B[k][j]
rij.append(totaal)
print(rij) # [4, 4]
j kiest de uitvoerkolom; k doorloopt de tussenroutes en telt één cel bij elkaar. Na de binnenste lus is die cel klaar; daarna voeg je haar toe aan de rij. Voor de hele matrix zet je er een buitenste lus over rijpositie i omheen, vervang je A[0][k] door A[i][k] en begin je elke uitvoerrij opnieuw met [].
Voeg een rij pas na de j-lus toe aan de resultaatlijst. Geef die lijst na alle rijen terug. De drie lussen hebben daarmee ieder één taak: rij kiezen, cel kiezen, bijdragen optellen.
Kies een uitvoercel. De gemarkeerde rij en kolom leveren precies die som.
1.0 × 2.0 + 2.0 × 1.0 = 4.0
Kies in het diagram de cel rechtsboven en bereken de getoonde som zelf vóór je de uitkomst leest. De beginwaarden zijn die van onze handberekening. Verander daarna de schuif: alleen de eerste rij van A verandert, dus alleen de eerste uitvoerrij kan veranderen.
Veelgemaakte fout: element voor element vermenigvuldigen zou linksboven 1 × 2 = 2 geven. Het matrixproduct geeft daar 4, omdat de tweede tussenroute ook bijdraagt. Maak nu matmul(A, B) voor passende, niet-lege matrices.
3. Draaien en rekken wissel je niet zomaar om
Neem draaier R met rijen (0, −1), (1, 0) en rekker S met rijen (2, 0), (0, 1). R draait een pijl 90 graden tegen de klok in; S verdubbelt alleen de horizontale component. Begin met (1, 0).
Eerst R geeft (0, 1); daarna S laat (0, 1) staan. Eerst S geeft (2, 0); daarna R maakt daarvan (0, 2). Dezelfde machines, maar verschillende uitkomsten:
R = [[0, -1], [1, 0]]
S = [[2, 0], [0, 1]]
x = [1, 0]
print(matvec(S, matvec(R, x))) # [0, 1]
print(matvec(R, matvec(S, x))) # [0, 2]
Python rekent de binnenste functieaanroep eerst uit. De helper matvec uit de vorige les staat hiervoor al volledig in je starter; die hoef je niet opnieuw te schrijven. Maak achtereen(A, B, x) door eerst matvec(B, x) te bewaren en die tussenvector daarna aan A te geven.
Wat neem je mee?
- Passende binnenmaten verbinden twee machines; de buitenmaten bepalen de uitvoervorm.
- Iedere productcel is een inproduct van een rij links en een kolom rechts.
- In AB werkt B eerst; omwisselen kan een andere uitkomst geven.
Hierna onderzoek je of een matrix informatie bewaart of de ruimte platdrukt. Dat bepaalt of terugrekenen mogelijk is.