code: def query(self, query_data, k=10, queue_size=5.0):
          
          # query_data = check_array(query_data, dtype=np.float64, order='C')
          query_data = np.asarray(query_data).astype(np.float32)
          init = initialise_search(
              self._rp_forest,
              self._raw_data,
              query_data,
              int(k * queue_size),
              self._random_init,
              self._tree_init,
              self.rng_state,
          )
          result = self._search(
              self._raw_data,
              self._search_graph.indptr,
              self._search_graph.indices,
              init,
              query_data,
          )
  
          indices, dists = deheap_sort(result)
          return indices[:, :k], dists[:, :k]
docs: Query the training data for the k nearest neighbors
  
          Parameters
          ----------
          query_data: array-like, last dimension self.dim
              An array of points to query
  
          k: integer (default = 10)
              The number of nearest neighbors to return
  
          queue_size: float (default 5.0)
              The multiplier of the internal search queue. This controls the
              speed/accuracy tradeoff. Low values will search faster but with
              more approximate results. High values will search more
              accurately, but will require more computation to do so. Values
              should generally be in the range 1.0 to 10.0.
  
          Returns
          -------
          indices, distances: array (n_query_points, k), array (n_query_points, k)
              The first array, ``indices``, provides the indices of the data
              points in the training set that are the nearest neighbors of
              each query point. Thus ``indices[i, j]`` is the index into the
              training data of the jth nearest neighbor of the ith query points.
  
              Similarly ``distances`` provides the distances to the neighbors
              of the query points such that ``distances[i, j]`` is the distance
              from the ith query point to its jth nearest neighbor in the
              training data.