Returns a random decimal number in the range of [min, max].

@param min
minimum value for generated number
@param max
maximum value for generated number
430153
public double getDouble(final double min, final double max) {
		return min(min, max) + getDouble(abs(max - min));
	}
795129
public final void setMinNumber(final int minNumber) {
        Condition.INSTANCE.ensureSmaller(minNumber, getMaxNumber(),
                "The minimum number must be less than the maximum number");
        this.minNumber = minNumber;
        setNumber(Math.max(getNumber(), minNumber));
    }
1149823
public static int[] range(int min, int max) {
    int[] range = new int[max - min];
    for (int i = 0; i < (max - min); i++) {
      range[i] = i + min;
    }
    return range;
  }
336821
public static int getRandomInteger(int min, int max)
    {
        Check.inferiorOrEqual(min, max);

        return min + RANDOM.nextInt(max + 1 - min);
    }
1171610
public static int clamp(int n, int min, int max) {
        if (n < min) return min;
        if (n > max) return max;
        return n;
    }
1264023
public SELF size(int min, int max) {

    return size(new Range<>(Integer.valueOf(min), Integer.valueOf(max)));
  }
1353109
@ArgumentsChecked
	@Throws(IllegalNullArgumentException.class)
	public static boolean isInRange(@Nonnull final Number number, @Nonnull final BigInteger min, @Nonnull final BigInteger max) {
		Check.notNull(number, "number");
		Check.notNull(min, "min");
		Check.notNull(max, "max");

		BigInteger bigInteger = null;
		if (number instanceof Byte || number instanceof Short || number instanceof Integer || number instanceof Long) {
			bigInteger = BigInteger.valueOf(number.longValue());
		} else if (number instanceof Float || number instanceof Double) {
			bigInteger = new BigDecimal(number.doubleValue()).toBigInteger();
		} else if (number instanceof BigInteger) {
			bigInteger = (BigInteger) number;
		} else if (number instanceof BigDecimal) {
			bigInteger = ((BigDecimal) number).toBigInteger();
		} else {
			throw new IllegalNumberArgumentException("Return value is no known subclass of 'java.lang.Number': "
					+ number.getClass().getName());
		}
		return max.compareTo(bigInteger) >= 0 && min.compareTo(bigInteger) <= 0;
	}
560616
protected function random(float $min, float $max) : float
    {
        return ($min + lcg_value() * (abs($max - $min)));
    }
912628
public static Range range(final double minValue, final double maxValue) {
        if (minValue > maxValue) {
            throw new IllegalArgumentException("minValue should be less then or equal to maxValue (" + minValue+ ", " + maxValue + ")");
        }
        return new Range() {

            @Override
            public Number getMinimum() {
                return minValue;
            }

            @Override
            public Number getMaximum() {
                return maxValue;
            }

            @Override
            public String toString() {
                return Ranges.toString(this);
            }
            
        };
    }
938068
protected int readInteger(final String intString, final int min, final int max) {
        return Math.max(Math.min(Integer.parseInt(intString), max), min);
    }
503202
public ValidatorBuilderDouble<PARENT> range(double min, double max) {

    return range(new Range<>(Double.valueOf(min), Double.valueOf(max)));
  }
231150
public static int rollover(int value, int min, int max) {
		if (value < min) {
			int roll = (min - value) % (max - min + 1);
			return roll != 0 ? max + 1 - roll : min;
		} else if (value > max) {
			int roll = (value - max) % (max - min + 1);
			return roll != 0 ? min - 1 + roll : max;
		}
		return value;
	}
345844
public static final double random(double max) {
        last = (last * IA + IC) % IM;
        return max * last / IM;
    }
806867
function Random(Max, Min){
    var Range = Max - Min;
    var Rand = Math.random();
    return (Min + Math.round(Rand * Range));
}
1024293
public int getNumberBetween(final int min, final int max) {

    if (max < min) {
      throw new IllegalArgumentException(String.format("Minimum must be less than minimum (min=%d, max=%d)", min, max));
    }
    if (max == min) {
      return min;
    }

    return min + random.nextInt(max - min);
  }
291160
function getRandom(min, max){		
		var randomNum = Math.random() * (max-min); 
		// Round to the closest integer and return it
		return(Math.round(randomNum) + min); 
		}
1338314
public static double getRandomDouble(double min, double max) {
		Random r = new Random();
		return min + (max - min) * r.nextDouble();
	}