pd-code-connected-sum 0.0.3__tar.gz → 0.1.1__tar.gz

pd_code_connected_sum-0.1.1/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: pd-code-connected-sum
+Version: 0.1.1
+Summary: make connected sum for link pd_code
+License: MIT
+License-File: LICENSE
+Author: GGN_2015
+Author-email: neko@jlulug.org
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: pd-code-pre-nxt (>=0.1.0)
+Requires-Dist: pd-code-sanity (>=0.1.0)
+Description-Content-Type: text/markdown
+
+# pd-code-connected-sum
+
+Join two selected oriented PD-code components and canonically renumber the result.
+
+## Installation
+
+```bash
+pip install pd-code-connected-sum
+```
+
+## Usage example
+
+```python
+from pd_code_connected_sum import connected_sum
+
+left = [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
+right = [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
+result, label_map = connected_sum(left, right, 1, 1)
+print(result)
+print(label_map["a_1"], label_map["b_1"])
+```
+
+## Algorithm
+
+Each input component is converted to a deterministic oriented cycle. The algorithm locates the incidence immediately after each selected arc, offsets the second code to avoid collisions, cuts those two oriented arcs, and glues the endpoints crosswise. It then canonically orders component cycles, assigns contiguous labels, orients every crossing consistently, and returns maps for all original labels. This avoids the incorrect local crossing replacement used by older releases.
+
+## Input conventions
+
+A PD code is represented as a list of four-entry crossings. Arc labels normally occur exactly twice. Public functions validate inputs and return new values rather than mutating caller-owned data unless their API explicitly says otherwise.
+
+## External software
+
+No external software is required.
+
+## Development
+
+Run examples and package checks before release. Python packages require Python 3.10 or newer. Build PyPI artifacts with:
+
+```bash
+poetry check
+poetry build
+```
+
+## License
+
+MIT. See `LICENSE`.
+

pd_code_connected_sum-0.1.1/README.md

@@ -0,0 +1,46 @@
+# pd-code-connected-sum
+
+Join two selected oriented PD-code components and canonically renumber the result.
+
+## Installation
+
+```bash
+pip install pd-code-connected-sum
+```
+
+## Usage example
+
+```python
+from pd_code_connected_sum import connected_sum
+
+left = [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
+right = [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
+result, label_map = connected_sum(left, right, 1, 1)
+print(result)
+print(label_map["a_1"], label_map["b_1"])
+```
+
+## Algorithm
+
+Each input component is converted to a deterministic oriented cycle. The algorithm locates the incidence immediately after each selected arc, offsets the second code to avoid collisions, cuts those two oriented arcs, and glues the endpoints crosswise. It then canonically orders component cycles, assigns contiguous labels, orients every crossing consistently, and returns maps for all original labels. This avoids the incorrect local crossing replacement used by older releases.
+
+## Input conventions
+
+A PD code is represented as a list of four-entry crossings. Arc labels normally occur exactly twice. Public functions validate inputs and return new values rather than mutating caller-owned data unless their API explicitly says otherwise.
+
+## External software
+
+No external software is required.
+
+## Development
+
+Run examples and package checks before release. Python packages require Python 3.10 or newer. Build PyPI artifacts with:
+
+```bash
+poetry check
+poetry build
+```
+
+## License
+
+MIT. See `LICENSE`.

pd_code_connected_sum-0.1.1/pd_code_connected_sum/__init__.py

@@ -0,0 +1,6 @@
+from .main import connected_sum, normalize_pd_code
+
+__all__ = [
+    "connected_sum",
+    "normalize_pd_code",
+]

pd_code_connected_sum-0.1.1/pd_code_connected_sum/main.py

@@ -0,0 +1,90 @@
+from copy import deepcopy
+
+import pd_code_pre_nxt
+import pd_code_sanity
+
+
+def _normalize(pd_code: list[list[int]]) -> tuple[list[list[int]], dict[int, int]]:
+    if not pd_code:
+        return [], {}
+    pre, nxt = pd_code_pre_nxt.get_pre_nxt(pd_code)
+    old_to_new: dict[int, int] = {}
+    next_label = 1
+    for start in pd_code_pre_nxt.get_num_set(pd_code):
+        if start in old_to_new:
+            continue
+        current = start
+        while current not in old_to_new:
+            old_to_new[current] = next_label
+            next_label += 1
+            current = nxt[current]
+
+    normalized = [[old_to_new[label] for label in crossing] for crossing in pd_code]
+    new_next = {old_to_new[label]: old_to_new[target] for label, target in nxt.items()}
+    for index, crossing in enumerate(normalized):
+        if new_next[crossing[0]] == crossing[2]:
+            continue
+        if new_next[crossing[2]] == crossing[0]:
+            normalized[index] = crossing[2:] + crossing[:2]
+        else:
+            raise ValueError("crossing is inconsistent with component orientation")
+    normalized.sort()
+    if not pd_code_sanity.sanity(normalized):
+        raise AssertionError("normalization produced an invalid PD code")
+    return normalized, old_to_new
+
+
+def normalize_pd_code(pd_code: list[list[int]]) -> tuple[list[list[int]], dict[int, int]]:
+    """Return a canonically oriented, contiguously labelled copy and its map."""
+    if not pd_code_sanity.sanity(pd_code):
+        raise ValueError("invalid PD code")
+    return _normalize(deepcopy(pd_code))
+
+
+def _endpoint(pd_code, label, nxt, pre, want_after: bool) -> tuple[int, int]:
+    slots = [(i, j) for i, crossing in enumerate(pd_code) for j, value in enumerate(crossing) if value == label]
+    if len(slots) != 2:
+        raise ValueError("connected-sum label must occur exactly twice")
+    if nxt[label] == pre[label]:
+        return slots[1 if want_after else 0]
+    target = nxt[label] if want_after else pre[label]
+    for i, j in slots:
+        if pd_code[i][(j + 2) % 4] == target:
+            return i, j
+    raise ValueError("could not locate oriented endpoint for label")
+
+
+def connected_sum(
+    pd_code1: list[list[int]], pd_code2: list[list[int]], val_1: int, val_2: int
+) -> tuple[list[list[int]], dict[str, int]]:
+    """Join the oriented components containing ``val_1`` and ``val_2``."""
+    for pd_code in (pd_code1, pd_code2):
+        if not pd_code_sanity.sanity(pd_code):
+            raise ValueError("invalid PD code")
+        if any(isinstance(x, bool) or not isinstance(x, int) for crossing in pd_code for x in crossing):
+            raise TypeError("connected_sum requires integer labels")
+
+    if not pd_code1 or not pd_code2:
+        normalized, mapping = _normalize(deepcopy(pd_code1 or pd_code2))
+        prefix = "a_" if pd_code1 else "b_"
+        return normalized, {prefix + str(old): new for old, new in mapping.items()}
+    if sum(label == val_1 for crossing in pd_code1 for label in crossing) != 2:
+        raise ValueError("val_1 must occur exactly twice in pd_code1")
+    if sum(label == val_2 for crossing in pd_code2 for label in crossing) != 2:
+        raise ValueError("val_2 must occur exactly twice in pd_code2")
+
+    first = deepcopy(pd_code1)
+    offset = max(label for crossing in first for label in crossing)
+    second = [[label + offset for label in crossing] for crossing in deepcopy(pd_code2)]
+    second_label = val_2 + offset
+    pre_a, nxt_a = pd_code_pre_nxt.get_pre_nxt(first)
+    pre_b, nxt_b = pd_code_pre_nxt.get_pre_nxt(second)
+    ai, aj = _endpoint(first, val_1, nxt_a, pre_a, True)
+    bi, bj = _endpoint(second, second_label, nxt_b, pre_b, True)
+
+    first[ai][aj] = second_label
+    second[bi][bj] = val_1
+    normalized, mapping = _normalize(first + second)
+    output_map = {"a_" + str(old): new for old, new in mapping.items() if old <= offset}
+    output_map.update({"b_" + str(old - offset): new for old, new in mapping.items() if old > offset})
+    return normalized, output_map

{pd_code_connected_sum-0.0.3 → pd_code_connected_sum-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pd-code-connected-sum"
-version = "0.0.3"
+version = "0.1.1"
 description = "make connected sum for link pd_code"
 authors = [
     {name = "GGN_2015",email = "neko@jlulug.org"}
@@ -9,8 +9,8 @@ license = {text = "MIT"}
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "pd-code-sanity",
-    "pd-code-pre-nxt"
+    "pd-code-sanity>=0.1.0",
+    "pd-code-pre-nxt>=0.1.0"
 ]
 
 

pd_code_connected_sum-0.0.3/PKG-INFO

@@ -1,50 +0,0 @@
-Metadata-Version: 2.4
-Name: pd-code-connected-sum
-Version: 0.0.3
-Summary: make connected sum for link pd_code
-License: MIT
-License-File: LICENSE
-Author: GGN_2015
-Author-email: neko@jlulug.org
-Requires-Python: >=3.10
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: pd-code-pre-nxt
-Requires-Dist: pd-code-sanity
-Description-Content-Type: text/markdown
-
-# pd_code_connected_sum
-caculate connected sum for link pd_code.
-
-## Install
-
-```bash
-pip install pd-code-connected-sum
-```
-
-## Usage
-
-```python
-import pd_code_connected_sum
-
-# L2a1
-link_pd_code_1 = [[4, 1, 3, 2], [2, 3, 1, 4]]
-
-# L4a1
-link_pd_code_2 = [[6, 1, 7, 2], [8, 3, 5, 4], [2, 5, 3, 6], [4, 7, 1, 8]]
-
-connect_pos_1 = 1
-connect_pos_2 = 1
-
-new_pd_code, num_map = pd_code_connected_sum.connected_sum(
-    link_pd_code_1, link_pd_code_2, connect_pos_1, connect_pos_2)
-
-print(new_pd_code)
-print(num_map)
-```
-

pd_code_connected_sum-0.0.3/README.md

@@ -1,29 +0,0 @@
-# pd_code_connected_sum
-caculate connected sum for link pd_code.
-
-## Install
-
-```bash
-pip install pd-code-connected-sum
-```
-
-## Usage
-
-```python
-import pd_code_connected_sum
-
-# L2a1
-link_pd_code_1 = [[4, 1, 3, 2], [2, 3, 1, 4]]
-
-# L4a1
-link_pd_code_2 = [[6, 1, 7, 2], [8, 3, 5, 4], [2, 5, 3, 6], [4, 7, 1, 8]]
-
-connect_pos_1 = 1
-connect_pos_2 = 1
-
-new_pd_code, num_map = pd_code_connected_sum.connected_sum(
-    link_pd_code_1, link_pd_code_2, connect_pos_1, connect_pos_2)
-
-print(new_pd_code)
-print(num_map)
-```

pd_code_connected_sum-0.0.3/pd_code_connected_sum/__init__.py

@@ -1,5 +0,0 @@
-from .main import connected_sum
-
-__all__ = [
-    "connected_sum"
-]

pd_code_connected_sum-0.0.3/pd_code_connected_sum/main.py

@@ -1,245 +0,0 @@
-import pd_code_sanity
-import pd_code_pre_nxt
-import json
-
-# 为编码增加前缀
-def add_prefix(pd_code:list[list], prefix:str) -> list[list]:
-    pd_code = json.loads(json.dumps(pd_code))
-    for i in range(len(pd_code)):
-        for j in range(len(pd_code[i])):
-            pd_code[i][j] = prefix + str(pd_code[i][j])
-    return json.loads(json.dumps(pd_code))
-
-# 替换一个值恰好一次
-def replace_val(crossing:list, val_now:str, val_new:str):
-    cnt = 0
-    for i in range(len(crossing)):
-        if crossing[i] == val_now:
-            crossing[i] = val_new
-            cnt += 1
-    if cnt != 1:
-        raise ValueError()
-
-# 检查一个 crossing 是否包含某个值
-def check_has(crossing:list, val_now:str) -> bool:
-    for i in range(len(crossing)):
-        if crossing[i] == val_now:
-            return True
-    return False
-
-# 检查两个元素同时存在
-def check_has2(crossing:list, val1:str, val2:str) -> bool:
-    return (
-        check_has(crossing, val1) and 
-        check_has(crossing, val2))
-
-get_num_set = pd_code_pre_nxt.get_num_set
-
-# 按照顺序对循环进行遍历
-def dfs(val, nxt:dict[str, str], vis: set[int], idx:dict[str, int]):
-    if val in vis:
-        return
-    assert nxt.get(val) is not None
-
-    # 向已经访问元素队列中添加该节点
-    vis.add(val)
-    idx[val] = len(vis) # 当前元素个数，就是当前节点新编号
-
-    if nxt[val] not in vis:
-        dfs(nxt[val], nxt, vis, idx)
-    
-# 在有向图中重新编号
-def get_new_number_map(nxt:dict[str, str], num_set:list[int]) -> dict[str, int]:
-    vis = set()
-    idx = dict()
-    for val in num_set:
-        if val not in vis:
-            dfs(val, nxt, vis, idx)
-    return idx
-
-# 检查有多少个 crossing 包含了 val_now
-def count_crossing_exists(pd_code_now:list[list], val_now) -> int:
-    ans = 0
-    for crossing in pd_code_now:
-        if check_has(crossing, val_now):
-            ans += 1
-    return ans
-
-# 找到同一个连通分量中合法的位置
-def find_avaible_pos(pd_code:list[list], val_now):
-    for crossing in pd_code:
-        if check_has(crossing, val_now):
-            values = []
-            for i in range(len(crossing)):
-                if crossing[i] != val_now and crossing[i] not in values:
-                    values.append(crossing[i])
-            if len(values) == 1:
-                return None
-            else:
-                return values[0]
-    
-    # 在这里报错说明 pd_code 中没找到 val_now
-    raise AssertionError()
-
-# 删除 pd_code1 中 val_1 所在的 crossing
-# 然后把两个扭结直接合并
-# 然后重新编号
-def del_component_and_merge(pd_code1, pd_code2, val_1, val_2) -> tuple[list[list], dict]:
-    suc = False
-    for i in range(len(pd_code1)):
-        if check_has(pd_code1[i], val_1):
-            suc = True
-            pd_code1 = pd_code1[:i] + pd_code1[i+1:] # 跳过第 i 个元素
-    
-    # 这里报错说明没找到 val_1 对应的 component
-    if not suc:
-        raise AssertionError()
-    
-    # 获取元素集合
-    num_set_1 = add_prefix([get_num_set(pd_code1)], "a_")[0]
-    num_set_2 = add_prefix([get_num_set(pd_code2)], "b_")[0]
-
-    # 增加前缀编码
-    pd_code1 = add_prefix(pd_code1, "a_")
-    pd_code2 = add_prefix(pd_code2, "b_")
-
-    # 计算前驱后继
-    _, nxt1 = pd_code_pre_nxt.get_pre_nxt(pd_code1)
-    _, nxt2 = pd_code_pre_nxt.get_pre_nxt(pd_code2)
-    nxt = nxt1 | nxt2
-
-    # 合并得到新的 pd_code
-    new_pd_code = json.loads(json.dumps(pd_code1 + pd_code2))
-
-    # 获得新的编号方式
-    num_map = get_new_number_map(nxt, num_set_1 + num_set_2)
-    for crossing in new_pd_code:
-        for i in range(len(crossing)):
-            if num_map.get(crossing[i]) is None:
-                assert AssertionError()
-            crossing[i] = num_map[crossing[i]]
-    return sorted(new_pd_code), num_map
-
-# 将 pd_code1 里面的 val_1 和 pd_code2 里面的 val_2 连接起来
-def connected_sum(
-    pd_code1:list[list], pd_code2:list[list], val_1, val_2) -> tuple[list[list], dict]:
-    
-    # 如果有一个扭结平凡，则不需要连接
-    if pd_code1 == [] or pd_code2 == []:
-        return json.loads(json.dumps(pd_code1 + pd_code2))
-
-    # 检查 pd_code 的弱合法性
-    for pd_code in [pd_code1, pd_code2]:
-        if not pd_code_sanity.sanity(pd_code):
-            raise TypeError()
-    
-    # 检查 val_1 和 val_2 是否出现了
-    lis_wrap_1 = [0]
-    lis_wrap_2 = [0]
-    lis_wrap = [lis_wrap_1, lis_wrap_2]
-    for cnt_wrap, val_now, pd_now in [
-        (lis_wrap_1, val_1, pd_code1),
-        (lis_wrap_2, val_2, pd_code2)
-    ]:
-        for crossing in pd_now:
-            for term in crossing:
-                if term == val_now:
-                    cnt_wrap[0] += 1
-    
-    # 检查出现次数是否正确
-    for i in range(2):
-        if lis_wrap[i][0] != 2:
-            raise ValueError(f"val_{i+1} not in pd_code{i+1}")
-
-    # 分别计算两个需要连接的地方
-    # 是不是在一个 r1 crossing 上
-    #   如果 has_val_x_cnt[0] != 2
-    #     则说明，val_x 在一个 r1 crossing
-    #     其中 x = 1 或者 2
-    has_val_1_cnt = [0]
-    has_val_2_cnt = [0]
-    for pd_code_now, has_val_cnt, val_now in [
-        (pd_code1, has_val_1_cnt, val_1),
-        (pd_code2, has_val_2_cnt, val_2)
-    ]:
-        has_val_cnt[0] = count_crossing_exists(pd_code_now, val_now)
-
-    vals = [val_1, val_2]
-    for val_pos, pd_code_now, pd_code_other, has_cnt_now in [
-            (0, pd_code1, pd_code2, has_val_1_cnt),
-            (1, pd_code2, pd_code1, has_val_2_cnt),
-        ]:
-            if has_cnt_now[0] != 2:
-
-                # 在同一个连通分量中
-                # 找到一个出现在多个 crossing 中的编号
-                vals_new = find_avaible_pos(pd_code_now, vals[val_pos])
-                if vals_new is None:
-
-                    # 遇到了 [a, b, b, a] 或者 [a, a, b, b] 之类的
-                    # 直接删掉当前 components 然后 merge 即可
-                    return del_component_and_merge(
-                        pd_code_now, pd_code_other, vals[val_pos], vals[1-val_pos])
-                
-                vals[val_pos] = vals_new
-    
-    # 覆盖旧的元素
-    val_1, val_2 = vals
-
-    # 获取元素集合
-    num_set_1 = add_prefix([get_num_set(pd_code1)], "a_")[0]
-    num_set_2 = add_prefix([get_num_set(pd_code2)], "b_")[0]
-    
-    # 增加前缀编码
-    pd_code1 = add_prefix(pd_code1, "a_")
-    pd_code2 = add_prefix(pd_code2, "b_")
-
-    # 由于不存在 nugatory crossing 和 r1 crossing
-    # 所以两侧各有两个相关 crossing
-    _, nxt1 = pd_code_pre_nxt.get_pre_nxt(pd_code1)
-    _, nxt2 = pd_code_pre_nxt.get_pre_nxt(pd_code2)
-    nxt = nxt1 | nxt2
-
-    # 带有字母前缀的成分
-    a_val_1 = f"a_{val_1}"
-    b_val_2 = f"b_{val_2}"
-
-    # 将两组 pd_code 合并
-    # 需要注意 nxt[a_val_1] 和 pre[a_val_1] 可能相同
-    # 所以要保证只替换一次
-    suc_1 = False
-    suc_2 = False
-    new_pd_code = json.loads(json.dumps(pd_code1 + pd_code2))
-    for crossing in new_pd_code:
-        if not suc_1 and check_has2(crossing, a_val_1, nxt[a_val_1]):
-            replace_val(crossing, a_val_1, b_val_2)
-            suc_1 = True
-        if not suc_2 and check_has2(crossing, b_val_2, nxt[b_val_2]):
-            replace_val(crossing, b_val_2, a_val_1)
-            suc_2 = True
-        if suc_1 and suc_2:
-            break
-
-    # 调整前驱后继关系
-    nxt[b_val_2] = nxt1[a_val_1]
-    nxt[a_val_1] = nxt2[b_val_2]
-
-    # 获得新的编号方式
-    num_map = get_new_number_map(nxt, num_set_1 + num_set_2)
-    for crossing in new_pd_code:
-        for i in range(len(crossing)):
-            if num_map.get(crossing[i]) is None:
-                assert AssertionError()
-            crossing[i] = num_map[crossing[i]]
-
-    ans_pd_code = sorted(new_pd_code)
-    if not pd_code_sanity.sanity(ans_pd_code):
-        raise AssertionError()
-    
-    return ans_pd_code, num_map
-
-if __name__ == "__main__":
-    pd_code, num_map = connected_sum(
-        [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]], 
-        [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]], 1, 1)
-    print(num_map)