import copy
def interchange(matrix, row1Index, row2Index): #swaps two rows with given indices
matrix[row1Index], matrix[row2Index] = matrix[row2Index], matrix[row1Index]
return matrix
def scaleBy(matrix, rowIndex, scalar): #multiplies any given row by a number
for i in range(len(matrix[rowIndex])):
matrix[rowIndex][i] = (matrix[rowIndex][i] * scalar)
return matrix
def addScaled(matrix, row1Index, row2Index, scalar): #adds multiple of one row to the other
for i in range(len(matrix[row1Index])):
matrix[row1Index][i] = matrix[row1Index][i] + (matrix[row2Index][i] * scalar)
return matrix
def zeroCheck(matrix): #checks for zero rows and puts all of them at the bottom.
nCols = len(matrix[0]) #puts rows with leading zeroes below the non-zero leading rows
nonzeroRows = list()
leadingzeroRows = list()
for row in range(len(matrix)):
RowElems = list(set(matrix[row]))
if(len(RowElems) == 1 and RowElems[0] == 0):
continue
elif(matrix[row][0] == 0):
leadingzeroRows.append(matrix[row])
else:
nonzeroRows.append(matrix[row])
nonzeroRows.extend(leadingzeroRows)
zeroRow = [0] * nCols
numZeroRow = len(matrix) - len(nonzeroRows)
for i in range(numZeroRow):
nonzeroRows.append(zeroRow)
return nonzeroRows
final = None
def printMatrix(matrix): #prints matrix. Rounds up till 3 decimal places. added constant spacing
between elements.
print()
global final
max_width = max(len(str(round(matrix[row][col], 3))) for row in range(len(matrix)) for col in
range(len(matrix[0])))
final = matrix
for row in range(len(matrix)):
for col in range(len(matrix[0])):
value = round(matrix[row][col], 3)
formatted_value = int(value) if type(value) is float and value.is_integer() else value
print("{:{}}".format(formatted_value, max_width), end=" ")
print()
return final
def zeroColCount(matrix): #counts number of zero columns. Returns the INDICIES of zero
columns.
zeroCols = list()
for j in range(len(matrix[0])):
s=0
for i in range(len(matrix)):
s = s + abs(matrix[i][j])
if(s == 0):
zeroCols.append(j)
return zeroCols
def scaledRowEliminator(matrix): #first checks if matrix is LC of another.
#If yes, then keeps smaller row and makes bigger row into a 0 row.
#Calls zerocheck to put this row at the bottom.
for i in range(len(matrix)):
for j in range(i+1, len(matrix), 1):
count = 0
for k in range(len(matrix[0])):
if min(matrix[i][k], matrix[j][k]) != 0 and min(matrix[i][k], matrix[j][k]) != 1 and
min(matrix[i][k], matrix[j][k]) != -1:
scale = max(matrix[i][k], matrix[j][k]) / min(matrix[j][k], matrix[i][k])
if(scale - int(scale) == 0):
count = count + 1
if(count == len(matrix[0])):
atleastOneScaled = True
reqdRow = 0
if(max(matrix[i][0], matrix[j][0]) == matrix[i][0]):
reqdRow = i
else:
reqdRow = j
for z in range(len(matrix[0])):
matrix[reqdRow][z] = 0
matrix = zeroCheck(matrix)
return matrix
def count_zero_rows(matrix): #counts and returns number of zero rows.
zero_rows = 0
for row in matrix:
if all(element == 0 for element in row):
zero_rows += 1
return zero_rows
def isRREF(matrix): #checks rref. Kind of extra but helps in verifying if input is already rref.
rref_check = True
one_found = 0
for i in range(len(matrix)):
first_nonzero_col = None
for j in range(len(matrix[0])):
if matrix[i][j] == 1:
one_found += 1
first_nonzero_col = j
break
if first_nonzero_col is not None:
for k in range(i):
if matrix[k][first_nonzero_col] != 0:
check1 = False
break
if one_found != len(matrix) - count_zero_rows(matrix):
rref_check = False
return rref_check
pivots_column = []
already_rref=0
def toEchelon(matrix, showSteps=True, reduced=False):
"""converts to rref using above functions
first calls zerocheck
checks for leading 0 element puts it at the top.
Then checks pivot elements and swaps rows to put into staircase pattern by checking
for gaps. Then uses current pivot row to make elements below it into zeroes by multiplying
negative and dividing by pivot element and sending into scaleadd.
Scales pivots down to 1 by multiplying multiplicative inverse.
Then takes first row and makes all pivot column
positions into 0's by dividing with a scalar."""
global already_rref
global pivots_column
nRows = len(matrix)
nCols = len(matrix[0])
if(showSteps):
print('Original Matrix:')
printMatrix(matrix)
matrix = zeroCheck(matrix)
"""if isRREF(matrix):
already_rref+=1
print("The matrix is already in Row Reduced Echelon Form!")
printMatrix(matrix)
return"""
scaledRowEliminator(matrix)
if(showSteps):
print()
print("Reaaranging Matrix:")
printMatrix(matrix)
minpos = 0
c=0
for i in range(1, nRows, 1):
if(matrix[i][0] == 0):
continue
elif(abs(matrix[i][0]) < abs(matrix[minpos][0]) and abs(matrix[i][0]) != 0):
minpos = i
c += 1
if(c > 0):
matrix = interchange(matrix, minpos, 0)
if(showSteps):
print()
print("Row 1 <--> Row", minpos+1)
printMatrix(matrix)
pivotsR = list()
pivotsC = list()
zColC = zeroColCount(matrix)
for col in range(nCols):
if(col not in zColC and col not in pivotsC):
for row in range(nRows):
if(row not in pivotsR and col not in pivotsC):
if(matrix[row][col] != 0):
if(len(pivotsR) != 0 and row != pivotsR[-1]+1):
matrix = interchange(matrix, row, pivotsR[-1]+1)
if(showSteps):
print()
print("Row", row+1, "<--> Row", pivotsR[-1]+2)
printMatrix(matrix)
pivotsR.append(pivotsR[-1]+1)
else:
pivotsR.append(row)
pivotsC.append(col)
currPivotRow = pivotsR[-1]
currPivotCol = pivotsC[-1]
for h in range(currPivotRow+1, nRows, 1):
if(matrix[h][currPivotCol] != 0):
reqdScalar = (-1) * (matrix[h][currPivotCol]) / (matrix[currPivotRow][currPivotCol])
matrix = addScaled(matrix, h, currPivotRow, reqdScalar)
if(showSteps):
print()
print("Row", h+1, "--> Row", h+1, "+ (", reqdScalar, ")x Row", currPivotRow+1)
printMatrix(matrix)
print()
pivots_column = pivotsC
if(reduced):
if(showSteps):
print("Further Reducing to Reduced Echelon Form:\n")
for k in range(len(pivotsC)):
if(matrix[pivotsR[k]][pivotsC[k]] != 1):
scaleFactor = 1 / matrix[pivotsR[k]][pivotsC[k]]
scale_factor_display = matrix[pivotsR[k]][pivotsC[k]]
matrix = scaleBy(matrix, pivotsR[k], scaleFactor)
if showSteps:
print()
print(f"Row {pivotsR[k]+1} = ( 1 / {scale_factor_display} ) x Row {pivotsR[k]
+1}")
printMatrix(matrix)
for k in range(len(pivotsC)):
for i in range(pivotsR[k]-1, -1, -1):
if(matrix[i][pivotsC[k]] != 0):
reqdScalar = (-1) * (matrix[i][pivotsC[k]]) / (matrix[pivotsR[k]][pivotsC[k]])
matrix = addScaled(matrix, i, pivotsR[k], reqdScalar)
if(showSteps):
print()
print("Row", i+1, "--> Row", i+1, "+ (", reqdScalar, ")x Row", pivotsR[k]+1)
printMatrix(matrix)
zeroCheck(matrix)
return matrix
print()
print("---------------------------------ROW REDUCED ECHELON
FORM----------------------------------\n")
while True:
try:
row_number = int(input('Enter the number of rows (n): '))
column_number = int(input('Enter the number of columns (m): '))
if row_number > 0 and column_number > 0:
break
else:
print()
print("Please enter positive integers for the number of rows and columns.")
print()
except ValueError:
print()
print("Invalid input! Please enter valid integers for the number of rows and columns.")
print()
a = []
for i in range(row_number):
while True:
try:
elements_str = input(f"Enter {column_number} numbers separated by spaces for row
number {i + 1}: ")
elements = [float(x) for x in elements_str.split()]
if len(elements) == column_number:
a.append(elements)
break
else:
print()
print(f"Invalid input! Please enter exactly {column_number} numbers.")
print()
except ValueError:
print()
print("Invalid input! Please enter valid numbers separated by spaces.")
print()
input_matrix = copy.deepcopy(a)
toEchelon(a, reduced=True)
if already_rref==0:
print()
print("The matrix is now in row reduced echelon form")
print()
print("Factorizing:")
threshold = 1e-10 # Define a threshold value for "close to zero"
for row in final:
for i in range(len(row)):
if abs(row[i]) < threshold:
row[i] = 0.0
number_of_zero = count_zero_rows(a)
non_zero_matrix = final[ : len(final)-number_of_zero]
def extract_pivot_columns(matrix, pivots_column):
pivot_matrix = []
for row in matrix:
pivot_row = [row[col] for col in pivots_column]
pivot_matrix.append(pivot_row)
return pivot_matrix
pivot_column_matrix = extract_pivot_columns(input_matrix, pivots_column)
printMatrix(non_zero_matrix)
print()
print("Multiplied By")
printMatrix(pivot_column_matrix)
print()
print("Equals")
printMatrix(input_matrix)
print()
print('The matrix has been rank factorized!')
print("------------------------------------------------------------------------------------------")
