multipers 1.0__cp311-cp311-manylinux_2_34_x86_64.whl

multipers/data/pytorch2simplextree.py

@@ -0,0 +1,91 @@
+from tqdm import tqdm
+import numpy as np
+from torch_geometric.data.data import Data
+import networkx as nx
+from sklearn.base import BaseEstimator, TransformerMixin
+from typing import Iterable
+
+
+def modelnet2pts2gs(train_dataset, test_dataset , nbr_size = 8, exp_flag = True, labels_only = False,n=100, n_jobs=1, random=False):
+	from sklearn.neighbors import kneighbors_graph
+	""" 
+    sample points and create neighborhoold graph
+	"""	
+	dataset = train_dataset + test_dataset
+	indices = np.random.choice(range(len(dataset)),replace=False, size=n) if random else range(n)
+
+	dataset:list[Data] = [dataset[i] for i in indices]
+	_,labels = torch_geometric_2nx(dataset, labels_only=True)
+	if labels_only: return labels
+	
+	def data2graph(data:Data):
+		pos = data.pos.numpy()
+		adj = kneighbors_graph(pos, nbr_size, mode='distance', n_jobs=n_jobs) 
+		g = nx.from_scipy_sparse_array(adj, edge_attribute= 'weight')
+		if exp_flag:
+			for u, v in g.edges(): # TODO optimize
+				g[u][v]['weight'] = np.exp(-g[u][v]['weight'])
+		return g
+		#TODO : nx.set_edge_attributes()
+
+	return [data2graph(data) for data in dataset], labels
+def torch_geometric_2nx(dataset, labels_only = False, print_flag = False, weight_flag = False):
+	"""
+	:param dataset:
+	:param labels_only: return labels only
+	:param print_flag:
+	:param weight_flag: whether computing distance as weights or not
+	:return:
+	"""
+	if labels_only:
+		return None, [int(data.y) for data in dataset]
+	def data2graph(data:Data):
+		edges = np.unique(data.edge_index.numpy().T, axis=0)
+		g = nx.from_edgelist(edges)
+		edge_filtration = {(u,v):np.linalg.norm(data.pos[u] - data.pos[v]) for u,v in g.edges}
+		nx.set_node_attributes(g,{node:0 for node in g.nodes}, "geodesic")
+		nx.set_edge_attributes(g, edge_filtration, "geodesic")
+		return g
+	return [data2graph(data) for data in tqdm(dataset, desc="Turning Data to graphs")], [int(data.y) for data in dataset]
+
+
+def modelnet2graphs(version = '10', print_flag = False, labels_only = False, a = 0, b = 10, weight_flag = False):
+	""" load modelnet 10 or 40 and convert to graphs"""
+	from torch_geometric.transforms import FaceToEdge
+	from .shape3d import load_modelnet
+	train_dataset, test_dataset = load_modelnet(version, point_flag = False)
+	dataset = train_dataset + test_dataset
+	if b>0:	dataset = [dataset[i] for i in range(a,b)]
+	if labels_only:
+		return torch_geometric_2nx(dataset, labels_only=True)
+	dataset = [FaceToEdge(remove_faces=False)(data) for data in dataset]
+	graphs, labels = torch_geometric_2nx(dataset, print_flag=print_flag, weight_flag= weight_flag)
+	return graphs, labels
+
+
+
+
+class Torch2SimplexTree(BaseEstimator,TransformerMixin):
+	"""
+	WARNING : build in progress
+	PyTorch Data-like to simplextree.
+	
+	Input
+	-----
+	Class having `pos`, `edges`, `faces` methods
+    
+	Filtrations
+	-----------
+	 - Geodesic (geodesic rips)
+	 - eccentricity 
+	"""
+	import multipers as mp
+	
+	def __init__(self, filtrations:Iterable[str]=[]):
+		super().__init__()
+		
+	def fit(self, X, y=None):
+		return self
+	
+	def transform(self,X:list[nx.Graph]):
+		return

multipers/data/shape3d.py

@@ -0,0 +1,101 @@
+import numpy as np
+from os.path import expanduser
+from torch_geometric.datasets import ModelNet
+
+DATASET_PATH = expanduser("~/Datasets/")
+import os
+
+
+####################### MODELNET
+def load_modelnet(version='10', sample_points = False, reset:bool=False, remove_faces=False):
+	from torch_geometric.transforms import FaceToEdge, SamplePoints
+	"""
+	:param point_flag: Sample points if point_flag true. Otherwise load mesh
+	:return: train_dataset, test_dataset
+	"""
+	assert version in ['10', '40']
+	if sample_points:
+		pre_transform, transform = FaceToEdge(remove_faces=remove_faces), SamplePoints(num=sample_points)
+	else:
+		pre_transform, transform = FaceToEdge(remove_faces=remove_faces), None
+	path = f"{DATASET_PATH}/ModelNet{version}"
+	if reset:
+		# print(f"rm -rf {path}")
+		os.system(f"rm -rf {path+'/processed/'}")
+	train_dataset = ModelNet(path, name=version, train=True, transform=transform, pre_transform=pre_transform)
+	test_dataset = ModelNet(path, name=version, train=False, transform=transform, pre_transform=pre_transform)
+	return train_dataset, test_dataset
+
+
+def get_ModelNet(dataset, num_graph, seed):
+	train,test = load_modelnet(version=dataset[8:])
+	test_size = len(test) / len(train)
+	if num_graph >0:
+		np.random.seed(seed)
+		indices = np.random.choice(len(train), num_graph, replace=False)
+		train = train[indices]
+		indices = np.random.choice(len(test), int(num_graph*test_size), replace=False)
+		test = test[indices]
+		np.random.seed() # resets seed
+	return train, test
+	
+
+def get(dataset:str, num_graph=0, seed=0, node_per_graph=0):
+	if dataset.startswith("ModelNet"):
+		return get_ModelNet(dataset=dataset, num_graph=num_graph, seed=seed)
+	datasets = get_(dataset=dataset, num_sample=num_graph)
+	graphs = []
+	labels = []
+	np.random.seed(seed)
+	for data, ls in datasets:
+		nodes = np.random.choice(range(len(data.pos)), replace=False, size=node_per_graph)
+		for i,node in enumerate(nodes):
+			data_ = data # if i == 0 else None # prevents doing copies
+			graphs.append([data_, node])
+			labels.append(ls[node])
+	return graphs, labels
+
+
+def get_(dataset:str, dataset_num:int|None=None, num_sample:int=0, DATASET_PATH = expanduser("~/Datasets/")):
+	from torch_geometric.io import read_off
+	if dataset.startswith("3dshapes/"):
+		dataset_ = dataset[len("3dshapes/"):]
+	else:
+		dataset_ = dataset
+	if dataset_num is None and "/" in dataset_:
+		position = dataset_.rfind("/")
+		dataset_num = int(dataset_[position+1:-4]) # cuts the "<dataset>/" and the ".off"
+		dataset_ = dataset_[:position]
+
+	if dataset_num is None: # gets a random (available) number for this dataset
+		from os import listdir
+		from random import choice
+		files = listdir(DATASET_PATH+f"3dshapes/{dataset_}")
+		if num_sample <= 0:
+			files = [file for file in files if "label" not in file]
+		else:
+			files = np.random.choice([file for file in files if "label" not in file], replace=False, size=num_sample)
+		dataset_nums = np.sort([int("".join([char for  char in file  if char.isnumeric()])) for file in files])
+		
+		print("Dataset nums : ", *dataset_nums)
+		out = [get_(dataset_, dataset_num=num) for num in dataset_nums]
+		return out
+
+	path = DATASET_PATH+f"3dshapes/{dataset_}/{dataset_num}.off"
+	data = read_off(path)
+	faces = data.face.numpy().T
+	# data = FaceToEdge(remove_faces=remove_faces)(data)
+	#labels 
+	label_path = path.split(".")[0] + "_labels.txt"
+	f = open(label_path, "r")
+	labels = np.zeros(len(data.pos), dtype="<U10") # Assumes labels are of size at most 10 chars
+	current_label=""
+	for i, line in enumerate(f.readlines()):
+		if i %  2 == 0:
+			current_label = line.strip()
+			continue
+		faces_of_label = np.array(line.strip().split(" "), dtype=int) -1 # this starts at 1, python starts at 0
+		# print(faces_of_label.min())
+		nodes_of_label = np.unique(faces[faces_of_label].flatten())
+		labels[nodes_of_label] = current_label  # les labels sont sur les faces
+	return data, labels

multipers/data/synthetic.py

@@ -0,0 +1,68 @@
+import numpy as np
+from sklearn.preprocessing import LabelEncoder
+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):
+	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,100 @@
+import torch
+import ot
+import numpy as np
+from multipers.simplex_tree_multi import SimplexTreeMulti
+from multipers.multiparameter_module_approximation import PyMultiDiagrams, PyModule
+
+def sm2diff(sm1,sm2):
+	if isinstance(sm1[0],np.ndarray):
+		backend_concatenate = lambda a,b : np.concatenate([a,b], axis=0)
+		backend_tensor = lambda x : np.asarray(x, dtype=int)
+	elif isinstance(sm1[0],torch.Tensor):
+		backend_concatenate = lambda a,b : torch.concatenate([a,b], dim=0)
+		backend_tensor = lambda x :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
+	clean = lambda dgm : 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,132 @@
+# 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):
+	"""
+	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]
+	# 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
+	
+	coords = np.empty(shape=pts.shape, dtype=float)
+	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,101 @@
+# 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]]
+	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