fathom 0.3.7 → 0.5.0

data/lib/fathom/distributions/discrete_uniform.rb

@@ -1,25 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-class Fathom::Distributions::DiscreteUniform
-  extend Fathom::Distributions::SharedMethods
-  class << self
-    def rng
-      @rng ||= GSL::Rng.alloc(GSL::Rng::MT19937_1999, Kernel.rand(100_000))
-    end
-    
-    # Bounded from 0 to size - 1
-    def rand(size)
-      value = get_rand(size)
-      while value < 0 or value >= size
-        value = get_rand(size)
-      end
-      value
-    end
-    
-    protected
-      def get_rand(size)
-        (rng.ugaussian / size).floor + 1
-      end
-    
-  end
-end
-

data/lib/fathom/distributions/gaussian.rb

@@ -1,46 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-class Fathom::Distributions::Gaussian
-  extend Fathom::Distributions::SharedMethods
-  class << self
-    def rng
-      @rng ||= GSL::Rng.alloc(GSL::Rng::MT19937_1999, Kernel.rand(100_000))
-    end
-    
-    def rand(sd)
-      rng.gaussian(sd)
-    end
-    
-    def inverse_cdf(opts={})
-      mean = opts[:mean]
-      sd = opts[:sd]
-      sd ||= opts[:std]
-      sd ||= opts[:standard_deviation]
-      lower = opts.fetch(:lower, true)
-      lower = false if opts[:upper]
-      confidence_interval = opts.fetch(:confidence_interval, 0.05)
-      value = lower ? GSL::Cdf.gaussian_Pinv(confidence_interval, sd) : GSL::Cdf.gaussian_Qinv(confidence_interval, sd)
-      value + mean
-    end
-    alias :lower_bound :inverse_cdf
-
-    def upper_bound(opts={})
-      inverse_cdf(opts.merge(:lower => false))
-    end
-
-    def interval_values(opts={})
-      confidence_interval = opts.fetch(:confidence_interval, 0.9)
-      bound = (1 - confidence_interval) / 2.0
-      [lower_bound(opts.merge(:confidence_interval => bound)), upper_bound(opts.merge(:confidence_interval => bound))]
-    end
-    
-    # If only I had the background to explain what this is....
-    # I want to know how many standard deviations are expressed by the confidence interval
-    # I can then divide  the range by this number to get the standard deviation
-    def standard_deviations_under(confidence_interval)
-      GSL::Cdf.gaussian_Qinv((1 - confidence_interval) / 2) * 2
-    end
-    
-    
-  end
-end
-

data/lib/fathom/distributions/uniform.rb

@@ -1,35 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-class Fathom::Distributions::Uniform
-  extend Fathom::Distributions::SharedMethods
-  class << self
-    def rng
-      @rng ||= GSL::Rng.alloc(GSL::Rng::MT19937_1999, Kernel.rand(100_000))
-    end
-    
-    def rand
-      rng.ugaussian
-    end
-    
-    def inverse_cdf(opts={})
-      mean = opts[:mean]
-      lower = opts.fetch(:lower, true)
-      lower = false if opts[:upper]
-      confidence_interval = opts.fetch(:confidence_interval, 0.05)
-      value = lower ? GSL::Cdf.ugaussian_Pinv(confidence_interval) : GSL::Cdf.ugaussian_Qinv(confidence_interval)
-      value + mean
-    end
-    alias :lower_bound :inverse_cdf
-
-    def upper_bound(opts={})
-      inverse_cdf(opts.merge(:lower => false))
-    end
-
-    def interval_values(opts={})
-      confidence_interval = opts.fetch(:confidence_interval, 0.9)
-      bound = (1 - confidence_interval) / 2.0
-      [lower_bound(opts.merge(:confidence_interval => bound)), upper_bound(opts.merge(:confidence_interval => bound))]
-    end
-    
-  end
-end
-

data/lib/fathom/import.rb

@@ -1,85 +0,0 @@
-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  
-
-module Fathom
-  class Import
-  
-    class << self
-      def import(opts={})
-        importer = new(opts)
-        importer.import
-      end
-    end
-  
-    attr_reader :content, :options, :import_node
-  
-    def initialize(opts={})
-      @options = OptionsHash.new(opts)
-      @content = @options[:content]
-      @import_node = ImportNode.new(opts)
-    end
-  
-    def import
-      import_methods.each do |method|
-        klass, initialization_data = self.send(method.to_sym)
-        initialization_data.each do |values|
-          extract_nodes(klass, values)
-        end
-      end
-      self.import_node
-    end
-  
-    protected
-  
-      # Just blankly try to initiate a node.  If it fails, silently fail for now.
-      def extract_nodes(klass, values)
-        begin
-          node = klass.new(values)
-          if node
-            self.import_node.add_child(node) 
-            Fathom.knowledge_base[node.name] = node
-          end
-        rescue
-          nil
-        end
-      end
-    
-      def import_methods
-        (self.methods - self.class.superclass.instance_methods).map {|m| m if m =~ /import_\w+/}.compact
-      end
-
-  end
-end

data/lib/fathom/import/csv_import.rb

@@ -1,59 +0,0 @@
-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'
-require 'ext/faster_csv'
- 
-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, :header_converters => [:strip, :symbol]}
-      @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
-  Fathom::CSVImport.import(:content => ARGV.first)
-end

data/lib/fathom/import/import_node.rb

@@ -1,17 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-class Fathom::ImportNode < Fathom::Node
-  
-  attr_reader :imported_at
-  
-  def initialize(opts={})
-    super(opts)
-    @imported_at = Time.now
-  end
-  
-end
-
-if __FILE__ == $0
-  include Fathom
-  # TODO: Is there anything you want to do to run this file on its own?
-  # ImportNode.new
-end

data/lib/fathom/import/yaml_import.rb

@@ -1,74 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-require 'open-uri'
-require 'yaml'
-
-class Fathom::YAMLImport < Fathom::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
-  
-  def import_facts
-    assert_yaml_content
-    facts = extract_facts
-    [Fact, facts]
-  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_facts
-      return [] unless @yaml_content
-      output = []
-      @yaml_content.each do |e|
-        next unless e.is_a?(Array)
-        next unless e.first.to_s.match(/fact/i)
-        obj = e[1]
-        next unless obj.is_a?(Hash)
-        output << obj
-      end
-      output
-    end
-    
-    def extract_plausible_ranges
-      return [] unless @yaml_content
-      @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]
-          list << value.merge(:name => name)
-        end
-        list 
-      end
-    end
-    
-    def extract_data_nodes
-      return [] unless @yaml_content
-      @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
-  Fathom::YAMLImport.import(:content => ARGV.first)
-end

data/lib/fathom/knowledge_base.rb

@@ -1,46 +0,0 @@
-require File.expand_path("../../fathom", __FILE__)
-
-require 'rdf'
-require 'knowledge_base/search'
-
-module Fathom
-  class KnowledgeBase
-  
-    # =====================
-    # = Module Extensions =
-    # =====================
-    include Search
-  
-    # attr_reader :data_store
-  
-    def initialize(opts={})
-      # opts = OptionsHash.new(opts)
-      # @data_store = OpenStruct.new
-    end
-  
-    # def []=(key, value)
-    #   @data_store.table[key] = value
-    # end
-    # 
-    # def [](key)
-    #   @data_store.table[key]
-    # end
-    # 
-    # # This is temporary, but useful for now.  After we have the persisted KnowledgeBase, 
-    # # we'll create explicit accessor methods or a find syntax.
-    # def method_missing(sym, *args, &block)
-    #   if @data_store.table.keys.include?(sym)
-    #     @data_store.send(sym)
-    #   else
-    #     super
-    #   end
-    # end
-    
-  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

data/lib/fathom/knowledge_base/search.rb

@@ -1,19 +0,0 @@
-require 'sparql/algebra'
-
-module Fathom
-  module Search
-    
-    def self.included(base)
-      base.send(:extend, ClassMethods)
-      base.send(:include, InstanceMethods)
-    end
-    
-    module ClassMethods
-      def find(opts={})
-      end
-    end
-    
-    module InstanceMethods
-    end
-  end
-end

data/lib/fathom/monte_carlo_set.rb

@@ -1,152 +0,0 @@
-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
-    
-    def define_summary_method(field)
-      define_method("#{field}_summary".to_sym) do
-        self.summary(field.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
-  
-  def fields
-    @samples.keys
-  end
-  
-  def summary(field=nil)
-    return summarize_field(field) if field
-    fields.inject({}) do |h, field|
-      h[field] = summarize_field(field)
-      h
-    end
-  end
-  
-  def print_summary
-    print_hash(self.summary)
-  end
-  
-  protected
-  
-    def print_hash(hash, indent=0)
-      hash.each do |key, value|
-        if value.is_a?(Hash)
-          puts "#{' ' * indent}#{key} => {"
-          print_hash(value, indent + 2)
-          puts "#{' ' * indent}}"
-        else
-          puts "#{' ' * indent}#{key} => #{value}"
-        end
-      end
-    end
-  
-    def summarize_field(field)
-      raise "No fields are defined.  Have you processed this model yet?" if fields.empty?
-      raise ArgumentError, "#{field} is not a field in this set." unless fields.include?(field)
-      vector = self.send(field)
-      return vector unless vector.is_a?(GSL::Vector)
-      lb = lower_bound(:mean => vector.mean, :sd => vector.sd)
-      lb = vector.min if vector.min > lb
-      ub = upper_bound(:mean => vector.mean, :sd => vector.sd)
-      ub = vector.max if vector.max < ub
-      
-      {
-        :coefficient_of_variation => (vector.sd / vector.mean),
-        :max => vector.max,
-        :mean => vector.mean,
-        :min => vector.min,
-        :sd => vector.sd,
-        :upper_bound => ub,
-        :lower_bound => lb
-      }
-    end
-    
-    def inverse_cdf(opts={})
-      mean = opts[:mean]
-      sd = opts[:sd]
-      lower = opts.fetch(:lower, true)
-      confidence_interval = opts.fetch(:confidence_interval, 0.05)
-      value = lower ? GSL::Cdf.gaussian_Pinv(confidence_interval, sd) : GSL::Cdf.gaussian_Qinv(confidence_interval, sd)
-      value + mean
-    end
-    alias :lower_bound :inverse_cdf
-
-    def upper_bound(opts={})
-      inverse_cdf(opts.merge(:lower => false))
-    end
-
-    def interval_values(opts={})
-      confidence_interval = opts.fetch(:confidence_interval, 0.9)
-      bound = (1 - confidence_interval) / 2.0
-      [lower_bound(opts.merge(:confidence_interval, bound)), upper_bound(opts.merge(:confidence_interval, bound))]
-    end
-  
-    def assert_sample_vectors
-      vectors = @samples.inject({}) do |h, o|
-        key, obj = o.first, o.last
-        h[key] = (obj.is_a?(Array) and obj.first.is_a?(Numeric)) ? GSL::Vector.ary_to_gv(obj) : obj
-        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)
-        self.class.define_summary_method(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