src.it.unimi.dsi.util.LongInterval Maven / Gradle / Ivy
Show all versions of dsiutils Show documentation
package it.unimi.dsi.util;
/*
* DSI utilities
*
* Copyright (C) 2003-2019 Paolo Boldi and Sebastiano Vigna
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; either version 3 of the License, or (at your option)
* any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
* for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, see You cannot generate an empty interval with this constructor. Use {@link Intervals#EMPTY_INTERVAL} instead.
*
* @param left the left extreme.
* @param right the right extreme (which must be greater than
* or equal to the left extreme).
*/
protected LongInterval(final long left, final long right) {
this.left = left;
this.right = right;
}
/** Returns an interval with given extremes.
*
*
You cannot obtain an empty interval with this factory method. Use {@link Intervals#EMPTY_INTERVAL} instead.
*
* @param left the left extreme.
* @param right the right extreme (which must be greater than
* or equal to the left extreme).
* @return an interval with the given extremes.
*/
public static LongInterval valueOf(final long left, final long right) {
if (left > right) throw new IllegalArgumentException("The left extreme (" + left + ") is greater than the right extreme (" + right + ")");
if (left == right) return valueOf(left);
return new LongInterval(left, right);
}
/** Returns a one-point interval.
*
*
You cannot obtain an empty interval with this factory method. Use {@link Intervals#EMPTY_INTERVAL} instead.
*
* @param point a point.
* @return a one-point interval
*/
public static LongInterval valueOf(final long point) {
if (point >= 0 && point < MAX_SINGLE_POINT) return POINT_INTERVAL[(int)point];
return new LongInterval(point, point);
}
/** Returns the interval length, that is, the number of integers
* contained in the interval.
*
* @return the interval length.
*/
public long length() {
return right - left + 1;
}
/** An alias for {@link #length()} miminised with {@link Integer#MAX_VALUE}.
* @return the interval length minimised with {@link Integer#MAX_VALUE}.
*/
@Override
public int size() {
return (int)Math.min(length(), Integer.MAX_VALUE);
}
/** An alias for {@link #length()}.
* @return the interval length.
*/
public long size64() {
return length();
}
/** Returns an iterator over the integers in this interval.
*
* @return an integer iterator over the elements in this interval.
*/
@Override
public LongBidirectionalIterator iterator() {
if (this == EMPTY_INTERVAL) return LongIterators.EMPTY_ITERATOR;
// Note that fromTo() does NOT include the last integer.
return LongIterators.fromTo(left, right + 1);
}
/** Returns an iterator over the integers in this interval larger than or equal to a given integer.
*
* @param from the starting integer.
* @return an integer iterator over the elements in this interval.
*/
@Override
public LongBidirectionalIterator iterator(final long from) {
if (this == EMPTY_INTERVAL) return LongIterators.EMPTY_ITERATOR;
// Note that fromTo() does NOT include the last integer.
final LongBidirectionalIterator i = LongIterators.fromTo(left, right + 1);
if (from >= left) {
long toSkip = Math.min(length(), from + 1 - left);
while(toSkip > 0) toSkip -= i.skip((int)Math.min(1 << 30, toSkip));
}
return i;
}
/** Checks whether this interval contains the specified integer.
*
* @param x an integer.
* @return whether this interval contains x, that is,
* whether {@link #left} ≤ x ≤ {@link #right}.
*/
public boolean contains(final int x) {
return x >= left && x <= right;
}
/** Checks whether this interval contains the specified interval.
*
* @param interval an interval.
* @return whether this interval contains (as a set) interval.
*/
public boolean contains(final LongInterval interval) {
if (interval == EMPTY_INTERVAL) return true;
if (this == EMPTY_INTERVAL) return false;
return left <= interval.left && interval.right <= right;
}
/** Checks whether this interval would contain the specified integer if enlarged in both
* directions by the specified radius.
*
* @param x an integer.
* @param radius the radius.
* @return whether this interval enlarged by radius would contain x,
* e.g., whether {@link #left}−radius ≤ x ≤ {@link #right}+radius.
*/
public boolean contains(final int x, final int radius) {
if (this == EMPTY_INTERVAL) throw new IllegalArgumentException();
return x >= left - radius && x <= right + radius;
}
/** Checks whether this interval would contain the specified integer if enlarged in each
* direction with the respective radius.
* directions by the specified radius.
*
* @param x an integer.
* @param leftRadius the left radius.
* @param rightRadius the right radius.
* @return whether this interval enlarged to the left by leftRadius
* and to the right by rightRadius would contain x,
* e.g., whether {@link #left}−leftRadius ≤ x ≤ {@link #right}+rightRadius.
*/
public boolean contains(final int x, final int leftRadius, final int rightRadius) {
if (this == EMPTY_INTERVAL) throw new IllegalArgumentException();
return x >= left - leftRadius && x <= right + rightRadius;
}
/** Compares this interval to an integer.
*
* @param x an integer.
* @return a negative integer, zero, or a positive integer as x is positioned
* at the left, belongs, or is positioned to the right of this interval, e.g.,
* as x < {@link #left},
* {@link #left} ≤ x ≤ {@link #right} or
* {@link #right} < x.
*/
public int compareTo(final int x) {
if (this == EMPTY_INTERVAL) throw new IllegalArgumentException();
if (x < left) return -1;
if (x > right) return 1;
return 0;
}
/** Compares this interval to an integer with a specified radius.
*
* @param x an integer.
* @param radius the radius.
* @return a negative integer, zero, or a positive integer as x is positioned
* at the left, belongs, or is positioned to the right of this interval enlarged by radius, that is,
* as x < {@link #left}−radius,
* {@link #left}−radius ≤ x ≤ {@link #right}+radius or
* {@link #right}+radius < x.
*/
public int compareTo(final int x, final int radius) {
if (this == EMPTY_INTERVAL) throw new IllegalArgumentException();
if (x < left - radius) return -1;
if (x > right + radius) return 1;
return 0;
}
/** Compares this interval to an integer with specified left and right radii.
*
* @param x an integer.
* @param leftRadius the left radius.
* @param rightRadius the right radius.
* @return a negative integer, zero, or a positive integer as x is positioned
* at the left, belongs, or is positioned to the right of this interval enlarged by leftRadius
* on the left and rightRadius in the right, that is,
* as x < {@link #left}−leftRadius,
* {@link #left}−leftRadius ≤ x ≤ {@link #right}+rightRadius or
* {@link #right}+rightRadius < x.
*/
public int compareTo(final int x, final int leftRadius, final int rightRadius) {
if (this == EMPTY_INTERVAL) throw new IllegalArgumentException();
if (x < left - leftRadius) return -1;
if (x > right + rightRadius) return 1;
return 0;
}
@Override
public LongComparator comparator() {
return null;
}
@Override
public LongSortedSet headSet(final long to) {
if (this == EMPTY_INTERVAL) return this;
if (to > left) return to > right ? this : valueOf(left, to - 1);
else return EMPTY_INTERVAL;
}
@Override
public LongSortedSet tailSet(final long from) {
if (this == EMPTY_INTERVAL) return this;
if (from <= right) return from <= left ? this : valueOf(from, right);
else return EMPTY_INTERVAL;
}
@Override
public LongSortedSet subSet(final long from, final long to) {
if (this == EMPTY_INTERVAL) return this;
if (from > to) throw new IllegalArgumentException("Start element (" + from + ") is larger than end element (" + to + ")");
if (to <= left || from > right || from == to) return EMPTY_INTERVAL;
if (from <= left && to > right) return this;
return valueOf(Math.max(left, from), Math.min(right, to - 1));
}
@Override
public long firstLong() {
if (this == EMPTY_INTERVAL) throw new NoSuchElementException();
return left;
}
@Override
public long lastLong() {
if (this == EMPTY_INTERVAL) throw new NoSuchElementException();
return right;
}
@Override
public String toString() {
if (this == EMPTY_INTERVAL) return "\u2205";
if (left == right) return "[" + left + "]";
return "[" + left + ".." + right + "]"; // Hoare's notation.
}
@Override
public int hashCode() {
return (int)(left * 23 + right);
}
/** Checks whether this interval is equal to another set of integers.
*
* @param o an object.
* @return true if o is an ordered set of integer containing
* the same element of this interval in the same order, or if o
* is a set of integers containing the same elements of this interval.
*/
@Override
public boolean equals(final Object o) {
if (o instanceof LongInterval)
return ((LongInterval)o).left == left && ((LongInterval)o).right == right;
else if (o instanceof LongSortedSet) { // For sorted sets, we require the same order
LongSortedSet s = (LongSortedSet) o;
if (s.size() != length()) return false;
long n = length();
LongIterator i = iterator(), j = s.iterator();
while(n-- != 0) if (i.nextLong() != j.nextLong()) return false;
return true;
}
else if (o instanceof LongSet) { // For sets, we just require the same elements
LongSet s = (LongSet) o;
if (s.size() != length()) return false;
long n = length();
LongIterator i = iterator();
while(n-- != 0) if (! s.contains(i.nextLong())) return false;
return true;
}
else return false;
}
}