Creates and returns a condition of the range key that has a value between
the given values.
481112
public RangeKeyCondition between(Object low, Object hi) {
        kcond = KeyConditions.BETWEEN;
        return withValues(low, hi);
    }
587119
public static boolean isBetween( double value, double... ranges ) {
        boolean even = true;
        for( int i = 0; i < ranges.length; i++ ) {
            if (even) {
                // lower bound
                if (value < ranges[i]) {
                    return false;
                }
            } else {
                // higher bound
                if (value > ranges[i]) {
                    return false;
                }
            }
            even = !even;
        }
        return true;
    }
1113587
def find_range(self, interval):
        """"""
        return self.find(self.tree, interval, self.start, self.end)
52432
def setrange(self, key, offset, value):
        
        if not isinstance(offset, int):
            raise TypeError("offset argument must be int")
        if offset < 0:
            raise ValueError("offset must be greater equal 0")
        return self.execute(b'SETRANGE', key, offset, value)
1101081
def dynamize_range_key_condition(self, range_key_condition):
        
        d = None
        if range_key_condition:
            d = {}
            for range_value in range_key_condition:
                range_condition = range_key_condition[range_value]
                if range_condition == 'BETWEEN':
                    if isinstance(range_value, tuple):
                        avl = [self.dynamize_value(v) for v in range_value]
                    else:
                        msg = 'BETWEEN condition requires a tuple value'
                        raise TypeError(msg)
                elif isinstance(range_value, tuple):
                    msg = 'Tuple can only be supplied with BETWEEN condition'
                    raise TypeError(msg)
                else:
                    avl = [self.dynamize_value(range_value)]
            d = {'AttributeValueList': avl,
                 'ComparisonOperator': range_condition}
        return d
789932
@Override
    public SequenceQuality getRange(Range range) {
        byte[] rdata = Arrays.copyOfRange(data, range.getLower(), range.getUpper());
        if (range.isReverse())
            ArraysUtils.reverse(rdata);
        return new SequenceQuality(rdata, true);
    }
243292
function range(a, b) {
    var total = b - a;
    var rec = function(x, y) {
        if (y - a >= total) return x;

        x[y] = y++;
        return rec(x, y);
    };
    return rec([], a);
}
87338
function(key, condition, value) {
      // Check if we already have a condition
      if (!this._where[key]) {
        this._where[key] = {};
      }
      this._where[key][condition] = Parse._encode(value);
      return this;
    }
810475
def between(y, z):
        """"""
        return _combinable(lambda x: (y <= x < z) or _equal_or_float_equal(x, y))
124042
@Override
    public RangeCondition build() {
        return new RangeCondition(boost, field, lower, upper, includeLower, includeUpper, docValues);
    }
210976
def _generate_conditions(self, map_slice):
        
        conditions = []
        for dim, dim_slice in zip(self.kdims, map_slice):
            if isinstance(dim_slice, slice):
                start, stop = dim_slice.start, dim_slice.stop
                if dim.values:
                    values = dim.values
                    dim_slice = slice(None if start is None else values.index(start),
                                      None if stop is None else values.index(stop))
                if dim_slice == slice(None):
                    conditions.append(self._all_condition())
                elif start is None:
                    conditions.append(self._upto_condition(dim_slice))
                elif stop is None:
                    conditions.append(self._from_condition(dim_slice))
                else:
                    conditions.append(self._range_condition(dim_slice))
            elif isinstance(dim_slice, (set, list)):
                if dim.values:
                    dim_slice = [dim.values.index(dim_val)
                                 for dim_val in dim_slice]
                conditions.append(self._values_condition(dim_slice))
            elif dim_slice is Ellipsis:
                conditions.append(self._all_condition())
            elif callable(dim_slice):
                conditions.append(dim_slice)
            elif isinstance(dim_slice, (tuple)):
                raise IndexError("Keys may only be selected with sets or lists, not tuples.")
            else:
                if dim.values:
                    dim_slice = dim.values.index(dim_slice)
                conditions.append(self._value_condition(dim_slice))
        return conditions
1144597
function(range) {
			if (this.overlap(range)) {
				var start = Math.max(range.start, this.start);
				var end = Math.min(range.end, this.end);
				return new Range(start, end - start);
			}
			
			return null;
		}
1055868
public AVQuery<T> whereContainedIn(String key, Collection<? extends Object> values) {
    conditions.whereContainedIn(key, values);
    return this;
  }
1363388
public static Between between( String property, int minimum, int maximum)
    {
    return new Between( notLessThan( property, minimum), notMoreThan( property, maximum));
    }
753290
def between(arg, lower, upper):
    
    lower = as_value_expr(lower)
    upper = as_value_expr(upper)

    op = ops.Between(arg, lower, upper)
    return op.to_expr()
862318
def in_range(x: int, minimum: int, maximum: int) -> bool:
    
    return (x >= minimum and x <= maximum)
1138007
boolean rangeEquals(final int start, final int count, final String cached) {
        return rangeEquals(charBuf, start, count, cached);
    }