//
// Computation of the reduction axis for the Sum op depends on whether the
// input is a scalar or not. Restrict pattern to ranked inputs so that input to
// the Sum op is also ranked.

// TODO(hinsu): Support scalar inputs by introducing reshape to 1D.
def NonScalarType : Type<Neg<HasAnyRankOfPred<[0]>>, "Non scalar type">;

def LowerSoftmaxCrossEntropyWithLogitsOp : Pattern<

 */

package org.gradle.internal.snapshot.impl;

import org.gradle.internal.snapshot.ValueSnapshot;
import org.gradle.internal.snapshot.ValueSnapshotter;

/**
 * A snapshot of an immutable scalar value. Should only be used for immutable JVM provided or core Gradle types.
 *
 * @param <T> the type of the value
 */
abstract class AbstractScalarValueSnapshot<T> implements ValueSnapshot {
    private final T value;

      const Tensor& max_tensor = context->input(3 * idx + 1);
      const Tensor& histogram_tensor = context->input(3 * idx + 2);

      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());

	//
	// 1) `atomic`: the list is treated as a single entity, like a scalar.
	//      Atomic lists will be entirely replaced when updated. This extension
	//      may be used on any type of list (struct, scalar, ...).
	// 2) `set`:
	//      Sets are lists that must not have multiple items with the same value. Each
	//      value must be a scalar, an object with x-kubernetes-map-type `atomic` or an

	//
	// 1) `atomic`: the list is treated as a single entity, like a scalar.
	//      Atomic lists will be entirely replaced when updated. This extension
	//      may be used on any type of list (struct, scalar, ...).
	// 2) `set`:
	//      Sets are lists that must not have multiple items with the same value. Each
	//      value must be a scalar, an object with x-kubernetes-map-type `atomic` or an

template <typename Op>
void BuildReduceBody(Type element_type, Region* body, OpBuilder* builder) {
  OpBuilder::InsertionGuard guard(*builder);
  Block* block = builder->createBlock(body);

  // Block arguments are scalars of the given element type.
  Type type = RankedTensorType::get(/*shape=*/{}, element_type);
  Location loc = body->getLoc();
  block->addArguments({type, type}, SmallVector<Location, 2>(2, loc));

  auto reducer =

  - image: docker.io/istio/proxyv2:1.3.0
    name: istio-proxy
---
# Namespace 'revision-namespace' has istio injection enabled and label istio.io/rev=canary, so will be enforced.
apiVersion: v1
kind: Namespace
metadata:
  labels:
    istio.io/rev: canary
  name: revision-namespace
---
# Revision-details-v1-pod-old is out of date and should get a warning.
apiVersion: v1
kind: Pod
metadata:
  labels:

// Creates an 1D array const with float values.
class Create1DConst<string values> : NativeCodeCall<
  "Create1DConstValue<float>($_builder, $_loc, "# values #")">;

// Creates a scalar const with float value.
class CreateScalarConst<string value> : NativeCodeCall<
  "CreateScalarConstValue<float>($_builder, $_loc, "# value #")">;

// Creates an 1D array const with integer values.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is an optimization check. We want to make sure that we compare
// string lengths, and other scalar fields, before checking string
// contents.  There's no way to verify this in the language, and
// codegen tests in test/codegen can't really detect ordering
// optimizations like this. Instead, we generate invalid strings with

            failure.assertThatCause(containsNormalizedString("Incompatible because this component declares attribute 'quality' with value 'qa' and the consumer needed attribute 'quality' with value '$requested'"))
        }

        where:
        requested | outcome
        'qa'      | 'succeeds'
        'canary'  | 'fails'
    }