code: def residual_resample(weights):
      """Performs the residual resampling algorithm used by particle filters.
  
      Based on observation that we don't need to use random numbers to select
      most of the weights. Take int(N*w^i) samples of each particle i, and then
      resample any remaining using a standard resampling algorithm [1]
  
  
      Parameters
      ----------
  
      weights : list-like of float
          list of weights as floats
  
      Returns
      -------
  
      indexes : ndarray of ints
          array of indexes into the weights defining the resample. i.e. the
          index of the zeroth resample is indexes[0], etc.
  
      References
      ----------
  
      .. [1] J. S. Liu and R. Chen. Sequential Monte Carlo methods for dynamic
         systems. Journal of the American Statistical Association,
         93(443):1032–1044, 1998.
      """
  
      N = len(weights)
      indexes = np.zeros(N, "i")
  
      # take int(N*w) copies of each weight, which ensures particles with the
      # same weight are drawn uniformly
      num_copies = (np.floor(N * np.asarray(weights))).astype(int)
      k = 0
      for i in range(N):
          for _ in range(num_copies[i]):  # make n copies
              indexes[k] = i
              k += 1
  
      # use multinormal resample on the residual to fill up the rest. This
      # maximizes the variance of the samples
      residual = weights - num_copies  # get fractional part
      residual /= sum(residual)  # normalize
      cumulative_sum = np.cumsum(residual)
      cumulative_sum[
          -1
      ] = 1.0  # avoid round-off errors: ensures sum is exactly one
      indexes[k:N] = np.searchsorted(cumulative_sum, random(N - k))
  
      return indexes
  
imports: import numpy
  from numpy.random import random
label_desc: Use image node_id 1 for calling a global function with example usage: residual_resample(weights) and returns: indexes