rubylabs 0.8.3 → 0.9.0

data/VERSION

@@ -1 +1 @@
-0.8.3
+0.9.0

data/lib/bitlab.rb

@@ -590,7 +590,6 @@ module BitLab
       Canvas.move(tree.drawing.rseg, dx, dy)
       move_tree(tree.right, dx, dy)
     end
-    Canvas.sync
   end
   
   def draw_root(node, left, right)
@@ -598,8 +597,10 @@ module BitLab
     x = (left.coords.x + right.coords.x) / 2
     y = left.coords.y - 2 * @@unit
     draw_node(node, x, y)
-    node.drawing.lseg = Canvas.line(x, y, left.coords.x, left.coords.y).lower
-    node.drawing.rseg = Canvas.line(x, y, right.coords.x, right.coords.y).lower
+    node.drawing.lseg = Canvas::Line.new(x, y, left.coords.x, left.coords.y)
+    node.drawing.rseg = Canvas::Line.new(x, y, right.coords.x, right.coords.y)
+    node.drawing.lseg.lower
+    node.drawing.rseg.lower
     # [left, right].each do |desc|
     #   desc.drawing.ftext.delete
     #   desc.drawing.ftext = nil
@@ -610,9 +611,9 @@ module BitLab
     return nil unless @@drawing
     opts = @@drawing.options
     d = @@unit
-    circ = Canvas.circle( x, y, d / 2, :fill => opts[:nodefill] )
-    text = Canvas.text( node.char, x, y, :anchor => :center )
-    ftext = Canvas.text( node.freq.to_s, x, y-d, {:font => opts[:freqfont], :anchor => :center} )
+    circ = Canvas::Circle.new( x, y, d / 2, :fill => opts[:nodefill] )
+    text = Canvas::Text.new( node.char, x, y, :anchor => :center )
+    ftext = Canvas::Text.new( node.freq.to_s, x, y-d, {:font => opts[:freqfont].name, :anchor => :center} )
     node.drawing = NodeView.new(circ, text, ftext, nil, nil)
     node.coords = NodeCoords.new(x, y, x, 0, x, 0)
   end
@@ -626,17 +627,23 @@ module BitLab
     Canvas.init(options[:width], options[:height], "BitLab")
     @@drawing = QueueView.new(pq, options)
     options[:nodefill] = "lightgray"
-    options[:freqfont] = Canvas.font(:family => 'Helvetica', :size => 10)
+    options[:freqfont] = Canvas::Font.new('freqfont', :family => 'Helvetica', :size => 10)
     pq.on_canvas = true
     x = options[:qx]
     pq.each_with_index do |node, i|
       draw_node(node, x, options[:qy])
       x += 3 * @@unit
     end
-    Canvas.sync
     return true    
   end
   
+  # def test_setup
+  #   vf = read_frequencies(:hvfreq)
+  #   pq = init_queue(vf)
+  #   view_queue(pq)
+  #   return pq
+  # end
+
   @@unit = 24           # pixels per "tree unit"
   
   @@queueViewOptions = {
@@ -732,7 +739,7 @@ class PriorityQueue
     # end
     return res
   end
-
+  
 end
 
 class Fixnum
@@ -768,17 +775,5 @@ class Fixnum
   
 end
 
-=begin
-  TODO delete this 
-=end
-
-def test_view
-  vf = read_frequencies(:hafreq)
-  pq = init_queue(vf)
-  view_queue(pq)
-  Canvas.sync
-  return pq
-end
-
 
 

data/lib/hashlab.rb

@@ -14,7 +14,7 @@ module RubyLabs
 
 module HashLab
   
-  TableView = Struct.new(:table, :nrows)
+  TableView = Struct.new(:cells, :buckets, :nrows, :options)
   
 =begin rdoc
 
@@ -131,6 +131,7 @@ Ruby magic defines three new methods just for the new object:
     @@hash_functions = [:h0, :h1, :hr]
     
     attr_reader :table
+    attr_accessor :drawing
 
     def initialize(n, f = :hr)
       raise "HashTable: hash function must be one of #{@@hash_functions.inspect}" unless @@hash_functions.include?(f)
@@ -155,6 +156,16 @@ Ruby magic defines three new methods just for the new object:
     	i = send(@hash, s, @table.length)
       @table[i] = Array.new if @table[i].nil?
       @table[i] << s
+      if @drawing
+        options = @drawing.options
+        if @drawing.buckets[i]
+          @drawing.buckets[i].update( @table[i].join(", ") )
+        else
+          y0 = options[:tableY] + i * (options[:cellHeight] + options[:cellYSpace])
+          @drawing.buckets[i] = Canvas::Text.new(@table[i], options[:textX], y0, {:font => :bucketfont})
+          @drawing.cells[i].fill = 'white'
+        end
+      end
       return i
     end
     
@@ -239,28 +250,31 @@ Ruby magic defines three new methods just for the new object:
   end
   
 =begin rdoc
-  Initialize the canvas with a drawing of an hash table +t+ (a table is
-  just an array augmented with a hash method)
+  Initialize the canvas with a drawing of an hash table +t+
 =end
 
   def view_table(t, userOptions = {} )
     options = @@tableOptions.merge(userOptions)
-    Canvas.init(300, 500, "HashLab")
+    Canvas.init(400, 500, "HashLab")
+    Canvas::Font.new('bucketfont', :family => 'Helvetica', :size => 11)
     tbl = t.table
     x0 = options[:tableX]
     x1 = x0 + options[:cellWidth]
-    # if nil, color = gray, else color = white and draw text
-    # todo -- arrow
-    # todo -- save text, update with call to insert
+    cells = []
+    buckets = []
     nrows = min(tbl.size, options[:maxRows])
     nrows.times do |i|
       y0 = options[:tableY] + i * (options[:cellHeight] + options[:cellYSpace])
       y1 = y0 + options[:cellHeight]
-      Canvas.rectangle(x0, y0, x1, y1, :fill => options[:cellColor])
-      # Canvas.text(tbl[i].inspect, textx, y0)
+      cells << Canvas::Rectangle.new(x0, y0, x1, y1)
+      if tbl[i]
+        buckets << Canvas::Text.new(tbl[i].join(", "), options[:textX], y0, {:font => :bucketfont})
+        cells[i].fill = 'white'
+      else
+        cells[i].fill = options[:cellColor]
+      end
     end
-    @@drawing = TableView.new(t, nrows)
-    Canvas.sync
+    t.drawing = TableView.new(cells, buckets, nrows, options)
     return true    
   end
 

data/lib/marslab.rb

@@ -34,6 +34,8 @@ to assemble a program call MARS.assemble(foo).
 module RubyLabs
 	
 module MARSLab
+  
+  MARSView = Struct.new(:cells, :palettes, :options)
 
   class MARSRuntimeException < StandardError
   end
@@ -243,7 +245,7 @@ module MARSLab
 	    end
 		end
 		
-		# Major ambiguity here -- what does it mean for an word A to be "less than"
+		# Major ambiguity here -- what does it mean for a word A to be "less than"
 		# word B?  First assumption, don't compare opcodes.  Second, we're just going
 		# to implement one-field comparisons of B fields.  Otherwise for full-word operands
 		# we'd need to do a lexicographic compare of A and B fields of both operands, skipping
@@ -394,7 +396,7 @@ module MARSLab
   
   To help visualize the operation of a program the class keeps a history of memory
   references made by each thread.  A call to next automatically records the program counter
-  value, but a semantic routine can also all log(x) to append location x to a history.
+  value, but a semantic routine can also call log(x) to append location x to a history.
   Call history to get the history vectors for all threads. 
 =end
 
@@ -612,91 +614,7 @@ module MARSLab
 	  end
 	 
 	end # MiniMARS
-	
-=begin rdoc
-  Make a window to display the state of the machine
-=end
-	
-	class Draw 
-
-  	@@cellSize = 8
-  	@@cellRows = 32
-  	@@cellCols = 128
-  	@@padding = @@cellSize
-  	@@traceSize = 10
-  	@@cellColor = '#CCCCCC'
-
-  	def paintCell(i, color)
-  		@cells[i]['fill'] = color
-  	end
-
-  	def fillCanvas(mem)
-  		@cells = []
-  		mem.each_with_index do |val, i|	
-  			x = (i % @@cellCols) * @@cellSize + @@padding
-  			y = (i / @@cellCols) * @@cellSize + @@padding
-  			@cells << TkcRectangle.new( @canvas, x, y, x+@@cellSize, y+@@cellSize, :outline => "#888888", :fill => @@cellColor )
-  		end
-  	end
-  	
-  	def reset
-  	  @cells.each do |cell|
-  	    cell['fill'] = @@cellColor
-  	  end
-  	end
-  	
-  	# Make a range of colors starting from first and going to last in n steps.
-  	# First and last are expected to be 3-tuples of integer RGB values.  The
-  	# result is an array that starts with first, has n-1 intermediate colors,
-  	# and ends with last.  Example: 
-  	#    makePalette( [255,0,0], [0,0,0], 10) 
-  	# makes 11 colors starting with red and ending with black.
-
-  	def makePalette(first, last, n)
-  		d = Array.new(3)
-  		3.times { |i| d[i] = (first[i] - last[i]) / n }
-  		a = [first]
-  		(n-1).times do |i|
-  			a << a.last.clone 
-  			3.times { |j| a.last[j] -= d[j] }
-  		end
-  		a << last
-  		a.map { |c| sprintf("#%02X%02X%02X",c[0],c[1],c[2]) }
-  	end
-
-  	def updateCells(pc)
-  	  id = pc.id
-  	  a = pc.history[pc.current[:thread]]
-  		d = @palette[id].length - a.length
-  		a.each_with_index do |x, i| 
-  			paintCell(x, @palette[id][i+d])
-  		end
-  	end
-
-  	def initialize(parent) 
-  		content = TkFrame.new(parent)
-  		@canvas = TkCanvas.new(content, :borderwidth => 1,
-  			:width => @@cellCols*@@cellSize+@@padding, :height => @@cellRows*@@cellSize+@@padding) 
-  		fillCanvas(Array.new(4096))
-  		
-  		@canvas.grid :column => 0, :row => 0, :columnspan => 4, :padx => 10, :pady => 10
-  		content.pack :pady => 20
-
-  		# initialize palettes with blends from a dingy color to gray, then
-  		# add a bright color as the last item
-
-  		@palette = [
-  			makePalette( [204,204,204], [204,100,100], @@traceSize ), 
-  			makePalette( [204,204,204], [100,100,204], @@traceSize ),
-  			makePalette( [204,204,204], [100,204,100], @@traceSize ),
-  		]
-  		@palette[0] << "#FF0000"
-  		@palette[1] << "#0000FF"
-  		@palette[2] << "#00FF00"
-  	end 
-
-  end # class Draw
-  
+	  
   
 =begin rdoc
   The MARS module is a package that has the methods used to assemble, load, and execute
@@ -890,7 +808,7 @@ module MARSLab
   		  printf("%04d: %s\n", pc.current[:addr], instr) if @@params[:tracing]
 
         if @@drawing
-          @@drawing.updateCells(pc)
+          MARS.updateCells(pc)
           sleep(@@params[:pace])
         end
       
@@ -967,63 +885,89 @@ module MARSLab
   only when no programs are loaded)
 =end
 
-  def MARS.set_option(key, val)
-    if ! @@entries.empty?
-      puts "Options can be set only when no programs are loaded (call 'reset' to clear programs)"
-      return false
-    end
-    case key
-    when :memSize
-      if val.class != Fixnum || val < 1024 || val > 16536
-        puts ":memSize must be an integer between 1024 and 16536"
-        return nil
-      end
-    when :maxRounds, :buffer
-      if val.class != Fixnum
-        puts ":#{key} must be an integer"
-        return nil
+    def MARS.set_option(key, val)
+      if ! @@entries.empty?
+        puts "Options can be set only when no programs are loaded (call 'reset' to clear programs)"
+        return false
       end
-    when :pace
-      if val.class != Float
-        puts ":#{key} must be an floating point number (e.g. 0.05)"
-        return nil
-      end
-    when :tracing
-      if ! (val.class == TrueClass || val.class == FalseClass)
-        puts ":tracing must be true or false"
+      case key
+      when :memSize
+        if val.class != Fixnum || val < 1024 || val > 16536
+          puts ":memSize must be an integer between 1024 and 16536"
+          return nil
+        end
+      when :maxRounds, :buffer
+        if val.class != Fixnum
+          puts ":#{key} must be an integer"
+          return nil
+        end
+      when :pace
+        if val.class != Float
+          puts ":#{key} must be an floating point number (e.g. 0.05)"
+          return nil
+        end
+      when :tracing
+        if ! (val.class == TrueClass || val.class == FalseClass)
+          puts ":tracing must be true or false"
+          return nil
+        end
+      else
+        puts "Unknown option: #{key}"
         return nil
       end
-    else
-      puts "Unknown option: #{key}"
-      return nil
+      @@params[key] = val
     end
-    @@params[key] = val
-  end
 	
 =begin rdoc
   view() -- open a visual view of the machine state
+  
+	initialize palettes with blends from a dingy color to gray, then
+	add a bright color as the last item
 =end
 
-    def MARS.view
-      require 'tk'
-    
-      if ! defined? @@tkroot
-      	@@tkroot = TkRoot.new { title "MARS" }
-    	end
-  	
-    	if @@drawing == nil
-      	@@drawing = Draw.new(@tkroot) 
-      	@@threads = []
-      	@@threads << Thread.new() do
-      		Tk.mainloop
-      	end
-    	end
+    def MARS.view(userOptions = {} )
+
+      options = @@viewOptions.merge(userOptions)
+      
+      cellsize = options[:cellSize]
+      padding = options[:padding]
+      
+      width = options[:cellCols] * cellsize + 2*padding
+      height = options[:cellRows] * cellsize + 2*padding
+      Canvas.init(width, height, "MARSLab")
+      
+      cells = []
+      for i in 0...@@displayMemSize
+  			x = (i % options[:cellCols]) * cellsize + padding
+  			y = (i / options[:cellCols]) * cellsize + padding
+  			cells << Canvas::Rectangle.new( x, y, x+cellsize, y+cellsize, :outline => "#888888", :fill => options[:cellColor] ) 
+      end
+      
+  		palettes = [
+  			Canvas.palette( [204,204,204], [204,100,100], options[:traceSize] ), 
+  			Canvas.palette( [204,204,204], [100,100,204], options[:traceSize] ),
+  			Canvas.palette( [204,204,204], [100,204,100], options[:traceSize] ),
+  		]
+  		palettes[0] << "#FF0000"
+  		palettes[1] << "#0000FF"
+  		palettes[2] << "#00FF00"
+  		
+      @@drawing = MARSView.new(cells, palettes, options)
+      return true
+      
     end
   
     def MARS.close_view
-      @@threads[0].kill
-      @@tkroot.destroy
-      @@drawing = nil
+      Canvas.close
+    end
+    
+    def MARS.updateCells(pc)
+  	  id = pc.id
+  	  a = pc.history[pc.current[:thread]]
+  		d = @@drawing.palettes[id].length - a.length
+  		a.each_with_index do |x, i|
+  		  @@drawing.cells[x].fill = @@drawing.palettes[id][i+d]
+  		end    	
     end
   
 =begin rdoc
@@ -1052,7 +996,12 @@ module MARSLab
     	@@mem = Memory.new(@@params[:memSize])
       @@entries = Array.new
       Warrior.reset
-      @@drawing.reset if @@drawing
+      if @@drawing
+        @@drawing.cells.each do |x|
+          x.fill = @@drawing.options[:cellColor]
+        end
+      end
+      return true
     end
    
 =begin rdoc
@@ -1100,7 +1049,7 @@ module MARSLab
       end
       return nil
     end
-  
+      
   end # class MARS
   
   
@@ -1136,6 +1085,15 @@ module MARSLab
     :pace => 0.01,
   }
   
+  @@viewOptions = {
+    :cellSize => 8,
+  	:cellRows => 32,
+  	:cellCols => 128,
+  	:padding => 20,
+  	:traceSize => 10,
+  	:cellColor => '#DDDDDD',
+  }
+
 	@@drawing = nil
 
   @@pcs = Array.new

data/lib/randomlab.rb

@@ -86,7 +86,20 @@ module RandomLab
   def new_deck
     (0..51).map { |i| Card.new(i) }
   end
+  
+  
+=begin rdoc
+  Compute the probability of a duplicate item in a collection of n items
+  drawn from the range [1..d].  Example: call pdup(5,52) to compute the 
+  probability if drawing the same card twice when sampling with replacement
+  5 times from a deck of 52 cards.
+=end
 
+  def pdup(n, d)
+    return 1.0 if n > d
+    return 1.0 - (1..(n-1)).inject(1.0) { |p, k| p * (1.0 - (k / 52.0)) }
+  end
+  
 =begin rdoc
   A "helper method" that can be called via a probe, to print the contents
   of an array during the execution of the permute! method
@@ -272,7 +285,7 @@ module RandomLab
   def view_numberline(npoints, userOptions = {})
     Canvas.init(500, 100, "RandomLab::NumberLine")
     options = @@numberLineOptions.merge(userOptions)
-    line = Canvas.line(0, 70, 500, 70, :width => options[:lineThickness], :fill => options[:lineColor])
+    line = Canvas::Line.new(0, 70, 500, 70, :width => options[:lineThickness], :fill => options[:lineColor])
     @@drawing = NumberLine.new(line, npoints, options)
     return true
   end
@@ -286,7 +299,7 @@ module RandomLab
 		  x0, y0, x1, y1 = @@drawing.line.coords
 			tx = (i.to_f / @@drawing.npoints) * (x1-x0)
 			ty = y0 - @@drawing.options[:tickHeight]
-			Canvas.line(tx, y0, tx, ty, :width => @@drawing.options[:tickWidth], :fill => @@drawing.options[:tickColor])
+			Canvas::Line.new(tx, y0, tx, ty, :width => @@drawing.options[:tickWidth], :fill => @@drawing.options[:tickColor])
 			sleep(@@delay)
 		end
 		return true
@@ -321,7 +334,7 @@ module RandomLab
     binTop = 280
     nbins.times do |i| 
       x = i * binWidth + binWidth/2
-      bins << Canvas.rectangle( x + binBorder, binTop, x + binWidth - binBorder, binTop + binHeight, :outline => options[:binColor], :fill => options[:binColor] ) 
+      bins << Canvas::Rectangle.new( x + binBorder, binTop, x + binWidth - binBorder, binTop + binHeight, :outline => options[:binColor], :fill => options[:binColor] ) 
     end
 
     @@drawing = Histogram.new(bins, max.to_f, keys, counts, binTop, options)
@@ -364,6 +377,7 @@ module RandomLab
       end
       @@drawing.options[:boxIncrement] /= 2
     end
+    sleep(@@delay)
     return true
   end
 
@@ -393,7 +407,7 @@ module RandomLab
       py = (y.to_f / @@drawing.max) * Canvas.height
       r = @@drawing.options[:dotRadius]
       color = @@drawing.options[:dotColor]
-      Canvas.circle( px, py, r, :outline => color, :fill => color ) 
+      Canvas::Circle.new( px, py, r, :outline => color, :fill => color ) 
 		end
 		return nil
   end
@@ -422,7 +436,7 @@ module RandomLab
   }
   
   @@drawing = nil
-  @@delay = 0.1
+  @@delay = 0.01
   
 end # RandomLab