longjing 0.1.0

data/lib/longjing/search/ff.rb

@@ -0,0 +1,138 @@
+require 'set'
+require 'longjing/search/base'
+require 'longjing/ff/preprocess'
+require 'longjing/ff/connectivity_graph'
+require 'longjing/ff/ordering'
+require 'longjing/ff/relaxed_graph_plan'
+
+module Longjing
+  module PDDL
+    class Literal
+      attr_accessor :ff_neg_goal
+    end
+  end
+
+  module Search
+    def self.ff
+      FF
+    end
+
+    class FF < Base
+      include Longjing::FF
+
+      def init(problem)
+        log { 'Preprocess' }
+        @problem = Preprocess.new.execute(problem)
+        log { 'Propositionalized problem:' }
+        log { "# actions: #{@problem.all_actions.size}" }
+        log { 'Initialize graphs' }
+        cg = ConnectivityGraph.new(@problem)
+        @h = RelaxedGraphPlan.new(cg)
+        @ordering = Ordering.new(cg)
+      end
+
+      def search(problem)
+        log { 'FF search starts' }
+        init(problem)
+        log { "Build goal agenda" }
+        agenda = @ordering.goal_agenda(@problem)
+        log { "Goal agenda:" }
+        log(:facts, agenda)
+        goal = []
+        state = @problem.initial
+        agenda.each do |g|
+          goal << g
+          unless state = hill_climbing(state, goal)
+            return greedy_search
+          end
+        end
+        solution(state)
+      end
+
+      def hill_climbing(state, goal_list)
+        log { "Hill climbing, goal:" }
+        log(:facts, goal_list)
+        reset_best_heuristic
+
+        best = if relaxed_solution = @h.extract(goal_list, state)
+                 distance(relaxed_solution)
+               end
+        logger.debug { "Initial cost: #{best}" }
+        return unless best
+        state.cost = best
+        helpful_actions = relaxed_solution[1]
+        goal_set = goal_list.to_set
+        until best == 0 do
+          state, best, helpful_actions = breadth_first([state],
+                                                       best,
+                                                       helpful_actions,
+                                                       goal_set,
+                                                       goal_list)
+          return unless state
+          logger.debug { "----\nState: #{state}\nCost: #{best}\nPath: #{state.path.map(&:signature).join("\n")}" }
+        end
+        state
+      end
+
+      def breadth_first(frontier, best, helpful_actions,
+                        goal_set, goal_list)
+        known = Hash[frontier.map{|f| [f, true]}]
+        until frontier.empty? do
+          state = frontier.shift
+          statistics.expanded += 1
+
+          log(:exploring, state)
+          log_progress(state)
+
+          actions = helpful_actions || @problem.actions(state)
+          helpful_actions = nil
+          actions.each do |action|
+            new_state = @problem.result(action, state)
+            statistics.generated += 1
+            log(:action, action, new_state)
+            if known.include?(new_state)
+              logger.debug { "Known state" }
+              next
+            end
+
+            added_goals = Hash[action.effect.to_a.select{|lit| goal_set.include?(lit)}.map{|k| [k, true]}]
+            if solution = @h.extract(goal_list, new_state, added_goals)
+              dist = distance(solution)
+              new_state.cost = dist
+              log(:heuristic, new_state, solution, dist, best)
+              if dist < best
+                return [new_state, dist, solution[1]]
+              else
+                known[new_state] = true
+                frontier << new_state
+              end
+            else
+              # ignore infinite heuristic state
+              logger.debug { "No relaxed solution" }
+            end
+            statistics.evaluated += 1
+          end
+        end
+        return nil
+      end
+
+      def greedy_search
+        reset_best_heuristic
+        goal_list = @problem.goal.to_a
+        greedy = Greedy.new
+        heuristic = lambda {|state| distance(@h.extract(goal_list, state))}
+        greedy.search(@problem, heuristic)
+      end
+
+
+      def distance(relaxed)
+        return Float::INFINITY if relaxed.nil?
+        if relaxed[0].empty?
+          0
+        else
+          relaxed[0].map(&:size).reduce(:+)
+        end
+      end
+    end
+  end
+end

data/lib/longjing/search/ff_greedy.rb

@@ -0,0 +1,28 @@
+require 'set'
+require 'longjing/search/base'
+require 'longjing/ff/preprocess'
+require 'longjing/ff/connectivity_graph'
+require 'longjing/ff/ordering'
+require 'longjing/ff/relaxed_graph_plan'
+
+module Longjing
+  module PDDL
+    class Literal
+      attr_accessor :ff_neg_goal
+    end
+  end
+
+  module Search
+    def self.ff_greedy
+      FFGreedy
+    end
+
+    class FFGreedy < FF
+      def search(problem)
+        log { 'FF greedy search starts' }
+        init(problem)
+        greedy_search
+      end
+    end
+  end
+end

data/lib/longjing/search/greedy.rb

@@ -0,0 +1,43 @@
+require 'set'
+require 'longjing/search/base'
+
+module Longjing
+  module Search
+    class Greedy < Base
+      def search(problem, heuristic)
+        log { "Greedy search" }
+        initial = problem.initial
+        if problem.goal?(initial)
+          return solution(initial)
+        end
+        initial.cost = heuristic.call(initial)
+        frontier = SortedSet.new([initial])
+        known = {initial => true}
+        until frontier.empty? do
+          state = frontier.first
+          statistics.expanded += 1
+          frontier.delete(state)
+          log(:exploring, state)
+          log_progress(state)
+          problem.actions(state).each do |action|
+            new_state = problem.result(action, state)
+            statistics.generated += 1
+            log(:action, action, new_state)
+            if known.include?(new_state)
+              logger.debug { "Known state" }
+              next
+            end
+            if problem.goal?(new_state)
+              return solution(new_state)
+            end
+            new_state.cost = heuristic.call(new_state)
+            statistics.evaluated += 1
+            known[new_state] = true
+            frontier << new_state
+          end
+        end
+        no_solution
+      end
+    end
+  end
+end

data/lib/longjing/search/statistics.rb

@@ -0,0 +1,10 @@
+module Longjing
+  module Search
+    class Statistics
+      attr_accessor :generated, :expanded, :evaluated
+      def initialize
+        @generated, @expanded, @evaluated = 0, 0, 0
+      end
+    end
+  end
+end

data/lib/longjing/state.rb

@@ -0,0 +1,27 @@
+module Longjing
+  class State
+    attr_reader :raw, :path, :hash
+    attr_accessor :cost
+
+    def initialize(raw, path=[])
+      @raw = raw
+      @path = path
+      @hash = @raw.hash
+      @cost = 0
+    end
+
+    def ==(state)
+      return true if state.object_id == self.object_id
+      @raw == state.raw
+    end
+    alias :eql? :==
+
+    def to_s
+      "{#{@raw.to_a.join(" ")}}"
+    end
+
+    def <=>(s)
+      @cost <=> s.cost
+    end
+  end
+end

data/lib/longjing/version.rb

@@ -0,0 +1,3 @@
+module Longjing
+  VERSION = "0.1.0"
+end

data/longjing.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'longjing/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "longjing"
+  spec.version       = Longjing::VERSION
+  spec.authors       = ["Xiao Li"]
+  spec.email         = ["swing1979@gmail.com"]
+
+  spec.summary       = %q{Longjing is classical planner.}
+  spec.description   = %q{Longjing is classical planner for learning classical planning algorithms.}
+  spec.homepage      = "https://github.com/xli/longjing"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "ruby-prof"
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: longjing
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Xiao Li
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Longjing is classical planner for learning classical planning algorithms.
+email:
+- swing1979@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- TODO
+- benchmark.log
+- bin/console
+- bin/longjing
+- bin/setup
+- lib/longjing.rb
+- lib/longjing/ff/action.rb
+- lib/longjing/ff/connectivity_graph.rb
+- lib/longjing/ff/ordering.rb
+- lib/longjing/ff/preprocess.rb
+- lib/longjing/ff/relaxed_graph_plan.rb
+- lib/longjing/logging.rb
+- lib/longjing/parameters.rb
+- lib/longjing/pddl.rb
+- lib/longjing/pddl/action.rb
+- lib/longjing/pddl/literal.rb
+- lib/longjing/pddl/obj.rb
+- lib/longjing/pddl/parser.tab.rb
+- lib/longjing/pddl/parser.y
+- lib/longjing/pddl/predicate.rb
+- lib/longjing/pddl/type.rb
+- lib/longjing/pddl/var.rb
+- lib/longjing/problem.rb
+- lib/longjing/search.rb
+- lib/longjing/search/base.rb
+- lib/longjing/search/ff.rb
+- lib/longjing/search/ff_greedy.rb
+- lib/longjing/search/greedy.rb
+- lib/longjing/search/statistics.rb
+- lib/longjing/state.rb
+- lib/longjing/version.rb
+- longjing.gemspec
+homepage: https://github.com/xli/longjing
+licenses: []
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Longjing is classical planner.
+test_files: []