Question

Implement this pseudo code with Java.

n is the size of the matrix for an n x n matrix.

k is the pivot.

i is the equation being eliminated.

j is the term you're working with.

Gaussian Elimination with Scaled Partial Pivoting

// Forward Elimination

function SPPFwdElimination(coeff : array(n,n), const : vector(n), ind : vector(n))
  scaling := new vector(n) // vector of scaling factors

// Initialize index and scaling vectors
  for i = 1 to n
  smax := 0

  for j = 1 to n
  smax := max(smax,|coeff[i][j]|) // find coefficient with greatest absolute value
  end for

  scaling[i] := smax   
  end for

  for k = 1 to n - 1
  rmax := 0
  maxInd := k

  for i = k to n
  r := |coeff[ind[i]][k] / scaling[ind[i]]| // ratio of coefficient to scaling factor
  if (r > rmax) then
  rmax := r
  maxInd := i
  end if
  end for
  swap(ind[maxInd], ind[k])

  for i = k + 1 to n
  mult := coeff[ind[i]][k] / coeff[ind[k]][k]
  
  for j = k + 1 to n
coeff[ind[i]][j] := coeff[ind[i]][j] - mult * coeff[ind[k]][j]
  end for

  const[ind[i]] := const[ind[i]] - mult * const[ind[k]]
  end for
  end for
end function

// Back Substitution

function SPPBackSubst(coeff : array(n,n), const : vector(n), sol : vector(n), ind : vector(n))
  sol[n] := const[ind[n]] / coeff[ind[n]][n]
  for i = n - 1 to 1
  sum := const[ind[i]]
  for j = i + 1 to n
  sum := sum - coeff[ind[i]][j] * sol[j]
  end for
  sol[i] := sum / coeff[ind[i]][i]
  end for
end function

// SPP Gaussian Algorithm

function SPPGaussian(coeff : array(n,n), const : vector(n))
  sol := new array(n,n)
  ind := new vector(n)

  for i = 1 to n
  ind[i] := i
  end for

  call SPPFwdElimination(coeff,const,ind)
  call SPPBackSubst(coeff,const,sol,ind)
end function

Answer 1

package chirag;
import java.util.*;
import java.lang.Math;

public class dog {
  
   public static void SPPFwdElimination(int [][]coeff,int b[],int [] ind,int n) {
       int scaling[] =new int[n+1];

               //Initialize index and scaling vectors
               for(int i=1;i<=n;i++) {
               int smax = 0;

               for (int j =1;j<=n;j++) {
               smax = Math.max(smax,Math.abs(coeff[i][j])); // find coefficient with greatest absolute value
               }

               scaling[i]=smax;   
               }

               for( int k=1;k<=n - 1;k++) {
               int rmax=0;
               int maxInd=k;

               for (int i =k;i<=n;i++) {
                  
               int r = Math.abs(coeff[ind[i]][k] / scaling[ind[i]]); // ratio of coefficient to scaling factor
               if (r > rmax) {
               rmax = r;
               maxInd= i;
               }
               }
               int temp=ind[maxInd];
               ind[maxInd]=ind[k];
               ind[k]=temp;

               for(int i = k + 1;i<=n;i++) {
               int mult = coeff[ind[i]][k] / coeff[ind[k]][k];

               for(int j = k + 1;j<=n;j++) {
               coeff[ind[i]][j] = coeff[ind[i]][j] - mult * coeff[ind[k]][j];
               }

               b[ind[i]] = b[ind[i]] - (mult*b[ind[k]]);
               }
               }
   }
   public static void SPPBackSubst(int [][]coeff,int b[],int []sol,int ind[],int n) {
       sol[n] = b[ind[n]] / coeff[ind[n]][n];
               for(int i = n - 1;i>=1;i--) {
               int sum = b[ind[i]];
               for(int j = i + 1;j<=n;j++) {
               sum= sum - coeff[ind[i]][j] * sol[j];
               }
               sol[i] = sum / coeff[ind[i]][i];
               }
   }
public static void SPPGaussian(int [][]coeff,int []b,int n ) {
   int []sol= new int [n+1];
       int ind[] = new int[n+1];

           for (int i = 1;i<n;i++) {
               ind[i]=i;
           }
           SPPFwdElimination(coeff,b,ind,n);
           SPPBackSubst(coeff,b,sol,ind,n);
}
   public static void main(String[] args) {
       int n;
       Scanner sc = new Scanner(System.in);
       n=sc.nextInt();
       int coeff[][]=new int[n+1][n+1];
       int []b=new int[n+1];
       for(int i=1;i<=n;i++) {
           for(int j=1;j<=n;j++) {
               coeff[i][j]=sc.nextInt();
           }
           b[i]=sc.nextInt();
       }
      
       SPPGaussian(coeff,b,n);
   }

}