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 matter(cls, m: Matter) -> Matter: new_matter: Matter = m.copy() new_values = m.background_color * np.ones(m.shape, dtype=np.int) keep_color = m.max_color() new_values[m.values == keep_color] = keep_color new_matter.set_values(new_values) return new_matter
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 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 point_cross_cnt_mat(m: Matter, y_arr: np.array) -> Tuple[np.array, int]: assert m.n_color() == 1 color_cnt = m.color_count() color_cnt[m.background_color] = 0 m_color = [c for c in range(10) if color_cnt[c] > 0][0] x_arr = np.zeros(y_arr.shape, dtype=np.int) try: x_arr[m.x0:m.x0 + m.shape[0], m.y0:m.y0 + m.shape[1]] = m.values except: print(x_arr, y_arr, m.x0, m.x0 + m.shape[0], m.y0, m.y0 + m.shape[1]) raise return point_cross_cnt_arr(x_arr, y_arr, m_color), m_color
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, color_dict: dict) -> Matter: if m.a is not None: if m.a in color_dict.keys(): new_matter = m.paste_color(color_dict[m.a]) else: flag, bar = is_monotone(color_dict) if flag: if m.a >= flag: new_matter = m.paste_color(color_dict[max(color_dict.keys())]) else: new_matter = m.paste_color(color_dict[min(color_dict.keys())]) else: raise AssertionError return new_matter else: return m
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 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, hole_type: str) -> Matter: if m.is_filled_rectangle() and min(m.shape) >= 3: new_matter = m.copy() new_values = m.values.copy() if hole_type == "simple": new_values[1:-1, 1:-1] = m.background_color elif hole_type == "mesh": new_values[1:-1:2, 1:-1:2] = m.background_color elif hole_type == "mesh_x": new_values[1:-1:2, 1:-1:2] = m.background_color new_values[2:-1:2, 2:-1:2] = m.background_color else: raise NotImplementedError new_matter.set_values(new_values) return new_matter else: return m
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 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 matter(cls, m: Matter) -> Matter: assert m.n_color() <= 2 if m.is_mesh: return m elif m.n_color() == 0: return m elif m.n_color() == 1: color_count = m.color_count() for c in range(10): if color_count[c] > 0 and c != m.background_color: base_color = c new_matter: Matter = m.copy() new_values = m.background_color * np.ones(m.shape, dtype=np.int) new_values[m.values == m.background_color] = base_color new_matter.set_values(new_values) return new_matter else: # m.n_color() == 2 color_count = m.color_count() switch = [] for c in range(10): if color_count[c] > 0 and c != m.background_color: switch.append(c) new_matter: Matter = m.copy() new_values = m.background_color * np.ones(m.shape, dtype=np.int) new_values[m.values == switch[0]] = switch[1] new_values[m.values == switch[1]] = switch[0] new_matter.set_values(new_values) return new_matter
def matter(cls, m: Matter, n_row, n_col): assert m.a is not None assert m.a > 0 if m.b is None: assert max(m.a * n_row, m.a * n_col) <= 30 new_matter: Matter = m.copy() new_matter.set_values(duplicate_array(m.values, m.a, m.a)) new_matter.x0 = 0 new_matter.y0 = 0 return new_matter, m.a, m.a else: assert m.b > 0 assert max(m.a * n_row, m.b * n_col) <= 30 new_matter: Matter = m.copy() new_matter.set_values(duplicate_array(m.values, m.a, m.b)) new_matter.x0 = 0 new_matter.y0 = 0 return new_matter, m.a, m.b
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 matter(cls, m: Matter, color_add: int) -> Matter: res_bool = cls.array(m.values) new_values = m.values.copy() new_values[res_bool] = color_add new_m: Matter = m.copy() new_m.set_values(new_values) return new_m
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 point_cross_fit_mat(m: Matter, n_row, n_col, op_arr: np.array) -> Matter: assert m.n_color() == 1 color_cnt = m.color_count() color_cnt[m.background_color] = 0 m_color = [c for c in range(10) if color_cnt[c] > 0][0] x_arr = np.zeros((n_row, n_col), dtype=np.int) x_arr[m.x0:m.x0 + m.shape[0], m.y0:m.y0 + m.shape[1]] = m.values res_arr = point_cross_fit_arr(x_arr, m_color, op_arr[m_color]) new_values = np.zeros(x_arr.shape, dtype=int) new_values[res_arr == 1] = m_color new_values[res_arr == 0] = m.background_color new_matter = m.copy() new_matter.set_values(new_values) new_matter.x0 = 0 new_matter.y0 = 0 return new_matter
def matter(cls, m: Matter, op: str, const: int, color_add: int) -> Matter: assert m.a is not None if op == "<=": if m.a <= const: return m.paste_color(color_add) else: return m elif op == "==": if m.a == const: return m.paste_color(color_add) else: return m elif op == ">=": if m.a >= const: return m.paste_color(color_add) else: return m else: raise NotImplementedError
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 matter(cls, m: Matter) -> Matter: new_matter = m.deepcopy() if new_matter.is_filled_rectangle(): if new_matter.is_square(): new_matter.a = 2 else: new_matter.a = 1 else: if m.a is not None: new_matter.a = 0 else: new_matter.a = None return new_matter
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 __init__(self, m: Matter, ind: int, hash_count: int): self.a_init = m.a self.n_color = m.n_color() self.n_cell = m.n_cell() self.size = m.shape[0] * m.shape[1] self.is_filled_rectangle = m.is_filled_rectangle() if m.is_filled_rectangle(): if m.is_square(): self.is_rectangle = 2 else: self.is_rectangle = 1 else: if m.a is not None: self.is_rectangle = 0 else: self.is_rectangle = None # assume trimmed x_arr = m.values # row res_row = 0 for i in range(x_arr.shape[0] // 2): res_row += (x_arr[i, :] != x_arr[x_arr.shape[0] - 1 - i, :]).sum() # col res_col = 0 for j in range(x_arr.shape[1] // 2): res_col += (x_arr[:, j] != x_arr[:, x_arr.shape[1] - 1 - j]).sum() res = 0 if res_row == 0: res += 1 if res_col == 0: res += 2 self.is_symmetry = res self.ind = ind self.hash = hash_count self.n_noise = (m.values != m.max_color()).sum() self.a = None self.y = None
def matter(cls, m: Matter, color_add: int) -> Matter: new_matter: Matter = m.copy() new_values = m.values.copy() new_values[new_values == m.background_color] = color_add new_matter.set_values(new_values) return new_matter