namespace {

// Calculates the number of bins from the range and bin width.
inline int32_t CalculateActualNumBins(const float min_value,
                                      const float max_value,
                                      const float bin_width) {
  const float lower_bound = CalculateLowerBound(min_value, bin_width);
  return std::ceil((max_value - lower_bound) / bin_width);
}

namespace mlir {
namespace TFL {

template <class TFFakeQuantOp>
struct FetchMinMaxAttrs {
  using AttrType = FloatAttr;
  bool operator()(TFFakeQuantOp tf_op, AttrType &min_value,
                  AttrType &max_value) const {
    min_value = tf_op.getMinAttr();
    max_value = tf_op.getMaxAttr();
    return true;  // Successfully matched and fetched.
  }
};

template <class TFFakeQuantOp>

namespace mlir {
namespace quant {

template <class TFFakeQuantOp>
struct FetchMinMaxAttrs {
  using AttrType = FloatAttr;
  bool operator()(TFFakeQuantOp tf_op, AttrType &min_value,
                  AttrType &max_value) const {
    min_value = tf_op.getMinAttr();
    max_value = tf_op.getMaxAttr();
    return true;  // Successfully matched and fetched.
  }
};

template <class TFFakeQuantOp>

                                                     &histogram_output));
    if (num_bins > 0) {
      const float min_value = min_output->scalar<float>()();
      const float max_value = max_output->scalar<float>()();
      CalculateHistogramStatistics(context, input_tensor, min_value, max_value,
                                   num_bins, histogram_output);
    }
  }

 private:
  std::string id_;

// number of bins might be smaller than the given `num_bins`.
inline float CalculateBinWidth(const float min_value, const float max_value,
                               const int32_t num_bins) {
  const float raw_bin_width = (max_value - min_value) / num_bins;
  return std::pow(2, std::ceil(std::log2(raw_bin_width)));
}

// Calculates the lower bound of the histogram. The lower bound is in form of

  private static final double[] VALUES = {
    Double.NEGATIVE_INFINITY,
    -Double.MAX_VALUE,
    (double) Long.MIN_VALUE,
    (double) Integer.MIN_VALUE,
    -Math.PI,
    -1.0,
    -Double.MIN_VALUE,
    -0.0,
    +0.0,
    Double.MIN_VALUE,
    1.0,
    Math.PI,
    (double) Integer.MAX_VALUE,
    (double) Long.MAX_VALUE,
    Double.MAX_VALUE,
    Double.POSITIVE_INFINITY,

      status = absl::InternalError(
          "Cannot find min/max values for calibration statistics.");
      return;
    }

    const auto [min_value, max_value] = *min_max_values;
    mlir::OpBuilder builder(aggregator_op);
    aggregator_op->setAttr("min", builder.getF32FloatAttr(min_value));
    aggregator_op->setAttr("max", builder.getF32FloatAttr(max_value));
  });
  return status;
}

      const float min_value = min_tensor.scalar<float>()();
      const float max_value = max_tensor.scalar<float>()();
      auto histogram_flat = histogram_tensor.flat<int64_t>();
      absl::Span<const int64_t> histogram_data =
          absl::MakeSpan(histogram_flat.data(), histogram_flat.size());
      id_to_collector_[ids_[idx]]->Collect(min_value, max_value,

    // a special case that there are tf.Identity ops between the min/max
    // constants and the tf.FakeQuantWithMinMaxVarsOp.
    Value min = tf_op.getMin(), max = tf_op.getMax();
    DenseFPElementsAttr min_value, max_value;
    if (auto id1 = dyn_cast_or_null<TF::IdentityOp>(min.getDefiningOp())) {
      id1.replaceAllUsesWith(id1.getInput());
      min = tf_op.getMin();
      rewriter.eraseOp(id1);
    }