fathom 0.3.7 → 0.5.0

data/lib/fathom/node/data_node.rb

@@ -1,22 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-
-=begin
-  A DataNode is a node generated from data itself.  It stores the data and reveals some statistical 
-  measurements for the data.  It expects an array or vector of values and generates a vector on demans.
-=end
-class Fathom::DataNode < Fathom::Node
-
-  include Fathom::NumericMethods
-  
-  def initialize(opts={})
-    super(opts)
-    raise ArgumentError, "Must provided values: DataNode.new(:values => [...])" unless self.values
-  end
-  
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # DataNode.new
-end

data/lib/fathom/node/decision.rb

@@ -1,11 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-class Fathom::Decision < Fathom::Node
-  undef_method :values
-  undef_method :distribution
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # Decision.new
-end

data/lib/fathom/node/discrete_node.rb

@@ -1,41 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-class Fathom::DiscreteNode < Fathom::Node
-  attr_reader :labels
-
-  def initialize(opts={})
-    opts[:distribution] ||= :discrete_uniform
-    super(opts)
-    assert_labels(opts)
-  end
-
-  def size
-    @size ||= self.labels.length
-  end
-  alias :length :size
-
-  def rand
-    self.labels[self.distribution.rand(self.size)]
-  end
-  
-  # This makes it easier to interface to a belief node
-  def likelihood(ignored_value)
-    GSL::Vector.ary_to_gv(Array.new(self.size, 1))
-  end
-  alias :l :likelihood
-
-  protected
-    def assert_labels(opts)
-      @labels = opts[:labels]
-      @labels ||= self.values
-      @labels ||= [:true, :false]
-      @labels = Array[@labels] unless @labels.is_a?(Array)
-      @labels.uniq!
-    end
-  
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # DiscreteNode.new
-end

data/lib/fathom/node/fact.rb

@@ -1,24 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-class Fathom::Fact < Fathom::Node
-  
-  attr_reader :value
-  
-  def initialize(opts={})
-    symbolize_keys!(opts)
-    @value = opts[:value]
-    @value ||= opts[:values]
-    super(opts)
-  end
-  
-  alias :rand :value
-  
-  undef_method :values
-  undef_method :distribution
-  
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # Fact.new
-end

data/lib/fathom/node/mc_node.rb

@@ -1,70 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-class Fathom::MCNode < Fathom::Node
-  
-  attr_reader :samples_taken
-  attr_accessor :value_description
-  
-  def initialize(opts={}, &block) 
-    super(opts)
-    @value_description = opts[:value_description]
-    @value_description ||= block if block_given?
-    raise ArgumentError, "Must provide a value_description from either a parameter or by passing in a block" unless
-      @value_description
-  end
-  
-  def process(n=10_000)
-    @samples_taken, @samples = n, {}
-    @samples_taken.times do
-      result = value_description.call(self)
-      store(result)
-    end
-    assert_nodes
-  end
-  
-  def reset!
-    @samples_taken, @samples = nil, {}
-    @samples_asserted = false
-  end
-  
-  def fields
-    self.children.map {|c| c.name_sym}.compact
-  end
-  
-  protected
-    
-    def store(result)
-      result = assert_result_hash(result)
-      assert_samples(result)
-      result.each do |key, value|
-        @samples[key.to_sym] << value
-      end
-    end
-    
-    def assert_samples(result)
-      return true if @samples_asserted
-      result.each do |k, v|
-        @samples[k.to_sym] ||= []
-      end
-      @samples_asserted = true
-    end
-    
-    def assert_result_hash(result)
-      result.is_a?(Hash) ? result : {:result => result}
-    end
-    
-    # Assumes the same value description for all samples taken
-    def assert_nodes
-      @samples.each do |key, values|
-        node = Fathom::DataNode.new(:name => key, :values => values)
-        add_child(node)
-#        self.class.define_summary_method(key)
-      end
-    end
-    
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # MCNode.new
-end

data/lib/fathom/node/node_extensions/enforced_name.rb

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

data/lib/fathom/node/node_extensions/numeric_methods.rb

@@ -1,68 +0,0 @@
-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
-    
-    def coefficient_of_variation
-      return nil unless vector
-      vector.sd / vector.mean
-    end
-    alias :cov :coefficient_of_variation
-    
-    def summary
-      {
-        :mean => mean,
-        :standard_deviation => standard_deviation,
-        :min => vector ? vector.min : nil,
-        :max => vector ? vector.max : nil,
-        :lower_bound => lower_bound,
-        :upper_bound => upper_bound,
-        :coefficient_of_variation => coefficient_of_variation
-      }
-    end
-    
-  end
-end

data/lib/fathom/node/plausible_range.rb

@@ -1,98 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-module Fathom
-  class PlausibleRange < Fathom::Node
-    
-    include NumericMethods
-    
-    attr_reader :upper_bound, :lower_bound, :confidence_interval, :hard_lower_bound, :hard_upper_bound
-    
-    def initialize(opts={})
-      super(opts)
-      
-      opts = OptionsHash.new(opts)
-      
-      @hard_upper_bound = opts[:hard_upper_bound]
-      @upper_bound = opts[:upper_bound]
-      @upper_bound ||= opts[:max]
-      @upper_bound ||= @hard_upper_bound
-      @upper_bound = @hard_upper_bound if @upper_bound and @hard_upper_bound and @hard_upper_bound < @upper_bound
-      raise ArgumentError, "Must provide an upper bound." unless @upper_bound
-      
-      @hard_lower_bound = opts[:hard_lower_bound]
-      @lower_bound = opts[:lower_bound]
-      @lower_bound ||= opts[:min]
-      @lower_bound ||= @hard_lower_bound
-      @lower_bound = @hard_lower_bound if @lower_bound and @hard_lower_bound and @hard_lower_bound > @lower_bound
-      raise ArgumentError, "Must provide a lower bound." unless @lower_bound
-      
-      @confidence_interval = opts[:confidence_interval]
-      @confidence_interval ||= opts[:ci]
-      @confidence_interval ||= 0.9
-      
-    end
-    
-    alias :min :lower_bound
-    alias :max :upper_bound
-    alias :ci :confidence_interval
-    
-    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 / distribution.standard_deviations_under(confidence_interval)
-    end
-    alias :std :standard_deviation
-    alias :sd :standard_deviation
-    
-    def rand
-      value = get_rand
-      until is_bounded?(value) do
-        value = get_rand
-      end
-      value
-    end
-    
-    def array_of_random_values(n=10)
-      n.times.map {self.rand}
-    end
-    alias :to_a :array_of_random_values
-    
-    def vector_of_random_values(n=10)
-      GSL::Vector.alloc(array_of_random_values(n))
-    end
-    alias :to_v :vector_of_random_values
-    
-    protected
-    
-      def is_bounded?(value)
-        return true unless hard_lower_bound or hard_upper_bound
-        if hard_lower_bound and hard_upper_bound
-          value >= hard_lower_bound and value <= hard_upper_bound
-        elsif hard_lower_bound
-          value >= hard_lower_bound
-        elsif hard_upper_bound
-          value <= hard_upper_bound
-        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
-        distribution.rand(sd) + mean
-      end
-      
-  end
-  
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # PlausibleRange.new
-end

data/lib/fathom/simulation.rb

@@ -1,59 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
-class Fathom::Simulation
-  
-  class << self
-    
-    # Expects a symbol for the callback to define on the simulation.
-    def define_callback_accessor(callback, obj)
-      call_method = callback.to_s.scan(/^on_(\w+)/).flatten.compact.first
-      raise ArgumentError, "Callback doesn't appear to be a callback: #{callback}" unless call_method
-      return true if self.respond_to?(call_method)
-      define_method(call_method) do
-        callbacks[callback].each do |agent|
-          agent.send(callback, obj)
-        end
-      end
-      
-      agent_lookup_method = "agents_using_#{call_method}".to_sym
-      return true if self.respond_to?(agent_lookup_method)
-      define_method(agent_lookup_method) do
-        callbacks[callback]
-      end
-      
-    end
-  end
-  
-  attr_reader :agents
-  
-  def initialize(*agents)
-    @agents = agents
-    assert_callbacks
-  end
-  
-  def callbacks
-    @callbacks ||= {}
-  end
-  
-  protected
-    def assert_callbacks
-      self.agents.each do |agent|
-        assert_agent(agent)
-      end
-    end
-    
-    def assert_agent(agent)
-      return false unless agent.respond_to?(:callbacks)
-      agent.callbacks.each do |callback|
-        callback_sym = callback.to_sym
-        self.callbacks[callback_sym] ||= []
-        self.callbacks[callback_sym] << agent
-        self.class.define_callback_accessor(callback_sym, self)
-      end
-    end
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # Simulation.new
-end

data/lib/fathom/simulation/tick_methods.rb

@@ -1,25 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-module Fathom
-  module TickMethods
-    def initialize(*agents)
-      super(*agents)
-    end
-    
-    attr_reader :ticks_designed, :ticks_executed
-    
-    def process(n)
-      @ticks_designed = n
-      @ticks_executed = 0
-      n.times do
-        self.tick(self)
-        @ticks_executed += 1
-      end
-    end
-  end
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # TicksSimulation.new
-end

data/lib/fathom/simulation/tick_simulation.rb

@@ -1,12 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-module Fathom
-  class TickSimulation < Simulation
-    include TickMethods
-  end
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # TickSimulator.new
-end