fathom 0.1.0

data/lib/fathom/archive/scratch.rb

@@ -0,0 +1,45 @@
+require 'node'
+require 'conditional_probability_matrix'
+
+class A
+  class << self
+    # def will_pay
+    #   @will_pay ||= Node.new :true, :false
+    # end
+    # 
+    # def has_money
+    #   @has_money ||= Node.new :plenty => 0.1, :some => 0.8, :little => 0.1
+    # end
+    # 
+    # def ones
+    #   Matrix.ones(will_pay.values.length, has_money.values.length)
+    # end
+    # 
+    # def parents
+    #   will_pay.values.col * has_money.values
+    #   # will_pay.each do |value|
+    #   # 
+    #   # end
+    # end
+    # 
+    # def cpm
+    #   ConditionalProbabilityMatrix.new(will_pay, has_money)
+    # end
+    
+    def killer_identity
+      @killer_identity ||= Node.new(:killer_identity, :jack => 0.8, :joe => 0.1, :jeff => 0.1)
+    end
+    alias :k :killer_identity 
+    alias :x :killer_identity
+    
+    def fingerprint_information
+      @fingerprint_information ||= Node.new(:fingerprint_information, :jack => 2/3.0, :joe => 1/6.0, :jeff => 1/6.0)
+    end
+    alias :f :fingerprint_information
+    alias :y :fingerprint_information
+    
+    def cpm
+      @cpm ||= ConditionalProbabilityMatrix.new(x, y)
+    end
+  end
+end

data/lib/fathom/basic_node.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+module Fathom
+  module BasicNode
+    def initialize(opts={})
+    end
+  end
+end
+

data/lib/fathom/causal_graph.rb

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

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

data/lib/fathom/concept.rb

@@ -0,0 +1,83 @@
+=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/data_node.rb

@@ -0,0 +1,51 @@
+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
+
+  include NodeUtilities
+  
+  attr_reader :values, :name, :distribution, :confidence_interval
+  
+  def initialize(opts={})
+    @values = opts[:values]
+    raise ArgumentError, "Must provided values: DataNode.new(:values => [...])" unless self.values
+    @name = opts[:name]
+    @distribution = opts[:distribution]
+  end
+  
+  alias :ci :confidence_interval
+  
+  def vector
+    @vector ||= GSL::Vector.ary_to_gv(self.values)
+  end
+  
+  def standard_deviation
+    @standard_deviation ||= vector.sd
+  end
+  alias :sd :standard_deviation
+  alias :std :standard_deviation
+  
+  def mean
+    @mean ||= vector.mean
+  end
+  
+  def rand
+    rng.gaussian(std) + mean
+  end
+  
+  protected
+    def rng
+      @rng ||= GSL::Rng.alloc
+    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/import.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+
+=begin
+
+  The import scripts are meant to make it easier to build up a knowledge base from
+  real data.  There are a lot of ways we could get our data: YAML files, spreadsheets,
+  web crawlers, relational databases, RDF data.  The Import class creates a regular
+  way to create nodes in the knowledge base.  The following example would be a 
+  simple way to import some data about weekend trips:
+
+  class WeekendPlanningImport < Import
+    def import_plausible_data
+      values = [
+        {:name => 'Chance of Rain', :min => 0.2, :max => 0.3, :confidence_interval => 0.8},
+        {:name => 'Would Go to the Beach Despite the Rain', :min => 0, :max => 0.2},
+        {:name => 'Would Go to the Movies if Something Good Was Playing', :min => 0.8, :max => 1.0},
+        {:name => 'Would Go to the Movies Despite the Rain', :min => 0.9, :max => 1.0}
+      ]
+      return [PlausibleRange, values]
+    end
+    
+    def import_destination_data
+      value_hash = FasterCSV...
+      return [DataNode, value_hash]
+    end
+  end
+  
+  Each import method is starts with 'import_' and returns an array of [NodeClass, values_hash].  
+  The Import class will then create a series of nodes and insert them into the active knowledge
+  base.
+  
+  There are a number of useful Import classes that make most data imports fairly straight forward.
+  This way data from spreadsheets or YAML files can easily be added to the knowledge base.
+  
+=end  
+class Fathom::Import
+  
+  attr_reader :content, :options
+  
+  def initialize(opts={})
+    @options = OptionsHash.new(opts)
+    @content = @options[:content]
+  end
+  
+  def import
+    results = []
+    import_methods.each do |method|
+      klass, initialization_data = self.send(method.to_sym)
+      initialization_data.each do |values|
+        results << extract_nodes(klass, values)
+      end
+    end
+    results
+  end
+  
+  protected
+  
+    def extract_nodes(klass, values)
+      node = klass.new(values)
+      Fathom.knowledge_base[node.name] = node
+      node
+    end
+    
+    def import_methods
+      (self.methods - self.class.superclass.instance_methods).map {|m| m if m =~ /import_\w+/}.compact
+    end
+  
+end

data/lib/fathom/import/csv_import.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
+require 'import'
+require 'open-uri'
+
+# TODO: Work this out with Ruby 1.9.  We don't need to load this for all Rubies.
+require 'fastercsv'
+ 
+module Fathom
+  class CSVImport < Import
+    
+    # @content could be a filename, URI, or actual file contents.  We figure out which 
+    # it is and then parse the contents with FasterCSV.  We assume that there are column 
+    # headers that are the names of each node, and that the values in the node are
+    # values for a DataNode.  
+    def import_csv
+      parsed = parse_contents
+      extracted = extract_columns(parsed)
+      [DataNode, extracted]
+    end
+    
+    # These are the options we use to parse the file.  They can be overriden 
+    # by calling CSVImport.new(:parse_options => {...}, ...)
+    def parse_options
+      return @parse_options if @parse_options
+      @parse_options = @options[:parse_options]
+      @parse_options ||= {:converters => [:all], :headers => true, :skip_blanks => true}
+      @parse_options
+    end
+    
+    protected
+      def parse_contents
+          arr_of_arrs = FasterCSV.parse(get_contents, parse_options)
+      end
+      
+      # Tries to read a file or URL.  That failing, assumes the contents are CSV contents.
+      def get_contents
+        begin
+          content = open(@content).read
+        rescue
+          content = @content
+        end
+        return content
+      end
+      
+      # Returns an array of hashes with :name => row header, :values => values
+      def extract_columns(parsed)
+        transposed = parsed.to_a.transpose
+        transposed.inject([]) do |list, column|
+          list << {:name => column.shift, :values => column}
+        end
+      end
+        
+  end
+end
+
+if __FILE__ == $0
+  include Fathom
+  # TODO: Is there anything you want to do to run this file on its own?
+  # CSV.new
+end

data/lib/fathom/import/yaml_import.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
+require 'open-uri'
+
+class Fathom::YAMLImport < Import
+  def import_plausible_ranges
+    assert_yaml_content
+    plausible_ranges = extract_plausible_ranges
+    [PlausibleRange, plausible_ranges]
+  end
+  
+  def import_data_nodes
+    assert_yaml_content
+    data_nodes = extract_data_nodes
+    [DataNode, data_nodes]
+  end
+  
+  protected
+    def assert_yaml_content
+      return @yaml_content if @yaml_content
+      begin
+        file_contents = open(self.content).read
+        raise ArgumentError, "Unable to extract YAML data out of the contents." unless file_contents
+      rescue
+        file_contents = self.content
+      end
+        @yaml_content = YAML.load(file_contents)
+    end
+    
+    def extract_plausible_ranges
+      @yaml_content.inject([]) do |list, array|
+        name, value = array.first, array.last
+        if value.is_a?(Hash)
+          value = OptionsHash.new(value)
+          list << value.merge(:name => name) if value[:min] and value[:max]
+        end
+        list 
+      end
+    end
+    
+    def extract_data_nodes
+      @yaml_content.inject([]) do |list, array|
+        name, value = array.first, array.last
+        list << {:name => name, :values => value} if value.is_a?(Array)
+        list 
+      end
+    end
+end
+
+if __FILE__ == $0
+  include Fathom
+  # TODO: Is there anything you want to do to run this file on its own?
+  # YAMLImport.new
+end

data/lib/fathom/inverter.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+module Fathom
+  class Invertor
+    include BasicNode
+    
+    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/knowledge_base.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
+class Fathom::KnowledgeBase
+  
+  def initialize(opts={})
+    opts = OptionsHash.new(opts)
+    @data_store = {}
+  end
+  
+  def []=(key, value)
+    @data_store[key] = value
+  end
+  
+  def [](key)
+    @data_store[key]
+  end
+  
+end
+
+if __FILE__ == $0
+  include Fathom
+  # TODO: Is there anything you want to do to run this file on its own?
+  # KnowledgeBase.new
+end