fathom 0.3.7 → 0.5.0

data/lib/fathom/value_description.rb

@@ -1,79 +0,0 @@
-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/options_hash.rb

@@ -1,186 +0,0 @@
-# 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

data/spec/ext/array_spec.rb

@@ -1,10 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Array do
-  it "should define rand, a way to get a random variable from an array" do
-    a = [1,2]
-    a.should be_include(a.rand)
-    # 9.31322574615479e-10 chance of failing
-    30.times.map {a.rand}.uniq.sort.should eql([1,2])
-  end
-end

data/spec/ext/faster_csv_spec.rb

@@ -1,10 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'fastercsv'
-require 'ext/faster_csv'
-
-describe FasterCSV do
-  it "should have a header converter to strip values" do
-    FasterCSV::HeaderConverters.keys.should be_include(:strip)
-    FasterCSV::HeaderConverters[:strip].call(' this ').should eql('this')
-  end
-end

data/spec/ext/open_struct_spec.rb

@@ -1,20 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe OpenStruct do
-  
-  before do
-    @o = OpenStruct.new(:this => 1)
-  end
-  
-  it "should expose its table" do
-    @o.table.should eql({:this => 1})
-  end
-  
-  it "should expose the keys from the table" do
-    @o.keys.should eql([:this])
-  end
-  
-  it "should expose the values from the table" do
-    @o.values.should eql([1])
-  end
-end

data/spec/ext/string_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe String do
-  it "should be able to constantize a string" do
-    "Fathom".constantize.should eql(Fathom)
-  end
-end

data/spec/fathom/agent/agent_cluster_spec.rb

@@ -1,17 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Fathom
-
-describe AgentCluster do
-  
-  before do
-    @agent = double()
-    @agents = [@agent]
-  end
-  
-  it "should initialize with a set of agents" do
-    @ac = AgentCluster.new @agent
-    @ac.agents.should eql(@agents)
-  end
-  
-end

data/spec/fathom/agent_spec.rb

@@ -1,51 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-include Fathom
-
-describe Agent do
-  
-  before do
-    @pr1 = PlausibleRange.new(:min => 1, :max => 2)
-    @pr2 = PlausibleRange.new(:min => 10, :max => 11)
-    @da = DemoAgent.new(:field1 => @pr1, :field2 => @pr2)
-  end
-  
-  it "should be have a list of properties" do
-    DemoAgent.properties.should eql([:field1, :field2])
-  end
-  
-  it "should be able to set a seed node for each property defined in the class" do
-    @da.node_for_field1.should eql(@pr1)
-    @da.node_for_field2.should eql(@pr2)
-  end
-  
-  it "should not set a seed node for a node that doesn't have a property" do
-    da = DemoAgent.new(:field1 => @pr1, :field2 => @pr2, :field3 => :should_not_be_found)
-    da.should_not be_respond_to(:node_for_field3)
-  end
-  
-  it "should have a state accessor for each property" do
-    @da.should be_respond_to(:field1)
-    @da.should be_respond_to(:field1=)
-    @da.should be_respond_to(:field2)
-    @da.should be_respond_to(:field2=)
-  end
-  
-  it "should set the initial state of each property from the seed node, if defined" do
-    @pr1.should_receive(:rand).and_return(1.5)
-    @pr2.should_not_receive(:rand)
-    @da = DemoAgent.new(:field1 => @pr1)
-    @da.field1.should eql(1.5)
-    @da.field2.should be_nil
-  end
-  
-  it "should be able to send a hard parameter and save it in a property" do
-    @da = DemoAgent.new(:field1 => 2)
-    @da.field1.should eql(2)
-  end
-  
-  it "should expose the callbacks, those methods starting with on_" do
-    @da.callbacks.should eql(["on_tick"])
-  end
-  
-end

data/spec/fathom/distributions/discrete_gaussian_spec.rb

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