Checks if there is a free value smaller than self.size
        :return: True if there is a free value, False if not
516310
def has_free_slots(self):
        
        return next(filterfalse(self.numbers.__contains__, count(1))) < self.size
563651
def get_size(self, value=None):
        
        if isinstance(value, type(self)):
            return value.get_size()

        return 2 + self.length
1153242
def isOrigin(self):
        
        for name, value in self.items():
            if isinstance(value, tuple):
                if (value < (-_EPSILON,) * len(value)
                        or value > (_EPSILON,) * len(value)):
                    return False
            if value < -_EPSILON or value > _EPSILON:
                return False
        return True
712149
def full(self):
        
        if self._parent._maxsize <= 0:
            return False
        else:
            return self.qsize() >= self._parent._maxsize
348433
def _is_sub_intrinsic(data):
        
        return isinstance(data, dict) and len(data) == 1 and LambdaUri._FN_SUB in data
948073
def is_contradictory(self, other):
        
        if other.size() > self.size():
            return other.is_contradictory(self)
        # ensure self is bigger or equal size
        if other.size() == 0:
            # empty lists are fine
            return False
        
        # see if any values in the shorter list are contradictory or 
        # unequal
        for i, oval in enumerate(other.value):
            if hasattr(self.value[i], 'is_contradictory') and \
                    self.value[i].is_contradictory(oval):
                # allow comparing cells
                return True
            elif self.value[i] != oval:
                return True
        return False
691536
private boolean isLongMIN_VALUE()
    {
        if (decimalAt != count || count != MAX_LONG_DIGITS)
            return false;

            for (int i = 0; i < count; ++i)
        {
            if (digits[i] != LONG_MIN_REP[i]) return false;
        }

        return true;
    }
14744
def _min(self):
        """"""
        return (
            self.range[0] if (self.range and self.range[0] is not None) else
            (min(self._values) if self._values else None)
        )
308688
def free=(new_val)
      return nil if new_val == @free
      raise JSS::InvalidDataError, 'New value must be true or false' unless new_val.jss_boolean?
      @free = new_val
      @need_to_update = true
    end
257890
def min_length?(value, length)
			has_min_length = coerce_bool (value.length >= length)
			unless has_min_length
				@error = "Error, expected value to have at least #{length} characters, got: #{value.length}"
			end
			has_min_length
		end
931774
def is_empty(self):
        
        return (
            self._lower > self._upper or
            (self._lower == self._upper and (self._left == OPEN or self._right == OPEN))
        )
1206198
def _is_enlargement(locator, global_index):
    
    if (
        is_list_like(locator)
        and not is_slice(locator)
        and len(locator) > 0
        and not is_boolean_array(locator)
        and (isinstance(locator, type(global_index[0])) and locator not in global_index)
    ):
        n_diff_elems = len(pandas.Index(locator).difference(global_index))
        is_enlargement_boolean = n_diff_elems > 0
        return is_enlargement_boolean
    return False
848050
def calculate_size(name, new_value):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += BOOLEAN_SIZE_IN_BYTES
    if new_value is not None:
        data_size += calculate_size_data(new_value)
    return data_size
68179
def isAboveUpperDetectionLimit(self):
        
        if self.isUpperDetectionLimit():
            return True

        result = self.getResult()
        if result and str(result).strip().startswith(UDL):
            return True

        if api.is_floatable(result):
            return api.to_float(result) > self.getUpperDetectionLimit()

        return False
898004
public boolean isFull()
	{
		return !itemStack.isEmpty() && itemStack.getCount() == Math.min(itemStack.getMaxStackSize(), getSlotStackLimit());
	}
1270707
def full(self):
        """"""
        if not self.size: return False
        return len(self.pq) == (self.size + self.removed_count)
1233954
def min_value(self):
        

        if self._is_completely_masked:
            return np.nan * self._data_unit
        else:
            return np.min(self.values)