}

  tensorflow::shape_inference::ShapeHandle shape = ic->output(output.index);

  int rank = -1;
  if (ic->RankKnown(shape)) {
    rank = ic->Rank(shape);
  }

  if (num_dims != rank) {
    status->status = InvalidArgument("Expected rank is ", num_dims,
                                     " but actual rank is ", rank);
    return;
  }

  if (num_dims == 0) {
    // Output shape is a scalar.

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.rank.fusion;

import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

import org.apache.lucene.search.TotalHits.Relation;
import org.codelibs.fess.entity.FacetInfo;

    /** The key of the configuration. e.g. 200 */
    String RANK_FUSION_window_size = "rank.fusion.window_size";

    /** The key of the configuration. e.g. 20 */
    String RANK_FUSION_rank_constant = "rank.fusion.rank_constant";

    /** The key of the configuration. e.g. -1 */
    String RANK_FUSION_THREADS = "rank.fusion.threads";

    /** The key of the configuration. e.g. rf_score */

        as `tf.tpu.experimental.embedding.serving_embedding_lookup` which can
        take arbitrary rank of dense and sparse tensor. For ragged tensor,
        though the input tensor remains to be rank 2, the activations now can be
        rank 2 or above by specifying the output shape in the feature config or
        via the build method.

*   Add

    TF_RETURN_IF_ERROR(
        operation->SetOpName(absl::StrCat("_input_", inputs_.size()).c_str()));
    TF_RETURN_IF_ERROR(operation->SetAttrType("dtype", dtype));
    if (!shape.unknown_rank()) {
      TF_RETURN_IF_ERROR(operation->SetAttrShape(
          "shape", reinterpret_cast<int64_t*>(shape.dim_sizes().data()),
          shape.dims()));
    }
    int num_outputs = 1;

// required except where indicated.
typedef struct TFE_CustomDeviceTensorHandleMethods {
  int version = TFE_CUSTOM_DEVICE_VERSION;

  // Computes the rank of the tensor handle.
  //
  // Shapes are specified via callbacks because retrieving the shape of a tensor
  // is a blocking operation for async eager; custom devices should avoid

  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);
  EXPECT_EQ(dims[0], returned_dims[0]);
  EXPECT_EQ(dims[1], returned_dims[1]);

  // Try to set 'unknown' with unknown rank on the shape and see that
  // it doesn't change.
  TF_GraphSetTensorShape(graph, feed_out_0, /*dims=*/nullptr, -1, s);
  EXPECT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

                        static_cast<TF_DataType>(default_value.type()));
      break;
    case tensorflow::AttrValue::kShape: {
      const auto& tensor_shape = default_value.shape();
      if (tensor_shape.unknown_rank()) {
        TFE_OpSetAttrShape(op, attr_name, nullptr, -1, status);
      } else {
        const auto num_dims = tensor_shape.dim_size();
        std::unique_ptr<int64_t[]> dims(new int64_t[num_dims]);

					<groupId>org.opensearch.plugin</groupId>
					<artifactId>aggs-matrix-stats-client</artifactId>
				</exclusion>
				<exclusion>
					<groupId>org.opensearch.plugin</groupId>
					<artifactId>rank-eval-client</artifactId>
				</exclusion>
				<exclusion>
					<groupId>org.opensearch.plugin</groupId>
					<artifactId>lang-expression</artifactId>
				</exclusion>
				<exclusion>