fathom 0.3.7 → 0.5.0

data/spec/fathom/distributions/gaussian_spec.rb

@@ -1,64 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom::Distributions
-
-describe Gaussian do
-  
-  before do
-    @opts = {:mean => 0, :sd => 0.1, :confidence_interval => 0.05}
-  end
-  
-  it "should provide a GSL::Rng through rng" do
-    Gaussian.rng.should be_a(GSL::Rng)
-  end
-  
-  it "should be able to generate a random variable through GSL::Rng#gaussian" do
-    Gaussian.rng.should_receive(:gaussian).and_return(0.5)
-    Gaussian.rand(1)
-  end
-  
-  it "should be able to generate an inverse CDF" do
-    Gaussian.inverse_cdf(@opts).should be_within(0.00001).of(-0.16448)
-  end
-  
-  it "should require mean as an option for an inverse CDF" do
-    @opts.delete(:mean)
-    lambda{Gaussian.inverse_cdf(@opts)}.should raise_error
-  end
-  
-  it "should require a Gaussian deviation for an inverse CDF" do
-    @opts.delete(:sd)
-    lambda{Gaussian.inverse_cdf(@opts)}.should raise_error
-  end
-  
-  it "should take std as an alias for sd when creating an inverse CDF" do
-    @opts.delete(:sd)
-    Gaussian.inverse_cdf(@opts.merge(:std => 0.1)).should be_within(0.00001).of(-0.16448)
-  end
-
-  it "should take standard_deviation as an alias for sd when creating an inverse CDF" do
-    @opts.delete(:sd)
-    Gaussian.inverse_cdf(@opts.merge(:standard_deviation => 0.1)).should be_within(0.00001).of(-0.16448)
-  end
-  
-  it "should be able to set upper to true and get Q instead of P" do
-    Gaussian.inverse_cdf(@opts.merge(:upper =>true)).should be_within(0.00001).of(0.16448)
-  end
-  
-  it "should be able to take a different confidence interval" do
-    Gaussian.inverse_cdf(@opts.merge(:confidence_interval => 0.1)).should be_within(0.00001).of(-0.12815)
-  end
-
-  it "should have a lower_bound alias for inverse_cdf" do
-    Gaussian.lower_bound(@opts).should eql(Gaussian.inverse_cdf(@opts))
-  end
-  
-  it "should have an upper_bound shortcut for inverse_cdf(:upper => true, ...)" do
-    Gaussian.upper_bound(@opts).should eql(Gaussian.inverse_cdf(@opts.merge(:upper => true)))
-  end
-  
-  it "should provide interval values, an array of the lower and upper bounds" do
-    Gaussian.interval_values(@opts.merge(:confidence_interval => 0.9)).should eql([Gaussian.lower_bound(@opts), Gaussian.upper_bound(@opts)])
-  end
-end
-

data/spec/fathom/import/csv_import_spec.rb

@@ -1,52 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe CSVImport do
-  
-  before do
-    @content =<<-END
-      this,and,that
-      1,2,3
-      4,5,6
-      7,8,9
-    END
-    
-    @opts = {:content => @content}
-    @ci = CSVImport.new(@opts)
-    @result = @ci.import
-  end
-  
-  it "should not work unless content is set" do
-    lambda{CSVImport.new.import}.should raise_error(NoMethodError)
-    lambda{CSVImport.new(@opts)}.should_not raise_error
-  end
-  
-  it "should return the ImportNode as the result" do
-    @result.should be_a(ImportNode)
-  end
-  
-  it "should create as many data nodes as there are columns" do
-    @result.children.size.should eql(3)
-    @result.children.each {|dn| dn.should be_a(DataNode)}
-  end
-  
-  it "should import the values from each column into each data node" do
-    @result.this.values.should eql([1,4,7])
-    @result.and.values.should eql([2,5,8])
-    @result.that.values.should eql([3,6,9])
-  end
-  
-  # KB Override
-  # it "should store the imported values in the knowledge base" do
-  #   Fathom.knowledge_base[:this].should be_a(DataNode)
-  #   Fathom.kb[:this].values.should eql([1,4,7])
-  # end
-
-  # KB Override
-  # it "should import from the class level" do
-  #   CSVImport.import(@opts)
-  #   Fathom.knowledge_base[:this].should be_a(DataNode)
-  #   Fathom.kb[:this].values.should eql([1,4,7])
-  # end
-end

data/spec/fathom/import/import_node_spec.rb

@@ -1,10 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe ImportNode do
-  it "should record the time of the import" do
-    i = ImportNode.new
-    i.imported_at.should be_within(0.01).of(Time.now)
-  end
-end

data/spec/fathom/import/yaml_import_spec.rb

@@ -1,73 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe YAMLImport do
-
-  before do
-    @demo_yaml_location = File.expand_path(File.dirname(__FILE__) + "/../../support/demo.yml")
-    @demo_yaml = open(@demo_yaml_location).read
-    @opts = {:content => @demo_yaml}
-    @yi = YAMLImport.new(@opts)
-    @result = @yi.import
-  end
-  
-  it "should not work unless content is set" do
-    lambda{YAMLImport.new.import}.should raise_error
-    lambda{YAMLImport.new(@opts)}.should_not raise_error
-  end
-  
-  it "should create an ImportNode as a return value" do
-    @result.should be_an(ImportNode)
-  end
-  
-  it "should create PlausibleRange nodes for any hashes with at least a min and max key in it" do
-    @result.co2_emissions.should_not be_nil
-  end
-  
-  it "should not create a PlausibleRange for entries missing min and max" do
-    @result.should_not respond_to(:invalid_hash)
-  end
-  
-  it "should be able to create a PlausibleRange with more complete information" do
-    @result.more_complete_range.ci.should eql(0.6)
-    @result.more_complete_range.description.should eql('Some good description')
-  end
-  
-  it "should create DataNodes for entries that have an array of information" do
-    @result.co2_readings.should be_a(DataNode)
-    @result.co2_readings.values.should eql([10,20,30])
-  end
-
-  # KB Override
-  # it "should store the imported values in the knowledge base" do
-  #   Fathom.knowledge_base['CO2 Emissions'].should be_a(PlausibleRange)
-  #   Fathom.kb['CO2 Emissions'].min.should eql(1_000_000)
-  # end
-  
-  # KB Override
-  # it "should import from the class level" do
-  #   YAMLImport.import(@opts)
-  #   Fathom.knowledge_base['CO2 Emissions'].should be_a(PlausibleRange)
-  #   Fathom.kb['CO2 Emissions'].min.should eql(1_000_000)
-  # end
-  
-  it "should not complain if there's an empty YAML file" do
-    filename = '/tmp/empty_yaml_test.yml'
-    File.open(filename, 'w') {|f| f.puts ''}
-    lambda{YAMLImport.import(:content => filename)}.should_not raise_error
-    `rm -rf #{filename}`
-  end
-  
-  it "should create a Fact if it is an object named fact and has a name and value function" do
-    filename = File.expand_path(File.dirname(__FILE__) + "/../../support/fact.yml")
-    yaml = open(filename).read
-    opts = {:content => yaml}
-    yi = YAMLImport.new(opts)
-    result = yi.import
-    result.one.value.should eql(1)
-    result.two.value.should eql(2)
-    result.three.value.should eql(3)
-  end
-  
-end

data/spec/fathom/import_spec.rb

@@ -1,36 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-include Fathom
-
-describe Import do
-
-  before do
-    @content = 'some content'
-    @options = OptionsHash.new({:content => @content})
-    @i = Import.new(@options)
-    @values = [1,2,3,4,5]
-  end
-  
-  it "should initialize with optional content" do
-    @i.content.should eql(@content)
-  end
-
-  it "should record the initialization options" do
-    @i.options.should eql(@options)
-  end
-  
-  it "should have a class-level import method" do
-    Import.should be_respond_to(:import)
-  end
-  
-  it "should create an import node to attach its imports to in the knowledge base" do
-    @i.import_node.should be_a(ImportNode)
-  end
-  
-  it "should pass its options to the import node for that node to record the parts it is interested in." do
-    i = Import.new(:name => "New Import", :content => @content, :description => "This gets passed along too.")
-    i.import_node.name.should eql("New Import")
-    i.import_node.description.should eql("This gets passed along too.")
-  end
-  
-end

data/spec/fathom/knowledge_base_spec.rb

@@ -1,20 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-include Fathom
-
-describe KnowledgeBase do
-  
-  before do
-    @kb = KnowledgeBase.new
-  end
-  
-  it "should have a find accessor" do
-    KnowledgeBase.should respond_to(:find)
-  end
-  
-  # it "should be able to add a node" do
-  #   @dn = DataNode.new(:name => :new_node, :values => [1,2,3])
-  #   @kb[:new_node] = @dn
-  #   @kb[:new_node].should eql(@dn)
-  # end
-end

data/spec/fathom/monte_carlo_set_spec.rb

@@ -1,149 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-include Fathom
-
-describe MonteCarloSet do
-  
-  before(:all) do
-    @q1_sales = PlausibleRange.new(:min => 10, :max => 20, :hard_lower_bound => 0, :name => "First Quarter Sales")
-    @q1_prices = PlausibleRange.new(:min => 10_000, :max => 12_000, :name => "First Quarter Prices")
-    @q1_sales_commissions = PlausibleRange.new(:min => 0.2, :max => 0.2, :name => "Sales Commission Rate")
-
-    @q1_gross_margins = ValueDescription.new(@q1_sales, @q1_prices, @q1_sales_commissions) do |random_sample|
-      revenue = (random_sample.first_quarter_sales * random_sample.first_quarter_prices)
-      commissions_paid = random_sample.sales_commission_rate * revenue
-      gross_margins = revenue - commissions_paid
-      {:revenue => revenue, :commissions_paid => commissions_paid, :gross_margins => gross_margins}
-    end
-    
-    @fields = [:commissions_paid, :gross_margins, :revenue]
-    @summary_fields = [:coefficient_of_variation, :lower_bound, :max, :mean, :min, :sd, :upper_bound]
-  end
-  
-  before do
-    @mcs = MonteCarloSet.new(@q1_gross_margins)
-  end
-  
-  it "should initialize with a ValueDescription" do
-    lambda{MonteCarloSet.new}.should raise_error
-    lambda{MonteCarloSet.new(@q1_gross_margins)}.should_not raise_error
-  end
-  
-  it "should expose the value_description" do
-    @mcs.value_description.should eql(@q1_gross_margins)
-  end
-  
-  it "should process with the default number of runs at 10,000", :slow => true do
-    lambda{@mcs.process}.should_not raise_error
-    @mcs.samples_taken.should eql(10_000)
-  end
-  
-  it "should be able to process with a specified number of runs" do
-    @mcs.process(3)
-    @mcs.samples_taken.should eql(3)
-  end
-  
-  it "should define lookup methods for all keys in the result set" do
-    @mcs.process(1)
-    @mcs.revenue.should be_a(GSL::Vector)
-    @mcs.revenue.length.should eql(1)
-    @mcs.commissions_paid.should be_a(GSL::Vector)
-    @mcs.commissions_paid.length.should eql(1)
-    @mcs.gross_margins.should be_a(GSL::Vector)
-    @mcs.gross_margins.length.should eql(1)
-  end
-  
-  it "should be resetable" do
-    @mcs.process(1)
-    @mcs.reset!
-    lambda{@mcs.process(1)}.should_not raise_error
-  end
-
-  it "should expose the fields from the samples" do
-    @mcs.process(1)
-    sort_array_of_symbols(@mcs.fields).should eql(@fields)
-  end
-  
-  it "should offer a summary of the fields" do
-    @mcs.process(1)
-    summary = @mcs.summary
-    summary.should be_a(Hash)
-    sort_array_of_symbols(summary.keys).should eql(@fields)
-    summary.each do |key, value|
-      value.should be_a(Hash)
-      sort_array_of_symbols(value.keys).should eql(@summary_fields)
-    end
-  end
-  
-  it "should be able to summarize a single field" do
-    @mcs.process(2)
-    summary = @mcs.summary(:revenue)
-    summary.should be_a(Hash)
-    sort_array_of_symbols(summary.keys).should eql(@summary_fields)
-    summary[:coefficient_of_variation].should eql(@mcs.revenue.sd / @mcs.revenue.mean)
-    summary[:max].should eql(@mcs.revenue.max)
-    summary[:min].should eql(@mcs.revenue.min)
-    summary[:sd].should eql(@mcs.revenue.sd)
-  end
-  
-  it "should define summary methods on the object" do
-    @mcs.process(2)
-    @mcs.revenue_summary.should eql(@mcs.summary(:revenue))
-  end
-  
-  it "should allow the model to be able to produce non-array values" do
-    margin_description = ValueDescription.new(@q1_sales) do |s|
-      {
-        :description => {:first_quarter_sales => s.first_quarter_sales, :first_quarter_prices => s.first_quarter_prices}
-      }
-    end
-    mcs = MonteCarloSet.new(margin_description)
-    lambda{mcs.process(2)}.should_not raise_error
-    lambda{mcs.summary}.should_not raise_error
-  end
-  
-  it "should set the lower bound in the summary to be no more than the minimum (when hard_lower_bound truncates the curve)" do
-    @q1_sales = PlausibleRange.new(:min => 0, :max => 2, :hard_lower_bound => 0, :name => "First Quarter Sales")
-    @q1_prices = PlausibleRange.new(:min => 1, :max => 1, :name => "First Quarter Prices")
-    @q1_sales_commissions = PlausibleRange.new(:min => 0.2, :max => 0.2, :name => "Sales Commission Rate")
-
-    @q1_gross_margins = ValueDescription.new(@q1_sales, @q1_prices, @q1_sales_commissions) do |random_sample|
-      revenue = (random_sample.first_quarter_sales * random_sample.first_quarter_prices)
-      commissions_paid = random_sample.sales_commission_rate * revenue
-      gross_margins = revenue - commissions_paid
-      {:revenue => revenue, :commissions_paid => commissions_paid, :gross_margins => gross_margins}
-    end
-    @mcs = MonteCarloSet.new(@q1_gross_margins)
-    @mcs.process(5)
-    # This is an environment where the lower bound would usually be below the minimum.  
-    # So, the minimum adheres to the hard_lower_bound constraints in the plausible range (tested elsewhere)
-    # and now we're expecting the lower bound here to reflect an actual minimum, or a 5% confidence interval,
-    # whichever is higher.
-    (@mcs.summary[:revenue][:lower_bound] >= @mcs.revenue.min).should be_true
-  end
-
-  it "should set the upper bound in the summary to be no more than the minimum (when hard_upper_bound truncates the curve)" do
-    @q1_sales = PlausibleRange.new(:min => 0, :max => 2, :hard_upper_bound => 2, :name => "First Quarter Sales")
-    @q1_prices = PlausibleRange.new(:min => 1, :max => 1, :name => "First Quarter Prices")
-    @q1_sales_commissions = PlausibleRange.new(:min => 0.2, :max => 0.2, :name => "Sales Commission Rate")
-
-    @q1_gross_margins = ValueDescription.new(@q1_sales, @q1_prices, @q1_sales_commissions) do |random_sample|
-      revenue = (random_sample.first_quarter_sales * random_sample.first_quarter_prices)
-      commissions_paid = random_sample.sales_commission_rate * revenue
-      gross_margins = revenue - commissions_paid
-      {:revenue => revenue, :commissions_paid => commissions_paid, :gross_margins => gross_margins}
-    end
-    @mcs = MonteCarloSet.new(@q1_gross_margins)
-    @mcs.process(5)
-    # This is an environment where the upper bound would usually be above the maximum
-    # So, the maximum adheres to the hard_upper_bound constraints in the plausible range (tested elsewhere)
-    # and now we're expecting the upper bound here to reflect an actual maximum, or a 95% confidence interval,
-    # whichever is higher.
-    (@mcs.summary[:revenue][:upper_bound] <= @mcs.revenue.max).should be_true
-  end
-
-end
-
-def sort_array_of_symbols(array)
-  array.map {|e| e.to_s}.sort.map {|e| e.to_sym}
-end

data/spec/fathom/node/belief_node_spec.rb

@@ -1,180 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe BeliefNode do
-  
-  before do
-    @bn = BeliefNode.new(:labels => [:red, :green, :blue])
-  end
-  
-  it "should be a Node" do
-    BeliefNode.ancestors.should be_include(Node)
-  end
-
-  it "should be a DiscreteNode as well" do
-    BeliefNode.ancestors.should be_include(DiscreteNode)
-  end
-  
-  it "should initialize with a uniform probability distribution" do
-    @bn.probabilities.should ==(GSL::Vector[1.0/3, 1.0/3, 1.0/3])
-  end
-  
-  it "should allow a pre-defined probability distribution" do
-    @bn = BeliefNode.new(:labels => [:red, :green, :blue], :probabilities => [0.1, 0.2, 0.7])
-    @bn.probabilities.should ==(GSL::Vector[0.1, 0.2, 0.7])
-  end
-  
-  it "should raise an error if the supplied probability distribution is of the wrong size" do
-    lambda{BeliefNode.new(:labels => [:red, :green, :blue], :probabilities => [0.1, 0.2, 0.7, 0.1])}.should raise_error(/Probabilities must be 3/)
-    lambda{BeliefNode.new(:labels => [:red, :green, :blue], :probabilities => [0.1, 0.2])}.should raise_error(/Probabilities must be 3/)
-  end
-  
-  it "should normalize even the supplied probabilities" do
-    @bn = BeliefNode.new(:labels => [:red, :green, :blue], :probabilities => [1, 2, 7])
-    @bn.probabilities.should ==(GSL::Vector[0.1, 0.2, 0.7])
-  end
-  
-  it "should initialize with a uniform likelihood vector" do
-    @bn.likelihoods.should ==(GSL::Vector[1,1,1])
-  end
-  
-  it "should allow pre-defined likelihoods to be supplied" do
-    @bn = BeliefNode.new(:labels => [:red, :green, :blue], :likelihoods => [1,1,2])
-    @bn.likelihoods.should ==(GSL::Vector[1,1,2])
-  end
-  
-  it "should raise an error if the supplied likelihoods are the wrong size" do
-    lambda{BeliefNode.new(:labels => [:red, :green, :blue], :likelihoods => [1,1,2,1])}.should raise_error(/Likelihoods must be 3/)
-    lambda{BeliefNode.new(:labels => [:red, :green, :blue], :likelihoods => [1,1])}.should raise_error(/Likelihoods must be 3/)
-  end
-  
-  it "should establish a precision threshold at 1.0e-05" do
-    @bn.precision_threshold.should eql(0.00001)
-  end
-  
-  it "should allow the precision_threshold as a parameter" do
-    @bn = BeliefNode.new(:labels => [:red, :green, :blue], :precision_threshold => 0.01)
-    @bn.precision_threshold.should eql(0.01)
-  end
-  
-  it "should allow a initialization from a values hash" do
-    @bn = BeliefNode.new(:values => {:red => 0.1, :green => 0.2, :yellow => 0.3, :blue => 0.4})
-    @bn.probabilities.to_a.sort.should eql([0.1, 0.2, 0.3, 0.4])
-    @bn.labels.map(&:to_s).sort.should eql(%w(blue green red yellow))
-  end
-
-  context "CPMNodes" do
-    before do
-      @b1 = BeliefNode.new(:name => :person, :values => {:david => 0.4, :adina => 0.6})
-      @b2 = BeliefNode.new(:name => :movie_preference, :values => {:drama => 0.5, :comedy => 0.4, :romance => 0.1})
-    end
-    
-    it "should automatically create an intermediary cpm when adding a child" do
-      @b1.add_child(@b2)
-      @b1.children.first.should be_a(CPMNode)
-      @b1.children.first.child.should eql(@b2)
-      @b2.parents.first.should be_a(CPMNode)
-      @b2.parents.first.parent.should eql(@b1)
-      @cpm = @b1.children.first
-      @cpm.should eql(@b2.parents.first)
-    end
-
-    it "should create an accessor for the child, rather than the cpm" do
-      @b1.add_child(@b2)
-      @b1.should_not be_respond_to(:cpm)
-      @b1.should respond_to(:movie_preference)
-      @b1.movie_preference.should eql(@b2)
-    end
-    
-    it "should create a cpm_for_* accessor for the cpm" do
-      @b1.add_child(@b2)
-      @b1.should respond_to(:cpm_for_movie_preference)
-      @b1.cpm_for_movie_preference.should eql(@b1.children.first)
-    end
-    
-    it "should create a cpm_for_* accessor for the child" do
-      @b1.add_child(@b2)
-      @b2.should respond_to(:cpm_for_person)
-      @b2.cpm_for_person.should eql(@b2.parents.first)
-      @b2.cpm_for_person.should eql(@b1.children.first)
-    end
-
-    it "should automatically create an intermediary cpm when adding a parent" do
-      @b2.add_parent(@b1)
-      @b1.children.first.should be_a(CPMNode)
-      @b1.children.first.child.should eql(@b2)
-      @b2.parents.first.should be_a(CPMNode)
-      @b2.parents.first.parent.should eql(@b1)
-      @cpm = @b1.children.first
-      @cpm.should eql(@b2.parents.first)
-    end
-    
-    it "should create an accessor for the parent, rather than the cpm" do
-      @b2.add_parent(@b1)
-      @b2.should_not be_respond_to(:cpm)
-      @b2.should respond_to(:person)
-      @b2.person.should eql(@b1)
-    end
-    
-    it "should create a cpm_for_* accessor for the cpm" do
-      @b2.add_parent(@b1)
-      @b2.should respond_to(:cpm_for_person)
-      @b2.cpm_for_person.should eql(@b2.parents.first)
-    end
-    
-    it "should create an inspect string that reflects the grandchild, rather than the cpm" do
-      @b1.add_child(@b2)
-      @b1.inspect.should eql("Fathom::BeliefNode: person, children:, [\"movie_preference (Fathom::BeliefNode)\", \"movie_preference (Fathom::BeliefNode)\"], parents: , []")
-    end
-    
-    it "should create an inspect string that reflects the grandparent, rather than the cpm" do
-      @b2.add_parent(@b1)
-      @b2.inspect.should eql("Fathom::BeliefNode: movie_preference, children:, [], parents: , [\"person (Fathom::BeliefNode)\", \"person (Fathom::BeliefNode)\"]")
-    end
-
-    it "should create a cpm_for_* accessor for the parent" do
-      @b2.add_parent(@b1)
-      @b1.should respond_to(:cpm_for_movie_preference)
-      @b1.cpm_for_movie_preference.should eql(@b1.children.first)
-      @b1.cpm_for_movie_preference.should eql(@b2.parents.first)
-    end
-    
-  end
-
-  context "Belief and Propagation" do
-    
-    before do
-      
-      @season = BeliefNode.new(:name => :season, :labels => [:winter, :spring, :summer, :fall])
-      @sprinkler = BeliefNode.new(:name => :sprinkler)
-      @rain = BeliefNode.new(:name => :rain)
-      @wet = BeliefNode.new(:name => :wet)
-      @slippery = BeliefNode.new(:name => :slippery)
-
-      @season.add_child(@sprinkler)
-      @sprinkler.add_child(@wet)
-      @season.add_child(@rain)
-      @rain.add_child(@wet)
-      @wet.add_child(@slippery)
-      
-    end
-    
-    it "should provide the likelihood for a particular value" do
-      @sprinkler.should be_respond_to(:likelihood)
-      output = @sprinkler.likelihood(:true)
-      output.should be_a(OpenStruct)
-      # @sprinkler.parents.map(&:name_sym).each {|key| output.table.keys.should be_include(key)}
-      # output.
-      # output.table.keys.should eql([:matrix, :parents])
-    end
-  end
-
-  # What's next:
-  # Deal with multiple parents and the matrix that comes in
-  # Propagate the likelihoods and probabilities up and down
-  # Calculate the belief
-  # Update the information directly on the node and propagate
-  # Receive an update from a child or parent and propagate
-  # Adhere to the precision_threshold when propagating
-end