Returns true if any one of the channel, height, or width ranges of this shape allow more than one input value.
6829
def isFlexible(self):
        
        for key, value in self.arrayShapeRange.items():
            if key in _CONSTRAINED_KEYS:
                if value.isFlexible:
                    return True

        return False
820429
boolean checkInputDependencyConstraints() {
		if (getInputDependencyConstraint() == InputDependencyConstraint.ANY) {
			// InputDependencyConstraint == ANY
			return IntStream.range(0, inputEdges.length).anyMatch(this::isInputConsumable);
		} else {
			// InputDependencyConstraint == ALL
			return IntStream.range(0, inputEdges.length).allMatch(this::isInputConsumable);
		}
	}
1159101
public boolean containsRange(final Range<T> other) {
        if (other == null) {
            return false;
        }

        return (other.lowerEndpoint.isClosed ? contains(other.lowerEndpoint.value) : lowerEndpoint.value.compareTo(other.lowerEndpoint.value) <= 0)
                && (other.upperEndpoint.isClosed ? contains(other.upperEndpoint.value) : upperEndpoint.value.compareTo(other.upperEndpoint.value) >= 0);
    }
1323074
public boolean isMultiple()
        throws EFapsException
    {
        final boolean ret;
        if (this.valueSelect == null) {
            ret = this.fromSelect.getMainOneSelect().isMultiple(this.currentObject);
        } else {
            ret = this.objectList.size() > 1;
        }
        return ret;
    }
880483
public boolean IsOverlapping(DoubleRange range) {
        return ((isInside(range.min)) || (isInside(range.max)) ||
                (range.isInside(min)) || (range.isInside(max)));
    }
424944
def is_slice_or_dim_range_request(key, depth=0):
    '''
    
    '''
    # Slice, DimensionRange, or list of those elements
    return (is_slice_or_dim_range(key) or
            # Don't check more than the first depth
            (depth == 0 and non_str_len_no_throw(key) > 0 and
             all(is_slice_or_dim_range_request(subkey, depth+1) for subkey in key)))
682992
async def on_isupport_chanlimit(self, value):
        
        self._channel_limits = {}

        for entry in value.split(','):
            types, limit = entry.split(':')

            # Assign limit to channel type group and add lookup entry for type.
            self._channel_limits[frozenset(types)] = int(limit)
            for prefix in types:
                self._channel_limit_groups[prefix] = frozenset(types)
671808
def validate_range_value(value):
    
    if value == (None, None):
        return

    if not hasattr(value, '__iter__'):
        raise TypeError('Range value must be an iterable, got "%s".' % value)
    if not 2 == len(value):
        raise ValueError('Range value must consist of two elements, got %d.' %
                         len(value))
    if not all(isinstance(x, (int,float)) for x in value):
        raise TypeError('Range value must consist of two numbers, got "%s" '
                        'and "%s" instead.' % value)
    if not value[0] <= value[1]:
        raise ValueError('Range must consist of min and max values (min <= '
                         'max) but got "%s" and "%s" instead.' % value)
    return
608235
public boolean containsRange(Range<T> otherRange) {
    if (otherRange == null) { return false; }
    return contains(otherRange.min) && contains(otherRange.max);
  }
1371080
@Override
    public boolean isValid(Object input) {
        Float d;
        try {
            d = (Float) input;
        } catch (Exception e) {
            return false;
        }

        if (allowNaN && Float.isNaN(d))
            return true;
        if (allowInfinite && Float.isInfinite(d))
            return true;

        if (minAllowedValue != null && d < minAllowedValue)
            return false;
        if (maxAllowedValue != null && d > maxAllowedValue)
            return false;

        return true;
    }
116808
public boolean inRange(InetAddress ip) {
        if (greaterThan(ip, ipHigher))
            return false;
        else if (lessThan(ip, ipLower))
            return false;
        else
            return true;
    }
476507
public boolean isMultiPoint() {
    boolean mp = true;
    if (this == UNDEFINED) { mp = false; }
    else if (this == NULL) { mp = false; }
    else if (this == POINT) { mp = false; }
    return mp;
  }
457198
public boolean isAfterRange(Range<T> otherRange) {
    if (otherRange == null) { return false; }
    return isAfter(otherRange.max);
  }
806556
function checkLimit (limit, keys) {
  if (limit && typeof limit === 'string') limit = +limit;
  if (!limit || Number(limit) !== limit || limit % 1 !== 0 ||
      limit > keys.length)
    limit = keys.length;
  if (limit < 0) limit = 0;
  return limit;
}
1021567
private boolean checkSideSize( Polygon2D_F64 p ) {
		double max=0,min=Double.MAX_VALUE;

		for (int i = 0; i < p.size(); i++) {
			double l = p.getSideLength(i);
			max = Math.max(max,l);
			min = Math.min(min,l);
		}

		// See if a side is too small to decode
		if( min < 10 )
			return false;

		// see if it's under extreme perspective distortion and unlikely to be readable
		return !(min / max < thresholdSideRatio);
	}
285116
private boolean checkDimensions(CLIQUEUnit other, int e) {
    for(int i = 0, j = 0; i < e; i++, j += 2) {
      if(dims[i] != other.dims[i] || bounds[j] != other.bounds[j] || bounds[j + 1] != bounds[j + 1]) {
        return false;
      }
    }
    return true;
  }
1236688
def is_valid_input_array(x, ndim=None):
    """"""
    x = np.asarray(x)

    if ndim is None or ndim == 1:
        return x.ndim == 1 and x.size > 1 or x.ndim == 2 and x.shape[0] == 1
    else:
        return x.ndim == 2 and x.shape[0] == ndim