// Relies on the correctness of sqrt(BigInteger, FLOOR).
  @GwtIncompatible // TODO
  public void testSqrtExact() {
    for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) {
      BigInteger floor = BigIntegerMath.sqrt(x, FLOOR);
      // We only expect an exception if x was not a perfect square.
      boolean isPerfectSquare = floor.pow(2).equals(x);
      try {
        assertEquals(floor, BigIntegerMath.sqrt(x, UNNECESSARY));

  const float kern_size = pool.kh * pool.kw;

  // LEMMA 1: Changing the rounding mode from floor to ceil will increase an
  // output dimension by at most 1 (see `ComputeSpatialOutDim`). This is because
  // for any `x`, `ceil(x) - floor(x) <= 1`.

  // Consider that we pad the input of a average pool with floor rounding to the
  // appropriate size and switch the rounding mode to ceil. When computing the

            panels: sanitizePanels(sanePanel.panels, std.length(sanePanel.panels)),
          }
          else sanePanel + {
            gridPos+: {
              h: panelHeight,
              w: std.floor(gridWidth/row),
            },
          }
        ),
      ps
    );
    local sanitizedPanels = sanitizePanels(panels, 0);

    local grouped = panelUtil.groupPanelsInRows(sanitizedPanels);

inline float CalculateLowerBound(const float min_value, const float bin_width) {
  return std::floor(min_value / bin_width) * bin_width;
}

// Calculates the bin index of the current value.
inline int32_t CalculateBinIndex(const float value, const float lower_bound,
                                 const float bin_width) {
  return std::floor((value - lower_bound) / bin_width);
}

	if config.MaxPerCore != nil && *config.MaxPerCore > 0 {
		floor := 0
		if config.Min != nil {
			floor = int(*config.Min)
		}
		scaled := int(*config.MaxPerCore) * detectNumCPU()
		if scaled > floor {
			logger.V(3).Info("GetConntrackMax: using scaled conntrack-max-per-core")
			return scaled, nil
		}
		logger.V(3).Info("GetConntrackMax: using conntrack-min")
		return floor, nil
	}
	return 0, nil
}

			// `memory.high=floor[(requests.memory + memory throttling factor * (limits.memory or node allocatable memory - requests.memory))/pageSize] * pageSize`
			// where default value of memory throttling factor is set to 0.9
			// More info: https://git.k8s.io/enhancements/keps/sig-node/2570-memory-qos
			memoryHigh := int64(0)
			if memoryLimit != 0 {
				memoryHigh = int64(math.Floor(
					float64(memoryRequest)+

		return 0, fmt.Errorf("invalid value for IntOrString: %v", err)
	}
	if isPercent {
		if roundUp {
			value = int(math.Ceil(float64(value) * (float64(total)) / 100))
		} else {
			value = int(math.Floor(float64(value) * (float64(total)) / 100))
		}
	}
	return value, nil
}

// GetValueFromIntOrPercent was deprecated in favor of

def LowerTruncateDivOpOnIntTensors : Pat<
  (TF_TruncateDivOp TF_IntTensor:$lhs, $rhs),
  (TF_DivOp $lhs, $rhs)>;

// Note: truncation could also be implemented as sign(x) * floor(abs(x)) or
//       (-1 & x) || floor(abs(x)), based on performance benchmarks.
def LowerTruncateDivOpOnFloatTensors : Pat<
  (TF_TruncateDivOp TF_FloatTensor:$lhs, $rhs),
  (TF_SelectV2Op
    (TF_LessOp
      (TF_DivOp:$div $lhs, $rhs),

    assertThat(set.floor("f")).isNull();
  }

  public void testFloor_elementPresent() {
    ImmutableSortedSet<String> set =
        ImmutableSortedSet.copyOf(new String[] {"e", "a", "e", "f", "b", "i", "d", "a", "c", "k"});
    assertThat(set.floor("f")).isEqualTo("f");
    assertThat(set.floor("j")).isEqualTo("i");
    assertThat(set.floor("q")).isEqualTo("k");
  }

	// In general (x*n)/2⁶⁴ = k for x*n in [k*2⁶⁴,(k+1)*2⁶⁴).
	// There are either floor(2⁶⁴/n) or ceil(2⁶⁴/n) possible products
	// in that range, depending on k.
	// But suppose we reject the sample and try again when
	// x*n is in [k*2⁶⁴, k*2⁶⁴+(2⁶⁴%n)), meaning rejecting fewer than n possible
	// outcomes out of the 2⁶⁴.
	// Now there are exactly floor(2⁶⁴/n) possible ways to produce
	// each output value k, so we've restored uniformity.