Helper method to get the minimum of all values (must be numbers)

@param slaveValues
@return
18700
protected static Number minimum(List<?> slaveValues) {
        Number min = null;
        for (Object slaveValue : slaveValues) {
            if (min == null) {
                min = (Number) slaveValue;
            } else {
                Comparable<Object> comparable = NumberComparator.getComparable(min);
                if (comparable.compareTo(slaveValue) > 0) {
                    min = (Number) slaveValue;
                }
            }
        }
        return min;
    }
792945
public static BigRational min(BigRational... values) {
		if (values.length == 0) {
			return BigRational.ZERO;
		}
		BigRational result = values[0];
		for (int i = 1; i < values.length; i++) {
			result = result.min(values[i]);
		}
		return result;
	}
1076746
public static long minimum(long... values)
    {
        int len = values.length;
        long current = values[0];

        for (int i=1; i < len; i++)
        {
            current = Math.min(values[i], current);
        }

        return current;
    }
1329269
public java.util.List<? extends org.tensorflow.framework.Summary.ValueOrBuilder> 
      getValueOrBuilderList() {
    return value_;
  }
350120
@Pure
	public static double min(double... values) {
		if (values == null || values.length == 0) {
			return Double.NaN;
		}
		double min = values[0];
		for (final double v : values) {
			if (v < min) {
				min = v;
			}
		}
		return min;
	}
690272
public T getMinimum() {
        Lock lock = this.lock.readLock();
        lock.lock();
        try {
            return this.minimum != null ? this.minimum : (T)this.math.createZeroValue();
        } finally {
            lock.unlock();
        }
    }
769412
protected static Integer sumAsInteger(final List<?> slaveValues) {
        int sum = 0;
        for (final Object slaveValue : slaveValues) {
            final Number value = (Number) slaveValue;
            if (value != null) {
                sum += value.intValue();
            }
        }
        return sum;
    }
1060829
public static int min(int[] values)
    {
        int min = Integer.MAX_VALUE;

        for (int i = 0; i < values.length; ++i)
        {
            if (values[i] < min)
            {
                min = values[i];
            }
        }

        return min;
    }
1206268
public static <T extends Comparable<T>> T minOr(Collection<T> values, T defaultVal) {
    if (values.isEmpty()) {
      return defaultVal;
    } else {
      return Collections.min(values);
    }
  }
713013
public int getMinimumNumberOfInstances(final InstanceType instanceType) {

		final Integer val = this.minimumMap.get(instanceType);
		if (val != null) {
			return val.intValue();
		}

		return 0;
	}
76983
public com.google.api.ads.adwords.axis.v201809.cm.ComparableValue getMin() {
        return min;
    }
283210
public static String min(String... values) {
        BigDecimal bd;
        BigDecimal bd2;
        try {
            int start = 0;
            while (values[start] == null) {
                start++;
            }
            bd = new BigDecimal(values[start]);
            for (int i = start + 1; i < values.length; i++) {
                if (values[i] == null) {
                    continue;
                }
                bd2 = new BigDecimal(values[i]);
                if (bd.compareTo(bd2) > 0) {
                    bd = bd2;
                }
            }
            return bd.toString();
        } catch (Exception e) {
            return null;
        }
    }
724004
public BoundedAssertion getMin()
    {
    ICondition min = null;
    Iterator<ICondition> conditions = getConditions();
    for( int i = 0; i < 1; i++) min = conditions.next();
    return (BoundedAssertion) min;
    }
68344
public static Constraint min(final Number min) {
		return new Constraint("min", minPayload(min)) {
			public boolean isValid(Object actualValue) {
				return actualValue == null || (actualValue instanceof Number && min != null &&
						min.longValue() <= ((Number) actualValue).longValue());
			}
		};
	}
736804
public static PactDslJsonArray arrayMinLike(int minSize, int numberExamples, PactDslJsonRootValue value) {
    if (numberExamples < minSize) {
      throw new IllegalArgumentException(String.format("Number of example %d is less than the minimum size of %d",
        numberExamples, minSize));
    }
    PactDslJsonArray parent = new PactDslJsonArray("", "", null, true);
    parent.setNumberExamples(numberExamples);
    parent.matchers.addRule("", parent.matchMin(minSize));
    parent.putObject(value);
    return parent;
  }
454945
public T min() {
        TObjectIntIterator<T> iter = counts.iterator();
        int minCount = Integer.MAX_VALUE;
        T min = null;
        while (iter.hasNext()) {
            iter.advance();
            int count = iter.value();
            if (count < minCount) {
                min = iter.key();
                minCount = count;
            }
        }
        return min;
    }
446914
public java.util.List<MinimumEngineVersionPerAllowedValue> getMinimumEngineVersionPerAllowedValue() {
        if (minimumEngineVersionPerAllowedValue == null) {
            minimumEngineVersionPerAllowedValue = new com.amazonaws.internal.SdkInternalList<MinimumEngineVersionPerAllowedValue>();
        }
        return minimumEngineVersionPerAllowedValue;
    }