unionf 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6f0c6481177e23e0f76e9485cf4c875823d6a217
+  data.tar.gz: ee1eb653f1fdf2a58173578a82a294917f8fc241
+SHA512:
+  metadata.gz: 85cb6a548aa1ab36eaac77643158473a33a4c993d962959cc207a4355b92fe623cb980aa92b6f544b178c6e2d9d36eeb24c247836baed53f7c103be9ed59eece
+  data.tar.gz: 063d06eb4bf14fbf215aaffd510ccf037d1b55e356f955904472cac65a89193bc8ddd62ef21ab893faee2a2c656740f26fb022080bc9b2ffbbacca47a6cac14f

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in unionf.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Marlon Henry Schweigert and Matheus Valenza
+
+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.

data/README.md

@@ -0,0 +1,79 @@
+# Unionf
+
+In computer science, a disjoint-set data structure, also called a union–find data structure or merge–find set, is a data structure that keeps track of a set of elements partitioned into a number of disjoint (non-overlapping) subsets. It provides near-constant-time operations (bounded by the inverse Ackermann function) to add new sets, to merge existing sets, and to determine whether elements are in the same set. In addition to many other uses (see the Applications section), disjoint-sets play a key role in Kruskal's algorithm for finding the minimum spanning tree of a graph.
+
+A disjoint-set forest consists of a number of elements each of which stores an id, a parent pointer, and, in efficient algorithms, a value called the "rank".
+
+The parent pointers of elements are arranged to form one or more trees, each representing a set. If an element's parent pointer points to no other element, then the element is the root of a tree and is the representative member of its set. A set may consist of only a single element. However, if the element has a parent, the element is part of whatever set is identified by following the chain of parents upwards until a representative element (one without a parent) is reached at the root of the tree.
+
+Forests can be represented compactly in memory as arrays in which parents are indicated by their array index.
+
+Disjoint-set data structures model the partitioning of a set, for example to keep track of the connected components of an undirected graph. This model can then be used to determine whether two vertices belong to the same component, or whether adding an edge between them would result in a cycle. The Union–Find algorithm is used in high-performance implementations of unification.
+
+This data structure is used by the Boost Graph Library to implement its Incremental Connected Components functionality. It is also a key component in implementing Kruskal's algorithm to find the minimum spanning tree of a graph.
+
+Note that the implementation as disjoint-set forests doesn't allow the deletion of edges, even without path compression or the rank heuristic.
+
+Sharir and Agarwal report connections between the worst-case behavior of disjoint-sets and the length of Davenport–Schinzel sequences, a combinatorial structure from computational geometry.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'unionf'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install unionf
+
+## Usage
+
+Create a new set:
+```ruby
+require 'unionf'
+
+include Unionf
+
+a = UnionFind.new [:marlon, :pamella, :matheus]
+```
+
+The return of a union is the size of the new set created.
+The find method for a set tells you what element represents that set.
+
+```ruby
+a.union :marlon, :pamella      # => 2
+a.find :marlon                 # => :pamella
+a.connected? :marlon, :pamella # => true
+a.connected? :marlon, :matheus # => false
+```
+
+You can also find the size of the set, and the subsets.
+
+```ruby
+a.size # => 4
+a.size? :marlon, :pamella # => 2
+```
+
+You can acquire the elements of the set again.
+
+```ruby
+a.elements # => [:marlon, :pamella, :matheus]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Schweigert/unionf.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "unionf"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/unionf.rb

@@ -0,0 +1,57 @@
+
+module Unionf
+
+  class UnionFind
+
+    def initialize elements
+      @id = {}
+      @sz = {}
+      @el = []
+      elements.each {|n| @id[n] = n; @sz[n] = 1; @el << n}
+    end
+
+    def connected? a, b
+      a, b = pair_search a, b
+      a == b
+    end
+
+    def union a, b
+      a, b = pair_search a, b
+
+      return if a == b or a.nil? or b.nil?
+
+      a, b = b, a if @sz[a] > @sz[b]
+
+      @id[a] = b
+      @sz[a] += @sz[b]
+      @sz[b] = @sz[a]
+    end
+
+    def find a
+      return a if @id[a] == a
+      @id[a] = find @id[a]
+    end
+
+    def size
+      @id.size
+    end
+
+    def size? a
+      a = find a
+      @sz[a]
+    end
+
+    def elements
+      @el
+    end
+
+    private
+
+    def pair_search a, b
+      a = find a
+      b = find b
+      [a,b]
+    end
+
+  end
+end

data/lib/unionf/version.rb

@@ -0,0 +1,3 @@
+module Unionf
+  VERSION = "0.1.0"
+end

data/unionf.gemspec

@@ -0,0 +1,50 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "unionf/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "unionf"
+  spec.version       = Unionf::VERSION
+  spec.authors       = ["Marlon Henry Schweigert", "Matheus Valenza"]
+  spec.email         = ["fleyhe0@gmail.com"]
+
+  spec.summary       = %q{Union-find algorithm.}
+  spec.description   = %q{
+    In computer science, a disjoint-set data structure, also called a union–find data structure or merge–find set, is a data structure that keeps track of a set of elements partitioned into a number of disjoint (non-overlapping) subsets. It provides near-constant-time operations (bounded by the inverse Ackermann function) to add new sets, to merge existing sets, and to determine whether elements are in the same set. In addition to many other uses (see the Applications section), disjoint-sets play a key role in Kruskal's algorithm for finding the minimum spanning tree of a graph.
+
+    A disjoint-set forest consists of a number of elements each of which stores an id, a parent pointer, and, in efficient algorithms, a value called the "rank".
+
+    The parent pointers of elements are arranged to form one or more trees, each representing a set. If an element's parent pointer points to no other element, then the element is the root of a tree and is the representative member of its set. A set may consist of only a single element. However, if the element has a parent, the element is part of whatever set is identified by following the chain of parents upwards until a representative element (one without a parent) is reached at the root of the tree.
+
+    Forests can be represented compactly in memory as arrays in which parents are indicated by their array index.
+
+    Disjoint-set data structures model the partitioning of a set, for example to keep track of the connected components of an undirected graph. This model can then be used to determine whether two vertices belong to the same component, or whether adding an edge between them would result in a cycle. The Union–Find algorithm is used in high-performance implementations of unification.
+
+    This data structure is used by the Boost Graph Library to implement its Incremental Connected Components functionality. It is also a key component in implementing Kruskal's algorithm to find the minimum spanning tree of a graph.
+
+    Note that the implementation as disjoint-set forests doesn't allow the deletion of edges, even without path compression or the rank heuristic.
+
+    Sharir and Agarwal report connections between the worst-case behavior of disjoint-sets and the length of Davenport–Schinzel sequences, a combinatorial structure from computational geometry.
+  }
+  spec.homepage      = "http://www.github.com/Schweigert/unionf"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org/"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: unionf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Marlon Henry Schweigert
+- Matheus Valenza
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: "\n    In computer science, a disjoint-set data structure, also called
+  a union–find data structure or merge–find set, is a data structure that keeps track
+  of a set of elements partitioned into a number of disjoint (non-overlapping) subsets.
+  It provides near-constant-time operations (bounded by the inverse Ackermann function)
+  to add new sets, to merge existing sets, and to determine whether elements are in
+  the same set. In addition to many other uses (see the Applications section), disjoint-sets
+  play a key role in Kruskal's algorithm for finding the minimum spanning tree of
+  a graph.\n\n    A disjoint-set forest consists of a number of elements each of which
+  stores an id, a parent pointer, and, in efficient algorithms, a value called the
+  \"rank\".\n\n    The parent pointers of elements are arranged to form one or more
+  trees, each representing a set. If an element's parent pointer points to no other
+  element, then the element is the root of a tree and is the representative member
+  of its set. A set may consist of only a single element. However, if the element
+  has a parent, the element is part of whatever set is identified by following the
+  chain of parents upwards until a representative element (one without a parent) is
+  reached at the root of the tree.\n\n    Forests can be represented compactly in
+  memory as arrays in which parents are indicated by their array index.\n\n    Disjoint-set
+  data structures model the partitioning of a set, for example to keep track of the
+  connected components of an undirected graph. This model can then be used to determine
+  whether two vertices belong to the same component, or whether adding an edge between
+  them would result in a cycle. The Union–Find algorithm is used in high-performance
+  implementations of unification.\n\n    This data structure is used by the Boost
+  Graph Library to implement its Incremental Connected Components functionality. It
+  is also a key component in implementing Kruskal's algorithm to find the minimum
+  spanning tree of a graph.\n\n    Note that the implementation as disjoint-set forests
+  doesn't allow the deletion of edges, even without path compression or the rank heuristic.\n\n
+  \   Sharir and Agarwal report connections between the worst-case behavior of disjoint-sets
+  and the length of Davenport–Schinzel sequences, a combinatorial structure from computational
+  geometry.\n  "
+email:
+- fleyhe0@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/unionf.rb
+- lib/unionf/version.rb
+- unionf.gemspec
+homepage: http://www.github.com/Schweigert/unionf
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Union-find algorithm.
+test_files: []