stupidedi 1.1.0

data/lib/stupidedi/sets/relative_complement.rb

@@ -0,0 +1,137 @@
+# encoding: UTF-8
+
+module Stupidedi
+  module Sets
+
+    #
+    # This data type is an infinite and non-enumerable set of values that
+    # encodes the complement of a {RelativeSet}
+    #
+    class RelativeComplement < AbstractSet
+
+      def initialize(complement)
+        @complement = complement
+      end
+
+      # (see AbstractSet#include?)
+      def include?(object)
+        not @complement.include?(object)
+      end
+
+      # (see AbstractSet#size)
+      # @return Infinity
+      def size
+        1.0 / 0.0
+      end
+
+      # (see AbstractSet#finite?)
+      # @return false
+      def finite?
+        false
+      end
+
+      # (see AbstractSet#empty?)
+      # @return false
+      def empty?
+        false
+      end
+
+      # (see AbstractSet#replace)
+      def replace(other)
+        Sets.build(other)
+      end
+
+      # @group Set Operations
+      #########################################################################
+
+      # (see AbstractSet#complement)
+      def complement
+        # ¬(¬A) = A
+        @complement
+      end
+
+      # (see AbstractSet#intersection)
+      def intersection(other)
+        if other.is_a?(RelativeComplement)
+          # ¬A ∩ ¬B = ¬(A ∪ B)
+          complement.union(other.complement).complement
+        else
+          # ¬A ∩ B = B ∖ A
+          Sets.build(other).difference(complement)
+        end
+      end
+
+      # (see AbstractSet#union)
+      def union(other)
+        if other.is_a?(RelativeComplement)
+          # ¬A ∪ ¬B = ¬(A ∩ B)
+          complement.intersection(other.complement).complement
+        else
+          # ¬A ∪ B = ¬(A ∖ B)
+          complement.difference(Sets.build(other)).complement
+        end
+      end
+
+      # (see AbstractSet#symmetric_difference)
+      def symmetric_difference(other)
+        if other.is_a?(RelativeComplement)
+          # ¬A ⊖ ¬B = (¬A ∖ ¬B) ∪ (¬B ∖ ¬A)
+          #         =  (B ∖ A)  ∪ (A ∖ B)
+          #         = A ⊖ B
+          complement.symmetric_difference(other.complement)
+        else
+          # ¬A ⊖ B = (¬A ∖ B)  ∪ (B ∖ ¬A)
+          #        = (¬A ∩ ¬B) ∪ (B ∩ A)
+          #        = (¬B ∖ A)  ∪ (A ∖ ¬B)
+          #        = A ⊖ ¬B
+          other = Sets.build(other)
+
+          intersection(other.complement).
+            union(other.intersection(complement))
+        end
+      end
+
+      # (see AbstractSet#difference)
+      def difference(other)
+        if other.is_a?(RelativeComplement)
+          # ¬A ∖ ¬B = ¬A ∩ B = B ∖ A
+          other.complement.difference(complement)
+        else
+          # ¬A ∖ B = ¬A ∩ ¬B = ¬(A ∪ B)
+          complement.union(Sets.build(other)).complement
+        end
+      end
+
+      # @group Set Ordering
+      #########################################################################
+
+      # (see AbstractSet#proper_subset?)
+      def proper_subset?(other)
+        other.is_a?(RelativeComplement) and intersection(other) == self
+      end
+
+      # (see AbstractSet#proper_superset?)
+      def proper_superset?(other)
+        other.is_a?(RelativeComplement) and intersection(other) == other
+      end
+
+      # (see AbstractSet#==)
+      def ==(other)
+        eql?(other) or
+         (other.is_a?(RelativeComplement) and complement == other.complement)
+      end
+
+      # @group Pretty Printing
+      #########################################################################
+
+      # @return [String]
+      def inspect
+        "RelativeComplement(#{@complement.inspect})"
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/sets/relative_set.rb

@@ -0,0 +1,269 @@
+# encoding: UTF-8
+
+module Stupidedi
+  module Sets
+
+    #
+    # This data type encodes a set of unique values that belong to an _infinite_
+    # universe of possible values (aka domain). Set operations generally perform
+    # worse than {AbsoluteSet}, as they operate on {Hash} values and require
+    # iterating the underlying {Hash} of at least one of the two sets in `O(n)`
+    # time.
+    #
+    # This is suitable for sets that don't have an inherently restricted domain
+    # (eg sets of arbitrary {String} values), including those where the domain
+    # is significantly large compared to the typical size of sets built from
+    # those values. {RelativeSet} also requires only a single step to execute
+    # {#include?}, while {AbsoluteSet} requires two.
+    #
+    class RelativeSet < AbstractSet
+      include Enumerable
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      # Yields each element in the set to the implicit block argument.
+      #
+      # @return [void]
+      def each
+        @hash.keys.each{|o| yield o }
+      end
+
+      # Returns an {Array} containing each element in this set
+      #
+      # @return [Array]
+      def to_a
+        @hash.keys
+      end
+
+      # (see AbstractSet#include?)
+      def include?(object)
+        @hash.include?(object)
+      end
+
+      # (see AbstractSet#finite?)
+      #
+      # @return true
+      def finite?
+        true
+      end
+
+      # Returns a single element from the set, with no guarantees about which
+      # element. If the set is {#empty?}, the return value is undefined.
+      def first
+        @hash.keys.first
+      end
+
+      # (see AbstractSet#replace)
+      def replace(other)
+        Sets.build(other)
+      end
+
+      # (see AbstractSet#size)
+      def size
+        @hash.size
+      end
+
+      # (see AbstractSet#empty?)
+      def empty?
+        @hash.empty?
+      end
+
+      # @group Set Operations
+      #########################################################################
+
+      # @return [RelativeSet]
+      def map
+        RelativeSet.new(@hash.keys.inject({}) do |hash, key|
+          hash[yield(key)] = true
+          hash
+        end)
+      end
+
+      # @return [RelativeSet]
+      def select
+        RelativeSet.new(@hash.clone.delete_if{|o,_| not yield(o) })
+      end
+
+      # @return [RelativeSet]
+      def reject
+        RelativeSet.new(@hash.clone.delete_if{|o,_| yield(o) })
+      end
+
+      # (see AbstractSet#complement)
+      # @return [RelativeComplement]
+      def complement
+        RelativeComplement.new(self)
+      end
+
+      # (see AbstractSet#intersection)
+      def intersection(other)
+        if other.is_a?(RelativeComplement)
+          # A ∩ ¬B = ¬B ∩ A
+          other.intersection(self)
+        elsif other.is_a?(AbstractSet)
+          if other.is_a?(RelativeSet) and size > other.size
+            # For efficiency, iterate the smaller of the two sets: A ∩ B = B ∩ A
+            other.intersection(self)
+          elsif other.empty?
+            # A ∩ ∅ = ∅
+            NullSet.build
+          else
+            hash = @hash.clone.delete_if{|o,_| not other.include?(o) }
+
+            if hash.empty?
+              NullSet.build
+            else
+              RelativeSet.new(hash)
+            end
+          end
+        else
+          intersection(Sets.build(other))
+        end
+      end
+
+      # (see AbstractSet#intersection)
+      def union(other)
+        if other.is_a?(RelativeComplement)
+          # A ∪ ¬B = ¬B ∪ A
+          other.union(self)
+        elsif other.is_a?(AbstractSet)
+          unless other.is_a?(RelativeSet) and size < other.size
+            hash = other.inject(@hash.clone){|h,o| h[o] = true; h }
+
+            if hash.empty?
+              NullSet.build
+            else
+              RelativeSet.new(hash)
+            end
+          else
+            # For efficiency, iterate the smaller of the two sets: A ∪ B = B ∪ A
+            if other.empty?
+              self
+            else
+              other.union(self)
+            end
+          end
+        else
+          union(Sets.build(other))
+        end
+      end
+
+      # (see AbstractSet#difference)
+      def difference(other)
+        if other.is_a?(RelativeComplement)
+          # A ∖ ¬B = A ∩ B
+          intersection(other.complement)
+        elsif other.is_a?(AbstractSet)
+          if other.empty?
+            self
+          else
+            # A ∖ B = A ∩ ¬B
+            hash = @hash.clone.delete_if{|o,_| other.include?(o) }
+
+            if hash.empty?
+              NullSet.build
+            else
+              RelativeSet.new(hash)
+            end
+          end
+        else
+          difference(Sets.build(other))
+        end
+      end
+
+      # (see AbstractSet#symmetric_difference)
+      def symmetric_difference(other)
+        if other.is_a?(RelativeComplement)
+          # A ⊖ ~B = (A ∖ ¬B) | (¬B ∖ A)
+          #        = (A ∩ B)  | (¬B ∩ ¬A)
+          #        = (B ∖ ¬A) | (¬A ∖ B)
+          #        = ~A ⊖ B
+          intersection(other.complement).
+            union(other.intersection(complement))
+        else
+          # A ⊖ B = (A ∖ B) | (B ∖ A)
+          #       = (A ∪ B) - (A ∩ B)
+          other = Sets.build(other)
+
+          if other.empty?
+            self
+          else
+            union(other).difference(intersection(other))
+          end
+        end
+      end
+
+      # @group Set Ordering
+      #########################################################################
+
+      # (see AbstractSet#==)
+      def ==(other)
+        eql?(other) or
+          (other.is_a?(Enumerable) and
+           @hash.keys == other.to_a)
+      end
+
+      # @group Pretty Printing
+      #########################################################################
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("RelativeSet[#{size}]")
+        q.group(2, "(", ")") do
+          q.breakable ""
+
+          elements = to_a
+          elements.take(5).each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+
+          if elements.length > 5
+            q.text ","
+            q.breakable
+            q.text "..."
+          end
+        end
+      end
+
+      # @return [String]
+      def inspect
+        "RelativeSet(#{to_a.map(&:inspect).join(', ')})"
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+    class << RelativeSet
+      # @group Constructors
+      #########################################################################
+
+      # @return [RelativeSet]
+      def build(object)
+        if object.is_a?(RelativeSet)
+          object
+        elsif object.is_a?(Enumerable)
+          if object.empty?
+            NullSet.build
+          elsif object.is_a?(Hash)
+            new(object)
+          else
+            new(object.inject({}){|h,o| h[o] = true; h })
+          end
+        else
+          raise TypeError
+        end
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+
+  end
+end

data/lib/stupidedi/sets/universal_set.rb

@@ -0,0 +1,104 @@
+module Stupidedi
+  module Sets
+
+    # @private
+    UniversalSet = Class.new(RelativeComplement) do
+
+      def initialize
+      end
+
+      # @return [UniversalSet]
+      def build
+        self
+      end
+
+      # @return true
+      def include?(object)
+        true
+      end
+
+      # @return false
+      def finite?
+        false
+      end
+
+      # @return Infinity
+      def size
+        1.0 / 0.0
+      end
+
+      # @return false
+      def empty?
+        false
+      end
+
+      # @return [AbstractSet]
+      def replace(other)
+        Sets.build(other)
+      end
+
+      # @group Set Operations
+      #########################################################################
+
+      # @return NullSet
+      def complement
+        # ¬U = ∅
+        NullSet.build
+      end
+
+      # @return [AbstractSet]
+      def intersection(other)
+        # U & A = A
+        Sets.build(other)
+      end
+
+      # @return [AbstractSet]
+      def union(other)
+        # U ∪ A = U
+        self
+      end
+
+      # @return [AbstractSet]
+      def symmetric_difference(other)
+        # U ⊖ A = (U ∖ A) ∪ (A ∖ U) = (¬A) ∪ (∅) = ¬A
+        Sets.complement(other)
+      end
+
+      # @return [AbstractSet]
+      def difference(other)
+        # U ∖ A = ¬A
+        Sets.complement(other)
+      end
+
+      # @group Set Ordering
+      #########################################################################
+
+      # @return [Boolean]
+      def proper_subset?(other)
+        false
+      end
+
+      # @return [Boolean]
+      def proper_superset?(other)
+        not other.eql?(self)
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other)
+      end
+
+      # @group Pretty Printing
+      #########################################################################
+
+      # @return [String]
+      def inspect
+        "UniversalSet"
+      end
+
+      # @endgroup
+      #########################################################################
+    end.new
+
+  end
+end

data/lib/stupidedi/sets.rb

@@ -0,0 +1,57 @@
+module Stupidedi
+
+  module Sets
+    autoload :AbstractSet,        "stupidedi/sets/abstract_set"
+    autoload :AbsoluteSet,        "stupidedi/sets/absolute_set"
+    autoload :NullSet,            "stupidedi/sets/null_set"
+    autoload :RelativeComplement, "stupidedi/sets/relative_complement"
+    autoload :RelativeSet,        "stupidedi/sets/relative_set"
+    autoload :UniversalSet,       "stupidedi/sets/universal_set"
+  end
+
+  class << Sets
+    # @group Constructors
+    ###########################################################################
+
+    # @return [Sets::AbstractSet]
+    def build(object)
+      if object.is_a?(Sets::AbstractSet)
+        object
+      elsif object.is_a?(Enumerable)
+        Sets::RelativeSet.build(object)
+      else
+        raise TypeError,
+          "argument must be an AbstractSet or Enumerable"
+      end
+    end
+
+    # @return [Sets::AbstractSet]
+    def complement(other)
+      build(other).complement
+    end
+
+    # @return [Sets::UniversalSet]
+    def universal
+      Sets::UniversalSet.build
+    end
+
+    # @return [Sets::NullSet]
+    def empty
+      Sets::NullSet.build
+    end
+
+    # @return [Sets::AbsoluteSet]
+    def absolute(other, universe = other)
+      if universe.eql?(other)
+        Sets::AbsoluteSet.build(universe)
+      else
+        Sets::AbsoluteSet.build(universe).intersection(other)
+      end
+    end
+
+    # @endgroup
+    ###########################################################################
+  end
+
+
+end

data/lib/stupidedi/tail_call.rb

@@ -0,0 +1,109 @@
+module Stupidedi
+
+  #
+  # This performs tail call optimization on methods declared by the programmer
+  # to be in tail call form. It can't actually verify if they are, so be sure
+  # to write tests for your methods.
+  #
+  # Because the optimizations are done in pure Ruby, the benefits are somewhat
+  # limited -- the stack doesn't grow but it only begins to outperform the
+  # unoptimized code only when the stack reaches a depth of about 5000 frames.
+  # Before that threshold, it actually performs significantly worse -- about 70%
+  # slower at 50 stack frames, and nearly 100% slower at 10 stack frames.
+  #
+  # @example
+  #   class Unoptimized
+  #     def fact(n, accumulator = 1)
+  #       (n < 2) ? accumulator : fact(n-1, n * accumulator)
+  #     end
+  #   end
+  #
+  #   class Optimized
+  #     include TailCall
+  #
+  #     def fact(n, accumulator = 1)
+  #       (n < 2) ? accumulator : fact(n-1, n * accumulator)
+  #     end
+  #
+  #     optimize_tailcall :fact
+  #   end
+  #
+  # Benchmarks
+  # ----------
+  #     o = Optimized.new
+  #     u = Unoptimized.new
+  #
+  #     [10, 50, 100, 500, 1000, 5000, 10000, 50000].each do |n|
+  #       Benchmark.bm do |x|
+  #         x.report("#{n} optim = ") { puts(begin; o.fact(n).size; rescue; $! end) }
+  #         x.report("#{n} plain = ") { puts(begin; u.fact(n).size; rescue; $! end) }
+  #       end
+  #     end
+  #
+  # With 10000 stack frames the optimized version runs about 40% faster. These
+  # benchmark results were produced by Ruby Enterprise Edition 1.8.7
+  #
+  #          n       tco     plain    ratio
+  #     ------------------------------------
+  #         10    0.7918    0.0045    0.0056
+  #         50    0.2476    0.0674    0.2723
+  #        100    0.5207    0.2008    0.3856
+  #        500    2.5064    1.0426    0.4160
+  #       1000    5.8834    3.2413    0.5509
+  #       5000   42.5210   41.7398    0.9816
+  #      10000   14.5664   20.3000    1.3936
+  #      25000    9.3729  (stack err)
+  #
+  # It seems like this tradeoff makes sense only for methods we know are going to
+  # consistently generate thousands of stack frames. We're probably better off
+  # using Ruby YARV (1.9) in all cases though, since it performs faster in general
+  # and it supposedly implements tail call optimization in the interpreter.
+  #
+  #
+  # @see http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/145593
+  #
+  module TailCall
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # @private
+    module ClassMethods
+
+      # @return [void]
+      def optimize_tailcall(*names)
+        @__tc ||= Hash.new
+
+        for name in names
+          @__tc[name.to_sym] = instance_method(name)
+
+          module_eval <<-RUBY
+            def #{name}(*args, &block)
+              if Thread.current[:tc_#{name}]
+                throw(:recurse_#{name}, [args, block])
+              else
+                Thread.current[:tc_#{name}] =
+                  self.class.instance_variable_get(:@__tc)[:#{name}].bind(self)
+
+                result = catch(:done_#{name}) do
+                  while true
+                    args, block =
+                      catch(:recurse_#{name}) do
+                        throw(:done_#{name},
+                          Thread.current[:tc_#{name}].call(*args, &block))
+                      end
+                  end
+                end
+
+                Thread.current[:tc_#{name}] = nil
+
+                result
+              end
+            end
+          RUBY
+        end
+      end
+    end
+
+  end
+end