ruby_ex 0.1.1

data/src/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 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_ex'
+require 'abstract'
+
+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/src/algorithms.rb

@@ -0,0 +1,12 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: algorithms.rb 258 2005-06-01 00:22:51Z ertai $
+
+require 'module/autoload_tree'
+
+module Algorithms
+
+  autoloaded_module(__FILE__)
+
+end # module Algorithms

data/src/algorithms/simulated_annealing.rb

@@ -0,0 +1,142 @@
+# 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 'ruby_ex'
+require 'choose'
+
+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
+      @generator = opts[:generator]
+      @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(@generator)
+        @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(@generator)
+          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 ( generator=nil )
+      1.0.choose(generator)
+    end
+  
+  
+    module Support
+  
+      def included ( aModule )
+  
+        aModule.module_eval do
+  
+          #
+          # Return a transition which can be applied by apply_transition.
+          #
+          def choose_transition ( generator=nil )
+            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

data/src/ask.rb

@@ -0,0 +1,100 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id: ask.rb 266 2005-06-01 14:27:18Z ertai $
+
+require 'ruby_ex'
+
+ANSWERS = [ :y, :n ]
+ANSWER_NOT_VALID = 'Not a valid answer, please answer correctly'
+
+# `ask', ask the user to answer, to your question.
+#
+# Example:
+#   ask('Commiting, are you sure', :n)
+#
+#   produce => Commiting, are you sure (y/N): 
+#   and wait your answer.
+def ask ( aQuestion, theDefaultAnswer=:y, cin=STDIN, cout=STDOUT, cerr=STDERR )
+  
+  yn = case theDefaultAnswer
+       when :y then ' [Y/n]: '
+       when :n then ' [y/N]: '
+       else raise ArgumentError, "not valid default answer #{theDefaultAnswer}"
+       end
+
+  loop do
+    cout.print aQuestion, yn
+    cout.flush
+
+    answer = cin.readline.chomp.downcase
+    
+    return theDefaultAnswer if answer.empty?
+
+    answer = answer.to_sym
+
+    return answer if ANSWERS.include? answer
+
+    cerr.puts ANSWER_NOT_VALID
+    cout.puts
+  end
+
+end
+
+test_section __FILE__ do
+
+class AskTest < Test::Unit::TestCase
+
+  def ask_checker ( question, default, answer, ref, out, err )
+    require 'stringio'
+    cin, cout, cerr = StringIO.new, StringIO.new, StringIO.new
+    cin.puts answer
+    cin.rewind
+    res = ask(question, default, cin, cout, cerr)
+    cout.rewind
+    cerr.rewind
+    assert_equal(res, ref, 'bad return value')
+    assert_equal(cout.readlines.join, out, 'bad standard output')
+    assert_equal(cerr.readlines.join, err, 'bad error output')
+  end
+
+  def test_bad_default
+    assert_raise(ArgumentError) { ask_checker('Q', :foo, '', :y, [], []) }
+    assert_nothing_raised do
+      ask_checker('Q', :y, 'y', :y, 'Q [Y/n]: ', '')
+    end
+    assert_nothing_raised do
+      ask_checker('Q', :n, 'y', :y, 'Q [y/N]: ', '')
+    end
+  end
+
+  def test_valid_default_yes
+    ask_checker('Q', :y, 'y', :y, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, 'Y', :y, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, 'n', :n, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, 'N', :n, 'Q [Y/n]: ', '')
+    ask_checker('Q', :y, '',  :y, 'Q [Y/n]: ', '')
+  end
+
+  def test_valid_default_no
+    ask_checker('Q', :n, 'y', :y, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, 'Y', :y, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, 'n', :n, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, 'N', :n, 'Q [y/N]: ', '')
+    ask_checker('Q', :n, '',  :n, 'Q [y/N]: ', '')
+  end
+
+  def test_invalid_answer
+    ask_checker('Q', :n, "bad\ny", :y,
+                "Q [y/N]: \nQ [y/N]: ", ANSWER_NOT_VALID + "\n")
+    ask_checker('Q', :y, "ad\n\n", :y,
+                "Q [Y/n]: \nQ [Y/n]: ", ANSWER_NOT_VALID + "\n")
+  end
+
+  def test_ask1
+    ask_checker('Q', :y, 'y', :y, 'Q [Y/n]: ', '')
+  end
+
+end # class AskTest
+
+end

data/src/attributed_class.rb

@@ -0,0 +1,303 @@
+# Copyright:: Copyright (c) 2004, 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: attributed_class.rb 266 2005-06-01 14:27:18Z ertai $
+
+
+require 'ruby_ex'
+
+# Extension to have inherited, class attributes,
+# Where each class have his own attributes set.
+module AttributedClass
+
+  class Attribute
+
+    attr_reader :name, :descr, :klass, :default_proc
+    attr_accessor :default
+
+    @@default_proc = nil
+
+    def initialize ( name, descr, *args, &block )
+      raise ArgumentError, 'need a symbol' unless name.is_a? Symbol
+      @name, @descr = name, descr
+      @default, @klass = nil, nil
+      @mandatory = false
+      @visible = true
+      if block_given?
+        @default_proc = block
+      else
+        @default_proc = @@default_proc
+      end
+      other = []
+
+      args.each do |arg|
+        case arg
+        when :mandatory then @mandatory = true
+        when :invisible then @visible = false
+        else other << arg
+        end
+      end
+
+      case other.size
+      when 1
+        if other[0].is_a? Class
+          @klass = [other[0]]
+        elsif other[0].is_a? Array and other[0].all? { |k| k.is_a? Class }
+          @klass = other[0]
+        else
+          @default = other[0]
+        end
+      when 2
+        a, b = other
+        if a.is_a? Class and b.is_a? a
+          @klass, @default = [a], b
+        elsif a.is_a? Array and
+              a.all? { |k| k.is_a? Class } and
+              a.any? { |k| b.is_a? k }
+          @klass, @default = a, b
+        elsif b.is_a? Class and a.is_a? b
+          @klass, @default = [b], a
+        elsif b.is_a? Array and
+              b.all? { |k| k.is_a? Class } and
+              b.any? { |k| a.is_a? k }
+          @klass, @default = b, a
+        else
+          raise ArgumentError, 'need a Class and a default value'
+        end
+      when 0
+      else raise ArgumentError, 'too many values'
+      end
+
+      # removed because it causes some probleme when distributed such a class
+      #[@name, @descr, @default].each { |x| x.freeze }
+    end
+
+    def visible?
+      @visible
+    end
+
+    def invisible?
+      !@visible
+    end
+
+    def mandatory?
+      @mandatory
+    end
+
+    def valid? ( anObject )
+      return false if mandatory? and anObject.nil?
+      @klass.nil? or @klass.empty? or @klass.any? { |k| anObject.is_a? k }
+    end
+
+
+    def self.set_default_proc ( &block )
+      @@default_proc = block
+    end
+      
+    
+    def help ( output=STDERR )
+      output << "#@name: #@descr"
+      output << " [#@klass]" unless @klass.nil?
+      other = []
+      other << 'mandatory' if mandatory?
+      other << 'invisible' if invisible?
+      output << " (#{other.join(', ')})" unless other.empty?
+      output
+    end
+
+    def inspect
+      help('#<') + '>'
+    end
+
+  end # class Attribute
+
+
+  class MethodAttribute < Attribute
+    VISIBILITIES = [ :private, :protected, :public, :unknown ]
+    attr_reader :visibility
+    def private?
+      @visibility == :private
+    end
+    def protected?
+      @visibility == :protected
+    end
+    def public?
+      @visibility == :public
+    end
+    def initialize ( name, descr, *args )
+      vis = args.find { |arg| VISIBILITIES.include? arg }
+      args.delete(vis) unless vis.nil?
+      @visibility = vis || :unknown
+      super(name, descr, *args)
+    end
+  end # class MethodAttribute
+
+
+  class AttributeError < Exception
+
+    def initialize ( anObject, anAttr, val=nil )
+      if val.nil?
+        super "Missing the #{anAttr.name} attribute for `#{anObject}'"
+      else
+        super "Attribute #{anAttr.name} wait for a `#{anAttr.klass}' not " +
+              "`#{val}' in #{anObject}"
+      end
+    end
+
+  end # class AttributeError
+
+
+  def self.included ( aClass )
+
+    aClass.module_eval do
+
+      def initialize_attributes ( *default_proc_args )
+        self.class.attributes.each do |attr|
+          next if attr.is_a? MethodAttribute
+          if attr.default_proc.nil? and attr.default.nil?
+            instance_variable_set("@#{attr.name}", nil)
+          else
+            unless attr.default_proc.nil?
+              pr = attr.default_proc
+              if pr.arity == default_proc_args.size
+                default = pr[*default_proc_args]
+              else
+                default = pr[attr, *default_proc_args]
+              end
+              attr.default = default
+            end
+            send "#{attr.name}=", attr.default
+          end
+        end
+      end
+
+      def self.set_default_proc ( &block )
+        Attribute.set_default_proc(&block)
+      end
+
+      def each_attribute ( &block )
+        self.class.attributes.each do |attr|
+          block[attr, send(attr.name)]
+        end
+      end
+
+      def each_variable_attribute ( &block )
+        self.class.attributes.each do |attr|
+          next if attr.is_a? MethodAttribute
+          block[attr, send(attr.name)]
+        end
+      end
+
+      def each_method_attribute ( &block )
+        self.class.attributes.each do |attr|
+          next unless attr.is_a? MethodAttribute
+          block[attr, send(attr.name)]
+        end
+      end
+
+      def check_attribute ( attr, anObject )
+        unless attr.valid? anObject
+          raise AttributeError.new(self, attr, anObject)
+        end
+      end
+
+      def check_attributes
+        each_variable_attribute(&method(:check_attribute))
+      end
+
+      def self.help ( output=STDERR )
+        output.puts "#{self.to_s}:"
+        attributes.each do |attr|
+          output << '  '
+          attr.help(output)
+          output.puts '.'
+        end
+      end
+
+      def self.attributes
+        unless defined? @attributes
+          if superclass and superclass.respond_to? :attributes
+            @attributes = superclass.attributes.dup
+          else
+            @attributes = []
+          end
+        end
+        @attributes
+      end
+
+      def self.attribute ( name, descr, *args, &block )
+        attr = Attribute.new(name, descr, *args, &block)
+        unless method_defined? name
+          if att = get_attribute(name, MethodAttribute)
+            attributes.delete(att)
+          end
+          attr_reader name
+        end
+        meth = "#{name}="
+        unless method_defined? meth
+          if att = get_attribute(meth, MethodAttribute)
+            attributes.delete(att)
+          end
+          attr_writer name
+        end
+        attributes << attr
+      end
+
+      def self.method_attribute ( name, descr, *args, &block )
+        # unless method_defined? name
+          # raise ArgumentError, "Undefined method #{name}"
+        # end
+        attr = MethodAttribute.new(name, descr, *args, &block)
+        attributes << attr
+      end
+
+      def self.get_attribute ( name, type=nil )
+        if type.nil?
+          attributes.find { |attr| attr.name == name }
+        else
+          attributes.find { |attr| attr.name == name && attr.is_a?(type) }
+        end
+      end
+
+    end
+
+  end
+
+end # module AttributedClass
+
+
+
+test_section __FILE__ do
+
+  class AttributedClassTest < Test::Unit::TestCase
+
+    def test_simple
+      c = Class.new
+      assert_nothing_raised do
+        c.module_eval { include AttributedClass }
+      end
+      assert_equal([], c.attributes)
+      assert_nothing_raised do
+        c.module_eval { attribute :foo, 'foofoo', 42 }
+      end
+      cc, d, dd = nil, nil, nil
+      assert_nothing_raised { cc = c.new }
+      assert_equal(nil, cc.foo)
+      assert_nothing_raised { cc.initialize_attributes }
+      assert_equal(42, cc.foo)
+      assert_nothing_raised { cc.foo = 32 }
+      assert_equal(32, cc.foo)
+      assert_nothing_raised { d = Class.new(c) }
+      assert_nothing_raised do
+        d.module_eval { attribute :bar, 'foofoo', :mandatory }
+      end
+      assert_nothing_raised { dd = d.new }
+      assert_nothing_raised { dd.initialize_attributes }
+      assert_raise(AttributedClass::AttributeError) do
+        dd.check_attributes
+      end
+    end
+
+  end # class AttributedClassTest
+
+end