print("Hello World")

def HelloWorldXY(x, y):
  if (x < 10):
    print("Hello World, x was < 10")
  elif (x < 20):
    print("Hello World, x was >= 10 but < 20")
  else:
    print("Hello World, x was >= 20")
  return x + y

for i in range(8, 25, 5):  # i=8, 13, 18, 23 (start, stop, step)
  print("--- Now running with i: {}".format(i))
  r = HelloWorldXY(i,i)
  print("Result from HelloWorld: {}".format(r))

print(HelloWorldXY(1,2))

print("Iterate over the items. `range(2)` is like a list [0,1].")
for i in range(2):
  print(i)

print("Iterate over an actual list.")
for i in [0,1]:
  print(i)

print("While works")
i = 0
while i < 2:
  print(i)
  i += 1

print("Python supports standard key words like continue and break")
while True:
  print("Entered while")
  break

import numpy as np  # Make numpy available using np.

# Create a numpy array, and append an element
a = np.array(["Hello", "World"])
a = np.append(a, "!")
print("Current array: {}".format(a))
print("Printing each element")
for i in a:
  print(i)

print("\nPrinting each element and their index")
for i,e in enumerate(a):
  print("Index: {}, was: {}".format(i, e))

print("\nShowing some basic math on arrays")
b = np.array([0,1,4,3,2])
print("Max: {}".format(np.max(b)))
print("Average: {}".format(np.average(b)))
print("Max index: {}".format(np.argmax(b)))

print("\nYou can print the type of anything")
print("Type of b: {}, type of b[0]: {}".format(type(a), type(a[0])))

print("\nUse numpy to create a [3,3] dimension array with random number")
c = np.random.rand(3, 3)
print(c)

print("\nYou can print the dimensions of arrays")
print("Shape of a: {}".format(a.shape))
print("Shape of b: {}".format(b.shape))
print("Shape of c: {}".format(c.shape))

import numpy as np
from IPython.display import display

a = np.array([1, 2, 3])  # 랭크 1 배열을 만듭니다
print(type(a), a.shape, a[0], a[1], a[2])
a[0] = 5                 # 배열의 요소를 변경합니다
display(a)

b = np.array([[1,2,3],[4,5,6]])   # 랭크 2 배열을 만듭니다
display(b)

print(b.shape)  # b의 모양을 출력합니다. 일반적으로 배열의 모양은 배열의 차원입니다.
print(b[0, 0], b[0, 1], b[1, 0])

a = np.zeros((2,2))  # 0으로 가득찬 배열을 만듭니다.
display(a)

b = np.ones((1,2))   # 1로 가득찬 배열을 만듭니다.
display(b)

c = np.full((2,2), 7) # 상수 배열을 만듭니다.
display(c)

d = np.eye(2)        # 2x2 단위행렬을 만듭니다.
display(d)

e = np.random.random((2,2)) # 0~1 사이의 값 중 무작위값으로 채워진 배열을 만듭니다.
display(e)

f = np.random.randn(2,2)  # 표준정규분포를 따르는 무작위값 배열을 만듭니다.
display(f)

g = np.random.normal(size=(2,2))  # 정규분포를 따르는 무작위값 배열을 만듭니다.
display(g)

# (3,4) 형태의 랭크 2 배열을 만듭니다.
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

# 슬라이싱을 이용하여 처음 두 행과 두 열로 구성된 부분배열을 만듭니다.
# b 는 (2, 2) 형태의 배열이 됩니다.
# [[2 3]
#  [6 7]]
b = a[:2, 1:3]
display(b)

print(a[0, 1])
b[0, 0] = 77    # b[0, 0] 는 a[0, 1] 과 동일한 데이터를 갖고 있습니다.
print(a[0, 1])

# (3, 4) 모양의 랭크 2 배열을 만듭니다.
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
display(a)

row_r1 = a[1, :]    # a의 두번째 행의 랭크 1 뷰  
row_r2 = a[1:2, :]  # a의 두번째 행의 랭크 2 뷰
row_r3 = a[[1], :]  # a의 두번째 행의 랭크 2 뷰
print(row_r1, row_r1.shape)  # 정수 인덱스와 섞은 경우
print(row_r2, row_r2.shape)  # 슬라이스만 사용한 경우
print(row_r3, row_r3.shape)  # 슬라이스만 사용한 경우

# 행이 아닌 열의 경우에도 마찬가지입니다:
col_r1 = a[:, 1]
col_r2 = a[:, 1:2]
print (col_r1, col_r1.shape)  # 출력 "[ 2  6 10] (3,)"
print (col_r2, col_r2.shape)  # 출력 "[[ 2]
                              #       [ 6]
                              #       [10]] (3, 1)"

a = np.array([[1,2], [3, 4], [5, 6]])
display(a)

# 정수 배열 인덱싱 예.
# 결과 배열은 (3,) 형태가 됩니다. 
display(a[[0, 1, 2], [0, 1, 0]])

# 위의 정수 배열 인덱싱은 아래와 같습니다.
display(np.array([a[0, 0], a[1, 1], a[2, 0]]))

# 배열 인덱싱을 사용할 때, 소스 배열과 같은 요소를 사용해도 됩니다.
display(a[[0, 0], [1, 1]])

# 위의 정수 배열 인덱싱 예와 같은 경우입니다.
display(np.array([a[0, 1], a[0, 1]]))

# 요소를 선택할 새 배열을 만듭니다.
a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
display(a)

# 인덱스 배열을 만듭니다.
b = np.array([0, 2, 0, 1])

# b의 인덱스를 이용하여 a의 각 행으로부터 하나의 요소들을 선택합니다.
display(a[np.arange(4), b])  # Prints "[ 1  6  7 11]"

# b의 인덱스를 이용하여 각 행의 하나의 요소를 변경합니다.
a[np.arange(4), b] += 10
display(a)

import numpy as np

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

bool_idx = (a > 2)  # 2보다 큰 a의 원소를 찾습니다. 
                    # 이것은 a와 동일한 모양의 부울 값 배열을 반환합니다. 
                    # 여기서 bool_idx의 각 슬롯은 a의 해당 요소가 2보다 큰지 여부를 나타냅니다.

display(bool_idx)

# 부울 배열 인덱싱을 사용하여 bool_idx의 True 값에 해당하는 요소로 구성된 
# 랭크 1 배열을 생성합니다
display(a[bool_idx])

# 위의 모든 것을 간결하게 할 수 있습니다.
display(a[a > 2])

x = np.array([1, 2])  # numpy 가 데이터 유형을 선택하게 합시다.
y = np.array([1.0, 2.0])  # numpy 가 데이터 유형을 선택하게 합시다.
z = np.array([1, 2], dtype=np.int64)  # 특정 데이터 유형을 강제로 할당합시다.

print(x.dtype, y.dtype, z.dtype)

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

# 요소별 합. 둘 다 배열을 만듭니다.
display(x + y)
display(np.add(x, y))

# 요소별 차. 둘 다 배열을 만듭니다.
print(x - y)
print(np.subtract(x, y))

# 요소별 곱. 둘 다 배열을 만듭니다.
print(x * y)
print(np.multiply(x, y))

# 요소별 나누기. 둘 다 배열을 만듭니다.
# [[ 0.2         0.33333333]
#  [ 0.42857143  0.5       ]]
print(x / y)
print(np.divide(x, y))

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

v = np.array([9,10])
w = np.array([11, 12])

# 벡터의 내적.  둘 다 219
print(v.dot(w))
print(np.dot(v, w))

# 행렬 / 벡터 곱. 둘 다 랭크 1 배열 [29 67] 을 만듭니다.
print(x.dot(v))
print(np.dot(x, v))

# 행렬 / 행렬 곱. 둘 다 랭크 2 배열을 만듭니다.
# [[19 22]
#  [43 50]]
print(x.dot(y))
print(np.dot(x, y))

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

print(np.sum(x))  # 모든 요소의 합. "10"을 출력합니다.
print(np.sum(x, axis=0))  # 각 열의 합. "[4 6]" 을 출력합니다.
print(np.sum(x, axis=1))  # 각 행의 합. "[3 7]" 을 출력합니다.

print(x)
print(x.T)

v = np.array([[1,2,3]])
print(v)
print(v.T)

# 행렬 x의 각 행에 벡터 v를 더하고 그 결과를 행렬 y에 저장할 것입니다.
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = np.empty_like(x)   # x와 같은 모양의 빈 행렬 생성

# 루프를 이용하여 행렬의 각 행에 벡터 v를 더한다.
for i in range(4):
    y[i, :] = x[i, :] + v

display(y)

vv = np.tile(v, (4, 1))  # v의 4개의 카피를 쌓음.
print(vv)                # 출력은   "[[1 0 1]
                         #          [1 0 1]
                         #          [1 0 1]
                         #          [1 0 1]]"

y = x + vv  # x 와 vv를 요소별로 더함
print(y)

y = x + v  # 브로드캐스팅을 이용해 x의 각 행에 v를 더하기
print(y)

v = np.array([1,2,3])  # v 는 (3,) 모양
w = np.array([4,5])    # w 는 (2,) 모양
# 벡터를 행렬의 각 행에 더합니다.
x = np.array([[1,2,3], [4,5,6]])
# x 는 (2, 3) 모양이며, v 는 (3, ) 모양입니다. 그래서 (2, 3)으로 브로드캐스트됩니다:

print(x + v)

# 행렬의 각 열에 벡터를 추가합니다. 
# x는 (2, 3) 모양이고 w는 (2,) 모양 입니다.
# x를 전치한다면 (3, 2) 모양이 되며, w에 대해 브로드캐스트하여 (3, 2) 모양의 결과를 얻을 수 있습니다. 
# 이 결과를 전치하면 (2, 3) 모양의 최종 결과가 나오는데, 이는 행렬 x의 각 열에 벡터 w를 더한 것입니다.

print((x.T + w).T)

# 다른 방법은 w의 모양을 (2, 1)의 행벡터로 바꾸는 것입니다.
# 그 다음 x에 대해 바로 브로드캐스트하여 같은 결과를 만들 수 있습니다.
print(x + np.reshape(w, (2, 1)))

# 행렬에 상수를 곱합니다:
# x 는 (2, 3)의 모양입니다. Numpy 는 스칼라를 () 모양의 배열로 다룹니다;
# 이것들은 아래의 방법으로 (2, 3) 모양으로 브로드캐스트할 수 있습니다.
print(x * 2)

x = np.arange(5)
print('Original:\n', x)  # Prints [0 1 2 3 4]

# Modifying the view will modify the array
view = x[1:3]
view[1] = -1
print('Array After Modified View:\n', x)  # Prints [0 1 -1 3 4]

x = np.arange(5)
view = x[1:3]
view[1] = -1

# Modifying the array will modify the view
print('View Before Array Modification:\n', view)  # Prints [1 -1]
x[2] = 10
print('Array After Modifications:\n', x)          # Prints [0 1 10 3 4]
print('View After Array Modification:\n', view)   # Prints [1 10]

x = np.arange(5)
print('Original:\n', x)  # Prints [0 1 2 3 4]

# Modifying the result of the selection due to fancy indexing
# will not modify the original array.
copy = x[[1, 2]]
copy[1] = -1
print('Copy:\n', copy) # Prints [1 -1]
print('Array After Modified Copy:\n', x)  # Prints [0 1 2 3 4]

# Another example involving fancy indexing
x = np.arange(5)
print('Original:\n', x)  # Prints [0 1 2 3 4]

copy = x[x >= 2]
print('Copy:\n', copy) # Prints [2 3 4]
x[3] = 10
print('Modified Array:\n', x)  # Prints [0 1 2 10 4]
print('Copy After Modified Array:\n', copy)  # Prints [2 3 4]