bn4r 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+*0.1*
+
+First release

data/README

@@ -0,0 +1,62 @@
+
+= Bayesian Networks for Ruby ( bn4r )
+
+bn4r is a bayesian networks library on ruby that provides
+the user with classes for create bayesian networks and 
+diverse algorithms for solve them.
+
+Its algorithms implementation are based on: S.Russell, P.Norving, "Artificial
+Intelligence, A Modern Approach", 2nd Edition.
+
+Website:
+http://bn4r.rubyforge.org
+
+Rubyforge Project:
+http://rubyforge.org/projects/bn4r
+
+= Dependencies
+
+* rgl-0.2.3 ( Ruby Graph Library ), http://rgl.rubyforge.org
+
+= Design principles
+
+The library consists on the object BayesNet thinked to be filled with
+BayesNetNode, these objects are defined in bn.rb. BayesNet object is a
+especialization of RGL::DirectedAdjacencyGraph ( http://rgl.rubyforge.org ).
+
+
+The file bn_algorithms.rb has the implementation of the inference algorithms
+that can be used to solve BayesNet structures.
+
+Finally, a set of objects and methods are given to automaticly fill BayesNetNode
+probabilities tables.
+
+
+= Documentation
+
+Documentation can be found at
+http://bn4r.rubyforge.org/rdoc
+or can be generated using rdoc tool under the source code with:
+  rdoc README lib
+  
+= Credits
+
+Thanks to N�ria Bel ( http://www.upf.edu/pdi/iula/nuria.bel ) for her work in this project
+without her it cannot be done.
+
+Thanks to Ryan Dahl for his work in http://www.math.rochester.edu/people/grads/rld/bayesnets
+that was the inspiration of the project.
+
+Also thanks to all the ruby community.
+
+== Copying
+
+This work is developed by Sergio Espeja ( http://www.upf.edu/pdi/iula/sergio.espeja, sergio.espeja at gmail.com )
+mainly in Institut Universitari de Ling�istica Aplicada of Universitat Pompeu Fabra ( http://www.iula.upf.es ),
+and also in bee.com.es ( http://bee.com.es ).
+
+It is free software, and may be redistributed under GPL license.
+
+== Support
+
+Please contact me in http://rubyforge.org/projects/bn4r.

data/Rakefile

@@ -0,0 +1,85 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'bn4r', 'version')
+
+AUTHOR = "Sergio Espeja"
+EMAIL = "sergio.espeja@gmail.com"
+DESCRIPTION = "bn4r is a bayesian networks library on ruby that provides the user with classes for create bayesian networks and diverse algorithms for solve them."
+RUBYFORGE_PROJECT = "bn4r"
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+BIN_FILES = %w(  )
+
+
+NAME = "bn4r"
+REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (Bn4r::VERSION::STRING + (REV ? ".#{REV}" : ""))
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "bn4r documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+desc "Packages up bn4r gem."
+task :default => [:test]
+task :package => [:clean]
+
+Rake::TestTask.new("test") { |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = true
+}
+
+spec =
+    Gem::Specification.new do |s|
+        s.name = NAME
+        s.version = VERS
+        s.platform = Gem::Platform::RUBY
+        s.has_rdoc = true
+        s.extra_rdoc_files = ["README", "CHANGELOG"]
+        s.rdoc_options += RDOC_OPTS + ['--exclude', '^(examples|extras)/']
+        s.summary = DESCRIPTION
+        s.description = DESCRIPTION
+        s.author = AUTHOR
+        s.email = EMAIL
+        s.homepage = HOMEPATH
+        s.executables = BIN_FILES
+        s.rubyforge_project = RUBYFORGE_PROJECT
+        s.bindir = "bin"
+        s.require_path = "lib"
+        s.autorequire = "bn4r"
+        
+        s.add_dependency('rgl', '>=0.2.3')
+        #s.required_ruby_version = '>= 1.8.2'
+
+        s.files = %w(README CHANGELOG Rakefile) +
+          Dir.glob("{bin,doc,test,lib,templates,generator,extras,website,script}/**/*") + 
+          Dir.glob("ext/**/*.{h,c,rb}") +
+          Dir.glob("examples/**/*.rb") +
+          Dir.glob("tools/*.rb")
+        
+        # s.extensions = FileList["ext/**/extconf.rb"].to_a
+    end
+
+Rake::GemPackageTask.new(spec) do |p|
+    p.need_tar = true
+    p.gem_spec = spec
+end
+
+task :install do
+  name = "#{NAME}-#{VERS}.gem"
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{name}}
+end
+
+task :uninstall => [:clean] do
+  sh %{sudo gem uninstall #{NAME}}
+end

data/lib/bn4r/bn.rb

@@ -0,0 +1,249 @@
+##############################################################
+#
+#  Bayesian Network Library for Ruby
+#  
+#  Author: Sergio Espeja ( http://www.upf.edu/pdi/iula/sergio.espeja, sergio.espeja at gmail.com )
+#  
+#  Developed in: IULA ( http://www.iula.upf.es ) and 
+#  in bee.com.es ( http://bee.com.es )
+#  
+#  Based on work by Ryan Dahl in 
+#  http://www.math.rochester.edu/people/grads/rld/bayesnets
+#
+##############################################################
+require 'rgl/adjacency'
+require 'rgl/dot'
+
+include RGL
+
+class BayesNet < DirectedAdjacencyGraph
+
+#  DirectedAdjacencyGraph redefined methods
+#  ---------------------------------------- 
+
+# Adds a directed edge between parent and child BayesNetNodes labeled
+# with tag ( if tag is included, othewise the label is nil ).
+  def add_edge(parent, child, tag=nil)
+    raise "Nodes must be of the class BayesNetNodes" if parent.class != BayesNetNode or child.class != BayesNetNode
+    edge = super(parent, child)
+    child.parents << parent
+    child.relations << tag if !tag.nil?
+    edge
+  end
+
+# BN Methods
+# ----------
+
+  # Clears the value of all BayesNetNodes in Bayes Net.
+  def clear_values!
+      vertices.each { |v| v.clear_value }
+  end
+
+  # Gets the variable with given name.
+  def get_variable( text )
+    vertices.each { |v| return v if v.name == text }
+  end
+
+  # Returns the root nodes of the Bayes Net.
+  def roots
+    vertices.select { |v| root?(v) }
+  end
+
+  # Returns true/false if given Node is root.
+  def root?(v)
+    return true if num_parents(v) == 0
+    false
+  end
+
+  # Returns the number of parents of a node.
+  def num_parents(v)
+    return v.parents.size
+  end
+
+  # Return the probability of a distribution in the bayes net
+  # all nodes in the Bayes Net must have a value, otherwise
+  # will raise a exception  
+  def inference_by_enumeration
+    prob = 1.0;
+    vertices.each {|v| prob = prob * p_v_cond_parents(v)}
+    prob
+  end
+
+  # Returns the probability of a node conditioned to his parents:
+  #   P(v|parents(v))
+  def p_v_cond_parents(v)
+    givens_assignments = v.parents.collect {|parents| parents.value}
+    v.get_probability(v.value, givens_assignments).to_f
+  end
+  
+  # Returns true if all nodes have values.
+  def all_nodes_with_values?
+    vertices.select {|v| !v.value.nil? }.size == vertices.size
+  end
+
+  # Returns nodes ordered by dependencies ( from those who haven't ( roots )
+  # to leaves ).
+  def nodes_ordered_by_dependencies(nodes = vertices, bn_ordered = Array.new)
+    nodes.each { |v| 
+      next if bn_ordered.include?(v)
+      nodes_ordered_by_dependencies(v.parents, bn_ordered) if !v.root?
+      bn_ordered << v 
+     }
+     return bn_ordered.flatten
+  end
+
+ 
+end
+
+class BayesNetNode
+  attr_reader :name, :outcomes, :extra_info, :value, :relations
+
+  # create de BayesNetNode
+  # name is the identifier of the node in the Bayesian Network
+  # outcomes is an array with the posible values that this node 
+  # can have, by default [true, false].
+  # [optional] extra_info extra information that can be putted in the node
+  def initialize ( name , outcomes = [true, false], extra_info = nil)
+    @name = name
+    @outcomes = outcomes
+    @extra_info = extra_info
+    @givens = []
+    @relations = []
+  end
+
+  # Returns a copy of the node itself
+  def copy
+    tmp = BayesNetNode.new(@name, @outcomes, @extra_info)
+    tmp.set_value(@value)
+    tmp.set_probability_table(@givens, @table)
+    tmp
+  end
+
+  def set_value(value)
+    @value = value
+  end
+
+  def clear_value
+    @value = nil
+  end
+
+  # Return node parents  
+  def parents
+    return @givens
+  end
+
+  # Return node relations
+  def relations
+    return @relations
+  end
+
+  # Return the number of parents
+  def num_parents
+    parents.size
+  end
+  
+  # Returns true if the node is a root node ( doesn't have parents ).
+  def root?
+    return true if num_parents == 0
+    false
+  end
+
+  # Returns true if all parents of the node in the bn have values
+  def all_parents_with_values?
+    parents.select {|v| !v.value.nil? }.size == parents.size
+  end
+
+  def to_s
+    return name + (value.nil? ? "" : (" = " + value.to_s))
+  end
+
+  # if givens is nil, then internal givens is assumed
+  # table must have probability values in order like BAD!!!
+  # [g0=pos0 & g1=pos0 & ... & node_value=pos0, ..., g0=pos0 & g1=pos0 & ... & node_value=posN,
+  # 
+  def set_probability_table (givens, table)
+    # perhaps we should do some error checking on the table entries here?
+    @table_is_a_proc = (table.class != Array)
+    @givens = givens if !givens.nil?
+    
+    raise "Error table incorrect number of positions (" \
+      + table.size.to_s + " of " + self.get_table_size.to_s \
+      + ")" if table.size != self.get_table_size
+
+    @table = table
+  end
+
+  def parents_assignments
+    parents.collect { |p| p.value }
+  end
+
+  # returns the number of cells that conditional probability table ( CPT )
+  # haves.
+  def get_table_size
+    num = @outcomes.size
+    @givens.each { |given| num = num * given.outcomes.size }
+    return num
+  end
+  
+  # Sets a probability to the node with a node_assignment conditioned to given_assignments
+  #   P (node = node_assignment | givens = givens_assignments) = number
+  def set_probability(number, node_assignment, givens_assignments)
+    @table[get_table_index(node_assignment, givens_assignments)] = number
+  end
+
+  # Returns the probability of an assignment to a node conditioned to given_assignments
+  #    P(node = node_assignment | givens = givens_assignments)
+  # 
+  # All givens_assigments must have value.
+  def get_probability(node_assignment = value, givens_assignments = parents_assignments)
+#    raise "Node must have a value and a givens_assignments, otherwise put" \
+ #         + "them in function call" if node_assignment.nil? or givens_assignments.nil?
+    # if there's a cached table take the index
+    return @table[get_table_index(node_assignment, givens_assignments)] if @table_is_a_proc.nil? or !@table_is_a_proc
+    # if the value is calculated on the fly using a function instead of
+    # a table
+    return @table[node_assignment, givens_assignments]
+  end
+
+  # Returns the corresponding index for the probability table given
+  # <i>node_assignment</i> and <i>givens_assignments</i>
+  def get_table_index(node_assignment, givens_assignments)
+    x = []
+    indices = []
+    index = 0
+    
+    if givens_assignments.length != @givens.length
+      raise "Error. Number of assignments does not match node."
+    end
+  
+    if @givens.length > 0
+      # create a indices array with the position of each value of
+      # given assignments.
+      givens_assignments.length.times { |i|
+        assignment = givens_assignments[i]
+        indices[i] = @givens[i].outcomes.index(assignment)
+      }
+  
+      # create a array with the number of possible values each
+      # given node and this node itself can have ( node.outcomes.length )
+      # plus all next nodes.
+      x[givens_assignments.length-1] = @outcomes.length
+      (givens_assignments.length-2).downto(0) { |j|
+        x[j] = x[j+1] * @givens[j+1].outcomes.length
+      }      
+  
+      # to get the index, sum for each assignment the
+      # product of each given assignment outcomes size
+      # by its value index.
+      givens_assignments.length.times { |i|
+        index += x[i] * indices[i]
+      }
+    end
+    
+    index += @outcomes.index(node_assignment)
+    
+    return index
+  end
+
+  
+end

data/lib/bn4r/bn_algorithms.rb

@@ -0,0 +1,215 @@
+##############################################################
+#
+#  Inference Algorithms for Bayesian Network Library for Ruby
+#  
+#  Author: Sergio Espeja ( http://www.upf.edu/pdi/iula/sergio.espeja, sergio.espeja at gmail.com )
+#  
+#  Developed in: IULA ( http://www.iula.upf.es ) and 
+#  in bee.com.es ( http://bee.com.es )
+#  
+#  == Current implemented algorithms
+#  * enumeration_ask
+#  * prior_sample
+#  * rejection_sampling
+#  * likelihood_weighting
+#
+##############################################################
+class BayesNet < DirectedAdjacencyGraph
+
+# Inference Algorithms
+  
+  # ENUMERATION ASK algorithm
+  # 
+  # Implementation based on: S.Russell, P.Norving, "Artificial
+  # Intelligence, A Modern Approach", 2nd Edition. pp 506
+  # 
+  # <b>x</b> --> query variable
+  # 
+  # <b>e</b> --> variables with observed values
+  def enumeration_ask(x,e, bn_vertices = vertices)
+    e << x
+    q = []
+    #p bn_vertices.collect { |v| v.name }
+    x.outcomes.each {|outcome|
+      x.set_value(outcome)
+      q << enumerate_all(bn_vertices, e)
+    }
+    q
+  end
+
+  # Returns a sample from prior joint distribution specified by the network.
+  # 
+  # Implementation based on: S.Russell, P.Norving, "Artificial
+  # Intelligence, A Modern Approach", 2nd Edition. pp 511-512
+  # 
+  # The input are the nodes of the bn ordered by dependencies see nodes_ordered_by_dependencies
+  def prior_sample(nodes_ordered = nodes_ordered_by_dependencies)
+    sample = Array.new
+    nodes_ordered.each { |v| 
+      value = rand < v.get_probability(true)
+      v.set_value(value) 
+      sample << v.copy
+    }
+    # leave the bn clear of values.
+    nodes_ordered.each { |v| v.clear_value }
+
+    return sample
+  end
+
+  # Returns an estimation of P(X=x|e) = <P(X=x|e), 1 - P(X=x|e)> obtained. Generates samples from prior joint 
+  # distribution specified by the network, rejects all those that do not match the evidence,
+  # and finally counts hoy often X = x occurs in remaining samples.
+  # 
+  # Caution, this algorthm is unusable for complex problems because rejects many samples!
+  # 
+  # Implementation based on: S.Russell, P.Norving, "Artificial
+  # Intelligence, A Modern Approach", 2nd Edition. pp 513
+  # 
+  # <b>x</b> --> query variable
+  # 
+  # <b>e</b> --> variables with observed values
+  # 
+  # <b>n</b> --> Number of samples generated
+  #  
+  def rejection_sampling( x, e, n, bn = self )
+  
+      evidece_list = [e] if e.class != Array
+      x_list = [x] if x.class != Array
+           
+      nodes_ordered = bn.nodes_ordered_by_dependencies
+      evidence_vector = get_vector_value(evidece_list, nodes_ordered)
+      x_vector = get_vector_value(x_list, nodes_ordered)
+      
+      total_valid = 0; total_correct = 0
+      n.times do
+        sample_vector  = bn.prior_sample(nodes_ordered).collect {|v| v.value}
+        
+        valid = true; correct = true
+        for i in 0..(sample_vector.size-1) do
+          correct = false if !x_vector[i].nil? and sample_vector[i] != x_vector[i]
+          valid = false and break if !evidence_vector[i].nil? and sample_vector[i] != evidence_vector[i]
+        end
+        
+        next if !valid
+        total_valid += 1
+        total_correct += 1 if correct  
+      end
+      
+      p_true = total_correct.to_f/total_valid.to_f
+      return [p_true, 1-p_true]
+      #return [total_correct.to_f, total_valid.to_f]
+  end
+  
+  # Returns an estimation of P(X=x|e) = <P(X=x|e), 1 - P(X=x|e)> obtained.
+  # 
+  # Implementation based on: S.Russell, P.Norving, "Artificial
+  # Intelligence, A Modern Approach", 2nd Edition. pp 515
+  # 
+  # <b>x</b> --> query variable
+  # 
+  # <b>e</b> --> variables with observed values
+  # 
+  # <b>n</b> --> Number of samples generated
+  #  
+  def likelihood_weighting( x, e, n, bn = self )
+  
+    retval = [0.0, 0.0]
+    n.times {
+      w_sample, w = weighted_sample(e)
+      value = w_sample.select { |v| v.name == x.name }[0].value
+      #p value
+      if value == x.value
+        retval[1] += w
+      else
+        retval[0] += w
+      end
+    }
+  
+    norm = retval[1].to_f / (retval[0]+retval[1]).to_f
+
+    return [norm, 1-norm]
+  end
+
+  protected
+  # Auxiliar function to compute Enumeration Ask Algorithm
+  def enumerate_all(vars, e)
+  
+    return 1.0 if vars.empty?
+    
+    y = vars.first; i = 1
+    while !y.all_parents_with_values? and i < vars.size
+      y = vars[i]
+      i = i + 1
+    end
+    raise "Error bayes net not computable with enumeration-ask " + \
+    "algorithm" if i == vars.size and !y.all_parents_with_values?
+    
+    if e.include?(y)
+      return p_v_cond_parents(y) * enumerate_all(vars-[y], e)
+    else
+      prob = 0.0
+      y.outcomes.each { |outcome|
+        y.set_value(outcome)
+        prob = prob + p_v_cond_parents(y) * enumerate_all(vars-[y], e+[y])
+        y.clear_value
+      }
+      return prob
+    end
+  end
+
+  # Returns an event and a weight.
+  # 
+  # Implementation based on: S.Russell, P.Norving, "Artificial
+  # Intelligence, A Modern Approach", 2nd Edition. pp 515
+  # 
+  # <b>e</b> --> variables with observed values
+  # 
+  def weighted_sample(e, bn = self)
+    
+    nodes_ordered = bn.nodes_ordered_by_dependencies
+    
+    sample = Array.new
+    w = 1.0
+    nodes_ordered.each { |v| 
+      node_actual = e.select { |node| node.name == v.name } if e.class == Array
+      node_actual = [e] if e.class == BayesNetNode and e.name == v.name
+      if !node_actual.nil? and node_actual.size == 1
+        value = node_actual[0].value
+        w = w * v.get_probability(value)
+      else
+        value = rand < v.get_probability(true)
+      end
+      v.set_value(value) 
+      sample << v.copy
+    }
+    
+    # leave the bn clear of values.
+    bn.clear_values!
+    return sample, w
+  end
+
+  # Axiliar function that returns an array of bn_vertices_ordered.size positions
+  # with nil if position aren't in vertices_vector, and value if there's a match
+  # in vertices_vector.
+  def get_vector_value(vertices_vector, bn_vertices_ordered)
+      bn_vertices_ordered.collect { |v|
+        if !vertices_vector.nil?
+          node_actual = vertices_vector.select { |node| node.name == v.name }
+  
+          case node_actual.size
+            when 0
+              nil
+            when 1
+              node_actual[0].value
+            else
+              raise "Error in get_vector_value" 
+          end
+        else
+          nil
+        end
+      }  
+  end
+
+ 
+
+end

data/lib/bn4r/bn_table_probabilities.rb

@@ -0,0 +1,65 @@
+##############################################################
+#
+#  Methods for poulating Bayes Net Probabilities tables.
+#  
+#  Author: Sergio Espeja ( http://www.upf.edu/pdi/iula/sergio.espeja, sergio.espeja at gmail.com )
+#  
+#  Developed in: IULA ( http://www.iula.upf.es )
+#  
+##############################################################
+
+
+# Bayes Net Table Probabilities Generator
+class BnTableProbabilitiesGenerator
+  def get_node_probability_from_boolean_combination(boolean_combination)
+    0.0
+  end  
+end
+
+# Bayes Net Table Probabilities Generator from Positive Negative Relations
+class BNTPGFromPositiveNegativeRelations < BnTableProbabilitiesGenerator
+
+  public
+  # type_of_position_impact is a array of boolean values showing the 
+  # relation ( positive | negative ) beetwen the node and its parents.
+  def table_probabilities_for_node(node, type_of_position_impact)
+    raise "Node parents and type_of_position_impact with different size" if node.parents.size != type_of_position_impact.size
+    boolean_combinations = []
+    (2**node.parents.size).times { |i|
+      boolean_combination = Array.new(node.parents.size, false)
+      actual_value = i
+      (node.parents.size).times { |j|
+        boolean_combination[j] = !(actual_value%2 == 0)
+        actual_value = actual_value / 2
+      }
+      boolean_combinations << boolean_combination
+    }
+    #p boolean_combinations
+    table_probabilities = [] # Array.new(2**(node.parents.size+1))
+    boolean_combinations.each { |boolean_combination|
+      [true,false].each { |node_value|
+        prob = BNTPGFromPositiveNegativeRelations.get_node_probability_from_boolean_combination(boolean_combination, type_of_position_impact)
+        prob = 1 - prob if node_value == false
+        table_probabilities[node.get_table_index(node_value, boolean_combination)] = prob
+        #p "pos :" + node.get_table_index(node_value, boolean_combination).to_s
+        #p "Ok :" + node.get_table_index(node_value, boolean_combination).to_s if node.get_table_index(node_value, boolean_combination) > 2**node.parents.size
+      }
+    }
+   #p table_probabilities
+   table_probabilities
+  end
+
+  # returns P(node=yes| parents={boolean_combination}) where parents have
+  # relations with the node showed in type_of_position_impact
+  # type_of_position_impact is a array of boolean values showing the 
+  # relation ( positive | negative ) beetwen the node and its parents.
+  def self.get_node_probability_from_boolean_combination(boolean_combination, type_of_position_impact)
+    num_eq = 0.0
+    boolean_combination.size.times { |i|
+      num_eq = num_eq + 1.0 if type_of_position_impact[i] && boolean_combination[i]
+      num_eq = num_eq + 1.0 if !type_of_position_impact[i] && !boolean_combination[i]
+    }
+    num_eq / boolean_combination.size.to_f
+  end
+end
+

data/lib/bn4r/version.rb

@@ -0,0 +1,9 @@
+module Bn4r #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/bn4r.rb

@@ -0,0 +1,11 @@
+##############################################################
+#
+#  Bayesian Network Library for Ruby
+#  
+#  Author: Sergio Espeja ( sergio.espeja@gmail.com )
+#  
+#  Developed in: IULA ( http://www.iula.upf.es ) and 
+#  in bee.com.es ( http://bee.com.es )
+#  
+##############################################################
+Dir[File.join(File.dirname(__FILE__), 'bn4r/**/*.rb')].sort.each { |lib| require lib }

data/test/bn4r_test.rb

@@ -0,0 +1,290 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Bn4rTest < Test::Unit::TestCase
+
+  # Returns the BayesNet used as example in "Artificial Intelligence A 
+  # Modern Approach, Rusell & Norvig, 2nd Ed." pp.494
+  def self.bayes_net_aima
+    bn_aima = BayesNet.new
+    
+    b = BayesNetNode.new("Burglary")
+    e = BayesNetNode.new("Earthquake")
+    a = BayesNetNode.new("Alarm")
+    j = BayesNetNode.new("JohnCalls")
+    m = BayesNetNode.new("MaryCalls")
+
+    bn_aima.add_vertex(b)
+    bn_aima.add_vertex(e)
+    bn_aima.add_vertex(a)
+    bn_aima.add_vertex(j)
+    bn_aima.add_vertex(m)
+    
+    bn_aima.add_edge(b,a)
+    bn_aima.add_edge(e,a)
+    bn_aima.add_edge(a,j)
+    bn_aima.add_edge(a,m)
+    
+    b.set_probability_table([], [0.001, 0.999] )
+    e.set_probability_table([], [0.002, 0.998] )
+    
+    a.set_probability_table([b,e], [0.95, 0.05, 0.94, 0.06, 0.29, 0.61, 0.001,0.999] )
+    
+    j.set_probability_table([a], [0.90,0.10,0.05,0.95])
+    m.set_probability_table([a], [0.70,0.30,0.01,0.99])
+    
+    bn_aima
+  end
+
+  # Returns the BayesNet used as example in "Artificial Intelligence A 
+  # Modern Approach, Rusell & Norvig, 2nd Ed." pp.510
+  def self.bayes_net_aima2
+    bn_aima = BayesNet.new
+
+    cloudy = BayesNetNode.new("Cloudy")
+    sprinkler = BayesNetNode.new("Sprinkler")
+    rain = BayesNetNode.new("Rain")
+    wetgrass = BayesNetNode.new("WetGrass")
+
+    bn_aima.add_vertex(cloudy)
+    bn_aima.add_vertex(sprinkler)
+    bn_aima.add_vertex(rain)
+    bn_aima.add_vertex(wetgrass)
+    
+    bn_aima.add_edge(cloudy,sprinkler)
+    bn_aima.add_edge(cloudy,rain)
+    bn_aima.add_edge(sprinkler,wetgrass)
+    bn_aima.add_edge(rain,wetgrass)
+    
+    cloudy.set_probability_table([], [0.5, 0.5] )
+
+    sprinkler.set_probability_table([cloudy], [0.1, 0.9, 0.5, 0.5] )
+    rain.set_probability_table([cloudy], [0.8, 0.2, 0.2, 0.8] )
+    
+    wetgrass.set_probability_table([sprinkler, rain], [0.99, 0.01, 0.9, 0.1, 0.9, 0.1, 0.0, 1.0] )
+    bn_aima
+  end
+
+  def bayes_net_aaile
+    bn = BayesNet.new
+    rel = BayesNetNode.new("relational")
+    q = BayesNetNode.new("qualificative")
+    a = BayesNetNode.new("Adverbial")
+    bn.add_vertex(rel)
+    bn.add_vertex(q)
+    bn.add_vertex(a)
+
+#    ["preN", ...]    
+    preN = BayesNetNode.new("preN")
+    bn.add_vertex(preN)
+    
+    postN = BayesNetNode.new("postN")
+    bn.add_vertex(postN)
+    
+ #   bn.add_edge("ser")
+ #   bn.add_edge("G")
+ #   bn.add_edge("prep")
+    
+    bn.add_edge(rel, preN)
+    bn.add_edge(q, preN)
+    bn.add_edge(a, preN)
+    bn.add_edge(q, postN)
+    
+    bn
+  end
+
+  def setup
+  end
+ 
+# TESTS
+ 
+  def test_create_sample_bn
+    bn = bayes_net_aaile
+  
+    assert_equal bn.vertices.size, 5
+    assert_equal bn.edges.size, 4
+  end
+  
+  
+  def test_graph_viz
+    bn = bayes_net_aaile
+    # print "\n\n" + bn.to_dot_graph.to_s
+    
+    assert bn.to_dot_graph.to_s.size > 0, "bn.to_dot_graph gives no output."
+  end
+  
+  def test_probability_assingment
+    bn_aima = Bn4rTest.bayes_net_aima
+    b = bn_aima.get_variable("Burglary")
+    a = bn_aima.get_variable("Alarm")
+    j = bn_aima.get_variable("JohnCalls")
+    m = bn_aima.get_variable("MaryCalls")
+    
+    assert_equal b.get_probability(true, []), 0.001
+    assert_equal b.get_probability(false, []), 0.999
+    assert_equal b.get_probability(false, []), 0.999
+    
+    assert_equal a.get_probability(true, [false,false]), 0.001
+    assert_equal a.get_probability(true, [true,false]), 0.94
+    assert_equal a.get_probability(false, [true,true]), 0.05
+    
+    assert_equal j.get_probability(true, [true]), 0.90
+    assert_equal m.get_probability(true, [false]), 0.01
+    
+  end
+  
+  def test_CPT_size
+    bn_aima = Bn4rTest.bayes_net_aima
+    b = bn_aima.get_variable("Burglary")
+    a = bn_aima.get_variable("Alarm")
+    j = bn_aima.get_variable("JohnCalls")
+    m = bn_aima.get_variable("MaryCalls")
+
+    assert_equal b.get_table_size, 2
+    assert_equal a.get_table_size, 8
+    assert_equal j.get_table_size, 4
+    assert_equal m.get_table_size, 4
+  end
+  
+  def test_base_methods
+    bn_aima = Bn4rTest.bayes_net_aima
+    b = bn_aima.get_variable("Burglary")
+    a = bn_aima.get_variable("Alarm")
+    assert bn_aima.root?(b)
+    assert !bn_aima.root?(a)
+    
+  end
+  
+  def test_inference_by_enumeration
+    bn_aima = Bn4rTest.bayes_net_aima
+    b = bn_aima.get_variable("Burglary")
+    e = bn_aima.get_variable("Earthquake")
+    a = bn_aima.get_variable("Alarm")
+    j = bn_aima.get_variable("JohnCalls")
+    m = bn_aima.get_variable("MaryCalls")
+
+    assert_equal bn_aima.vertices.size, 5
+    assert_equal bn_aima.edges.size, 4
+    
+    assert !bn_aima.all_nodes_with_values?
+    b.set_value(false); assert !bn_aima.all_nodes_with_values?
+    e.set_value(false); assert !bn_aima.all_nodes_with_values?
+    a.set_value(true); assert !bn_aima.all_nodes_with_values?
+    j.set_value(true); assert !bn_aima.all_nodes_with_values?
+    m.set_value(true)
+
+    assert bn_aima.all_nodes_with_values?
+        
+    value = bn_aima.inference_by_enumeration
+    assert_in_delta 0.0006281112, value, 10**(-10)
+    
+    bn_aima.clear_values!
+    assert !bn_aima.all_nodes_with_values?
+    
+  end
+  
+  def test_inference_by_enumeration_ask
+    bn_aima = Bn4rTest.bayes_net_aima
+    b = bn_aima.get_variable("Burglary")
+    e = bn_aima.get_variable("Earthquake")
+    a = bn_aima.get_variable("Alarm")
+    j = bn_aima.get_variable("JohnCalls")
+    m = bn_aima.get_variable("MaryCalls")    
+    j.set_value(true)  
+    m.set_value(true)
+    
+    assert_equal bn_aima.vertices.size, 5
+    assert_equal bn_aima.edges.size, 4
+    value1 = bn_aima.enumeration_ask(b,[j,m])
+    value2 = bn_aima.enumeration_ask(b,[j,m], [j,m,a,b,e])
+    value3 = bn_aima.enumeration_ask(b,[j,m], [b,e,a,j,m])
+    assert_equal value1[0], value2[0]
+    assert_equal value1[0].to_f, value3[0].to_f
+    assert_in_delta value1[1].to_f, value2[1].to_f, 10**(-10)
+    assert_equal value1[1], value3[1]
+    assert_in_delta 0.000592242, bn_aima.enumeration_ask(b,[j,m])[0], 10**(-9)
+    bn_aima.clear_values!
+    assert !bn_aima.all_nodes_with_values?
+
+  end
+  
+  
+  def test_table_probabilities_for_node
+    bn_aima = Bn4rTest.bayes_net_aima
+    b = bn_aima.get_variable("Burglary")
+    e = bn_aima.get_variable("Earthquake")
+    a = bn_aima.get_variable("Alarm")
+    BNTPGFromPositiveNegativeRelations.new.table_probabilities_for_node(a, [true,true])
+
+#    BNTPGFromPositiveNegativeRelations.new.populate_bn_with_tags(bn_aima)
+    assert true
+  end
+
+  def test_prior_sampling
+
+    bn = Bn4rTest.bayes_net_aima2
+
+    hash = Hash.new(0)
+    nodes_ordered = bn.nodes_ordered_by_dependencies
+    10000.times { hash[ bn.prior_sample(nodes_ordered).collect {|v| v.value} ] += 1 }
+    
+    combination_of_prob = nodes_ordered.collect { |v|
+      case v.name
+        when "Cloudy"
+          true
+        when "Sprinkler"
+          false
+        when "Rain"
+          true
+        when "WetGrass"
+          true
+        else
+          raise "Incorrect BayesNet created at Bn4rTest.bayes_net_aima2"
+      end
+    }
+    
+    prob = hash[combination_of_prob].to_f/10000.0
+
+    assert_in_delta 0.3, prob, 0.1, "Its inprobable but possible that this error occurs, \
+                                      because we are working with statistics and random data, \
+                                      try again and if still occurs take care of it."
+     
+  end
+
+  def test_rejection_sampling
+    bn = Bn4rTest.bayes_net_aima2
+
+    rain = bn.get_variable("Rain").copy
+    sprinkler = bn.get_variable("Sprinkler").copy
+
+    rain.set_value(true)
+    sprinkler.set_value(true)
+    
+    results = bn.rejection_sampling(rain, sprinkler, 1000)
+
+    str_error = " Its improbable but possible that this error occurs, \
+                  because we are working with statistics and random data, \
+                  try again and if still occurs take care of it."
+    assert ((results[0] > 0.2) and (results[0] < 0.4)), "Results aren't in interval [0.2,0.4] --> " + results[0].to_s + str_error
+    assert ((results[1] > 0.6) and (results[1] < 0.8)), "Results aren't in interval [0.6,0.8] --> " + results[1].to_s + str_error
+  end
+
+  def test_likelihood_weighting
+    bn = Bn4rTest.bayes_net_aima2
+
+    rain = bn.get_variable("Rain").copy
+    sprinkler = bn.get_variable("Sprinkler").copy
+
+    rain.set_value(true)
+    sprinkler.set_value(true)
+    
+    results = bn.likelihood_weighting(rain, sprinkler, 100)
+
+    str_error = " Its improbable but possible that this error occurs, \
+                  because we are working with statistics and random data, \
+                  try again and if still occurs take care of it."
+    assert ((results[0] > 0.2) and (results[0] < 0.4)), "Results aren't in interval [0.2,0.4] --> " + results[0].to_s + str_error
+    assert ((results[1] > 0.6) and (results[1] < 0.8)), "Results aren't in interval [0.6,0.8] --> " + results[1].to_s + str_error
+  end
+
+
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/bn4r'

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: bn4r
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-10-31 00:00:00 +01:00
+summary: bn4r is a bayesian networks library on ruby that provides the user with classes for create bayesian networks and diverse algorithms for solve them.
+require_paths: 
+- lib
+email: sergio.espeja@gmail.com
+homepage: http://bn4r.rubyforge.org
+rubyforge_project: bn4r
+description: bn4r is a bayesian networks library on ruby that provides the user with classes for create bayesian networks and diverse algorithms for solve them.
+autorequire: bn4r
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Sergio Espeja
+files: 
+- README
+- CHANGELOG
+- Rakefile
+- test/test_helper.rb
+- test/bn4r_test.rb
+- lib/bn4r
+- lib/bn4r.rb
+- lib/bn4r/version.rb
+- lib/bn4r/bn.rb
+- lib/bn4r/bn_table_probabilities.rb
+- lib/bn4r/bn_algorithms.rb
+test_files: []
+
+rdoc_options: 
+- --quiet
+- --title
+- bn4r documentation
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README
+- --inline-source
+- --exclude
+- ^(examples|extras)/
+extra_rdoc_files: 
+- README
+- CHANGELOG
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rgl
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.3
+    version: