Calcul de la matrice inverse Java

De façon exponentielle? Non, je crois inversion de matrice est O(N^3).

Je vous conseille d'utiliser La décomposition LU pour résoudre une équation matricielle. Vous n'avez pas à régler pour le facteur déterminant lorsque vous l'utilisez.

Mieux encore, se tournent vers un forfait pour vous aider. JAMA vient à l'esprit.

12x12 ou 19x19 ne sont pas de grandes matricies. Il est commun pour résoudre des problèmes avec des dizaines ou des centaines de milliers de degrés de liberté.

Voici un exemple de la façon d'utiliser le JAMA. Vous devez avoir le JAMA JAR dans le CLASSPATH lorsque vous compilez et exécutez:

package linearalgebra;

import Jama.LUDecomposition;
import Jama.Matrix;

public class JamaDemo
{
    public static void main(String[] args)
    {
        double [][] values = {{1, 1, 2}, {2, 4, -3}, {3, 6, -5}};  //each array is a row in the matrix
        double [] rhs = { 9, 1, 0 }; //rhs vector
        double [] answer = { 1, 2, 3 }; //this is the answer that you should get.

        Matrix a = new Matrix(values);
        a.print(10, 2);
        LUDecomposition luDecomposition = new LUDecomposition(a);
        luDecomposition.getL().print(10, 2); //lower matrix
        luDecomposition.getU().print(10, 2); //upper matrix

        Matrix b = new Matrix(rhs, rhs.length);
        Matrix x = luDecomposition.solve(b); //solve Ax = b for the unknown vector x
        x.print(10, 2); //print the solution
        Matrix residual = a.times(x).minus(b); //calculate the residual error
        double rnorm = residual.normInf(); //get the max error (yes, it's very small)
        System.out.println("residual: " + rnorm);
    }
}

Ici est le même problème, résolu en utilisant Apache Commons Mathématiques, par quant_dev recommandation:

package linearalgebra;

import org.apache.commons.math.linear.Array2DRowRealMatrix;
import org.apache.commons.math.linear.ArrayRealVector;
import org.apache.commons.math.linear.DecompositionSolver;
import org.apache.commons.math.linear.LUDecompositionImpl;
import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.linear.RealVector;

public class LinearAlgebraDemo
{
    public static void main(String[] args)
    {
        double [][] values = {{1, 1, 2}, {2, 4, -3}, {3, 6, -5}};
        double [] rhs = { 9, 1, 0 };

        RealMatrix a = new Array2DRowRealMatrix(values);
        System.out.println("a matrix: " + a);
        DecompositionSolver solver = new LUDecompositionImpl(a).getSolver();

        RealVector b = new ArrayRealVector(rhs);
        RealVector x = solver.solve(b);
        System.out.println("solution x: " + x);;
        RealVector residual = a.operate(x).subtract(b);
        double rnorm = residual.getLInfNorm();
        System.out.println("residual: " + rnorm);
    }
}

Les adapter à votre situation.

Inversion de matrice est de calcul intensif. Comme duffymo répondu LU est un bon algorithme, et il existe d'autres variantes (QR, par exemple).

Malheureusement, vous ne pouvez pas vous débarrasser de la lourde calculs... et peut-être le bottelneck est le getSubmatrix méthode si vous n'êtes pas à l'aide d'une bibliothèque optimisée.

Aussi, spéciale structures de la matrice (bande-matricity, la symétrie, la diagonality, sparsity) ont un impact considérable en termes de performance si, considérée dans les calculs. Votre kilométrage peut varier...

Votre algorithme pour calculer un déterminant est exponentielle. Le problème de base est que vous êtes le calcul de la définition, et le droit de la définition conduit à une exponentielle de la quantité de subdeterminants à calculer. Vous avez vraiment besoin pour transformer la matrice d'abord avant de calculer son déterminant ou de son inverse. (J'ai pensé à expliquer la dynamique de la programmation, mais ce problème ne peut être résolu par programmation dynamique comme le nombre de sous-problèmes est exponentielle).

La décomposition LU, comme recommandé par d'autres, est un bon choix. Si vous êtes nouveau à la matrice de calcul, vous pouvez également regarder l'élimination de Gauss pour calculer les déterminants et inverses, qui pourraient être un peu plus facile à comprendre au premier abord.

Et n'oubliez pas une chose dans l'inversion de matrice est stabilité numérique, car vous avez affaire à des nombres à virgule flottante. Toutes les bonnes algorithme inclure des permutations de lignes et/ou colonnes de choisir le convenable pivots, comme ils sont appelés. Au moins dans l'élimination de Gauss, vous souhaitez, à chaque étape, de permuter les colonnes de sorte que l'élément le plus important en valeur absolue est choisi comme pivot, comme c'est le stablest choix.

Il est difficile à battre Matlab à leur jeu. Ils sont aussi cautiou au sujet de la précision. Si vous avez 2.0 et 2.00001 comme pivots - attention! Votre réponse pourrait être très imprécise. Aussi, découvrez Python de mise en œuvre (c'est dans numpy /scipy quelque part ...)

Depuis ACM de la bibliothèque a mis à jour au fil des ans, ici est la mise en œuvre conforme à la dernière définition pour l'inversion de matrice.

import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.ArrayRealVector;
import org.apache.commons.math3.linear.DecompositionSolver;
import org.apache.commons.math3.linear.LUDecomposition;
import org.apache.commons.math3.linear.RealMatrix;
import org.apache.commons.math3.linear.RealVector;

public class LinearAlgebraDemo
{
    public static void main(String[] args)
    {
        double [][] values = {{1, 1, 2}, {2, 4, -3}, {3, 6, -5}};
        double [][] rhs = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};

        //Solving AB = I for given A
        RealMatrix A = new Array2DRowRealMatrix(values);
        System.out.println("Input A: " + A);
        DecompositionSolver solver = new LUDecomposition(A).getSolver();

        RealMatrix I = new Array2DRowRealMatrix(rhs);
        RealMatrix B = solver.solve(I);
        System.out.println("Inverse B: " + B);
    }
}