multipers 2.0.0__cp311-cp311-macosx_13_0_arm64.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,198 @@
+import numpy as np
+import ot
+
+from multipers.mma_structures import PyMultiDiagrams_type
+from multipers.multiparameter_module_approximation import PyModule_type
+from multipers.simplex_tree_multi import SimplexTreeMulti_type
+
+
+def sm2diff(sm1, sm2):
+    pts = sm1[0]
+    dtype = pts.dtype
+    if isinstance(pts, np.ndarray):
+
+        def backend_concatenate(a, b):
+            return np.concatenate([a, b], axis=0, dtype=dtype)
+
+        def backend_tensor(x):
+            return np.asarray(x, dtype=int)
+
+    else:
+        import torch
+
+        assert isinstance(pts, torch.Tensor), "Invalid backend. Numpy or torch."
+
+        def backend_concatenate(a, b):
+            return torch.concatenate([a, b], dim=0)
+
+        def backend_tensor(x):
+            return torch.tensor(x).type(torch.int)
+
+    pts1, w1 = sm1
+    pts2, w2 = sm2
+    ## TODO: optimize this
+    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: tuple,
+    sm2: tuple,
+    reg: float = 0,
+    reg_m: float = 0,
+    numItermax: int = 10000,
+    p: float = 1,
+):
+    """
+    Computes the wasserstein distances between two signed measures,
+    of the form
+     - (pts,weights)
+    with
+     - pts : (num_pts, dim) float array
+     - weights : (num_pts,) int array
+
+    Regularisation:
+     - sinkhorn if reg != 0
+     - sinkhorn unbalanced if reg_m != 0
+    """
+    x, y = sm2diff(sm1, sm2)
+    loss = ot.dist(
+        x, y, metric="sqeuclidean", p=p
+    )  # 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
+    else:
+        import torch
+
+        assert isinstance(x, torch.Tensor), "Unimplemented backend."
+        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_type, b2: PyMultiDiagrams_type):
+    assert len(b1) == len(b2)
+    from gudhi.bottleneck import bottleneck_distance
+
+    def get_bc(b: PyMultiDiagrams_type, 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_type,
+    module: PyModule_type,
+    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:int
+        The homology degree to consider
+
+    Returns
+    -------
+     - float: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,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, 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
+	# assert simplextree.num_parameters == 2
+	grid_shape = np.array([len(f) for f in simplextree.filtration_grid])
+	
+	# 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
+		if grid_conversion is not None:
+			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
+	sm = (pts,weights)
+
+	if grid_conversion is not None:
+		from multipers.hilbert_function import sms_in_grid
+		sm, = sms_in_grid([sm], grid_conversion)
+	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/filtration_conversions.pxd

@@ -0,0 +1,229 @@
+# WARNING: Do not edit this file directly.
+# It is automatically generated from 'multipers/filtration_conversions.pxd.tp'.
+# Changes must be made there.
+
+
+# Python to C++ conversions
+from multipers.filtrations cimport Finitely_critical_multi_filtration,KCriticalFiltration
+from libcpp.vector cimport vector
+from libcpp cimport bool
+cimport numpy as cnp
+import numpy as np
+from libc.stdint cimport int32_t, int64_t
+from cython.operator cimport dereference
+###### ------------------- PY TO CPP
+#### ---------- 
+
+cdef inline KCriticalFiltration[int32_t] _py2kc_i32(object filtrations_):
+    cdef int32_t[:,:] filtrations = np.asarray(filtrations_, dtype=np.int32)
+    cdef KCriticalFiltration[int32_t] out
+    with nogil:
+      out.set_num_generators(filtrations.shape[0])
+      for i in range(filtrations.shape[0]):
+          out[i].resize(filtrations.shape[1])
+          for j in range(filtrations.shape[1]):
+              out[i][j] = filtrations[i,j]
+    return out
+
+cdef inline Finitely_critical_multi_filtration[int32_t] _py21c_i32(object filtration_):
+    cdef int32_t[:] filtration = np.asarray(filtration_, dtype=np.int32)
+    cdef Finitely_critical_multi_filtration[int32_t] out
+    with nogil:
+      out.reserve(len(filtration))
+      for i in range(len(filtration)):
+          out.push_back(filtration[i])
+    return out
+
+
+cdef inline vector[Finitely_critical_multi_filtration[int32_t]] _py2v1c_i32(object filtrations_):
+    cdef int32_t[:,:] filtrations = np.asarray(filtrations_, dtype=np.int32)
+    cdef vector[Finitely_critical_multi_filtration[int32_t]] out
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        out.push_back(_py21c_i32(filtrations[i,:]))
+    return out
+
+
+###### ------------------- CPP to PY
+
+
+## CYTHON BUG: using tuples here will cause some weird issues. 
+cdef inline _ff21cview_i32(Finitely_critical_multi_filtration[int32_t]* x, bool copy=False):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  cdef int32_t[:] x_view = <int32_t[:num_parameters]>(&(dereference(x)[0]))
+  return np.array(x_view) if copy else np.asarray(x_view)
+
+cdef inline  _ff2kcview_i32(KCriticalFiltration[int32_t]* x, bool copy=False):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+  return [_ff21cview_i32(&(dereference(x)[i]), copy=copy) for i in range(k)]
+
+
+cdef inline  _vff21cview_i32(vector[Finitely_critical_multi_filtration[int32_t]]& x, bool copy = False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff21cview_i32(&(x[i]), copy=copy) for i in range(num_stuff)]
+
+cdef inline  _vff2kcview_i32(vector[KCriticalFiltration[int32_t]]& x, bool copy = False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff2kcview_i32(&(x[i]), copy=copy) for i in range(num_stuff)]
+###### ------------------- PY TO CPP
+#### ---------- 
+
+cdef inline KCriticalFiltration[int64_t] _py2kc_i64(object filtrations_):
+    cdef int64_t[:,:] filtrations = np.asarray(filtrations_, dtype=np.int64)
+    cdef KCriticalFiltration[int64_t] out
+    with nogil:
+      out.set_num_generators(filtrations.shape[0])
+      for i in range(filtrations.shape[0]):
+          out[i].resize(filtrations.shape[1])
+          for j in range(filtrations.shape[1]):
+              out[i][j] = filtrations[i,j]
+    return out
+
+cdef inline Finitely_critical_multi_filtration[int64_t] _py21c_i64(object filtration_):
+    cdef int64_t[:] filtration = np.asarray(filtration_, dtype=np.int64)
+    cdef Finitely_critical_multi_filtration[int64_t] out
+    with nogil:
+      out.reserve(len(filtration))
+      for i in range(len(filtration)):
+          out.push_back(filtration[i])
+    return out
+
+
+cdef inline vector[Finitely_critical_multi_filtration[int64_t]] _py2v1c_i64(object filtrations_):
+    cdef int64_t[:,:] filtrations = np.asarray(filtrations_, dtype=np.int64)
+    cdef vector[Finitely_critical_multi_filtration[int64_t]] out
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        out.push_back(_py21c_i64(filtrations[i,:]))
+    return out
+
+
+###### ------------------- CPP to PY
+
+
+## CYTHON BUG: using tuples here will cause some weird issues. 
+cdef inline _ff21cview_i64(Finitely_critical_multi_filtration[int64_t]* x, bool copy=False):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  cdef int64_t[:] x_view = <int64_t[:num_parameters]>(&(dereference(x)[0]))
+  return np.array(x_view) if copy else np.asarray(x_view)
+
+cdef inline  _ff2kcview_i64(KCriticalFiltration[int64_t]* x, bool copy=False):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+  return [_ff21cview_i64(&(dereference(x)[i]), copy=copy) for i in range(k)]
+
+
+cdef inline  _vff21cview_i64(vector[Finitely_critical_multi_filtration[int64_t]]& x, bool copy = False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff21cview_i64(&(x[i]), copy=copy) for i in range(num_stuff)]
+
+cdef inline  _vff2kcview_i64(vector[KCriticalFiltration[int64_t]]& x, bool copy = False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff2kcview_i64(&(x[i]), copy=copy) for i in range(num_stuff)]
+###### ------------------- PY TO CPP
+#### ---------- 
+
+cdef inline KCriticalFiltration[float] _py2kc_f32(object filtrations_):
+    cdef float[:,:] filtrations = np.asarray(filtrations_, dtype=np.float32)
+    cdef KCriticalFiltration[float] out
+    with nogil:
+      out.set_num_generators(filtrations.shape[0])
+      for i in range(filtrations.shape[0]):
+          out[i].resize(filtrations.shape[1])
+          for j in range(filtrations.shape[1]):
+              out[i][j] = filtrations[i,j]
+    return out
+
+cdef inline Finitely_critical_multi_filtration[float] _py21c_f32(object filtration_):
+    cdef float[:] filtration = np.asarray(filtration_, dtype=np.float32)
+    cdef Finitely_critical_multi_filtration[float] out
+    with nogil:
+      out.reserve(len(filtration))
+      for i in range(len(filtration)):
+          out.push_back(filtration[i])
+    return out
+
+
+cdef inline vector[Finitely_critical_multi_filtration[float]] _py2v1c_f32(object filtrations_):
+    cdef float[:,:] filtrations = np.asarray(filtrations_, dtype=np.float32)
+    cdef vector[Finitely_critical_multi_filtration[float]] out
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        out.push_back(_py21c_f32(filtrations[i,:]))
+    return out
+
+
+###### ------------------- CPP to PY
+
+
+## CYTHON BUG: using tuples here will cause some weird issues. 
+cdef inline _ff21cview_f32(Finitely_critical_multi_filtration[float]* x, bool copy=False):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  cdef float[:] x_view = <float[:num_parameters]>(&(dereference(x)[0]))
+  return np.array(x_view) if copy else np.asarray(x_view)
+
+cdef inline  _ff2kcview_f32(KCriticalFiltration[float]* x, bool copy=False):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+  return [_ff21cview_f32(&(dereference(x)[i]), copy=copy) for i in range(k)]
+
+
+cdef inline  _vff21cview_f32(vector[Finitely_critical_multi_filtration[float]]& x, bool copy = False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff21cview_f32(&(x[i]), copy=copy) for i in range(num_stuff)]
+
+cdef inline  _vff2kcview_f32(vector[KCriticalFiltration[float]]& x, bool copy = False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff2kcview_f32(&(x[i]), copy=copy) for i in range(num_stuff)]
+###### ------------------- PY TO CPP
+#### ---------- 
+
+cdef inline KCriticalFiltration[double] _py2kc_f64(object filtrations_):
+    cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef KCriticalFiltration[double] out
+    with nogil:
+      out.set_num_generators(filtrations.shape[0])
+      for i in range(filtrations.shape[0]):
+          out[i].resize(filtrations.shape[1])
+          for j in range(filtrations.shape[1]):
+              out[i][j] = filtrations[i,j]
+    return out
+
+cdef inline Finitely_critical_multi_filtration[double] _py21c_f64(object filtration_):
+    cdef double[:] filtration = np.asarray(filtration_, dtype=np.float64)
+    cdef Finitely_critical_multi_filtration[double] out
+    with nogil:
+      out.reserve(len(filtration))
+      for i in range(len(filtration)):
+          out.push_back(filtration[i])
+    return out
+
+
+cdef inline vector[Finitely_critical_multi_filtration[double]] _py2v1c_f64(object filtrations_):
+    cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef vector[Finitely_critical_multi_filtration[double]] out
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        out.push_back(_py21c_f64(filtrations[i,:]))
+    return out
+
+
+###### ------------------- CPP to PY
+
+
+## CYTHON BUG: using tuples here will cause some weird issues. 
+cdef inline _ff21cview_f64(Finitely_critical_multi_filtration[double]* x, bool copy=False):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  cdef double[:] x_view = <double[:num_parameters]>(&(dereference(x)[0]))
+  return np.array(x_view) if copy else np.asarray(x_view)
+
+cdef inline  _ff2kcview_f64(KCriticalFiltration[double]* x, bool copy=False):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+  return [_ff21cview_f64(&(dereference(x)[i]), copy=copy) for i in range(k)]
+
+
+cdef inline  _vff21cview_f64(vector[Finitely_critical_multi_filtration[double]]& x, bool copy = False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff21cview_f64(&(x[i]), copy=copy) for i in range(num_stuff)]
+
+cdef inline  _vff2kcview_f64(vector[KCriticalFiltration[double]]& x, bool copy = False):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff2kcview_f64(&(x[i]), copy=copy) for i in range(num_stuff)]