BigDecimal sumSquares = BigDecimal.ZERO;
        Units<Q> baseUnits = average.getUnits().getBaseUnits();
        BigDecimal averageValue = average.toUnits(baseUnits).getValue();
        for (Amount<Q> amount : this) {
            BigDecimal diff = amount.toUnits(baseUnits).getValue();
            diff = diff.subtract(averageValue);
            diff = diff.multiply(diff);
            sumSquares = sumSquares.add(diff);
        }

    def "rule can create a map of model elements"() {
        when:
        buildScript '''
            @Managed
            interface Thing extends Named {
              void setValue(String value)
              String getValue()
            }

            @Managed
            interface Container {
              ModelMap<Thing> getThings();
            }

            class Rules extends RuleSource {

              @Model

    if (ceilingEntry != null
        && ceilingEntry.getValue().isConnected(range)
        && !ceilingEntry.getValue().intersection(range).isEmpty()) {
      return true;
    }
    Entry<Cut<C>, Range<C>> priorEntry = rangesByLowerBound.lowerEntry(range.lowerBound);
    return priorEntry != null
        && priorEntry.getValue().isConnected(range)
        && !priorEntry.getValue().intersection(range).isEmpty();
  }

  @Override

                return transformer.apply(ResolutionResultProvider.this.getTaskDependencyValue());
            }

            @Override
            public E getValue() {
                return transformer.apply(ResolutionResultProvider.this.getValue());
            }
        };
    }

    }

    public static Number getDifferenceRatio(DataSeries<Duration> baselineVersion, DataSeries<Duration> currentVersion) {
        double base = baselineVersion.getMedian().getValue().doubleValue();
        double current = currentVersion.getMedian().getValue().doubleValue();
        return (current - base) / base;
    }

      @Override
      @ParametricNullness
      V transform(Cell<R, C, V> cell) {
        return cell.getValue();
      }
    };
  }

  Spliterator<V> valuesSpliterator() {
    return CollectSpliterators.map(cellSpliterator(), Table.Cell::getValue);
  }

  @WeakOuter
  class Values extends AbstractCollection<V> {
    @Override
    public Iterator<V> iterator() {

  if (!padding) {
    return func_.emitWarning() << "'padding' attribute for " << kMaxUnpooling
                               << " is not set or not a string";
  }
  if (padding.getValue() != "VALID" && padding.getValue() != "SAME") {
    return func_.emitWarning()
           << "Padding for " << kMaxUnpooling << " must be 'SAME' or 'VALID'";
  }
  return success();
}

void MoveFuncOp(FlatSymbolRefAttr &symbol_ref, SymbolTable &from,
                SymbolTable &to) {
  if (to.lookup<func::FuncOp>(symbol_ref.getValue())) return;
  func::FuncOp callee = from.lookup<func::FuncOp>(symbol_ref.getValue());
  callee.getOperation()->getBlock()->getOperations().remove(
      callee.getOperation());
  to.insert(callee);
}

void TPUBridgeExecutorIslandOutlining::runOnOperation() {

      const TF::ResourceDataflowState *latticeElement =
          solver.lookupState<TF::ResourceDataflowState>(val);
      if (!latticeElement || latticeElement->getValue().ops.size() != 1)
        continue;

      // Don't freeze mutable tensors.
      Operation *op = *latticeElement->getValue().ops.begin();
      GlobalTensorOp globalTensor = llvm::dyn_cast<GlobalTensorOp>(op);

      if (!globalTensor)

import spock.lang.Specification

class ParsedCommandLineOptionSpec extends Specification {

    final option = new ParsedCommandLineOption();

    def "reports no value"() {
        when:
        option.getValue()

        then:
        thrown(IllegalStateException)
        !option.hasValue()
    }

    def "reports single value"() {
        when:
        option.addArgument("foo")

        then: