public int compareTo(Units<Q> o) {
            if (o == this) {
                return 0;
            }
            if (o.getType() != getType()) {
                throw new IllegalArgumentException(String.format("Cannot compare units of %s with units of %s.", getType(), o.getType()));
            }
            return -1;
        }

        public void add(ScaledUnits<Q> units) {
            this.units.add(units);

  "static_cast<int32_t>($0.getType().cast<RankedTensorType>().getDimSize(  "
  "  $0.getType().cast<RankedTensorType>().getRank() - 1)))">;

// Check whether the tensor is ranked and whether its last dim is static.
def IsRankedShapeLastDimStatic : Constraint<And<[
  CPred<"$0.getType().isa<RankedTensorType>()">,
  CPred<"!$0.getType().cast<ShapedType>().isDynamicDim( "
  "  $0.getType().cast<RankedTensorType>().getRank() - 1)">]>>;

      Operation* load = builder.create<mlir::ml_program::GlobalLoadOp>(
          op.getLoc(), globalOp.getType(),
          SymbolRefAttr::get(op->getContext(), globalOp.getSymName()));
      if (globalOp.getType() != op.getValue().getType()) {
        load = builder.create<TF::CastOp>(op.getLoc(), op.getValue().getType(),
                                          load->getResult(0));
      }

  "TFL::IsTransposeTrivial($0.getType().cast<ShapedType>().getShape(), $1)">>;

// Constraint that checks if the reshape op is equivalent to a transpose op.
// This is true if the reshape op is a trivial reshape op, meaning no change in
// the order of non-identity dimensions.
def IsReshapeEquivalentToTranspose : Constraint<CPred<
  "TFL::IsReshapeEquivalentToTranspose("
    "$0.getType().cast<ShapedType>(),"

  if ((op->getNumOperands() != 2 && op->getNumOperands() != 3) ||
      op->getResultTypes().size() != 1) {
    return false;
  }
  Type lhs_type = op->getOperand(0).getType();
  Type rhs_type = op->getOperand(1).getType();
  Type result_type = op->getResult(0).getType();
  return !IsQuantizedTensorType(lhs_type) && IsQuantizedTensorType(rhs_type) &&
         !IsQuantizedTensorType(result_type);
}

      return;
    }
    auto element_type = splat_elements_attr.getType().getElementType();
    if (!(element_type.isF32() || element_type.isF16() ||
          element_type.isInteger(1) || element_type.isInteger(32) ||
          element_type.isInteger(64))) {
      return;
    }
    if (splat_elements_attr.getNumElements() *
            splat_elements_attr.getType().getElementTypeBitWidth() <
        kConstantSizeThresholdInBits) {

  CPred<"$0.getType() == $1.getType()">>;

// Checks if the given two values are the same.
def AreTheSameValue : Constraint<
  CPred<"$0 == $1">>;

// Checks if the value has rank.
def HasRank : Constraint<
  CPred<"$0.getType().cast<ShapedType>().hasRank()">>;

// Checks if the value has rank of `n`.
class HasRankOf<int n> : Constraint<
  CPred<"$0.getType().cast<ShapedType>().hasRank() && "

        return InstanceModelView.of(modelNode.getPath(), getType(), instance);
    }

    @Override
    public Optional<String> getValueDescription(MutableModelNode modelNode) {
        Object instance = this.asImmutable(ModelType.untyped(), modelNode, null).getInstance();
        if (instance == null) {
            if (isPrimitiveType(getType())) {
                if (getType().equals(ModelType.of(char.class))) {

        return new ModelView<M>() {
            private final Map<String, Object> propertyViews = new HashMap<String, Object>();

            @Override
            public ModelPath getPath() {
                return modelNode.getPath();
            }

            @Override
            public ModelType<M> getType() {

        ModelType<?> type = reference.getType();
        return "{type: " + (type == null ? null : type.getDisplayName()) + ", path: " + getPath() + ", scope: " + getScope() + ", state: " + getState() + "}";
    }

    @Nullable
    @Override
    public ModelPath getPath() {
        return reference.getPath();
    }

    public ModelType<?> getType() {
        return reference.getType();
    }