simulation-alg 0.1.9__tar.gz → 0.1.10__tar.gz

{simulation_alg-0.1.9 → simulation_alg-0.1.10}/.gitignore

@@ -1,2 +1,3 @@
 /target
 /.vscode
+/logs

{simulation_alg-0.1.9 → simulation_alg-0.1.10}/Cargo.lock

@@ -543,7 +543,7 @@ dependencies = [
 
 [[package]]
 name = "simulation"
-version = "0.1.8"
+version = "0.1.10"
 dependencies = [
  "graph-base",
  "graph-simulation",

{simulation_alg-0.1.9 → simulation_alg-0.1.10}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "simulation"
-version = "0.1.8"
+version = "0.1.10"
 edition = "2021"
 license = "MIT"
 description = "A Python package for simulation algorithms"
@@ -15,7 +15,7 @@ crate-type = ["cdylib"]
 [dependencies]
 pyo3 = { version = "0.27.1", features = ["extension-module"] }
 graph-simulation = "0.1.24"
-graph-base = "0.1.13"
+graph-base = "0.1.14"
 rayon = "1.10.0"
 # [tool.maturin]
 # include-pyi = true  # 自动打包生成的 .pyi 文件

{simulation_alg-0.1.9 → simulation_alg-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulation-alg
-Version: 0.1.9
+Version: 0.1.10
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{simulation_alg-0.1.9 → simulation_alg-0.1.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "simulation-alg"
-version = "0.1.9"
+version = "0.1.10"
 requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Rust",

{simulation_alg-0.1.9 → simulation_alg-0.1.10}/simulation.pyi

@@ -33,6 +33,16 @@ def is_simulation_isomorphic_of_edge_fn(nx_graph1: networkx.DiGraph, nx_graph2:
     Check if two graphs are isomorphic by graph simulation.
     """
 
+def get_bounded_simulation(nx_graph1: networkx.DiGraph, nx_graph2: networkx.DiGraph, compare: Callable, bound: Callable, is_label_cached=False) -> Dict:
+    """
+    Get the bounded simulation between two graphs.
+    
+    The compare function should take two node attribute dictionaries and return True if they have the same label.
+    The bound function should take a node attribute dictionary and return an integer representing the bound value for that node.
+    
+    Returns a dictionary mapping nodes from nx_graph1 to sets of nodes from nx_graph2 that satisfy the bounded simulation.
+    """
+
 class Node:
     """
     Node for hypergraph.

{simulation_alg-0.1.9 → simulation_alg-0.1.10}/src/graph/networkx_graph.rs

@@ -1,9 +1,10 @@
 use graph_base::interfaces::vertex::Vertex;
 use graph_simulation::algorithm::simulation::Simulation;
+use graph_simulation::algorithm::bounded::{BoundedSimulation, Bounded};
 use pyo3::types::PySet;
 use pyo3::{prelude::*, types::PyDict};
 use graph_base::interfaces::labeled::{Label, Labeled, LabeledAdjacency};
-use graph_base::interfaces::graph::{Graph, Directed, Adjacency, AdjacencyInv, SingleId, IdPair};
+use graph_base::interfaces::graph::{Graph, Directed, Adjacency, AdjacencyInv, SingleId, IdPair, Degree, DegreeList};
 
 use pyo3::prelude::*;
 use std::collections::{HashMap, HashSet};
@@ -139,7 +140,8 @@ pub struct NetworkXGraph {
     same_label_fn: Option<Py<PyAny>>,
     same_edge_fn: Option<Py<PyAny>>,
     same_node_edge_fn: Option<Py<PyAny>>,
-    same_label_cache: Option<HashSet<(usize, usize)>>
+    same_label_cache: Option<HashSet<(usize, usize)>>,
+    bound_values: HashMap<usize, usize>,  // 节点 ID 到 bound 值的映射
 }
 
 impl Clone for NetworkXGraph {
@@ -153,6 +155,7 @@ impl Clone for NetworkXGraph {
                 same_edge_fn: self.same_edge_fn.as_ref().map(|f| f.clone_ref(py)),
                 same_node_edge_fn: self.same_node_edge_fn.as_ref().map(|f| f.clone_ref(py)),
                 same_label_cache: self.same_label_cache.clone(),
+                bound_values: self.bound_values.clone(),
             }
         })
     }
@@ -181,6 +184,7 @@ impl NetworkXGraph {
             same_edge_fn: None,
             same_node_edge_fn: None, 
             same_label_cache: None,
+            bound_values: HashMap::new(),
         }
     }
 
@@ -321,17 +325,6 @@ impl NetworkXGraph {
     }
 
     fn build_compare_cache(&mut self, other: &NetworkXGraph) {
-        // use rayon::prelude::*;
-        // let cache: HashSet<_> = self.nodes.par_iter().flat_map(|node1| {
-        //     let local: HashSet<_> = other.nodes.par_iter().filter_map(|node2| {
-        //         if self.label_same(node1, node2) {
-        //             Some((node1.id, node2.id))
-        //         } else {
-        //             None
-        //         }
-        //     }).collect();
-        //     local
-        // }).collect();
 
         let cache: HashSet<_> = self.nodes.iter().flat_map(|node1| {
             other.nodes.iter().filter_map(|node2| {
@@ -345,6 +338,22 @@ impl NetworkXGraph {
 
         self.same_label_cache = Some(cache);
     }
+
+    fn set_bound_values(&mut self, bound_fn: Py<PyAny>) {
+        // 使用 bound 函数为每个节点设置 bound 值
+        for node in &self.nodes {
+            let bound_value = Python::attach(|py| {
+                let node_attrs = node.attributes.0.iter()
+                    .map(|(k, v)| (k.clone(), v.clone_ref(py)))
+                    .collect::<HashMap<_, _>>();
+                bound_fn.call1(py, (node_attrs,))
+                    .ok()
+                    .and_then(|result| result.extract::<usize>(py).ok())
+                    .unwrap_or(0)
+            });
+            self.bound_values.insert(node.id, bound_value);
+        }
+    }
 }
 
 impl Vertex for Node {}
@@ -363,6 +372,7 @@ impl<'a> Graph<'a> for NetworkXGraph {
             same_edge_fn: None,
             same_node_edge_fn: None,
             same_label_cache: None,
+            bound_values: HashMap::new(),
         }
     }
 
@@ -489,14 +499,14 @@ impl std::fmt::Display for NetworkXGraph {
     }
 }
 
-fn to_nx_node(py: Python, node: &Node) -> PyResult<Py<PyAny>> {
-    let attrs_dict = PyDict::new(py);
-    for (k, v) in &node.attributes.0 {
-        attrs_dict.set_item(k, v.clone_ref(py))?;
-    }
-    let nx = py.import("networkx")?;
-    let node = nx.getattr("Node")?.call1((node.id.clone(), attrs_dict))?;
-    Ok(node.into())
+fn to_nx_node(_py: Python, node: &Node) -> PyResult<Py<PyAny>> {
+    // Return the node id as a Python object
+    Python::attach(|py| {
+        let builtins = py.import("builtins")?;
+        let int_fn = builtins.getattr("int")?;
+        let val = int_fn.call1((node.id,))?;
+        Ok(val.into())
+    })
 }
 
 #[pyfunction]
@@ -616,6 +626,100 @@ impl Adjacency<'_> for NetworkXGraph {}
 
 impl AdjacencyInv<'_> for NetworkXGraph {}
 
+impl<'a> Degree<'a> for NetworkXGraph {
+    fn get_out_degree(&'a self) -> DegreeList<'a, Self> {
+        let mut degree_map = HashMap::new();
+        
+        for node in &self.nodes {
+            let out_degree = self.edges.iter()
+                .filter(|edge| edge.source == node.id)
+                .count();
+            degree_map.insert(node, out_degree);
+        }
+        
+        // 使用 unsafe 代码来创建 DegreeList，因为其字段是私有的
+        unsafe { std::mem::transmute::<HashMap<&'a Self::Node, usize>, DegreeList<'a, Self>>(degree_map) }
+    }
+
+    fn get_in_degree(&'a self) -> DegreeList<'a, Self> {
+        let mut degree_map = HashMap::new();
+        
+        for node in &self.nodes {
+            let in_degree = self.edges.iter()
+                .filter(|edge| edge.target == node.id)
+                .count();
+            degree_map.insert(node, in_degree);
+        }
+        
+        // 使用 unsafe 代码来创建 DegreeList，因为其字段是私有的
+        unsafe { std::mem::transmute::<HashMap<&'a Self::Node, usize>, DegreeList<'a, Self>>(degree_map) }
+    }
+
+    fn out_degree(&'a self, degree_list: &DegreeList<'a, Self>, node: &Self::Node) -> usize {
+        // 使用 unsafe 代码访问私有字段
+        unsafe { 
+            let degree_map = &*(degree_list as *const _ as *const HashMap<&'a Self::Node, usize>);
+            *degree_map.get(node).unwrap_or(&0)
+        }
+    }
+
+    fn in_degree(&'a self, degree_list: &DegreeList<'a, Self>, node: &Self::Node) -> usize {
+        // 使用 unsafe 代码访问私有字段
+        unsafe { 
+            let degree_map = &*(degree_list as *const _ as *const HashMap<&'a Self::Node, usize>);
+            *degree_map.get(node).unwrap_or(&0)
+        }
+    }
+}
+
+impl<'a> Bounded<'a> for NetworkXGraph {
+    fn get_bound(&'a self, u: &'a Self::Node, v: &'a Self::Node) -> usize {
+        // 从 u 到 v 的 bound 值。我们定义为 u 节点的 bound_values 中的值
+        // 或者可以定义为基于 (u, v) 对的某个函数
+        *self.bound_values.get(&u.id).unwrap_or(&0)
+    }
+}
+
+#[pyfunction]
+#[pyo3(signature = (nx_graph1, nx_graph2, compare, bound, is_label_cached = false))]
+pub fn get_bounded_simulation(
+    nx_graph1: &Bound<'_, PyAny>, 
+    nx_graph2: &Bound<'_, PyAny>, 
+    compare: Py<PyAny>,
+    bound: Py<PyAny>,
+    is_label_cached: bool
+) -> PyResult<Py<PyAny>> {
+    // 1. 从 NetworkX 图转换
+    let mut graph1 = NetworkXGraph::from_networkx(nx_graph1)?;
+    let graph2 = NetworkXGraph::from_networkx(nx_graph2)?;
+    
+    // 2. 注册 compare 函数
+    graph1.register_compare_fn(compare);
+    
+    // 3. 为 graph1 设置 bound 值
+    graph1.set_bound_values(bound);
+    
+    // 4. 构建缓存
+    if is_label_cached {
+        graph1.build_compare_cache(&graph2);
+    }
+    
+    // 5. 执行 bounded simulation
+    let sim = graph1.get_bounded_simulation(&graph2);
+    
+    // 6. 转换结果为 Python 对象
+    Python::attach(|py| {
+        let map = PyDict::new(py);
+        
+        for (node, set) in sim.iter() {
+            let py_set = PySet::new(py, set.iter().map(|node| to_nx_node(py, node)).collect::<PyResult<Vec<_>>>()?)?;
+            map.set_item(to_nx_node(py, node)?, py_set)?;
+        }
+    
+        Ok(map.into())
+    })
+}
+
 // 模块定义
 // #[pymodule]
 // pub fn networkx_graph(_py: Python, m: &PyModule) -> PyResult<()> {

{simulation_alg-0.1.9 → simulation_alg-0.1.10}/src/lib.rs

@@ -21,5 +21,6 @@ fn simulation(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(graph::networkx_graph::is_simulation_isomorphic_fn, m)?)?;
     m.add_function(wrap_pyfunction!(graph::networkx_graph::is_simulation_isomorphic_of_edge_fn, m)?)?;
     m.add_function(wrap_pyfunction!(graph::networkx_graph::is_simulation_isomorphic_of_node_edge_fn, m)?)?;
+    m.add_function(wrap_pyfunction!(graph::networkx_graph::get_bounded_simulation, m)?)?;
     Ok(())
 }

simulation_alg-0.1.10/test_bounded_simulation.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""
+Test script for bounded simulation functionality.
+"""
+
+import networkx as nx
+import sys
+sys.path.insert(0, '/home/vincent/simulation/target/release')
+
+try:
+    import simulation
+    print("✓ Successfully imported simulation module")
+except ImportError as e:
+    print(f"✗ Failed to import simulation module: {e}")
+    sys.exit(1)
+
+def test_bounded_simulation():
+    """Test the get_bounded_simulation function."""
+    
+    # Create two simple graphs
+    graph1 = nx.DiGraph()
+    graph1.add_node(0, label='A')
+    graph1.add_node(1, label='B')
+    graph1.add_edge(0, 1)
+    
+    graph2 = nx.DiGraph()
+    graph2.add_node(0, label='A')
+    graph2.add_node(1, label='B')
+    graph2.add_node(2, label='B')
+    graph2.add_edge(0, 1)
+    graph2.add_edge(0, 2)
+    
+    # Define the compare function (checks if labels are the same)
+    def compare_labels(attr1, attr2):
+        return attr1.get('label') == attr2.get('label')
+    
+    # Define the bound function (returns a fixed bound value for each node)
+    def get_bound_value(attr):
+        return 2  # bound value = 2 for all nodes
+    
+    try:
+        result = simulation.get_bounded_simulation(
+            graph1, 
+            graph2, 
+            compare_labels, 
+            get_bound_value,
+            is_label_cached=False
+        )
+        
+        print("✓ get_bounded_simulation executed successfully")
+        print(f"  Result type: {type(result)}")
+        
+        # Check if result is a dictionary
+        if isinstance(result, dict):
+            print("✓ Result is a dictionary")
+            print(f"  Result size: {len(result)} entries")
+            for i, (node, sim_set) in enumerate(result.items()):
+                if i < 5:  # Print only first 5 entries
+                    print(f"  Node: {node}, Simulated nodes: {list(sim_set) if hasattr(sim_set, '__iter__') else sim_set}")
+        else:
+            print(f"✗ Expected dict, got {type(result)}")
+            return False
+        
+        return True
+        
+    except Exception as e:
+        print(f"✗ Error calling get_bounded_simulation: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    print("Testing bounded simulation functionality...")
+    print("=" * 50)
+    
+    success = test_bounded_simulation()
+    
+    print("=" * 50)
+    if success:
+        print("✓ All tests passed!")
+    else:
+        print("✗ Some tests failed")
+        sys.exit(1)