Как реализовать метод простых итераций?

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package lab3;
 
/**
 *
 * @author Администратор
 */
public class Lab3 {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) 
      {
         double e=0.001;
         double[] X = {0,0,0,0};
         double[][] MatH=new double[4][4];
         double[] MatV=new double[4];
         double [] Xk =new double[4] ;
        double[][] MatA = 
          {
              {-2,0,9,65},
              {-7,0,7,2},
              {-11, 10,1,0},
              {1000, 8, 0,7},
          };
            double[][] A = 
          {
              {-2,0,9,65},
              {-7,0,7,2},
              {-11, 10,1,0},
              {1000, 8, 0,7},
          };
          double[] B ={7,4,4,8};
          double[] MatB ={7,4,4,8};
          double [] L= new double [4];
       
         ordering(MatA,MatB);
         transformation(MatH,MatA,MatB,MatV);
         Print(MatH);
         Iteration(X,MatH,MatV,e,Xk);
         for(int j=0;j<4;j++)
         {
         System.out.println(X[j]);
         
         }
         Vidxul(A,X,B,L);
      }
    // упорядочивание матрици формирование диагонально доминирующей матрици 
    public static void ordering(double [][] MatA,double [] MatB)
    {
        double max,temp;
        int p;
       for(int j=0;j<4;j++)
       {
           max=MatA[j][j];
           p=j;
        for (int i=0;i<4-j;i++)
         {
          if(max<MatA[i][j])
            {
            p=i;
            max=MatA[i][j];
           }
           if(p!=j)
           {
               for(int k=0;k<4;k++)
               {
                 temp=MatA[j][k];
                  MatA[j][k]=MatA[p][k];
                  MatA[p][k]=temp;
               }
               temp=MatB[j];
               MatB[j]=MatB[p];
               MatB[p]=temp;
           }
         } 
       }
      for(int j=0;j<4;j++)
        {
         MatA[3][j]=MatA[3][j]-MatA[2][j];
       }
      MatB[3]=MatB[3]-MatB[2]; 
      
    }
    // формирование матрицы H и V
    public static void transformation(double [][] MatH, double[][] MatA, double [] MatB,double [] MatV)
    {
      for(int i=0;i<4;i++)
      {
       for(int j=0;j<4;j++)
       {
        MatH[i][j]=-MatA[i][j]/MatA[j][j];
        if(i==j)
        {
        MatH[i][j]++;
        }
       }
       MatV[i]=MatB[i]/MatA[i][i];
      
      }
    }
    // виполнения итерации 
    public static void Iteration(double [] X,double [][] MatH,double[] MatV,double e, double [] Xk)
    {
     int k=1;
     int metka=0;
     while ( k<=40 && metka==0)
     { 
      for(int y=0;y<4;y++)
      {
        double s=0;
        for (int j=0;j<4;j++)
        {
          s=s+MatH[y][j]*X[j];
        }
        
        Xk[y]=MatV[y]-s;
      }
      int i=0; 
      double g=0;
      double t=0;
      while(g<e && i<=3)
      {
       g=Math.abs(Xk[i]-X[i]);
       t=Math.abs(Xk[i]);
      if(t>1)
      {
      g=g/t;
      }
      i=i+1;
      }
      if (i==4) 
      {
      metka=1;
      }
     k=k+1;
     for(int j=0;j<4;j++)
     {
     X[j]=Xk[j];
 
     }
     }
     
    }
    // вывод массива
     public static void Print(double MatA[][])
    {
      for (int i=0;i<4;i++)
          {
               for (int j=0;j<4;j++)
               {
          System.out.printf("%3.4f ",MatA[i][j]);
               }
               System.out.println("");
          }
    
    }
     // подсчет вектора отклонения 
     public static void Vidxul(double A[][],double X[],double B[], double[] L)
     {
        for(int i=0;i<4;i++)
          {
            L[i]=0;
            for(int j=0;j<4;j++)
             {
               L[i]=L[i]+A[i][j]*X[j]; 
             }
            L[i] = L[i]-B[i];
            System.out.println(L[i]);
          } 
     }
}