fathom 0.3.7 → 0.5.0

data/lib/fathom/archive/n3.rb

@@ -1,119 +0,0 @@
-class Array
-  def expand(array)
-    return array.map{|e| [e]} if self.empty?
-    array.inject([]) do |list, other_e|
-      self.each do |e|
-        list << [e,other_e].flatten
-      end
-      list
-    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
-
-class Table
-  
-  attr_reader :columns, :variables, :legend
-  def initialize(*variables)
-    @columns = variables.map {|v| v.name}
-    @variables = variables
-    @legend = @variables.inject([]) do |list, e|
-      list = list.expand(e)
-    end
-  end
-  
-  protected
-    def lookup()
-    end
-end
-
-class Node
-  def initialize(name, *parents)
-  end
-  
-  # Take an array, array of arrays, dictionary, hash, or OpenStruct.
-  # Anything but an array can add a new parent to observe.
-  def observe(values)
-  end
-end
-
-require 'rubygems'
-require 'spec'
-
-=begin
-variables = [[:spring, :summer, :fall, :winter], [:true, :false], [:true, :false], [:true, :false]]
-
-@all = []
-(0...variables.size).each do |i|
-  @all << variables.inject([]) do |list, v|
-    list << (0...v.size).map do |j|
-      variables[i][j]
-    end
-  end
-end
-
-@all
-
-
-v1 = [:spring, :summer, :fall, :winter]
-v2 = [:true, :false]
-a = [v1, v2]
-b = []
-a.each do |e|
-  b << e
-end
-
-
-
-=end

data/lib/fathom/archive/node.rb

@@ -1,97 +0,0 @@
-require 'rubygems'
-require 'gsl'
-
-include GSL
-
-class Node
-  
-  attr_reader :name, :labels, :probabilities, :likelihood
-  
-  def initialize(*args)
-    @name = args.shift
-    raise ArgumentError, "Must provide a node name" unless self.name
-    if args.empty?
-      extract_from_array([:true, :false])
-    elsif args.length == 1 and args.first.is_a?(Hash)
-      extract_from_hash(args.first)
-    elsif args.length == 1 and args.first.is_a?(Array)
-      extract_from_array(args.first)
-    else
-      extract_from_array(args)
-    end
-    assert_likelihood
-  end
-  
-  def inspect
-    matched_array = []
-    self.labels.each_with_index {|e, i| matched_array << e; matched_array << self.probabilities[i]}
-    "Node: #{self.name.to_s} #{self.labels.inspect} #{self.probabilities.to_a.inspect}"
-    "Node: #{self.name.to_s} #{matched_array.inspect}"
-  end
-  
-  def belief
-    probabilities * likelihood
-  end
-  
-  alias :b :belief
-  alias :l :likelihood
-  alias :p :probabilities
-  
-  def probability(label)
-    probabilities[index_for(label)]
-  end
-  
-  def inverse_probability(label)
-    1 - probability(label)
-  end
-  
-  def odds(label)
-    probability(label) / inverse_probability(label)
-  end
-  
-  def to_a
-    self.probabilities.to_a
-  end
-  
-  protected
-  
-    def index_for(label)
-      labels.index(label)
-    end
-
-    def assert_likelihood
-      @likelihood = Vector.ary_to_gv(Array.new(@probabilities.size, 1))
-    end
-    
-    def extract_from_array(array)
-      @labels = array
-      @probabilities = Vector.ary_to_gv(uniform_distribution(array.size))
-    end
-    
-    def uniform_distribution(n)
-      Array.new(n, 1/n.to_f)
-    end
-
-    def extract_from_hash(hash)
-      @labels, probabilities = [], []
-      hash.each do |k, v|
-        @labels << k
-        probabilities << v
-      end
-      @probabilities = Vector.ary_to_gv(probabilities)
-      normalize_probabilities!
-    end
-    
-    # I don't like GSL::Vector#normalize!, it's not accurate, or has a different
-    # idea of what a normalized vector looks like.
-    def normalize_probabilities!
-      sum = 0.0
-      @probabilities.each do |value|
-        sum += value
-      end
-      @probabilities.map! do |value|
-        value.to_f / sum
-      end
-    end
-    
-end

data/lib/fathom/archive/noodle.rb

@@ -1,136 +0,0 @@
-=begin
-  I want to noodle around a bit with basic probabilities, odds, that sort of thing.  Here's the example:
-  
-  Upon being awakened by the sound of a burglar alary, what is your degree of belief that a burglary attempt took place?
-  
-  Supporting information:
-  
-  * There is a 95% chance that an attempted burglary will trigger the alarm system, P(alarm|burglary) = 95%
-  * There is a 1% chance that the alarms will be triggered by non-burglary attempts, p(alarm|no burglary) = 1%
-  * There is a 1/10_000 chance of a particular home being burglarized, generally, P(burglary) = 10^-4
-  
-  O(burglary|alarm) = L(alarm|burglary)O(burglary)
-  
-  P(burglary|alarm) = O(burglary|alarm) / 1 + O(burglary|alarm)
-  
-=end
-
-require 'mathn'
-
-def likelihood(effect, cause)
-  effect / cause
-end
-alias :l :likelihood
-
-def odds(effect, cause=nil)
-  cause ? ( likelihood(cause, effect) * odds(effect) ) : (effect / (1 - effect))
-end
-alias :o :odds
-
-# The same as the odds above, but only in the case of a single hypothesis
-def prior_odds(e)
-  e / ( 1 - e )
-end
-
-def likelihood_ratio(e, h)
-  p(e,h) / p(e, 1 - h)
-end
-
-def probability(e, h)
-  (e * h) / h
-end
-
-def product_rule(*e)
-end
-alias :p :probability
-
-class Array
-  
-  def givens
-    @givens ||= {}
-  end
-  
-  def give(sym, array=Array.new(self.size, 1/self.size))
-    self.givens[sym] = array
-  end
-  
-  def given(sym, index)
-    self.givens[sym][index]
-  end
-end
-
-=begin
-  Since Rational is the automatic choice for probabilistic data, 
-  and since I don't want to override how mathn infers numbers, 
-  I am adding some baggage to Rational:
-  
-  * It still reduces to the LCD
-  * It keeps track of all events, 
-    so that I can keep a new event proportional to old ones
-  * It has an add_event (add) which takes a true or false value
-    true values, records that a condition was found
-    
-  This really only works for binary data, but this is a noodle file.
-  
-=end
-class Rational < Numeric
-  class << self
-    alias :orig_reduce :reduce
-    def reduce(num, den=1)
-      val = orig_reduce(num, den)
-      val.total_events = den
-      val.positive_events = num
-      val
-    end
-  end
-  
-  def total_events(val=nil)
-    @total_events ||= 0
-    @total_events = val if val
-    @total_events
-  end
-  alias :events :total_events
-  alias :total :total_events
-  
-  def total_events=(val)
-    total_events(val)
-  end
-  
-  def positive_events(val=nil)
-    @positive_events ||= 0
-    @positive_events = val if val
-    @positive_events
-  end
-  alias :positive :positive_events
-  
-  def positive_events=(val)
-    positive_events(val)
-  end
-  
-  # Uses the Rational constructor to calculate the lowest common denominator
-  def add_event(positive=true)
-    num = positive ? self.positive_events + 1 : self.positive_events
-    den = self.total_events + 1
-    other = Rational(num, den)
-    @numerator, @denominator, @positive_events, @total_events = other.numerator, other.denominator, num, den
-    self
-  end
-  alias :add :add_event
-end
-
-
-class A
-  class << self
-    include GSL
-
-    def r
-      @r ||= Rng.alloc
-    end
-
-    def pdf
-      r = self.r.gaussian
-      pdf = Ran.gaussian_pdf(r)
-      puts r, pdf
-    end
-  end
-end

data/lib/fathom/archive/scratch.rb

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

@@ -1,8 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'fathom'))
-module Fathom
-  module Distributions
-    module SharedMethods
-      # TODO: Put helper methods here for sharing some of the distribution functionality
-    end
-  end
-end

data/lib/fathom/distributions/discrete_gaussian.rb

@@ -1,44 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fathom'))
-class Fathom::Distributions::DiscreteGaussian
-  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) / size).floor + 1
-    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
-