rubylabs 0.9.6 → 0.9.7

data/VERSION

@@ -1 +1 @@
-0.9.6
+0.9.7

data/lib/iterationlab.rb

@@ -118,20 +118,9 @@ module IterationLab
 # and reinsert it at a location between 0 and +i+ (i.e. move the item
 # to the left in the array).
 #--
-# updated 10/9/2012 for visualization
 # :begin :move_left
   def move_left(a, i)
-    # x = a.slice!(i)                 # remove the item at location i
-    # j = i-1                         # start scanning from the left of i
-    # while j >= 0 && less(x, a[j])
-    #   j = j-1                       # move left
-    # end
-    # a.insert(j+1, x)                # insert x back into a at location j    
-    if @@drawing
-      touch(i) 
-      set_region(i+1)
-      sleep(@@drawing.options[:delay])
-    end
+    init_step(a, i) if @@drawing
     while i > 0 && less(a[i], a[i-1])
       swap(a, i-1, i)
       i -= 1
@@ -140,18 +129,14 @@ module IterationLab
 # :end :move_left
 
 # Helper method called by +move_left+ to exchange the items at specified
-# locations in an array.
+# locations in an array.  If there is a visualization on the screen call
+# the helper method that swaps the locations of bars for a[i] and a[j].
 #--
 # :begin :swap
   def swap(a, i, j)
     a[i], a[j] = a[j], a[i]
-    if @@drawing.class == ArrayView
-      dist = (j - i) * @@drawing.options[:dx]
-      ri = @@drawing.rects[i]
-      rj = @@drawing.rects[j]
-      Canvas.move(ri, dist, 0)
-      Canvas.move(rj, -dist, 0)
-      @@drawing.rects[i], @@drawing.rects[j] = @@drawing.rects[j], @@drawing.rects[i]
+    if @@drawing
+      a.swap_bars(@@drawing.rects, i, j, @@drawing.options)
       sleep(@@drawing.options[:delay])
     end
   end
@@ -198,41 +183,30 @@ module IterationLab
     end
   end
   
-# Visualization
+# Visualization for isort.  Draw a vertical bar for each item in the array,
+# setting the height of bar i according to the value of a[i].  Draw a horizontal
+# progress bar below the array values.
 
   def view_array(a, userOptions = {})
     Canvas.init(800, 200, "IterationLab")
     options = @@viewOptions.merge(userOptions)
+
+    rects = TestArray.draw_bars(a, options)
+    progress = Canvas::Rectangle.new( options[:x0], options[:y1] + 10, options[:x0] + a.length*options[:dx], options[:y1]+15, :fill => options[:bar_fill] )
     
-    amax = a.max
-    rects = []
-    a.each_with_index do |val, i| 
-      rx = options[:x0] + i * options[:dx]
-      y = Float(val)
-      dy = options[:y1] - options[:y0] - options[:ymin]     # height of tallest bar
-      ry = options[:y1] - options[:ymin] - (y/amax)*dy      # height of this bar 
-      rects << Canvas::Rectangle.new( rx, ry, rx + options[:dx], options[:y1], :fill => options[:array_fill], :outline => options[:canvas_fill] ) 
-    end
-    bar = Canvas::Rectangle.new( options[:x0], options[:y1] + 10, options[:x0] + a.length*options[:dx], options[:y1]+15, :fill => options[:bar_fill] )
-    
-    @@drawing = ArrayView.new(a, rects, bar, ['#000080','#BADFEB'], [], options)
+    @@drawing = ArrayView.new(a, rects, progress, ['#000080','#BADFEB'], [], options)
     return true
   end
   
-  def touch(loc)
-    rect = @@drawing.rects[loc]
-    pmax = @@drawing.palette.length
-    @@drawing.history.pop if @@drawing.history.length >= pmax
-    @@drawing.history.insert(0, rect)
-    @@drawing.history.each_with_index do |r, i|
-      r.fill = @@drawing.palette[i]
-    end   
-  end
-  
-  def set_region(loc)
-    x1, y1, x2, y2 = @@drawing.bar.coords
-    x1 = @@drawing.options[:x0] + loc * @@drawing.options[:dx]
-    @@drawing.bar.coords = [x1, y1, x2, y2]
+# Helper method called at the start of each top level iteration if the
+# array is on the canvas -- change the color of the bar for a[i] and resize
+# the progress bar to show a[i] has been moved.
+
+  def init_step(a, i)
+    rect = @@drawing.rects[i]
+    a.touch(rect, @@drawing.history, @@drawing.palette) 
+    a.set_region(i+1, a.length, @@drawing.bar, @@drawing.options)
+    sleep(@@drawing.options[:delay])    
   end
   
 end # IterationLab

data/lib/recursionlab.rb

@@ -19,6 +19,24 @@ of the algorithms.
 
 module RecursionLab
   
+  ArrayView = Struct.new(:array, :rects, :bar, :palette, :history, :groupstart, :group, :options)
+  
+  @@viewOptions = {
+    :array_fill => 'lightblue',
+    :bar_fill => 'darkblue',
+    :canvas_fill => 'white',
+    :mark_color => 'blue',
+    :x0 => 10,                  # left edge of leftmost bar
+    :dx => 10,                  # distance between left edges of adjacent bars
+    :y0 => 50,                  # top edege of tallest bar
+    :y1 => 150,                 # bottom edge of array bars
+    :gdy => 150,                # distance between array and temp area below
+    :ymin => 3,                 # minimum height of bar
+    :delay => 0.01,
+  }
+
+  @@drawing = nil
+
 # The linear search method from iterationlab.rb is replicated here so it can be
 # used  for baseline tests.
 #--
@@ -179,15 +197,19 @@ end
     ix = j = min(i + gs, a.length)
     jx = min(j + gs, a.length)
     res = []
+    start_group(a,i,jx) if @@drawing
     while i < ix || j < jx
       if j == jx || i < ix && less( a[i], a[j] )
         res << a[i]
+        move_down(a,i) if @@drawing
         i += 1
       else
         res << a[j]
+        move_down(a,j) if @@drawing
         j += 1
       end
     end
+    move_up(a) if @@drawing
     return res
   end
 # :end :merge
@@ -246,8 +268,9 @@ end
     a = a.dup if p == 0 && r == a.length-1  # don't modify the input array (top level only)
     if p < r
       q = partition(a, p, r)                # q is boundary between small items and large items
-      qsort(a, p, q)                        # sort small items (range from p to q)
+      qsort(a, p, q-1)                      # sort small items (range from p to q)
       qsort(a, q+1, r)                      # sort large items (range from q+1 to r)
+      mark(a, q, 'lightblue') if @@drawing
     end
     return a
   end
@@ -263,20 +286,32 @@ end
 # :begin :partition
   def partition(a, p, r)        # partition the region bounded by p and r
     x = a[p]                    # x is the pivot value
-    i = p - 1
-    j = r + 1
-    while true                  # squeeze i, j until they point at items to exchange
-      loop { j = j - 1; break if a[j] <= x }
-      loop { i = i + 1; break if a[i] >= x }
-      if i < j                  
-        a[i], a[j] = a[j], a[i] # exchange items at locations i and j
-      else
-        return j                # no more exchanges; return location that separates regions
+    i = p
+    mark(a, i, 'darkgreen') if @@drawing
+    for j in (p+1)..r do
+      touch(a, j) if @@drawing
+      if a[j] <= x
+        i += 1
+        touch(a, i) if @@drawing
+        swap(a, i, j)
       end
     end
+    swap(a, p, i)
+    return i
   end
 # :end :partition
 
+# Helper method for partition -- exchange two items in the array, and if the
+# array is on the canvas, exchange the locations of the two bars
+
+def swap(a, i, j)
+  a[i], a[j] = a[j], a[i]
+  if @@drawing
+    a.swap_bars(@@drawing.rects, i, j, @@drawing.options)
+    sleep(@@drawing.options[:delay])
+  end
+end
+
 # Helper procedure used to trace the execution of qsort.
   def qsort_brackets(a, left, right)
     tmp = []
@@ -288,6 +323,81 @@ end
     return tmp.join(" ")
   end
 
+# Visualization for msort and qsort.  Draw a vertical bar for each item in the array,
+# setting the height of bar i according to the value of a[i].  Merge sort uses auxilliary
+# space for merges, so the window has room below the main array to show the merge steps.
+
+  def view_array(a, userOptions = {})
+    Canvas.init(800, 400, "RecursionLab")
+    options = @@viewOptions.merge(userOptions)
+
+    rects = TestArray.draw_bars(a, options)
+    progress = Canvas::Rectangle.new( options[:x0], options[:y1] + 10, options[:x0] + a.length*options[:dx], options[:y1]+15, :fill => options[:bar_fill] )
+
+    palette = Canvas.palette( [0,0,128], [182,224,234], 4)
+    palette[-1] = '#BADFEB'
+    
+    @@drawing = ArrayView.new(a, rects, progress, palette, [], 0, [], options)
+    return true
+  end
+  
+# Visualization method for bsearch -- resize the progress bar so it's below
+# the search region and color the bar at the midpoint of the region.  
+
+# Note this method is not called by bsearch itself.  Instead attach a probe
+# and run the method via trace.
+
+  def show_bsearch_region(a, lower, upper, mid)
+    return unless @@drawing
+    rect = @@drawing.rects[mid]
+    a.touch(rect, @@drawing.history, @@drawing.palette) 
+    a.set_region(lower+1, upper-1, @@drawing.bar, @@drawing.options)
+    sleep(@@drawing.options[:delay])    
+  end
+
+# Method called at the start of each call to merge -- position the progress
+# bar below the group and initialize the auxilliary region where merged
+# groups are put.
+
+  def start_group(a,i,j)
+    @@drawing.groupstart = i
+    @@drawing.group = []
+    a.set_region(i, j, @@drawing.bar, @@drawing.options)
+  end
+  
+# Move one of the bars from the main array to the next location in the 
+# auxilliary area
+
+  def move_down(a,i)
+    rect = @@drawing.rects[i]
+    a.touch(rect, @@drawing.history, @@drawing.palette)
+    sleep(@@drawing.options[:delay])
+    a.move_down(rect, @@drawing.groupstart, @@drawing.group, @@drawing.options)
+    sleep(@@drawing.options[:delay])
+  end
+  
+# Move all the bars from auxilliary region back up to the main array.
+
+  def move_up(a)
+    a.move_up(@@drawing.rects, @@drawing.groupstart, @@drawing.group, @@drawing.options)
+    sleep(@@drawing.options[:delay])    
+  end
+  
+# Set the fill color of the specified bar (called by qsort to indicate active regions)
+
+  def mark(a, i, color)
+    rect = @@drawing.rects[i]
+    rect.fill = color
+    sleep(@@drawing.options[:delay])    
+  end
+  
+# Update the color of a bar (cycling through the palette of colors)
+
+  def touch(a, i)
+    rect = @@drawing.rects[i]
+    a.touch(rect, @@drawing.history, @@drawing.palette) 
+  end
+  
 end # RecursionLab
 
 end # RubyLabs

data/lib/rubylabs.rb

@@ -312,6 +312,74 @@ call <tt>a.random(:success)</tt> to get a value that is in the array +a+, or cal
         return nil
       end
     end
+
+# Visualization methods called by searching and sorting algorithms in
+# IterationLab and RecursionLab.
+
+    def TestArray.draw_bars(a, options)
+      amax = a.max
+      rects = []
+      a.each_with_index do |val, i| 
+        rx = options[:x0] + i * options[:dx]
+        y = Float(val)
+        dy = options[:y1] - options[:y0] - options[:ymin]     # height of tallest bar
+        ry = options[:y1] - options[:ymin] - (y/amax)*dy      # height of this bar 
+        rects << Canvas::Rectangle.new( rx, ry, rx + options[:dx], options[:y1], :fill => options[:array_fill], :outline => options[:canvas_fill] ) 
+      end
+      return rects    
+    end
+
+# Add rectangle i to the history list, then set the color of each bar
+# in the list to the corresponding palette color
+
+    def touch(rect, history, palette)
+      pmax = palette.length
+      history.pop if history.length >= pmax
+      history.insert(0, rect)
+      history.each_with_index do |r, i|
+        r.fill = palette[i]
+      end   
+    end
+
+# Set the left and right ends of the progress bar
+
+    def set_region(i, j, bar, options)
+      x0, y0, x1, y1 = bar.coords
+      x0 = options[:x0] + i * options[:dx]
+      x1 = options[:x0] + j * options[:dx]
+      bar.coords = [x0, y0, x1, y1]
+    end
+    
+# Exchange the locations of rectangles i and j
+
+    def swap_bars(rects, i, j, options)
+      dist = (j - i) * options[:dx]
+      ri = rects[i]
+      rj = rects[j]
+      Canvas.move(ri, dist, 0)
+      Canvas.move(rj, -dist, 0)
+      rects[i], rects[j] = rects[j], rects[i]
+    end
+    
+# Move a bar down to the auxilliary area below the progress bar.  Argument 'groupstart'
+# is the index of the first bar in the area, group is the current set of bars in the area.
+
+    def move_down(rect, groupstart, group, options)
+      x0, y0, x1, y1 = rect.coords
+      newx = options[:x0] + (groupstart + group.length) * options[:dx]
+      Canvas.move(rect, newx - x0, options[:gdy])
+      group << rect
+    end
+    
+# Move all the bars in the auxilliary area straight up so they fill the space in the 
+# main array, update the array of rectangles so they correspond to the new order of bars
+
+    def move_up(rects, groupstart, group, options)
+      group.each do |rect|
+        Canvas.move(rect, 0, -options[:gdy])
+      end
+      rects[groupstart ... (groupstart + group.length)] = group
+    end
     
 # Return a list of types of items that can be passed as arguments
 # to <tt>TestArray.new</tt>
@@ -326,7 +394,7 @@ call <tt>a.random(:success)</tt> to get a value that is in the array +a+, or cal
         
   end       # class TestArray 
   
-# Equivalent to calling <tt>TestArray.new</tt>.
+# Make a new TestArray object (equivalent to calling <tt>TestArray.new</tt>).
 #
 # Examples:
 #   >> TestArray(5)
@@ -340,8 +408,7 @@ call <tt>a.random(:success)</tt> to get a value that is in the array +a+, or cal
 
   def TestArray(n, type = nil)
     TestArray.new(n, type)
-  end
-  
+  end  
   
 =begin rdoc
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rubylabs
 version: !ruby/object:Gem::Version 
-  hash: 55
+  hash: 53
   prerelease: 
   segments: 
   - 0
   - 9
-  - 6
-  version: 0.9.6
+  - 7
+  version: 0.9.7
 platform: ruby
 authors: 
 - conery
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-10 00:00:00 Z
+date: 2012-10-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rubygems-test