min_max_statistics_.set_global_max(
      std::max(min_max_statistics_.global_max(), max));
}

std::optional<CalibrationStatistics>
CalibrationStatisticsCollectorMinMax::GetStatistics() const {
  if (min_max_statistics_.global_min() == std::numeric_limits<float>::max())
    return std::nullopt;

  CalibrationStatistics statistics;
  statistics.mutable_min_max_statistics()->CopyFrom(min_max_statistics_);

  return statistics;
}

  collector.Collect(
      /*min=*/1.0f, /*max=*/10.f, /*histogram=*/{});
  collector.Collect(
      /*min=*/-5.0f, /*max=*/5.f, /*histogram=*/{});

  std::optional<CalibrationStatistics> statistics = collector.GetStatistics();

  EXPECT_TRUE(statistics.has_value());
  EXPECT_EQ(statistics.value().min_max_statistics().global_min(), -5.0f);

  const CalibrationStatistics& stats_1 = statistics_map.statistics().at("1");
  ASSERT_TRUE(stats_1.has_average_min_max_statistics());
  EXPECT_FLOAT_EQ(stats_1.average_min_max_statistics().min_sum(), 1.f);
  EXPECT_FLOAT_EQ(stats_1.average_min_max_statistics().max_sum(), 5.f);
  EXPECT_EQ(stats_1.average_min_max_statistics().num_samples(), 1);

  const CalibrationStatistics& stats_2 = statistics_map.statistics().at("2");

  average_min_max_statistics_.set_num_samples(current_num_samples + 1);
}

std::optional<CalibrationStatistics>
CalibrationStatisticsCollectorAverageMinMax::GetStatistics() const {
  if (average_min_max_statistics_.num_samples() == 0) return std::nullopt;

  CalibrationStatistics statistics;
  statistics.mutable_average_min_max_statistics()->CopyFrom(
      average_min_max_statistics_);

syntax = "proto3";

package tensorflow.calibrator;

option cc_enable_arenas = true;

// Calibration algorithm's collecting statistics.
// NEXT_ID: 4
message CalibrationStatistics {
  message MinMaxStatistics {
    // global minimum of all sample datasets.
    float global_min = 1;

    // global maximum of all sample datasets.
    float global_max = 2;
  }

  message AverageMinMaxStatistics {

  void ClearData() override;

  void Collect(float min, float max,
               absl::Span<const int64_t> histogram) override;

  std::optional<CalibrationStatistics> GetStatistics() const override;

 private:
  CalibrationStatistics::AverageMinMaxStatistics average_min_max_statistics_;
};
}  // namespace calibrator
}  // namespace tensorflow

                                           range_start + bin_width_);
  }
}

std::optional<CalibrationStatistics>
CalibrationStatisticsCollectorHistogram::GetStatistics() const {
  if (hist_freq_.empty()) return std::nullopt;

  CalibrationStatistics::HistogramStatistics hist_stats;

  // Skip trailing zeros in the histogram.
  int32_t real_size = hist_freq_.size();

  def test_min_max_max(self):
    calib_opts = stablehlo_quant_config_pb2.CalibrationOptions(
        calibration_method=_CalibrationMethod.CALIBRATION_METHOD_MIN_MAX
    )
    statistics = calib_stats_pb2.CalibrationStatistics()
    statistics.min_max_statistics.global_min = 1.0
    statistics.min_max_statistics.global_max = 5.0

    min_value, max_value = calibration_algorithm.get_min_max_value(
        statistics, calib_opts
    )

  void ClearData() override;

  void Collect(float min, float max,
               absl::Span<const int64_t> histogram) override;

  std::optional<CalibrationStatistics> GetStatistics() const override;

 private:
  CalibrationStatistics::MinMaxStatistics min_max_statistics_;
};

}  // namespace calibrator
}  // namespace tensorflow

namespace {

using ::stablehlo::quantization::CalibrationOptions;
using ::tensorflow::calibrator::CalibrationStatistics;
using ::tensorflow::calibrator::CalibrationStatisticsMap;
using ::tensorflow::quantization::PyFunctionLibrary;
using CalibrationStatisticsFlatMap =
    absl::flat_hash_map<std::string, CalibrationStatistics>;

}  // namespace

// Reads the calibration statistics from the given directory.