new useful complexes methods

Author: gabe-rbo

CITATION.cff

@@ -5,7 +5,7 @@ authors:
     given-names: "Gabriel"
     email: "gabriel.ribeiro@dcc.ufmg.br"
 title: "pySurgery: Computational Surgery Theory in Python"
-version: 2.1.2
+version: 2.1.3
 date-released: 01-05-2026
 url: "https://github.com/gabe-rbo/pysurgery"
 repository-code: "https://github.com/gabe-rbo/pysurgery"

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pysurgery"
-version = "2.1.2"
+version = "2.1.3"
 description = "A high-performance Python library for Computational Surgery Theory."
 dependencies = [
     "numpy>=2.4.4",
@@ -83,7 +83,7 @@ python_files = ["test_*.py"]
 "*" = ["*.jl", "*.yaml", "*.json"]
 
 [tool.bumpversion]
-current_version = "2.1.2"
+current_version = "2.1.3"
 commit = true
 tag = true
 

pysurgery/__init__.py

@@ -315,7 +315,7 @@
 
 from . import integrations
 
-__version__ = "2.1.2"
+__version__ = "2.1.3"
 
 def __getattr__(name):
     if name == "JuliaBridge":

pysurgery/topology/complexes.py

@@ -3896,6 +3896,68 @@ def link(self, simplex: Iterable[int]) -> "SimplicialComplex":
         # if we include all faces. from_simplices will organize them.
         return SimplicialComplex.from_simplices(link_simplices, coefficient_ring=self.coefficient_ring, close_under_faces=True)
 
+    def get_subfaces(self, simplex: Iterable[int], dimension: Optional[int] = None) -> Set[Tuple[int, ...]]:
+        """Return all subfaces of a simplex present in the complex, optionally filtered by dimension.
+
+        A subface of sigma is any simplex tau in the complex that is a subset of sigma.
+
+        Args:
+            simplex: The simplex to find subfaces of.
+            dimension: Optional dimension to filter by.
+
+        Returns:
+            A set of tuples representing the subfaces.
+        """
+        sigma = _normalize_simplex(simplex)
+        subfaces = set()
+        
+        for r in range(1, len(sigma) + 1):
+            d = r - 1
+            if dimension is not None and d != dimension:
+                continue
+            if d not in self._simplices_table:
+                continue
+            for combo in itertools.combinations(sigma, r):
+                f = tuple(sorted(combo))
+                if f in self._simplices_table[d]:
+                    subfaces.add(f)
+        return subfaces
+
+    def get_cofaces(self, simplex: Iterable[int], dimension: Optional[int] = None) -> Set[Tuple[int, ...]]:
+        """Return all cofaces of a simplex in the complex, optionally filtered by dimension.
+
+        A coface of sigma is any simplex tau in the complex that contains sigma.
+
+        Args:
+            simplex: The simplex to find cofaces of.
+            dimension: Optional dimension to filter by.
+
+        Returns:
+            A set of tuples representing the cofaces.
+        """
+        cofaces = self.star(simplex)
+        if dimension is not None:
+            cofaces = {c for c in cofaces if len(c) - 1 == dimension}
+        return cofaces
+
+    def to_dynamic_complex(self) -> "DynamicComplex":
+        """Convert this static SimplicialComplex into a DynamicComplex.
+
+        Preserves the simplices, coefficient ring, filtration, and coordinates.
+
+        Returns:
+            DynamicComplex: The dynamic complex representation.
+        """
+        dc = DynamicComplex(
+            simplices=self.simplices_field,
+            coefficient_ring=self.coefficient_ring,
+            filtration=self.filtration,
+        )
+        if hasattr(self, "_coordinates") and self._coordinates is not None:
+            dc._coordinates = self._coordinates.copy()
+            dc._generate_point_cloud_mappings(dc._coordinates)
+        return dc
+
     def simplex_to_index(self, d: int) -> Dict[Tuple[int, ...], int]:
         """Map each d-simplex to its index in the ordered simplex list.
 

tests/test_dynamic_complexes.py

@@ -40,3 +40,31 @@ def test_dynamic_complex_skeletal_closure_removal():
     assert dc.count_simplices(1) == 0
     assert dc.count_simplices(0) == 1
     assert dc.n_simplices(0) == [(1,)]
+
+
+def test_new_simplicial_complex_methods():
+    sc = SimplicialComplex.from_simplices([(0, 1, 2)], close_under_faces=True)
+    
+    # Test get_subfaces
+    subfaces_all = sc.get_subfaces((0, 1, 2))
+    assert (0,) in subfaces_all
+    assert (0, 1) in subfaces_all
+    assert (0, 1, 2) in subfaces_all
+    
+    subfaces_dim1 = sc.get_subfaces((0, 1, 2), dimension=1)
+    assert subfaces_dim1 == {(0, 1), (1, 2), (0, 2)}
+    
+    # Test get_cofaces
+    cofaces_all = sc.get_cofaces((0,))
+    assert (0,) in cofaces_all
+    assert (0, 1) in cofaces_all
+    assert (0, 1, 2) in cofaces_all
+    
+    cofaces_dim2 = sc.get_cofaces((0,), dimension=2)
+    assert cofaces_dim2 == {(0, 1, 2)}
+    
+    # Test to_dynamic_complex
+    dc = sc.to_dynamic_complex()
+    assert isinstance(dc, DynamicComplex)
+    assert dc.betti_number(0) == 1
+    assert dc.betti_number(1) == 0