multipers 2.3.3b7__cp313-cp313-win_amd64.whl → 2.3.5b1__cp313-cp313-win_amd64.whl

multipers/_signed_measure_meta.py

@@ -2,6 +2,7 @@ from collections.abc import Iterable, Sequence
 from typing import Optional, Union
 
 import numpy as np
+import time
 
 from multipers.grids import compute_grid, sms_in_grid
 from multipers.plots import plot_signed_measures
@@ -176,10 +177,12 @@ def signed_measure(
 
     if not filtered_complex.is_squeezed:
         if verbose:
-            print("Coarsening complex...", end="")
+            print("Coarsening complex...", end="",flush=True)
+            t0 = time.time()
         filtered_complex_ = filtered_complex.grid_squeeze(grid)
+
         if verbose:
-            print("Done.")
+            print(f"Done. ({time.time() - t0:.3f}s)")
     else:
         filtered_complex_ = filtered_complex.copy()
 
@@ -190,26 +193,18 @@ def signed_measure(
         else:
             max_degree = np.max(degrees) + 1
             if verbose:
-                print(f"Pruning simplicies up to {max_degree}...", end="")
+                print(f"Pruning simplicies up to {max_degree}...", end="", flush=True)
+                t0 = time.time()
             if filtered_complex_.dimension > max_degree:
                 filtered_complex_.prune_above_dimension(max_degree)
             if verbose:
-                print("Done.")
+                print(f"Done. ({time.time() - t0:.3f}s)")
 
     num_parameters = filtered_complex.num_parameters
     assert num_parameters == len(
         grid
     ), f"Number of parameter do not coincide. Got (grid) {len(grid)} and (filtered complex) {num_parameters}."
 
-    # if is_simplextree_multi(filtered_complex_):
-    #     # if num_collapses != 0:
-    #     #     if verbose:
-    #     #         print("Collapsing edges...", end="")
-    #     #     filtered_complex_.collapse_edges(num_collapses)
-    #     #     if verbose:
-    #     #         print("Done.")
-    #     # if backend is not None:
-    #     #     filtered_complex_ = mp.Slicer(filtered_complex_, vineyard=vineyard)
 
     fix_mass_default = mass_default is not None
     if is_slicer(filtered_complex_):
@@ -217,59 +212,14 @@ def signed_measure(
             print("Input is a slicer.")
         if backend is not None and not filtered_complex_.is_minpres:
             raise ValueError("giving a backend to this function is deprecated")
-        #     from multipers.slicer import minimal_presentation
-        #
-        #     assert (
-        #         invariant != "euler"
-        #     ), "Euler Characteristic cannot be speed up by a backend"
-        #     # This returns a list of reduced complexes
-        #     if verbose:
-        #         print("Reducing complex...", end="")
-        #     reduced_complex = minimal_presentation(
-        #         filtered_complex_,
-        #         degrees=degrees,
-        #         backend=backend,
-        #         vineyard=vineyard,
-        #         verbose=verbose,
-        #     )
-        #     if verbose:
-        #         print("Done.")
-        #     if invariant is not None and "rank" in invariant:
-        #         if verbose:
-        #             print("Computing rank...", end="")
-        #         sms = [
-        #             _rank_from_slicer(
-        #                 s,
-        #                 degrees=[d],
-        #                 n_jobs=n_jobs,
-        #                 # grid_shape=tuple(len(g) for g in grid),
-        #                 zero_pad=fix_mass_default,
-        #                 ignore_inf=ignore_infinite_filtration_values,
-        #             )[0]
-        #             for s, d in zip(reduced_complex, degrees)
-        #         ]
-        #         fix_mass_default = False
-        #         if verbose:
-        #             print("Done.")
-        #     else:
-        #         if verbose:
-        #             print("Reduced slicer. Retrieving measure from it...", end="")
-        #         sms = [
-        #             _signed_measure_from_slicer(
-        #                 s,
-        #                 shift=(
-        #                     reduced_complex.minpres_degree & 1 if d is None else d & 1
-        #                 ),
-        #             )[0]
-        #             for s, d in zip(reduced_complex, degrees)
-        #         ]
-        #         if verbose:
-        #             print("Done.")
         else:  # No backend
-            if invariant is not None and ("rank" in invariant or "hook" in invariant or "rectangle" in invariant):
+            if invariant is not None and (
+                "rank" in invariant or "hook" in invariant or "rectangle" in invariant
+            ):
                 degrees = np.asarray(degrees, dtype=int)
                 if verbose:
-                    print("Computing rank...", end="")
+                    print("Computing rank...", end="", flush=True)
+                    t0 = time.time()
                 sms = _rank_from_slicer(
                     filtered_complex_,
                     degrees=degrees,
@@ -280,10 +230,11 @@ def signed_measure(
                 )
                 fix_mass_default = False
                 if verbose:
-                    print("Done.")
+                    print(f"Done. ({time.time() - t0:.3f}s)")
             elif filtered_complex_.is_minpres:
                 if verbose:
-                    print("Reduced slicer. Retrieving measure from it...", end="")
+                    print("Reduced slicer. Retrieving measure from it...", end="",flush=True)
+                    t0 = time.time()
                 sms = [
                     _signed_measure_from_slicer(
                         filtered_complex_,
@@ -294,21 +245,23 @@ def signed_measure(
                     for d in degrees
                 ]
                 if verbose:
-                    print("Done.")
+                    print(f"Done. ({time.time() - t0:.3f}s)")
             elif (invariant is None or "euler" in invariant) and (
                 len(degrees) == 1 and degrees[0] is None
             ):
                 if verbose:
-                    print("Retrieving measure from slicer...", end="")
+                    print("Retrieving measure from slicer...", end="",flush=True)
+                    t0 = time.time()
                 sms = _signed_measure_from_slicer(
                     filtered_complex_,
                     shift=0,  # no minpres
                 )
                 if verbose:
-                    print("Done.")
+                    print(f"Done. ({time.time() - t0:.3f}s)")
             else:
                 if verbose:
-                    print("Computing Hilbert function...", end="")
+                    print("Computing Hilbert function...", end="", flush=True)
+                    t0 = time.time()
                 sms = _hilbert_signed_measure(
                     filtered_complex_,
                     degrees=degrees,
@@ -319,7 +272,7 @@ def signed_measure(
                 )
                 fix_mass_default = False
                 if verbose:
-                    print("Done.")
+                    print(f"Done. ({time.time() - t0:.3f}s)")
 
     elif is_simplextree_multi(filtered_complex_):
         if verbose:
@@ -327,7 +280,9 @@ def signed_measure(
         ## we still have a simplextree here
         if invariant in ["rank_invariant", "rank", "hook", "rectangle"]:
             if verbose:
-                print("Computing rank invariant...", end="")
+                print("Computing rank invariant...", end="", flush=True)
+                t0 = time.time()
+
             assert (
                 num_parameters == 2
             ), "Rank invariant only implemented for 2-parameter modules."
@@ -342,10 +297,11 @@ def signed_measure(
             )
             fix_mass_default = False
             if verbose:
-                print("Done.")
+                print(f"Done. ({time.time() - t0:.3f}s)")
         elif len(degrees) == 1 and degrees[0] is None:
             if verbose:
-                print("Computing Euler Characteristic...", end="")
+                print("Computing Euler Characteristic...", end="", flush=True)
+                t0 = time.time()
             assert invariant is None or invariant in [
                 "euler",
                 "euler_characteristic",
@@ -362,10 +318,11 @@ def signed_measure(
             ]
             fix_mass_default = False
             if verbose:
-                print("Done.")
+                print(f"Done. ({time.time() - t0:.3f}s)")
         else:
             if verbose:
-                print("Computing Hilbert Function...", end="")
+                print("Computing Hilbert Function...", end="", flush=True)
+                t0 = time.time()
             assert invariant is None or invariant in [
                 "hilbert",
                 "hilbert_function",
@@ -384,19 +341,21 @@ def signed_measure(
             )
             fix_mass_default = False
             if verbose:
-                print("Done.")
+                print(f"Done. ({time.time() - t0:.3f}s)")
     else:
         raise ValueError("Filtered complex has to be a SimplexTree or a Slicer.")
 
     if clean:
         if verbose:
-            print("Cleaning measure...", end="")
+            print("Cleaning measure...", end="",flush=True)
+            t0 = time.time()
         sms = clean_sms(sms)
         if verbose:
-            print("Done.")
+            print(f"Done. ({time.time() - t0:.3f}s)")
     if grid is not None and not coordinate_measure:
         if verbose:
-            print("Pushing back the measure to the grid...", end="")
+            print("Pushing back the measure to the grid...", end="", flush=True)
+            t0 = time.time()
         sms = sms_in_grid(
             sms,
             grid=grid,
@@ -404,21 +363,28 @@ def signed_measure(
             # num_parameters=num_parameters,
         )
         if verbose:
-            print("Done.")
+            print(f"Done. ({time.time() - t0:.3f}s)")
 
     if fix_mass_default:
         # TODO : some methods need to use this, this could be optimized
         if verbose:
-            print("Seems that fixing mass default is necessary...", end="")
+            print("Seems that fixing mass default is necessary...", end="", flush=True)
+            t0 = time.time()
         sms = zero_out_sms(sms, mass_default=mass_default)
         if verbose:
-            print("Done.")
+            print(f"Done. ({time.time() - t0:.3f}s)")
 
     if invariant == "hook":
+        if verbose:
+            print("Converting rank decomposition to hook decomposition...", end="",flush=True)
+            t0 = time.time()
         from multipers.point_measure import rectangle_to_hook_minimal_signed_barcode
-        sms = [rectangle_to_hook_minimal_signed_barcode(pts,w) for pts,w in sms]
+
+        sms = [rectangle_to_hook_minimal_signed_barcode(pts, w) for pts, w in sms]
+        if verbose:
+            print(f"Done. ({time.time() - t0:.3f}s)")
     if plot:
-        plot_signed_measures(sms)
+        plot_signed_measures(sms, alpha=1 if invariant == "hook" else None)
     return sms
 
 

multipers/array_api/numpy.py

@@ -31,17 +31,19 @@ def check_keops():
     global _is_keops_available, LazyTensor
     if _is_keops_available is not None:
         return _is_keops_available
-    import pykeops.numpy as pknp
-    from pykeops.numpy import LazyTensor as LT
-
-    formula = "SqNorm2(x - y)"
-    var = ["x = Vi(3)", "y = Vj(3)"]
-    expected_res = _np.array([63.0, 90.0])
-    x = _np.arange(1, 10).reshape(-1, 3).astype("float32")
-    y = _np.arange(3, 9).reshape(-1, 3).astype("float32")
-
-    my_conv = pknp.Genred(formula, var)
     try:
+        if _is_keops_available is not None:
+            return _is_keops_available
+        import pykeops.numpy as pknp
+        from pykeops.numpy import LazyTensor as LT
+
+        formula = "SqNorm2(x - y)"
+        var = ["x = Vi(3)", "y = Vj(3)"]
+        expected_res = _np.array([63.0, 90.0])
+        x = _np.arange(1, 10).reshape(-1, 3).astype("float32")
+        y = _np.arange(3, 9).reshape(-1, 3).astype("float32")
+
+        my_conv = pknp.Genred(formula, var)
         _is_keops_available = _np.allclose(my_conv(x, y).flatten(), expected_res)
         LazyTensor = LT
     except:

multipers/array_api/torch.py

@@ -41,7 +41,7 @@ def check_keops():
 
         my_conv = pknp.Genred(formula, var)
         _is_keops_available = _t.allclose(
-            my_conv(x, y).view(-1), _t.tensor(expected_res).type(_t.float32)
+            my_conv(x, y).view(-1), expected_res.type(_t.float32)
         )
         LazyTensor = LT
 
@@ -55,6 +55,9 @@ def check_keops():
     return _is_keops_available
 
 
+check_keops()
+
+
 def from_numpy(x):
     return _t.from_numpy(x)
 
@@ -100,8 +103,8 @@ def maxvalues(x: _t.Tensor, **kwargs):
     return _t.max(x, **kwargs).values
 
 
-def asnumpy(x):
-    return x.detach().numpy()
+def asnumpy(x: _t.Tensor):
+    return x.cpu().detach().numpy()
 
 
 def is_tensor(x):

multipers/filtrations/filtrations.py

@@ -76,9 +76,10 @@ def RipsLowerstar(
         st.fill_lowerstar(api.asnumpy(function[:, i]), parameter=1 + i)
     if api.has_grad(D) or api.has_grad(function):
         from multipers.grids import compute_grid
-
-        grid = compute_grid([D.ravel(), *[f for f in function.T]])
+        filtration_values = [D.ravel(), *[f for f in function.T]]
+        grid = compute_grid(filtration_values)
         st = st.grid_squeeze(grid)
+        st._clean_filtration_grid()
     return st
 
 
@@ -239,6 +240,7 @@ def Cubical(image: ArrayLike, **slicer_kwargs):
             ).reshape(slice_shape)
         slicer = from_bitmap(coord_img, **slicer_kwargs)
         slicer.filtration_grid = grid
+        slicer._clean_filtration_grid()
         return slicer
 
     return from_bitmap(image, **slicer_kwargs)

multipers/grids.pyx

@@ -124,8 +124,7 @@ def compute_grid(
     except TypeError:
         pass
 
-    if api is npapi:
-        return _compute_grid_numpy(
+    grid = _compute_grid_numpy(
         initial_grid,
         resolution=resolution, 
         strategy = strategy, 
@@ -133,9 +132,9 @@ def compute_grid(
         _q_factor=_q_factor, 
         drop_quantiles=drop_quantiles,
         dense = dense,
-        )
-    from multipers.torch.diff_grids import get_grid
-    grid = get_grid(strategy)(initial_grid,resolution)
+    )
+    # from multipers.torch.diff_grids import get_grid
+    # grid = get_grid(strategy)(initial_grid,resolution)
     if dense:
         grid = todense(grid)
     return grid
@@ -169,7 +168,7 @@ def _compute_grid_numpy(
     Iterable[array[float, ndim=1]] : the 1d-grid for each parameter.
     """
     num_parameters = len(filtrations_values)
-    api = api_from_tensors(filtrations_values)
+    api = api_from_tensors(*filtrations_values)
     try:
         a,b=drop_quantiles
     except:
@@ -189,7 +188,7 @@ def _compute_grid_numpy(
     elif strategy == "quantile":
         F = tuple(api.unique(f) for f in filtrations_values)
         max_resolution = [min(len(f),r) for f,r in zip(F,resolution)]
-        F = tuple( api.quantile_closest(f, q=np.linspace(0,1,num=int(r*_q_factor)), axis=0) for f,r in zip(F, resolution) )
+        F = tuple( api.quantile_closest(f, q=api.linspace(0,1,int(r*_q_factor)), axis=0) for f,r in zip(F, resolution) )
         if unique:
             F = tuple(api.unique(f) for f in F)
             if np.all(np.asarray(max_resolution) > np.asarray([len(f) for f in F])):
@@ -203,7 +202,7 @@ def _compute_grid_numpy(
     # elif strategy == "torch_regular_closest":
     #     F = tuple(_torch_regular_closest(f,r, unique) for f,r in zip(filtrations_values, resolution))
     elif strategy == "partition":
-        F = tuple(_todo_partition(f,r, unique) for f,r in zip(filtrations_values, resolution))
+        F = tuple(_todo_partition(f,r, unique, api) for f,r in zip(filtrations_values, resolution))
     elif strategy == "precomputed":
         F=filtrations_values
     else:
@@ -215,7 +214,7 @@ def _compute_grid_numpy(
 def todense(grid, bool product_order=False):
     if len(grid) == 0:
         return np.empty(0)
-    api = api_from_tensors(grid)
+    api = api_from_tensors(*grid)
     # if product_order:
     #     if not api.backend ==np:
     #         raise NotImplementedError("only numpy here.")
@@ -235,8 +234,10 @@ def todense(grid, bool product_order=False):
 
 
 
-## TODO : optimize. Pykeops ?
 def _todo_regular(f, int r, api):
+    if api.has_grad(f):
+        from warnings import warn
+        warn("`strategy=regular` is not differentiable. Removing grad.")
     with api.no_grad():
         return api.linspace(api.min(f), api.max(f), r)
 
@@ -284,8 +285,14 @@ def _todo_regular_left_old(some_float[:] f, int r, bool unique):
     if unique: f_regular_closest = np.unique(f_regular_closest)
     return f_regular_closest
 
+def _todo_partition(x, int resolution, bool unique, api):
+    if api.has_grad(x):
+        from warnings import warn
+        warn("`strategy=partition` is not differentiable. Removing grad.")
+    out = _todo_partition_(api.asnumpy(x), resolution, unique)
+    return api.from_numpy(out)
 
-def _todo_partition(some_float[:] data,int resolution, bool unique):
+def _todo_partition_(some_float[:] data,int resolution, bool unique):
     if data.shape[0] < resolution: resolution=data.shape[0]
     k = data.shape[0] // resolution
     partitions = np.partition(data, k)
@@ -362,7 +369,7 @@ def _inf_value(array):
         return torch.iinfo(dtype).max
     raise ValueError(f"Dtype must be integer or floating like (got {dtype})")
 
-def evaluate_in_grid(pts, grid, mass_default=None):
+def evaluate_in_grid(pts, grid, mass_default=None, input_inf_value=None, output_inf_value=None):
     """    
     Input
     -----
@@ -372,28 +379,21 @@ def evaluate_in_grid(pts, grid, mass_default=None):
     assert pts.ndim == 2
     first_filtration = grid[0]
     dtype = first_filtration.dtype
-    if isinstance(first_filtration, np.ndarray):
-        if mass_default is not None:
-            grid = tuple(np.concatenate([g, [m]]) for g,m in zip(grid, mass_default))
-        def empty_like(x):
-            return np.empty_like(x, dtype=dtype)
-    else: 
-        import torch
-        # assert isinstance(first_filtration, torch.Tensor), f"Invalid grid type. Got {type(grid[0])}, expected numpy or torch array."
-        if mass_default is not None:
-            grid = tuple(torch.cat([g, torch.tensor(m)[None]]) for g,m in zip(grid, mass_default))
-        def empty_like(x):
-            return torch.empty(x.shape,dtype=dtype)
+    api = api_from_tensors(*grid)
+    if mass_default is not None:
+        grid = tuple(api.cat([g, api.astensor(m)[None]]) for g,m in zip(grid, mass_default))
+    def empty_like(x):
+        return api.empty(x.shape, dtype=dtype)
 
     coords=empty_like(pts)
     cdef int dim = coords.shape[1]
-    pts_inf = _inf_value(pts)
-    coords_inf = _inf_value(coords)
+    pts_inf = _inf_value(pts) if input_inf_value is None else input_inf_value
+    coords_inf = _inf_value(coords) if output_inf_value is None else output_inf_value
     idx = np.argwhere(pts == pts_inf)
-    pts[idx] == 0
+    pts[idx[:,0],idx[:,1]] = 0
     for i in range(dim):
         coords[:,i] = grid[i][pts[:,i]]
-    coords[idx] = coords_inf
+    coords[idx[:,0],idx[:,1]] = coords_inf
     return coords
 
 def sm_in_grid(pts, weights, grid, mass_default=None):
@@ -445,8 +445,9 @@ def sms_in_grid(sms, grid, mass_default=None):
     return sms
 
 
-def _push_pts_to_line(pts, basepoint, direction=None):
-    api = api_from_tensors(pts, basepoint)
+def _push_pts_to_line(pts, basepoint, direction=None, api=None):
+    if api is None:
+        api = api_from_tensors(pts, basepoint)
     pts = api.astensor(pts)
     basepoint = api.astensor(basepoint)
     num_parameters = basepoint.shape[0]
@@ -472,3 +473,23 @@ def _push_pts_to_line(pts, basepoint, direction=None):
     else:
         xs = xa
     return xs.squeeze()
+
+def _push_pts_to_lines(pts, basepoints, directions=None, api=None):
+    if api is None:
+        api = api_from_tensors(pts,basepoints)
+    cdef int num_lines = len(basepoints)
+    cdef int num_pts = len(pts)
+
+    pts = api.astensor(pts)
+    basepoints = api.astensor(basepoints)
+    if directions is None:
+        directions = [None]*num_lines
+    else:
+        directions = api.astensor(directions)
+
+    out = api.empty((num_lines, num_pts), dtype=pts.dtype)
+    for i in range(num_lines):
+        out[i] = _push_pts_to_line(pts, basepoints[i], directions[i], api=api)[None]
+    return out
+
+

multipers/gudhi/gudhi/Multi_critical_filtration.h

@@ -805,7 +805,7 @@ class Multi_critical_filtration {
         res.add_generator(nf);
       }
     }
-    swap(f1, res);
+    std::swap(f1, res);
 
     return f1 != res;
   }

multipers/multi_parameter_rank_invariant/function_rips.h

@@ -61,7 +61,7 @@ inline get_degree_filtrations( // also return max_degree,filtration_values
   // preprocess
   filtration_lists edge_filtration_of_nodes(st.num_vertices());
   for (auto sh : st.complex_simplex_range()) {
-    if (st.dimension() == 0)
+    if (st.dimension(sh) == 0)
       continue;
     value_type filtration = st.filtration(sh);
     for (auto node : st.simplex_vertex_range(sh)) {

multipers/multiparameter_module_approximation/approximation.h

@@ -1477,8 +1477,14 @@ std::vector<int> inline to_grid_coord(const Gudhi::multi_filtration::One_critica
       out[i] = grid[i].size() - 1;
     else if (pt[i] <= grid[i][0]) [[unlikely]] {
       out[i] = 0;
-    } else
-      out[i] = std::distance(grid[i].begin(), std::lower_bound(grid[i].begin(), grid[i].end(), pt[i]));
+    } else {
+      auto temp = std::distance(grid[i].begin(), std::lower_bound(grid[i].begin(), grid[i].end(), pt[i]));
+      if (std::abs(grid[i][temp] - pt[i]) < std::abs(grid[i][temp - 1] - pt[i])) {
+        out[i] = temp;
+      } else {
+        out[i] = temp - 1;
+      }
+    }
   }
   return out;
 }

multipers/plots.py

@@ -81,7 +81,8 @@ def _plot_signed_measure_4(
     **plt_kwargs,  # ignored ftm
 ):
     # compute the maximal rectangle area
-    pts = np.clip(pts, a_min=-np.inf, a_max=np.array((*threshold, *threshold))[None, :])
+    pts = np.clip(pts, a_min=-np.inf,
+                  a_max=np.array((*threshold, *threshold))[None, :])
     alpha_rescaling = 0
     for rectangle, weight in zip(pts, weights):
         if rectangle[2] >= x_smoothing * rectangle[0]:
@@ -161,7 +162,7 @@ def plot_signed_measure(signed_measure, threshold=None, ax=None, **plt_kwargs):
         )
 
 
-def plot_signed_measures(signed_measures, threshold=None, size=4):
+def plot_signed_measures(signed_measures, threshold=None, size=4, alpha=None):
     num_degrees = len(signed_measures)
     if num_degrees <= 1:
         axes = [plt.gca()]
@@ -170,7 +171,9 @@ def plot_signed_measures(signed_measures, threshold=None, size=4):
             nrows=1, ncols=num_degrees, figsize=(num_degrees * size, size)
         )
     for ax, signed_measure in zip(axes, signed_measures):
-        plot_signed_measure(signed_measure=signed_measure, ax=ax, threshold=threshold)
+        plot_signed_measure(signed_measure=signed_measure,
+                            ax=ax, threshold=threshold,
+                            alpha=alpha)
     plt.tight_layout()
 
 
@@ -200,13 +203,17 @@ def plot_surface(
             cmap = matplotlib.colormaps["gray_r"]
         else:
             cmap = _cmap
+    if discrete_surface or not contour:
+        # for shading="flat"
+        grid = [np.concatenate([g, [g[-1]*1.1 - .1*g[0]]]) for g in grid]
     if discrete_surface:
         if has_negative_values:
             bounds = np.arange(-5, 6, 1, dtype=int)
         else:
             bounds = np.arange(0, 11, 1, dtype=int)
         norm = matplotlib.colors.BoundaryNorm(bounds, cmap.N, extend="max")
-        im = ax.pcolormesh(grid[0], grid[1], hf.T, cmap=cmap, norm=norm, **plt_args)
+        im = ax.pcolormesh(grid[0], grid[1], hf.T, cmap=cmap,
+                           norm=norm, shading="flat", **plt_args)
         cbar = fig.colorbar(
             matplotlib.cm.ScalarMappable(cmap=cmap, norm=norm),
             spacing="proportional",
@@ -217,9 +224,11 @@ def plot_surface(
 
     if contour:
         levels = plt_args.pop("levels", 50)
-        im = ax.contourf(grid[0], grid[1], hf.T, cmap=cmap, levels=levels, **plt_args)
+        im = ax.contourf(grid[0], grid[1], hf.T,
+                         cmap=cmap, levels=levels, **plt_args)
     else:
-        im = ax.pcolormesh(grid[0], grid[1], hf.T, cmap=cmap, **plt_args)
+        im = ax.pcolormesh(grid[0], grid[1], hf.T,
+                           cmap=cmap,  shading="flat", **plt_args)
     return im
 
 
@@ -314,25 +323,30 @@ def plot2d_PyModule(
                         trivial_summand = False
                     if shapely:
                         list_of_rect.append(
-                            _rectangle_box(birth[0], birth[1], death[0], death[1])
+                            _rectangle_box(
+                                birth[0], birth[1], death[0], death[1])
                         )
                     else:
                         list_of_rect.append(
-                            _rectangle(birth, death, cmap(i / n_summands), alpha)
+                            _rectangle(birth, death, cmap(
+                                i / n_summands), alpha)
                         )
         if not (trivial_summand):
             if separated:
                 fig, ax = plt.subplots()
-                ax.set(xlim=[box[0][0], box[1][0]], ylim=[box[0][1], box[1][1]])
+                ax.set(xlim=[box[0][0], box[1][0]],
+                       ylim=[box[0][1], box[1][1]])
             if shapely:
                 summand_shape = union_all(list_of_rect)
                 if type(summand_shape) is _Polygon:
                     xs, ys = summand_shape.exterior.xy
-                    ax.fill(xs, ys, alpha=alpha, fc=cmap(i / n_summands), ec="None")
+                    ax.fill(xs, ys, alpha=alpha, fc=cmap(
+                        i / n_summands), ec="None")
                 else:
                     for polygon in summand_shape.geoms:
                         xs, ys = polygon.exterior.xy
-                        ax.fill(xs, ys, alpha=alpha, fc=cmap(i / n_summands), ec="None")
+                        ax.fill(xs, ys, alpha=alpha, fc=cmap(
+                            i / n_summands), ec="None")
             else:
                 for rectangle in list_of_rect:
                     ax.add_patch(rectangle)
@@ -396,7 +410,8 @@ def plot_simplicial_complex(
         if len(s) == 2:  # simplexe = segment
             xx = np.array([pts[a, 0] for a in s])
             yy = np.array([pts[a, 1] for a in s])
-            plt.plot(xx, yy, c=color(density), alpha=1, zorder=10 * density, lw=1.5)
+            plt.plot(xx, yy, c=color(density), alpha=1,
+                     zorder=10 * density, lw=1.5)
         if len(s) == 3:  # simplexe = triangle
             xx = np.array([pts[a, 0] for a in s])
             yy = np.array([pts[a, 1] for a in s])