fathom 0.3.7 → 0.5.0

data/autotest/discover.rb

@@ -1 +0,0 @@
-Autotest.add_discovery { "rspec2" }

data/lib/ext/faster_csv.rb

@@ -1 +0,0 @@
-FasterCSV::HeaderConverters[:strip] = lambda{|h| h.strip}

data/lib/ext/open_struct.rb

@@ -1,17 +0,0 @@
-require 'ostruct'
-
-# Fix a few bugs in OpenStruct
-class OpenStruct
-  def table
-    @table
-  end
-  
-  def values
-    @table.values
-  end
-  
-  def keys
-    @table.keys
-  end
-end
-

data/lib/fathom/agent.rb

@@ -1,48 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
-class Fathom::Agent
-
-  # =================
-  # = Class Methods =
-  # =================
-  
-  include Properties
-  
-  def initialize(opts={})
-    self.class.define_property_states
-    assert_node_accessors(opts)
-  end
-  
-  def states
-    @states ||= self.class.properties.inject({}) do |h, state_method_name|
-      h[state_method_name] = nil
-      h
-    end
-  end
-  
-  def callbacks
-    @callbacks ||= (self.methods - Object.methods).grep(/^on_(\w+)/)
-  end
-  
-  protected
-    def assert_node_accessors(nodes)
-      nodes.each do |name, node|
-        next unless self.class.properties.include?(name)
-        states[name] = node.respond_to?(:rand) ? node.rand : node
-
-        method_name = ("node_for_" + name.to_s.downcase.gsub(/\s+/, '_')).to_sym
-        (class << self; self; end).module_eval do
-          define_method method_name do
-            node
-          end
-        end
-        
-      end
-    end
-  
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # Agent.new
-end

data/lib/fathom/agent/agent_cluster.rb

@@ -1,23 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-
-=begin
-  This class is designed to hold a cluster of agents in memory.  It runs the  simulation locally and
-  speaks to other clusters via EventMachine.  In this way, we don't need a Ruby runtime/thread/fiber
-  for each agent, just one per dozen/hundred/thousand agents, depending on what balances the 
-  simulation.
-=end
-class Fathom::AgentCluster
-  
-  attr_reader :agents
-  
-  def initialize(*agents)
-    @agents = agents
-  end
-  
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # AgentCluster.new
-end

data/lib/fathom/agent/properties.rb

@@ -1,48 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-module Fathom
-  module Properties
-    
-    def self.included(base)
-      base.send(:extend, ClassMethods)
-    end
-    
-    module ClassMethods
-      
-      def properties
-        @properties ||= []
-      end
-      
-      def property(name, opts={})
-        self.properties << name_sym(name)
-      end
-      
-      def define_property_states
-        return true if @property_states_defined
-        self.properties.each do |state_method_name|
-          unless self.instance_methods.include?(state_method_name.to_s)
-            define_method(state_method_name) do
-              states[state_method_name]
-            end
-          end
-          
-          state_method_writer = "#{state_method_name}=".to_sym
-          unless self.instance_methods.include?(state_method_writer.to_s)
-            define_method(state_method_writer) do |value|
-              states[state_method_name] = value
-            end
-          end
-        end
-        
-        @property_states_defined = true
-      end
-
-      protected
-        def name_sym(name)
-          name.to_s.downcase.gsub(/\s+/, '_').to_sym
-        end
-        
-    end
-  end
-end
-
-

data/lib/fathom/archive/causal_graph.rb

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

data/lib/fathom/archive/concept.rb

@@ -1,83 +0,0 @@
-=begin
-  This is a first approach to an RDF back end for a broadly-defined data store.  
-  
-  I am borrowing from the SKOS ontology here to be able to define any sort of concept
-  that may assist me with my decision-making work.
-  
-  TODO:
-  
-  [x] Build a basic Spira modeal
-  [x] Make a SKOS commitment
-  [.] Create helper methods to find or create the concept easily (using hash syntax for field names)
-  [] Create association methods for associating the concept to other concepts (need to think about this one)
-  [] Create specific methods to define a plausible range (probably define a Spira model here too)
-  [] Create specific methods to define a ValueDescription
-  [] Create specific methods to define a MonteCarloSet
-  [] Create specific methods to define a CausalGraph
-  [] Create specific methods to define a DependencyGraph
-  [] Create specific methods to define the value of further measurement (another un-named class)
-  
-=end
-
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
-require 'rdf'
-require 'rdf/ntriples'
-require 'data_objects'
-require 'do_sqlite3'
-require 'rdf/do'
-require 'spira'
-
-
-module Fathom
-
-  # Go ahead and create a generic repo for Fathom
-  def repo
-    @repo ||= RDF::DataObjects::Repository.new('sqlite3:/tmp/test.db')
-  end
-
-  Spira.add_repository(:default, repo)
-
-  class Concept
-
-    include Spira::Resource
-    include RDF
-    
-    class << self
-      def find_or_build(name, description=nil)
-        concept = Concept.for(concept_name(name))
-        return concept if concept.exist?
-        concept.name = name
-        concept.description = description
-        concept
-      end
-      
-      def find_or_create(name, description=nil)
-        concept = Concept.for(concept_name(name))
-        return concept if concept.exist?
-        concept.name = name
-        concept.description = description
-        concept.save!
-        concept
-      end
-      
-      protected
-        def concept_name(name)
-          concept_name = name.downcase.gsub(/\s+/, '_')
-        end
-    end
-    
-    base_uri "http://example.org/example/concepts"
-    
-    property :name, :predicate => SKOS.prefLabel
-    property :description, :predicate => SKOS.definition
-    property :scope, :predicate => SKOS.scopeNote
-    
-    
-  end
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # Concept.new
-end

data/lib/fathom/archive/conditional_probability_matrix.rb

@@ -1,119 +0,0 @@
-require 'rubygems'
-require 'gsl'
-
-include GSL
-
-class NodeAccessor
-  
-  attr_reader :cpm
-  
-  def initialize(cpm)
-    @cpm = cpm
-  end
-  
-  def is(*labels)
-    ChildAccessor.new(cpm, *labels)
-  end
-  
-  def is_not(*labels)
-    ChildAccessor.new(cpm, *(cpm.child.labels - labels))
-  end
-end
-
-class ChildAccessor
-  
-  attr_reader :cpm, :labels
-  def initialize(cpm, *labels)
-    @cpm, @labels = cpm, labels
-  end
-  
-  def given(parent_name)
-    ParentAccessor.new(cpm, labels)
-  end
-  
-end
-
-class ParentAccessor
-  
-  attr_reader :cpm, :node, :child_labels, :child_indices
-  def initialize(cpm, child_labels)
-    @cpm = cpm
-    @child_labels = child_labels
-    @node = cpm.parent
-    @child_indices = child_labels.map {|label| @cpm.child.labels.index(label)}
-  end
-  
-  def is(*labels)
-    indices = labels.map {|label| get_index(label) }
-    sum_probabilities(indices)
-  end
-  
-  def is_not(*labels)
-    not_indices = labels.map {|label| get_index(label) }
-    indices = (0..node.labels.size).to_a - not_indices
-    sum_probabilities(indices)
-  end
-  
-  protected
-  
-    # TODO: Not right...
-    def sum_probabilities(indices)
-      first_child = child_indices.first
-      cpm.matrix[indices.first, first_child]
-      # indices.inject(0.0) do |s, i|
-      #   s += cpm.matrix[i, first_child]
-      # end
-    end
-    
-    def get_index(label)
-      node.labels.index(label)
-    end
-    
-end
-
-
-class ConditionalProbabilityMatrix
-  
-  class << self
-    def define_node_accessor(node, cpm)
-      define_method(node.name.to_sym) do
-        NodeAccessor.new(cpm)
-      end
-    end
-  end
-  
-  attr_reader :parent, :child, :matrix
-  
-  def initialize(parent, child)
-    @parent, @child = parent, child
-    @matrix = @parent.probabilities.col * @child.probabilities
-    assert_name_access
-  end
-  
-  def probability(opts={})
-    child_label = opts[:child]
-    parent_label = opts[:parent]
-    raise ArgumentError, "Must provide a child and parent label.  E.g., probability(:child => true, :parent => false)" unless child_label and parent_label
-    child_label_index = get_index(child, child_label)
-    parent_label_index = get_index(parent, parent_label)
-    self.matrix[parent_label_index, child_label_index]
-  end
-  alias :p :probability
-  
-  def inspect
-    "ConditionalProbabilityMatrix: #{matrix.to_a.inspect}"
-  end
-  
-  protected
-  
-    def assert_name_access
-      ConditionalProbabilityMatrix.define_node_accessor(child, self)
-    end
-    
-    def get_index(node, label)
-      node.labels.index(label)
-    end
-end
-
-class CPM < ConditionalProbabilityMatrix
-end

data/lib/fathom/archive/inverter.rb

@@ -1,20 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
-module Fathom
-  class Invertor < Fathom::Node
-    
-    def initialize(opts={})
-      super(opts)
-      @name ||= "Inverter"
-    end
-    
-    def value
-      -1
-    end
-  end
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # Invertor.new
-end

data/lib/fathom/archive/n2.rb

@@ -1,198 +0,0 @@
-
-
-=begin
-Some noodling about what a node might contain in order to describe the joint probabilities.
-=end
-class Node
-  
-  attr_reader :variable, :parents
-  def initialize(variable, *parents)
-    @variable = Variable.infer(variable)
-    raise ArgumentError, "A valid variable cannot be implied from #{variable}" unless @variable
-    @parents = parents
-  end
-  
-  def name
-    self.variable.name
-  end
-  
-  def inspect
-    "Node: #{self.name} #{ self.parents.map{|p| p.name}.inspect }"
-  end
-  
-  class << self
-    def infer(obj, *parents)
-      return obj if obj.is_a?(Node)
-      
-    end
-  end
-end
-
-class Variable
-  
-  attr_reader :values, :name, :observations, :total
-  
-  def initialize(name, *values)
-    values = [true, false] if values.empty?
-    @name = name
-    @values = values
-    @observations = Array.new(@values.size, 0)
-    @total = 0
-  end
-  
-  # You can observe anything but nothing: we record any observation but nil.  
-  # If nil is set, we use the first value as the default.
-  def observe(value=nil)
-    value = self.values.first if value.nil?
-    unless self.values.include?(value)
-      self.values << value 
-      self.observations << 0
-    end
-    index = self.values.index(value)
-    self.observations[index] += 1
-    @total += 1
-  end
-  
-  # Lookup observations
-  def observed(value)
-    index = self.values.index(value)
-    return 0 unless index
-    self.observations[index]
-  end
-  
-  def inspect
-    "Variable: #{self.name} #{self.values.inspect}"
-  end
-  
-  class << self
-    def infer(obj, *values)
-      return obj if obj.is_a?(Variable)
-      case obj
-      when Symbol
-        Variable.new(obj, *values)
-      when String
-        Variable.new(obj.to_sym, *values)
-      else
-        nil
-      end
-    end
-    
-  end
-end
-
-require 'rubygems'
-require 'spec'
-
-describe Variable do
-  
-  before do
-    @v = Variable.new(:v1)
-  end
-  
-  it "should require a name" do
-    lambda{Variable.new}.should raise_error(ArgumentError)
-    lambda{@v = Variable.new(:name)}.should_not raise_error
-    @v.name.should eql(:name)
-  end
-  
-  it "should default to true and false as parameter values" do
-    v = Variable.new(:v)
-    v.values.should eql([true, false])
-  end
-  
-  it "should be able to take a variables parameters" do
-    v = Variable.new :v, :red, :blue, :green
-    v.values.should eql([:red, :blue, :green])
-  end
-  
-  it "should be able to infer a variable from a variable" do
-    v = Variable.new(:v)
-    Variable.infer(v).should eql(v)
-  end
-  
-  it "should be able to infer a variable from a symbol" do
-    v = Variable.infer(:v)
-    v.should be_a(Variable)
-    v.name.should eql(:v)
-  end
-  
-  it "should be able to infer a variable from a string" do
-    v = Variable.infer('v')
-    v.should be_a(Variable)
-    v.name.should eql(:v)
-  end
-  
-  it "should be able to infer values from a list" do
-    v = Variable.infer :v, 1, 2
-    v.values.should eql([1,2])
-  end
-  
-  it "should start with zero observations" do
-    @v.total.should eql(0)
-  end
-  
-  it "should increment observations" do
-    @v.observe
-    @v.total.should eql(1)
-    @v.observe
-    @v.total.should eql(2)
-  end
-  
-  it "should record observations" do
-    @v.observe(true)
-    @v.total.should eql(1)
-    @v.observed(true).should eql(1)
-    @v.observed(false).should eql(0)
-    @v.observe(false)
-    @v.total.should eql(2)
-    @v.observed(true).should eql(1)
-    @v.observed(false).should eql(1)
-  end
-  
-end
-
-describe Node do
-  
-  before do
-    @season = Variable.new(:season, :spring, :summer, :fall, :winter)
-    @x1 = Node.new(@season)
-    @x2 = Node.new(:rain, @x1)
-    @x3 = Node.new(:sprinkler, @x1)
-    @x4 = Node.new(:wet, @x3, @x2)
-    @x5 = Node.new(:slippery, @x4)
-  end
-  
-  it "should infer a variable for the node" do
-    v = Variable.new(:v)
-    n = Node.new(v)
-    n.variable.should eql(v)
-    
-    n = Node.new(:v)
-    v = n.variable
-    v.should be_a(Variable)
-    v.name.should eql(:v)
-  end
-  
-  it "should raise an error when it cannot infer a variable for the node" do
-    lambda{Node.new(1)}.should raise_error(ArgumentError, /A valid variable cannot be implied from/)
-  end
-  
-  it "should be able to create a node with parents" do
-    @x1.parents.should be_empty
-    @x2.parents.should eql([@x1])
-    @x3.parents.should eql([@x1])
-    @x4.parents.should eql([@x3, @x2])
-    @x5.parents.should eql([@x4])
-  end
-  
-  # it "should be able to infer a node" do
-  #   n = Node.infer(:v1, :v2)
-  #   n.name.should eql(:v1)
-  #   n.variable.name.should eql(:v1)
-  #   n.variable.should be_a(Variable)
-  #   n.parents.size.should eql(1)
-  #   p = n.parents.first
-  #   p.name.should eql(:v2)
-  #   p.should be_a(Variable)
-  # end
-end