multipers 2.3.3b6__cp313-cp313-macosx_10_13_x86_64.whl

multipers/slicer.pxd.tp

@@ -0,0 +1,234 @@
+{{py:
+"""
+Vine and non-vine slicers.
+both type have the same interface, defined the slicer.pyx file
+"""
+
+## generation with another file as Tempita is slightly bugged for python <3.12
+import pickle
+with open("build/tmp/_slicer_names.pkl", "rb") as f:
+  slicers = pickle.load(f)
+
+# TODO: FIXME. This is not possible as the import is hardcoded as f32 and f64.
+# float_value_types = set([(D['C_VALUE_TYPE'],D['PY_VALUE_TYPE'],D['SHORT_VALUE_TYPE']) for D in slicers if D['IS_FLOAT']])
+
+float_value_types = set((("float",   "np.float32", "f32"), ("double",  "np.float64", "f64")) )
+
+
+}}
+
+cimport numpy as cnp
+
+# SequentialDataset and its two concrete subclasses are (optionally randomized)
+# iterators over the rows of a matrix X and corresponding target values y.
+
+from libcpp.utility cimport pair 
+from libcpp cimport bool, int, float
+from libcpp.vector cimport vector
+
+
+from libc.stdint cimport intptr_t, uint16_t, uint32_t, int32_t, uint64_t, int64_t
+from cython cimport uint
+
+import numpy as np
+python_value_type=np.float32
+from libcpp.string cimport string
+
+cdef extern from "Simplex_tree_multi_interface.h" namespace "Gudhi::multiparameter::python_interface":
+    cdef cppclass Simplex_tree_multi_interface[F=*, value_type=*]:
+        pass
+
+from multipers.filtrations cimport *
+ctypedef  vector[uint] cycle_type ## its the cycle type of matrix
+
+
+{{for D in slicers}}
+
+#------------------------------------------------------------------------------
+cdef extern from "Persistence_slices_interface.h":
+  cdef cppclass {{D['C_TEMPLATE_TYPE']}} "{{D['TRUC_TYPE']}}":
+      ctypedef {{D['C_VALUE_TYPE']}} value_type
+
+      {{D['C_TEMPLATE_TYPE']}}()
+
+      {{if D['IS_SIMPLICIAL']}}
+      {{D['C_TEMPLATE_TYPE']}}(Simplex_tree_multi_interface[{{D['FILTRATION_TYPE']}}, {{D['C_VALUE_TYPE']}}]*)
+      {{else}}
+      {{D['C_TEMPLATE_TYPE']}}(const vector[vector[unsigned int]]&, const vector[int]&, const vector[{{D['FILTRATION_TYPE']}}]&)
+      {{endif}}
+
+      {{D['C_TEMPLATE_TYPE']}}& operator=(const {{D['C_TEMPLATE_TYPE']}}&)
+      
+      pair[{{D['C_TEMPLATE_TYPE']}}, vector[unsigned int]] colexical_rearange() except + nogil
+      {{D['C_TEMPLATE_TYPE']}} permute(const vector[unsigned int]&) except + nogil
+
+      vector[vector[pair[{{D['C_VALUE_TYPE']}}, {{D['C_VALUE_TYPE']}}]]] get_barcode() nogil
+      vector[vector[pair[int,int]]] get_barcode_idx() nogil
+      vector[vector[vector[pair[int,int]]]] custom_persistences({{D['C_VALUE_TYPE']}}*, int size, bool ignore_inf) except + nogil
+
+      void push_to(const Line[{{D['C_VALUE_TYPE']}}]&) nogil
+      void set_one_filtration(const vector[{{D['C_VALUE_TYPE']}}]&) nogil
+      int prune_above_dimension(int) except + nogil 
+
+      vector[{{D['C_VALUE_TYPE']}}] get_one_filtration()
+      # void compute_persistence(vector[bool]) except+ nogil
+      void compute_persistence(bool) except+ nogil # ignore_inf
+      void compute_persistence() except+ nogil # ignore_inf
+      uint32_t num_generators() nogil
+      uint32_t num_parameters() nogil
+      string to_str() nogil
+      pair[One_critical_filtration[{{D['C_VALUE_TYPE']}}], One_critical_filtration[{{D['C_VALUE_TYPE']}}]] get_bounding_box() except + nogil
+      vector[One_critical_filtration[{{D['C_VALUE_TYPE']}}]] get_filtration_values() nogil
+      vector[int] get_dimensions() nogil
+      int get_dimension(int i) nogil
+      vector[vector[uint]] get_boundaries() nogil
+      void coarsen_on_grid_inplace(vector[vector[{{D['C_VALUE_TYPE']}}]], bool) nogil
+      vector[{{D['FILTRATION_TYPE']}}]& get_filtrations() nogil
+      {{if D['COLUMN_TYPE'] is not None}}
+      {{D['C_TEMPLATE_TYPE'][:-3]+"i32"}} coarsen_on_grid(vector[vector[{{D['C_VALUE_TYPE']}}]]) nogil
+      {{endif}}
+      {{if D['IS_VINE']}}
+      void vineyard_update() nogil
+      vector[vector[vector[vector[unsigned int]]]] get_representative_cycles(bool, bool) nogil
+      vector[uint32_t] get_current_order() nogil
+      {{endif}}
+
+      {{if D['IS_KCRITICAL']}}
+      void add_generator(const One_critical_filtration[{{D['C_VALUE_TYPE']}}] &) nogil
+      {{endif}}
+
+      void write_to_scc_file(const string&, int, int, bool, bool, bool, bool) nogil
+      {{if not D['IS_KCRITICAL']}}
+      void build_from_scc_file(const string&, bool, bool, int) except + nogil
+      {{endif}}
+
+
+      vector[vector[vector[pair[{{D['C_VALUE_TYPE']}}, {{D['C_VALUE_TYPE']}}]]]] persistence_on_lines(vector[vector[{{D['C_VALUE_TYPE']}}]], bool) except + nogil
+      vector[vector[vector[pair[{{D['C_VALUE_TYPE']}}, {{D['C_VALUE_TYPE']}}]]]] persistence_on_lines(vector[pair[vector[{{D['C_VALUE_TYPE']}}],vector[{{D['C_VALUE_TYPE']}}]]],bool) except + nogil
+
+
+      {{if D['COLUMN_TYPE'] is not None}}
+      {{D['C_TEMPLATE_TYPE']}} projective_cover_kernel(int dim) except + nogil
+      {{endif}}
+{{endfor}}
+
+
+
+#### MMA Stuff
+
+from multipers.mma_structures cimport Module
+cdef extern from "multiparameter_module_approximation/approximation.h" namespace "Gudhi::multiparameter::mma":
+{{for D in slicers}}
+  {{if D['IS_VINE'] and D['IS_FLOAT']}}
+  Module[{{D['C_VALUE_TYPE']}}] multiparameter_module_approximation({{D['C_TEMPLATE_TYPE']}}&, One_critical_filtration[{{D['C_VALUE_TYPE']}}]&, {{D['C_VALUE_TYPE']}}, Box[{{D['C_VALUE_TYPE']}}]&, bool, bool, bool) except + nogil
+  {{endif}}
+  {{endfor}}
+  pass
+
+
+
+
+import multipers.slicer as mps
+from cython.operator cimport dereference
+{{for C_VALUE_TYPE,PYTHON_VALUE_TYPE,SHORT_VALUE_TYPE in float_value_types}}
+cdef inline Module[{{C_VALUE_TYPE}}] _multiparameter_module_approximation_{{SHORT_VALUE_TYPE}}(object slicer, One_critical_filtration[{{C_VALUE_TYPE}}] direction, {{C_VALUE_TYPE}} max_error, Box[{{C_VALUE_TYPE}}] box, bool threshold, bool complete, bool verbose):
+  import multipers.slicer as mps
+  cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
+  cdef Module[{{C_VALUE_TYPE}}] mod
+  if False:
+    pass
+  {{for D in slicers}}
+  {{if D['IS_VINE'] and D['SHORT_VALUE_TYPE'] == SHORT_VALUE_TYPE}} 
+  elif isinstance(slicer, mps.{{D['PYTHON_TYPE']}}):
+    with nogil:
+      mod = multiparameter_module_approximation(dereference(<{{D['C_TEMPLATE_TYPE']}}*>(slicer_ptr)), direction, max_error, box, threshold, complete, verbose)
+    return mod
+  {{endif}}
+  {{endfor}}
+  else:
+    raise ValueError(f"Unsupported slicer type {type(slicer)}")
+{{endfor}}
+
+###### RANK INVARIANT
+from libc.stdint cimport intptr_t, uint16_t, uint32_t, int32_t, int16_t, int8_t
+ctypedef int32_t tensor_dtype
+ctypedef int32_t indices_type
+python_indices_type=np.int32
+python_tensor_dtype = np.int32
+
+
+
+ctypedef pair[vector[vector[indices_type]], vector[tensor_dtype]] signed_measure_type
+
+
+
+cdef extern from "multi_parameter_rank_invariant/rank_invariant.h" namespace "Gudhi::multiparameter::rank_invariant":
+  ## from slicers
+{{for D in slicers}}
+    void compute_rank_invariant_python({{D['C_TEMPLATE_TYPE']}}&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool ignore_inf) except + nogil
+    signed_measure_type compute_rank_signed_measure({{D['C_TEMPLATE_TYPE']}}&, tensor_dtype* , const vector[indices_type], const vector[indices_type], indices_type, bool verbose, bool ignore_inf) except + nogil
+  {{endfor}}
+
+
+
+
+
+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):
+  import multipers.slicer as mps
+  cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
+{{for D in slicers}}
+  if isinstance(slicer, mps.{{D['PYTHON_TYPE']}}):
+    with nogil:
+      compute_rank_invariant_python(dereference(<{{D['C_TEMPLATE_TYPE']}}*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs,ignore_inf)
+      return
+  {{endfor}}
+  raise ValueError(f"Unsupported slicer type {type(slicer)}")
+
+
+
+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):
+  import multipers.slicer as mps
+  cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
+  cdef signed_measure_type sm
+  cdef cnp.ndarray[indices_type, ndim=2] pts
+  cdef cnp.ndarray[tensor_dtype, ndim=1] weights
+{{for D in slicers}}
+  if isinstance(slicer, mps.{{D['PYTHON_TYPE']}}):
+    with nogil:
+      sm = compute_rank_signed_measure(dereference(<{{D['C_TEMPLATE_TYPE']}}*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, n_jobs, verbose, ignore_inf)
+    pts = np.asarray(sm.first,dtype=python_indices_type)
+    weights = np.asarray(sm.second,dtype=python_tensor_dtype)
+    return (pts,weights)
+  {{endfor}}
+  raise ValueError(f"Unsupported slicer type {type(slicer)}")
+
+
+
+#### Hilbert Function
+
+cdef extern from "multi_parameter_rank_invariant/hilbert_function.h" namespace "Gudhi::multiparameter::hilbert_function":
+  ## from slicers
+{{for D in slicers}}
+    signed_measure_type get_hilbert_signed_measure({{D['C_TEMPLATE_TYPE']}}&, tensor_dtype* , const vector[indices_type], const vector[indices_type],  bool zero_pad,indices_type n_jobs, bool verbose, bool ignore_inf) except + nogil
+  {{endfor}}
+cdef inline  _compute_hilbert_sm(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):
+  import multipers.slicer as mps
+  if len(slicer) == 0:
+    return (np.empty(shape=(0, 1), dtype=slicer.dtype), np.empty(shape=(0), dtype=int))
+  cdef intptr_t slicer_ptr = <intptr_t>(slicer.get_ptr())
+  cdef signed_measure_type sm
+  cdef cnp.ndarray[indices_type, ndim=2] pts
+  cdef cnp.ndarray[tensor_dtype, ndim=1] weights
+{{for D in slicers}}
+  if isinstance(slicer, mps.{{D['PYTHON_TYPE']}}):
+    with nogil:
+      sm = get_hilbert_signed_measure(dereference(<{{D['C_TEMPLATE_TYPE']}}*>(slicer_ptr)),container_ptr, c_grid_shape,degrees, zero_pad, n_jobs, verbose, ignore_inf)
+    if len(sm.first) == 0:
+      pts = np.empty(shape=(0, slicer.num_parameters), dtype=python_indices_type)
+      weights = np.empty(shape=(0), dtype=python_tensor_dtype)
+    else:
+      pts = np.asarray(sm.first,dtype=python_indices_type)
+      weights = np.asarray(sm.second,dtype=python_tensor_dtype)
+    return (pts,weights)
+  {{endfor}}
+  raise ValueError(f"Unsupported slicer type {type(slicer)}")