setfu 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72565070f36393bad5dc9eb8cbeba0dd49804c9a
-  data.tar.gz: c1efb9f7cff8811a55282d31f6cbe0eda66a1bff
+  metadata.gz: 86cb17462d85ca1892275124d15b258e39500a81
+  data.tar.gz: 0c6b22148997f47f43494269c18fe78de5cec4fc
 SHA512:
-  metadata.gz: 1256c103b03a79bfc631377c9eea812cbea1743fb7526a7c1fbd1edc366f04edc6fe6777a1ba320bb14d8290924bf701af2f7720327dfcabb7a9255d63488842
-  data.tar.gz: 729b9b90ff87bda5ccd4b70f9241daed3a613ac16d9b74933903c79fe5bf0d5ba732aaf4cc659ad156d473c94b356caef1f4bec6d9a383111a73aa4ea91783ee
+  metadata.gz: ba3a1ecece8183f14ce227512e19b89fcda2724bcc84e7e5ec67e81b7c781013375ac29cd777370411dc9aaf499117fcc6100857211e06d9bc92713a360ffa89
+  data.tar.gz: c4f64253c8796b4e917aa09a0ff93eeefe9e2a05b39e5f212968aa51e02c8f123dfb662707f646c06362f79d7cf3ba9ac912e0f13f4649622a5bb66d6ee2dfb9

data/lib/setfu.rb

@@ -1,6 +1,6 @@
 require "setfu/version"
 
-class Set
+class BitSet
   attr_reader :entropy
   
   def entropy=(ent)  # entropy only gets bigger, just like the universe!
@@ -8,42 +8,42 @@ class Set
   end
   
   def self.uppercase_chars
-    set = Set.new
+    set = BitSet.new
     set.set_bits!(2475880041677272402379145216)
     set.entropy=91
     return set
   end
   
   def self.lowercase_chars
-    set = Set.new
+    set = BitSet.new
     set.set_bits!(10633823807823001954701781295154855936)
     set.entropy=123
     return set
   end
   
   def self.letter_chars
-    set = Set.new
+    set = BitSet.new
     set.set_bits!(10633823810298881996379053697534001152)
     set.entropy=123
     return set
   end
   
   def self.digit_chars
-    set = Set.new
+    set = BitSet.new
     set.set_bits!(287948901175001088)
     set.entropy=58
     return set
   end
   
   def self.parse_chars
-    set = Set.new
+    set = BitSet.new
     set.set_bits!(159507359650170349735020301117175103487)
     set.entropy=127
     return set
   end
   
   def replace(ent)
-    ent = ent.to_set
+    ent = ent.to_bset
     @mode = ent.mode
     @entropy = ent.entropy
     @bits = ent.to_i
@@ -52,53 +52,111 @@ class Set
   
   def add_parse_chars!
     # add! [0..47, 58..64, 91..96, 123..126]
-    add! Set.parse_chars
+    add! BitSet.parse_chars
     self
   end
   
   def add_parse_chars
-    return Set.parse_chars | self
+    return BitSet.parse_chars | self
   end
   
   def add_digit_chars!
-    add! Set.digit_chars
+    add! BitSet.digit_chars
     self
   end
   
   def add_digit_chars
-    return Set.digit_chars | self
+    return BitSet.digit_chars | self
   end
   
   def add_uppercase_chars!
-    add! Set.uppercase_chars
+    add! BitSet.uppercase_chars
     self
   end
 
   def add_uppercase_chars
-    return Set.uppercase_chars | self
+    return BitSet.uppercase_chars | self
   end
   
   def add_lowercase_chars!
-    add! Set.lowercase_chars
+    add! BitSet.lowercase_chars
     self
   end
 
   def add_lowercase_chars
-    return Set.lowercase_chars | self
+    return BitSet.lowercase_chars | self
   end
   
   def add_letter_chars
-    return Set.letter_chars | self
+    return BitSet.letter_chars | self
   end
 
   def add_letter_chars!
-    add! Set.letter_chars
+    add! BitSet.letter_chars
     self
   end
   
+  #    01100010011111111100010101001101   ... test
+  #   01100010011111111100010101001101    ... left shift
+  #   001000000011111111000000000001000   ... and with left shift
+  #
+  #    01100010011111111100010101001101   ... test
+  #    00110001001111111110001010100110    ... right shift
+  #    00100000001111111100000000000100    ... and with right shift
+  #  
+  #   001000000011111111000000000001000   ... AND with left shift
+  #    00100000001111111100000000000100    ... AND with right shift
+  #   001100000011111111100000000001100    ... OR the two ands
+  #    01100010011111111100010101001101   ... test original
+  #    01100000011111111100000000001100   ... BINGO ... original with the OR  gives us the runs only
+  #    00000010000000000000010101000001   ... BINGO ... original XOR with OR gives us the singles!  
+
+  def runs # runs    << creates a set of touching elements
+    an_l = (@bits << 1) & @bits
+    an_r = (@bits >> 1) & @bits
+    or_lr = an_l | an_r
+    rtn = BitSet.new
+    rtn.set_bits!(or_lr & @bits)
+    rtn.entropy=self.entropy
+    return rtn
+  end
+
+  def singles # singles << creates a set of non-touching elements 
+    an_l = (@bits << 1) & @bits
+    an_r = (@bits >> 1) & @bits
+    or_lr = an_l | an_r
+    rtn = BitSet.new
+    rtn.set_bits!(or_lr ^ @bits)
+    rtn.entropy=self.entropy
+    return rtn
+  end
+
+  def max_run # max_run << returns maximum number of consecutive numbers
+    return 0 if @bits==0
+    mx = 1
+    bits = @bits
+    loop do
+      bits <<= 1
+      bits &= @bits
+      break if 0 == bits
+      mx += 1
+    end
+    return mx
+  end
+  
+  def runs?(cnt=2)
+    bits = @bits
+    (cnt-1).times do
+      bits <<= 1
+      bits &= @bits
+      return false if 0 == bits
+    end
+    return true
+  end
+  
   def add_opposing_case!
-    aa = Set.lowercase_chars
-    bb = Set.uppercase_chars
+    aa = BitSet.lowercase_chars
+    bb = BitSet.uppercase_chars
     ka = aa & self  # subset lower case
     kb = bb & self  # subset upper case
     @bits |= ka.to_i >> 32
@@ -111,7 +169,7 @@ class Set
     dup.add_opposing_case!
   end
   
-  def to_set
+  def to_bset
     return self
   end
   
@@ -119,10 +177,10 @@ class Set
     return @mode
   end
   
-  def initialize(data=nil)
+  def initialize(*data)
     @bits = 0
     @entropy = 0
-    add!(data) unless data.nil?
+    add!(data)
     self
   end
 
@@ -132,6 +190,25 @@ class Set
     self
   end
   
+  def inc!
+    @entropy += 1
+    @bits <<= 1
+    self
+  end
+
+  def dec!
+    @bits >>= 1
+    self
+  end
+  
+  def inc
+    return dup.inc!
+  end
+
+  def dec
+    return dup.dec!
+  end
+  
   def recalculate_entropy!
     @entropy = 0
     bits = @bits
@@ -165,17 +242,17 @@ class Set
   end
   
   def dup
-    rtn = Set.new
+    rtn = BitSet.new
     rtn.replace(self)
     return rtn
   end
   
   def ^(item)
     rtn = self.dup
-    if(item.class==Set)
+    if(item.class==BitSet)
       rtn.set_bits!(rtn.to_i ^ item.to_i)
     else
-      rtn = Set.new(item)
+      rtn = BitSet.new(item)
       rtn.set_bits!(@bits ^ rtn.to_i)
     end
     rtn
@@ -183,11 +260,11 @@ class Set
 
   def |(item)
     rtn = self.dup
-    if(item.class==Set)
+    if(item.class==BitSet)
       rtn.set_bits!(rtn.to_i | item.to_i)
       self.entropy=item.entropy
     else
-      rtn = Set.new(item)
+      rtn = BitSet.new(item)
       rtn.set_bits!(@bits | rtn.to_i)
     end
     rtn
@@ -195,24 +272,24 @@ class Set
 
   def &(item)
     rtn = self.dup
-    if(item.class==Set)
+    if(item.class==BitSet)
       rtn.set_bits!(rtn.to_i & item.to_i)
     else
-      rtn = Set.new(item)
+      rtn = BitSet.new(item)
       rtn.set_bits!(@bits & rtn.to_i)
     end
     rtn
   end
 
   def -(item)
-    rtn = Set.new
+    rtn = BitSet.new
     rtn.entropy = self.entropy
     a = self.to_i
-    if(item.class==Set)
+    if(item.class==BitSet)
       b = item.to_i
       rtn.entropy = item.entropy
     else
-      b = Set.new(item)
+      b = BitSet.new(item)
       rtn.entropy = b.entropy
       b = b.to_i
     end
@@ -223,26 +300,26 @@ class Set
   end
   
   def **(item)  # intersection test
-    set_item = Set.new(item)
+    set_item = BitSet.new(item)
     return false if (self & set_item).empty?
     return true
   end
 
   # comparison operators:
   def ==(item)
-    if(item.class==Set)
+    if(item.class==BitSet)
       rtn = item.to_i == self.to_i
     else
-      rtn = Set.new(item).to_i == self.to_i
+      rtn = BitSet.new(item).to_i == self.to_i
     end
     rtn
   end
 
   def !=(item)
-    if(item.class==Set)
+    if(item.class==BitSet)
       rtn = item.to_i != self.to_i
     else
-      rtn = Set.new(item).to_i != self.to_i
+      rtn = BitSet.new(item).to_i != self.to_i
     end
     rtn
   end
@@ -257,7 +334,7 @@ class Set
     # item ... case clause  ... case(item)
     # Note: coerce does not work in this context ...
     
-    md = item.to_set.mode || @mode
+    md = item.to_bset.mode || @mode
     
     case md
       when :mode_intersection
@@ -276,18 +353,18 @@ class Set
   end
   
   def <=(item)
-    si = Set.new item
+    si = BitSet.new item
     return si.include?(self)
   end
   
   def <(item)
-    si = Set.new item
+    si = BitSet.new item
     return false if (si == self)  # not a 'proper' subset
     return si.include?(self)
   end
 
   def add!(items)
-    if(items.class==Set)
+    if(items.class==BitSet)
       @bits |= items.to_i
       entropy = items.entropy
     elsif(items.class==Range)
@@ -325,8 +402,9 @@ class Set
   end
 
   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==Set)
+    if(items.class==BitSet)
       tmp = @bits & items.to_i
       return false if tmp==0
       return (tmp) == items.to_i
@@ -458,17 +536,17 @@ class Set
       end
     end
     unless idx.nil?
-      raise "Negative indexes are illegal for Set" if idx < 0
+      raise "Negative indexes are illegal for BitSet" if idx < 0
       self.entropy = idx+1
       y = @bits & (1<<idx)
       return true if y > 0
       return false    
     end
-    return pset.to_set & self
+    return pset.to_bset & self
   end
   
   def []=(*pset,value)  # pset goes in the box, value after '='
-    pset = pset.to_set
+    pset = pset.to_bset
     state = value ? true : false
     if state
       replace pset | self  # add elements to set
@@ -529,47 +607,47 @@ class Set
         end
         return rtn.join ""
       else # :set
-        return ary.to_set
+        return ary.to_bset
     end
   end  
   
-end  # end Set
+end  # end BitSet
 
 module SetFuMixinBinaryAndOperator
   def &(item)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a & b
   end
 end
 
 module SetFuMixinBinaryOrOperator
   def |(item)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a | b
   end
 end
 
 module SetFuMixinBinaryXorOperator
   def ^(item)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a ^ b
   end
 end
 
 module SetFuMixinBinaryIntersectionOperator
   def **(item)  # intersection test
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a ** b
   end
 end
 
 module SetFuMixinToSetMethod
-  def to_set
-    rtn = Set.new(self)
+  def to_bset
+    rtn = BitSet.new(self)
     # byebug
     return rtn
   end
@@ -578,31 +656,31 @@ end
 module SetFuMixinTrippleEqualsOperator
   alias_method :old_triple_equal4Set, :===
   def ===(item)
-    return old_triple_equal4Set(item) unless (item.class==Set)
-    return self.to_set === item
+    return old_triple_equal4Set(item) unless (item.class==BitSet)
+    return self.to_bset === item
   end
 end
 
 module SetFuMixinBinarySubtractOperator
   def -(item)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a - b
   end
 end
 
 module SetFuMixinBinarySubsetOperator
   def <=(item)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a <= b
   end
 end
 
 module SetFuMixinBinaryProperOperator
   def <(item)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a < b
   end
 end
@@ -621,14 +699,14 @@ class String
 
   def <=(item)
     return old_string_lte4set(item) if (item.class==String)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a <= b
   end
   def <(item)
     return old_string_lt4set(item) if (item.class==String)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a < b
   end 
 end
@@ -647,20 +725,20 @@ class Array
 
   def -(item)
     return old_subtract_method4set(item) if (item.class==Array)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a - b 
   end
   def &(item)
     return old_and_method4set(item) if (item.class==Array)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a & b 
   end
   def |(item)
     return old_or_method4set(item) if (item.class==Array)
-    a = Set.new(self)
-    b = Set.new(item)
+    a = BitSet.new(self)
+    b = BitSet.new(item)
     return a | b 
   end
 end

data/lib/setfu/version.rb

@@ -1,3 +1,3 @@
 module Setfu
-  VERSION = "1.2.1"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: setfu
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Bryan Colvin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-04 00:00:00.000000000 Z
+date: 2016-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler