godfat-ludy 0.1.13

data/lib/ludy/tasks/preprocess_cpp/attr_builder.rb

@@ -0,0 +1,49 @@
+
+module Kernel
+private
+# just like attr_accessor for c++
+def accessor type, *pros
+  (reader_only type, *pros) +
+  (writer_only type, *pros) +
+  (member_only type, *pros)
+end
+
+# just like attr_reader for c++
+def reader type, *pros
+  (reader_only type, *pros) +
+  (member_only type, *pros)
+end
+
+# just like attr_writer for c++
+def writer type, *pros
+  (writer_only type, *pros) +
+  (member_only type, *pros)
+end
+
+# create only reader(getter), no member and no writer(setter)
+def reader_only type, *pros
+  result = "#{@prefix}public:\n"
+  pros.each{ |p|
+    # getter
+    result << "#{@prefix}#{@indent}#{type} #{p}() const{ return #{p}_; }\n"
+  }
+  result
+end
+
+# create only writer(setter), no member and no reader(getter)
+def writer_only type, *pros
+  result = "#{@prefix}public:\n"
+  pros.each{ |p|
+    # setter
+    result << "#{@prefix}#{@indent}#{@class}& #{p}(#{type} const& new_#{p}){ #{p}_ = new_#{p}; return *this; }\n"
+  }
+  result
+end
+
+# create only member, no writer(setter) and no reader(getter)
+def member_only type, *pros
+  result = "#{@prefix}private:\n"
+  result << "#{@prefix}#{@indent}#{type} #{pros.map{|p|"#{p}_"}.join(", ")};\n"
+end
+
+end # of Kernel

data/lib/ludy/tasks/preprocess_cpp/debug_hook.rb

@@ -0,0 +1,36 @@
+
+require 'ludy/tasks/common'
+
+module Kernel
+private
+  # it simply output:
+  #  #ifndef NDEBUG
+  #  #include <iostream>
+  #  #endif
+  def debug_include
+'#ifndef NDEBUG
+#include <iostream>
+#endif'
+  end
+  # example usage:
+  #  void <% debug_hook 'C::f' do %>(){
+  #    <% end %>
+  #    std::cout << "hello" << std::endl;
+  #  }
+  # became:
+  #  void C::f(){
+  #    #ifndef NDEBUG
+  #    std::cerr << "method C::f called, for " << this << " at c.cpp: 12\n"
+  #    #endif
+  #    std::cout << "hello" << std::endl;
+  #  }
+  def debug_hook name, &block
+    Ludy::erbout name, block.binding
+    block.call
+    Ludy::erbout "
+#ifndef NDEBUG
+std::clog << \"method #{name} called, for \" << this << \" at #{@file}: #{eval '__LINE__', block.binding}\\n\";
+#endif
+", block.binding
+  end
+end # of Kernel

data/lib/ludy/tasks/preprocess_cpp/header_guard.rb

@@ -0,0 +1,17 @@
+
+require 'ludy/tasks/common'
+
+module Kernel
+private
+# C/C++ header guard generator, you shold provide the final #endif yourself,
+# and you should provide PROJ name for header guard prefix
+def header_guard random_suffix = nil, &block
+  defined = "_#{Project.name.upcase}_#{@dir.upcase}_#{@class.upcase}_#{random_suffix.nil? ? '' : rand.to_s[2..-1]+'_'}"
+
+  Ludy::erbout "#ifndef #{defined}
+#define #{defined}", block.binding
+  block.call
+  Ludy::erbout '#endif', block.binding
+end
+
+end # of Kernel

data/lib/ludy/tasks/preprocess_cpp/template_forward_parameters.rb

@@ -0,0 +1,45 @@
+
+require 'ludy/array/combos'
+require 'ludy/array/map_with_index'
+require 'ludy/array/tail'
+
+module Kernel
+private
+# forward template functions' generator
+def for_template_parameters_within range, modifiers = ['volatile', 'const volatile']
+  modifiers = ['', 'const'] + modifiers
+  range.to_a.map_with_index{ |size, i|
+    ([(["T"]*modifiers.size).zip(
+    modifiers,
+    ['&']*modifiers.size)]*size).
+      map_with_index{ |args, arg_i|
+        args.map{ |arg|
+          # e.g., T0 const& a
+          "#{arg.first}#{arg_i} #{arg.tail.join} #{(arg_i+10).to_s(36)}"
+        }
+      }.combos.map{ |arg| arg.kind_of?(Array) ? arg.join(', ') : arg }
+  }.flatten.each{ |args_list| yield args_list }
+end
+
+# parameter for template
+def template_parameters args_list
+  size = args_list.count(',') + 1
+  '<' + (['class T']*size).map_with_index{ |t, index|
+    "#{t}#{index}"
+  }.join(', ') + '>'
+end
+
+# the parameters' list
+def forward_parameters args_list
+  args_list
+end
+
+# the arguments it passed
+def arguments args_list
+  size = args_list.count(',') + 1
+  Array.new(size).map_with_index{ |not_important, i|
+    (i+10).to_s 36
+  }.join(', ')
+end
+
+end # of Kernel

data/lib/ludy/timer.rb

@@ -0,0 +1,30 @@
+
+module Ludy
+  # whenever a Timer was timeout, it was thrown
+  class Timeout < Exception; end
+  # simple and stupid timer for puzzle_generator...
+  class Timer
+    # create a timer for timeout seconds.
+    def initialize timeout
+      @timeout = timeout
+    end
+    # start ticking
+    def start
+      @now = Time.now
+      @parent = Thread.current
+      @thread = Thread.new{
+        sleep @timeout
+        @parent.raise Timeout.new("timeout for #{@timeout} seconds.")
+      }
+      self
+    end
+    # total time until start ticking
+    def total_time
+      Time.now - @now
+    end
+    # stop ticking
+    def stop
+      @thread.kill
+    end
+  end
+end

data/lib/ludy/variable.rb

@@ -0,0 +1,29 @@
+
+require 'ludy/kernel/public_send'
+require 'ludy/class/undef_all_methods'
+
+module Ludy
+
+  # a variable reference, used for side effect...
+  class Variable
+    undef_all_methods
+
+    # init the refered instance
+    def initialize obj
+      @__obj__ = obj
+    end
+
+    # delegator
+    def method_missing msg, *arg, &block
+      @__obj__.public_send msg, *arg, &block
+    end
+
+    attr_accessor :__obj__
+  end
+
+  # provided for creating lazy object more convient
+  def var arg
+    Variable.new arg
+  end
+
+end # of Ludy

data/lib/ludy/version.rb

@@ -0,0 +1,9 @@
+
+require 'rubygems'
+module Ludy
+  GEM_RUBY_VERSION = Gem::Version.new(::RUBY_VERSION)
+  module_function
+  def ruby_before ver
+    GEM_RUBY_VERSION < Gem::Version.new(ver)
+  end
+end

data/lib/ludy/y_combinator.rb

@@ -0,0 +1,11 @@
+
+require 'ludy/lazy'
+
+module Ludy
+
+  # the Y combinator, with lazy stuff
+  Y = lambda{|f|
+    lambda{|x| lazy{f[x[x]]} }[lambda{|x| lazy{f[x[x]]} }]
+  }
+
+end # of Ludy

data/lib/ludy/z_combinator.rb

@@ -0,0 +1,11 @@
+
+module Ludy
+
+  # the Z combinator, without lazy stuff
+  Z = lambda{|f|
+    lambda{|x| f[lambda{|y| x[x][y]}]}[
+      lambda{|x| f[lambda{|y| x[x][y]}]}
+    ]
+  }
+
+end # of Ludy

data/lib/puzzle_generator.rb

@@ -0,0 +1,53 @@
+
+# alpha at 2007.10.14
+
+require 'puzzle_generator/puzzle'
+
+require 'ludy/hash/reverse_merge'
+
+# require 'rubygems' if RUBY_VERSION < '1.9.0'
+# require 'facets/timer'
+require 'ludy/timer' # simple and stupid timer....
+
+# puzzle generator for shooting-cubes[http://shooting-cubes.googlecodes.com],
+# example usage:
+#  PuzzleGenerator.debug = true
+#  pg = PuzzleGenerator::Puzzle.new :level => 4, :timeout => 2, :invoke_max => 5
+#  begin
+#    pg.generate
+#    pg.display_map
+#  rescue Ludy::Timeout => e
+#    puts e
+#  ensure
+#    p pg.tried_times
+#    p pg.tried_duration
+#  end
+module PuzzleGenerator
+
+  def self.generate_chained_map option = {} #:nodoc:
+    generate_klass ChainedMap, option
+  end
+  def self.generate_klass klass, option = {} #:nodoc:
+    option.reverse_merge! :timeout => 5
+    generate(option[:timeout]){ klass.new option }
+  end
+
+  LastTriedInfo = {} # :nodoc:
+  # generate someing with generator with timeout, used in Puzzle#generate
+  def self.generate timeout = 5, &generator
+    timer = Ludy::Timer.new(timeout).start
+    tried_times = 1
+    begin
+      result = generator.call
+      until result.result_map.kind_of? Array
+        tried_times += 1
+        result = generator.call
+      end
+    ensure
+      # timer.stop
+      LastTriedInfo.merge! :tried_times => tried_times, :tried_duration => timer.total_time
+    end
+    result
+  end
+
+end

data/lib/puzzle_generator/chain.rb

@@ -0,0 +1,35 @@
+
+require 'puzzle_generator/misc'
+
+module PuzzleGenerator
+
+  class Chain # :nodoc:
+    include Enumerable
+    def initialize position = [0, 0], direct = Up, invoke = DefaultOption[:invoke]
+      @direct = direct
+      x, y = position
+      @data = case @direct
+                when Up   ; ([x]*invoke).zip((y...y+invoke).to_a)
+                when Right; (x...x+invoke).to_a.zip([y]*invoke)
+                when Left ; (x-invoke+1..x).to_a.zip([y]*invoke)
+              end
+    end
+    def <=> rhs; @data <=> rhs.instance_variable_get('@data'); end
+    def == rhs; (self <=> rhs) == 0; end
+    alias_method :eql?, :==
+    def hash; @data.hash; end
+    def each &block; @data.each &block; self end
+    def [] index; @data[index]; end
+    def to_a; @data.clone; end
+    def up?; @direct == Up; end
+    def bound_ok? max_width, max_height
+      not @data.find{ |i|
+        i.first >= max_width ||
+        i.last >= max_height ||
+        i.first < 0          ||
+        i.last < 0
+      }
+    end
+  end
+
+end

data/lib/puzzle_generator/chained_map.rb

@@ -0,0 +1,113 @@
+
+require 'puzzle_generator/misc'
+require 'puzzle_generator/chain'
+require 'puzzle_generator/map'
+
+require 'ludy/kernel/deep_copy'
+require 'ludy/array/combine'
+require 'ludy/array/rotate'
+require 'ludy/array/choice' # for Array#choice!
+require 'ludy/array/product'
+
+module PuzzleGenerator
+
+  # 1. put a chain
+  # 2. destroy a chain by chain
+  # 2. a. choose a position by last map
+  # 2. b. choose a direct from 3 direct (memo p+d)
+  # 2. c. check if the position + direct is ok? ok pass, failed choose again
+  # 2. d. goto 2
+
+  class ChainedMap # :nodoc:
+    include DisplayMap, MapUtils
+    attr_reader :maps, :option
+    def initialize option = {}
+      @option = DefaultOption.merge option
+      raise_if_bad_argument
+      init_map
+      @result_map = begin  next_level until @maps.size >= @option[:level]; put_fire_point
+                    rescue GenerationFailed; $! end
+    end
+
+    private
+    def raise_if_bad_argument
+      msg = []
+      @option.each{ |name, value| msg << "#{name} should be greater than 1." if value <= 1 }
+      raise ArgumentError.new(msg.join("\n")) unless msg.empty?
+    end
+    def make_map; Map.new @option; end
+    def init_map
+      @maps = [make_map]
+      @result_map = make_map_array
+      # @picked_chain = make_init_chains([(0..@option[:width]-@option[:invoke]), [0]].combos).pick
+      @picked_chain = make_init_chains((0..@option[:width]-@option[:invoke]).to_a.product([0])).choice
+      put_picked_chain_on @maps
+      resolve_map
+    end
+    # please make this init chain to variable length chain
+    def make_init_chains positions
+      positions.inject([]){ |result, pos| result << Chain.new(pos, Right, @option[:invoke]) }
+    end
+
+    def chain_ok?
+      raise GenerationFailed.new("ChainedMap: last result_map: #{@result_map.inspect}") if @picked_chain.nil?
+      @maps_preview = @maps.deep_copy
+      put_picked_chain_on @maps_preview
+
+      result = check_overlap_and_resolve_it &&
+               check_broken_except_last     &&
+               check_answer_correctness(@result_map_preview) # need this if you gen variable length chain
+
+      @maps_preview = nil
+      @result_map_preview = nil
+      result
+    end
+    def next_level new_map = nil
+      @maps << (new_map || make_map)
+      chains = @maps[-1].break_chains @maps[-2], @result_map
+
+      @picked_chain = chains.choice!
+      @picked_chain = chains.choice! until chain_ok?
+
+      put_picked_chain_on @maps
+      @picked_chain = nil
+      resolve_map
+    end
+    def put_fire_point; next_level Map.new(@option.merge(:invoke => 1, :invoke_max => 1)); end
+    def put_picked_chain_on maps
+      maps.last.chains << @picked_chain
+      @picked_chain.each{ |pos|
+        x, y = pos
+        maps.each{ |map|
+          column = map[x]
+          column.replace(column[0...y] + column[y..-1].rotate)
+        }
+        maps.last[x, y] = maps.size
+      }
+    end
+    def check_overlap_and_resolve_it
+      @result_map_preview = @maps_preview[0...-1].inject(make_map_array){ |result, map|
+        result.each_with_index{ |column, x|
+          column.each_with_index{ |value, y|
+            # assert one of them is zero or they are all zero
+            return false unless value * map[x, y] == 0
+          }
+        }
+        combine_map result, map
+      }
+    end
+    def check_broken_except_last
+      @maps_preview[0...-1].all?{ |map|
+        result = true
+        map.each_with_index_2d{ |i, x, y|
+          result &&= !check_left_chain( map, x, y) &&
+                     !check_right_chain(map, x, y) &&
+                     !check_up_chain(   map, x, y) &&
+                     !check_down_chain( map, x, y)
+        }
+        result
+      }
+    end
+  end
+
+end