lineaarialgebra1

2276 days ago by maarvi

Matriisilaskennan perusasioita

Ari Virtanen 7.1.2012

jaa palautettavat laskenta-arkit käyttäjätunnukselle MOkes

Matriisit, determinantit ja lineaariset yhtälöryhmät


Otsikot ja esimerkkien ja lauseiden numerointi viittaa Pentti Haukkasen monisteeseen Lineaarialgebra 1, joka on saatavavilla netistä http://www.uta.fi/sis/mtt/mttmp3/lineaarialgebra1a.pdf


Tämän laskenta-arkin esitystavassa oletetaan, että lukija on jo perehtynyt Sagen peruskäyttöön.


Pikaoppaasta quickref-linalg.pdf löytyy hyödyllisiä komentoja.

Pikaoppaat löytyvät osoitteesta http://wiki.sagemath.org/quickref ja matemaattisten ohjelmistojen Moodle-sivustolta.

#Matriisin muodostaminen #Esimerkki 1.1.1 # A = matrix([[1,5,-1,0],[4,2,sqrt(2),6],[1,0,1,1/2]]) show(A) 
       
A2 = matrix(3,4, [1,5,-1,0,4,2,sqrt(2),6,1,0,1,1/2]) show(A2) 
       
A2[0,0] 
       
#ei toimi alkio(M,i,j) = M[i-1,j-1] 
       
#matriisin alkio #Sagessa numerointi alkaa nollasta def alkio(M,i,j): #matriisin M alkio m_ij return M[i-1,j-1] #HUOM. 
       
alkio(A,2,1), A[1,0], alkio(A,1,2), A[0,1] 
       
#kaksi matriisia ovat samat, jos niillä on samat dimensiot ja samat alkiot A = matrix([[1,2],[3,4]]) B = matrix([[1,2],[3,4]]) C = matrix([[1,2],[3,5]]) D = matrix([[1,2],[3,4],[0,0]]) A == B, A == C, A == D 
       
#vektori #vektori ei ole Sagessa sama kuin vastaava matriisi A = matrix([1,2,3]) B = matrix(3,1,[1,2,3]) a = vector([1,2,3]) A,B,a, A == a, B == a, A == B 
       
#neliömatriisi B = matrix(3,[1,2,3,5,4,-3,0,7,-1]) #täyttöjärjestys riveittäin show(B) 
       
#diagonaalialkiot B.diagonal() 
       
#diagonaalimatriisin konstruktio B2 = diagonal_matrix([3,5,0,1,2,2]) show(B2) 
       
#nollamatriisi Nolla = matrix(3,3,0) show(Nolla) 
       
#muodostetaan nollamatriisista sama diagonaalimatriisi kuin yllä Nolla[0,0] = 3; Nolla[1,1] = 5 show(Nolla) 
       
#Millainen matriisi on matrix(m,n,x)? Kokeile. m = 2; n = 5 matrix(10,10,x) x * identity_matrix(10) 
       
#alimatriisit #muodostetaan ensin matriisi M, jonka alkiot ovat kokonaislukuja M = matrix([[1,2,0],[2,4,-1]]) show(M) 
       
#rivi M[0],M.row(0) 
       
#sarake M[:,0],M.column(0) 
       
show(M) 
       
#yleinen alimatriisi M.matrix_from_rows_and_columns([0,1],[0,1]) 
       
############################################################## 
       

Matriisien laskutoimitukset

#Esimerkkiaineistoina käytetään satunnaisluvuista generoituja kokokonaislukuarvoisia matriiseja A = random_matrix(ZZ, 2,3) B = random_matrix(ZZ, 2,3) show(A);show(B) 
       
#yhteenlasku A + B 
       
#skalaarilla kertominen 10 * A 
       
#matriisin sarakkeiden ja rivien lukumäärä A = matrix([[1,2,3],[4,5,6]]) A, A.nrows(), A.ncols() 
       
#Matriisien kertolasku # #tulo AB määritelty, kun A:ssa on yhtä monta saraketta kuin B:ssä riviä A.ncols() == B.nrows() 
       
#katso virheilmoitus A*B 
       
#uudet esimerkkimatriisit A = random_matrix(ZZ, 3,3) B = random_matrix(ZZ, 3,3) show(A*B) show(B*A) 
       
 
       
I^2 
       
#nyt dimensiot kunnossa A.ncols() == B.nrows() 
       
show(A*B) 
       
##################################### #EXTRA koodaamisesta kiinnostuneille# ##################################### #Lasketaan tulo kaavan mukaisesti #funktion määrittelyssä useita uusia asioita, #joiden osaamista ei tällä kurssilla edellytetä. def tulon_alkio(A,B,i,j): var('k') if (i < 1) | (i > A.nrows()): print('Virhe, 3. argumentti ilmoittaa tulomatriisin rivin') print('Arvon pitää olla väliltä 1 -- ensimmäisen matriisin rivien LKM') elif (j < 1) | (j > B.ncols()): print('Virhe, 4. argumentti ilmoittaa tulomatriisin sarakkeen') print('Arvon pitää olla väliltä 1 -- toisen matriisin sarakkeiden LKM') elif A.ncols() == B.nrows(): sarakkeetLKM = A.ncols() kaava = '' symbkaava = 'AB(' +str(i)+','+str(j)+') = \n' summa = 0 for k in range(sarakkeetLKM): if k < sarakkeetLKM-1: loppu = ' + ' else: loppu = ' = ' symbkaava = symbkaava + 'A(' + str(i) + ',' + str(k+1) + ')*B('+str(k+1) + ',' + str(j)+ ')'+loppu kaava = kaava + str(A[i-1,k]) + '*' + str(B[k,j-1])+loppu summa = summa + A[i-1,k]*B[k,j-1] print symbkaava print(kaava+str(summa)) # return summa else: print("Tulo ei määritelty, tarkista dimensiot") 
       
x = 1 x 
       
show(A) 
       
show(B) 
       
#kokeile ja vertaa (A ja B pitää olla määritelty) i = 1; j = 2 tulon_alkio(A,B,i,j) (A*B)[i-1,j-1] 
       
A.row(0) * B.column(1) 
       

Matriisialgebraa

#vastamatriisi A = random_matrix(ZZ, 2,3) show(A) show(-A) show(A + (-A)) 
       
#matriisien erotus A = random_matrix(ZZ, 3,2) B = random_matrix(ZZ, 3,2) A, B, A - B 
       
#identiteettimatriisi n = 5 #tms. show(identity_matrix(n)) 
       
A = random_matrix(ZZ, 3,3) (A == A*identity_matrix(3)) 
       
#Käänteismatriisi A = matrix([[2,-5],[-1,3]]) B = matrix([[3,5],[1,2]]) show(A) show(B) 
       
show(A*B) show(B*A) A*B == identity_matrix(2) 
       
#Käänteismatriisin laskeminen A.inverse(),A^(-1),A^(-1) == B 
       
#lyhenne käänteismatriisille A.I 
       
#Neliömatriisin potenssit A, A^0, A^2, A^5, A^5 == A*A*A*A*A 
       
A = matrix([[1,1,1],[1,2,1],[1,1,3]]) 
       
A^(-1), (A^(-1))^(-1), (A^(-1))^(-1) == A 
       
#Transpoosi A = matrix([[1,2], [3,4], [5,6]]) show(A) show(transpose(A)) show(A.transpose()) 
       
#lyhenne transpoosille A.T 
       
#Symmetrinen matriisi var('a,b,c,d,e,f') M = matrix(3,[a,d,e,d,b,f,e,f,c]) show(M) show(transpose(M)) 
       
M == transpose(M) 
       
#Symmetrisyyden toteaminen suoralla komennolla M.is_symmetric() 
       

Determinantti ja kofaktori

#determinantti voidaan laskea suoraan usealla komennolla A = matrix([[3,1,0],[4,0,2],[5,5,5]]) A, det(A), A.det(), A.determinant() 
       
##################################### #EXTRA koodaamisesta kiinnostuneille# ##################################### #funktio, joka laskee kofaktorin C_ij #ensin alimatriisi, joka saadaan poistamalla i. rivi ja j. sarake def alimatriisi(M,i,j): #1. rivi on i=1 jne Sagei = i-1 Sagej = j-1 n = M.ncols() rivit = range(0,Sagei) + range(Sagei+1, n) sarakkeet = range(0,Sagej) + range(Sagej+1, n) alimatriisi = M.matrix_from_rows_and_columns(rivit,sarakkeet) return alimatriisi #Minori M_ij on alimatriisin, joka saatu poistamalla i. rivi ja j. sarake, determinantti def minori(M,i,j): return det(alimatriisi(M,i,j)) #Kofaktori C_ij saadaan kertomalla minori M_ij termillä (-1)^(i+j) def kofaktori(M,i,j): return (-1)^(i+j)*minori(M,i,j) 
       
#Esimerkki 1.5.1 A = matrix([[3,1,-4],[2,5,6],[1,4,8]]) 
       
alimatriisi(A,1,1),minori(A,1,1),kofaktori(A,1,1) 
       
alimatriisi(A,3,2), minori(A,3,2), kofaktori(A,3,2) 
       
var('a_11, a_12, a_13, a_21, a_22, a_23, a_31, a_32, a_33') A = matrix(3,[a_11, a_12, a_13, a_21, a_22, a_23, a_31, a_32, a_33]) show(A) 
       
#Lause 1.5.4 show(expand(det(A))) 
       
#Lauseen 1.5.1 havainnollistus edellä määritellylle 3x3 -matriisille def apu(k): return alkio(A,1,k)*kofaktori(A,1,k) show(apu(1) + apu(2) + apu(3)) 
       
show(expand(apu(1) + apu(2) + apu(3))) 
       
bool(det(A) == apu(1) + apu(2) + apu(3)) #vertailu ei palauta totuusarvoa ilman komentoa 'bool' 
       
#Matriisin A kaikki kofaktorit saa Sagessa myös suoraan muodostamalla #matriisin A adjugaatin (ks. monisteen s. 19) komennolla A.adjoint() A = matrix([[3,1,-4],[2,5,6],[1,4,8]]) adjA = A.adjoint() show(adjA) 
       
#Nyt kofaktori C_ij on adjugaatin transpoosin i. rivin, j. sarakkeen alkio show(transpose(adjA)) show(matrix([[kofaktori(A,1,1), kofaktori(A,1,2), kofaktori(A,1,3)], [kofaktori(A,2,1), kofaktori(A,2,2), kofaktori(A,2,3)], [kofaktori(A,3,1), kofaktori(A,3,2), kofaktori(A,3,3)]])) 
       
#alakolmiomatriisin determinantti var('a b c d e f') A = matrix([[a,0,0],[b,c,0],[d,e,f]]) det(A) 
       
##################################################### #Lauseen 1.5.6 havainnollistus # #Tehdään ensin apufunktio 'teeMatriisi', jonka avulla voi nopeasti generoida symbolisia matriisi 
       
##################################### #EXTRA koodaamisesta kiinnostuneille# ##################################### def teeMatriisi(kirjain,rivit,sarakkeet): #muodostaa rivit x sarakkeet matriisin, jonka yleinen alkio on kirjain_ij #muuttuja kirjain on annettava lainausmerkkien sisällä #Esimerkki teeMatriisi('a', 2, 2) palauttaa matriisin #[a_11 a_12] #[a_21 a_22] #Lähde: http://ask.sagemath.org/question/505/symbolic-matrices s = join([kirjain + '_%d%d' %(i,j) for (i,j) in CartesianProduct(range(1,rivit+1),range(1,sarakkeet+1))]) alkiot = var(s) matriisi = matrix(SR,rivit,sarakkeet,alkiot) return(matriisi) 
       
#muodostetaan yleinen 4 x 4 matriisi A = teeMatriisi('a',4,4) show(A) 
       
#muodostetaan matriisista A uusi matriisi B vaihtamalla 2. ja 3. rivi keskenään B = 1 * A #kokeile, miksei pelkka B = A ei toimi; myös komentoa 'copy' voi käyttää B[1,:] = A[2,:] #huomaa, että numerointi alkaa nollasta B[2,:] = A[1,:] show(B) show(A) 
       
#vertaillaan matriisin A ja B determinantteja #kun kaksi riviä (tai saraketta) vaihdetaan keskenään, determinantin merkki vaihtuu bool(det(A)== -1 * det(B)) 
       
#muodostetaan matriisista A uusi matriisi B kertomalla 2. rivi skalaarilla k var('k') B = 1*A B[1,:] = k* B[1,:] show(A) show(B) 
       
#kun matriisin rivi kerrotaan skalaarilla k, determinantti tulee k-kertaiseksi bool(det(B) == k*det(A)) 
       
#muodostetaan matriisista A uusi matriisi B lisäämällä #1. rivi skalaarilla k kerrottuna 3. riviin #determinantin arvo ei tällöin muutu B = 1 * A B[2,:] = B[2,:] + k * B[0,:] show(B) bool(det(B) == det(A)) 
       
#Lause 1.5.7 #testataan Sagea muodostamalla yleinen nxn -matriisi, jonka yksi rivi on nollia #Huom. Sage ei selviydy testistä järkevässä ajassa "isoilla" n:nnän arvoilla n = 5 A = teeMatriisi('a',n,n) A[1,:] = matrix(1,n,0) det(A) 
       
#Lause 1.5.7 #käytetään numeerisia testimatriiseja #nyt ei ole vaikeuksia n = 100 A = random_matrix(ZZ, n,n) A[5,:] = matrix(1,n,0) det(A) 
       
#lause 1.5.8 n = 10 testienLKM = 10 for i in range(testienLKM): A = random_matrix(ZZ, n,n) #huomaa, että laskutarkkuus saattaa pettää kun A = random_matrix(RR, n,n) print(det(A) == det(transpose(A))) 
       
#Lause 1.5.8 #Testataan tulon determinantti -sääntöä nxn -matriiseille #ainakin testi n = 3 menee läpi n = 3 A = teeMatriisi('a',n,n) B = teeMatriisi('b',n,n) bool(det(A*B) == det(A)*det(B)) 
       
#Valitse ensin jokin matriisi A ja tutki, milloin #det(A+B) == det(A) + det(B) #Tässä esimerkkinä 2x2 tapaus A = matrix([[1,2],[3,4]]) var('x y u v') B = matrix([[x,y],[u,v]]) solve(det(A+B) ==det(A) + det(B),x,y,u,v) 
       
#ratkaisu B = matrix([[1/2*u - 1/4*v + 3/4*y,y],[u,v]]) show(B) 
       
#tarkistus bool(det(A + B) == det(A) + det(B)) 
       

Käänteismatriisin kaava ja olemassaolo

#Tutkitaan, riittääkö Sagen laskentatarkkuus #kaavan A^(-1) = (1/det(A)) adj A #oikeaksi toteamiseen #Aloitetaan esimerkillä 1.6.1 A = matrix([[3,1,0],[4,0,2],[5,5,5]]) show(A) show(A^(-1)) show((1/det(A))*A.adjoint()) bool(A^(-1) == (1/det(A))*A.adjoint()) 
       
#Seuraavaksi satunnainen liukukuarvoinen matriisi A =random_matrix(RR,3,3) show(A) show(A^(-1)) show((1/det(A))*A.adjoint()) show(bool(A^(-1) == (1/det(A))*A.adjoint())) erotusMatriisi = A^(-1) - (1/det(A))*A.adjoint() maxero = max(max([erotusMatriisi[i] for i in range(eroMatriisi.nrows())])) minero = min(min([erotusMatriisi[i] for i in range(eroMatriisi.nrows())])) show(maxero) show(minero) 
       
#Laskutarkkuuden rajoissa kaava siis näyttäisi pätevän #Miten Sagessa voisi yhtäsuuruus -vertailussa huomioida laskutarkkuuden? #HUOM. yllä korjattu tapa, millä suurin ja pienin alkio otetaan matriisista 
       
#Esimerkki 1.6.2 A = matrix([[1,1],[0,1]]) B = matrix([[1,1],[0,0]]) print "det(A) = ",det(A) print "A^(-1) =" show(A.I) print "det(B) = ",det(B) print "B^(-1) = (virheilmoitus odotettavissa)" show(B.I) 
       
#Eräitä huomioita käänteismatriisin laskemisesta Sagella # #Ensinnäkin huomaa, että A = [[1,1],[0,1]] on lista, ei matriisi, #ja käänteismatriisia ei voi laskea A = [[1,1],[0,1]] A^(-1) #antaa virheilmoituksen 
       
#Komentoa 'random_matrix' antaessa täytyy antaa rengas #(ZZ kokokonaisluvut,RR reaaliluvut), josta satunnaiset alkiot generoidaan #Tarkastellaan määreiden 'RR' ja 'ZZ' merkitystä tarkemmin 
       
A1 = matrix(ZZ,[[1,0],[0,3]]) A2 = matrix(RR,[[1,0],[0,3]]) A3 = matrix([[1,0],[0,3]]) A1.I, A2.I, A3.I 
       
#B1 = matrix(ZZ,[[1,0],[0,sqrt(3)]]) ei onnistu B2 = matrix(RR,[[1,0],[0,sqrt(3)]]) B3 = matrix([[1,0],[0,sqrt(3)]]) B2.I, B3.I