Jacobi-módszer

Innen: testwiki
Ugrás a navigációhoz Ugrás a kereséshez

A Jacobi-módszer (vagy Jacobi-féle sajátértékmódszer) néven ismert eljárás olyan iteratív módszer, amely kis méretű (n<10) szimmetrikus valós mátrixok sajátértékeinek és sajátvektorainak a meghatározására használható. Ezen módszer célja a mátrix főátlón kívüli elemeinek iteratív eljárással történő kinullázása. A Jacobi-módszer esetén az iterációs lépéseket addig ismételjük, míg egy általunk meghatározott pontosságig az ismeretleneket meg nem határozzuk. Ez azt fogja jelenteni, hogy akkor állunk meg a lépesekkel, mikor már két egymás utáni lépésben kapott ismeretlen értékek különbsége kisebb egy általunk meghatározott értéknél.

Nevét Carl Gustav Jacob Jacobiról kapta, aki először 1846-ban publikálta,[1] de csak az 1950-es években vált elterjedtté a számítógépek fejlődése miatt.[2]

A Jacobi-módszer esetében az iterációs képlet a következő lesz:

xi(k+1)=1aii(bij=1,jinaijxj(k)),i=1,2,,n

Ahhoz, hogy könnyebben megérthessük a módszer elvét, tekintsünk egy példát:

(a11a12a21a22)(x1x2)=(b1b2)

Hogy jobban áttekinthető legyen, átírhatjuk egyenletek formájába, amely így nézhet ki:

{a11x1+a12x2=b1a21x1+a22x2=b2

Innen kifejezhető az x1 és x2 ismeretlen, így a következő egyenleteket kapjuk:

x1=a12a11x2+b1a11,

x2=a21a22x1+b2a22

Az így kapott egyenletrendszert úgy oldhatjuk meg, hogy kezdetben kiindulunk az x1(0), illetve az x2(0) legjobb becslésünkből, vagy az egyszerűség kedvéért indulhatunk 0-ból is. Ezután felhasználva az

x1(k)=a12a11x2(k1)+b1a11,

x2(k)=a21a22x1(k1)+b2a22

lépéseket, eljuthatunk egy jobb közelítő értékig. Ezt addig alkalmazzuk, amíg az ismeretleneket tetszőleges pontossággal meg nem határozzuk.

Leírás

Az olyan transzformációt, ahol egy mátrixszal jobbról és az inverzével balról szorzunk egy mátrixot, hasonlósági transzformációnak nevezzük. A karakterisztikus egyenletet felírva belátható, hogy a hasonlósági transzformáció nem változtatja meg a sajátértékeket. Valós és szimmetrikus mátrixok esetén 𝐑𝟏=𝐑𝐓, vagyis a hasonlósági transzformáció ortogonális transzformáció is egyben. Ezen az összefüggésen alapul a következőkben ismertetett módszer is. Vagyis a megfelelően megválasztott transzformációval a mátrixot diagonalizáljuk. Mivel a sajátvektorok maguk is valósak és ortogonálisak, az 𝐀 szimmetrikus mátrix diagonalizálása megoldható az 𝐑 ortogonális hasonlósági transzformáció segítségével, azaz

𝐑𝐓𝐀𝐑=Λ.

Vegyük példaként a 2×2 típusú mátrix esetét. Ekkor a transzformációhoz használjuk a

𝐑=(cosφsinφsinφcosφ)

síkforgatást leíró mátrixot, ahol φ a forgatás szöge. Ha felírjuk ezzel az 𝐀=𝐑𝐓𝐀𝐑 szimmetria transzformációt, a transzformálás után az 𝐀 mátrix elemei

a11'=a11cos2φ+2a21sinφcosφ+a22sin2φa22'=a11sin2φ2a21sinφcosφ+a22cos2φa21'=a21(cos2φsin2φ)+(a22a11)sinφcosφ=a12'

lesznek. Ha a nem átlós a12' és a21' elemeket 0-vá alakítjuk, az elforgatási szögre a következő egyenletet kapjuk:

cot2φ+a22a11a21cotφ1=0,

melynek alapján

tanφ=[a11a222a12±(a11a222a12)2+1]1.

Innen megkaphatjuk a cosφ=(1+tanφ)1/2 és sinφ=tanφcosφ függvényeket, melyekkel felépítjük a forgatásmátrixot. Az így kapott 𝐀 mátrix diagonális, tehát az átlóban található együtthatók a sajátértékek, míg az 𝐑 forgatásmátrix két oszlopa a sajátértékeknek megfelelő két sajátvektor:

λ1=a11',𝐱(1)=[cosφsinφ];λ2=a22',𝐱(2)=[sinφcosφ].

Általános eset

A következőkben nézzük meg, hogy miként működik ez a módszer általános esetben n×n méretű mátrixok esetén. A sík-forgatás mátrixunk az egységmátrixtól csak az rii,rij,rji,rjj elemekben tér el, vagyis

𝐑ij=(10cosφsinφsinφcosφ01)

Ezt felhasználva az

𝐀=R𝐢𝐣𝐓𝐀𝐑𝐢𝐣

ortogonális hasonlósági transzformációval nullákat viszünk be az aij'és aji' elemek helyére. A szorzás elvégzése után az

aik'=aki'=aikcosφ+ajksinφ,k=1,najk'=akj'=aiksinφ+ajkcosφ,ki,jaii'=aiicos2φ+2ajisinφcosφ+ajjsin2φajj'=aiisin2φ2ajisinφcosφ+ajjcos2φaji'=aji(cos2φsin2φ)+(ajjaii)sinφcosφ=aij'

mátrixelemeket kapjuk eredményül. Ezek közül megköveteljük, hogy az aij' , illetve az aji' elemek 0-ák legyenek. Ekkor a

cot2φ+ajjaiiajicotφ1=0

egyenlethez jutunk, melyet megoldva a forgatás szöge

tanφ=[aiiajj2aij±(aiiajj2aji)2+1]1

lesz.

Meg kell jegyeznünk, hogy amikor egy másik elemet nullázunk ki a következő lépésben, akkor az előzőekben kinullázott elem elromlik. Viszont belátható, hogy bizonyos feltételek mellett az átlón kívüli elemek négyzetösszege egy lépésben 2aij2-tel csökken, vagyis monoton módon tart 0-hoz.

Al-lel jelölve az l. transzformáció utáni mátrixot, a transzformáció-sorozatot a következőképpen írhatjuk:

𝐀𝟎=𝐀,𝐀𝟏=R𝟏𝐓𝐀𝟎𝐑𝟏,𝐀𝟐=R𝟐𝐓𝐀𝟏𝐑𝟐,,𝐀𝐥=R𝐥𝐓𝐀𝐥𝟏𝐑𝐥,,

ahol 𝐑𝐥-el valamely nem-átlós elemre alkalmazott transzformációt jelöltük. Képezzük a transzformációs mátrixok

𝐗𝐥=𝐑𝟎𝐑𝟏𝐑𝐥,l=0,1,2,,

szorzatát. Ha végtelen sok transzformációt végzünk, akkor

liml𝐀𝐥=Λ,liml𝐗𝐥=𝐗

lesz. Ez azt jelenti, hogy ha ezeket a transzformációkat egymás után alkalmazzuk, akkor a mátrix diagonalizálódik, és az átlóban a sajátértékeket kapjuk. A sajátvektorok pedig a transzformációk szorzatmátrixának oszlopaiban lesznek.

A módszer konvergenciáját a tanφ1 feltétel tiszteletben tartása biztosítja, ami egy φπ/4 forgatásnak felel meg. Ezt úgy tudjuk biztosítani, hogy a két gyök közül a "+" előjelest választjuk, amennyiben (aiiajj)/aji>0 és a "−" előjelest az ellenkező esetben. Ezt úgy tudjuk legkönnyebben megvalósítani, hogy a szöget a következőképpen számoljuk:

tanφ=sign(aiiajj2aji)[|aiiajj2aji|+(aiiajj2aji)2+1]1.

Algoritmus

A leírt módszer a következő algoritmus segítségével alkalmazható számítógépre:

from __future__ import division
import math
dim=4

def Jacobi(a,imax,epsilon,x,l):
	for i in range(dim):
		for j in range(dim):
			x[i][j]=0
		x[i][i]=1
		l[i]=a[i][i]
	for it in range (imax):
		amax=0
		for j in range(1,dim,1):
			for i in range (j):
				a[i][i]=l[i]
				a[j][j]=l[j]
				a[j][i]=math.fabs(a[j][i])
				if amax<a[j][i]:
					amax=a[j][i]
				if a[j][i]>epsilon:
					tmp=(a[i][i]-a[j][j])/(2*a[j][i])
					t=1/(math.fabs(tmp)+math.sqrt(1+tmp*tmp))
					if tmp<0:
						t=-t
					c=1.0/(math.sqrt(1+t*t))
					s=c*t
					for k in range(i):
						temp=a[i][k]*c+a[j][k]*s
						a[j][k]=a[j][k]*c-a[i][k]*s
						a[i][k]=temp
					for k in range(i+1,j,1):
						temp=a[k][i]*c+a[j][k]*s
						a[j][k]=a[j][k]*c-a[k][i]*s
						a[k][i]=temp
					for k in range(j+1,dim,1):
						temp=a[k][i]*c+a[k][j]*s
						a[k][j]=a[k][j]*c-a[k][i]*s
						a[k][i]=temp
					for k in range (dim):
						temp=x[k][i]*c+x[k][j]*s
						x[k][j]=x[k][j]*c-x[k][i]*s
						x[k][i]=temp
					tmp=2*s*c*a[j][i]
					l[i]=a[i][i]*c*c+a[j][j]*s*s+tmp
					l[j]=a[i][i]*s*s+a[j][j]*c*c-tmp
					a[j][i]=0
		if amax<=epsilon:
			return 0
	return 666

a=[
	[3,0,2,1],
	[0,1,3,4],
	[2,3,2,1],
	[1,4,1,5]
	]
x=[
	[0,0,0,0],
	[0,0,0,0],
	[0,0,0,0],
	[0,0,0,0]
	]
l=[0,0,0,0]
epsilon=1e-16
imax=1e6
print a
b=Jacobi(a,imax,epsilon,x,l)
print b
print x
print l

Példa

Legyen A=(3021013423211415)

A jacobi a következő sajátértékeket és sajátvektorokat adja:

λ1=3.8614176875601696

η(1)=[0.208479345940251720.92480911132118690.309406558911403560.07437776036050801]

λ2=1.0818507981865024

η(2)=[0.047023207453763960.3341746418337770.90433361663581970.2613366345126636]

λ3=2.741255286528889

η(3)=[0.56415704988770140.093325003379545950.28602000544657120.7689016993677129]

λ4=8.797986800782214

η(4)=[0.79752868496317420.1560315997379720.068123766846277660.5787584029064224]

Jegyzetek

Sablon:Jegyzetek

Források

  • Sablon:Cite book
  • Digitális tankönyvtár/Természettudományok/Matematika/Numerikus módszerek 1./Jacobi-módszer

További információk

Sablon:Refbegin

Sablon:Refend