Remove from the current bitmap all integers in [rangeStart,rangeEnd).

@param rangeStart inclusive beginning of range
@param rangeEnd exclusive ending of range
@deprecated use the version where longs specify the range
433524
@Deprecated
  public void remove(final int rangeStart, final int rangeEnd) {
    if (rangeStart >= 0) {
      remove((long) rangeStart, (long) rangeEnd);
    }
    // rangeStart being -ve and rangeEnd being positive is not expected)
    // so assume both -ve
    remove(rangeStart & 0xFFFFFFFFL, rangeEnd & 0xFFFFFFFFL);
  }
196933
void removeRange(int firstParagraph, int lastParagraph) {
    for(int i = 0; i < entries.size(); i++) {
      if(entries.get(i).numberOfParagraph >= firstParagraph && entries.get(i).numberOfParagraph <= lastParagraph) {
        entries.remove(i);
        i--;
      }
    }
  }
1302125
public static void resetBitmapRange(LongBuffer bitmap, int start, int end) {
    if (isBackedBySimpleArray(bitmap)) {
      Util.resetBitmapRange(bitmap.array(), start, end);
      return;
    }
    if (start == end) {
      return;
    }
    int firstword = start / 64;
    int endword = (end - 1) / 64;
    if (firstword == endword) {
      bitmap.put(firstword, bitmap.get(firstword) & ~((~0L << start) & (~0L >>> -end)));
      return;
    }
    bitmap.put(firstword, bitmap.get(firstword) & (~(~0L << start)));
    for (int i = firstword + 1; i < endword; i++) {
      bitmap.put(i, 0L);
    }
    bitmap.put(endword, bitmap.get(endword) & (~(~0L >>> -end)));
  }
568978
public static RubyRange<Integer> range(int start, int end) {
    return new RubyRange<>(IntegerSuccessor.getInstance(), start, end,
        Interval.CLOSED);
  }
1323274
public static RoaringBitmap add(RoaringBitmap rb, final long rangeStart, final long rangeEnd) {
    rangeSanityCheck(rangeStart, rangeEnd);
    if (rangeStart >= rangeEnd) {
      return rb.clone(); // empty range
    }


    final int hbStart = Util.toIntUnsigned(Util.highbits(rangeStart));
    final int lbStart = Util.toIntUnsigned(Util.lowbits(rangeStart));
    final int hbLast = Util.toIntUnsigned(Util.highbits(rangeEnd - 1));
    final int lbLast = Util.toIntUnsigned(Util.lowbits(rangeEnd - 1));

    RoaringBitmap answer = new RoaringBitmap();
    answer.highLowContainer.appendCopiesUntil(rb.highLowContainer, (short) hbStart);

    if (hbStart == hbLast) {
      final int i = rb.highLowContainer.getIndex((short) hbStart);
      final Container c =
          i >= 0 ? rb.highLowContainer.getContainerAtIndex(i).add(lbStart, lbLast + 1)
              : Container.rangeOfOnes(lbStart, lbLast + 1);
      answer.highLowContainer.append((short) hbStart, c);
      answer.highLowContainer.appendCopiesAfter(rb.highLowContainer, (short) hbLast);
      return answer;
    }
    int ifirst = rb.highLowContainer.getIndex((short) hbStart);
    int ilast = rb.highLowContainer.getIndex((short) hbLast);

    {
      final Container c = ifirst >= 0
          ? rb.highLowContainer.getContainerAtIndex(ifirst).add(lbStart,
              Util.maxLowBitAsInteger() + 1)
          : Container.rangeOfOnes(lbStart, Util.maxLowBitAsInteger() + 1);
      answer.highLowContainer.append((short) hbStart, c);
    }
    for (int hb = hbStart + 1; hb < hbLast; ++hb) {
      Container c = Container.rangeOfOnes(0, Util.maxLowBitAsInteger() + 1);
      answer.highLowContainer.append((short) hb, c);
    }
    {
      final Container c =
          ilast >= 0 ? rb.highLowContainer.getContainerAtIndex(ilast).add(0, lbLast + 1)
              : Container.rangeOfOnes(0, lbLast + 1);
      answer.highLowContainer.append((short) hbLast, c);
    }
    answer.highLowContainer.appendCopiesAfter(rb.highLowContainer, (short) hbLast);
    return answer;
  }
632676
function RangeIterator(start, end, step) {
    this.start = start;
    this.end = (end !== undefined) ? end : Math.pow(2,32);    // or should this be Number.MAX_VALUE
    this.step = (step !== undefined)
        ? step
        : (this.end >= this.start)
            ? 1
            : -1;
    this.reset();
}
113082
public function setRange(string $rangeStart = null, string $rangeEnd = null): Matomo
    {
        $this->_date = '';
        $this->_rangeStart = $rangeStart;
        $this->_rangeEnd = $rangeEnd;

        if (is_null($rangeEnd)) {
            if (strpos($rangeStart, 'last') !== false || strpos($rangeStart, 'previous') !== false) {
                $this->setDate($rangeStart);
            } else {
                $this->_rangeEnd = self::DATE_TODAY;
            }
        }

        return $this;
    }
594819
public void removeMax() {
		Node<RedBlackTreeLong<T>> e = ranges.getMax();
		e.getElement().removeMax();
		if (e.getElement().isEmpty())
			ranges.removeInstance(e.getValue(), e.getElement());
		size--;
	}
1259418
public void removeAtRange(int index, int size) {
        final int end = Math.min(mSize, index + size);
        for (int i = index; i < end; i++) {
            removeAt(i);
        }
    }
306820
public T setRange(float start, float end) {
        this.mStart = start;
        this.mEnd = end;
        updateProgressWidth();
        return self();
    }
521562
public static RubyRange<Long> range(long start, long end) {
    return new RubyRange<>(LongSuccessor.getInstance(), start, end,
        Interval.CLOSED);
  }
158511
public static IntStream numberRangeClosed(int startInclusive,
            int endInclusive, int interval) {
        return numberRange(startInclusive, endInclusive, interval,
                n -> n <= endInclusive);
    }
1327981
public static void resetBitmapRange(long[] bitmap, int start, int end) {
    if (start == end) {
      return;
    }
    int firstword = start / 64;
    int endword = (end - 1) / 64;

    if (firstword == endword) {
      bitmap[firstword] &= ~((~0L << start) & (~0L >>> -end));
      return;
    }
    bitmap[firstword] &= ~(~0L << start);
    for (int i = firstword + 1; i < endword; i++) {
      bitmap[i] = 0;
    }
    bitmap[endword] &= ~(~0L >>> -end);

  }
555636
public boolean hasIntersection(final Range range) {
		return Math.max(this.start, range.start) <= Math.min(this.end, range.end);
	}
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;
		}
533638
@Deprecated
  public static int flipBitmapRangeAndCardinalityChange(LongBuffer bitmap, int start, int end) {
    if (BufferUtil.isBackedBySimpleArray(bitmap)) {
      return Util.flipBitmapRangeAndCardinalityChange(bitmap.array(), start, end);
    }
    int cardbefore = cardinalityInBitmapWordRange(bitmap, start, end);
    flipBitmapRange(bitmap, start, end);
    int cardafter = cardinalityInBitmapWordRange(bitmap, start, end);
    return cardafter - cardbefore;
  }
718539
public Mutations<S> removeMutationsInRange(Range range) {
        return removeMutationsInRange(range.getFrom(), range.getTo());
    }