if d < 0 {
		return -d
	}
	return d
}

// averageDelta returns the average delta in RGB space. The two images must
// have the same bounds.
func averageDelta(m0, m1 image.Image) int64 {
	b := m0.Bounds()
	return averageDeltaBound(m0, m1, b, b)
}

// averageDeltaBound returns the average delta in RGB space. The average delta is
// calculated in the specified bounds.

      
      By using a startup probe, we can poll for the sidecar to start more aggressively, without polling as aggressively throughout
      the entire pod's lifecycle.
      On average, this improves pod startup time by roughly 1s.
      
      If the startup probe does not pass after 10 minutes, the pod will be terminated.

)

// leastResourceScorer favors nodes with fewer requested resources.
// It calculates the percentage of memory, CPU and other resources requested by pods scheduled on the node, and
// prioritizes based on the minimum of the average of the fraction of requested to capacity.
//
// Details:
// (cpu((capacity-requested)*MaxNodeScore*cpuWeight/capacity) + memory((capacity-requested)*MaxNodeScore*memoryWeight/capacity) + ...)/weightSum

  AverageMinMax calibration calculates the average of min and max values.
  average of min = sum of min values / number of samples
  average of max = sum of max values / number of samples
  """

  def get_min_max_value(self) -> tuple[float, float]:
    """Calculates the average of min and max values.

    Returns:

// GetResourceUtilizationRatio takes in a set of metrics, a set of matching requests,
// and a target utilization percentage, and calculates the ratio of
// desired to actual utilization (returning that, the actual utilization, and the raw average value)
func GetResourceUtilizationRatio(metrics PodMetricsInfo, requests map[string]int64, targetUtilization int32) (utilizationRatio float64, currentUtilization int32, rawAverageValue int64, err error) {
	metricsTotal := int64(0)

	internodeDialedErrorsTotalMD = NewCounterMD(internodeDialErrorsTotal,
		"Total number of internode TCP dial timeouts and errors")
	internodeDialAvgTimeNanosMD = NewGaugeMD(internodeDialAvgTimeNanos,
		"Average dial time of internode TCP calls in nanoseconds")
	internodeSentBytesTotalMD = NewCounterMD(internodeSentBytesTotal,
		"Total number of bytes sent to other peer nodes")

)

// mostResourceScorer favors nodes with most requested resources.
// It calculates the percentage of memory and CPU requested by pods scheduled on the node, and prioritizes
// based on the maximum of the average of the fraction of requested to capacity.
//
// Details:
// (cpu(MaxNodeScore * requested * cpuWeight / capacity) + memory(MaxNodeScore * requested * memoryWeight / capacity) + ...) / weightSum

					0: {10, 10, 10, 10},
					1: {10, 10, 10, 10},
					2: {10, 10, 10, 10},
					3: {10, 10, 10, 10},
				},
			},
		},
		{
			description: "current and candidate length is the same, candidate average distance is smaller",
			current:     NewTestBitMask(0, 3),
			candidate:   NewTestBitMask(0, 1),
			expected:    "candidate",
			numaInfo: &NUMAInfo{
				NUMADistances: NUMADistances{
					0: {10, 11, 12, 12},

 *       <ul>
 *         <li>2 levels: average of 64ns per lock()/unlock()
 *         <li>3 levels: average of 77ns per lock()/unlock()
 *         <li>4 levels: average of 99ns per lock()/unlock()
 *         <li>5 levels: average of 103ns per lock()/unlock()
 *         <li>10 levels: average of 184ns per lock()/unlock()
 *         <li>20 levels: average of 393ns per lock()/unlock()
 *       </ul>
 * </ul>
 *

// each collected sample by its probability of appearing in the
// profile. heap profiles rely on a poisson process to determine
// which samples to collect, based on the desired average collection
// rate R. The probability of a sample of size S to appear in that
// profile is 1-exp(-S/R).
func scaleHeapSample(count, size, rate int64) (int64, int64) {
	if count == 0 || size == 0 {
		return 0, 0
	}