def matter(cls, m: Matter) -> List[Matter]:
"""
function to split a matter by mesh
others in one and mesh
:param m: matter to split
:return: List[Matter]
"""
c = find_mesh(m.values)
assert c != -1
arr_list, mesh_arr = split_by_mesh(m.values, m.background_color)
# reduce
main_values = m.background_color * np.ones(m.shape, dtype=np.int)
for arr, xy0 in arr_list:
x0, y0 = xy0
main_values[x0:x0 + arr.shape[0], y0:y0 + arr.shape[1]] = arr
# main
matter_main = Matter(main_values,
background_color=m.background_color,
new=True)
# mesh
matter_mesh = Matter(mesh_arr,
background_color=m.background_color,
new=True)
matter_mesh.is_mesh = True
return [matter_main, matter_mesh]
def matter(cls, m: Matter) -> List[Matter]:
"""
function to split a matter by mesh
split others by mesh, and mesh
:param m: matter to split
:return: List[Matter]
"""
assert find_mesh(m.values) != -1
arr_list, mesh_arr = split_by_mesh(m.values, m.background_color)
res_list = []
# split
for arr, xy0 in arr_list:
x0, y0 = xy0
new_matter = Matter(arr, x0, y0, m.background_color, new=True)
res_list.append(new_matter)
# mesh
matter_mesh = Matter(mesh_arr,
background_color=m.background_color,
new=True)
matter_mesh.is_mesh = True
res_list.append(matter_mesh)
return res_list
def duplicate(p: Problem) -> Problem:
flag, m_row, m_col = is_multiple(p)
flag_n = False
if not flag:
flag, nc_row, nc_col = is_constant(p)
flag_n = True
assert flag
q: Problem
q = p.copy()
q.train_x_list = []
q.test_x_list = []
c_x: Case
c_x_new: Case
for c_x in p.train_x_list:
c_x_new = c_x.copy()
base_values = c_x.repr_values()
n_row, n_col = base_values.shape
if flag_n:
assert nc_row % n_row == 0
assert nc_col % n_col == 0
m_row = nc_row // n_row
m_col = nc_col // n_col
c_x_new.shape = m_row * n_row, m_col * n_col
new_values = np.zeros((m_row * n_row, m_col * n_col), dtype=np.int)
for i in range(m_row):
for j in range(m_col):
new_values[i * n_row:(i + 1) * n_row,
j * n_col:(j + 1) * n_col] = base_values
c_x_new.matter_list = [
Matter(new_values, background_color=c_x.background_color, new=True)
]
q.train_x_list.append(c_x_new)
for c_x in p.test_x_list:
c_x_new = c_x.copy()
base_values = c_x.repr_values()
n_row, n_col = base_values.shape
c_x_new.shape = m_row * n_row, m_col * n_col
new_values = np.zeros((m_row * n_row, m_col * n_col), dtype=np.int)
for i in range(m_row):
for j in range(m_col):
new_values[i * n_row:(i + 1) * n_row,
j * n_col:(j + 1) * n_col] = base_values
c_x_new.matter_list = [
Matter(new_values, background_color=c_x.background_color, new=True)
]
q.test_x_list.append(c_x_new)
return q
def matter(cls, m: Matter, allow_diagonal: bool, case_background,
boundary_none) -> List[Matter]:
arr_list = cls.array(m.values, allow_diagonal, m.background_color)
# avoid meaningless
assert len(arr_list) >= 2
res_list = []
for i, x_arr in enumerate(arr_list):
if i > 0:
# trim
x_sum = (x_arr != 0).sum(axis=1)
y_sum = (x_arr != 0).sum(axis=0)
min_x = min([i for i in range(x_arr.shape[0]) if x_sum[i]])
max_x = max([i for i in range(x_arr.shape[0]) if x_sum[i]])
min_y = min([i for i in range(x_arr.shape[1]) if y_sum[i]])
max_y = max([i for i in range(x_arr.shape[1]) if y_sum[i]])
new_values = x_arr[min_x:max_x + 1, min_y:max_y + 1].copy()
# print(new_values)
if case_background == 0:
m_values = 1 - new_values
new_m: Matter = Matter(m_values,
min_x,
min_y,
background_color=1,
new=True)
else:
new_m: Matter = Matter(new_values * case_background,
min_x,
min_y,
background_color=0,
new=True)
if min_x > 0 and max_x < m.shape[
0] - 1 and min_y > 0 and max_y < m.shape[1] - 1:
new_m.a = 1
else:
if not boundary_none:
new_m.a = 0
else:
new_values = x_arr.copy()
new_m: Matter = Matter(new_values,
0,
0,
background_color=m.background_color,
new=True)
# new_m.a = None
res_list.append(new_m)
return res_list
def matter(cls, m: Matter) -> List[Matter]:
arr_list = cls.array(m.values, m.background_color)
res_list = []
for arr in arr_list:
x_arr = arr[0]
# trim
x_sum = (x_arr != m.background_color).sum(axis=1)
y_sum = (x_arr != m.background_color).sum(axis=0)
min_x = min([i for i in range(x_arr.shape[0]) if x_sum[i]])
max_x = max([i for i in range(x_arr.shape[0]) if x_sum[i]])
min_y = min([i for i in range(x_arr.shape[1]) if y_sum[i]])
max_y = max([i for i in range(x_arr.shape[1]) if y_sum[i]])
new_values = x_arr[min_x:max_x + 1, min_y:max_y + 1].copy()
m = Matter(new_values,
min_x,
min_y,
background_color=m.background_color,
new=True)
m.color = arr[1]
res_list.append(m)
return res_list
def case_row_col(cls, c: Case) -> Case:
new_case = c.copy()
new_values = cls.auto_fill_row_col(c.repr_values(), c.background_color)
new_case.matter_list = [
Matter(new_values, background_color=c.background_color, new=True)
]
return new_case
def matter(cls, m: Matter, allow_diagonal: bool) -> List[Matter]:
arr_list = cls.array(m.values, allow_diagonal, m.background_color)
# avoid meaningless
assert len(arr_list) >= 2
res_list = []
for x_arr in arr_list:
# trim
x_sum = (x_arr != m.background_color).sum(axis=1)
y_sum = (x_arr != m.background_color).sum(axis=0)
min_x = min([i for i in range(x_arr.shape[0]) if x_sum[i]])
max_x = max([i for i in range(x_arr.shape[0]) if x_sum[i]])
min_y = min([i for i in range(x_arr.shape[1]) if y_sum[i]])
max_y = max([i for i in range(x_arr.shape[1]) if y_sum[i]])
new_values = x_arr[min_x:max_x + 1, min_y:max_y + 1].copy()
res_list.append(
Matter(new_values,
min_x,
min_y,
background_color=m.background_color,
new=True))
return res_list
def problem(cls, p: Problem) -> Problem:
c_x: Case
c_y: Case
# find rule
x_arr_list = []
y_arr_list = []
for c_x, c_y in zip(p.train_x_list, p.train_y_list):
assert c_x.background_color == p.background_color
x_arr_list.append(c_x.repr_values())
y_arr_list.append(c_y.repr_values())
rule_33 = find_replace_rule_33_all(x_arr_list, y_arr_list,
p.background_color)
# fit rule
q: Problem = p.copy()
q.train_x_list = []
q.test_x_list = []
c_x: Case
c_x_new: Case
for c_x in p.train_x_list:
c_x_new = c_x.copy()
new_values = fit_replace_rule_33_one_all(c_x.repr_values(),
rule_33,
p.background_color)
c_x_new.matter_list = [
Matter(new_values,
background_color=p.background_color,
new=True)
]
q.train_x_list.append(c_x_new)
for c_x in p.test_x_list:
c_x_new = c_x.copy()
new_values = fit_replace_rule_33_one_all(c_x.repr_values(),
rule_33,
p.background_color)
c_x_new.matter_list = [
Matter(new_values,
background_color=p.background_color,
new=True)
]
q.test_x_list.append(c_x_new)
return q
def case(cls, c: Case) -> Case:
res_arr = c.repr_fractal_values()
new_case: Case = c.copy()
new_case.shape = res_arr.shape
new_case.matter_list = [Matter(res_arr, background_color=c.background_color, new=True)]
return new_case
def case(cls, c: Case) -> Case:
new_case = c.copy()
x_arr = trivial_reducer(c)
# print(x_arr)
new_values = cls.array(x_arr)
new_case.matter_list = [
Matter(new_values, background_color=c.background_color, new=True)
]
new_case.shape = new_values.shape
return new_case
def case(cls, c_x: Case, pattern_arr: np.array) -> Case:
x_values = c_x.repr_values()
if c_x.color_delete is None:
new_x_values = cls.array(x_values, pattern_arr,
c_x.background_color)
else:
new_x_values = cls.array(x_values, pattern_arr, c_x.color_delete)
new_case: Case = c_x.copy()
new_case.matter_list = [Matter(new_x_values, new=True)]
return new_case
def case(cls, c: Case, full) -> Case:
assert c.shape[0] > 2 and c.shape[1] > 2
new_case = c.copy()
if c.color_delete is None:
new_values = cls.array(c.repr_values(), c.background_color, full)
else:
new_values = cls.array(c.repr_values(), c.color_delete, full)
new_case.matter_list = [
Matter(new_values, background_color=c.background_color, new=True)
]
return new_case
def case_col(cls, c: Case) -> Case:
new_case = c.copy()
if c.color_delete is None:
new_values = cls.auto_fill_symmetry_col_background(c.repr_values())
else:
new_values = cls.auto_fill_symmetry_col(c.repr_values(),
c.color_delete)
new_case.matter_list = [
Matter(new_values, background_color=c.background_color, new=True)
]
return new_case
def case(cls, c: Case) -> Case:
if c.color_delete is not None:
new_case = c.copy()
new_values = fill_somewhere(c.repr_values(), c.color_delete)
new_case.matter_list = [
Matter(new_values,
background_color=c.background_color,
new=True)
]
return new_case
else:
return c
def case_21(cls, c: Case, compare_c: Case) -> Case:
assert c.color_add is not None
new_values = trivial_reducer(c)
compare_values = trivial_reducer(compare_c)
assert new_values.shape == compare_values.shape
new_values[new_values != compare_values] = c.color_add
new_case: Case = c.copy()
new_case.matter_list = [Matter(new_values, background_color=c.background_color, new=True)]
return new_case
def fit_replace_rule_33(p: Problem) -> Problem:
# assert
case_x: Case
case_y: Case
x_arr_list = []
y_arr_list = []
for case_x, case_y in zip(p.train_x_list, p.train_y_list):
# same shape
x_values = case_x.repr_values()
y_values = case_y.repr_values()
assert x_values.shape == y_values.shape
x_arr_list.append(x_values)
y_arr_list.append(y_values)
rule_33 = find_replace_rule_33(x_arr_list, y_arr_list, p.background_color)
q: Problem
q = p.copy()
q.train_x_list = []
q.test_x_list = []
c_x: Case
c_x_new: Case
for c_x in p.train_x_list:
c_x_new = c_x.copy()
new_values = fit_replace_rule_33_one(c_x.repr_values(), rule_33, p.background_color)
c_x_new.matter_list = [Matter(new_values, background_color=p.background_color, new=True)]
q.train_x_list.append(c_x_new)
for c_x in p.test_x_list:
c_x_new = c_x.copy()
new_values = fit_replace_rule_33_one(c_x.repr_values(), rule_33, p.background_color)
c_x_new.matter_list = [Matter(new_values, background_color=p.background_color, new=True)]
q.test_x_list.append(c_x_new)
return q
def case(cls, c: Case) -> Case:
m: Matter
x0_arr = np.array([m.x0 for m in c.matter_list if not m.is_mesh])
y0_arr = np.array([m.y0 for m in c.matter_list if not m.is_mesh])
x1_arr = np.array(
[m.x0 + m.shape[0] for m in c.matter_list if not m.is_mesh])
y1_arr = np.array(
[m.y0 + m.shape[1] for m in c.matter_list if not m.is_mesh])
c_arr = np.array(
[m.max_color() for m in c.matter_list if not m.is_mesh])
res_arr = align_xy(x0_arr, y0_arr, x1_arr, y1_arr, c_arr)
new_case: Case = c.copy()
new_case.shape = res_arr.shape
new_case.matter_list = [
Matter(res_arr, background_color=c.background_color, new=True)
]
return new_case
def matter(cls, m: Matter) -> List[Matter]:
"""
function to split a matter by mesh
others aligned and drop mesh
:param m: matter to split
:return: List[Matter]
"""
assert find_mesh(m.values) != -1
arr_list, mesh_arr = split_by_mesh(m.values, m.background_color)
res_list = []
assert len(arr_list) > 0
# split and align
arr_0 = arr_list[0][0]
for arr, _ in arr_list: # drop position
assert arr.shape == arr_0.shape
new_matter = Matter(arr, np.int(0), np.int(0), m.background_color, new=True)
res_list.append(new_matter)
return res_list
def color_change(p: Problem) -> Problem:
assert is_same(p)
# print(p)
case_x: Case
case_y: Case
case_x_new: Case
change_vec = -2 * np.ones(10, dtype=np.int64)
for case_x, case_y in zip(p.train_x_list, p.train_y_list):
# need to be one matter
assert len(case_y.matter_list) == 1
if len(case_x.matter_list) == 1:
x_values = case_x.repr_values()
else:
x_values = trivial_reducer(case_x)
y_values = case_y.repr_values()
# same shape
assert x_values.shape == y_values.shape
# value range
assert x_values.min() >= 0
assert x_values.max() <= 9
assert y_values.min() >= 0
assert y_values.max() <= 9
# one rule
res_arr = find_color_change_rule_one(x_values, y_values)
# print(res_arr)
for c in range(10):
if res_arr[c] == -2:
pass
elif change_vec[c] == -2:
change_vec[c] = res_arr[c]
else:
assert change_vec[c] == res_arr[c]
# print(change_vec)
# fill
for c in range(10):
if (change_vec == c).sum() >= 3:
change_vec[change_vec == -2] = c
# fill
if (change_vec == np.arange(10)).sum() >= 3:
for c in range(10):
if change_vec[c] == -2:
change_vec[c] = c
q: Problem
q = p.copy()
q.train_x_list = []
q.test_x_list = []
# transform
# test_x first so that find exception faster
for case_x in p.test_x_list:
if len(case_x.matter_list) == 1:
x_values = case_x.repr_values()
else:
x_values = trivial_reducer(case_x)
# print(x_values)
# value range
assert x_values.min() >= 0
assert x_values.max() <= 9
# change_vec
new_values = fit_color_change_rule_one(x_values, change_vec)
assert new_values.min() >= 0 # no more-2
# print(new_values)
case_x_new = case_x.copy()
case_x_new.matter_list = [
Matter(new_values,
background_color=case_x_new.background_color,
new=True)
]
q.test_x_list.append(case_x_new)
# train_x
for case_x in p.train_x_list:
if len(case_x.matter_list) == 1:
x_values = case_x.repr_values()
else:
x_values = trivial_reducer(case_x)
# print(x_values)
# value range
assert x_values.min() >= 0
assert x_values.max() <= 9
# change_vec
new_values = fit_color_change_rule_one(x_values, change_vec)
# print(new_values)
case_x_new = case_x.copy()
case_x_new.matter_list = [
Matter(new_values,
background_color=case_x_new.background_color,
new=True)
]
q.train_x_list.append(case_x_new)
return q
def divide(p: Problem) -> Problem:
flag, d_row, d_col = is_division(p)
flag_n = False
if not flag:
flag, nc_row, nc_col = is_constant(p)
flag_n = True
cnt_arr = np.zeros((2, 2), dtype=int)
else:
cnt_arr = np.zeros((d_row, d_col), dtype=int)
assert flag
q: Problem
q = p.copy()
q.train_x_list = []
q.test_x_list = []
c_x: Case
c_x_new: Case
# find best
for c_x, c_y in zip(p.train_x_list, p.train_y_list):
base_values = c_x.repr_values()
res_values = c_y.repr_values()
n_row, n_col = base_values.shape
if flag_n:
assert n_row % nc_row == 0
assert n_col % nc_col == 0
d_row = n_row // nc_row
d_col = n_col // nc_col
q_row, q_col = n_row // d_row, n_col // d_col
# print(d_row, d_col)
# is_division -> any
if not flag_n:
for i in range(d_row):
for j in range(d_col):
if (base_values[i * q_row:(i + 1) * q_row,
j * q_col:(j + 1) *
q_col] == res_values).min():
cnt_arr[i, j] += 1
# is_constant -> 4 corners
else:
if (base_values[:q_row, :q_col] == res_values).min():
cnt_arr[0, 0] += 1
if (base_values[:q_row, -q_col:] == res_values).min():
cnt_arr[0, 1] += 1
if (base_values[-q_row:, :q_col] == res_values).min():
cnt_arr[1, 0] += 1
if (base_values[-q_row:, -q_col:] == res_values).min():
cnt_arr[1, 1] += 1
# print(cnt_arr)
# fit
i0, j0 = -1, -1
for i in range(cnt_arr.shape[0]):
for j in range(cnt_arr.shape[1]):
if cnt_arr[i, j] == len(p.train_x_list):
i0, j0 = i, j
break
if i0 >= 0:
break
assert i0 >= 0 and j0 >= 0
# fit
for c_x in p.train_x_list:
base_values = c_x.repr_values()
n_row, n_col = base_values.shape
if flag_n:
assert n_row % nc_row == 0
assert n_col % nc_col == 0
d_row = n_row // nc_row
d_col = n_col // nc_col
q_row, q_col = n_row // d_row, n_col // d_col
# is_division -> any
if not flag_n:
new_values = base_values[i0 * q_row:(i0 + 1) * q_row,
j0 * q_col:(j0 + 1) * q_col].copy()
# is_constant -> 4 corners
else:
if i0 == 0 and j0 == 0:
new_values = base_values[:q_row, :q_col].copy()
elif i0 == 0 and j0 == 1:
new_values = base_values[:q_row, -q_col:].copy()
elif i0 == 1 and j0 == 0:
new_values = base_values[-q_row:, :q_col].copy()
else:
new_values = base_values[-q_row:, -q_col:].copy()
c_x_new = c_x.copy()
c_x_new.shape = q_row, q_col
c_x_new.matter_list = [
Matter(new_values, background_color=c_x.background_color, new=True)
]
q.train_x_list.append(c_x_new)
for c_x in p.test_x_list:
base_values = c_x.repr_values()
n_row, n_col = base_values.shape
if flag_n:
assert n_row % nc_row == 0
assert n_col % nc_col == 0
d_row = n_row // nc_row
d_col = n_col // nc_col
q_row, q_col = n_row // d_row, n_col // d_col
# is_division -> any
if not flag_n:
new_values = base_values[i0 * q_row:(i0 + 1) * q_row,
j0 * q_col:(j0 + 1) * q_col].copy()
# is_constant -> 4 corners
else:
if i0 == 0 and j0 == 0:
new_values = base_values[:q_row, :q_col].copy()
elif i0 == 0 and j0 == 1:
new_values = base_values[:q_row, -q_col:].copy()
elif i0 == 1 and j0 == 0:
new_values = base_values[-q_row:, :q_col].copy()
else:
new_values = base_values[-q_row:, -q_col:].copy()
c_x_new = c_x.copy()
c_x_new.shape = q_row, q_col
c_x_new.matter_list = [
Matter(new_values, background_color=c_x.background_color, new=True)
]
q.test_x_list.append(c_x_new)
return q
def color_pile(p: Problem) -> Problem:
case_x: Case
case_y: Case
case_x_new: Case
rule_all = 10 * np.ones(10, dtype=np.int64)
for case_x, case_y in zip(p.train_x_list, p.train_y_list):
# same shape
assert case_x.shape == case_y.shape
# reduce count
cnt_arr = np.zeros((case_x.shape[0], case_x.shape[1], 10), dtype=np.int64)
# collect values
for m in case_x.matter_list:
if not m.bool_show:
continue
for i in range(m.shape[0]):
for j in range(m.shape[1]):
if m.values[i, j] != m.background_color:
assert 0 <= m.values[i, j] <= 9
cnt_arr[m.x0 + i, m.y0 + j, m.values[i, j]] += 1
y_values = case_y.repr_values()
# one rule
res_arr = color_pile_arr(cnt_arr, y_values, case_x.background_color)
for color in range(10):
if (y_values == color).sum():
assert res_arr[color] < 10
# reduce rule
rule_all = reduce_rule(res_arr, rule_all)
q: Problem
q = p.copy()
q.train_x_list = []
q.test_x_list = []
# transform
# test_x first so that find exception faster
for case_x in p.test_x_list:
new_values = case_x.background_color * np.ones(case_x.shape, dtype=np.int64)
cnt_arr = np.zeros((case_x.shape[0], case_x.shape[1], 10), dtype=np.int64)
# collect values
for m in case_x.matter_list:
if not m.bool_show:
continue
for i in range(m.shape[0]):
for j in range(m.shape[1]):
if m.values[i, j] != m.background_color:
assert 0 <= m.values[i, j] <= 9
cnt_arr[m.x0 + i, m.y0 + j, m.values[i, j]] += 1
# reduce
for color_order in range(9, -1, -1):
for color in range(10):
if rule_all[color] == color_order:
new_values[cnt_arr[:, :, color] > 0] = color
case_x_new = case_x.copy()
case_x_new.matter_list = [Matter(new_values, background_color=case_x_new.background_color, new=True)]
q.test_x_list.append(case_x_new)
# train_x
for case_x in p.train_x_list:
new_values = case_x.background_color * np.ones(case_x.shape, dtype=np.int64)
cnt_arr = np.zeros((case_x.shape[0], case_x.shape[1], 10), dtype=np.int64)
# collect values
for m in case_x.matter_list:
if not m.bool_show:
continue
for i in range(m.shape[0]):
for j in range(m.shape[1]):
if m.values[i, j] != m.background_color:
assert 0 <= m.values[i, j] <= 9
cnt_arr[m.x0 + i, m.y0 + j, m.values[i, j]] += 1
# reduce
for color_order in range(9, -1, -1):
for color in range(10):
if rule_all[color] == color_order:
new_values[cnt_arr[:, :, color] > 0] = color
case_x_new = case_x.copy()
case_x_new.matter_list = [Matter(new_values, background_color=case_x_new.background_color, new=True)]
q.train_x_list.append(case_x_new)
return q
def matter(cls, m: Matter) -> Matter:
new_values, xy0 = cls.array(m.values, m.background_color)
return Matter(new_values, 0, 0, m.background_color, new=True)