libreria - matrix java api

Elevando una matriz al método de poder JAVA

Question

Me está costando mucho crear un método para elevar una matriz a la potencia. Intenté usar esto

public static int powerMethod(int matrix, int power) {
    int temp = matrix ; 

    for (int i = power; i == 1; i--)
        temp = temp * matrix ; 



    return temp ;

pero el regreso está MUY BIEN apagado. Solo el primer elemento de la matriz (1,1) está en el punto.

Intenté usar ese método en un main como

// Multiplying matrices
            for (i = 0; i < row; i++)
            {
                for (j = 0; j < column; j++) 
                {
                    for (l = 0; l < row; l++)
                    {
                        sum += matrix[i][l] * matrix[l][j] ;
                    }
                    matrix[i][j] = sum ;
                    sum = 0 ;
                }
                }

    // Solving Power of matrix
            for (i = 0; i < row; i++) {
                for (j = 0; j < column; j++) 
            matrixFinal[power][i][j] = Tools.powerMethod(matrix[i][j], power) ;
            }

Donde "potencia", "fila" y "columna" es una int que el usuario ingresa.

¿Alguna idea de cómo puedo hacer esto?

¡¡¡Gracias!!!

Answer 1

¿Por qué no usar Math.pow ?

    import java.lang.Math;

Entonces solo tienes que hacer

    matrixFinal[power][i][j] = (int) Math.pow(matrix[i][j],power); //might have to cast this to an int

Answer 2

Tienes muchos problemas aquí.

En primer lugar, su algoritmo de cuadratura matricial tiene un error (común). Tienes:

for (i = 0; i < row; i++) {
    for (j = 0; j < column; j++) {
        for (l = 0; l < row; l++) {
            sum += matrix[i][l] * matrix[l][j] ;
        }
        matrix[i][j] = sum ;
        sum = 0 ;
    }
}

Sin embargo, debe almacenar el resultado en una segunda matriz temporal, porque cuando hace la matrix[i][j] = sum , reemplaza el valor en esa posición con la salida, luego los resultados posteriores terminan siendo incorrectos. También sugiero inicializar la sum en 0, ya que parece que la declaras fuera de este bucle, e inicializarla primero te protege de cualquier valor arbitrario que la sum pueda tener antes de entrar en el bucle. Además, no está inmediatamente claro qué quiere decir con row y column , asegúrese de que está iterando sobre toda la matriz. P.ej:

int temp[][] = new int[matrix.length];

for (i = 0; i < matrix.length; i++) {
    temp[i] = new int[matrix[i].length];
    for (j = 0; j < matrix[i].length; j++) {
        sum = 0 ;
        for (l = 0; l < matrix.length; l++) {
            sum += matrix[i][l] * matrix[l][j] ;
        }
        temp[i][j] = sum ;
    }
}

// the result is now in ''temp'', you could do this if you wanted:
matrix = temp;

Tenga en cuenta que matrix.length y matrix[i].length son bastante intercambiables arriba si la matriz es cuadrada (que debe ser, para poder multiplicarse por sí misma).

En segundo lugar, tu multiplicación cuadra una matriz. Esto significa que si lo aplicas repetidamente, mantienes la cuadratura cuadrando siempre, lo que significa que solo podrás calcular poderes que en sí mismos son potencias de dos.

Tu tercer problema es tu parte final que no tiene mucho sentido:

for (i = 0; i < row; i++) {
    for (j = 0; j < column; j++) 
        matrixFinal[power][i][j] = Tools.powerMethod(matrix[i][j], power) ;
}

No está claro de inmediato lo que estás tratando de hacer aquí. La parte final parece estar tratando de elevar elementos individuales a un cierto poder. Pero esto no es lo mismo que elevar una matriz a una potencia.

Lo que necesita hacer es definir un método de multiplicación de matriz adecuado que pueda multiplicar dos matrices arbitrarias, por ejemplo:

int[][] multiplyMatrices (int[][] a, int[][] b) {
    // compute and return a x b, similar to your existing multiplication
    // algorithm, and of course taking into account the comments about
    // the ''temp'' output matrix above
}

Luego, calcular una potencia se vuelve sencillo:

int[][] powerMatrix (int[][] a, int p) {
    int[][] result = a;
    for (int n = 1; n < p; ++ n)
        result = multiplyMatrices(result, a);
    return result;
}