@see #range(Range)

@param min the minimum allowed value.
@param max the maximum allowed value.
@return this build instance for fluent API calls.
503202
public ValidatorBuilderDouble<PARENT> range(double min, double max) {

    return range(new Range<>(Double.valueOf(min), Double.valueOf(max)));
  }
32030
public static ByteRangeRandomizer aNewByteRangeRandomizer(final Byte min, final Byte max, final long seed) {
        return new ByteRangeRandomizer(min, max, seed);
    }
1264023
public SELF size(int min, int max) {

    return size(new Range<>(Integer.valueOf(min), Integer.valueOf(max)));
  }
176817
public static RubyRange<String> range(String start, String end) {
    return new RubyRange<>(StringSuccessor.getInstance(), start, end,
        Interval.CLOSED);
  }
658379
public static Protos.Value.Range range(long begin, long end) {
		return Protos.Value.Range.newBuilder().setBegin(begin).setEnd(end).build();
	}
279426
public static function range($min = 0, $max = -1)
    {
        for ($i = $min; $max < 0 || $i < $max; ++$i) {
            yield $i;
        }
    }
494485
public static Constraint size(final Number min, final Number max) {
		return new Constraint("size", sizePayload(min, max)) {
			public boolean isValid(Object actualValue) {
				if (actualValue != null && min != null && max != null) {
					if (actualValue instanceof String) {
						return !isOutOfRange(((String) actualValue).length(), min, max);
					} else if (actualValue instanceof Collection) {
						return !isOutOfRange(((Collection) actualValue).size(), min, max);
					} else if (actualValue instanceof Map) {
						return !isOutOfRange(((Map) actualValue).size(), min, max);
					} else if (actualValue.getClass().isArray()) {
						return !isOutOfRange(ArrayUtils.getLength(actualValue), min, max);
					} else {
						return false;
					}
				}
				return true;
			}
		};
	}
1199306
function range($min = null, $max = null)
	{
		$this->min($min);
		$this->max($max);
		return $this;
	}
1300350
public static <T extends Comparable<? super T>> List<T> minList (Iterable<T> iterable)
    {
        return maxList(iterable, java.util.Collections.reverseOrder());
    }
56807
function exclusiveRange($min = null, $max = null)
	{
		$this->exclusiveMin($min);
		$this->exclusiveMax($max);
		return $this;
	}
428236
public void setMinMax(double min, double max)
    {
        if(min <= 0 || Double.isNaN(min) || Double.isInfinite(min))
            throw new IllegalArgumentException("min value must be positive, not " + min);
        else if(min >= max || Double.isNaN(max) || Double.isInfinite(max))
            throw new IllegalArgumentException("max (" + max + ") must be larger than min (" + min+")" );
        this.max = max;
        this.min = min;
        this.logMax = Math.log(max);
        this.logMin = Math.log(min);
        this.logDiff = logMax-logMin;
        this.diff = max-min;
    }
568978
public static RubyRange<Integer> range(int start, int end) {
    return new RubyRange<>(IntegerSuccessor.getInstance(), start, end,
        Interval.CLOSED);
  }
137185
@ArgumentsChecked
	@Throws(IllegalNullArgumentException.class)
	public static boolean isInRange(@Nonnull final Number number, @Nonnull final BigDecimal min, @Nonnull final BigDecimal max) {
		Check.notNull(number, "number");
		Check.notNull(min, "min");
		Check.notNull(max, "max");

		BigDecimal bigDecimal = null;
		if (number instanceof Byte || number instanceof Short || number instanceof Integer || number instanceof Long) {
			bigDecimal = new BigDecimal(number.longValue());
		} else if (number instanceof Float || number instanceof Double) {
			bigDecimal = new BigDecimal(number.doubleValue());
		} else if (number instanceof BigInteger) {
			bigDecimal = new BigDecimal((BigInteger) number);
		} else if (number instanceof BigDecimal) {
			bigDecimal = (BigDecimal) number;
		} else {
			throw new IllegalNumberArgumentException("Return value is no known subclass of 'java.lang.Number': "
					+ number.getClass().getName());
		}
		return max.compareTo(bigDecimal) >= 0 && min.compareTo(bigDecimal) <= 0;
	}
366872
public function range($min, $max, $message = null)
    {
        $this->set([
            'min' => (int)$min,
            'max' => (int)$max,
        ], $message);
        return $this;
    }
343356
@SuppressWarnings("rawtypes")
	public Set zrangeByScore(Object key, double min, double max) {
		Jedis jedis = getJedis();
		try {
			Set<byte[]> data = jedis.zrangeByScore(keyToBytes(key), min, max);
			Set<Object> result = new LinkedHashSet<Object>();	// 有序集合必须 LinkedHashSet
			valueSetFromBytesSet(data, result);
			return result;
		}
		finally {close(jedis);}
	}
209097
public static function ruleLenRange($min, $max)
    {
        return function ($input) use ($min, $max) {
            return strlen($input) >= $min && strlen($input) <= $max;
        };
    }
389296
public static Between betweenExclusiveMax( String property, int minimum, int maximum)
    {
    return new Between( notLessThan( property, minimum), lessThan( property, maximum));
    }