//==================================================
//== Znajduje macierz odwrotna metoda             ==
//==  Gaussa-Jordana                              ==
//==                                              ==
//==  A - macierz wejsciowa                       ==
//==  zwraca macierz odwrotna do A                ==
//==================================================

  static double [][] invertMatrix(double [][] A) {
       int wym=A.length;                        // wymiar macierzy
    double Ai[][];                              // macierz odwrotna do A
    double skala;                               // skalowanie do 1.0
       int i,j,k,l;                             // indeksy w macierzy
    double tmp;                                 // do zamiany elementow

//    ==============================
//    == przygotuj macierz Ai jako =
//    == macierz jednostkowa       =
//    ==============================
        Ai=new double[wym][wym];

        for (i=0; i<wym; i++)
         for (j=0; j<wym; j++)
          if (i==j) Ai[i][j]=1.0; else Ai[i][j]=0.0;


    for (j=0; j<wym; j++) {
//     ====================================
//     = gdy 0 na przek.to zamien wiersze =
//     ====================================
          if (A[j][j]==0) {
           if (j==wym-1) {
               System.out.println("B┼é─ůd: macierz A jest osobliwa!");
               System.exit (-1);
            }

        //=============================
        //== szukaj wiersza bez zera ==
        //=============================
          k=j;
          while ((k<wym-1)&&(A[k][j]==0.0)) k++;

          //==========================
          //== zamien wiersze j<->l ==
          //==========================
          for (l=0; l<wym; l++) {                // zamien wiersze
            tmp = A[j][l];
            A[j][l]=A[k][l];
            A[k][l]=tmp;

            tmp = Ai[j][l];
            Ai[j][l]=Ai[k][l];
            Ai[k][l]=tmp;
          }
         }

//      ==================================
//      = gdy dalej 0 to zamien kolumny  =
//      ==================================
          if (A[j][j]==0.0) {
          //==========================
          //== szukaj kolumny bez 0 ==
          //==========================
            k=j;                                  //
            while ((A[j][k]==0.0)&&(k<wym-1)) k++;

          //==========================
          //== zamien kolumny j<->l ==
          //==========================
            for (l=0; l<wym;l++) {               // zamien kolumny
             tmp=A[l][j];
             A[l][j]=A[l][k];
             A[l][k]=tmp;

             tmp=Ai[l][j];
             Ai[l][j]=A[l][k];
             Ai[l][k]=tmp;
            }
          }

//      ====================================
//      == przeskaluj wiersz zeby dostac 1 =
//      == na przekatnej                   =
//      ====================================
          skala = 1.0/A[j][j];
          for (l=0; l<wym; l++) {
            A[j][l] = A[j][l] *skala;
            Ai[j][l] = Ai[j][l] *skala;
          }

          for (i=0; i<wym; i++) {
//      =================================
//      == likwiduj wszystkie elementy  =
//      == w kolumnie procz elementu j  =
//      =================================
            if (i!=j) {
              skala = A[i][j]/A[j][j];
              for (l=0; l<wym; l++) {
                A[i][l]=A[i][l] -A[j][l]* skala;
                Ai[i][l]=Ai[i][l] -Ai[j][l]* skala;
              }
             }
           }
      }
    return Ai;
  }