algorithmix 0.0.0.1 → 0.0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a24575f97c049c71963bab72100c81e205970249
-  data.tar.gz: 8fdc66e3238f5dd4442208ce7607d6f115413cb3
+  metadata.gz: f8e724de2b470e9bba5bb91835d8838b8a1c9539
+  data.tar.gz: 9f2cfd73e638455a1a5c77ef9d84e39fc8242f7b
 SHA512:
-  metadata.gz: 6c3ef71e4be3c66742c9dbc5baf89f47be04857a73567cb7eaabb72e91df73c456fe733296f7a1033b30c6a19dbe00b49569b15c5572da1c8f2f33daa2b8f11b
-  data.tar.gz: eccf1833bcfd65c0b77fc24c69aa4509278179bccc4b5091d03743b76c795cca563d38fa9e757f0d41a3362313a1944adb5c960f271d50d13f62bbc0a7b5102e
+  metadata.gz: 72ea4e1a6a1edded2b5aba0a94e93488971ea0663be32e4857be9c760343be171492756a3f90aee7bb6471c84fa65596a42180a454681fc9de778a90cca93569
+  data.tar.gz: 5a393b92e1b96b896f7f4283ca6d904913e690bd21d8554135e32ef7af9f5cc599f26c03e25f6882d9d24e26cc5fb3bf98fd2ff64f7d25c5d7108f17b860205b

data/.gitignore

@@ -11,3 +11,4 @@
 .rspec_status
 
 algorithmix-*.gem
+Gemfile.lock

data/.travis.yml

@@ -1,4 +1,3 @@
-sudo: false
 language: ruby
 rvm:
   - 2.4.4

data/README.md

@@ -9,7 +9,9 @@ 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.1-green.svg) A [**Stack**](https://github.com/monzita/algorithmix/wiki/Stack) implementation is released.
+![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.
 
 ## Installation
 

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

@@ -0,0 +1,316 @@
+# Documentation: https://github.com/monzita/algorithmix/wiki/Queue
+
+module Algorithmix
+  module DataStructure
+    module Generic
+
+      class Queue
+
+        # Creates a new queue.
+        #
+        # @param obj [#to_a] Any objects which responds to #to_a method
+        # @kwarg copy [true, false] If is set to true, will duplicate the given object. By default is set to false.
+        # @return [Queue] a newly create queue
+        def initialize(obj = nil, copy: false)
+          @container = []
+          obj.nil? ? nil : from_obj(obj, copy)
+        end
+
+        # Assigns content of an object, to stack's content, removing previous elements.
+        #
+        # @param obj [#to_a] Any object which responds to #to_a method.
+        # @kwarg copy [true, false]  If is set to true, will duplicate the given object. By default is set to false.
+        # @return self object [Queue]
+        def assign(obj, copy: false)
+          from_obj(obj, copy)
+        end
+
+        # Inserts a value at the end of the queue.
+        #
+        # @param value
+        # @return [Queue] self object
+        def push(value)
+          @container << value
+          self
+        end
+
+        # (see #push)
+        def <<(value)
+          push(value)
+        end
+
+        # Removes the front element of the queue.
+        #
+        # @return front element
+        # @raise Algorithmix::EmptyContainerError if the queue is empty.
+        def pop
+          raise EmptyContainerError, "The queue is empty." if @container.empty?
+          @container.shift
+        end
+
+        # Returns the front element of the queue, or nil if it's empty.
+        def front
+          @container.first
+        end
+
+        # Returns number of elements in the queue.
+        def size
+          @container.size
+        end
+
+        # Checks if the queue is empty.
+        def empty?
+          @container.empty?
+        end
+        
+        # Compares contents of the self object and that given as argument.
+        #
+        # @param queue [Queue]
+        # @return [true, false]
+        # @raise ArgumentError, if given object is not a queue.
+        def ==(queue)
+          raise ArgumentError, "Undefined method Queue#== for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          @container == queue.to_a
+        end
+
+        # (see #==)
+        def eql?(queue)
+          raise ArgumentError, "Undefined method Queue#eql? for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          self == queue
+        end
+
+        # Compares contents of the self object and that given as argument.
+        #
+        # @param queue [Queue]
+        # @return [true, false]
+        # @raise ArgumentError, if given object is not a queue.
+        def !=(queue)
+          raise ArgumentError, "Undefined method Queue#!= for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          @container != queue.to_a
+        end
+
+        # (see #!=)
+        def diff?(queue)
+          raise ArgumentError, "Undefined method Queue#diff? for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          self != queue
+        end
+
+        # Compares contents of the self object and that given as argument.
+        #
+        # @param queue [Queue]
+        # @return 1, if content of the first queue is greater than content of the second
+        #         0, if contents of both queues are equal
+        #         -1, if content of the second queue is greater than content of the first
+        # @raise ArgumentError, if given object is not a queue.
+        def <=>(queue)
+          raise ArgumentError, "Undefined method Queue#<=> for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          @container <=> queue.to_a
+        end
+
+        # Concatenates contents of two queues.
+        #
+        # @param queue [Queue]
+        # @return [Queue] a new queue object
+        def +(queue)
+          raise ArgumentError, "Undefined method Queue#+ for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          Queue.new(@container + queue.to_a)
+        end
+
+        # (see #+)
+        def concat(queue)
+          raise ArgumentError, "Undefined method Queue#concat for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          self + queue
+        end
+
+        # (see #+)
+        def merge(queue)
+          raise ArgumentError, "Undefined method Queue#merge for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          self + queue
+        end
+
+        # Same as #+, but modifies the current object
+        def concat!(queue)
+          raise ArgumentError, "Undefined method Queue#concat! for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          @container += queue.to_a
+          self
+        end
+
+        # Same as #+, but modifies the current object
+        def merge!(queue)
+          raise ArgumentError, "Undefined method Queue#merge! for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          @container += queue.to_a
+          self
+        end
+
+        # Unites contents of the self queue and queue given as argument.
+        #
+        # @param queue [Queue]
+        # @return [Queue] a new queue
+        # @raise ArgumentError, if given object is not a queue
+        def |(queue)
+          raise ArgumentError, "Undefined method Queue#| for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          Queue.new(@container | queue.to_a)
+        end
+
+        # (see #|)
+        def union(queue)
+          raise ArgumentError, "Undefined method Queue#union for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          self | queue
+        end
+
+        # Same as #union, but modifies the current object
+        def union!(queue)
+          raise ArgumentError, "Undefined method Queue#union! for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          @container |= queue.to_a
+          self
+        end
+
+        # Finds the intersection of the self object and queue given as argument.
+        #
+        # @param queue [Queue]
+        # @return [Queue] a new queue
+        # @raise ArgumentError, if given object is not a queue
+        def &(queue)
+          raise ArgumentError, "Undefined method Queue#& for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          Queue.new(@container & queue.to_a)
+        end
+
+        # (see #&)
+        def intersect(queue)
+          raise ArgumentError, "Undefined method Queue#intersect for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          self & queue
+        end
+
+        # Same as #&, but modifies the current object.
+        def intersect!(queue)
+          raise ArgumentError, "Undefined method Queue#intersect! for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          @container &= queue.to_a
+          self
+        end
+
+        # Finds the difference of the current queue and queue given as argument.
+        #
+        # @param queue [Queue]
+        # @return [Queue] a new queue
+        # @raise ArgumentError, if given object is not a queue
+        def -(queue)
+          raise ArgumentError, "Undefined method Queue#- for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          Queue.new(@container - queue.to_a)
+        end
+
+        # (see #-)
+        def difference(queue)
+          raise ArgumentError, "Undefined method Queue#difference for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          self - queue
+        end
+
+        # Same as #-, but modifies the current queue.
+        def difference!(queue)
+          raise ArgumentError, "Undefined method Queue#difference! for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          @container -= queue.to_a
+          self
+        end
+
+        # Finds the symmetric difference of the self object and queue given as argument.
+        #
+        # @param queue [Queue]
+        # @return [Queue] a new queue
+        # @raise ArgumentError, if given object is not a queue
+        def ^(queue)
+          raise ArgumentError, "Undefined method Queue#^ for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          Queue.new((@container | queue.to_a) - (@container & queue.to_a))
+        end
+
+        # (see #^)
+        def symmetric_difference(queue)
+          raise ArgumentError, "Undefined method Queue#symmetric_difference for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          self ^ queue
+        end
+
+        # Same as #^, but modifies the current object.
+        def symmetric_difference!(queue)
+          raise ArgumentError, "Undefined method Queue#symmetric_difference! for #{queue}:#{queue.class}" unless queue.is_a?(Queue)
+          @container = (@container | queue.to_a) - (@container & queue.to_a)
+        end
+
+        # Converts the queue to an array with elements.
+        def to_a
+          @container
+        end
+
+        # Clears content of the queue.
+        def clear
+          @container = []
+          self
+        end
+
+        # Filters elements of the queue by given condition.
+        #
+        # @param &block
+        # @return [Queue] a new queue
+        def select(&block)
+          Queue.new(@container.select { |e| block.call(e) })
+        end
+
+        # Same as #select, but modofies the current 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 queue.
+        #
+        # @param &block
+        # @return [Queue] a new queue
+        def map(&block)
+          Queue.new(@container.map { |e| block.call(e)})
+        end
+
+        # Same as #map, but modifies the current 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/data_structure/generic/stack.rb

@@ -0,0 +1,335 @@
+# Documentation: https://github.com/monzita/algorithmix/wiki/Stack
+
+module Algorithmix
+  module DataStructure
+    module Generic
+
+      class Stack
+
+        # Creates a new stack.
+        #
+        # @param obj [#to_a] any object which responds to #to_a method.
+        # @return [Stack] a new stack object
+        def initialize(obj = nil, copy: false)
+
+          @container = []
+          obj.nil? ? nil : from_obj(obj, copy)
+        end
+
+        # Copies the content of an object to the content of the stack, removing
+        # previous elements inserted in it.
+        #
+        # @param obj [#to_a] any object which responds to to_a method
+        # @return [Stack] self object, modified
+        def assign(obj, copy: false)
+          from_obj(obj, copy)
+        end
+
+        # Inserts a new element at the top of the stack.
+        #
+        # @param value
+        # @return [Stack] self object, modified
+        def push(value)
+          @container << value
+          self
+        end
+
+        # (see #push)
+        def <<(value)
+          push(value)
+        end
+
+        # Removes the top element of the stack.
+        # 
+        # @return top element of the stack
+        # @raise Algorithmix::EmptyContainerError, if there are no elements in the stack.
+        def pop
+          raise EmptyContainerError, "The stack is empty." if @container.empty?
+          @container.pop
+        end
+
+        # Returns the number of elements in the stack.
+        def size
+          @container.size
+        end
+
+        # Returns the top element of the stack, without removing it. 
+        # If the stack is empty, returns nil.
+        def top
+          @container.last
+        end
+
+        # Checks if the stack contains any elements.
+        def empty?
+          @container.empty?
+        end
+
+        # Compares the self stack with given as argument stack.
+        #
+        # @param [Stack]
+        # @return [true, false]
+        def ==(stack)
+          raise ArgumentError, "Undefined method Stack#== for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          @container == stack.to_a
+        end
+
+        # (see #==)
+        def eql?(stack)
+          raise ArgumentError, "Undefined method Stack#eql? for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          self == stack
+        end
+
+        # (see #==)
+        def !=(stack)
+          raise ArgumentError, "Undefined method Stack#!= for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          @container != stack.to_a
+        end
+
+        # (see #==)
+        def diff?(stack)
+          raise ArgumentError, "Undefined method Stack#diff? for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          self != stack
+        end
+
+        # Compares the self stack with given as argument stck.
+        #
+        # @return 1, if content of the first stack is greater than content of the second.
+        #         0, if both stacks have equal contents
+        #         -1, if content of the first stack is less than content of the second.
+        # @raise ArgumentError, if given object is not a stack
+        def <=>(stack)
+          raise ArgumentError, "Undefined method Stack#<=> for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          @container <=> stack.to_a
+        end
+
+        # Merges contents of the self stack and stack given as argument, without removing repetitions from both stacks.
+        #
+        # @param [Stack]
+        # @return [Stack] a new stack object, without modifying any of given stacks.
+        # @raise ArgumentError, if given object is not a stack
+        def +(stack)
+          raise ArgumentError, "Undefined method Stack#+ for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          Stack.new(@container + stack.to_a)
+        end
+
+        # (see #+)
+        def merge(stack)
+          raise ArgumentError, "Undefined method Stack#merge for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          self + stack
+        end
+
+        # Merges contents of the self stack, and stack given as argument.
+        # Modifies self object.
+        #
+        # @param [Stack]
+        # @return [Stack] self object
+        # @raise ArgumentError, if given object is not a stack
+        def merge!(stack)
+          raise ArgumentError, "Undefined method Stack#merge! for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          @container += stack.to_a
+          self
+        end
+
+        # (see #+)
+        def concat(stack)
+          raise ArgumentError, "Undefined method Stack#concat for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          self + stack
+        end
+
+        # (see #merge!)
+        def concat!(stack)
+          raise ArgumentError, "Undefined method Stack#concat! for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          @container += stack.to_a
+          self
+        end
+
+        # Finds intersection of contents of the self stack and stack given as argument, and returns a new stack
+        # with the result.
+        #
+        # @param [Stack]
+        # @return [Stack] a new stack
+        # @raise ArgumentError, if given object is not a stack
+        def &(stack)
+          raise ArgumentError, "Undefined method Stack#& for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          Stack.new(@container & stack.to_a)
+        end
+
+        # (see #&)
+        def intersect(stack)
+          raise ArgumentError, "Undefined method Stack#intersect for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          self & stack
+        end
+
+        # Like intersect, finds intersection of the self stack object and stack given as argument, but modifies the 
+        # object to which operation was called.
+        def intersect!(stack)
+          raise ArgumentError, "Undefined method Stack#intersect! for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          @container &= stack.to_a
+          self
+        end
+
+        # Finds difference of the self stack object and that given as argument.
+        #
+        # @param [Stack]
+        # @return [Stack] a new stack
+        # @raise ArgumentError, if given object is not a stack
+        def -(stack)
+          raise ArgumentError, "Undefined method Stack#- for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          Stack.new(@container - stack.to_a)
+        end
+
+        # (see #-)
+        def difference(stack)
+          raise ArgumentError, "Undefined method Stack#difference for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          self - stack
+        end
+
+        # As difference, finds the difference of the stack and that given as argument, but
+        # modifies self object.
+        #
+        # @param [Stack]
+        # @return [Stack] self object
+        # @raise ArgumentError, if given object is not a stack
+        def difference!(stack)
+          raise ArgumentError, "Undefined method Stack#difference! for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          @container -= stack.to_a
+          self
+        end
+
+        # Finds union of the self object and stack given as argument.
+        #
+        # @param [Stack]
+        # @return [Stack] a new stack
+        # @raise ArgumentError, if given object is not a stack
+        def |(stack)
+          raise ArgumentError, "Undefined method Stack#| for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          Stack.new(@container | stack.to_a)
+        end
+
+        # (see #|)
+        def union(stack)
+          raise ArgumentError, "Undefined method Stack#union for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          self | stack
+        end
+
+        # Like #|, finds the union of the self object and the stack given as argument, but
+        # keeps the result in the current stack.
+        #
+        # @param [Stack]
+        # @return [Stack] self object
+        # @raise ArgumentError, if given object is not a stack
+        def union!(stack)
+          raise ArgumentError, "Undefined method Stack#union! for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          @container |= stack.to_a
+          self
+        end
+
+        # Finds the symmetric difference of the stack and that given as argument.
+        #
+        # @param [Stack]
+        # @return [Stack] a new stack
+        # @raise ArgumentError, if given object is not a stack
+        def ^(stack)
+          raise ArgumentError, "Undefined method Stack#^ for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          Stack.new((@container | stack.to_a) - (@container & stack.to_a))
+        end
+
+        # (see #^)
+        def symmetric_difference(stack)
+          raise ArgumentError, "Undefined method Stack#symmetric_difference for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          self ^ stack
+        end
+
+        # Finds the symmetric difference of the self object and stack given as argument.
+        #
+        # @param [Stack]
+        # @return [Stack] self object, modified
+        # @raise ArgumentError, if given object is not a stack
+        def symmetric_difference!(stack)
+          raise ArgumentError, "Undefined method Stack#symmetric_difference! for #{stack}:#{stack.class}" unless stack.is_a?(Stack)
+          @container = (@container | stack.to_a) - (@container & stack.to_a)
+          self
+        end
+
+        # Returns current object as array.
+        def to_a
+          @container
+        end
+
+        # Clears content of current stack.
+        def clear
+          @container = []
+          self
+        end
+
+        # Filters elements of the stack, by given condition.
+        #
+        # @param &block represents condition by which elements of the stack will be filtered
+        # @return [Stack] a new stack object
+        def select(&block)
+          Stack.new(@container.select { |e| block.call(e) })
+        end
+
+        # Same as #select, but modifying the 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 stack.
+        #
+        # @param &block
+        # @return [Stack] a new stack
+        def map(&block)
+          Stack.new(@container.map { |e| block.call(e)})
+        end
+
+        # Same as #map, but the result is kept in the current object.
+        #
+        # @param &block
+        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/error.rb

@@ -0,0 +1,3 @@
+module Algorithmix
+  EmptyContainerError = Class.new(StandardError)
+end

data/lib/algorithmix/version.rb

@@ -1,3 +1,3 @@
 module Algorithmix
-  VERSION = "0.0.0.1"
+  VERSION = "0.0.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algorithmix
 version: !ruby/object:Gem::Version
-  version: 0.0.0.1
+  version: 0.0.0.2
 platform: ruby
 authors:
 - Monika Ilieva
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-07 00:00:00.000000000 Z
+date: 2018-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,6 +86,9 @@ files:
 - bin/console
 - bin/setup
 - lib/algorithmix.rb
+- lib/algorithmix/data_structure/generic/queue.rb
+- lib/algorithmix/data_structure/generic/stack.rb
+- lib/algorithmix/error.rb
 - lib/algorithmix/version.rb
 homepage: https://github.com/monzita/algorithmix/wiki
 licenses: