Valores y vectores propios (Método de Leverrier)

Valores propios y vectores propios

El cálculo de los valores propios y de los vectores propios de una matriz simétrica tiene gran importancia en las matemáticas y en la ingeniería, entre los que cabe destacar, el problema de la diagonalización de una matriz, el cálculo de los momentos de inercia y de los ejes principales de inercia de un sólido rígido, o de las frecuencias propias de oscilación de un sistema oscilante.

Se denominan valores propios o raíces características de una matriz cuadrada A, a los valores de λ tales que.

$\det (A - λ E) = | \begin{matrix} a_{00} - λ & a_{01} & ... a_{0 n} \\ a_{10} & a_{11} - λ & ... a_{1 n} \\ ... & ... & ... \\ a_{n - 10} & a_{n - 11} & a_{n - 1 n - 1} - λ \end{matrix} | = 0$

Desarrollando el determinante tenemos un polinomio de grado n. Trataremos de encontrar los coeficientes del polinomio, y luego aplicaremos un método de hallar las raíces del polinomio. Este procedimiento es apropiado cuando se presentan valores propios que no son reales sino complejos.

Una vez hallados los valores propios, para hallar el vector propio X correspondiente al valor propio λ es necesario resolver el sistema homogéneo

$A X = λ X$

donde el vector X es $X = {x_{0}, x_{1,} ... x_{n - 1}}$ Siempre podemos tomar x₀ como 1, y hallar las otras n-1 incógnitas. De las n ecuaciones podemos tomar n-1, y resolver el sistema lineal.

$\begin{array}{l} (a_{11} - λ) x_{1} + a_{12} x_{2} + .... + a_{1 n - 1} x_{n - 1} = - a_{10} \\ a_{21} x_{1} + (a_{22} - λ) x_{2} + .... + a_{2 n - 1} x_{n - 1} = - a_{20} \\ ............................................... \\ a_{n - 11} x_{1} + a_{n - 12} x_{2} + .... + (a_{n - 1 n - 1} - λ) x_{n - 1} = - a_{n - 10} \end{array}$

El método de Leverrier

Dada una matriz cuadrada A de dimensión n. El polinomio característico de la matriz es

$p (λ) = λ^{n} + p_{1} λ^{n - 1} + p_{2} λ^{n - 2} + ... p_{n - 1} λ + p_{n}$

Los coeficientes se hallan mediante las siguientes relaciones

$\begin{array}{l} p_{1} = - s_{1} \\ p_{2} = \frac{1}{2} (s_{2} + p_{1} s_{1}) \\ .......................... \\ p_{n} = - \frac{1}{n} (s_{n} + p_{1} s_{n - 1} + .... + p_{n - 1} s_{1}) \end{array}}$ (1)

Los valores s₁, s₂, ... s_n son las trazas de las potencias de la matriz cuadrada A.

$\begin{array}{l} s_{1} = traza A \\ s_{2} = traza A^{2} \\ .................... \\ s_{n} = traza A^{n} \end{array}} traza A = \sum_{i = 0}^{i < n} a_{i i}$

La traza de una matriz es la suma de los elementos de su diagonal principal.

La codificación en términos de la clase Matriz no reviste dificultad, y tiene dos partes, en la primera se calcula las potencias de la matriz A, y la traza de cada una de ellas, en segundo lugar se calculan los coeficientes p_i del polinomio característico. Para hallar las potencias de la matriz A se emplea un código similar al que empleamos para hallar las potencias de un número. En aquella ocasión la potencia de orden cero de un número es la unidad, en este caso es la matriz unidad de la misma dimensión que A.

        Matriz pot=new Matriz(n);
        for(int i=0; i<n; i++){
            pot.x[i][i]=1.0;
        }

Luego, se calcula las trazas de las distintas matrices pot cuando se van elevando ésta (this) a las sucesivas potencias llamando a la función miembro traza de la clase Matriz, y la guarda en el array s.

        for(int i=1; i<=n; i++){
            pot=Matriz.producto(pot, this);
            s[i]=pot.traza();

El polinomio característico tiene por primer coeficiente la unidad, el resto de los coeficientes se calculan codificando las relaciones (1) en un doble bucle.

        p[0]=1.0;
        p[1]=-s[1];
        for(int i=2; i<=n; i++){
            p[i]=-s[i]/i;
            for(int j=1; j<i; j++){
                p[i]-=s[i-j]*p[j]/i;
            }
        }

Una vez calculados todos los coeficientes del polinomio característicos, la función devuelve el array p. El código completo de la función polCracteristico es el siguiente.

    public double[] polCaracteristico(){
        Matriz pot=new Matriz(n);
//matriz unidad
        for(int i=0; i<n; i++){
            pot.x[i][i]=1.0;
        }
        double[] p=new double[n+1];
        double[] s=new double[n+1];
//potencias de la matriz y traza 
       for(int i=1; i<=n; i++){
            pot=Matriz.producto(pot, this);
            s[i]=pot.traza();
        }
//coeficientes del polinomio característico
        p[0]=1.0;
        p[1]=-s[1];
        for(int i=2; i<=n; i++){
            p[i]=-s[i]/i;
            for(int j=1; j<i; j++){
                p[i]-=s[i-j]*p[j]/i;
            }
        }
        return p;
    }

Ejemplo

Hallar el polinomio característico de la matriz

$(\begin{matrix} 1 & 2 & 3 & 4 \\ 2 & 1 & 2 & 3 \\ 3 & 2 & 1 & 2 \\ 4 & 3 & 2 & 1 \end{matrix})$

El desarrollo del determinante secular mediante el método de Leverrier conduce a la ecuación

$λ^{4} - 4 λ^{3} - 40 λ^{2} - 56 λ - 20 = 0$

Los valores propios o raíces del polinomio característico los podemos calcular mediante el procedimiento del punto medio, el procedimiento de Graeffe, o de Laguerre.

        double[][] p1={{1,2,3,4},{2,1,2,3},{3,2,1,2},{4,3,2,1}};
        Matriz p=new Matriz(p1);
        double pol[]=p.polCaracteristico();
        System.out.println("Polinomio característico");
        for(int i=0; i<pol.length; i++){
            System.out.print((double)Math.round(pol[i]*1000)/1000+" , ");
        }
        System.out.println("");

Vectores propios

Conocidos los valores propios de una matriz simétrica A, se pueden calcular el vector propio X correspondiente a cada valor propio λ.

AX=λX

mediante el siguiente procedimiento. Supongamos una matriz simétrica A de dimensión 4.

$\begin{array}{l} [\begin{matrix} a_{00} & a_{01} & a_{02} & a_{03} \\ a_{10} & a_{11} & a_{12} & a_{13} \\ a_{20} & a_{21} & a_{22} & a_{23} \\ a_{30} & a_{31} & a_{32} & a_{33} \end{matrix}] [\begin{matrix} x_{0} \\ x_{0} \\ x_{0} \\ x_{0} \end{matrix}] = λ [\begin{matrix} x_{0} \\ x_{1} \\ x_{2} \\ x_{3} \end{matrix}] \\ [\begin{matrix} a_{00} - λ & a_{01} & a_{02} & a_{03} \\ a_{10} & a_{11} - λ & a_{12} & a_{13} \\ a_{20} & a_{21} & a_{22} - λ & a_{23} \\ a_{30} & a_{31} & a_{32} & a_{33} - λ \end{matrix}] [\begin{matrix} x_{0} \\ x_{1} \\ x_{2} \\ x_{3} \end{matrix}] = 0 \end{array}$

Conocido el valor propio λ, tenemos un sistema de ecuaciones homogéneo de 4 ecuaciones con 4 incógnitas. Le damos a x₀ el valor arbitrario de 1 y lo convertimos en el sistema de tres ecuaciones con tres incógnitas

$\begin{array}{l} {\begin{cases} a_{10} x_{0} + (a_{11} - λ) x_{1} + a_{12} x_{2} + a_{13} x_{3} = 0 \\ a_{20} x_{0} + a_{21} x_{1} + (a_{22} - λ) x_{2} + a_{23} x_{3} = 0 \\ a_{30} x_{0} + a_{31} x_{1} + a_{32} x_{2} + (a_{33} - λ) x_{3} = 0 \end{cases} \\ {\begin{cases} (a_{11} - λ) x_{1} + a_{12} x_{2} + a_{13} x_{3} = - a_{10} x_{0} \\ a_{21} x_{1} + (a_{22} - λ) x_{2} + a_{23} x_{3} = - a_{20} x_{0} \\ a_{31} x_{1} + a_{32} x_{2} + (a_{33} - λ) x_{3} = - a_{30} x_{0} \end{cases} \\ [\begin{matrix} (a_{11} - λ) & a_{12} & a_{13} \\ a_{21} & (a_{22} - λ) & a_{23} \\ a_{31} & a_{32} & (a_{33} - λ) \end{matrix}] [\begin{matrix} x_{1} \\ x_{2} \\ x_{3} \end{matrix}] = [\begin{matrix} - a_{10} x_{0} \\ - a_{20} x_{0} \\ - a_{30} x_{0} \end{matrix}] \end{array}$

Construimos la matriz M reducida de dimensión 3 y el vector B de términos independientes

MY=B

Despejamos el vector Y (x₁, x₂…x_n)

Y=M^-1·B

El vector propio correspondiente al valor propio λ es

(1, x₁, x₂…x_n)

El procedimiento de calcular los vectores propios falla cuando x₀=0, como puede comprobarse en el ejemplo de la siguiente página. Por lo que se han creado otros procedimientos para calcular los valores y vectores propios.

 public class MyClass1 {
  public static void main(String[] args) {
         double[][] p1={{1,2,3,4},{2,1,2,3},{3,2,1,2},{4,3,2,1}};
        Matriz p=new Matriz(p1);
        double pol[]=p.polCaracteristico();
//raíces del polinomio
        Graeffe g=new Graeffe(pol);
        g.mostrarRaices();
      double[] lambda=g.raicesReales;   //valores propios
//vectores propios
       double[][] p2=new double[p1.length-1][p1.length-1];
       double[] ind=new double[p2.length];
       Vector x;
       Matriz m;
//términos independientes 
      for(int j=0; j<ind.length; j++){
          ind[j]=-p1[0][j+1];
       }
       Vector v=new Vector(ind);
//Matriz reducida M 
      for(int k=0; k<lambda.length; k++){
            for(int i=0; i<p2.length; i++){
                for(int j=0; j<p2.length; j++){
                    p2[i][j]=p1[i+1][j+1];
                    if(i==j) p2[i][j]=p1[i+1][j+1]-lambda[k];
                }
            }
            m=new Matriz(p2);
            System.out.println("Valor propio "+ lambda[k]);
            System.out.println("Vector propio ");
            x=Vector.producto(Matriz.inversa(m), v);
            System.out.println("1");
            System.out.println(x);
       }
    }
}