import numpy as np
import time

def scaling(A, Y):
    n=len(A)
    for i in range(0, n):
        max = abs(Y[i])
        for j in range(0, n):
            if abs(A[i][j]) > max:
                max = abs(A[i][j])
        Y[i] = Y[i]/max
        for j in range(0, n):
            A[i][j] = A[i][j]/max
    return A, Y

def row_echelon_form(A, Y): #A*X=Y
    n = len(A)
    for i in range(0, n):
        #search for maximum in column i
        max = abs(A[i][i])
        max_row = i
        for j in range(i+1, n):
            if abs(A[j][i]) > max:
                max = abs(A[j][i])
                max_row = j
        if(max > 0):
            #swap rows
            A[[i, max_row]] = A[[max_row, i]]
            Y[i], Y[max_row] = Y[max_row], Y[i]

            #make 0 in column i
            for j in range(i+1, n):
                c = -(A[j][i]/A[i][i])
                A[j][i] = 0
                Y[j] = Y[j] + (c*Y[i])
                for k in range(i+1, n):
                    A[j][k] = A[j][k] + (c*A[i][k])
            #up
            for j in range(0, i):
                c = -(A[j][i]/A[i][i])
                Y[j] = Y[j] + (c*Y[i])
                for k in range(i+1, n):
                    A[j][k] = A[j][k] + (c*A[i][k])


    return A, Y

def solve_triangle_lin(A, Y):
    n=len(A)
    X = np.zeros(n)
    X[n-1] = Y[n-1]/A[n-1][n-1]
    for i in range(n-2, -1, -1):
        X[i] = Y[i]/A[i][i]

    return X

if __name__ == "__main__":
    random_matrix = 100 * np.random.random_sample((5, 5))
    random_Y = 100 * np.random.random_sample(5)
    start_time_np = time.process_time()
    print(np.linalg.solve(random_matrix, random_Y))
    end_time_np = time.process_time()
    print(random_matrix)
    print(random_Y)
    A, Y = scaling(random_matrix, random_Y)
    A, Y = row_echelon_form(A, Y)
    print(A)
    print(Y)
    print(solve_triangle_lin(A, Y))
    end_time = time.process_time()
    print("czas np.linalg: " + str(end_time_np - start_time_np))
    print("czas mojego algorytmu: " + str(end_time - end_time_np))