bfsearch 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 129bb56223f1aa129ca1abefda4b85b23da47c47
+  data.tar.gz: a65004653985341496fc91c1cd440657ebcb230f
+SHA512:
+  metadata.gz: e0703db610278237f10eae69ff6b073bebc898127209c5e59939ce165f85568b18f2d40e63f21c1e7f97581da731ea04caa3e5d410397124e7f67445abd50b92
+  data.tar.gz: b8dda051b7b5834263486fdc87d6b834bd393b5644361796687d0fc5450b43f5cb05a686cbdf20560392400eaeb1a1855bd3f5ae5769caf5bc05de1798753a2e

data/lib/bfsearch.rb

@@ -0,0 +1,138 @@
+#   IDAstar --- A pure Ruby implementation of the IDA* search algorithm
+#   Copyright (C) 2016  Eric MSP Veith <eveith+idastar-ruby@veith-m.de>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+##
+# This class implements the Best-First Search algorithm.
+#
+# The Best-First Search algorithm (BFS) tries to find a valid path from a
+# starting node to a destination node. It will always find a path if one
+# exists.
+#
+# The typical usage is to call BFsearch.find_path.
+module BFsearch
+  Entry = Struct.new(:node, :parent, :distance)
+
+  ##
+  # Finds a way from +root_node+ to +destination_node+ and returns the path
+  # node by node.
+  #
+  # This method implements the Best-First Search algorithm. It starts at
+  # +root_node+, trying to find a way to the +destination+.
+  #
+  # The distance between two nodes is measured using a function object passed
+  # as the +distance_function+ parameter. It is called as:
+  #
+  #   distance_function.call(node_1, node_2)  # => Float
+  #
+  # Whenever the algorithm advances from the current node, it needs to know of
+  # the node's neighbors. For this, the foruth parameter,
+  # +neighbors_function+, is required. It is also assumed to be a lambda
+  # object or any object that responds to
+  # +neighbors_function#call(current_node)+ and returns a list of adjacent
+  # nodes.
+  #
+  #   neighbors_function(node)  # => Array
+  #
+  # BFS is an informed search algorithm, i.e., it uses an heuristic to select
+  # the probably best next node at any given state. This heuristic is
+  # implemented using a Lambda and the third parameter,
+  # +heuristic_function(node)+. The distance function must return an
+  # optimistic guess of the distance from the given node to the destination
+  # node. 'Optimistic' means that the value returned (a float) must be equal
+  # to or lower than the actual distance, but never greater. The air-line
+  # distance is a valid implementation of the distance function, since it will
+  # always return a value equal to or lower than the actual distance due to
+  # the triangle inequality.
+  #
+  #   heuristic_function(node)  # => Float
+  def self.find_path(root_node, destination,
+      distance_function, neighbors_function, heuristic_function)
+    root_entry = Entry.new(root_node, nil, 0.0)
+    open = [root_entry]
+    closed = []
+
+    until open.empty?
+      catch :restart do
+        current = open.shift
+        return construct_path(root_node, current) if current.node == destination
+        closed.push current
+
+        neighbors_function.call(current.node).each do |node|
+          open_entry = open.find { |i| i.node == node }
+          closed_entry = closed.find { |i| i.node == node }
+          entry = open_entry || closed_entry ||
+            Entry.new(node, current, nil)
+
+          distance_from_start = distance(entry, distance_function)
+          entry.distance ||= distance_from_start
+
+          # Greedy BFS:
+
+          heuristic_neighbor = heuristic_function.call node
+          heuristic_current = heuristic_function.call current.node
+          if heuristic_neighbor < heuristic_current
+            open.unshift current
+            open.unshift entry
+            throw :restart
+          end
+
+          if !(open_entry || closed_entry)
+            open.push entry
+          else
+            if distance_from_start < entry.distance
+              entry.parent = current
+              entry.distance = distance_from_start
+              open.push entry unless open_entry
+            end
+          end
+        end
+
+        open.sort_by(&:distance)
+      end
+    end
+  end
+
+  ##
+  # Constructs and returns an array that contains the best path from the
+  # root_node to the destination object.
+  def self.construct_path(root_node, destination)
+    nodes = [destination[:node]]
+
+    while destination[:node] != root_node
+      destination = destination[:parent]
+      nodes.unshift destination[:node]
+    end
+
+    nodes
+  end
+
+  ##
+  # Retruns the accumulated distance between two nodes along the currently
+  # recorded path
+  def self.distance(start, distance_function)
+    current = start
+    distance = 0.0
+
+    while current.parent
+      distance += distance_function.call current.node, current.parent.node
+      current = current.parent
+    end
+
+    distance
+  end
+
+  private_class_method :distance, :construct_path
+end

data/test/test_bfsearch.rb

@@ -0,0 +1,97 @@
+require 'minitest/autorun'
+require 'bfsearch'
+
+class BFsearchTest < Minitest::Unit::TestCase
+  def test_smallest_tree
+    tree = {
+      name: :a,
+      next: [
+        {
+          name: :b,
+          next: [
+            {
+              name: :goal,
+              next: []
+            }
+          ]
+        },
+        {
+          name: :c,
+          next: []
+        }
+      ]
+    }
+
+    distance = ->(n, m) { 1.0 }
+    heuristic = ->(node) { 1.0 }
+    neighbors = ->(node) { node[:next] }
+
+    path = BFsearch.find_path(tree, tree[:next][0][:next][0],
+                              distance, neighbors, heuristic)
+    assert_equal 3, path.length
+    assert_equal :goal, path[-1][:name]
+  end
+
+  def test_parallel_paths
+    tree = {
+      sb: {
+        i: :sb,
+        h: 222,
+        n: { kl: 70, ka: 145 }
+      },
+      wu: {
+        i: :wu,
+        h: 0,
+        n: {}
+      },
+      kl: {
+        i: :kl,
+        h: 158,
+        n: { f: 103, lu: 53 }
+      },
+      hn: {
+        i: :hn,
+        h: 87,
+        n: { wu: 102 }
+      },
+      ka: {
+        i: :ka,
+        h: 140,
+        n: { hn: 84 }
+      },
+      f: {
+        i: :f,
+        h: 96,
+        n: { wu: 116 }
+      },
+      lu: {
+        i: :lu,
+        h: 108,
+        n: { wu: 183 }
+      }
+    }
+
+    distance = ->(n, m) { n[:n][m[:i]] || 1000.0 }
+    heuristic = ->(node) { node[:h] }
+    neighbors = ->(node) { node[:n].keys.map { |k| tree[k] } }
+
+    path = BFsearch.find_path(tree[:sb], tree[:wu],
+                              distance, neighbors, heuristic)
+    assert_equal 4, path.length
+    assert_equal :sb, path[0][:i]
+    assert_equal :kl, path[1][:i]
+    assert_equal :f, path[2][:i]
+    assert_equal :wu, path[3][:i]
+  end
+
+  def test_map
+    map = "########" +
+          "#    X #" +
+          "#      #" +
+          "#  ##  #" +
+          "#   #  #" +
+          "#      #" +
+          "# S    #" +
+          "########"
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: bfsearch
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Eric MSP Veith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-16 00:00:00.000000000 Z
+dependencies: []
+description: A pure Ruby implementation of gBFS
+email: eveith+bfsearch@veith-m.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bfsearch.rb
+- test/test_bfsearch.rb
+homepage: https://github.com/eveith/bfsearch
+licenses:
+- GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: The Greedy Best First Search algorithm
+test_files: []