Vektorer och matriser

En vektor är en enkel lista med tal, till exempel en riktning i rummet eller en uppsättning mängder. En matris är en lista med rader. Den här sidan beskriver skalärprodukt och kryssprodukt, matrismultiplikation, determinanter och inverser, lösning av flera linjära ekvationer samtidigt samt numeriska verktyg inom linjär algebra: egenvärden, QR- och LU-faktorisering samt singularvärdesuppdelning.

Använd dem för kursuppgifter i linjär algebra, geometri och transformationer eller problem där flera obekanta binds samman av linjära ekvationer. Vektorer och matriser är vanliga listor, så allt under Listor och statistik, till exempel indexering, gäller även här.

Vektorer

calc

dot([1, 2, 3], [4, 5, 6]) ger 32

dot([3, 4], [4, -3]) ger 0

cross([1, 0, 0], [0, 1, 0]) ger [0, 0, 1]

cross([1, 2, 3], [4, 5, 6]) ger [-3, 6, -3]

v = [3, 4]

sqrt(dot(v, v)) ger 5

dot multiplicerar motsvarande element och summerar produkterna. Om skalärprodukten är noll är vektorerna vinkelräta mot varandra, som [3, 4] och [4, -3]. cross ger en vektor som är vinkelrät mot båda indatavektorerna: kryssprodukten av x-riktningen och y-riktningen är z-riktningen. En vektors längd är kvadratroten ur dess skalärprodukt med sig själv.

dot kräver två lika långa vektorer. cross kräver två vektorer med tre element vardera. Använd vanlig listaritmetik för att addera eller skala vektorer: [1, 2] + [3, 4] ger [4, 6] och 2 * [3, 4] ger [6, 8].

Skrivning och multiplikation av matriser

Skriv en matris som en lista med rader, med varje rad inom egna hakparenteser:

calc

shape([[1, 2, 3], [4, 5, 6]]) ger [2, 3]

transpose([[1, 2, 3], [4, 5, 6]]) ger [[1, 4], [2, 5], [3, 6]]

identity(3) ger [[1, 0, 0], [0, 1, 0], [0, 0, 1]]

[[1, 2], [3, 4]] * [[5, 6], [7, 8]] ger [[19, 22], [43, 50]]

shape ger [rows, columns]. transpose byter plats på rader och kolumner. identity(n) är enhetsmatrisen med n rader och n kolumner, som lämnar en annan matris oförändrad vid multiplikation.

* mellan två matriser betyder matrismultiplikation. Den vänstra matrisen måste då ha lika många kolumner som den högra har rader. Om du vill multiplicera en matris med en vektor skriver du vektorn som en kolumn, med ett element per rad:

calc

# Rotate the point (3, 1) by 90° anticlockwise

rotate = [[0, -1], [1, 0]]

rotate * [[3], [1]] ger [[-1], [3]]

rotate * rotate ger [[-1, 0], [0, -1]]

Två rotationer på 90° ger ett halvt varv. Därför byter rotate * rotate tecken på båda koordinaterna. En enkel lista som [3, 1] godtas inte till höger om en matris. Om du har sparat en sådan lista under ett namn gör transpose([v]) om den till en kolumn.

Matriser med samma dimensioner kan adderas och subtraheras. De kan även multipliceras eller divideras med ett tal, precis som andra listor.

Några regler gäller för varje matrisoperation:

Varje rad måste ha samma antal element.
Elementen måste vara tal utan enheter. Enheter och valutabelopp godtas inte.
En matris kan ha högst 32 rader och 32 kolumner.
Kortformen med semikolon stöds inte. Skriv [[1, 2], [3, 4]], inte [1, 2; 3, 4].

Determinant, invers, spår och rang

calc

M = [[2, 1], [5, 3]]

det(M) ger 1

inverse(M) ger [[3, -1], [-5, 2]]

M * inverse(M) ger [[1, 0], [0, 1]]

trace(M) ger 5

inverse([[2, 1], [1, 3]]) ger [[0.6, -0.2], [-0.2, 0.4]]

det([[1, 2], [2, 4]]) ger 0

rank([[1, 2, 3], [2, 4, 6]]) ger 1

det, inverse och trace (summan av diagonalelementen) kräver en kvadratisk matris. Om determinanten är noll är matrisen singulär: dess rader är inte oberoende och den saknar invers. Därför ger inverse([[1, 2], [2, 4]]) ett fel. rank räknar antalet oberoende rader och godtar även matriser som inte är kvadratiska. I sista raden är matrisens andra rad dubbelt så stor som den första, så rangen är 1.

Dessa fyra använder exakta bråk i stället för decimaltal. Därför ger M * inverse(M) exakt enhetsmatrisen.

Lös ett linjärt system

Anta att tre koppar kaffe och två koppar te kostar 13,50 £, medan en kopp kaffe och fyra koppar te kostar 11,50 £. Skriv antalet av varje dryck på en rad per ekvation, med kolumnerna i samma ordning (kaffe, te), och beloppen i en motsvarande lista:

calc

solve_system([[3, 2], [1, 4]], [13.5, 11.5]) ger [3.1, 2.1]

Resultatet följer samma ordning som kolumnerna: en kaffe kostar 3,10 £ och ett te 2,10 £. Utelämna valutasymbolerna, eftersom matriselement måste vara tal utan enheter.

solve_system(A, b) löser A * x = b med avseende på x. Funktionen kräver en kvadratisk matris med en rad per obekant samt en enkel lista med lika många högerled. Den använder exakta bråk, så resultatet saknar avrundningsfel.

Om ekvationerna inte bestämmer en enda lösning visas ett fel som anger att systemet saknar en entydig lösning. Till exempel misslyckas solve_system([[1, 2], [2, 4]], [3, 6]) eftersom den andra ekvationen är den första multiplicerad med två. solve_system hanterar bara linjära ekvationer. För en ekvation som x^2 = 2 använder du solve, som beskrivs under Summering, ekvationslösning och matematisk analys.

Egenvärden

calc

eigenvalues([[2, 1], [1, 2]]) ger [1, 3]

eigenvalues([[4, 1], [2, 3]]) ger [5, 2]

eigenvalues([[0, -1], [1, 0]]) ger [i, -i]

eigenvalues tar en kvadratisk matris och returnerar en enkel lista. En rotation på 90° lämnar ingen riktning oförändrad, så dess egenvärden är det komplexa paret i och -i. Se Komplexa tal. Utgå inte från att listan har en viss ordning.

Faktoriseringar: QR, LU och SVD

Varje uppdelning returnerar en lista med matriser. Använd index för att hämta delarna:

calc

A = [[3, 0], [4, 5]]

parts = qr(A)

q = parts[0] ger [[0.6, -0.8], [0.8, 0.6]]

r = parts[1] ger [[5, 4], [0, 3]]

q * r ger [[3, 0], [4, 5]]

Om du multiplicerar ihop faktorerna får du tillbaka A, vilket gör det lätt att kontrollera en uppdelning. Beräkningar med binära flyttal lämnar små avrundningsrester, omkring 10⁻¹⁵, som Varlig visar som 0 i listor och matriser. De lagrade värdena behåller alla siffror. Jämför därför resultaten visuellt eller genom att undersöka skillnaden, inte med ==.

calc

lu([[2, 1], [4, 3]]) ger [[[0, 1], [1, 0]], [[1, 0], [0.5, 1]], [[4, 3], [0, -0.5]]]

lu returnerar [P, L, U], där P beskriver eventuella radbyten och P * A är lika med L * U. Här har raderna bytt plats så att det större talet, 4, används först.

calc

B = [[3, 1], [4, 7]]

f = svd(B)

u = f[0]

s = f[1]

vt = f[2]

u * [[s[0], 0], [0, s[1]]] * vt ger [[3, 1], [4, 7]]

svd([[3, 4]]) ger [[[1]], [5], [[0.6, 0.8]]]

svd returnerar [U, s, Vt], där s är en enkel lista med singularvärden, störst först. I läroböcker skrivs B som U * diag(s) * Vt. Det finns ingen funktion diag, så bygg diagonalmatrisen själv, till exempel [[s[0], 0], [0, s[1]]].

Funktion	Vad funktionen kräver och returnerar
`identity(n)`	Enhetsmatrisen med `n` rader och `n` kolumner
`shape(A)`	`[rows, columns]`
`transpose(A)`	Rader och kolumner bytta
`det(A)`	Determinant för en kvadratisk matris
`inverse(A)`	Invers av en kvadratisk matris med en icke-noll determinant
`trace(A)`	Summan av diagonalelementen i en kvadratisk matris
`rank(A)`	Antal oberoende rader; vilken rektangulär matris som helst
`solve_system(A,b)`	Lösning av `A * x = b` för en kvadratisk matris med en enda lösning
`eigenvalues(A)`	Egenvärdena för en kvadratisk matris, eventuellt komplexa, utan bestämd ordning
`qr(A)`	`[Q, R]` med `Q * R` ungefär `A`; vilken rektangulär matris som helst
`lu(A)`	`[P, L, U]` med `P * A` ungefär `L * U`; kvadratmatris
`svd(A)`	`[U, s, Vt]` där `s` är en platt lista; vilken rektangulär matris som helst

För en matris som inte är kvadratisk returnerar qr och svd tunna faktorer: för en 3 × 2‑matris är Q också 3 × 2 snarare än 3 × 3.

Vad som är exakt och vad som inte godtas

Addition, subtraktion och multiplikation av matriser, multiplikation med ett tal samt transpose, det och inverse beräknas med exakta bråk för alla matriser som Varlig godtar. Inget avrundas när värden läses in eller förs vidare till en annan beräkning. Därför ger en matris multiplicerad med sin invers exakt enhetsmatrisen:

calc

[[1, 2], [3, 4]] + [[10, 20], [30, 40]] ger [[11, 22], [33, 44]]

[[1, 2], [3, 4]] - [[1, 1], [1, 1]] ger [[0, 1], [2, 3]]

3 * [[1, 2], [3, 4]] ger [[3, 6], [9, 12]]

[[1, 2], [3, 4]] * [[0, 1], [1, 0]] ger [[2, 1], [4, 3]]

det([[1, 2], [3, 4]]) ger -2

inverse([[1, 2], [3, 4]]) ger [[-2, 1], [1.5, -0.5]]

inverse([[1, 2], [3, 4]]) * [[1, 2], [3, 4]] ger [[1, 0], [0, 1]]

Varje villkor kontrolleras innan ett svar visas, och meddelandet anger vilket som misslyckades:

calc

det([[1, 2, 3], [4, 5, 6]]) ger Unsupported: Expected a square matrix

inverse([[1, 2], [2, 4]]) ger Unsupported: Singular matrix has no inverse

[[1, 2], [3, 4]] + [[1, 2, 3], [4, 5, 6]] ger Unsupported: List dimensions do not match

[[1, 2, 3], [4, 5, 6]] * [[1, 2], [3, 4]] ger Unsupported: Matrix inner dimensions do not match

Matriselement måste vara tal utan enheter. Om något element innehåller en enhet, ett valutabelopp eller ett komplext värde stoppas beräkningen i stället för att föra värdet vidare, eftersom ingen matrisoperation skulle bevara det:

calc

det([[1 kg, 2], [3, 4]]) ger Unsupported: Matrix entries must be plain numbers; units, money and complex values are not supported

Bara en lista med rader tolkas som en matris. En enkel lista behåller sin vanliga betydelse: [1, 2] + [3, 4] ger fortfarande [4, 6] genom addition element för element, och [1, 2] * [3, 4] ger fortfarande ett fel som hänvisar till dot.

För exakthetsreglerna för ekvationer, matriser och statistik på ett ställe, se Vad motorn garanterar.

Algoritmer och gränser

det, inverse, rank och solve_system använder exakta bråk inom kalkylatorns gränser för talstorlek. eigenvalues, qr, lu och svd använder binära flyttal, så resultaten är nära approximationer. Iterationerna stoppas efter 10 000 steg.

Matriser vars rader är nästan linjärt beroende, till exempel [[1, 1], [1, 1.0000001]], kallas illa konditionerade. Små avrundningsfel kan växa kraftigt i beräkningarna. Uppdelningar och egenvärden för sådana matriser kan därför förlora noggrannhet. I extrema fall kan de numeriska gränserna överskridas och ett fel visas.

De fullständiga reglerna finns i referensboken för avancerad matematik.

Samlat exempel

Tre kvitton från ett marknadsstånd visar antalet köpta äpplen, bananer och apelsiner samt totalsumman, men inte styckpriserna:

calc

# Each row: apples, bananas, oranges

baskets = [[2, 3, 1], [1, 2, 3], [4, 1, 2]]

paid = [2.15, 2.70, 3.05]

det(baskets) ger 25

prices = solve_system(baskets, paid) ger [0.4, 0.25, 0.6]

# Check the prices against every receipt

baskets * transpose([prices]) ger [[2.15], [2.7], [3.05]]

# What would 5 apples, 2 bananas and 4 oranges cost?

dot([5, 2, 4], prices) ger 4.9

Att determinanten är skild från noll bekräftar att kvittona räcker för att bestämma en uppsättning priser: 40 pence för äpplen, 25 pence för bananer och 60 pence för apelsiner. Om du multiplicerar inköpskorgarna med priserna som en kolumn får du tillbaka totalsummorna. dot beräknar priset för en ny korg till 4,90 £.