class_docstr: !
  @brief Class represents clustering algorithm HSyncNet. HSyncNet is bio-inspired algorithm that is based on oscillatory network that uses modified Kuramoto model.
  
  Example:
  @code
      from pyclustering.cluster.hsyncnet import hsyncnet
      from pyclustering.nnet.sync import sync_visualizer
      from pyclustering.utils import read_sample, draw_clusters
      from pyclustering.samples.definitions import SIMPLE_SAMPLES
  
      # Read list of points for cluster analysis.
      sample = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE2)
  
      # Create network for allocation of three clusters.
      network = hsyncnet(sample, 3)
  
      # Run cluster analysis and output dynamic of the network.
      analyser = network.process(0.995, collect_dynamic=True)
  
      # Get allocated clusters.
      clusters = analyser.allocate_clusters(eps=0.1)
  
      # Show output dynamic of the network.
      sync_visualizer.show_output_dynamic(analyser)
  
      # Show allocated clusters.
      draw_clusters(sample, clusters)
  @endcode
docstr: !
  @brief Performs clustering of input data set in line with input parameters.
  
  @param[in] order (double): Level of local synchronization between oscillator that defines end of synchronization process, range [0..1].
  @param[in] solution (solve_type) Type of solving differential equation.
  @param[in] collect_dynamic (bool): If True - returns whole history of process synchronization otherwise - only final state (when process of clustering is over).
  
  @return (tuple) Returns dynamic of the network as tuple of lists on each iteration (time, oscillator_phases) that depends on collect_dynamic parameter. 
  
  @see get_clusters()
code: def process(
      self, order=0.998, solution=solve_type.FAST, collect_dynamic=False
  ):
      """!
      @brief Performs clustering of input data set in line with input parameters.
  
      @param[in] order (double): Level of local synchronization between oscillator that defines end of synchronization process, range [0..1].
      @param[in] solution (solve_type) Type of solving differential equation.
      @param[in] collect_dynamic (bool): If True - returns whole history of process synchronization otherwise - only final state (when process of clustering is over).
  
      @return (tuple) Returns dynamic of the network as tuple of lists on each iteration (time, oscillator_phases) that depends on collect_dynamic parameter.
  
      @see get_clusters()
  
      """
  
      if self.__ccore_network_pointer is not None:
          analyser = wrapper.hsyncnet_process(
              self.__ccore_network_pointer,
              order,
              solution,
              collect_dynamic,
          )
          return syncnet_analyser(None, None, analyser)
  
      number_neighbors = self.__initial_neighbors
      current_number_clusters = float("inf")
  
      dyn_phase = []
      dyn_time = []
  
      radius = average_neighbor_distance(
          self._osc_loc, number_neighbors
      )
  
      increase_step = int(len(self._osc_loc) * self.__increase_persent)
      if increase_step < 1:
          increase_step = 1
  
      analyser = None
      while current_number_clusters > self._number_clusters:
          self._create_connections(radius)
  
          analyser = self.simulate_dynamic(
              order, solution, collect_dynamic
          )
          if collect_dynamic:
              if len(dyn_phase) == 0:
                  self.__store_dynamic(
                      dyn_phase, dyn_time, analyser, True
                  )
  
              self.__store_dynamic(dyn_phase, dyn_time, analyser, False)
  
          clusters = analyser.allocate_sync_ensembles(0.05)
  
          # Get current number of allocated clusters
          current_number_clusters = len(clusters)
  
          # Increase number of neighbors that should be used
          number_neighbors += increase_step
  
          # Update connectivity radius and check if average function can be used anymore
          radius = self.__calculate_radius(number_neighbors, radius)
  
      if not collect_dynamic:
          self.__store_dynamic(dyn_phase, dyn_time, analyser, False)
  
      return syncnet_analyser(dyn_phase, dyn_time, None)
  
file_path: pyclustering/pyclustering/cluster/hsyncnet.py
imports: import pyclustering.core.hsyncnet_wrapper
  from pyclustering.core.wrapper import ccore_library
  from pyclustering.nnet import initial_type, solve_type
  from pyclustering.cluster.syncnet import syncnet, syncnet_analyser
  from pyclustering.utils import average_neighbor_distance
label_desc: Use image node_id 3 for calling the hsyncnet obj's underlying member method code with example usage: obj.process(order, solution, collect_dynamic) and returns: syncnet_analyser, syncnet_analyser