drp 0.0.6

data/lib/instance_methods.rb

@@ -0,0 +1,154 @@
+
+=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 InstanceMethods
+
+    # this is called when all rule methods are exhausted
+    # during the selection process. by default returns nil.
+    # you can override this in your extended class, 
+    # but as a regular method
+    # not a rule method to have non-nil value returned, but
+    # be sure to accept an array of *args or have the arity
+    # correct to handle all your rule methods.
+    def default_rule_method *args; end
+
+=begin
+    # EXTRANEOUS, CAN JUST BE DONE IN :initialize METHOD
+    # this is called automatically for you after
+    # your objects are initialized but before any codons
+    # are used to set weights depths etc..
+    # it does nothing by default
+    def init_codons; end
+=end
+
+    # you should reimplement this method in your
+    # extended class, that is unless you want the
+    # default behaviour of an endless random stream.
+    # this is included mostly for quick testing purposes
+    def next_codon
+      rand
+    end
+
+    # this is what weights and max_depths use to get codons.
+    # it defaults to just using next_codon. override it in
+    # your extended class to have them use a separate codon stream
+    def next_meta_codon
+      next_codon
+    end
+
+    # how deep is the current rule method's recursion
+    def depth
+      @__drp__depth__stack.last
+    end
+
+    # what is the maximum depth attainable by the current rule method.
+    # do not confuse this with the class method setter
+    def max_depth
+      @__drp__rule__method__stack.last.max_depth
+    end
+
+    # don't know if these two are really worth implementing 
+    # how many time has the current rule method executed
+    # including this execution
+    #def count
+    #  @__drp__count__stack.last
+    #end
+    # how many times has the current rule (all rule methods) 
+    # executed including this execution
+    # def rule_count
+    # end
+    
+    # uses next_codon to output to somewhere within the range
+    # specified using specified function, unless a block is given
+    # in which case it counts the formal parameters to the block,
+    # and yields appropriate number of codons using next_codon
+    # you may not pass both a block and a range, only one or the other
+    def map rng = nil, function = :linear, &b # :yields: next_codon ... 
+      if block_given?
+        if rng
+          raise ArgumentError, "both block and #{rng} passed to map", caller
+        end
+        arity = b.arity
+        case arity
+          # these are here, and also ordered, for efficiencies sake
+          when 1
+            yield next_codon
+          when 2
+            yield next_codon, next_codon
+          when 0, -1
+            raise ArgumentError, 'block given to map must have 1 or more arguments', caller
+          else
+            yield *Array.new(arity) { next_codon }
+        end
+      else
+        Utils::map rng, next_codon, function
+      end
+    end
+    
+   private
+
+    def __drp__choose__method useable_methods
+
+      weights = useable_methods.collect do |meth|
+        meth.weight
+      end
+      scale_by = weights.inject(0) do |weight, prev|
+        prev + weight
+      end
+
+      weights = if scale_by == 0
+        sz = weights.size
+        weight = 1.0/sz
+        prev_weight = 0
+        Array.new(sz) do 
+          prev_weight = weight + prev_weight
+        end
+      else
+        prev_weight = 0
+        weights.collect do |weight|
+          prev_weight = weight / scale_by + prev_weight
+        end
+      end
+     
+      index, codon = -1, next_codon
+      weights.detect do |weight| 
+        index += 1;
+        codon < weight
+      end
+
+      useable_methods[index]
+
+    end
+
+    def __drp__call__method meth, args
+      @__drp__depth__stack.push(meth.depth + 1)
+      @__drp__rule__method__stack.push meth
+      res = meth.call *args
+      @__drp__rule__method__stack.pop
+      @__drp__depth__stack.pop
+      res
+    end
+
+  end
+
+end # module DRP

data/lib/pso.rb

@@ -0,0 +1,178 @@
+
+=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 SearchAlgorithms
+module PSO
+
+VERY_LARGE_NUMBER = 2**29
+
+class AbstractParticleSwarmOptimizer
+
+  attr_reader :global_best_error, :global_best_vector
+
+  def initialize swarm_size, vector_size
+    @swarm_size, @vector_size = swarm_size, vector_size
+  end
+
+ private
+
+  # must be called by subclass initialize methods
+  def init_particles particle_class
+    @particles = Array.new(@swarm_size) { particle_class.new(self,@vector_size) }
+    set_as_global_best @particles[rand(@swarm_size)] 
+  end
+
+  def set_as_global_best particle
+    @global_best_vector = particle.vector.dup
+  end
+
+end
+
+class InteractiveParticle
+
+  attr_accessor :vector
+
+  def initialize pso, vector_size
+    @pso, @vector_size = pso, vector_size
+    init_vector
+  end
+
+  def set_as_best
+    @best_vector = @vector.dup
+  end
+  def set_as_global_best
+    @pso.set_as_global_best self
+  end
+
+  def roam
+    gbest = @pso.global_best_vector
+    @vector_size.times do |i|
+      c = @vector[i]
+      pbest = @best_vector[i]
+      @vector[i] = c + 2 * rand * pbest - c + 2 * rand * gbest[i] - c
+    end
+  end
+
+  def init_vector 
+    @vector = Array.new(@vector_size) { rand }
+    set_as_best
+  end
+
+=begin
+  def save name
+    
+  end
+  def load name
+    if @thawed
+      # ...
+    end
+  end
+
+  def freeze; @thawed = false end
+  def thaw; @thawed = true end
+  def frozen? !@thawed end
+=end
+end
+
+class InteractiveParticleSwarmOptimizer < AbstractParticleSwarmOptimizer
+
+  attr_reader :particles
+
+  def initialize swarm_size, vector_size, rebirth = 0.0
+    super
+    init_particles InteractiveParticle
+  end
+  def each
+    @particles.each do |p|
+      yield p
+    end
+  end
+  def roam_all
+    each { |p| p.roam }
+  end
+  def reinit_all
+    each { |p| p.init_vector }
+  end
+
+end
+
+class Particle < InteractiveParticle
+  def initialize pso, vector_size
+    @best_error = VERY_LARGE_NUMBER
+    super
+  end
+  def optimize error
+    if error < @best_error
+      @best_error = error
+      set_as_best
+    end
+  end
+end
+
+class ParticleSwarmOptimizer < AbstractParticleSwarmOptimizer
+
+  def initialize swarm_size, vector_size, rebirth = 0.0
+    @global_best_error = VERY_LARGE_NUMBER
+    @num_reborn = (swarm_size * rebirth).to_i
+    @rebirth_index = 0
+    super swarm_size, vector_size
+    init_particles Particle    
+  end
+
+  def each
+    rebirth
+    best_this_time = VERY_LARGE_NUMBER
+    @particles.each do |p|
+      v = p.vector
+      error = yield v
+      if error < @global_best_error
+        @global_best_vector = v.dup
+        @global_best_error = error
+      end
+      if error < best_this_time
+        best_this_time = error
+      end
+      p.optimize error
+      p.roam
+    end
+    #puts best_this_time
+  end
+
+ private
+
+  # my non-standard addition to pso algorithm
+  # the idea being brutal removal from local optima.
+  # cycles through particles to give the reborn
+  # a chance to roam a bit before being reborn yet again.
+  def rebirth
+    @num_reborn.times do
+      @rebirth_index = 0 if @rebirth_index == @swarm_size
+      @particles[@rebirth_index].init_vector
+      @rebirth_index += 1
+    end 
+  end
+
+end
+
+end # module PSO
+end # module SearchAlgoritms
+end # module DRP

data/lib/rule_engine.rb

@@ -0,0 +1,324 @@
+
+=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
+
+class RuleMethod
+
+  attr_reader :depth, :max_depth
+
+  def initialize drp_instance, method_name, weight_factory, max_depth
+    @method = drp_instance.method method_name
+    @max_depth = max_depth.value drp_instance
+    @weight = weight_factory.call self, drp_instance
+    @depth = 0
+  end
+
+  def expressed? 
+    @depth < @max_depth
+  end
+
+  def call *args
+    @depth += 1
+    result = @method.call *args
+    @depth -= 1
+    result
+  end
+
+  def weight
+    @weight.value
+  end
+
+end
+
+module RuleEngine
+
+  def new *a, &b 
+    super.__drp__init
+  end
+
+ private
+
+  def self.extend_object klass
+    DRPNameClashError.test(klass) if DEFAULT[:test_for_extend_name_clashes]
+    klass.class_eval do
+      include InstanceMethods
+    end
+    super
+  end
+
+  def method_added name
+    # explicit boolean test because can also be :finished
+    if @__drp__defining_rules == true
+
+      rule = @__drp__rules[name] ||= []
+
+      # to stop recursion of method_added due to alias which calls it
+      @__drp__defining_rules = false 
+      class_eval "private :#{name}; alias __drp__#{name}__#{rule.size} #{name}"
+      @__drp__defining_rules = true
+      
+      # note this comes after class_eval cuz of ref to rule.size there
+      rule << [@__drp__weights.last, @__drp__max__depths.last]
+
+    end
+  end
+
+ # TODO find way of making rdoc document these even if they are private
+ public
+
+  def begin_rules
+    # if it is true or :finished, see end_rules & method_added
+    if @__drp__defining_rules 
+      raise DRPError, 'begin rules may only be called once'
+    else
+      @__drp__rules = {}
+      @__drp__defining_rules = true
+      @__drp__weights = []
+      @__drp__max__depths = []
+      # NB max_depth should come first here in case user changes
+      # the default to some weight which needs to know the max_depth
+      max_depth DEFAULT[:max_depth]
+      weight DEFAULT[:weight]
+    end
+  end
+
+  # NB the two methods defined via define_method in end_rules
+  # will be instance methods in instances of classes which 
+  # are extended by this module. they are here because they
+  # are closures referencing the 'name' and 'all_methods' 
+  # variables respectively. 
+  # other non-closure methods are in module InstanceMethods
+
+  def end_rules
+
+    @__drp__defining_rules = :finished
+
+    all_methods = {}
+
+    @__drp__rules.each do |name, weights_and_max_depths|
+
+      methods = []
+
+      weights_and_max_depths.each_with_index do |w_md, i|
+        methods.push ["__drp__#{name}__#{i}"] + w_md
+      end
+
+      all_methods[name] = methods
+
+      define_method name do |*args|
+
+        useable_methods = @__drp__rule__methods[name].select do |meth|
+          meth.expressed?
+        end
+
+        case useable_methods.size
+
+          when 0
+          default_rule_method *args          
+
+          when 1
+          __drp__call__method(useable_methods.first, args)
+
+          else
+          __drp__call__method(__drp__choose__method(useable_methods), args)
+
+        end
+        
+      end # define_method name do
+
+
+    end # @__drp__rules.each do
+
+    define_method :__drp__init do
+
+      @__drp__rule__methods = {}
+      @__drp__depth__stack = []
+      @__drp__rule__method__stack = []
+
+      all_methods.each do |name, arg_array|
+        @__drp__rule__methods[name] = arg_array.collect do |args|
+          RuleMethod.new self, *args
+        end
+      end
+
+      self
+
+    end
+
+  end # end_rules
+
+=begin rdoc
+
+sets the maximum obtainable depth of the rule methods which follow it
+in the listing. max_depths are set for each instance of the class you
+extended with DRP::RuleEngine upon initialization (or when you call init_drp),
+once and only once, and remains set to that static value. max depths are always
+integer values.
+
+it may be used in any of the following four ways:
+
+*scalar*, all following rule_methods are set to given value
+
+ max_depth 1                
+                   
+*range*, each following rule_method is initialized to some integer
+from range.start to range.end inclusive using a linear mapping
+of a codon gotten via the method next_meta_codon.
+
+ max_depth 1..2             
+
+same as the previous but uses the function given, at present
+the only function implemented is i_linear (integer linear),
+which is the default action when no function is given, so at 
+present this is useless.
+
+ max_depth 1..2, :function
+
+*block*, each following rule_method is initialized to some integer
+given by your block. the formal parameters to your supplied
+block are counted, and the appropriate number of codons harvested using
+InstanceMethods#next_meta_codon are passed to the block.
+
+ max_depth { |next_meta_codon, ...| ... }
+ 
+see example_2.rb
+
+=end
+
+  def max_depth *args, &block
+    
+    sz = args.size
+    are_args = sz > 0
+    md = nil
+    
+    if block_given?
+      if are_args
+        raise ArgumentError, 'max_depth called with both arguments and a block', caller
+      else
+        md = MaxDepths::ProcMaxDepth.new(block)
+      end
+    else
+      case sz
+      when 1
+        arg = args[0]
+        case arg
+        when Numeric
+          md = MaxDepths::StaticMaxDepth.new arg.to_i
+        when Range
+          md = MaxDepths::MappedMaxDepth.new arg
+        else
+          raise ArgumentError, 'bad argument to max_depth', caller
+        end
+      when 2
+        arg1, arg2 = args
+        if (arg1.kind_of? Range) && (arg2.kind_of? Symbol)
+          md = MaxDepths::MappedMaxDepth.new arg1, arg2
+        else
+          raise ArgumentError, 'bad argument to max_depth', caller
+        end
+      else 
+        raise ArgumentError, "too many (#{sz}) args passed to max_depth", caller
+      end # case sz
+    end # if block_given
+
+    @__drp__max__depths << md
+
+  end # def max_depth
+
+=begin rdoc
+
+sets the weight of the rule methods which follow it
+in the listing, and may be used in any of the following four ways:
+
+*scalar*, all following rule_methods are set to given value
+
+max_depth 1                
+                   
+*range*, each following rule_method is initialized to some integer
+from range.start to range.end inclusive using a linear mapping
+of a codon gotten via the method next_meta_codon when your
+extended object is initialized via drp_init.
+
+max_depth 1..2             
+
+same as the previous but uses the function given, at present
+the only function implemented is i_linear (integer linear),
+which is the default action when no function is given, so at 
+present this is useless.
+
+max_depth 1..2, :function
+
+*block*, each following rule_method is initialized to some integer
+given by your block upon a call to drp_init, i.e. when you initialize
+your extended object instance. the formal parameters to your supplied
+block are counted, and the appropriate number of codons harvested using
+InstanceMethods#next_meta_codon are passed to the block.
+
+max_depth { |next_meta_codon, ...| ... }
+                         
+=end
+
+
+  def weight *args, &block
+    bg, are_args = block_given?, args.size > 0
+    if bg && are_args
+      raise ArgumentError, 'weight called with both arguments and a block', caller
+    elsif bg
+      @__drp__weights << Weights::ProcStaticWeight.factory(block)
+    elsif are_args
+      @__drp__weights << Weights::StaticWeight.factory(args)
+    else
+      raise ArgumentError, 'weight called with neither args nor block', caller
+    end 
+  end
+
+=begin NOT REALLY USEFUL
+  def weight_dyn *args, &block
+    bg, are_args = block_given?, args.size > 0
+    if bg && are_args
+      __drp__error "weight_dyn called with both args and block"
+    elsif bg
+      @__drp__weights << Weights::ProcDynamicWeight.factory(block)
+    elsif are_args
+      @__drp__weights << Weights::DynamicWeight.factory(args)
+    else
+      raise ArgumentError, 'weight_dyn called with neither args nor block', caller
+    end 
+  end
+=end
+
+  def weight_fcd *args, &block
+    bg, are_args = block_given?, args.size > 0
+    if bg && are_args
+      __drp__error "weight_fcd called with both args and block"
+    elsif bg
+      @__drp__weights << Weights::ProcWeightFromCurrentDepth.factory(block)
+    elsif are_args
+      @__drp__weights << Weights::WeightFromCurrentDepth.factory(args)
+    else
+      raise ArgumentError, 'weight_fcd called with neither args nor block', caller
+    end 
+  end
+
+end # class RuleEngine
+
+end # module DRP