vcs 0.1 → 0.2.148

data/ruby_ex/abstract.rb

@@ -0,0 +1,254 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: abstract.rb 210 2005-05-05 19:59:45Z ertai $
+
+
+#FIXME: find a way to be thread safe.
+
+
+require 'module/instance_method_visibility'
+
+
+module Concrete; end
+
+
+# When this module is included into a class, this class can't be instantiate
+# any more until the Concrete module is included too. This module cannot be
+# included if the Concrete module has been included before in one of the
+# class' superclass.
+module Abstract
+
+  def self.included(klass)
+    super
+    if klass.include?(Concrete)
+      raise(TypeError, "#{klass} - cannot make abstract a concrete class")
+    end
+    klass.module_eval do
+      class << self
+        unless private_method_defined?(:concrete_new)
+          alias_method :concrete_new, :new
+          visibility = instance_method_visibility('new')
+          def new(*args, &block)
+            raise(TypeError, "cannot instantiate an abstract class #{name}")
+          end
+          send(visibility, :new)
+          private :concrete_new
+        end
+      end
+    end
+  end
+
+end # module Abstract
+
+
+# Include this module in an abstract class to make it concrete and so, to be
+# able to instantiate it again. This module can be included if and only if the
+# Abstract module has been included before in one of the class' superclass.
+module Concrete
+
+  def self.included(klass)
+    super
+    unless klass.include?(Abstract)
+      raise(TypeError, "#{klass} - not an abstract class")
+    end
+    klass.module_eval do
+      class << self
+        visibility = instance_method_visibility('new')
+        def new(*args, &block)
+          concrete_new(*args, &block)
+        end
+        send(visibility, :new)
+      end
+
+      def is_a?(klass)
+        klass == Abstract ? false : super(klass)
+      end
+    end
+  end
+
+end # module Concrete
+
+
+class Class
+
+  def abstract
+    include Abstract
+  end
+
+  def concrete
+    include Concrete
+  end
+
+  def abstract?
+    include?(Abstract) ? (not include?(Concrete)) : false;
+  end
+
+end # class Class
+
+
+if (not defined? ABSTRACT_TESTED) and (defined? TEST_MODE or __FILE__ == $0)
+ABSTRACT_TESTED = true
+
+
+require 'test/unit/ui/yaml/testrunner'
+require 'singleton'
+
+
+class AbstractTest < Test::Unit::TestCase
+
+  class R; end
+
+  class A
+    include Abstract
+
+    attr_reader :initialized
+
+    def initialize(toto=nil)
+      @initialized = true
+    end
+
+  end
+
+  class B < A; end
+
+  def test_abstract
+    assert_nothing_raised { R.new }
+    assert(A.include?(Abstract))
+    assert_raises(TypeError) { A.new }
+    assert_raises(TypeError) { B.new }
+    assert_raises(TypeError) do
+      AbstractTest.module_eval %q{
+        class D
+          include Concrete
+          include Abstract
+        end
+      }
+    end
+  end
+
+  class C < A
+    include Concrete
+
+    attr_reader :toto
+
+    def initialize(toto=nil)
+      super
+      @toto = toto
+    end
+  end
+
+  class CC < C; end
+
+  def test_concrete
+    assert_raises(TypeError) do
+      AbstractTest.module_eval %q{ class D; include Concrete; end }
+    end
+    assert(C.new.initialized)
+    assert_nil(C.new.toto)
+    assert_equal('toto', C.new('toto').toto)
+    assert(CC.new.initialized)
+    assert_equal(SC.instance, SC.instance)
+    assert_equal(SCC.instance, SCC.instance)
+    assert_not_equal(SC.instance, SCC.instance)
+  end
+
+  class SA
+    include Singleton
+    include Abstract
+
+    attr_reader :initialized
+
+    def initialize(toto=nil)
+      @initialized = true
+    end
+
+  end
+
+  class SB < SA; end
+
+  def test_abstract_singleton
+    assert(SA.include?(Abstract))
+    assert_raises(NoMethodError) { SA.new }
+    assert_raises(TypeError) { SA.instance }
+    assert_raises(NoMethodError) { SB.new }
+    assert_raises(TypeError) { SB.instance }
+    assert_raises(TypeError) do
+      AbstractTest.module_eval %q{
+        class SD; include Concrete; include Abstract; end
+      }
+    end
+  end
+
+  class SC < SA
+    include Concrete
+
+  end
+
+  class SCC < SC; end
+
+  def test_concrete_singleton
+    assert_raises(TypeError) do
+      AbstractTest.module_eval %q{ class SD; include Concrete; end }
+    end
+    assert_raises(NoMethodError) { SC.new }
+    assert(SC.instance.initialized)
+    assert(SCC.instance.initialized)
+    assert_equal(SC.instance, SC.instance)
+    assert_equal(SCC.instance, SCC.instance)
+    assert_not_equal(SC.instance, SCC.instance)
+  end
+
+  class IsA; include Abstract; end
+  class IsB < IsA; include Concrete; end
+
+  def test_is_a
+    assert(! IsB.new.is_a?(Abstract))
+    assert(IsB.new.is_a?(IsA))
+    assert(IsB.include?(Abstract))
+  end
+
+  def test_abstract?
+    assert(IsA.abstract?)
+    assert(! IsB.abstract?)
+  end
+
+  class AArg
+    include Abstract
+
+    attr_reader :arg
+
+    def initialize(arg)
+      @arg = arg
+    end
+
+  end
+
+  class CArg < AArg
+    include Concrete
+  end
+
+  def test_arg
+    assert_nothing_raised { CArg.new('toto') }
+    assert_raises(ArgumentError) { CArg.new }
+  end
+
+  class AA_; include Abstract; end
+  class BB_ < AA_; include Abstract; end
+  class CC_ < BB_; include Concrete; end
+  class DD_ < CC_; include Concrete; end
+
+  def test_double_abstract
+    assert_raises(TypeError) { AA_.new }
+    assert_raises(TypeError) { BB_.new }
+    assert_nothing_raised { CC_.new }
+    assert_nothing_raised { DD_.new }
+  end
+
+end # class AbstractTest
+
+
+end
+

data/ruby_ex/abstract_node.rb

@@ -0,0 +1,85 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: abstract_node.rb 186 2005-04-03 00:07:45Z ertai $
+
+
+require 'abstract'
+require 'array_each_pair'
+
+class AbstractNode
+  include Abstract
+
+  def initialize(data=nil, *sub_nodes)
+    @data = data
+    self.each_node { |sub_node| check_sub_node_type(sub_node) }
+  end
+
+  attr_reader :data, :sub_nodes
+
+  def [](index)
+    @sub_nodes[index]
+  end
+
+  def []=(index, sub_node)
+    check_sub_node_type(sub_node)
+    @sub_nodes[index] = sub_node
+  end
+
+  def merge!(sub_nodes)
+    sub_nodes.each { |index, sub_node| self[index] = sub_node }
+  end
+
+  def each_pair(&block)
+    @sub_nodes.each_pair { |index, sub_node| block[index, sub_node] }
+  end
+
+  def each_node(&block)
+    @sub_nodes.each_pair { |index, sub_node| block[sub_node] }
+  end
+
+  alias :each :each_node
+
+  def each_index(&block)
+    @sub_nodes.each_pair { |index, sub_node| block[index] }
+  end
+
+  def delete(index)
+    @sub_nodes.delete(index)
+  end
+
+  def nb_sub_nodes
+    @sub_nodes.size
+  end
+
+  alias size nb_sub_nodes
+  alias length nb_sub_nodes
+
+  def leaf?
+    @sub_nodes.empty?
+  end
+
+  def pre_depth_first(index=nil, &block)
+    block[index, self]
+    @sub_nodes.each_pair do |index, sub_node|
+      sub_node.pre_depth_first(index, &block)
+    end
+    nil
+  end
+
+#   FIXME: implement me
+#   def breadth_first(&block)
+#   end
+
+  protected
+  def check_sub_node_type(sub_node)
+    unless sub_node.is_a?(self.class)
+      raise(TypeError, "`#{sub_node}' - must be a #{self.class}")
+    end
+  end
+
+end # class AbstractNode
+
+

data/ruby_ex/algorithms/simulated_annealing.rb

@@ -0,0 +1,140 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id$
+
+require 'string_ex'
+
+module Algorithms
+
+  class SimulatedAnnealing
+  
+    # Example:
+    #
+    #   obj = MySimulatedAnnealingObject.new
+    #
+    #   SimulatedAnnealing.new(
+    #     :support             => obj,
+    #     :global_thresold     => 200,
+    #     :step_multiplicator  => 0.63,
+    #     :initial_temperature => 10,
+    #     :initial_cost        => obj.cost,
+    #     :iteration_modulus   => 500,      # display status once a 500
+    #     :step_modulus        => 5000      # change the temperature once a 5000
+    #   )
+    #
+    def initialize ( opts )
+      @support = opts[:support]
+      @global_thresold = opts[:global_thresold]
+      @step_multiplicator = opts[:step_multiplicator]
+      @temperature = opts[:initial_temperature]
+      @cur_cost = opts[:initial_cost]
+      @output = opts[:output] || STDOUT
+      @iteration_modulus = opts[:iteration_modulus] || 1
+      @step_modulus = opts[:step_modulus] || 1
+      @progression = ' '
+      @diff_cost = 0
+      @iteration = 0
+      @probability_threshold = 0
+    end
+  
+  
+    def run
+      @output.puts '---'
+      while @cur_cost > @global_thresold
+        # puts "Iteration(#{it}) #{@cur_cost}"
+        @transition = @support.choose_transition()
+        @diff_cost = @support.transition_cost(@cur_cost, @transition)
+        
+        @iteration += 1
+        if (@iteration % @step_modulus).zero?
+          @temperature *= @step_multiplicator 
+        end
+
+        if @diff_cost > 0
+          @probability_threshold = Math.exp(- @diff_cost.to_f / @temperature)
+          @proba = choose_probability()
+          if @proba < @probability_threshold
+            progression '+'
+          else
+            progression ' '
+            next
+          end
+        else
+          @probability_threshold = 1
+          @proba = 1
+          progression((@diff_cost.zero?)? '=' : '-')
+        end
+
+        @support.apply_transition(@transition)
+        @cur_cost += @diff_cost
+      end
+    end
+  
+  
+    def disp ( output=@output )
+      args = [ @progression, @diff_cost.abs, @temperature,
+               @proba, @probability_threshold, @cur_cost ]
+      fmt = '- { diff: %s%-7d, temp: %-4f, ' +
+                'prob: %-7f, thres: %-7f, cost: %-5s }'
+      output.puts fmt % args
+    end
+  
+  
+    def summary
+      @output.puts %Q[
+        |---
+        |Found a mininum: #@cur_cost
+        |Temperature at the end: #@temperature
+        |Nb iterations: #@iteration
+      ].head_cut!
+    end
+  
+  
+    def progression ( x )
+      @progression = x
+      disp if (@iteration % @iteration_modulus).zero?
+    end
+  
+  
+    def choose_probability
+      rand()
+    end
+  
+  
+    module Support
+  
+      def included ( aModule )
+  
+        aModule.module_eval do
+  
+          #
+          # Return a transition which can be applied by apply_transition.
+          #
+          def choose_transition
+            raise NotImplementedError
+          end
+  
+          #
+          # Return a cost difference
+          #
+          def transition_cost ( current_cost, transition )
+            raise NotImplementedError
+          end
+  
+          #
+          # Apply the given transition to your current object.
+          #
+          def apply_transition ( transition )
+            raise NotImplementedError
+          end
+  
+        end
+  
+      end
+  
+    end # module Support
+  
+  end # class SimulatedAnnealing
+
+end # module Algorithms