multipers 2.6.0__tar.gz → 2.6.1__tar.gz

{multipers-2.6.0 → multipers-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multipers
-Version: 2.6.0
+Version: 2.6.1
 Summary: Multiparameter Topological Persistence for Machine Learning
 Keywords: TDA,Persistence,Multiparameter,sklearn,autodiff
 Author-Email: David Loiseaux <david.lapous@proton.me>, Hannah Schreiber <hannah.schreiber@inria.fr>

{multipers-2.6.0 → multipers-2.6.1}/cmake/MultipersBuild.cmake

@@ -346,7 +346,10 @@ multipers_add_generated_patch_file(
   "${MULTIPERS_GENERATED_EXT_PATCH_DIR}/multi_critical_runtime_logs.patch"
   MULTIPERS_MULTI_CRITICAL_LOG_PATCH_FILE
   "${CMAKE_SOURCE_DIR}/ext/multi_critical/include/multi_critical/basic.h"
+  "${CMAKE_SOURCE_DIR}/ext/multi_critical/include/multi_critical/free_resolution.h"
   "${CMAKE_SOURCE_DIR}/ext/multi_critical/mpfree_mod/include/mpfree/global.h"
+  "${CMAKE_SOURCE_DIR}/ext/multi_critical/mpp_utils_mod/include/mpp_utils/Graded_matrix.h"
+  "${CMAKE_SOURCE_DIR}/ext/multi_critical/mpp_utils_mod/include/mpp_utils/create_graded_matrices_from_pre_column_struct.h"
   "${CMAKE_SOURCE_DIR}/ext/multi_critical/multi_chunk_mod/include/multi_chunk/basic.h"
   "${CMAKE_SOURCE_DIR}/ext/multi_critical/scc_mod/include/scc/basic.h"
 )
@@ -426,6 +429,7 @@ multipers_add_generated_patch_overlay(
   MULTIPERS_MULTI_CRITICAL_PATCH_OVERLAY_ROOT
   include
   mpfree_mod/include
+  mpp_utils_mod/include
   multi_chunk_mod/include
   scc_mod/include
 )
@@ -449,7 +453,7 @@ set(MULTIPERS_FUNCTION_DELAUNAY_INCLUDE_DIRS
 set(MULTIPERS_MULTI_CRITICAL_INCLUDE_DIRS
   "${MULTIPERS_MULTI_CRITICAL_PATCH_OVERLAY_ROOT}/ext/multi_critical/include"
   "${MULTIPERS_MULTI_CRITICAL_PATCH_OVERLAY_ROOT}/ext/multi_critical/mpfree_mod/include"
-  "${CMAKE_SOURCE_DIR}/ext/multi_critical/mpp_utils_mod/include"
+  "${MULTIPERS_MULTI_CRITICAL_PATCH_OVERLAY_ROOT}/ext/multi_critical/mpp_utils_mod/include"
   "${MULTIPERS_MULTI_CRITICAL_PATCH_OVERLAY_ROOT}/ext/multi_critical/multi_chunk_mod/include"
   "${CMAKE_SOURCE_DIR}/ext/multi_critical/phat_mod/include"
   "${MULTIPERS_MULTI_CRITICAL_PATCH_OVERLAY_ROOT}/ext/multi_critical/scc_mod/include"

{multipers-2.6.0 → multipers-2.6.1}/ext/patches/generate_log_patch.py

@@ -166,6 +166,211 @@ namespace multi_critical {
     )
 
 
+def _patch_multi_critical_free_resolution(text: str, rel_path: Path) -> str:
+    text = _replace_once(
+        text,
+        r"""    struct Grade_sorter {
+
+	std::vector<Output_simplex>& data;
+
+	Grade_sorter(std::vector<Output_simplex>& data) : data(data) {}
+
+	bool operator() (int i, int j) {
+	    Grade& g1 = data[i].grade;
+	    Grade& g2 = data[j].grade;
+	    if(g1.x<g2.x) {
+		return true;
+	    }
+	    if(g1.x>g2.x) {
+		return false;
+	    }
+	    return g1.y<g2.y;
+	}
+    };
+""",
+        r"""    struct Grade_sorter {
+
+	std::vector<Output_simplex>& data;
+
+	Grade_sorter(std::vector<Output_simplex>& data) : data(data) {}
+
+	bool operator() (int i, int j) {
+	    Grade& g1 = data[i].grade;
+	    Grade& g2 = data[j].grade;
+	    if(g1.x<g2.x) {
+		return true;
+	    }
+	    if(g1.x>g2.x) {
+		return false;
+	    }
+	    if(g1.y<g2.y) {
+		return true;
+	    }
+	    if(g1.y>g2.y) {
+		return false;
+	    }
+	    return i<j;
+	}
+    };
+""",
+        rel_path,
+    )
+    text = _replace_once(
+        text,
+        r"""std::vector<std::vector<std::pair<index,index>>> relations;
+	// Syzygy with relation idx as upper boundary is saved with key idx
+""",
+        r"""std::vector<std::vector<std::pair<index,index>>> relations;
+	// path mode only creates adjacent relations, so direct lookup avoids repeated scans
+	bool path_uses_only_adjacent_relations=false;
+	std::vector<index> adjacent_relations;
+	// Syzygy with relation idx as upper boundary is saved with key idx
+""",
+        rel_path,
+    )
+    text, count = re.subn(
+        r"\s*void get_path_of_relations\(int i,int j, std::vector<index>& rels\) \{\n"
+        r"\s*assert\(i<=j\);\n"
+        r"\s*if\(i==j\) \{\n"
+        r"\s*return;\n"
+        r"\s*\}\n"
+        r"\s*int next_copy=0;\n"
+        r"\s*int next_rel=0;\n"
+        r"\s*for\(auto pair : relations\[i\]\) \{\n"
+        r"\s*if\(pair.first>j\) \{\n"
+        r"\s*break;\n"
+        r"\s*\}\n"
+        r"\s*next_copy=pair.first;\n"
+        r"\s*next_rel=pair.second;\n"
+        r"\s*\}\n"
+        r"\s*rels.push_back\(next_rel\);\n"
+        r"\s*get_path_of_relations\(next_copy,j,rels\);\n"
+        r"\s*\}\n",
+        r"""
+	void get_path_of_relations(int i,int j, std::vector<index>& rels) {
+	    assert(i<=j);
+	    if(i==j) {
+		return;
+	    }
+	    if(path_uses_only_adjacent_relations) {
+		assert(j<=adjacent_relations.size());
+		for(int k=i;k<j;k++) {
+		    assert(adjacent_relations[k]>=0);
+		    rels.push_back(adjacent_relations[k]);
+		}
+		return;
+	    }
+	    int next_copy=0;
+	    int next_rel=0;
+	    for(auto pair : relations[i]) {
+		if(pair.first>j) {
+		    break;
+		}
+		next_copy=pair.first;
+		next_rel=pair.second;
+	    }
+	    rels.push_back(next_rel);
+	    get_path_of_relations(next_copy,j,rels);
+	}
+""",
+        text,
+        count=1,
+    )
+    if count != 1:
+        raise ValueError(f"Expected get_path_of_relations snippet not found in {rel_path.as_posix()}")
+    text = _replace_once(
+        text,
+        r"""		int width=1;
+		input_simplex.relations.resize(input_simplex.copies.size());
+""",
+        r"""		int width=1;
+		input_simplex.path_uses_only_adjacent_relations=!use_logpath;
+		input_simplex.relations.resize(input_simplex.copies.size());
+		if(input_simplex.path_uses_only_adjacent_relations && input_simplex.copies.size()>1) {
+		    input_simplex.adjacent_relations.assign(input_simplex.copies.size()-1,-1);
+		}
+""",
+        rel_path,
+    )
+    text = _replace_once(
+        text,
+        r"""			output_complex[ell+1].push_back(new_output_simplex_for_relation);
+			input_simplex.relations[j-width].push_back(std::make_pair(j,idx_of_new_output_relation));
+			
+""",
+        r"""			output_complex[ell+1].push_back(new_output_simplex_for_relation);
+			input_simplex.relations[j-width].push_back(std::make_pair(j,idx_of_new_output_relation));
+			if(input_simplex.path_uses_only_adjacent_relations) {
+			    assert(width==1);
+			    input_simplex.adjacent_relations[j-width]=idx_of_new_output_relation;
+			}
+			
+""",
+        rel_path,
+    )
+    return _replace_once(
+        text,
+        r"""#if 1
+	    Grade_sorter sorter(output_complex[i]);
+	    std::stable_sort(permutations[i].begin(),permutations[i].end(),sorter);
+#endif
+""",
+        r"""#if 1
+	    Grade_sorter sorter(output_complex[i]);
+	    std::sort(permutations[i].begin(),permutations[i].end(),sorter);
+#endif
+""",
+        rel_path,
+    )
+
+
+def _patch_multi_critical_graded_matrix(text: str, rel_path: Path) -> str:
+    text = _replace_once(
+        text,
+        r"""M1.row_grades.clear();
+	    for(index j=0;j<M1.num_rows;j++) {
+		M1.row_grades.push_back(M2.grades[j]);
+	    }
+""",
+        r"""M1.row_grades.assign(M2.grades.begin(),M2.grades.begin()+M1.num_rows);
+""",
+        rel_path,
+    )
+    return _replace_once(
+        text,
+        r"""	M1.row_grades.clear();
+	for(int i=0;i<n2;i++) {
+	    M1.row_grades.push_back(M2.grades[i]);
+	}
+""",
+        r"""	M1.row_grades.assign(M2.grades.begin(),M2.grades.begin()+n2);
+""",
+        rel_path,
+    )
+
+
+def _patch_multi_critical_pre_column_struct(text: str, rel_path: Path) -> str:
+    text = _replace_once(text, "#include<cstring>\n", "#include<cstring>\n#include<utility>\n", rel_path)
+    text, count = re.subn(
+        r"(\s*void get_boundary\(int i, int j,std::vector<index>& result\) \{\n)"
+        r"\s*result=pre_columns\[i\]\[j\]\.boundary;\n"
+        r"(\s*\}\n)",
+        r"\1\t  result=std::move(pre_columns[i][j].boundary);\n\2",
+        text,
+        count=1,
+    )
+    if count != 1:
+        raise ValueError(f"Expected pre-column get_boundary snippet not found in {rel_path.as_posix()}")
+    return _replace_once(
+        text,
+        r"""matrix.set_col(j,bd);
+""",
+        r"""matrix.set_col(j,std::move(bd));
+""",
+        rel_path,
+    )
+
+
 def _patch_scc_basic(text: str, rel_path: Path, *, bit: str) -> str:
     return _replace_once(
         text,
@@ -250,7 +455,10 @@ def _multi_critical_targets() -> dict[Path, str]:
     return _build_explicit_targets(
         {
             Path("ext/multi_critical/include/multi_critical/basic.h"): _patch_multi_critical_basic,
+            Path("ext/multi_critical/include/multi_critical/free_resolution.h"): _patch_multi_critical_free_resolution,
             Path("ext/multi_critical/mpfree_mod/include/mpfree/global.h"): _patch_mpfree_global,
+            Path("ext/multi_critical/mpp_utils_mod/include/mpp_utils/Graded_matrix.h"): _patch_multi_critical_graded_matrix,
+            Path("ext/multi_critical/mpp_utils_mod/include/mpp_utils/create_graded_matrices_from_pre_column_struct.h"): _patch_multi_critical_pre_column_struct,
             Path("ext/multi_critical/multi_chunk_mod/include/multi_chunk/basic.h"): (
                 lambda text, rel: _patch_multi_chunk_basic(
                     text,

multipers-2.6.1/ext/patches/multi_critical_runtime_logs.patch

@@ -0,0 +1,219 @@
+--- a/ext/multi_critical/include/multi_critical/basic.h
++++ b/ext/multi_critical/include/multi_critical/basic.h
+@@ -20,11 +20,20 @@
+ 
+ #include<mpp_utils/basic.h>
+ 
++#if __has_include("ext_interface/backend_log_flag.hpp")
++#include "ext_interface/backend_log_flag.hpp"
++#endif
++
+ namespace multi_critical {
+ 
+     typedef mpp_utils::index index;
+ 
++#if __has_include("ext_interface/backend_log_flag.hpp")
++    inline multipers::backend_log_policy::runtime_flag<multipers::backend_log_policy::backend_log_bit::multi_critical> verbose;
++    inline multipers::backend_log_policy::constant_flag<false> very_verbose;
++#else
+     bool verbose = false;
+     bool very_verbose=false;
++#endif
+ 
+ } // of namespace multi-critical
+--- a/ext/multi_critical/include/multi_critical/free_resolution.h
++++ b/ext/multi_critical/include/multi_critical/free_resolution.h
+@@ -221,6 +221,9 @@
+ 	std::vector<index> copies;
+ 	// relations[i] is the list of pairs (j,idx) with i<j and idx a relation joining i and j
+ 	std::vector<std::vector<std::pair<index,index>>> relations;
++	// path mode only creates adjacent relations, so direct lookup avoids repeated scans
++	bool path_uses_only_adjacent_relations=false;
++	std::vector<index> adjacent_relations;
+ 	// Syzygy with relation idx as upper boundary is saved with key idx
+ 	std::unordered_map<index,index> syzygies;
+ 	// The two other relations bounding the syzygy are saved here
+@@ -233,10 +236,17 @@
+ 	    std::copy(boundary.begin(),boundary.end(),std::back_inserter(this->boundary));
+ 	    
+ 	}
+-
+ 	void get_path_of_relations(int i,int j, std::vector<index>& rels) {
+ 	    assert(i<=j);
+ 	    if(i==j) {
++		return;
++	    }
++	    if(path_uses_only_adjacent_relations) {
++		assert(j<=adjacent_relations.size());
++		for(int k=i;k<j;k++) {
++		    assert(adjacent_relations[k]>=0);
++		    rels.push_back(adjacent_relations[k]);
++		}
+ 		return;
+ 	    }
+ 	    int next_copy=0;
+@@ -491,7 +501,13 @@
+ 	    if(g1.x>g2.x) {
+ 		return false;
+ 	    }
+-	    return g1.y<g2.y;
++	    if(g1.y<g2.y) {
++		return true;
++	    }
++	    if(g1.y>g2.y) {
++		return false;
++	    }
++	    return i<j;
+ 	}
+     };
+ 
+@@ -704,7 +720,11 @@
+ 		}
+ 		// Generate relations and syzygies
+ 		int width=1;
++		input_simplex.path_uses_only_adjacent_relations=!use_logpath;
+ 		input_simplex.relations.resize(input_simplex.copies.size());
++		if(input_simplex.path_uses_only_adjacent_relations && input_simplex.copies.size()>1) {
++		    input_simplex.adjacent_relations.assign(input_simplex.copies.size()-1,-1);
++		}
+ 		// It is important for later that the relations are generated in increasing
+ 		// length, that is, the width of the relations (for a single input simplex)
+ 		// increase with their index
+@@ -726,6 +746,10 @@
+ 						
+ 			output_complex[ell+1].push_back(new_output_simplex_for_relation);
+ 			input_simplex.relations[j-width].push_back(std::make_pair(j,idx_of_new_output_relation));
++			if(input_simplex.path_uses_only_adjacent_relations) {
++			    assert(width==1);
++			    input_simplex.adjacent_relations[j-width]=idx_of_new_output_relation;
++			}
+ 			
+ 			
+ 			if(width>1) {
+@@ -1217,7 +1241,7 @@
+ 	    }
+ #if 1
+ 	    Grade_sorter sorter(output_complex[i]);
+-	    std::stable_sort(permutations[i].begin(),permutations[i].end(),sorter);
++	    std::sort(permutations[i].begin(),permutations[i].end(),sorter);
+ #endif
+ 	    for(int j=0;j<m;j++) {
+ 		inv_permutations[i][permutations[i][j]]=j;
+--- a/ext/multi_critical/mpfree_mod/include/mpfree/global.h
++++ b/ext/multi_critical/mpfree_mod/include/mpfree/global.h
+@@ -20,9 +20,17 @@
+ 
+ #include<phat/helpers/misc.h>
+ 
++#if __has_include("ext_interface/backend_log_flag.hpp")
++#include "ext_interface/backend_log_flag.hpp"
++#endif
++
+ namespace mpfree {
+ 
++#if __has_include("ext_interface/backend_log_flag.hpp")
++  inline multipers::backend_log_policy::runtime_flag<multipers::backend_log_policy::backend_log_bit::mpfree> verbose;
++#else
+   bool verbose = false;
++#endif
+ 
+   typedef phat::index index;
+   
+--- a/ext/multi_critical/mpp_utils_mod/include/mpp_utils/Graded_matrix.h
++++ b/ext/multi_critical/mpp_utils_mod/include/mpp_utils/Graded_matrix.h
+@@ -538,10 +538,7 @@
+ 	    GradedMatrix& M1=*it1;
+ 	    GradedMatrix& M2=*it2;
+ 	    assert(M1.num_rows==M2.get_num_cols());
+-	    M1.row_grades.clear();
+-	    for(index j=0;j<M1.num_rows;j++) {
+-		M1.row_grades.push_back(M2.grades[j]);
+-	    }
++	    M1.row_grades.assign(M2.grades.begin(),M2.grades.begin()+M1.num_rows);
+ 	    //std::cout << "Copied " << M1.num_rows << " grades" << std::endl;
+ 	    it1++;
+ 	    it2++;
+@@ -685,10 +682,7 @@
+ 	    M2.grades[i].index_at[0]=val_to_index_x[M2.grades[i].at[0]];
+ 	    M2.grades[i].index_at[1]=val_to_index_y[M2.grades[i].at[1]];
+ 	}
+-	M1.row_grades.clear();
+-	for(int i=0;i<n2;i++) {
+-	    M1.row_grades.push_back(M2.grades[i]);
+-	}
++	M1.row_grades.assign(M2.grades.begin(),M2.grades.begin()+n2);
+ 	M1.grade_indices_assigned=true;
+ 	M2.grade_indices_assigned=true;
+     
+--- a/ext/multi_critical/mpp_utils_mod/include/mpp_utils/create_graded_matrices_from_pre_column_struct.h
++++ b/ext/multi_critical/mpp_utils_mod/include/mpp_utils/create_graded_matrices_from_pre_column_struct.h
+@@ -19,6 +19,7 @@
+ #pragma once
+ 
+ #include<cstring>
++#include<utility>
+ 
+ #include<mpp_utils/basic.h>
+ #include<mpp_utils/Pre_column_struct.h>
+@@ -61,7 +62,7 @@
+       }
+ 
+       void get_boundary(int i, int j,std::vector<index>& result) {
+-	  result=pre_columns[i][j].boundary;
++	  result=std::move(pre_columns[i][j].boundary);
+       }
+ 
+       void clear(int i) {
+@@ -100,7 +101,7 @@
+ 	matrix.grades[j]=pre_column_accessor.get_grade(i,j);
+ 	bd.clear();
+ 	pre_column_accessor.get_boundary(i,j,bd);
+-	matrix.set_col(j,bd);
++	matrix.set_col(j,std::move(bd));
+       }
+       pre_column_accessor.clear(i);
+       matrix.sync();
+--- a/ext/multi_critical/multi_chunk_mod/include/multi_chunk/basic.h
++++ b/ext/multi_critical/multi_chunk_mod/include/multi_chunk/basic.h
+@@ -20,10 +20,18 @@
+ 
+ #include<mpp_utils/basic.h>
+ 
++#if __has_include("ext_interface/backend_log_flag.hpp")
++#include "ext_interface/backend_log_flag.hpp"
++#endif
++
+ namespace multi_chunk {
+ 
+   typedef mpp_utils::index index;
+ 
++#if __has_include("ext_interface/backend_log_flag.hpp")
++  inline multipers::backend_log_policy::runtime_flag<multipers::backend_log_policy::backend_log_bit::multi_critical> verbose;
++#else
+   bool verbose = true;
++#endif
+ }
+ 
+--- a/ext/multi_critical/scc_mod/include/scc/basic.h
++++ b/ext/multi_critical/scc_mod/include/scc/basic.h
+@@ -1,12 +1,20 @@
+ #pragma once
+ 
+ #include <stdint.h>
++
++#if __has_include("ext_interface/backend_log_flag.hpp")
++#include "ext_interface/backend_log_flag.hpp"
++#endif
+ 
+ namespace scc {
+ 
+   typedef int64_t index;
+ 
++#if __has_include("ext_interface/backend_log_flag.hpp")
++  inline multipers::backend_log_policy::runtime_flag<multipers::backend_log_policy::backend_log_bit::multi_critical> verbose;
++#else
+   bool verbose = false;
++#endif
+ 
+   class ParseError {
+   public: