pd-code-connected-sum 0.0.1__tar.gz

pd_code_connected_sum-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TopologicalKnotIndexer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pd_code_connected_sum-0.0.1/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: pd-code-connected-sum
+Version: 0.0.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-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
+
+print(pd_code_connected_sum.connected_sum(
+    link_pd_code_1, link_pd_code_2, connect_pos_1, connect_pos_2))
+```
+

pd_code_connected_sum-0.0.1/README.md

@@ -0,0 +1,26 @@
+# 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
+
+print(pd_code_connected_sum.connected_sum(
+    link_pd_code_1, link_pd_code_2, connect_pos_1, connect_pos_2))
+```

pd_code_connected_sum-0.0.1/pd_code_connected_sum/__init__.py

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

pd_code_connected_sum-0.0.1/pd_code_connected_sum/main.py

@@ -0,0 +1,306 @@
+import pd_code_sanity
+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 get_raw_val(val_in_crs:int|str) -> int:
+    if isinstance(val_in_crs, str):
+        return int(val_in_crs.split("_")[-1])
+    return int(val_in_crs)
+
+def add_edge(pre:dict, nxt:dict, val1, val2):
+    raw_val1 = get_raw_val(val1)
+    raw_val2 = get_raw_val(val2)
+
+    # 记录前后关系
+    pre_val = -1
+    nxt_val = -1
+
+    # 确定前后关系
+    if abs(raw_val1 - raw_val2) == 1:
+        if raw_val1 < raw_val2:
+            pre_val = val1
+            nxt_val = val2
+        else:
+            pre_val = val2
+            nxt_val = val1
+    else:
+        if raw_val1 < raw_val2:
+            pre_val = val2
+            nxt_val = val1
+        else:
+            pre_val = val1
+            nxt_val = val2
+
+    # 设置 dict 值 
+    pre[nxt_val] = pre_val
+    nxt[pre_val] = nxt_val
+
+# 计算 pre 和 nxt
+# 没有 r1 crossing 就不会出现混乱
+def get_pre_nxt(pd_code:list[list]) -> tuple[dict, dict]:
+    pre = dict()
+    nxt = dict()
+    for crossing in pd_code:
+        if len(set(crossing)) > 2: # 至少有三个不同的数
+            add_edge(pre, nxt, crossing[0], crossing[2])
+            add_edge(pre, nxt, crossing[1], crossing[3])
+        else:
+            two_values = list(set(crossing)) # 只有两个不同的数
+            if len(two_values) != 2:
+                raise AssertionError()
+            for i in range(2):
+                pre[two_values[i]] = two_values[1-i] # 互为前驱后继
+                nxt[two_values[i]] = two_values[1-i]
+    
+    # 获取数值合集
+    num_set = get_num_set(pd_code)
+    for num in num_set:
+        if pre.get(num) is None:
+            pre[num] = nxt[num]
+        if nxt.get(num) is None:
+            nxt[num] = pre[num]
+    return pre, nxt
+
+# 替换一个值恰好一次
+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))
+
+def get_num_set(pd_code:list[list]):
+    val_set = set()
+    for crossing in pd_code:
+        for term in crossing:
+            if term not in val_set:
+                val_set.add(term)
+    return sorted(list(val_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) -> list[list]:
+    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 = get_pre_nxt(pd_code1)
+    _, nxt2 = 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)
+
+# 将 pd_code1 里面的 val_1 和 pd_code2 里面的 val_2 连接起来
+def connected_sum(
+    pd_code1:list[list], pd_code2:list[list], val_1, val_2) -> list[list]:
+    
+    # 如果有一个扭结平凡，则不需要连接
+    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 = get_pre_nxt(pd_code1)
+    _, nxt2 = 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
+
+if __name__ == "__main__":
+    print(connected_sum([[1, 2, 2, 1]], [[1, 2, 2, 1]], 1, 1))

pd_code_connected_sum-0.0.1/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "pd-code-connected-sum"
+version = "0.0.1"
+description = "make connected sum for link pd_code"
+authors = [
+    {name = "GGN_2015",email = "neko@jlulug.org"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pd-code-sanity"
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"