multipers 1.1.3__cp311-cp311-macosx_11_0_universal2.whl

multipers/point_measure_integration.pyx

@@ -0,0 +1,59 @@
+# cimport multipers.tensor as mt
+from libc.stdint cimport intptr_t, uint16_t, uint32_t, int32_t, int64_t
+from libcpp.vector cimport vector
+from libcpp cimport bool, int, float
+import numpy as np
+cimport numpy as cnp
+cnp.import_array()
+
+ctypedef fused some_int:
+	int32_t
+	int64_t
+	int
+
+ctypedef fused some_float:
+	float
+	double
+
+
+## TODO : optimize. The filtrations is a list of filtrations, but thats not easily convertible to a cython type without copies
+import cython
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def integrate_measure(
+	some_float[:,:] pts, 
+	some_int[:] weights, 
+	filtrations
+):
+	resolution = np.asarray([len(f) for f in filtrations])
+	cdef int num_pts = pts.shape[0]
+	cdef int num_parameters = pts.shape[1]
+	assert weights.shape[0] == num_pts
+	out = np.zeros(shape=resolution, dtype=np.int32) ## dim cannot be known at compiletime
+	# cdef some_float[:] filtration_of_parameter
+	# cdef cnp.ndarray indices = np.zeros(shape=num_parameters, dtype=int)
+	for i in range(num_pts): ## this is slow...
+		# for parameter in range(num_parameters):
+		# 	indices[parameter] = np.asarray(filtrations[parameter]) >= pts[i,parameter]
+		indices = (
+			# np.asarray(
+			# 	<some_float[:]>(&filtrations[parameter][0])
+			# 	) ## I'm not sure why it doesn't work
+			np.asarray(filtrations[parameter])
+			>=
+			pts[i,parameter] for parameter in range(num_parameters)
+		) ## iterator so that below there is no copy
+
+		out[np.ix_(*indices)] += weights[i] # This is slow...
+	return out
+
+## for benchmark purposes
+def integrate_measure_python(pts, weights, filtrations):
+	resolution = tuple([len(f) for f in filtrations])
+	out = np.zeros(shape=resolution, dtype=pts.dtype)
+	num_pts = pts.shape[0]
+	num_parameters = pts.shape[1]
+	for i in range(num_pts): #this is slow.
+		indices = (filtrations[parameter]>=pts[i][parameter] for parameter in range(num_parameters))
+		out[np.ix_(*indices)] += weights[i]
+	return out

multipers/rank_invariant.pyx

@@ -0,0 +1,154 @@
+# cimport multipers.tensor as mt
+from libc.stdint cimport intptr_t, uint16_t, uint32_t, int32_t
+from libcpp.vector cimport vector
+from libcpp cimport bool, int, float
+from libcpp.utility cimport pair
+from typing import Optional,Iterable,Callable
+
+import numpy as np
+cimport numpy as cnp
+cnp.import_array()
+
+ctypedef float value_type 
+python_value_type=np.float32
+
+ctypedef int32_t indices_type # uint fails for some reason
+python_indices_type=np.int32
+
+ctypedef int32_t tensor_dtype
+python_tensor_dtype = np.int32
+
+
+ctypedef pair[vector[vector[indices_type]], vector[tensor_dtype]] signed_measure_type
+
+cdef extern from "multi_parameter_rank_invariant/rank_invariant.h" namespace "Gudhi::multiparameter::rank_invariant":
+	void compute_rank_invariant_python(const intptr_t, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool) except + nogil
+	
+
+def rank_invariant(simplextree, vector[indices_type] degrees, mass_default=None, plot=False, indices_type n_jobs=0, bool verbose=False, bool expand_collapse=False):
+	"""
+	Computes the signed measures given by the decomposition of the hilbert function.
+
+	Input
+	-----
+	 - simplextree:SimplexTreeMulti, the multifiltered simplicial complex
+	 - degrees:array-like of ints, the degrees to compute
+	 - mass_default: Either None, or 'auto' or 'inf', or array-like of floats. Where to put the default mass to get a zero-mass measure.
+	 - plot:bool, plots the computed measures if true.
+	 - n_jobs:int, number of jobs. Defaults to #cpu, but when doing parallel computations of signed measures, we recommend setting this to 1.
+	 - verbose:bool, prints c++ logs.
+	
+	Output
+	------
+	`[signed_measure_of_degree for degree in degrees]`
+	with `signed_measure_of_degree` of the form `(dirac location, dirac weights)`.
+	"""
+	assert simplextree._is_squeezed, "Squeeze grid first."
+	cdef bool zero_pad = mass_default is not None
+	grid_conversion = [np.asarray(f) for f in simplextree.filtration_grid]
+	# assert simplextree.num_parameters == 2
+	grid_shape = np.array([len(f) for f in grid_conversion])
+	
+	if mass_default is None:
+		mass_default = mass_default
+	else:
+		mass_default = np.asarray(mass_default)
+		assert mass_default.ndim == 1 and mass_default.shape[0] == simplextree.num_parameters
+	if zero_pad:
+		for i, _ in enumerate(grid_shape):
+			grid_shape[i] += 1 # adds a 0
+		for i,f in enumerate(grid_conversion):
+			grid_conversion[i] = np.concatenate([f, [mass_default[i]]])
+		
+	assert len(grid_shape) == simplextree.num_parameters, "Grid shape size has to be the number of parameters."
+	grid_shape_with_degree = np.asarray(np.concatenate([[len(degrees)], grid_shape, grid_shape]), dtype=python_indices_type)
+	container_array = np.ascontiguousarray(np.zeros(grid_shape_with_degree, dtype=python_tensor_dtype).flatten())
+	assert len(container_array) < np.iinfo(python_indices_type).max, "Too large container. Raise an issue on github if you encounter this issue. (Due to tensor's operator[])"
+	cdef intptr_t simplextree_ptr = simplextree.thisptr
+	cdef vector[indices_type] c_grid_shape = grid_shape_with_degree
+	cdef tensor_dtype[::1] container = container_array
+	cdef tensor_dtype* container_ptr = &container[0]
+	with nogil:
+		compute_rank_invariant_python(simplextree_ptr, container_ptr,c_grid_shape,degrees, n_jobs, expand_collapse)
+	container_array = container_array.reshape(grid_shape_with_degree)
+	if plot:
+		from multipers.plots import plot_surfaces
+		plot_surfaces((grid_conversion, container_array))
+	return (grid_conversion, container_array)
+
+
+def signed_measure(simplextree, vector[indices_type] degrees, mass_default=None, plot=False, indices_type n_jobs=0, bool verbose=False, bool expand_collapse=False):
+	"""
+	Computes the signed measures given by the decomposition of the hilbert function.
+
+	Input
+	-----
+	 - simplextree:SimplexTreeMulti, the multifiltered simplicial complex
+	 - degrees:array-like of ints, the degrees to compute
+	 - mass_default: Either None, or 'auto' or 'inf', or array-like of floats. Where to put the default mass to get a zero-mass measure.
+	 - plot:bool, plots the computed measures if true.
+	 - n_jobs:int, number of jobs. Defaults to #cpu, but when doing parallel computations of signed measures, we recommend setting this to 1.
+	 - verbose:bool, prints c++ logs.
+	
+	Output
+	------
+	`[signed_measure_of_degree for degree in degrees]`
+	with `signed_measure_of_degree` of the form `(dirac location, dirac weights)`.
+	"""
+	assert simplextree._is_squeezed > 0, "Squeeze grid first."
+	cdef bool zero_pad = mass_default is not None
+	grid_conversion = [np.asarray(f) for f in simplextree.filtration_grid]
+	# assert simplextree.num_parameters == 2
+	grid_shape = np.array([len(f) for f in grid_conversion])
+	
+	if mass_default is None:
+		mass_default = mass_default
+	else:
+		mass_default = np.asarray(mass_default)
+		assert mass_default.ndim == 1 and mass_default.shape[0] == simplextree.num_parameters, "Mass default has to be an array like of shape (num_parameters,)"
+	if zero_pad:
+		for i, _ in enumerate(grid_shape):
+			grid_shape[i] += 1 # adds a 0
+		for i,f in enumerate(grid_conversion):
+			grid_conversion[i] = np.concatenate([f, [mass_default[i]]])
+		
+	assert len(grid_shape) == simplextree.num_parameters, "Grid shape size has to be the number of parameters."
+	grid_shape_with_degree = np.asarray(np.concatenate([[len(degrees)], grid_shape, grid_shape]), dtype=python_indices_type)
+	container_array = np.ascontiguousarray(np.zeros(grid_shape_with_degree, dtype=python_tensor_dtype).flatten())
+	assert len(container_array) < np.iinfo(python_indices_type).max, "Too large container. Raise an issue on github if you encounter this issue. (Due to tensor's operator[])"
+	cdef intptr_t simplextree_ptr = simplextree.thisptr
+	cdef vector[indices_type] c_grid_shape = grid_shape_with_degree
+	cdef tensor_dtype[::1] container = container_array
+	cdef tensor_dtype* container_ptr = &container[0]
+	with nogil:
+		compute_rank_invariant_python(simplextree_ptr, container_ptr,c_grid_shape,degrees, n_jobs, expand_collapse)
+	rank = container_array.reshape(grid_shape_with_degree)
+	from multipers.ml.signed_betti import rank_decomposition_by_rectangles
+	from torch import Tensor
+	rank = [rank_decomposition_by_rectangles(rank_of_degree) for rank_of_degree in rank]
+	out = []
+	cdef int num_parameters = simplextree.num_parameters
+	for rank_decomposition in rank:
+		rank_decomposition = Tensor(np.ascontiguousarray(rank_decomposition)).to_sparse()
+		def _is_trivial(rectangle:np.ndarray):
+			birth=rectangle[:num_parameters]
+			death=rectangle[num_parameters:]
+			return np.all(birth<=death) and not np.array_equal(birth,death)
+		coords = np.asarray(rank_decomposition.indices().T, dtype=int)
+		weights = np.asarray(rank_decomposition.values(), dtype=int)
+		correct_indices = np.asarray([_is_trivial(rectangle) for rectangle in coords])
+		coords = coords[correct_indices]
+		weights = weights[correct_indices]
+		if len(correct_indices) == 0:
+			pts, weights = np.empty((0, 2*num_parameters)), np.empty((0))
+		else:
+			pts = np.empty(shape=coords.shape, dtype=grid_conversion[0].dtype)
+			for i in range(pts.shape[1]):
+				pts[:,i] = grid_conversion[i % num_parameters][coords[:,i]]
+		rank_decomposition = (pts,weights)
+		out.append(rank_decomposition)
+	
+	if plot:
+		from multipers.plots import plot_signed_measures
+		plot_signed_measures(out)
+	return out

multipers/simplex_tree_multi.pxd

@@ -0,0 +1,121 @@
+# This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+# See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+# Author(s):       Vincent Rouvreau
+#
+# Copyright (C) 2016 Inria
+#
+# Modification(s):
+#	- 2022 David Loiseaux, Hannah Schreiber: adapt for multipersistence. 
+#   - YYYY/MM Author: Description of the modification
+
+from cython cimport numeric
+from libcpp.vector cimport vector
+from libcpp.utility cimport pair
+from libcpp cimport bool
+from libcpp.string cimport string
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+ctypedef int dimension_type
+ctypedef float value_type
+ctypedef Finitely_critical_multi_filtration filtration_type
+ctypedef vector[value_type] python_filtration_type ## TODO: move constructor for C++ filtration type ?
+ctypedef vector[int] simplex_type
+ctypedef vector[simplex_type] simplex_list
+ctypedef vector[pair[pair[int,int], pair[double, double]]] edge_list
+ctypedef vector[int] euler_char_list
+ctypedef pair[simplex_type, value_type*] simplex_filtration_type
+
+
+
+cdef extern from "gudhi/Simplex_tree/multi_filtrations/Finitely_critical_filtrations.h" namespace "Gudhi::multiparameter::multi_filtrations":
+	cdef cppclass Finitely_critical_multi_filtration "Gudhi::multiparameter::multi_filtrations::Finitely_critical_multi_filtration<Gudhi::multiparameter::Simplex_tree_options_multidimensional_filtration::value_type>":
+		Finitely_critical_multi_filtration()  except + nogil
+		Finitely_critical_multi_filtration(vector[value_type]) except +
+		Finitely_critical_multi_filtration& operator=(const Finitely_critical_multi_filtration&)
+		filtration_type& get_vector()  nogil
+		int size() nogil
+		void push_back(const value_type&) nogil
+		void clear() nogil
+		value_type& operator[](int)
+		
+
+
+cdef extern from "Simplex_tree_multi_interface.h" namespace "Gudhi::multiparameter":
+	cdef cppclass Simplex_tree_options_multidimensional_filtration:
+		pass
+
+	cdef cppclass Simplex_tree_multi_simplex_handle "Gudhi::multiparameter::Simplex_tree_multi_interface<Gudhi::multiparameter::Simplex_tree_options_multidimensional_filtration>::Simplex_handle":
+		pass
+
+	cdef cppclass Simplex_tree_multi_simplices_iterator "Gudhi::multiparameter::Simplex_tree_multi_interface<Gudhi::multiparameter::Simplex_tree_options_multidimensional_filtration>::Complex_simplex_iterator":
+		Simplex_tree_multi_simplices_iterator() nogil
+		Simplex_tree_multi_simplex_handle& operator*() nogil
+		Simplex_tree_multi_simplices_iterator operator++() nogil
+		bint operator!=(Simplex_tree_multi_simplices_iterator) nogil
+
+	cdef cppclass Simplex_tree_multi_skeleton_iterator "Gudhi::multiparameter::Simplex_tree_multi_interface<Gudhi::multiparameter::Simplex_tree_options_multidimensional_filtration>::Skeleton_simplex_iterator":
+		Simplex_tree_multi_skeleton_iterator() nogil
+		Simplex_tree_multi_simplex_handle& operator*() nogil
+		Simplex_tree_multi_skeleton_iterator operator++() nogil
+		bint operator!=(Simplex_tree_multi_skeleton_iterator) nogil
+
+	cdef cppclass Simplex_tree_multi_boundary_iterator "Gudhi::multiparameter::Simplex_tree_multi_interface<Gudhi::multiparameter::Simplex_tree_options_multidimensional_filtration>::Boundary_simplex_iterator":
+		Simplex_tree_multi_boundary_iterator() nogil
+		Simplex_tree_multi_simplex_handle& operator*() nogil
+		Simplex_tree_multi_boundary_iterator operator++() nogil
+		bint operator!=(Simplex_tree_multi_boundary_iterator) nogil
+
+
+	cdef cppclass Simplex_tree_multi_interface "Gudhi::multiparameter::Simplex_tree_multi_interface<Gudhi::multiparameter::Simplex_tree_options_multidimensional_filtration>":
+		Simplex_tree_multi_interface() nogil
+		Simplex_tree_multi_interface(Simplex_tree_multi_interface&) nogil
+		value_type* simplex_filtration(const vector[int]& simplex) nogil
+		void assign_simplex_filtration(vector[int]& simplex, const filtration_type& filtration) noexcept nogil
+		void initialize_filtration() nogil
+		int num_vertices() nogil
+		int num_simplices() nogil
+		void set_dimension(int dimension) nogil
+		dimension_type dimension() nogil
+		dimension_type upper_bound_dimension() nogil
+		bool find_simplex(vector[int]& simplex) nogil
+		bool insert(vector[int]& simplex, filtration_type& filtration) noexcept nogil
+		vector[simplex_filtration_type] get_star(const vector[int]& simplex) nogil
+		vector[simplex_filtration_type] get_cofaces(const vector[int]& simplex, int dimension) nogil
+		void expansion(int max_dim)  except + nogil
+		void remove_maximal_simplex(simplex_type simplex) nogil
+		# bool prune_above_filtration(filtration_type filtration) nogil
+		bool prune_above_dimension(int dimension) nogil
+		bool make_filtration_non_decreasing()  except + nogil
+		# void compute_extended_filtration() nogil
+		# Simplex_tree_multi_interface* collapse_edges(int nb_collapse_iteration)  except + nogil
+		void reset_filtration(const filtration_type& filtration, int dimension) nogil
+		bint operator==(Simplex_tree_multi_interface) nogil
+		# Iterators over Simplex tree
+		simplex_filtration_type get_simplex_and_filtration(Simplex_tree_multi_simplex_handle f_simplex) nogil
+		Simplex_tree_multi_simplices_iterator get_simplices_iterator_begin() nogil
+		Simplex_tree_multi_simplices_iterator get_simplices_iterator_end() nogil
+		vector[Simplex_tree_multi_simplex_handle].const_iterator get_filtration_iterator_begin() nogil
+		vector[Simplex_tree_multi_simplex_handle].const_iterator get_filtration_iterator_end() nogil
+		Simplex_tree_multi_skeleton_iterator get_skeleton_iterator_begin(int dimension) nogil
+		Simplex_tree_multi_skeleton_iterator get_skeleton_iterator_end(int dimension) nogil
+		pair[Simplex_tree_multi_boundary_iterator, Simplex_tree_multi_boundary_iterator] get_boundary_iterators(vector[int] simplex)  except + nogil
+		# Expansion with blockers
+		ctypedef bool (*blocker_func_t)(vector[int], void *user_data)
+		void expansion_with_blockers_callback(int dimension, blocker_func_t user_func, void *user_data)
+
+		## MULTIPERS STUFF
+		void set_keys_to_enumerate() nogil const
+		int get_key(const simplex_type) nogil
+		void set_key(simplex_type, int) nogil
+		void fill_lowerstar(const vector[value_type]&, int) nogil
+		simplex_list get_simplices_of_dimension(int) nogil
+		edge_list get_edge_list() nogil
+		# euler_char_list euler_char(const vector[filtration_type]&) nogil
+		void resize_all_filtrations(int) nogil
+		void set_number_of_parameters(int) nogil
+		int get_number_of_parameters() nogil
+
+