longjing 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a17ae65cb063c4303bd29aabd3398ea2f2a08265
+  data.tar.gz: 50a3fdd3658157a6c5794b94585352b4323505fe
+SHA512:
+  metadata.gz: 29296cb079d586c4ba748179c6877a5773a50bb135730bf1f15ba71ad28861db3e7e84ec63597f88b48a481c900fc8df27fc63671b78c47c235916822f0c5f4c
+  data.tar.gz: 53d69b19419c40586f270dbeeee8639cde8e9d1f963e9956650bbbb58766d1d637ca35c6a85212c8b218171a97a1b13a3c08925f7fd52b97817f0ab740b0e3a1

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/profile.html

data/.ruby-version

@@ -0,0 +1 @@
+2.2.1

data/.travis.yml

@@ -0,0 +1,27 @@
+language: ruby
+rvm:
+  - 2.2.1
+before_install: gem install bundler -v 1.10.2
+env:
+  global:
+    - JRUBY_OPTS="$JRUBY_OPTS --debug"
+gemfile:
+  - Gemfile
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - 2.2.1
+  - jruby-19mode
+  - jruby-head
+  - rbx-2
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: jruby-head
+    - rvm: rbx-2
+    - rvm: ruby-head
+  fast_finish: true
+sudo: false
+before_install: gem install bundler -v 1.10.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in longjing.gemspec
+gemspec

data/README.md

@@ -0,0 +1,35 @@
+# Longjing 龙井
+
+Longjing is a variety of pan-roasted green tea from the area of Longjing Village near Hangzhou in Zhejiang Province, China.
+
+Longjing is classical planner which resolves problems defined by a specific version of PDDL (Planning Domain Definition Language) described in book "Artificial Intelligence: a modern approach".
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'longjing'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install longjing
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/xli/longjing.

data/Rakefile

@@ -0,0 +1,64 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'longjing'
+
+def pddl_problems
+  Dir['test/domains/*.pddl'].each do |f|
+    Longjing.pddl(f)
+  end
+
+  Dir['test/problems/*.pddl'].map do |f|
+    prob = Longjing.pddl(f)
+    {name: prob[:problem], prob: prob}
+  end
+end
+
+def problems
+  pddl_problems
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*test.rb']
+  t.verbose = true
+end
+
+task :default => [:test, :benchmark]
+
+task :profile do
+  require 'ruby-prof'
+  puts "Profile started"
+  result = RubyProf.profile do
+    problems.each do |prob|
+      Longjing.plan(prob[:prob])
+    end
+  end
+  puts "output: profile.html"
+  printer = RubyProf::CallStackPrinter.new(result)
+  File.open("profile.html", 'w') do |f|
+    printer.print(f, {})
+  end
+end
+
+task :b => :benchmark
+
+task :benchmark do
+  require 'benchmark'
+  puts "Benchmark started, output: benchmark.log"
+  stdout = STDOUT
+  $stdout = File.new('benchmark.log', 'w')
+  $stdout.sync = true
+  label_len = problems.map{|p|p[:name].length}.max + 1
+  Benchmark.benchmark(Benchmark::CAPTION, label_len, Benchmark::FORMAT, ">total:", ">avg:") do |x|
+    bms = problems.map do |prob|
+      x.report(prob[:name].to_s.ljust(20)) do
+        10.times do
+          Longjing.plan(prob[:prob])
+        end
+      end
+    end
+    [bms.reduce(:+), bms.reduce(:+)/bms.size]
+  end
+  $stdout = stdout
+  puts File.read('benchmark.log')
+end

data/TODO

@@ -0,0 +1,27 @@
+* planning graph
+** !support typing
+*** Inheritance
+** !propositionalize action schema
+** !planning graph for heuristic estimation
+*** ? A* search
+*** !Enforced hill climbing search
+* FF
+** !relaxed graph plan as heuristic
+** !hill climbing search
+** !handle negative goal
+** !helper actions
+** !added goal deletion
+** !fallback to greedy best-first search when hill climbing search failed
+** !goals agenda
+* support pddl 3.1 strip pddl input and output
+** !pddl file parser
+** analysis support requirements, only do plan with supported problem
+** test parser with more complex domains and problems
+** typing support
+* full support of pddl 3.1
+** support definition of constant objects
+
+--------
+* remove actions having conflict effects:
+** !contain positive & negative of a fact
+** use predicates to validate?

data/benchmark.log

@@ -0,0 +1,10 @@
+                                  user     system      total        real
+BW-rand-8                     0.130000   0.000000   0.130000 (  0.126941)
+BW-rand-12                    0.540000   0.000000   0.540000 (  0.543002)
+BW-rand-20                   14.630000   0.030000  14.660000 ( 14.657970)
+BW-rand-4                     0.030000   0.000000   0.030000 (  0.033519)
+cake-a                        0.000000   0.000000   0.000000 (  0.001633)
+cargo-a                       0.010000   0.000000   0.010000 (  0.008611)
+freecell-f2-c2-s2-i1-02-12    4.220000   0.020000   4.240000 (  4.236310)
+>total:                      19.560000   0.050000  19.610000 ( 19.607987)
+>avg:                         2.794286   0.007143   2.801429 (  2.801141)

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "longjing"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/longjing

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path)
+
+require 'longjing'
+
+input = ARGV.dup
+
+Longjing.logger.level = if input.include?('-v')
+                          input.delete('-v')
+                          Logger::DEBUG
+                        elsif input.include?('-s')
+                          input.delete('-s')
+                          Logger::WARN
+                        else
+                          Logger::INFO
+                        end
+
+prof = if input.include?('-p')
+         input.delete('-p')
+         require 'ruby-prof'
+         puts "Profile start"
+         RubyProf.start
+       end
+
+Longjing.pddl_plan(*input)
+
+if prof
+  result = RubyProf.stop
+  puts "output: profile.html"
+  # printer = RubyProf::CallStackPrinter.new(result)
+  printer = RubyProf::GraphHtmlPrinter.new(result)
+  File.open("profile.html", 'w') do |f|
+    printer.print(f, {})
+  end
+end

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/longjing.rb

@@ -0,0 +1,54 @@
+require "longjing/version"
+require 'longjing/logging'
+require 'longjing/pddl'
+require 'longjing/search'
+
+module Longjing
+  extend Logging
+
+  module_function
+  def pddl(file)
+    raise "File #{file.inspect} does not exist" unless File.exist?(file)
+    PDDL.parse(File.read(file))
+  end
+
+  def pddl_problem(domain_file, problem_file)
+    pddl(domain_file)
+    pddl(problem_file)
+  end
+
+  def pddl_plan(domain_file, problem_file, search=:ff)
+    prob = pddl_problem(domain_file, problem_file)
+    plan(prob, search).tap do |solution|
+      validate!(prob, solution)
+    end
+  end
+
+  def plan(problem, search=:ff)
+    log(:problem, problem)
+    Search.send(search).new.search(problem)
+  end
+
+  def validate!(prob, solution)
+    raise "No solution" if solution.nil?
+    goal = prob[:goal]
+    actions = Hash[prob[:actions].map{|o| [o.name, o]}]
+    objects = Hash[prob[:objects].map{|o| [o.name, o]}]
+    state = prob[:init].to_set
+
+    solution.each do |step|
+      name, *args = step.gsub(/[()]/, ' ').strip.split(' ').map(&:to_sym)
+      action = actions[name]
+      args = Array(args).map{|arg| objects[arg]}
+      action = action.substitute(args)
+      if action.precond.applicable?(state)
+        state = action.effect.apply(state)
+      else
+        raise "Invalid solution, failed at step: #{step.inspect}"
+      end
+    end
+    unless goal.applicable?(state)
+      raise "Invalid solution, end with #{state}"
+    end
+  end
+end

data/lib/longjing/ff/action.rb

@@ -0,0 +1,39 @@
+module Longjing
+  module FF
+    class Action
+      attr_accessor :counter, :difficulty, :layer
+      attr_reader :count_target, :action, :hash
+      attr_reader :pre, :add, :del
+
+      def initialize(action)
+        @action = action
+        @pre = []
+        @add = []
+        @del = []
+        @action.precond.to_a.each do |lit|
+          if lit.ff_neg_goal || !lit.is_a?(PDDL::Not)
+            @pre << lit
+          end
+        end
+
+        @action.effect.to_a.each do |lit|
+          if lit.ff_neg_goal || !lit.is_a?(PDDL::Not)
+            @add << lit
+          else
+            @del << lit.literal
+          end
+        end
+        @count_target = @pre.size
+        @hash = self.object_id
+      end
+
+      def signature
+        @action.signature
+      end
+
+      def to_s
+        "Action[#{signature}]"
+      end
+    end
+  end
+end

data/lib/longjing/ff/connectivity_graph.rb

@@ -0,0 +1,35 @@
+require 'longjing/ff/action'
+
+module Longjing
+  module FF
+    class ConnectivityGraph
+      attr_reader :actions, :add2actions, :pre2actions, :del2actions, :literals
+
+      def initialize(problem)
+        @actions = problem.all_actions.map do |action|
+          Action.new(action)
+        end
+        @add2actions = {}
+        @pre2actions = {}
+        @del2actions = {}
+        @actions.each do |action|
+          action.pre.each do |lit|
+            @pre2actions[lit] ||= []
+            @pre2actions[lit] << action
+          end
+          action.add.each do |lit|
+            @add2actions[lit] ||= []
+            @add2actions[lit] << action
+          end
+          action.del.each do |lit|
+            @del2actions[lit] ||= {}
+            @del2actions[lit][action] = true
+          end
+        end
+        @literals = (@pre2actions.keys +
+                     @add2actions.keys +
+                     @del2actions.keys).uniq
+      end
+    end
+  end
+end

data/lib/longjing/ff/ordering.rb

@@ -0,0 +1,125 @@
+module Longjing
+  module FF
+    class Ordering
+      def initialize(connectivity_graph)
+        @actions = connectivity_graph.actions
+        @add2actions = connectivity_graph.add2actions
+        @del2actions = connectivity_graph.del2actions
+      end
+
+      def da(f)
+        if actions = @add2actions[f]
+          set = Hash[actions[0].del.map{|l|[l, true]}]
+          actions[1..-1].inject(set) do |memo, action|
+            n = {}
+            action.del.each do |f|
+              if memo.include?(f)
+                n[f] = true
+              end
+            end
+            n
+          end
+        else
+          {}
+        end
+      end
+
+      def possibly_achievable_atoms(p, action_set)
+        if actions = @add2actions[p]
+          actions.any? do |action|
+            next unless action_set.include?(action)
+            action.pre.all? do |lit|
+              if acs = @add2actions[lit]
+                acs.any? do |a|
+                  action_set.include?(a) && a != action
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def heuristic_fixpoint_reduction(a)
+        facts = da(a)
+        del_a_actions = @del2actions[a] || {}
+        actions = {}
+        @actions.each do |action|
+          next if del_a_actions.include?(action)
+          next if action.pre.any?{|l| facts.include?(l)}
+          actions[action] = true
+        end
+
+        fixpoint = false
+        while(!fixpoint) do
+          fixpoint = true
+          facts.keys.each do |f|
+            if possibly_achievable_atoms(f, actions)
+              facts.delete(f)
+              actions = {}
+              @actions.each do |action|
+                next if del_a_actions.include?(action)
+                next if action.pre.any?{|l| facts.include?(l)}
+                actions[action] = true
+              end
+              fixpoint = false
+            end
+          end
+        end
+        [facts, actions]
+      end
+
+      def heuristic_ordering(a, b)
+        facts, actions = heuristic_fixpoint_reduction(a)
+        possibly_achievable_atoms(b, actions)
+      end
+
+      def goal_agenda(prob)
+        g = Hash.new{|h,k|h[k]={}}
+        list = prob.goal.to_a
+        list.each do |a|
+          list.each do |b|
+            next if a == b
+            g[a][b] = !heuristic_ordering(b, a)
+          end
+        end
+
+        compute_transitive_closure(list, g)
+
+        # in&out edges
+        degree = Hash.new{|h,k| h[k]=0}
+        hits = Hash.new{|h,k| h[k]=0}
+        list.each do |a|
+          list.each do |b|
+            next if a == b
+            if g[a][b]
+              degree[a] -= 1
+              degree[b] += 1
+              hits[a] += 1
+              hits[b] += 1
+            end
+          end
+        end
+
+        # order by increasing degree
+        # disconnected at the end
+        list.sort_by do |a|
+          hits[a] == 0 ? Float::INFINITY : degree[a]
+        end
+      end
+
+      def compute_transitive_closure(nodes, graph)
+        nodes.each do |j|
+          nodes.each do |i|
+            if graph[i][j]
+              nodes.each do |k|
+                if graph[j][k]
+                  graph[i][k] = true
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end