// This field is added to distinguish between scalars and tensors of unknown
  // ranks (both of which shape is []).
  // For scalars (rank = 0), shape = [] and has_rank = true.
  // For tensors with known rank (rank > 0) and shape, shape = [...] and
  // has_rank = true.
  // For tensors with unknown rank and shape, shape = [] and has_rank = false.
  has_rank: bool = false;

  Status status;
  TF_DataType dtype = TypeParam::kDType;
  // This is our 1D tensor of varying dtype.
  std::vector<typename TypeParam::type> value = {42, 100, 0, 1, 4, 29};
  // Shape is Rank 1 vector.
  std::vector<int64_t> shape;
  shape.push_back(value.size());

  Tensor tensor = Tensor::FromBuffer(
      /*dtype=*/dtype, /*shape=*/shape,
      /*data=*/value.data(),

    if (operand.getOperandNumber() != 1) {
      return false;
    }
    Operation* user = operand.getOwner();
    if (!IsWeightOnlyQuantizableOp(*user)) {
      return false;
    }
    Method method = GetQuantizationMethodOrDefault(user);
    return HasValidWeightOnlyPtqMethod(method.weight_only_ptq(), rank);
  }

digraph cppSourcesetsCompilation {
  graph [ dpi = 100, fontname="Sans"];
  node [fontname = "Sans"];
  edge [fontname = "Sans"];
  node [shape=rectangle, fixedsize=true, width=2.6, height=0.8];

  subgraph firstLine {
    {rank=same cppCompileVariant implementation variantImplementation}
    cppCompileVariant -> includeRoot
    implementation -> includeRoot
    variantImplementation -> includeRoot

  func.return %0 : tensor<2x2xf32>
}

// -----

// Test tf.Transpose with invalid rank of y
func.func @testTranspose(tensor<2x3xf32>) -> tensor<3x2x1xf32> {
^bb0(%arg0: tensor<2x3xf32>):
  %cst = arith.constant dense<[1, 0]> : tensor<2xi32>
  // expected-error @+1 {{x should be of the same rank with y, got x of rank 2, and y of rank 3}}

  SmallVector<int64_t, 4> concat_out_shape;
  SmallVector<int64_t, 4> pack_out_shape;

  const int64_t rank = input_type.getRank();
  int64_t pack_axis = pack_op.getAxis();
  size_t count = pack_inputs.size();
  if (pack_axis < 0) {
    pack_axis += rank;
  }

  // Concat out shape.
  for (int i = 0; i < rank; ++i) {
    int64_t dim_size = input_type.getDimSize(i);
    if (i == pack_axis) {
      dim_size *= count;

  clean

  // Ensure ordering
  compileDebugSwift -> compileReleaseSwift -> clean [style=invis]
  {rank=same compileDebugSwift compileReleaseSwift clean}

  check -> assemble -> assembleDebug -> assembleRelease [style=invis]
  {rank=same check assemble assembleDebug assembleRelease}

Copyright (c) 2013-2020, Frank Schroeder

All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright notice,

```python
    # Scalar indices (output is rank(params) - 1).
    output[a_0, ..., a_n, b_0, ..., b_n] =
      params[a_0, ..., a_n, indices, b_0, ..., b_n]

    # Vector indices (output is rank(params)).
    output[a_0, ..., a_n, i, b_0, ..., b_n] =
      params[a_0, ..., a_n, indices[i], b_0, ..., b_n]

    # Higher rank indices (output is rank(params) + rank(indices) - 1).

siamo
siete
sia
siate
siano
sarò
sarai
sarà
saremo
sarete
saranno
sarei
saresti
sarebbe
saremmo
sareste
sarebbero
ero
eri
era
eravamo
eravate
erano
fui
fosti
fu
fummo
foste
furono
fossi
fosse
fossimo
fossero
essendo
faccio
fai
facciamo
fanno
faccia
facciate
facciano
farò
farai
farà