setfu 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 20de7e408d7b32f92cb46c72fb9aaaa5b3ecb21b
-  data.tar.gz: 0b3d9d1b0fd55b4251498ec87b2187e6236e1587
+SHA256:
+  metadata.gz: 6835cd9233c1ac203c4fafe4e768e9f8bb9516cc0117c3bf09af283e00701501
+  data.tar.gz: 1e7ada3f3e973a852920d6c7f63370be29850cc1ebd734e02de078071a764520
 SHA512:
-  metadata.gz: 4f22cc1c2ebe5ccc90043b716e6737606b758fefa3fcb5204e61cd7a0eca28413b0a71d9dd99ed9c2ba023e15bba19f1ae0e26238aeacbedc2d502e64718453e
-  data.tar.gz: fa7fcfb09c6916c30e32c400af291c0f9cf92e2b4614e044436d48128c427f7f127025a69d9cd6f8ffde9c98517b62a1c7945e1ae81442e7a33a6420b93fbe14
+  metadata.gz: 21568cf5048c7c855958a91f2c092936e1e4033a902b5bf18d3d6f5ff69914559205ce6539d5e2d1cebe355bd4fda58e21e60d7338315869c8572d53f8d5035a
+  data.tar.gz: 90ca1f585914e530cf9d05241c9d6cc3aeb6b49fcce4777b803512d7c6df767d7e5c24cf387d76d5e1fa18dccd8fcd0d30bfb96444846b4120a6d324f01d9197

data/README.md

@@ -131,6 +131,7 @@ aaa     <  aaa        # false
 BitSet defines array access operators `:[]` and `:[]=` as it it were an array of bits.
 If you pass an Integer type, you will get `true` (if member of set) or `false`.
 Anything else will return a BitSet instance. You can also set or clear members of the set as well.
+Note that more than one value can be set or cleared.
 See the example below:
 
 ```ruby
@@ -176,6 +177,29 @@ Recursion is used to unravel the Array.
 
 These methods remove elements from the BitSet instance if they exist.
 
+#### bitset.neighbor(no_vars,direction)
+
+This is used in a Karnaugh map to find adjacent neighboring cell coordinates.
+The current bitset instance contains the initial vector in the table.
+It is best to use the BitSet.int(initial_coordinate) as the constructor.
+Note that for each variable used in the map, the self-same number determines the total possible number of neighbors.
+The direction has values `0` to `(no_vars-1)`.
+For a 5-variable system, we can have left, right, up, down, or over for possible connecting cells.
+This method is extensively used in the upcoming `gatefu` gem which deals with logic systems.
+
+
+#### bitset.double, bitset.double!
+
+This method doubles the entropy and copies the original bottom to the top half.
+This doubles the number of elements.
+The bang version self-modifies while the non-bang version creates a new instance.
+
+#### bitset.swap(position1, position2), bitset.swap!(position1, position2)
+
+This method looks up the values of position1, and position2 and stores them in swapping fashion.
+The bang version self modifies, while the non-bang version returns a new instance (without modification of original).
+
+
 #### bitset.include?(item)
 
 Returns true if p is a subset. Parameter `p` can be:
@@ -189,6 +213,10 @@ Returns true if there are no elements in the BitSet instance.
 
 This removes all elements from the BitSet instance making it empty. Self-modifies.
 
+#### bitset.set_all!
+
+This sets all possible elements of the set (up to the entropy).
+
 #### bitset.dup
 
 This create and returns a duplicate copy of the BitSet instance.
@@ -215,7 +243,7 @@ This routine is computationally slow as each bit must be examined.
 #### bitset.to_ra(int=true, th=3)
 
 This returns as array filled with either integers or ranges of integers. The threshold parameter decides the minimum range size
-that will be used. The minimum value is 2. The `int` parameter when set to false will return string characters and string ranges.
+that will be used. The minimum allowed value for `th` is 2. The `int` parameter when set to false will return string characters and string ranges.
 This routine is computationally slow as each bit must be examined.
 
 #### bitset.set_bits!(n)
@@ -230,7 +258,7 @@ This returns the current entropy number of the set. You can also set this proper
 like the universe entropy can only increase.
 
 #### bitset.entropy_2n!
-This sets the entropy number to the nearest 2**n that will contain the highest set element.
+This sets the entropy number to the nearest `2**n` that will contain the highest set element.
 
 #### bitset.first(int=true), bitset.first!(int=true)
 This returns the first element of the set, or nil if the set is empty.
@@ -354,7 +382,47 @@ This bisects the set into two roughly equally sized sets and returns an array of
 The first set contains the lower elements, while the second set contains the higher elements.
 The bang version retaines the lower elements are returns the higher elements.
 
-###Class Methods
+### Utility Methods on standard objects
+
+#### array.pop2
+This is similar to `array.pop(2)` except that the returning array is reversed.
+
+#### array.stack_swap
+This reverses the data values of the last two elements of the array.
+
+#### array.stack_rot
+This rotates the last three values of the array as seen the the example below:
+```ruby
+  array = [1,2,3,4,5]
+  array.stack_rot  #  [1, 2, 5, 3, 4]
+```
+
+#### array.peek(pos=0)
+This indexes the array from right to left.
+
+#### array.ascending?
+Returns true if elements of the array are sorted in ascending order, have two or more elements, and first element not equal to last element.
+
+#### array.descending?
+Returns true if elements of the array are sorted in descending order, have two or more elements, and first element not equal to last element.
+
+#### array.sorted?
+Returns true if elements of the array are sorted in either ascending or descending order, and have one or more elements.
+
+### BitSet Class Methods
+
+#### BitSet.generate_pattern(num_bits, zero_first_flag, num_zeros, num_ones)
+This generates BitSet instance with a pattern of contiguous ones(elements of the set) and zeros(voids of the set)
+starting from position zero and stopping on the num_bits parameter.  See the example below:
+
+```ruby
+bs = BitSet.generate_pattern(19, false, 3, 5)
+bs.to_ra # [0..4, 8..12, 16..18]
+``` 
+
+#### BitSet.int(int, ent=nil)
+This constructor sets the internal Integer instance to `int` and if provided, sets the internal entropy to `ent`.
+If not provided, the entropy will be automatically calculated.
 
 ### BitSet.fill(num_elements, start=0)
 This constructs a BitSet instance with contiguous values set to the parameter `num_elements`.
@@ -556,7 +624,7 @@ This utility method converts elements of the array to BitSets instances.
 During the reduction process some items in the array get tagged. This routine clears such tagging.
 This is a utility method called by the `#reduce_tuples` method.
 
-###case subsumption operator ===
+### case subsumption operator ===
 The `===` operator has special meaning in ruby. It is known as the case subsumption operator.
 It is used during the `case when` statements as its comparison means.
 The left side of the operator's type is the owner and defines what it means to have the right side passed to it.
@@ -646,6 +714,14 @@ the right opperand takes precedence however.
 
 ## Revision History
 
+### Version 3.1.0
+
+* added BitSet.int constructor
+* added BitSet.generate_pattern constructor
+* added BitSet methods: neighbor, double, double!, swap, swap! set_all!
+* added Array stack methods: pop2, stack_swap, stack_rot, peek
+* added Array utility methods: ascending?, descending?, sorted?
+
 ### Version 3.0.1
 
 * updated @@TRANS_HASH to include missing translation: (422,640)

data/lib/setfu.rb

@@ -15,6 +15,188 @@ class Object
   better_install_as!(:delete_many_at, :setfu_delete_many_at)
 end
 
+###
+### Version 3.2.0 additions
+###
+
+# ::TODO:: add document
+class Array
+  def stack_swap
+    a = pop
+    b = pop
+    push a
+    push b
+  end
+  def stack_rot
+    a = pop
+    b = pop
+    c = pop
+    push a
+    push c
+    push b
+  end
+  def pop2
+    a = pop
+    b = pop
+    return [a,b]
+  end
+  def peek(n=0)
+    return self[count-n-1]
+  end
+end
+
+# ::TODO:: add document
+class Array  # additions to be used by other future gems:
+  def ascending?
+    return false unless count >=2
+    cnt = self.length - 1
+    cnt.times do |ii|
+      return false unless self[ii+1] >= self[ii]
+    end
+    return false if first==last  # ascending means something has to get bigger
+    true
+  end
+  def descending?
+    return false unless count >=2
+    cnt = self.length - 1
+    cnt.times do |ii|
+      return false unless self[ii+1] <= self[ii]
+    end
+    return false if first==last  # descending means something has to get smaller
+    true
+  end
+  def sorted?
+    return false unless count >=1
+    return true if (self & self).count == 1  # [4,4,4,4] is sorted, but not ascending or desending
+    return true if ascending?
+    return true if descending?
+    false
+  end
+end
+
+# ::TODO:: add document
+class BitSet
+  def swap!(pos1,pos2)
+    self[pos1],self[pos2] = self[pos2], self[pos1]
+    self
+  end
+  def swap(pos1,pos2)
+    bs = dup
+    bs[pos1],bs[pos2] = self[pos2], self[pos1]
+    bs
+  end
+end
+
+# ::TODO:: add document
+# this routine takes a linear binary table and finds a coordinate neighbor.
+# not to be confused with finding a neighbor in a Logic Map.
+#   of a given map
+class BitSet
+  def neighbor(nvars, dir)
+    raise "too many neighbors for #{nvars} variables" if dir >= nvars
+    raise "dir must be positive" if dir.negative?
+    rtn = dup
+
+    if 1==nvars      # two squares
+      rtn[dir]=!self[dir]
+    elsif 2==nvars   # a 2x2 box
+      if 0==dir
+        rtn[0]=!self[0]
+      else
+        rtn[1]=!self[1]
+      end
+    end
+    # now programmatically do the remaining pattern
+    if nvars.even?
+      if dir.even?   # up if dir==0 and nvars==4  ... left if dir==2 and nvars==4
+        rtn[dir]=self[dir+1]
+        rtn[dir+1]=!self[dir]
+      else          # down if dir ==1 and nvars==4 ... right if dir==3 and nvars==4
+        rtn[dir-1]=!self[dir]  # modified on dec 21, 2019  9:34AM
+        rtn[dir]=self[dir-1]
+      end
+    else # odd    .......... compare with neighbor5    dir [0,1,2,3,4]
+      if dir==(nvars-1)   # dir==4
+        rtn[dir]=!self[dir]
+      elsif dir.even?          # 0,2 validated
+        rtn[dir]=self[dir+1]
+        rtn[dir+1]=!self[dir]
+      else                     # 1,3 validated
+        rtn[dir-1]=!self[dir]
+        rtn[dir]=self[dir-1]
+      end
+    end
+    return rtn
+  end
+end  
+
+# this one will get added to setfu soon.
+class BitSet
+  def self.generate_pattern(nbits, flag_zero_first, zeros, ones )
+    bs = BitSet.new
+    bs.entropy = nbits
+    return bs if ones<=0
+    return bs | [0..(nbits-1)] if zeros<=0
+    k=0
+    hash = {:zero => zeros, :one => ones}
+    if flag_zero_first
+      ptr = :zero
+      val = false
+    else
+      ptr = :one
+      val = true
+    end
+    nbits.times do |ii|
+      if (k >= hash[ptr])
+        k = 1
+        val = !val
+        ptr = (ptr == :zero) ? :one : :zero
+      else
+        k += 1  
+      end
+      bs[ii] = val
+    end
+    return bs
+  end
+end
+
+# add this one to setfu  ... also create non bang version
+class BitSet
+  def double!
+    @bits |= @bits << @entropy
+    @entropy <<= 1
+    self    
+  end
+  def double
+    dup.double!
+  end
+end
+
+# this should be added to gem ...
+class BitSet
+  def self.int(int,ent=nil)
+    bs = BitSet.new
+    bs.set_bits!(int)
+    if ent.nil?
+      bs.recalculate_entropy!
+    else
+      bs.entropy=ent
+    end
+    bs
+  end
+end
+
+class BitSet
+  def set_all!  # set all possible bits   ... make sure this does not already exist ... if it does, then use the proper name
+    bits = (2 ** entropy) - 1
+    set_bits! bits
+  end
+end
+
+###
+###  Version 3.1.0 and older
+###
+
 module Setfu
   def self.bset_elements(ary)
     ary.count.times do |ii|

data/lib/setfu/version.rb

@@ -1,3 +1,3 @@
 module Setfu
-  VERSION = "3.0.1"
+  VERSION = "3.1.0"
 end

data/setfu.gemspec

@@ -26,7 +26,7 @@ When characters are used, the ordinate value sets the element bit of the interna
   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_runtime_dependency 'primitive_wrapper', '~> 2', '>= 2.3.0'
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency 'rake', '~> 10.1', '>= 10.1.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: setfu
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Bryan Colvin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-26 00:00:00.000000000 Z
+date: 2020-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pred
@@ -79,7 +79,7 @@ dependencies:
         version: '2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -89,7 +89,7 @@ dependencies:
         version: '2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.3.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -206,7 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Set class