optimal-control 0.0.2

data/CHANGELOG

@@ -0,0 +1,4 @@
+
+v0.0.2  Issue with resource pathing on version 0.0.1 resolved 
+
+v0.0.1 initial format 

data/Manifest

@@ -0,0 +1,11 @@
+CHANGELOG
+Manifest
+README
+Rakefile
+bin/optimalcontrol
+lib/cgl/evaluate.rb
+lib/cgl/neighbors.rb
+lib/cgl/runner.rb
+test/test_evaluate.rb
+test/test_neighbors.rb
+test/test_runner.rb

data/README

@@ -0,0 +1,17 @@
+Optimal Control for Conway's game of Life - 0.0.1
+Franziska Hinkelmann 
+fhinkel@vt.edu
+
+
+This gem will generate an optimal controller for Conway's game of Life on a n
+x n grid with periodic boundary conditions. The control objective is to have
+the left upper corner dead after m iterations, the control that can be applied
+is to kill the cell one to the right of it. 
+
+Cost for control is 1 cost unit, independent of the iteration step it is
+applied to. Every initial state to which control should be applied is
+reported, including the iteration steps at which control should be applied. 
+
+Unit tests are in test/
+
+

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rake/gempackagetask' 
+require 'echoe'
+
+#spec = Gem::Specification.new do |s| 
+#  s.name = "optimal-control" 
+#  s.summary = "Simulate Conway's game of Life on a small grid with periodic
+#  boundary conditions and find the optimal controller for the specified
+#  control objective and control options"
+#  s.description= File.read(File.join(File.dirname(__FILE__), 'README')) 
+#  s.author = "Franziska Hinkelmann" 
+#  s.email = "fhinkel@vt.edu" 
+#  s.version = "0.0.2" 
+#  s.platform = Gem::Platform::RUBY 
+#  s.required_ruby_version = '>=1.8.6' 
+#  s.files = Dir['**/**'] 
+#  s.executables = [ 'optimalcontrol' ] 
+#  s.test_files = Dir["test/test*.rb"] 
+#  s.has_rdoc = false 
+#end 
+#Rake::GemPackageTask.new(spec).define
+
+spec = Echoe.new("optimal-control") do |s| 
+  s.summary = "Simulate Conway's game of Life on a small grid with periodic
+  boundary conditions and find the optimal controller for the specified
+  control objective and control options"
+  #s.description= File.read(File.join(File.dirname(__FILE__), 'README')) 
+  s.author = "Franziska Hinkelmann" 
+  s.email = "fhinkel@vt.edu" 
+  s.url = "http://rubyforge.org/projects/optimal-control/" 
+  s.platform = Gem::Platform::RUBY 
+  #s.required_ruby_version = '>=1.8.6' 
+  #s.files = Dir['**/**'] 
+  #s.executables = [ 'optimalcontrol' ] 
+  #s.test_files = Dir["test/test*.rb"] 
+  #s.has_rdoc = false 
+end 

data/bin/optimalcontrol

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../lib/cgl/runner' 
+
+# Optimal Control for a 4by4 Conways game of life, control objective is
+# defined in the assign_final_cost function
+# assume control is 1 unit cost per cell, the central 4 cells can be
+# independently controlled
+
+if /-h/ =~ ARGV.to_s
+  puts
+  puts "Optimal Control for Conway's Game of Life"
+  puts
+  puts "Usage: bin/optimalconrol Iterations Height Width"
+  puts "Default values are 5 for the number of steps to iterate, and 2 as\
+ grid height and width of the grid."
+ puts
+  exit
+end
+
+Steps = ARGV[0].to_i - 1 || 4 # Steps + 1 iterations 
+
+unless 0 <= Steps 
+  puts "The first argument, the number of iterations, must be an integer at least 1"
+  exit
+end
+
+Max_cost = (Steps+1)*4 + 1 #     make states that are not admissible more expensive than
+      # applying control before all #Steps iterations
+
+Grid_height = ARGV[1].to_i || 2
+unless 0 < Grid_height && Grid_height < 5
+  puts "The second argument, height of the grid, must be an integer between 1 and 5"
+  exit
+end
+Grid_width = ARGV[2].to_i || Grid_height # if no hight is given, use a square grid
+unless 0 < Grid_width && Grid_width < 5
+  puts "The third argument, width of the grid, must be an integer between 1 and 5"
+  exit
+end
+
+
+runner = Cgl::Runner.new(Steps, Max_cost, Grid_height, Grid_width) 
+
+# result = [cost_vector[0], control[0]]
+result = runner.run
+
+n_agents = Grid_height * Grid_width
+cost_vector = result[0]
+control = result[1]
+
+# print all states that can lead to a valid final state 
+# TODO print control input to reach final state
+for i in 0..2**n_agents-1 do 
+  if (cost_vector[i]>0)
+      puts "%0#{n_agents}d" % i.to_s(2) + ": cost = #{cost_vector[i]}, control applied at timeSteps \"#{control[i]}\""
+  end
+end
+

data/lib/cgl/evaluate.rb

@@ -0,0 +1,26 @@
+module Cgl
+  class Evaluate
+    # given an array of length 9, where the first entry is the agent to
+    # update, return the agents updated value
+    def self.evaluate( neighbors )
+      agent = neighbors.shift.to_i
+      number_of_alive_neighbors = neighbors.inject(0){|sum,item| sum.to_i + item.to_i }
+      # assume the very first column is the agent we're computing the next state
+      # for
+      if (number_of_alive_neighbors < 2) 
+        f = 0
+      elsif (number_of_alive_neighbors == 2)
+        if (agent==1)
+          f = 1
+        else
+          f = 0
+        end
+      elsif (number_of_alive_neighbors == 3)
+        f = 1
+      else # number_of_alive_neighbors > 3
+        f = 0
+      end
+      f
+    end
+  end
+end

data/lib/cgl/neighbors.rb

@@ -0,0 +1,26 @@
+module Cgl
+  class Neighbors
+    # given the index of an agent and the full grid, return an array with the
+    # values of the 8 neighboring agents
+    # assume periodic boundary conditions (wrap) 
+    # all indexing is 0 based, so a 3 x 4 grid has these indexes: 
+    #   0     1   2   3
+    #   4     5   6   7
+    #   8     9  10  11
+    #
+    def self.neighbors(agent, all_agents, height, width = height)
+      neighbors = Array.new
+      row = agent/width
+      column = agent%width
+      neighbors.push all_agents[(row*width)+(column+1)%width]
+      neighbors.push all_agents[((row+1)%height)*width+(column+1)%width]
+      neighbors.push all_agents[((row+1)%height)*width+(column)]
+      neighbors.push all_agents[((row+1)%height)*width+(column-1)%width]
+      neighbors.push all_agents[row*width+(column-1)%width]
+      neighbors.push all_agents[(row-1)*width+(column-1)%width]
+      neighbors.push all_agents[(row-1)*width+(column)]
+      neighbors.push all_agents[(row-1)*width+(column+1)%width]
+      neighbors
+    end
+  end
+end

data/lib/cgl/runner.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/evaluate' 
+require File.dirname(__FILE__) + '/neighbors' 
+
+module Cgl
+  class Runner 
+    attr_reader :steps
+    attr_reader :max_cost
+    attr_reader :grid_height
+    attr_reader :grid_width 
+    attr_reader :n_agents
+    def initialize( steps, max_cost, grid_height, grid_width = grid_height )
+      @steps = steps
+      @max_cost = max_cost
+      @grid_height = grid_height
+      @grid_width = grid_width
+      @n_agents = grid_height * grid_width
+    end
+
+    def run
+      cost_vector = Array.new(@steps+2) # cost_vector[i][state]cost of getting from state to admissible state in
+          # @steps+2-i time@steps 
+
+      # control[j][i] has a sequence for applying control to state i
+      control = Array.new(@steps+2) # need an extra vector of empty strings, so we
+        #can later concatenate without worrying about being at the last entry
+      for i in 0..@steps+1 do 
+        cost_vector[i] = Array.new(2**@n_agents)
+        control[i] = Array.new(2**@n_agents, "")
+      end
+
+      for i in 0..2**@n_agents-1 do 
+        cost_vector[@steps+1][i] = assign_final_cost(i)
+      end
+
+      for j in 0..@steps do 
+        puts @steps - j
+        for i in 0..2**@n_agents-1 do 
+          i_as_array = ("%0#{@n_agents}d" % i.to_s(2)).split(//)
+
+           # calculate cost without control
+          output = iterate i_as_array
+          state = output.to_s.to_i(2)
+          cost_without_control = cost_vector[@steps-j+1][state]
+
+           # calculate cost with control and take min
+          # TODO pass agent to kill as arg
+          # control: kill agent 2 
+          i_as_array[1] = "0"
+          output = iterate i_as_array
+          state_with_control = output.to_s.to_i(2)
+          cost_for_control = 1
+          cost_with_control = cost_vector[@steps-j+1][state_with_control] + cost_for_control
+
+          # take min and record if control was applied 
+          if (cost_without_control < cost_with_control)
+            cost_vector[@steps-j][i] = cost_without_control
+            control[@steps-j][i] = control[@steps-j+1][state]
+          else 
+            cost_vector[@steps-j][i] = cost_with_control
+            control[@steps-j][i] = "#{@steps-j+1}" + control[@steps-j+1][state_with_control]
+          end
+        end
+      end
+       
+      [cost_vector[0], control[0]]
+    end
+
+  private
+    def assign_final_cost( state ) 
+      # valid if agent 1 is dead 
+      if ( state < 2**(@n_agents - 1) ) 
+        cost = 0
+      else
+        cost = @max_cost
+      end
+      cost
+    end
+
+    def iterate( i_as_array )
+      output = Array.new(@n_agents)
+      for k in 0..@n_agents-1 do # update all N_agents states
+        input_data = Cgl::Neighbors.neighbors(k, i_as_array, @grid_height,
+        @grid_width)
+        output[k] = Cgl::Evaluate.evaluate([i_as_array[k]] + input_data)
+      end
+      output
+    end
+  end
+end
+

data/optimal-control.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{optimal-control}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Franziska Hinkelmann"]
+  s.date = %q{2010-01-01}
+  s.default_executable = %q{optimalcontrol}
+  s.description = %q{Simulate Conway's game of Life on a small grid with periodic
+  boundary conditions and find the optimal controller for the specified
+  control objective and control options}
+  s.email = %q{fhinkel@vt.edu}
+  s.executables = ["optimalcontrol"]
+  s.extra_rdoc_files = ["CHANGELOG", "README", "bin/optimalcontrol", "lib/cgl/evaluate.rb", "lib/cgl/neighbors.rb", "lib/cgl/runner.rb"]
+  s.files = ["CHANGELOG", "Manifest", "README", "Rakefile", "bin/optimalcontrol", "lib/cgl/evaluate.rb", "lib/cgl/neighbors.rb", "lib/cgl/runner.rb", "test/test_evaluate.rb", "test/test_neighbors.rb", "test/test_runner.rb", "optimal-control.gemspec"]
+  s.homepage = %q{http://rubyforge.org/projects/optimal-control/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Optimal-control", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{optimal-control}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Simulate Conway's game of Life on a small grid with periodic boundary conditions and find the optimal controller for the specified control objective and control options}
+  s.test_files = ["test/test_evaluate.rb", "test/test_neighbors.rb", "test/test_runner.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/test_evaluate.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+
+require 'lib/cgl/evaluate'
+
+class TestEvaluate < Test::Unit::TestCase
+  context "alive agent" do 
+    should "die as if caused by underpopulation" do
+      agent = Cgl::Evaluate.evaluate( ["1", "1"] ) 
+      assert_equal agent, 0 
+      agent = Cgl::Evaluate.evaluate( ["1"] ) 
+      assert_equal agent, 0 
+    end
+    should "die as if by overcrowding " do
+      agent = Cgl::Evaluate.evaluate( ["1", "1", "1", "1", "1"] ) 
+      assert_equal agent, 0 
+    end
+    should "life on with 2 or 3 neighbors" do
+      agent = Cgl::Evaluate.evaluate( ["1", "1", "1"] ) 
+      assert_equal agent, 1 
+      agent = Cgl::Evaluate.evaluate( ["1", "0", "0", "0", "1", "1"] ) 
+      assert_equal agent, 1 
+      agent = Cgl::Evaluate.evaluate( ["1", "1", "1", "1"] ) 
+      assert_equal agent, 1 
+      agent = Cgl::Evaluate.evaluate( ["1", "1", "0", "1", "1", "0", "0", "0",
+      "0"] ) 
+      assert_equal agent, 1 
+      agent = Cgl::Evaluate.evaluate( ["1", "0", "0", "1", "1", "0", "0", "0",
+      "0"] ) 
+      assert_equal agent, 1 
+    end
+  end
+  context "dead agent" do 
+    should "become a live cell with 3 neighbors" do 
+      agent = Cgl::Evaluate.evaluate( ["0", "1", "1", "1"] ) 
+      assert_equal agent, 1 
+      agent = Cgl::Evaluate.evaluate( ["0", "0", "0", "0","1", "1", "1","0", "0"] ) 
+      assert_equal agent, 1 
+      agent = Cgl::Evaluate.evaluate( ["0", "1", "0", "0","1", "0", "1"] ) 
+      assert_equal agent, 1 
+      agent = Cgl::Evaluate.evaluate( ["1", "1", "0", "1", "1", "0","0", "0",
+      "0"] ) 
+      assert_equal agent, 1 
+    end
+  end
+end
+

data/test/test_neighbors.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+
+require 'lib/cgl/neighbors'
+
+class TestNeighbors < Test::Unit::TestCase
+  context "agent in a 1 by 1 grid " do 
+    should "have all 8 neighbors the same" do
+      neighbors = Cgl::Neighbors.neighbors(0, ["0"], 1)
+      assert_equal ["0", "0", "0", "0", "0", "0", "0", "0"], neighbors 
+      neighbors = Cgl::Neighbors.neighbors(0, ["aa"], 1)
+      assert_equal ["aa", "aa", "aa", "aa", "aa", "aa", "aa", "aa"], neighbors 
+    end
+  end
+  context "agent a in a 2 by 2 grid " do 
+    should "have all 8 neighbors bdcdbdcdb" do
+      neighbors = Cgl::Neighbors.neighbors(0, ["a", "b", "c", "d"], 2)
+      assert_equal ["b", "d", "c", "d", "b", "d", "c", "d"], neighbors 
+    end
+  end
+  context "central agent a in a 3 by 3 grid " do 
+    should "have all normal 8 neighbors" do
+      neighbors = Cgl::Neighbors.neighbors(4, ["a", "b", "c", "d", "e", "f", "g", "h", "i"], 3)
+      assert_equal ["f", "i", "h", "g", "d", "a", "b", "c"], neighbors 
+    end
+  end
+  context "upper right agent a in a 2 by 3 grid " do 
+    should "have all normal 8 neighbors" do
+      neighbors = Cgl::Neighbors.neighbors(0, ["a", "b", "c", "d", "e", "f"],
+      2, 3)
+      assert_equal ["b", "e", "d", "f", "c", "f", "d", "e"], neighbors 
+    end
+  end
+  context "lower right corner on 3 by 3 grid" do 
+    should "have the following neighbors" do 
+      neighbors = Cgl::Neighbors.neighbors(8, ["a", "b", "c", "d", "e", "f", "g", "h", "i"], 3)
+      assert_equal ["g", "a", "c", "b", "h", "e", "f", "d"], neighbors 
+    end
+  end
+      
+end
+

data/test/test_runner.rb

@@ -0,0 +1,114 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+
+require 'lib/cgl/runner'
+
+class TestRunner < Test::Unit::TestCase
+  context "2 by 2 grid, 1 timestep " do 
+    should "have these intial states with max cost" do
+      steps = 0
+      max_cost = (steps+1)*1 + 1
+      grid_size = 2
+      n_agents = grid_size**2
+      runner = Cgl::Runner.new(steps, max_cost, grid_size)
+      result = runner.run      
+      assert_equal 2, result.size
+      cost_vector = result[0]
+      control = result[1]
+      assert_equal 2**n_agents, cost_vector.size
+      assert_equal 2**n_agents, control.size
+      for i in 0..2**n_agents-1
+        unless cost_vector[i] == max_cost
+          assert cost_vector[i]==control[i].size
+        end
+        #puts "%0#{n_agents}d" %i.to_s(2) + ": #{cost_vector[i]}"
+      end
+      precomputed_cost = "0000000000201000".split(//).collect{|x| x.to_i}
+      assert precomputed_cost == cost_vector,
+      precomputed_cost + cost_vector
+      assert ["", "", "", "", "", "", "", "", "", "", "", "", "1", "", "",
+      ""] == control
+    end
+  end
+  context "2 by 3 grid, 1 timestep " do 
+    should "have these intial states with max cost" do
+      steps = 0
+      max_cost = (steps+1)*1 + 1
+      grid_hight = 2
+      grid_width = 3 
+      n_agents = grid_width * grid_hight  
+      runner = Cgl::Runner.new(steps, max_cost, grid_hight, grid_width)
+      result = runner.run      
+      cost_vector = result[0]
+      control = result[1]
+      for i in 0..2**n_agents-1
+        unless cost_vector[i] == max_cost
+          assert cost_vector[i]==control[i].size
+        end
+        #puts "%0#{n_agents}d" %i.to_s(2) + ": #{cost_vector[i]}"
+      end
+
+      precomputed_cost =
+      "0000000002202000011010000000000002202000022020000220200010000000".split(//).collect{|x| x.to_i}
+      assert precomputed_cost == cost_vector,
+      precomputed_cost.to_s + "\n" +  cost_vector.to_s
+      precomputed_control = ["", "", "", "", "", "", "", "", "", "", "", "",
+      "", "", "", "", "", "1", "1", "", "1", "", "", "", "", "", "", "", "",
+      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+      "", "", "", "", "", "", "", "", "", "1", "", "", "", "", "", "", ""]
+      assert precomputed_control  == control, "control is wrong"
+    end
+  end
+  context "2 by 2 grid, 3 timestep " do 
+    should "have these intial states with max cost" do
+      steps = 2
+      max_cost = (steps+1)*1 + 1
+      grid_size = 2
+      n_agents = grid_size**2
+      runner = Cgl::Runner.new(steps, max_cost, grid_size)
+      result = runner.run      
+      assert_equal 2, result.size
+      cost_vector = result[0]
+      control = result[1]
+      assert_equal 2**n_agents, cost_vector.size
+      assert_equal 2**n_agents, control.size
+      for i in 0..2**n_agents-1
+        unless cost_vector[i] == max_cost
+          assert cost_vector[i]==control[i].size
+        end
+      end
+      precomputed_cost = "0000000000401000".split(//).collect{|x| x.to_i}
+      assert precomputed_cost == cost_vector,
+      precomputed_cost + cost_vector
+      assert ["", "", "", "", "", "", "", "", "", "", "", "", "1", "", "",
+      ""] == control
+    end
+  end
+  context "3 by 3 grid, 1 timestep " do 
+    should "have these intial states with max cost" do
+      steps = 0 
+      max_cost = (steps+1)*1 + 1
+      grid_size = 3
+      n_agents = grid_size**2
+      runner = Cgl::Runner.new(steps, max_cost, grid_size)
+      result = runner.run      
+      assert_equal 2, result.size
+      cost_vector = result[0]
+      control = result[1]
+      assert_equal 2**n_agents, cost_vector.size
+      assert_equal 2**n_agents, control.size
+      for i in 0..2**n_agents-1
+        unless cost_vector[i] == max_cost
+          assert cost_vector[i]==control[i].size
+        end
+        #puts "%0#{n_agents}d" %i.to_s(2) + ": #{cost_vector[i]} control in step #{control[i]}"
+      end
+      # some hand crafted test cases
+      assert cost_vector[335] == 0
+      assert cost_vector[432] == 2
+      assert cost_vector[448] == 1
+    end
+  end
+end
+

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: optimal-control
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Franziska Hinkelmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-01 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: |-
+  Simulate Conway's game of Life on a small grid with periodic
+    boundary conditions and find the optimal controller for the specified
+    control objective and control options
+email: fhinkel@vt.edu
+executables: 
+- optimalcontrol
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- README
+- bin/optimalcontrol
+- lib/cgl/evaluate.rb
+- lib/cgl/neighbors.rb
+- lib/cgl/runner.rb
+files: 
+- CHANGELOG
+- Manifest
+- README
+- Rakefile
+- bin/optimalcontrol
+- lib/cgl/evaluate.rb
+- lib/cgl/neighbors.rb
+- lib/cgl/runner.rb
+- test/test_evaluate.rb
+- test/test_neighbors.rb
+- test/test_runner.rb
+- optimal-control.gemspec
+has_rdoc: true
+homepage: http://rubyforge.org/projects/optimal-control/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Optimal-control
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: optimal-control
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simulate Conway's game of Life on a small grid with periodic boundary conditions and find the optimal controller for the specified control objective and control options
+test_files: 
+- test/test_evaluate.rb
+- test/test_neighbors.rb
+- test/test_runner.rb