fathom 0.2.2 → 0.2.3

data/lib/fathom/{basic_node.rb → enforced_name.rb}

@@ -1,7 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+require 'uuid'
+
 module Fathom
-  module BasicNode
+  module EnforcedName
     def initialize(opts={})
+      super(opts)
+      @name ||= UUID.generate
     end
   end
 end

data/lib/fathom/ext/string.rb

@@ -0,0 +1,27 @@
+# From ActiveSupport
+class String
+  if Module.method(:const_get).arity == 1
+    def constantize
+      names = self.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+  else
+    def constantize #:nodoc:
+      names = self.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+  end
+  
+end

data/lib/fathom/inverter.rb

@@ -1,7 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
 module Fathom
-  class Invertor
-    include BasicNode
+  class Invertor < Node
     
     def initialize(opts={})
       super(opts)

data/lib/fathom/monte_carlo_set.rb

@@ -54,19 +54,42 @@ class Fathom::MonteCarloSet
       raise "No fields are defined.  Have you processed this model yet?" if fields.empty?
       raise ArgumentError, "#{field} is not a field in this set." unless fields.include?(field)
       vector = self.send(field)
+      return vector unless vector.is_a?(GSL::Vector)
       {
         :coefficient_of_variation => (vector.sd / vector.mean),
         :max => vector.max,
         :mean => vector.mean,
         :min => vector.min,
-        :sd => vector.sd
+        :sd => vector.sd,
+        :upper_bound => upper_bound(:mean => vector.mean, :sd => vector.sd),
+        :lower_bound => lower_bound(:mean => vector.mean, :sd => vector.sd)
       }
     end
+    
+    def inverse_cdf(opts={})
+      mean = opts[:mean]
+      sd = opts[:sd]
+      lower = opts.fetch(:lower, true)
+      confidence_interval = opts.fetch(:confidence_interval, 0.05)
+      value = lower ? GSL::Cdf.gaussian_Pinv(confidence_interval, sd) : GSL::Cdf.gaussian_Qinv(confidence_interval, sd)
+      value + mean
+    end
+    alias :lower_bound :inverse_cdf
+
+    def upper_bound(opts={})
+      inverse_cdf(opts.merge(:lower => false))
+    end
+
+    def interval_values(opts={})
+      confidence_interval = opts.fetch(:confidence_interval, 0.9)
+      bound = (1 - confidence_interval) / 2.0
+      [lower_bound(opts.merge(:confidence_interval, bound)), upper_bound(opts.merge(:confidence_interval, bound))]
+    end
   
     def assert_sample_vectors
       vectors = @samples.inject({}) do |h, o|
-        key, array = o.first, o.last
-        h[key] = GSL::Vector.ary_to_gv(array)
+        key, obj = o.first, o.last
+        h[key] = (obj.is_a?(Array) and obj.first.is_a?(Numeric)) ? GSL::Vector.ary_to_gv(obj) : obj
         h
       end
       @samples = vectors

data/lib/fathom/node.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+class Fathom::Node
+  
+  attr_reader :name, :distribution, :description, :values
+  
+  def initialize(opts={})
+    @name = opts[:name]
+    assert_distribution(opts)
+    @description = opts[:description]
+    @values = opts[:values]
+    assert_links(opts)
+  end
+  
+  def name_sym
+    return nil unless self.name
+    @name_sym ||= self.name.to_s.downcase.gsub(/\s+|-+/, '_').to_sym
+  end
+
+  def parents
+    @parents ||= []
+  end
+  
+  def add_parent(parent)
+    self.parents << parent
+    parent.register_child(self)
+  end
+  
+  def register_child(child)
+    raise "Cannot register a child if this node is not a parent already.  Use add_parent to the other node or add_child to this node." unless
+      child.parents.include?(self)
+    children << child unless children.include?(child)
+    true
+  end
+  
+  def children
+    @children ||= []
+  end
+  
+  def add_child(child)
+    self.children << child
+    child.register_parent(self)
+  end
+  
+  def register_parent(parent)
+    raise "Cannot register a parent if this node is not a child already.  Use add_child to the other node or add_parent to this node." unless
+      parent.children.include?(self)
+    parents << parent unless parents.include?(parent)
+    true
+  end
+  
+  protected
+  
+    def assert_links(opts)
+      found = opts[:parents]
+      found ||= opts[:parent]
+      found ||= []
+      found = [found] unless found.is_a?(Array)
+      found.each do |parent|
+        add_parent(parent)
+      end
+
+
+      found = opts[:children]
+      found ||= opts[:child]
+      found ||= []
+      found = [found] unless found.is_a?(Array)
+      found.each do |child|
+        add_child(child)
+      end
+    end
+    
+    def assert_distribution(opts)
+      case opts[:distribution]
+      when Class
+        @distribution = opts[:distribution]
+      when Symbol
+        class_name = opts[:distribution].to_s.downcase.split(/_+/).map {|t| t[0].chr.upcase + t[1..-1]}.join
+        if Fathom::Distributions.constants.include?(class_name)
+          @distribution = "Fathom::Distributions::#{class_name}".constantize
+        end
+      end
+      @distribution ||= Fathom::Distributions::Gaussian
+    end
+end
+
+if __FILE__ == $0
+  include Fathom
+  # TODO: Is there anything you want to do to run this file on its own?
+  # Node.new
+end

data/lib/fathom/numeric_methods.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+module Fathom  
+  module NumericMethods
+    def initialize(opts={})
+      super(opts)
+    end
+    
+    def rand
+      return nil unless vector
+      distribution.rand(sd) + mean
+    end
+    
+    def vector
+      return @vector if @vector
+      return nil unless values
+      case values
+      when Array
+        @vector = GSL::Vector.ary_to_gv(values)
+      when GSL::Vector
+        @vector = values
+      end
+    end
+    
+    def standard_deviation
+      return nil unless vector
+      vector.sd
+    end
+    alias :std :standard_deviation
+    alias :sd :standard_deviation
+
+    def mean
+      return nil unless vector
+      vector.mean
+    end
+    
+    def inverse_cdf(opts={})
+      distribution.inverse_cdf(opts.merge(:mean => mean, :sd => sd))
+    end
+    alias :lower_bound :inverse_cdf
+
+    def upper_bound(opts={})
+      distribution.upper_bound(opts.merge(:mean => mean, :sd => sd))
+    end
+
+    def interval_values(opts={})
+      distribution.interval_values(opts.merge(:mean => mean, :sd => sd))
+    end
+    
+  end
+end

data/lib/fathom/plausible_range.rb

@@ -1,12 +1,13 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
 module Fathom
-  class PlausibleRange
+  class PlausibleRange < Node
     
-    include NodeUtilities
+    include NumericMethods
     
-    attr_reader :upper_bound, :lower_bound, :confidence_interval, :name, :description, :hard_lower_bound, :hard_upper_bound
+    attr_reader :upper_bound, :lower_bound, :confidence_interval, :hard_lower_bound, :hard_upper_bound
     
     def initialize(opts={})
+      super(opts)
       
       opts = OptionsHash.new(opts)
       
@@ -28,9 +29,6 @@ module Fathom
       @confidence_interval ||= opts[:ci]
       @confidence_interval ||= 0.9
       
-      @name = opts[:name]
-      @description = opts[:description]
-      
     end
     
     alias :min :lower_bound
@@ -40,21 +38,22 @@ module Fathom
     def midpoint
       @midpoint ||= lower_bound + (range / 2.0)
     end
+    alias :mean :midpoint
     
     def range
       @range ||= upper_bound - lower_bound
     end
     
     def standard_deviation
-      @standard_deviation ||= range / 3.29
+      @standard_deviation ||= range / distribution.standard_deviations_under(confidence_interval)
     end
     alias :std :standard_deviation
+    alias :sd :standard_deviation
     
-    # Not using specific distributions yet
     def rand
       value = get_rand
       until is_bounded?(value) do
-        value= get_rand
+        value = get_rand
       end
       value
     end
@@ -82,17 +81,14 @@ module Fathom
         end
       end
     
+      # Uses the distribution system, but doesn't use a vector to determine the sd, mean, etc.
+      # So keeping this part in-house.
       def get_rand
-        rng.gaussian(std) + midpoint
+        distribution.rand(sd) + mean
       end
       
-      def rng
-        @rng ||= GSL::Rng.alloc(GSL::Rng::MT19937_1999, Kernel.rand(100_000))
-      end
   end
   
-  class R < PlausibleRange
-  end
 end
 
 if __FILE__ == $0

data/spec/fathom/data_node_spec.rb

@@ -25,11 +25,9 @@ describe DataNode do
     @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)
+    @dn = DataNode.new(@opts.merge(:distribution => :gaussian))
+    @dn.distribution.should eql(Fathom::Distributions::Gaussian)
   end
 
   it "should create a vector from the values" do
@@ -58,4 +56,47 @@ describe DataNode do
     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/distributions/discrete_gaussian_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+include Fathom::Distributions
+
+describe DiscreteGaussian 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_close(-0.16448, 0.00001)
+  # 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 standard 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_close(-0.16448, 0.00001)
+  # 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_close(-0.16448, 0.00001)
+  # 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_close(0.16448, 0.00001)
+  # end
+  # 
+  # it "should be able to take a different confidence interval" do
+  #   Gaussian.inverse_cdf(@opts.merge(:confidence_interval => 0.1)).should be_close(-0.12815, 0.00001)
+  # 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/distributions/gaussian_spec.rb

@@ -0,0 +1,64 @@
+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_close(-0.16448, 0.00001)
+  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_close(-0.16448, 0.00001)
+  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_close(-0.16448, 0.00001)
+  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_close(0.16448, 0.00001)
+  end
+  
+  it "should be able to take a different confidence interval" do
+    Gaussian.inverse_cdf(@opts.merge(:confidence_interval => 0.1)).should be_close(-0.12815, 0.00001)
+  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
+