fathom 0.3.7 → 0.5.0

data/spec/fathom/node/cpm_node_spec.rb

@@ -1,144 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe CPMNode do
-  
-  before do
-    @child = BeliefNode.new(:name => :color, :values => {:red => 0.4, :green => 0.6})
-    @parent = BeliefNode.new(:name => :child, :values => {:asher => 0.2, :stella => 0.8})
-    @cpm = CPMNode.new(:child => @child, :parent => @parent)
-  end
-  
-  it "should subclass Node" do
-    CPMNode.ancestors[1].should eql(Node)
-  end
-  
-  it "should allow a BeliefNode child and parent" do
-    @cpm.parent.should eql(@parent)
-    @cpm.child.should eql(@child)
-  end
-  
-  it "should generate a conditional probability matrix from the parent and child" do
-    parent_values = @cpm.parent.probabilities.col
-    child_values = @cpm.child.probabilities
-    matrix = parent_values * child_values
-    @cpm.values.to_a.should eql(matrix.to_a)
-  end
-  
-  it "should alias the values with matrix" do
-    @cpm.values.should eql(@cpm.matrix)
-  end
-  
-  it "should raise an error when trying to load non-BeliefNode parent or child" do
-    lambda{CPMNode.new(:child => :not_a_belief_node, :parent => @parent)}.should raise_error(/must be a BeliefNode/)
-    lambda{CPMNode.new(:child => @child, :parent => :not_a_belief_node)}.should raise_error(/must be a BeliefNode/)
-  end
-  
-  it "should have a probability lookup" do
-    @cpm.should be_respond_to(:probability)
-  end
-
-  it "should only allow options for the parent and child names" do
-    lambda{@cpm.probability :not_a_link => true}.should raise_error(/unknown/i)
-  end
-
-  it "should be able to lookup the values we're looking for" do
-    # The Matrix looks like this:
-    # GSL::Matrix
-    # [  8.000e-02  1.200e-01 
-    #    3.200e-01  4.800e-01 ]
-    @cpm.probability(:color => :red, :child => :asher).should be_within(1e-10).of(0.08)
-    @cpm.probability(:color => :red, :child => :stella).should be_within(1e-10).of(0.32)
-    @cpm.probability(:color => :green, :child => :asher).should be_within(1e-10).of(0.12)
-    @cpm.probability(:color => :green, :child => :stella).should be_within(1e-10).of(0.48)
-  end
-  
-  it "should look for all children values, if no child is provided" do
-    @cpm.probability(:child => :asher).should be_within(1e-10).of(0.2)
-    @cpm.probability(:child => :stella).should be_within(1e-10).of(0.8)
-  end
-  
-  it "should look for all parent values, if no parent is provided" do
-    @cpm.probability(:color => :red).should be_within(1e-10).of(0.4)
-    @cpm.probability(:color => :green).should be_within(1e-10).of(0.6)
-  end
-  
-  it "should provide a probability of 1 if no filter is set" do
-    @cpm.probability.should be_within(1e-10).of(1.0)
-  end
-  
-  it "should give a description in a hash, if description is turned on" do
-    @cpm.probability(:color => :red, :child => :asher, :describe => true).keys.first.should eql('P(red | asher)')
-    @cpm.probability(:color => :red, :child => :stella, :describe => true).keys.first.should eql('P(red | stella)')
-    @cpm.probability(:color => :green, :child => :asher, :describe => true).keys.first.should eql('P(green | asher)')
-    @cpm.probability(:color => :green, :child => :stella, :describe => true).keys.first.should eql('P(green | stella)')
-    @cpm.probability(:child => :asher, :describe => true).keys.first.should eql('P(red or green | asher)')
-    @cpm.probability(:child => :stella, :describe => true).keys.first.should eql('P(red or green | stella)')
-    @cpm.probability(:color => :red, :describe => true).keys.first.should eql('P(red | asher or stella)')
-    @cpm.probability(:color => :green, :describe => true).keys.first.should eql('P(green | asher or stella)')
-    @cpm.probability(:describe => true).keys.first.should eql('P(red or green | asher or stella)')
-  end
-  
-  it "should alias p for probability" do
-    @cpm.p(:color => :red, :child => :asher).should be_within(1e-10).of(0.08)
-    @cpm.p(:color => :red, :child => :stella).should be_within(1e-10).of(0.32)
-    @cpm.p(:color => :green, :child => :asher).should be_within(1e-10).of(0.12)
-    @cpm.p(:color => :green, :child => :stella).should be_within(1e-10).of(0.48)
-    @cpm.p(:child => :asher).should be_within(1e-10).of(0.2)
-    @cpm.p(:child => :stella).should be_within(1e-10).of(0.8)
-    @cpm.p(:color => :red).should be_within(1e-10).of(0.4)
-    @cpm.p(:color => :green).should be_within(1e-10).of(0.6)
-    @cpm.p.should be_within(1e-10).of(1.0)
-  end
-  
-  it "should have odds for any query" do
-    @cpm.odds(:color => :red, :child => :asher).should be_within(1e-3).of(0.087)
-    @cpm.odds(:color => :red, :child => :stella).should be_within(1e-3).of(0.471)
-    @cpm.odds(:color => :green, :child => :asher).should be_within(1e-3).of(0.136)
-    @cpm.odds(:color => :green, :child => :stella).should be_within(1e-3).of(0.923)
-    @cpm.odds(:child => :asher).should be_within(1e-3).of(0.25)
-    @cpm.odds(:child => :stella).should be_within(1e-3).of(4.0)
-    @cpm.odds(:color => :red).should be_within(1e-3).of(0.666)
-    @cpm.odds(:color => :green).should be_within(1e-3).of(1.5)
-    @cpm.odds.should eql(1 / 0.0)
-  end
-  
-  it "should alias o for odds" do
-    @cpm.o(:color => :red, :child => :asher).should be_within(1e-3).of(0.087)
-    @cpm.o(:color => :red, :child => :stella).should be_within(1e-3).of(0.471)
-    @cpm.o(:color => :green, :child => :asher).should be_within(1e-3).of(0.136)
-    @cpm.o(:color => :green, :child => :stella).should be_within(1e-3).of(0.923)
-    @cpm.o(:child => :asher).should be_within(1e-3).of(0.25)
-    @cpm.o(:child => :stella).should be_within(1e-3).of(4.0)
-    @cpm.o(:color => :red).should be_within(1e-3).of(0.666)
-    @cpm.o(:color => :green).should be_within(1e-3).of(1.5)
-    @cpm.o.should eql(1 / 0.0)
-  end
-  
-  it "should default the name to :cpm" do
-    @cpm.name.should eql(:cpm)
-  end
-  
-  it "should default the description" do
-    @cpm.description.should eql("Conditional Probability Matrix from child to color.")
-  end
-  
-  it "should return a vector for likelihood" do
-    @cpm.likelihood(:red).should be_a(GSL::Vector)
-  end
-  
-  it "should offer the likelihood of each parent value, given a child value" do
-    values = @cpm.likelihood(:red).to_a
-    values.sort.map {|e| (e * 100).to_i}.should eql([8, 32])
-
-    values = @cpm.likelihood(:green).to_a
-    values.sort.map {|e| (e * 100).to_i}.should eql([12, 48])
-  end
-  
-  it "should offer l as an alias for likelihood" do
-    values = @cpm.l(:red).to_a
-    values.sort.map {|e| (e * 100).to_i}.should eql([8, 32])
-
-    values = @cpm.l(:green).to_a
-    values.sort.map {|e| (e * 100).to_i}.should eql([12, 48])
-  end
-end

data/spec/fathom/node/data_collection_spec.rb

@@ -1,26 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe DataCollection do
-  it "should be a node" do
-    DataCollection.ancestors.should be_include(Node)
-  end
-  
-  it "should be a DiscreteNode as well" do
-    DataCollection.ancestors.should be_include(DiscreteNode)
-  end
-  
-  it "should be able to extract the discrete labels from the first discrete parent node added to it" do
-    pr = PlausibleRange.new(:min => 0, :max => 1)
-    dn = DiscreteNode.new(:labels => [1,2,3])
-    dc = DataCollection.new(:parents => [pr, dn])
-    dc.labels.should eql([1,2,3])
-  end
-  
-  it "should enforce a name" do
-    dc = DataCollection.new(:labels => [1,2,3])
-    dc.name.should_not be_nil
-  end
-  
-end

data/spec/fathom/node/data_node_spec.rb

@@ -1,102 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe DataNode do
-
-  before do
-    @values = [1,2,3,4,5]
-    @opts = {:values => @values}
-    @dn = DataNode.new(@opts)
-    @vector = GSL::Vector.ary_to_gv(@values)
-  end
-  
-  it "should initialize requiring values in the options" do
-    lambda{DataNode.new}.should raise_error(/values/)
-    lambda{DataNode.new(:values => @values)}.should_not raise_error
-  end
-  
-  it "should make the values readable" do
-    @dn.values.should eql(@values)
-  end
-  
-  it "should allow an optional name for the node" do
-    @dn = DataNode.new(:values => @values, :name => "Demo Name")
-    @dn.name.should eql("Demo Name")
-  end
-  
-  it "should take an optional distribiution" do
-    @dn = DataNode.new(@opts.merge(:distribution => :gaussian))
-    @dn.distribution.should eql(Fathom::Distributions::Gaussian)
-  end
-
-  it "should create a vector from the values" do
-    @dn.vector.should ==(@vector)
-  end
-  
-  it "should provide the standard deviation" do
-    @dn.standard_deviation.should ==(@vector.sd)
-  end
-  
-  it "should alias sd and std for standard_deviation" do
-    @dn.sd.should eql(@dn.standard_deviation)
-    @dn.std.should eql(@dn.standard_deviation)
-  end
-  
-  it "should be able to produce the mean" do
-    @dn.mean.should eql(@vector.mean)
-  end
-
-  it "should generate a random variable that fits the data's distribution" do
-    @dn.rand.should be_a(Float)
-  end
-  
-  it "should have a name_sym method" do
-    dn = DataNode.new(:name => "Demo Node", :values => [1,2,3])
-    dn.name_sym.should eql(:demo_node)
-  end
-
-  it "should offer the lower bounds at a default confidence level of 0.05" do
-    GSL::Cdf.should_receive(:gaussian_Pinv).with(0.05, @dn.vector.sd).and_return(0.0)
-    @dn.inverse_cdf
-  end
-  
-  it "should offer the lower bounds at an arbitrary confidence level" do
-    GSL::Cdf.should_receive(:gaussian_Pinv).with(0.95, @dn.vector.sd).and_return(0.0)
-    @dn.inverse_cdf(:confidence_interval => 0.95)
-  end
-  
-  it "should be able to calculate the upper bound by passing upper as a parameter" do
-    GSL::Cdf.should_receive(:gaussian_Qinv).with(0.05, @dn.vector.sd).and_return(0.0)
-    @dn.inverse_cdf(:confidence_interval => 0.05, :upper => true)
-  end
-  
-  it "should be able to calculate a lower_bound, an alias for inverse_cdf" do
-    GSL::Cdf.should_receive(:gaussian_Pinv).with(0.05, @dn.vector.sd).and_return(0.0)
-    @dn.lower_bound
-  end
-  
-  it "should be able to pass arguments to lower_bound" do
-    GSL::Cdf.should_receive(:gaussian_Pinv).with(0.1, @dn.vector.sd).and_return(0.0)
-    @dn.lower_bound(:confidence_interval => 0.1)
-  end
-  
-  it "should be able to calculate an upper_bound, a shortcut for inverse_cdf(confidence_interval, false)" do
-    GSL::Cdf.should_receive(:gaussian_Qinv).with(0.05, @dn.vector.sd).and_return(0.0)
-    @dn.upper_bound
-  end
-  
-  it "should be able to pass arguments to upper_bound" do
-    GSL::Cdf.should_receive(:gaussian_Qinv).with(0.1, @dn.vector.sd).and_return(0.0)
-    @dn.upper_bound(:confidence_interval => 0.1)
-  end
-  
-  it "should offset the cdf results by the mean" do
-    @dn.lower_bound.should eql(GSL::Cdf.gaussian_Pinv(0.05, @dn.vector.sd) + @dn.vector.mean)
-  end
-  
-  it "should return the lower and upper bounds of a confidence interval" do
-    @dn.interval_values.should eql([@dn.lower_bound, @dn.upper_bound])
-  end
-  
-end

data/spec/fathom/node/decision_spec.rb

@@ -1,15 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe Decision do
-  it "should be a type of node" do
-    Decision.ancestors.should be_include(Node)
-  end
-  
-  it "should not have a distribution or values" do
-    @d = Decision.new
-    @d.should_not be_respond_to(:distribution)
-    @d.should_not be_respond_to(:values)
-  end
-end

data/spec/fathom/node/discrete_node_spec.rb

@@ -1,56 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe DiscreteNode do
-  
-  before do
-    @dn = DiscreteNode.new(:labels => [1,2,3])
-  end
-  
-  it "should assign :true and :false for labels, if none are provided" do
-    lambda{@dn = DiscreteNode.new}.should_not raise_error
-    @dn.labels.should eql([:true, :false])
-  end
-  
-  it "should create an array from a single value for its labels" do
-    dn = DiscreteNode.new(:labels => 1)
-    dn.labels.should eql([1])
-  end
-  
-  it "should take the values and convert them to labels, if there are no labels provided" do
-    dn = DiscreteNode.new(:values => [1,2,3])
-    dn.labels.should eql([1,2,3])
-  end
-  
-  it "should create a unique list of labels" do
-    dn = DiscreteNode.new(:labels => [1,1,2,3,1])
-    dn.labels.should eql([1,2,3])
-  end
-  
-  it "should expose the size of the labels" do
-    @dn.size.should eql(3)
-  end
-  
-  it "should alias length for size" do
-    @dn.length.should eql(3)
-  end
-  
-  it "should have a default distribution of DiscreteUniform" do
-    @dn.distribution.should eql(Fathom::Distributions::DiscreteUniform)
-  end
-  
-  it "should be able to produce a random variable from the discrete distribution" do
-    @dn = DiscreteNode.new(:labels => [1,2])
-    # 9.31322574615479e-10 chance of failing
-    30.times.map {@dn.rand}.uniq.sort.should eql([1,2])
-  end
-  
-  it "should offer a uniform likelihood" do
-    @dn.likelihood(:anything).to_a.should eql([1.0, 1.0, 1.0])
-  end
-  
-  it "should offer an alias of l for likelihood" do
-    @dn.l(:anything).to_a.should eql([1.0, 1.0, 1.0])
-  end
-end

data/spec/fathom/node/fact_spec.rb

@@ -1,33 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe Fact do
-  before do
-    @f = Fact.new(
-      :value => 2, 
-      :name => "Some Fact", 
-      :description => "Just a demonstration of what a good fact may look like.  Facts are really about things that are certain--there are 7 days in a week, that sort of thing.  Too often I was creating a PlausibleRange with the min and max to the same value."
-    )
-  end
-  
-  it "should be a Node" do
-    Fact.ancestors.should be_include(Fathom::Node)
-  end
-  
-  it "should take a value (rather than values)" do
-    @f.value.should eql(2)
-  end
-  
-  it "should return the value for rand" do
-    @f.rand.should eql(2)
-  end
-  
-  it "should have removed the distribution and values methods" do
-    @f.should_not be_respond_to(:values)
-    @f.should_not be_respond_to(:distribution)
-    @n = Node.new(:distribution => :standard, :values => [1,2,3])
-    @n.values.should eql([1,2,3])
-    @n.distribution.should eql(Fathom::Distributions::Gaussian)
-  end
-end

data/spec/fathom/node/mc_node_spec.rb

@@ -1,66 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe MCNode do
-  
-  before(:all) do
-    @fields = [:value_result]
-  end
-  
-  before do 
-    @vd = lambda{|n| {:value_result => 1}}
-    @mcn = MCNode.new(:value_description => @vd)
-  end
-  
-  it "should be a type of Node" do
-    MCNode.ancestors.should be_include(Fathom::Node)
-  end
-  
-  it "should use a value_description from the command-line arguments" do
-    mcn = MCNode.new(:value_description => @vd)
-    mcn.value_description.should eql(@vd)
-  end
-  
-  it "should be able to take a block instead of a named lambda for the value description" do
-    mcn = MCNode.new {|n| {:value_result => 1}}
-    mcn.value_description.should be_a(Proc)
-  end
-  
-  it "should require a value_description from either a parameter or a block passed in" do
-    lambda{MCNode.new}.should raise_error(/value_description/)
-  end
-  
-  it "should process with the default number of runs at 10,000", :slow => true do
-    lambda{@mcn.process}.should_not raise_error
-    @mcn.samples_taken.should eql(10_000)
-  end
-  
-  it "should call the value_description block each time it is processed" do
-    @vd.should_receive(:call).exactly(3).times.with(@mcn).and_return({:value_result => 1})
-    @mcn.process(3)
-  end
-  
-  it "should define children nodes for all keys in the result set" do
-    @mcn.process(1)
-    @mcn.value_result.should be_a(Node)
-    @mcn.value_result.values.should eql([1])
-    @mcn.value_result.vector.should be_a(GSL::Vector)
-  end
-  
-  it "should be resetable" do
-    @mcn.process(1)
-    @mcn.reset!
-    lambda{@mcn.process(1)}.should_not raise_error
-  end
-  
-  it "should expose the fields from the samples" do
-    @mcn.process(1)
-    sort_array_of_symbols(@mcn.fields).should eql(@fields)
-  end
-  
-  
-end
-def sort_array_of_symbols(array)
-  array.map {|e| e.to_s}.sort.map {|e| e.to_sym}
-end