Set limits for the point sizes.

        :param min: point size for the lowest value.
        :param max: point size for the highest value.
760664
def set_slimits(self, row, column, min, max):
        
        subplot = self.get_subplot_at(row, column)
        subplot.set_slimits(min, max)
729899
def setMaximum( self, value ):
        
        super(XRatingSlider, self).setMaximum(value)
        
        self.adjustMinimumWidth()
708237
public void setClipping(double[] min, double[] max) {
    // if only one dimension was given, expand to all dimensions.
    if(min.length == 1 && max.length == 1) {
      if(min[0] >= max[0]) {
        throw new AbortException("Clipping range empty.");
      }
      clipmin = new double[dim];
      clipmax = new double[dim];
      Arrays.fill(clipmin, min[0]);
      Arrays.fill(clipmax, max[0]);
      return;
    }
    if(dim != min.length) {
      throw new AbortException("Clipping double[] dimensionalities do not match: " + dim + " vs. " + min.length);
    }
    if(dim != max.length) {
      throw new AbortException("Clipping double[] dimensionalities do not match: " + dim + " vs. " + max.length);
    }
    for(int i = 0; i < dim; i++) {
      if(min[i] >= max[i]) {
        throw new AbortException("Clipping range empty in dimension " + (i + 1));
      }
    }
    clipmin = min;
    clipmax = max;
  }
46315
def maxsize(self, size):
        """"""
        if size < 0:
            raise ValueError('maxsize must be non-negative')
        with self._lock:
            self._enforce_size_limit(size)
            self._maxsize = size
1254848
def setMaximum(self, m, update=True):
        """"""
        if m is not None:
            m = D(asUnicode(m))
        self.opts['bounds'][1] = m
        if update:
            self.setValue()
320210
def min(self, value):
        
        if value == self._defaults['min'] and 'min' in self._values:
            del self._values['min']
        else:
            self._values['min'] = value
513476
def _fix_max_min(self, op_name, inputs):
        
        if len(inputs) > 1:
            if op_name == 'Max':
                op = mx.sym.maximum(inputs[0], inputs[1])
                for ip in inputs[2:]:
                    op = mx.sym.maximum(op, ip)
            elif op_name == 'Min':
                op = mx.sym.minimum(inputs[0], inputs[1])
                for ip in inputs[2:]:
                    op = mx.sym.minimum(op, ip)
        else:
            op = inputs[0]
        return op
1356664
public function setMinMax($min,$max=null)
    {
       $this->min = $min; 
       $this->max = $max; 
    }
186793
function (min, max) {

    /**
     * Minimum coords of bounding box
     * @type {clay.Vector3}
     */
    this.min = min || new Vector3(Infinity, Infinity, Infinity);

    /**
     * Maximum coords of bounding box
     * @type {clay.Vector3}
     */
    this.max = max || new Vector3(-Infinity, -Infinity, -Infinity);

    this.vertices = null;
}
967007
public void setRange( int dimension , double min , double max ) {
		valueMin[dimension] = min;
		valueMax[dimension] = max;
	}
1035253
public static void minMax(Integer min, Integer max) {
		if(!validation) return;
		Validate.notNull(min);
		Validate.notNull(max);
		if(min > max)
			throw new ParameterException(ErrorCode.RANGEVIOLATION, "Minumum is bigger than maximum.");
	}
1069708
function(min, max) {
    return function limitZoom(params) {
      params.zoom = clamp(params.zoom, min, max);
      return params;
    };
  }
171335
def set_min_lease(self, min_lease):
        
        self._query_params += str(QueryParam.MIN_LEASE) + str(min_lease)
295637
def _rlimit_min(one_val, nother_val):
    """"""
    if one_val < 0 or nother_val < 0 :
        return max(one_val, nother_val)
    else:
        return min(one_val, nother_val)
474502
private float limit(float value, float min, float max) {
    return Math.min(Math.max(min, value), max);
  }
404479
def _adjust_limits(self):
        
        if not self.is_load:
#            self.p_min = min([point[0] for point in self.p_cost])
            self.p_max = max([point[0] for point in self.p_cost])
        else:
            p_min = min([point[0] for point in self.p_cost])
            self.p_max = 0.0
            self.q_min = self.q_min * p_min / self.p_min
            self.q_max = self.q_max * p_min / self.p_min
            self.p_min = p_min
1129649
def inbounds(self, min, max):
        
        mincheck = sum(self.coordinates >= min, axis=1) == 0
        maxcheck = sum(self.coordinates < max, axis=1) == 0
        return True if (mincheck.sum() + maxcheck.sum()) == 0 else False