drp 0.0.6

data/lib/utils.rb

@@ -0,0 +1,67 @@
+
+=begin 
+
+DRP, Genetic Programming + Grammatical Evolution = Directed Ruby Programming
+Copyright (C) 2006, Christophe McKeon
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Softwar Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+=end
+
+module DRP
+
+module Utils
+
+ class << self
+ 
+  def map range, val, function = :linear
+    # this line is necessary in case nil is explicitly passed
+    function = function ? function.to_sym : :linear
+    case function.to_sym
+
+    when :linear, :lin
+      linear_map range, val
+
+    when :i_linear, :i_lin
+      i_linear_map range, val
+    
+    else
+      raise ArgumentError, "bad function for range: #{function}", caller
+    end
+  end
+
+ private
+
+  def linear_map range, val
+    first, last = range.first, range.last
+    diff = last - first
+    diff * val + first
+  end
+
+  def i_linear_map range, val
+    first, last = range.first, range.last
+    distance = (last - first).to_i.abs + 1
+    i = (distance * val).floor
+    if first < last
+      first + i
+    else
+      first - i
+    end
+  end
+
+ end # class << self
+
+end # module Utils
+
+end # module DRP

data/lib/weights_and_max_depths.rb

@@ -0,0 +1,264 @@
+
+=begin 
+
+DRP, Genetic Programming + Grammatical Evolution = Directed Ruby Programming
+Copyright (C) 2006, Christophe McKeon
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Softwar Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+=end
+
+module DRP
+
+module MaxDepths
+
+# the max_depth classes are stored in class variables
+# and are passed an instance of the extended user class
+# so that they can ask for codons if they need them.
+# they need not be copied like weights because they are 
+# only run once at instance initialization
+
+class StaticMaxDepth
+  def initialize int
+    @value = int.to_i
+  end
+  def value drp_instance_unused
+    @value
+  end
+end
+
+class MappedMaxDepth
+  def initialize range, function = :i_linear
+    @range, @function = range, function
+  end
+  def value drp_instance
+    Utils::map(
+      @range,
+      drp_instance.next_meta_codon,
+      @function
+    )
+  end
+end
+
+class ProcMaxDepth
+  def initialize proc
+    @proc, @arity = proc, proc.arity
+  end
+  def value drp_instance
+    if @arity <= 0
+      @proc.call.to_i
+    elsif @arity == 1
+      @proc.call(drp_instance.next_meta_codon).to_i
+    else
+      @proc.call(*Array.new(@arity) { drp_instance.next_meta_codon }).to_i
+    end
+  end
+end
+
+end # module MaxDepths
+
+module Weights
+
+# user args can be array or proc
+WeightArgs = Struct.new :user_args, :rule_method, :drp_instance
+
+class AbstractWeight
+  def self.factory args_or_proc
+    proc do |rule_method, drp_instance|
+      self.new WeightArgs.new(args_or_proc, rule_method, drp_instance)
+    end
+  end
+end
+
+=begin
+  weight 10.0                         static weight
+  weight 0..1                         static mapped
+  weight 0..1, :function              static mapped w/ function
+  weight {}                           static proc gets codons
+=end
+
+class StaticWeight < AbstractWeight
+  attr_reader :value
+  def initialize args
+    user_args = args.user_args
+    sz = user_args.size
+    case sz
+      when 1
+        arg = user_args[0]
+        case arg
+          when Numeric
+            @value = arg.to_f
+          when Range
+            @value = Utils::map(
+              arg, 
+              args.drp_instance.next_meta_codon
+            )
+          else 
+            raise ArgumentError, 'when 1 arg given to weight, must be Numeric, or Range', caller
+        end
+      when 2
+        rng = args[0] 
+        func = args[1].to_sym
+        if (rng.kind_of? Range) && (func.kind_of? Symbol)
+          @value = Utils::map(
+            rng, 
+            args.drp_instance.next_meta_codon,
+            func
+          )
+        else
+          raise ArgumentError, 'weight args of wrong types'
+        end
+      else
+      raise ArgumentError, "weight takes 1 or 2 args, #{sz} given"
+    end # case user_args.size
+  end # def initialize
+end
+
+class ProcStaticWeight < StaticWeight
+  def initialize args
+    proc = args.user_args
+    ar = proc.arity
+    inst = args.drp_instance
+    if ar <= 0
+      @value = proc.call
+    elsif ar == 1
+      @value = proc.call inst.next_meta_codon
+    else
+      @value = proc.call *Array.new(ar) { inst.next_meta_codon }
+    end
+  end
+end
+
+=begin
+  weight_dyn 0..1                     codon maps to range for every rule method choice
+  weight_dyn 0..1, :function          same but using function
+  weight_dyn 0..1, 0..1               initial min and max determined by metacodons
+                                        and further runtime mapping also
+  weight_dyn 0..1, 0..1, :function    same but function used for runtime mapping
+  weight_dyn { |codon| }              same but using use block, gets meta_codons
+=end
+
+=begin DYNAMIC WEIGHTS PROBABLY NOT THAT USEFUL 
+
+class DynamicWeight < AbstractWeight 
+  def initialize args
+    @drp_instance = args.drp_instance
+    arg1, arg2, arg3 = args.user_args
+    if arg1.kind_of? Range
+      @range = arg1
+      if arg2.kind_of? Range
+        if (arg3.kind_of? Symbol) or (arg3.kind_of? String)
+          @function = arg3
+        end
+        min = Utils::map(@range, @drp_instance.next_meta_codon)
+        max = Utils::map(arg2, @drp_instance.next_meta_codon)
+        @range = min..max
+      elsif (arg2.kind_of? Symbol) or (arg2.kind_of? String)
+        @function = arg2
+      end
+    else
+      raise ArgumentError, 'weight_dyn args of wrong type'
+    end
+  end
+  def value
+    val = Utils::map(
+      @range, 
+      @drp_instance.next_meta_codon,
+      @function
+    )
+    puts val
+    val
+  end
+end
+
+class ProcDynamicWeight < AbstractWeight
+  def initialize args
+    @proc = args.user_args
+    @arity = @proc.arity
+    @drp_instance = args.drp_instance
+  end
+  def value
+    case @arity
+        # these are here, and also ordered, for efficiencies sake
+      when 1
+        @proc.call @drp_instance.next_meta_codon
+      when 2
+        @proc.call @drp_instance.next_meta_codon, @drp_instance.next_meta_codon
+      when 0
+        raise ArgumentError, "block given to dynamic weight must have 1 or more arguments"
+      else
+        @proc.call *Array.new(@arity) { @drp_instance.next_meta_codon }
+    end
+  end
+end
+
+=end
+
+=begin
+  weight_fcd 0..1                     dynamic from current depth (uses max_depth)
+  weight_fcd 0..1, :function          dynamic fcd w/ function
+  weight_fcd 0..1, 0..1               dynamic like previous but start
+                                        and end of range mapped from codons
+  weight_fcd 0..1, 0..1, :function    like previous with function
+                                        the function applies to the dynamic mapping
+                                        of the current depth, and not the static
+                                        mapping via codons of start and end
+                                        which is always just linear
+  weight_fcd { |max_depth|            dynamic, expects a block which takes the 
+               ...                      max_depth and returns a proc which 
+               proc {|depth| ... }      which takes the current depth
+             }                      
+=end
+
+class WeightFromCurrentDepth < AbstractWeight
+  def initialize args
+    @drp_instance = args.drp_instance
+    @rule_method = args.rule_method
+    @max_depth = @rule_method.max_depth - 1
+    arg1, arg2, arg3 = args.user_args
+    if arg1.kind_of? Range
+      @range = arg1
+      if arg2.kind_of? Range
+        if (arg3.kind_of? Symbol) or (arg3.kind_of? String)
+          @function = arg3
+        end
+        min = Utils::map(@range, @drp_instance.next_meta_codon)
+        max = Utils::map(arg2, @drp_instance.next_meta_codon)
+        @range = min..max
+      elsif (arg2.kind_of? Symbol) or (arg2.kind_of? String)
+        @function = arg2
+      end
+    else
+      raise ArgumentError, 'bad argument to weight_fcd'
+    end    
+  end
+  def value
+    val = @rule_method.depth.to_f / @max_depth
+    Utils::map(@range, val, @function)
+  end
+end
+
+class ProcWeightFromCurrentDepth < AbstractWeight
+  def initialize args
+    @rule_method = args.rule_method
+    @proc = args.user_args.call @rule_method.max_depth
+  end
+  def value
+    @proc.call @rule_method.depth
+  end
+end
+
+end # module Weights
+
+end # module DRP

data/test/tc_instance_methods.rb

@@ -0,0 +1,219 @@
+
+=begin 
+
+DRP, Genetic Programming + Grammatical Evolution = Directed Ruby Programming
+Copyright (C) 2006, Christophe McKeon
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Softwar Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+=end
+
+class TestInstanceMethodsHelper
+  
+  extend DRP::RuleEngine
+
+  MAX_DEPTH = 10
+  MAX_DEPTH_2 = 3
+  DEFAULT_NUM_CODONS = 40
+
+  attr_reader :minimum_depth, :maximum_depth, :depths
+
+  def initialize codons = nil
+    @minimum_depth = 2000000000 
+    @maximum_depth = 0
+    @depths = []
+    self.codons= codons
+    # init_drp
+  end
+
+  def next_codon
+    @codon_index = 0 if @codon_index == @num_codons
+    res = @codons[@codon_index]
+    @codon_index += 1
+    res
+  end
+
+  def codons= codons
+    @codons = codons || Array.new(DEFAULT_NUM_CODONS) { rand }
+    @codon_index = 0
+    @num_codons = @codons.size
+  end
+
+  begin_rules
+
+  ### depth tests ###
+
+  # because there is only ever one LHS
+  # in the follwing rules, each one is always
+  # picked and hence is deterministic and
+  # recursed to the maximum depth.
+
+  max_depth MAX_DEPTH
+
+  def test_depth_pre
+    register_depth
+    test_depth_pre
+  end
+
+  def test_depth_post
+    test_depth_post
+    register_depth
+  end
+
+  def test_depth_2_rules
+    @depths << depth
+    other_rule
+    test_depth_2_rules
+  end
+
+  max_depth MAX_DEPTH_2
+
+  def other_rule
+    @depths << depth
+    other_rule
+  end
+
+  end_rules
+
+  def register_depth
+    the_depth = depth
+    @depths << the_depth
+    # print @depths, "\n"
+    @minimum_depth = the_depth if the_depth < @minimum_depth
+    @maximum_depth = the_depth if the_depth > @maximum_depth
+  end
+
+end
+
+class TestInstanceMethods < Test::Unit::TestCase
+
+  MD = TestInstanceMethodsHelper::MAX_DEPTH
+  MD2 = TestInstanceMethodsHelper::MAX_DEPTH_2
+
+  def setup
+    @drp_obj = TestInstanceMethodsHelper.new
+  end
+
+  def test_depth_pre
+    @drp_obj.test_depth_pre
+    assert_equal 1, @drp_obj.minimum_depth
+    assert_equal MD, @drp_obj.maximum_depth
+    assert_equal (1..MD).to_a, @drp_obj.depths
+    # assert false, "NOTE: just to have a false assertion for gemspec"
+  end
+
+  def test_depth_post
+    @drp_obj.test_depth_post
+    assert_equal 1, @drp_obj.minimum_depth
+    assert_equal MD, @drp_obj.maximum_depth
+    assert_equal (1..MD).to_a.reverse, @drp_obj.depths
+  end
+
+  def test_depth_2_rules
+    @drp_obj.test_depth_2_rules
+    depths_should_be = []
+    MD.times do |i|
+      depths_should_be << (i + 1)
+      MD2.times do |j|
+        depths_should_be << (j + 1)
+      end
+    end
+    assert_equal depths_should_be, @drp_obj.depths
+  end
+
+  def test_map_range
+
+    # NOTE the following effectively tests Utils::RangeFunctions as well
+
+    assert_kind_of Float, @drp_obj.map(0..1)
+    assert_kind_of Float, @drp_obj.map(0.0..1.0) 
+
+    single_codon 0.0
+
+    # linear function tests
+    r = @drp_obj.map 0..1
+    assert_equal r, 0.0
+
+    r = @drp_obj.map 1..0
+    assert_equal r, 1.0
+    r = @drp_obj.map -12.3..12.3
+    assert_equal r, -12.3
+    r = @drp_obj.map 12.3..-12.3
+    assert_equal r, 12.3
+
+    single_codon 0.5
+
+    # linear function tests
+    r = @drp_obj.map 0..1
+    assert_equal r, 0.5
+    r = @drp_obj.map 1..0
+    assert_equal r, 0.5
+    r = @drp_obj.map -12.3..12.3
+    assert_equal r, 0
+    r = @drp_obj.map 12.3..-12.3    
+    assert_equal r, 0
+
+    single_codon 1.0
+
+    # linear function tests
+    r = @drp_obj.map 0..1
+    assert_equal r, 1.0
+    r = @drp_obj.map 1..0
+    assert_equal r, 0.0
+    r = @drp_obj.map -12.3..12.3
+    assert_equal r, 12.3
+    r = @drp_obj.map 12.3..-12.3
+    assert_equal r, -12.3
+
+  end
+
+  def test_map_block
+
+    num_codons = 10
+    codons = Array.new(num_codons) { rand }
+    set_codons codons
+    
+    # assert_nil(codons.detect { |c| c >= 1.0 || c < 0.0 })
+    identity = proc { |x| x }
+    no_params = proc {}
+    local = codons.collect &identity
+    mapped = []
+
+    num_codons.times do
+      mapped << @drp_obj.map(&identity)
+    end
+
+    assert_equal local, mapped
+
+    # test multiple params
+    set_codons [1,2,3]
+    r = @drp_obj.map { |a,b,c,d| [a,b,c,d] }
+    assert_equal [1,2,3,1], r
+
+    assert_raise(ArgumentError) { @drp_obj.map &no_params }
+
+    # should not accept args and block
+    assert_raise(ArgumentError) { @drp_obj.map 0..1, &identity }
+    assert_raise(ArgumentError) { @drp_obj.map 0..1, :linear,  &identity }
+
+  end
+
+  def single_codon codon
+    @drp_obj.codons = [codon]
+  end
+  def set_codons codons
+    @drp_obj.codons = codons
+  end
+
+end