Develop a python implementation of Gaussian elimination using partial pivoting using attached code. (just need add partial pivoting)

Develop a python code reducing echelon matrices to their reduced echelon forms. (need convert echelon to reduced echelon after gauss elimination)

You can use the python functions in the attached image.

Finding the bugs and the shortcomings of the attached code.

import numpy as np

from scipy import linalg

def eliminateCol(A, k=0):

# guarantee that A is float type

if A.dtype.kind != 'f' and A.dtype.kind != 'c': return None

# load dimensions

dim0,dim1 = np.shape(A)

# initialize outputs

swap = np.identity(dim0,dtype=float)

oper = np.identity(dim0,dtype=float)

# k < dim1

k = k%dim1

# if the column k is zero column, return

if A[:,k].any() == False: return swap,oper

i0 = 0

if k != 0:

# find a row i0 whose left most k-1 entries are all zero

while i0 < dim0:

if A[i0,0:k].any() == False: break

i0+= 1

# find a nonzero element A[i,k] to use as a pivot

i = i0;

while i < dim0:

if A[i,k] != 0: break

i+= 1

if i == dim0: return swap,oper

# swap the row i with the row i0

if i != i0: A[[i0,i],] = A[[i,i0],];swap[[i0,i],] = swap[[i,i0],]

# row i0 is the pivot row and A[j,k] is zero for i0

i = i+1

while i < dim0:

if A[i,k] != 0:

quot = A[i,k] / A[i0,k]

A[i,:] = A[i,:] - quot*A[i0,:]

oper[i,i0] = -quot

i+=1

return swap,oper

def eliminateRow(A, k=-1):

# guarantee that A is float type

if A.dtype.kind != 'f' and A.dtype.kind != 'c': return None

# load dimensions

dim0,dim1 = np.shape(A)

# initialize outputs

oper = np.identity(dim0,dtype=float)

# k < dim0

k = k%dim0

# if the row k is zero column, return

if k == 0 or A[k,:].any() == False: return oper

# find a nonzero element A[k,j] to use as a pivot

j = 0;

while j < dim1:

if A[k,j] != 0: break

j+= 1

i =k-1

while i >= 0:

if A[i,j] != 0:

quot = A[i,j] / A[k,j]

A[i,:] = A[i,:] - quot*A[k,:]

oper[i,k] = -quot

i-=1

return oper

def eliminateScale(A):

# guarantee that A is float type

if A.dtype.kind != 'f' and A.dtype.kind != 'c': return None

# load dimensions

dim0,dim1 = np.shape(A)

# initialize outputs

oper = np.identity(dim0,dtype=float)

# find pivots

i = 0

while i < dim0:

j = 0

while j < dim1:

if A[i,j] == 0: j+= 1; continue

else:

oper[i,i] = 1/A[i,j]

A[i,j:] = A[i,j:]/A[i,j]

break

j+= 1

i+= 1

return oper