victory 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00bcbcbc7b4fc5a87806420fd5be8e30e7719ce1212b6b674e08d9ace7e72fdd
-  data.tar.gz: 31ee4514bcb2997b72aee5ea38eec75630ad0181c870ee79d3d16dab0e41d709
+  metadata.gz: e93ae56ddafc7ac1417ad10315adf6f567d22ee164b8edc5f248eed2c090cf27
+  data.tar.gz: 28f25fa29c6dd9a68e512a917c113c8e078ae4c7838bc3f21274567551e7a550
 SHA512:
-  metadata.gz: 2c141a43232ac8012bf7add4eb505c19f6e4dd378b7fb808319646cf1e45d6156bf2f3b47529cf73aa7cbdb8eb464264783b015b95a1f01c33efe1e3bd09c352
-  data.tar.gz: 29c366ee9083993a489f6263a630ac16e8e3dd4d0c653bebce97ce996adfeda2faed40deacbd7b495f89387a791bf8a8881ff73afc2c5762815e5270e52f88be
+  metadata.gz: 84ae4f944daad2fc7a053425a9c73cb230d41f7ff5846692fff6869e47e7d7461a6459041de6934ed5284aa2b324b9f5d4db1481ace28dfa5994903dc7a21124
+  data.tar.gz: 0e6b5adec80cc7268b6b35a72cba740d977e2fa2dd90b33d159cdfad394ab2ed8645438e6b3668f1aa2310ae7907516c14896026358b6314b74be4c01a175dc1

data/Rakefile

@@ -11,12 +11,10 @@ require "rake/extensiontask"
 
 task :build => :compile
 
-Rake::ExtensionTask.new('algorithms/string')        { |ext| ext.name = "CString" }
-Rake::ExtensionTask.new('containers/deque')         { |ext| ext.name = "CDeque" }
-Rake::ExtensionTask.new('containers/bst')           { |ext| ext.name = "CBst" }
-Rake::ExtensionTask.new('containers/rbtree_map')    { |ext| ext.name = "CRBTreeMap" }
-Rake::ExtensionTask.new('containers/splaytree_map') { |ext| ext.name = "CSplayTreeMap" }
-Rake::ExtensionTask.new('containers/xor_list') { |ext| ext.name = 'XORList' }
+require_relative 'extensions'
+extensions.each do |extension|
+  Rake::ExtensionTask.new(extension.path) { |ext| ext.name = extension.name }
+end
 
 require 'rspec/core/rake_task'
 

data/USAGE.md

@@ -2,6 +2,8 @@
 
 In this markdown you will see the usage of all the datastructures and algorithms available through the standard library and this gem.
 
+For them to work you firstly need to require the library with `require 'victory'`.
+
 # Data Structures
 
 * [Ranges and Loops](#ranges)
@@ -15,6 +17,7 @@ In this markdown you will see the usage of all the datastructures and algorithms
 * [Tuple](#tuple)
 * [Graph](#graph)
 * [IOHelpers](#io-helpers)
+* [Concurrent Structures](#concurrent)
 
 <a name="ranges" />
 
@@ -205,6 +208,156 @@ t[2]
 # => 2
 ```
 
+<a name="bitset" />
+
+## Bitset
+
+From [Bitset](https://github.com/ericboesch/bitset):
+
+You create a bitset like this:
+
+    >> Bitset.new(8)
+    => 00000000
+
+Here we created an 8-bit bitset. All bits are initialized to 0.
+
+We can also create a bitset based on a string of ones and zeros.
+
+    >> Bitset.from_s('00010001')
+    => 00010001
+
+or from an array. Falsey values (false and nil) are converted to
+zeroes; all other values, including 0 and "", are converted to ones.
+
+    >> Bitset.new [false, nil, 3, 0]
+    => 0011
+
+To input an array of ones and zeroes:
+
+    >> Bitset.new([0,1,1,0].map(&:positive?))
+    => 0110
+
+Obviously you can also set and clear bits...
+
+    >> bitset = Bitset.new(8)
+    => 00000000
+
+    >> bitset[3] = true
+    => 00010000
+
+    >> bitset[3] = false
+    => 00000000
+
+    >> bitset.set(1, 3, 5, 7)
+    => 01010101
+
+    >> bitset.clear(1, 5)
+    => 00010001
+
+Arrays of Integers can also be passed to #clear and #set (c/o brendon9x).
+
+The point of a bitset is to be, effectively, an array of single bits. It should
+support basic set and bitwise operations. So, let's look at a few of those.
+
+    >> a = Bitset.from_s('00001111')
+    => 00001111
+
+    >> b = Bitset.from_s('01010101')
+    => 01010101
+
+    >> a & b
+    => 00000101
+
+    >> a | b
+    => 01011111
+
+    >> b - a
+    => 01010000
+
+    >> a ^ b
+    => 01011010
+
+    >> ~a
+    => 11110000
+
+    >> a.hamming(b)
+    => 4
+
+    >> a.cardinality
+    => 4
+
+    >> a.reverse
+    => 11110000
+
+    # Tell whether all of the given bit numbers are set
+    >> a.set? 6
+    => true
+
+    # Return a new Bitset composed of bits #1, #3, #5, #4, and #1
+    # again. Unlike Array#values_at, this function currently only
+    # accepts an array of Fixnums as its argument.
+    >> a.values_at [1,3,5,4,1]
+    => 00110
+
+    # Tell whether all of the given bit numbers are clear
+    >> a.clear? 1,3,5
+    => false
+
+    # Tell whether all bits are clear
+    >> a.empty?
+    => false
+
+    # Pass all bits to the block
+    >> b.each { |v| puts v }
+    => false
+       true
+       false
+       ...
+
+    # Pass the positions of all set bits to the block
+    >> b.each_set { |bit| puts bit }
+    => 1
+       3
+       5
+       7
+
+    # Return an array of the positions of all set bits
+    >> b.each_set      # AKA b.to_a
+    => [1, 3, 5, 7]
+
+    # b.each_set(index) == b.each_set[index], but faster.
+    >> b.each_set(-3) # Negative index wraps around.
+    => 3
+
+    # b.each_set(index, len) == b.each_set[index, len], but faster.
+    >> b.each_set(2,2) # Block is also allowed
+    => [5,7]
+
+
+    # The following methods modify a Bitset in place very quickly:
+    >> a.intersect!(b)      #  like a &= b
+    >> a.union!(b)          #  like a |= b
+    >> a.difference!(b)     #  like a -= b
+    >> a.xor!(b)            #  like a ^= b
+    >> a.reset!             # Zeroes all bits
+
+    # Above, "like" does not mean "identical to." a |= b creates a new
+    # Bitset object. a.union!(b) changes an existing object which
+    # affects all variables that point to the same object.
+
+    # Attempting to apply bitwise binary operators or their in-place
+    # equivalents between bitsets of different sizes will raise an
+    # ArgumentError.
+
+    >> b.to_binary_array
+    => [0, 1, 0, 1, 0, 1, 0, 1]
+
+    # b.dup and b.clone are also available.
+
+    # Marshal.dump and Marshal.load are also supported. If you want to
+    # save a few bytes and don't need Marshal.load to work, you can
+    # use #pack and Bitset.unpack instead.
+
 <a name="graph" />
 
 ## Graph
@@ -285,6 +438,114 @@ Writer.string(a, line_sep: "\n", col_sep: ' ', mapper: ->(x) {"0,#{x}"})
 Writer.file("b", a, line_sep: "\n", col_sep: ' ', mapper: ->x {"0,#{x}"}) 
 ```
 
+<a name="concurrent" />
+
+## Concurrent Structures
+
+They are included from [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby). To use them:
+```ruby
+Containers::Concurrent::Array
+include Containers
+Concurrent::Array
+```
+From [Concurrent Ruby Features](https://github.com/ruby-concurrency/concurrent-ruby#features--documentation):
+
+### General-purpose Concurrency Abstractions
+
+*   [Async](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Async.html):
+    A mixin module that provides simple asynchronous behavior to a class. Loosely based on Erlang's 
+    [gen_server](http://www.erlang.org/doc/man/gen_server.html).
+*   [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ScheduledTask.html):
+    Like a Future scheduled for a specific future time.
+*   [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/TimerTask.html):
+    A Thread that periodically wakes up to perform work at regular intervals.
+*   [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html):
+    Unified implementation of futures and promises which combines features of previous `Future`,
+    `Promise`, `IVar`, `Event`, `dataflow`, `Delay`, and (partially) `TimerTask` into a single 
+    framework. It extensively uses the new synchronization layer to make all the features 
+    **non-blocking** and **lock-free**, with the exception of obviously blocking operations like 
+    `#wait`, `#value`. It also offers better performance.    
+
+### Thread-safe Value Objects, Structures, and Collections
+
+Collection classes that were originally part of the (deprecated) `thread_safe` gem:
+
+*   [Array](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Array.html) A thread-safe
+    subclass of Ruby's standard [Array](http://ruby-doc.org/core-2.2.0/Array.html).
+*   [Hash](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Hash.html) A thread-safe
+    subclass of Ruby's standard [Hash](http://ruby-doc.org/core-2.2.0/Hash.html).
+*   [Set](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Set.html) A thread-safe
+    subclass of Ruby's standard [Set](http://ruby-doc.org/stdlib-2.4.0/libdoc/set/rdoc/Set.html).
+*   [Map](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Map.html) A hash-like object
+    that should have much better performance characteristics, especially under high concurrency, 
+    than `Concurrent::Hash`.
+*   [Tuple](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Tuple.html) A fixed size
+    array with volatile (synchronized, thread safe) getters/setters.
+
+Value objects inspired by other languages:
+
+*   [Maybe](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Maybe.html) A thread-safe,
+    immutable object representing an optional value, based on 
+    [Haskell Data.Maybe](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html).
+
+Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
+
+*   [ImmutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ImmutableStruct.html)
+    Immutable struct where values are set at construction and cannot be changed later.
+*   [MutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/MutableStruct.html)
+    Synchronized, mutable struct where values can be safely changed at any time.
+*   [SettableStruct](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/SettableStruct.html)
+    Synchronized, write-once struct where values can be set at most once, either at construction 
+    or any time thereafter.
+
+Thread-safe variables:
+
+*   [Agent](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Agent.html): A way to
+    manage shared, mutable, *asynchronous*, independent state. Based on Clojure's 
+    [Agent](http://clojure.org/agents).
+*   [Atom](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Atom.html): A way to manage
+    shared, mutable, *synchronous*, independent state. Based on Clojure's 
+    [Atom](http://clojure.org/atoms).
+*   [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/AtomicBoolean.html)
+    A boolean value that can be updated atomically.
+*   [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/AtomicFixnum.html)
+    A numeric value that can be updated atomically.
+*   [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/AtomicReference.html)
+    An object reference that may be updated atomically.
+*   [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Exchanger.html)
+    A synchronization point at which threads can pair and swap elements within pairs. Based on 
+    Java's [Exchanger](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Exchanger.html).
+*   [MVar](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/MVar.html) A synchronized
+    single element container. Based on Haskell's 
+    [MVar](https://hackage.haskell.org/package/base-4.8.1.0/docs/Control-Concurrent-MVar.html) and 
+    Scala's [MVar](http://docs.typelevel.org/api/scalaz/nightly/index.html#scalaz.concurrent.MVar$).
+*   [ThreadLocalVar](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ThreadLocalVar.html)
+    A variable where the value is different for each thread.
+*   [TVar](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/TVar.html) A transactional
+    variable implementing software transactional memory (STM). Based on Clojure's 
+    [Ref](http://clojure.org/refs).
+
+### Java-inspired ThreadPools and Other Executors
+
+*   See the [thread pool](http://ruby-concurrency.github.io/concurrent-ruby/master/file.thread_pools.html)
+    overview, which also contains a list of other Executors available.
+
+### Thread Synchronization Classes and Algorithms
+
+*   [CountDownLatch](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/CountDownLatch.html)
+    A synchronization object that allows one thread to wait on multiple other threads.
+*   [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/CyclicBarrier.html)
+    A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
+*   [Event](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Event.html) Old school
+    kernel-style event.
+*   [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ReadWriteLock.html)
+    A lock that supports multiple readers but only one writer.
+*   [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ReentrantReadWriteLock.html)
+    A read/write lock with reentrant and upgrade features.
+*   [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Semaphore.html)
+    A counting-based locking mechanism that uses permits.
+*   [AtomicMarkableReference](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/AtomicMarkableReference.html)
+
 # Other useful links
 
 * https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/

data/ext/containers/bitset/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Tyler McMullen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.