This is equivalent to
<code>complement(MIN_VALUE, MAX_VALUE)</code>.
340877
public UnicodeSet complement() {
        checkFrozen();
        if (list[0] == LOW) {
            System.arraycopy(list, 1, list, 0, len-1);
            --len;
        } else {
            ensureCapacity(len+1);
            System.arraycopy(list, 0, list, 1, len);
            list[0] = LOW;
            ++len;
        }
        pat = null;
        return this;
    }
58059
public static <T extends Comparable<T>> ExtraConstraint<T>
                min(T minVal) {
        return min(minVal, true);
    }
1285221
def __clip(val, minimum, maximum):
        
        if val is None or minimum is None or maximum is None:
            return None
        if val < minimum:
            return minimum
        if val > maximum:
            return maximum
        return val
674893
public static List<ByteBuffer> minComponents(List<ByteBuffer> minSeen, Composite candidate, CellNameType comparator)
    {
        // For a cell name, no reason to look more than the clustering prefix
        // (and comparing the collection element would actually crash)
        int size = Math.min(candidate.size(), comparator.clusteringPrefixSize());

        if (minSeen.isEmpty())
            return getComponents(candidate, size);

        // In most case maxSeen is big enough to hold the result so update it in place in those cases
        minSeen = maybeGrow(minSeen, size);

        for (int i = 0; i < size; i++)
            minSeen.set(i, min(minSeen.get(i), candidate.get(i), comparator.subtype(i)));

        return minSeen;
    }
135121
def minValue(self, value):
        """"""
        if isinstance(value, [int, float, long]):
            self._rangeMin = value
37975
public static int bound (int low, int value, int high)
    {
        return Math.min(high, Math.max(low, value));
    }
40227
function (value, min, max) {
            var interval;
            if (min > max) {
                max = min + max;
                min = max - min;
                max = max - min;
            }
            interval = max - min;
            return min + ((value % interval) + interval) % interval;
        }
254953
public MinMax<C> combine(final MinMax<C> other) {
		_min = min(_comparator, _min, other._min);
		_max = max(_comparator, _max, other._max);
		_count += other._count;

		return this;
	}
586877
public static <E extends Comparable<E>> E minimum(Iterator<E> iterator, E init) {
        return Reductions.reduce(iterator, BinaryOperator.minBy(new ComparableComparator<E>()), init);
    }
1208270
public static int random(int min, int max) {
        if (min < 0 || max < 0) {
            throw new RuntimeException(
                    "illegal argment, min and max must great then zero.");
        }
        if (min > max) {
            int t = max;
            max = min;
            min = t;
        } else if (min == max) {
            return min;
        }

        Random random = new Random();
        return random.nextInt(max) % (max - min + 1) + min;

    }
561048
public static <T, U> Collector<T, ?, Optional<T>> minBy(Function<? super T, ? extends U> function, Comparator<? super U> comparator) {
        return maxBy(function, comparator.reversed());
    }
729830
def min=(m)
      m = m.to_i
      raise ArgumentError.new("Minimum value must be greater than 0 and less than or equal to maximum (#{max})") unless m > 0 && m <= max
      @min_threads = m
      m
    end
109635
private float MIN(float first, float second, float third) {

        float min = Integer.MAX_VALUE;
        if (first < min) {
            min = first;
        }
        if (second < min) {
            min = second;
        }
        if (third < min) {
            min = third;
        }
        return min;
    }
406988
public List<Interval<T>> complement(final Interval<T> op) throws MIDDException {

        final boolean disJoined = (this.lowerBound.compareTo(op.upperBound) >= 0) ||
                (this.upperBound.compareTo(op.lowerBound) <= 0);

        if (disJoined) {
            Interval<T> newInterval = new Interval<>(this.lowerBound, this.upperBound);

            final boolean isLowerClosed;
            if (this.lowerBound.compareTo(op.upperBound) == 0) {
                isLowerClosed = this.lowerBoundClosed && !op.upperBoundClosed;
            } else {
                isLowerClosed = this.lowerBoundClosed;
            }
            newInterval.closeLeft(isLowerClosed);

            final boolean isUpperClosed;
            if (this.upperBound.compareTo(op.lowerBound) == 0) {
                isUpperClosed = this.upperBoundClosed && !op.upperBoundClosed;
            } else {
                isUpperClosed = this.upperBoundClosed;
            }
            newInterval.closeRight(isUpperClosed);

            // return empty if new interval is invalid
            if (!newInterval.validate()) {
                return ImmutableList.of();
            }
            return ImmutableList.of(newInterval);
        } else {
            final Interval<T> interval1 = new Interval<>(this.lowerBound, op.lowerBound);
            final Interval<T> interval2 = new Interval<>(op.upperBound, this.upperBound);

            interval1.closeLeft(!interval1.isLowerInfinite() && this.lowerBoundClosed);
            interval1.closeRight(!interval1.isUpperInfinite() && !op.lowerBoundClosed);

            interval2.closeLeft(!interval2.isLowerInfinite() && !op.upperBoundClosed);
            interval2.closeRight(!interval2.isUpperInfinite() && this.upperBoundClosed);

            final List<Interval<T>> result = new ArrayList<>();
            if (interval1.validate()) {
                result.add(interval1);
            }
            if (interval2.validate()) {
                result.add(interval2);
            }
            return ImmutableList.copyOf(result);
        }
    }
217634
public RangeSet complement()
    {
        SortedSet<CharRange> nset = new TreeSet<CharRange>();
        int from = 0;
        for (CharRange r : set)
        {
            int to = r.getFrom();
            if (from < to)
            {
                nset.add(new CharRange(from, to));
            }
            from = r.getTo();
        }
        if (from < Integer.MAX_VALUE)
        {
            nset.add(new CharRange(from, Integer.MAX_VALUE));
        }
        return new RangeSet(nset);
    }
921123
public static <T> Pair<T, T> minAndMax(Collection<? extends T> coll, Comparator<? super T> comp) {

		Iterator<? extends T> i = coll.iterator();
		T minCandidate = i.next();
		T maxCandidate = minCandidate;

		while (i.hasNext()) {
			T next = i.next();
			if (comp.compare(next, minCandidate) < 0) {
				minCandidate = next;
			} else if (comp.compare(next, maxCandidate) > 0) {
				maxCandidate = next;
			}
		}

		return Pair.of(minCandidate, maxCandidate);
	}
747950
public static float map(float minStart, float minStop, float maxStart, float maxStop, float value) {
        return maxStart + (maxStop - maxStart) * ((value - minStart) / (minStop - minStart));
    }