drp 0.0.6

data/README

@@ -0,0 +1,77 @@
+= DRP, Directed Ruby Programming
+
+Grammatical Evolution + Genetic Programming = Directed Programming
+
+DRP is a generative programming system which lets you do GP, GE, hybrid GP and GE, and which like GE separates the search algorithm from the program representation.
+
+The Web site of DRP is http://drp.rubyforge.org.
+Documentation can be found at http://drp.rubyforge.org/rdoc.
+For a much more in depth explanation see the INTRO file in the rdoc.
+The RubyForge project page is http://rubyforge.org/projects/drp, where the latest
+version of DRP may be downloaded. 
+DRP is also available as a RubyGem, see installation instructions below.
+
+== Dependencies
+
+DRP does not require any other packages. The test suite in the tests
+directory requires the testing framework TestUnit, which comes with Ruby 1.8
+and later and can also be found in the Ruby Application Archive
+(http://raa.ruby-lang.org).
+
+Deployment is handled by RubyGems and Rake.
+
+== Installation
+
+=== RubyGems Installation
+
+To install drp as a gem, type:
+
+    $ gem install drp
+
+To update it if previously installed as a gem:
+
+    $ gem update drp
+
+To remove drp (although I'm sure you want want to do that):
+
+    $ gem uninstall drp
+
+You may need root privileges to install, update, or remove the gem.
+You can also download the compressed archive, but installing
+as a gem is much more highly recomended.
+
+== Testing
+
+To run the test suite if you have the gem installed:
+
+    $ gem check -t drp
+
+Note, it disconcertingly prints nothing on success.
+
+If you are manually installing the archive:
+
+    $ rake test
+
+runs all of the tests in the test directory. 
+
+= Support
+
+* Visit the forums, bug list, and mailing list pages at
+  http://rubyforge.org/projects/drp
+
+* Send email to Christophe McKeon at mailto:polypus@yahoo.com
+
+* Ask on the ruby-talk mailing list or ruby forum
+
+= Administrivia
+
+:include:AUTHORS
+Copyright (c) 2006, Christophe McKeon
+Software License:: Distributed under the GNU GPL, see LICENSE
+Documentation and Website:: Creative Commons Attribution-NonCommercial-ShareAlike 2.5 License
+
+== Warranty
+
+This software is provided "as is" and without any express or implied
+warranties, including, without limitation, the implied warranties of
+merchantability and fitness for a particular purpose.

data/Rakefile

@@ -0,0 +1,99 @@
+
+require 'rubygems'
+Gem::manage_gems
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'rake/contrib/sshpublisher'
+
+PROJECT_NAME = 'drp'
+RUBYFORGE_USER = 'polypus'
+RDOC_OPTIONS = ['--main','README','--include','examples/intro']
+
+PKG_FILES = FileList[ 
+  'CHANGES', 'AUTHORS', 'README', 'TODO', 'LICENSE',
+  'Rakefile',
+  'examples/intro/*',
+  'examples/*.rb',
+  'lib/**/*.rb',
+  'test/**/*.rb'
+].to_a
+
+RDOC_FILES = FileList[
+  'README', 
+  'INTRO'
+].to_a
+
+TEST_SUITE_FILE_NAME = 'test/ts_drp.rb'
+
+DRP_DESCRIPTION = %{
+Directed Programming is a new generative programming technique developed by Christophe McKeon which is a generalisation of Grammatical Evolution (http://www.grammatical-evolution.org) allowing one not only to do GE, but also to do Genetic Programming (http://www.genetic-programming.org) in pure Ruby without explicitly generating a program string as output. DP even allows you to set up hybrids of GP and GE where part of a GE subtree is calculated using normal Ruby functions/operators/etc. via. GP. DRP is the first ever implementation of DP and is written in pure Ruby. 
+}
+
+spec = Gem::Specification.new do |s|
+
+  s.name    = PROJECT_NAME
+  s.version = `ruby -Ilib -e 'require "info"; puts DRP::Version'`.strip
+  s.summary = 'genetic programming * grammatical evolution = directed (ruby) programming'
+  s.platform = Gem::Platform::RUBY
+
+  s.require_path = 'lib'
+#  s.autorequire = PROJECT_NAME
+  s.files = PKG_FILES
+
+  s.has_rdoc = true
+  s.rdoc_options = s.rdoc_options + RDOC_OPTIONS
+  s.extra_rdoc_files = RDOC_FILES
+
+  s.author = 'Christophe McKeon'
+  s.email = 'polypus@yahoo.com'
+  s.homepage = 'http://drp.rubyforge.org'
+  s.rubyforge_project = PROJECT_NAME
+
+  s.description = DRP_DESCRIPTION
+      
+  s.test_file = TEST_SUITE_FILE_NAME
+
+end
+
+task :default => [:package]
+
+# creates :package and :gem tasks
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+# creates an :rdoc task
+Rake::RDocTask.new do |rd|
+  # rd.main = 'README' # this is set in options
+  rd.title = PROJECT_NAME
+  rd.rdoc_files = RDOC_FILES + FileList['lib/**/*.rb'].to_a
+  rd.rdoc_dir = 'rdoc'
+  rd.options += RDOC_OPTIONS
+end
+
+# creates an :rdoc task for :rubyforge_publish task
+Rake::RDocTask.new(:rdoc_publish) do |rd|
+  rd.title = PROJECT_NAME
+  rd.rdoc_files = RDOC_FILES + FileList['lib/**/*.rb'].to_a
+  rd.rdoc_dir = 'rubyforge_website/rdoc'
+  rd.options += RDOC_OPTIONS
+end
+
+# creates a :test task
+Rake::TestTask.new do |tt|
+  tt.pattern = TEST_SUITE_FILE_NAME
+  tt.verbose = true
+#  tt.warning = true
+end
+
+task :rubyforge_publish => [:rdoc_publish] do
+  # copies the contents of website, into the top level dir at rubyforge
+  host = RUBYFORGE_USER + "@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{PROJECT_NAME}"
+  local_dir = "rubyforge_website"
+  Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+  # this did not allow control over name of local dir
+  # Rake::RubyForgePublisher.new(PROJECT_NAME, RUBYFORGE_USER).upload
+end

data/TODO

@@ -0,0 +1,13 @@
+
+more work on exceptions and error handling, and also testing of
+   exceptions
+
+clean up weight and max_depth argument parsing, it's a bit all over
+   the place
+
+feature idea: make a weight_fcd_of (perhaps named differently) which allows
+   you to determine the weight for a given rule depending on the depth
+   of another rule. this is handy if you have some higher rule method
+   which calls another rule method which has several choices, and you
+   want the choice to be contingent on the higher method's depth.
+

data/examples/intro/README

@@ -0,0 +1,2 @@
+
+all the examples in this directory are included into the INTRO file in the rdoc.

data/examples/intro/canvas_example.rb

@@ -0,0 +1,123 @@
+require 'rubygems'
+require 'drp'
+
+NUM_CANVASES = 8
+CANVAS_SIZE = 200
+
+class CanvasExample
+
+  extend DRP::RuleEngine
+
+  def initialize num_codons = 100
+    @codons = Array.new(num_codons) { rand }
+    @num_codons = num_codons
+    @index = 0
+  end
+
+  def next_codon
+    @index += 1
+    @index = 0 if @index >= @num_codons
+    @codons[@index]
+  end
+
+ begin_rules
+
+  max_depth 4..24
+  weight 1
+
+  def start_rule
+    start_rule + ctx_mv_list_prep
+  end
+
+  def ctx_mv_list_prep    
+    ctx_begin + ctx_fill_style + ctx_stroke_style + ctx_mv_list + ctx_end
+  end
+  def ctx_mv_list
+    ctx_mv_list + ctx_mv
+  end
+
+  def ctx_mv
+    "ctx.#{mv_type}"
+  end
+
+  # this weight will apply to all following rule methods
+  weight_fcd 0..1
+
+  def mv_type
+    "lineTo(#{loc},#{loc});"
+  end
+  def mv_type
+    "moveTo(#{loc},#{loc});"
+  end
+  def mv_type
+    "bezierCurveTo(#{loc},#{loc},#{loc},#{loc},#{loc},#{loc});"
+  end
+  
+  def ctx_end
+    "ctx.fill();"
+  end
+  def ctx_end
+    "ctx.stroke();"
+  end
+
+ end_rules
+
+  def loc
+    map(0..CANVAS_SIZE).to_i
+  end
+
+  def ctx_fill_style
+    "ctx.fillStyle=#{rgba}"
+  end
+  def ctx_stroke_style
+    "ctx.strokeStyle=#{rgba}"
+  end  
+  def ctx_begin
+    "ctx.beginPath();"
+  end
+  def rgba
+    "'rgba(#{rgb_val},#{rgb_val},#{rgb_val},#{next_codon})';"
+  end
+  def rgb_val
+    map(0..256).to_i
+  end
+
+  def default_rule_method
+    ''
+  end
+
+end
+
+def html script, body
+  %{<html><head>
+    <style>
+      canvas {margin: 10px; border: solid black 1px}
+      #drp {margin: 10px}
+    </style>
+    <script>#{script}</script></head>
+    <body>#{body}</body></html>
+  }
+end
+def js_draw_func
+  "function(ctx){#{CanvasExample.new.start_rule}},\n"
+end
+
+script = %{
+  window.onload = function() {
+    for( var i = 0; i < #{NUM_CANVASES}; i++ ) { 
+      var ctx = document.getElementById('cvs_' + i).getContext('2d');
+      draw_funcs[i](ctx);
+    }
+  }
+  var draw_funcs = [
+}
+NUM_CANVASES.times do |i|
+  script += js_draw_func
+end
+script += "];"
+
+body = ""
+NUM_CANVASES.times do |i|
+  body += %{<canvas id='cvs_#{i}' width="#{CANVAS_SIZE}" height="#{CANVAS_SIZE}"></canvas>}
+end
+puts html(script, body)

data/examples/intro/max_depths_example.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'drp'
+
+class MaxDepthsExample
+
+  extend DRP::RuleEngine
+
+ begin_rules
+
+  max_depth 2
+
+  def foo
+    "foo1 #{foo}"
+  end
+
+  max_depth 3
+
+  def foo
+    "foo2 #{foo}"
+  end
+
+ end_rules
+
+  def default_rule_method
+    "bar!"
+  end
+
+end
+
+mde = MaxDepthsExample.new
+3.times do
+  puts mde.foo
+end
+

data/examples/intro/max_depths_example_2.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'drp'
+
+class MaxDepthsExample2
+
+  extend DRP::RuleEngine
+
+ begin_rules
+
+  max_depth 0..3
+
+  def foo
+    "foo1 #{foo}"
+  end
+
+  def foo
+    "foo2 #{foo}"
+  end
+
+ end_rules
+
+end
+
+3.times do
+  mde2 = MaxDepthsExample2.new
+  3.times do
+    puts mde2.foo
+  end
+  puts
+end

data/examples/intro/odds_and_ends.rb

@@ -0,0 +1,96 @@
+
+require 'rubygems'
+require 'drp'
+
+class OddsAndEnds
+
+  extend DRP::RuleEngine
+
+  def initialize num_codons
+    @array_of_goodies = %w{ lollypop hotpants sunset whalesong }
+    @num_codons = num_codons
+    @codons = Array.new(num_codons) { rand }
+    @c_index = 0
+  end
+
+  def next_codon
+    @c_index = 0 if @c_index == @num_codons
+    cod = @codons[@c_index]
+    @c_index += 1
+    cod 
+  end
+
+ begin_rules
+
+  max_depth 2..4
+
+  def max_depth_string
+    "max_depth = #{max_depth}"
+  end
+
+  def depth_example
+    "#{depth} #{depth_example}"
+  end
+
+  def depth_indirect_a
+    "#{depth} #{depth_indirect_b}"
+  end
+  def depth_indirect_b
+    "#{depth} #{depth_indirect_a}"
+  end
+
+  def map_range
+    val = map 0..10
+    "#{val} #{map_range}"
+  end
+
+  def map_range_i
+    index = map 0..3, :i_lin
+    @array_of_goodies[index] + ' ' +  map_range_i
+  end
+
+  def map_block
+    val = map { |x,y| x * y * 10 }
+    "#{val} #{map_block}"
+  end
+
+  def next_codons
+    "you can even get the next_codon: #{next_codon},\nand next_meta_codon: #{next_meta_codon}"
+  end
+
+ end_rules
+
+  def default_rule_method
+    "!"
+  end
+
+end
+
+oae = OddsAndEnds.new(40)
+
+puts "querying for the max_depth:"
+puts oae.max_depth_string
+puts
+
+puts "simple depth example:"
+puts oae.depth_example
+puts
+
+puts "indirect depth example:"
+puts oae.depth_indirect_a
+puts
+
+puts "map a range:"
+puts oae.map_range
+puts
+
+puts "map an integer range:"
+puts oae.map_range_i
+puts
+
+puts "map a block:"
+puts oae.map_block
+puts
+
+puts oae.next_codons
+puts