rubylabs 0.7.5 → 0.8.0

data/lib/permute.rb

@@ -0,0 +1,30 @@
+=begin rdoc
+  Permute the order of items in x.  Does not copy x -- shuffles the
+  items in place.  Works for strings, arrays, any container that responds to
+  length, [], and []=
+=end
+
+# :begin :permute! :random
+  def permute!(x)
+    for i in 0..x.length-2
+      r = random(i, x.length-1)
+      x[i], x[r] = x[r], x[i]
+    end
+    return x
+  end
+# :end :permute!
+
+=begin rdoc
+  A "helper method" for permute! that makes it easier to see which two
+  locations are being swapped.  A call to random(i,j) returns a random
+  integer in the range i..j.  See also PRNG::random
+=end
+
+# :begin :random
+  def random(min, max)
+    return nil if max < min
+    range = max - min + 1
+    return rand(range) + min
+  end
+# :end :random
+

data/lib/randomlab.rb

@@ -7,10 +7,17 @@ Random number generators and associated methods.
 
 =end
 
+=begin
+  TODO number line -- mini-histogram, e.g. second tick drawn above first? else explain in lab manual / reference why two values per tickmark
+  TODO another thing for documentation: diff between p.random(x,y) and random(x,y) [latter uses Ruby's PRNG]
+=end
+
 module RubyLabs
 	
 module RandomLab
   
+  require "permute.rb"
+  
 =begin rdoc
   Pseudo-random number generator.  Constraints on a, c, and m:
   *  c and m must be relatively prime
@@ -80,39 +87,13 @@ module RandomLab
     (0..51).map { |i| Card.new(i) }
   end
 
-=begin rdoc
-  Permute the order of items in x.  Does not copy x -- shuffles the
-  items in place.  Works for strings, arrays, any container that responds to
-  length, [], and []=
-=end
-
-# :begin :permute
-  def permute(x)
-    for i in 0..x.length-2
-      r = random(i, x.length-1)
-      x[i], x[r] = x[r], x[i]
-    end
-    return x
-  end
-# :end :permute
-
-=begin rdoc
-  A "helper method" for permute, that makes it easier to see which two
-  locations are being swapped.  A call to random(i,j) returns a random
-  integer in the range i..j.  See also PRNG::random
-=end
-
-  def random(min, max)
-    return nil if max < min
-    range = max - min + 1
-    return rand(range) + min
-  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
+  of an array during the execution of the permute! method
 =end
 
+# Note: permute! moved to own source file, permute.rb
+
   def brackets(a, i, r)
     res = "#{r}: "
     if i <= 0

data/lib/recursionlab.rb

@@ -64,18 +64,18 @@ Recursive implementation of binary search.
 
 =end
 
-# :begin :rsearch
-  def rsearch(a, k, lower = -1, upper = a.length)
+# :begin :rbsearch
+  def rbsearch(a, k, lower = -1, upper = a.length)
     mid = (lower + upper) / 2
     return nil if upper == lower + 1      # search fails if the region is empty
     return mid if k == a[mid]             # search succeeds if k is at the midpoint
     if k < a[mid]
-      return rsearch(a, k, lower, mid)
+      return rbsearch(a, k, lower, mid)
     else
-      return rsearch(a, k, mid, upper)
+      return rbsearch(a, k, mid, upper)
     end
   end
-# :end :rsearch
+# :end :rbsearch
 
 =begin rdoc
 A helper method that can be called from a probe to display the contents
@@ -116,30 +116,38 @@ combine successively bigger pieces of the input array.
 
 =end
 
-# :begin :msort :merge :less
-	def msort(a)
-	  g = 1                       # group size
-	  while g < a.length
-  	  tmp = []                  # append merged groups to this array
-	    i = 0                     # first group starts here
-	    while i < a.length
-	      tmp += merge(a, i, g)   # merge groups at a[i] and a[i+g], append to tmp
-	      i += 2*g                # next groups starts 2*g places to the right of i
-	    end
-	    g *= 2                    # double the group size
-	    a = tmp                   # a now refers to array just built
-	  end
-  	return a
-	end
+# :begin :msort :merge :merge_groups :less
+def msort(array)
+  a = array.clone
+  size = 1
+  while size < a.length
+    merge_groups(a, size)
+    size = size * 2
+  end
+	return a
+end
 # :end :msort
 
-# "Helper function" to merge two blocks.  A call of the form merge(a, i, n) creates
-# a new list by merging n-element lists at a[i] and a[i+n].
+# "Helper method" to merge all groups of size g
+
+# :begin :merge_groups
+def merge_groups(a, gs)
+  i = 0                            # first group starts here
+  while i < a.length
+    j = i + 2*gs - 1               # end of second group
+    a[i..j] = merge(a, i, gs)      # merge groups at a[i] and a[i+g]
+    i += 2*gs                      # next groups starts 2*g places to the right
+  end
+end
+# :end :merge_groups
+
+# "Helper method" to merge two blocks.  A call of the form merge(a, i, n) creates
+# a new list by merging n-element lists starting at a[i] and a[i+n].
 
 # :begin :merge
-  def merge(a, i, n)    # :nodoc:
-    ix = j = min(i + n, a.length)
-    jx = min(j + n, a.length)
+  def merge(a, i, gs)    # :nodoc:
+    ix = j = min(i + gs, a.length)
+    jx = min(j + gs, a.length)
     res = []
     while i < ix || j < jx
       if j == jx || i < ix && less( a[i], a[j] )

data/lib/rubylabs.rb

@@ -10,8 +10,7 @@ Methods used to monitor execution of programs during experiments.
 
 SCRIPT_LINES__ = Hash.new unless defined? SCRIPT_LINES__
 
-# $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'bin'))
-
+autoload :IntroLab, 		  "introlab.rb"
 autoload :SieveLab, 		  "sievelab.rb"
 autoload :IterationLab,   "iterationlab.rb"
 autoload :RecursionLab,   "recursionlab.rb"
@@ -24,6 +23,10 @@ autoload :ElizaLab, 		  "elizalab.rb"
 autoload :SphereLab,      "spherelab.rb"
 autoload :TSPLab, 			  "tsplab.rb"
 
+autoload :Demos,     		  "demos.rb"
+
+include Math
+
 module RubyLabs
 
 =begin rdoc
@@ -43,7 +46,7 @@ Log base 2.
 =end
 
   def log2(x)
-    Math.log(x) / Math.log(2.0)
+    log(x) / log(2.0)
   end
   
 =begin rdoc
@@ -55,31 +58,17 @@ Log base 2.
   end
   
 =begin rdoc
-  Return the smaller of a and b
+  Return the smaller of +a+ and +b+
 =end
 
   def min(a,b)
     a < b ? a : b
   end
-  
-# =begin rdoc
-#   Return a copy of object x with the elements in a new, scrambled order.  The
-#   parameter x can be any object that has an index operator (e.g. strings or
-#   arrays).
-# =end
-#   
-#   def permutation(x)
-#     res = x.clone
-#     for i in 0..res.length-2
-#       r = rand(res.length-i) + i
-#       res[i], res[r] = res[r], res[i]
-#     end
-#     return res
-#   end
+
   
 =begin rdoc
   
-Call time { foo(...) } to measure the execution time of a call to foo.  This
+Call +time { foo(...) }+ to measure the execution time of a call to +foo+.  This
 method will time any arbitrary Ruby expression.
 
 =end
@@ -157,9 +146,6 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
 # to keep around for very few calls, but it's efficient enough -- making an array
 # of 100K items takes less than a second.
 
-# The @spread variable controls the average spacing between items.  The 6.667 for
-# small arrays means an array of 15 will have numbers between 0 and 99.
-
 # An earlier version used a method named test_array to make a regular Array object
 # and augment it with the location method, but the singleton's methods were not passed
 # on to copies made by a call to sort:
@@ -169,72 +155,93 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
 #   NoMethodError: undefined method `random' for [4, 13, 16]:Array
  
   class TestArray < Array
-        
-    def initialize(size)
-      @spread = (size > 50) ? 10 : 6.667
-  		@h = Hash.new
 
-  		while @h.size < size
-  			@h[ rand( size * @spread ) ] = 1		
-  		end
+	  data = File.join(File.dirname(__FILE__), '..', 'data', 'arrays')    
+	  
+		@@sources = {
+		  :cars => "#{data}/cars.txt",
+		  :colors => "#{data}/colors.txt",
+		  :fruits => "#{data}/fruit.txt",
+		  :words => "#{data}/wordlist.txt",
+		}
 
-  		@h.keys.each do |k|
-  		  self << k
-  		end    
+    def initialize(size, src = nil)
+      
+      if src.nil? || src.class == Fixnum
+        raise "TestArray: array size must be an integer" unless size.class == Fixnum
+        if src.nil?
+          @max = (size < 50) ? 100 : (10 * size)
+        else
+          @max = src
+          raise "TestArray: max must be at least 2x larger than size" unless @max >= 2 * size
+        end
+      else
+        raise "TestArray: array size must be an integer or :all" unless size.class == Fixnum || size == :all
+      end
+       
+  		@h = Hash.new
+  		
+  		# if @max is defined make an array of integers, otherwise src defines the type of data;
+  		# size might be :all, in which case return the whole file, and set @all to true so random
+  		# doesn't try to make a random value not in the array.
+  		
+  		if @max
+    		while @h.size < size
+    			@h[ rand( @max ) ] = 1		
+    		end
+  		else
+  			fn = @@sources[src] or raise "TestArray: undefined source: #{src}"
+  			@words = File.open(fn).readlines
+  			if size != :all
+          max = @words.length
+    			raise "TestArray: size must be less than #{max} for an array of #{src}" unless size < max
+    			while @h.size < size
+    			  @h[ @words[ rand(max) ].chomp ] = 1
+    			end
+  			end
+		  end
+		  		
+			if size == :all
+			  self.concat @words.map { |s| s.chomp! }
+			  @all = true
+		  else
+  		  self.concat @h.keys
+        for i in 0..length-2
+          r = rand(length-i) + i      # i <= r < length
+          self[i],self[r] = self[r],self[i]
+        end
+		  end
+		  
     end
     
     def random(outcome)
       if outcome == :success
         return self[ rand(self.length) ]
       elsif outcome == :fail
+        raise "TestArray#random: array is universal set" if @all
         loop do
-          i = rand( self.length * @spread )
-          return i if @h[i] == nil
+          if @max
+            x = rand( @max )
+          else
+            x = @words[ rand( @words.length ) ].chomp
+          end
+          return x if @h[x] == nil
         end
       else
         return nil
       end
     end
-    
-  end       # class TestArray	
-	
-=begin rdoc
-	
-=== RandomArray
-
-Similar to TestArray, but draws random words from a file.
-
-=end
-
-  class RandomArray < Array
-
-	  data = File.join(File.dirname(__FILE__), '..', 'data', 'arrays')    
-	  
-		@@sources = {
-		  :cars => "#{data}/cars.txt",
-		  :colors => "#{data}/colors.txt",
-		  :fruit => "#{data}/fruit.txt",
-		  :words => "#{data}/wordlist.txt",
-		}
 
-		def initialize(src, n)
-			fn = @@sources[src] or raise "RandomArray: undefined array type: #{src}"
-			words = File.open(fn).readlines
-			a = Hash.new
-			while a.size < n
-			  w = words[rand(words.length)].chomp
-				a[w] = 1		
-			end
-			a.keys.each do |w|
-			  self << w
-			end
-		end
-		
-		def RandomArray.sources
+		def TestArray.sources
 		  return @@sources.keys.sort { |a,b| a.to_s <=> b.to_s }
 	  end
-
-	end # RandomArray
+	      
+  end       # class TestArray	
+  
+  
+  def TestArray(n, type = nil)
+    TestArray.new(n, type)
+  end
 	
 	
 =begin
@@ -406,7 +413,8 @@ Similar to TestArray, but draws random words from a file.
   							next
 					    end
 						end
-						if s =~ /:end\s+:#{id.to_s}/
+            # if s =~ /:end\s+:#{id.to_s}\b/
+						if s =~ /:end\s+:#{id.to_s}\s/
 						  size = line_num - base
 							throw :found
 						end
@@ -565,11 +573,25 @@ Similar to TestArray, but draws random words from a file.
     # synch the drawing thread....
     
     def Canvas.sync
-      if RUBY_VERSION =~ %r{^1\.8} && RUBY_PLATFORM =~ %r{darwin} && caller[2] =~ %r{workspace}
+      if RUBY_VERSION =~ %r{^1\.8} && RUBY_PLATFORM =~ %r{darwin} && caller[1].index("(irb)") == 0
         sleep(0.1)
       end
     end
     
+=begin rdoc
+  Add text at (x, y).  Note -- looks like :anchor is required, otherwise runtime error
+  from Tk (something about illegal coords).
+=end
+
+    def Canvas.text(s, x, y, opts = {})
+      return nil unless @@canvas
+      opts[:anchor] = :nw
+      opts[:text] = s
+      text = TkcText.new( @@canvas, x, y, opts)
+      @@objects << text
+      return text
+    end
+    
 =begin rdoc
   Draw a line from (x0,y0) to (x1,y1)
 =end
@@ -666,8 +688,8 @@ Similar to TestArray, but draws random words from a file.
       (0...a.length).step(2) do |i| 
         x = a[i] - x0
         y = a[i+1] - y0
-        a[i]   = x0 + x * Math.cos(theta) - y * Math.sin(theta)
-        a[i+1] = y0 + x * Math.sin(theta) + y * Math.cos(theta)
+        a[i]   = x0 + x * cos(theta) - y * sin(theta)
+        a[i+1] = y0 + x * sin(theta) + y * cos(theta)
       end
       obj.coords = a
       return a

data/lib/sievelab.rb

@@ -10,19 +10,18 @@ filtering step until no more composite numbers are left in the worklist.
 
 =end
 
-include Math
-
 module RubyLabs
 	
 module SieveLab
-		
-# Call sieve(n) to create an array of prime numbers between 2 and n
+
+=begin rdoc
+  Call +sieve(n)+ to create an array of prime numbers between +2+ and +n+  
+=end
 
 # :begin :sieve
 	def sieve(n)
-		return [] if n < 2
-	  worklist = []
-		(n-1).times { |i| worklist << i+2 }
+	  return [] if n < 2
+	  worklist = Array(2..n)
 		primes = []
 	
 	  while worklist.first < sqrt(n)
@@ -34,25 +33,6 @@ module SieveLab
 	end
 # :end :sieve
 
-
-# A first version of the sieve, iterates until the worklist is empty
-
-# :begin :proto_sieve
-	def proto_sieve(n)
-		return [] if n < 2
-	  worklist = []
-		(n-1).times { |i| worklist << i+2 }
-		primes = []
-	
-	  while worklist.length > 0
-	    primes << worklist.first
-	    worklist.delete_if { |x| x % primes.last == 0 }
-	  end
-
-		return primes
-	end
-# :end :proto_sieve
-
 end # SieveLab
 
 end # RubyLabs

data/lib/spherelab.rb

@@ -7,8 +7,6 @@ Definition of Vector and Body objects used for n-body simulations.
 
 =end
 
-include Math
-
 module RubyLabs
 	
 module SphereLab
@@ -18,7 +16,7 @@ module SphereLab
   global values.
 =end
   
-  @@dataDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'spheres')
+  @@sphereDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'spheres')
 
   @@viewerOptions = {
     :dotColor => '#000080',
@@ -210,6 +208,17 @@ module SphereLab
       end
       @force = Vector.new(0.0, 0.0, 0.0)
     end
+    
+    def clone
+      copy = super
+      if graphic
+        copy.position = position.clone
+        copy.velocity = velocity.clone
+        copy.force = force.clone
+        copy.graphic = Canvas.circle(prevx, prevy, size, :fill => color)
+      end
+      return copy
+    end
   
     def inspect
       name = @name ? @name : ""
@@ -398,7 +407,8 @@ module SphereLab
   end
   
   def set_flag(fx, fy)
-    Canvas.circle( fx, fy, 3, :fill => 'darkblue' )
+    r = 3.0
+    Canvas.circle( fx + r/2, fy + r/2, r, :fill => 'darkblue' )
     @reference = [ fx, fy ]          
   end
     
@@ -475,8 +485,8 @@ module SphereLab
   def falling_bodies(n)
     raise "n must be 5 or more" unless n >= 5
     a = random_bodies(n-1, n-1)
-    # b = Body.new(1e13, (a[0].position + a[1].position), Vector.new(0,0,0))
-    b = Body.new(1e13, (a[0].position + a[1].position)*0.85, Vector.new(0,0,0))
+    b = Body.new(1e13, (a[0].position + a[1].position), Vector.new(0,0,0))
+    # b = Body.new(1e13, (a[0].position + a[1].position)*0.85, Vector.new(0,0,0))
     # pos = a[0].position
     # (1..(n-2)).each { |i| pos.add( a[i].position ) }
     # b = Body.new(1e14, pos * (1.0 / n), Vector.new(0,0,0))
@@ -506,7 +516,7 @@ module SphereLab
 	    end
 	    filename = args[0]
   	  if filename.class == Symbol
-  	    filename = File.join(@@dataDirectory, filename.to_s + ".txt")
+  	    filename = File.join(@@sphereDirectory, filename.to_s + ".txt")
       end
       File.open(filename).each do |line|
         line.strip!
@@ -521,7 +531,7 @@ module SphereLab
         b.color = a[-1]
         bodies << b
       end
-      if args[0] == :urey
+      if args[0] == :melon
         class <<bodies[0]
           def height
             return 0 if prevy.nil?
@@ -538,6 +548,27 @@ module SphereLab
 		return bodies
 	end
 	
+=begin rdoc
+  Write the mass, position, and velocity for each body to a file.  Not intended to
+  be used by students, but used to save interesting data sets they can load and use.
+=end
+
+# d 4.5e16 300 -75 0 -5 2 0 6 #ff6666
+
+	
+	def save_system(b, fn)
+	  raise "file exists" if File.exists?(fn)
+	  File.open(fn, "w") do |f|
+	    b.each do |x|
+	      f.printf "%s %g %g %g %g %g %g %g %d %s\n", 
+	        x.name, x.mass, 
+	        x.position.x, x.position.y, x.position.z, 
+	        x.velocity.x, x.velocity.y, x.velocity.z, 
+	        x.size, x.color
+	    end
+	  end
+	end
+	
 =begin rdoc
   Initialize the drawing canvas by drawing a circle for each body in list b.
 =end
@@ -571,31 +602,26 @@ module SphereLab
   Demonstrate adding force vectors by moving only one body
 =end
 
-  def update_one(bodies, time)
-    b = bodies[0]
-    if b.graphic.nil?
+  def update_one(falling, stationary, time)
+    if falling.graphic.nil?
       puts "display the system with view_system"
       return nil
     end
-    for j in 1...bodies.length
-      Body.interaction( b, bodies[j] )
+    stationary.each do |x|
+      Body.interaction( falling, x )
     end
-    b.move(time)
+    falling.move(time)
     if @@drawing.options.has_key?(:dash)
       @@drawing.options[:dashcount] = (@@drawing.options[:dashcount] + 1) % @@drawing.options[:dash]
       if @@drawing.options[:dashcount] == 0
         @@drawing.options[:pendown] = @@drawing.options[:pendown].nil? ? :track : nil
       end        
     end
-    newx, newy = scale(b.position, @@drawing.origin, @@drawing.scale)
-    Canvas.move(b.graphic, newx-b.prevx, newy-b.prevy, @@drawing.options[:pendown])
-    b.prevx = newx
-    b.prevy = newy
-    b.clear_force
-    # puts b.velocity.norm
-    # if (speed = b.velocity.norm) > 7.5
-    #   b.velocity.scale(7.5 / speed)
-    # end
+    newx, newy = scale(falling.position, @@drawing.origin, @@drawing.scale)
+    Canvas.move(falling.graphic, newx-falling.prevx, newy-falling.prevy, @@drawing.options[:pendown])
+    falling.prevx = newx
+    falling.prevy = newy
+    falling.clear_force
     Canvas.sync
     return true
   end