multipers package

Subpackages

Submodules

multipers._signed_measure_meta module

multipers._signed_measure_meta.signed_measure(filtered_complex, degree=None, degrees=[], mass_default=None, grid_strategy='exact', invariant=None, plot=False, verbose=False, n_jobs=-1, expand_collapse=False, backend=None, grid=None, coordinate_measure=False, num_collapses=0, clean=None, vineyard=False, grid_conversion=None, ignore_infinite_filtration_values=True, **infer_grid_kwargs)

Computes the signed measures given by the decomposition of the hilbert function or the euler characteristic, or the rank invariant.

Input

  • filtered_complex: given by a simplextree or a slicer.

  • degree:int|None / degrees:list[int] the degrees to compute. None represents the euler characteristic.

  • 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. This corresponds to zero-out the filtered complex outside of ${ xin mathbb R^n mid xle mass_default}$

  • invariant: The invariant to use, either “hilbert”, “rank”, or “euler”.

  • plot:bool, plots the computed measures if true.

  • n_jobs:int, number of jobs. Defaults to #cpu.

  • verbose:bool, prints c++ logs.

  • expand_collapse: when the input is a simplextree, only expands the complex when computing 1-dimensional slices. Meant to reduce memory footprint at some computational expense.

  • backend:str reduces first the filtered complex using some external backend backend,

    see backend in multipers.ops.minimal_presentation().

  • grid: If given, the computations will be done on the restriction of the filtered complex to this grid.

    It can also be used for auto-differentiation, i.e., if the grid is a list of pytorch tensors, then the output measure will be pytorch-differentiable.

  • grid_strategy: If not squeezed yet, and no grid is given, the strategy to coarsen the grid; see strategy in multipers.grids.compute_grid().

  • coordinate_measure: bool, if True, compute the signed measure as a coordinates given in grid.

  • num_collapses: int, if filtered_complex is a simplextree, does some collapses if possible.

  • clean: if True, reduces the measure. It is not necessary in general.

  • ignore_infinite_filtration_values: Backend optimization.

Output

[signed_measure_of_degree for degree in degrees] with signed_measure_of_degree of the form (dirac location, dirac weights).

Notes on computational backends

There are several backends for each of these computations. The backend for computations used can be displayed with verbose=True, use it! Also note that if backend is given, then the input will be converted to a slicer.

  • Euler: is always computed by summing the weights of the simplices

  • Hilbert: is computed by computing persistence on slices, and a Möbius inversion, unless the detected input is a minimal presentation (i.e., filtered_complex.is_minpres), which in that case, doesn’t need any computation. - If the input is a simplextree, this is done via a the standard Gudhi implementation,

    with parallel (TBB) computations of slices.

    • If the input is a slicer then - If the input is vineyard-capable, then slices are computed via vineyards updates.

      It is slower in general, but faster if single threaded. In particular, it is usually faster to use this backend if you want to compute the signed measure of multiple datasets in a parallel context.

      • Otherwise, slices are computed in parallel. It is usually faster to use this backend if not in a parallel context.

  • Rank: Same as Hilbert.

Parameters:
Return type:

list[tuple[ndarray, ndarray]]

multipers._simplextree_algorithms module

multipers._simplextree_algorithms._euler_signed_measure(simplextree, mass_default=None, verbose=False)
multipers._simplextree_algorithms._hilbert_signed_measure(simplextree, degrees, mass_default=None, plot=False, n_jobs=0, verbose=False, expand_collapse=False)
multipers._simplextree_algorithms._rank_signed_measure(simplextree, degrees, mass_default=None, plot=False, n_jobs=0, verbose=False, expand_collapse=False)

multipers._slicer_algorithms module

multipers._slicer_algorithms._hilbert_signed_measure(slicer, degrees, zero_pad=False, n_jobs=0, verbose=False, ignore_inf=True)
multipers._slicer_algorithms._rank_from_slicer(slicer, degrees, verbose=False, n_jobs=1, zero_pad=False, grid_shape=None, plot=False, return_raw=False, ignore_inf=True)

multipers._slicer_meta module

multipers._slicer_meta.Slicer(st=None, vineyard=None, reduce=False, reduce_backend=None, dtype=None, kcritical=None, column_type=None, backend=None, filtration_container=None, max_dim=None, return_type_only=False, _shift_dimension=0)

Given a simplextree, slicer, or SCC file path, returns a structure that can compute persistence on line (or more) slices, eventually vineyard update, etc.

This can be used to compute interval-decomposable module approximations or signed measures, using, e.g.

  • multipers.module_approximation(this, *args)

  • multipers.signed_measure(this, *args)

Input

  • st : SimplexTreeMulti, slicer, or path to an SCC file

  • backend: slicer backend, e.g, “matrix”, “clement”, “graph”

  • vineyard: vineyard capable (may slow down computations if true)

Output

The corresponding slicer.

Parameters:

  • vineyard (bool | None)

  • reduce (bool)

  • reduce_backend (str | None)

  • dtype (Any | None)

  • kcritical (bool | None)

  • column_type (str | None)

  • backend (str | None)

  • filtration_container (str | None)

  • max_dim (int | None)

  • return_type_only (bool)

  • _shift_dimension (int)

Return type:

_KFlatSlicer_Matrix0_vine_i32 | _KContiguousSlicer_Matrix0_vine_i32 | _KFlatSlicer_Matrix0_vine_f64 | _KContiguousSlicer_Matrix0_vine_f64 | _KFlatSlicer_Matrix0_vine_i64 | _KContiguousSlicer_Matrix0_vine_i64 | _KFlatSlicer_Matrix0_vine_f32 | _KContiguousSlicer_Matrix0_vine_f32 | _ContiguousSlicer_Matrix0_vine_i32 | _ContiguousSlicer_Matrix0_vine_f64 | _ContiguousSlicer_Matrix0_vine_i64 | _ContiguousSlicer_Matrix0_vine_f32 | _KFlatSlicer_Matrix0_i32 | _KContiguousSlicer_Matrix0_i32 | _KFlatSlicer_Matrix0_f64 | _KContiguousSlicer_Matrix0_f64 | _KFlatSlicer_Matrix0_i64 | _KContiguousSlicer_Matrix0_i64 | _KFlatSlicer_Matrix0_f32 | _KContiguousSlicer_Matrix0_f32 | _ContiguousSlicer_Matrix0_i32 | _ContiguousSlicer_Matrix0_f64 | _ContiguousSlicer_Matrix0_i64 | _ContiguousSlicer_Matrix0_f32 | _KFlatSlicer_GudhiCohomology0_i32 | _KContiguousSlicer_GudhiCohomology0_i32 | _KFlatSlicer_GudhiCohomology0_f64 | _KContiguousSlicer_GudhiCohomology0_f64 | _KFlatSlicer_GudhiCohomology0_i64 | _KContiguousSlicer_GudhiCohomology0_i64 | _KFlatSlicer_GudhiCohomology0_f32 | _KContiguousSlicer_GudhiCohomology0_f32 | _ContiguousSlicer_GudhiCohomology0_i32 | _ContiguousSlicer_GudhiCohomology0_f64 | _ContiguousSlicer_GudhiCohomology0_i64 | _ContiguousSlicer_GudhiCohomology0_f32

multipers._slicer_meta._slicer_from_simplextree(st, backend, vineyard)

multipers.distances module

multipers.distances._can_use_native_monte_carlo_matching_distance(left, right)
Return type:

bool

multipers.distances._compute_signed_measure_projections(X, num_directions, scales=None, api=None, seed=42)
Parameters:

seed (int)

multipers.distances._extract_measure(entry, api)
multipers.distances._get_monte_carlo_line_reduction(line_reduction)
Parameters:

line_reduction (str)

Return type:

None

multipers.distances._infer_api(X, Y=None, api=None)
multipers.distances._iter_arrays(obj)
multipers.distances._matching_distance_monte_carlo(left, right, degree, *, num_lines, seed, line_oversampling, fpsample_bucket_height, line_distance_delta, n_jobs, wasserstein_order, line_reduction, return_stats, api=None, basepoints=None, directions=None)
Parameters:

  • num_lines (int)

  • seed (int)

  • line_oversampling (int)

  • fpsample_bucket_height (int)

  • line_distance_delta (float)

  • n_jobs (int)

  • wasserstein_order (float | None)

  • line_reduction (str)

  • return_stats (bool)

multipers.distances._normalize_hera_strategy(strategy, options, name)
Parameters:

name (str)

Return type:

int

multipers.distances._normalize_signed_measures(X, api=None)
multipers.distances._process_monte_carlo_raw_distances(raw_distances, *, api, directions, line_reduction, line_distance_kind, line_distance_order, return_stats)
Parameters:

  • line_reduction (str)

  • line_distance_kind (str)

  • line_distance_order (float)

  • return_stats (bool)

multipers.distances._reduce_monte_carlo_line_distances(weighted_distances, *, line_reduction, api)
Parameters:

line_reduction (str)

multipers.distances._repeat_signed_points(pts, weights, sign, api)
multipers.distances._require_balanced_effective_mass(left_size, right_size, *, metric)
Parameters:

  • left_size (int)

  • right_size (int)

  • metric (str)

multipers.distances._sample_monte_carlo_lines(left, right, *, nlines, seed, oversampling, fpsample_bucket_height)
Parameters:

  • nlines (int)

  • seed (int)

  • oversampling (int)

  • fpsample_bucket_height (int)

multipers.distances._sliced_wasserstein_distance_on_projections(meas1, meas2)
multipers.distances._validate_monte_carlo_lines(basepoints, directions, *, api=None)
multipers.distances.hera_bottleneck_distances(left_diagrams, right_diagrams, *, delta=0.01, n_jobs=0)

Compute Hera bottleneck distances for aligned batches of persistence diagrams.

The compiled Hera bridge drops diagonal points once, then evaluates the batch with a native TBB loop when available. n_jobs <= 0 keeps backend default concurrency.

Parameters:

  • delta (float)

  • n_jobs (int)

multipers.distances.hera_wasserstein_distances(left_diagrams, right_diagrams, *, order=1.0, internal_p=inf, delta=0.01, n_jobs=0)

Compute Hera Wasserstein distances for aligned batches of persistence diagrams.

The compiled Hera bridge drops diagonal points internally and evaluates the batch with a native TBB loop when available. n_jobs <= 0 keeps backend default concurrency.

Parameters:

  • order (float)

  • internal_p (float)

  • delta (float)

  • n_jobs (int)

multipers.distances.matching_distance(left, right, *, api=None, degree=None, strategy='monte_carlo', epsilon=1e-05, delta=0.001, mc_nlines=128, mc_seed=42, mc_oversampling=10, mc_fpsample_bucket_height=2, mc_n_jobs=0, mc_wp=None, mc_line_reduction='max', hera_max_depth=8, hera_initialization_depth=2, hera_bound_strategy='local_combined', hera_traverse_strategy='breadth_first', hera_tolerate_max_iter_exceeded=False, hera_stop_asap=True, return_stats=False, verbose=False, mc_basepoints=None, mc_directions=None)

Compute a 2-parameter matching-distance estimate between two filtrations/presentations.

The input should be a pair of simplextrees/slicers. The Hera strategy requires presentations, is usually slower, but guarantees the output precision to the specified parameters.

Parameters

left, rightmultipers.Slicer or multipers.SimplexTreeMulti

Simplex trees are converted to slicers first. Both backends then require slicer inputs. The exact “hera” backend additionally requires 2-parameter 1-critical slicers.

apimultipers.array_api.available_interfaces, optional

WIP for autodiff.

strategy{“monte_carlo”, “hera”}, default=”monte_carlo”

Backend used to estimate the matching distance. “monte_carlo” samples lines, computes per-line bottleneck or Wasserstein distances according to mc_wp, and aggregates according to mc_line_reduction across sampled lines. When both inputs are native unsqueezed floating slicers, this path uses a fused compiled fast path; otherwise it falls back to the Python batch implementation. “hera” runs Hera’s 2-parameter matching-distance algorithm on the presentations.

epsilonfloat, default=1e-5

Hera slice-bottleneck approximation tolerance used by the exact “hera” backend.

deltafloat, default=0.001

Relative tolerance used by Hera-backed approximations. The exact “hera” backend uses it for adaptive search over line directions. The Monte Carlo backend uses it for per-line bottleneck or Wasserstein computations.

mc_nlinesint, default=128

Number of sampled lines for the Monte Carlo backend.

mc_seedint, default=42

Random seed used to sample Monte Carlo basepoints and directions.

mc_oversamplingint, default=10

Monte Carlo direction oversampling factor before optional farthest-point subsampling with fpsample.

mc_fpsample_bucket_heightint, default=2

Bucket height passed to fpsample when direction resampling is enabled.

mc_n_jobsint, default=0

Worker count used by the Monte Carlo backend for per-line bottleneck or Wasserstein computations. mc_n_jobs <= 0 keeps backend default concurrency.

mc_wpfloat, optional

Per-line Wasserstein order used by the Monte Carlo backend. If None or np.inf, use bottleneck distance on sampled lines. If finite, compute Hera’s W_p on sampled line diagrams with internal_p=np.inf.

mc_line_reduction{“max”, “mean”, “softmax”, “softmax<d>”, “l<p>”}, default=”max”

Reduction applied to the sampled Monte Carlo line scores line_distance. “max” is the Linf reduction, “mean” is the L1 mean across sampled line scores, “l<p>” applies the corresponding Lp mean (for example, “l3”), “softmax” uses unscaled softmax weights, and “softmax<d>” rescales sampled line scores by d before applying softmax weights. Ignored by the exact “hera” backend.

hera_max_depthint, default=8

Maximum quadtree refinement depth used by the exact “hera” backend. Larger values allow more refinement but increase runtime.

hera_initialization_depthint, default=2

Initial uniform refinement depth before the exact “hera” backend switches to adaptive subdivision.

hera_bound_strategy{“bruteforce”, “local_dual_bound”, “local_dual_bound_refined”, “local_dual_bound_for_each_point”, “local_combined”} or int, default=”local_combined”

Strategy used by the exact “hera” backend to estimate upper and lower bounds on each dual cell. String values are mapped to Hera’s BoundStrategy enum; integer enum values are also accepted.

hera_traverse_strategy{“depth_first”, “breadth_first”, “breadth_first_value”, “upper_bound”} or int, default=”breadth_first”

Order in which the exact “hera” backend explores candidate dual cells during refinement. String values are mapped to Hera’s TraverseStrategy enum; integer enum values are also accepted.

hera_tolerate_max_iter_exceededbool, default=False

Forwarded to Hera’s internal bottleneck computations in the exact “hera” backend. If True, the current estimate is accepted when Hera’s bottleneck solver hits its iteration limit instead of raising an error.

hera_stop_asapbool, default=True

If True, the exact “hera” backend stops evaluating a slice as soon as the current point is already too far to improve the active bound. This is usually faster, at the cost of less informative intermediate bounds.

return_statsbool, default=False

If False, return only the matching distance. If True, also return a backend-specific diagnostics. The exact “hera” backend returns actual_error, actual_max_depth, and n_hera_calls. The Monte Carlo backend returns the number of sampled lines, the reduction, the line metric, the best sampled line, and its raw line distance.

verbosebool, default=False

If True, print timing scopes for validation and backend work.

mc_basepoints, mc_directionsarray-like, optional

Optional pre-sampled Monte Carlo lines. When provided, both must share the same shape (nlines, num_parameters) or (num_parameters,), and every direction coordinate must be strictly positive.

Returns

float or tuple[float, dict[str, float | int]]

The matching distance, optionally paired with Hera diagnostics when return_stats=True.

References

Hera project: https://github.com/anigmetov/hera

Parameters:

  • strategy (str)

  • epsilon (float)

  • delta (float)

  • mc_nlines (int)

  • mc_seed (int)

  • mc_oversampling (int)

  • mc_fpsample_bucket_height (int)

  • mc_n_jobs (int)

  • mc_wp (float | None)

  • mc_line_reduction (str)

  • hera_max_depth (int)

  • hera_initialization_depth (int)

  • hera_bound_strategy (str)

  • hera_traverse_strategy (str)

  • hera_tolerate_max_iter_exceeded (bool)

  • hera_stop_asap (bool)

  • return_stats (bool)

  • verbose (bool)

multipers.distances.pairwise_distances(items_X, items_Y=None, metric=None, n_jobs=None, api=None)
multipers.distances.sm2diff(sm1, sm2, threshold=None, api=None)
multipers.distances.sm_distance(sm1, sm2, sliced=False, api=None, reg=0, reg_m=0, numItermax=10000, p=1, threshold=None, num_directions=10, seed=42)

Computes a distance 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

Balanced sliced Wasserstein, exact EMD, and balanced Sinkhorn paths require equal effective mass under the current repeated-point model. Unequal masses are only supported by the unbalanced Sinkhorn path (reg != 0 and reg_m != 0).

Parameters:

  • sm1 (tuple)

  • sm2 (tuple)

  • sliced (bool)

  • reg (float)

  • reg_m (float)

  • numItermax (int)

  • p (float)

  • num_directions (int)

  • seed (int)

multipers.function_rips module

multipers.function_rips._canonical_degree_rips_simplextree(st_multi)
multipers.function_rips.function_rips_signed_measure(st_multi, homological_degrees, mobius_inversion=True, zero_pad=False, n_jobs=0, reconvert=True)
Parameters:

homological_degrees (Iterable[int])

multipers.function_rips.function_rips_surface(st_multi, homological_degrees, mobius_inversion=True, zero_pad=False, n_jobs=0)
Parameters:

homological_degrees (Iterable[int])

multipers.function_rips.get_degree_rips(st, degrees)
Parameters:

degrees (Iterable[int])

multipers.grids module

multipers.grids._compute_grid(filtrations_values, resolution=None, strategy='exact', unique=True, _q_factor=1.0, drop_quantiles=[0, 0], api=None)

Computes a grid from filtration values, using some strategy.

Input

  • filtrations_values: Iterable[filtration of parameter for parameter] where filtration_of_parameter is a array[float, ndim=1]

  • resolution:Optional[int|tuple[int]]

  • strategy: either exact, regular, regular_closest, regular_left, partition, quantile, or precomputed.

  • unique: if true, doesn’t repeat values in the output grid.

  • drop_quantiles : drop some filtration values according to these quantiles

Output

Iterable[array[float, ndim=1]] : the 1d-grid for each parameter.

Parameters:

strategy (Literal['exact', 'regular', 'regular_closest', 'regular_left', 'partition', 'quantile', 'precomputed'])

multipers.grids._exact_grid(x, api, _mean)
multipers.grids._get_push_pts_to_lines_kernel(api, with_directions)
multipers.grids._inf_value(array)
multipers.grids._push_pts_to_line(pts, basepoint, direction=None, api=None, return_coordinate=False)
multipers.grids._push_pts_to_lines(pts, basepoints, directions=None, api=None, return_coordinate=False)
multipers.grids._todo_partition(x, resolution, unique, api)
multipers.grids._todo_partition_(data, resolution, unique)
multipers.grids._todo_regular(f, r, api)
multipers.grids._todo_regular_closest(f, r, unique, api=None)
multipers.grids._todo_regular_left(f, r, unique, api)
multipers.grids.coarsen_points(points, strategy='exact', resolution=-1, coordinate=False)
multipers.grids.compute_bounding_box(stuff, inflate=0.0)

Returns a array of shape (2, num_parameters) such that for any filtration value $y$ of something in stuff, then if (x,z) is the output of this function, we have $xle y le z$.

multipers.grids.compute_grid(x, resolution=None, strategy='exact', unique=True, _q_factor=1.0, drop_quantiles=[0, 0], dense=False, threshold_min=None, threshold_max=None, _mean=False, force_contiguous=True, api=None)

Computes a grid from filtration values, using some strategy.

Input

  • filtrations_values: Iterable[filtration of parameter for parameter]

    where filtration_of_parameter is a array[float, ndim=1]

  • resolution:Optional[int|tuple[int]]

  • strategy: either exact, regular, regular_closest, regular_left, partition, quantile, or precomputed.

  • unique: if true, doesn’t repeat values in the output grid.

  • drop_quantiles : drop some filtration values according to these quantiles

Output

Iterable[array[float, ndim=1]] : the 1d-grid for each parameter.

Parameters:

  • resolution (int | Iterable[int] | None)

  • strategy (Literal['exact', 'regular', 'regular_closest', 'regular_left', 'partition', 'quantile', 'precomputed'])

multipers.grids.compute_grid_from_iterable(xs, resolution=None, strategy='exact', unique=True, _q_factor=1.0, drop_quantiles=[0, 0], dense=False, threshold_min=None, threshold_max=None)
Parameters:

  • resolution (int | Iterable[int] | None)

  • strategy (Literal['exact', 'regular', 'regular_closest', 'regular_left', 'partition', 'quantile', 'precomputed'])

multipers.grids.evaluate_in_grid(pts, grid, mass_default=None, input_inf_value=None, output_inf_value=None, api=None)

Input

  • pts: of the form array[int, ndim=2]

  • grid of the form Iterable[array[float, ndim=1]]

multipers.grids.evaluate_mod_in_grid(mod, grid, box=None)

Given an MMA module, pushes it into the specified grid. Useful for e.g., make it differentiable.

Input

  • mod: PyModule

  • grid: Iterable of 1d array, for num_parameters

Ouput

torch-compatible module in the format: (num_degrees) x (num_interval of degree) x ((num_birth, num_parameter), (num_death, num_parameters))

multipers.grids.get_exact_grid(x, threshold_min=None, threshold_max=None, return_api=False, _mean=False, api=None)

Computes an initial exact grid

multipers.grids.push_to_grid(points, grid, return_coordinate=False)

Given points and a grid (list of one parameter grids), pushes the points onto the grid.

multipers.grids.sanitize_grid(grid, numpyfy=False, add_inf=False, api=None)
multipers.grids.sm_in_grid(pts, weights, grid, mass_default=None)

Given a measure whose points are coordinates, pushes this measure in this grid. Input —–

  • pts: of the form array[int, ndim=2]

  • weights: array[int, ndim=1]

  • grid of the form Iterable[array[float, ndim=1]]

  • num_parameters: number of parameters

multipers.grids.sms_in_grid(sms, grid, mass_default=None)

Given a measure whose points are coordinates, pushes this measure in this grid. Input —–

  • sms: of the form (signed_measure_like for num_measures) where signed_measure_like = tuple(array[int, ndim=2], array[int])

  • grid of the form Iterable[array[float, ndim=1]]

multipers.grids.threshold_slice(a, m, M)
multipers.grids.todense(grid, api=None)

multipers.logs module

Runtime warning classes and toggles for multipers.

Usage:

import multipers as mp mp.logs.CopyWarning.enabled = False

exception multipers.logs.AutodiffWarning

Bases: MultipersWarning

enabled: bool = True
exception multipers.logs.CopyWarning

Bases: MultipersWarning

enabled: bool = False
exception multipers.logs.ExperimentalWarning

Bases: MultipersWarning

enabled: bool = True
exception multipers.logs.FallbackWarning

Bases: MultipersWarning

enabled: bool = True
exception multipers.logs.GeometryWarning

Bases: MultipersWarning

enabled: bool = True
exception multipers.logs.MultipersWarning

Bases: UserWarning

enabled: bool = True
exception multipers.logs.SuperfluousComputationWarning

Bases: MultipersWarning

enabled: bool = True
class multipers.logs._Timings(name, *, enabled, details=None, parent=None, label=None)

Bases: object

Parameters:

  • name (str)

  • enabled (bool)

  • details (Mapping[str, object] | None)

  • parent (_Timings | None)

  • label (str | None)

_format_details()
Return type:

str

_format_stats()
Return type:

str

_format_substeps()
Return type:

str

_stats: dict[str, object]
_substeps: list[tuple[str, float]]
add_stats(stats)
Parameters:

stats (Mapping[str, object] | None)

Return type:

None

step(label, *, details=None)
Parameters:

  • label (str)

  • details (Mapping[str, object] | None)

Return type:

_Timings

substep(label)
Parameters:

label (str)

Return type:

None

total()
Return type:

float

multipers.logs._emit(kind, message, stacklevel=2)
Parameters:

  • kind (str)

  • message (str)

  • stacklevel (int)

Return type:

None

multipers.logs._get_backend_log_mask()
Return type:

int

multipers.logs._set_backend_log_mask(mask)
Parameters:

mask (int)

Return type:

None

multipers.logs.enable_ext_log(enabled=True)

Enable or disable raw stdout coming from all external backends.

This policy is global to the current Python process. It is intended for debugging only. Do not toggle it while threaded backend computations are already running.

Parameters:

enabled (bool)

Return type:

None

multipers.logs.ext_log_enabled(backend=None)
Parameters:

backend (str | None)

Return type:

bool

multipers.logs.ext_log_policy()
Return type:

dict[str, bool]

multipers.logs.log_verbose(message, *, enabled)
Parameters:

  • message (str)

  • enabled (bool)

Return type:

None

multipers.logs.set_ext_log_policy(*, mpfree=None, multi_critical=None, function_delaunay=None, twopac=None)

Set raw backend log policy for external backends.

Each argument updates one backend when not None. This policy is process-global. It is intended for debugging only. Do not toggle it while threaded backend computations are already running.

Parameters:

  • mpfree (bool | None)

  • multi_critical (bool | None)

  • function_delaunay (bool | None)

  • twopac (bool | None)

Return type:

None

multipers.logs.set_level(level)
Parameters:

level (int)

Return type:

None

multipers.logs.timings(name, *, enabled, details=None)
Parameters:

  • name (str)

  • enabled (bool)

  • details (Mapping[str, object] | None)

Return type:

_Timings

multipers.logs.warn_autodiff(message, *, stacklevel=2)
Parameters:

  • message (str)

  • stacklevel (int)

Return type:

None

multipers.logs.warn_copy(message, *, stacklevel=2)
Parameters:

  • message (str)

  • stacklevel (int)

Return type:

None

multipers.logs.warn_experimental(message, *, stacklevel=2)
Parameters:

  • message (str)

  • stacklevel (int)

Return type:

None

multipers.logs.warn_fallback(message, *, stacklevel=2)
Parameters:

  • message (str)

  • stacklevel (int)

Return type:

None

multipers.logs.warn_geometry(message, *, stacklevel=2)
Parameters:

  • message (str)

  • stacklevel (int)

Return type:

None

multipers.logs.warn_superfluous_computation(message, *, stacklevel=2)
Parameters:

  • message (str)

  • stacklevel (int)

Return type:

None

multipers.mma_structures module

multipers.multiparameter_edge_collapse module

multipers.multiparameter_edge_collapse._collapse_edge_list(edges, num=0, full=False, strong=False, progress=False)

Given an edge list defining a 1 critical 2 parameter 1 dimensional simplicial complex, simplificates this filtered simplicial complex, using filtration-domination’s edge collapser.

Parameters:

  • num (int)

  • full (bool)

  • strong (bool)

  • progress (bool)

multipers.multiparameter_module_approximation module

class multipers.multiparameter_module_approximation.PyBox_f32(*args, **kwargs)

Bases: object

property _template_id

(self) -> int

contains(self, arg: object, /) → bool
contains(self, arg: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], /) → bool
property dtype

(self) -> object

get(self) → numpy.ndarray[dtype=float32]
property num_parameters

(self) -> int

to_multipers(self) → numpy.ndarray[dtype=float32]
class multipers.multiparameter_module_approximation.PyBox_f64(*args, **kwargs)

Bases: object

property _template_id

(self) -> int

contains(self, arg: object, /) → bool
contains(self, arg: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], /) → bool
property dtype

(self) -> object

get(self) → numpy.ndarray[dtype=float64]
property num_parameters

(self) -> int

to_multipers(self) → numpy.ndarray[dtype=float64]
class multipers.multiparameter_module_approximation.PyBox_i32(*args, **kwargs)

Bases: object

property _template_id

(self) -> int

contains(self, arg: object, /) → bool
contains(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → bool
property dtype

(self) -> object

get(self) → numpy.ndarray[dtype=int32]
property num_parameters

(self) -> int

to_multipers(self) → numpy.ndarray[dtype=int32]
class multipers.multiparameter_module_approximation.PyBox_i64(*args, **kwargs)

Bases: object

property _template_id

(self) -> int

contains(self, arg: object, /) → bool
contains(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → bool
property dtype

(self) -> object

get(self) → numpy.ndarray[dtype=int64]
property num_parameters

(self) -> int

to_multipers(self) → numpy.ndarray[dtype=int64]
class multipers.multiparameter_module_approximation.PyModule_f32(*args, **kwargs)

Bases: object

_add_mmas(self, arg: collections.abc.Iterable, /) → multipers._mma_nanobind.PyModule_f32
static _bc_to_full(bcs, basepoint, direction=None)
_compute_landscapes_box(self, degree: int, ks: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], box: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], resolution: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], n_jobs: int = 0) → numpy.ndarray[dtype=float32]
_compute_landscapes_box(self, degree: int, ks: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], box: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], resolution: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], n_jobs: int = 0) → numpy.ndarray[dtype=float32]
_compute_landscapes_grid(self, degree: int, ks: object, grid: object, n_jobs: int = 0) → numpy.ndarray[dtype=float32]
_compute_landscapes_grid(self, degree: int, ks: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], grid: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], n_jobs: int = 0) → numpy.ndarray[dtype=float32]
_compute_landscapes_grid(self, degree: int, ks: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], grid: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], n_jobs: int = 0) → numpy.ndarray[dtype=float32]
_compute_pixels(self, coordinates: object, degrees: object, box: object, delta: float, p: float, normalize: bool = False, n_jobs: int = 0) → numpy.ndarray[dtype=float32]
_compute_pixels(self, coordinates: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], degrees: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], box: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], delta: float, p: float, normalize: bool = False, n_jobs: int = 0) → numpy.ndarray[dtype=float32]
_compute_pixels(self, coordinates: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], degrees: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], box: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], delta: float, p: float, normalize: bool = False, n_jobs: int = 0) → numpy.ndarray[dtype=float32]
_from_ptr(self, arg: int, /) → multipers._mma_nanobind.PyModule_f32
_get_barcode_from_line(self, basepoint: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], direction: object | None = None, degree: int = -1) → tuple
_get_dump(self) → tuple
_load_dump(self, arg: object, /) → multipers._mma_nanobind.PyModule_f32
property _template_id

(self) -> int

static _threshold_bc(bc)
barcode2(basepoint, direction=None, degree=-1, *, threshold=False, keep_inf=True, full=False)
Parameters:

  • degree (int)

  • threshold (bool)

  • keep_inf (bool)

  • full (bool)

barcodes(degree=-1, basepoints=None, num=100, box=None, threshold=False)
Parameters:

  • degree (int)

  • num (int)

  • threshold (bool)

barcodes2(degree=-1, basepoints=None, num=100, box=None, threshold=False)
Parameters:

  • degree (int)

  • num (int)

  • threshold (bool)

distance_to(self, pts: object, signed: bool = False, n_jobs: int = 0) → numpy.ndarray[dtype=float32]
distance_to(self, pts: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], signed: bool = False, n_jobs: int = 0) → numpy.ndarray[dtype=float32]
property dtype

(self) -> object

dump(self, path: object | None = None) → tuple
evaluate_in_grid(self, arg: object, /) → multipers._mma_nanobind.PyModule_f32
evaluate_in_grid(self, arg: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], /) → multipers._mma_nanobind.PyModule_f32
get_bottom(self) → numpy.ndarray[dtype=float32]
get_bounds(self) → numpy.ndarray[dtype=float32]
get_box(self) → numpy.ndarray[dtype=float32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration_values(self, unique: bool = True) → list[list[float]]
get_interleavings(self) → numpy.ndarray[dtype=float32]
get_interleavings(self, box: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False]) → numpy.ndarray[dtype=float32]
get_module_of_degree(self, arg: int, /) → multipers._mma_nanobind.PyModule_f32
get_module_of_degrees(self, arg: object, /) → multipers._mma_nanobind.PyModule_f32
get_top(self) → numpy.ndarray[dtype=float32]
landscape(degree, k=0, box=None, resolution=(100, 100), plot=False)
Parameters:

  • degree (int)

  • k (int)

  • resolution (Sequence[int] | ndarray)

  • plot (bool)

landscapes(degree, ks=[0], box=None, resolution=[100, 100], grid=None, n_jobs=0, plot=False)
Parameters:

  • degree (int)

  • ks (list | ndarray)

  • resolution (list | ndarray)

  • n_jobs (int)

  • plot (bool)

property max_degree

(self) -> int

merge(self, other: multipers._mma_nanobind.PyModule_f32, dim: int = -1) → multipers._mma_nanobind.PyModule_f32
property num_parameters

(self) -> int

permute_summands(self, arg: object, /) → multipers._mma_nanobind.PyModule_f32
plot(degree=-1, **kwargs)
Parameters:

degree (int)

representation(degrees=None, bandwidth=0.1, resolution=50, kernel='gaussian', signed=False, normalize=False, plot=False, save=False, dpi=200, p=2.0, box=None, flatten=False, n_jobs=0, grid=None)
Parameters:

  • bandwidth (float)

  • resolution (Sequence[int] | int)

  • kernel (str | Callable)

  • signed (bool)

  • normalize (bool)

  • plot (bool)

  • save (bool)

  • dpi (int)

  • p (float)

  • flatten (bool)

  • n_jobs (int)

rescale(self, rescale_factors: object, degree: int = -1) → multipers._mma_nanobind.PyModule_f32
rescale(self, rescale_factors: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], degree: int = -1) → multipers._mma_nanobind.PyModule_f32
set_box(self, arg: object, /) → multipers._mma_nanobind.PyModule_f32
set_box(self, arg: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], /) → multipers._mma_nanobind.PyModule_f32
translate(self, translation: object, degree: int = -1) → multipers._mma_nanobind.PyModule_f32
translate(self, translation: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], degree: int = -1) → multipers._mma_nanobind.PyModule_f32
class multipers.multiparameter_module_approximation.PyModule_f64(*args, **kwargs)

Bases: object

_add_mmas(self, arg: collections.abc.Iterable, /) → multipers._mma_nanobind.PyModule_f64
static _bc_to_full(bcs, basepoint, direction=None)
_compute_landscapes_box(self, degree: int, ks: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], box: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], resolution: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], n_jobs: int = 0) → numpy.ndarray[dtype=float64]
_compute_landscapes_box(self, degree: int, ks: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], box: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], resolution: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], n_jobs: int = 0) → numpy.ndarray[dtype=float64]
_compute_landscapes_grid(self, degree: int, ks: object, grid: object, n_jobs: int = 0) → numpy.ndarray[dtype=float64]
_compute_landscapes_grid(self, degree: int, ks: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], grid: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], n_jobs: int = 0) → numpy.ndarray[dtype=float64]
_compute_landscapes_grid(self, degree: int, ks: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], grid: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], n_jobs: int = 0) → numpy.ndarray[dtype=float64]
_compute_pixels(self, coordinates: object, degrees: object, box: object, delta: float, p: float, normalize: bool = False, n_jobs: int = 0) → numpy.ndarray[dtype=float64]
_compute_pixels(self, coordinates: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], degrees: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], box: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], delta: float, p: float, normalize: bool = False, n_jobs: int = 0) → numpy.ndarray[dtype=float64]
_compute_pixels(self, coordinates: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], degrees: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], box: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], delta: float, p: float, normalize: bool = False, n_jobs: int = 0) → numpy.ndarray[dtype=float64]
_from_ptr(self, arg: int, /) → multipers._mma_nanobind.PyModule_f64
_get_barcode_from_line(self, basepoint: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], direction: object | None = None, degree: int = -1) → tuple
_get_dump(self) → tuple
_load_dump(self, arg: object, /) → multipers._mma_nanobind.PyModule_f64
property _template_id

(self) -> int

static _threshold_bc(bc)
barcode2(basepoint, direction=None, degree=-1, *, threshold=False, keep_inf=True, full=False)
Parameters:

  • degree (int)

  • threshold (bool)

  • keep_inf (bool)

  • full (bool)

barcodes(degree=-1, basepoints=None, num=100, box=None, threshold=False)
Parameters:

  • degree (int)

  • num (int)

  • threshold (bool)

barcodes2(degree=-1, basepoints=None, num=100, box=None, threshold=False)
Parameters:

  • degree (int)

  • num (int)

  • threshold (bool)

distance_to(self, pts: object, signed: bool = False, n_jobs: int = 0) → numpy.ndarray[dtype=float64]
distance_to(self, pts: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], signed: bool = False, n_jobs: int = 0) → numpy.ndarray[dtype=float64]
property dtype

(self) -> object

dump(self, path: object | None = None) → tuple
evaluate_in_grid(self, arg: object, /) → multipers._mma_nanobind.PyModule_f64
evaluate_in_grid(self, arg: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], /) → multipers._mma_nanobind.PyModule_f64
get_bottom(self) → numpy.ndarray[dtype=float64]
get_bounds(self) → numpy.ndarray[dtype=float64]
get_box(self) → numpy.ndarray[dtype=float64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration_values(self, unique: bool = True) → list[list[float]]
get_interleavings(self) → numpy.ndarray[dtype=float64]
get_interleavings(self, box: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False]) → numpy.ndarray[dtype=float64]
get_module_of_degree(self, arg: int, /) → multipers._mma_nanobind.PyModule_f64
get_module_of_degrees(self, arg: object, /) → multipers._mma_nanobind.PyModule_f64
get_top(self) → numpy.ndarray[dtype=float64]
landscape(degree, k=0, box=None, resolution=(100, 100), plot=False)
Parameters:

  • degree (int)

  • k (int)

  • resolution (Sequence[int] | ndarray)

  • plot (bool)

landscapes(degree, ks=[0], box=None, resolution=[100, 100], grid=None, n_jobs=0, plot=False)
Parameters:

  • degree (int)

  • ks (list | ndarray)

  • resolution (list | ndarray)

  • n_jobs (int)

  • plot (bool)

property max_degree

(self) -> int

merge(self, other: multipers._mma_nanobind.PyModule_f64, dim: int = -1) → multipers._mma_nanobind.PyModule_f64
property num_parameters

(self) -> int

permute_summands(self, arg: object, /) → multipers._mma_nanobind.PyModule_f64
plot(degree=-1, **kwargs)
Parameters:

degree (int)

representation(degrees=None, bandwidth=0.1, resolution=50, kernel='gaussian', signed=False, normalize=False, plot=False, save=False, dpi=200, p=2.0, box=None, flatten=False, n_jobs=0, grid=None)
Parameters:

  • bandwidth (float)

  • resolution (Sequence[int] | int)

  • kernel (str | Callable)

  • signed (bool)

  • normalize (bool)

  • plot (bool)

  • save (bool)

  • dpi (int)

  • p (float)

  • flatten (bool)

  • n_jobs (int)

rescale(self, rescale_factors: object, degree: int = -1) → multipers._mma_nanobind.PyModule_f64
rescale(self, rescale_factors: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], degree: int = -1) → multipers._mma_nanobind.PyModule_f64
set_box(self, arg: object, /) → multipers._mma_nanobind.PyModule_f64
set_box(self, arg: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], /) → multipers._mma_nanobind.PyModule_f64
translate(self, translation: object, degree: int = -1) → multipers._mma_nanobind.PyModule_f64
translate(self, translation: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], degree: int = -1) → multipers._mma_nanobind.PyModule_f64
class multipers.multiparameter_module_approximation.PyModule_i32(*args, **kwargs)

Bases: object

_add_mmas(self, arg: collections.abc.Iterable, /) → multipers._mma_nanobind.PyModule_i32
static _bc_to_full(bcs, basepoint, direction=None)
_from_ptr(self, arg: int, /) → multipers._mma_nanobind.PyModule_i32
_get_dump(self) → tuple
_load_dump(self, arg: object, /) → multipers._mma_nanobind.PyModule_i32
property _template_id

(self) -> int

static _threshold_bc(bc)
property dtype

(self) -> object

dump(self, path: object | None = None) → tuple
get_bottom(self) → numpy.ndarray[dtype=int32]
get_bounds(self) → numpy.ndarray[dtype=int32]
get_box(self) → numpy.ndarray[dtype=int32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration_values(self, unique: bool = True) → list[list[int]]
get_module_of_degree(self, arg: int, /) → multipers._mma_nanobind.PyModule_i32
get_module_of_degrees(self, arg: object, /) → multipers._mma_nanobind.PyModule_i32
get_top(self) → numpy.ndarray[dtype=int32]
property max_degree

(self) -> int

merge(self, other: multipers._mma_nanobind.PyModule_i32, dim: int = -1) → multipers._mma_nanobind.PyModule_i32
property num_parameters

(self) -> int

permute_summands(self, arg: object, /) → multipers._mma_nanobind.PyModule_i32
rescale(self, rescale_factors: object, degree: int = -1) → multipers._mma_nanobind.PyModule_i32
rescale(self, rescale_factors: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], degree: int = -1) → multipers._mma_nanobind.PyModule_i32
set_box(self, arg: object, /) → multipers._mma_nanobind.PyModule_i32
set_box(self, arg: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], /) → multipers._mma_nanobind.PyModule_i32
translate(self, translation: object, degree: int = -1) → multipers._mma_nanobind.PyModule_i32
translate(self, translation: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], degree: int = -1) → multipers._mma_nanobind.PyModule_i32
class multipers.multiparameter_module_approximation.PyModule_i64(*args, **kwargs)

Bases: object

_add_mmas(self, arg: collections.abc.Iterable, /) → multipers._mma_nanobind.PyModule_i64
static _bc_to_full(bcs, basepoint, direction=None)
_from_ptr(self, arg: int, /) → multipers._mma_nanobind.PyModule_i64
_get_dump(self) → tuple
_load_dump(self, arg: object, /) → multipers._mma_nanobind.PyModule_i64
property _template_id

(self) -> int

static _threshold_bc(bc)
property dtype

(self) -> object

dump(self, path: object | None = None) → tuple
get_bottom(self) → numpy.ndarray[dtype=int64]
get_bounds(self) → numpy.ndarray[dtype=int64]
get_box(self) → numpy.ndarray[dtype=int64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration_values(self, unique: bool = True) → list[list[int]]
get_module_of_degree(self, arg: int, /) → multipers._mma_nanobind.PyModule_i64
get_module_of_degrees(self, arg: object, /) → multipers._mma_nanobind.PyModule_i64
get_top(self) → numpy.ndarray[dtype=int64]
property max_degree

(self) -> int

merge(self, other: multipers._mma_nanobind.PyModule_i64, dim: int = -1) → multipers._mma_nanobind.PyModule_i64
property num_parameters

(self) -> int

permute_summands(self, arg: object, /) → multipers._mma_nanobind.PyModule_i64
rescale(self, rescale_factors: object, degree: int = -1) → multipers._mma_nanobind.PyModule_i64
rescale(self, rescale_factors: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], degree: int = -1) → multipers._mma_nanobind.PyModule_i64
set_box(self, arg: object, /) → multipers._mma_nanobind.PyModule_i64
set_box(self, arg: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], /) → multipers._mma_nanobind.PyModule_i64
translate(self, translation: object, degree: int = -1) → multipers._mma_nanobind.PyModule_i64
translate(self, translation: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], degree: int = -1) → multipers._mma_nanobind.PyModule_i64
class multipers.multiparameter_module_approximation.PySummand_f32(*args, **kwargs)

Bases: object

property _template_id

(self) -> int

property degree

(self) -> int

property dtype

(self) -> object

get_birth_list(self) → numpy.ndarray[dtype=float32]
get_bounds(self) → numpy.ndarray[dtype=float32]
get_death_list(self) → numpy.ndarray[dtype=float32]
num_parameters(self) → int
class multipers.multiparameter_module_approximation.PySummand_f64(*args, **kwargs)

Bases: object

property _template_id

(self) -> int

property degree

(self) -> int

property dtype

(self) -> object

get_birth_list(self) → numpy.ndarray[dtype=float64]
get_bounds(self) → numpy.ndarray[dtype=float64]
get_death_list(self) → numpy.ndarray[dtype=float64]
num_parameters(self) → int
class multipers.multiparameter_module_approximation.PySummand_i32(*args, **kwargs)

Bases: object

property _template_id

(self) -> int

property degree

(self) -> int

property dtype

(self) -> object

get_birth_list(self) → numpy.ndarray[dtype=int32]
get_bounds(self) → numpy.ndarray[dtype=int32]
get_death_list(self) → numpy.ndarray[dtype=int32]
num_parameters(self) → int
class multipers.multiparameter_module_approximation.PySummand_i64(*args, **kwargs)

Bases: object

property _template_id

(self) -> int

property degree

(self) -> int

property dtype

(self) -> object

get_birth_list(self) → numpy.ndarray[dtype=int64]
get_bounds(self) → numpy.ndarray[dtype=int64]
get_death_list(self) → numpy.ndarray[dtype=int64]
num_parameters(self) → int
multipers.multiparameter_module_approximation.module_approximation(input, box=None, max_error=-1, nlines=557, from_coordinates=False, complete=True, threshold=False, verbose=False, ignore_warnings=False, direction=(), swap_box_coords=(), *, n_jobs=-1)
Parameters:
Return type:

PyModule_f32 | PyModule_f64 | PyModule_i32 | PyModule_i64

multipers.multiparameter_module_approximation.module_approximation_from_slicer(slicer, box=None, max_error=-1, complete=True, threshold=False, verbose=False, direction=[], warnings=True, unsqueeze_grid=None, n_jobs=-1)
Parameters:
Return type:

PyModule_f32 | PyModule_f64 | PyModule_i32 | PyModule_i64

multipers.ops module

multipers.ops._minimal_presentation_from_slicer(slicer, degree, backend='mpfree', auto_clean=True, verbose=False, full_resolution=True, use_clearing=True, use_chunk=True, keep_generators=False)
multipers.ops._multi_critical_from_slicer(slicer, reduce=False, algo='path', degree=None, clear=True, swedish=None, verbose=False, kcritical=False, filtration_container='contiguous', **slicer_kwargs)
Parameters:

  • algo (Literal['path', 'tree'])

  • degree (int | None)

multipers.ops.aida(s, sort=True, verbose=False, progress=False)
multipers.ops.minimal_presentation(slicer, degree=-1, degrees=[], backend='mpfree', n_jobs=-1, force=False, auto_clean=True, verbose=False, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)

Computes a minimal presentation of a (1-critical) multifiltered complex.

From [Fast minimal presentations of bi-graded persistence modules](https://doi.org/10.1137/1.9781611976472.16), whose code is available here: https://bitbucket.org/mkerber/mpfree

Available backends include mpfree and 2pac.

Parameters:

  • degrees (Iterable[int])

  • backend (Literal['mpfree', '2pac', ''])

  • keep_generators (bool)

multipers.ops.one_criticalify(slicer, reduce=None, degree=None, clear=True, swedish=None, verbose=False, kcritical=False, algo='path', filtration_container='contiguous', force_resolution=True)

Computes a free implicit representation of a given multi-critical multifiltration of a given homological degree (i.e., for a given homological degree, a quasi-isomorphic 1-critical filtration), or free resolution of the multifiltration (i.e., quasi-isomorphic 1-critical chain complex).

From [Fast free resolutions of bifiltered chain complexes](https://doi.org/10.48550/arXiv.2512.08652), whose code is available here: https://bitbucket.org/mkerber/multi_critical

Parameters:

  • reduce (bool | None)

  • degree (int | None)

  • swedish (bool | None)

  • algo (Literal['path', 'tree'])

multipers.pickle module

multipers.pickle.get_sm_with_axis(sms, idx, axis, degree)
multipers.pickle.get_sm_without_axis(sms, idx, degree)
multipers.pickle.load(path)
Parameters:

path (str)

multipers.pickle.load_with_axis(sms)
multipers.pickle.load_without_axis(sms)
multipers.pickle.save(path, signed_measures)
Parameters:

path (str)

multipers.pickle.save_with_axis(path, signed_measures)
Parameters:

path (str)

multipers.pickle.save_without_axis(path, signed_measures)
Parameters:

path (str)

multipers.plots module

multipers.plots._d_inf(a, b)
multipers.plots._plot_rectangle(rectangle, weight, **plt_kwargs)
Parameters:

rectangle (ndarray)

multipers.plots._plot_signed_measure_2(pts, weights, temp_alpha=0.7, threshold=(inf, inf), **plt_kwargs)
multipers.plots._plot_signed_measure_4(pts, weights, x_smoothing=1, area_alpha=True, threshold=(inf, inf), alpha=None, **plt_kwargs)
Parameters:

  • x_smoothing (float)

  • area_alpha (bool)

multipers.plots._rectangle(x, y, color, alpha)

Defines a rectangle patch in the format {z | x  ≤ z ≤ y} with color and alpha

multipers.plots.plot2d_PyModule(birth_corners, death_corners, box, *, dimension=-1, separated=False, min_persistence=0, alpha=None, verbose=False, save=False, dpi=200, xlabel=None, ylabel=None, cmap=None, outline_width=0.2, outline_threshold=inf, interleavings=None, backend=None)
multipers.plots.plot_point_cloud(pts, function, x, y, mma=None, degree=None, ball_alpha=0.3, point_cmap='viridis', color_bias=1, ball_color=None, point_size=20)
multipers.plots.plot_signed_measure(signed_measure, threshold=None, ax=None, s=None, **plt_kwargs)
multipers.plots.plot_signed_measures(signed_measures, threshold=None, size=4, alpha=None, s=None, **plot_kwargs)
multipers.plots.plot_simplicial_complex(st, pts, x, y, mma=None, degree=None, show_pos=True)

Scatters the points, with the simplices in the filtration at coordinates (x,y). if an mma module is given, plots it in a second axis

Parameters:

  • pts (ArrayLike)

  • x (float)

  • y (float)

  • show_pos (bool)

multipers.plots.plot_surface(grid, hf, fig=None, ax=None, cmap=None, discrete_surface=None, has_negative_values=None, contour=True, threshold_max=10, threshold_min=-10, **plt_args)
Parameters:

  • cmap (str | Any | None)

  • discrete_surface (bool | None)

  • has_negative_values (bool | bool | None)

  • contour (bool)

multipers.plots.plot_surfaces(HF, size=4, **plt_args)

multipers.point_measure module

multipers.point_measure.add_sms(sms)
multipers.point_measure.barcode_from_rank_sm(sm, basepoint, direction=None, full=False)

Given a rank signed measure sm and a line with basepoint basepoint (1darray) and direction direction (1darray), projects the rank signed measure on the given line, and returns the associated estimated barcode. If full is True, the barcode is given as coordinates in R^{num_parameters} instead of coordinates w.r.t. the line.

Parameters:

  • sm (tuple[ndarray, ndarray])

  • basepoint (ndarray)

  • direction (ndarray | None)

multipers.point_measure.clean_signed_measure(pts, w, dtype=<class 'numpy.int32'>)
multipers.point_measure.clean_signed_measure_old(pts, weights, dtype=<class 'numpy.float32'>)

Sum the diracs at the same locations. i.e., returns the minimal sized measure to represent the input. Mostly useful for, e.g., euler_characteristic from simplical complexes.

multipers.point_measure.clean_sms(sms)

Sum the diracs at the same locations. i.e., returns the minimal sized measure to represent the input. Mostly useful for, e.g., euler_characteristic from simplical complexes.

multipers.point_measure.estimate_rank_from_rank_sm(sm, a, b)

Given a rank signed measure (sm) and two points (a) and (b), estimates the rank between these two points.

Parameters:

sm (tuple)

Return type:

int64

multipers.point_measure.integrate_measure(pts, weights, filtration_grid=None, grid_strategy='regular', resolution=100, return_grid=False, plot=False, **get_fitration_kwargs)

Integrate a point measure on a grid. Measure is a sum of diracs, based on points pts and weights weights. For instance, if the signed measure comes from the hilbert signed measure, this integration will return the hilbert function on this grid.

  • pts : array of points (num_pts, D)

  • weights : array of weights (num_pts,)

  • filtration_grid (optional) : list of 1d arrays

  • resolution : int or list of int

  • return_grid : return the grid of the measure

  • **get_fitration_kwargsarguments to compute the grid,

    if the grid is not given.

Parameters:

  • filtration_grid (Iterable[ndarray] | None)

  • grid_strategy (str)

  • resolution (int | list[int])

multipers.point_measure.integrate_measure_python(pts, weights, filtrations)
multipers.point_measure.rank_decomposition_by_rectangles(rank_invariant, threshold=False)
Parameters:

rank_invariant (ndarray)

multipers.point_measure.rectangle_to_hook_minimal_signed_barcode(pts, w)
multipers.point_measure.signed_betti(hilbert_function, threshold=False)
Parameters:

hilbert_function (ndarray)

multipers.point_measure.sparsify(x)

Given an arbitrary dimensional numpy array, returns (coordinates,data). – cost : scipy sparse + num_points*num_parameters^2 divisions

multipers.point_measure.zero_out_sm(pts, weights, mass_default)

Zeros out the modules outside of $ { xin mathbb R^n mid x le mathrm{mass_default}} $.

multipers.point_measure.zero_out_sms(sms, mass_default)

Zeros out the modules outside of $ { xin mathbb R^n mid x le mathrm{mass_default}} $.

multipers.simplex_tree_multi module

multipers.simplex_tree_multi.SimplexTreeMulti(input=None, num_parameters=-1, dtype=<class 'numpy.float64'>, kcritical=False, ftype='Contiguous', default_values=None, max_dim=-1, return_type_only=False, **kwargs)
Parameters:

  • num_parameters (int)

  • dtype (type)

  • kcritical (bool)

  • max_dim (int)

  • return_type_only (bool)

Return type:

_SimplexTreeMulti_Flat_Ki32 | _SimplexTreeMulti_Contiguous_Ki32 | _SimplexTreeMulti_Flat_Kf64 | _SimplexTreeMulti_Contiguous_Kf64 | _SimplexTreeMulti_Flat_Ki64 | _SimplexTreeMulti_Contiguous_Ki64 | _SimplexTreeMulti_Flat_Kf32 | _SimplexTreeMulti_Contiguous_Kf32 | _SimplexTreeMulti_Contiguous_i32 | _SimplexTreeMulti_Contiguous_f64 | _SimplexTreeMulti_Contiguous_i64 | _SimplexTreeMulti_Contiguous_f32

class multipers.simplex_tree_multi._SimplexTreeMulti_Contiguous_Kf32(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float32, shape=(, *), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*, *), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(, , *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(, *, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf32
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Contiguous_Kf64(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float64, shape=(, *), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*, *), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(, , *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(, *, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Kf64
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Contiguous_Ki32(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int32, shape=(, *), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*, *), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(, , *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(, *, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki32
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Contiguous_Ki64(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int64, shape=(, *), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*, *), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(, , *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(, *, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_Ki64
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Contiguous_f32(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(*, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(*, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(, ), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f32
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Contiguous_f64(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(*, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(*, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(, ), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_f64
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Contiguous_i32(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(*, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(*, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(, ), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i32
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Contiguous_i64(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(*, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(*, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(, ), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Contiguous_i64
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Flat_Kf32(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float32, shape=(, *), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float32, shape=(*, *), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(, , *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=float32, shape=(, *, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf32
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Flat_Kf64(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float64, shape=(, *), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=float64, shape=(*, *), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(, , *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=float64, shape=(, *, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Kf64
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Flat_Ki32(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int32, shape=(, *), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int32, shape=(*, *), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(, , *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=int32, shape=(, *, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki32
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
class multipers.simplex_tree_multi._SimplexTreeMulti_Flat_Ki64(*args, **kwargs)

Bases: object

_assign_filtration(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_assign_filtration(self, arg0: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], arg1: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_clean_filtration_grid(api=None)
_clean_filtration_grid_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_copy_from_any(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_deserialize_state(self, arg: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_from_gudhi_state(self, arg0: object, arg1: int, arg2: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_from_ptr(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_from_slicer(self, slicer: object, max_dim: int = -1) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_get_boundaries(self, arg: object, /) → list
_get_filtration(self, arg: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], /) → object
_get_filtration(self, arg: object, /) → object
_get_filtration_values(degrees=(-1,), inf_to_nan=False, return_raw=False)
_get_skeleton(self, arg: int, /) → list
_get_to_std_linear_projection_state(self, arg: object, /) → numpy.ndarray[dtype=int8]
_get_to_std_state(self, arg0: object, arg1: object, arg2: int, /) → numpy.ndarray[dtype=int8]
_insert(self, simplex: object, filtration: object | None = None) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False]) → bool
_insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False]) → bool
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(*, *), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(*, *, *), writable=False]) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_insert_batch(self, arg0: object, arg1: object, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_insert_simplex(self, simplex: object, filtration: object | None = None, force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], force: bool = False) → bool
_insert_simplex(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order='C', writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], force: bool = False) → bool
_iter_simplices(self) → collections.abc.Iterator[tuple]
_reconstruct_from_edge_array(self, edges: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], expand_dimension: int = 0) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_reconstruct_from_edge_list(edges, swap=True, expand_dimension=0)
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()
_simplify_filtration_raw(self) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_squeeze_inplace(self, arg0: object, arg1: bool, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
_squeeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64, arg1: object, /) → None
property _template_id

(self) -> int

_unsqueeze_to(self, arg0: multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64, arg1: object, /) → None
assign_filtration(simplex, filtration)
astype(dtype=None, kcritical=None, ftype=None, filtration_container=None)
collapse_edges(num=1, max_dimension=0, progress=False, strong=True, full=False, ignore_warning=False, auto_clean=True)
copy()
property dimension
property dtype

(self) -> object

euler_characteristic(dtype=None)
expansion(max_dim)
fill_distance_matrix(distance_matrix, parameter, node_value=0)
fill_lowerstar(F, parameter)
filtration(simplex)
filtration_bounds(degrees=None, q=0, split_dimension=False)
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

find_simplex(self, arg: object, /) → bool
flagify(dim=2)
property ftype

(self) -> str

get_boundaries(self, simplex: object) → collections.abc.Iterator[tuple]
get_edge_list()
get_filtration_grid(resolution=None, degrees=None, drop_quantiles=0, grid_strategy='exact', threshold_min=None, threshold_max=None)
get_key(self, arg: object, /) → int
get_simplices(self) → collections.abc.Iterator[tuple]
get_simplices_of_dimension(dim)
get_skeleton(self, dimension: int) → collections.abc.Iterator[tuple]
grid_squeeze(filtration_grid=None, coordinate_values=True, strategy='exact', resolution=None, coordinates=False, grid_strategy=None, inplace=False, threshold_min=None, threshold_max=None, **filtration_grid_kwargs)
insert()

_insert(self, simplex: object, filtration: object | None = None) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int32, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int64, shape=(, *), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False]) -> bool _insert(self, simplex: numpy.ndarray[dtype=int64, shape=(*), order=’C’, writable=False], filtration: numpy.ndarray[dtype=int64, shape=(*, *), order=’C’, writable=False]) -> bool

insert_batch()

_insert_batch(self, vertex_array: numpy.ndarray[dtype=int32, shape=(, *), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(, , *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64 _insert_batch(self, vertex_array: numpy.ndarray[dtype=int64, shape=(, ), writable=False], filtrations: numpy.ndarray[dtype=int64, shape=(, *, *), writable=False]) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64 _insert_batch(self, arg0: object, arg1: object, /) -> multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64

property is_kcritical

(self) -> bool

property is_squeezed
key(simplex)
linear_projections(linear_forms)
Parameters:

linear_forms (ndarray)

make_filtration_non_decreasing()
property num_parameters

(self) -> int

property num_simplices
property num_vertices
project_on_line(parameter=0, basepoint=None, direction=None)
prune_above_dimension(dimension)
pts_to_indices(pts, simplices_dimensions)
remove_maximal_simplex(simplex)
reset_filtration(filtration, min_dim=0)
set_dimension(self, arg: int, /) → multipers._simplex_tree_multi_nanobind._SimplexTreeMulti_Flat_Ki64
set_key(simplex, key)
set_keys_to_enumerate()
set_num_parameter(num)
simplex_dimension(self, arg: object, /) → int
property thisptr

(self) -> int

to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False)
unsqueeze(grid=None)
upper_bound_dimension(self) → int
multipers.simplex_tree_multi._euler_signed_measure(simplextree, mass_default=None, verbose=False)
multipers.simplex_tree_multi._hilbert_signed_measure(simplextree, degrees, mass_default=None, plot=False, n_jobs=0, verbose=False, expand_collapse=False)
multipers.simplex_tree_multi._rank_signed_measure(simplextree, degrees, mass_default=None, plot=False, n_jobs=0, verbose=False, expand_collapse=False)
multipers.simplex_tree_multi.is_simplextree_multi(input)
Return type:

bool

multipers.slicer module

class multipers.slicer._ContiguousSlicer_GudhiCohomology0_f32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f32
class multipers.slicer._ContiguousSlicer_GudhiCohomology0_f64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_f64
class multipers.slicer._ContiguousSlicer_GudhiCohomology0_i32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
class multipers.slicer._ContiguousSlicer_GudhiCohomology0_i64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_GudhiCohomology0_i64
class multipers.slicer._ContiguousSlicer_Matrix0_f32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f32
class multipers.slicer._ContiguousSlicer_Matrix0_f64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_f64
class multipers.slicer._ContiguousSlicer_Matrix0_i32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
class multipers.slicer._ContiguousSlicer_Matrix0_i64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_i64
class multipers.slicer._ContiguousSlicer_Matrix0_vine_f32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float32]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f32
class multipers.slicer._ContiguousSlicer_Matrix0_vine_f64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float64]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_f64
class multipers.slicer._ContiguousSlicer_Matrix0_vine_i32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int32]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
class multipers.slicer._ContiguousSlicer_Matrix0_vine_i64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int64]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._ContiguousSlicer_Matrix0_vine_i64
class multipers.slicer._KContiguousSlicer_GudhiCohomology0_f32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f32
class multipers.slicer._KContiguousSlicer_GudhiCohomology0_f64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_f64
class multipers.slicer._KContiguousSlicer_GudhiCohomology0_i32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
class multipers.slicer._KContiguousSlicer_GudhiCohomology0_i64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_GudhiCohomology0_i64
class multipers.slicer._KContiguousSlicer_Matrix0_f32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f32
class multipers.slicer._KContiguousSlicer_Matrix0_f64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_f64
class multipers.slicer._KContiguousSlicer_Matrix0_i32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
class multipers.slicer._KContiguousSlicer_Matrix0_i64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_i64
class multipers.slicer._KContiguousSlicer_Matrix0_vine_f32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float32]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f32
class multipers.slicer._KContiguousSlicer_Matrix0_vine_f64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float64]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_f64
class multipers.slicer._KContiguousSlicer_Matrix0_vine_i32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int32]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
class multipers.slicer._KContiguousSlicer_Matrix0_vine_i64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int64]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KContiguousSlicer_Matrix0_vine_i64
class multipers.slicer._KFlatSlicer_GudhiCohomology0_f32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f32
class multipers.slicer._KFlatSlicer_GudhiCohomology0_f64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_f64
class multipers.slicer._KFlatSlicer_GudhiCohomology0_i32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
class multipers.slicer._KFlatSlicer_GudhiCohomology0_i64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_GudhiCohomology0_i64
class multipers.slicer._KFlatSlicer_Matrix0_f32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f32
class multipers.slicer._KFlatSlicer_Matrix0_f64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_f64
class multipers.slicer._KFlatSlicer_Matrix0_i32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int32]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
class multipers.slicer._KFlatSlicer_Matrix0_i64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int64]
get_ptr(self) → int
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_i64
class multipers.slicer._KFlatSlicer_Matrix0_vine_f32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float32]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f32
class multipers.slicer._KFlatSlicer_Matrix0_vine_f64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=float64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[float]], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[float]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=float64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=float64]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_f64
class multipers.slicer._KFlatSlicer_Matrix0_vine_i32(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int32, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int32]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int32]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
class multipers.slicer._KFlatSlicer_Matrix0_vine_i64(*args, **kwargs)

Bases: object

_build_from_scc_file(self, path: str, rivet_compatible: bool = False, reverse: bool = False, shift_dimension: int = 0) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
_clean_filtration_grid()
_clean_filtration_grid_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
_compute_persistence_on_slices(self, values: numpy.ndarray[dtype=int64, shape=(*, *), order='C', writable=False], ignore_infinite_filtration_values: bool = True) → tuple
_copy_from_any(self, other: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
_deserialize_state(self, state: object) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
_from_ptr(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
property _generator_basis

(self) -> object

_get_filtrations_impl(self, raw: bool = False, view: bool = False, packed: bool = False) → object
_inf_value = <nanobind.nb_func object>
_info_string(self) → str
_make_filtration_non_decreasing_raw(self, safe: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
_serialize_state(self) → numpy.ndarray[dtype=uint8]
_simplify_filtration()

_simplify_filtration_raw(self) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64

_simplify_filtration_raw(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
property _template_id

(self) -> int

_to_scc_raw(self, path: str, degree: int = -1, rivet_compatible: bool = False, ignore_last_generators: bool = False, strip_comments: bool = False, reverse: bool = False) → None
astype(vineyard=None, kcritical=None, dtype=None, col=None, pers_backend=None, filtration_container=None)
build_from_simplex_tree(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
coarsen_on_grid_copy(self, arg: collections.abc.Sequence[collections.abc.Sequence[int]], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i32
coarsen_on_grid_inplace(self, arg0: collections.abc.Sequence[collections.abc.Sequence[int]], arg1: bool, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
property col_type

(self) -> str

compute_kernel_projective_cover(self, dim: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
compute_persistence(one_filtration=None, ignore_infinite_filtration_values=True, verbose=False)
copy(self) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
property dimension
property dtype

(self) -> object

filtration_bounds()
property filtration_container

(self) -> str

property filtration_grid

(self) -> object

property ftype

(self) -> str

get_barcode(self) → tuple
get_barcode_idx(self) → tuple
get_boundaries(self, packed: bool = False) → object
get_current_filtration(self) → numpy.ndarray[dtype=int64]
get_dimensions(self) → numpy.ndarray[dtype=int32]
get_filtration(self, idx: int, raw: bool = False) → object
get_filtration_grid(grid_strategy='exact', **infer_grid_kwargs)
get_filtrations(unsqueeze=False, raw=False, view=False, packed=False, copy=None)
get_filtrations_values(self) → numpy.ndarray[dtype=int64]
get_most_persistent_cycle(self, dim: int = 1, update: bool = True, idx: bool = False) → object
get_permutation(self) → numpy.ndarray[dtype=uint32]
get_ptr(self) → int
get_representative_cycles(self, update: bool = True, idx: object | None = None, intersect_points: object | None = None) → list
grid_squeeze(filtration_grid=None, strategy='exact', resolution=None, coordinates=True, inplace=False, grid_strategy=None, threshold_min=None, threshold_max=None)
property info
initialize_persistence_computation(self, ignore_infinite_filtration_values: bool = True) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
property is_kcritical

(self) -> bool

property is_minpres: bool
property is_squeezed: bool
property is_vine

(self) -> bool

make_filtration_non_decreasing()

_make_filtration_non_decreasing_raw(self, safe: bool = True) -> multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64

minpres(degree=-1, degrees=None, backend='mpfree', force=True, auto_clean=True, full_resolution=True, use_chunk=True, use_clearing=True, keep_generators=False)
property minpres_degree

(self) -> int

property num_generators

(self) -> int

property num_parameters

(self) -> int

permute_generators(self, arg: collections.abc.Sequence[int], /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
property pers_backend

(self) -> str

persistence_on_line(basepoint, direction=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None)
persistence_on_lines(basepoints, directions=None, keep_inf=True, full=False, ignore_infinite_filtration_values=True, api=None, *, _single_input=False)
prune_above_dimension(self, arg: int, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
push_to_line(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
set_slice(self, arg: object, /) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
to_colexical(self, return_permutation: bool = False) → object
to_scc(path, degree=-1, rivet_compatible=False, ignore_last_generators=False, strip_comments=False, reverse=False, unsqueeze=True)
Parameters:

path (PathLike)

unsqueeze(grid=None, inf_overflow=True)
update_persistence_computation(self, ignore_infinite_filtration_values: bool = False) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
vine_update(self, basepoint: object, direction: object | None = None) → multipers._slicer_nanobind._KFlatSlicer_Matrix0_vine_i64
multipers.slicer._hilbert_signed_measure(slicer, degrees, zero_pad=False, n_jobs=0, verbose=False, ignore_inf=True)
multipers.slicer._is_slicer(input)
Return type:

bool

multipers.slicer._rank_from_slicer(slicer, degrees, verbose=False, n_jobs=1, zero_pad=False, grid_shape=None, plot=False, return_raw=False, ignore_inf=True)
multipers.slicer._signed_measure_from_scc(minimal_presentation)
multipers.slicer._signed_measure_from_slicer(slicer, shift=0)
Parameters:
multipers.slicer.get_matrix_slicer(is_vineyard, is_k_critical, dtype, col, pers_backend, filtration_container)
multipers.slicer.is_slicer(input, allow_minpres=True)
Return type:

bool

multipers.slicer.to_simplextree(s, max_dim=-1)
Parameters:

Module contents

multipers.SimplexTreeMulti(input=None, num_parameters=-1, dtype=<class 'numpy.float64'>, kcritical=False, ftype='Contiguous', default_values=None, max_dim=-1, return_type_only=False, **kwargs)
Parameters:

  • num_parameters (int)

  • dtype (type)

  • kcritical (bool)

  • max_dim (int)

  • return_type_only (bool)

Return type:

_SimplexTreeMulti_Flat_Ki32 | _SimplexTreeMulti_Contiguous_Ki32 | _SimplexTreeMulti_Flat_Kf64 | _SimplexTreeMulti_Contiguous_Kf64 | _SimplexTreeMulti_Flat_Ki64 | _SimplexTreeMulti_Contiguous_Ki64 | _SimplexTreeMulti_Flat_Kf32 | _SimplexTreeMulti_Contiguous_Kf32 | _SimplexTreeMulti_Contiguous_i32 | _SimplexTreeMulti_Contiguous_f64 | _SimplexTreeMulti_Contiguous_i64 | _SimplexTreeMulti_Contiguous_f32

multipers.Slicer(st=None, vineyard=None, reduce=False, reduce_backend=None, dtype=None, kcritical=None, column_type=None, backend=None, filtration_container=None, max_dim=None, return_type_only=False, _shift_dimension=0)

Given a simplextree, slicer, or SCC file path, returns a structure that can compute persistence on line (or more) slices, eventually vineyard update, etc.

This can be used to compute interval-decomposable module approximations or signed measures, using, e.g.

  • multipers.module_approximation(this, *args)

  • multipers.signed_measure(this, *args)

Input

  • st : SimplexTreeMulti, slicer, or path to an SCC file

  • backend: slicer backend, e.g, “matrix”, “clement”, “graph”

  • vineyard: vineyard capable (may slow down computations if true)

Output

The corresponding slicer.

Parameters:

  • vineyard (bool | None)

  • reduce (bool)

  • reduce_backend (str | None)

  • dtype (Any | None)

  • kcritical (bool | None)

  • column_type (str | None)

  • backend (str | None)

  • filtration_container (str | None)

  • max_dim (int | None)

  • return_type_only (bool)

  • _shift_dimension (int)

Return type:

_KFlatSlicer_Matrix0_vine_i32 | _KContiguousSlicer_Matrix0_vine_i32 | _KFlatSlicer_Matrix0_vine_f64 | _KContiguousSlicer_Matrix0_vine_f64 | _KFlatSlicer_Matrix0_vine_i64 | _KContiguousSlicer_Matrix0_vine_i64 | _KFlatSlicer_Matrix0_vine_f32 | _KContiguousSlicer_Matrix0_vine_f32 | _ContiguousSlicer_Matrix0_vine_i32 | _ContiguousSlicer_Matrix0_vine_f64 | _ContiguousSlicer_Matrix0_vine_i64 | _ContiguousSlicer_Matrix0_vine_f32 | _KFlatSlicer_Matrix0_i32 | _KContiguousSlicer_Matrix0_i32 | _KFlatSlicer_Matrix0_f64 | _KContiguousSlicer_Matrix0_f64 | _KFlatSlicer_Matrix0_i64 | _KContiguousSlicer_Matrix0_i64 | _KFlatSlicer_Matrix0_f32 | _KContiguousSlicer_Matrix0_f32 | _ContiguousSlicer_Matrix0_i32 | _ContiguousSlicer_Matrix0_f64 | _ContiguousSlicer_Matrix0_i64 | _ContiguousSlicer_Matrix0_f32 | _KFlatSlicer_GudhiCohomology0_i32 | _KContiguousSlicer_GudhiCohomology0_i32 | _KFlatSlicer_GudhiCohomology0_f64 | _KContiguousSlicer_GudhiCohomology0_f64 | _KFlatSlicer_GudhiCohomology0_i64 | _KContiguousSlicer_GudhiCohomology0_i64 | _KFlatSlicer_GudhiCohomology0_f32 | _KContiguousSlicer_GudhiCohomology0_f32 | _ContiguousSlicer_GudhiCohomology0_i32 | _ContiguousSlicer_GudhiCohomology0_f64 | _ContiguousSlicer_GudhiCohomology0_i64 | _ContiguousSlicer_GudhiCohomology0_f32

multipers.module_approximation(input, box=None, max_error=-1, nlines=557, from_coordinates=False, complete=True, threshold=False, verbose=False, ignore_warnings=False, direction=(), swap_box_coords=(), *, n_jobs=-1)
Parameters:
Return type:

PyModule_f32 | PyModule_f64 | PyModule_i32 | PyModule_i64

multipers.signed_measure(filtered_complex, degree=None, degrees=[], mass_default=None, grid_strategy='exact', invariant=None, plot=False, verbose=False, n_jobs=-1, expand_collapse=False, backend=None, grid=None, coordinate_measure=False, num_collapses=0, clean=None, vineyard=False, grid_conversion=None, ignore_infinite_filtration_values=True, **infer_grid_kwargs)

Computes the signed measures given by the decomposition of the hilbert function or the euler characteristic, or the rank invariant.

Input

  • filtered_complex: given by a simplextree or a slicer.

  • degree:int|None / degrees:list[int] the degrees to compute. None represents the euler characteristic.

  • 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. This corresponds to zero-out the filtered complex outside of ${ xin mathbb R^n mid xle mass_default}$

  • invariant: The invariant to use, either “hilbert”, “rank”, or “euler”.

  • plot:bool, plots the computed measures if true.

  • n_jobs:int, number of jobs. Defaults to #cpu.

  • verbose:bool, prints c++ logs.

  • expand_collapse: when the input is a simplextree, only expands the complex when computing 1-dimensional slices. Meant to reduce memory footprint at some computational expense.

  • backend:str reduces first the filtered complex using some external backend backend,

    see backend in multipers.ops.minimal_presentation().

  • grid: If given, the computations will be done on the restriction of the filtered complex to this grid.

    It can also be used for auto-differentiation, i.e., if the grid is a list of pytorch tensors, then the output measure will be pytorch-differentiable.

  • grid_strategy: If not squeezed yet, and no grid is given, the strategy to coarsen the grid; see strategy in multipers.grids.compute_grid().

  • coordinate_measure: bool, if True, compute the signed measure as a coordinates given in grid.

  • num_collapses: int, if filtered_complex is a simplextree, does some collapses if possible.

  • clean: if True, reduces the measure. It is not necessary in general.

  • ignore_infinite_filtration_values: Backend optimization.

Output

[signed_measure_of_degree for degree in degrees] with signed_measure_of_degree of the form (dirac location, dirac weights).

Notes on computational backends

There are several backends for each of these computations. The backend for computations used can be displayed with verbose=True, use it! Also note that if backend is given, then the input will be converted to a slicer.

  • Euler: is always computed by summing the weights of the simplices

  • Hilbert: is computed by computing persistence on slices, and a Möbius inversion, unless the detected input is a minimal presentation (i.e., filtered_complex.is_minpres), which in that case, doesn’t need any computation. - If the input is a simplextree, this is done via a the standard Gudhi implementation,

    with parallel (TBB) computations of slices.

    • If the input is a slicer then - If the input is vineyard-capable, then slices are computed via vineyards updates.

      It is slower in general, but faster if single threaded. In particular, it is usually faster to use this backend if you want to compute the signed measure of multiple datasets in a parallel context.

      • Otherwise, slices are computed in parallel. It is usually faster to use this backend if not in a parallel context.

  • Rank: Same as Hilbert.

Parameters:
Return type:

list[tuple[ndarray, ndarray]]