FloatRule::OPTION_MIN_VALUE;
508362
protected function execute($value, EntityInterface $entity = null)
    {
        if (is_null($value)) {
            $value = '';
        }

        if (!is_scalar($value)) {
            $this->throwError('invalid_type', [ 'value' => $value ]);
            return false;
        }

        $rule = null;

        $value_type = gettype($value);
        switch ($value_type) {
            case 'integer':
                $rule = new IntegerRule('integer', $this->getIntegerOptions());
                break;
            case 'float':
            // in case gettype returns 'float' in future versions of php, fall trough.
            case 'double':
                $rule = new FloatRule('float', $this->getFloatOptions());
                break;
            case 'boolean':
                $rule = new BooleanRule('boolean', $this->getOptions());
                break;
            case 'string':
                $rule = new TextRule('text', $this->getOptions());
                break;
            default:
                $this->throwError('invalid_type', [ 'value' => $value ]);
                return false;
        }

        // validate value to be a valid string, integer, float or boolean
        if (!$rule->apply($value)) {
            $this->throwIncidentsAsErrors($rule);
            return false;
        }
        $value = $rule->getSanitizedValue();

        $this->setSanitizedValue($value);

        return true;
    }
1300971
def _prnt_min_max_val(var, text, verb):
    """
    if var.size > 3:
        print(text, _strvar(var.min()), "-", _strvar(var.max()),
              ":", _strvar(var.size), " [min-max; #]")
        if verb > 3:
            print("                   : ", _strvar(var))
    else:
        print(text, _strvar(np.atleast_1d(var)))
341228
function minValueNode(root) {
  var current = root;
  while (current.left) {
    current = current.left;
  }
  return current;
}
742789
def min_values(args):
    
    return Interval(min(x.low for x in args), min(x.high for x in args))
893321
function SetFilterFloatRange ( $attribute, $min, $max, $exclude=false )
    {
        assert ( is_string($attribute) );
        assert ( is_float($min) );
        assert ( is_float($max) );
        assert ( $min<=$max );

        $this->_filters[] = array ( "type"=>SPH_FILTER_FLOATRANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max );
    }
646755
function ruleMin($min, $error_message = null) {
        if (!is_numeric($min)) {
            throw new \Exception('Incorrect parameter MIN in rule min');
        }

        return $this->_rule('min:' . $min, $error_message);
    }
5504
public static function ufloat(&$value, $options = ['max'=>null, 'min'=>null, 'default'=>null])
    {
        $value = (float)$value;
        self::processUNum($value, $options);
        return $value;
    }
320210
def min(self, value):
        
        if value == self._defaults['min'] and 'min' in self._values:
            del self._values['min']
        else:
            self._values['min'] = value
1241208
function min(x) {
        var value;
        for (var i = 0; i < x.length; i++) {
            // On the first iteration of this loop, min is
            // undefined and is thus made the minimum element in the array
            if (x[i] < value || value === undefined) value = x[i];
        }
        return value;
    }
685305
def _limit_value(value, upper=1.0, lower=0.0):
    
    if value > upper:
        return(upper)
    if value < lower:
        return(lower)
    return value
752854
def get_float_value(self, section, option, default=0.0):
        """"""
        try:
            return self.parser.getfloat(section, option)
        except NoOptionError:
            return float(default)
318919
protected function validate_negative_float( $var, $include_zero = false, $min = null, $max = null ) {
		$validate = $this->validate_float( $var, $min, $max );
		if ( true === $validate ) {
			return $this->validate_negative( $var, $include_zero );
		}

		return $validate;
	}
488228
public static float restrict(float value, float minValue, float maxValue) {
        return Math.max(minValue, Math.min(value, maxValue));
    }
1096235
def clamp(value, lower=0, upper=sys.maxsize):
    """"""
    return max(lower, min(upper, value))
534589
function min (arr) {
    if (isArray(arr) && !(arr[0] instanceof Array)) {
        // Filter out undefined, null and NaN values
        const filteredValues = getFilteredValues(arr);

        return (filteredValues.length) ? Math.min(...filteredValues) : InvalidAwareTypes.NULL;
    }
    return InvalidAwareTypes.NULL;
}
356004
def min(cls, x: 'TensorFluent', y: 'TensorFluent') -> 'TensorFluent':
        '''
        '''
        return cls._binary_op(x, y, tf.minimum, tf.float32)
131094
protected function _validate_min($value, $parameters)
    {
        /** @noinspection CallableParameterUseCaseInTypeContextInspection */
        $value = $this->_validate_float($value);

        return $value === null || $value < $parameters[0] ? null : $value;
    }