예제 #1
0
        // copy on write so we can cache a..a intervals and sets of that
        protected virtual void Add(Interval addition)
        {
            //[email protected]("add "+addition+" to "+intervals.toString());
            if (addition.b < addition.a)
            {
                return;
            }
            // find position in list
            // Use iterators as we modify list in place
            //for ( ListIterator iter = intervals.listIterator(); iter.hasNext(); )
            for (int i = 0; i < intervals.Count; i++)
            {
                //Interval r = (Interval)iter.next();
                Interval r = intervals[i];
                if (addition.Equals(r))
                {
                    return;
                }
                if (addition.Adjacent(r) || !addition.Disjoint(r))
                {
                    // next to each other, make a single larger interval
                    Interval bigger = addition.Union(r);
                    intervals[i] = bigger;
                    // make sure we didn't just create an interval that
                    // should be merged with next interval in list
                    while (i < intervals.Count - 1)
                    {
                        i++;
                        Interval next = intervals[i];
                        //Interval next = (Interval)iter.next();
                        if (!bigger.Adjacent(next) && bigger.Disjoint(next))
                        {
                            break;
                        }

                        // if we bump up against or overlap next, merge
                        //iter.remove();   // remove this one
                        intervals.RemoveAt(i);
                        //iter.previous(); // move backwards to what we just set
                        i--;
                        //iter.set( bigger.union( next ) ); // set to 3 merged ones
                        intervals[i] = bigger.Union(next);
                    }
                    return;
                }
                if (addition.StartsBeforeDisjoint(r))
                {
                    // insert before r
                    //iter.previous();
                    //iter.add( addition );
                    intervals.Insert(i, addition);
                    return;
                }
                // if disjoint and after r, a future iteration will handle it
            }
            // ok, must be after last interval (and disjoint from last interval)
            // just add it
            intervals.Add(addition);
        }
예제 #2
0
        /** 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);
        }