multipers 2.3.1__cp311-cp311-win_amd64.whl → 2.3.2b1__cp311-cp311-win_amd64.whl

multipers/io.pyx

@@ -18,7 +18,7 @@ cimport cython
 current_doc_url = "https://davidlapous.github.io/multipers/"
 doc_soft_urls = {
         "mpfree":"https://bitbucket.org/mkerber/mpfree/",
-        "multi_chunk":"",
+        "multi_chunk":"https://bitbucket.org/mkerber/multi_chunk/",
         "function_delaunay":"https://bitbucket.org/mkerber/function_delaunay/",
         "2pac":"https://gitlab.com/flenzen/2pac",
         }
@@ -29,7 +29,7 @@ git clone {doc_soft_urls["mpfree"]}
 cd mpfree
 cmake . --fresh
 make
-sudo cp mpfree /usr/bin/
+cp mpfree $CONDA_PREFIX/bin/
 cd .. 
 rm -rf mpfree
 ```
@@ -40,7 +40,7 @@ git clone {doc_soft_urls["multi_chunk"]}
 cd multi_chunk
 cmake . --fresh
 make
-sudo cp multi_chunk /usr/bin/
+cp multi_chunk $CONDA_PREFIX/bin/
 cd .. 
 rm -rf multi_chunk
 ```
@@ -51,7 +51,7 @@ git clone {doc_soft_urls["function_delaunay"]}
 cd function_delaunay
 cmake . --fresh
 make
-sudo cp main /usr/bin/function_delaunay
+cp main $CONDA_PREFIX/bin/function_delaunay
 cd ..
 rm -rf function_delaunay
 ```
@@ -62,7 +62,7 @@ git clone {doc_soft_urls["2pac"]} 2pac
 cd 2pac && mkdir build && cd build
 cmake ..
 make
-sudo cp 2pac /usr/bin
+cp 2pac $CONDA_PREFIX/bin
 ```
 """,
         }
@@ -109,6 +109,13 @@ cdef dict[str,str|None] pathes = {
 input_path:str|os.PathLike = "multipers_input.scc"
 output_path:str|os.PathLike = "multipers_output.scc"
 
+def _put_temp_files_to_ram():
+    global input_path,output_path
+    shm_memory = "/tmp/"  # on unix, we can write in RAM instead of disk.
+    if os.access(shm_memory, os.W_OK) and not input_path.startswith(shm_memory):
+        input_path = shm_memory + input_path
+        output_path = shm_memory + output_path
+_put_temp_files_to_ram()
 
 
 ## TODO : optimize with Python.h ?
@@ -205,14 +212,6 @@ def scc_parser__old(path: str):
     return blocks
 
 
-
-def _put_temp_files_to_ram():
-    global input_path,output_path
-    shm_memory = "/tmp/"  # on unix, we can write in RAM instead of disk.
-    if os.access(shm_memory, os.W_OK) and not input_path.startswith(shm_memory):
-        input_path = shm_memory + input_path
-        output_path = shm_memory + output_path
-
 def _init_external_softwares(requires=[]):
     global pathes
     cdef bool any = False
@@ -262,7 +261,7 @@ def scc_reduce_from_str(
     backend: "mpfree", "multi_chunk" or "2pac"
     """
     global pathes, input_path, output_path
-    assert _check_available(backend), f"Backend {backend} is not available."
+    _init_external_softwares(requires=[backend])
 
 
     resolution_str = "--resolution" if full_resolution else ""
@@ -329,7 +328,7 @@ def scc_reduce_from_str_to_slicer(
     backend: "mpfree", "multi_chunk" or "2pac"
     """
     global pathes, input_path, output_path
-    assert _check_available(backend), f"Backend {backend} is not available."
+    _init_external_softwares(requires=[backend])
 
 
     resolution_str = "--resolution" if full_resolution else ""
@@ -448,7 +447,7 @@ def function_delaunay_presentation(
         id = str(threading.get_native_id())
     global input_path, output_path, pathes
     backend = "function_delaunay"
-    assert _check_available(backend), f"Backend {backend} is not available."
+    _init_external_softwares(requires=[backend])
 
     to_write = np.concatenate([point_cloud, function_values.reshape(-1,1)], axis=1)
     np.savetxt(input_path+id,to_write,delimiter=' ')
@@ -496,7 +495,7 @@ def function_delaunay_presentation_to_slicer(
         id = str(threading.get_native_id())
     global input_path, output_path, pathes
     backend = "function_delaunay"
-    assert _check_available(backend), f"Backend {backend} is not available."
+    _init_external_softwares(requires=[backend])
 
     to_write = np.concatenate([point_cloud, function_values.reshape(-1,1)], axis=1)
     np.savetxt(input_path+id,to_write,delimiter=' ')
@@ -527,75 +526,6 @@ def clear_io(*args):
 
 
 
-
-
-# cdef extern from "multiparameter_module_approximation/format_python-cpp.h" namespace "Gudhi::multiparameter::mma":
-    # pair[boundary_matrix, vector[One_critical_filtration[double]]] simplextree_to_boundary_filtration(intptr_t)
-    # vector[pair[ vector[vector[float]],boundary_matrix]] simplextree_to_scc(intptr_t)
-    # vector[pair[ vector[vector[vector[float]]],boundary_matrix]] function_simplextree_to_scc(intptr_t)
-    # pair[vector[vector[float]],boundary_matrix ] simplextree_to_ordered_bf(intptr_t)
-
-# def simplex_tree2boundary_filtrations(simplextree:SimplexTreeMulti | SimplexTree):
-#     """Computes a (sparse) boundary matrix, with associated filtration. Can be used as an input of approx afterwards.
-#
-#     Parameters
-#     ----------
-#     simplextree: Gudhi or mma simplextree
-#         The simplextree defining the filtration to convert to boundary-filtration.
-#
-#     Returns
-#     -------
-#     B:List of lists of ints
-#         The boundary matrix.
-#     F: List of 1D filtration
-#         The filtrations aligned with B; the i-th simplex of this simplextree has boundary B[i] and filtration(s) F[i].
-#
-#     """
-#     cdef intptr_t cptr
-#     if isinstance(simplextree, SimplexTreeMulti):
-#         cptr = simplextree.thisptr
-#     elif isinstance(simplextree, SimplexTree):
-#         temp_st = gd.SimplexTreeMulti(simplextree, parameters=1)
-#         cptr = temp_st.thisptr
-#     else:
-#         raise TypeError("Has to be a simplextree")
-#     cdef pair[boundary_matrix, vector[One_critical_filtration[double]]] cboundary_filtration = simplextree_to_boundary_filtration(cptr)
-#     boundary = cboundary_filtration.first
-#     # multi_filtrations = np.array(<vector[vector[float]]>One_critical_filtration.to_python(cboundary_filtration.second))
-#     cdef cnp.ndarray[double, ndim=2] multi_filtrations = _fmf2numpy_f64(cboundary_filtration.second)
-#     return boundary, multi_filtrations
-
-# def simplextree2scc(simplextree:SimplexTreeMulti | SimplexTree, filtration_dtype=np.float32, bool flattened=False):
-#     """
-#     Turns a simplextree into a (simplicial) module presentation.
-#     """
-#     cdef intptr_t cptr
-#     cdef bool is_function_st = False
-#     if isinstance(simplextree, SimplexTreeMulti):
-#         cptr = simplextree.thisptr
-#         is_function_st = simplextree._is_function_simplextree
-#     elif isinstance(simplextree, SimplexTree):
-#         temp_st = gd.SimplexTreeMulti(simplextree, parameters=1)
-#         cptr = temp_st.thisptr
-#     else:
-#         raise TypeError("Has to be a simplextree")
-#     
-#     cdef pair[vector[vector[float]], boundary_matrix] out
-#     if flattened:
-#         out = simplextree_to_ordered_bf(cptr)
-#         return np.asarray(out.first,dtype=filtration_dtype), tuple(out.second)
-#
-#     if is_function_st:
-#         blocks = function_simplextree_to_scc(cptr)
-#     else:
-#         blocks = simplextree_to_scc(cptr)
-#     # reduces the space in memory
-#     if is_function_st:
-#         blocks = [(tuple(f), tuple(b)) for f,b in blocks[::-1]]
-#     else:
-#         blocks = [(np.asarray(f,dtype=filtration_dtype), tuple(b)) for f,b in blocks[::-1]] ## presentation is on the other order 
-#     return blocks+[(np.empty(0,dtype=filtration_dtype),[])]
-
 @cython.boundscheck(False)
 @cython.wraparound(False)
 def scc2disk(

multipers/ml/mma.py

@@ -8,7 +8,7 @@ from tqdm import tqdm
 import multipers as mp
 import multipers.simplex_tree_multi
 import multipers.slicer
-from multipers.grids import compute_grid as reduce_grid
+from multipers.grids import compute_grid
 from multipers.mma_structures import PyBox_f64, PyModule_type
 
 _FilteredComplexType = Union[
@@ -353,7 +353,7 @@ class MMAFormatter(BaseEstimator, TransformerMixin):
         if "_mean" in strategy:
             substrategy = strategy.split("_")[0]
             processed_filtration_values = [
-                reduce_grid(f, resolution, substrategy, unique=False)
+                compute_grid(f, resolution, substrategy, unique=False)
                 for f in filtration_values
             ]
             reduced_grid = np.mean(processed_filtration_values, axis=0)
@@ -368,7 +368,7 @@ class MMAFormatter(BaseEstimator, TransformerMixin):
                 )
                 for parameter in range(num_parameters)
             ]
-            reduced_grid = reduce_grid(
+            reduced_grid = compute_grid(
                 filtration_values, resolution, strategy, unique=True
             )
 

multipers/ml/signed_measures.py

@@ -9,8 +9,9 @@ from sklearn.base import BaseEstimator, TransformerMixin
 from tqdm import tqdm
 
 import multipers as mp
-from multipers.grids import compute_grid as reduce_grid
+from multipers.array_api import api_from_tensor
 from multipers.filtrations.density import available_kernels, convolution_signed_measures
+from multipers.grids import compute_grid
 from multipers.point_measure import rank_decomposition_by_rectangles, signed_betti
 
 
@@ -145,7 +146,7 @@ class FilteredComplex2SignedMeasure(BaseEstimator, TransformerMixin):
         ## ax, num_x
         filtrations = tuple(
             tuple(
-                reduce_grid(x, strategy="exact")
+                compute_grid(x, strategy="exact")
                 for x in (X[idx][ax] for idx in indices)
             )
             for ax in range(self._num_axis)
@@ -164,7 +165,7 @@ class FilteredComplex2SignedMeasure(BaseEstimator, TransformerMixin):
         ]
         ## ax, param, gridsize
         filtration_grid = tuple(
-            reduce_grid(
+            compute_grid(
                 filtrations_values[ax],
                 resolution=self.resolution,
                 strategy=self.grid_strategy,
@@ -237,7 +238,7 @@ class FilteredComplex2SignedMeasure(BaseEstimator, TransformerMixin):
     ):
         # st = mp.SimplexTreeMulti(st, num_parameters=st.num_parameters)  # COPY
         if self.individual_grid:
-            filtration_grid = reduce_grid(
+            filtration_grid = compute_grid(
                 simplextree, strategy=self.grid_strategy, resolution=self.resolution
             )
             mass_default = (
@@ -546,6 +547,27 @@ def rescale_sparse_signed_measure(
     return out
 
 
+def sm2deep(signed_measure):
+    dirac_positions, dirac_signs = signed_measure
+    dtype = dirac_positions.dtype
+    new_shape = list(dirac_positions.shape)
+    new_shape[1] += 1
+    if isinstance(dirac_positions, np.ndarray):
+        c = np.empty(new_shape, dtype=dtype)
+        c[:, :-1] = dirac_positions
+        c[:, -1] = dirac_signs
+
+    else:
+        import torch
+
+        c = torch.empty(new_shape, dtype=dtype)
+        c[:, :-1] = dirac_positions
+        if isinstance(dirac_signs, np.ndarray):
+            dirac_signs = torch.from_numpy(dirac_signs)
+        c[:, -1] = dirac_signs
+    return c
+
+
 class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
     """
     Input
@@ -612,14 +634,8 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
         return
 
     def _get_filtration_bounds(self, X, axis):
-        if self._backend == "numpy":
-            _cat = np.concatenate
-
-        else:
-            ## torch is globally imported
-            _cat = torch.cat
         stuff = [
-            _cat(
+            self._backend.cat(
                 [sm[axis][degree][0] for sm in X],
                 axis=0,
             )
@@ -627,17 +643,20 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
         ]
         sizes_ = np.array([len(x) == 0 for x in stuff])
         assert np.all(~sizes_), f"Degree axis {np.where(sizes_)} is/are trivial !"
-        if self._backend == "numpy":
-            filtrations_bounds = np.array(
-                [([f.min(axis=0), f.max(axis=0)]) for f in stuff]
-            )
-        else:
-            filtrations_bounds = torch.stack(
+
+        filtrations_bounds = self._backend.asnumpy(
+            self._backend.stack(
                 [
-                    torch.stack([f.min(axis=0).values, f.max(axis=0).values])
+                    self._backend.stack(
+                        [
+                            self._backend.minvalues(f, axis=0),
+                            self._backend.maxvalues(f, axis=0),
+                        ]
+                    )
                     for f in stuff
                 ]
-            ).detach()  ## don't want to rescale gradient of normalization
+            )
+        )  ## don't want to rescale gradient of normalization
         normalization_factors = (
             filtrations_bounds[:, 1] - filtrations_bounds[:, 0]
             if self.normalize
@@ -700,14 +719,7 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
             first_sm = X[0][0][0][0]
         else:
             first_sm = X[0][0][0]
-        if isinstance(first_sm, np.ndarray):
-            self._backend = "numpy"
-        else:
-            global torch
-            import torch
-
-            assert isinstance(first_sm, torch.Tensor)
-            self._backend = "pytorch"
+        self._backend = api_from_tensor(first_sm, verbose=self.verbose)
 
     def _check_measures(self, X):
         if self._has_axis:
@@ -770,7 +782,7 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
             ]
             # axis, filtration_values
             filtration_values = [
-                reduce_grid(
+                compute_grid(
                     f_ax.T, resolution=self.resolution, strategy=self.grid_strategy
                 )
                 for f_ax in filtration_values
@@ -841,25 +853,6 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
         else:
             return np.asarray(out)[0]
 
-    @staticmethod
-    def deep_format_measure(signed_measure):
-        dirac_positions, dirac_signs = signed_measure
-        dtype = dirac_positions.dtype
-        new_shape = list(dirac_positions.shape)
-        new_shape[1] += 1
-        if isinstance(dirac_positions, np.ndarray):
-            c = np.empty(new_shape, dtype=dtype)
-            c[:, :-1] = dirac_positions
-            c[:, -1] = dirac_signs
-
-        else:
-            import torch
-
-            c = torch.empty(new_shape, dtype=dtype)
-            c[:, :-1] = dirac_positions
-            c[:, -1] = dirac_signs
-        return c
-
     @staticmethod
     def _integrate_measure(sm, filtrations):
         from multipers.point_measure import integrate_measure
@@ -928,7 +921,7 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
         elif self.deep_format:
             num_degrees = self._num_degrees
             out = tuple(
-                tuple(self.deep_format_measure(sm[axis][degree]) for sm in out)
+                tuple(sm2deep(sm[axis][degree]) for sm in out)
                 for degree in range(num_degrees)
                 for axis in self._axis_iterator
             )
@@ -943,11 +936,7 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
                 ), f"Bad axis/degree count. Got {num_axis_degree} (Internal error)"
                 num_parameters = out[0][0].shape[1]
                 dtype = out[0][0].dtype
-                if isinstance(out[0][0], np.ndarray):
-                    from numpy import zeros
-                else:
-                    from torch import zeros
-                unragged_tensor = zeros(
+                unragged_tensor = self._backend.zeros(
                     (
                         num_axis_degree,
                         num_data,
@@ -1027,6 +1016,7 @@ class SignedMeasure2Convolution(BaseEstimator, TransformerMixin):
         self.plot = plot
         self.log_density = log_density
         self.kde_kwargs = kde_kwargs
+        self._api = None
         return
 
     def fit(self, X, y=None):
@@ -1035,13 +1025,16 @@ class SignedMeasure2Convolution(BaseEstimator, TransformerMixin):
             return self
         if isinstance(X[0][0], tuple):
             self._is_input_sparse = True
+
+            self._api = api_from_tensor(X[0][0][0], verbose=self.progress)
         else:
             self._is_input_sparse = False
+
+            self._api = api_from_tensor(X, verbose=self.progress)
         # print(f"IMG output is set to {'sparse' if self.sparse else 'matrix'}")
         if not self._is_input_sparse:
             self._input_resolution = X[0][0].shape
             try:
-                float(self.bandwidth)
                 b = float(self.bandwidth)
                 self._bandwidths = [
                     b if b > 0 else -b * s for s in self._input_resolution
@@ -1060,24 +1053,24 @@ class SignedMeasure2Convolution(BaseEstimator, TransformerMixin):
         # If not sparse : a grid has to be defined
         if self._refit:
             # print("Fitting a grid...", end="")
-            pts = np.concatenate(
+            pts = self._api.cat(
                 [sm[0] for signed_measures in X for sm in signed_measures]
             ).T
-            self.filtration_grid = reduce_grid(
+            self.filtration_grid = compute_grid(
                 pts,
                 strategy=self.grid_strategy,
                 resolution=self.resolution,
             )
             # print('Done.')
         if self.filtration_grid is not None:
-            self.diameter = np.linalg.norm(
-                [f.max() - f.min() for f in self.filtration_grid]
+            self.diameter = self._api.norm(
+                self._api.astensor([f[-1] - f[0] for f in self.filtration_grid])
             )
             if self.progress:
                 print(f"Computed a diameter of {self.diameter}")
         return self
 
-    def _sm2smi(self, signed_measures: Iterable[np.ndarray]):
+    def _sm2smi(self, signed_measures):
         # print(self._input_resolution, self.bandwidths, _bandwidths)
         from scipy.ndimage import gaussian_filter
 
@@ -1125,6 +1118,7 @@ class SignedMeasure2Convolution(BaseEstimator, TransformerMixin):
     def _plot_imgs(self, imgs: Iterable[np.ndarray], size=4):
         from multipers.plots import plot_surface
 
+        imgs = self._api.asnumpy(imgs)
         num_degrees = imgs[0].shape[0]
         num_imgs = len(imgs)
         fig, axes = plt.subplots(
@@ -1137,7 +1131,10 @@ class SignedMeasure2Convolution(BaseEstimator, TransformerMixin):
         for i, img in enumerate(imgs):
             for j, img_of_degree in enumerate(img):
                 plot_surface(
-                    self.filtration_grid, img_of_degree, ax=axes[i, j], cmap="Spectral"
+                    [self._api.asnumpy(f) for f in self.filtration_grid],
+                    img_of_degree,
+                    ax=axes[i, j],
+                    cmap="Spectral",
                 )
 
     def transform(self, X):
@@ -1153,6 +1150,7 @@ class SignedMeasure2Convolution(BaseEstimator, TransformerMixin):
                     X, desc="Computing images", disable=not self.progress
                 )
             )
+            out = self._api.cat([x[None] for x in out])
         if self.plot and not self.flatten:
             if self.progress:
                 print("Plotting convolutions...", end="")
@@ -1160,8 +1158,8 @@ class SignedMeasure2Convolution(BaseEstimator, TransformerMixin):
             if self.progress:
                 print("Done !")
         if self.flatten and not self._is_input_sparse:
-            out = [x.flatten() for x in out]
-        return np.asarray(out)
+            out = self._api.cat([x.ravel()[None] for x in out])
+        return out
 
 
 class SignedMeasure2SlicedWassersteinDistance(BaseEstimator, TransformerMixin):

multipers/mma_structures.pxd

@@ -30,7 +30,7 @@ cdef extern from "multiparameter_module_approximation/approximation.h" namespace
         bool contains(const vector[T]&)  nogil const
         Box[T] get_bounds() nogil const
         void rescale(const vector[T]&) nogil
-
+        bool operator==(const Summand[T]&) nogil
 
 
 
@@ -86,6 +86,7 @@ cdef extern from "multiparameter_module_approximation/approximation.h" namespace
         Summand[T]& at(unsigned int)  nogil
         vector[Summand[T]].iterator begin()
         vector[Summand[T]].iterator end() 
+        bool operator==(const Module[T]&) nogil
         void clean(const bool)  nogil
         void fill(const T)  nogil
         # vector[image_type] get_vectorization(const T,const T, unsigned int,unsigned int,const Box&)

multipers/mma_structures.pyx

@@ -97,6 +97,11 @@ cdef class PySummand_f64:
             return v[0].num_parameters()
         v = self.sum.get_death_list()
         return v[0].num_parameters()
+    def __eq__(self, PySummand_f64 other):
+        return self.sum == other.sum 
+
+
+
 
 cdef inline get_summand_filtration_values_f64(Summand[double] summand):
     r"""
@@ -161,6 +166,10 @@ cdef class PyModule_f64:
 
     cdef set(self, Module[double] m):
         self.cmod = m
+
+    def __eq__(self, PyModule_f64 other):
+        return self.cmod == other.cmod
+
     def merge(self, PyModule_f64 other, int dim=-1):
         r"""
         Merges two modules into one
@@ -176,7 +185,9 @@ cdef class PyModule_f64:
         Copy module from a memory pointer. Unsafe.
         """
         self.cmod = move(dereference(<Module[double]*>(module_ptr)))
-    def set_box(self, PyBox_f64 pybox):
+    def set_box(self, box):
+        assert len(box) == 2, "Box format is [low, hight]"
+        pybox = PyBox_f64(box[0], box[1])
         cdef Box[double] cbox = pybox.box
         with nogil:
             self.cmod.set_box(cbox)
@@ -959,8 +970,8 @@ cdef dump_summand_f64(Summand[double]& summand):
     cdef vector[One_critical_filtration[double]] births = summand.get_birth_list()
     cdef vector[One_critical_filtration[double]] deaths = summand.get_death_list()
     return (
-            _vff21cview_f64(births, copy=True), ## copy as local variables
-            _vff21cview_f64(deaths, copy=True),
+            np.array(_vff21cview_f64(births)),
+            np.array(_vff21cview_f64(deaths)),
             summand.get_dimension(),
             )
 
@@ -1047,6 +1058,11 @@ cdef class PySummand_f32:
             return v[0].num_parameters()
         v = self.sum.get_death_list()
         return v[0].num_parameters()
+    def __eq__(self, PySummand_f32 other):
+        return self.sum == other.sum 
+
+
+
 
 cdef inline get_summand_filtration_values_f32(Summand[float] summand):
     r"""
@@ -1111,6 +1127,10 @@ cdef class PyModule_f32:
 
     cdef set(self, Module[float] m):
         self.cmod = m
+
+    def __eq__(self, PyModule_f32 other):
+        return self.cmod == other.cmod
+
     def merge(self, PyModule_f32 other, int dim=-1):
         r"""
         Merges two modules into one
@@ -1126,7 +1146,9 @@ cdef class PyModule_f32:
         Copy module from a memory pointer. Unsafe.
         """
         self.cmod = move(dereference(<Module[float]*>(module_ptr)))
-    def set_box(self, PyBox_f32 pybox):
+    def set_box(self, box):
+        assert len(box) == 2, "Box format is [low, hight]"
+        pybox = PyBox_f32(box[0], box[1])
         cdef Box[float] cbox = pybox.box
         with nogil:
             self.cmod.set_box(cbox)
@@ -1909,8 +1931,8 @@ cdef dump_summand_f32(Summand[float]& summand):
     cdef vector[One_critical_filtration[float]] births = summand.get_birth_list()
     cdef vector[One_critical_filtration[float]] deaths = summand.get_death_list()
     return (
-            _vff21cview_f32(births, copy=True), ## copy as local variables
-            _vff21cview_f32(deaths, copy=True),
+            np.array(_vff21cview_f32(births)),
+            np.array(_vff21cview_f32(deaths)),
             summand.get_dimension(),
             )
 
@@ -1997,6 +2019,11 @@ cdef class PySummand_i32:
             return v[0].num_parameters()
         v = self.sum.get_death_list()
         return v[0].num_parameters()
+    def __eq__(self, PySummand_i32 other):
+        return self.sum == other.sum 
+
+
+
 
 cdef inline get_summand_filtration_values_i32(Summand[int32_t] summand):
     r"""
@@ -2061,6 +2088,10 @@ cdef class PyModule_i32:
 
     cdef set(self, Module[int32_t] m):
         self.cmod = m
+
+    def __eq__(self, PyModule_i32 other):
+        return self.cmod == other.cmod
+
     def merge(self, PyModule_i32 other, int dim=-1):
         r"""
         Merges two modules into one
@@ -2076,7 +2107,9 @@ cdef class PyModule_i32:
         Copy module from a memory pointer. Unsafe.
         """
         self.cmod = move(dereference(<Module[int32_t]*>(module_ptr)))
-    def set_box(self, PyBox_i32 pybox):
+    def set_box(self, box):
+        assert len(box) == 2, "Box format is [low, hight]"
+        pybox = PyBox_i32(box[0], box[1])
         cdef Box[int32_t] cbox = pybox.box
         with nogil:
             self.cmod.set_box(cbox)
@@ -2277,8 +2310,8 @@ cdef dump_summand_i32(Summand[int32_t]& summand):
     cdef vector[One_critical_filtration[int32_t]] births = summand.get_birth_list()
     cdef vector[One_critical_filtration[int32_t]] deaths = summand.get_death_list()
     return (
-            _vff21cview_i32(births, copy=True), ## copy as local variables
-            _vff21cview_i32(deaths, copy=True),
+            np.array(_vff21cview_i32(births)),
+            np.array(_vff21cview_i32(deaths)),
             summand.get_dimension(),
             )
 
@@ -2365,6 +2398,11 @@ cdef class PySummand_i64:
             return v[0].num_parameters()
         v = self.sum.get_death_list()
         return v[0].num_parameters()
+    def __eq__(self, PySummand_i64 other):
+        return self.sum == other.sum 
+
+
+
 
 cdef inline get_summand_filtration_values_i64(Summand[int64_t] summand):
     r"""
@@ -2429,6 +2467,10 @@ cdef class PyModule_i64:
 
     cdef set(self, Module[int64_t] m):
         self.cmod = m
+
+    def __eq__(self, PyModule_i64 other):
+        return self.cmod == other.cmod
+
     def merge(self, PyModule_i64 other, int dim=-1):
         r"""
         Merges two modules into one
@@ -2444,7 +2486,9 @@ cdef class PyModule_i64:
         Copy module from a memory pointer. Unsafe.
         """
         self.cmod = move(dereference(<Module[int64_t]*>(module_ptr)))
-    def set_box(self, PyBox_i64 pybox):
+    def set_box(self, box):
+        assert len(box) == 2, "Box format is [low, hight]"
+        pybox = PyBox_i64(box[0], box[1])
         cdef Box[int64_t] cbox = pybox.box
         with nogil:
             self.cmod.set_box(cbox)
@@ -2645,8 +2689,8 @@ cdef dump_summand_i64(Summand[int64_t]& summand):
     cdef vector[One_critical_filtration[int64_t]] births = summand.get_birth_list()
     cdef vector[One_critical_filtration[int64_t]] deaths = summand.get_death_list()
     return (
-            _vff21cview_i64(births, copy=True), ## copy as local variables
-            _vff21cview_i64(deaths, copy=True),
+            np.array(_vff21cview_i64(births)),
+            np.array(_vff21cview_i64(deaths)),
             summand.get_dimension(),
             )