multipers 1.0__cp311-cp311-manylinux_2_34_x86_64.whl

multipers/pickle.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+def save_with_axis(path:str, signed_measures):
+	np.savez(path, 
+		**{f"{i}_{axis}_{degree}":np.c_[sm_of_degree[0],sm_of_degree[1][:,np.newaxis]] for i,sm in enumerate(signed_measures) for axis,sm_of_axis in enumerate(sm) for degree,sm_of_degree in enumerate(sm_of_axis)},
+	)
+
+def save_without_axis(path:str, signed_measures):
+    np.savez(path, 
+        **{f"{i}_{degree}":np.c_[sm_of_degree[0],sm_of_degree[1][:,np.newaxis]] for i,sm in enumerate(signed_measures) for degree,sm_of_degree in enumerate(sm)},
+    )
+
+def get_sm_with_axis(sms,idx,axis,degree):
+    sm = sms[f"{idx}_{axis}_{degree}"]
+    return (sm[:,:-1],sm[:,-1])
+def get_sm_without_axis(sms,idx,degree):
+    sm = sms[f"{idx}_{degree}"]
+    return (sm[:,:-1],sm[:,-1])
+
+
+def load_without_axis(sms):
+	indices = np.array([[int(i) for i in key.split('_')] for key in sms.keys()], dtype=int)
+	num_data,num_degrees = indices.max(axis=0)+1
+	signed_measures_reconstructed = [[get_sm_without_axis(sms,idx,degree) for degree in range(num_degrees)] for idx in range(num_data)]
+	return signed_measures_reconstructed
+# test : np.all([np.array_equal(a[0],b[0]) and np.array_equal(a[1],b[1]) and len(a) == len(b) == 2 for x,y in zip(signed_measures_reconstructed,signed_measures_reconstructed) for a,b in zip(x,y)])
+
+def load_with_axis(sms):
+	indices = np.array([[int(i) for i in key.split('_')] for key in sms.keys()], dtype=int)
+	num_data,num_axis,num_degrees = indices.max(axis=0)+1
+	signed_measures_reconstructed = [[[get_sm_with_axis(sms,idx,axis,degree) for degree in range(num_degrees)] for axis in range(num_axis)] for idx in range(num_data)]
+	return signed_measures_reconstructed
+
+def save(path:str, signed_measures):
+	if isinstance(signed_measures[0][0], tuple):
+		save_without_axis(path=path,signed_measures=signed_measures)
+	else:
+		save_with_axis(path=path,signed_measures=signed_measures)
+
+def load(path:str):
+	sms = np.load(path)
+	item=None
+	for i in sms.keys():
+		item=i
+		break
+	n = len(item.split('_'))
+	match n:
+		case 2:
+			return load_without_axis(sms)
+		case 3:
+			return load_with_axis(sms)
+		case _:
+			raise Exception("Invalid Signed Measure !")

multipers/plots.py

@@ -0,0 +1,207 @@
+import matplotlib.pyplot as plt
+import matplotlib
+import numpy as np
+
+def _plot_rectangle(rectangle:np.ndarray, weight, **plt_kwargs):
+	rectangle = np.asarray(rectangle)
+	x_axis=rectangle[[0,2]]
+	y_axis=rectangle[[1,3]]
+	color = "blue" if weight > 0 else "red"
+	plt.plot(x_axis, y_axis, c=color, **plt_kwargs)
+
+
+def _plot_signed_measure_2(pts, weights,temp_alpha=.7, **plt_kwargs):
+	import matplotlib.colors
+	weights = np.asarray(weights)
+	color_weights = np.array(weights, dtype=float)
+	neg_idx = weights<0
+	pos_idx = weights>0
+	if np.any(neg_idx):
+		current_weights = -weights[neg_idx]
+		min_weight = np.max(current_weights)
+		color_weights[neg_idx] /= min_weight
+		color_weights[neg_idx] -= 1
+	else:
+		min_weight=0
+
+	if np.any(pos_idx):
+		current_weights = weights[pos_idx]
+		max_weight = np.max(current_weights)
+		color_weights[pos_idx] /= max_weight
+		color_weights[pos_idx] += 1
+	else:
+		max_weight=1
+
+	bordeaux = np.array([0.70567316, 0.01555616, 0.15023281, 1        ])
+	light_bordeaux = np.array([0.70567316, 0.01555616, 0.15023281, temp_alpha        ])
+	bleu = np.array([0.2298057 , 0.29871797, 0.75368315, 1        ])
+	light_bleu = np.array([0.2298057 , 0.29871797, 0.75368315, temp_alpha       ])
+	norm = plt.Normalize(-2,2)
+	cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", [bordeaux,light_bordeaux,"white",light_bleu,bleu])
+	plt.scatter(pts[:,0],pts[:,1], c=color_weights, cmap=cmap, norm=norm, **plt_kwargs)
+	plt.scatter([],[],color=bleu,label="positive mass", **plt_kwargs)
+	plt.scatter([],[],color=bordeaux,label="negative mass", **plt_kwargs)
+	plt.legend()
+
+def _plot_signed_measure_4(pts, weights, x_smoothing:float=1, area_alpha:bool=True):
+    # compute the maximal rectangle area
+	alpha_rescaling = 0;
+	for rectangle, weight in zip(pts, weights):
+		if rectangle[2] > x_smoothing*rectangle[0]:
+			alpha_rescaling = max(alpha_rescaling, (rectangle[2]/x_smoothing-rectangle[0])*(rectangle[3]-rectangle[1]))
+	# draw the rectangles
+	for rectangle, weight in zip(pts, weights):
+		# draw only the rectangles that have not been reduced to the empty set
+		if rectangle[2] > x_smoothing*rectangle[0]:
+			# make the alpha channel proportional to the rectangle's area
+			if area_alpha:
+				_plot_rectangle(rectangle=[rectangle[0], rectangle[1], rectangle[2]/x_smoothing, rectangle[3]], weight=weight, alpha=(rectangle[2]/x_smoothing-rectangle[0])*(rectangle[3]-rectangle[1])/alpha_rescaling)
+			else:
+				_plot_rectangle(rectangle=[rectangle[0], rectangle[1], rectangle[2]/x_smoothing, rectangle[3]], weight=weight, alpha=1)
+
+def plot_signed_measure(signed_measure, ax=None, **plt_kwargs):
+	if ax is None:
+		ax = plt.gca()
+	else:
+		plt.sca(ax)
+	pts, weights = signed_measure
+	num_parameters = pts.shape[1]
+
+	if isinstance(pts,np.ndarray):
+		pass
+	else:
+		import torch
+		if isinstance(pts,torch.Tensor):
+			pts = pts.detach().numpy()
+		else:
+			raise Exception("Invalid measure type.")
+
+	assert num_parameters in (2,4)
+	if num_parameters == 2:
+		_plot_signed_measure_2(pts=pts,weights=weights, **plt_kwargs)
+	else:
+		_plot_signed_measure_4(pts=pts,weights=weights, **plt_kwargs)
+
+def plot_signed_measures(signed_measures, size=4):
+	num_degrees = len(signed_measures)
+	fig, axes = plt.subplots(nrows=1,ncols=num_degrees, figsize=(num_degrees*size,size))
+	if num_degrees == 1:
+		axes = [axes]
+	for ax, signed_measure in zip(axes,signed_measures):
+		plot_signed_measure(signed_measure=signed_measure,ax=ax)
+	plt.tight_layout()
+
+
+def plot_surface(grid, hf, fig=None, ax=None,cmap=None, **plt_args):
+	import matplotlib
+	if ax is None:
+		ax = plt.gca()
+	else:
+		plt.sca(ax)
+	if hf.ndim == 3 and hf.shape[0] == 1: hf=hf[0]
+	assert hf.ndim == 2, "Can only plot a 2d surface"
+	fig = plt.gcf() if fig is None else fig
+	cmap = matplotlib.colormaps["gray_r"] if cmap is None else matplotlib.colormaps[cmap]
+	bounds = np.arange(0,11,1, dtype=int)
+	norm = matplotlib.colors.BoundaryNorm(bounds, cmap.N, extend='max')
+	im = ax.pcolormesh(grid[0], grid[1], hf.T,cmap=cmap,norm=norm, **plt_args)
+	cbar=fig.colorbar(matplotlib.cm.ScalarMappable(cmap=cmap, norm=norm), spacing="proportional", ax=ax)
+	cbar.set_ticks(ticks=bounds, labels=bounds)
+
+def plot_surfaces(HF, size=4, **plt_args):
+	grid, hf = HF
+	assert hf.ndim == 3, f"Found hf.shape = {hf.shape}, expected ndim = 3 : degree, 2-parameter surface."
+	num_degrees = hf.shape[0]
+	fig, axes = plt.subplots(nrows=1,ncols=num_degrees, figsize=(num_degrees*size,size))
+	if num_degrees == 1:
+		axes = [axes]
+	for ax, hf_of_degree in zip(axes,hf):
+		plot_surface(grid=grid,hf=hf_of_degree, fig=fig,ax=ax,**plt_args)
+	plt.tight_layout()
+
+
+
+
+
+
+
+
+
+def _rectangle(x,y,color, alpha):
+	"""
+	Defines a rectangle patch in the format {z | x  ≤ z ≤ y} with color and alpha
+	"""
+	from matplotlib.patches import Rectangle as RectanglePatch
+	return RectanglePatch(x, max(y[0]-x[0],0),max(y[1]-x[1],0), color=color, alpha=alpha)
+
+def _d_inf(a,b):
+	if type(a) != np.ndarray or type(b) != np.ndarray:
+		a = np.array(a)
+		b = np.array(b)
+	return np.min(np.abs(b-a))
+
+
+
+def plot2d_PyModule(corners, box = [],*,dimension=-1, separated=False, min_persistence = 0, alpha=1, verbose = False, save=False, dpi=200, shapely = True, xlabel=None, ylabel=None, cmap=None):
+	import matplotlib
+	try:
+		from shapely.geometry import Polygon as _Polygon
+		from shapely.geometry import box as _rectangle_box
+		from shapely import union_all
+		shapely=True and shapely
+	except:
+		from warnings import warn
+		shapely=False
+		warn("Shapely not installed. Fallbacking to matplotlib. The plots may be inacurate.")
+	cmap = matplotlib.colormaps["Spectral"] if cmap is None else matplotlib.colormaps[cmap]
+	if not(separated):
+		# fig, ax = plt.subplots()
+		ax = plt.gca()
+		ax.set(xlim=[box[0][0],box[1][0]],ylim=[box[0][1],box[1][1]])
+	n_summands = len(corners)
+	for i in range(n_summands):
+		trivial_summand = True
+		list_of_rect = []
+		for birth in corners[i][0]:
+			for death in corners[i][1]:
+				death[0] = min(death[0],box[1][0])
+				death[1] = min(death[1],box[1][1])
+				if death[1]>birth[1] and death[0]>birth[0]:
+					if trivial_summand and _d_inf(birth,death)>min_persistence:
+						trivial_summand = False
+					if shapely:
+						list_of_rect.append(_rectangle_box(birth[0], birth[1], death[0],death[1]))
+					else:
+						list_of_rect.append(_rectangle(birth,death,cmap(i/n_summands),alpha))
+		if not(trivial_summand):	
+			if separated:
+				fig,ax= plt.subplots()
+				ax.set(xlim=[box[0][0],box[1][0]],ylim=[box[0][1],box[1][1]])
+			if shapely:
+				summand_shape = union_all(list_of_rect)
+				if type(summand_shape) is _Polygon:
+					xs,ys=summand_shape.exterior.xy
+					ax.fill(xs,ys,alpha=alpha, fc=cmap(i/n_summands), ec='None')
+				else:
+					for polygon in summand_shape.geoms:
+						xs,ys=polygon.exterior.xy
+						ax.fill(xs,ys,alpha=alpha, fc=cmap(i/n_summands), ec='None')
+			else:
+				for rectangle in list_of_rect:
+					ax.add_patch(rectangle)
+			if separated:
+				if xlabel:
+					plt.xlabel(xlabel)
+				if ylabel:
+					plt.ylabel(ylabel)
+				if dimension>=0:
+					plt.title(rf"$H_{dimension}$ $2$-persistence")
+	if not(separated):
+		if xlabel != None:
+			plt.xlabel(xlabel)
+		if ylabel != None:
+			plt.ylabel(ylabel)
+		if dimension>=0:
+			plt.title(rf"$H_{dimension}$ $2$-persistence")
+	return
+

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
+
+