fathom 0.1.0

data/spec/fathom/data_node_spec.rb

@@ -0,0 +1,61 @@
+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
+  
+  # Note, the distributions aren't defined here yet, so this will eventually be
+  # Some sort of Fathom::Distribution::Constant eventually.
+  it "should take an optional distribiution" do
+    @dn = DataNode.new(@opts.merge(:distribution => :some_distribution))
+    @dn.distribution.should eql(:some_distribution)
+  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
+
+end

data/spec/fathom/import/csv_import_spec.rb

@@ -0,0 +1,36 @@
+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 create as many data nodes as there are columns" do
+    @result.size.should eql(3)
+    @result.each {|dn| dn.should be_a(DataNode)}
+  end
+  
+  it "should import the values from each column into each data node" do
+    @result[0].values.should eql([1,4,7])
+    @result[1].values.should eql([2,5,8])
+    @result[2].values.should eql([3,6,9])
+  end
+  
+end

data/spec/fathom/import/yaml_import_spec.rb

@@ -0,0 +1,40 @@
+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 PlausibleRange nodes for any hashes with at least a min and max key in it" do
+    @result.find {|r| r.name == "CO2 Emissions"}.should_not be_nil
+  end
+  
+  it "should not create a PlausibleRange for entries missing min and max" do
+    @result.find {|r| r.name == "Invalid Hash"}.should be_nil
+  end
+  
+  it "should be able to create a PlausibleRange with more complete information" do
+    more_complete_range = @result.find {|r| r.name == "More Complete Range"}
+    more_complete_range.ci.should eql(0.6)
+    more_complete_range.description.should eql('Some good description')
+  end
+  
+  it "should create DataNodes for entries that have an array of information" do
+    data_node = @result.find {|r| r.name == 'CO2 Readings'}
+    data_node.should be_a(DataNode)
+    data_node.values.should eql([10,20,30])
+  end
+  
+end

data/spec/fathom/import_spec.rb

@@ -0,0 +1,22 @@
+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 a optional content" do
+    @i.content.should eql(@content)
+  end
+
+  it "should record the initialization options" do
+    @i.options.should eql(@options)
+  end
+  
+end

data/spec/fathom/knowledge_base_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include Fathom
+
+describe KnowledgeBase do
+  
+  before do
+    @kb = KnowledgeBase.new
+  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

@@ -0,0 +1,58 @@
+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
+  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
+end

data/spec/fathom/plausible_range_spec.rb

@@ -0,0 +1,130 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include Fathom
+
+describe PlausibleRange do
+  
+  before do
+    @d = {:upper_bound => 10, :lower_bound => 1}
+    @pr = PlausibleRange.new(@d)
+  end
+  
+  it "should require an upper and lower bound" do
+    lambda{PlausibleRange.new}.should raise_error(/upper/)
+    lambda{PlausibleRange.new(:upper_bound => 10)}.should raise_error(/lower/)
+    lambda{PlausibleRange.new(:upper_bound => 10, :lower_bound => 1)}.should_not raise_error
+  end
+  
+  it "should expose the upper bound and lower bound" do
+    @pr.upper_bound.should eql(10)
+    @pr.lower_bound.should eql(1)
+  end
+  
+  it "should use min or max instead of lower_bound or upper_bound" do
+    pr = PlausibleRange.new(:min => 1, :max => 10)
+    pr.min.should eql(1)
+    pr.max.should eql(10)
+    pr.lower_bound.should eql(1)
+    pr.upper_bound.should eql(10)
+  end
+  
+  it "should allow an optional hard_lower_bound" do
+    pr = PlausibleRange.new(@d.merge(:hard_lower_bound => 0))
+    pr.hard_lower_bound.should eql(0)
+  end
+  
+  it "should set the lower_bound to the hard_lower_bound if the hard_lower_bound is greater than the lower_bound" do
+    pr = PlausibleRange.new(:lower_bound => 2, :hard_lower_bound => 3, :upper_bound => 4)
+    pr.lower_bound.should eql(3)
+  end
+  
+  it "should allow an optional hard_upper_bound" do
+    pr = PlausibleRange.new(@d.merge(:hard_upper_bound => 20))
+    pr.hard_upper_bound.should eql(20)
+  end
+  
+  it "should set the upper_bound to the hard_upper_bound if the hard_upper_bound is less than the upper_bound" do
+    pr = PlausibleRange.new(:lower_bound => 2, :hard_upper_bound => 3, :upper_bound => 4)
+    pr.upper_bound.should eql(3)
+  end
+  
+  it "should have a default confidence interval of 90%" do
+    @pr.confidence_interval.should eql(0.9)
+  end
+  
+  it "should be able to instantiate with confidence_interval" do
+   pr = PlausibleRange.new(@d.merge(:confidence_interval => 0.8)) 
+   pr.confidence_interval.should eql(0.8)
+  end
+  
+  it "should be able to use ci instead of confidence_interval" do
+    pr = PlausibleRange.new(@d.merge(:ci => 0.8)) 
+    pr.ci.should eql(0.8)
+    pr.confidence_interval.should eql(0.8)
+  end
+  
+  it "should be able to calculate the midpoint" do
+    @pr.midpoint.should eql(5.5)
+  end
+  
+  # TODO: Make this more accurate when we start using the GSL stuff more
+  it "should be able to calculate the standard deviation" do
+    @pr.standard_deviation.should be_close(2.73556231003039, 0.00000001)
+  end
+  
+  it "should be able to use std instead of standard_deviation" do
+    @pr.std.should eql(@pr.standard_deviation)
+  end
+  
+  it "should be able to produce a random value from within the distribution" do
+    @pr.should be_respond_to(:rand)
+    @pr.rand.should be_a(Float)
+  end
+  
+  it "should be able to produce an array of random values" do
+    @pr.array_of_random_values.should be_an(Array)
+    @pr.array_of_random_values.length.should eql(10)
+    @pr.array_of_random_values(13).length.should eql(13)
+  end
+  
+  it "should alias array_of_random_values with to_a" do
+    @pr.to_a.should be_an(Array)
+    @pr.to_a.length.should eql(10)
+    @pr.to_a(13).length.should eql(13)
+  end
+  
+  it "should be able to produce a vector of random values" do
+    @pr.vector_of_random_values.should be_a(GSL::Vector)
+    @pr.vector_of_random_values.length.should eql(10)
+    @pr.vector_of_random_values(12).length.should eql(12)
+  end
+  
+  it "should alias vector_of_random_values with to_v" do
+    @pr.to_v.should be_a(GSL::Vector)
+    @pr.to_v.length.should eql(10)
+    @pr.to_v(12).length.should eql(12)
+  end
+  
+  it "should record the name, if one is provided" do
+    pr = PlausibleRange.new(@d.merge(:name => 'pr1'))
+    pr.name.should eql('pr1')
+  end
+  
+  it "should record the description, if one is provided" do
+    pr = PlausibleRange.new(@d.merge(:description => 'some description'))
+    pr.description.should eql('some description')
+  end
+  
+  it "should have no problems with a range with matching lower and upper bounds" do
+    pr = PlausibleRange.new(:min => 1, :max => 1)
+    pr.rand.should eql(1.0)
+    pr.midpoint.should eql(1.0)
+    pr.std.should eql(0.0)
+  end
+  
+  it "should have a name_sym method" do
+    pr = PlausibleRange.new(:min => 1, :max => 2, :name => "Demo Node")
+    pr.name_sym.should eql(:demo_node)
+  end
+  
+end

data/spec/fathom/value_description_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include Fathom
+
+describe ValueDescription do
+  
+  before(:all) do
+    @r1 = PlausibleRange.new(:min => 1, :max => 3, :name => 'r1')
+    @r2 = PlausibleRange.new(:min => 1, :max => 3, :name => 'r2')
+    @r3 = PlausibleRange.new(:min => 1, :max => 3, :name => 'r3')
+    @r4 = PlausibleRange.new(:min => 1, :max => 3, :name => 'r4')
+  end
+  
+  before do
+    @vd = ValueDescription.new
+  end
+  
+  it "should be able to initialize with no nodes" do
+    @vd.nodes.should be_empty
+  end
+  
+  it "should be able to take a set of nodes to work with" do
+    vd = ValueDescription.new @r1, @r2, @r3, @r4
+    vd.nodes.should eql([@r1, @r2, @r3, @r4])
+  end
+  
+  it "should respond to the names of the nodes being added" do
+    vd = ValueDescription.new @r1, @r2
+    vd.r1.should be_a(Float)
+    vd.r2.should be_a(Float)
+  end
+  
+  it "should be able to add a node with add_node" do
+    @vd.add_node(@r3)
+    @vd.r3.should be_a(Float)
+  end
+  
+  it "should be able to add a node with an alternative value method" do
+    @vd.add_node(@r3, :name)
+    @vd.r3.should eql('r3')
+  end
+  
+  it "should be able to initialize with a hash, to define the value methods" do
+    vd = ValueDescription.new @r1 => :rand, @r2 => :name
+    vd.r1.should be_a(Float)
+    vd.r2.should eql('r2')
+  end
+  
+  it "should convert node names to lower case, underscore values" do
+    pr = PlausibleRange.new(:min => 1, :max => 3, :name => 'Test Node')
+    vd = ValueDescription.new pr => :name
+    vd.test_node.should eql('Test Node')
+  end
+
+  it "should respond to process, which by default just adds up the values of the nodes" do
+    vd = ValueDescription.new @r1, @r2
+    output = vd.process
+    sum = vd.last_process.values.inject(0.0) {|s, e| s += e}
+    output.should eql(sum)
+  end
+  
+  it "should be able to take an optional block at initialization" do
+    vd = ValueDescription.new(@r1 => :name) {|obj|
+      obj.r1
+    }
+    output = vd.process
+    output.should eql('r1')
+  end
+  
+end

data/spec/fathom_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Fathom" do
+  it "should have required gsl, but not included it (avoiding Rational conflicts)" do
+    Fathom.included_modules.should_not be_include(GSL)
+    lambda{GSL}.should_not raise_error
+  end
+end