*
     * @param dataset the dataset to do the calculation on, which must be non-empty, which will be
     *     cast to doubles (with any associated lost of precision), and which will not be mutated by
     *     this call (it is copied instead)
     * @return the quantile value
     */
    public double compute(Collection<? extends Number> dataset) {
      return computeInPlace(Doubles.toArray(dataset));
    }

/**
 * A set of managed model objects.
 * <p>
 * {@link org.gradle.model.Managed} types may declare managed set properties.
 * Managed sets can only contain managed types.
 * <p>
 * Managed set objects cannot be mutated via the mutative methods of the {@link java.util.Set} interface (e.g. {@link java.util.Set#add(Object)}, {@link java.util.Set#clear()}).
 * To add elements to the set, the {@link #create(Action)} method can be used.
 *

    @Override
    ImmutableAttributes getAttributes();

    ImmutableCapabilities getCapabilities();

    VariantGraphResolveMetadata getMetadata();

    /**
     * Does this instance represent some temporary or mutated view of the variant?
     *
     * See {@link ComponentGraphResolveState#isAdHoc()} for a definition of "ad hoc".
     */
    boolean isAdHoc();

    /**
     * Returns the public view for this variant.
     */

	if len(errs) == 0 {
		t.Errorf("Expected error from update validation for ipAddress, got none")
	}
	if invalidIPAddress.ResourceVersion != "4" {
		t.Errorf("Incoming resource version on update should not be mutated")
	}

     *
     * @param dataset the dataset to do the calculation on, which must be non-empty, which will be
     *     cast to doubles (with any associated lost of precision), and which will not be mutated by
     *     this call (it is copied instead)
     * @return the quantile value
     */
    public double compute(Collection<? extends Number> dataset) {
      return computeInPlace(Doubles.toArray(dataset));
    }

	walker := schemamutation.Walker{
		SchemaCallback: func(schema *spec.Schema) *spec.Schema {
			orig := schema
			clone := func() {
				if orig == schema { // if schema has not been mutated yet
					schema = new(spec.Schema)
					*schema = *orig // make a clone from orig to schema
				}
			}
			if headerIndex := strings.Index(schema.Description, enumTypeDescriptionHeader); headerIndex != -1 {

import org.gradle.internal.hash.HashCode;

import javax.annotation.Nullable;
import java.util.function.Function;

/**
 * A simplified scope that provides only a single local classpath and no exports, and that cannot be mutated.
 */
public class ImmutableClassLoaderScope extends AbstractClassLoaderScope {
    private final ClassLoaderScope parent;
    private final ClassPath classPath;
    @Nullable

  // thread safety analysis. Instead we use a boolean flag and release the lock
  // in the VariableInfo destructor.
  bool lock_held_ = false;
  bool shared_lock_held_ = false;

  // Whether this variable is going to be mutated. Left false if the caller
  // doesn't provide this information.
  bool read_only_ = false;
};

}  // namespace tensorflow

        writer.println(" is invalid due to incompatible types.");
        writer.print("This element was created by ");
        writer.print(creator);
        writer.print(" and can be ");
        writer.print(writable ? "mutated" : "read");
        writer.println(" as the following types:");
        boolean first = true;
        for (String candidateType : candidateTypes) {
            if (!first) {
                writer.println();
            }

  // Prints MLIR after specified passes. Supports regular expressions for
  // matching against the names of the desired passes. Currently only prints
  // after a pass if the MLIR is mutated.
  optional string print_ir_after = 6 [default = ""];

  // If true, always print the top-level operation when printing IR for
  // print_ir_[before|after].
  optional bool print_ir_module_scope = 7 [default = true];