The min property.
        
        Args:
            value (float). the property 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
803094
def _set_bottomMargin(self, value):
        
        diff = value - self.bottomMargin
        self.moveBy((0, diff))
        self.height += diff
417876
function (value) {
      var range = this.props.max - this.props.min;
      if (range === 0) {
        return 0;
      }
      var ratio = (value - this.props.min) / range;
      return ratio * this.state.upperBound;
    }
208648
def _check_above_value_float(string, minimum):
    
    value = float(string)

    if value < minimum:
        message = 'The Numeric Field value should be above %s' % minimum
        raise pp.ParseException(message)
408865
def validate(self, value):
        
        try:
            # trap blank fields here
            if not self.blank or value:
                v = float(value)
                if (self.allowzero and v != 0 and v < self.fmin) or \
                        (not self.allowzero and v < self.fmin) or v > self.fmax:
                    return None
            return value
        except ValueError:
            return None
704023
def _set_min_value(self, min_value):

        """"""

        # Check that the min value can be transformed if a transformation is present
        if self._transformation is not None:

            if min_value is not None:

                try:

                    _ = self._transformation.forward(min_value)

                except FloatingPointError:

                    raise ValueError("The provided minimum %s cannot be transformed with the transformation %s which "
                                     "is defined for the parameter %s" % (min_value,
                                                                          type(self._transformation),
                                                                          self.path))

        # Store the minimum as a pure float

        self._external_min_value = min_value

        # Check that the current value of the parameter is still within the boundaries. If not, issue a warning

        if self._external_min_value is not None and self.value < self._external_min_value:

            warnings.warn("The current value of the parameter %s (%s) "
                          "was below the new minimum %s." % (self.name, self.value, self._external_min_value),
                          exceptions.RuntimeWarning)

            self.value = self._external_min_value
1086717
function float(value) {
  var parsedFloat = Number.parseFloat(value);

  // couldn't parse it
  if (typeOf(parsedFloat) != 'number') {
    return throwModifierError('float', value, {message: 'Invalid Float'});
  }

  return parsedFloat;
}
727634
def min_pixels(self, value: float) -> 'Size':
        """"""
        raise_not_number(value)
        self.minimum = '{}px'.format(value)
        return self
797337
def set(self, value, samples=0):
        '''
        
        '''
        if self.params.length > self.pos and samples > 0:
            l = min(samples, self.params.length-self.pos)
            self.data[self.pos:self.pos+l] = np.full(l, value, dtype=np.float)
            self.pos += l
        self.latest = value
        return self
1086315
def pixels(self, value: float) -> 'Size':
        """"""
        raise_not_number(value)
        self.maximum = '{}px'.format(value)
        return self
705655
function () {
            var value, binding = this._binding;
            if (!binding) {
                return;
            }
            value = binding.inside[binding.to];
            if (ariaUtilsType.isArray(value)) {
                // Constrain values to be between 0 and 1 and the first to be smaller
                this.value[0] = Math.max(0, Math.min(value[0], value[1], 1));
                this.value[1] = Math.min(1, Math.max(value[0], value[1], 0));
            }
            ariaUtilsJson.setValue(binding.inside, binding.to, this.value, this._bindingCallback);
        }
538818
def _min(self):
        """"""
        return (
            self.range[0] if (self.range and self.range[0] is not None) else
            (min(self.yvals) if self.yvals else None)
        )
1265887
public void setValue(double value) {
        this.value = lockValueInRange
                ? Op.bound(value, minimum, maximum)
                : value;
    }
908602
def gte(min_value):
    
    def validate(value):
        if value < min_value:
            return e("{} is not greater than or equal to {}", value, min_value)
    return validate
703249
function(min, max){
	min = min || 0.0;
	max = typeof max === 'number' ? max : 1.0;
	// swap if necessary
	if(min > max){
		var t= max;
		max = min;
		min = t;
	}
	this.min = min;
	this.max = max;
	this.currValue = min;
}
863087
def percentAt(self, value):
        
        min_val = self.minimum()
        max_val = self.maximum()
        
        # round the max value to sync with the values in the grid
        total_seconds = (max_val - min_val).total_seconds()
        value_seconds = (value - min_val).total_seconds()
        
        if value < min_val:
            return 0.0
        elif max_val < value:
            return 1.0
        
        try:
            perc = value_seconds / float(total_seconds)
        except ZeroDivisionError:
            perc = 0.0
        
        return perc
896416
def setValue(self, value):
        
        if isinstance(value, Text):
            self.value = value
        else:
            self.value = Text(value)
        return self