carats 0.3.0

data/lib/carat-dev/predicate/predicate.rb

@@ -0,0 +1,109 @@
+
+module Predicate
+
+  class Predicate
+    attr_reader :predicate, :facts
+    def initialize( name )
+      @predicate = name
+      @facts = []
+    end
+    def <<(args)
+      @facts << args
+    end
+  end
+
+  # Criterion is a psuedo-method probe  
+  class Criterion
+    attr_accessor :expression, :matches
+    def initialize(exp)
+      @expression = exp
+      @matches = []
+    end
+    def match( value )
+      if @expression.is_a?(Regexp)
+        @matches << value if value =~ @expression
+      else
+        @matches << value if value == @expression
+      end
+    end
+  end
+  
+  class Tester
+    attr_reader :value
+    def initialize(v)
+      @value = v
+    end
+  end
+  
+  
+  module LogicInclusion
+  
+    def predicate( st, *args )
+      spred = ( (@predicates ||= {})[st] ||= Predicate.new(st) )
+      if args.any? { |a| a.is_a?(Regexp) || a.is_a?(Criterion) }
+        # every arugument is a criterion probe
+        cargs = args.collect { |a| (a.is_a?(Criterion) ? a : Criterion.new(a)) }
+        # update criterion matches
+        spred.facts.each { |f| f.each_with_index { |a,i| cargs[i].match(a) } }
+        # criterion probe
+        send("#{st}_?", *cargs)
+        # collect the match arrays
+        nargs = cargs.collect { |c| c.matches }
+        # deduce
+        perms = LogicExtension.permutations(nargs)
+        deductions = perms.collect { |_p|
+          _t = _p.collect { |v| Tester.new(v) }
+          _p if send(st,*_t)
+        }.compact
+        return spred.facts + deductions
+      elsif args.all? { |a| a.is_a?(Tester) }
+        if spred.facts.include?( args.collect { |t| t.value } )
+          return true
+        else
+          return send("#{st}_?", *args)
+        end
+      else
+        #puts "Defining fact #{st}(" + args.join(',') + ')'
+        spred << args
+      end
+    end  
+    
+  end  # LogicInclusion
+  
+  
+  module LogicExtension
+  
+    def self.permutations( arr, prepend=[] )
+      head = arr[0]
+      tail = arr[1..-1]
+      perms = []
+      if tail.empty?
+        head.each { |h| perms << (prepend + [h]) }
+      else
+        head.each { |h| perms = perms | permutations(tail, (prepend + [h])) }
+      end
+      return perms
+    end
+  
+    def method_added( st )
+      #if st.to_s[-1..-1] != '?' && !method_defined?("#{st}_?")
+      if !@prevent_method_added
+        @prevent_method_added = true
+        #puts "Defining predicate #{st}"
+        alias_method("#{st}_?".intern, st)
+        module_eval %Q{
+          def #{st}(*args)
+            predicate(:#{st}, *args)
+          end
+          def #{st}?(*args)
+            targs = args.collect { |a| Tester.new(a) }
+            #{st}(*targs)
+          end
+        }
+        @prevent_method_added = false
+      end
+    end
+  
+  end  # LogicalExtension
+
+end  # PredicateLogic

data/lib/carat-dev/predicate/predicate_test.rb

@@ -0,0 +1,67 @@
+  
+require 'test/unit'
+require 'raspberry/succ/predicate'
+
+module TestLogic
+    
+  include Predicate::LogicInclusion
+  extend Predicate::LogicExtension
+  
+  def man(x)
+  end
+
+  def woman(x)
+  end
+  
+  def tool(x)
+  end
+  
+  def mortal(x)
+    woman(x) | man(x)
+  end
+
+  def can_use(x, y)
+    ( man(x) | woman(x) ) & tool(y)
+  end
+    
+end
+
+class TC_Predicate < Test::Unit::TestCase
+
+  include TestLogic
+  
+  def setup 
+    man('socrates')
+    woman('dido')
+    tool('hammer')
+    can_use('me', 'ball')
+  end
+  
+  def test_facts
+    assert(man?('socrates'), "man?('socrates')")
+    assert(woman?('dido'), "woman?('dido')")
+    assert(tool?('hammer'), "tool?('hammer')")
+    assert(can_use?('me', 'ball'), "can_use?('me', 'ball')")
+  end
+
+  def test_deductions
+    assert(mortal?('socrates'))
+    assert(mortal?('dido'))
+    assert(can_use?('socrates','hammer'))
+    assert(can_use?('dido','hammer'))
+  end
+  
+  def test_queries
+    assert(man(/.*/).include?(['socrates']))
+    assert(woman(/.*/).include?(['dido']))
+    assert(mortal(/.*/).include?(['socrates']))
+    assert(mortal(/.*/).include?(['dido']))
+    assert(can_use(/.*/,/.*/).include?(['socrates', 'hammer']))
+    assert(can_use(/.*/,/.*/).include?(['dido', 'hammer']))
+    assert(can_use(/.*/,/.*/).include?(['me', 'ball']))
+  end
+    
+end
+
+
+ 

data/lib/carat-dev/premshree.rb

@@ -0,0 +1,40 @@
+#!/ur/local/bin/ruby
+# $premshree$ $2005-03-18 03:13$
+
+require 'GD'
+include GD
+
+img = Image.newFromPng(File.new('firefox.png', 'rb'))
+text = 'FIREFOX'
+
+width = img.width
+height = img.height
+temps = [0]*3
+skip_pixels = 1
+skip_lines = 2
+char_next = 0
+print '<pre style="background: #FFFFFF">'
+height.times { |i|
+	if temps[2] == 0
+		width.times { |j|
+			if temps[1] == 0
+				idx = img.getPixel(j, i)
+				color = img.rgb(idx)
+				print "<span style=\"color: rgb(#{color[0]}, #{color[1]},
+				 #{color[2]}); font-size:10px;\">#{text.split('')[char_next]}</span>"
+				char_next = char_next + 1
+				if char_next == text.split('').length then char_next = 0 end
+			end
+			temps[1] = temps[1] + 1
+			if temps[1] == skip_pixels then temps[1] = 0 end
+			if temps[0] == width
+				print '<br />'
+				temps[0] = 0
+			end
+			temps[0] = temps[0] + 1			
+		}
+	end
+	temps[2] = temps[2] + 1
+	if temps[2] == skip_lines then temps[2] = 0 end
+}
+print '</pre>'

data/lib/carat-dev/priority-queue/pqueue.rb

@@ -0,0 +1,183 @@
+=begin
+
+= PQueue
+
+Priority queue with array based heap.
+
+== Authors
+
+* Rick Bradley 2003/02/02 (patch for Ruby 1.6.5. Thank you!)
+* K.Kodama 2001/03/10
+
+== Legal
+
+This is distributed freely in the sence of 
+GPL(GNU General Public License).
+
+=end
+
+class PQueue
+
+  attr_accessor :qarray
+  attr_reader :size
+  attr_reader :gt
+  
+  def initialize(&compareProc)
+    # By default, retrieves maximal elements first. 
+    compareProc = ( block_given? ? compareProc : lambda{|x,y| x>y} )
+    @qarray=[nil]
+    @size=0
+    @gt=compareProc
+    make_legal
+  end
+  private :initialize
+
+  #
+  def upheap(k)
+    k2 = (k/2).to_i
+    v = @qarray[k]
+    while ( (k2 > 0) and (@gt[v,@qarray[k2]]) )
+      @qarray[k] = @qarray[k2]
+      k = k2
+      k2 = (k2 / 2).to_i
+    end
+    @qarray[k] = v
+  end
+  private :upheap
+
+  #
+  def downheap(k)
+    v = @qarray[k]
+    q2 = (@size/2).to_i
+    loop do
+      break if (k > q2)
+      j = k + k
+      j += 1 if ( (j < @size) and (@gt[@qarray[j+1],@qarray[j]]) )
+      break if @gt[v,@qarray[j]]
+      @qarray[k] = @qarray[j]
+      k = j
+    end
+    @qarray[k]=v
+  end
+  private :downheap
+
+  #
+  def make_legal
+    (2..@size).each do |k|
+      upheap(k)
+    end
+  end
+
+  #
+  def empty?
+    return (0==@size)
+  end
+
+  #
+  def clear
+    @qarray.replace([nil])
+    @size=0
+  end
+
+  # Returns array sorted in increasing order.
+  def to_a
+    res=@qarray[1..@size];
+    res.sort!{|x,y| if @gt[x,y]; 1;elsif @gt[y,x]; -1; else 0; end;}
+    return res
+  end
+
+  #
+  def replace(arr=[])
+    @qarray.replace([nil]+arr); @size=arr.size; make_legal
+  end
+  
+  #
+  def clone
+    q=new; q.qarray=@qarray.clone; q.size=@size; q.gt=@gt; return q;
+  end
+
+  #
+  def push(v)
+    @size += 1
+    @qarray[@size] = v
+    upheap(@size)
+  end
+
+  # Return top element. Returns nil if queue is empty.
+  def pop
+    if @size > 0
+      res = @qarray[1]
+      @qarray[1] = @qarray[@size]
+      @size -= 1
+      downheap(1)
+      return res
+    else 
+      return nil
+    end
+  end
+  
+  # Returns top element, non-destructive.
+  def top
+    @size > 0 ? @qarray[1] : nil
+  end
+
+  # Replace top element if v < top element.
+  def replace_low(v)
+    if @size > 0
+      @qarray[0] = v
+      downheap(0)
+      return @qarray[0]
+    else 
+      @qarray[1] = v
+      return nil
+    end
+  end
+
+  # Rreplace top element.
+  def replace(v)
+    if @size>0
+      res=@qarray[1]
+      @qarray[1] = v
+      downheap(1)
+      return res
+    else 
+      @qarray[1] = v
+      return nil
+    end
+  end
+
+  # Iterate pop. Destructive. 
+  # Use as self.each_pop{|x| ... }. 
+  def each_pop
+    while(@size>0)
+      yield self.pop
+    end
+  end
+
+  # Not ordered. 
+  # Use as self.each_with_index{|e,i| ... }. 
+  def each_with_index
+    (1..@size).each do |i|
+      yield( @qarray[i], i )
+    end
+  end
+
+end # class pqueue
+
+
+# --- test ---
+
+if $0 == __FILE__
+  pq=PQueue.new{ |x,y| x > y}
+  pq.push(2)
+  pq.push(3)
+  pq.push(4)
+  pq.push(3)
+  pq.push(2)
+  pq.push(4)
+  print pq.size.to_s+"\n"
+  print pq.to_a.to_s+"\n"
+  pq.each_with_index{|x,y| print x.to_s+","+y.to_s+"\n"}
+  pq.each_pop{|x| print x.to_s+"\n"}
+end
+ 

data/lib/carat-dev/priority-queue/priorityqueue.rb

@@ -0,0 +1,84 @@
+require 'thread'
+
+class PriorityQueue
+
+  def initialize (*classes)
+    @order = classes
+    @queues = Hash::new
+    classes.each { |c| @queues[c] = Queue::new }
+    @ilimit = @order.size
+    @waiting = []
+  end
+
+  def push (obj)
+    Thread.critical = true
+    begin
+      @queues[obj.class.to_s].push obj
+      t = @waiting.shift
+      t.wakeup if t
+    rescue ThreadError
+      retry
+    rescue NameError
+      raise NameError, "unknown class queue"
+    ensure
+      Thread.critical = false
+    end
+    begin
+      t.run if t
+    rescue ThreadError
+    end
+  end
+  alias << push
+  alias enq push
+
+  def pop(non_block=false)
+    Thread.critical = true
+    begin
+      loop do
+	i = 0
+	while (i < @ilimit) and (@queues[@order[i]].empty?)
+	  i = i + 1
+	end
+	if i == @ilimit
+	  if non_block
+	    raise ThreadError, "queue empty"
+	  end
+	  @waiting.push Thread.current
+	  Thread.stop
+	else
+	  return @queues[@order[i]].shift
+	end
+      end
+    ensure
+      Thread.critical = false
+    end
+  end
+  alias shift pop
+  alias deq pop
+
+  def empty?
+    epty = true
+    @queues.each_value { |q| epty = epty and q.empty? }
+    return epty
+  end
+
+  def clear
+    @queues.each_value { |q| q.clear }
+  end
+
+  def length
+    l = 0
+    @queues.each_value { |q| l += q.length }
+    return l
+  end
+  
+  def size
+    length
+  end
+
+  def num_waiting
+    @waiting.size
+  end
+
+end
+