static_cast<double>(uniform_type.getStorageTypeMax()),
            uniform_type.getStorageTypeIntegralWidth(),
            uniform_type.isSigned()) {
    assert(isa<FloatType>(uniform_type.getExpressedType()));
    assert(uniform_type.getStorageType().isSignlessInteger());
  }

  UniformQuantizedValueConverter(double scale, double zero_point,

        cost = target_hardware->GetOpCost(op);
      }

      mlir::StringAttr device_identifier =
          mlir::StringAttr::get(module.getContext(), device);
      auto float_type = mlir::FloatType::getF32(module.getContext());
      auto float_attr =
          mlir::FloatAttr::get(float_type, static_cast<float>(cost));
      device_costs.push_back({device_identifier, float_attr});
    }

#include "mlir/IR/Types.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project

namespace mlir::quantfork {

static bool isQuantizablePrimitiveType(Type input_type) {
  return isa<FloatType>(input_type);
}

ExpressedToQuantizedConverter ExpressedToQuantizedConverter::forInputType(
    Type input_type) {
  if (isa<TensorType, VectorType>(input_type)) {

      {2, 2}, quant::UniformQuantizedType::get(
                  quant::QuantizationFlags::FlagValue::Signed,
                  IntegerType::get(context.get(), 8),
                  FloatType::getF32(context.get()), 3.0, 2, -128, 127));

  auto dense_attr =
      GetDenseAttrFromTensorProtoAttr(GetQint8Tensor(), result_tensor_type);

  ASSERT_TRUE(succeeded(dense_attr));

  // Use the final state to set all the operands' parameters.
  for (int i = 0, e = op->getNumOperands(); i != e; ++i) {
    auto ele = op->getOperand(i).getType().cast<ShapedType>().getElementType();
    if (ele.isa<FloatType>() && SetOperandParams(op, i, params)) {
      *changed |= true;
      new_items->push_back(op->getOperand(i).getDefiningOp());
    }
  }

  // Use the final state to set all the results' parameters.

  return success();
}

static LogicalResult FoldDivOp(stablehlo::DivOp op, PatternRewriter& rewriter) {
  auto etype = op.getType().getElementType();
  if (etype.isa<FloatType>()) {
    return FoldDivOpInternal<APFloat>(op, rewriter);
  }
  if (etype.isa<IntegerType>()) {
    return FoldDivOpInternal<APInt>(op, rewriter);
  }
  return failure();
}
}  // namespace

// Returns true if the given `value` is of ranked float tensor type with the
// given `rank`.
inline bool IsOfRankedFloatTensorType(RankedTensorType type, int rank) {
  return type && type.getRank() == rank &&
         mlir::isa<FloatType>(type.getElementType());
}

// Returns true if the given `value` has the specified rank or has unranked
// type.
inline bool IsOfRankOrUnranked(Value value, int64_t rank) {

    // as the reduction.
    Value iota = reduce_op.getInputs().back();
    if (!MatchIota(reduce_op.getDimensions(), iota)) return failure();

    // Match the reduction computation.
    const bool is_float = mlir::isa<FloatType>(operand_init.getElementType());
    if (failed(MatchReduceToArgMinMaxType1(reduce_op, is_float, is_argmax)) &&
        failed(MatchReduceToArgMinMaxType2(reduce_op, is_argmax)))
      return rewriter.notifyMatchFailure(

#include "tensorflow/core/platform/test.h"

namespace {

using tensorflow::experimental::cc::Status;
using tensorflow::experimental::cc::Tensor;

using SimpleTypes = ::testing::Types<
    tensorflow::FloatType, tensorflow::DoubleType, tensorflow::Int32Type,
    tensorflow::UINT8Type, tensorflow::INT8Type, tensorflow::INT64Type,
    tensorflow::UINT16Type, tensorflow::UINT32Type, tensorflow::UINT64Type>;

template <typename T>

       std::is_same<OpT, RealDivOp>::value)
          ? 1
          : 0;

  Type element_ty = lhs_type.getElementType();
  Attribute identity_attr;
  if (auto ty = mlir::dyn_cast<FloatType>(element_ty)) {
    identity_attr = FloatAttr::get(ty, static_cast<double>(identity));
  } else if (auto ty = mlir::dyn_cast<IntegerType>(element_ty)) {
    identity_attr = IntegerAttr::get(ty, static_cast<int64_t>(identity));