}

TEST(CalibrationParametersTest, CalculateBinIndex) {
  int32_t bin_index = CalculateBinIndexSafe(/*value=*/3.0, /*lower_bound=*/0.0,
                                            /*bin_width=*/2.0, /*num_bins=*/2);
  EXPECT_EQ(bin_index, 1);
}

TEST(CalibrationParametersTest, CalculateBinIndexMaxValue) {
  int32_t bin_index = CalculateBinIndexSafe(/*value=*/4.0, /*lower_bound=*/0.0,

#include "tensorflow/core/framework/tensor.h"
#include "tensorflow/core/framework/types.h"
#include "tsl/platform/errors.h"

namespace tensorflow {
namespace {

using ::stablehlo::quantization::CalculateBinIndexSafe;
using ::stablehlo::quantization::CalculateBinWidth;
using ::stablehlo::quantization::CalculateLowerBound;
using ::stablehlo::quantization::CalibrationOptions;
using CPUDevice = ::Eigen::ThreadPoolDevice;

                                 const float bin_width) {
  return std::floor((value - lower_bound) / bin_width);
}

// Same as `CalculateBinIndex` but clamps to avoid out-of-bound.
inline int32_t CalculateBinIndexSafe(const float value, const float lower_bound,
                                     const float bin_width,
                                     const int32_t num_bins) {