fathom 0.3.7 → 0.5.0

data/lib/fathom/node.rb

@@ -1,139 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
-# TODO: Move this into a proper configuration module
-# require 'spira'
-# @repository = RDF::Repository.new
-# Spira.add_repository(:default, @repository)
-
-class Fathom::Node
-
-  # See notes in the spec about this.
-  # include Spira::Resource
-
-  attr_reader :name, :distribution, :description, :values
-  
-  def initialize(opts={})
-    symbolize_keys!(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
-    self.add_accessor_for_node(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)
-    unless children.include?(child)
-      self.add_accessor_for_node(child)
-      children << child 
-    end
-    true
-  end
-  
-  def children
-    @children ||= []
-  end
-  
-  def add_child(child)
-    self.children << child
-    self.add_accessor_for_node(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)
-    unless parents.include?(parent)
-      self.add_accessor_for_node(parent)
-      parents << parent 
-    end
-    true
-  end
-  
-  def simple_inspect
-    self.name ? "#{self.name} (#{self.class.to_s})" : self.class.to_s
-  end
-  
-  def inspect
-    "#{self.class.to_s}: " +  [
-      self.name,
-      self.description,
-      "children:",
-      self.children.map {|e| e.simple_inspect }.inspect,
-      "parents: ",
-      self.parents.map {|e| e.simple_inspect }.inspect,
-    ].compact.join(", ")
-  end
-  
-  protected
-  
-    # Quick and dirty extract from ActiveSupport's same method
-    def symbolize_keys!(h)
-      h.keys.each do |key|
-        h[(key.to_sym rescue key) || key] = h.delete(key)
-      end
-      h
-    end
-    
-    def add_accessor_for_node(node)
-      return false unless node.respond_to?(:name_sym) and node.name_sym
-      return false if self.respond_to?(node.name_sym)
-      (class << self; self; end).module_eval do
-        define_method node.name_sym do
-          node
-        end
-      end
-    end
-  
-    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/node/belief_node.rb

@@ -1,121 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-class Fathom::BeliefNode < DiscreteNode
-  
-  attr_reader :probabilities, :likelihoods, :precision_threshold
-  
-  def initialize(opts={})
-    super(opts)
-    assert_probabilities(opts)
-    assert_liklihoods(opts)
-    @precision_threshold = opts.fetch(:precision_threshold, 0.00001)
-  end
-
-  def add_child(child)
-    if child.is_a?(BeliefNode)
-      cpm = CPMNode.new(:parent => self, :child => child)
-      # self.children << cpm
-      self.add_accessor_for_cpm(cpm, child)
-      self.add_accessor_for_node(child)
-      # cpm.register_parent(self)
-      self.children << child
-      child.register_parent(self)
-      child.add_accessor_for_cpm(cpm, self)
-    else
-      super(child)
-    end
-  end
-  
-  def add_parent(parent)
-    if parent.is_a?(BeliefNode)
-      cpm = CPMNode.new(:parent => parent, :child => self)
-      # self.parents << cpm
-      self.add_accessor_for_cpm(cpm, parent)
-      self.add_accessor_for_node(parent)
-      # cpm.register_child(self)
-      self.parents << parent
-      parent.register_child(self)
-      parent.add_accessor_for_cpm(cpm, self)
-    else
-      super(parent)
-    end
-  end
-  
-  def inspect
-    "#{self.class.to_s}: " +  [
-      self.name,
-      self.description,
-      "children:",
-      self.children.map {|e| e.is_a?(CPMNode) ? e.child.simple_inspect : e.simple_inspect }.inspect,
-      "parents: ",
-      self.parents.map {|e| e.is_a?(CPMNode) ? e.parent.simple_inspect : e.simple_inspect }.inspect,
-    ].compact.join(", ")
-  end
-  
-  def add_accessor_for_cpm(cpm, node)
-    return false unless cpm.is_a?(CPMNode) and cpm.name_sym
-    method_name = ("cpm_for_" + node.name_sym.to_s).to_sym
-    return false if self.respond_to?(method_name)
-    (class << self; self; end).module_eval do
-      define_method method_name do
-        cpm
-      end
-    end
-  end
-  
-  def likelihood(label)
-    OpenStruct.new
-  end
-
-  protected
-    
-
-    def assert_probabilities(opts)
-      return assert_probabilities_and_labels_from_values_hash(opts[:values]) if 
-        opts[:values] and opts[:values].is_a?(Hash)
-        
-      unnormalized_obj = opts.fetch(:probabilities, Array.new(self.size, 1.0))
-      unnormalized_vector = case unnormalized_obj
-      when Array
-        GSL::Vector.ary_to_gv(unnormalized_obj)
-      when GSL::Vector
-        unnormalized_obj
-      else
-        GSL::Vector[unnormalized_obj]
-      end
-
-      raise ArgumentError, "Probabilities must be #{self.size} items long" unless
-        unnormalized_vector.size == self.size
-
-      sum = unnormalized_vector.sum
-      @probabilities = unnormalized_vector.map {|e| e / sum }
-    end
-    
-    def assert_probabilities_and_labels_from_values_hash(values)
-      @labels, probabilities = values.inject([[], []]) do |list, e|
-        list.first << e.first
-        list.last << e.last
-        list
-      end
-      @probabilities = GSL::Vector.ary_to_gv(probabilities)
-    end
-    
-    def assert_liklihoods(opts)
-      likelihoods = opts.fetch(:likelihoods, Array.new(self.size, 1.0))
-      @likelihoods = case likelihoods
-      when Array
-        GSL::Vector.ary_to_gv(likelihoods)
-      when GSL::Vector
-        likelihoods
-      else
-        GSL::Vector[likelihoods]
-      end
-      raise ArgumentError, "Likelihoods must be #{self.size} items long" unless
-        likelihoods.size == self.size
-    end
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # BeliefNode.new
-end

data/lib/fathom/node/cpm_node.rb

@@ -1,100 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-
-# Conditional Probability Matrix to join two nodes
-class Fathom::CPMNode < Fathom::Node
-  
-  def initialize(opts={})
-    ensure_belief_nodes(opts)
-    super(opts)
-    assert_name
-    assert_description
-    assert_cpm
-  end
-  
-  def parent
-    parents.first
-  end
-  
-  def child
-    children.first
-  end
-  
-  alias :matrix :values
-  
-  # Filter values from the matrix.  Allows us to grab multiple rows and columns if desired.
-  # If the rows or columns aren't filtered, all values are assumed to be desired.
-  #
-  # @cpm.probability :child_node_name => [:desired, :values], :parent_node_name => :value
-  # This filters both the child columns and the parent rows
-  # 
-  # @cpm.probability :child_node_name => [:desired, :values]
-  # This only filters the child columns
-  def probability(opts={})
-    # Are we using long descriptions for the return value?
-    # If so, we'll use a hash to describe it without having to parse the value out of a string later.
-    describe = opts.delete(:describe) || false
-    
-    # Is something unknown being asked for?
-    allowed = [parent.name_sym, child.name_sym]
-    unknown_keys = opts.reject {|k, v| allowed.include?(k)}
-    raise ArgumentError, "Unknown node: #{unknown_keys.inspect}" unless unknown_keys.empty?
-
-    # Values for the desired child and parent values
-    child_values = Array(opts[self.child.name_sym] || self.child.labels)
-    parent_values = Array(opts[self.parent.name_sym] || self.parent.labels)
-    
-    # Indices in the matrix for the desired values
-    child_indices = child_values.map {|c| self.child.labels.index(c)}
-    parent_indices = parent_values.map {|c| self.parent.labels.index(c)}
-
-    # Collect the filtered values from the matrix
-    value = parent_indices.inject(0.0) do |sum, row|
-      sum += child_indices.inject(0.0) do |s, col|
-        s += matrix.get(row, col)
-      end
-    end
-    
-    return value unless describe
-
-    label = "P(" + 
-      child_values.map(&:to_s).join(" or ") + 
-      " | " + 
-      parent_values.map(&:to_s).join(" or ") + 
-      ")"
-    { label => value }
-
-  end
-  alias :p :probability
-  
-  def odds(opts={})
-    p = probability(opts)
-    return p / (1 - p)
-  end
-  alias :o :odds
-  
-  # Returns a vector of likelihoods for each parent value, given the child value
-  def likelihood(value)
-    GSL::Vector.alloc(
-      *parent.labels.map {|parent_label| probability(parent.name_sym => parent_label, child.name_sym => value)}
-    )
-  end
-  alias :l :likelihood
-  
-  protected
-    def assert_name
-      @name ||= :cpm
-    end
-    
-    def assert_description
-      @description ||= "Conditional Probability Matrix from #{parent.name.to_s} to #{child.name.to_s}."
-    end
-  
-    def ensure_belief_nodes(opts)
-      raise ArgumentError, "The child must be a BeliefNode" unless opts[:child].is_a?(BeliefNode)
-      raise ArgumentError, "The parent must be a BeliefNode" unless opts[:parent].is_a?(BeliefNode)
-    end
-    
-    def assert_cpm
-      @values = self.parent.probabilities.col * self.child.probabilities
-    end
-end

data/lib/fathom/node/data_collection.rb

@@ -1,97 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-
-=begin
-  This class uses SQLite for in-memory set operations.  It is based on a discrete variable
-  which can be translated into fields in a table.  For now, I am just using float data
-  types for the fields.  This will evolve as needs drive it into a more robust data set.
-  
-  It turns out that SQLite set operations are quite fast and speed things up pretty well.
-  So, to use this class, you'll need to have sqlite3-ruby SQLite3 bindings installed.
-  
-  This also uses uuid to enforce a node name, an additional dependency.
-=end
-
-require 'uuid'
-
-class Fathom::DataCollection < DiscreteNode
-
-  def initialize(opts={})
-    opts = extract_labels(opts)
-    opts[:name] ||= UUID.generate
-    super(opts)
-  end
-
-  
-  protected
-  
-    # Looking for labels.
-    # Using :labels, then :parents, then :parent, looking for the first node with labels defined
-    def extract_labels(opts)
-      return opts if opts[:labels]
-      parents = opts[:parents]
-      parents ||= opts[:parent]
-      parents = Array[parents] if parents and not parents.is_a?(Array)
-      parents.each do |parent|
-        if parent.respond_to?(:labels)
-          opts[:labels] = parent.labels
-          return opts
-        end
-      end
-      opts
-    end
-  
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # DataCollection.new
-end
-
-
-# J2: Some bare-minimum sqlite3 stuff
-# See: http://sqlite-ruby.rubyforge.org/
-# require 'rubygems'
-# require 'sqlite3'
-# 
-# def prepare_database(table_name)
-#   @db = SQLite3::Database.new(":memory:")
-#   # @db = SQLite3::Database.new("/tmp/j2.db")
-# 
-#   create_sql = <<-SQL
-#   
-#   CREATE TABLE "#{table_name}" (
-#     "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, 
-#     "field1" FLOAT);
-#   SQL
-#     @db.execute_batch(create_sql)
-# 
-#   insert_sql = <<-SQL
-#     INSERT INTO #{table_name} 
-#       ("field1")
-#     VALUES
-#       (:field1);
-#   SQL
-#   @insert_record = @db.prepare(insert_sql)
-# 
-#   # select_sql = <<-SQL
-#   #   "select * from 'asdf';"
-#   # SQL
-#   # @select_record = @db.prepare(select_sql)
-#   @select_record = @db.prepare( "select * from asdf" )
-# end
-# 
-# def insert_record(opts)
-#   @insert_record.bind_params(:field1 => opts[:field1])
-#   @insert_record.execute
-# end
-# 
-# def select_record(opts={})
-#   # @db.execute( "select * from 'asdf'" )
-#   @select_record.execute.entries
-# end
-# 
-# prepare_database('asdf')
-# insert_record :field1 => 123.1
-# insert_record :field1 => 122.2
-# @a = select_record