
from typing import List

Vector = List[float]


# (키, 몸무게, 나이)

height_weight_age1 : Vector = [70, 170, 50]
height_weight_age2 : Vector = [66, 163, 50]


# (1차점수, 2차점수, 3차점수, 4차점수)

grades1 : Vector = [95, 80, 75, 62]
grades2 : Vector = [85, 82, 79, 82]


def addV(v: Vector, w: Vector) -> Vector:
    assert len(v) == len(w)   # 두 벡터의 길이가 같아야 함

    return [v_i + w_i for v_i, w_i in zip(v, w)]


addV(height_weight_age1, height_weight_age2)

[136, 333, 100]


addV(grades1, grades2)

[180, 162, 154, 144]


def vector_sum(vectors: List[Vector]) -> Vector:
    """
    인자: 동일한 차원의 벡터들의 리스트
    반환값: 각 항목의 합으로 이루어진 동일한 차원의 벡터
    """
    
    assert vectors                   # 1개 이상의 벡터가 주어져야 함

    num_elements = len(vectors[0])   # 벡터 개수
    
    assert all(len(v) == num_elements for v in vectors)   # 모든 벡터의 크기가 같아야 함

    # 동일한 위치의 항목을 모두 더한 값들로 이루어진 벡터 반환
    return [sum(vector[i] for vector in vectors)
            for i in range(num_elements)]


vector_sum([[1, 2], [3, 4], [5, 6], [7, 8]])

[16, 20]


def subtractV(v: Vector, w: Vector) -> Vector:
    assert len(v) == len(w)   # 두 벡터의 길이가 같아야 함

    return [v_i - w_i for v_i, w_i in zip(v, w)]


subtractV(height_weight_age1, height_weight_age2)

[4, 7, 0]


subtractV(grades1, grades2)

[10, -2, -4, -20]


def scalar_multV(c: float, v: Vector) -> Vector:
    return [c * v_i for v_i in v]


scalar_multV(2, [1, 2, 3])

[2, 4, 6]


def vector_mean(vectors: List[Vector]) -> Vector:
    n = len(vectors)
    return scalar_multV(1/n, vector_sum(vectors))


vector_mean([[1, 2], [2, 1], [2, 3]])

[1.6666666666666665, 2.0]


def dot(v: Vector, w: Vector) -> float:
    assert len(v) == len(w), "벡터들의 길이가 동일해야 함"""

    return sum(v_i * w_i for v_i, w_i in zip(v, w))


dot([1, 2, 3], [4, 5, 6]) == 32

True


import math

def sum_of_squares(v: Vector) -> float:

    return dot(v, v)

def magnitude(v: Vector) -> float:
    return math.sqrt(sum_of_squares(v))


magnitude([3, 4])

5.0


def squared_distance(v: Vector, w: Vector) -> float:
    return sum_of_squares(subtractV(v, w))

# 버전 1
def distance(v: Vector, w: Vector) -> float:
    return math.sqrt(squared_distance(v, w))

# 버전 2
def distance(v: Vector, w: Vector) -> float:
    return magnitude(subtractV(v, w))


distance([1,2], [2,1])

1.4142135623730951


Matrix = List[List[float]]


A = [[1, 2, 3],  # 2 x 3 행렬
     [4, 5, 6]]

B = [[1, 2],     # 3 x 2 행렬
     [3, 4],
     [5, 6]]


from typing import Tuple

def shape(A: Matrix) -> Tuple[int, int]:
    num_rows = len(A)
    num_cols = len(A[0]) if A else 0   # number of elements in first row
    return num_rows, num_cols


shape(A)

(2, 3)


shape(B)

(3, 2)


# 행벡터 계산
def get_row(A: Matrix, i: int) -> Vector:
    return A[i]             

# 열벡터 계산
def get_column(A: Matrix, j: int) -> Vector:
    return [A_i[j] for A_i in A]


get_row(A, 0)

[1, 2, 3]


get_column(B, 1)

[2, 4, 6]


from typing import Callable

def make_matrix(num_rows: int,
                num_cols: int,
                entry_fn: Callable[[int, int], float]) -> Matrix:
    return [ [entry_fn(i, j) for j in range(num_cols)] for i in range(num_rows)]


def zero_matrix(n: int, m:int) -> Matrix:
    return make_matrix(n, m, lambda i, j: 0)


zero_matrix(5,7)

[[0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0]]


def identity_matrix(n: int) -> Matrix:
    return make_matrix(n, n, lambda i, j: 1 if i == j else 0)


identity_matrix(5)

[[1, 0, 0, 0, 0],
 [0, 1, 0, 0, 0],
 [0, 0, 1, 0, 0],
 [0, 0, 0, 1, 0],
 [0, 0, 0, 0, 1]]


def addM(A: Matrix, B: Matrix) -> Matrix:
    assert shape(A) == shape(B)
    
    m, n = shape(A)
    
    return make_matrix(m, n, lambda i, j: A[i][j] + B[i][j])

def subtractM(A: Matrix, B: Matrix) -> Matrix:
    assert shape(A) == shape(B)
    
    m, n = shape(A)
    
    return make_matrix(m, n, lambda i, j: A[i][j] - B[i][j])


C = [[1, 3, 7],
     [1, 0, 0]]

D = [[0, 0, 5], 
     [7, 5, 0]]


addM(C, D)

[[1, 3, 12], [8, 5, 0]]


subtractM(C, D)

[[1, 3, 2], [-6, -5, 0]]


# pass와 None 적절한 코드와 표현식으로 대체하라.

def scalar_multM(c: float, A: Matrix) -> Matrix:
    pass

    return None


# pass와 None 적절한 코드와 표현식으로 대체하라.
# 힌트: 벡터 내적을 이용하라.

def multM(A: Matrix, B: Matrix) -> Matrix:
    pass

    return None


E = [[3, 1],
     [2, 1],
     [1, 0]]


assert addM(E, zero_matrix(3, 2)) == E


assert multM(E, identity_matrix(2)) == E


# pass와 None 적절한 코드와 표현식으로 대체하라.

def transpose(A: Matrix) -> Matrix:
    pass

    return None


assert transpose(transpost(A)) == A


assert transpose(addM(C, D)) == addM(transpose(C), transpose(D))


assert transpose(subtractM(C, D)) == subtractM(transpose(C), transpose(D))


assert transpose(scalar_multM(3, A)) == scalar_multM(3, transpose(A))


assert transpose(multM(A, B)) == multM(transpose(B), transpose(A))


friendships = [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (3, 4),
               (4, 5), (5, 6), (5, 7), (6, 8), (7, 8), (8, 9)]


# None 을 적절한 표현식으로 대체하라.

friend_matrix = None


assert friend_matrix[0][2] == 1


assert friend_matrix[8][0] == 0


friends_of_five = [ i for i, is_friend in enumerate(friend_matrix[5]) if is_friend ]

friends_of_five

선형대수 기초 밑바닥부터¶

주요 내용¶

목표¶

벡터¶

벡터 자료형¶

벡터 덧셈¶

벡터 덧셈의 기하적 의미¶

벡터 덧셈 함수¶

벡터 덧셈 함수 일반화¶

벡터 뺄셈¶

벡터 뺄셈의 기하적 의미¶

벡터 뺄셈 함수¶

벡터 스칼라 곱셈¶

스칼라 곱셈의 기하적 의미¶

벡터 스칼라 곱셈 함수¶

항목별 평균 벡터¶

항목별 평균 벡터 함수¶

벡터 내적¶

벡터 내적의 기하적 의미¶

벡터 내적 함수¶

벡터의 크기¶

벡터 사이의 거리¶

행렬¶

행렬 자료형¶

행렬의 모양(shape)¶

행벡터와 열벡터¶

행렬 생성 함수¶

특수 행렬¶

영행렬¶

단위행렬¶

행렬 덧셈과 뺄셈¶

행렬의 스칼라 곱셈¶

행렬 곱셈¶

행렬 곱셈과 벡터 내적¶

항등원¶

전치행렬¶

전치행렬의 성질¶

연습문제¶

문제 1¶

문제 2¶

문제 3¶

문제 4¶

문제 5¶

문제 6¶

문제 7¶