const auto single_map,
        io::ReadBinaryProto<CalibrationStatisticsMap>(
            tsl::io::JoinPath(calibration_data_dir, statistics_file)));
    statistics_map.insert(single_map.statistics().begin(),
                          single_map.statistics().end());
  }
  return statistics_map;
}

absl::Status AddCalibrationStatistics(
    mlir::ModuleOp module_op, absl::string_view calibration_data_dir,

#include "tensorflow/compiler/mlir/quantization/tensorflow/python/py_function_lib.h"

namespace stablehlo::quantization {

// Reads the calibration statistics from the given directory.
absl::StatusOr<absl::flat_hash_map<
    std::string, tensorflow::calibrator::CalibrationStatistics>>
ReadStatistics(absl::string_view calibration_data_dir);

                    bin width

    Args:
      statistics: Collected calibration statistics.
      calib_opts: Calibration options used for calculating min and max.
    """
    super().__init__(statistics, calib_opts)
    hist_stats = statistics.histogram_statistics
    self._bin_width = hist_stats.bin_width
    self._lower_bound = hist_stats.lower_bound

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

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

  collector.ClearData();
  statistics = collector.GetStatistics();
  EXPECT_FALSE(statistics.has_value());

  collector.Collect(

  TF_CHECK_OK(
      ReadBinaryProto(Env::Default(), output_file_path, &statistics_map));
  ASSERT_THAT(statistics_map.statistics(), SizeIs(2));
  ASSERT_THAT(statistics_map.statistics(), Contains(Key("1")));
  ASSERT_THAT(statistics_map.statistics(), Contains(Key("2")));

  const CalibrationStatistics& stats_1 = statistics_map.statistics().at("1");
  ASSERT_TRUE(stats_1.has_average_min_max_statistics());

    }

    private static boolean retainedFiles(Map<String, ?> result) {
        def statistics = result.statistics
        statistics.retainedRegularFiles > 0 ||
            statistics.retainedDirectories > 0 ||
            statistics.retainedMissingFiles > 0
    }

    )
    statistics = calib_stats_pb2.CalibrationStatistics()
    statistics.average_min_max_statistics.min_sum = 5.0
    statistics.average_min_max_statistics.max_sum = 50.0
    statistics.average_min_max_statistics.num_samples = 5

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

            boolean printedDetail = formatDetail(textOutput, statistics.getExecutedTasksCount(), "executed", false);
            printedDetail = formatDetail(textOutput, statistics.getFromCacheTaskCount(), "from cache", printedDetail);
            formatDetail(textOutput, statistics.getUpToDateTaskCount(), "up-to-date", printedDetail);
            textOutput.println();
        }
    }

      std::optional<CalibrationStatistics> statistics =
          collector->GetStatistics();
      if (!statistics.has_value()) continue;

      statistics_map.mutable_statistics()->emplace(id, std::move(*statistics));
    }

    if (auto status = output_file_->Append(statistics_map.SerializeAsString());
        !status.ok()) {
      LOG(ERROR) << "Failed to write calibration statistics: "
                 << status.message();

cc_library(
    name = "min_max_value",
    srcs = [],
    hdrs = ["min_max_value.h"],
    compatible_with = get_compatible_with_portable(),
    deps = [],
)

cc_library(
    name = "statistics",
    srcs = ["statistics.cc"],
    hdrs = ["statistics.h"],
    compatible_with = get_compatible_with_portable(),
    deps = [
        "//tensorflow/compiler/mlir/quantization/stablehlo:quantization_config_proto_cc",