multipers 2.4.0b1__cp312-cp312-macosx_11_0_arm64.whl

multipers/filtrations.pxd.tp

@@ -0,0 +1,332 @@
+{{py:
+import pickle
+
+with open("build/tmp/_filtration_names.pkl", "rb") as f:
+  Filtrations=pickle.load(f)
+}}
+from libcpp.utility cimport pair
+from libcpp cimport bool
+from libcpp.vector cimport vector
+from libcpp cimport tuple
+from libc.stdint cimport uintptr_t,intptr_t
+from cpython cimport Py_buffer
+from libc.stdint cimport int32_t, int64_t
+
+cdef extern from "gudhi/Persistence_slices_interface.h" namespace "multipers::tmp_interface":
+{{for f in Filtrations}}
+    cdef cppclass {{f["python"]}} "{{f['c']}}":
+        {{f["python"]}}()  except + nogil
+        {{f["python"]}}(int)  except + nogil
+        {{f["python"]}}(int, {{f["c_value_type"]}})  except + nogil
+        {{f["python"]}}(vector[{{f["c_value_type"]}}]&)  except + nogil
+        {{f["python"]}}(vector[{{f["c_value_type"]}}].iterator, vector[{{f["c_value_type"]}}].iterator, int)  except + nogil
+        {{f["python"]}}& operator=(const {{f["python"]}}&) except + nogil
+        {{f["c_value_type"]}}& operator()(size_t, size_t) nogil
+        size_t num_parameters() nogil
+        size_t num_generators() nogil
+        size_t num_entries() nogil
+        void set_num_generators(size_t) nogil
+        @staticmethod
+        {{f["python"]}} inf(int)
+        @staticmethod
+        {{f["python"]}} minus_inf(int)
+        @staticmethod
+        {{f["python"]}} nan(int)
+        bool is_plus_inf() nogil
+        bool is_minus_inf() nogil
+        bool is_nan() nogil
+        bool is_finite() nogil
+        bool add_generator(vector[{{f["c_value_type"]}}] &x) nogil
+        bool add_generator(vector[{{f["c_value_type"]}}] x) nogil
+        void add_guaranteed_generator(vector[{{f["c_value_type"]}}] &x) nogil
+        void simplify() nogil
+        void remove_empty_generators(bool) nogil
+        bool push_to_least_common_upper_bound(vector[{{f["c_value_type"]}}] &, bool) nogil
+        bool push_to_least_common_upper_bound(const {{f["python"]}} &, bool) nogil
+        bool pull_to_greatest_common_lower_bound(vector[{{f["c_value_type"]}}] &, bool) nogil
+{{endfor}}
+
+cdef extern from "gudhi/Persistence_slices_interface.h" namespace "multipers::tmp_interface":
+    cdef cppclass One_critical_filtration[T]:
+        ## Copied from cython vector
+        # ctypedef size_t size_type
+        # ctypedef ptrdiff_t difference_type
+        # ctypedef T value_type
+
+        One_critical_filtration()  except + nogil
+        One_critical_filtration(int)  except + nogil
+        One_critical_filtration(int, T)  except + nogil
+        One_critical_filtration(vector[T]&)  except + nogil
+        One_critical_filtration(vector[T].iterator, vector[T].iterator, int)  except + nogil
+        One_critical_filtration[T]& operator=(const One_critical_filtration[T]&) except + nogil
+        T& operator()(size_t, size_t) nogil
+        size_t num_parameters() nogil
+        size_t num_generators() nogil
+        size_t num_entries() nogil
+        void set_num_generators(size_t) nogil
+        @staticmethod
+        One_critical_filtration inf(int)
+        @staticmethod
+        One_critical_filtration minus_inf(int)
+        @staticmethod
+        One_critical_filtration nan(int)
+        bool is_plus_inf() nogil
+        bool is_minus_inf() nogil
+        bool is_nan() nogil
+        bool is_finite() nogil
+        bool add_generator(vector[T] &x) nogil
+        bool add_generator(vector[T] x) nogil
+        void add_guaranteed_generator(vector[T] &x) nogil
+        void simplify() nogil
+        void remove_empty_generators(bool) nogil
+        bool push_to_least_common_upper_bound(vector[T] &, bool) nogil
+        bool push_to_least_common_upper_bound(const One_critical_filtration &, bool) nogil
+        bool pull_to_greatest_common_lower_bound(vector[T] &, bool) nogil
+        # bool pull_to_greatest_common_lower_bound(const One_critical_filtration &, bool) nogil
+
+cdef extern from "gudhi/Persistence_slices_interface.h" namespace "multipers::tmp_interface":
+    cdef cppclass Multi_critical_filtration[T]:
+        ## Copied from cython vector
+        # ctypedef size_t size_type
+        # ctypedef ptrdiff_t difference_type
+        # ctypedef T value_type
+
+        Multi_critical_filtration()  except + nogil
+        Multi_critical_filtration(int)  except + nogil
+        Multi_critical_filtration(int, T)  except + nogil
+        Multi_critical_filtration(vector[T]&)  except + nogil
+        Multi_critical_filtration(vector[T].iterator, vector[T].iterator, int)  except + nogil
+        Multi_critical_filtration[T]& operator=(const Multi_critical_filtration[T]&) except + nogil
+        T& operator()(size_t, size_t) nogil
+        size_t num_parameters() nogil
+        size_t num_generators() nogil
+        size_t num_entries() nogil
+        void set_num_generators(size_t) nogil
+        @staticmethod
+        Multi_critical_filtration inf(int)
+        @staticmethod
+        Multi_critical_filtration minus_inf(int)
+        @staticmethod
+        Multi_critical_filtration nan(int)
+        bool is_plus_inf() nogil
+        bool is_minus_inf() nogil
+        bool is_nan() nogil
+        bool is_finite() nogil
+        bool add_generator(vector[T] &x) nogil
+        bool add_generator(vector[T] x) nogil
+        void add_guaranteed_generator(vector[T] &x) nogil
+        void simplify() nogil
+        void remove_empty_generators(bool) nogil
+        # "push_to_least_common_upper_bound<std::vector<T>>"
+        bool push_to_least_common_upper_bound(vector[T] &, bool) nogil
+        bool push_to_least_common_upper_bound(const Multi_critical_filtration[T] &, bool) nogil
+        bool pull_to_greatest_common_lower_bound(vector[T] &, bool) nogil
+        # bool pull_to_greatest_common_lower_bound(const Multi_critical_filtration[T] &, bool) nogil
+
+
+cdef extern from "gudhi/Multi_persistence/Point.h" namespace "Gudhi::multi_persistence":
+    cdef cppclass Point[T]:
+        ctypedef size_t size_type
+        ctypedef ptrdiff_t difference_type
+        ctypedef T value_type
+        ctypedef T& reference
+        ctypedef T* pointer
+
+        cppclass const_iterator
+        cppclass iterator:
+            iterator() except +
+            iterator(iterator&) except +
+            value_type& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator++(int)
+            iterator operator--(int)
+            iterator operator+(size_type)
+            iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+            bint operator<(iterator)
+            bint operator<(const_iterator)
+            bint operator>(iterator)
+            bint operator>(const_iterator)
+            bint operator<=(iterator)
+            bint operator<=(const_iterator)
+            bint operator>=(iterator)
+            bint operator>=(const_iterator)
+        cppclass const_iterator:
+            const_iterator() except +
+            const_iterator(iterator&) except +
+            const_iterator(const_iterator&) except +
+            operator=(iterator&) except +
+            const value_type& operator*()
+            const_iterator operator++()
+            const_iterator operator--()
+            const_iterator operator++(int)
+            const_iterator operator--(int)
+            const_iterator operator+(size_type)
+            const_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+            bint operator<(iterator)
+            bint operator<(const_iterator)
+            bint operator>(iterator)
+            bint operator>(const_iterator)
+            bint operator<=(iterator)
+            bint operator<=(const_iterator)
+            bint operator>=(iterator)
+            bint operator>=(const_iterator)
+
+        cppclass const_reverse_iterator
+        cppclass reverse_iterator:
+            reverse_iterator() except +
+            reverse_iterator(reverse_iterator&) except +
+            value_type& operator*()
+            reverse_iterator operator++()
+            reverse_iterator operator--()
+            reverse_iterator operator++(int)
+            reverse_iterator operator--(int)
+            reverse_iterator operator+(size_type)
+            reverse_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator<(const_reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator>(const_reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator<=(const_reverse_iterator)
+            bint operator>=(reverse_iterator)
+            bint operator>=(const_reverse_iterator)
+        cppclass const_reverse_iterator:
+            const_reverse_iterator() except +
+            const_reverse_iterator(reverse_iterator&) except +
+            operator=(reverse_iterator&) except +
+            const value_type& operator*()
+            const_reverse_iterator operator++()
+            const_reverse_iterator operator--()
+            const_reverse_iterator operator++(int)
+            const_reverse_iterator operator--(int)
+            const_reverse_iterator operator+(size_type)
+            const_reverse_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator<(const_reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator>(const_reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator<=(const_reverse_iterator)
+            bint operator>=(reverse_iterator)
+            bint operator>=(const_reverse_iterator)
+
+        Point() except + nogil
+        Point(size_type) except + nogil
+        Point(size_type, const T &) except + nogil
+        Point(const vector[T]&) except + nogil
+        Point& operator=(Point&) except + nogil
+        reference at(size_type) except +
+        reference operator[](size_type)
+        reference front()
+        reference back()
+        pointer data()
+        const value_type* const_data "data"()
+        iterator begin()
+        const_iterator const_begin "begin"()
+        const_iterator cbegin()
+        iterator end()
+        const_iterator const_end "end"()
+        const_iterator cend()
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        const_reverse_iterator crbegin()
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+        const_reverse_iterator crend()
+        size_type size()
+
+    bint operator<(const Point &, const Point &)
+    bint operator<=(const Point &, const Point &)
+    bint operator>(const Point &, const Point &)
+    bint operator>=(const Point &, const Point &)
+    bint operator==(const Point &, const Point &)
+    bint operator!=(const Point &, const Point &)
+    Point operator-(const Point &)
+    Point operator-(Point, const Point &)
+    Point operator-(Point, double)
+    Point operator-(Point, float)
+    Point operator-(Point, int)
+    Point operator-(double, Point)
+    Point operator-(float, Point)
+    Point operator-(int, Point)
+    Point operator+(Point, const Point &)
+    Point operator+(Point, double)
+    Point operator+(Point, float)
+    Point operator+(Point, int)
+    Point operator+(double, Point)
+    Point operator+(float, Point)
+    Point operator+(int, Point)
+    Point operator*(Point, const Point &)
+    Point operator*(Point, double)
+    Point operator*(Point, float)
+    Point operator*(Point, int)
+    Point operator*(double, Point)
+    Point operator*(float, Point)
+    Point operator*(int, Point)
+    Point operator/(Point, const Point &)
+    Point operator/(Point, double)
+    Point operator/(Point, float)
+    Point operator/(Point, int)
+    Point operator/(double, Point)
+    Point operator/(float, Point)
+    Point operator/(int, Point)
+
+cdef extern from "gudhi/Multi_persistence/Box.h" namespace "Gudhi::multi_persistence":
+    cdef cppclass Box[T=*]:
+        ctypedef Point[T] corner_type
+        Box()   except +
+        # Box(corner_type&, corner_type&) nogil 
+        # Box(pair[Point[T], Point[T]]&) nogil 
+        Box(vector[T]&, vector[T]&) nogil 
+        Box(pair[vector[T], vector[T]]&) nogil  
+        void inflate(T)  nogil 
+        # const corner_type& get_lower_corner()  nogil 
+        # const corner_type& get_upper_corner()  nogil 
+        const vector[T]& get_lower_corner()  nogil 
+        const vector[T]& get_upper_corner()  nogil 
+        # bool contains(corner_type&)  nogil
+        bool contains(vector[T]&)  nogil
+        # pair[corner_type, corner_type] get_bounding_corners() nogil
+        pair[vector[T], vector[T]] get_bounding_corners() nogil
+
+cdef extern from "gudhi/Multi_persistence/Line.h" namespace "Gudhi::multi_persistence":
+    cdef cppclass Line[T=*]:
+        ctypedef Point[T] point_type
+        Line()   except + nogil
+        # Line(point_type&)   except + nogil
+        # Line(point_type&, point_type&)   except + nogil
+        Line(vector[T]&)   except + nogil
+        Line(vector[T]&, vector[T]&)   except + nogil
+
+
+
+
+
+# ------ useful types:
+# ctypedef One_critical_filtration[float] Generator
+# ctypedef Multi_critical_filtration[float] kcritical

multipers/function_rips.pyx

@@ -0,0 +1,104 @@
+# 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, tuple
+from typing import Optional,Iterable,Callable
+
+import numpy as np
+cimport numpy as cnp
+cnp.import_array()
+
+ctypedef double value_type 
+python_value_type=np.float64
+
+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
+
+
+from multipers.simplex_tree_multi import _SimplexTreeMulti_Flat_Kf64
+from gudhi.simplex_tree import SimplexTree
+
+cdef extern from "multi_parameter_rank_invariant/function_rips.h" namespace "Gudhi::multiparameter::function_rips":
+	void compute_function_rips_surface_python(const intptr_t, tensor_dtype* , const vector[indices_type], indices_type,indices_type, bool, bool, indices_type) except + nogil
+	signed_measure_type compute_function_rips_signed_measure_python(const intptr_t, tensor_dtype* , const vector[indices_type], indices_type,indices_type, bool, bool, indices_type) except + nogil
+	void get_degree_rips_st_python(const intptr_t,const intptr_t, const vector[int]) except + nogil
+
+
+import multipers.grids as mpg
+
+
+
+def get_degree_rips(st, vector[int] degrees):
+	assert isinstance(st,SimplexTree), "Input has to be a Gudhi simplextree for now."
+	assert st.dimension() == 1, "Simplextree has to be of dimension 1. You can use the `prune_above_dimension` method."
+	degree_rips_st = _SimplexTreeMulti_Flat_Kf64(num_parameters=degrees.size())
+	cdef intptr_t simplextree_ptr = st.thisptr
+	cdef intptr_t st_multi_ptr = degree_rips_st.thisptr
+	with nogil:
+		get_degree_rips_st_python(simplextree_ptr, st_multi_ptr, degrees)
+	return degree_rips_st
+	# cdef int max_degree = out.second
+	# cdef bool inf_flag = filtrations[-1] == np.inf
+	# if inf_flag:
+	# 	filtrations = filtrations[:-1]
+	# filtrations, = mpg.compute_grid([filtrations],strategy=grid_strategy,resolution=resolution)
+	# if inf_flag:
+	# 	filtrations = np.concatenate([filtrations, [np.inf]])
+	# degree_rips_st.grid_squeeze([filtrations, degrees], inplace=True, coordinate_values=True)
+	# degree_rips_st.filtration_grid = mpg.sanitize_grid([filtrations, np.asarray(degrees)])
+	# # degree_rips_st._is_function_simplextree=True
+	# return degree_rips_st,max_degree
+
+def function_rips_surface(st_multi, vector[indices_type] homological_degrees, bool mobius_inversion=True, bool zero_pad=False, indices_type n_jobs=0):
+	assert st_multi.is_squeezed, "Squeeze first !"
+	cdef intptr_t st_multi_ptr = st_multi.thisptr
+	cdef indices_type I = len(st_multi.filtration_grid[0])
+	cdef indices_type J = st_multi.num_parameters
+	container_shape = (homological_degrees.size(),I,J)
+	container_array = np.ascontiguousarray(np.zeros(container_shape, dtype=python_tensor_dtype).flatten())
+	assert len(container_array) < np.iinfo(np.uint32).max, "Too large container. Raise an issue on github if you encounter this issue. (Due to tensor's operator[])"
+	cdef tensor_dtype[::1] container = container_array
+	cdef tensor_dtype* container_ptr = &container[0]
+	with nogil:
+		compute_function_rips_surface_python(st_multi_ptr,container_ptr, homological_degrees, I,J, mobius_inversion, zero_pad, n_jobs)
+	filtration_grid = st_multi.filtration_grid
+	if filtration_grid[0][-1] == np.inf:
+		filtration_grid[0][-1] = filtration_grid[0][-2]
+	return filtration_grid, container_array.reshape(container_shape)
+
+
+
+def function_rips_signed_measure(st_multi, vector[indices_type] homological_degrees, bool mobius_inversion=True, bool zero_pad=False, indices_type n_jobs=0, bool reconvert = True):
+	assert st_multi.is_squeezed
+	cdef intptr_t st_multi_ptr = st_multi.thisptr
+	cdef indices_type I = len(st_multi.filtration_grid[0])
+	cdef indices_type J = st_multi.num_parameters
+	container_shape = (homological_degrees.size(),I,J)
+	container_array = np.ascontiguousarray(np.zeros(container_shape, dtype=python_tensor_dtype).flatten())
+	assert len(container_array) < np.iinfo(np.uint32).max, "Too large container. Raise an issue on github if you encounter this issue. (Due to tensor's operator[])"
+	cdef tensor_dtype[::1] container = container_array
+	cdef tensor_dtype* container_ptr = &container[0]
+	cdef signed_measure_type out 
+	# TODO nogil
+	with nogil:
+		out = compute_function_rips_signed_measure_python(st_multi_ptr,container_ptr, homological_degrees, I,J, mobius_inversion, zero_pad, n_jobs)
+	pts, weights = np.asarray(out.first, dtype=int).reshape(-1, 3), np.asarray(out.second, dtype=int)
+
+	degree_indices = [np.argwhere(pts[:,0] == degree_index).flatten() for degree_index, degree in enumerate(homological_degrees)] ## TODO : maybe optimize
+	sms = [(pts[id,1:],weights[id]) for id in degree_indices]
+	if not reconvert: return sms
+
+	grid_conversion = st_multi.filtration_grid
+	for degree_index,(pts,weights) in enumerate(sms):
+		coords = np.empty(shape=pts.shape, dtype=float)
+		for i in range(coords.shape[1]):
+			coords[:,i] = np.asarray(grid_conversion[i])[pts[:,i]]
+		sms[degree_index]=(coords, weights)
+	
+	return sms