From: Bob Hutchison <hutch@...>
Date: 2007-02-23T07:34:47+09:00
Subject: Re: Range#overlap?

Hi,

On 22-Feb-07, at 2:51 PM, Daniel Finnie wrote:

> I have made some tests for the code and shown the results at http:// 
> pastie.caboo.se/42266 .  Please check the assertions with # I  
> assume by them, the paper referenced went way over my head.
>
> Dan

I modified your stuff and changed the tests around a bit. I don't  
know, maybe it'll help, maybe it won't. I'm not sure how to use the  
pastie thing, so I've just appended the code.

Cheers,
Bob

----
Bob Hutchison                  -- blogs at <http://www.recursive.ca/ 
hutch/>
Recursive Design Inc.          -- <http://www.recursive.ca/>
Raconteur                      -- <http://www.raconteur.info/>
xampl for Ruby                 -- <http://rubyforge.org/projects/xampl/>



## These are the tests and the code from P-C David
class Range
   # self:   |---|
   # other:         |---|
   def before?(other)
     self.end < other.begin
   end

   # self:          |---|
   # other:  |---|
   def after?(other)
     other.before?(self)
   end

   # self:  |---|
   # other:     |---|
   def meets?(other)
     self.end == other.begin
   end

   # self:      |---|
   # other: |---|
   def met_by?(other)
     other.meets?(self)
   end

   # self:  |---|
   # other:   |---|
   def overlaps?(other)
     (self.begin < other.begin) and
     (other.begin < self.end) and
     (self.end < other.end)
   end

   # self:    |---|
   # other: |---|
   def overlapped_by?(other)
     other.overlaps?(self)
   end

   # self:  |---|
   # other: |-----|
   def starts?(other)
     (self.begin == other.begin) and
     (self.end < other.end)
   end

   # self:  |-----|
   # other: |---|
   def started_by?(other)
     other.starts?(self)
   end

   # self:    |---|
   # other: |-----|
   def finishes?(other)
     (self.end == other.end) and
     (other.begin < self.begin)
   end

   # self:  |-----|
   # other:   |---|
   def finished_by?(other)
     other.finishes?(self)
   end

   # self:     |---|
   # other:  |-------|
   def during?(other)
     (other.begin < self.begin) and
     (self.end < other.end)
   end

   # self:  |-------|
   # other:   |---|
   def contains?(other)
     other.during?(self)
   end

   # self:   |---|
   # other:  |---|
   def equals?(other)
     (self.begin == other.begin) and
     (self.end == other.end)
   end

   def disjoint?(other)
     (self.end <= other.begin) or
     (other.end <= self.begin)
   end

end

if $0 == __FILE__
   require 'test/unit'

   class TestRange < Test::Unit::TestCase
     def determine(a, b)
       m = a.match(/([\. ]*)([^\. ]*)/)
       interval1 = (1 + $1.length)..($1.length + $2.length)

       m = b.match(/([\. ]*)([^\. ]*)/)
       interval2 = (1 + $1.length)..($1.length + $2.length)

       result = []

       result << :before if interval1.before?(interval2)
       result << :after if interval1.after?(interval2)
       result << :meets if interval1.meets?(interval2)
       result << :met_by if interval1.met_by?(interval2)
       result << :overlaps if interval1.overlaps?(interval2)
       result << :overlapped_by if interval1.overlapped_by?(interval2)
       result << :starts if interval1.starts?(interval2)
       result << :started_by if interval1.started_by?(interval2)
       result << :finishes if interval1.finishes?(interval2)
       result << :finished_by if interval1.finished_by?(interval2)
       result << :during if interval1.during?(interval2)
       result << :contains if interval1.contains?(interval2)
       result << :equals if interval1.equals?(interval2)
       result << :disjoint if interval1.disjoint?(interval2)

       puts "[#{interval1}] [#{interval2}] --> #{result.inspect}"

       return result
     end

     def test_intervals
       assert (determine("111........",
                         "....222....") - [:before, :disjoint]).empty?
       assert (determine("11111......",
                         "....222....") - [:meets, :disjoint]).empty?
       assert (determine("111111......",
                         "....222....") - [:overlaps]).empty?
       assert (determine("1111111....",
                         "....222....") - [:finished_by]).empty?
       assert (determine("....111....",
                         "2222222....") - [:finishes]).empty?
       assert (determine("11111111111",
                         "....222....") - [:contains]).empty?
       assert (determine("....111....",
                         "22222222222") - [:during]).empty?
       assert (determine("....111....",
                         "....222....") - [:equals]).empty?
       assert (determine("....11.....",
                         "....222....") - [:starts]).empty?
       assert (determine("....1111111",
                         "....222....") - [:started_by]).empty?
       assert (determine(".....111111",
                         "....222....") - [:overlapped_by]).empty?
       assert (determine("......11111",
                         "....222....") - [:met_by, :disjoint]).empty?
       assert (determine("........111",
                         "....222....") - [:after, :disjoint]).empty?
     end
   end
end