간단한 선형대수의 수식들을 List Comprehesion을 사용하여 pythonic code 를 작성하려고 한다.

Linear Algebra codes - 1 은 처음 배웠을 때 작성한 것이라 부족한 부분이 있어 다시 작성하려고 한다.

2024.01.02 - [✍🏻Language/Python] - [Python for ML] Linear algebra codes

1. Vector Size Check

• vector 간 덧셈 또는 뺄셈 연산을 할 때, 연산이 가능한 사이즈인지를 확인하여 가능 여부를 True 또는 False로 반환

def vector_size_check(*vector_variables):
    return all(len(vector_variables[0]) == x 
                for x in [len(vector) for vector in vector_variables[1:]])

# 실행결과
print(vector_size_check([1,2,3], [2,3,4], [5,6,7])) 
print(vector_size_check([1, 3], [2,4], [6,7])) 
print(vector_size_check([1, 3, 4], [4], [6,7]))

True

Ture

Flase

2. Vector Addition

• vector간 덧셈을 실행하여 결과를 반환함, 단 입력되는 vector의 갯수와 크기는 일정하지 않음

def vector_addition(*vector_variables):
    if vector_size_check(*vector_variables) == False:
        raise ArithmeticError
    return [sum(element) for element in zip(*vector_variables)]

# 실행결과
print(vector_addition([1, 3], [2, 4], [6, 7])) 
print(vector_addition([1, 5], [10, 4], [4, 7]))
print(vector_addition([1, 3, 4], [4], [6,7]))

[9, 14]
[15, 16]

ArithmeticError

3. Vector Substraction

• vector간 뺄셈을 실행하여 결과를 반환함, 단 입력되는 vector의 갯수와 크기는 일정하지 않음

def vector_subtraction(*vector_variables):
    if vector_size_check(*vector_variables) == False:
        raise ArithmeticError
    return [2 * elements[0] - sum(elements) for element in zip(*vector_variables)]

# 실행결과
print(vector_subtraction([1, 3], [2, 4]))
print(vector_subtraction([1, 5], [10, 4], [4, 7]))

[-1, -1]
[-13, -6]

4. Scalar Vector Product

• 하나의 scalar 값을 vector에 곱함, 단 입력되는 vector의 크기는 일정하지 않음

def scalar_vector_product(alpha, *vector_variables):
    return [alpha * row for row in vector_variables]

# 실행결과
print (scalar_vector_product(5,[1,2,3])
print (scalar_vector_product(3,[2,2]))
print (scalar_vector_product(4,[1]))

[5, 10, 15]
[6, 6]
[4]

5. Matrix Size Check

• matrix 간 덧셈 또는 뺄셈 연산을 할 때, 연산이 가능한 사이즈인지를 확인하여 가능 여부를 True 또는 False로 반환함
• 열 판단 and 행 판단

def matrix_size_check(*martix_variables):
    all([len(set(len(matrix[0]) for matrix in matrix_variables)) == 1]) and 
        all([len(matrix_variables[0]) == len(matrix) for matrix in matrix_variables])

# 실행결과
matrix_x = [[2, 2], [2, 2], [2, 2]]
matrix_y = [[2, 5], [2, 1]]
matrix_z = [[2, 4], [5, 3]]
matrix_w = [[2, 5], [1, 1], [2, 2]]

print (matrix_size_check(matrix_x, matrix_y, matrix_z)) 
print (matrix_size_check(matrix_y, matrix_z))
print (matrix_size_check(matrix_x, matrix_w))

False

True

True

6. Is Matrix Equal

• 비교가 되는 n개의 matrix가 서로 동치인지 확인하여 True 또는 False를 반환함
• all( ) 이 두 번인 이유 : matrix 형태이므로 row의 값이 다 같은지 확인하고, column이 모두 같은지도 확인

def is_matrix_equal(*matrix_variables):
    all([all([len(set(row)) == 1 for row in zip(*matrix)]) for matrix in zip(*matrix_variables)])
    
# 실행결과
matrix_x = [[2, 2], [2, 2]]
matrix_y = [[2, 5], [2, 1]]

print (is_matrix_equal(matrix_x, matrix_y, matrix_y, matrix_y))
print (is_matrix_equal(matrix_x, matrix_x))

False

True

7. Matrix Addition

• matrix간 덧셈을 실행하여 결과를 반환함, 단 입력되는 matrix의 갯수와 크기는 일정하지 않음

def matrix_addition(*matrix_variables):
    if matrix_size_check(*matrix_variables) == False:
        raise ArithmeticError
    return [[sum(row) for row in zip(*matrix)] for matrix in zip(*matrix_variables)]
    
# 실행결과
matrix_x = [[2, 2], [2, 2]]
matrix_y = [[2, 5], [2, 1]]
matrix_z = [[2, 4], [5, 3]]

print (matrix_addition(matrix_x, matrix_y))
print (matrix_addition(matrix_x, matrix_y, matrix_z))

[[4, 7], [4, 3]]

[[6, 11], [9, 6]]

8. Matrix Subtraction

• matrix간 뺄셈을 실행하여 결과를 반환함, 단 입력되는 matrix의 갯수와 크기는 일정하지 않음

def matrix_subtraction(*matrix_variables):
    if matrix_size_check(*matrix_variables) == False:
        raise ArithmeticError
        
    return [[2 * row[0] - sum(row) for row in zip(*matrix)] for matrix in zip(*matrix_variables)]
    
# 실행결과
matrix_x = [[2, 2], [2, 2]]
matrix_y = [[2, 5], [2, 1]]
matrix_z = [[2, 4], [5, 3]]

print(matrix_subtraction(matrix_x, matrix_y))
print(matrix_subtraction(matrix_x, matrix_y, matrix_z))

[[0, -3], [0, 1]]

[[-2, -7], [-5, -2]]

9. Matrix Transpose

• matrix의 역행렬을 구하여 결과를 반환함, 단 입력되는 matrix의 크기는 일정하지 않음

def matrix_transpose(*matrix_variables):
    return [[element for element in row] for row in zip(*matrix_variables)]]
    
# 실행결과
matrix_w = [[2, 5], [1, 1], [2, 2]]
print(matrix_transpose(matrix_w))

[[2, 1, 2], [5, 1, 2]]

10. Scalar Matrix Product

• 하나의 scalar 값을 matrix에 곱함, 단 입력되는 matrix의 크기는 일정하지 않음

def scalar_matrix_product(alpha, matrix_variable):
    return [[alpha * element for element in row] for row in matrix_x]

# 실행결과
matrix_x = [[2, 2], [2, 2], [2, 2]]
matrix_y = [[2, 5], [2, 1]]
matrix_z = [[2, 4], [5, 3]]
matrix_w = [[2, 5], [1, 1], [2, 2]]

print(scalar_matrix_product(3, matrix_x))
print(scalar_matrix_product(2, matrix_y))
print(scalar_matrix_product(4, matrix_z))
print(scalar_matrix_product(3, matrix_w))

[[6, 6], [6, 6], [6, 6]]
[[4, 10], [4, 2]]
[[8, 16], [20, 12]]
[[6, 15], [3, 3], [6, 6]]

11. Is Product Availability Matrix

• 두 개의 matrix가 입력 되었을 경우, 두 matrix의 곱셈 연산의 가능 여부를 True 또는 False로 반환함

def is_product_availability_matrix(matrix_a, matrix_b):
     return len([colunm_vector for colunm_vector in zip(*matrix_a)]) == len(matrix_b)
     
# 실행 결과
matrix_x= [[2, 5], [1, 1]]
matrix_y = [[1, 1, 2], [2, 1, 1]]
matrix_z = [[2, 4], [5, 3], [1, 3]]

print(is_product_availability_matrix(matrix_y, matrix_x))
print(is_product_availability_matrix(matrix_y, matrix_z))
print(is_product_availability_matrix(matrix_z, matrix_x))
print(is_product_availability_matrix(matrix_z, matrix_w))
print(is_product_availability_matrix(matrix_x, matrix_x))

True

True

True

False

True

12. Matrix Product

• 곱셈 연산이 가능한 두 개의 matrix의 곱셈을 실행하여 반환함

def matrix_product(matrix_a, matrix_b):
    return [[sum(x * y for x, y in zip(row, col)) for col in zip(*matrix_b)] for row in matrix_a]]
    
# 실행결과
matrix_x= [[2, 5], [1, 1]]
matrix_y = [[1, 1, 2], [2, 1, 1]]
matrix_z = [[2, 4], [5, 3], [1, 3]]

print(matrix_product(matrix_y, matrix_z))
print(matrix_product(matrix_z, matrix_x))
print(matrix_product(matrix_x, matrix_x))

[[9, 13], [10, 14]]
[[8, 14], [13, 28], [5, 8]]
[[9, 15], [3, 6]]