setfu 2.1.0 → 3.0.0

data/lib/setfu.rb

@@ -1,13 +1,256 @@
 require "setfu/version"
 require "prime"
+require "betterobject"
+require "yieldhelper"
+require "primitive_wrapper"
+
+####
+####   DOC add  eql?
+####
+
+class Object
+  better_install_as!(:push_unique, :setfu_push_unique)
+  better_install_as!(:tag, :setfu_tag)
+  better_install_as!(:tag, :setfu_count)
+  better_install_as!(:delete_many_at, :setfu_delete_many_at)
+end
+
+module Setfu
+  def self.bset_elements(ary)
+    ary.count.times do |ii|
+      ary[ii] = ary[ii].to_bset
+    end
+  end
+  def self.untag_bset_elements(ary)
+    ary.count.times do |ii|
+      ary[ii].remove_instance_variable :@bo_setfu_tag rescue :never_mind
+      ary[ii].remove_instance_variable :@bo_setfu_count rescue :never_mind
+    end
+  end
+  def self.find_tuple(ary, tup_size)  # assumes ary is comprised of sets
+    candidates = {}
+    entropy = 0
+    ary.count.times do |ii|
+      entropy = ary[ii].entropy > entropy ? ary[ii].entropy : entropy
+      unless ary[ii].setfu_count?
+        ary[ii].setfu_count = ary[ii].count  # store this as #count is slow
+      end
+      next unless ary[ii].setfu_count == tup_size
+      tup = ary[ii].to_i  # integer keys are good Hash keys, BitSets are not
+      candidates[tup] = 0  # store integer version of set in candidate hash if size matches
+      ary.count.times do |jj|
+        candidates[tup] +=1 if ary[ii]==ary[jj]  # vote count each match
+      end
+    end
+    valid = []
+    error = []
+    candidates.each_pair do |key,val|
+      bset = BitSet.new
+      bset.set_bits!(key)
+      bset.entropy=entropy
+      if val==tup_size
+        bset.setfu_tag
+        valid.push bset
+      elsif val>tup_size
+        error.push bset
+      end
+    end
+    group = []
+    ary.count.times do |ii|
+      next if ary[ii].setfu_tag?
+      next if ary[ii].setfu_count > tup_size
+      next if ary[ii] <= valid
+      next if ary[ii] <= error
+      group.push ary[ii]
+    end
+    
+    if (tup_size >=3) && (group.count >= tup_size)  # stardard match finds smaller things ...
+      ptup = []
+      group.combination(tup_size) do |combo|
+        ta = combo.to_bset
+        next unless ta.count == tup_size
+        next if ta <= error
+        if ta <= ptup  # we have an error! There can only be one tuple
+          pp = []
+          ptup.count.times do |ii|
+            pp.push ptup[ii] unless ta==ptup[ii]
+          end
+          ptup = pp
+          error.push ta
+        else
+          ptup.push ta
+        end
+      end    
+      valid.concat ptup
+    end
+    
+    # ok everything is in the bin ... what about the shorts of the previous calls?
+    # let's just mark what we know for next time ...
+    ary.count.times do |ii|
+      next if ary[ii].setfu_tag?
+      if ary[ii] <= valid
+        ary[ii].setfu_tag = :valid
+      elsif ary[ii] <= error
+        ary[ii].setfu_tag = :error
+      end
+    end
+    
+    return [valid,error]
+  end
+  
+  def self.tuples(ary)  # errors include empty sets
+    src = []
+    valid = []
+    error = []
+    ary.each do |bs|
+      if bs.empty?
+        error.setfu_push_unique bs
+      else
+        src.push bs  
+      end
+    end
+    src.count.times do |tup_no|
+      rslt = find_tuple(src, tup_no)
+      valid.concat rslt[0]
+      error.concat rslt[1] # was 2 ... but removed short
+    end
+    src.count.times do |idx|
+      next if src[idx] <= valid
+      next if src[idx] <= error
+    end
+    return [valid,error] if true
+  end
+    
+  def self.reduce(ary)
+    elms = ary.count
+    # process tupples ... first check for errors
+    tups = tuples(ary)
+    unless (tups.last.empty?)
+      ary.setfu_tag = tups.last  # tag with broken set items
+      return -1  # can't reduce a system of errors
+    end
+    if (tups.first.empty?)
+      return 0
+    end
+    tups = tups[0].reverse  # we only need the good ones.
+    reductions = 0
+    loop do
+      tup = tups.pop    
+      elms.times do |idx|
+        if (tup ** ary[idx]) && !(ary[idx] <= tup)
+          ary[idx] -= tup
+          reductions += 1
+        end
+      end
+      break if tups.empty?
+    end
+    return reductions
+  end
+
+  # returns the tuple, else nil  
+  def self.tuple(ary)
+    tup = ary.to_bset
+    return nil unless tup.size==ary.count
+    return tup if ary.size == 1 # trivial case
+    if ary.size==2
+      return tup if ary.first==ary.last
+    end
+    ary.count.times do |idx|
+      ta = ary - [ary[idx]]
+      return nil if tuple?(ta)
+    end
+    return tup
+  end
+  
+  # the whole thing must be a tuple else false
+  def self.tuple?(ary)  # from documentation
+    return false if ary.empty?
+    tup = ary.to_bset
+    return false unless tup.size==ary.count
+    return true if ary.size == 1 # trivial case
+    if ary.size==2
+      return true if ary.first==ary.last
+    end
+    ary.count.times do |idx|
+      ta = ary - [ary[idx]]
+      return false if tuple?(ta)
+    end
+    return true
+  end
+end
+
+class BitSet
+  def untag
+    BitSet.new | self
+  end
+  def untag!
+    remove_instance_variable :@bo_setfu_tag rescue :never_mind
+    remove_instance_variable :@bo_setfu_count rescue :never_mind
+  end
+end
+
+class Array
+  def members_to_bset
+    Setfu::bset_elements(self)
+    self
+  end
+  def tuples
+    members_to_bset
+    rtn = Setfu::tuples(self)
+    rtn
+  end
+  def tuple?
+    Setfu::tuple?(self)
+  end
+  def tuple
+    Setfu::tuple(self)
+  end
+  def reduce_tuples(passes = 1)
+    Setfu::bset_elements(self)
+    Setfu::untag_bset_elements(self)
+    total_count = 0
+    loop do
+      tc = Setfu::reduce(self)
+      if tc < 0
+        total_count = -1
+        break
+      end
+      break if tc == 0
+      total_count += tc
+      passes -= 1
+      break if passes <= 0
+    end
+    total_count
+  end
+  def untag_bset_elements
+    Setfu::untag_bset_elements(self)
+  end
+end
 
 class BitSet
   attr_reader :entropy
+
+# can't do this ... already using operators for something else
+=begin  
+  include Comparable
+  def <=>(other)
+    @bits <=> other.to_bset.to_i
+  end
+=end
   
   def entropy=(ent)  # entropy only gets bigger, just like the universe!
     @entropy = ent unless @entropy > ent
   end
   
+  def self.fill(n_elms, start=0)
+    set = BitSet.new
+    bits = (1 << n_elms) - 1
+    set.set_bits!(bits)
+    set.entropy=n_elms
+    set.inc!(start.ord)
+    return set
+  end  
+  
   def self.uppercase_chars
     set = BitSet.new
     set.set_bits!(2475880041677272402379145216)
@@ -176,6 +419,10 @@ class BitSet
     self
   end
   
+  def size
+    count
+  end
+  
   def inc!(n=1)
     raise "illegal negative parameter in #inc" if n < 0
     @entropy += n
@@ -237,7 +484,7 @@ class BitSet
   
   def ^(item)
     rtn = self.dup
-    if(item.class==BitSet)
+    if(item.type_of? BitSet)
       rtn.set_bits!(rtn.to_i ^ item.to_i)
     else
       rtn = BitSet.new(item)
@@ -248,7 +495,7 @@ class BitSet
 
   def |(item)
     rtn = self.dup
-    if(item.class==BitSet)
+    if(item.type_of? BitSet)
       rtn.set_bits!(rtn.to_i | item.to_i)
       self.entropy=item.entropy
     else
@@ -260,7 +507,7 @@ class BitSet
 
   def &(item)
     rtn = self.dup
-    if(item.class==BitSet)
+    if(item.type_of? BitSet)
       rtn.set_bits!(rtn.to_i & item.to_i)
     else
       rtn = BitSet.new(item)
@@ -273,7 +520,7 @@ class BitSet
     rtn = BitSet.new
     rtn.entropy = self.entropy
     a = self.to_i
-    if(item.class==BitSet)
+    if(item.type_of? BitSet)
       b = item.to_i
       rtn.entropy = item.entropy
     else
@@ -295,7 +542,7 @@ class BitSet
 
   # comparison operators:
   def ==(item)
-    if(item.class==BitSet)
+    if(item.type_of? BitSet)
       rtn = item.to_i == self.to_i
     else
       rtn = BitSet.new(item).to_i == self.to_i
@@ -304,7 +551,7 @@ class BitSet
   end
 
   def !=(item)
-    if(item.class==BitSet)
+    if(item.type_of? BitSet)
       rtn = item.to_i != self.to_i
     else
       rtn = BitSet.new(item).to_i != self.to_i
@@ -312,6 +559,10 @@ class BitSet
     rtn
   end
   
+  def eql?(item)
+    self.==(item)
+  end
+  
   def set_case(mode=:mode_equal)
     @mode = mode
     self
@@ -352,13 +603,15 @@ class BitSet
   end
 
   def add!(items)
-    if(items.class==BitSet)
+    if(items.type_of? BitSet)
       @bits |= items.to_i
       entropy = items.entropy
-    elsif(items.class==Range)
-      f=items.first.ord
-      l=items.last.ord
-      f,l = l,f if f>l
+    elsif(items.type_of? Range)
+      ran = items.reorder.simplify
+      return add!(ran.to_a) unless ran.simple?
+      f=ran.first.ord
+      l=ran.last.ord
+      # f,l = l,f if f>l
       t = (l-f)+1
       t = (1 << t)-1
       @bits |= t << f
@@ -392,14 +645,16 @@ class BitSet
   def include?(items)
     return false if items.nil?   # sets never include nil
     return false if @bits == 0   # empty sets include nothing including other empty sets
-    if(items.class==BitSet)
+    if(items.type_of? BitSet)
       tmp = @bits & items.to_i
       return false if tmp==0
       return (tmp) == items.to_i
-    elsif(items.class==Range)
-      f=items.first.ord
-      l=items.last.ord
-      f,l = l,f if f>l
+    elsif(items.type_of? Range)
+      ran = items.reorder.simplify
+      return(include?(ran.to_a)) unless ran.simple?
+      f=ran.first.ord
+      l=ran.last.ord
+      # f,l = l,f if f>l
       t = (l-f)+1
       t = (1 << t)-1
       t = t << f
@@ -423,6 +678,7 @@ class BitSet
   end
   
   def reverse_each(*prms)  # do a benchmark and see which is faster, reverse_each or each
+    return Enumerator.enumerate_yields(self, :reverse_each, *prms) unless block_given?
     int_mode = true
     set = self.dup
     prms.each do |prm|
@@ -433,20 +689,13 @@ class BitSet
       end
     end
     ary = set.to_a(int_mode)
-    unless block_given?
-      enu = Enumerator.new do |yy|
-        while !ary.empty?
-          yy <<  ary.pop
-        end
-      return enu  
-      end
-    end
     while !ary.empty?
       yield ary.pop
     end
   end
 
   def each(*prms)
+    return Enumerator.enumerate_yields(self, :each, *prms) unless block_given?
     bits = @bits
     pos = 0
     stop = nil
@@ -463,21 +712,6 @@ class BitSet
         chr_mode = !prm
       end
     end
-    unless block_given?
-      enu = Enumerator.new do |yy|
-        while bits > 0
-          if ((bits & 1) == 1)
-            yy <<  chr_mode ? pos.chr(Encoding::UTF_8) : pos
-          end
-          pos += 1
-          unless stop.nil?
-            break if pos > stop
-          end
-          bits >>= 1
-        end # while
-      end # do 
-      return enu  
-    end # unless
     while bits > 0
       if ((bits & 1) == 1)
         yield chr_mode ? pos.chr(Encoding::UTF_8) : pos
@@ -575,9 +809,9 @@ class BitSet
   def [](*pset)
     idx = nil
     if pset.count==1  # check for single instance  inst[5], inst['t']
-      if pset.first.kind_of? Integer
+      if pset.first.type_of? Integer
         idx = pset.first
-      elsif pset.first.kind_of? String
+      elsif pset.first.type_of? String
         if pset.first.length == 1
           idx = pset.first.ord
         end
@@ -605,8 +839,7 @@ class BitSet
   end  
     
   # :array  :array_chars  :string  :set   
-  def rand(elm_count, format = :set)
-    raise "rand minimum count too low" if elm_count < 1
+  def rand(elm_count, format = :bset)
     ary = self.to_a
     ary.shuffle!
     ary = ary[0..(elm_count-1)]
@@ -625,10 +858,36 @@ class BitSet
           rtn.push elm.chr(Encoding::UTF_8)
         end
         return rtn.join ""
-      else # :set
+      else # :bset
         return ary.to_bset
     end
-  end  
+  end 
+  
+  def rand!(elm_count, format = :bset)
+    ary = self.to_a
+    rna = ary.shuffle[0..(elm_count-1)]
+    replace rna.to_bset
+    case format
+      when :array
+        return (ary - rna).shuffle
+      when :array_chars
+        src = (ary - rna).shuffle
+        rtn = []
+        src.each do |elm|
+          rtn.push elm.chr(Encoding::UTF_8)
+        end
+        return rtn
+      when :string
+        src = (ary - rna).shuffle
+        rtn = []
+        src.each do |elm|
+          rtn.push elm.chr(Encoding::UTF_8)
+        end
+        return rtn.join ""
+      else # :bset
+        return (ary - rna).to_bset
+    end
+  end
   
 end  # end BitSet
 
@@ -675,7 +934,7 @@ end
 module SetFuMixinTrippleEqualsOperator
   alias_method :old_triple_equal4Set, :===
   def ===(item)
-    return old_triple_equal4Set(item) unless (item.class==BitSet)
+    return old_triple_equal4Set(item) unless (item.type_of? BitSet)
     return self.to_bset === item
   end
 end
@@ -717,13 +976,13 @@ class String
   include SetFuMixinBinarySubtractOperator
 
   def <=(item)
-    return old_string_lte4set(item) if (item.class==String)
+    return old_string_lte4set(item) if (item.type_of? String)
     a = BitSet.new(self)
     b = BitSet.new(item)
     return a <= b
   end
   def <(item)
-    return old_string_lt4set(item) if (item.class==String)
+    return old_string_lt4set(item) if (item.type_of? String)
     a = BitSet.new(self)
     b = BitSet.new(item)
     return a < b
@@ -735,27 +994,37 @@ class Array
   alias_method :old_and_method4set, :&
   alias_method :old_or_method4set, :|
 
-  include SetFuMixinBinaryXorOperator
+  # include SetFuMixinBinaryXorOperator
   include SetFuMixinBinaryIntersectionOperator
   include SetFuMixinToSetMethod
   include SetFuMixinTrippleEqualsOperator
   include SetFuMixinBinarySubsetOperator
   include SetFuMixinBinaryProperOperator
+  
+  def ^(item)
+    if item.type_of? Array
+      return (self | item) - (self & item)
+    else
+      a = BitSet.new(self)
+      b = BitSet.new(item)
+      return a ^ b
+    end
+  end
 
   def -(item)
-    return old_subtract_method4set(item) if (item.class==Array)
+    return old_subtract_method4set(item) if (item.type_of? Array)
     a = BitSet.new(self)
     b = BitSet.new(item)
     return a - b 
   end
   def &(item)
-    return old_and_method4set(item) if (item.class==Array)
+    return old_and_method4set(item) if (item.type_of? Array)
     a = BitSet.new(self)
     b = BitSet.new(item)
     return a & b 
   end
   def |(item)
-    return old_or_method4set(item) if (item.class==Array)
+    return old_or_method4set(item) if (item.type_of? Array)
     a = BitSet.new(self)
     b = BitSet.new(item)
     return a | b 
@@ -1139,6 +1408,27 @@ class BitSet
     @@UTF_UPPER_CASE_DUAL_SET = "".to_bset
     @@UTF_MIXED_CASE_DUAL_SET = "".to_bset
   end
+
+  def self.uppercase_utf_chars(return_set=true)
+    return @@UTF_UPPER_CASE_SET.dup if return_set
+    return @@UTF_UPPER_CASE_CHARS.dup
+  end  
+  def self.lowercase_utf_chars(return_set=true)
+    return @@UTF_LOWER_CASE_SET.dup if return_set
+    return @@UTF_LOWER_CASE_CHARS.dup
+  end
+  def self.mixcase_utf_chars(return_set=true)
+    return @@UTF_MIXED_CASE_DUAL_SET.dup if return_set
+    return @@UTF_MIXED_CASE_DUAL_CHARS.dup
+  end
+  def self.dual_uppercase_utf_chars(return_set=true)
+    return @@UTF_UPPER_CASE_DUAL_SET.dup if return_set
+    return @@UTF_UPPER_CASE_DUAL_CHARS.dup
+  end
+  def self.dual_lowercase_utf_chars(return_set=true)
+    return @@UTF_LOWER_CASE_DUAL_SET.dup if return_set
+    return @@UTF_LOWER_CASE_DUAL_CHARS.dup
+  end
   
   def self.modify_utf_sets(*prms)
     flag_add = true
@@ -1146,11 +1436,15 @@ class BitSet
     target_set   = nil
     source = nil
     prms.each do |prm|
-      if    prm.kind_of? String
+      if    prm.type_of? String
         source = prm
-      elsif prm.kind_of? BitSet
+      elsif prm.type_of? BitSet
         source = prm
-      elsif prm.kind_of? Symbol
+      elsif prm.type_of? Array
+        source = prm
+      elsif prm.type_of? Integer
+        source = [prm]
+      elsif prm.type_of? Symbol
         if prm == :rm
           flag_add = false
         elsif prm == :add
@@ -1175,32 +1469,61 @@ class BitSet
     end
     return false if target_chars.nil? 
     return false if source.nil?
-    return false unless source ** target_set
     if flag_add
       eval("#{target_set} |= source")
-      eval("#{target_chars} |= #{target_set}.to_s")
+      eval("#{target_chars} = #{target_set}.to_s")
     else
       eval("#{target_set} -= source")
-      eval("#{target_chars} -= #{target_set}.to_s")
+      eval("#{target_chars} = #{target_set}.to_s")
     end
     return true
   end
+    
+  def add_lowercase_utf
+    return BitSet.lowercase_utf_chars | self
+  end
   
-  def self.uppercase_utf_chars
-    return @@UTF_UPPER_CASE_SET.dup
-  end  
-  def self.lowercase_utf_chars
-    return @@UTF_LOWER_CASE_SET.dup
+  def add_lowercase_utf!
+    add! BitSet.lowercase_utf_chars
+    self
+  end
+
+  def add_uppercase_utf
+    return BitSet.uppercase_utf_chars | self
   end
-  def self.mixcase_utf_chars
-    return @@UTF_MIXED_CASE_DUAL_SET.dup
+  
+  def add_uppercase_utf!
+    add! BitSet.uppercase_utf_chars
+    self
   end
-  def self.dual_uppercase_utf_chars
-    return @@UTF_UPPER_CASE_DUAL_SET.dup
+
+  def add_mixcase_utf
+    return BitSet.mixcase_utf_chars | self
   end
-  def self.dual_lowercase_utf_chars
-    return @@UTF_LOWER_CASE_DUAL_SET.dup
+  
+  def add_mixcase_utf!
+    add! BitSet.mixcase_utf_chars
+    self
+  end
+
+  def add_dual_upper_utf
+    return BitSet.dual_uppercase_utf_chars | self
   end
+  
+  def add_dual_upper_utf!
+    add! BitSet.dual_uppercase_utf_chars
+    self
+  end
+
+  def add_dual_lower_utf
+    return BitSet.dual_lowercase_utf_chars | self
+  end
+  
+  def add_dual_lower_utf!
+    add! BitSet.dual_lowercase_utf_chars
+    self
+  end
+  
 end
 
 =begin

data/setfu.gemspec

@@ -24,6 +24,10 @@ When characters are used, the ordinate value sets the element bit of the interna
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
   spec.required_ruby_version = '>= 1.9.1'
+  spec.add_runtime_dependency 'pred', '~> 0.1', '>= 0.1.2'  
+  spec.add_runtime_dependency 'betterobject', '~> 1.2', '>= 1.2.0'
+  spec.add_runtime_dependency 'yieldhelper', '~> 0.1', '>= 0.1.0'
+  spec.add_runtime_dependency 'primitive_wrapper', '~> 2', '>= 2.0.0'
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency 'rake', '~> 10.1', '>= 10.1.0'