Block 2: Lineära system

Transkript

1 Exempel Från labben: Block : Lineära system Del 1 Trampolinens böjning och motsvarande matris (här 6060-matris) Matrisen är ett exempel på - gles matris (huvuddelen av elementen nollor) - bandmatris Från labben Från labben Beräkningstid ökar kraftigt med ökande storlek. Hur mycket? Varför? Med LU-faktorisering kan man lösa många system på nästan samma tid som ett sparar exekveringstid Hur kan man kontrollera noggrannhet? Insättning av lösning ej säker Konditionstal har betydelse för noggrannheten på vilket sätt? Och vad är konditionstalet för något? I stora drag Ca 60-70% av exekveringstiden i beräkningsprogram Löpsedel Dagens föreläsning Grundalgoritmer: Gausseliminering med radpivotering Bakåtsubstitution Speciella algoritmer för exempelvis stora, glesa ekvationssystem Algoritmerna gausseliminering och bakåtsubstitution Gausseliminering är instabil Radpivotering för att stabilisera Exekveringstid LU-faktorisering 1

2 Läroboken Mål Linj algebra Ber vet I Kap 9.-3 (s 18-7) Kap (s 36-43) OBS 1 Kursboken ger en ofullständig motivering till behovet av pivotering OBS Kursboken visar inte LU-faktorisering med pivotering, men det ingår i kursen Målen här jämfört med matematikursen Linjär algebra Mål i matematikkursen att kunna lösa små ekvationssystem för hand att teoretiskt förstå egenskaper hos lineära ekvationssystem i allmänhet Mål i vår kurs att kunna lösa stora ekvationssystem med dator att förstå de datoranpassade algoritmerna och deras egenskaper Representation i datorn 1. Ekvationssystemet skrivs som matris/ vektor: Ax = b där A är en nn-matris x och b är n1-vektorer (kolonnvektorer av längd n). I datorns minne lagras ekvationssystemet genom att vi lagrar matrisen A och vektorn b => ekvationssystemet representeras med A och b i datorn. Algoritmerna gausseliminering och bakåtsubstitution Matlabs backslash -operator (\) löser systemet Ax = b: >> x = A\b \ använder Gausselimination baserad på s k LU-faktorisering som standard Intelligent operator väljer automatiskt olika metoder beroende på problemet som ska lösas Gausseliminering grundalgoritmen Algoritmen gausseliminering, naiv version Grundalgoritmen egentligen två algoritmer: 1. Gausseliminering Systemet Ax = b överförs till formen Ux = d, där U är en övertriangulär matris. Bakåtsubstitution Systemet Ux = d löses och lösningen lagras i vektorn x Indata: A, b, n Elementet i A, rad i, kolonn k, betecknas a ik 1. Bilda totalmatrisen Aug = [A b]. För k = 1,,..., n-1 Använd rad k i Aug för att nollställa a ik för i=k+1, k+,..., n

3 Algoritmen gausseliminering, naiv version, pseudokod Algoritmen bakåtsubstitution, pseudokod Indata: A, b, n Bilda totalmatrisen Aug = [A b] För k = 1,,..., n-1: För i = k+1, k+,..., n: faktor = Aug(i,k)/Aug(k,k) Aug(i,k:n+1) = Aug(i,k:n+1) faktoraug(k,k:n+1) OBS minustecknet Indata: U, d, n Efter föregående algoritm finns U i Aug (1:n,1:n) och d i Aug(1:n,n+1) x(n) = d(n)/u(n,n) För i = n-1, n-,..., 1: x(i) = ( d(i) U(i,i+1:n) d(i+1:n) )/U(i,i) Naiv gausseliminering instabil Exempel, beräknat med 3 siffrors noggrannhet Naiv gausseliminering är instabil l 1 = fl(1 / 3) = l 31 = fl(4 / 3) = 1.33 Beteckning: l ik är faktorn som används för att nollställa a ik l 3 = fl(3.33 / 0.333) = 10 3 Exakt lösning är x = 1 x 1 = 1 =>, rel fel: Instabil algoritm håller inte avrundningsfelen i schack utan de ackumuleras till ett större fel i den beräknade lösningen Stabilisera algoritmen genom att införa radpivotering Problemet med den naiva algoritmen: Om l ik > 1 så kommer multiplikation med l ik att förstora avrundningsfel I algoritmen finns Felen förstoras här Aug(i,k:n) = Aug(i,k:n) l ik *Aug(k,k:n) där elementen i Aug innehåller olika fel, t ex avrundningsfel. Om l ik är stor till belopp förstoras dessa fel successivt i processen Stabilisera algoritmen genom att införa radpivotering Åtgärd: Radpivotering För varje nytt k-värde: Hitta rad m så att Aug(m,k) Aug(i,k), i=k, k+1,..., n Byt plats mellan rad m och rad k När l ik skapas divideras då med största elementet i kolonnen Resultat: l ik 1, algoritmen blir stabil OBS! Kursboken ger en alltför förenklad motivering till behovet av pivotering 3

4 Gausseliminering med radpivotering Samma exempel: k=1: k=: l 1 = fl(1 / 4) = 0.5 l 31 = fl(3 / 4) = 0.75 l 3 = fl( 0.5 /.5) = 0. Exekveringstid Hur lång tid kommer det att ta för en dator att exekvera (utföra/köra) algoritmerna? Hur kommer exekveringstiden i Matlab att bli när vi gör kommandot x = A\b? Lämpligt med ett datoroberoende mått på exekveringstiden. Man talar om en algoritms komplexitet. Olika mått för olika typer av algoritmer. Komplexitet hos gausseliminering Ett lämpligt komplexitetsmått är antal aritmetiska operationer. Exekveringstiden kommer väsentligen att vara proportionell mot detta antal. Det intressanta är: hur beror exekveringstiden på antalet ekvationer, n? Vi vill alltså uttrycka komplexiteten som en funktion av n Komplexitetsanalys av gausseliminering 1. Undersök antal operationer för ett godtyckligt k-värde: n-(k+1) st i-värden För i = k+1, k+,..., n faktor = Aug(i,k)/Aug(k,k) 1 op Aug(i,k:n) = Aug(i,k:n) faktor*aug(k,k:n) (n-k) op Slutsats: ca (n-k) aritmetiska operationer för steg k i algoritmen (då har vi bortsett från divisionen och lagt till ett i-värde) 4

5 Komplexitetsanalys (forts) Komplexitetsanalys (forts). Summera antal operationer för samtliga k-värden, k=1,...,n-1 totalt antal operationer =. Slutsats: Gausseliminering av ett - system kräver ca (⅔)n 3 aritmetiska operationer, eller operationer 3. Kan även visa att bakåtsubstitution kräver ca n aritmetiska operationer, eller Vad blir det här i tid? Antag t f = 10-9 s/flyttalsoperation (s/flop) på en viss dator Gausseliminering Bakåtsubstitution n (/3)n 3 t f n t f s s s 500 s 8.3 min 1 år Komplexitetsanalys (forts) Behov av effektiva algoritmer Hur stort system kan lösas på en timme om datorn klarar 1 Gflop/s? (Gflop = 1 miljard flyttalsoperationer) 0.67n s = 1 tim = 3600 s => n Hur stort system kan lösas på en minut? 0.67n s = 60 s => n 4500 Komplexiteten O(n 3 ) begränsar användbarheten hos gausseliminering. Alternativ: Utnyttja struktur hos koefficientmatrisen om möjligt (exempelvis bandmatriser). Fortfarande gausseliminering men lägre komplexitet. Iterativa metoder för mycket stora, glesa system (ingår ej i denna kurs) LU-faktorisering (se längre fram) Dessutom använda speciella högpresterande datorer Behov av effektiva algoritmer Man löser system med ända upp 10 9 obekanta Använder speciella datorer, t ex grids, och speciella beräkningsmetoder Vanligt att lösning av partiella diffar leder till stora linjära ekvationssystem LU-faktorisering Vanlig situation: Följd av ekvationssystem med samma koefficientmatris, olika högerled (jfr trampolinexemplet) Idé: Gausseliminera A en gång för alla - Spara U. - Spara faktorerna l ik i en matris L. - Spara information om pivoteringen i en matris P Detta kallas LU-faktorisering av A. Man kan visa att: LU = PA 5

6 LU-faktorisering, användning LU-faktorisering, vinst Utför en gång: LU-faktorisering Ax=b => PAx = Pb => LUx = Pb För varje högerled b (k) : - Ld = Pb (framåtsubstitution) Bestäm d (vektor) - Ux = d (bakåtsubstitution) Bestäm lösningen x Innebär att man skiljer Gausseliminationen från hantering av högerledet först eliminera enbart matrisen, sedan applicera på högerledet n n Ineffektivt: Lös varje system med x = A\b (gausseliminering av A för varje nytt högerled) aritmetiska operationer Effektivt: LU-faktorisera A (lu(a) i Matlab) och lös sedan varje system med - d = L\b - x = U\d aritmetiska operationer LU-faktorisering i Matlab >> A=[3-1 ;1 0-1;4-3]; >> b= [8;-1;-4]; >> [L,U,P]=lu(A) L = U = P = LU-faktorisering i Matlab Stämmer PA=LU? >> P*A ans = >> L*U ans = Lösning >> d = L\(P*b) d = >> x = U\d x = 1-1 Backslash använder algoritmerna för framåtoch bakåtsubstitution när matriserna är under- respektive övertriangulära LU-faktorisering i Matlab Använder backslash LU-faktorisering? Litet test: >> n = 000; >> A = rand(n,n); >> b40 = rand(n,40); b1 = rand(n,1); >> tic; x = A\b40; toc Elapsed time is seconds. >> tic; x = A\b1; toc Elapsed time is seconds. 40 system med samma matris löses nästan lika fort som 1 system => LU-faktorisering OBS 40 högerled lagrade [b 1 b b 40 ] Ett exempel Matematiskt objekt Matris Datastruktur Matris Vektor p

7 Eliminering av x 1 : l 1 =-1/, l 31 =1/ / 1-1 1/ 4 8 OBS! Hela rader byter plats Eliminering av x : l 3 =1/ Klart! Tolkning av datastrukturernas innehåll: LU = PA = / / 1 / Slutsats: LU = PA 4 = = 3 9 L och U sparas i A:s minnesutrymme P lagras som en vektor (inga nollor lagras) 7