maneuver 0.0.1pre

data/lib/maneuver.rb

@@ -0,0 +1,2 @@
+%w(maneuver node edge graph cost_algorithm 
+   search_algorithm first_search a_star).each { |f| require "maneuver/#{f}" }

data/lib/maneuver/a_star.rb

@@ -0,0 +1,56 @@
+require 'maneuver/search_algorithm'
+
+module Maneuver
+  class AStar < SearchAlgorithm
+    def self.path(from, to, cost_algorithm)
+      raise "EdgeAlgorithm hueristic (param #3 => cost_algorithm) can not be nil" unless cost_algorithm
+      open = [from]
+      estimate = Maneuver.cost_algorithms[cost_algorithm]
+      came_from = {}
+      g_score = { from => 0}
+      f_score = { from => g_score[from] + estimate.compute(from, to)}
+
+      while !open.empty?
+        current = self.key_with_min_value open, f_score
+        return reconstruct_path(came_from, to) if current == to
+        open.delete current
+        current.outgoing_edges.each do |e|
+          n = e.to
+          t_g_score = g_score[current] + e.cost(cost_algorithm)
+          if !open.include? n || t_g_score <= g_score[n]
+            came_from[n] = current
+            g_score[n] = t_g_score
+            f_score[n] = t_g_score + estimate.compute(n, to)
+            open << n unless open.include? n
+          end
+        end
+      end
+      nil
+    end
+
+    def self.key_with_min_value(set, hash)
+      min_value = Float::MAX
+      min_key = nil
+      set.each do |k|
+        m = hash[k] 
+        if m < min_value
+          min_key = k 
+          min_value = m
+        end
+      end
+      min_key
+    end
+
+    def self.reconstruct_path(came_from, current)
+      path = [current]
+      while came_from.key? current
+        n = came_from[current]
+        path.unshift n
+        current = n
+      end
+      path
+    end
+  end
+
+  add_search_algorithm :a_star, AStar
+end

data/lib/maneuver/cost_algorithm.rb

@@ -0,0 +1,29 @@
+module Maneuver
+  class CostAlgorithm
+    class << self
+      attr_accessor :cache
+      
+      def compute(from, to)
+        0
+      end
+    
+      def method_added(method)
+        return unless method.to_sym == :compute
+        self.send :define_singleton_method, :_sing_compute, self.method(method.to_sym)
+        self.singleton_method_added(:_sing_compute)
+      end
+
+      def singleton_method_added(method)
+        return if method.to_sym != :compute &&  
+          method.to_sym != :_sing_compute
+        internal = lambda do |from, to|
+          self.cache ||= {}
+          self.cache[[from, to]] ||= begin
+            self.send :compute, from, to            
+          end
+        end
+        self.send :define_singleton_method, :_compute, internal
+      end
+    end
+  end
+end

data/lib/maneuver/edge.rb

@@ -0,0 +1,17 @@
+module Maneuver
+  class Edge
+    attr_reader :from, :to
+
+    def initialize(from, to)
+      @from, @to = from, to
+      from.edges << self
+      to.edges << self
+    end
+    
+    def cost(algorithm)
+      ca = Maneuver.cost_algorithms[algorithm]
+      raise "Unknow Cost Algorithm: #{algorithm}" unless ca
+      ca._compute(@from, @to)
+    end
+  end
+end

data/lib/maneuver/first_search.rb

@@ -0,0 +1,66 @@
+require 'maneuver/search_algorithm'
+
+module Maneuver
+
+  class FirstSearch < SearchAlgorithm
+    def self.prep_node
+      Maneuver::Node.send :define_method, :_fs_parent, lambda { instance_variable_get :@_fs_parent }
+      Maneuver::Node.send :define_method, :_fs_parent=, lambda {|a| instance_variable_set(:@_fs_parent, a)}
+    end
+
+    def self.clean_node
+      Maneuver::Node.send :remove_method, :_fs_parent
+      Maneuver::Node.send :remove_method, :_fs_parent=
+    end
+
+    def self.reconstruct_path(node)
+      path = [node]
+      while node._fs_parent
+        path.unshift node._fs_parent
+        node = node._fs_parent
+      end
+      self.clean_node
+      path
+    end
+
+    def self.get_node(nodes_to_check)
+      nil
+    end
+
+    def self.path(from, to, edge_algorithm = nil)
+      return from if from == to
+      self.prep_node
+      nodes_to_check = []
+      visited = [from]
+      from.outgoing_edges.each { |edge| edge.to._fs_parent = from; nodes_to_check << edge.to }
+      while !nodes_to_check.empty?
+        node = self.get_node nodes_to_check
+        return self.reconstruct_path(to) if node == to
+        node.outgoing_edges.each do |e|
+          test = e.to
+          unless visited.include? test
+            test._fs_parent = node
+            visited << test
+            nodes_to_check.unshift test
+          end
+        end
+      end
+      self.clean_node
+      nil
+    end
+  end
+
+  class DFS < FirstSearch
+    def self.get_node(nodes_to_check)
+      nodes_to_check.shift
+    end
+  end
+
+  class BFS < FirstSearch
+    def self.get_node(nodes_to_check)
+      nodes_to_check.pop
+    end
+  end
+
+  [[:bfs, BFS], [:dfs, DFS]].each { |alg| add_search_algorithm alg[0], alg[1]}
+end

data/lib/maneuver/graph.rb

@@ -0,0 +1,39 @@
+module Maneuver
+  class Graph
+    def initialize(edges = [])
+      @nodes = []
+      @edges = edges.map { |e| Edge.new e[0], e[1] }
+      @edges.each do |e|
+        @nodes << e.to unless @nodes.include? e.to
+        @nodes << e.from unless  @nodes.include? e.from
+      end
+    end
+
+    def insert_nodes(*nodes)
+      nodes.each { |n| @nodes << n unless @nodes.include? n }
+    end
+
+    def insert_edges(*edges)
+      edges.each do |e|
+        unless has_edge e
+          @edges << e
+          @nodes << e.to unless @nodes.include? e.to
+          @nodes << e.from unless  @nodes.include? e.from
+        end
+      end
+    end
+    
+    def has_edge(edge)
+      exists = false
+      @edges.each { |e| break if (exists = (e.from == edge.from && 
+        e.to == edge.to)) }
+      exists
+    end
+
+    def path(from, to, search_algorithm, cost_algorithm = nil)
+      search = Maneuver.search_algorithms[search_algorithm]
+      raise "Unknown Search Algorithm: #{search_algorithm}" unless search
+      search.path(from, to, cost_algorithm)
+    end
+  end
+end

data/lib/maneuver/maneuver.rb

@@ -0,0 +1,23 @@
+module Maneuver
+  @@cost_algorithms = {}
+  @@search_algorithms = {}
+
+  class << self
+    def add_cost_algorithm(sym, klass)
+      @@cost_algorithms[sym] = klass
+    end
+
+    def cost_algorithms
+      @@cost_algorithms
+    end
+
+    def add_search_algorithm(sym, klass)
+      @@search_algorithms[sym] = klass
+    end
+
+    def search_algorithms
+      @@search_algorithms
+    end
+  end
+  
+end

data/lib/maneuver/node.rb

@@ -0,0 +1,24 @@
+module Maneuver
+  class Node
+    attr_reader :edges
+    def initialize(*args)
+      @edges = []
+    end
+
+    def outgoing_edges
+      @edges.reject { |e| e.to == self }
+    end
+
+    def incoming_edges
+      @edges.reject { |e| e.from == self }
+    end
+
+    def out_degree
+      outgoing_edges.length
+    end
+
+    def in_degree
+      incoming_edges.length
+    end
+  end
+end

data/lib/maneuver/search_algorithm.rb

@@ -0,0 +1,7 @@
+module Maneuver
+  class SearchAlgorithm
+    def self.path(from, to, cost_algorithm = nil)
+      nil
+    end
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: maneuver
+version: !ruby/object:Gem::Version
+  version: 0.0.1pre
+  prerelease: 5
+platform: ruby
+authors:
+- Kayle Gishen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-19 00:00:00.000000000 Z
+dependencies: []
+description: A simple graph library with path planning.
+email: kayle@moremagic.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/maneuver/a_star.rb
+- lib/maneuver/cost_algorithm.rb
+- lib/maneuver/edge.rb
+- lib/maneuver/first_search.rb
+- lib/maneuver/graph.rb
+- lib/maneuver/maneuver.rb
+- lib/maneuver/node.rb
+- lib/maneuver/search_algorithm.rb
+- lib/maneuver.rb
+homepage: https://github.com/kayleg/maneuver
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Graph and Path Planning
+test_files: []