phimaker 0.2.0__tar.gz → 0.2.2__tar.gz

{phimaker-0.2.0 → phimaker-0.2.2}/Cargo.lock

@@ -272,7 +272,7 @@ dependencies = [
 
 [[package]]
 name = "phimaker"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "atomic_refcell",
  "bincode",

{phimaker-0.2.0 → phimaker-0.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "phimaker"
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

{phimaker-0.2.0 → phimaker-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phimaker
-Version: 0.2.0
+Version: 0.2.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{phimaker-0.2.0 → phimaker-0.2.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 [project]
 name = "phimaker"
 requires-python = ">=3.7"
-version = "0.2.0"
+version = "0.2.2"
 classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",

{phimaker-0.2.0 → phimaker-0.2.2}/src/cylinder.rs

@@ -1,5 +1,6 @@
 use lophat::columns::{Column, VecColumn};
 use pyo3::prelude::*;
+use log::debug;
 
 use std::cmp::Ordering;
 
@@ -43,6 +44,7 @@ pub struct CylinderMetadata {
     pub domain_shift: Vec<usize>,
 }
 
+// Build the filtered mapping cylinder of a map between filtered chain complexes.
 pub fn build_cylinder(
     domain_matrix: Vec<(f64, VecColumn)>,
     codomain_matrix: Vec<(f64, VecColumn)>,
@@ -67,7 +69,7 @@ pub fn build_cylinder(
         .into_iter()
         .enumerate()
         .map(|(idx, (time, col))| {
-            // Make two copies of each domain column
+            // First copy of domain columns
             (idx, time, CylinderColType::Domain, col.clone())
         });
 
@@ -75,7 +77,7 @@ pub fn build_cylinder(
         .into_iter()
         .enumerate()
         .map(|(idx, (time, col))| {
-            // Make two copies of each domain column
+            // Second copy of domain columns
             (idx, time, CylinderColType::DomainShifted, col)
         });
 
@@ -136,7 +138,7 @@ pub fn build_cylinder(
                     .entries()
                     .map(|row_idx|
                         codomain_idxs.get(row_idx)
-                        .expect("Map must be compatibile with both filtrations i.e. entrance time of f(c) <= entrance time of c")
+                        .expect("Map must be compatible with both filtrations i.e. entrance time of f(c) <= entrance time of c")
                     )
                     .copied();
                 let domain_shift_part = col
@@ -180,6 +182,7 @@ pub fn build_cylinder(
         codomain: codomain_idxs,
         domain_shift: domain_shift_idxs,
     };
+    debug!("Built mapping cylinder with {} simplices.", cylinder_matrix.len());
     (cylinder_matrix, metadata)
 }
 

{phimaker-0.2.0 → phimaker-0.2.2}/src/diagrams.rs

@@ -1,6 +1,8 @@
 use bincode::deserialize_from;
 use std::{fs::File, io::BufReader};
 
+use log::debug;
+
 use lophat::{
     algorithms::RVDecomposition, columns::Column, utils::PersistenceDiagram, utils::RVDFileFormat,
 };
@@ -214,7 +216,7 @@ impl FileEnsemble {
             let at_diagram = f_decomp.diagram();
             at_diagram.anti_transpose(self.metadata.size_of_k)
         };
-        println!("Got f");
+        debug!("Got f");
         let f_negative_list = compute_negative_list(&self.metadata, &f_diagram);
         let rel_diagram = {
             let rel_decomp = from_file(&self.rel);

{phimaker-0.2.0 → phimaker-0.2.2}/src/ensemble.rs

@@ -1,7 +1,7 @@
 use bincode::serialize_into;
+use log::debug;
 use serde::Serialize;
 use std::{fs::File, io::BufWriter, marker::PhantomData, thread};
-use log::info;
 
 use lophat::{
     algorithms::RVDecomposition,
@@ -31,18 +31,18 @@ pub struct EnsembleMetadata {
 #[derive(Debug)]
 pub struct DecompositionEnsemble<C, Algo>
 where
-        C: Column,
-        Algo: RVDecomposition<C>,
-    {
-        pub f: Algo,
-        pub g: Algo,
-        pub im: Algo,
-        pub ker: Algo,
-        pub cok: Algo,
-        pub rel: Algo,
-        pub metadata: EnsembleMetadata,
-        phantom: PhantomData<C>,
-    }
+    C: Column,
+    Algo: RVDecomposition<C>,
+{
+    pub f: Algo,
+    pub g: Algo,
+    pub im: Algo,
+    pub ker: Algo,
+    pub cok: Algo,
+    pub rel: Algo,
+    pub metadata: EnsembleMetadata,
+    phantom: PhantomData<C>,
+}
 
 #[derive(Debug)]
 pub struct FileEnsemble {
@@ -64,9 +64,9 @@ pub fn thread_1_job<Algo: RVDecomposition<VecColumn, Options = LoPhatOptions> +
 ) -> Algo {
     // Decompose Df
     // Df is a chain complex so can compute anti-transpose instead
-    let df_at = anti_transpose(&df);
+    let df_at = anti_transpose(df);
     let out = Algo::decompose(df_at.into_iter(), Some(base_options));
-    info!("Decomposed f");
+    debug!("Decomposed f");
     out
 }
 
@@ -78,17 +78,17 @@ pub fn thread_2_job<Algo: RVDecomposition<VecColumn, Options = LoPhatOptions> +
 ) -> (Algo, Algo) {
     // Decompose Dg
     // Need to use v columns of Dg later, so no AT
-    let dg = build_dg(&df, &g_elements, &l_first_mapping);
-    let mut dg_options = base_options.clone();
+    let dg = build_dg(df, g_elements, l_first_mapping);
+    let mut dg_options = base_options;
     dg_options.maintain_v = true;
     let decomp_dg = Algo::decompose(dg, Some(dg_options));
-    info!("Decomposed g");
+    debug!("Decomposed g");
     // Decompose dcok
-    let dcok = build_dcok(&df, &decomp_dg, &g_elements, l_first_mapping);
-    let mut dcok_options = base_options.clone();
+    let dcok = build_dcok(df, &decomp_dg, g_elements, l_first_mapping);
+    let mut dcok_options = base_options;
     dcok_options.clearing = false; // Not a chain complex
     let decompose_dcok = Algo::decompose(dcok, Some(dcok_options));
-    info!("Decomposed cok");
+    debug!("Decomposed cok");
     (decomp_dg, decompose_dcok)
 }
 pub fn thread_3_job<Algo: RVDecomposition<VecColumn, Options = LoPhatOptions> + Send>(
@@ -99,20 +99,20 @@ pub fn thread_3_job<Algo: RVDecomposition<VecColumn, Options = LoPhatOptions> +
 ) -> (Algo, Algo, VectorMapping) {
     // Decompose dim
     // Need to use v columns of Dim later, also no AT or clearing since D^2 != 0
-    let dim = build_dim(&df, l_first_mapping);
-    let mut dim_options = base_options.clone();
+    let dim = build_dim(df, l_first_mapping);
+    let mut dim_options = base_options;
     dim_options.maintain_v = true;
     dim_options.clearing = false;
     let decompose_dim = Algo::decompose(dim, Some(dim_options));
-    info!("Decomposed im");
+    debug!("Decomposed im");
     // Decompose dker
     let dker = build_dker(&decompose_dim, l_first_mapping);
-    let mut dker_options = base_options.clone();
+    let mut dker_options = base_options;
     dker_options.clearing = false; // Not a chain complex so no clearing
     dker_options.column_height = Some(size_of_k); // Non-square matrix
     let decompose_dker = Algo::decompose(dker, Some(dker_options));
     let kernel_mapping = build_kernel_mapping(&decompose_dim);
-    info!("Decomposed ker");
+    debug!("Decomposed ker");
     (decompose_dim, decompose_dker, kernel_mapping)
 }
 
@@ -123,12 +123,12 @@ pub fn thread_4_job<Algo: RVDecomposition<VecColumn, Options = LoPhatOptions> +
     size_of_k: usize,
     base_options: LoPhatOptions,
 ) -> (Algo, VectorMapping) {
-    let (rel_mapping, l_index) = build_rel_mapping(&df, &g_elements, size_of_l, size_of_k);
-    let drel = build_drel(&df, &g_elements, &rel_mapping, l_index).collect();
+    let (rel_mapping, l_index) = build_rel_mapping(df, g_elements, size_of_l, size_of_k);
+    let drel = build_drel(df, g_elements, &rel_mapping, l_index).collect();
     // Chain complex so can use clearing and AT
     let drel_at = anti_transpose(&drel);
     let decompose_drel = Algo::decompose(drel_at.into_iter(), Some(base_options));
-    info!("Decomposed rel");
+    debug!("Decomposed rel");
     (decompose_drel, rel_mapping)
 }
 
@@ -199,7 +199,7 @@ pub fn to_file<Algo: Serialize>(algo: Algo) -> File {
         let mut buf = BufWriter::new(&mut file_write);
         serialize_into(&mut buf, &algo).expect("Can serialize to file");
     }
-    // Explicity release memory
+    // Explicitly release memory
     drop(algo);
     file_read
 }

{phimaker-0.2.0 → phimaker-0.2.2}/src/lib.rs

@@ -27,7 +27,7 @@ fn compute_ensemble(
     num_threads: usize,
     slow: bool,
 ) -> DiagramEnsemble {
-    let annotated_matrix = matrix
+    let annotated_matrix: Vec<_> = matrix
         .into_iter()
         .map(|(in_g, dimension, boundary)| AnnotatedColumn {
             in_g,
@@ -64,15 +64,15 @@ fn compute_ensemble(
 /// - If `map` is not compatible with the domain matrix, i.e., if the entrance time of any
 ///   generator in the domain is less than the entrance time of any generators in its image under
 ///   $f$.
-
 #[pyfunction]
-#[pyo3(signature = (domain_matrix, codomain_matrix, map, num_threads=0))]
+#[pyo3(signature = (domain_matrix, codomain_matrix, map, num_threads=0, slow=false))]
 fn compute_ensemble_cylinder(
     py: Python<'_>,
     domain_matrix: Vec<(f64, usize, Vec<usize>)>,
     codomain_matrix: Vec<(f64, usize, Vec<usize>)>,
     map: Vec<Vec<usize>>,
     num_threads: usize,
+    slow: bool,
 ) -> (DiagramEnsemble, CylinderMetadata) {
     // We mark each map with the dimension of the domain column
     let map = map
@@ -89,9 +89,16 @@ fn compute_ensemble_cylinder(
         .map(|(time, dimension, boundary)| (time, VecColumn::from((dimension, boundary))))
         .collect();
     let (cylinder, metadata) = build_cylinder(domain_matrix, codomain_matrix, map);
-    let decomps =
-        py.allow_threads(|| all_decompositions::<LockFreeAlgorithm<_>>(cylinder, num_threads));
-    (decomps.all_diagrams(), metadata)
+    if slow {
+        let decomps =
+            all_decompositions_slow::<LockFreeAlgorithm<_>>(cylinder, num_threads);
+        (decomps.all_diagrams(), metadata)
+    } else {
+        let decomps = py.allow_threads(|| {
+            all_decompositions::<LockFreeAlgorithm<_>>(cylinder, num_threads)
+        });
+        (decomps.all_diagrams(), metadata)
+    }
 }
 
 #[pyfunction]