def gauss_trid(A: np.array, B: np.array) -> np.array:
'''
>>> A = np.array([[1, -1, 0, 0, 0], \
[1, 1, -1, 0, 0], \
[0, 1, -1, 1, 0], \
[0, 0, -1, 1, 1], \
[0, 0, 0, -1, 2]], dtype=float)
>>> B = np.array([0, 1, 2, -1, -2], dtype=float)
>>> gauss_trid(A, B)
array([5., 5., 9., 6., 2.])
'''
n = len(A)
# t, r, d, b = optimize(A, B)
t = np.append([np.nan], A.diagonal(-1))
r = A.diagonal(0).copy()
d = np.append(A.diagonal(1), [np.nan])
for i in range(1, n):
factor = t[i] / r[i - 1]
r[i] -= factor * d[i - 1]
B[i] -= factor * B[i - 1]
X = np.empty_like(B)
X[-1] = B[-1] / r[-1]
for i in reversed(range(n - 1)):
X[i] = (B[i] - d[i] * X[i + 1]) / r[i]
return X
def LUTridiagonal(A:np.array) -> (np.matrix, np.matrix):
""" LU decomposition for tridiagonal matrices. Done in a hurry, expect bugs JGC.
Args:
A: A list representation of a matrix, or numpy type matrix.
Returns:
L: Lower triangular matrix.
U: Upper triangular matrix.
"""
A = np.matrix(A)
m,n = A.shape
d = np.squeeze(np.asarray(A.diagonal()))
a = np.squeeze(np.asarray(A.diagonal(-1)))
c = np.squeeze(np.asarray(A.diagonal(1)))
l = np.zeros(n-1)
v = np.zeros(n)
v[0] = d[0]
for i in range(1,n):
l[i-1] = a[i-1] / v[i-1]
v[i] = d[i] - np.dot(l[i-1],c[i-1])
L = np.eye(m,n, dtype=int) + np.diag(l, -1)
U = np.diag(v) + np.diag(c,1)
return L,U
def check_win(board: np.array) -> int:
"""
Given a 3*3 numpy array whose elements are 0, 1, -1
representing empty, player1 and player 2,
return the player who's won if any or 0 if no winner found
Args:
board (np.array): 3 x 3 board
Returns:
int: 0 -> no winner
1 -> player 1
-1 -> player 2
"""
assert board.shape == (3, 3)
for axis in [0, 1]:
axis_sum = board.sum(axis=axis)
if 3 in axis_sum:
return 1
elif -3 in axis_sum:
return -1
diag = board.diagonal().sum()
diag_inv = np.fliplr(board).diagonal().sum()
for diag_sum in [diag, diag_inv]:
if diag_sum == 3:
return 1
elif diag_sum == -3:
return -1
# no winner yet
return 0
def prod_upper_avg_diagonal(matrix: np.array):
aver, diag = np.average(matrix), matrix.diagonal()
return np.prod(diag[diag > aver])
def prod_upper_avg_diagonal(matrix: np.array):
average = np.average(matrix)
diagonal = matrix.diagonal()
f = diagonal > average
return np.prod(diagonal[f])
def prod_upper_avg_diagonal(matrix: np.array):
diagonal = matrix.diagonal()
average = np.average(matrix)
return np.prod(diagonal[diagonal > average])
