algorithmix 0.0.0.3 → 0.0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fa9af42a9283735ddfb27fd46138b88433af8c2
-  data.tar.gz: ed9cafc8c1adbb181e9344f21d8ed61dc2e20e74
+  metadata.gz: ac9e4d6a402a8e5a2114525fc9309e68f64e44b2
+  data.tar.gz: 3f04fc2ca5c59e1b3287372e629bda85319cbf1f
 SHA512:
-  metadata.gz: ba4aa0ee6ed557ee62842f17ecf1c78ed4d5b4fa0a1b4fe9191325a100774abdfedc1c30d3272714729c8b475a135867c06e6c09bee4513c2a863e5031984795
-  data.tar.gz: f34df850923955a0d0d88d542c8e27cc54417dc24f997bd4b4a7ba33b921ed348170503c338520d75e79c1de76ec663678edf6ae736bf8f6f7fe5086fcb14f61
+  metadata.gz: 4b6271b398a3905cbcf52dc50800d3098362de2fd28b3ffffd882576487549d38efb7be18b85d56335567597aa89e5250937c4d063bcc5297246739586cfa30c
+  data.tar.gz: 28d57ee9d13a571051cc00e0858c7d97dee1a3f307f03d541d88c507973f966495611449986a35aee4d593a0da92d30cdb5f4e1293e8cb8615dfa6134ffa5d05

data/README.md

@@ -9,6 +9,10 @@ The gem contains various implementations of known and unknown data structures an
 :construction: Because the gem is still not ready, with each new implementation of a data structure or an algorithm, a new
 minor version will be released.
 
+![Gem](https://img.shields.io/badge/min-0.0.0.4-green.svg) [**BinaryHeap**](https://github.com/monzita/algorithmix/wiki/BinaryHeap)
+
+![Gem](https://img.shields.io/badge/min-0.0.0.3-green.svg) [**Deque**](https://github.com/monzita/algorithmix/wiki/Deque)
+
 ![Gem](https://img.shields.io/badge/min-0.0.0.2-green.svg) [**Queue**](https://github.com/monzita/algorithmix/wiki/Queue) implementation & option for duplication of elements in [**Stack**](https://github.com/monzita/algorithmix/wiki/Stack)
 
 ![Gem](https://img.shields.io/badge/min-0.0.0.1-green.svg) [**Stack**](https://github.com/monzita/algorithmix/wiki/Stack) implementation is released.

data/algorithmix.gemspec

@@ -8,11 +8,15 @@ Gem::Specification.new do |spec|
   spec.version       = Algorithmix::VERSION
   spec.authors       = ["Monika Ilieva"]
   spec.email         = ["*@*.*"]
+  spec.summary       = %q{The gem contains various implementations of known and uknown data structures and algorithms}
+  spec.description   = <<-DOC
+                          Currently the gem contains:
+                          1. Stack
+                          2. Queue
+                          3. Deque
+                          4. Binary heap
 
-  spec.summary       = %q{The gem contains various implementations of known and uknown data structure and algorithms}
-  spec.description   = %q{The gem contains various implementations of known and uknown data structure and algorithms, which will be useful for developers.\n
-                          Currently the gem contains:\n
-                          1. Stack\n2. Queue\n3. Deque\n Check the documentation for more information.}
+                        DOC
   spec.homepage      = "https://github.com/monzita/algorithmix/wiki"
   spec.license       = "MIT"
 

data/lib/algorithmix/data_structure/generic/deque.rb

@@ -0,0 +1,394 @@
+# Documentation: https://github.com/monzita/algorithmix/wiki/Deque
+
+module Algorithmix
+  module DataStructure
+    module Generic
+
+      class Deque
+
+        # Creates a new deque.
+        #
+        # @param obj [#to_a]
+        # @kwarg copy [true, false]
+        # @return newly created deque
+        # @raise ArgumentError, if given obj doesn't respond to #to_a method
+        def initialize(obj = nil, copy: false)
+          @container = []
+          obj.nil? ? nil : from_obj(obj, copy)
+        end
+
+        # Assigns content of an obj, to content of the deque.
+        #
+        # @param obj [#to_a]
+        # @kwarg copy [true, false] by default is set to false, which means that no copy of the object will be made
+        # @raise ArgumentError, if given object doesn't respond to #to_a method
+        # @return self object
+        def assign(obj, copy: false)
+          from_obj(obj, copy)
+        end
+
+        # Inserts a new element at the beginning of the deque.
+        #
+        # @param value
+        # @return self object
+        def push_front(value)
+          @container.unshift(value)
+          self
+        end
+
+        # (see #push_front)
+        def >>(value)
+          push_front(value)
+        end
+
+        # Inserts a new element at the end of the deque.
+        #
+        # @param value
+        # @return self object
+        def push_back(value)
+          @container << value
+          self
+        end
+
+        # (see #push_back)
+        def <<(value)
+          push_back(value)
+        end
+
+        # Removes first element of the deque.
+        #
+        # @raise Algorithmix::EmptyContainerError, if the deque is empty.
+        # @return first element of the deque
+        def pop_front
+          raise EmptyContainerError, "The deque is empty." if @container.empty?
+          @container.shift
+        end
+
+        # Removes last element of the deque.
+        #
+        # @raise Algorithmix::EmptyContainerError, if the deque is empty.
+        # @return last element of the deque
+        def pop_back
+          raise EmptyContainerError, "The deque is empty." if @container.empty?
+          @container.pop
+        end
+
+        # Returns first element of the deque.
+        def front
+          @container.first
+        end
+
+        # Returns last element of the deque.
+        def back
+          @container.last
+        end
+
+        # Checks if the deque is empty.
+        def empty?
+          @container.empty?
+        end
+
+        # Returns size of the deque.
+        def size
+          @container.size
+        end
+
+        # Returns the element at given index.
+        #
+        # @param idx
+        # @return element at given position, or nil if there is no element at that index.
+        def [](idx)
+          @container[idx]
+        end
+
+        # (see #[])
+        def at(idx)
+          @container[idx]
+        end
+
+        # Compares contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [true, false]
+        # @raise ArgumentError, if given object is not a deque
+        def ==(deque)
+          raise ArgumentError, "Undefined method Deque#== for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          @container == deque.to_a
+        end
+
+        # (see #==)
+        def eql?(deque)
+          raise ArgumentError, "Undefined method Deque#eql? for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          self == deque
+        end
+
+        # Compares contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [true, false]
+        # @raise ArgumentError, if given object is not a deque
+        def !=(deque)
+          raise ArgumentError, "Undefined method Deque#!= for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          @container != deque.to_a
+        end
+
+        # (see #!=)
+        def diff?(deque)
+          raise ArgumentError, "Undefined method Deque#diff? for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          self != deque
+        end
+
+        # Compares contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return 1, if content of the deque is greater than content of the given deque,
+        #         0, if contents are equal
+        #         -1, if content of the second deque is greater than content of self object
+        # @raise ArgumentError, if given object is not a deque
+        def <=>(deque)
+          raise ArgumentError, "Undefined method Deque#<=> for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          @container <=> deque.to_a
+        end
+
+        # Concatenates contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] a new deque
+        # @raise ArgumentError, if given object is not a deque
+        def +(deque)
+          raise ArgumentError, "Undefined method Deque#+ for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          Deque.new(@container + deque.to_a)
+        end
+
+        # (see #+)
+        def concat(deque)
+          raise ArgumentError, "Undefined method Deque#concat for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          self + deque
+        end
+
+        # (see #+)
+        def merge(deque)
+          raise ArgumentError, "Undefined method Deque#merge for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          self + deque
+        end
+
+        # Concatenates contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] self object
+        # @raise ArgumentError, if given object is not a deque
+        def concat!(deque)
+          raise ArgumentError, "Undefined method Deque#concat! for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          @container += deque.to_a
+          self
+        end
+
+        # Concatenates contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] self object
+        # @raise ArgumentError, if given object is not a deque
+        def merge!(deque)
+          raise ArgumentError, "Undefined method Deque#merge! for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          @container += deque.to_a
+          self
+        end
+
+        # Unites contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] a new deque
+        # @raise ArgumentError, if given object is not a deque
+        def |(deque)
+          raise ArgumentError, "Undefined method Deque#| for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          Deque.new(@container | deque.to_a)
+        end
+
+        # (see #|)
+        def union(deque)
+          raise ArgumentError, "Undefined method Deque#union for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          self | deque
+        end
+
+        # Unites contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] self object
+        # @raise ArgumentError, if given object is not a deque
+        def union!(deque)
+          raise ArgumentError, "Undefined method Deque#union! for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          @container |= deque.to_a
+          self
+        end
+
+        # Finds intersection of contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] a new deque
+        # @raise ArgumentError, if given object is not a deque
+        def &(deque)
+          raise ArgumentError, "Undefined method Deque#& for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          Deque.new(@container & deque.to_a)
+        end
+
+        # (see #&)
+        def intersect(deque)
+          raise ArgumentError, "Undefined method Deque#intersect for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          self & deque
+        end
+
+        # Finds intersection of contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] self object
+        # @raise ArgumentError, if given object is not a deque
+        def intersect!(deque)
+          raise ArgumentError, "Undefined method Deque#intersect! for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          @container &= deque.to_a
+          self
+        end
+
+        # Finds difference of contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] a new deque
+        # @raise ArgumentError, if given object is not a deque
+        def -(deque)
+          raise ArgumentError, "Undefined method Deque#- for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          Deque.new(@container - deque.to_a)
+        end
+
+        # (see #-)
+        def difference(deque)
+          raise ArgumentError, "Undefined method Deque#difference for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          self - deque
+        end
+
+        # Finds difference of contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] a new deque
+        # @raise ArgumentError, if given object is not a deque
+        def difference!(deque)
+          raise ArgumentError, "Undefined method Deque#difference! for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          @container -= deque.to_a
+          self
+        end
+
+        # Finds symmetric difference of contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] a new deque
+        # @raise ArgumentError, if given object is not a deque
+        def ^(deque)
+          raise ArgumentError, "Undefined method Deque#^ for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          Deque.new((@container | deque.to_a) - (@container & deque.to_a))
+        end
+
+        # (see #symmetric_difference)
+        def symmetric_difference(deque)
+          raise ArgumentError, "Undefined method Deque#symmetric_difference for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          self ^ deque
+        end
+
+        # Finds symmetric difference of contents of the deque and a deque given as argument.
+        #
+        # @param deque [Deque]
+        # @return [Deque] self object
+        # @raise ArgumentError, if given object is not a deque
+        def symmetric_difference!(deque)
+          raise ArgumentError, "Undefined method Deque#symmetric_difference! for #{deque}:#{deque.class}" unless deque.is_a?(Deque)
+          @container = (@container | deque.to_a) - (@container & deque.to_a)
+          self
+        end
+
+        # Converts content of the deque to an array witl elements.
+        def to_a
+          @container
+        end
+
+        # Clears content of the deque.
+        #
+        # @return self object
+        def clear
+          @container = []
+          self
+        end
+
+        # Filters elements of the deque by given condition.
+        #
+        # @param &block 
+        # @return [Deque] a new deque
+        def select(&block)
+          Deque.new( @container.select { |e| block.call(e)})
+        end
+
+        # Filters elements of the deque by given condition.
+        #
+        # @param &block 
+        # @return [Deque] self object
+        def select!(&block)
+          @container.select! { |e| block.call(e)}
+          self
+        end
+
+        # (see #select)
+        def filter(&block)
+          select(&block)
+        end
+
+        # (see #select!)
+        def filter!(&block)
+          select!(&block)
+        end
+
+        # (see #select)
+        def find_all(&block)
+          select(&block)
+        end
+
+        # (see #select!)
+        def find_all!(&block)
+          select!(&block)
+        end
+
+        # Applies a function to each element of the deque.
+        #
+        # @param &block
+        # @return [Deque] a new deque
+        def map(&block)
+          Deque.new(@container.map { |e| block.call(e)})
+        end
+
+        # Applies a function to each element of the deque.
+        #
+        # @param &block
+        # @return [Deque] self object
+        def map!(&block)
+          @container.map! { |e| block.call(e)}
+          self
+        end
+
+        # (see #map)
+        def apply(&block)
+          map(&block)
+        end
+
+        # (see #map!)
+        def apply!(&block)
+          map!(&block)
+        end
+
+        private
+
+        def from_obj(obj, copy)
+          raise ArgumentError, "Object doesn't respond to #to_a method" unless obj.respond_to?(:to_a)
+
+          @container = copy ? obj.send(:to_a).dup : obj.send(:to_a)
+          self
+        end
+
+      end
+    end
+  end
+end

data/lib/algorithmix/version.rb

@@ -1,3 +1,3 @@
 module Algorithmix
-  VERSION = "0.0.0.3"
+  VERSION = "0.0.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algorithmix
 version: !ruby/object:Gem::Version
-  version: 0.0.0.3
+  version: 0.0.0.4
 platform: ruby
 authors:
 - Monika Ilieva
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-12 00:00:00.000000000 Z
+date: 2018-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,10 +66,13 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.0
-description: |-
-  The gem contains various implementations of known and uknown data structure and algorithms, which will be useful for developers.\n
-                            Currently the gem contains:\n
-                            1. Stack\n2. Queue\n3. Deque\n Check the documentation for more information.
+description: |2+
+                            Currently the gem contains:
+                            1. Stack
+                            2. Queue
+                            3. Deque
+                            4. Binary heap
+
 email:
 - "*@*.*"
 executables: []
@@ -88,6 +91,7 @@ files:
 - bin/console
 - bin/setup
 - lib/algorithmix.rb
+- lib/algorithmix/data_structure/generic/deque.rb
 - lib/algorithmix/data_structure/generic/queue.rb
 - lib/algorithmix/data_structure/generic/stack.rb
 - lib/algorithmix/error.rb
@@ -116,6 +120,6 @@ rubyforge_project:
 rubygems_version: 2.6.14.1
 signing_key: 
 specification_version: 4
-summary: The gem contains various implementations of known and uknown data structure
+summary: The gem contains various implementations of known and uknown data structures
   and algorithms
 test_files: []