Adjunkte Matrix erstellen

f61

Grünschnabel
Hallo,
ich beschäftige mich momentan mit einer Aufgabe die sich auf die Multiplikation von Matrizen, die Berechnung der Determinanten und der Ausgabe von Untermatrizen bezieht. Jedoch habe ich folgendes Problem, ich weiß nicht genau wie ich die Adjungierte Matrix ausrechen/ausgeben soll. Mein Ansatz es wird nach der Formel für die Adjungierte Matrix die (-1) mit der Determinante ((Matrix.det(Matrix.submatrix(a,i,j)) multipliziert welche die submatrix beinhält. Am Ende wird das ganze noch transponiert um an die Adjunkte Matrix zu kommen.
Irgendetwas scheint aber noch nicht zu stimmen,
Ich würde mich freuen wenn sie mir behilflich sein könnten.
VG



Code:
public class Matrix{
        double[][] array;
        // initalisiert Matrix mit row Zeilen und colum Spalten. Alle Werte werden auf 0 initalisiert
        public static void init(Matrix a, int row, int column){
         a.array = new double [row][column];
        }
        
      
    // gibt die Anzahl der Zeilen zurueck
     public static int getNRows(Matrix a){
     return a.array.length;
     }
        
      
    // gibt die Anzahl der Spalten zurueck
     public static int getNColumns(Matrix a){
      return a.array[0].length;
     }
      
      
      
    // gibt die Matrix aus
     public static void print(Matrix a){
        int zeilen=a.array.length;
        int spalten=a.array[0].length;
        for (int i=0;i<zeilen;i++){
            for (int j=0;j<spalten;j++){
            System.out.print(a.array[i][j]+"\t");
        }
        System.out.println();
        }
        System.out.println();
    }
    

 
    // multipliziert Matrix A(NxM) mit Matrix B(QxR). Wenn M ungleich Q ist, wird eine Fehlermeldung ausgegeben.
    public static Matrix mult(Matrix a, Matrix b){
        int zeilen=a.array.length;
        int spalten=b.array[0].length;
        Matrix C = new Matrix();
        Matrix.init(C, zeilen, spalten);
        
        for (int i=0;i<zeilen;i++){
        for (int j=0;j<spalten;j++){
            double ergebnismatrix=0;
            for (int k=0;k<a.array[0].length;k++)
            ergebnismatrix += a.array[i][k]*b.array[k][j];
        
            
            
        C.array[i][j]=ergebnismatrix;
      }
    
    }
    return C;
}
        // berechnet die Determinante einer 3x3 Matrix
        public static double det(Matrix a){
            double det=0;
            if (Matrix.getNRows(a)!=Matrix.getNColumns(a)){
                System.out.println("Determinante wird nicht berechnet");
            }
            else if (Matrix.getNRows(a)==3){
            System.out.println("Ergebnis der Determinante");
            det = (a.array[0][0]*a.array[1][1]*a.array[2][2])+(a.array[0][1]*a.array[1][2]*a.array[2][0])+(a.array[0][2]*a.array[1][0]*a.array[2][1])-(a.array[0][1]*a.array[1][0]*a.array[2][2])-(a.array[0][0]*a.array[1][2]*a.array[2][1])-(a.array[0][2]*a.array[1][1]*a.array[2][0]);
            }else if (Matrix.getNRows(a)==2){
                det = (a.array[0][0]*a.array[1][1]-a.array[1][0]-a.array[1][0]*a.array[0][1]);

            }
            return det;
        }
        // berechnet die Transponierte einer NxN Matrix
        public static Matrix transpose(Matrix a){
            Matrix b = new Matrix();
            int zeilen = Matrix.getNRows(a);
            int spalten = Matrix.getNColumns(a);
            Matrix.init(b, spalten, zeilen);
            for (int i = 0; i <zeilen; i++) {
                for (int j =0; j < spalten; j++) {
              b.array[j][i] = a.array[i][j];

                }
                
            }
            return b;
        }



         // berechnet die Untermatrix, in dem Zeile exclRow und Spalte exclCol entfernt wurden
       public static Matrix subMatrix(Matrix a, int exclRow, int exclCol){
         Matrix b = new Matrix();
         int zeilena = Matrix.getNRows(a);
         int spaltena = Matrix.getNColumns(a);

         Matrix.init(b, zeilena-1, spaltena-1);
         for (int i = 0; i < zeilena; i++) {
            for (int j = 0; j < spaltena; j++) {
                if (i == exclRow || j == exclCol){
                }
                else if (i>exclRow && j>exclCol){
            b.array[i-1][j-1] = a.array[i][j];
            }
            else if (i>exclRow){
                b.array[i-1][j] =a.array [i][j];
            }
            else if (j>exclCol){
                b.array [i][j-1] = a.array [i][j];

            }else {
                b.array[i][j] = a.array[i][j];
            }
        }
    }
    return b;
}
          // berechnet die Adjungierte einer 3x3 Matrix
          public static Matrix adjoint(Matrix a){
              double potenz=1;
              Matrix b = new Matrix();
              int zeilen = Matrix.getNRows(a);
              int spalten= Matrix.getNColumns(a);
              if (zeilen!=3 && spalten!=3){
                  System.out.println("Matrix nixht 3x3");
              }else {
               Matrix.init(b,zeilen,spalten);
               for (int i = 0; i <zeilen; i++) {
                for (int j =0; j < spalten; j++) {
                  if ((zeilen+spalten)%2==0)
                   b.array[i][j] = (-1)*Matrix.det(Matrix.subMatrix(a, i, j));
                  }
                    }
                }
            }
        
        return Matrix.transpose(b);
    }
    
}