Vectoren en matrices

Om met matrices te werken moet eerst de library 'linalg' geladen worden, hiervoor gebruikt men 'with'.

> with(linalg):

Warning, new definition for norm

Warning, new definition for trace

Er zijn diverse manieren om matrices te definiëren:

Men kan eerst het aantal rijen en kolommen van de matrix specificeren, en als derde argument een lijst met elementen.

> A := matrix(2,2,[-1,0,2,3]);

[Maple Math]

Matrices kunnen voor enige verwarring zorgen, ondanks het feit dat de matrix 'A' hierboven gedefinieerd werd, geeft:

> A;

[Maple Math]

Het lijkt op het eerste zicht of 'A' niet gedefinieerd is! Gebruikt men echter het commando 'evalm' (evaluate matrix) dan ziet men dat dit wel degelijk het geval is.

> evalm(A);

[Maple Math]

Het is ook mogelijk de elementen van de matrix te definieren als een lijst van rijen die elk ook lijsten zijn met behulp van 'matrix'.

> B := matrix([[2,-3],[0,1]]);

[Maple Math]

De elementen van een matrix kunnen uiteraard ook mbv. een voorschrift ingegeven worden:

> C := matrix(4,5,[seq(seq(x^i*y^j,i=0..4),j=0..3)]);

[Maple Math]

Hier werden eerst het aantal rijen en kolommen als parameters van 'matrix' gespecifieerd, het derde argument is immers de lijst met elementen van de matrix waaruit de dimensies niet op te maken zijn zoals hieronder getoond.

> [seq(seq(x^i*y^j,i=0..4),j=0..3)];

[Maple Math]

Men kan ook de elementen van een matrix stuk per stuk toekennen of opvragen.

> E := matrix(2,2);

[Maple Math]

> E[1,1] := 3: E[1,2] := -1: E[2,1] := 2: E[2,2] := 0: evalm(E);

[Maple Math]

> E[1,2];

[Maple Math]

Men zou vectoren kunnen ingeven zoals matrices met het aantal rijen of kolommen gelijk aan 1, maar er is ook een functie 'vector' voor:

> V := vector([2,3]);

[Maple Math]

Ook voor vectoren is het gebruik van 'evalm' nodig:

> V;

[Maple Math]

> evalm(V);

[Maple Math]

> A := 'A': B := 'B': C := 'C': E := 'E': V := 'V':

Bewerkingen met matrices zijn eenvoudig in Maple, hoewel er toch enkele punten zijn waarop gelet moet worden.

> A := matrix([[1,3],[-1,2]]); B := matrix([[2,-1],[6,-2]]);

[Maple Math]

[Maple Math]

De optelling kan met de '+' uitgevoerd worden, 'evalm' moet echter ook gebruikt worden bij bewerkingen met matrices. Zonder 'evalm':

> A + B;

[Maple Math]

met 'evalm':

> evalm(A + B);

[Maple Math]

Jammer genoeg is de vermenigvuldiging van matrices niet gedefinieerd met '*' maar wel met '&*'. Dit is de niet-commutatieve vermenigvuldiging in Maple.

> evalm(A &* B);

[Maple Math]

Het vermenigvuldigen van een matrix met een vector werkt analoog:

> V := vector([1,0]);

[Maple Math]

> evalm(A &* V);

[Maple Math]

Merk echter op dat Maple de vector 'V' automatisch getransponeerd heeft. Indien men de vector als matrix definieert met het gewenste aantal rijen en kolommen krijgt men wel het te verwachten gedrag:

> U := matrix(1,2,[2,0]);

[Maple Math]

De vector 'U' is een rijvector, A.U is dus niet gedefinieerd, U.A daarentegen wel:

> evalm(A &* U);

Error, (in linalg[multiply]) non matching dimensions for vector/matrix product

> evalm(U &* A);

[Maple Math]

De berekening van het scalair product van twee vectoren ligt voor de hand:

> evalm(U &* V);

[Maple Math]

Er staan vierkante haken om het resultaat: 'U' was immers een matrix, geen vector. Eerst 'U' omzetten naar een vector met behulp van convert geeft het verwachte resultaat:

> evalm(convert(U,vector) &* V);

[Maple Math]

De machtsverheffing is wel gedefinieerd als '^':

> evalm(A^2);

[Maple Math]

Een matrixoperatie die eveneens vrij frequent voorkomt is exp(A*t):

> exponential(A,t);

[Maple Math]

Uiteraard kunnen de determinant, inverse, getransponeerde en het spoor berkend worden.

> det(A);

[Maple Math]

> inverse(A);

[Maple Math]

> transpose(A);

[Maple Math]

> trace(A);

[Maple Math]

Men kan testen of twee matrices gelijk zijn mbv. de functie 'equal'.

> equal(A,B);

[Maple Math]

> equal(A,A);

[Maple Math]

> A := 'A': B := 'B':: U := 'U': V := 'V':

Er is nog een andere functie om vector- en matrixachtige datastructuren te definieren, nl. 'array'.

> A := array(1..2,1..2,[[a,b],[c,d]]);

[Maple Math]

Of men 'matrix' of 'array' gebruikt hangt af van de toepassing. De 'array' vorm leent zich beter tot programmeertoepassingen: de ondergrens en bovengrens van de rij- en kolomindex kan immers gespecifieerd worden:

> B := array(-1..1,-1..1,[[a,b,c],[e,f,g],[h,i,j]]);

[Maple Math]
[Maple Math]
[Maple Math]
[Maple Math]
[Maple Math]
[Maple Math]
[Maple Math]
[Maple Math]
[Maple Math]
[Maple Math]
[Maple Math]

> B[-1,-1]; B[1,-1];

[Maple Math]

[Maple Math]

Bij het gebruik van 'matrix' en 'vector' loopt de index steeds vanaf 1 tot de opgegeven bovengrens. 'matrix' en 'vector' zullen dus eerder gebruikt worden in strikt wiskundige toepassingen zoals lineaire algebra. Merk echter op dat men zonder probleem een array met een matrix of een vector kan vermenigvuldigen (mits de dimensies dit toelaten uiteraard).

> V := vector([1,3]);

[Maple Math]

> evalm(A &* V);

[Maple Math]

Een bijkomend voordeel van 'array' ten opzichte van 'matrix' is dat men er gemakkelijk enkele speciale types matrices mee kan definieren. Belangrijke voordelen zijn de identische, de diagonale en de symmetrische matrix.

> C := array(identity, 1..3, 1..3);

[Maple Math]

> evalm(C);

[Maple Math]

> E := array(diagonal, 1..3, 1..3);

[Maple Math]

> E[1,1] := a: E[2,2] := b: E[3,3] := c:

> evalm(E);

[Maple Math]

> F := array(symmetric, 1..3, 1..3);

[Maple Math]

> F[1,1] := a: F[1,2] := b: F[1,3] := c: F[2,2] := d: F[2,3] := e: F[3,3] := f:

> evalm(F);

[Maple Math]

> A := 'A': B := 'B': C := 'C': E := 'E': F := 'F': V := 'V':