multipers 2.3.3b6__cp313-cp313-macosx_10_13_x86_64.whl

multipers/data/synthetic.py

@@ -0,0 +1,113 @@
+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
+
+    """
+    theta = np.random.normal(size=(n1, dim))
+    theta /= np.linalg.norm(theta, axis=1)[:, None]
+    rs = np.sqrt(np.random.uniform(low=r1**2, high=r2**2, size=n1))
+    annulus = rs[:, None] * theta
+    if center is not None:
+        annulus += np.array(center)
+    diffuse_noise = np.random.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):
+    q, r = divmod(num_pts, 3)
+    num_pts_1, num_pts_2, num_pts_3 =  q, q + (r > 0), q + (r > 1)
+    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=num_pts_1,
+                        n2=0,
+                        center=[1, -0.2],
+                    )
+                )
+            ],
+            [
+                np.array(
+                    noisy_annulus(
+                        r1=0.4,
+                        r2=0.55,
+                        n1=num_pts_2,
+                        n2=0,
+                        center=[-1.2, -1],
+                    )
+                )
+            ],
+            [
+                np.array(
+                    noisy_annulus(
+                        r1=0.3,
+                        r2=0.4,
+                        n1=num_pts_3,
+                        n2=0,
+                        center=[-0.7, 1.1],
+                    )
+                )
+            ],
+        ]
+    )
+    return X
+
+
+def orbit(n: int = 1000, r: float = 1.0, 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,202 @@
+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, threshold=None):
+    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])
+    if threshold is not None:
+        x[x>threshold]=threshold
+        y[y>threshold]=threshold
+    return x, y
+
+
+def sm_distance(
+    sm1: tuple,
+    sm2: tuple,
+    reg: float = 0,
+    reg_m: float = 0,
+    numItermax: int = 10000,
+    p: float = 1,
+    threshold=None,
+):
+    """
+    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, threshold=threshold)
+    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/filtration_conversions.pxd

@@ -0,0 +1,229 @@
+
+# Python to C++ conversions
+from multipers.filtrations cimport One_critical_filtration,Multi_critical_filtration
+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 Multi_critical_filtration[int32_t] _py2kc_i32(int32_t[:,:] filtrations) noexcept nogil:
+    # cdef int32_t[:,:] filtrations = np.asarray(filtrations_, dtype=np.int32)
+    cdef Multi_critical_filtration[int32_t] out
+    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]
+    out.simplify()
+    return out
+
+cdef inline One_critical_filtration[int32_t] _py21c_i32(int32_t[:] filtration) noexcept nogil:
+    # cdef int32_t[:] filtration = np.asarray(filtration_, dtype=np.int32)
+    cdef One_critical_filtration[int32_t] out = One_critical_filtration[int32_t](0)
+    out.reserve(len(filtration))
+    for i in range(len(filtration)):
+        out.push_back(filtration[i])
+    return out
+
+
+cdef inline vector[One_critical_filtration[int32_t]] _py2v1c_i32(int32_t[:,:] filtrations) noexcept nogil:
+    # cdef int32_t[:,:] filtrations = np.asarray(filtrations_, dtype=np.int32)
+    cdef vector[One_critical_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(One_critical_filtration[int32_t]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  if copy and duplicate and not dereference(x).is_finite():
+    return np.full(shape=duplicate, fill_value=dereference(x)[0])
+  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(Multi_critical_filtration[int32_t]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+  return [_ff21cview_i32(&(dereference(x)[i]), copy=copy, duplicate=duplicate) for i in range(k)]
+
+
+cdef inline  _vff21cview_i32(vector[One_critical_filtration[int32_t]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff21cview_i32(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+
+cdef inline  _vff2kcview_i32(vector[Multi_critical_filtration[int32_t]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff2kcview_i32(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+###### ------------------- PY TO CPP
+#### ---------- 
+
+cdef inline Multi_critical_filtration[int64_t] _py2kc_i64(int64_t[:,:] filtrations) noexcept nogil:
+    # cdef int64_t[:,:] filtrations = np.asarray(filtrations_, dtype=np.int64)
+    cdef Multi_critical_filtration[int64_t] out
+    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]
+    out.simplify()
+    return out
+
+cdef inline One_critical_filtration[int64_t] _py21c_i64(int64_t[:] filtration) noexcept nogil:
+    # cdef int64_t[:] filtration = np.asarray(filtration_, dtype=np.int64)
+    cdef One_critical_filtration[int64_t] out = One_critical_filtration[int64_t](0)
+    out.reserve(len(filtration))
+    for i in range(len(filtration)):
+        out.push_back(filtration[i])
+    return out
+
+
+cdef inline vector[One_critical_filtration[int64_t]] _py2v1c_i64(int64_t[:,:] filtrations) noexcept nogil:
+    # cdef int64_t[:,:] filtrations = np.asarray(filtrations_, dtype=np.int64)
+    cdef vector[One_critical_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(One_critical_filtration[int64_t]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  if copy and duplicate and not dereference(x).is_finite():
+    return np.full(shape=duplicate, fill_value=dereference(x)[0])
+  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(Multi_critical_filtration[int64_t]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+  return [_ff21cview_i64(&(dereference(x)[i]), copy=copy, duplicate=duplicate) for i in range(k)]
+
+
+cdef inline  _vff21cview_i64(vector[One_critical_filtration[int64_t]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff21cview_i64(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+
+cdef inline  _vff2kcview_i64(vector[Multi_critical_filtration[int64_t]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff2kcview_i64(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+###### ------------------- PY TO CPP
+#### ---------- 
+
+cdef inline Multi_critical_filtration[float] _py2kc_f32(float[:,:] filtrations) noexcept nogil:
+    # cdef float[:,:] filtrations = np.asarray(filtrations_, dtype=np.float32)
+    cdef Multi_critical_filtration[float] out
+    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]
+    out.simplify()
+    return out
+
+cdef inline One_critical_filtration[float] _py21c_f32(float[:] filtration) noexcept nogil:
+    # cdef float[:] filtration = np.asarray(filtration_, dtype=np.float32)
+    cdef One_critical_filtration[float] out = One_critical_filtration[float](0)
+    out.reserve(len(filtration))
+    for i in range(len(filtration)):
+        out.push_back(filtration[i])
+    return out
+
+
+cdef inline vector[One_critical_filtration[float]] _py2v1c_f32(float[:,:] filtrations) noexcept nogil:
+    # cdef float[:,:] filtrations = np.asarray(filtrations_, dtype=np.float32)
+    cdef vector[One_critical_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(One_critical_filtration[float]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  if copy and duplicate and not dereference(x).is_finite():
+    return np.full(shape=duplicate, fill_value=dereference(x)[0])
+  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(Multi_critical_filtration[float]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+  return [_ff21cview_f32(&(dereference(x)[i]), copy=copy, duplicate=duplicate) for i in range(k)]
+
+
+cdef inline  _vff21cview_f32(vector[One_critical_filtration[float]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff21cview_f32(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+
+cdef inline  _vff2kcview_f32(vector[Multi_critical_filtration[float]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff2kcview_f32(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+###### ------------------- PY TO CPP
+#### ---------- 
+
+cdef inline Multi_critical_filtration[double] _py2kc_f64(double[:,:] filtrations) noexcept nogil:
+    # cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef Multi_critical_filtration[double] out
+    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]
+    out.simplify()
+    return out
+
+cdef inline One_critical_filtration[double] _py21c_f64(double[:] filtration) noexcept nogil:
+    # cdef double[:] filtration = np.asarray(filtration_, dtype=np.float64)
+    cdef One_critical_filtration[double] out = One_critical_filtration[double](0)
+    out.reserve(len(filtration))
+    for i in range(len(filtration)):
+        out.push_back(filtration[i])
+    return out
+
+
+cdef inline vector[One_critical_filtration[double]] _py2v1c_f64(double[:,:] filtrations) noexcept nogil:
+    # cdef double[:,:] filtrations = np.asarray(filtrations_, dtype=np.float64)
+    cdef vector[One_critical_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(One_critical_filtration[double]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  if copy and duplicate and not dereference(x).is_finite():
+    return np.full(shape=duplicate, fill_value=dereference(x)[0])
+  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(Multi_critical_filtration[double]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+  return [_ff21cview_f64(&(dereference(x)[i]), copy=copy, duplicate=duplicate) for i in range(k)]
+
+
+cdef inline  _vff21cview_f64(vector[One_critical_filtration[double]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff21cview_f64(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+
+cdef inline  _vff2kcview_f64(vector[Multi_critical_filtration[double]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff2kcview_f64(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]

multipers/filtration_conversions.pxd.tp

@@ -0,0 +1,84 @@
+{{py:
+
+"""
+Filtrations conversions between python and C++
+"""
+
+## Value types : CTYPE, PYTHON_TYPE, short
+value_types = [
+  ("int32_t", "np.int32", "i32"),
+  ("int64_t", "np.int64", "i64"),
+  ("float", "np.float32", "f32"),
+  ("double", "np.float64", "f64"),
+]
+
+}}
+
+# Python to C++ conversions
+from multipers.filtrations cimport One_critical_filtration,Multi_critical_filtration
+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
+
+{{for CTYPE, PYTYPE, SHORT in value_types}}
+###### ------------------- PY TO CPP
+#### ---------- 
+
+cdef inline Multi_critical_filtration[{{CTYPE}}] _py2kc_{{SHORT}}({{CTYPE}}[:,:] filtrations) noexcept nogil:
+    # cdef {{CTYPE}}[:,:] filtrations = np.asarray(filtrations_, dtype={{PYTYPE}})
+    cdef Multi_critical_filtration[{{CTYPE}}] out
+    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]
+    out.simplify()
+    return out
+
+cdef inline One_critical_filtration[{{CTYPE}}] _py21c_{{SHORT}}({{CTYPE}}[:] filtration) noexcept nogil:
+    # cdef {{CTYPE}}[:] filtration = np.asarray(filtration_, dtype={{PYTYPE}})
+    cdef One_critical_filtration[{{CTYPE}}] out = One_critical_filtration[{{CTYPE}}](0)
+    out.reserve(len(filtration))
+    for i in range(len(filtration)):
+        out.push_back(filtration[i])
+    return out
+
+
+cdef inline vector[One_critical_filtration[{{CTYPE}}]] _py2v1c_{{SHORT}}({{CTYPE}}[:,:] filtrations) noexcept nogil:
+    # cdef {{CTYPE}}[:,:] filtrations = np.asarray(filtrations_, dtype={{PYTYPE}})
+    cdef vector[One_critical_filtration[{{CTYPE}}]] out
+    out.reserve(filtrations.shape[0])
+    for i in range(filtrations.shape[0]):
+        out.push_back(_py21c_{{SHORT}}(filtrations[i,:]))
+    return out
+
+
+###### ------------------- CPP to PY
+
+
+## CYTHON BUG: using tuples here will cause some weird issues. 
+cdef inline _ff21cview_{{SHORT}}(One_critical_filtration[{{CTYPE}}]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t num_parameters = dereference(x).num_parameters()
+  if copy and duplicate and not dereference(x).is_finite():
+    return np.full(shape=duplicate, fill_value=dereference(x)[0])
+  cdef {{CTYPE}}[:] x_view = <{{CTYPE}}[:num_parameters]>(&(dereference(x)[0]))
+  return np.array(x_view) if copy else np.asarray(x_view)
+
+cdef inline _ff2kcview_{{SHORT}}(Multi_critical_filtration[{{CTYPE}}]* x, bool copy=False, int duplicate=0):
+  cdef Py_ssize_t k = dereference(x).num_generators()
+  return [_ff21cview_{{SHORT}}(&(dereference(x)[i]), copy=copy, duplicate=duplicate) for i in range(k)]
+
+
+cdef inline  _vff21cview_{{SHORT}}(vector[One_critical_filtration[{{CTYPE}}]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff21cview_{{SHORT}}(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+
+cdef inline  _vff2kcview_{{SHORT}}(vector[Multi_critical_filtration[{{CTYPE}}]]& x, bool copy = False, int duplicate=0):
+  cdef Py_ssize_t num_stuff = x.size()
+  return [_ff2kcview_{{SHORT}}(&(x[i]), copy=copy, duplicate=duplicate) for i in range(num_stuff)]
+
+{{endfor}}
+

multipers/filtrations/__init__.py

@@ -0,0 +1,18 @@
+from .filtrations import (
+    CoreDelaunay,
+    Cubical,
+    DegreeRips,
+    DelaunayCodensity,
+    DelaunayLowerstar,
+    RipsCodensity,
+    RipsLowerstar,
+)
+__all__ = [
+    "CoreDelaunay",
+    "Cubical",
+    "DegreeRips",
+    "DelaunayCodensity",
+    "DelaunayLowerstar",
+    "RipsCodensity",
+    "RipsLowerstar",
+]