> A:=matrix([[2,1,1],[3,1,-1],[1,-2,-4]]): > b:=vector([10,6,-10]): > Ab:=augment(A,b); [2 1 1 10] [ ] Ab := [3 1 -1 6] [ ] [1 -2 -4 -10] > with(linalg):gausselim(Ab); [2 1 1 10] [ ] [0 -1/2 -5/2 -9] [ ] [0 0 8 30] > backsub("); [7/2, -3/4, 15/4] > # toinen tapa ratkaista: > linsolve(A,b); [7/2, -3/4, 15/4] > ##################### > # teht. 2 > ##################### > # ensin m=20, n=20, luultavasti 1-kasitt. ratkaisu. > ?randmatrix > a1:=randmatrix(20,21): # kokonaislukumatriisi > # a1:n sarakkeita on 21 kpl, viimeinen sarake on 'b'. > gausselim(a1):evalf("); > backsub("):evalf("); # tai suoraan evalf(backsub(")); [-34.28486420, 18.28823848, -19.09095620, 1.508460503, 18.50899448, -31.99176535, -48.79068443, 2.965294682, -4.141919942, 26.73819697, -9.999100133, -33.26685295, 27.08896739, -6.840266989, 21.92433535, -2.343407770, 10.57497519, -19.96356312, -.02523143773, -39.38401694] > # nakojaan 1-kasitteinen ratkaisu. > # sitten m=20, n=25: ainakin 5 vapaata parametria, jos ratkaisu on olemassa. > a2:=randmatrix(20,26): > gausselim(a2):evalf("); > backsub("):evalf("); [.3153569033 + .3814320633 _t[2] - 1.555052625 _t[5] - .9501854299 _t[1] + 2.069857618 _t[4] - .4715497573 _t[3], .6678579334 - 1.011261097 _t[2] - .6402577909 _t[5] + .04112885278 _t[1] - .3636551964 _t[4] + .3050205542 _t[3], -.0002702507143 - .9491740945 _t[2] + .5412405845 _t[5] - 1.253293587 _t[1] + 1.083006450 _t[4] + .2011574636 _t[3], -.3581478906 - 3.172350403 _t[2] - .8436410500 _t[5] + .5567972549 _t[1] - 1.851271335 _t[4] + .3902578189 _t[3], -.2652656542 + .1670000410 _t[2] - .4830021102 _t[5] + .8928323430 _t[1] - 1.428231534 _t[4] - .03583122938 _t[3], -1.217841724 + .02883171427 _t[2] + .1526328012 _t[5] - .2576886036 _t[1] - .9618894699 _t[4] + .09719071984 _t[3], -1.043110486 - .9193690995 _t[2] - .03797093438 _t[5] + .7355418038 _t[1] - 2.510245020 _t[4] + .09988410633 _t[3], -.9357354968 - 1.016058691 _t[2] - .9704410697 _t[5] - 1.924969260 _t[1] + .1994620434 _t[4] + .4110584952 _t[3], -.3746066806 - 3.579265475 _t[2] - .3843793971 _t[5] + .2337267095 _t[1] - 2.736267500 _t[4] + 1.573534396 _t[3], -.4704327192 - .1852465081 _t[2] - .3453740403 _t[5] - .9934065424 _t[1] + .8247621055 _t[4] + .2036637447 _t[3], -.7778026791 - .6415894883 _t[2] - .4491882161 _t[5] - .6346554332 _t[1] - .5323256829 _t[4] + .1693809922 _t[3], 1.490589910 - .8693064823 _t[2] + .4395182437 _t[5] - .5612343062 _t[1] + 1.044002854 _t[4] + .7278175651 _t[3], .5602602571 - 2.268847464 _t[2] - .6355731470 _t[5] - .6201199370 _t[1] - .6691433061 _t[4] + .5732069691 _t[3], 1.378622437 + 1.626744069 _t[2] + 1.603330228 _t[5] + 1.093194855 _t[1] + .6974912209 _t[4] - .3004936184 _t[3], 1.062307975 + .04212043665 _t[2] + 1.076302805 _t[5] + 1.549738673 _t[1] - 1.216929953 _t[4] + .05456300175 _t[3], -.8710339165 - .5913107615 _t[2] - .7998780775 _t[5] + 1.306237862 _t[1] - 1.992949726 _t[4] - .2565954430 _t[3], -1.545620203 - 1.234085082 _t[5] + .2398832071 _t[4] - .8031838012 _t[3] + .7034586232 _t[2] - .4648101989 _t[1], 1.255852917 + 1.178516610 _t[5] - 1.031588253 _t[4] + .6335713079 _t[3] - 1.628216945 _t[2] + .3520904007 _t[1], .8138641468 + .3339749348 _t[5] + .4640289669 _t[4] + .01289360371 _t[3] - .2788693524 _t[2] + 1.234362738 _t[1], -.8891054176 - .7622548321 _t[5] - .5609298042 _t[4] + .8742829744 _t[3] - 2.101289894 _t[2] - .8621940530 _t[1], _t[5], _t[4], _t[3], _t[2], _t[1]] > # ok, vapaita parametreja t1,..,t5 eli 5 kpl. > # sitten c)-kohta, m=30, n=20. ylimaaraytynyt, luultavasti ratkaisua ei ole olemassa. > a3:=randmatrix(30,21): > evalf(gausselim(a3)); > evalf(backsub(")); Error, (in backsub) inconsistent system > # ratkaisua ei olemassa. > ###################################### > # teht. 5 > ###################################### >with(linalg): # Ellei jo tehty >A:=matrix(3,3,[371,-76,-40,36,-7,-4,-176,36,19]); [ 371 -76 -40] [ ] A := [ 36 -7 -4] [ ] [-176 36 19] > yks:=diag(1,1,1); [1 0 0] [ ] yks := [0 1 0] [ ] [0 0 1] > gaussjord(augment(A,yks)); [1 0 0 11 4 24] [ ] [0 1 0 20 9 44] [ ] [0 0 1 64 20 139] > # eli kaanteismatriisi luetaan oikeasta puoliskosta. Tarkistus: > # Jos haluttaisiin poimia tuo matriisin osa jatkohommia varten, niin: > B:=submatrix(",1..3,4..6); [ 11 4 24 ] [ ] B := [ 20 9 44 ] [ ] [ 64 20 139 ] ># Tarkistus > evalm(A&*B); [ 1 0 0 ] [ ] [ 0 1 0 ] [ ] [ 0 0 1 ] > # tai: > inverse(A); [11 4 24] [ ] [20 9 44] [ ] [64 20 139] > ########################### > # teht. 6 > ########################### > ?GramSchmidt > v1:=vector([1,1,0]);v2:=vector([2,-1,1]);v3:=vector([1,0,3]); v1 := [1, 1, 0] v2 := [2, -1, 1] v3 := [1, 0, 3] > gram:=GramSchmidt([v1,v2,v3]); -8 24 gram := [[1, 1, 0], [3/2, -3/2, 1], [--, 8/11, --]] 11 11 > # GramSchmidt ei normeeraa, normeeraus pitaa hoitaa muulla tavalla: > norm(gram,2); 1/2 8/11 11 > # ei toiminut, norm laski vain viimeisen vektorin normin. Kaytetaan map-komentoa (kts. ?map): > normit:=map(norm,gram,2); 1/2 1/2 1/2 normit := [2 , 1/2 22 , 8/11 11 ] > for i to 3 do ortonr[i]:=gram[i]/normit[i] od; 1/2 ortonr[1] := 1/2 [1, 1, 0] 2 1/2 ortonr[2] := 1/11 [3/2, -3/2, 1] 22 -8 24 1/2 ortonr[3] := 1/8 [--, 8/11, --] 11 11 11 > # ja kootaan tulos yhdeksi matriisiksi: > ortonormaalit:=[ortonr[1],ortonr[2],ortonr[3]]; 1/2 1/2 ortonormaalit := [1/2 [1, 1, 0] 2 , 1/11 [3/2, -3/2, 1] 22 , -8 24 1/2 1/8 [--, 8/11, --] 11 ] 11 11 > expand(ortonormaalit); # sieventaa eri muotoon. 1/2 1/2 1/2 1/2 1/2 [[1/2 2 , 1/2 2 , 0], [3/22 22 , - 3/22 22 , 1/11 22 ], 1/2 1/2 1/2 [- 1/11 11 , 1/11 11 , 3/11 11 ]] > # Huom! toinen, helpompi tapa: > ortonormaalit2:=seq(gram[i]/normit[i],i=1..3); 1/2 1/2 ortonormaalit2 := 1/2 [1, 1, 0] 2 , 1/11 [3/2, -3/2, 1] 22 , -8 24 1/2 1/8 [--, 8/11, --] 11 11 11 > expand([ortonormaalit2]); 1/2 1/2 1/2 1/2 1/2 [[1/2 2 , 1/2 2 , 0], [3/22 22 , - 3/22 22 , 1/11 22 ], 1/2 1/2 1/2 [- 1/11 11 , 1/11 11 , 3/11 11 ]] > # Huom! GramSchmidt toimii eri tavalla, kun kaytetaan aaltosulkuja: > GramSchmidt({v1,v2,v3}); 24 -24 -8 {[1, 1, 0], [1/2, -1/2, 3], [--, ---, --]} 19 19 19 > # Tämä johtuu siitä, että aaltosulut ovat joukkosulut, joukon alkioilla > # ei ole järjestystä, Maple päättää itse, missä järjestyksessä otetaan, > # Gram-Schmidt-prosessi riippuu järjstyksestä. ## Kaikkein elegantein ratkaisu on: > map(normalize,gram); # eli koko homma näin: > with(linalg): > v1:=vector([1,1,0]);v2:=vector([2,-1,1]);v3:=vector([1,0,3]); > gram:=GramSchmidt([v1,v2,v3]); > map(normalize,gram); # normalize tekee juuri normeerauksen 2-normin suhteen. # map # toimii yleisesti näin: # Olkoon f jokin Maple-funktio (itse määritelty tai Mapleen kuuluva) # Olkoon esim x:=[x1,x2,x3] ja halutaan laskea [f(x1),f(x2),f(x3)]. # Jotkut funktiot toimivat niin, että f(x) tekee homman. Ne, jotka eivät toimi, # saadaan map:n avulla tekemään se, eli "mapataan" f listan alkioille. # map(f,x); # Tämä toimii monille muillekin tietorakenteille (esim. jonkin # sievennysfunktion mappaaminen lausekkeen osille on usein kätevää.)