feldtruby 0.2.0

data/lib/feldtruby/optimize/search_space.rb

@@ -0,0 +1,69 @@
+require 'feldtruby/optimize'
+
+# A search space is a set of constraints that limits which values
+# are searched for. The search space can generate valid candidate
+# solutions that are inside the space. It can also check if a
+# given candidate is in the space. The default search space has min
+# and max values for each element of a continuous vector.
+class FeldtRuby::Optimize::SearchSpace
+	attr_reader :min_values, :max_values
+
+	def initialize(minValues, maxValues)
+		# Check that we have valid min and max values
+		raise "Not same num of min values (#{minValues.length}) as there are max values (#{maxValues.length})" if minValues.length != maxValues.length
+		raise "A search space must have >= 1 variable to be searched, here you specified min values: #{minValues.inspect}" if minValues.length < 1
+		minValues.zip(maxValues).each do |min,max|
+			raise "The min value #{min} is larger than the max value #{max} in min values = #{minValues.inspect} and #{maxValues.inspect}" if min > max
+		end
+		@min_values, @max_values = minValues, maxValues
+		@deltas = @min_values.zip(@max_values).map {|min,max| max-min}
+	end
+
+	# Bound candidate using the min and max values. We randomly generate a new value inside the space
+	# for each element that is outside.
+	def bound(candidate)
+		a = candidate.each_with_index.map do |v, i|
+			in_range_for_position?(v, i) ? v : gen_value_for_position(i)
+		end
+		candidate.class.send(:[], *a)
+	end
+
+	def in_range_for_position?(value, index)
+		(value >= @min_values[index]) && (value <= @max_values[index])
+	end
+
+	def self.new_symmetric(numVariables = 2, distanceFromZero = 1)
+		min_values = Array.new(numVariables).map {-distanceFromZero}
+		max_values = Array.new(numVariables).map {distanceFromZero}
+		self.new_from_min_max(numVariables, -distanceFromZero, distanceFromZero)
+	end
+
+	def self.new_from_min_max(numVariables = 2, min = -1, max = 1)
+		min_values = Array.new(numVariables).map {min}
+		max_values = Array.new(numVariables).map {max}
+		self.new(min_values, max_values)
+	end
+
+	def num_variables
+		@min_values.length
+	end
+
+	def gen_candidate
+		(0...num_variables).map {|i| gen_value_for_position(i)}
+	end
+
+	def gen_value_for_position(i)
+		min, delta = @min_values[i], @deltas[i]
+		min + delta * rand()
+	end
+
+	def is_candidate?(c)
+		return false unless c.length == num_variables
+		c.length.times do |i|
+			return false unless c[i] >= min_values[i] && c[i] <= max_values[i]
+		end
+		return true
+	end
+end
+
+FeldtRuby::Optimize::DefaultSearchSpace = FeldtRuby::Optimize::SearchSpace.new_symmetric(2, 1)

data/lib/feldtruby/optimize/stdout_logger.rb

@@ -0,0 +1,138 @@
+require 'feldtruby/time'
+require 'feldtruby/float'
+
+class FeldtRuby::Optimize::StdOutLogger
+	class DummyStream
+		def puts(str); end
+		def print(str); end
+		def flush(); end
+	end
+
+	def initialize(optimizer, verbose = true)
+		@optimizer = optimizer
+		@verbose = verbose
+		@start_time = Time.now # To ensure we have a value even if optimizer forgot calling note_optimization_starts
+		@events = Hash.new(0)
+		@last_report_time = Hash.new(Time.new("1970-01-01")) # Maps event strings to the last time they were reported on, used by anote.
+		if verbose
+			@outstream = STDOUT
+		else
+			@outstream = DummyStream.new
+		end
+	end
+
+	def note_optimization_starts
+		log("Optimization with optimizer #{@optimizer.class.inspect} started")
+		@start_time = Time.now
+	end
+
+	def internal_note(shouldPrint, msg, values)
+		@events[msg] += 1
+		if (values.all? {|e| String === e})
+			vstr = values.join("\n  ")
+		else
+			vstr = values.inspect
+		end
+		if msg == "."
+			# Just a tick so no event stat etc
+			log_print( msg ) if shouldPrint
+		else
+			log( "#{event_stat_in_relation_to_step(@events[msg])}: #{msg}\n  #{vstr}", true ) if shouldPrint
+		end
+	end
+
+	def note(msg, *values)
+		internal_note true, msg, values
+	end
+
+	# Adaptive notes are recorded as any (normal) notes but is only reported to the user in a readable
+	# manner i.e. the frequency of reporting them is limited.
+	def adaptive_note(frequency, msg, values = [])
+		should_print = elapsed_since_last_reporting_of(msg) > frequency
+		@last_report_time[msg] = Time.now if should_print
+		internal_note should_print, msg, values
+	end
+
+	def anote(msg, *values)
+		adaptive_note(2.0, msg, values)
+	end
+
+	def elapsed_since_last_reporting_of(msg)
+		Time.now - @last_report_time[msg]
+	end
+
+	def note_end_of_optimization(optimizer)
+		best_msg = info_about_candidate(optimizer.best, optimizer.best_quality_value, 
+			optimizer.best_sub_quality_values, "best")
+		note("End of optimization", "Optimizer: #{optimizer.class}", 
+			best_msg, 
+			event_summary_to_str(),
+			"Time used = #{Time.human_readable_timestr(elapsed_time)}, " + 
+			"Steps performed = #{num_steps}, " + 
+			"#{Time.human_readable_timestr(time_per_step, true)}/step")
+	end
+
+	def event_summary_to_str()
+		"Event counts:\n    " + @events.to_a.map {|key,count| "#{key}: #{event_stat_in_relation_to_step(count)}"}.join("\n    ")
+	end
+
+	def event_stat_in_relation_to_step(eventCount)
+		"#{eventCount} times (%.3f times/step)" % (eventCount.to_f / num_steps)
+	end
+
+	def info_about_candidate(candidate, qualityValue, subQualityValues, nameString = "new")
+		info_str = nameString ? "#{nameString} = #{candidate.inspect}\n  " : "  "
+		info_str + candidate._quality_value.inspect
+	end
+
+	def note_new_better(betterMsg, newBetter, newQv, newSubQvs)
+		new_better_msg = info_about_candidate(newBetter, newQv, newSubQvs, nil)
+		anote(betterMsg, new_better_msg)
+	end
+
+	def note_new_best(newBest, newQv, newSubQvs, oldBest = nil, oldQv = nil, oldSubQvs = nil)
+		new_best_msg = info_about_candidate(newBest, newQv, newSubQvs, "new")
+		if oldBest
+			new_best_msg += ",\n  supplants old best\n  #{oldQv.inspect}"
+			new_best_msg += "\n  #{newQv.improvement_in_relation_to(oldQv)}\n"
+		end
+		anote("Found new best", new_best_msg)
+	end
+
+	def note_another_optimization_step(stepNumber)
+		@events['Optimization steps'] += 1 # we note it by hand since we are printing something different than the event name
+		adaptive_note(0.1, '.')
+	end
+
+	def quality_values_to_str(qv, subQvs)
+		"q = %.4f, subqs = %s" % [qv, subQvs.map {|v| v.round_to_decimals(4)}.inspect]
+	end
+
+	def note_termination(message)
+		log(message, true)
+	end
+
+	def log(str, newlineBefore = false, newlineAfter = true)
+		@outstream.puts "" if newlineBefore
+		@outstream.print "#{Time.timestamp({:short => true})} #{num_steps}: (#{Time.human_readable_timestr(elapsed_time)}), #{str}"
+		@outstream.puts "" if newlineAfter
+		@outstream.flush
+	end
+
+	def log_print(str)
+		@outstream.print str
+		@outstream.flush
+	end
+
+	def num_steps
+		@events['Optimization steps']
+	end
+
+	def time_per_step
+		elapsed_time / num_steps
+	end
+
+	def elapsed_time
+		Time.now - @start_time
+	end
+end

data/lib/feldtruby/optimize.rb

@@ -0,0 +1,28 @@
+require 'feldtruby'
+
+module FeldtRuby::Optimize; end
+
+require 'feldtruby/optimize/differential_evolution'
+module FeldtRuby::Optimize
+	# Optimize the _numVariables_ between the _min_ and _max_ values given _costFunction_.
+	# Default is to minimize.
+	def self.optimize(min, max, options = {:verbose => true}, 
+		objectiveFuncClass = FeldtRuby::Optimize::ObjectiveMinimizeBlock, &costFunction)
+		objective = objectiveFuncClass.new(&costFunction)
+		num_vars = costFunction.arity
+		search_space = SearchSpace.new_from_min_max(num_vars, min, max)
+		optimizer = DEOptimizer.new(objective, search_space, options)
+		optimizer.optimize()
+		optimizer.best.to_a
+	end
+
+	# Short hand wrapper for function minimization.
+	def self.minimize(min, max, options = {}, &costFunction)
+		optimize(min, max, options, &costFunction)
+	end
+
+	# Short hand wrapper for function maximization.
+	def self.maximize(min, max, options = {}, &costFunction)
+		optimize(min, max, options, FeldtRuby::Optimize::ObjectiveMaximizeBlock, &costFunction)
+	end
+end

data/lib/feldtruby/string/to_iso.rb

@@ -0,0 +1,7 @@
+class String
+    # Convert to normal, iso formatted string. Skip invalid and undefined utf-8 sequences
+    # in the conversion.
+    def to_iso
+        self.encode('ISO-8859-1', 'utf-8', :invalid => :replace, :undef => :replace)
+    end
+end

data/lib/feldtruby/time.rb

@@ -0,0 +1,22 @@
+def Time.timestamp(options = {:short => false})
+	if options[:short]
+		Time.now.strftime("%y%m%d %H:%M.%S")
+	else
+		Time.now.strftime("%Y%m%d %H:%M.%S")
+	end
+end
+
+def Time.human_readable_timestr(seconds, insertSpace = false)
+	sp = insertSpace ? " " : ""
+	if seconds < 1e-4
+		"%.2f#{sp}usec" % (seconds*1e6)
+	elsif seconds < 1e-1
+		"%.2f#{sp}msec" % (seconds*1e3)
+	elsif seconds > 60*60.0
+		"%.2f#{sp}hours" % (seconds/3600.0)
+	elsif seconds > 60.0
+		"%.2f#{sp}mins" % (seconds/60.0)
+	else
+		"%.2f#{sp}sec" % seconds
+	end
+end

data/lib/feldtruby/vector.rb

@@ -0,0 +1,14 @@
+require 'matrix'
+require 'feldtruby/array/basic_stats'
+
+class Vector
+	# length is used by the BasicStatistics methods but is not available in Vector so add it...
+	def length; size(); end
+	include BasicStatistics
+
+	# Override index method and add slicing.
+	def [](index, length = nil)
+		return @elements[index] unless length
+		Vector.elements(self.to_a[index, length])
+	end
+end

data/lib/feldtruby/visualization/circos.rb

@@ -0,0 +1,25 @@
+# Minimal info to dump circos conf files, for beautiful rendering of
+# circular data visualizations.
+class Circos
+	class Chromosome < Hash
+		attr_reader :bands
+		def initialize(*args, &block)
+			super
+			@bands = Hash.new
+		end
+		def dump_to_circos_data(keyOrder = nil)
+			keyOrder ||= self.keys.sort
+			(name + keyOrder.map {|key| self[key]}).join(" ") + "\n"
+		end
+		def dump_bands_to_circos(bandKeyOrder = nil)
+			bands.map {|b| b.dump_to_circos_data(bandKeyOrder)}.join("\n")
+		end
+	end
+	class Band < Hash
+		attr_reader :name
+		def dump_to_circos_data(keyOrder = nil)
+			keyOrder ||= self.keys.sort
+			(name + keyOrder.map {|key| self[key]}).join(" ")
+		end
+	end
+end

data/lib/feldtruby/word_counter.rb

@@ -0,0 +1,100 @@
+class FeldtRuby::WordCounter
+  def initialize
+    @counts = Hash.new(0)
+  end
+
+  # Ensure it has canonical form
+  def preprocess_word(word)
+    word.strip.downcase
+  end
+
+  def count_word(word)
+    w = preprocess_word(word)
+    @counts[w] += 1 unless is_stop_word?(w)
+  end
+
+  def invidual_words_in_string(str)
+    str.downcase.split(/[^\w-]+/)
+  end
+
+  def count_words(string)
+    invidual_words_in_string(string).map {|w| count_word(w)}
+  end
+
+  def words
+    @counts.keys
+  end
+
+  def count(word)
+    @counts[preprocess_word(word)]
+  end
+
+  def top_words(numberOfWords)
+    @counts.to_a.sort_by {|e| e.last}[-numberOfWords, numberOfWords].reverse
+  end
+
+  StopWords = ["a", "about", "above", "after", "again", "against", "all", "am", "an", "and", "any", "are", "aren't", "as", "at", "be", "because", "been", "before", "being", "below", "between", "both", "but", "by", "can't", "cannot", "could", "couldn't", "did", "didn't", "do", "does", "doesn't", "doing", "don't", "down", "during", "each", "few", "for", "from", "further", "had", "hadn't", "has", "hasn't", "have", "haven't", "having", "he", "he'd", "he'll", "he's", "her", "here", "here's", "hers", "herself", "him", "himself", "his", "how", "how's", "i", "i'd", "i'll", "i'm", "i've", "if", "in", "into", "is", "isn't", "it", "it's", "its", "itself", "let's", "me", "more", "most", "mustn't", "my", "myself", "no", "nor", "not", "of", "off", "on", "once", "only", "or", "other", "ought", "our", "ours ", "ourselves", "out", "over", "own", "same", "shan't", "she", "she'd", "she'll", "she's", "should", "shouldn't", "so", "some", "such", "than", "that", "that's", "the", "their", "theirs", "them", "themselves", "then", "there", "there's", "these", "they", "they'd", "they'll", "they're", "they've", "this", "those", "through", "to", "too", "under", "until", "up", "very", "was", "wasn't", "we", "we'd", "we'll", "we're", "we've", "were", "weren't", "what", "what's", "when", "when's", "where", "where's", "which", "while", "who", "who's", "whom", "why", "why's", "with", "won't", "would", "wouldn't", "you", "you'd", "you'll", "you're", "you've", "your", "yours", "yourself", "yourselves"]
+  
+  def is_stop_word?(word)
+    StopWords.include?(word)
+  end
+
+  # Merge words together that are pluralis or -ing (or -ming) forms of each other.
+  # Destructive, so only use this after all words have been added.
+  def merge!
+    words = @counts.keys
+    base_words = words.select {|w| w[-1,1] != "s" && w[-4,4] != "ming" && w[-3,3] != "ing"}
+    non_base = words - base_words
+    ending_in_s = non_base.select {|w| w[-1,1] == "s"}
+    ending_in_ing = non_base.select {|w| w[-3,3] == "ing"}
+    ending_in_ming = non_base.select {|w| w[-4,4] == "ming"}
+    base_words.each do |base_word|
+      merged_word = base_word
+      count = @counts[base_word]
+      if ending_in_s.include?(base_word + "s")
+        count += @counts[base_word + "s"]
+        @counts.delete(base_word + "s")
+        merged_word += "|#{base_word}s"
+      end
+      if ending_in_ming.include?(base_word + "ming")
+        count += @counts[base_word + "ming"]
+        @counts.delete(base_word + "ming")
+        merged_word += "|#{base_word}ming"
+      end
+      if ending_in_ing.include?(base_word + "ing")
+        count += @counts[base_word + "ing"]
+        @counts.delete(base_word + "ing")
+        merged_word += "|#{base_word}ing"
+      end
+      if merged_word != base_word
+        @counts[merged_word] = count
+        @counts.delete(base_word)
+      end
+    end
+  end
+end
+
+class FeldtRuby::NgramWordCounter < FeldtRuby::WordCounter
+  def initialize(n = 2)
+    super()
+    @n = n
+  end
+  def count_words(words)
+    # Split sentences, get words in each sentence, create n-grams, filter n-grams containing stop words, and count remaining
+    words.split(/\.\s+(?=[A-Z]{1})/).each do |sentence|
+      ngrams = all_ngrams(invidual_words_in_string(sentence))
+      non_stop_ngrams = ngrams.select {|ngram| !ngram.any? {|ngw| is_stop_word?(ngw)}}
+      non_stop_ngrams.each {|ngram| count_word(ngram.join(' '))}
+    end
+  end
+  def all_ngrams(array)
+    res = []
+    length = array.length
+    index = 0
+    while (length - index) >= @n
+      res << array[index, @n]
+      index += 1
+    end
+    res
+  end
+end

data/lib/feldtruby.rb

@@ -0,0 +1,6 @@
+# this is just for Hoe's version numbering
+class Feldtruby
+  VERSION = '0.2.0'
+end
+# This is the namespace under which we put things...
+module FeldtRuby; end

data/test/helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'minitest/spec'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'feldtruby'

data/test/test_array.rb

@@ -0,0 +1,71 @@
+require 'minitest/spec'
+require 'feldtruby/array'
+
+class TestFeldtRubyArray < MiniTest::Unit::TestCase
+	def test_distance_between_elements_normal_cases
+		assert_equal [1], 		[1, 2].distance_between_elements
+		assert_equal [1, 2], 	[1, 2, 4].distance_between_elements
+		assert_equal [3, 11], 	[-1, 2, 13].distance_between_elements
+	end
+
+	def test_distance_elements_when_one_element
+		assert_equal [], [1].distance_between_elements
+	end
+
+	def test_distance_elements_empty_array
+		assert_equal nil, [].distance_between_elements
+	end
+
+	def test_swap!
+		a = (0..9).to_a
+
+		a.swap!(0, 8)
+		assert_equal 8, a[0]
+		assert_equal 0, a[8]
+		assert_equal 1, a[1]
+		assert_equal 9, a[9]
+
+		a.swap!(0, 9)
+		assert_equal 9, a[0]
+		assert_equal 0, a[8]
+		assert_equal 8, a[9]
+		assert_equal 2, a[2]
+	end
+end
+
+describe "Array extensions" do
+	describe "ranks" do
+		it "works when elements are already in order" do
+			[2.5, 1.5, 0.3].ranks.must_equal [1, 2, 3]
+			[15, 7, 1, 0].ranks.must_equal [1, 2, 3, 4]
+		end
+
+		it "works when elements are in reverse order" do
+			[0.3, 1.5, 2.5].ranks.must_equal [3, 2, 1]
+			[0, 1, 7, 15].ranks.must_equal [4, 3, 2, 1]
+		end
+
+		it "works when elements are out of order" do
+			[1.5, 0.5, 2.3].ranks.must_equal [2, 3, 1]
+			[1, 7, 15, 0].ranks.must_equal [3, 2, 1, 4]
+		end
+
+		it "works when given an empty array" do
+			[].ranks.must_equal []
+		end
+	end
+
+	describe "ranks_by" do
+		it "works when element to rank by is first and we prepend the ranks" do
+			[[2.5, :a], [1.5, :b], [0.3, :c]].ranks_by(true) {|v| v.first}.must_equal [
+				[1, 2.5, :a], [2, 1.5, :b], [3, 0.3, :c]
+			]
+		end		
+
+		it "works when element to rank by is second and we append the ranks" do
+			[[:a, 2.5], [:c, 0.3], [:b, 1.5]].ranks_by(false) {|v| v[1]}.must_equal [
+				[:a, 2.5, 1], [:c, 0.3, 3], [:b, 1.5, 2]
+			]
+		end		
+	end
+end

data/test/test_array_basic_stats.rb

@@ -0,0 +1,130 @@
+require 'helper'
+require 'feldtruby/array/basic_stats'
+
+class TestArrayBasicStats < MiniTest::Unit::TestCase
+	def test_sum_normal
+		assert_equal 3, [1,2].sum
+		assert_equal 6, [1,2,3].sum
+	end
+
+	def test_sum_one_element
+		assert_equal 1, [1].sum
+	end
+
+	def test_sum_empty_array
+		assert_equal 0, [].sum
+	end
+
+	def test_mean_normal
+		assert_equal 1.5, [1,2].mean
+		assert_equal 2,   [1,2,3].mean
+	end
+
+	def test_mean_one_element
+		assert_equal 1, [1].mean
+	end
+
+	def test_mean_empty_array
+		assert_equal 0, [].mean
+	end
+
+	def test_mean_from_wikipedia_def_page_for_stdev
+		assert_equal 2.0, [2, 4, 4, 4, 5, 5, 7, 9].stdev 
+	end
+
+	def test_root_mean_square
+		assert_equal Math.sqrt((1*1 + 2*2)/2.0), [1, 2].root_mean_square
+		assert_equal Math.sqrt((10*10 + 243*243)/2.0), [10, 243].rms
+	end
+
+	def test_weighted_sum_one_element
+		assert_equal 1, [1].weighted_sum([1])
+		assert_equal 2, [1].weighted_sum([2])
+	end
+
+	def test_weighted_sum_two_elements
+		assert_equal 3, 	[1, 2].weighted_sum([1, 1])
+		assert_equal 22, 	[1, 4].weighted_sum([2, 5])
+	end
+
+	def test_weighted_mean_one_elements
+		assert_equal 1, 	[1].weighted_mean([1])
+		assert_equal 4, 	[4].weighted_mean([2])
+	end
+
+	def test_weighted_mean_two_elements
+		assert_equal 1.5, 		[1, 2].weighted_mean([1, 1])
+		assert_equal 22.0/7, 	[1, 4].weighted_mean([2, 5])
+
+		assert_equal 1.5, 		[1, 2].weighted_mean()
+	end
+end
+
+describe "Basic statistics" do
+	describe "sum of abs" do
+		it "works for simple example" do
+			[1, 2, 3, -4, 5, -6].sum_of_abs.must_equal 1+2+3+4+5+6
+		end
+	end
+
+	describe "sum of absolute deviations from value" do
+		it "is same as sum of absolutes if the value is 0.0" do
+			a = [1, 2, 3, -4, 5, -6]
+			expected = a.map {|v| v.abs}.sum
+			a.sum_of_abs_deviations(0.0).must_equal expected
+		end
+
+		it "works for simple example" do
+			a = [1, 2, 3, -4, 5, -6]
+			a.sum_of_abs_deviations(1.0).must_equal 0+1+2+5+4+7
+		end
+	end
+
+	describe "rms_from_scalar" do
+		it "is the same as rms if scalar is 0.0" do
+			a = [1,2,3,4,5]
+			a.rms_from_scalar(0.0).must_be_within_delta a.rms
+		end
+
+		it "is correct for concrete example" do
+			a = [1,2]
+			a.rms_from_scalar(1.5).must_equal Math.sqrt( (0.5**2 + 0.5**2)/2 )
+		end
+	end
+
+	describe "squared_error" do
+		it "works for simple example" do
+			a = [1, 2, 3]
+			b = [2, 4, 7]
+			a.sum_squared_error(b).must_equal(1*1 + 2*2 + 4*4)
+		end
+	end
+
+	describe "median" do
+		it "works when there is a single value" do
+			[1].median.must_equal 1
+		end
+
+		it "works when there are two integers, median is float" do
+			[1, 2].median.must_equal 1.5
+		end
+
+		it "works when there are two floats, median is float" do
+			[1.0, 2.0].median.must_equal 1.5
+		end
+
+		it "works when there are three inputs" do
+			[1.0, 2.0, 3.0].median.must_equal 2.0
+		end
+
+		it "works when there are four inputs" do
+			[1, 2, 3, 4].median.must_equal 2.5
+		end
+	end
+
+	describe "summary_stats" do
+		it "gives a nice string with descriptive statistics" do
+			[1,2,3,4].summary_stats.must_equal "2.500 (min = 1.0, max = 4.0, median = 2.5, stdev = 1.12)"
+		end
+	end
+end

data/test/test_array_count_by.rb

@@ -0,0 +1,13 @@
+require 'minitest/spec'
+require 'feldtruby/array/count_by'
+
+describe "Array#count_by" do
+  it "counts right" do
+    counts = ["a", "ab", "b", "abfd", "e", "gf"].count_by {|e| e.length}
+    counts.must_be_instance_of Hash
+    counts.keys.sort.must_equal [1, 2, 4]
+    counts[1].must_equal 3
+    counts[2].must_equal 2
+    counts[4].must_equal 1
+  end
+end

data/test/test_float.rb

@@ -0,0 +1,20 @@
+require 'feldtruby/float'
+
+class TestFloat < MiniTest::Unit::TestCase
+	def test_round_to_decimals
+		assert_equal 1.2, 1.204.round_to_decimals(1)
+		assert_equal 1.20, 1.204.round_to_decimals(2)
+		assert_equal 1.204, 1.204.round_to_decimals(3)
+	end
+end
+
+describe "protected_division_with" do
+	it "works for non-zero values" do
+		1.0.protected_division_with(2).must_equal 0.5
+		120.4.protected_division_with(4).must_equal 30.1
+	end
+
+	it "returns positive infinity if numerator is positive and denominator is zero" do
+		1.0.protected_division_with(0).must_equal 0.0
+	end
+end

data/test/test_html_doc_getter.rb

@@ -0,0 +1,16 @@
+require 'minitest/spec'
+require 'feldtruby/net/html_doc_getter'
+
+describe "HtmlDocGetter" do
+  it "Can get the html page as a string" do
+    h = FeldtRuby::HtmlDocGetter.new
+    s = h.get("http://www.google.com")
+    s.must_be_instance_of String
+  end
+
+  it "Can get the html page as a Nokogiri doc" do
+    h = FeldtRuby::HtmlDocGetter.new
+    d = h.get_html_doc("http://www.google.com")
+    d.must_be_instance_of Nokogiri::HTML::Document
+  end
+end