Metoda potęgowa - szukanie największej wartości własnej

[kedzior123]

Witam,
bardzo proszę kogoś o wytłumaczenie mi dlaczego gdy stosuję się do algorytmu metody potęgowej (matlab):
function [ output_args ] = zadanie_3_8N( )
A = [19/12 13/12 5/6 5/6 13/12 -17/12 ;
13/12 13/12 5/6 5/6 -11/12 13/12 ;
5/6 5/6 5/6 -1/6 5/6 5/6 ;
5/6 5/6 -1/6 5/6 5/6 5/6 ;
13/12 -11/12 5/6 5/6 13/12 13/12 ;
-17/12 13/12 5/6 5/6 13/12 19/12 ];
n=6;
x(1:n) = (1:6); %byle jaki wektor [1 2 3 4 5 6]
x = x/norm(x); %normalizujemy go do długosci 1 (norma eukildesowa)
x = transpose(x); %obracamy go
for i = 1:100 % 100 iteracji
x = A*x; % według algorytmu
x = x/norm(x); % kolejna normalizacja
end
x %wyświetlenie wektora własnego

to wówczas wychodzą mi jakieś bzdury:
x =
0.40824829046377
0.40824829046386
0.40824829046386
0.40824829046386
0.40824829046386
0.40824829046396

ale gdy linię :
x = x/norm(x);
zamienię na:
x = x/x(1); % weź pierwszą wartość wektora x : x1

to zbiega mi poprawnie do wektora własnego powiązanego z największą wartością własną. Bez względu na to jaki wybrałem wektor początkowy. Nawet gdy rezygnowałem z normalizacji losowego początkowego wektora działało!
x =
1.00000000000000
1.00000000000023
1.00000000000023
1.00000000000023
1.00000000000023
1.00000000000046

Rozwiązanie z x(1) spotkałem gdzieś na internecie. Ale nie rozumiem dlaczego ono działa. A tak jak powinno być według algorytmu nie działa...

Bardzo proszę o pomoc i jakąś wskazówkę.

300903.htm

Pozdrawiam

[Zordon]

A jaki wektor ma wyjść? Jak dla mnie to pierwszy i drugi x są równe z dokładnością do skalowania.

[kedzior123]

Powinno wyjść ~[1 1 1 1 1 1]

tutaj są wszystkie poprawne wyniki
}}

-- 1 lut 2014, o 21:37 --

to co wyjdzie powinno spełniać równość

\(\displaystyle{ Ax = x*lambda}\)

gdzie \(\displaystyle{ lambda}\) to wartość własna czyli tutaj 4.

[Zordon]

No to przecież wyszło dobrze.

[kedzior123]

No właśnie wyszło dobrze gdy zamiast podzielić x/norm(x) podzieliłem x/x(1) czyli przez pierwszą wartość wektora x.

I nie mam bladego pojęcia dlaczego to drugie działa. A bez zrozumienia tego nie wiem jak przebudować program by wyszukiwał 2 największe na moduł wartości własne macierzy.

Bo mam algorytm na 2 największą wartość własną następujący:

Założenia:
||y1|| = 1 gdzie |||| to chyba norma2 euklidesa
e1^T y1 = 0 gdzie e1 to chyba(?) wektor powiązany z wartością własną największej przez moduł.

Iteracje:
Ayk = zk
zk = zk - e1*[(e1^T)*zk] gdzie T to transpozycja
y(k+1) = zk/||zk||

[Zordon]

Nie rozumiem, piszesz że dostałeś wynik:

Kod: Zaznacz cały

x =
0.40824829046377
0.40824829046386
0.40824829046386
0.40824829046386
0.40824829046386
0.40824829046396

Dlaczego on jest niby zły?
Policz \(\displaystyle{ Ax}\)

[kedzior123]

Już wiem skąd mój brak zrozumienia.

Nie rozumiałem sensu działania algorytmu.
Po wielu x(k+1)=A*x + normalizacja x
dostajemy po prostu wektor którego norma to poszukiwana wartość własna.

Ja znalazłem gdzieś dziwnie zniekształcony algorytm gdzie normalizowało się "x" przez "x1".

Wyszedł mi wówczas wektor własny z samych jedynek co ładnie wyglądało i przekonało mnie że wynik gdzie niema samych jedynek jest zły. Tym bardziej że na Wolframie wszystkie wektory były ładnie znormalizowane by były same jedynki i tym bardziej mnie to utwierdziło w błędnym przekonaniu.

Jednak wszystko działa OK.
Dziękuje za naprowadzenie mnie.