code: def _calculate_outlier_scores(
      X, bin_edges, hist, n_bins, alpha, tol
  ):  # pragma: no cover
      """The internal function to calculate the outlier scores based on
      the bins and histograms constructed with the training data. The program
      is optimized through numba. It is excluded from coverage test for
      eliminating the redundancy.
  
      Parameters
      ----------
      X : numpy array of shape (n_samples, n_features)
          The input samples.
  
      bin_edges : numpy array of shape (n_bins + 1, n_features )
          The edges of the bins.
  
      hist : numpy array of shape (n_bins, n_features)
          The density of each histogram.
  
      n_bins : int
          The number of bins.
  
      alpha : float in (0, 1)
          The regularizer for preventing overflow.
  
      tol : float in (0, 1)
          The parameter to decide the flexibility while dealing
          the samples falling outside the bins.
  
      Returns
      -------
      outlier_scores : numpy array of shape (n_samples, n_features)
          Outlier scores on all features (dimensions).
      """
  
      n_samples, n_features = X.shape[0], X.shape[1]
      outlier_scores = np.zeros(shape=(n_samples, n_features))
  
      for i in range(n_features):
          # Find the indices of the bins to which each value belongs.
          # See documentation for np.digitize since it is tricky
          # >>> x = np.array([0.2, 6.4, 3.0, 1.6, -1, 100, 10])
          # >>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])
          # >>> np.digitize(x, bins, right=True)
          # array([1, 4, 3, 2, 0, 5, 4], dtype=int64)
  
          bin_inds = np.digitize(X[:, i], bin_edges[:, i], right=True)
  
          # Calculate the outlying scores on dimension i
          # Add a regularizer for preventing overflow
          out_score_i = np.log2(hist[:, i] + alpha)
  
          for j in range(n_samples):
              # If the sample does not belong to any bins
              # bin_ind == 0 (fall outside since it is too small)
              if bin_inds[j] == 0:
                  dist = bin_edges[0, i] - X[j, i]
                  bin_width = bin_edges[1, i] - bin_edges[0, i]
  
                  # If it is only slightly lower than the smallest bin edge
                  # assign it to bin 1
                  if dist <= bin_width * tol:
                      outlier_scores[j, i] = out_score_i[0]
                  else:
                      outlier_scores[j, i] = np.min(out_score_i)
  
              # If the sample does not belong to any bins
              # bin_ind == n_bins+1 (fall outside since it is too large)
              elif bin_inds[j] == n_bins + 1:
                  dist = X[j, i] - bin_edges[-1, i]
                  bin_width = bin_edges[-1, i] - bin_edges[-2, i]
  
                  # If it is only slightly larger than the largest bin edge
                  # assign it to the last bin
                  if dist <= bin_width * tol:
                      outlier_scores[j, i] = out_score_i[n_bins - 1]
                  else:
                      outlier_scores[j, i] = np.min(out_score_i)
              else:
                  outlier_scores[j, i] = out_score_i[bin_inds[j] - 1]
  
      return outlier_scores
  
file_path: pyod/pyod/models/hbos.py
imports: from __future__ import division
  from __future__ import print_function
  import numpy
  from numba import njit
  from sklearn.utils import check_array
  from sklearn.utils.validation import check_is_fitted
  from .base import BaseDetector
  from ..utils.utility import check_parameter
  from ..utils.utility import get_optimal_n_bins
  from ..utils.utility import invert_order
label_desc: Use image node_id 2 for calling a global function with example usage: _calculate_outlier_scores(X, bin_edges, hist, n_bins, alpha, tol) and returns: outlier_scores