이재문

논문 작성시 유용한 도구 모음

https://youngseokim.tistory.com/72

https://moonjae.tistory.com/35

0 shot CoT는 여기 리뷰했어요!

만관부..

회사 세미나 준비하면서 개인적으로 해본 결과인데

뭐.. 저는 멍청이라 좀 좋은 프롬프트가 생각이 안 나네요

흠.. K의 갯수를 다르게 해서 성능 차이 났던걸 무시했네요.. ㅠ

• CCW
  • 점 3개가 있을 때 이 3점을 이은 방향을 알고자 할 때 쓰는 알고리즘
  • https://www.acmicpc.net/blog/view/27
  • 두점을 잇는 직선 2개의 벡터들을 외적했을 때
    • 값이 -1이면 세점은 시계방향으로 회전
    • 값이 0 이면 세점은 한 직선위에
    • 값이 1이면 세점은 반시계방향으로 회전한다

def ccw(a, b, c):
    return (b[0] - a[0])*(c[1] - a[1])-(c[0] - a[0])*(b[1] - a[1])

• convex hull
  • 수많은 점들이 있을 때 그중 일부를 이용해 볼록 다각형을 만들되 볼록 다각형 내에 모든 점이 있는 것을 만드는 알고리즘
  • 그라함 알고리즘이 대표적인 알고리즘
• 그라함 알고리즘
  • O(NlogN)으로 처리가 가능
  • 방법 https://red-pulse.tistory.com/182
• https://www.acmicpc.net/problem/1708

import sys
import math

def input():
    return sys.stdin.readline().rstrip()

INF = 10e9

N = int(input())
P = [list(map(int, input().split())) for i in range(N)]
S = []

def incl(a, b):
    return INF if a[0] == b[0] else (a[1]-b[1])/(a[0]-b[0])

def dist(a, b):
    return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2

def ccw(a, b, c):
    return (b[0] - a[0])*(c[1] - a[1])-(c[0] - a[0])*(b[1] - a[1]) > 0

def convex_hull():
    for p3 in P:
        while len(S) >= 2:
            p1, p2 = S[-2], S[-1]
            if ccw(p1, p2, p3):
                break
            S.pop()
        S.append(p3)

    return len(S)

P.sort()
P = P[:1] + sorted(P[1:], key = lambda x: incl(x, P[0]))

print(convex_hull())

https://www.acmicpc.net/problem/17403

import sys
import math

def input():
    return sys.stdin.readline().rstrip()

INF = 10e9

N = int(input())
P = [list(map(int, input().split())) for i in range(N)]
ans = [0] * N

def incl(a, b):
    return INF if a[0] == b[0] else (a[1]-b[1])/(a[0]-b[0])

def dist(a, b):
    return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2

def ccw(a, b, c):
    return (b[0] - a[0])*(c[1] - a[1])-(c[0] - a[0])*(b[1] - a[1])

def convex_hull(prev_P, cur):
    S = []
    sorted_P = sorted(prev_P)
    sorted_P = sorted_P[:1] + sorted(sorted_P[1:], key = lambda x: (incl(x, sorted_P[0]), dist(x, sorted_P[0])))
    for p3 in sorted_P:
        while len(S) >= 2:
            p1, p2 = S[-2], S[-1]
            if ccw(p1, p2, p3) > 0:
                break
            S.pop()
        S.append(p3)
    if len(S) <= 2:
        return sorted_P, S
    ans[P.index(S[0])] = cur
    sorted_P.remove(S[0])
    
    for i in range(2, len(S)):
        if ccw(S[i-2], S[i-1], S[i]) != 0:
            ans[P.index(S[i-1])] = cur
        sorted_P.remove(S[i-1])
        
    ans[P.index(S[-1])] = cur
    sorted_P.remove(S[-1])
    
    return sorted_P, S

prev_P = P.copy()

cur = 1
while True:
    prev_P, k = convex_hull(prev_P, cur)
    if len(k) <= 2:
        break
    cur += 1
print(*ans)

1. Pandas

• 데이터 분석과 처리를 위한 라이브러리
• numpy와 같이 행과 열에 대해서 다루지만 numpy는 수치 분석등에 유용하고 pandas는 데이터들의 처리에 유용하다
• pandas의 강점은 데이터 탐색에 있다
• pandas 자료구조에는 1차원 - Series, 2차원 - DataFrame, 3차원 - Panel 등이 있다

2. Pandas 사용하기

import pandas as pd

3. Pandas로 1차원 데이터 다루기 - Series

• 1차원적인 데이터 집합이다

s = pd.Series([1,4,9,16,25])

• 딕셔너리도 호환이 가능하다

t = pd.Series({'one': 1, 'two': 2, 'three':3})

4. Series + Numpy 

• Seires는 ndarray와 유사하다

print(s[1]) #pandas 인덱싱
print(t[1])
print(t[1:3]) #pandas 슬라이싱

• numpy와 다르게 조건을 추가하기 쉽다.

#자신의 중앙값보다 큰 값만 가지고 오기

s[s > s.median()]

• numpy와 호환 가능하다

import numpy as np

#자연상수 e의 s제곱 값
np.exp(s)

5. Series + dict

• series는 dict과도 유사하다

print(t['one'])

• series에 값 추가

t['six'] = 6

• dic_series에서 요소 찾기

print(t['six'])

#딕셔너리와 마찬가지로 없는 값 접근 불가
#print(t['seven'])

#없는 값 가져오기
#값이 없으면 2번째 인자를 가져옴

print(t.get('seven', 0))

6. Series에 이름 붙이기

• 'name' 속성을 가지고 있다
• 처음 Series를 만들 때 이름을 붙일 수 있다

s = pd.Series(np.random.randn(5), name = 'rand_num')
print(s)
print(s.name)

7. DataFrame

• 2차원 데이터

d = {'height':[175,173,169,183], 'weight':[60, 78, 65, 84]}

df = pd.DataFrame(d)

df

8. CSV에서 DataFrame으로 옮기기

• csv -> dataframe화 하는 함수 존재
• .read_csv()를 이용
• https://www.kaggle.com/datasets/imdevskp/corona-virus-report  사용된 CSV

covid = pd.read_csv('파일의 위치')

print(covid)

• 일부분만 관찰하기

N = 5
#위에서부터 N개 관찰하기
print(covid.head(N))
#아래서부터 N개 관찰하기
print(covid.tail(N))

• 데이터 접근하기
  •  df['column_name']  or df.column.name

print(covid['Active'])
print(covid.Active)
print(covid['Active'][1:5])

• 조건을 이용해서 데이터 접근하기

# 신규 확진자가 10이하인 나라를 찾아보기

covid[covid['New cases']<10]

# WHO 지역이 동남아인 나라 찾기

print(covid['WHO Region'].unique()) #중복 되지 않는 지역의 목록 살펴보기

covid[covid['WHO Region'] == 'South-East Asia']

• 인덱스를 통해 가져오고 싶으면 loc=key, iloc = index를 통해 가져올 수 있다

9. Groupby

• 일정한 조건으로 묶는 방법
• Groupby 과정
  • Split : 특정한 "기준"을 바탕으로 DataFrame을 분할
  • Apply : 통계함수 - sum(), mean(), median()을 적용해서 각 데이터 압축
  • Combine: Apply된 결과를 바탕으로 새로운 Series 생성

# WHO Region별 확진자 수 구하기

#split
covid_by_region = covid['Confirmed'].groupby(by = covid['WHO Region'])

#Apply
covid_by_region_sum = covid_by_region.sum()
print(covid_by_region_sum)

#Combine
covid_by_region_sum_df = pd.DataFrame(covid_by_region_sum)
print(covid_by_region_sum_df)

10. 데이터 병합

• merge(가로 병합), concat(세로 병합)을 사용

user = pd.DataFrame({'id':[1,2,3,4], 'name' = ['재문', '민준', '영희', '철수']})

game = pd.DataFrame({'id':[1,2,3,4], 'name' = ['LOL','PUBG','DarkSoul','발더게3', 'Play_User' = [1,3,2,2]}

new_user = pd.DataFrame({'id':[5,6], 'name' = ['창수', '호야']})

# 세로로 합치기 = append, concat
# ignore_index를 통해 새로 인덱스 지정 가능

new_user_set = user.append(new_user, ignore_index = True)
print(new_user_set)

new_user_set2 = pd.concat([user,new_user], ignore_index = True)
print(new_user_set2)

#가로로 합치기 = merge
#기준 열 이름이 같을 때 on = 기준열, how = join 방식
#기준 열 이름이 다를 때 left_on = 왼쪽 열, right_on 오른쪽 열 
ans = game.merge(user, left_on = 'rent_user', right_on = 'id')

• suffixes = 병합할 객체들간 이름이 중복되는 열이 있을 때, 해당 열에 붙일 접미사 설정

ans = game.merge(user, left_on = 'rent_user', right_on = 'id',suffixes=('','_user'))

• drop을 통해 해당 열을 날릴 수 있음

#axis = 0 가로 axis = 1 세로
ans.drop('id_user' ,axis = 1)

더 다양한 기능은: https://wikidocs.net/151740 여기에 많이 적혀 있네요 

• Numpy
  • Numpy는 는 벡터 및 행렬 연산에 있어서 매우 편리한 기능을 제공하는 파이썬 라이브러리이다
• 넘파이 기본 사용 예제
  • 배열을 np.array()로 선언

import numpy as np

#기본 배열 선언
A = np.array([[1,2],[2,3]])

#넘파이 베열의 수 확인 = np.shape()
print(np.shape(A))

• 벡터와 스칼라 연산

#벡터 스칼라 연산

x = np.array([1])
y = 3

print("스칼라 벡터 덧셈 {}".format(x+y))
print("스칼라 벡터 곱셈 {}".format(x*y))

• 벡터와 벡터의 연산
  • 벡터와 벡터의 연산에서의 주의 사항은 행과 열이 같아야 재대로 된 연산이 가능하다
  • 추후에 나올 브로드캐스팅이 있는데 그건 추후에 기술

#벡터 벡터 연산
#벡터 연산은 행과 열이 모두 일치할 때 가능

x = np.array([1,2,3])
y = np.array([4,5,6])

print("스칼라 벡터 덧셈 {}".format(x+y))
print("스칼라 벡터 곱셈 {}".format(x*y))

• 넘파이의 인덱싱과 슬라이싱
  • 기본적으로 파이썬과 같지만 2차원 이상 일 때 대괄호 연속해서 치는 python코드와 달리 한 대괄호 내에서 처리한다

#파이썬 indexing과 유사

x = np.array([[1,2,3,4],[2,3,4,5],[4,5,6,7]])

print(x[0,0])
print(x[1,2])

#파이썬 Slicing과 유사

x = np.array([[1,2,3,4],[2,3,4,5],[4,5,6,7]])

print(x[0:2, 0:2])
print(x[0:2])

• 넘파이의 브로드캐스팅
  • 행과 열과 같은 길이가 아니면 연산이 원하는 대로 안 나올 수 있는데 이를 해결하기 위해 브로드캐스팅을 넘파이에서 해준다
  • 브로드캐스팅이란  피연산자를 복제해 같은 data type으로 변형 시킬 수 있으면 복제해서 연산을 실행하는 것이다
  • 예를들어 [[1,2],[1,1]]에 [0,1]을 더하면 1열 뿐만 아니라 2열도 [0,1]과의 연산을 하는 것이다

#Array Broadcating은 피연산자를 복제해 같은 data type으로 변형 시킬 수 잇으면 그리한대요~~

#열 복사
a = np.array([[1, 2, 3], [4,5,6], [7,8,9]])
x = np.array([0,1,0])

x = x[:, None] #x를 전치

print(a+x)

#행 복사
a = np.array([[1, 2, 3], [4,5,6], [7,8,9]])
x = np.array([0,1,-1])

print(a*x)

• 영 벡터(행렬)
  • 모든 원소의 값이 0인 벡터(행렬)
  • 'np.zeros(dim)'을 통해 생성 / dim은 값, 혹은 튜플(,)
  • 일벡터도 동일하게 ones통해 생성

print(np.zeros(3))

print(np.zeros((3,3,3)))

print(np.ones(3))

• 대각행렬
  • main diagonal을 제외한 성분이 0인 행렬
  • 'np.diag'(main_diagonal <- tuple)을 통해 생성

print(np.diag((2, 4)))

print(np.diag((1,3,5)))

• 항등 행렬
  • main diagonal이 1인 대각 행렬
  • 'np.eye(length, dtype = type)'을 통해 생성
  • dtype의 default = float

print(np.eye(3, dtype = int))

• ★ 행렬곱
  • 행렬 곱은 n * r , r * m 일때 r이 서로 같아야 연산 가능
  • 행렬의 곱은 * 기호가 아니라 @를 통해 연산한다
  • 'A.dot(B)'로도 사용 가능 단 3차원이상은 @ 과 dot은 다르게 연산 된다

A = np.array([[1, 2], [3,5]])
B = np.array([[1, 3], [2,4]])

print(A.dot(B))
print(A @ B)

• trace
  • Main diagonal의 합
  • 'np.trace()'사용

A = np.array([[1,2,5],[2,4,1]])

print(A.trace())
print(np.eye(2, dtype = int).trace())

• 행렬식
  • 행렬을 대표하는 값들 중 하나 -> 선형 변환
  • 'np.linalg.det()'으로 계산

arr_3 = np.array([[1,4,7],[2,5,8],[3,6,9]])

print(np.linalg.det(arr_3))

• 역행렬
  • A에 대해 AB = BA를 만족하는 행렬
  • 'np.linalg.inv()'로 계산

arr_2 = np.array([[1, 2], [3, 5]])
arr_inv = np.array([[1, 2], [3,5]])
print(arr_inv)

#검증
print(arr_2 @ arr_inv)

• 고유값과 고유벡터
  • 정방행렬 A에 대해 Ax(\lambda)x를 만족하는 상수 (\lambda)와 이에 대응되는 벡터
  • 'np.linalg.eig()'로 계산

mat = np.array([[2, 0, -2], [1, 1, -2], [0, 0, 1]])

print(mat)

print(np.linalg.eig(mat))

#검증
eig_val , eig_vec = np.linalg.eig(mat)

print(mat @ eig_vec[:, 0]) # Ax

print(eig_val[0] * eig_vec[:,0])# (lambda)x

• Norm
  • Norm 은 벡터의 크기(혹은 길이)를 측정하는 방법
  • L1 Norm: 각 벡터의 원소의 절대값들의 합
  • L2 Norm: 각 벡터를 잇는 선분의 길이

def get_L2_norm(arr):
  return np.linalg.norm(arr)

A = np.array([1,2,3,4,5])

print(get_L2_norm(A))

• 특이 행렬
  • 역행렬이 존재하지 않는 행렬
  •  역행렬이 존재하지 않기 위해서는 행렬식(Determinant)이 0이 되어야 한다.

def singular_matrix(arr):
  return True if np.linalg.det(arr) == 0 else False

A = np.array([[1,4,0],[2,5,0],[3,6,0]])

print(singular_matrix(A))

1.  Git : 분산 버전 관리 시스템

• Git에는 로컬 레포지토리하고 서버에 레포지토리(저장소)가 있는데 내 로컬에서 충분히 작업을 한 후 서버에 업데이트를 하면 추후 다른 분산 개발자가 업데이트를 받아 사용 할 수 있다
• 깃 설치 방법: 터미널 -> sudo apt get install git -all(리눅스), git --version(MacOs)
• 기본 용어 및 사용 방법:
  • git init: 로컬 레포지토리 생성 및 초기화, .git 폴더에 git에 필요한 파일 생성(기본적으로 숨겨져 있음)
  • git status: 파일의 상태를 확인하는 명령어
  • git add: 작업 폴더에서 작업한 변경을 stage에 올릴 때 사용하는 명령어, add한 파일이 staged상태가 됨
    • staged: 현재 수정한 파일을 곧 커밋할 것이라고 표시한 상태
  • git commit: stage에 있는 값들을 로컬 저장소 데이터베이스에 저장 하는 것

2.  Git Branch

• 나무의 가지와 비슷함
• 어떤 작업을 독립적으로 진행하기 위해 만들어진 기능
• 각각의 브랜치들은 다른 브랜치의 영향을 받지 않아서, 동시에 여러 작업을 가능하게 한다
• 또한 이 브랜치들끼리 모여(merge) 다른 하나의 브랜치를 만들 수 있다
• 브랜치 용어 및 사용 방법:
  • git branch -v: 브랜치 확인(master가 기본, git-hub는 main이 기본)
  • git checkout <branch_name>: 해당 브랜치로 이동해 작업
  • git merge <branch_name>: 현재 있는 브랜치에 적은 브랜치를 병합
  • git branch -d <branch_name>: 브랜치 삭제

3.  Git Hub

• 다른 사람과의 협업을 위해 서버에 원격 저장소를 두게 하는 서비스
• 기본적으로 branch가 main이 기본
• pull / push를 통해 서버에 저장 가능
• git hub용어 및 사용방법:
  • git clone <url> : 해당 url을 클론 시킨다
    • clone:  해당 소스를 다운 받아 내가 작업 할 수 있게 만드는 것
  • git push <repository_name><branch_name>: commit한 파일을 원격 저장소에 올리는 명령어
  • git fetch <repository_name>: 로컬에는 없지만 원격 저장소에 있는 데이터를 모두 가져옴, 데이터를 합치지는 않음
  • git pull <repository_name><branch_name>: 원격 저장소의 데이터를 가져오고, 자동으로 현재 작업하는 로컬 브랜치와 merge
    • 서로 영향을 안받게, branch를 지정하는게 중요함
  • git merge <branch_name>: 현재 있는 브랜치에 적은 브랜치를 병합

1. 선형 시스템

• 선형 시스템: Ax + b와 같은 연립 1차 방정식의 대수적 표현
• Ax + b로의 표현으로는 A, b(linear question)과 x(미지수) 로 표현된다
• 표현은 다음과 같다
  
  1. 선형시스템의 unknown을 모아 열벡터로 표현한다
  2. 선형시스템의 linear equestion에 대해 다음을 수행한다
     • 계수를 모아 A의 행벡터로 표현한다
     • 상수를 모아 b에 의해 표현한다

• Ax + b에서 A의 행벡터의 모든 값이 0인 경우 해가 무수히 많거나 해가 없을 수 있다

2. 선형 시스템에서의 해

• 선형 시스템 Ax + b에서의 해는 기본적으로 inverse(A)*b로 구할 수 있다
• 이를 numpy에서 구현하면 아래와 같이 나온다

#numpy 호출
import numpy as np

#행렬 코딩

A = np.array([[3, 1, 1], [1, -2, -1], [1, 1, 1]])
print(A)
print(np.shape(A)) #np.shape = ? x ? 행렬인지 표현

#벡터 코딩
#벡터는 열로 표현하지만 너무 번거롭기 때문에 행으로 표현
b = np.array([4, 1, 2])
print(b)

#역행렬 구하기
# x = A_inv * b
A_inv = np.linalg.inv(A)
print(A_inv)

#역 행렬을 이용한 선형시스템 Ax = b의 해 구하기
x = A_inv @ b

print(x)

#결과 검증
#bb = np.matmul(A, x)
bb = A @ x

print(bb)
print('OK' if np.linalg.norm(b-bb) < 1e-3 else 'Not OK')

3. 가우스 소거법

• 가우스 소거법을 알기전에 필요한 용어로는 아래와 같이 있다
  • 피벗(Pivot, Leading Entry)은 각 행에서 처음으로 나오는 00이 아닌 성분
  • 행사다리꼴(Row Echelon Form Matrix)은 모든 피벗이 다른 열에 위치하고, 모든 성분이 0인 행이 그렇지 않은 행의 앞쪽에 나오는 경우가 존재하지 않으며, 임의의 두 피벗을 비교했을 때 항상 앞쪽 행의 피벗이 앞쪽 열에 위치하는 행렬이다.
  • 기약행사다리꼴(Reduced Row Echelon Form, RREF)은 피벗의 값이 모두 1이고, 피벗과 같은 열에 위치하는 성분은 모두 0인 행사다리꼴이다.
  • 대각행렬(Diagonal Matrix)은 주대각선 이외의 성분이 모두 0인 정사각행렬이다.
    • 출처 : https://00ad-8e71-00ff-055d.tistory.com/61
• 가우스 소거법의 방법으로는 아래와 같이 있다
  • 전방소거법: 주어진 선형시스템을 아래로 갈수록 더 단순한 형태의 선형방정식을 가지도록 변형
  • 후방대입법: 아래에서부터 위로 미지수의 실제값을 대치한다

• 전방 소거법의 절차로는 아래의 방법을 통해 진행 된다
  1. 각열의 행의 값을 pivot으로 잡기
  2. 스케일링을 통해 pivot과 같은 배수값으로 변경
  3. 치환으로 식을 바꾸기
  4. 4교환을 통해 다음 열의 pivot항의 값이 0이 되지 않게 교환
  5. 제일 밑항까지 반복
• 가우스 소거법의 대표적인 PS문제가 있는데 다음과 같다 https://www.acmicpc.net/problem/22940

• 다음 문제에 대한 해결 방법은 다음과 같다 (후방 대입법은 이분을 참고 하였다 / https://guru.tistory.com/54

import sys
def input():
    return sys.stdin.readline().rstrip()

def gauss(A, x):
    n = len(A)
    for i in range(n):
        # 전방 소거법
        # A[i][i]와 A[j][i] 같게 만든 후 나머지 항들을 빼준다
        for j in range(i+1, n):
            div = A[j][i]/A[i][i]
            for k in range(n+1):
                A[j][k] -= div*A[i][k]

    #후방 대입법
    for i in range(n-1, -1, -1):
        x[i] = A[i][n]
        for j in range(i+1, n):
            x[i] -= A[i][j] *x[j]
        x[i] /= A[i][i]

N = int(input())

A = [list(map(int, input().split())) for i in range(N)]

X = [0 for i in range(N)]

gauss(A,X)

ans = [round(i) for i in X]

print(*ans)

• Rank 시스템: 가우스 소거법의 전방소거법을 통해 의미 있는 식의 갯수를 알려주는 시스템
  • Rank의 수의 따라 판별 할 수 있는 해의 갯수가 달라진다

4.  LU분해

• 주어진 행렬을 상삼각행렬과 하 삼각행렬의 곱으로 나누는 행렬의 형태이다
  • 상삼각행렬(Upper Triangular Matrix)은 주대각선 아래의 성분이 모두 0인 정사각행렬이다.
  • 하삼각행렬(Lower Triangular Matrix)은 주대각선 위의 성분이 모두 0인 정사각행렬이다.
• Ax + b의 형태에서 LUx = b 형태로 변환할 수 있고 Ux = y 로 대입해 Ly = b 라는 식을 이끌어 낼 수 있다
• LU분해를 쓰는 이유는 아래와 같이 있다 
  • 수치적 안정성
  • b가 자주업데이트 되는 경우 연산 속도의 향상

5. 행렬의 다양한 용어

• 스칼라 : 어느 한 원소만을 가지고 있는것 (점과 유사)
• 벡터 : 스칼라의 집합으로 만들어진 1 x N 혹은 N x 1의 행렬(선과 유사)
• 행렬 : 직사각형 구조에 숫자들을 담아 놓은 구조 -> 열벡터나 행벡터들의 모음
• 전치행렬: NxM의 행렬을 MxN의 행렬로 바꿔 놓은 형태
• 영행렬 : 모든 원소의 값이 0인 행렬
• 정방행렬: NxN의 정사각형 행렬
  • 주대각선: 정방 행렬에서 a(i,i)들의 집합
  • 항등행렬: 주대각선은 모두 1이고 나머지는 0인 정방행렬
• 행렬의 합과 곱:
  • 행렬의 합: A,B행렬의 모든 행과 열의 갯수가 갓을때 C(i,j) = A(i,j)+B(i,j)로 표현
  • 행렬의 곱:m*r의 A행렬과 r*n의 행렬에 대해 AB = C에서 C(i,j) = A(i,1)*B(1,j)+A(i,2)*B(2,j)....A(i,r)*B(r,j)로 정의
    • 행렬의 곱에서 일반적으로 A*B ≠  B*A 이고 A*(B*C) ≠ (A*B)*C이다
• 텐서: 스칼라, 벡터, 행렬을 아우르는 개념, 숫자가 늘어설 수 잇는 방향이 K면 K-텐서로 부름
  
  • 스칼라 -> 0-텐서, 벡터 -> 1-텐서, 행렬 -> 2-텐서
• 분할 행렬: 행렬을 몇개의 조각 단위로 분할하여 생각한 것

6. 선형 조합

• 행렬은 열벡터의 리스트들이다
• Ax는 행렬 A가 가지고 있는 열벡터의 선형 조합이다
  •  x1a1 + x2a2...+xnan
• 선형대수에서 이처럼 벡터들에 대한 가중치의 합이 선형 조합이라고 한다
• 행렬 A의 열벡터들의 대한 모든 선형 조합의 결과를 모아 집합으로 구성될 때 그 집합을 열공간이라고 하며 col(A)로 표현된다

7. 좌표계 변환

• 좌표계를 도입한 후 시작점을 원접으로 맞추고 끝점을 v로 표현한것
• 좌표계 변환: 아래와 같이 변환 벡터들의 곱을 해당 축과의 좌표로 변환 할 수 있다

8. 선형 변환

• 선형 함수: 임의의 함수 f가 두가지 조건을 만족하면 f를 선형 함수라고 한다
  • f(x+y) = f(x) + f(y)
  • f(cx) = c*f(x)
•  함수의 입력이 n-벡터이고 출력이 m벡터인 함수 T를 변환이라고 한다.
  • T:Rn⟶Rm
• 특별히 n = m이면 연산자(operation)이라고 한다
• 여기서 선형 함수의 성질을 만족하면 선형 변환이라고 한다

• 선형 변환에 대한 코딩
  1. 구현하고자 하는 function과의 입력과 출력이 벡터로 정의 되는지 확인
  2. 구현하고자 하는 기능이 선형인지 확인
  3. 입력이 n-벡터고 출력이 m벡터면 m*n표준 행렬 구성
• 표준행렬을 이용한 선형변환 코딩
  • 다음의 m×n 표준행렬(standard matrix)을 구성함으로써, 우리가 원하는 방식대로 동작하는 행렬변환 TA​:Rn⟶Rm을 코딩할 수 있다
    • A=[TA​(e1​)TA​(e2​)⋯TA​(en​)]m×n​

https://developer.android.com/jetpack/compose/tutorial?hl=ko 

해당 링크를 보고 따라 적용해 보았다..
기존에 안드로이드를 배울때 xml을 통해서 만들었던거 같은데.. 시대가 변한거 같다
 
약간 예전에 스위프트를 배울때 UI를 지정할때 하던 방식과 비슷한 느낌을 많이 받았는데
MVVM모델 적용시 더욱 보기 편하고 구성하기 쉬울거 같다는 생각을 한다.
아직 MVVM아키텍처를 설계하는 방법을 잘 모르긴 하지만.. 차차 연습해 나가면서 해봐야 할거 같다
 
더 자세한 정보는 
https://developer.android.com/jetpack/compose/mental-model?hl=ko 

을 보는것을 추천드린다.

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Compose_practiceTheme() {
                Surface(modifier = Modifier.fillMaxSize()) {
                    Conversation(conversationSample)
                }
            }
        }
    }
}


data class Message(val author: String, val body: String)

//== VIEW
@Composable
fun MessageCard(msg: Message){
    Row(modifier = Modifier.padding(all = 8.dp)){
        Image(
            painter = painterResource(id = jordan1) ,
            contentDescription = "Jordan1 x OffWhite",
            modifier = Modifier.run {
                size(40.dp)
                        .clip(CircleShape)
                        .border(1.5.dp, MaterialTheme.colorScheme.secondary, CircleShape)
            })
        Spacer(modifier = Modifier.width(8.dp)
        )
        // 상태를 기억하는거 같음
        var isExpanded by remember{ mutableStateOf(false) }
        // 클릭시 반대 값으로 지정
        Column(modifier = Modifier.clickable { isExpanded = !isExpanded }){
            Text(text = msg.author,
                color = MaterialTheme.colorScheme.secondary,
                style = MaterialTheme.typography.titleLarge)
            Spacer(modifier = Modifier.height(4.dp))
            Surface(shape = MaterialTheme.shapes.medium, tonalElevation = 1.dp){
                Text(text = msg.body,
                    modifier = Modifier.padding(all = 4.dp),
                    maxLines = if (isExpanded) Int.MAX_VALUE else 1,
                    style = MaterialTheme.typography.bodyMedium)
            }
        }
    }
}

@Composable
fun Conversation(messages: List<Message>){
    LazyColumn{
        items(messages){ message ->
            MessageCard(message)
        }
    }
}

@Preview(showBackground = true, name = "Light Mode")
@Preview(
    uiMode = Configuration.UI_MODE_NIGHT_YES,
    showBackground = true,
    name = "Dark Mode"
)
@Composable
fun PreviewMessageCard() {
    Compose_practiceTheme{
        Surface{
            Conversation(conversationSample)
        }
    }
}