tree-red_black 0.4.2 → 0.4.3

data/contrib/graph_red-black_tree.rb

@@ -0,0 +1,203 @@
+#!/usr/bin/env ruby
+
+require 'tree/red_black'
+require 'benchmark'
+
+OPEN = case RbConfig::CONFIG['target_os']
+       when /darwin/
+         '/usr/bin/open'
+       else
+         '/usr/bin/xdg-open'
+       end
+
+def red_black_tree_paths(rbt)
+  paths = {}
+  rbt.pre_order do |node; path, count, ancestor|
+    if node.left.nil? || node.right.nil?
+      path = []
+      count = 0
+      ancestor = node
+      loop do
+        path.unshift ancestor.key
+        count += 1 if ancestor.color == :BLACK
+        break if (ancestor = ancestor.parent).nil?
+      end
+      paths[path] = count
+    end
+  end
+  paths
+end
+
+
+# To graph duplicate values, generate a unique ID for each instance of
+# a given value. For example, if there are multiple 10s, then the
+# first instance is assigned ID 10_0, the second instance 10_1, etc.
+#
+# To calculate the index of a given value, note that during in-order
+# traversal, a left child node is visited before its parent. So when a
+# left child node is visited, its instance index must be incremented.
+#
+# On the other hand, since a graph is described as a sequence of arcs
+# from parent nodes to their child nodes, e.g.,
+#
+#     parent_1 -- left_child_of_parent_1
+#     parent_1 -- right_child_of_parent_2
+#     parent_2 -- left_child_of_parent_2
+#     parent_2 -- right_child_of_parent_2
+#     ...
+#
+# a right child node is referenced in an arc before it's visited via
+# in-order traversal. So a right child node's instance index must be
+# incremented when the right child is referenced in an arc.
+#
+# Finally, use the node itself (or perhaps a string containing its
+# oject ID) as the key of a hash of instance values.
+#
+
+def graph_red_black_tree(rbt, filename, title)
+  count = {}
+  instance = {}
+
+  rbt.each { |node| count[node.key] ||= 0; count[node.key] += 1 }
+
+  File.open(filename, 'w') do |file|
+    file.write "graph \"\"\n{\n  label=\"#{title}\"\n"
+
+    i = 0
+    rbt.in_order do |node|
+      parent = if count[node.key] == 1
+                 node.key
+               else
+
+                 # left child...
+                 if node == node.parent&.left
+
+                   # so increment node.key instance index.
+                   instance[node.key] ||= -1
+                   instance[node.key] += 1
+                   instance[node] = instance[node.key]
+                 end
+                 "#{node.key}_#{instance[node]}"
+               end
+
+      left_child = if node.left
+                     if  count[node.left.key] > 1
+                       "#{node.left.key}_#{instance[node.left]}"
+                     else
+                       node.left.key
+                     end
+                   else
+                     'NIL' + (i += 1).to_s
+                   end
+
+      right_child = if node.right
+
+                      # right child...
+                      if  count[node.right.key] > 1
+
+                        # so increment node.right.key instance index.
+                        instance[node.right.key] ||= -1
+                        instance[node.right.key] += 1
+                        instance[node.right] = instance[node.right.key]
+                        "#{node.right.key}_#{instance[node.right]}"
+                      else
+                        node.right.key
+                      end
+                    else
+                      'NIL' + (i += 1).to_s
+                    end
+
+      file.write("  \"#{parent}\" [style=filled,color=#{node.color.to_s.downcase},fontcolor=white,label=#{node.key}];\n")
+      file.write("  \"#{parent}\" -- \"#{left_child}\";\n")
+      file.write("  \"#{parent}\" -- \"#{right_child}\";\n")
+    end
+
+    i.times do |n|
+      file.write("  NIL#{n + 1} [fontsize=6,shape=box,width=0.2,height=0.2,style=filled,color=black,fontcolor=white,label=\"NIL\"];\n")
+    end
+
+    file.write("}\n")
+  end
+end
+
+def delete_keys_of_interest(rbt, deleted, log)
+  paths = red_black_tree_paths(rbt)
+
+  raise "Unbalanced tree after deleting: #{deleted}" if paths.values.uniq.size > 1
+
+  koi = rbt.select do |node|
+    node.color == :BLACK && node.left.nil? && node.right.nil?
+  end.map(&:key)
+
+  v = koi.size > 0 ? koi.shuffle.first : rbt.root&.key
+
+  return log if v.nil?
+
+  log << "key of interest: #{v}"
+  deleted << v
+  rbt.delete(v)
+
+  delete_keys_of_interest(rbt, deleted, log)
+end
+
+values = [*0..20].shuffle
+# values = [2, 10, 4, 5, 6, 3, 1, 0, 9, 8, 7]
+# values = [0, 2, 6, 4, 5, 3, 7, 1, 9, 8, 10]
+puts "values: #{values.inspect}"
+
+rbt = nil
+Benchmark.bm do |benchmark|
+  benchmark.report("insert:") do
+    rbt = Tree::RedBlack.new(true)
+    rbt.insert(*values)
+  end
+end
+
+puts "root.key: #{rbt.root.key}"
+puts "tree size: #{rbt.size}"
+puts "sorted values: #{rbt.map(&:key).inspect}"
+paths = red_black_tree_paths(rbt)
+puts "black-node counts: #{paths.values.uniq}"
+graph_red_black_tree(rbt, 'dot.txt', 'Red-Black Tree')
+system "dot -Tpng -odot.png dot.txt && #{OPEN} dot.png"
+
+deleted = []
+
+rbt_copy = rbt.dup
+log = []
+Benchmark.bm do |benchmark|
+  benchmark.report("koi:") do
+    log = delete_keys_of_interest(rbt_copy, deleted, log)
+  end
+end
+
+puts log
+
+trap("SIGINT") { print "\n"; exit! }
+
+
+toggle = insert_n = delete_n = 0
+while insert_n || delete_n
+  print "Integer to insert [Enter for none, Ctrl+C to exit]? "
+  ans = gets
+  insert_n = ans == "\n" ? nil : ans.to_i
+  print "Integer to delete [Enter for none, Ctrl+C to exit]? "
+  ans = gets
+  delete_n = ans == "\n" ? nil : ans.to_i
+  print "Inserting: #{insert_n}\n" if insert_n
+  print "Deleting: #{delete_n}\n" if delete_n
+
+  rbt.insert(insert_n) if insert_n
+  rbt.delete(delete_n) if delete_n
+
+  name = toggle == 0  ? 'dot2' : 'dot'
+  title = 'Red-Black Tree '
+  title += insert_n ? "+ #{insert_n} " : ''
+  title += delete_n ? "- #{delete_n} " : ''
+  graph_red_black_tree(rbt, name + '.txt', title)
+
+  system  'dot -Tpng -o' + name + '.png ' + name + '.txt'
+  system "#{OPEN} " + name + '.png'
+
+  toggle ^= 1
+end

data/contrib/schedule_reservation.rb

@@ -0,0 +1,242 @@
+#!/usr/bin/env ruby
+require 'tree/red_black'
+
+module IntegerTime
+  interval_in_seconds = {
+    second: 1,
+    minute: 60,
+    hour: 60 * 60,
+    day: 24 * 60 * 60,
+    week: 7 * 24 * 60 * 60,
+    year: 365 * 24 * 60 * 60
+  }
+
+  refine Integer do
+    interval_in_seconds.keys.each do |key|
+      define_method(key) { self * interval_in_seconds[key] }
+      define_method((key.to_s + 's').to_sym) { self * interval_in_seconds[key] }
+    end
+  end
+end
+
+class BusyFreeEvent
+  include Comparable
+
+  attr_reader :time, :owner
+
+  def initialize(time, owner)
+    @time = time
+    @owner = owner
+  end
+
+  def <=>(other)
+    time <=> other.time
+  end
+
+  def inspect
+    { time => owner }
+  end
+end
+
+class Reservation
+  attr_reader :from, :to, :owner
+
+  def initialize(from, to, owner)
+    @from = from
+    @to = to
+    @owner = owner
+  end
+
+  def inspect
+    { [from, to] => owner }
+  end
+end
+
+class Schedule
+  using IntegerTime
+
+  attr_accessor :events
+
+  def initialize
+    @events = Tree::RedBlack.new(false)
+  end
+
+  def reserve(from:, to: from + 1.hour,  owner:)
+    return nil if owner == :FREE
+
+    next_owner = :FREE
+    total_events = events.size
+
+    rsv_from = BusyFreeEvent.new(from, owner)
+    rsv_to = BusyFreeEvent.new(to, next_owner)
+
+    if total_events.zero?
+      events.insert(rsv_from, rsv_to)
+    else
+      succ_event = events.bsearch { |event| event.key > rsv_from }
+      if succ_event.nil?
+        pred_event = events.root.max
+
+        # Assert: pred_event.key.owner == :FREE
+        if pred_event.key == rsv_from
+          events.delete(pred_event.key)
+          total_events -= 1
+        end
+        events.insert(rsv_from, rsv_to)
+      elsif succ_event.key >= rsv_to
+        pred_event = succ_event.pred
+        if pred_event.nil? || pred_event.key.owner == :FREE
+          events.delete(pred_event.key) if pred_event&.key == rsv_from
+          events.insert(rsv_from)
+          if succ_event.key != rsv_to
+
+            # Assert: succ_event.key.owner != :FREE
+            events.insert(rsv_to)
+          else
+            next_owner = succ_event.key.owner
+            total_events -= 1
+          end
+        end
+      end
+    end
+
+    # Assert: inserts/deletes successful
+    events.size == total_events + 2 ? Reservation.new(from, to, owner) : nil
+  end
+
+  def unreserve(reservation)
+    event = events.bsearch { |ev| ev.key.time >= reservation.from }
+
+    return false if (event.nil? || event.key.time != reservation.from || event.key.owner != reservation.owner)
+
+    # Assert: event.key.owner != :FREE
+    pred_event = event.pred
+    succ_event = event.succ
+
+    # Assert: ! succ_event.nil?
+
+    events.delete(event.key)
+    events.delete(succ_event.key) if succ_event.key.owner == :FREE
+    events.insert(BusyFreeEvent.new(reservation.from, :FREE)) if pred_event && pred_event.key.owner != :FREE
+    true
+  end
+
+  def is_consistent?
+    count = 0
+    prev = nil
+    event = events.root&.min
+    return false if event && event.key.owner == :FREE
+    while event
+      return false if prev&.key&.owner == :FREE && event.key.owner == :FREE
+      prev = event
+      event = event.succ
+      count += 1
+    end
+    return false if prev && prev.key.owner != :FREE
+    count == events.size && prev&.key&.owner == :FREE
+  end
+end
+
+if $0 == __FILE__
+  using IntegerTime
+
+  sched = Schedule.new
+  reserve_time = Time.now
+
+  puts "Before:"
+  sched.events.each do |event|
+    puts "key: #{event.key}"
+  end
+
+  puts "First reservation:"
+  reservation1 = sched.reserve(from: reserve_time, owner: :BUSY3)
+  puts "reservation: #{reservation1.inspect}"
+
+  puts "After first reservation:"
+  sched.events.each do |event|
+    puts "key: #{event.key.inspect}"
+  end
+
+  puts "Second reservation:"
+  reservation2 = sched.reserve(from: reserve_time - 1.hour, owner: :BUSY2)
+  puts "reservation: #{reservation2.inspect}"
+
+  puts "After second reservation:"
+  sched.events.each do |event|
+    puts "key: #{event.key.inspect}"
+  end
+
+  puts "Third reservation:"
+  reservation3 = sched.reserve(from: reserve_time + 1.hour, owner: :BUSY4)
+  puts "reservation: #{reservation3.inspect}"
+
+  puts "After third reservation:"
+  sched.events.each do |event|
+    puts "key: #{event.key.inspect}"
+  end
+
+  puts "Fourth reservation:"
+  reservation4 = sched.reserve(from: reserve_time - 4.hours, owner: :BUSY0)
+  puts "reservation: #{reservation4.inspect}"
+
+  puts "After fourth reservation:"
+  sched.events.each do |event|
+    puts "key: #{event.key.inspect}"
+  end
+
+  puts "Fifth reservation:"
+  reservation5 = sched.reserve(from: reserve_time - 2.hours, to: reserve_time - 90.minutes, owner: :BUSY1)
+  puts "reservation: #{reservation5.inspect}"
+
+  puts "After fifth reservation:"
+  sched.events.each do |event|
+    puts "key: #{event.key.inspect}"
+  end
+
+  puts "Schedule is consistent?: #{sched.is_consistent?}"
+
+  puts "Delete fifth reservation:"
+  result = sched.unreserve(reservation5)
+  puts "result: #{result}"
+
+  puts "After deleting fifth reservation:"
+  sched.events.each do |event|
+    puts "key: #{event.key.inspect}"
+  end
+
+  puts "Delete fourth reservation:"
+  result = sched.unreserve(reservation4)
+  puts "result: #{result}"
+
+  puts "After deleting fourth reservation:"
+  sched.events.each do |event|
+    puts "key: #{event.key.inspect}"
+  end
+
+  puts "Delete third reservation:"
+  result = sched.unreserve(reservation3)
+  puts "result: #{result}"
+
+  puts "After deleting third reservation:"
+  sched.events.each do |event|
+    puts "key: #{event.key.inspect}"
+  end
+
+  puts "Delete second reservation:"
+  result = sched.unreserve(reservation2)
+  puts "result: #{result}"
+
+  puts "After deleting second reservation:"
+  sched.events.each do |event|
+    puts "key: #{event.key.inspect}"
+  end
+
+  puts "Delete first reservation:"
+  result = sched.unreserve(reservation1)
+  puts "result: #{result}"
+
+  puts "After deleting first reservation:"
+  sched.events.each do |event|
+    puts "key: #{event.key.inspect}"
+  end
+end

data/lib/tree/red_black/version.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 module Tree
   class RedBlack
-    VERSION = '0.4.2'
+    VERSION = '0.4.3'
   end
 end