multipers 2.2.3__cp310-cp310-win_amd64.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of multipers might be problematic. Click here for more details.
- multipers/__init__.py +31 -0
- multipers/_signed_measure_meta.py +430 -0
- multipers/_slicer_meta.py +212 -0
- multipers/data/MOL2.py +458 -0
- multipers/data/UCR.py +18 -0
- multipers/data/__init__.py +1 -0
- multipers/data/graphs.py +466 -0
- multipers/data/immuno_regions.py +27 -0
- multipers/data/minimal_presentation_to_st_bf.py +0 -0
- multipers/data/pytorch2simplextree.py +91 -0
- multipers/data/shape3d.py +101 -0
- multipers/data/synthetic.py +111 -0
- multipers/distances.py +198 -0
- multipers/filtration_conversions.pxd +229 -0
- multipers/filtration_conversions.pxd.tp +84 -0
- multipers/filtrations.pxd +224 -0
- multipers/function_rips.cp310-win_amd64.pyd +0 -0
- multipers/function_rips.pyx +105 -0
- multipers/grids.cp310-win_amd64.pyd +0 -0
- multipers/grids.pyx +350 -0
- multipers/gudhi/Persistence_slices_interface.h +132 -0
- multipers/gudhi/Simplex_tree_interface.h +245 -0
- multipers/gudhi/Simplex_tree_multi_interface.h +561 -0
- multipers/gudhi/cubical_to_boundary.h +59 -0
- multipers/gudhi/gudhi/Bitmap_cubical_complex.h +450 -0
- multipers/gudhi/gudhi/Bitmap_cubical_complex_base.h +1070 -0
- multipers/gudhi/gudhi/Bitmap_cubical_complex_periodic_boundary_conditions_base.h +579 -0
- multipers/gudhi/gudhi/Debug_utils.h +45 -0
- multipers/gudhi/gudhi/Fields/Multi_field.h +484 -0
- multipers/gudhi/gudhi/Fields/Multi_field_operators.h +455 -0
- multipers/gudhi/gudhi/Fields/Multi_field_shared.h +450 -0
- multipers/gudhi/gudhi/Fields/Multi_field_small.h +531 -0
- multipers/gudhi/gudhi/Fields/Multi_field_small_operators.h +507 -0
- multipers/gudhi/gudhi/Fields/Multi_field_small_shared.h +531 -0
- multipers/gudhi/gudhi/Fields/Z2_field.h +355 -0
- multipers/gudhi/gudhi/Fields/Z2_field_operators.h +376 -0
- multipers/gudhi/gudhi/Fields/Zp_field.h +420 -0
- multipers/gudhi/gudhi/Fields/Zp_field_operators.h +400 -0
- multipers/gudhi/gudhi/Fields/Zp_field_shared.h +418 -0
- multipers/gudhi/gudhi/Flag_complex_edge_collapser.h +337 -0
- multipers/gudhi/gudhi/Matrix.h +2107 -0
- multipers/gudhi/gudhi/Multi_critical_filtration.h +1038 -0
- multipers/gudhi/gudhi/Multi_persistence/Box.h +171 -0
- multipers/gudhi/gudhi/Multi_persistence/Line.h +282 -0
- multipers/gudhi/gudhi/Off_reader.h +173 -0
- multipers/gudhi/gudhi/One_critical_filtration.h +1431 -0
- multipers/gudhi/gudhi/Persistence_matrix/Base_matrix.h +769 -0
- multipers/gudhi/gudhi/Persistence_matrix/Base_matrix_with_column_compression.h +686 -0
- multipers/gudhi/gudhi/Persistence_matrix/Boundary_matrix.h +842 -0
- multipers/gudhi/gudhi/Persistence_matrix/Chain_matrix.h +1350 -0
- multipers/gudhi/gudhi/Persistence_matrix/Id_to_index_overlay.h +1105 -0
- multipers/gudhi/gudhi/Persistence_matrix/Position_to_index_overlay.h +859 -0
- multipers/gudhi/gudhi/Persistence_matrix/RU_matrix.h +910 -0
- multipers/gudhi/gudhi/Persistence_matrix/allocators/entry_constructors.h +139 -0
- multipers/gudhi/gudhi/Persistence_matrix/base_pairing.h +230 -0
- multipers/gudhi/gudhi/Persistence_matrix/base_swap.h +211 -0
- multipers/gudhi/gudhi/Persistence_matrix/boundary_cell_position_to_id_mapper.h +60 -0
- multipers/gudhi/gudhi/Persistence_matrix/boundary_face_position_to_id_mapper.h +60 -0
- multipers/gudhi/gudhi/Persistence_matrix/chain_pairing.h +136 -0
- multipers/gudhi/gudhi/Persistence_matrix/chain_rep_cycles.h +190 -0
- multipers/gudhi/gudhi/Persistence_matrix/chain_vine_swap.h +616 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/chain_column_extra_properties.h +150 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/column_dimension_holder.h +106 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/column_utilities.h +219 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/entry_types.h +327 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/heap_column.h +1140 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/intrusive_list_column.h +934 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/intrusive_set_column.h +934 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/list_column.h +980 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/naive_vector_column.h +1092 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/row_access.h +192 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/set_column.h +921 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/small_vector_column.h +1093 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/unordered_set_column.h +1012 -0
- multipers/gudhi/gudhi/Persistence_matrix/columns/vector_column.h +1244 -0
- multipers/gudhi/gudhi/Persistence_matrix/matrix_dimension_holders.h +186 -0
- multipers/gudhi/gudhi/Persistence_matrix/matrix_row_access.h +164 -0
- multipers/gudhi/gudhi/Persistence_matrix/ru_pairing.h +156 -0
- multipers/gudhi/gudhi/Persistence_matrix/ru_rep_cycles.h +376 -0
- multipers/gudhi/gudhi/Persistence_matrix/ru_vine_swap.h +540 -0
- multipers/gudhi/gudhi/Persistent_cohomology/Field_Zp.h +118 -0
- multipers/gudhi/gudhi/Persistent_cohomology/Multi_field.h +173 -0
- multipers/gudhi/gudhi/Persistent_cohomology/Persistent_cohomology_column.h +128 -0
- multipers/gudhi/gudhi/Persistent_cohomology.h +745 -0
- multipers/gudhi/gudhi/Points_off_io.h +171 -0
- multipers/gudhi/gudhi/Simple_object_pool.h +69 -0
- multipers/gudhi/gudhi/Simplex_tree/Simplex_tree_iterators.h +463 -0
- multipers/gudhi/gudhi/Simplex_tree/Simplex_tree_node_explicit_storage.h +83 -0
- multipers/gudhi/gudhi/Simplex_tree/Simplex_tree_siblings.h +106 -0
- multipers/gudhi/gudhi/Simplex_tree/Simplex_tree_star_simplex_iterators.h +277 -0
- multipers/gudhi/gudhi/Simplex_tree/hooks_simplex_base.h +62 -0
- multipers/gudhi/gudhi/Simplex_tree/indexing_tag.h +27 -0
- multipers/gudhi/gudhi/Simplex_tree/serialization_utils.h +62 -0
- multipers/gudhi/gudhi/Simplex_tree/simplex_tree_options.h +157 -0
- multipers/gudhi/gudhi/Simplex_tree.h +2794 -0
- multipers/gudhi/gudhi/Simplex_tree_multi.h +163 -0
- multipers/gudhi/gudhi/distance_functions.h +62 -0
- multipers/gudhi/gudhi/graph_simplicial_complex.h +104 -0
- multipers/gudhi/gudhi/persistence_interval.h +253 -0
- multipers/gudhi/gudhi/persistence_matrix_options.h +170 -0
- multipers/gudhi/gudhi/reader_utils.h +367 -0
- multipers/gudhi/mma_interface_coh.h +255 -0
- multipers/gudhi/mma_interface_h0.h +231 -0
- multipers/gudhi/mma_interface_matrix.h +282 -0
- multipers/gudhi/naive_merge_tree.h +575 -0
- multipers/gudhi/scc_io.h +289 -0
- multipers/gudhi/truc.h +888 -0
- multipers/io.cp310-win_amd64.pyd +0 -0
- multipers/io.pyx +711 -0
- multipers/ml/__init__.py +0 -0
- multipers/ml/accuracies.py +90 -0
- multipers/ml/convolutions.py +520 -0
- multipers/ml/invariants_with_persistable.py +79 -0
- multipers/ml/kernels.py +176 -0
- multipers/ml/mma.py +714 -0
- multipers/ml/one.py +472 -0
- multipers/ml/point_clouds.py +346 -0
- multipers/ml/signed_measures.py +1589 -0
- multipers/ml/sliced_wasserstein.py +461 -0
- multipers/ml/tools.py +113 -0
- multipers/mma_structures.cp310-win_amd64.pyd +0 -0
- multipers/mma_structures.pxd +127 -0
- multipers/mma_structures.pyx +2746 -0
- multipers/mma_structures.pyx.tp +1085 -0
- multipers/multi_parameter_rank_invariant/diff_helpers.h +93 -0
- multipers/multi_parameter_rank_invariant/euler_characteristic.h +97 -0
- multipers/multi_parameter_rank_invariant/function_rips.h +322 -0
- multipers/multi_parameter_rank_invariant/hilbert_function.h +769 -0
- multipers/multi_parameter_rank_invariant/persistence_slices.h +148 -0
- multipers/multi_parameter_rank_invariant/rank_invariant.h +369 -0
- multipers/multiparameter_edge_collapse.py +41 -0
- multipers/multiparameter_module_approximation/approximation.h +2295 -0
- multipers/multiparameter_module_approximation/combinatory.h +129 -0
- multipers/multiparameter_module_approximation/debug.h +107 -0
- multipers/multiparameter_module_approximation/euler_curves.h +0 -0
- multipers/multiparameter_module_approximation/format_python-cpp.h +286 -0
- multipers/multiparameter_module_approximation/heap_column.h +238 -0
- multipers/multiparameter_module_approximation/images.h +79 -0
- multipers/multiparameter_module_approximation/list_column.h +174 -0
- multipers/multiparameter_module_approximation/list_column_2.h +232 -0
- multipers/multiparameter_module_approximation/ru_matrix.h +347 -0
- multipers/multiparameter_module_approximation/set_column.h +135 -0
- multipers/multiparameter_module_approximation/structure_higher_dim_barcode.h +36 -0
- multipers/multiparameter_module_approximation/unordered_set_column.h +166 -0
- multipers/multiparameter_module_approximation/utilities.h +419 -0
- multipers/multiparameter_module_approximation/vector_column.h +223 -0
- multipers/multiparameter_module_approximation/vector_matrix.h +331 -0
- multipers/multiparameter_module_approximation/vineyards.h +464 -0
- multipers/multiparameter_module_approximation/vineyards_trajectories.h +649 -0
- multipers/multiparameter_module_approximation.cp310-win_amd64.pyd +0 -0
- multipers/multiparameter_module_approximation.pyx +217 -0
- multipers/pickle.py +53 -0
- multipers/plots.py +334 -0
- multipers/point_measure.cp310-win_amd64.pyd +0 -0
- multipers/point_measure.pyx +320 -0
- multipers/simplex_tree_multi.cp310-win_amd64.pyd +0 -0
- multipers/simplex_tree_multi.pxd +133 -0
- multipers/simplex_tree_multi.pyx +10335 -0
- multipers/simplex_tree_multi.pyx.tp +1935 -0
- multipers/slicer.cp310-win_amd64.pyd +0 -0
- multipers/slicer.pxd +2371 -0
- multipers/slicer.pxd.tp +214 -0
- multipers/slicer.pyx +15467 -0
- multipers/slicer.pyx.tp +914 -0
- multipers/tbb12.dll +0 -0
- multipers/tbbbind_2_5.dll +0 -0
- multipers/tbbmalloc.dll +0 -0
- multipers/tbbmalloc_proxy.dll +0 -0
- multipers/tensor/tensor.h +672 -0
- multipers/tensor.pxd +13 -0
- multipers/test.pyx +44 -0
- multipers/tests/__init__.py +57 -0
- multipers/tests/test_diff_helper.py +73 -0
- multipers/tests/test_hilbert_function.py +82 -0
- multipers/tests/test_mma.py +83 -0
- multipers/tests/test_point_clouds.py +49 -0
- multipers/tests/test_python-cpp_conversion.py +82 -0
- multipers/tests/test_signed_betti.py +181 -0
- multipers/tests/test_signed_measure.py +89 -0
- multipers/tests/test_simplextreemulti.py +221 -0
- multipers/tests/test_slicer.py +221 -0
- multipers/torch/__init__.py +1 -0
- multipers/torch/diff_grids.py +217 -0
- multipers/torch/rips_density.py +304 -0
- multipers-2.2.3.dist-info/LICENSE +21 -0
- multipers-2.2.3.dist-info/METADATA +134 -0
- multipers-2.2.3.dist-info/RECORD +189 -0
- multipers-2.2.3.dist-info/WHEEL +5 -0
- multipers-2.2.3.dist-info/top_level.txt +1 -0
multipers/slicer.pxd
ADDED
|
@@ -0,0 +1,2371 @@
|
|
|
1
|
+
|
|
2
|
+
cimport numpy as cnp
|
|
3
|
+
|
|
4
|
+
# SequentialDataset and its two concrete subclasses are (optionally randomized)
|
|
5
|
+
# iterators over the rows of a matrix X and corresponding target values y.
|
|
6
|
+
|
|
7
|
+
from libcpp.utility cimport pair
|
|
8
|
+
from libcpp cimport bool, int, float
|
|
9
|
+
from libcpp.vector cimport vector
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
from libc.stdint cimport intptr_t, uint16_t, uint32_t, int32_t, uint64_t, int64_t
|
|
13
|
+
from cython cimport uint
|
|
14
|
+
|
|
15
|
+
import numpy as np
|
|
16
|
+
python_value_type=np.float32
|
|
17
|
+
from libcpp.string cimport string
|
|
18
|
+
|
|
19
|
+
cdef extern from "Simplex_tree_multi_interface.h" namespace "Gudhi::multiparameter::python_interface":
|
|
20
|
+
cdef cppclass Simplex_tree_multi_interface[F=*, value_type=*]:
|
|
21
|
+
pass
|
|
22
|
+
|
|
23
|
+
from multipers.filtrations cimport *
|
|
24
|
+
ctypedef vector[uint] cycle_type ## its the cycle type of matrix
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
#------------------------------------------------------------------------------
|
|
28
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
29
|
+
cdef cppclass C_KSlicer_Matrix0_vine_i32 "TrucPythonInterface<BackendsEnum::Matrix,true,true,int32_t,Available_columns::INTRUSIVE_SET>":
|
|
30
|
+
ctypedef int32_t value_type
|
|
31
|
+
|
|
32
|
+
C_KSlicer_Matrix0_vine_i32()
|
|
33
|
+
|
|
34
|
+
C_KSlicer_Matrix0_vine_i32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[int32_t]]&)
|
|
35
|
+
|
|
36
|
+
C_KSlicer_Matrix0_vine_i32& operator=(const C_KSlicer_Matrix0_vine_i32&)
|
|
37
|
+
vector[vector[pair[int32_t, int32_t]]] get_barcode() nogil
|
|
38
|
+
void push_to(const Line[int32_t]&) nogil
|
|
39
|
+
void set_one_filtration(const vector[int32_t]&) nogil
|
|
40
|
+
int prune_above_dimension(int) except + nogil
|
|
41
|
+
|
|
42
|
+
vector[int32_t] get_one_filtration()
|
|
43
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
44
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
45
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
46
|
+
uint32_t num_generators() nogil
|
|
47
|
+
uint32_t num_parameters() nogil
|
|
48
|
+
string to_str() nogil
|
|
49
|
+
pair[One_critical_filtration[int32_t], One_critical_filtration[int32_t]] get_bounding_box() except + nogil
|
|
50
|
+
vector[One_critical_filtration[int32_t]] get_filtration_values() nogil
|
|
51
|
+
vector[int] get_dimensions() nogil
|
|
52
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
53
|
+
void coarsen_on_grid_inplace(vector[vector[int32_t]], bool) nogil
|
|
54
|
+
vector[Multi_critical_filtration[int32_t]]& get_filtrations() nogil
|
|
55
|
+
C_KSlicer_Matrix0_vine_i32 coarsen_on_grid(vector[vector[int32_t]]) nogil
|
|
56
|
+
void vineyard_update() nogil
|
|
57
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
58
|
+
vector[uint32_t] get_current_order() nogil
|
|
59
|
+
void add_generator(const One_critical_filtration[int32_t] &) nogil
|
|
60
|
+
|
|
61
|
+
|
|
62
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[vector[int32_t]]) nogil
|
|
63
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[pair[vector[int32_t],vector[int32_t]]]) nogil
|
|
64
|
+
|
|
65
|
+
#------------------------------------------------------------------------------
|
|
66
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
67
|
+
cdef cppclass C_KSlicer_Matrix1_vine_i32 "TrucPythonInterface<BackendsEnum::Matrix,true,true,int32_t,Available_columns::SMALL_VECTOR>":
|
|
68
|
+
ctypedef int32_t value_type
|
|
69
|
+
|
|
70
|
+
C_KSlicer_Matrix1_vine_i32()
|
|
71
|
+
|
|
72
|
+
C_KSlicer_Matrix1_vine_i32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[int32_t]]&)
|
|
73
|
+
|
|
74
|
+
C_KSlicer_Matrix1_vine_i32& operator=(const C_KSlicer_Matrix1_vine_i32&)
|
|
75
|
+
vector[vector[pair[int32_t, int32_t]]] get_barcode() nogil
|
|
76
|
+
void push_to(const Line[int32_t]&) nogil
|
|
77
|
+
void set_one_filtration(const vector[int32_t]&) nogil
|
|
78
|
+
int prune_above_dimension(int) except + nogil
|
|
79
|
+
|
|
80
|
+
vector[int32_t] get_one_filtration()
|
|
81
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
82
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
83
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
84
|
+
uint32_t num_generators() nogil
|
|
85
|
+
uint32_t num_parameters() nogil
|
|
86
|
+
string to_str() nogil
|
|
87
|
+
pair[One_critical_filtration[int32_t], One_critical_filtration[int32_t]] get_bounding_box() except + nogil
|
|
88
|
+
vector[One_critical_filtration[int32_t]] get_filtration_values() nogil
|
|
89
|
+
vector[int] get_dimensions() nogil
|
|
90
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
91
|
+
void coarsen_on_grid_inplace(vector[vector[int32_t]], bool) nogil
|
|
92
|
+
vector[Multi_critical_filtration[int32_t]]& get_filtrations() nogil
|
|
93
|
+
C_KSlicer_Matrix1_vine_i32 coarsen_on_grid(vector[vector[int32_t]]) nogil
|
|
94
|
+
void vineyard_update() nogil
|
|
95
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
96
|
+
vector[uint32_t] get_current_order() nogil
|
|
97
|
+
void add_generator(const One_critical_filtration[int32_t] &) nogil
|
|
98
|
+
|
|
99
|
+
|
|
100
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[vector[int32_t]]) nogil
|
|
101
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[pair[vector[int32_t],vector[int32_t]]]) nogil
|
|
102
|
+
|
|
103
|
+
#------------------------------------------------------------------------------
|
|
104
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
105
|
+
cdef cppclass C_KSlicer_Matrix0_vine_i64 "TrucPythonInterface<BackendsEnum::Matrix,true,true,int64_t,Available_columns::INTRUSIVE_SET>":
|
|
106
|
+
ctypedef int64_t value_type
|
|
107
|
+
|
|
108
|
+
C_KSlicer_Matrix0_vine_i64()
|
|
109
|
+
|
|
110
|
+
C_KSlicer_Matrix0_vine_i64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[int64_t]]&)
|
|
111
|
+
|
|
112
|
+
C_KSlicer_Matrix0_vine_i64& operator=(const C_KSlicer_Matrix0_vine_i64&)
|
|
113
|
+
vector[vector[pair[int64_t, int64_t]]] get_barcode() nogil
|
|
114
|
+
void push_to(const Line[int64_t]&) nogil
|
|
115
|
+
void set_one_filtration(const vector[int64_t]&) nogil
|
|
116
|
+
int prune_above_dimension(int) except + nogil
|
|
117
|
+
|
|
118
|
+
vector[int64_t] get_one_filtration()
|
|
119
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
120
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
121
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
122
|
+
uint32_t num_generators() nogil
|
|
123
|
+
uint32_t num_parameters() nogil
|
|
124
|
+
string to_str() nogil
|
|
125
|
+
pair[One_critical_filtration[int64_t], One_critical_filtration[int64_t]] get_bounding_box() except + nogil
|
|
126
|
+
vector[One_critical_filtration[int64_t]] get_filtration_values() nogil
|
|
127
|
+
vector[int] get_dimensions() nogil
|
|
128
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
129
|
+
void coarsen_on_grid_inplace(vector[vector[int64_t]], bool) nogil
|
|
130
|
+
vector[Multi_critical_filtration[int64_t]]& get_filtrations() nogil
|
|
131
|
+
C_KSlicer_Matrix0_vine_i32 coarsen_on_grid(vector[vector[int64_t]]) nogil
|
|
132
|
+
void vineyard_update() nogil
|
|
133
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
134
|
+
vector[uint32_t] get_current_order() nogil
|
|
135
|
+
void add_generator(const One_critical_filtration[int64_t] &) nogil
|
|
136
|
+
|
|
137
|
+
|
|
138
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[vector[int64_t]]) nogil
|
|
139
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[pair[vector[int64_t],vector[int64_t]]]) nogil
|
|
140
|
+
|
|
141
|
+
#------------------------------------------------------------------------------
|
|
142
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
143
|
+
cdef cppclass C_KSlicer_Matrix1_vine_i64 "TrucPythonInterface<BackendsEnum::Matrix,true,true,int64_t,Available_columns::SMALL_VECTOR>":
|
|
144
|
+
ctypedef int64_t value_type
|
|
145
|
+
|
|
146
|
+
C_KSlicer_Matrix1_vine_i64()
|
|
147
|
+
|
|
148
|
+
C_KSlicer_Matrix1_vine_i64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[int64_t]]&)
|
|
149
|
+
|
|
150
|
+
C_KSlicer_Matrix1_vine_i64& operator=(const C_KSlicer_Matrix1_vine_i64&)
|
|
151
|
+
vector[vector[pair[int64_t, int64_t]]] get_barcode() nogil
|
|
152
|
+
void push_to(const Line[int64_t]&) nogil
|
|
153
|
+
void set_one_filtration(const vector[int64_t]&) nogil
|
|
154
|
+
int prune_above_dimension(int) except + nogil
|
|
155
|
+
|
|
156
|
+
vector[int64_t] get_one_filtration()
|
|
157
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
158
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
159
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
160
|
+
uint32_t num_generators() nogil
|
|
161
|
+
uint32_t num_parameters() nogil
|
|
162
|
+
string to_str() nogil
|
|
163
|
+
pair[One_critical_filtration[int64_t], One_critical_filtration[int64_t]] get_bounding_box() except + nogil
|
|
164
|
+
vector[One_critical_filtration[int64_t]] get_filtration_values() nogil
|
|
165
|
+
vector[int] get_dimensions() nogil
|
|
166
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
167
|
+
void coarsen_on_grid_inplace(vector[vector[int64_t]], bool) nogil
|
|
168
|
+
vector[Multi_critical_filtration[int64_t]]& get_filtrations() nogil
|
|
169
|
+
C_KSlicer_Matrix1_vine_i32 coarsen_on_grid(vector[vector[int64_t]]) nogil
|
|
170
|
+
void vineyard_update() nogil
|
|
171
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
172
|
+
vector[uint32_t] get_current_order() nogil
|
|
173
|
+
void add_generator(const One_critical_filtration[int64_t] &) nogil
|
|
174
|
+
|
|
175
|
+
|
|
176
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[vector[int64_t]]) nogil
|
|
177
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[pair[vector[int64_t],vector[int64_t]]]) nogil
|
|
178
|
+
|
|
179
|
+
#------------------------------------------------------------------------------
|
|
180
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
181
|
+
cdef cppclass C_KSlicer_Matrix0_vine_f32 "TrucPythonInterface<BackendsEnum::Matrix,true,true,float,Available_columns::INTRUSIVE_SET>":
|
|
182
|
+
ctypedef float value_type
|
|
183
|
+
|
|
184
|
+
C_KSlicer_Matrix0_vine_f32()
|
|
185
|
+
|
|
186
|
+
C_KSlicer_Matrix0_vine_f32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[float]]&)
|
|
187
|
+
|
|
188
|
+
C_KSlicer_Matrix0_vine_f32& operator=(const C_KSlicer_Matrix0_vine_f32&)
|
|
189
|
+
vector[vector[pair[float, float]]] get_barcode() nogil
|
|
190
|
+
void push_to(const Line[float]&) nogil
|
|
191
|
+
void set_one_filtration(const vector[float]&) nogil
|
|
192
|
+
int prune_above_dimension(int) except + nogil
|
|
193
|
+
|
|
194
|
+
vector[float] get_one_filtration()
|
|
195
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
196
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
197
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
198
|
+
uint32_t num_generators() nogil
|
|
199
|
+
uint32_t num_parameters() nogil
|
|
200
|
+
string to_str() nogil
|
|
201
|
+
pair[One_critical_filtration[float], One_critical_filtration[float]] get_bounding_box() except + nogil
|
|
202
|
+
vector[One_critical_filtration[float]] get_filtration_values() nogil
|
|
203
|
+
vector[int] get_dimensions() nogil
|
|
204
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
205
|
+
void coarsen_on_grid_inplace(vector[vector[float]], bool) nogil
|
|
206
|
+
vector[Multi_critical_filtration[float]]& get_filtrations() nogil
|
|
207
|
+
C_KSlicer_Matrix0_vine_i32 coarsen_on_grid(vector[vector[float]]) nogil
|
|
208
|
+
void vineyard_update() nogil
|
|
209
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
210
|
+
vector[uint32_t] get_current_order() nogil
|
|
211
|
+
void add_generator(const One_critical_filtration[float] &) nogil
|
|
212
|
+
|
|
213
|
+
|
|
214
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[vector[float]]) nogil
|
|
215
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[pair[vector[float],vector[float]]]) nogil
|
|
216
|
+
|
|
217
|
+
#------------------------------------------------------------------------------
|
|
218
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
219
|
+
cdef cppclass C_KSlicer_Matrix1_vine_f32 "TrucPythonInterface<BackendsEnum::Matrix,true,true,float,Available_columns::SMALL_VECTOR>":
|
|
220
|
+
ctypedef float value_type
|
|
221
|
+
|
|
222
|
+
C_KSlicer_Matrix1_vine_f32()
|
|
223
|
+
|
|
224
|
+
C_KSlicer_Matrix1_vine_f32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[float]]&)
|
|
225
|
+
|
|
226
|
+
C_KSlicer_Matrix1_vine_f32& operator=(const C_KSlicer_Matrix1_vine_f32&)
|
|
227
|
+
vector[vector[pair[float, float]]] get_barcode() nogil
|
|
228
|
+
void push_to(const Line[float]&) nogil
|
|
229
|
+
void set_one_filtration(const vector[float]&) nogil
|
|
230
|
+
int prune_above_dimension(int) except + nogil
|
|
231
|
+
|
|
232
|
+
vector[float] get_one_filtration()
|
|
233
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
234
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
235
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
236
|
+
uint32_t num_generators() nogil
|
|
237
|
+
uint32_t num_parameters() nogil
|
|
238
|
+
string to_str() nogil
|
|
239
|
+
pair[One_critical_filtration[float], One_critical_filtration[float]] get_bounding_box() except + nogil
|
|
240
|
+
vector[One_critical_filtration[float]] get_filtration_values() nogil
|
|
241
|
+
vector[int] get_dimensions() nogil
|
|
242
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
243
|
+
void coarsen_on_grid_inplace(vector[vector[float]], bool) nogil
|
|
244
|
+
vector[Multi_critical_filtration[float]]& get_filtrations() nogil
|
|
245
|
+
C_KSlicer_Matrix1_vine_i32 coarsen_on_grid(vector[vector[float]]) nogil
|
|
246
|
+
void vineyard_update() nogil
|
|
247
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
248
|
+
vector[uint32_t] get_current_order() nogil
|
|
249
|
+
void add_generator(const One_critical_filtration[float] &) nogil
|
|
250
|
+
|
|
251
|
+
|
|
252
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[vector[float]]) nogil
|
|
253
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[pair[vector[float],vector[float]]]) nogil
|
|
254
|
+
|
|
255
|
+
#------------------------------------------------------------------------------
|
|
256
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
257
|
+
cdef cppclass C_KSlicer_Matrix0_vine_f64 "TrucPythonInterface<BackendsEnum::Matrix,true,true,double,Available_columns::INTRUSIVE_SET>":
|
|
258
|
+
ctypedef double value_type
|
|
259
|
+
|
|
260
|
+
C_KSlicer_Matrix0_vine_f64()
|
|
261
|
+
|
|
262
|
+
C_KSlicer_Matrix0_vine_f64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[double]]&)
|
|
263
|
+
|
|
264
|
+
C_KSlicer_Matrix0_vine_f64& operator=(const C_KSlicer_Matrix0_vine_f64&)
|
|
265
|
+
vector[vector[pair[double, double]]] get_barcode() nogil
|
|
266
|
+
void push_to(const Line[double]&) nogil
|
|
267
|
+
void set_one_filtration(const vector[double]&) nogil
|
|
268
|
+
int prune_above_dimension(int) except + nogil
|
|
269
|
+
|
|
270
|
+
vector[double] get_one_filtration()
|
|
271
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
272
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
273
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
274
|
+
uint32_t num_generators() nogil
|
|
275
|
+
uint32_t num_parameters() nogil
|
|
276
|
+
string to_str() nogil
|
|
277
|
+
pair[One_critical_filtration[double], One_critical_filtration[double]] get_bounding_box() except + nogil
|
|
278
|
+
vector[One_critical_filtration[double]] get_filtration_values() nogil
|
|
279
|
+
vector[int] get_dimensions() nogil
|
|
280
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
281
|
+
void coarsen_on_grid_inplace(vector[vector[double]], bool) nogil
|
|
282
|
+
vector[Multi_critical_filtration[double]]& get_filtrations() nogil
|
|
283
|
+
C_KSlicer_Matrix0_vine_i32 coarsen_on_grid(vector[vector[double]]) nogil
|
|
284
|
+
void vineyard_update() nogil
|
|
285
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
286
|
+
vector[uint32_t] get_current_order() nogil
|
|
287
|
+
void add_generator(const One_critical_filtration[double] &) nogil
|
|
288
|
+
|
|
289
|
+
|
|
290
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[vector[double]]) nogil
|
|
291
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[pair[vector[double],vector[double]]]) nogil
|
|
292
|
+
|
|
293
|
+
#------------------------------------------------------------------------------
|
|
294
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
295
|
+
cdef cppclass C_KSlicer_Matrix1_vine_f64 "TrucPythonInterface<BackendsEnum::Matrix,true,true,double,Available_columns::SMALL_VECTOR>":
|
|
296
|
+
ctypedef double value_type
|
|
297
|
+
|
|
298
|
+
C_KSlicer_Matrix1_vine_f64()
|
|
299
|
+
|
|
300
|
+
C_KSlicer_Matrix1_vine_f64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[double]]&)
|
|
301
|
+
|
|
302
|
+
C_KSlicer_Matrix1_vine_f64& operator=(const C_KSlicer_Matrix1_vine_f64&)
|
|
303
|
+
vector[vector[pair[double, double]]] get_barcode() nogil
|
|
304
|
+
void push_to(const Line[double]&) nogil
|
|
305
|
+
void set_one_filtration(const vector[double]&) nogil
|
|
306
|
+
int prune_above_dimension(int) except + nogil
|
|
307
|
+
|
|
308
|
+
vector[double] get_one_filtration()
|
|
309
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
310
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
311
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
312
|
+
uint32_t num_generators() nogil
|
|
313
|
+
uint32_t num_parameters() nogil
|
|
314
|
+
string to_str() nogil
|
|
315
|
+
pair[One_critical_filtration[double], One_critical_filtration[double]] get_bounding_box() except + nogil
|
|
316
|
+
vector[One_critical_filtration[double]] get_filtration_values() nogil
|
|
317
|
+
vector[int] get_dimensions() nogil
|
|
318
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
319
|
+
void coarsen_on_grid_inplace(vector[vector[double]], bool) nogil
|
|
320
|
+
vector[Multi_critical_filtration[double]]& get_filtrations() nogil
|
|
321
|
+
C_KSlicer_Matrix1_vine_i32 coarsen_on_grid(vector[vector[double]]) nogil
|
|
322
|
+
void vineyard_update() nogil
|
|
323
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
324
|
+
vector[uint32_t] get_current_order() nogil
|
|
325
|
+
void add_generator(const One_critical_filtration[double] &) nogil
|
|
326
|
+
|
|
327
|
+
|
|
328
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[vector[double]]) nogil
|
|
329
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[pair[vector[double],vector[double]]]) nogil
|
|
330
|
+
|
|
331
|
+
#------------------------------------------------------------------------------
|
|
332
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
333
|
+
cdef cppclass C_Slicer_Matrix0_vine_i32 "TrucPythonInterface<BackendsEnum::Matrix,true,false,int32_t,Available_columns::INTRUSIVE_SET>":
|
|
334
|
+
ctypedef int32_t value_type
|
|
335
|
+
|
|
336
|
+
C_Slicer_Matrix0_vine_i32()
|
|
337
|
+
|
|
338
|
+
C_Slicer_Matrix0_vine_i32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[int32_t]]&)
|
|
339
|
+
|
|
340
|
+
C_Slicer_Matrix0_vine_i32& operator=(const C_Slicer_Matrix0_vine_i32&)
|
|
341
|
+
vector[vector[pair[int32_t, int32_t]]] get_barcode() nogil
|
|
342
|
+
void push_to(const Line[int32_t]&) nogil
|
|
343
|
+
void set_one_filtration(const vector[int32_t]&) nogil
|
|
344
|
+
int prune_above_dimension(int) except + nogil
|
|
345
|
+
|
|
346
|
+
vector[int32_t] get_one_filtration()
|
|
347
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
348
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
349
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
350
|
+
uint32_t num_generators() nogil
|
|
351
|
+
uint32_t num_parameters() nogil
|
|
352
|
+
string to_str() nogil
|
|
353
|
+
pair[One_critical_filtration[int32_t], One_critical_filtration[int32_t]] get_bounding_box() except + nogil
|
|
354
|
+
vector[One_critical_filtration[int32_t]] get_filtration_values() nogil
|
|
355
|
+
vector[int] get_dimensions() nogil
|
|
356
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
357
|
+
void coarsen_on_grid_inplace(vector[vector[int32_t]], bool) nogil
|
|
358
|
+
vector[One_critical_filtration[int32_t]]& get_filtrations() nogil
|
|
359
|
+
C_Slicer_Matrix0_vine_i32 coarsen_on_grid(vector[vector[int32_t]]) nogil
|
|
360
|
+
void vineyard_update() nogil
|
|
361
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
362
|
+
vector[uint32_t] get_current_order() nogil
|
|
363
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
364
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
365
|
+
|
|
366
|
+
|
|
367
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[vector[int32_t]]) nogil
|
|
368
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[pair[vector[int32_t],vector[int32_t]]]) nogil
|
|
369
|
+
|
|
370
|
+
#------------------------------------------------------------------------------
|
|
371
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
372
|
+
cdef cppclass C_Slicer_Matrix1_vine_i32 "TrucPythonInterface<BackendsEnum::Matrix,true,false,int32_t,Available_columns::SMALL_VECTOR>":
|
|
373
|
+
ctypedef int32_t value_type
|
|
374
|
+
|
|
375
|
+
C_Slicer_Matrix1_vine_i32()
|
|
376
|
+
|
|
377
|
+
C_Slicer_Matrix1_vine_i32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[int32_t]]&)
|
|
378
|
+
|
|
379
|
+
C_Slicer_Matrix1_vine_i32& operator=(const C_Slicer_Matrix1_vine_i32&)
|
|
380
|
+
vector[vector[pair[int32_t, int32_t]]] get_barcode() nogil
|
|
381
|
+
void push_to(const Line[int32_t]&) nogil
|
|
382
|
+
void set_one_filtration(const vector[int32_t]&) nogil
|
|
383
|
+
int prune_above_dimension(int) except + nogil
|
|
384
|
+
|
|
385
|
+
vector[int32_t] get_one_filtration()
|
|
386
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
387
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
388
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
389
|
+
uint32_t num_generators() nogil
|
|
390
|
+
uint32_t num_parameters() nogil
|
|
391
|
+
string to_str() nogil
|
|
392
|
+
pair[One_critical_filtration[int32_t], One_critical_filtration[int32_t]] get_bounding_box() except + nogil
|
|
393
|
+
vector[One_critical_filtration[int32_t]] get_filtration_values() nogil
|
|
394
|
+
vector[int] get_dimensions() nogil
|
|
395
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
396
|
+
void coarsen_on_grid_inplace(vector[vector[int32_t]], bool) nogil
|
|
397
|
+
vector[One_critical_filtration[int32_t]]& get_filtrations() nogil
|
|
398
|
+
C_Slicer_Matrix1_vine_i32 coarsen_on_grid(vector[vector[int32_t]]) nogil
|
|
399
|
+
void vineyard_update() nogil
|
|
400
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
401
|
+
vector[uint32_t] get_current_order() nogil
|
|
402
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
403
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
404
|
+
|
|
405
|
+
|
|
406
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[vector[int32_t]]) nogil
|
|
407
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[pair[vector[int32_t],vector[int32_t]]]) nogil
|
|
408
|
+
|
|
409
|
+
#------------------------------------------------------------------------------
|
|
410
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
411
|
+
cdef cppclass C_Slicer_Matrix0_vine_i64 "TrucPythonInterface<BackendsEnum::Matrix,true,false,int64_t,Available_columns::INTRUSIVE_SET>":
|
|
412
|
+
ctypedef int64_t value_type
|
|
413
|
+
|
|
414
|
+
C_Slicer_Matrix0_vine_i64()
|
|
415
|
+
|
|
416
|
+
C_Slicer_Matrix0_vine_i64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[int64_t]]&)
|
|
417
|
+
|
|
418
|
+
C_Slicer_Matrix0_vine_i64& operator=(const C_Slicer_Matrix0_vine_i64&)
|
|
419
|
+
vector[vector[pair[int64_t, int64_t]]] get_barcode() nogil
|
|
420
|
+
void push_to(const Line[int64_t]&) nogil
|
|
421
|
+
void set_one_filtration(const vector[int64_t]&) nogil
|
|
422
|
+
int prune_above_dimension(int) except + nogil
|
|
423
|
+
|
|
424
|
+
vector[int64_t] get_one_filtration()
|
|
425
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
426
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
427
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
428
|
+
uint32_t num_generators() nogil
|
|
429
|
+
uint32_t num_parameters() nogil
|
|
430
|
+
string to_str() nogil
|
|
431
|
+
pair[One_critical_filtration[int64_t], One_critical_filtration[int64_t]] get_bounding_box() except + nogil
|
|
432
|
+
vector[One_critical_filtration[int64_t]] get_filtration_values() nogil
|
|
433
|
+
vector[int] get_dimensions() nogil
|
|
434
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
435
|
+
void coarsen_on_grid_inplace(vector[vector[int64_t]], bool) nogil
|
|
436
|
+
vector[One_critical_filtration[int64_t]]& get_filtrations() nogil
|
|
437
|
+
C_Slicer_Matrix0_vine_i32 coarsen_on_grid(vector[vector[int64_t]]) nogil
|
|
438
|
+
void vineyard_update() nogil
|
|
439
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
440
|
+
vector[uint32_t] get_current_order() nogil
|
|
441
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
442
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
443
|
+
|
|
444
|
+
|
|
445
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[vector[int64_t]]) nogil
|
|
446
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[pair[vector[int64_t],vector[int64_t]]]) nogil
|
|
447
|
+
|
|
448
|
+
#------------------------------------------------------------------------------
|
|
449
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
450
|
+
cdef cppclass C_Slicer_Matrix1_vine_i64 "TrucPythonInterface<BackendsEnum::Matrix,true,false,int64_t,Available_columns::SMALL_VECTOR>":
|
|
451
|
+
ctypedef int64_t value_type
|
|
452
|
+
|
|
453
|
+
C_Slicer_Matrix1_vine_i64()
|
|
454
|
+
|
|
455
|
+
C_Slicer_Matrix1_vine_i64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[int64_t]]&)
|
|
456
|
+
|
|
457
|
+
C_Slicer_Matrix1_vine_i64& operator=(const C_Slicer_Matrix1_vine_i64&)
|
|
458
|
+
vector[vector[pair[int64_t, int64_t]]] get_barcode() nogil
|
|
459
|
+
void push_to(const Line[int64_t]&) nogil
|
|
460
|
+
void set_one_filtration(const vector[int64_t]&) nogil
|
|
461
|
+
int prune_above_dimension(int) except + nogil
|
|
462
|
+
|
|
463
|
+
vector[int64_t] get_one_filtration()
|
|
464
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
465
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
466
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
467
|
+
uint32_t num_generators() nogil
|
|
468
|
+
uint32_t num_parameters() nogil
|
|
469
|
+
string to_str() nogil
|
|
470
|
+
pair[One_critical_filtration[int64_t], One_critical_filtration[int64_t]] get_bounding_box() except + nogil
|
|
471
|
+
vector[One_critical_filtration[int64_t]] get_filtration_values() nogil
|
|
472
|
+
vector[int] get_dimensions() nogil
|
|
473
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
474
|
+
void coarsen_on_grid_inplace(vector[vector[int64_t]], bool) nogil
|
|
475
|
+
vector[One_critical_filtration[int64_t]]& get_filtrations() nogil
|
|
476
|
+
C_Slicer_Matrix1_vine_i32 coarsen_on_grid(vector[vector[int64_t]]) nogil
|
|
477
|
+
void vineyard_update() nogil
|
|
478
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
479
|
+
vector[uint32_t] get_current_order() nogil
|
|
480
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
481
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
482
|
+
|
|
483
|
+
|
|
484
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[vector[int64_t]]) nogil
|
|
485
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[pair[vector[int64_t],vector[int64_t]]]) nogil
|
|
486
|
+
|
|
487
|
+
#------------------------------------------------------------------------------
|
|
488
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
489
|
+
cdef cppclass C_Slicer_Matrix0_vine_f32 "TrucPythonInterface<BackendsEnum::Matrix,true,false,float,Available_columns::INTRUSIVE_SET>":
|
|
490
|
+
ctypedef float value_type
|
|
491
|
+
|
|
492
|
+
C_Slicer_Matrix0_vine_f32()
|
|
493
|
+
|
|
494
|
+
C_Slicer_Matrix0_vine_f32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[float]]&)
|
|
495
|
+
|
|
496
|
+
C_Slicer_Matrix0_vine_f32& operator=(const C_Slicer_Matrix0_vine_f32&)
|
|
497
|
+
vector[vector[pair[float, float]]] get_barcode() nogil
|
|
498
|
+
void push_to(const Line[float]&) nogil
|
|
499
|
+
void set_one_filtration(const vector[float]&) nogil
|
|
500
|
+
int prune_above_dimension(int) except + nogil
|
|
501
|
+
|
|
502
|
+
vector[float] get_one_filtration()
|
|
503
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
504
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
505
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
506
|
+
uint32_t num_generators() nogil
|
|
507
|
+
uint32_t num_parameters() nogil
|
|
508
|
+
string to_str() nogil
|
|
509
|
+
pair[One_critical_filtration[float], One_critical_filtration[float]] get_bounding_box() except + nogil
|
|
510
|
+
vector[One_critical_filtration[float]] get_filtration_values() nogil
|
|
511
|
+
vector[int] get_dimensions() nogil
|
|
512
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
513
|
+
void coarsen_on_grid_inplace(vector[vector[float]], bool) nogil
|
|
514
|
+
vector[One_critical_filtration[float]]& get_filtrations() nogil
|
|
515
|
+
C_Slicer_Matrix0_vine_i32 coarsen_on_grid(vector[vector[float]]) nogil
|
|
516
|
+
void vineyard_update() nogil
|
|
517
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
518
|
+
vector[uint32_t] get_current_order() nogil
|
|
519
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
520
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
521
|
+
|
|
522
|
+
|
|
523
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[vector[float]]) nogil
|
|
524
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[pair[vector[float],vector[float]]]) nogil
|
|
525
|
+
|
|
526
|
+
#------------------------------------------------------------------------------
|
|
527
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
528
|
+
cdef cppclass C_Slicer_Matrix1_vine_f32 "TrucPythonInterface<BackendsEnum::Matrix,true,false,float,Available_columns::SMALL_VECTOR>":
|
|
529
|
+
ctypedef float value_type
|
|
530
|
+
|
|
531
|
+
C_Slicer_Matrix1_vine_f32()
|
|
532
|
+
|
|
533
|
+
C_Slicer_Matrix1_vine_f32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[float]]&)
|
|
534
|
+
|
|
535
|
+
C_Slicer_Matrix1_vine_f32& operator=(const C_Slicer_Matrix1_vine_f32&)
|
|
536
|
+
vector[vector[pair[float, float]]] get_barcode() nogil
|
|
537
|
+
void push_to(const Line[float]&) nogil
|
|
538
|
+
void set_one_filtration(const vector[float]&) nogil
|
|
539
|
+
int prune_above_dimension(int) except + nogil
|
|
540
|
+
|
|
541
|
+
vector[float] get_one_filtration()
|
|
542
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
543
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
544
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
545
|
+
uint32_t num_generators() nogil
|
|
546
|
+
uint32_t num_parameters() nogil
|
|
547
|
+
string to_str() nogil
|
|
548
|
+
pair[One_critical_filtration[float], One_critical_filtration[float]] get_bounding_box() except + nogil
|
|
549
|
+
vector[One_critical_filtration[float]] get_filtration_values() nogil
|
|
550
|
+
vector[int] get_dimensions() nogil
|
|
551
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
552
|
+
void coarsen_on_grid_inplace(vector[vector[float]], bool) nogil
|
|
553
|
+
vector[One_critical_filtration[float]]& get_filtrations() nogil
|
|
554
|
+
C_Slicer_Matrix1_vine_i32 coarsen_on_grid(vector[vector[float]]) nogil
|
|
555
|
+
void vineyard_update() nogil
|
|
556
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
557
|
+
vector[uint32_t] get_current_order() nogil
|
|
558
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
559
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
560
|
+
|
|
561
|
+
|
|
562
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[vector[float]]) nogil
|
|
563
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[pair[vector[float],vector[float]]]) nogil
|
|
564
|
+
|
|
565
|
+
#------------------------------------------------------------------------------
|
|
566
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
567
|
+
cdef cppclass C_Slicer_Matrix0_vine_f64 "TrucPythonInterface<BackendsEnum::Matrix,true,false,double,Available_columns::INTRUSIVE_SET>":
|
|
568
|
+
ctypedef double value_type
|
|
569
|
+
|
|
570
|
+
C_Slicer_Matrix0_vine_f64()
|
|
571
|
+
|
|
572
|
+
C_Slicer_Matrix0_vine_f64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[double]]&)
|
|
573
|
+
|
|
574
|
+
C_Slicer_Matrix0_vine_f64& operator=(const C_Slicer_Matrix0_vine_f64&)
|
|
575
|
+
vector[vector[pair[double, double]]] get_barcode() nogil
|
|
576
|
+
void push_to(const Line[double]&) nogil
|
|
577
|
+
void set_one_filtration(const vector[double]&) nogil
|
|
578
|
+
int prune_above_dimension(int) except + nogil
|
|
579
|
+
|
|
580
|
+
vector[double] get_one_filtration()
|
|
581
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
582
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
583
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
584
|
+
uint32_t num_generators() nogil
|
|
585
|
+
uint32_t num_parameters() nogil
|
|
586
|
+
string to_str() nogil
|
|
587
|
+
pair[One_critical_filtration[double], One_critical_filtration[double]] get_bounding_box() except + nogil
|
|
588
|
+
vector[One_critical_filtration[double]] get_filtration_values() nogil
|
|
589
|
+
vector[int] get_dimensions() nogil
|
|
590
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
591
|
+
void coarsen_on_grid_inplace(vector[vector[double]], bool) nogil
|
|
592
|
+
vector[One_critical_filtration[double]]& get_filtrations() nogil
|
|
593
|
+
C_Slicer_Matrix0_vine_i32 coarsen_on_grid(vector[vector[double]]) nogil
|
|
594
|
+
void vineyard_update() nogil
|
|
595
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
596
|
+
vector[uint32_t] get_current_order() nogil
|
|
597
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
598
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
599
|
+
|
|
600
|
+
|
|
601
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[vector[double]]) nogil
|
|
602
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[pair[vector[double],vector[double]]]) nogil
|
|
603
|
+
|
|
604
|
+
#------------------------------------------------------------------------------
|
|
605
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
606
|
+
cdef cppclass C_Slicer_Matrix1_vine_f64 "TrucPythonInterface<BackendsEnum::Matrix,true,false,double,Available_columns::SMALL_VECTOR>":
|
|
607
|
+
ctypedef double value_type
|
|
608
|
+
|
|
609
|
+
C_Slicer_Matrix1_vine_f64()
|
|
610
|
+
|
|
611
|
+
C_Slicer_Matrix1_vine_f64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[double]]&)
|
|
612
|
+
|
|
613
|
+
C_Slicer_Matrix1_vine_f64& operator=(const C_Slicer_Matrix1_vine_f64&)
|
|
614
|
+
vector[vector[pair[double, double]]] get_barcode() nogil
|
|
615
|
+
void push_to(const Line[double]&) nogil
|
|
616
|
+
void set_one_filtration(const vector[double]&) nogil
|
|
617
|
+
int prune_above_dimension(int) except + nogil
|
|
618
|
+
|
|
619
|
+
vector[double] get_one_filtration()
|
|
620
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
621
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
622
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
623
|
+
uint32_t num_generators() nogil
|
|
624
|
+
uint32_t num_parameters() nogil
|
|
625
|
+
string to_str() nogil
|
|
626
|
+
pair[One_critical_filtration[double], One_critical_filtration[double]] get_bounding_box() except + nogil
|
|
627
|
+
vector[One_critical_filtration[double]] get_filtration_values() nogil
|
|
628
|
+
vector[int] get_dimensions() nogil
|
|
629
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
630
|
+
void coarsen_on_grid_inplace(vector[vector[double]], bool) nogil
|
|
631
|
+
vector[One_critical_filtration[double]]& get_filtrations() nogil
|
|
632
|
+
C_Slicer_Matrix1_vine_i32 coarsen_on_grid(vector[vector[double]]) nogil
|
|
633
|
+
void vineyard_update() nogil
|
|
634
|
+
vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
|
|
635
|
+
vector[uint32_t] get_current_order() nogil
|
|
636
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
637
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
638
|
+
|
|
639
|
+
|
|
640
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[vector[double]]) nogil
|
|
641
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[pair[vector[double],vector[double]]]) nogil
|
|
642
|
+
|
|
643
|
+
#------------------------------------------------------------------------------
|
|
644
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
645
|
+
cdef cppclass C_KSlicer_Matrix0_i32 "TrucPythonInterface<BackendsEnum::Matrix,false,true,int32_t,Available_columns::INTRUSIVE_SET>":
|
|
646
|
+
ctypedef int32_t value_type
|
|
647
|
+
|
|
648
|
+
C_KSlicer_Matrix0_i32()
|
|
649
|
+
|
|
650
|
+
C_KSlicer_Matrix0_i32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[int32_t]]&)
|
|
651
|
+
|
|
652
|
+
C_KSlicer_Matrix0_i32& operator=(const C_KSlicer_Matrix0_i32&)
|
|
653
|
+
vector[vector[pair[int32_t, int32_t]]] get_barcode() nogil
|
|
654
|
+
void push_to(const Line[int32_t]&) nogil
|
|
655
|
+
void set_one_filtration(const vector[int32_t]&) nogil
|
|
656
|
+
int prune_above_dimension(int) except + nogil
|
|
657
|
+
|
|
658
|
+
vector[int32_t] get_one_filtration()
|
|
659
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
660
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
661
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
662
|
+
uint32_t num_generators() nogil
|
|
663
|
+
uint32_t num_parameters() nogil
|
|
664
|
+
string to_str() nogil
|
|
665
|
+
pair[One_critical_filtration[int32_t], One_critical_filtration[int32_t]] get_bounding_box() except + nogil
|
|
666
|
+
vector[One_critical_filtration[int32_t]] get_filtration_values() nogil
|
|
667
|
+
vector[int] get_dimensions() nogil
|
|
668
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
669
|
+
void coarsen_on_grid_inplace(vector[vector[int32_t]], bool) nogil
|
|
670
|
+
vector[Multi_critical_filtration[int32_t]]& get_filtrations() nogil
|
|
671
|
+
C_KSlicer_Matrix0_i32 coarsen_on_grid(vector[vector[int32_t]]) nogil
|
|
672
|
+
void add_generator(const One_critical_filtration[int32_t] &) nogil
|
|
673
|
+
|
|
674
|
+
|
|
675
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[vector[int32_t]]) nogil
|
|
676
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[pair[vector[int32_t],vector[int32_t]]]) nogil
|
|
677
|
+
|
|
678
|
+
#------------------------------------------------------------------------------
|
|
679
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
680
|
+
cdef cppclass C_KSlicer_Matrix1_i32 "TrucPythonInterface<BackendsEnum::Matrix,false,true,int32_t,Available_columns::SMALL_VECTOR>":
|
|
681
|
+
ctypedef int32_t value_type
|
|
682
|
+
|
|
683
|
+
C_KSlicer_Matrix1_i32()
|
|
684
|
+
|
|
685
|
+
C_KSlicer_Matrix1_i32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[int32_t]]&)
|
|
686
|
+
|
|
687
|
+
C_KSlicer_Matrix1_i32& operator=(const C_KSlicer_Matrix1_i32&)
|
|
688
|
+
vector[vector[pair[int32_t, int32_t]]] get_barcode() nogil
|
|
689
|
+
void push_to(const Line[int32_t]&) nogil
|
|
690
|
+
void set_one_filtration(const vector[int32_t]&) nogil
|
|
691
|
+
int prune_above_dimension(int) except + nogil
|
|
692
|
+
|
|
693
|
+
vector[int32_t] get_one_filtration()
|
|
694
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
695
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
696
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
697
|
+
uint32_t num_generators() nogil
|
|
698
|
+
uint32_t num_parameters() nogil
|
|
699
|
+
string to_str() nogil
|
|
700
|
+
pair[One_critical_filtration[int32_t], One_critical_filtration[int32_t]] get_bounding_box() except + nogil
|
|
701
|
+
vector[One_critical_filtration[int32_t]] get_filtration_values() nogil
|
|
702
|
+
vector[int] get_dimensions() nogil
|
|
703
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
704
|
+
void coarsen_on_grid_inplace(vector[vector[int32_t]], bool) nogil
|
|
705
|
+
vector[Multi_critical_filtration[int32_t]]& get_filtrations() nogil
|
|
706
|
+
C_KSlicer_Matrix1_i32 coarsen_on_grid(vector[vector[int32_t]]) nogil
|
|
707
|
+
void add_generator(const One_critical_filtration[int32_t] &) nogil
|
|
708
|
+
|
|
709
|
+
|
|
710
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[vector[int32_t]]) nogil
|
|
711
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[pair[vector[int32_t],vector[int32_t]]]) nogil
|
|
712
|
+
|
|
713
|
+
#------------------------------------------------------------------------------
|
|
714
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
715
|
+
cdef cppclass C_KSlicer_Matrix0_i64 "TrucPythonInterface<BackendsEnum::Matrix,false,true,int64_t,Available_columns::INTRUSIVE_SET>":
|
|
716
|
+
ctypedef int64_t value_type
|
|
717
|
+
|
|
718
|
+
C_KSlicer_Matrix0_i64()
|
|
719
|
+
|
|
720
|
+
C_KSlicer_Matrix0_i64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[int64_t]]&)
|
|
721
|
+
|
|
722
|
+
C_KSlicer_Matrix0_i64& operator=(const C_KSlicer_Matrix0_i64&)
|
|
723
|
+
vector[vector[pair[int64_t, int64_t]]] get_barcode() nogil
|
|
724
|
+
void push_to(const Line[int64_t]&) nogil
|
|
725
|
+
void set_one_filtration(const vector[int64_t]&) nogil
|
|
726
|
+
int prune_above_dimension(int) except + nogil
|
|
727
|
+
|
|
728
|
+
vector[int64_t] get_one_filtration()
|
|
729
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
730
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
731
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
732
|
+
uint32_t num_generators() nogil
|
|
733
|
+
uint32_t num_parameters() nogil
|
|
734
|
+
string to_str() nogil
|
|
735
|
+
pair[One_critical_filtration[int64_t], One_critical_filtration[int64_t]] get_bounding_box() except + nogil
|
|
736
|
+
vector[One_critical_filtration[int64_t]] get_filtration_values() nogil
|
|
737
|
+
vector[int] get_dimensions() nogil
|
|
738
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
739
|
+
void coarsen_on_grid_inplace(vector[vector[int64_t]], bool) nogil
|
|
740
|
+
vector[Multi_critical_filtration[int64_t]]& get_filtrations() nogil
|
|
741
|
+
C_KSlicer_Matrix0_i32 coarsen_on_grid(vector[vector[int64_t]]) nogil
|
|
742
|
+
void add_generator(const One_critical_filtration[int64_t] &) nogil
|
|
743
|
+
|
|
744
|
+
|
|
745
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[vector[int64_t]]) nogil
|
|
746
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[pair[vector[int64_t],vector[int64_t]]]) nogil
|
|
747
|
+
|
|
748
|
+
#------------------------------------------------------------------------------
|
|
749
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
750
|
+
cdef cppclass C_KSlicer_Matrix1_i64 "TrucPythonInterface<BackendsEnum::Matrix,false,true,int64_t,Available_columns::SMALL_VECTOR>":
|
|
751
|
+
ctypedef int64_t value_type
|
|
752
|
+
|
|
753
|
+
C_KSlicer_Matrix1_i64()
|
|
754
|
+
|
|
755
|
+
C_KSlicer_Matrix1_i64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[int64_t]]&)
|
|
756
|
+
|
|
757
|
+
C_KSlicer_Matrix1_i64& operator=(const C_KSlicer_Matrix1_i64&)
|
|
758
|
+
vector[vector[pair[int64_t, int64_t]]] get_barcode() nogil
|
|
759
|
+
void push_to(const Line[int64_t]&) nogil
|
|
760
|
+
void set_one_filtration(const vector[int64_t]&) nogil
|
|
761
|
+
int prune_above_dimension(int) except + nogil
|
|
762
|
+
|
|
763
|
+
vector[int64_t] get_one_filtration()
|
|
764
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
765
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
766
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
767
|
+
uint32_t num_generators() nogil
|
|
768
|
+
uint32_t num_parameters() nogil
|
|
769
|
+
string to_str() nogil
|
|
770
|
+
pair[One_critical_filtration[int64_t], One_critical_filtration[int64_t]] get_bounding_box() except + nogil
|
|
771
|
+
vector[One_critical_filtration[int64_t]] get_filtration_values() nogil
|
|
772
|
+
vector[int] get_dimensions() nogil
|
|
773
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
774
|
+
void coarsen_on_grid_inplace(vector[vector[int64_t]], bool) nogil
|
|
775
|
+
vector[Multi_critical_filtration[int64_t]]& get_filtrations() nogil
|
|
776
|
+
C_KSlicer_Matrix1_i32 coarsen_on_grid(vector[vector[int64_t]]) nogil
|
|
777
|
+
void add_generator(const One_critical_filtration[int64_t] &) nogil
|
|
778
|
+
|
|
779
|
+
|
|
780
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[vector[int64_t]]) nogil
|
|
781
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[pair[vector[int64_t],vector[int64_t]]]) nogil
|
|
782
|
+
|
|
783
|
+
#------------------------------------------------------------------------------
|
|
784
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
785
|
+
cdef cppclass C_KSlicer_Matrix0_f32 "TrucPythonInterface<BackendsEnum::Matrix,false,true,float,Available_columns::INTRUSIVE_SET>":
|
|
786
|
+
ctypedef float value_type
|
|
787
|
+
|
|
788
|
+
C_KSlicer_Matrix0_f32()
|
|
789
|
+
|
|
790
|
+
C_KSlicer_Matrix0_f32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[float]]&)
|
|
791
|
+
|
|
792
|
+
C_KSlicer_Matrix0_f32& operator=(const C_KSlicer_Matrix0_f32&)
|
|
793
|
+
vector[vector[pair[float, float]]] get_barcode() nogil
|
|
794
|
+
void push_to(const Line[float]&) nogil
|
|
795
|
+
void set_one_filtration(const vector[float]&) nogil
|
|
796
|
+
int prune_above_dimension(int) except + nogil
|
|
797
|
+
|
|
798
|
+
vector[float] get_one_filtration()
|
|
799
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
800
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
801
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
802
|
+
uint32_t num_generators() nogil
|
|
803
|
+
uint32_t num_parameters() nogil
|
|
804
|
+
string to_str() nogil
|
|
805
|
+
pair[One_critical_filtration[float], One_critical_filtration[float]] get_bounding_box() except + nogil
|
|
806
|
+
vector[One_critical_filtration[float]] get_filtration_values() nogil
|
|
807
|
+
vector[int] get_dimensions() nogil
|
|
808
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
809
|
+
void coarsen_on_grid_inplace(vector[vector[float]], bool) nogil
|
|
810
|
+
vector[Multi_critical_filtration[float]]& get_filtrations() nogil
|
|
811
|
+
C_KSlicer_Matrix0_i32 coarsen_on_grid(vector[vector[float]]) nogil
|
|
812
|
+
void add_generator(const One_critical_filtration[float] &) nogil
|
|
813
|
+
|
|
814
|
+
|
|
815
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[vector[float]]) nogil
|
|
816
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[pair[vector[float],vector[float]]]) nogil
|
|
817
|
+
|
|
818
|
+
#------------------------------------------------------------------------------
|
|
819
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
820
|
+
cdef cppclass C_KSlicer_Matrix1_f32 "TrucPythonInterface<BackendsEnum::Matrix,false,true,float,Available_columns::SMALL_VECTOR>":
|
|
821
|
+
ctypedef float value_type
|
|
822
|
+
|
|
823
|
+
C_KSlicer_Matrix1_f32()
|
|
824
|
+
|
|
825
|
+
C_KSlicer_Matrix1_f32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[float]]&)
|
|
826
|
+
|
|
827
|
+
C_KSlicer_Matrix1_f32& operator=(const C_KSlicer_Matrix1_f32&)
|
|
828
|
+
vector[vector[pair[float, float]]] get_barcode() nogil
|
|
829
|
+
void push_to(const Line[float]&) nogil
|
|
830
|
+
void set_one_filtration(const vector[float]&) nogil
|
|
831
|
+
int prune_above_dimension(int) except + nogil
|
|
832
|
+
|
|
833
|
+
vector[float] get_one_filtration()
|
|
834
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
835
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
836
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
837
|
+
uint32_t num_generators() nogil
|
|
838
|
+
uint32_t num_parameters() nogil
|
|
839
|
+
string to_str() nogil
|
|
840
|
+
pair[One_critical_filtration[float], One_critical_filtration[float]] get_bounding_box() except + nogil
|
|
841
|
+
vector[One_critical_filtration[float]] get_filtration_values() nogil
|
|
842
|
+
vector[int] get_dimensions() nogil
|
|
843
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
844
|
+
void coarsen_on_grid_inplace(vector[vector[float]], bool) nogil
|
|
845
|
+
vector[Multi_critical_filtration[float]]& get_filtrations() nogil
|
|
846
|
+
C_KSlicer_Matrix1_i32 coarsen_on_grid(vector[vector[float]]) nogil
|
|
847
|
+
void add_generator(const One_critical_filtration[float] &) nogil
|
|
848
|
+
|
|
849
|
+
|
|
850
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[vector[float]]) nogil
|
|
851
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[pair[vector[float],vector[float]]]) nogil
|
|
852
|
+
|
|
853
|
+
#------------------------------------------------------------------------------
|
|
854
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
855
|
+
cdef cppclass C_KSlicer_Matrix0_f64 "TrucPythonInterface<BackendsEnum::Matrix,false,true,double,Available_columns::INTRUSIVE_SET>":
|
|
856
|
+
ctypedef double value_type
|
|
857
|
+
|
|
858
|
+
C_KSlicer_Matrix0_f64()
|
|
859
|
+
|
|
860
|
+
C_KSlicer_Matrix0_f64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[double]]&)
|
|
861
|
+
|
|
862
|
+
C_KSlicer_Matrix0_f64& operator=(const C_KSlicer_Matrix0_f64&)
|
|
863
|
+
vector[vector[pair[double, double]]] get_barcode() nogil
|
|
864
|
+
void push_to(const Line[double]&) nogil
|
|
865
|
+
void set_one_filtration(const vector[double]&) nogil
|
|
866
|
+
int prune_above_dimension(int) except + nogil
|
|
867
|
+
|
|
868
|
+
vector[double] get_one_filtration()
|
|
869
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
870
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
871
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
872
|
+
uint32_t num_generators() nogil
|
|
873
|
+
uint32_t num_parameters() nogil
|
|
874
|
+
string to_str() nogil
|
|
875
|
+
pair[One_critical_filtration[double], One_critical_filtration[double]] get_bounding_box() except + nogil
|
|
876
|
+
vector[One_critical_filtration[double]] get_filtration_values() nogil
|
|
877
|
+
vector[int] get_dimensions() nogil
|
|
878
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
879
|
+
void coarsen_on_grid_inplace(vector[vector[double]], bool) nogil
|
|
880
|
+
vector[Multi_critical_filtration[double]]& get_filtrations() nogil
|
|
881
|
+
C_KSlicer_Matrix0_i32 coarsen_on_grid(vector[vector[double]]) nogil
|
|
882
|
+
void add_generator(const One_critical_filtration[double] &) nogil
|
|
883
|
+
|
|
884
|
+
|
|
885
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[vector[double]]) nogil
|
|
886
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[pair[vector[double],vector[double]]]) nogil
|
|
887
|
+
|
|
888
|
+
#------------------------------------------------------------------------------
|
|
889
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
890
|
+
cdef cppclass C_KSlicer_Matrix1_f64 "TrucPythonInterface<BackendsEnum::Matrix,false,true,double,Available_columns::SMALL_VECTOR>":
|
|
891
|
+
ctypedef double value_type
|
|
892
|
+
|
|
893
|
+
C_KSlicer_Matrix1_f64()
|
|
894
|
+
|
|
895
|
+
C_KSlicer_Matrix1_f64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[double]]&)
|
|
896
|
+
|
|
897
|
+
C_KSlicer_Matrix1_f64& operator=(const C_KSlicer_Matrix1_f64&)
|
|
898
|
+
vector[vector[pair[double, double]]] get_barcode() nogil
|
|
899
|
+
void push_to(const Line[double]&) nogil
|
|
900
|
+
void set_one_filtration(const vector[double]&) nogil
|
|
901
|
+
int prune_above_dimension(int) except + nogil
|
|
902
|
+
|
|
903
|
+
vector[double] get_one_filtration()
|
|
904
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
905
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
906
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
907
|
+
uint32_t num_generators() nogil
|
|
908
|
+
uint32_t num_parameters() nogil
|
|
909
|
+
string to_str() nogil
|
|
910
|
+
pair[One_critical_filtration[double], One_critical_filtration[double]] get_bounding_box() except + nogil
|
|
911
|
+
vector[One_critical_filtration[double]] get_filtration_values() nogil
|
|
912
|
+
vector[int] get_dimensions() nogil
|
|
913
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
914
|
+
void coarsen_on_grid_inplace(vector[vector[double]], bool) nogil
|
|
915
|
+
vector[Multi_critical_filtration[double]]& get_filtrations() nogil
|
|
916
|
+
C_KSlicer_Matrix1_i32 coarsen_on_grid(vector[vector[double]]) nogil
|
|
917
|
+
void add_generator(const One_critical_filtration[double] &) nogil
|
|
918
|
+
|
|
919
|
+
|
|
920
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[vector[double]]) nogil
|
|
921
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[pair[vector[double],vector[double]]]) nogil
|
|
922
|
+
|
|
923
|
+
#------------------------------------------------------------------------------
|
|
924
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
925
|
+
cdef cppclass C_Slicer_Matrix0_i32 "TrucPythonInterface<BackendsEnum::Matrix,false,false,int32_t,Available_columns::INTRUSIVE_SET>":
|
|
926
|
+
ctypedef int32_t value_type
|
|
927
|
+
|
|
928
|
+
C_Slicer_Matrix0_i32()
|
|
929
|
+
|
|
930
|
+
C_Slicer_Matrix0_i32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[int32_t]]&)
|
|
931
|
+
|
|
932
|
+
C_Slicer_Matrix0_i32& operator=(const C_Slicer_Matrix0_i32&)
|
|
933
|
+
vector[vector[pair[int32_t, int32_t]]] get_barcode() nogil
|
|
934
|
+
void push_to(const Line[int32_t]&) nogil
|
|
935
|
+
void set_one_filtration(const vector[int32_t]&) nogil
|
|
936
|
+
int prune_above_dimension(int) except + nogil
|
|
937
|
+
|
|
938
|
+
vector[int32_t] get_one_filtration()
|
|
939
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
940
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
941
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
942
|
+
uint32_t num_generators() nogil
|
|
943
|
+
uint32_t num_parameters() nogil
|
|
944
|
+
string to_str() nogil
|
|
945
|
+
pair[One_critical_filtration[int32_t], One_critical_filtration[int32_t]] get_bounding_box() except + nogil
|
|
946
|
+
vector[One_critical_filtration[int32_t]] get_filtration_values() nogil
|
|
947
|
+
vector[int] get_dimensions() nogil
|
|
948
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
949
|
+
void coarsen_on_grid_inplace(vector[vector[int32_t]], bool) nogil
|
|
950
|
+
vector[One_critical_filtration[int32_t]]& get_filtrations() nogil
|
|
951
|
+
C_Slicer_Matrix0_i32 coarsen_on_grid(vector[vector[int32_t]]) nogil
|
|
952
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
953
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
954
|
+
|
|
955
|
+
|
|
956
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[vector[int32_t]]) nogil
|
|
957
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[pair[vector[int32_t],vector[int32_t]]]) nogil
|
|
958
|
+
|
|
959
|
+
#------------------------------------------------------------------------------
|
|
960
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
961
|
+
cdef cppclass C_Slicer_Matrix1_i32 "TrucPythonInterface<BackendsEnum::Matrix,false,false,int32_t,Available_columns::SMALL_VECTOR>":
|
|
962
|
+
ctypedef int32_t value_type
|
|
963
|
+
|
|
964
|
+
C_Slicer_Matrix1_i32()
|
|
965
|
+
|
|
966
|
+
C_Slicer_Matrix1_i32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[int32_t]]&)
|
|
967
|
+
|
|
968
|
+
C_Slicer_Matrix1_i32& operator=(const C_Slicer_Matrix1_i32&)
|
|
969
|
+
vector[vector[pair[int32_t, int32_t]]] get_barcode() nogil
|
|
970
|
+
void push_to(const Line[int32_t]&) nogil
|
|
971
|
+
void set_one_filtration(const vector[int32_t]&) nogil
|
|
972
|
+
int prune_above_dimension(int) except + nogil
|
|
973
|
+
|
|
974
|
+
vector[int32_t] get_one_filtration()
|
|
975
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
976
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
977
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
978
|
+
uint32_t num_generators() nogil
|
|
979
|
+
uint32_t num_parameters() nogil
|
|
980
|
+
string to_str() nogil
|
|
981
|
+
pair[One_critical_filtration[int32_t], One_critical_filtration[int32_t]] get_bounding_box() except + nogil
|
|
982
|
+
vector[One_critical_filtration[int32_t]] get_filtration_values() nogil
|
|
983
|
+
vector[int] get_dimensions() nogil
|
|
984
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
985
|
+
void coarsen_on_grid_inplace(vector[vector[int32_t]], bool) nogil
|
|
986
|
+
vector[One_critical_filtration[int32_t]]& get_filtrations() nogil
|
|
987
|
+
C_Slicer_Matrix1_i32 coarsen_on_grid(vector[vector[int32_t]]) nogil
|
|
988
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
989
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
990
|
+
|
|
991
|
+
|
|
992
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[vector[int32_t]]) nogil
|
|
993
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[pair[vector[int32_t],vector[int32_t]]]) nogil
|
|
994
|
+
|
|
995
|
+
#------------------------------------------------------------------------------
|
|
996
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
997
|
+
cdef cppclass C_Slicer_Matrix0_i64 "TrucPythonInterface<BackendsEnum::Matrix,false,false,int64_t,Available_columns::INTRUSIVE_SET>":
|
|
998
|
+
ctypedef int64_t value_type
|
|
999
|
+
|
|
1000
|
+
C_Slicer_Matrix0_i64()
|
|
1001
|
+
|
|
1002
|
+
C_Slicer_Matrix0_i64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[int64_t]]&)
|
|
1003
|
+
|
|
1004
|
+
C_Slicer_Matrix0_i64& operator=(const C_Slicer_Matrix0_i64&)
|
|
1005
|
+
vector[vector[pair[int64_t, int64_t]]] get_barcode() nogil
|
|
1006
|
+
void push_to(const Line[int64_t]&) nogil
|
|
1007
|
+
void set_one_filtration(const vector[int64_t]&) nogil
|
|
1008
|
+
int prune_above_dimension(int) except + nogil
|
|
1009
|
+
|
|
1010
|
+
vector[int64_t] get_one_filtration()
|
|
1011
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1012
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1013
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1014
|
+
uint32_t num_generators() nogil
|
|
1015
|
+
uint32_t num_parameters() nogil
|
|
1016
|
+
string to_str() nogil
|
|
1017
|
+
pair[One_critical_filtration[int64_t], One_critical_filtration[int64_t]] get_bounding_box() except + nogil
|
|
1018
|
+
vector[One_critical_filtration[int64_t]] get_filtration_values() nogil
|
|
1019
|
+
vector[int] get_dimensions() nogil
|
|
1020
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1021
|
+
void coarsen_on_grid_inplace(vector[vector[int64_t]], bool) nogil
|
|
1022
|
+
vector[One_critical_filtration[int64_t]]& get_filtrations() nogil
|
|
1023
|
+
C_Slicer_Matrix0_i32 coarsen_on_grid(vector[vector[int64_t]]) nogil
|
|
1024
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
1025
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
1026
|
+
|
|
1027
|
+
|
|
1028
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[vector[int64_t]]) nogil
|
|
1029
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[pair[vector[int64_t],vector[int64_t]]]) nogil
|
|
1030
|
+
|
|
1031
|
+
#------------------------------------------------------------------------------
|
|
1032
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1033
|
+
cdef cppclass C_Slicer_Matrix1_i64 "TrucPythonInterface<BackendsEnum::Matrix,false,false,int64_t,Available_columns::SMALL_VECTOR>":
|
|
1034
|
+
ctypedef int64_t value_type
|
|
1035
|
+
|
|
1036
|
+
C_Slicer_Matrix1_i64()
|
|
1037
|
+
|
|
1038
|
+
C_Slicer_Matrix1_i64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[int64_t]]&)
|
|
1039
|
+
|
|
1040
|
+
C_Slicer_Matrix1_i64& operator=(const C_Slicer_Matrix1_i64&)
|
|
1041
|
+
vector[vector[pair[int64_t, int64_t]]] get_barcode() nogil
|
|
1042
|
+
void push_to(const Line[int64_t]&) nogil
|
|
1043
|
+
void set_one_filtration(const vector[int64_t]&) nogil
|
|
1044
|
+
int prune_above_dimension(int) except + nogil
|
|
1045
|
+
|
|
1046
|
+
vector[int64_t] get_one_filtration()
|
|
1047
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1048
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1049
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1050
|
+
uint32_t num_generators() nogil
|
|
1051
|
+
uint32_t num_parameters() nogil
|
|
1052
|
+
string to_str() nogil
|
|
1053
|
+
pair[One_critical_filtration[int64_t], One_critical_filtration[int64_t]] get_bounding_box() except + nogil
|
|
1054
|
+
vector[One_critical_filtration[int64_t]] get_filtration_values() nogil
|
|
1055
|
+
vector[int] get_dimensions() nogil
|
|
1056
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1057
|
+
void coarsen_on_grid_inplace(vector[vector[int64_t]], bool) nogil
|
|
1058
|
+
vector[One_critical_filtration[int64_t]]& get_filtrations() nogil
|
|
1059
|
+
C_Slicer_Matrix1_i32 coarsen_on_grid(vector[vector[int64_t]]) nogil
|
|
1060
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
1061
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
1062
|
+
|
|
1063
|
+
|
|
1064
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[vector[int64_t]]) nogil
|
|
1065
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[pair[vector[int64_t],vector[int64_t]]]) nogil
|
|
1066
|
+
|
|
1067
|
+
#------------------------------------------------------------------------------
|
|
1068
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1069
|
+
cdef cppclass C_Slicer_Matrix0_f32 "TrucPythonInterface<BackendsEnum::Matrix,false,false,float,Available_columns::INTRUSIVE_SET>":
|
|
1070
|
+
ctypedef float value_type
|
|
1071
|
+
|
|
1072
|
+
C_Slicer_Matrix0_f32()
|
|
1073
|
+
|
|
1074
|
+
C_Slicer_Matrix0_f32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[float]]&)
|
|
1075
|
+
|
|
1076
|
+
C_Slicer_Matrix0_f32& operator=(const C_Slicer_Matrix0_f32&)
|
|
1077
|
+
vector[vector[pair[float, float]]] get_barcode() nogil
|
|
1078
|
+
void push_to(const Line[float]&) nogil
|
|
1079
|
+
void set_one_filtration(const vector[float]&) nogil
|
|
1080
|
+
int prune_above_dimension(int) except + nogil
|
|
1081
|
+
|
|
1082
|
+
vector[float] get_one_filtration()
|
|
1083
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1084
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1085
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1086
|
+
uint32_t num_generators() nogil
|
|
1087
|
+
uint32_t num_parameters() nogil
|
|
1088
|
+
string to_str() nogil
|
|
1089
|
+
pair[One_critical_filtration[float], One_critical_filtration[float]] get_bounding_box() except + nogil
|
|
1090
|
+
vector[One_critical_filtration[float]] get_filtration_values() nogil
|
|
1091
|
+
vector[int] get_dimensions() nogil
|
|
1092
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1093
|
+
void coarsen_on_grid_inplace(vector[vector[float]], bool) nogil
|
|
1094
|
+
vector[One_critical_filtration[float]]& get_filtrations() nogil
|
|
1095
|
+
C_Slicer_Matrix0_i32 coarsen_on_grid(vector[vector[float]]) nogil
|
|
1096
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
1097
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
1098
|
+
|
|
1099
|
+
|
|
1100
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[vector[float]]) nogil
|
|
1101
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[pair[vector[float],vector[float]]]) nogil
|
|
1102
|
+
|
|
1103
|
+
#------------------------------------------------------------------------------
|
|
1104
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1105
|
+
cdef cppclass C_Slicer_Matrix1_f32 "TrucPythonInterface<BackendsEnum::Matrix,false,false,float,Available_columns::SMALL_VECTOR>":
|
|
1106
|
+
ctypedef float value_type
|
|
1107
|
+
|
|
1108
|
+
C_Slicer_Matrix1_f32()
|
|
1109
|
+
|
|
1110
|
+
C_Slicer_Matrix1_f32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[float]]&)
|
|
1111
|
+
|
|
1112
|
+
C_Slicer_Matrix1_f32& operator=(const C_Slicer_Matrix1_f32&)
|
|
1113
|
+
vector[vector[pair[float, float]]] get_barcode() nogil
|
|
1114
|
+
void push_to(const Line[float]&) nogil
|
|
1115
|
+
void set_one_filtration(const vector[float]&) nogil
|
|
1116
|
+
int prune_above_dimension(int) except + nogil
|
|
1117
|
+
|
|
1118
|
+
vector[float] get_one_filtration()
|
|
1119
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1120
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1121
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1122
|
+
uint32_t num_generators() nogil
|
|
1123
|
+
uint32_t num_parameters() nogil
|
|
1124
|
+
string to_str() nogil
|
|
1125
|
+
pair[One_critical_filtration[float], One_critical_filtration[float]] get_bounding_box() except + nogil
|
|
1126
|
+
vector[One_critical_filtration[float]] get_filtration_values() nogil
|
|
1127
|
+
vector[int] get_dimensions() nogil
|
|
1128
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1129
|
+
void coarsen_on_grid_inplace(vector[vector[float]], bool) nogil
|
|
1130
|
+
vector[One_critical_filtration[float]]& get_filtrations() nogil
|
|
1131
|
+
C_Slicer_Matrix1_i32 coarsen_on_grid(vector[vector[float]]) nogil
|
|
1132
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
1133
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
1134
|
+
|
|
1135
|
+
|
|
1136
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[vector[float]]) nogil
|
|
1137
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[pair[vector[float],vector[float]]]) nogil
|
|
1138
|
+
|
|
1139
|
+
#------------------------------------------------------------------------------
|
|
1140
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1141
|
+
cdef cppclass C_Slicer_Matrix0_f64 "TrucPythonInterface<BackendsEnum::Matrix,false,false,double,Available_columns::INTRUSIVE_SET>":
|
|
1142
|
+
ctypedef double value_type
|
|
1143
|
+
|
|
1144
|
+
C_Slicer_Matrix0_f64()
|
|
1145
|
+
|
|
1146
|
+
C_Slicer_Matrix0_f64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[double]]&)
|
|
1147
|
+
|
|
1148
|
+
C_Slicer_Matrix0_f64& operator=(const C_Slicer_Matrix0_f64&)
|
|
1149
|
+
vector[vector[pair[double, double]]] get_barcode() nogil
|
|
1150
|
+
void push_to(const Line[double]&) nogil
|
|
1151
|
+
void set_one_filtration(const vector[double]&) nogil
|
|
1152
|
+
int prune_above_dimension(int) except + nogil
|
|
1153
|
+
|
|
1154
|
+
vector[double] get_one_filtration()
|
|
1155
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1156
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1157
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1158
|
+
uint32_t num_generators() nogil
|
|
1159
|
+
uint32_t num_parameters() nogil
|
|
1160
|
+
string to_str() nogil
|
|
1161
|
+
pair[One_critical_filtration[double], One_critical_filtration[double]] get_bounding_box() except + nogil
|
|
1162
|
+
vector[One_critical_filtration[double]] get_filtration_values() nogil
|
|
1163
|
+
vector[int] get_dimensions() nogil
|
|
1164
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1165
|
+
void coarsen_on_grid_inplace(vector[vector[double]], bool) nogil
|
|
1166
|
+
vector[One_critical_filtration[double]]& get_filtrations() nogil
|
|
1167
|
+
C_Slicer_Matrix0_i32 coarsen_on_grid(vector[vector[double]]) nogil
|
|
1168
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
1169
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
1170
|
+
|
|
1171
|
+
|
|
1172
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[vector[double]]) nogil
|
|
1173
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[pair[vector[double],vector[double]]]) nogil
|
|
1174
|
+
|
|
1175
|
+
#------------------------------------------------------------------------------
|
|
1176
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1177
|
+
cdef cppclass C_Slicer_Matrix1_f64 "TrucPythonInterface<BackendsEnum::Matrix,false,false,double,Available_columns::SMALL_VECTOR>":
|
|
1178
|
+
ctypedef double value_type
|
|
1179
|
+
|
|
1180
|
+
C_Slicer_Matrix1_f64()
|
|
1181
|
+
|
|
1182
|
+
C_Slicer_Matrix1_f64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[double]]&)
|
|
1183
|
+
|
|
1184
|
+
C_Slicer_Matrix1_f64& operator=(const C_Slicer_Matrix1_f64&)
|
|
1185
|
+
vector[vector[pair[double, double]]] get_barcode() nogil
|
|
1186
|
+
void push_to(const Line[double]&) nogil
|
|
1187
|
+
void set_one_filtration(const vector[double]&) nogil
|
|
1188
|
+
int prune_above_dimension(int) except + nogil
|
|
1189
|
+
|
|
1190
|
+
vector[double] get_one_filtration()
|
|
1191
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1192
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1193
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1194
|
+
uint32_t num_generators() nogil
|
|
1195
|
+
uint32_t num_parameters() nogil
|
|
1196
|
+
string to_str() nogil
|
|
1197
|
+
pair[One_critical_filtration[double], One_critical_filtration[double]] get_bounding_box() except + nogil
|
|
1198
|
+
vector[One_critical_filtration[double]] get_filtration_values() nogil
|
|
1199
|
+
vector[int] get_dimensions() nogil
|
|
1200
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1201
|
+
void coarsen_on_grid_inplace(vector[vector[double]], bool) nogil
|
|
1202
|
+
vector[One_critical_filtration[double]]& get_filtrations() nogil
|
|
1203
|
+
C_Slicer_Matrix1_i32 coarsen_on_grid(vector[vector[double]]) nogil
|
|
1204
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
1205
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
1206
|
+
|
|
1207
|
+
|
|
1208
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[vector[double]]) nogil
|
|
1209
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[pair[vector[double],vector[double]]]) nogil
|
|
1210
|
+
|
|
1211
|
+
#------------------------------------------------------------------------------
|
|
1212
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1213
|
+
cdef cppclass C_KSlicer_GudhiCohomology0_i32 "TrucPythonInterface<BackendsEnum::GudhiCohomology,false,true,int32_t,Available_columns::INTRUSIVE_SET>":
|
|
1214
|
+
ctypedef int32_t value_type
|
|
1215
|
+
|
|
1216
|
+
C_KSlicer_GudhiCohomology0_i32()
|
|
1217
|
+
|
|
1218
|
+
C_KSlicer_GudhiCohomology0_i32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[int32_t]]&)
|
|
1219
|
+
|
|
1220
|
+
C_KSlicer_GudhiCohomology0_i32& operator=(const C_KSlicer_GudhiCohomology0_i32&)
|
|
1221
|
+
vector[vector[pair[int32_t, int32_t]]] get_barcode() nogil
|
|
1222
|
+
void push_to(const Line[int32_t]&) nogil
|
|
1223
|
+
void set_one_filtration(const vector[int32_t]&) nogil
|
|
1224
|
+
int prune_above_dimension(int) except + nogil
|
|
1225
|
+
|
|
1226
|
+
vector[int32_t] get_one_filtration()
|
|
1227
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1228
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1229
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1230
|
+
uint32_t num_generators() nogil
|
|
1231
|
+
uint32_t num_parameters() nogil
|
|
1232
|
+
string to_str() nogil
|
|
1233
|
+
pair[One_critical_filtration[int32_t], One_critical_filtration[int32_t]] get_bounding_box() except + nogil
|
|
1234
|
+
vector[One_critical_filtration[int32_t]] get_filtration_values() nogil
|
|
1235
|
+
vector[int] get_dimensions() nogil
|
|
1236
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1237
|
+
void coarsen_on_grid_inplace(vector[vector[int32_t]], bool) nogil
|
|
1238
|
+
vector[Multi_critical_filtration[int32_t]]& get_filtrations() nogil
|
|
1239
|
+
C_KSlicer_GudhiCohomology0_i32 coarsen_on_grid(vector[vector[int32_t]]) nogil
|
|
1240
|
+
void add_generator(const One_critical_filtration[int32_t] &) nogil
|
|
1241
|
+
|
|
1242
|
+
|
|
1243
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[vector[int32_t]]) nogil
|
|
1244
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[pair[vector[int32_t],vector[int32_t]]]) nogil
|
|
1245
|
+
|
|
1246
|
+
#------------------------------------------------------------------------------
|
|
1247
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1248
|
+
cdef cppclass C_KSlicer_GudhiCohomology0_i64 "TrucPythonInterface<BackendsEnum::GudhiCohomology,false,true,int64_t,Available_columns::INTRUSIVE_SET>":
|
|
1249
|
+
ctypedef int64_t value_type
|
|
1250
|
+
|
|
1251
|
+
C_KSlicer_GudhiCohomology0_i64()
|
|
1252
|
+
|
|
1253
|
+
C_KSlicer_GudhiCohomology0_i64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[int64_t]]&)
|
|
1254
|
+
|
|
1255
|
+
C_KSlicer_GudhiCohomology0_i64& operator=(const C_KSlicer_GudhiCohomology0_i64&)
|
|
1256
|
+
vector[vector[pair[int64_t, int64_t]]] get_barcode() nogil
|
|
1257
|
+
void push_to(const Line[int64_t]&) nogil
|
|
1258
|
+
void set_one_filtration(const vector[int64_t]&) nogil
|
|
1259
|
+
int prune_above_dimension(int) except + nogil
|
|
1260
|
+
|
|
1261
|
+
vector[int64_t] get_one_filtration()
|
|
1262
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1263
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1264
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1265
|
+
uint32_t num_generators() nogil
|
|
1266
|
+
uint32_t num_parameters() nogil
|
|
1267
|
+
string to_str() nogil
|
|
1268
|
+
pair[One_critical_filtration[int64_t], One_critical_filtration[int64_t]] get_bounding_box() except + nogil
|
|
1269
|
+
vector[One_critical_filtration[int64_t]] get_filtration_values() nogil
|
|
1270
|
+
vector[int] get_dimensions() nogil
|
|
1271
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1272
|
+
void coarsen_on_grid_inplace(vector[vector[int64_t]], bool) nogil
|
|
1273
|
+
vector[Multi_critical_filtration[int64_t]]& get_filtrations() nogil
|
|
1274
|
+
C_KSlicer_GudhiCohomology0_i32 coarsen_on_grid(vector[vector[int64_t]]) nogil
|
|
1275
|
+
void add_generator(const One_critical_filtration[int64_t] &) nogil
|
|
1276
|
+
|
|
1277
|
+
|
|
1278
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[vector[int64_t]]) nogil
|
|
1279
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[pair[vector[int64_t],vector[int64_t]]]) nogil
|
|
1280
|
+
|
|
1281
|
+
#------------------------------------------------------------------------------
|
|
1282
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1283
|
+
cdef cppclass C_KSlicer_GudhiCohomology0_f32 "TrucPythonInterface<BackendsEnum::GudhiCohomology,false,true,float,Available_columns::INTRUSIVE_SET>":
|
|
1284
|
+
ctypedef float value_type
|
|
1285
|
+
|
|
1286
|
+
C_KSlicer_GudhiCohomology0_f32()
|
|
1287
|
+
|
|
1288
|
+
C_KSlicer_GudhiCohomology0_f32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[float]]&)
|
|
1289
|
+
|
|
1290
|
+
C_KSlicer_GudhiCohomology0_f32& operator=(const C_KSlicer_GudhiCohomology0_f32&)
|
|
1291
|
+
vector[vector[pair[float, float]]] get_barcode() nogil
|
|
1292
|
+
void push_to(const Line[float]&) nogil
|
|
1293
|
+
void set_one_filtration(const vector[float]&) nogil
|
|
1294
|
+
int prune_above_dimension(int) except + nogil
|
|
1295
|
+
|
|
1296
|
+
vector[float] get_one_filtration()
|
|
1297
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1298
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1299
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1300
|
+
uint32_t num_generators() nogil
|
|
1301
|
+
uint32_t num_parameters() nogil
|
|
1302
|
+
string to_str() nogil
|
|
1303
|
+
pair[One_critical_filtration[float], One_critical_filtration[float]] get_bounding_box() except + nogil
|
|
1304
|
+
vector[One_critical_filtration[float]] get_filtration_values() nogil
|
|
1305
|
+
vector[int] get_dimensions() nogil
|
|
1306
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1307
|
+
void coarsen_on_grid_inplace(vector[vector[float]], bool) nogil
|
|
1308
|
+
vector[Multi_critical_filtration[float]]& get_filtrations() nogil
|
|
1309
|
+
C_KSlicer_GudhiCohomology0_i32 coarsen_on_grid(vector[vector[float]]) nogil
|
|
1310
|
+
void add_generator(const One_critical_filtration[float] &) nogil
|
|
1311
|
+
|
|
1312
|
+
|
|
1313
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[vector[float]]) nogil
|
|
1314
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[pair[vector[float],vector[float]]]) nogil
|
|
1315
|
+
|
|
1316
|
+
#------------------------------------------------------------------------------
|
|
1317
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1318
|
+
cdef cppclass C_KSlicer_GudhiCohomology0_f64 "TrucPythonInterface<BackendsEnum::GudhiCohomology,false,true,double,Available_columns::INTRUSIVE_SET>":
|
|
1319
|
+
ctypedef double value_type
|
|
1320
|
+
|
|
1321
|
+
C_KSlicer_GudhiCohomology0_f64()
|
|
1322
|
+
|
|
1323
|
+
C_KSlicer_GudhiCohomology0_f64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[Multi_critical_filtration[double]]&)
|
|
1324
|
+
|
|
1325
|
+
C_KSlicer_GudhiCohomology0_f64& operator=(const C_KSlicer_GudhiCohomology0_f64&)
|
|
1326
|
+
vector[vector[pair[double, double]]] get_barcode() nogil
|
|
1327
|
+
void push_to(const Line[double]&) nogil
|
|
1328
|
+
void set_one_filtration(const vector[double]&) nogil
|
|
1329
|
+
int prune_above_dimension(int) except + nogil
|
|
1330
|
+
|
|
1331
|
+
vector[double] get_one_filtration()
|
|
1332
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1333
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1334
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1335
|
+
uint32_t num_generators() nogil
|
|
1336
|
+
uint32_t num_parameters() nogil
|
|
1337
|
+
string to_str() nogil
|
|
1338
|
+
pair[One_critical_filtration[double], One_critical_filtration[double]] get_bounding_box() except + nogil
|
|
1339
|
+
vector[One_critical_filtration[double]] get_filtration_values() nogil
|
|
1340
|
+
vector[int] get_dimensions() nogil
|
|
1341
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1342
|
+
void coarsen_on_grid_inplace(vector[vector[double]], bool) nogil
|
|
1343
|
+
vector[Multi_critical_filtration[double]]& get_filtrations() nogil
|
|
1344
|
+
C_KSlicer_GudhiCohomology0_i32 coarsen_on_grid(vector[vector[double]]) nogil
|
|
1345
|
+
void add_generator(const One_critical_filtration[double] &) nogil
|
|
1346
|
+
|
|
1347
|
+
|
|
1348
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[vector[double]]) nogil
|
|
1349
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[pair[vector[double],vector[double]]]) nogil
|
|
1350
|
+
|
|
1351
|
+
#------------------------------------------------------------------------------
|
|
1352
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1353
|
+
cdef cppclass C_Slicer_GudhiCohomology0_i32 "TrucPythonInterface<BackendsEnum::GudhiCohomology,false,false,int32_t,Available_columns::INTRUSIVE_SET>":
|
|
1354
|
+
ctypedef int32_t value_type
|
|
1355
|
+
|
|
1356
|
+
C_Slicer_GudhiCohomology0_i32()
|
|
1357
|
+
|
|
1358
|
+
C_Slicer_GudhiCohomology0_i32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[int32_t]]&)
|
|
1359
|
+
|
|
1360
|
+
C_Slicer_GudhiCohomology0_i32& operator=(const C_Slicer_GudhiCohomology0_i32&)
|
|
1361
|
+
vector[vector[pair[int32_t, int32_t]]] get_barcode() nogil
|
|
1362
|
+
void push_to(const Line[int32_t]&) nogil
|
|
1363
|
+
void set_one_filtration(const vector[int32_t]&) nogil
|
|
1364
|
+
int prune_above_dimension(int) except + nogil
|
|
1365
|
+
|
|
1366
|
+
vector[int32_t] get_one_filtration()
|
|
1367
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1368
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1369
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1370
|
+
uint32_t num_generators() nogil
|
|
1371
|
+
uint32_t num_parameters() nogil
|
|
1372
|
+
string to_str() nogil
|
|
1373
|
+
pair[One_critical_filtration[int32_t], One_critical_filtration[int32_t]] get_bounding_box() except + nogil
|
|
1374
|
+
vector[One_critical_filtration[int32_t]] get_filtration_values() nogil
|
|
1375
|
+
vector[int] get_dimensions() nogil
|
|
1376
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1377
|
+
void coarsen_on_grid_inplace(vector[vector[int32_t]], bool) nogil
|
|
1378
|
+
vector[One_critical_filtration[int32_t]]& get_filtrations() nogil
|
|
1379
|
+
C_Slicer_GudhiCohomology0_i32 coarsen_on_grid(vector[vector[int32_t]]) nogil
|
|
1380
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
1381
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
1382
|
+
|
|
1383
|
+
|
|
1384
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[vector[int32_t]]) nogil
|
|
1385
|
+
vector[vector[vector[pair[int32_t, int32_t]]]] persistence_on_lines(vector[pair[vector[int32_t],vector[int32_t]]]) nogil
|
|
1386
|
+
|
|
1387
|
+
#------------------------------------------------------------------------------
|
|
1388
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1389
|
+
cdef cppclass C_Slicer_GudhiCohomology0_i64 "TrucPythonInterface<BackendsEnum::GudhiCohomology,false,false,int64_t,Available_columns::INTRUSIVE_SET>":
|
|
1390
|
+
ctypedef int64_t value_type
|
|
1391
|
+
|
|
1392
|
+
C_Slicer_GudhiCohomology0_i64()
|
|
1393
|
+
|
|
1394
|
+
C_Slicer_GudhiCohomology0_i64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[int64_t]]&)
|
|
1395
|
+
|
|
1396
|
+
C_Slicer_GudhiCohomology0_i64& operator=(const C_Slicer_GudhiCohomology0_i64&)
|
|
1397
|
+
vector[vector[pair[int64_t, int64_t]]] get_barcode() nogil
|
|
1398
|
+
void push_to(const Line[int64_t]&) nogil
|
|
1399
|
+
void set_one_filtration(const vector[int64_t]&) nogil
|
|
1400
|
+
int prune_above_dimension(int) except + nogil
|
|
1401
|
+
|
|
1402
|
+
vector[int64_t] get_one_filtration()
|
|
1403
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1404
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1405
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1406
|
+
uint32_t num_generators() nogil
|
|
1407
|
+
uint32_t num_parameters() nogil
|
|
1408
|
+
string to_str() nogil
|
|
1409
|
+
pair[One_critical_filtration[int64_t], One_critical_filtration[int64_t]] get_bounding_box() except + nogil
|
|
1410
|
+
vector[One_critical_filtration[int64_t]] get_filtration_values() nogil
|
|
1411
|
+
vector[int] get_dimensions() nogil
|
|
1412
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1413
|
+
void coarsen_on_grid_inplace(vector[vector[int64_t]], bool) nogil
|
|
1414
|
+
vector[One_critical_filtration[int64_t]]& get_filtrations() nogil
|
|
1415
|
+
C_Slicer_GudhiCohomology0_i32 coarsen_on_grid(vector[vector[int64_t]]) nogil
|
|
1416
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
1417
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
1418
|
+
|
|
1419
|
+
|
|
1420
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[vector[int64_t]]) nogil
|
|
1421
|
+
vector[vector[vector[pair[int64_t, int64_t]]]] persistence_on_lines(vector[pair[vector[int64_t],vector[int64_t]]]) nogil
|
|
1422
|
+
|
|
1423
|
+
#------------------------------------------------------------------------------
|
|
1424
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1425
|
+
cdef cppclass C_Slicer_GudhiCohomology0_f32 "TrucPythonInterface<BackendsEnum::GudhiCohomology,false,false,float,Available_columns::INTRUSIVE_SET>":
|
|
1426
|
+
ctypedef float value_type
|
|
1427
|
+
|
|
1428
|
+
C_Slicer_GudhiCohomology0_f32()
|
|
1429
|
+
|
|
1430
|
+
C_Slicer_GudhiCohomology0_f32(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[float]]&)
|
|
1431
|
+
|
|
1432
|
+
C_Slicer_GudhiCohomology0_f32& operator=(const C_Slicer_GudhiCohomology0_f32&)
|
|
1433
|
+
vector[vector[pair[float, float]]] get_barcode() nogil
|
|
1434
|
+
void push_to(const Line[float]&) nogil
|
|
1435
|
+
void set_one_filtration(const vector[float]&) nogil
|
|
1436
|
+
int prune_above_dimension(int) except + nogil
|
|
1437
|
+
|
|
1438
|
+
vector[float] get_one_filtration()
|
|
1439
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1440
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1441
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1442
|
+
uint32_t num_generators() nogil
|
|
1443
|
+
uint32_t num_parameters() nogil
|
|
1444
|
+
string to_str() nogil
|
|
1445
|
+
pair[One_critical_filtration[float], One_critical_filtration[float]] get_bounding_box() except + nogil
|
|
1446
|
+
vector[One_critical_filtration[float]] get_filtration_values() nogil
|
|
1447
|
+
vector[int] get_dimensions() nogil
|
|
1448
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1449
|
+
void coarsen_on_grid_inplace(vector[vector[float]], bool) nogil
|
|
1450
|
+
vector[One_critical_filtration[float]]& get_filtrations() nogil
|
|
1451
|
+
C_Slicer_GudhiCohomology0_i32 coarsen_on_grid(vector[vector[float]]) nogil
|
|
1452
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
1453
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
1454
|
+
|
|
1455
|
+
|
|
1456
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[vector[float]]) nogil
|
|
1457
|
+
vector[vector[vector[pair[float, float]]]] persistence_on_lines(vector[pair[vector[float],vector[float]]]) nogil
|
|
1458
|
+
|
|
1459
|
+
#------------------------------------------------------------------------------
|
|
1460
|
+
cdef extern from "Persistence_slices_interface.h":
|
|
1461
|
+
cdef cppclass C_Slicer_GudhiCohomology0_f64 "TrucPythonInterface<BackendsEnum::GudhiCohomology,false,false,double,Available_columns::INTRUSIVE_SET>":
|
|
1462
|
+
ctypedef double value_type
|
|
1463
|
+
|
|
1464
|
+
C_Slicer_GudhiCohomology0_f64()
|
|
1465
|
+
|
|
1466
|
+
C_Slicer_GudhiCohomology0_f64(const vector[vector[unsigned int]]&, const vector[int]&, const vector[One_critical_filtration[double]]&)
|
|
1467
|
+
|
|
1468
|
+
C_Slicer_GudhiCohomology0_f64& operator=(const C_Slicer_GudhiCohomology0_f64&)
|
|
1469
|
+
vector[vector[pair[double, double]]] get_barcode() nogil
|
|
1470
|
+
void push_to(const Line[double]&) nogil
|
|
1471
|
+
void set_one_filtration(const vector[double]&) nogil
|
|
1472
|
+
int prune_above_dimension(int) except + nogil
|
|
1473
|
+
|
|
1474
|
+
vector[double] get_one_filtration()
|
|
1475
|
+
# void compute_persistence(vector[bool]) except+ nogil
|
|
1476
|
+
void compute_persistence(bool) except+ nogil # ignore_inf
|
|
1477
|
+
void compute_persistence() except+ nogil # ignore_inf
|
|
1478
|
+
uint32_t num_generators() nogil
|
|
1479
|
+
uint32_t num_parameters() nogil
|
|
1480
|
+
string to_str() nogil
|
|
1481
|
+
pair[One_critical_filtration[double], One_critical_filtration[double]] get_bounding_box() except + nogil
|
|
1482
|
+
vector[One_critical_filtration[double]] get_filtration_values() nogil
|
|
1483
|
+
vector[int] get_dimensions() nogil
|
|
1484
|
+
vector[vector[uint]] get_boundaries() nogil
|
|
1485
|
+
void coarsen_on_grid_inplace(vector[vector[double]], bool) nogil
|
|
1486
|
+
vector[One_critical_filtration[double]]& get_filtrations() nogil
|
|
1487
|
+
C_Slicer_GudhiCohomology0_i32 coarsen_on_grid(vector[vector[double]]) nogil
|
|
1488
|
+
void build_from_scc_file(const string&, bool, bool, int) except + nogil
|
|
1489
|
+
void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
|
|
1490
|
+
|
|
1491
|
+
|
|
1492
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[vector[double]]) nogil
|
|
1493
|
+
vector[vector[vector[pair[double, double]]]] persistence_on_lines(vector[pair[vector[double],vector[double]]]) nogil
|
|
1494
|
+
|
|
1495
|
+
|
|
1496
|
+
|
|
1497
|
+
#### MMA Stuff
|
|
1498
|
+
|
|
1499
|
+
from multipers.mma_structures cimport Module
|
|
1500
|
+
cdef extern from "multiparameter_module_approximation/approximation.h" namespace "Gudhi::multiparameter::mma":
|
|
1501
|
+
Module[float] multiparameter_module_approximation(C_KSlicer_Matrix0_vine_f32&, One_critical_filtration[float]&, float, Box[float]&, bool, bool, bool) except + nogil
|
|
1502
|
+
Module[float] multiparameter_module_approximation(C_KSlicer_Matrix1_vine_f32&, One_critical_filtration[float]&, float, Box[float]&, bool, bool, bool) except + nogil
|
|
1503
|
+
Module[double] multiparameter_module_approximation(C_KSlicer_Matrix0_vine_f64&, One_critical_filtration[double]&, double, Box[double]&, bool, bool, bool) except + nogil
|
|
1504
|
+
Module[double] multiparameter_module_approximation(C_KSlicer_Matrix1_vine_f64&, One_critical_filtration[double]&, double, Box[double]&, bool, bool, bool) except + nogil
|
|
1505
|
+
Module[float] multiparameter_module_approximation(C_Slicer_Matrix0_vine_f32&, One_critical_filtration[float]&, float, Box[float]&, bool, bool, bool) except + nogil
|
|
1506
|
+
Module[float] multiparameter_module_approximation(C_Slicer_Matrix1_vine_f32&, One_critical_filtration[float]&, float, Box[float]&, bool, bool, bool) except + nogil
|
|
1507
|
+
Module[double] multiparameter_module_approximation(C_Slicer_Matrix0_vine_f64&, One_critical_filtration[double]&, double, Box[double]&, bool, bool, bool) except + nogil
|
|
1508
|
+
Module[double] multiparameter_module_approximation(C_Slicer_Matrix1_vine_f64&, One_critical_filtration[double]&, double, Box[double]&, bool, bool, bool) except + nogil
|
|
1509
|
+
|
|
1510
|
+
|
|
1511
|
+
|
|
1512
|
+
|
|
1513
|
+
import multipers.slicer as mps
|
|
1514
|
+
from cython.operator cimport dereference
|
|
1515
|
+
cdef inline Module[float] _multiparameter_module_approximation_f32(object slicer, One_critical_filtration[float] direction, float max_error, Box[float] box, bool threshold, bool complete, bool verbose):
|
|
1516
|
+
import multipers.slicer as mps
|
|
1517
|
+
cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
|
|
1518
|
+
cdef Module[float] mod
|
|
1519
|
+
if False:
|
|
1520
|
+
pass
|
|
1521
|
+
elif isinstance(slicer, mps._KSlicer_Matrix0_vine_f32):
|
|
1522
|
+
with nogil:
|
|
1523
|
+
mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix0_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
|
|
1524
|
+
return mod
|
|
1525
|
+
elif isinstance(slicer, mps._KSlicer_Matrix1_vine_f32):
|
|
1526
|
+
with nogil:
|
|
1527
|
+
mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix1_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
|
|
1528
|
+
return mod
|
|
1529
|
+
elif isinstance(slicer, mps._Slicer_Matrix0_vine_f32):
|
|
1530
|
+
with nogil:
|
|
1531
|
+
mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix0_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
|
|
1532
|
+
return mod
|
|
1533
|
+
elif isinstance(slicer, mps._Slicer_Matrix1_vine_f32):
|
|
1534
|
+
with nogil:
|
|
1535
|
+
mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix1_vine_f32*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
|
|
1536
|
+
return mod
|
|
1537
|
+
else:
|
|
1538
|
+
raise ValueError(f"Unsupported slicer type {type(slicer)}")
|
|
1539
|
+
cdef inline Module[double] _multiparameter_module_approximation_f64(object slicer, One_critical_filtration[double] direction, double max_error, Box[double] box, bool threshold, bool complete, bool verbose):
|
|
1540
|
+
import multipers.slicer as mps
|
|
1541
|
+
cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
|
|
1542
|
+
cdef Module[double] mod
|
|
1543
|
+
if False:
|
|
1544
|
+
pass
|
|
1545
|
+
elif isinstance(slicer, mps._KSlicer_Matrix0_vine_f64):
|
|
1546
|
+
with nogil:
|
|
1547
|
+
mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix0_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
|
|
1548
|
+
return mod
|
|
1549
|
+
elif isinstance(slicer, mps._KSlicer_Matrix1_vine_f64):
|
|
1550
|
+
with nogil:
|
|
1551
|
+
mod = multiparameter_module_approximation(dereference(<C_KSlicer_Matrix1_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
|
|
1552
|
+
return mod
|
|
1553
|
+
elif isinstance(slicer, mps._Slicer_Matrix0_vine_f64):
|
|
1554
|
+
with nogil:
|
|
1555
|
+
mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix0_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
|
|
1556
|
+
return mod
|
|
1557
|
+
elif isinstance(slicer, mps._Slicer_Matrix1_vine_f64):
|
|
1558
|
+
with nogil:
|
|
1559
|
+
mod = multiparameter_module_approximation(dereference(<C_Slicer_Matrix1_vine_f64*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
|
|
1560
|
+
return mod
|
|
1561
|
+
else:
|
|
1562
|
+
raise ValueError(f"Unsupported slicer type {type(slicer)}")
|
|
1563
|
+
|
|
1564
|
+
###### RANK INVARIANT
|
|
1565
|
+
from libc.stdint cimport intptr_t, uint16_t, uint32_t, int32_t, int16_t, int8_t
|
|
1566
|
+
ctypedef int32_t tensor_dtype
|
|
1567
|
+
ctypedef int32_t indices_type
|
|
1568
|
+
python_indices_type=np.int32
|
|
1569
|
+
python_tensor_dtype = np.int32
|
|
1570
|
+
|
|
1571
|
+
|
|
1572
|
+
|
|
1573
|
+
ctypedef pair[vector[vector[indices_type]], vector[tensor_dtype]] signed_measure_type
|
|
1574
|
+
|
|
1575
|
+
|
|
1576
|
+
|
|
1577
|
+
cdef extern from "multi_parameter_rank_invariant/rank_invariant.h" namespace "Gudhi::multiparameter::rank_invariant":
|
|
1578
|
+
## from slicers
|
|
1579
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix0_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1580
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix0_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1581
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix1_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1582
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix1_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1583
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix0_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1584
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix0_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1585
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix1_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1586
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix1_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1587
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix0_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1588
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix0_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1589
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix1_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1590
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix1_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1591
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix0_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1592
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix0_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1593
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix1_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1594
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix1_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1595
|
+
void compute_rank_invariant_python(C_Slicer_Matrix0_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1596
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix0_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1597
|
+
void compute_rank_invariant_python(C_Slicer_Matrix1_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1598
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix1_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1599
|
+
void compute_rank_invariant_python(C_Slicer_Matrix0_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1600
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix0_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1601
|
+
void compute_rank_invariant_python(C_Slicer_Matrix1_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1602
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix1_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1603
|
+
void compute_rank_invariant_python(C_Slicer_Matrix0_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1604
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix0_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1605
|
+
void compute_rank_invariant_python(C_Slicer_Matrix1_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1606
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix1_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1607
|
+
void compute_rank_invariant_python(C_Slicer_Matrix0_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1608
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix0_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1609
|
+
void compute_rank_invariant_python(C_Slicer_Matrix1_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1610
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix1_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1611
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1612
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1613
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix1_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1614
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix1_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1615
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1616
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1617
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix1_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1618
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix1_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1619
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1620
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1621
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix1_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1622
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix1_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1623
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1624
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1625
|
+
void compute_rank_invariant_python(C_KSlicer_Matrix1_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1626
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_Matrix1_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1627
|
+
void compute_rank_invariant_python(C_Slicer_Matrix0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1628
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1629
|
+
void compute_rank_invariant_python(C_Slicer_Matrix1_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1630
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix1_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1631
|
+
void compute_rank_invariant_python(C_Slicer_Matrix0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1632
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1633
|
+
void compute_rank_invariant_python(C_Slicer_Matrix1_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1634
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix1_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1635
|
+
void compute_rank_invariant_python(C_Slicer_Matrix0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1636
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1637
|
+
void compute_rank_invariant_python(C_Slicer_Matrix1_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1638
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix1_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1639
|
+
void compute_rank_invariant_python(C_Slicer_Matrix0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1640
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1641
|
+
void compute_rank_invariant_python(C_Slicer_Matrix1_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1642
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_Matrix1_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1643
|
+
void compute_rank_invariant_python(C_KSlicer_GudhiCohomology0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1644
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_GudhiCohomology0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1645
|
+
void compute_rank_invariant_python(C_KSlicer_GudhiCohomology0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1646
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_GudhiCohomology0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1647
|
+
void compute_rank_invariant_python(C_KSlicer_GudhiCohomology0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1648
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_GudhiCohomology0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1649
|
+
void compute_rank_invariant_python(C_KSlicer_GudhiCohomology0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1650
|
+
signed_measure_type compute_rank_signed_measure(C_KSlicer_GudhiCohomology0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1651
|
+
void compute_rank_invariant_python(C_Slicer_GudhiCohomology0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1652
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_GudhiCohomology0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1653
|
+
void compute_rank_invariant_python(C_Slicer_GudhiCohomology0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1654
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_GudhiCohomology0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1655
|
+
void compute_rank_invariant_python(C_Slicer_GudhiCohomology0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1656
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_GudhiCohomology0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1657
|
+
void compute_rank_invariant_python(C_Slicer_GudhiCohomology0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
|
|
1658
|
+
signed_measure_type compute_rank_signed_measure(C_Slicer_GudhiCohomology0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
|
|
1659
|
+
|
|
1660
|
+
|
|
1661
|
+
|
|
1662
|
+
|
|
1663
|
+
|
|
1664
|
+
cdef inline void _compute_rank_invariant(object slicer, tensor_dtype* container_ptr, vector[indices_type] c_grid_shape, vector[indices_type] degrees, int n_jobs, bool ignore_inf):
|
|
1665
|
+
import multipers.slicer as mps
|
|
1666
|
+
cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
|
|
1667
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_i32):
|
|
1668
|
+
with nogil:
|
|
1669
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix0_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1670
|
+
return
|
|
1671
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_i32):
|
|
1672
|
+
with nogil:
|
|
1673
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix1_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1674
|
+
return
|
|
1675
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_i64):
|
|
1676
|
+
with nogil:
|
|
1677
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix0_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1678
|
+
return
|
|
1679
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_i64):
|
|
1680
|
+
with nogil:
|
|
1681
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix1_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1682
|
+
return
|
|
1683
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_f32):
|
|
1684
|
+
with nogil:
|
|
1685
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix0_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1686
|
+
return
|
|
1687
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_f32):
|
|
1688
|
+
with nogil:
|
|
1689
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix1_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1690
|
+
return
|
|
1691
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_f64):
|
|
1692
|
+
with nogil:
|
|
1693
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix0_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1694
|
+
return
|
|
1695
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_f64):
|
|
1696
|
+
with nogil:
|
|
1697
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix1_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1698
|
+
return
|
|
1699
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_i32):
|
|
1700
|
+
with nogil:
|
|
1701
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix0_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1702
|
+
return
|
|
1703
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_i32):
|
|
1704
|
+
with nogil:
|
|
1705
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix1_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1706
|
+
return
|
|
1707
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_i64):
|
|
1708
|
+
with nogil:
|
|
1709
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix0_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1710
|
+
return
|
|
1711
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_i64):
|
|
1712
|
+
with nogil:
|
|
1713
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix1_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1714
|
+
return
|
|
1715
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_f32):
|
|
1716
|
+
with nogil:
|
|
1717
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix0_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1718
|
+
return
|
|
1719
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_f32):
|
|
1720
|
+
with nogil:
|
|
1721
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix1_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1722
|
+
return
|
|
1723
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_f64):
|
|
1724
|
+
with nogil:
|
|
1725
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix0_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1726
|
+
return
|
|
1727
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_f64):
|
|
1728
|
+
with nogil:
|
|
1729
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix1_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1730
|
+
return
|
|
1731
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_i32):
|
|
1732
|
+
with nogil:
|
|
1733
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1734
|
+
return
|
|
1735
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_i32):
|
|
1736
|
+
with nogil:
|
|
1737
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix1_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1738
|
+
return
|
|
1739
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_i64):
|
|
1740
|
+
with nogil:
|
|
1741
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1742
|
+
return
|
|
1743
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_i64):
|
|
1744
|
+
with nogil:
|
|
1745
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix1_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1746
|
+
return
|
|
1747
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_f32):
|
|
1748
|
+
with nogil:
|
|
1749
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1750
|
+
return
|
|
1751
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_f32):
|
|
1752
|
+
with nogil:
|
|
1753
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix1_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1754
|
+
return
|
|
1755
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_f64):
|
|
1756
|
+
with nogil:
|
|
1757
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1758
|
+
return
|
|
1759
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_f64):
|
|
1760
|
+
with nogil:
|
|
1761
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_Matrix1_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1762
|
+
return
|
|
1763
|
+
if isinstance(slicer, mps._Slicer_Matrix0_i32):
|
|
1764
|
+
with nogil:
|
|
1765
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1766
|
+
return
|
|
1767
|
+
if isinstance(slicer, mps._Slicer_Matrix1_i32):
|
|
1768
|
+
with nogil:
|
|
1769
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix1_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1770
|
+
return
|
|
1771
|
+
if isinstance(slicer, mps._Slicer_Matrix0_i64):
|
|
1772
|
+
with nogil:
|
|
1773
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1774
|
+
return
|
|
1775
|
+
if isinstance(slicer, mps._Slicer_Matrix1_i64):
|
|
1776
|
+
with nogil:
|
|
1777
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix1_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1778
|
+
return
|
|
1779
|
+
if isinstance(slicer, mps._Slicer_Matrix0_f32):
|
|
1780
|
+
with nogil:
|
|
1781
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1782
|
+
return
|
|
1783
|
+
if isinstance(slicer, mps._Slicer_Matrix1_f32):
|
|
1784
|
+
with nogil:
|
|
1785
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix1_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1786
|
+
return
|
|
1787
|
+
if isinstance(slicer, mps._Slicer_Matrix0_f64):
|
|
1788
|
+
with nogil:
|
|
1789
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1790
|
+
return
|
|
1791
|
+
if isinstance(slicer, mps._Slicer_Matrix1_f64):
|
|
1792
|
+
with nogil:
|
|
1793
|
+
compute_rank_invariant_python(dereference(<C_Slicer_Matrix1_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1794
|
+
return
|
|
1795
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_i32):
|
|
1796
|
+
with nogil:
|
|
1797
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_GudhiCohomology0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1798
|
+
return
|
|
1799
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_i64):
|
|
1800
|
+
with nogil:
|
|
1801
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_GudhiCohomology0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1802
|
+
return
|
|
1803
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_f32):
|
|
1804
|
+
with nogil:
|
|
1805
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_GudhiCohomology0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1806
|
+
return
|
|
1807
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_f64):
|
|
1808
|
+
with nogil:
|
|
1809
|
+
compute_rank_invariant_python(dereference(<C_KSlicer_GudhiCohomology0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1810
|
+
return
|
|
1811
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_i32):
|
|
1812
|
+
with nogil:
|
|
1813
|
+
compute_rank_invariant_python(dereference(<C_Slicer_GudhiCohomology0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1814
|
+
return
|
|
1815
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_i64):
|
|
1816
|
+
with nogil:
|
|
1817
|
+
compute_rank_invariant_python(dereference(<C_Slicer_GudhiCohomology0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1818
|
+
return
|
|
1819
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_f32):
|
|
1820
|
+
with nogil:
|
|
1821
|
+
compute_rank_invariant_python(dereference(<C_Slicer_GudhiCohomology0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1822
|
+
return
|
|
1823
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_f64):
|
|
1824
|
+
with nogil:
|
|
1825
|
+
compute_rank_invariant_python(dereference(<C_Slicer_GudhiCohomology0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
|
|
1826
|
+
return
|
|
1827
|
+
raise ValueError(f"Unsupported slicer type {type(slicer)}")
|
|
1828
|
+
|
|
1829
|
+
|
|
1830
|
+
|
|
1831
|
+
cdef inline _compute_rank_sm(object slicer, tensor_dtype* container_ptr, vector[indices_type] c_grid_shape, vector[indices_type] degrees, int n_jobs, bool verbose, bool ignore_inf):
|
|
1832
|
+
import multipers.slicer as mps
|
|
1833
|
+
cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
|
|
1834
|
+
cdef signed_measure_type sm
|
|
1835
|
+
cdef cnp.ndarray[indices_type, ndim=2] pts
|
|
1836
|
+
cdef cnp.ndarray[tensor_dtype, ndim=1] weights
|
|
1837
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_i32):
|
|
1838
|
+
with nogil:
|
|
1839
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix0_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1840
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1841
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1842
|
+
return (pts,weights)
|
|
1843
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_i32):
|
|
1844
|
+
with nogil:
|
|
1845
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix1_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1846
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1847
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1848
|
+
return (pts,weights)
|
|
1849
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_i64):
|
|
1850
|
+
with nogil:
|
|
1851
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix0_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1852
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1853
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1854
|
+
return (pts,weights)
|
|
1855
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_i64):
|
|
1856
|
+
with nogil:
|
|
1857
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix1_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1858
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1859
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1860
|
+
return (pts,weights)
|
|
1861
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_f32):
|
|
1862
|
+
with nogil:
|
|
1863
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix0_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1864
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1865
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1866
|
+
return (pts,weights)
|
|
1867
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_f32):
|
|
1868
|
+
with nogil:
|
|
1869
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix1_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1870
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1871
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1872
|
+
return (pts,weights)
|
|
1873
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_f64):
|
|
1874
|
+
with nogil:
|
|
1875
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix0_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1876
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1877
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1878
|
+
return (pts,weights)
|
|
1879
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_f64):
|
|
1880
|
+
with nogil:
|
|
1881
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix1_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1882
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1883
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1884
|
+
return (pts,weights)
|
|
1885
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_i32):
|
|
1886
|
+
with nogil:
|
|
1887
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix0_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1888
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1889
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1890
|
+
return (pts,weights)
|
|
1891
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_i32):
|
|
1892
|
+
with nogil:
|
|
1893
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix1_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1894
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1895
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1896
|
+
return (pts,weights)
|
|
1897
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_i64):
|
|
1898
|
+
with nogil:
|
|
1899
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix0_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1900
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1901
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1902
|
+
return (pts,weights)
|
|
1903
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_i64):
|
|
1904
|
+
with nogil:
|
|
1905
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix1_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1906
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1907
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1908
|
+
return (pts,weights)
|
|
1909
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_f32):
|
|
1910
|
+
with nogil:
|
|
1911
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix0_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1912
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1913
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1914
|
+
return (pts,weights)
|
|
1915
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_f32):
|
|
1916
|
+
with nogil:
|
|
1917
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix1_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1918
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1919
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1920
|
+
return (pts,weights)
|
|
1921
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_f64):
|
|
1922
|
+
with nogil:
|
|
1923
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix0_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1924
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1925
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1926
|
+
return (pts,weights)
|
|
1927
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_f64):
|
|
1928
|
+
with nogil:
|
|
1929
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix1_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1930
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1931
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1932
|
+
return (pts,weights)
|
|
1933
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_i32):
|
|
1934
|
+
with nogil:
|
|
1935
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1936
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1937
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1938
|
+
return (pts,weights)
|
|
1939
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_i32):
|
|
1940
|
+
with nogil:
|
|
1941
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix1_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1942
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1943
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1944
|
+
return (pts,weights)
|
|
1945
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_i64):
|
|
1946
|
+
with nogil:
|
|
1947
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1948
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1949
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1950
|
+
return (pts,weights)
|
|
1951
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_i64):
|
|
1952
|
+
with nogil:
|
|
1953
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix1_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1954
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1955
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1956
|
+
return (pts,weights)
|
|
1957
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_f32):
|
|
1958
|
+
with nogil:
|
|
1959
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1960
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1961
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1962
|
+
return (pts,weights)
|
|
1963
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_f32):
|
|
1964
|
+
with nogil:
|
|
1965
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix1_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1966
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1967
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1968
|
+
return (pts,weights)
|
|
1969
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_f64):
|
|
1970
|
+
with nogil:
|
|
1971
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1972
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1973
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1974
|
+
return (pts,weights)
|
|
1975
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_f64):
|
|
1976
|
+
with nogil:
|
|
1977
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_Matrix1_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1978
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1979
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1980
|
+
return (pts,weights)
|
|
1981
|
+
if isinstance(slicer, mps._Slicer_Matrix0_i32):
|
|
1982
|
+
with nogil:
|
|
1983
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1984
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1985
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1986
|
+
return (pts,weights)
|
|
1987
|
+
if isinstance(slicer, mps._Slicer_Matrix1_i32):
|
|
1988
|
+
with nogil:
|
|
1989
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix1_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1990
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1991
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1992
|
+
return (pts,weights)
|
|
1993
|
+
if isinstance(slicer, mps._Slicer_Matrix0_i64):
|
|
1994
|
+
with nogil:
|
|
1995
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
1996
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
1997
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
1998
|
+
return (pts,weights)
|
|
1999
|
+
if isinstance(slicer, mps._Slicer_Matrix1_i64):
|
|
2000
|
+
with nogil:
|
|
2001
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix1_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2002
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2003
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2004
|
+
return (pts,weights)
|
|
2005
|
+
if isinstance(slicer, mps._Slicer_Matrix0_f32):
|
|
2006
|
+
with nogil:
|
|
2007
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2008
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2009
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2010
|
+
return (pts,weights)
|
|
2011
|
+
if isinstance(slicer, mps._Slicer_Matrix1_f32):
|
|
2012
|
+
with nogil:
|
|
2013
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix1_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2014
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2015
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2016
|
+
return (pts,weights)
|
|
2017
|
+
if isinstance(slicer, mps._Slicer_Matrix0_f64):
|
|
2018
|
+
with nogil:
|
|
2019
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2020
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2021
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2022
|
+
return (pts,weights)
|
|
2023
|
+
if isinstance(slicer, mps._Slicer_Matrix1_f64):
|
|
2024
|
+
with nogil:
|
|
2025
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_Matrix1_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2026
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2027
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2028
|
+
return (pts,weights)
|
|
2029
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_i32):
|
|
2030
|
+
with nogil:
|
|
2031
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_GudhiCohomology0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2032
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2033
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2034
|
+
return (pts,weights)
|
|
2035
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_i64):
|
|
2036
|
+
with nogil:
|
|
2037
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_GudhiCohomology0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2038
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2039
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2040
|
+
return (pts,weights)
|
|
2041
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_f32):
|
|
2042
|
+
with nogil:
|
|
2043
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_GudhiCohomology0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2044
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2045
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2046
|
+
return (pts,weights)
|
|
2047
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_f64):
|
|
2048
|
+
with nogil:
|
|
2049
|
+
sm = compute_rank_signed_measure(dereference(<C_KSlicer_GudhiCohomology0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2050
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2051
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2052
|
+
return (pts,weights)
|
|
2053
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_i32):
|
|
2054
|
+
with nogil:
|
|
2055
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_GudhiCohomology0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2056
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2057
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2058
|
+
return (pts,weights)
|
|
2059
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_i64):
|
|
2060
|
+
with nogil:
|
|
2061
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_GudhiCohomology0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2062
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2063
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2064
|
+
return (pts,weights)
|
|
2065
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_f32):
|
|
2066
|
+
with nogil:
|
|
2067
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_GudhiCohomology0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2068
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2069
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2070
|
+
return (pts,weights)
|
|
2071
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_f64):
|
|
2072
|
+
with nogil:
|
|
2073
|
+
sm = compute_rank_signed_measure(dereference(<C_Slicer_GudhiCohomology0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
|
|
2074
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2075
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2076
|
+
return (pts,weights)
|
|
2077
|
+
raise ValueError(f"Unsupported slicer type {type(slicer)}")
|
|
2078
|
+
|
|
2079
|
+
|
|
2080
|
+
|
|
2081
|
+
#### Hilbert Function
|
|
2082
|
+
|
|
2083
|
+
cdef extern from "multi_parameter_rank_invariant/hilbert_function.h" namespace "Gudhi::multiparameter::hilbert_function":
|
|
2084
|
+
## from slicers
|
|
2085
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix0_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2086
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix1_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2087
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix0_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2088
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix1_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2089
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix0_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2090
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix1_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2091
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix0_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2092
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix1_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2093
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix0_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2094
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix1_vine_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2095
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix0_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2096
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix1_vine_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2097
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix0_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2098
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix1_vine_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2099
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix0_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2100
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix1_vine_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2101
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2102
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix1_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2103
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2104
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix1_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2105
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2106
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix1_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2107
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2108
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_Matrix1_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2109
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2110
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix1_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2111
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2112
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix1_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2113
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2114
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix1_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2115
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2116
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_Matrix1_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2117
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_GudhiCohomology0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2118
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_GudhiCohomology0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2119
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_GudhiCohomology0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2120
|
+
signed_measure_type get_hilbert_signed_measure(C_KSlicer_GudhiCohomology0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2121
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_GudhiCohomology0_i32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2122
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_GudhiCohomology0_i64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2123
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_GudhiCohomology0_f32&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2124
|
+
signed_measure_type get_hilbert_signed_measure(C_Slicer_GudhiCohomology0_f64&, tensor_dtype* , const vector[indices_type], const vector[indices_type], bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
|
|
2125
|
+
cdef inline _compute_hilbert_sm(object slicer, tensor_dtype* container_ptr, vector[indices_type] c_grid_shape, vector[indices_type] degrees, int n_jobs, bool verbose,bool zero_pad, bool ignore_inf):
|
|
2126
|
+
import multipers.slicer as mps
|
|
2127
|
+
cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
|
|
2128
|
+
cdef signed_measure_type sm
|
|
2129
|
+
cdef cnp.ndarray[indices_type, ndim=2] pts
|
|
2130
|
+
cdef cnp.ndarray[tensor_dtype, ndim=1] weights
|
|
2131
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_i32):
|
|
2132
|
+
with nogil:
|
|
2133
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix0_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2134
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2135
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2136
|
+
return (pts,weights)
|
|
2137
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_i32):
|
|
2138
|
+
with nogil:
|
|
2139
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix1_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2140
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2141
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2142
|
+
return (pts,weights)
|
|
2143
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_i64):
|
|
2144
|
+
with nogil:
|
|
2145
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix0_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2146
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2147
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2148
|
+
return (pts,weights)
|
|
2149
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_i64):
|
|
2150
|
+
with nogil:
|
|
2151
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix1_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2152
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2153
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2154
|
+
return (pts,weights)
|
|
2155
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_f32):
|
|
2156
|
+
with nogil:
|
|
2157
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix0_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2158
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2159
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2160
|
+
return (pts,weights)
|
|
2161
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_f32):
|
|
2162
|
+
with nogil:
|
|
2163
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix1_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2164
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2165
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2166
|
+
return (pts,weights)
|
|
2167
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_vine_f64):
|
|
2168
|
+
with nogil:
|
|
2169
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix0_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2170
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2171
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2172
|
+
return (pts,weights)
|
|
2173
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_vine_f64):
|
|
2174
|
+
with nogil:
|
|
2175
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix1_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2176
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2177
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2178
|
+
return (pts,weights)
|
|
2179
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_i32):
|
|
2180
|
+
with nogil:
|
|
2181
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix0_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2182
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2183
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2184
|
+
return (pts,weights)
|
|
2185
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_i32):
|
|
2186
|
+
with nogil:
|
|
2187
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix1_vine_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2188
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2189
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2190
|
+
return (pts,weights)
|
|
2191
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_i64):
|
|
2192
|
+
with nogil:
|
|
2193
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix0_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2194
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2195
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2196
|
+
return (pts,weights)
|
|
2197
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_i64):
|
|
2198
|
+
with nogil:
|
|
2199
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix1_vine_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2200
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2201
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2202
|
+
return (pts,weights)
|
|
2203
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_f32):
|
|
2204
|
+
with nogil:
|
|
2205
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix0_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2206
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2207
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2208
|
+
return (pts,weights)
|
|
2209
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_f32):
|
|
2210
|
+
with nogil:
|
|
2211
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix1_vine_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2212
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2213
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2214
|
+
return (pts,weights)
|
|
2215
|
+
if isinstance(slicer, mps._Slicer_Matrix0_vine_f64):
|
|
2216
|
+
with nogil:
|
|
2217
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix0_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2218
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2219
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2220
|
+
return (pts,weights)
|
|
2221
|
+
if isinstance(slicer, mps._Slicer_Matrix1_vine_f64):
|
|
2222
|
+
with nogil:
|
|
2223
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix1_vine_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2224
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2225
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2226
|
+
return (pts,weights)
|
|
2227
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_i32):
|
|
2228
|
+
with nogil:
|
|
2229
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2230
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2231
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2232
|
+
return (pts,weights)
|
|
2233
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_i32):
|
|
2234
|
+
with nogil:
|
|
2235
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix1_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2236
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2237
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2238
|
+
return (pts,weights)
|
|
2239
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_i64):
|
|
2240
|
+
with nogil:
|
|
2241
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2242
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2243
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2244
|
+
return (pts,weights)
|
|
2245
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_i64):
|
|
2246
|
+
with nogil:
|
|
2247
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix1_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2248
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2249
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2250
|
+
return (pts,weights)
|
|
2251
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_f32):
|
|
2252
|
+
with nogil:
|
|
2253
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2254
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2255
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2256
|
+
return (pts,weights)
|
|
2257
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_f32):
|
|
2258
|
+
with nogil:
|
|
2259
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix1_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2260
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2261
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2262
|
+
return (pts,weights)
|
|
2263
|
+
if isinstance(slicer, mps._KSlicer_Matrix0_f64):
|
|
2264
|
+
with nogil:
|
|
2265
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2266
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2267
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2268
|
+
return (pts,weights)
|
|
2269
|
+
if isinstance(slicer, mps._KSlicer_Matrix1_f64):
|
|
2270
|
+
with nogil:
|
|
2271
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_Matrix1_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2272
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2273
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2274
|
+
return (pts,weights)
|
|
2275
|
+
if isinstance(slicer, mps._Slicer_Matrix0_i32):
|
|
2276
|
+
with nogil:
|
|
2277
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2278
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2279
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2280
|
+
return (pts,weights)
|
|
2281
|
+
if isinstance(slicer, mps._Slicer_Matrix1_i32):
|
|
2282
|
+
with nogil:
|
|
2283
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix1_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2284
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2285
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2286
|
+
return (pts,weights)
|
|
2287
|
+
if isinstance(slicer, mps._Slicer_Matrix0_i64):
|
|
2288
|
+
with nogil:
|
|
2289
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2290
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2291
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2292
|
+
return (pts,weights)
|
|
2293
|
+
if isinstance(slicer, mps._Slicer_Matrix1_i64):
|
|
2294
|
+
with nogil:
|
|
2295
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix1_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2296
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2297
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2298
|
+
return (pts,weights)
|
|
2299
|
+
if isinstance(slicer, mps._Slicer_Matrix0_f32):
|
|
2300
|
+
with nogil:
|
|
2301
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2302
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2303
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2304
|
+
return (pts,weights)
|
|
2305
|
+
if isinstance(slicer, mps._Slicer_Matrix1_f32):
|
|
2306
|
+
with nogil:
|
|
2307
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix1_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2308
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2309
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2310
|
+
return (pts,weights)
|
|
2311
|
+
if isinstance(slicer, mps._Slicer_Matrix0_f64):
|
|
2312
|
+
with nogil:
|
|
2313
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2314
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2315
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2316
|
+
return (pts,weights)
|
|
2317
|
+
if isinstance(slicer, mps._Slicer_Matrix1_f64):
|
|
2318
|
+
with nogil:
|
|
2319
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_Matrix1_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2320
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2321
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2322
|
+
return (pts,weights)
|
|
2323
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_i32):
|
|
2324
|
+
with nogil:
|
|
2325
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_GudhiCohomology0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2326
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2327
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2328
|
+
return (pts,weights)
|
|
2329
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_i64):
|
|
2330
|
+
with nogil:
|
|
2331
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_GudhiCohomology0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2332
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2333
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2334
|
+
return (pts,weights)
|
|
2335
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_f32):
|
|
2336
|
+
with nogil:
|
|
2337
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_GudhiCohomology0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2338
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2339
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2340
|
+
return (pts,weights)
|
|
2341
|
+
if isinstance(slicer, mps._KSlicer_GudhiCohomology0_f64):
|
|
2342
|
+
with nogil:
|
|
2343
|
+
sm = get_hilbert_signed_measure(dereference(<C_KSlicer_GudhiCohomology0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2344
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2345
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2346
|
+
return (pts,weights)
|
|
2347
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_i32):
|
|
2348
|
+
with nogil:
|
|
2349
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_GudhiCohomology0_i32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2350
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2351
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2352
|
+
return (pts,weights)
|
|
2353
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_i64):
|
|
2354
|
+
with nogil:
|
|
2355
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_GudhiCohomology0_i64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2356
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2357
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2358
|
+
return (pts,weights)
|
|
2359
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_f32):
|
|
2360
|
+
with nogil:
|
|
2361
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_GudhiCohomology0_f32*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2362
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2363
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2364
|
+
return (pts,weights)
|
|
2365
|
+
if isinstance(slicer, mps._Slicer_GudhiCohomology0_f64):
|
|
2366
|
+
with nogil:
|
|
2367
|
+
sm = get_hilbert_signed_measure(dereference(<C_Slicer_GudhiCohomology0_f64*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
|
|
2368
|
+
pts = np.asarray(sm.first,dtype=python_indices_type)
|
|
2369
|
+
weights = np.asarray(sm.second,dtype=python_tensor_dtype)
|
|
2370
|
+
return (pts,weights)
|
|
2371
|
+
raise ValueError(f"Unsupported slicer type {type(slicer)}")
|