/** Return a new set with the intersection of this set with other. Because
* the intervals are sorted, we can use an iterator for each list and
* just walk them together. This is roughly O(min(n,m)) for interval
* list lengths n and m.
*/
public IIntSet And(IIntSet other)
{
if (other == null)
{ //|| !(other instanceof IntervalSet) ) {
return(null); // nothing in common with null set
}
var myIntervals = this.intervals;
var theirIntervals = ((IntervalSet)other).intervals;
IntervalSet intersection = new IntervalSet();
int mySize = myIntervals.Count;
int theirSize = theirIntervals.Count;
int i = 0;
int j = 0;
// iterate down both interval lists looking for nondisjoint intervals
while (i < mySize && j < theirSize)
{
Interval mine = myIntervals[i];
Interval theirs = theirIntervals[j];
//[email protected]("mine="+mine+" and theirs="+theirs);
if (mine.StartsBeforeDisjoint(theirs))
{
// move this iterator looking for interval that might overlap
i++;
}
else if (theirs.StartsBeforeDisjoint(mine))
{
// move other iterator looking for interval that might overlap
j++;
}
else if (mine.ProperlyContains(theirs))
{
// overlap, add intersection, get next theirs
intersection.Intervals.Add(theirs);
j++;
}
else if (theirs.ProperlyContains(mine))
{
// overlap, add intersection, get next mine
intersection.Intervals.Add(mine);
i++;
}
else if (!mine.Disjoint(theirs))
{
// overlap, add intersection
intersection.Add(mine.Intersection(theirs));
// Move the iterator of lower range [a..b], but not
// the upper range as it may contain elements that will collide
// with the next iterator. So, if mine=[0..115] and
// theirs=[115..200], then intersection is 115 and move mine
// but not theirs as theirs may collide with the next range
// in thisIter.
// move both iterators to next ranges
if (mine.StartsAfterNonDisjoint(theirs))
{
j++;
}
else if (theirs.StartsAfterNonDisjoint(mine))
{
i++;
}
}
}
return(intersection);
}
