vcs 0.2.148 → 0.3.0

data/ruby_ex/abstract.rb

@@ -1,254 +0,0 @@
-# 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

@@ -1,85 +0,0 @@
-# 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

@@ -1,140 +0,0 @@
-# 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