fathom 0.3.7 → 0.5.0

data/spec/fathom/node/node_extensions/enforced_name_spec.rb

@@ -1,15 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
-
-include Fathom::Distributions
-
-class DemoEnforcedNameNode < Fathom::Node
-  include EnforcedName
-end
-
-describe EnforcedName do
-  
-  it "should ensure that we have a name as a UID if one is not provided" do
-    n = DemoEnforcedNameNode.new
-    n.name.should_not be_nil
-  end
-end

data/spec/fathom/node/node_extensions/numeric_methods_spec.rb

@@ -1,124 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
-
-include Fathom
-
-describe NumericMethods do
-  
-  before(:all) do
-    @values = [1,2,3]
-    @vector = GSL::Vector.ary_to_gv(@values)
-    @opts = {:values => @values}
-  end
-  
-  before do
-    @n = Distributions::DummyNumericNode.new(@opts)
-  end
-  
-  it "should respond to a rand method" do
-    @n = Distributions::DummyNumericNode.new
-    @n.should be_respond_to(:rand)
-  end
-  
-  it "should be able to construct a vector from the values" do
-    @n.vector.should ==(@vector)
-  end
-  
-  it "should have a standard deviation if it has a vector" do
-    @n.standard_deviation.should eql(@vector.sd)
-  end
-  
-  it "should have std and sd aliases for standard deviation" do
-    @n.sd.should eql(@n.standard_deviation)
-    @n.std.should eql(@n.standard_deviation)
-  end
-  
-  it "should not raise an error when looking for a standard deviation and there is no vector" do
-    @n = Distributions::DummyNumericNode.new
-    @n.vector.should be_nil
-    @n.sd.should be_nil
-  end
-  
-  it "should have a mean if it has a vector" do
-    @n.mean.should eql(@vector.mean)
-  end
-  
-  it "should return nil for mean if it doesn't have a vector" do
-    @n = Distributions::DummyNumericNode.new
-    @n.mean.should be_nil
-  end
-  
-  it "should provide rand, if it has a vector" do
-    Distributions::Gaussian.should_receive(:rand).and_return(0.5)
-    @n.rand
-  end
-  
-  it "should return nil for rand if it doesn't have a vector" do
-    @n = Distributions::DummyNumericNode.new
-    @n.mean.should be_nil
-  end
-  
-  it "should be able to calculate the inverse_cdf, lower_bound, upper_bound and interval_values" do
-    lambda{@n.inverse_cdf}.should_not raise_error
-    lambda{@n.lower_bound}.should_not raise_error
-    lambda{@n.upper_bound}.should_not raise_error
-    lambda{@n.interval_values}.should_not raise_error
-  end
-  
-  it "should pass the mean and standard deviation to the distribution when calculating an inverse_cdf" do
-    @n.inverse_cdf.should eql(Distributions::Gaussian.inverse_cdf(:mean => @n.mean, :sd => @n.sd))
-  end
-
-  it "should pass the mean and standard deviation to the distribution when calculating an lower_bound" do
-    @n.lower_bound.should eql(Distributions::Gaussian.lower_bound(:mean => @n.mean, :sd => @n.sd))
-  end
-
-  it "should pass the mean and standard deviation to the distribution when calculating an upper_bound" do
-    @n.upper_bound.should eql(Distributions::Gaussian.upper_bound(:mean => @n.mean, :sd => @n.sd))
-  end
-
-  it "should pass the mean and standard deviation to the distribution when calculating an interval_values" do
-    @n.interval_values.should eql(Distributions::Gaussian.interval_values(:mean => @n.mean, :sd => @n.sd))
-  end
-  
-  it "should have a coefficient_of_variation" do
-    @n.coefficient_of_variation.should eql(@n.sd / @n.mean)
-  end
-  
-  it "should have a cov alias for coefficient_of_variation" do
-    @n.cov.should eql(@n.coefficient_of_variation)
-  end
-  
-  it "should have a summary hash" do
-    @n.should be_respond_to(:summary)
-    @n.summary.should be_a(Hash)
-  end
-  
-  it "should have a mean in the summary" do
-    @n.summary[:mean].should eql(@n.mean)
-  end
-  
-  it "should have a standard deviation in the summary" do
-    @n.summary[:standard_deviation].should eql(@n.standard_deviation)
-  end
-  
-  it "should have a min in the summary" do
-    @n.summary[:min].should eql(@n.vector.min)
-  end
-  
-  it "should have a max in the summary" do
-    @n.summary[:max].should eql(@n.vector.max)
-  end
-  
-  it "should have a lower_bound in the summary" do
-    @n.summary[:lower_bound].should eql(@n.lower_bound)
-  end
-  
-  it "should have an upper_bound in the summary" do
-    @n.summary[:upper_bound].should eql(@n.upper_bound)
-  end
-  
-  it "should have a coefficient_of_variation in the summary" do
-    @n.summary[:coefficient_of_variation].should eql(@n.sd / @n.mean)
-  end
-  
-end

data/spec/fathom/node/plausible_range_spec.rb

@@ -1,151 +0,0 @@
-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
-  
-  it "should be able to calculate the standard deviation" do
-    @pr.standard_deviation.should be_within(0.0001).of( 2.7358)
-  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
-  
-  it "should not exceed the lower bound if it is set", :slow => true do
-    pr = PlausibleRange.new(:max => 100, :hard_lower_bound => 0)
-    1_000.times do
-      (pr.rand >= 0).should eql(true)
-    end
-  end
-  
-  it "should not exceed the upper bound if it is set", :slow => true do
-    pr = PlausibleRange.new(:min => 0, :hard_upper_bound => 100)
-    1_000.times do
-      (pr.rand <= 100).should eql(true)
-    end
-  end
-  
-  it "should not exceed the lower bound or upper bound if both are set", :slow => true do
-    pr = PlausibleRange.new(:hard_upper_bound => 100, :hard_lower_bound => 0)
-    1_000.times do
-      r = pr.rand
-      (r >= 0 and r <= 100).should eql(true)
-    end
-  end
-  
-end

data/spec/fathom/node_spec.rb

@@ -1,172 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-include Fathom
-
-describe Node do
-  it "should take an options hash to instantiate" do
-    lambda{Node.new(:any_value => true)}.should_not raise_error
-  end
-  
-  it "should take an optional name parameter" do
-    node = Node.new(:name => "My Name")
-    node.name.should eql("My Name")
-  end
-  
-  it "should take an optional distribution parameter" do
-    node = Node.new(:distribution => Fathom::Distributions::Gaussian)
-    node.distribution.should eql(Fathom::Distributions::Gaussian)
-  end
-  
-  it "should default to the standard distribution" do
-    node = Node.new
-    node.distribution.should eql(Fathom::Distributions::Gaussian)
-  end
-  
-  it "should be able to take a symbol and find the appropriate distribution" do
-    node = Node.new(:distribution => :gaussian)
-    node.distribution.should eql(Fathom::Distributions::Gaussian)
-  end
-  
-  it "should take an optional description" do
-    node = Node.new(:description => "some description")
-    node.description.should eql('some description')
-  end
-  
-  it "should take an optional values parameter" do
-    node = Node.new(:values => [1,2,3])
-    node.values.should eql([1,2,3])
-  end
-  
-  it "should provide name_sym, if a name is defined" do
-    node = Node.new(:name => "Some name")
-    node.name_sym.should eql(:some_name)
-  end
-  
-  it "should change dashes to underscores for name_sym" do
-    node = Node.new(:name => "Some-name")
-    node.name_sym.should eql(:some_name)
-  end
-  
-  it "should take an optional parents list" do
-    n1 = Node.new
-    n2 = Node.new(:parents => [n1])
-    n2.parents.should eql([n1])
-  end
-  
-  it "should allow a single node as a parent or parents and turn it into an array" do
-    n1 = Node.new
-    n2 = Node.new(:parents => n1)
-    n2.parents.should eql([n1])
-    n2 = Node.new(:parent => n1)
-    n2.parents.should eql([n1])
-  end
-  
-  it "should create an empty list of parents by default" do
-    n1 = Node.new
-    n1.parents.should eql([])
-  end
-  
-  it "should be able to add a parent" do
-    n1, n2 = Node.new, Node.new
-    n3 = Node.new(:parent => n2)
-    n3.add_parent(n1)
-    n3.parents.should eql([n2, n1])
-  end
-  
-  it "should register the receiving node when adding a parent" do
-    n1 = Node.new
-    n1.should_receive(:register_child).and_return(true)
-    n2 = Node.new(:parent => n1)
-
-    n1 = Node.new
-    n1.should_receive(:register_child).and_return(true)
-    n2 = Node.new
-    n2.add_parent(n1)
-  end
-
-  it "should not allow a parent to be registered if it is not a child of the other node" do
-    n1 = Node.new
-    n2 = Node.new
-    lambda{n2.register_parent(n1)}.should raise_error
-  end
-
-  it "should take an optional children list" do
-    n1 = Node.new
-    n2 = Node.new(:children => [n1])
-    n2.children.should eql([n1])
-  end
-  
-  it "should allow a single node as a child or children and turn it into an array" do
-    n1 = Node.new
-    n2 = Node.new(:children => n1)
-    n2.children.should eql([n1])
-    n2 = Node.new(:child => n1)
-    n2.children.should eql([n1])
-  end
-  
-  it "should create an empty list of children by default" do
-    n1 = Node.new
-    n1.children.should eql([])
-  end
-  
-  it "should register the receiving node when adding a child" do
-    n1 = Node.new
-    n1.should_receive(:register_parent).and_return(true)
-    n2 = Node.new(:child => n1)
-
-    n1 = Node.new
-    n1.should_receive(:register_parent).and_return(true)
-    n2 = Node.new
-    n2.add_child(n1)
-  end
-  
-  it "should not allow a child to be registered if it is not a parent of the other node" do
-    n1 = Node.new
-    n2 = Node.new
-    lambda{n2.register_child(n1)}.should raise_error
-  end
-  
-  it "should define an accessor method for the child node when added" do
-    n1 = Node.new(:name => 'n1')
-    n2 = Node.new :name => 'n2', :child => n1
-    n2.n1.should eql(n1)
-    n1.should_not respond_to(:n1)
-  end
-  
-  it "should define an accessor method for the parent node when added" do
-    n1 = Node.new(:name => 'n1')
-    n2 = Node.new :parent => n1
-    n2.n1.should eql(n1)
-    n1.should_not respond_to(:n1)
-  end
-  
-  it "should have defined an accessor method for the added child to the parent" do
-    n1 = Node.new(:name => 'n1')
-    n2 = Node.new :name => 'n2', :child => n1
-    n1.n2.should eql(n2)
-  end
-
-  it "should have defined an accessor method for the added parent to the child" do
-    n1 = Node.new(:name => 'n1')
-    n2 = Node.new :name => 'n2', :parent => n1
-    n1.n2.should eql(n2)
-  end
-  
-  # it "should have introduced the Spira infrastructure by now" do
-  #   Object.should be_const_defined(:Spira)
-  # end
-  
-  # it "should have defined the spira repository" do
-  #   Spira.repositories[:default].should be_a(RDF::Repository)
-  # end
-
-  # This really changes the interface for everything.  So, either I re-purpose a node, or something...
-  # Next steps: read the Spira source and figure out what's easier to do: replace the functionality
-  # or change my interfaces. (btw, 9 issues, only.  
-  # Mostly just tied to creating the node accessors (n1.n2 type thing))
-  
-  # it "should have Spira included" do
-  #   Node.included_modules.should be_include(Spira::Resource)
-  # end
-
-end