rubylabs 0.5.4

data/lib/sortlab.rb

@@ -0,0 +1,213 @@
+
+=begin rdoc
+  
+== SortLab
+
+Instrumented versions of the sorting algorithms described in the chapters
+on iterative algorithms and recursive algorithms.  The versions here are
+not intended to be viewed by students -- those implementations are in the
+modules named IterationLab and RecursionLab.
+
+The three public methods implemented here are +isort+ (insertion sort),
++msort+ (mergesort), and +qsort+ (quicksort).  The only required parameter
+is an array to sort.  A method will make a copy of the parameter and return
+a sorted version of the copy.
+
+An optional second parameter can be used when running experiments:
+  :trace    print the state of the array after each iteration of the outer loop
+  :count    return a count of the number of comparisons made instead of the sorted array
+  :timer    return the execution time in seconds instead of the sorted array
+
+=end
+
+module RubyLabs
+
+module SortLab
+
+=begin rdoc
+
+The Timer class implements a simpler timer.  Call +Timer.start+ to start
+the timer, and +Timer.stop+ to get the elapsed time since the call to
++Timer.start+.
+=end
+
+class Timer
+  
+  def Timer.start
+    @@tstart = Time.now
+  end
+  	
+  def Timer.stop
+    return Time.now - @@tstart
+  end
+  	
+end
+
+=begin rdoc
+Insertion sort.
+=end
+
+def isort(a, mode = nil)
+  a = a.clone
+  Timer.start if mode == :timer
+  count = 0
+  for i in 1..a.length - 1
+		puts isort_brackets(a,i) if mode == :trace
+    x = a.slice!(i)
+    j = i - 1
+    while j >= 0 && (count += 1) > 0 && a[j] > x
+      j = j - 1
+    end
+    a.insert(j + 1, x)
+  end
+  return case mode
+    when :count : count
+    when :timer : Timer.stop
+    else a
+  end
+end
+
+=begin rdoc
+Helper method for printing the state of the array during insertion sort.
+=end
+
+def isort_brackets(a, i)
+  pre = (i == 0) ? [] : a.slice(0..(i-1))
+  post = (i <= a.length) ? a.slice(i..-1) : []
+	return "[" + pre.join(", ") + "] [" + post.join(", ") + "]"
+end
+
+  
+# Merge sort.  Makes a copy of the input Array, returns a sorted
+# version of the copy.  Uses a "helper function" named merge to
+# combine successively bigger pieces of the input array.
+
+def msort(a, mode = nil)
+  a = a.clone                   # don't modify the input array!
+	Timer.start
+  n = 1                         # size of "pile" at each step
+  count = 0
+  while n < a.length
+    i = 0                       # first pile starts here
+    while i < a.length
+      count += merge(a,i,n)     # merge piles at a[i] and i+n, put at a[i]
+			print " [" + a[i..i+2*n-1].join(" ") + "] " if mode == :trace
+      i += 2*n                  # next pile starts at i+2n
+    end
+		puts if mode == :trace
+    n *= 2                      # double the pile size
+  end
+	if mode == :timer
+		return Timer.stop
+	elsif mode == :count
+	  return count
+	else
+  	return a
+	end
+end
+
+# "Helper function" to merge two "piles" in place.  A call to this method
+# merges n-element lists at a[i] and a[i+n] and stores the merged result
+# in the array starting at a[i].  Uses an auxiliary list to hold items moved
+# from a[i..i+n-1], then merges those into place at a[i+n].
+
+def merge(a, i, n)
+	aux = []
+	j = k = i + n
+	kmax = i + 2*n
+	kmax = a.length if kmax > a.length
+	count = 0
+	# phase 1 -- copy items from a[i..i+n-1] to aux
+	while i < k
+		if a[j] && a[j] < a[i] && (aux.empty? || a[j] < aux[0])
+			aux << a[i]
+			a[i] = a[j]
+			j += 1
+			count += 1
+		elsif !aux.empty? && aux[0] < a[i]
+			aux << a[i]
+			a[i] = aux.shift
+			count += 1
+		end
+		i += 1
+	end
+	# phase 2 -- merge aux into empty slots in a[i+n..i+2n]
+	while k < kmax && ! aux.empty?
+		if j == kmax || a[j] > aux[0]
+			a[k] = aux.shift
+		else
+			a[k] = a[j]
+			j += 1
+		end
+		k += 1
+		count += 1
+	end
+	return count
+end
+  
+# QuickSort, based on the description from Cormen et al.  The interface is
+# a method qsort, called with the array to sort and an optional mode parameter
+# that specifies whether to count comparisons or measure execution time.  
+
+# The actual sorting is done by qs.  The parameters (using notation from
+# Cormen et al): p is the left boundary of the region to sort, and r is
+# right boundary.  The call to partition sets q, the new boundary between
+# two sub-regions.
+
+def qsort(a, mode = nil)
+  dup = a.clone
+  Timer.start
+  if mode == :timer
+    return Timer.stop
+  else
+    count = qs(dup, 0, a.length-1, mode)
+    return mode == :count ? count : dup
+  end
+end
+
+def qs(a, p, r, mode)
+	puts bracketed(a,p,r) if mode == :trace
+  if p < r
+    q, count = partition(a, p, r)
+    count += qs(a, p, q, mode)
+    count += qs(a, q+1, r, mode)
+  else
+    count = 0
+  end
+	return count
+end
+
+# Set the pivot (called x here) to the item on the left edge of the
+# region, then extend the regions until they meet in the middle
+
+def partition(a, p, r)
+  x = a[p]
+  i = p - 1
+  j = r + 1
+  count = 0
+  while true
+    loop { j = j - 1; count += 1; break if a[j] <= x }
+    loop { i = i + 1; count += 1; break if a[i] >= x }
+    if i < j
+      a[i], a[j] = a[j], a[i]
+    else
+      return j, count
+    end
+  end
+end
+
+def bracketed(a, left, right)
+  # puts "#{left}..#{right}"
+  tmp = []
+  tmp += a[ 0 .. (left-1) ] if left > 0
+  tmp << "["
+  tmp += a[ left .. right ] if right >= 0
+  tmp << "]"
+  tmp += a[ (right+1) .. (a.length-1) ] if right < a.length
+  return tmp.join(" ")
+end
+
+end # RecursionLab
+
+end # RubyLabs
+

data/lib/spherelab.rb

@@ -0,0 +1,352 @@
+
+=begin rdoc
+  
+== SphereLab
+
+Definition of Vector and Body objects used for n-body simulations.
+
+=end
+
+module RubyLabs
+	
+module SphereLab
+
+=begin rdoc
+  The constant G is the universal gravitational constant, assuming mass is
+  in units of kilograms, distances are in meters, and time is in seconds.
+=end
+
+G = 6.67E-11
+
+
+class Vector
+  attr_accessor :x, :y, :z
+  
+=begin rdoc
+  Make a new vector with the specified x, y, and z components.
+=end
+  
+  def initialize(*args)
+    @x, @y, @z = args
+  end
+  
+  def inspect
+    sprintf "<%s, %s, %s>", @x.to_s, @y.to_s, @z.to_s
+  end
+  
+=begin rdoc
+  v1 == v2 if the three components are the same
+=end
+
+  def ==(v)
+    return (@x == v.x) && (@y == v.y) && (@z == v.z)
+  end
+
+=begin rdoc
+  Arithmetic methods are invoked for a vector v1 when Ruby evaluates an expression of the
+  form v1 <op> v2 where <op> is +, -, or *.  They create a a new vector containing the 
+  result of the operation.  + and - do element-wise addition or and subtraction, *
+  is a vector-scalar multiplication.
+=end
+  
+  def +(v)
+    Vector.new(@x + v.x, @y + v.y, @z + v.z)
+  end
+  
+  def -(v)
+    Vector.new(@x - v.x, @y - v.y, @z - v.z)
+  end
+
+  def *(a)
+    Vector.new(@x * a, @y * a, @z * a)
+  end
+
+=begin rdoc
+  v1.add(v2) adds the components of v2 to v1 -- would be v1 += v2 if Ruby
+  allowed us to overload +=
+=end
+
+  def add(v)
+    @x += v.x
+    @y += v.y
+    @z += v.z
+    self
+  end
+  
+=begin rdoc
+  v1.sub(v2) subtracts the components of v2 from v1 -- would be v1 -= v2 if Ruby
+  allowed us to overload -=
+=end
+
+  def sub(v)
+    @x -= v.x
+    @y -= v.y
+    @z -= v.z
+    self
+  end
+
+=begin rdoc
+  The magnitude of a vector is the Euclidean norm: sqrt(x**2 + y**2 + z**2)
+=end
+
+  def norm
+    Math.sqrt(@x*@x + @y*@y + @z*@z)
+  end
+  
+end # Vector
+
+
+=begin rdoc
+  A Body object represents the state of a celestial body.  A body has mass (a scalar),
+  position (a vector), and velocity (a vector).  A third vector, named force, is used
+  when calculating forces acting on a body.  The size and color attributes are used by
+  the visualization methods.
+=end
+
+class Body
+  attr_accessor :mass, :position, :velocity, :force, :name, :size, :color
+  
+=begin rdoc
+  The constructor can be called with a variety of different arguments:
+    * for the main n-body simulation, initial conditions are read from a data file,
+      and the constructor is passed three parameters:  mass, position vector, and
+      velocity vector; an optional 4th parameter is a name string
+    * for interactive experiments, pass two floats, which become the mass and the
+      x component of the velocity; an optional 3rd parameter is the name
+    * also for interactive experiments pass :rand to make a body with random
+      mass, position, and velocity
+    * pass no parameters to get a body with all attributes set to 0
+=end
+
+  def initialize(*args)
+    if args[1].class == Vector
+      @mass, @position, @velocity, @name = args
+    elsif args[0] == :random
+      @mass = rand(10000) * 1e6
+      @position = Vector.new(rand(300)-150, rand(300)-150, 0)
+      @velocity = Vector.new(rand(20)-10, rand(10)-5, 0)
+      @name = "b" + self.object_id.to_s
+    elsif args[0].is_a?(Numeric) && args[1].is_a?(Numeric)
+      @mass = args[0]
+      @position = Vector.new(args[1], 0.0, 0.0)
+      @velocity = Vector.new(0.0, 0.0, 0.0)
+      @name = args[2]
+      @linear = true
+    else
+      @mass = 0.0
+      @position = Vector.new(0.0, 0.0, 0.0)
+      @velocity = Vector.new(0.0, 0.0, 0.0)
+      @name = nil
+    end
+    @force = Vector.new(0.0, 0.0, 0.0)
+  end
+  
+  def inspect
+    s = ""
+    s << @name + ": " if @name
+    s << @mass.to_s + "g "
+    if @linear
+      s << "x: " + @position.x.to_s
+    else
+      s << @position.inspect + " " + @velocity.inspect 
+    end
+    return s
+  end
+
+=begin rdoc
+  Reset the force vector to 0 (to get ready for a new round of interaction calculations).
+=end
+
+  def clear_force
+    @force.x = 0.0
+    @force.y = 0.0
+    @force.z = 0.0
+  end
+  
+=begin rdoc
+  Compute force acting on this body wrt body b
+=end
+
+  def add_force(b)
+    r = @position - b.position
+    nr = r.norm ** 3
+    mr = b.mass / nr
+    @force.add(r * mr)
+  end
+  
+=begin rdoc
+  Move this body by applying current force vector for dt seconds
+=end
+
+  def move(dt)
+    acc = @force * G * -1.0
+    @velocity.add( acc * dt ) 
+    @position.add( @velocity * dt )
+  end
+  
+=begin rdoc
+  Class method to compute the interaction between bodies b1 and b2 and update
+  their force vectors.
+=end
+
+  def Body.interaction(b1, b2)
+    r = b1.position - b2.position
+    a = r.norm ** 3
+    b1.force.add(r * (b2.mass / a))
+    b2.force.add(r * (-b1.mass / a))
+  end
+  
+end # Body
+
+=begin rdoc
+  Make a list of Body objects using data in the file +fn+
+=end
+
+def read_bodies(fn)
+  bodies = []
+  File.open(fn).each do |line|
+    line.strip!
+    next if line.length == 0
+    next if line[0] == ?#
+    a = line.chomp.split
+    for i in 1..7
+      a[i] = a[i].to_f
+    end
+    b = Body.new( a[1], Vector.new(a[2],a[3],a[4]), Vector.new(a[5],a[6],a[7]), a[0] )
+    b.size = a[-2].to_i
+    b.color = a[-1]
+    bodies << b
+  end
+  return bodies
+end
+
+=begin rdoc
+  Call SphereLab::step(bodies, time) to calculate the pairwise interactions between all
+  Body objects in the array +bodies+ and then compute their new positions after +time+ seconds.
+=end
+
+# :begin :step
+def step(bodies, time)
+  nb = bodies.length
+  
+  for i in 0...nb         # compute all pairwise interactions
+    for j in (i+1)...nb
+      Body.interaction( bodies[i], bodies[j] )
+    end
+  end
+  
+  bodies.each do |b|
+    b.move(time)          # apply the accumulated forces
+    b.clear_force         # reset force to 0 for next round
+  end
+end
+# :end :step
+
+def random_vectors(r, i, n)
+  theta = (2 * Math::PI / n) * i + (Math::PI * rand / n)
+  radius = r + (r/3)*(rand-0.5)
+  x = radius * Math.cos(theta)
+  y = radius * Math.sin(theta)
+  vtheta = (Math::PI - theta) * -1 + Math::PI * (rand-0.5)
+  vx = radius/20 * Math.cos(vtheta)
+  vy = radius/20 * Math.sin(vtheta)
+  return Vector.new(x, y, 0), Vector.new(vx, vy, 0)
+end
+
+def random_velocity(v, r)
+  res = Vector.new(-r * Math.cos)
+end
+
+def random_bodies(n, big = 1)
+  res = []
+  mm = 1e12          # average mass
+  mr = 150          # average distance from origin
+  write_tuple( :scale, [ 1.0 ] )
+  big.times do |i|
+    r0, v0 = random_vectors(mr/2, i, big)
+    res << Body.new(mm*100/big, r0, v0)
+    write_tuple( :view, [i, 10, "#0080ff"] )
+  end
+  (n-big).times do |i|
+    r, v = random_vectors(mr, i, n-big)
+    b = Body.new(mm, r, v)
+    b.name = "b" + (i+1).to_s
+    write_tuple( :view, [i+big, 5, "#0080ff"] )
+    res << b
+  end
+  return res
+end
+
+def urey_hall
+  write_tuple( :scale, [ 1e-7 ] )
+  # a 6.6 lb watermelon 7 stories (84 feet) above the surface of the earth:
+  w = Body.new(3000, 6.37101e6 + 25)
+  w.name = "watermelon"
+  w.size = 2
+  w.color = "#ff6666"
+  write_tuple( :view, [1, w.size, w.color] )
+  # the earth:
+  e = Body.new(5.9736E+24, 0)
+  e.name = "earth"
+  e.size = 100
+  e.color = "#004080"
+  write_tuple( :view, [0, e.size, e.color] )
+  return [e, w]
+end
+
+def four_body
+  write_tuple( :scale, [ 0.5 ] )
+  a = Body.new(1.4e18, Vector.new(50, 70, 0), Vector.new(0, 1, 0))
+  write_tuple( :view, [0, 10, "#ff6666"] )
+  b = Body.new(1.2e16, Vector.new(50, 225, 0), Vector.new(-1000, 2, 0))
+  write_tuple( :view, [1, 3, "#ff6666"] )
+  c = Body.new(2.1e16, Vector.new(175, -75, 0), Vector.new(-1, -5, 0))
+  write_tuple( :view, [2, 5, "#ff6666"] )
+  d = Body.new(4.5e16, Vector.new(300, -75, 0), Vector.new(-5, 2, 0))
+  write_tuple( :view, [3, 6, "#ff6666"] )
+  return [a,b,c,d]  
+end
+
+=begin rdoc
+  Attach a probe to the step method, have it call this method to show the 
+  current state of the simulation.
+=end
+
+def display(bodies)
+  for i in 0...bodies.length
+    write_tuple( :body, [i, bodies[i].position.x, bodies[i].position.y] )
+  end
+  write_tuple( :timestep, [] )
+  return true
+end
+
+=begin rdoc
+  Call this method to create a "scope" for viewing the state of an n-body simulation.
+  Also creates a proc that will be executed when IRB exits to shut down the tuple
+  space and viewer.
+=end
+
+def make_viewer
+  include Viewer
+  launch_viewer("nbview.rb")
+end
+
+=begin rdoc
+  Methods used in IRB sessions.
+=end
+
+# :begin :dist
+def dist(r, t)
+  return r * t
+end
+# :end :dist
+
+# :begin :falling
+def falling(t)
+  return 0.5 * 9.8 * t**2
+end
+# :end :falling
+
+end # SphereLab
+
+end # RubyLabs

data/lib/temps.rb

@@ -0,0 +1,41 @@
+
+=begin rdoc
+  
+== Ruby Workbench
+
+Chapter 2, <em>The Ruby Workbench</em>, is an introduction to Ruby and IRB.  There
+are no "experiments," but the chapter does describe two methods.  The code here is
+available so students can make a copy by calling the +checkout+ method.
+
+=end
+
+module RubyLabs
+	
+module Temps
+
+=begin rdoc
+  Convert the temperature +f+ (in degrees Fahrenheit) into the equivalent
+  temperature in degrees Celsius.
+=end
+
+# :begin :celsius
+def celsius(f)
+  (f - 32) * 5 / 9
+end
+# :end :celsius
+
+=begin rdoc
+  Fill in the body of this method with an equation that converts a number of 
+  degrees on the Celsius scale to the equivalent on the Fahrenheit scale.
+=end
+
+# :begin :fahrenheit
+def fahrenheit(c)
+  
+end
+# :end :fahrenheit
+
+
+end # Temp
+
+end # RubyLabs