fathom 0.1.0

data/lib/fathom/monte_carlo_set.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+class Fathom::MonteCarloSet
+
+  class << self
+    def define_key(key)
+      define_method(key.to_sym) do
+        self.samples[key.to_sym]
+      end
+    end
+  end
+  
+  attr_reader :value_description, :samples_taken, :samples
+  
+  def initialize(value_description)
+    @value_description = value_description
+    @samples = {}
+  end
+  
+  def process(n=10_000)
+    @samples_taken = n
+    @samples_taken.times do
+      result = value_description.process
+      store(result)
+    end
+    assert_sample_vectors
+  end
+  
+  def reset!
+    @samples = {}
+    @keys_asserted = nil
+  end
+  
+  protected
+  
+    def assert_sample_vectors
+      vectors = @samples.inject({}) do |h, o|
+        key, array = o.first, o.last
+        h[key] = GSL::Vector.ary_to_gv(array)
+        h
+      end
+      @samples = vectors
+    end
+    
+    def store(result)
+      result = assert_result_hash(result)
+      assert_keys(result)
+      result.each do |key, value|
+        @samples[key.to_sym] << value
+      end
+    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_keys(result)
+      return true if @keys_asserted
+      result.keys.each do |key|
+        assert_key(key)
+      end
+      @keys_asserted = true
+    end
+    
+    def assert_key(key)
+      self.class.define_key(key)
+      @samples[key.to_sym] ||= []
+    end
+    
+end
+
+if __FILE__ == $0
+  include Fathom
+  # TODO: Is there anything you want to do to run this file on its own?
+  # MonteCarloSet.new
+end

data/lib/fathom/node_utilities.rb

@@ -0,0 +1,8 @@
+module Fathom
+  module NodeUtilities
+    def name_sym
+      return nil unless self.name
+      @name_sym ||= self.name.to_s.downcase.gsub(/\s+/, '_').to_sym
+    end
+  end
+end

data/lib/fathom/plausible_range.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+module Fathom
+  class PlausibleRange
+    
+    include NodeUtilities
+    
+    attr_reader :upper_bound, :lower_bound, :confidence_interval, :name, :description, :hard_lower_bound, :hard_upper_bound
+    
+    def initialize(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
+      
+      @name = opts[:name]
+      @description = opts[:description]
+      
+    end
+    
+    alias :min :lower_bound
+    alias :max :upper_bound
+    alias :ci :confidence_interval
+    
+    def midpoint
+      @midpoint ||= lower_bound + (range / 2.0)
+    end
+    
+    def range
+      @range ||= upper_bound - lower_bound
+    end
+    
+    def standard_deviation
+      @standard_deviation ||= range / 3.29
+    end
+    alias :std :standard_deviation
+    
+    # Not using specific distributions yet
+    def rand
+      rng.gaussian(std) + midpoint
+    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 rng
+        @rng ||= GSL::Rng.alloc
+      end
+  end
+  
+  class R < PlausibleRange
+  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/value_aggregator.rb

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

data/lib/fathom/value_description.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+module Fathom
+  class ValueDescription
+    
+    class << self
+      # Returns a simple accessor for the node, so that the value description works a little like an OpenStruct.
+      def define_node_accessor(node, method = :node)
+        define_method(node.name_sym) do
+          node.send(method)
+        end
+      end
+      
+    end
+    
+    attr_reader :nodes, :last_process
+    
+    def initialize(*nodes, &block)
+      assert_nodes(nodes)
+      @process_block = block if block_given?
+    end
+    
+    def add_node(node, method = :rand)
+      assert_node(node, method)
+    end
+    
+    def process
+      prepare_process
+      @process_block ? @process_block.call(@last_process) : default_process(@last_process)
+    end
+    
+    protected
+    
+    
+      def prepare_process
+        @last_process = self.nodes.inject(OpenStruct.new) do |o, node|
+          o.table[node.name_sym] = self.send(node.name_sym)
+          o
+        end
+      end
+      
+      def default_process(obj)
+        obj.values.inject(0.0) do |s, e|
+          s += e
+        end
+      end
+      
+      def assert_nodes(nodes)
+        @nodes ||= []
+        nodes.each do |node|
+          case node
+          when Hash
+            assert_node_from_hash(node)
+          else
+            assert_node(node)
+          end
+        end
+      end
+      
+      def assert_node(node, method = :rand)
+        raise ArgumentError, "Must provide a node that can respond to name" unless node.respond_to?(:name)
+        @nodes ||= []
+        self.class.define_node_accessor(node, method)
+        @nodes << node
+      end
+      
+      # Takes a node => :value_hash signature for the values in the hash
+      def assert_node_from_hash(hash)
+        hash.each do |node, value_method|
+          assert_node(node, value_method)
+        end
+      end
+  end
+end
+
+if __FILE__ == $0
+  include Fathom
+  # TODO: Is there anything you want to do to run this file on its own?
+  # ValueDescription.new
+end

data/lib/fathom/value_multiplier.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+module Fathom
+  class ValueMultiplier < ValueDescription
+    
+    def default_process
+      obj.values.inject(0.0) do |s, e|
+        s *= e
+      end
+    end
+    protected :default_process
+  end
+end
+
+if __FILE__ == $0
+  include Fathom
+  # TODO: Is there anything you want to do to run this file on its own?
+  # ValueMultiplier.new
+end

data/lib/options_hash.rb

@@ -0,0 +1,186 @@
+# Taken brazenly from ActiveSupport
+class OptionsHash < Hash
+  # Return a new hash with all keys converted to strings.
+  def stringify_keys
+    dup.stringify_keys!
+  end
+
+  # Destructively convert all keys to strings.
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+.
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+
+  alias_method :to_options,  :symbolize_keys
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+  # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+  # as keys, this will fail.
+  #
+  # ==== Examples
+  #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    unknown_keys = keys - [valid_keys].flatten
+    raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+  end
+  
+  def extractable_options?
+    true
+  end
+
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  def self.new_from_hash_copying_default(hash)
+    OptionsHash.new(hash).tap do |new_hash|
+      new_hash.default = hash.default
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # Assigns a new value to the hash:
+  #
+  #   hash = OptionsHash.new
+  #   hash[:key] = "value"
+  #
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # Updates the instantized hash with values from the second:
+  #
+  #   hash_1 = OptionsHash.new
+  #   hash_1[:key] = "value"
+  #
+  #   hash_2 = OptionsHash.new
+  #   hash_2[:key] = "New Value!"
+  #
+  #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+  #
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # Checks the hash for a key matching the argument passed in:
+  #
+  #   hash = OptionsHash.new
+  #   hash["key"] = "value"
+  #   hash.key? :key  # => true
+  #   hash.key? "key" # => true
+  #
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # Fetches the value for the specified key, same as doing hash[key]
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = OptionsHash.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  #
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # Returns an exact copy of the hash.
+  def dup
+    OptionsHash.new(self)
+  end
+
+  # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+  # Does not overwrite the existing hash.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+  # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a OptionsHash.
+  def reverse_merge(other_hash)
+    super self.class.new_from_hash_copying_default(other_hash)
+  end
+
+  def reverse_merge!(other_hash)
+    replace(reverse_merge( other_hash ))
+  end
+
+  # Removes a specified key from the hash.
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  def stringify_keys!; self end
+  def stringify_keys; dup end
+  undef :symbolize_keys!
+  def symbolize_keys; to_hash.symbolize_keys end
+  def to_options!; self end
+
+  # Convert to a Hash with String keys.
+  def to_hash
+    Hash.new(default).merge!(self)
+  end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      case value
+      when Hash
+        self.class.new_from_hash_copying_default(value)
+      when Array
+        value.collect { |e| e.is_a?(Hash) ? self.class.new_from_hash_copying_default(e) : e }
+      else
+        value
+      end
+    end
+end