Set the minimum size in ems.
556416
def min_ems(self, value: float) -> 'Size':
        """"""
        raise_not_number(value)
        self.minimum = '{}em'.format(value)
        return self
771725
public void ensureCapacity(int minCapacity) {
		modCount++;
		while (bucketSize << (bucketDepth*bucketExp) < minCapacity) {
			Object oldData[] = bucket;
			bucket = new Object[bucketSize];
			bucket[0] = oldData;
			bucketDepth++;
		}
	}
207402
def minimize(self, minimize):
        '''
        '''

        self._minimize = minimize
        self._logger.log('debug', 'Minimize set to {}'.format(minimize))
1165578
public void setMin(java.lang.Object _min) {
		getStateHelper().put(PropertyKeys.min, _min);
	}
637115
public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
1112565
def _set_min_level(self, handler_class, level):
        """"""
        if self._exist_handler(handler_class):
            if not level:
                self._delete_handler(handler_class)
            else:
                self._update_handler(handler_class, level=level)
        elif level:
            self._create_handler(handler_class, level)
431960
public void shrink (int maximumCapacity) {
		if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
		if (size > maximumCapacity) maximumCapacity = size;
		if (capacity <= maximumCapacity) return;
		maximumCapacity = nextPowerOfTwo(maximumCapacity);
		resize(maximumCapacity);
	}
1009007
def resize_bytes(self, size):
        
        Buffer.resize_bytes(self, size)
        self._size = size // self.itemsize
238759
def resize_volume(self, size):
        """"""
        curr_size = self.volume.size
        if size <= curr_size:
            raise exc.InvalidVolumeResize("The new volume size must be larger "
                    "than the current volume size of '%s'." % curr_size)
        body = {"volume": {"size": size}}
        self.manager.action(self, "resize", body=body)
538287
public void setMaxPayloadSize(int max) {
        addField(ConfigureNodeFields.max_payload_size, FormField.Type.text_single);
        setAnswer(ConfigureNodeFields.max_payload_size.getFieldName(), max);
    }
113423
def resize(self, size):
		
		if size is not None:
			self.__value = int(WBinArray(self.__value)[:size])
		self.__size = size
1271020
def setMinimum(self, minimum):
        
        if not isinstance(minimum, int):
            raise TypeError("Argument is not of type int or long")
        self._minimum = minimum
1321395
def withSize(cls, minimum, maximum):
        

        class X(cls):
            subtypeSpec = cls.subtypeSpec + constraint.ValueSizeConstraint(
                minimum, maximum)

        X.__name__ = cls.__name__
        return X
1186633
def set_size(params = {})
      @width    = params[:width]    if params[:width]
      @height   = params[:height]   if params[:height]
      @x_scale  = params[:x_scale]  if params[:x_scale]
      @y_scale  = params[:y_scale]  if params[:y_scale]
      @x_offset = params[:x_offset] if params[:x_offset]
      @y_offset = params[:y_offset] if params[:y_offset]
    end
798980
def setMaximumSize(self, *args):
        
        super(XView, self).setMaximumSize(*args)
        
        if ( not self.signalsBlocked() ):
            self.sizeConstraintChanged.emit()
1186897
public function setMinimumProportions($width = null, $height = null)
    {
        $this->minimumWidth = $width;
        $this->minimumHeight = $height;
    }
1128695
def set_size(self, size):
        
        if not isinstance(size, baseinteger):
            raise TypeError("size can only be an instance of type baseinteger")
        self._call("setSize",
                     in_p=[size])