fathom 0.1.0

data/lib/fathom/archive/n2.rb

@@ -0,0 +1,198 @@
+
+
+=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

data/lib/fathom/archive/n3.rb

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,74 @@
+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
+    "Node: #{self.labels.inspect} #{self.probabilities.inspect}"
+  end
+  
+  def belief
+    probabilities * likelihood
+  end
+  
+  alias :b :belief
+  alias :l :likelihood
+  alias :p :probabilities
+  
+  protected
+
+    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

@@ -0,0 +1,136 @@
+=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