rubylabs 0.5.4

data/test/random_test.rb

@@ -0,0 +1,64 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+include RandomLab
+
+class TestRandoms < Test::Unit::TestCase
+
+  # For the Card tests, a call to the Card constructor with an integer argument 
+  # makes a specified card, starting with 0 = A ♠ and ending with 51 = 2 ♣.
+
+  # Make a full deck, make sure every card is present.  Then shuffle the deck,
+  # check again.  Sort the shuffled deck, make sure all cards are there and in
+  # order.
+  
+  def test_01_decks
+    deck1 = deal((0..51).to_a)
+    check_all_cards(deck1)
+    deck2 = shuffle
+    check_all_cards(deck2)
+    deck3 = deck2.sort
+    check_all_cards(deck3)
+    assert_equal deck1, deck3
+  end
+  
+  # Make one of each kind of poker hand.  
+  
+  def test_02_poker_hands
+    print "\n  poker hands"
+    assert_equal poker_hand(deal([0,1,2,3,4])),     :straight_flush
+    assert_equal poker_hand(deal([0,13,26,39,1])),  :four_of_a_kind
+    assert_equal poker_hand(deal([0,13,26,1,14])),  :full_house
+    assert_equal poker_hand(deal([0,2,4,6,8])),     :flush
+    assert_equal poker_hand(deal([0,14,2,3,4])),    :straight
+    assert_equal poker_hand(deal([0,13,26,1,15])),  :three_of_a_kind
+    assert_equal poker_hand(deal([0,13,1,14,15])),  :two_pair
+    assert_equal poker_hand(deal([0,13,1,2,3])),    :pair
+    assert_equal poker_hand(deal([0,14,29,44,45])), :nada
+  end
+
+  
+=begin rdoc
+  The +bins+ method makes a hash using keys based on suits or ranks
+  and initialized with a count of 0.
+  
+  +check_all_cards+ makes sure there are 13 of each suit and 4 of each rank. 
+=end
+
+  def bins(a)
+    h = Hash.new
+    a.each do |x|
+      h[x] = 0
+    end
+    return h
+  end
+
+  def check_all_cards(a)
+    rb = bins(Card::Ranks)
+    sb = bins(Card::Suits)
+    a.each { |x| rb[x.rank] += 1; sb[x.suit] += 1 }
+    rb.each { |x,n| assert_equal n, 4 }
+    sb.each { |x,n| assert_equal n, 13 }
+  end
+
+end

data/test/recursion_test.rb

@@ -0,0 +1,47 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+include RecursionLab
+
+class TestRecursiveAlgoritms < Test::Unit::TestCase
+
+	# Make some test arrays, try successful and unsuccessful searches.
+	# Test array sizes students will use (one less than power of two)
+	# plus some odd ones.
+	
+  def test_01_bsearch
+    print "\n  bsearch"
+    [14, 15, 16].each do |size|
+      a = TestArray.new(size).sort
+      assert_not_nil bsearch(a, a.random(:success))
+      assert_nil bsearch(a, a.random(:fail))
+  	end
+  end
+
+	# Students will run tests with array sizes that are a power of two,
+	# but run some tests on other sizes, too.  Also checks to make sure
+	# the array is not modified
+
+	def test_02_msort
+    print "\n  msort"
+	  [15, 16, 17].each do |size|
+      a = TestArray.new(size)
+      b = a.dup
+  		assert_equal msort(a), a.sort
+  		assert_equal a, b
+    end
+	end
+	
+	# Array size not a factor here -- just try a few sorts	
+
+	def test_03_qsort
+    print "\n  qsort"
+	  [15, 16, 17].each do |size|
+      a = TestArray.new(size)
+      b = a.dup
+  		assert_equal qsort(a), a.sort
+  		assert_equal a, b
+    end
+	end
+	
+end

data/test/rubylabs_test.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+class RubyLabsTest < Test::Unit::TestCase
+	
+  def test_00_arrays
+    print "\n  test_array"
+    a = TestArray.new(10)
+		assert a.length == 10
+		assert a.include?(a.random(:success))
+		assert !a.include?(a.random(:fail))
+  end
+
+	def test_01_scope
+    print "\n  RubyScope [TBD]"
+	end
+
+end

data/test/sieve_test.rb

@@ -0,0 +1,28 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+include SieveLab
+
+class TestSieve < Test::Unit::TestCase
+
+	# Compare list generated by sieve method with list from Wikipedia.  Test both the main
+	# version (sieve) and the simple prototype that iterates until the worklist is empty.
+	
+  def test_01_first_25
+    print "\n  sieve"
+    expected = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
+		assert_equal expected, sieve(100)
+		assert_equal expected, proto_sieve(100)
+  end
+
+	# Check length of list generated by sieve with expected number of primes (also from Wikipedia).
+	# pi[i] is the number of primes less than 10**i.  Note: calling sieve(n) with n less than 2
+	# should quietly return an empty list.
+
+	def test_02_pi
+		pi = [0, 4, 25, 168, 1229, 9592]
+		for i in 0..(pi.length-1)
+			assert_equal pi[i], sieve(10**i).length
+		end
+	end
+end

data/test/sphere_test.rb

@@ -0,0 +1,130 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+include SphereLab
+
+=begin rdoc
+  This test file includes simple unit tests for the Vector and Body classes used in
+  the n-body simulation chapter, plus a more complicated test that should really be
+  an integration test.  The complicated test is a mini-simulation of the movement
+  of the four inner planets over a period of 88 days (enough time for Mercury to make
+  a complete orbit of the sun).  To see a plot of the simulation results run this
+  script with a file name as the command line argument, then run an R script (which
+  should be included in the tests directory) that will read the data and generate a plot:
+    % ruby sphere_test.rb nbody.out
+    % Rscript nbody.R
+    % open nbody.png
+=end
+
+class TestSpheres < Test::Unit::TestCase
+
+	# Vector arithmetic.  Note: calls to assert_equal will also test the == method.
+	
+  def test_01_vectors
+    print "\n  vectors"
+
+    v1 = Vector.new(1, 1, 1)
+    v2 = Vector.new(2, 2, 2)
+    v3 = Vector.new(3, 3, 3)
+
+    assert_equal v3, v1 + v2
+    assert_equal v1, v3 - v2
+    assert_equal v2, v1 * 2
+
+    v3.add(v1)
+    assert_equal v3, Vector.new(4, 4, 4)
+    v3.sub(v1)
+    assert_equal v3, Vector.new(3, 3, 3)
+    
+    assert_in_delta v2.norm, Math.sqrt(12), Float::EPSILON
+  end
+  
+  # Body objects -- make two of them, test calculation of force attraction between them,
+  # verify movement is equal magnitude and in opposite direction (i.e. bodies move toward
+  # each other on the y axis).
+  
+  def test_02_bodies
+    print "\n  bodies"
+    y1 = 1000
+    y2 = 0
+    b1 = Body.new(1000000, Vector.new(0, y1, 0), Vector.new(0, 0, 0))
+    b2 = Body.new(1000000, Vector.new(0, y2, 0), Vector.new(0, 0, 0))
+    b1.add_force(b2)
+    b2.add_force(b1)
+    b1.move(100)
+    b2.move(100)
+    assert_equal b1.position.x, 0.0
+    assert_equal b1.position.x, 0.0
+    assert_in_delta (y1 - b1.position.y), (b2.position.y - y2), 1e-10
+    assert_equal b1.position.z, 0.0
+    assert_equal b1.position.z, 0.0
+  end
+  
+  # Same as above, but use the class method (which does the calculation once and
+  # uses the same force twice)
+  
+  def test_03_interaction
+    print "\n  interaction"
+    y1 = 1000
+    y2 = 0
+    b1 = Body.new(1000000, Vector.new(0, y1, 0), Vector.new(0, 0, 0))
+    b2 = Body.new(1000000, Vector.new(0, y2, 0), Vector.new(0, 0, 0))
+    Body.interaction(b1, b2)
+    b1.move(100)
+    b2.move(100)
+    assert_equal b1.position.x, 0.0
+    assert_equal b1.position.x, 0.0
+    assert_in_delta (y1 - b1.position.y), (b2.position.y - y2), 1e-10
+    assert_equal b1.position.z, 0.0
+    assert_equal b1.position.z, 0.0
+  end
+  
+  # Test the Body class by doing a mini-simulation of bodies based on the sun and
+  # inner planets of the solar system.  Uses coordinates based on the JPL ephemeris
+  # for Jan 1 1970.  Run for 88 time steps, with dt = 1 day.  Expect mercury to be 
+  # close to where it started, and earth to be about 1/4 through its orbit.  
+  
+  def test_04_solar_system
+    print "\n  solar system"
+    
+    bodies = [
+      Body.new(1.989E30, Vector.new(0,0.000E00,0), Vector.new(0.000E0,0,0),	"sun"),
+      Body.new(3.303E23, Vector.new(3.83E+10, 2.87E+10, -1.17E+09), Vector.new(-38787.67,  41093.05,  6918.461),	"mercury"),
+      Body.new(4.870E24, Vector.new(-5.37E+09, -1.08E+11, -1.16E+09), Vector.new(34741.48, -1865.747, -2031.506), "venus"),
+      Body.new(5.976E24, Vector.new(-2.70E+10, 1.44E+11, 9686451), Vector.new(-29770.44, -5568.042, 0.3961261), "earth"),
+      Body.new(6.421E23, Vector.new(1.98E+11, 7.42E+10, -3.33E+09), Vector.new(-7557.626,  24761.27,  704.7457), "mars")
+    ]
+    
+    mercury = bodies[1]
+    
+    dt = 86459            # number of seconds in a day (at 365.25 days/year)
+    nb = bodies.length    # number of bodies
+    nt = 88               # number of time steps (simulated days); 88 is enough for 1 orbit for Mercury
+    
+    myfirst = mercury.position.clone
+    
+    nt.times do |t|           # main simulation loop
+      
+      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(dt)            # apply the accumulated forces
+        b.clear_force         # reset force to 0 for next round
+      end
+                 
+    end   
+        
+    # Check to see if Mercury is close to where it started...
+        
+    if nt == 88
+      assert_in_delta myfirst.x, mercury.position.x, 1e10
+      assert_in_delta myfirst.y, mercury.position.y, 1e10
+      assert_in_delta myfirst.z, mercury.position.z, 1e10
+    end
+  end
+
+end

data/test/temps_test.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+include Temps
+
+class TestTemps < Test::Unit::TestCase
+
+	# Check a few Faherenheit-to-Celsius conversions
+	
+  def test_01_celsius
+    print "\n  celsius"
+    assert_equal 100, celsius(212)
+    assert_equal 0, celsius(32)
+    assert_equal 26, celsius(80)
+    assert_equal "26.6666", celsius(80.0).to_s.slice(0..6)
+  end
+
+	# The fahrenheit method is a stub...
+
+	def test_02_fahrenheit
+    print "\n  fahrenheit"
+		assert_nil fahrenheit(100)
+	end
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+# require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubylabs'
+
+class Test::Unit::TestCase
+  
+  def max(a, b)
+    return (a > b) ? a : b
+  end
+  
+  def min(a, b)
+    return (a < b) ? a : b
+  end
+  
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: rubylabs
+version: !ruby/object:Gem::Version 
+  version: 0.5.4
+platform: ruby
+authors: 
+- conery
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-24 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A set of modules for interactive experiments in an introductory computer science class.
+email: conery@cs.uoregon.edu
+executables: 
+- bb.rb
+- statistics2.rb
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/bb.rb
+- bin/statistics2-0.53/ext/extconf.rb
+- bin/statistics2-0.53/ext/show.rb
+- bin/statistics2-0.53/ext/t.rb
+- bin/statistics2-0.53/mklist.rb
+- bin/statistics2-0.53/sample-tbl.rb
+- bin/statistics2-0.53/statistics2.rb
+- bin/statistics2-0.53/t-inv.rb
+- bin/statistics2.rb
+- data/aafreq.txt
+- data/cars.txt
+- data/century.txt
+- data/colors.txt
+- data/earth.yaml
+- data/fruit.txt
+- data/hacodes.txt
+- data/hafreq.txt
+- data/hvfreq.txt
+- data/nbody.R
+- data/nbody.out
+- data/nbody.pdf
+- data/nbody.png
+- data/nbody3d.pdf
+- data/outer.pdf
+- data/solar.dat
+- data/solarsystem.txt
+- data/suits.txt
+- data/wordlist.txt
+- lib/bitlab.rb
+- lib/elizalab.rb
+- lib/encryptionlab.rb
+- lib/hashlab.rb
+- lib/introlab.rb
+- lib/iterationlab.rb
+- lib/randomlab.rb
+- lib/recursionlab.rb
+- lib/rubylabs.rb
+- lib/sievelab.rb
+- lib/sortlab.rb
+- lib/spherelab.rb
+- lib/temps.rb
+- lib/tsplab.rb
+- lib/viewer.rb
+has_rdoc: true
+homepage: http://github.com/conery/rubylabs
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rubylabs
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Software and data for lab projects in the Science of Computing text.
+test_files: 
+- test/bit_test.rb
+- test/encryption_test.rb
+- test/iteration_test.rb
+- test/random_test.rb
+- test/recursion_test.rb
+- test/rubylabs_test.rb
+- test/sieve_test.rb
+- test/sphere_test.rb
+- test/temps_test.rb
+- test/test_helper.rb