Scribd
Upload
18 views

Ejercicio Power Method

The power method is an iterative algorithm for finding the largest eigenvalue and corresponding eigenvector of a matrix. It works by repeatedly multiplying a random starting vector by the matrix, which causes the vector to converge onto the eigenvector corresponding to the largest eigenvalue. In practice, the vector is normalized after each multiplication to avoid overflow or underflow issues. The Rayleigh quotient can also be used to estimate the largest eigenvalue at each step.

Uploaded by

Axel Flores Aranda
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
18 views

Ejercicio Power Method

The power method is an iterative algorithm for finding the largest eigenvalue and corresponding eigenvector of a matrix. It works by repeatedly multiplying a random starting vector by the matrix, which causes the vector to converge onto the eigenvector corresponding to the largest eigenvalue. In practice, the vector is normalized after each multiplication to avoid overflow or underflow issues. The Rayleigh quotient can also be used to estimate the largest eigenvalue at each step.

Uploaded by

Axel Flores Aranda
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 2

Power method

En la práctica, los valores propios de las matrices extensas no se calculan usando el polinomio característico.
Calcular el polinomio resulta muy costoso, y extraer las raíces exactas de un polinomio de grado alto puede
ser difícil de calcular y expresar. En consecuencia, los algoritmos generales para encontrar vectores propios
y valores propios son iterativos. La manera más fácil es el método de las potencias: se escoge un vector
aleatorio y se calcula una secuencia de vectores unitarios. Esta sucesión casi siempre convergerá a un vector
propio correspondiente al mayor valor propio.

Multiplying by a matrix Arepeatedly will exponentially amplify the largest eigenvalue. This is the basis for
many algorithms to compute eigenvectors and eigenvalues, the most basic of which is known as the power
method.

The simplest version of this is to just start with a random vector x and multiply it by A repeatedly. This works,
but has the practical problem that the vector quickly becomes very large or very small, and eventually becomes
too big/small for the computer to represent (this is known as "oveflow/underflow"). The fix is easy: normalize the
vector after each multiplication by A. That is:

Starting with a random x, repeatedly compute

If x was the exact eigenvector, we could just multiply Ax and see how much each component increased: they
would all increase (or decrease) by the same factor. But, for an approximate eigenvector, each component of Ax
will increase by a slightly different amount. Instead, the most common approach is to use the Rayleigh quotient.
If we have an exact eigenvector, so that , then the Rayleigh quotient will gives us exactly . Otherwise, it
is a kind of weighted-average (weighted by the components ) and is a reasonable approximation

A = gallery(3);
[V,D] = eig(A)

V = 3×3
0.3162 -0.4041 -0.1391
-0.9487 0.9091 0.9740
-0.0000 0.1010 -0.1789
D = 3×3
1.0000 0 0
0 2.0000 0
0 0 3.0000

spectralRadius = max(abs(diag(D)))

spectralRadius = 3.0000

[x,lambda] = powerMethod(A)

condicion = logical
1
x = 3×1

1
-0.4174
2.9219
-0.5367
lambda = 3.0000

Largest or dominant eigenvalue (spectral radius). Strictly greater (in absolute value) than the other
eigenvalues.

The method can converge very slowly if is close to 1. And if the two eigenvalues have equal magnitude, the

method may not converge at all.

The smallest eigenvalue can be determined by applying the power method to the matrix inverse of A. For this

case, the power method will converge on the largest value of - in other words, the smallest value of .

function [x, lambda] = powerMethod(A) % power iteration


tolRel = eps;
xp = ones(length(A),1);
MAX = 50;
i = 1;
condicion = true
while condicion
x = (A*xp)/norm(xp);
err = norm(xp-x);
i = i+1;
xp = x;
condicion = err>tolRel && i<=MAX;
end
lambda = dot(x,A*x)/dot(x,x);

end

You might also like