multipers 1.1.3__cp310-cp310-macosx_11_0_universal2.whl

multipers/data/synthetic.py

@@ -0,0 +1,68 @@
+import numpy as np
+def noisy_annulus(n1:int=1000,n2:int=200, r1:float=1, r2:float=2, dim:int=2, center:np.ndarray|list|None=None, **kwargs)->np.ndarray:
+	"""Generates a noisy annulus dataset.
+
+	Parameters
+	----------
+	r1 : float.
+		Lower radius of the annulus.
+	r2 : float.
+		Upper radius of the annulus.
+	n1 : int
+		Number of points in the annulus.
+	n2 : int
+		Number of points in the square.
+	dim : int
+		Dimension of the annulus.
+	center: list or array
+		center of the annulus.
+
+	Returns
+	-------
+	numpy array
+		Dataset. size : (n1+n2) x dim
+
+	"""
+	from numpy.random import uniform
+	from numpy.linalg import norm
+
+	set =[]
+	while len(set)<n1:
+		draw=uniform(low=-r2, high=r2, size=dim)
+		if norm(draw) > r1 and norm(draw) < r2:
+			set.append(draw)
+	annulus = np.array(set) if center == None else np.array(set) + np.array(center)
+	diffuse_noise = uniform(size=(n2,dim), low=-1.1*r2,high=1.1*r2)
+	if center is not None:	diffuse_noise += np.array(center)
+	return np.vstack([annulus, diffuse_noise])
+
+
+def three_annulus(num_pts:int=500,num_outliers:int=500):
+	X = np.block([
+		[np.random.uniform(low=-2,high=2,size=(num_outliers,2))],
+		[np.array(noisy_annulus(r1=0.6,r2=0.9,n1=(int)(num_pts*1/3), n2=0, center = [1,-0.2]))],
+		[np.array(noisy_annulus(r1=0.4,r2=0.55,n1=(int)(num_pts*1/3), n2=0, center = [-1.2,-1]))],
+		[np.array(noisy_annulus(r1=0.3,r2=0.4,n1=(int)(num_pts*1/3), n2=0, center = [-0.7,1.1]))],
+	])
+	return X
+
+def orbit(n:int=1000, r:float=1., x0=[]):
+	point_list=[]
+	if len(x0) != 2:
+		x,y=np.random.uniform(size=2)
+	else:
+		x,y = x0
+	point_list.append([x,y])
+	for _ in range(n-1):
+		x = (x + r*y*(1-y)) %1
+		y = (y + r*x*(1-x)) %1
+		point_list.append([x,y])
+	return np.asarray(point_list, dtype=float)
+
+def get_orbit5k(num_pts = 1000,  num_data=5000):
+	from sklearn.preprocessing import LabelEncoder
+	rs = [2.5, 3.5, 4, 4.1, 4.3]
+	labels = np.random.choice(rs, size=num_data, replace=True)
+	X = [orbit(n=num_pts, r=r) for r in labels]
+	labels = LabelEncoder().fit_transform(labels)
+	return X, labels

multipers/distances.py

@@ -0,0 +1,172 @@
+import torch
+import ot
+import numpy as np
+from multipers.simplex_tree_multi import SimplexTreeMulti
+from multipers.multiparameter_module_approximation import PyModule
+from multipers.mma_structures import PyMultiDiagrams
+
+
+def sm2diff(sm1, sm2):
+    if isinstance(sm1[0], np.ndarray):
+
+        def backend_concatenate(a, b):
+            return np.concatenate([a, b], axis=0)
+
+        def backend_tensor(x):
+            return np.asarray(x, dtype=int)
+    elif isinstance(sm1[0], torch.Tensor):
+
+        def backend_concatenate(a, b):
+            return torch.concatenate([a, b], dim=0)
+
+        def backend_tensor(x):
+            return torch.tensor(x).type(torch.int)
+    else:
+        raise Exception("Invalid backend. Numpy or torch.")
+    pts1, w1 = sm1
+    pts2, w2 = sm2
+    pos_indices1 = backend_tensor(
+        [i for i, w in enumerate(w1) for _ in range(w) if w > 0]
+    )
+    pos_indices2 = backend_tensor(
+        [i for i, w in enumerate(w2) for _ in range(w) if w > 0]
+    )
+    neg_indices1 = backend_tensor(
+        [i for i, w in enumerate(w1) for _ in range(-w) if w < 0]
+    )
+    neg_indices2 = backend_tensor(
+        [i for i, w in enumerate(w2) for _ in range(-w) if w < 0]
+    )
+    x = backend_concatenate(pts1[pos_indices1], pts2[neg_indices2])
+    y = backend_concatenate(pts1[neg_indices1], pts2[pos_indices2])
+    return x, y
+
+
+def sm_distance(sm1, sm2, reg=0, reg_m=0, numItermax=10000, p=1):
+    x, y = sm2diff(sm1, sm2)
+    loss = ot.dist(
+        x, y, metric="sqeuclidean", p=2
+    )  # only euc + sqeuclidian are implemented in pot for the moment with torch backend # TODO : check later
+    if isinstance(x, np.ndarray):
+        empty_tensor = np.array([])  # uniform weights
+    elif isinstance(x, torch.Tensor):
+        empty_tensor = torch.tensor([])  # uniform weights
+
+    if reg == 0:
+        return ot.lp.emd2(empty_tensor, empty_tensor, M=loss) * len(x)
+    if reg_m == 0:
+        return ot.sinkhorn2(
+            a=empty_tensor, b=empty_tensor, M=loss, reg=reg, numItermax=numItermax
+        )
+    return ot.sinkhorn_unbalanced2(
+        a=empty_tensor,
+        b=empty_tensor,
+        M=loss,
+        reg=reg,
+        reg_m=reg_m,
+        numItermax=numItermax,
+    )
+    # return ot.sinkhorn2(a=onesx,b=onesy,M=loss,reg=reg, numItermax=numItermax)
+    # return ot.bregman.empirical_sinkhorn2(x,y,reg=reg)
+
+
+def estimate_matching(b1: PyMultiDiagrams, b2: PyMultiDiagrams):
+    assert len(b1) == len(b2)
+    from gudhi.bottleneck import bottleneck_distance
+
+    def get_bc(b: PyMultiDiagrams, i: int) -> np.ndarray:
+        temp = b[i].get_points()
+        out = (
+            np.array(temp)[:, :, 0] if len(temp) > 0 else np.empty((0, 2))
+        )  # GUDHI FIX
+        return out
+
+    return max(
+        (bottleneck_distance(get_bc(b1, i), get_bc(b2, i))
+         for i in range(len(b1)))
+    )
+
+
+# Functions to estimate precision
+def estimate_error(
+    st: SimplexTreeMulti,
+    module: PyModule,
+    degree: int,
+    nlines: int = 100,
+    verbose: bool = False,
+):
+    """
+    Given an MMA SimplexTree and PyModule, estimates the bottleneck distance using barcodes given by gudhi.
+
+    Parameters
+    ----------
+    st:SimplexTree
+            The simplextree representing the n-filtered complex. Used to define the gudhi simplextrees on different lines.
+    module:PyModule
+            The module on which to estimate approximation error, w.r.t. the original simplextree st.
+    degree: The homology degree to consider
+
+    Returns
+    -------
+    The estimation of the matching distance, i.e., the maximum of the sampled bottleneck distances.
+
+    """
+    from time import perf_counter
+
+    parameter = 0
+
+    def _get_bc_ST(st, basepoint, degree: int):
+        """
+        Slices an mma simplextree to a gudhi simplextree, and compute its persistence on the diagonal line crossing the given basepoint.
+        """
+        gst = st.project_on_line(
+            basepoint=basepoint, parameter=parameter
+        )  # we consider only the 1rst coordinate (as )
+        gst.compute_persistence()
+        return gst.persistence_intervals_in_dimension(degree)
+
+    from gudhi.bottleneck import bottleneck_distance
+
+    low, high = module.get_box()
+    nfiltration = len(low)
+    basepoints = np.random.uniform(
+        low=low, high=high, size=(nlines, nfiltration))
+    # barcodes from module
+    print("Computing mma barcodes...", flush=1, end="") if verbose else None
+    time = perf_counter()
+    bcs_from_mod = module.barcodes(
+        degree=degree, basepoints=basepoints).get_points()
+    print(f"Done. {perf_counter() - time}s.") if verbose else None
+
+    def clean(dgm):
+        return np.array(
+            [
+                [birth[parameter], death[parameter]]
+                for birth, death in dgm
+                if len(birth) > 0 and birth[parameter] != np.inf
+            ]
+        )
+
+    bcs_from_mod = [
+        clean(dgm) for dgm in bcs_from_mod
+    ]  # we only consider the 1st coordinate of the barcode
+    # Computes gudhi barcodes
+    from tqdm import tqdm
+
+    bcs_from_gudhi = [
+        _get_bc_ST(st, basepoint=basepoint, degree=degree)
+        for basepoint in tqdm(
+            basepoints, disable=not verbose, desc="Computing gudhi barcodes"
+        )
+    ]
+    return max(
+        (
+            bottleneck_distance(a, b)
+            for a, b in tqdm(
+                zip(bcs_from_mod, bcs_from_gudhi),
+                disable=not verbose,
+                total=nlines,
+                desc="Computing bottleneck distances",
+            )
+        )
+    )

multipers/euler_characteristic.pyx

@@ -0,0 +1,137 @@
+# 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/euler_characteristic.h" namespace "Gudhi::multiparameter::euler_characteristic":
+	void get_euler_surface_python(const intptr_t, tensor_dtype*, const vector[indices_type], bool, bool, bool) except + nogil
+	signed_measure_type get_euler_signed_measure(const intptr_t, tensor_dtype* , const vector[indices_type], bool, bool) except + nogil
+
+def euler_signed_measure(simplextree, mass_default=None, bool verbose=False, bool plot=False, grid_conversion=None):
+	"""
+	Computes the signed measures given by the decomposition of the hilbert function.
+
+	Input
+	-----
+	 - simplextree:SimplexTreeMulti, the multifiltered simplicial complex
+	 - 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 len(simplextree.filtration_grid[0]) > 0, "Squeeze grid first."
+	cdef bool zero_pad = mass_default is not None
+	grid_conversion = [np.asarray(f) for f in simplextree.filtration_grid] if grid_conversion is None else grid_conversion
+	# assert simplextree.num_parameters == 2
+	grid_shape = np.array([len(f) for f in grid_conversion])
+	
+	# match mass_default: ## Cython bug
+	# 	case None:
+	# 		pass
+	# 	case "inf":
+	# 		mass_default = np.array([np.inf]*simplextree.num_parameters)
+	# 	case "auto":
+	# 		mass_default = np.array([1.1*np.max(f) - 0.1*np.min(f) for f in grid_conversion])
+	# 	case _:
+	# 		mass_default = np.asarray(mass_default)
+	# 		assert mass_default.ndim == 1 and mass_default.shape[0] == simplextree.num_parameters
+	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."
+	container_array = np.ascontiguousarray(np.zeros(grid_shape, 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
+	cdef tensor_dtype[::1] container = container_array
+	cdef tensor_dtype* container_ptr = &container[0]
+	cdef signed_measure_type out
+	with nogil:
+		out = get_euler_signed_measure(simplextree_ptr, container_ptr, c_grid_shape, zero_pad, verbose)
+	pts, weights = np.asarray(out.first, dtype=int).reshape(-1, simplextree.num_parameters), np.asarray(out.second, dtype=int)
+	# return pts, weights
+	def empty_like(x):
+		if isinstance(grid_conversion[0], np.ndarray):
+			return np.empty_like(x, dtype=float)
+		import torch
+		assert isinstance(grid_conversion[0], torch.Tensor), f"Invalid grid type. Got {type(grid_conversion[0])}, expected numpy or torch array."
+		return torch.empty(x.shape,dtype=float)
+	coords = empty_like(pts)
+	for i in range(coords.shape[1]):
+		coords[:,i] = grid_conversion[i][pts[:,i]]
+	sm =(coords, weights)
+	if plot:
+		from multipers.plots import plot_signed_measures
+		plot_signed_measures([sm])
+	return sm
+
+
+def euler_surface(simplextree, bool mobius_inversion=False, bool zero_pad=False, plot=False, bool verbose=False):
+	"""
+	Computes 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
+	------
+	Integer array of the form `(num_degrees, num_filtration_values_of_parameter 1, ..., num_filtration_values_of_parameter n)`
+	"""
+	assert len(simplextree.filtration_grid[0]) > 0, "Squeeze grid first."
+	grid_conversion = [np.asarray(f) for f in simplextree.filtration_grid] if len(simplextree.filtration_grid[0]) > 0 else None
+	# assert simplextree.num_parameters == 2
+	grid_shape = [len(f) for f in grid_conversion]
+	assert len(grid_shape) == simplextree.num_parameters
+	container_array = np.ascontiguousarray(np.zeros(grid_shape, dtype=python_tensor_dtype).flatten())
+	cdef intptr_t simplextree_ptr = simplextree.thisptr
+	cdef vector[indices_type] c_grid_shape = grid_shape
+	cdef tensor_dtype[::1] container = container_array
+	cdef tensor_dtype* container_ptr = &container[0]
+	# cdef signed_measure_type out
+	# cdef indices_type i = 0
+	# cdef indices_type j = 1
+	# cdef vector[indices_type] fixed_values = np.asarray([0,0], dtype=int)
+	with nogil:
+		get_euler_surface_python(simplextree_ptr, container_ptr, c_grid_shape, mobius_inversion, zero_pad, verbose)
+	out = (grid_conversion, container_array.reshape(grid_shape))
+	if plot:
+		from multipers.plots import plot_surface
+		plot_surface(*out)
+	return out
+

multipers/function_rips.pyx

@@ -0,0 +1,102 @@
+# 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 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
+
+
+from multipers.simplex_tree_multi import SimplexTreeMulti
+
+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
+	pair[vector[value_type],int] get_degree_rips_st_python(const intptr_t,const intptr_t, const vector[int]) except + nogil
+
+
+
+
+
+def get_degree_rips(st, vector[int] degrees, grid_strategy="exact", resolution=0):
+	assert st.dimension() == 1
+	degree_rips_st = SimplexTreeMulti(num_parameters=degrees.size())
+	cdef intptr_t simplextree_ptr = st.thisptr
+	cdef intptr_t st_multi_ptr = degree_rips_st.thisptr
+	cdef pair[vector[value_type],int] out
+	with nogil:
+		out = get_degree_rips_st_python(simplextree_ptr, st_multi_ptr, degrees)
+	filtrations = np.asarray(out.first)
+	cdef int max_degree = out.second
+	cdef bool inf_flag = filtrations[-1] == np.inf
+	if inf_flag:
+		filtrations = filtrations[:-1]
+	filtrations, = degree_rips_st._reduce_grid([filtrations],strategy=grid_strategy,resolutions=resolution)
+	if inf_flag:
+		filtrations = np.concatenate([filtrations, [np.inf]])
+	degree_rips_st.grid_squeeze([filtrations]*degree_rips_st.num_parameters)
+	degree_rips_st.filtration_grid = [filtrations, np.asarray(degrees)[::-1]]
+	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

multipers/hilbert_function.pyi

@@ -0,0 +1,46 @@
+# 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
+
+def hilbert_signed_measure(simplextree, degrees, mass_default=None, plot=False, n_jobs=0, verbose=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)`.
+	"""
+	pass
+
+
+def hilbert_function(simplextree, degrees, zero_pad=False, plot=False, n_jobs=0):
+	"""
+	Computes 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
+	------
+	Integer array of the form `(num_degrees, num_filtration_values_of_parameter 1, ..., num_filtration_values_of_parameter n)`
+	"""
+	pass

multipers/hilbert_function.pyx

@@ -0,0 +1,151 @@
+# 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/hilbert_function.h" namespace "Gudhi::multiparameter::hilbert_function":
+	void get_hilbert_surface_python(const intptr_t, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool, bool, indices_type, bool) except + nogil
+	signed_measure_type get_hilbert_signed_measure(const intptr_t, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool, indices_type, bool, bool) except + nogil
+
+
+def hilbert_signed_measure(
+		simplextree, 
+		vector[indices_type] degrees, 
+		mass_default=None, 
+		plot=False, 
+		indices_type n_jobs=0, 
+		bool verbose=False,
+		bool expand_collapse=False, 
+		grid_conversion = None
+	):
+	"""
+	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] if grid_conversion is None else grid_conversion
+	# 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]), 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(np.uint32).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]
+	cdef signed_measure_type out
+	with nogil:
+		out = get_hilbert_signed_measure(simplextree_ptr, container_ptr, c_grid_shape, degrees, zero_pad, n_jobs, verbose, expand_collapse)
+	pts, weights = np.asarray(out.first, dtype=int).reshape(-1, simplextree.num_parameters+1), np.asarray(out.second, dtype=int)
+	# return pts, weights
+	degree_indices = [np.argwhere(pts[:,0] == degree_index).flatten() for degree_index, degree in enumerate(degrees)] ## TODO : maybe optimize
+	sms = [(pts[id,1:],weights[id]) for id in degree_indices]
+	
+	def empty_like(x):
+		if isinstance(grid_conversion[0], np.ndarray):
+			return np.empty_like(x, dtype=float)
+		import torch
+		assert isinstance(grid_conversion[0], torch.Tensor), f"Invalid grid type. Got {type(grid_conversion[0])}, expected numpy or torch array."
+		return torch.empty(x.shape,dtype=float)
+
+	for degree_index,(pts,weights) in enumerate(sms):
+		coords = empty_like(pts)
+		for i in range(coords.shape[1]):
+			coords[:,i] = grid_conversion[i][pts[:,i]]
+		sms[degree_index]=(coords, weights)
+	if plot:
+		from multipers.plots import plot_signed_measures
+		plot_signed_measures(sms)
+	return sms
+
+
+def hilbert_surface(simplextree, vector[indices_type] degrees, mass_default=None, bool mobius_inversion=False, bool plot=False, indices_type n_jobs=0, bool expand_collapse=False):
+	"""
+	Computes 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
+	------
+	Integer array of the form `(num_degrees, num_filtration_values_of_parameter 1, ..., num_filtration_values_of_parameter n)`
+	"""
+	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]
+	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]), 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(np.uint32).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:
+		get_hilbert_surface_python(simplextree_ptr, container_ptr, c_grid_shape, degrees, mobius_inversion, zero_pad, n_jobs, expand_collapse)
+	out = (grid_conversion, container_array.reshape(grid_shape_with_degree))
+	if plot:
+		from multipers.plots import plot_surfaces
+		plot_surfaces(out)
+	return out
+