code: def weighted_percentile(
      a, q, weights=None, sorter=None, is_filtered=False
  ):
      """
      Returns the weighted percentile of a at q given weights.
  
      Parameters
      ----------
      a: array-like, shape=(n_samples,)
          samples at which the quantile.
      q: int
          quantile between 0 and 100.
      weights: array-like, shape=(n_samples,)
          weights[i] is the weight given to point a[i] while computing the
          quantile. If weights[i] is zero, a[i] is simply ignored during the
          percentile computation.
      sorter: array-like, shape=(n_samples,)
          If provided, assume that a[sorter] is sorted.
      is_filtered: bool
          If True, weights is assumed to contain only non-zero values.
  
      Returns
      -------
      percentile: float
          Weighted percentile of a at q.
  
      References
      ----------
      1. https://en.wikipedia.org/wiki/Percentile#The_Weighted_Percentile_method
  
      Notes
      -----
      Note that weighted_percentile(a, q) is not equivalent to
      np.percentile(a, q). This is because in np.percentile
      sorted(a)[i] is assumed to be at quantile 0.0, while here we assume
      sorted(a)[i] is given a weight of 1.0 / len(a), hence it is at the
      1.0 / len(a)th quantile.
      """
      if weights is None:
          weights = np.ones_like(a)
      if q > 100 or q < 0:
          raise ValueError(
              "q should be in-between 0 and 100, " "got %d" % q
          )
  
      a = np.asarray(a, dtype=np.float32)
      weights = np.asarray(weights, dtype=np.float32)
      if len(a) != len(weights):
          raise ValueError("a and weights should have the same length.")
  
      if sorter is not None:
          a = a[sorter]
          weights = weights[sorter]
  
      if not is_filtered:
          nz = weights != 0
          a = a[nz]
          weights = weights[nz]
  
      if sorter is None:
          sorted_indices = np.argsort(a)
          sorted_a = a[sorted_indices]
          sorted_weights = weights[sorted_indices]
      else:
          sorted_a = a
          sorted_weights = weights
  
      # Step 1
      sorted_cum_weights = np.cumsum(sorted_weights)
      total = sorted_cum_weights[-1]
  
      # Step 2
      partial_sum = (
          100.0 / total * (sorted_cum_weights - sorted_weights / 2.0)
      )
      start = np.searchsorted(partial_sum, q) - 1
      if start == len(sorted_cum_weights) - 1:
          return sorted_a[-1]
      if start == -1:
          return sorted_a[0]
  
      # Step 3.
      fraction = (q - partial_sum[start]) / (
          partial_sum[start + 1] - partial_sum[start]
      )
      return sorted_a[start] + fraction * (
          sorted_a[start + 1] - sorted_a[start]
      )
  
imports: import logging
  from functools import partial
  import numpy
  import pandas
  from sklearn.ensemble._forest import ForestRegressor
  from sklearn.tree import BaseDecisionTree, DecisionTreeRegressor, ExtraTreeRegressor
  from sklearn.utils import check_array, check_random_state, check_X_y
label_desc: Use image node_id 1 for calling a global function with example usage: weighted_percentile(a, q, weights, sorter, is_filtered) and returns: unknown, sorted_a, sorted_a