Checks if the passed parameter is in the range of this object.
438457
def Contains(self, other):
        
        if other is None:
            raise ValueError("other is None.")

        if isinstance(other, Range):
            if other.low >= self.low and other.high <= self.high:
                return True
            return False
        else:
            return self.Contains(Range(other, other))
862318
def in_range(x: int, minimum: int, maximum: int) -> bool:
    
    return (x >= minimum and x <= maximum)
908840
public static Validation<Integer> range(int min, int max) {
        return greaterThan(min).and(lowerThan(max));
    }
1263173
def _check_insersection(self, version, ranges):
        """"""

        for ver_range in ranges:
            if not self._check_ver_range(version, ver_range):
                return False

        return True
473033
def range(self, start='-', stop='+', count=None):
        
        return self.database.xrange(self.key, start, stop, count)
1267819
def is_in_data_type_range(self, raise_exception=True):
        """"""
        return self._header.data_type.is_in_range(
            self._values, self._header.unit, raise_exception)
1073072
def range_condition(self):
        
        if self._proto.HasField('rangeCondition'):
            return pvalue_pb2.RangeCondition.Name(self._proto.rangeCondition)
        return None
118993
def range_end(self):
        '''
        '''
        count = self.count
        range_end = self.range_start + self.limit - 1
        if count < range_end:
            range_end = count
        return range_end
1019248
def is_parameter(self):
        """"""
        return (isinstance(self.scope, CodeFunction)
                and self in self.scope.parameters)
723221
public boolean IsOverlapping(FloatRange range) {
        return ((isInside(range.min)) || (isInside(range.max)) ||
                (range.isInside(min)) || (range.isInside(max)));
    }
613967
public boolean contains(final CharRange range) {
        Validate.isTrue(range != null, "The Range must not be null");
        if (negated) {
            if (range.negated) {
                return start >= range.start && end <= range.end;
            }
            return range.end < start || range.start > end;
        }
        if (range.negated) {
            return start == 0 && end == Character.MAX_VALUE;
        }
        return start <= range.start && end >= range.end;
    }
272160
public boolean checkParams(int iAreaDesc)
    {
        KeyArea pIndex = this.getKeyArea(-1);
        int lastField = pIndex.getKeyFields() + DBConstants.MAIN_FIELD - 1;
        for (int keyFieldSeq = DBConstants.MAIN_FIELD; keyFieldSeq <= lastField; keyFieldSeq++)
        {
            KeyField pKeyField = pIndex.getKeyField(keyFieldSeq);
            BaseField pField = pKeyField.getField(DBConstants.MAIN_FIELD);
            BaseField pParamField = pKeyField.getField(iAreaDesc);
            int bCompare = pField.compareTo(pParamField);
            if (iAreaDesc == DBConstants.END_SELECT_KEY) if (bCompare > 0)
                return true;    // Past range
            if (iAreaDesc == DBConstants.START_SELECT_KEY) if (bCompare < 0)
                return true;    // Past range
        }
        return false; // Within the range!
    }
466292
public boolean isBeforeRange(Range<T> otherRange) {
    if (otherRange == null) { return false; }
    return isBefore(otherRange.min);
  }
40615
private static boolean checkParameters(Method method, Object... data)
	{
		Parameter[] parameters = method.getParameters();
		if (ArrayUtils.isEmpty(data) && parameters.length != 0)
			return false;
		if (parameters.length != data.length)
			return false;

		for (int i = 0; i < parameters.length; i++)
		{
			Class<?> paramClass = parameters[i].getType();
			if (data[i] != null)
			{
				Class<?> dataClass = data[i].getClass();
				if (!ClassUtils.isAssignable(dataClass, paramClass, true))
					return false;
			}
		}

		return true;
	}
1166749
def check_ranged_param(ranged_param, allowed)
      🔞 = ranged_param.keys.map(&:to_sym) - allowed.map(&:to_sym)
      raise InvalidRangeException, "Attributes #{🔞.map(&:to_s).to_sentence} doesn't exists or aren't rangeables. Available ranges are: #{allowed.to_sentence}" if 🔞.any?
    end
40701
def _check_bounds(self, v):
        
        below_bounds = v < self._x[0]
        above_bounds = v > self._x[-1]

        if self.bounds_error and below_bounds.any():
            raise ValueError("A value in x_new is below the interpolation "
                "range.")
        if self.bounds_error and above_bounds.any():
            raise ValueError("A value in x_new is above the interpolation "
                "range.")

        return below_bounds, above_bounds
219008
def _check_min_max_range(self, var, test_ctx):
        
        if 'valid_range' in var.ncattrs():
            test_ctx.assert_true(var.valid_range.dtype == var.dtype and
                                 len(var.valid_range) == 2
                                 and var.valid_range[0] <= var.valid_range[1],
                                 "valid_range must be a two element vector of min followed by max with the same data type as {}".format(var.name)
                                 )
        else:
            for bound in ('valid_min', 'valid_max'):
                v_bound = getattr(var, bound, '')
                warn_msg = '{} attribute should exist, have the same type as {}, and not be empty or valid_range should be defined'.format(bound, var.name)
                # need to special case str attributes since they aren't directly
                # comparable to numpy dtypes
                if isinstance(v_bound, six.string_types):
                    test_ctx.assert_true(v_bound != '' and
                                         var.dtype.char == 'S', warn_msg)
                # otherwise compare the numpy types directly
                else:
                    test_ctx.assert_true(v_bound.dtype == var.dtype, warn_msg)
        return test_ctx