graph_matching 0.0.2 → 0.1.0

data/benchmark/mcm_bipartite/complete_bigraphs/benchmark.rb

@@ -28,6 +28,6 @@ MIN_SIZE.upto(MAX_SIZE) do |v|
   print "%5d\t" % [v]
   g = complete_bigraph(v)
   GC.disable
-  puts Benchmark.realtime { g.maximum_cardinality_matching }
+  puts(Benchmark.realtime { g.maximum_cardinality_matching })
   GC.enable
 end

data/benchmark/mcm_general/complete_graphs/benchmark.rb

@@ -25,6 +25,6 @@ MIN_SIZE.upto(MAX_SIZE) do |v|
   print "%5d\t" % [v]
   g = complete_graph(v)
   GC.disable
-  puts Benchmark.realtime { g.maximum_cardinality_matching }
+  puts(Benchmark.realtime { g.maximum_cardinality_matching })
   GC.enable
 end

data/benchmark/mwm_bipartite/complete_bigraphs/benchmark.rb

@@ -38,6 +38,6 @@ MIN_SIZE.upto(MAX_SIZE) do |v|
   print "%5d\t" % [v]
   g = complete_weighted_bigraph(v)
   GC.disable
-  puts Benchmark.realtime { g.maximum_weighted_matching }
+  puts(Benchmark.realtime { g.maximum_weighted_matching })
   GC.enable
 end

data/benchmark/mwm_bipartite/misc/calc_d2/benchmark.rb

@@ -21,9 +21,5 @@ t = Set.new
 s = Set.new(dogs)
 
 GC.disable
-puts Benchmark.realtime {
-  100_000.times do
-    a.send(:calc_d2, s, t, u)
-  end
-}
+puts(Benchmark.realtime { 100_000.times { a.send(:calc_d2, s, t, u) } })
 GC.enable

data/benchmark/mwm_general/complete_graphs/benchmark.rb

@@ -13,7 +13,7 @@ $stdout.sync = true
 
 def complete_graph(n)
   g = GraphMatching::Graph::WeightedGraph.new
-  n_edges = (1 .. n - 1).reduce(:+)
+  n_edges = (1..n - 1).reduce(:+)
   0.upto(n - 2) do |i|
     (i + 1).upto(n - 1) do |j|
       g.add_edge(i, j)
@@ -27,6 +27,6 @@ MIN_SIZE.upto(MAX_SIZE) do |v|
   print "%5d\t" % [v]
   g = complete_graph(v)
   GC.disable
-  puts Benchmark.realtime { g.maximum_weighted_matching(true) }
+  puts(Benchmark.realtime { g.maximum_weighted_matching(true) })
   GC.enable
 end

data/benchmark/mwm_general/incomplete_graphs/benchmark.rb

@@ -17,14 +17,13 @@ $stdout.sync = true
 def incomplete_graph(n, completeness)
   g = GraphMatching::Graph::WeightedGraph.new
   0.upto(n - 1) do |i| g.add_vertex(i) end
-  max_weight = ((1 .. n - 1).reduce(:+).to_f * completeness).to_i + 1
+  max_weight = ((1..n - 1).reduce(:+).to_f * completeness).to_i + 1
   0.upto(n - 2) do |i|
     (i + 1).upto(n - 1) do |j|
-      if rand < completeness
-        g.add_edge(i, j)
-        w = rand(max_weight)
-        g.set_w([i, j], w)
-      end
+      next unless rand < completeness
+      g.add_edge(i, j)
+      w = rand(max_weight)
+      g.set_w([i, j], w)
     end
   end
   g
@@ -34,6 +33,6 @@ MIN_SIZE.upto(MAX_SIZE) do |v|
   print "%5d\t" % [v]
   g = incomplete_graph(v, COMPLETENESS)
   GC.disable
-  puts Benchmark.realtime { g.maximum_weighted_matching(true) }
+  puts(Benchmark.realtime { g.maximum_weighted_matching(true) })
   GC.enable
 end

data/graph_matching.gemspec

@@ -15,21 +15,17 @@ Gem::Specification.new do |spec|
   EOS
   spec.homepage      = 'https://github.com/jaredbeck/graph_matching'
   spec.license       = 'MIT'
-
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
-
-  spec.required_ruby_version = '>= 2.0.0'
-
+  spec.required_ruby_version = '>= 2.2.0'
   spec.add_runtime_dependency 'rgl', '~> 0.5.0'
-
   spec.add_development_dependency 'bundler', '~> 1.12'
-  spec.add_development_dependency 'pry-nav', '~> 0.2.4'
-  spec.add_development_dependency 'rspec-core', '~> 3.2'
-  spec.add_development_dependency 'rspec-expectations', '~> 3.2'
-  spec.add_development_dependency 'rspec-mocks', '~> 3.2'
-  spec.add_development_dependency 'rake', '~> 11.2'
-  spec.add_development_dependency 'rubocop', '~> 0.42.0'
+  spec.add_development_dependency 'pry-byebug', '~> 3.4'
+  spec.add_development_dependency 'rspec-core', '~> 3.6'
+  spec.add_development_dependency 'rspec-expectations', '~> 3.6'
+  spec.add_development_dependency 'rspec-mocks', '~> 3.6'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rubocop', '~> 0.48.1'
 end

data/lib/graph_matching/algorithm/mcm_bipartite.rb

@@ -9,18 +9,16 @@ module GraphMatching
     # `MCMBipartite` implements Maximum Cardinality Matching in
     # bipartite graphs.
     class MCMBipartite < MatchingAlgorithm
-
       def initialize(graph)
         assert(graph).is_a(Graph::Bigraph)
         super
       end
 
       def match
-        u, v = g.partition
+        u = g.partition[0]
         m = []
 
-        while true
-
+        loop do
           # Begin each stage by clearing all labels and marks
           t = []
           predecessors = {}
@@ -31,11 +29,14 @@ module GraphMatching
           unmarked = r = u.select { |i| m[i] == nil }
 
           # While there are unmarked R-vertexes
-          while aug_path.nil? && start = unmarked.pop
+          loop do
+            break unless aug_path.nil?
+            start = unmarked.pop
+            break unless start
 
             # Follow the unmatched edges (if any) to vertexes in V
             # ignoring any V-vertexes already labeled T
-            unlabeled_across_unmatched_edges_from(start, g, m ,t).each do |vi|
+            unlabeled_across_unmatched_edges_from(start, g, m, t).each do |vi|
               t << vi
               predecessors[vi] = start
 
@@ -70,7 +71,7 @@ module GraphMatching
 
       def assert_valid_aug_path(path)
         unless path.length >= 2 && path.length.even?
-          raise "Invalid augmenting path"
+          raise 'Invalid augmenting path'
         end
       end
 
@@ -93,7 +94,7 @@ module GraphMatching
 
       def backtrack_from(end_vertex, predecessors)
         augmenting_path = [end_vertex]
-        while predecessors.has_key?(augmenting_path.last)
+        while predecessors.key?(augmenting_path.last)
           augmenting_path.push(predecessors[augmenting_path.last])
         end
         augmenting_path

data/lib/graph_matching/algorithm/mcm_general.rb

@@ -57,7 +57,7 @@ module GraphMatching
         # assign a start label and begin a new search)
         # set LABEL(u) = FIRST(u) = 0
 
-        while true do
+        loop do
           u += 1
           break if u > g.size
           if mate[u] != 0
@@ -275,7 +275,7 @@ module GraphMatching
           r(x, y, label, mate)
           r(y, x, label, mate)
         else
-          fail "Vertex #{v} has an unexpected label type"
+          raise "Vertex #{v} has an unexpected label type"
         end
       end
 

data/lib/graph_matching/algorithm/mwm_bipartite.rb

@@ -28,8 +28,7 @@ module GraphMatching
         u = init_duals(cats, dogs)
 
         # For each stage
-        while true do
-
+        loop do
           # Clear all labels and marks
           # Label all single dogs with S
           aug_path = nil
@@ -39,29 +38,31 @@ module GraphMatching
           q = s.dup.to_a
 
           # While searching
-          while aug_path.nil? && i = q.pop do
+          loop do
+            break unless aug_path.nil?
+            i = q.pop
+            break unless i
 
             # Follow the unmatched edges (if any) to free (unlabeled)
             # cats.  Only consider edges with slack (π) of 0.
-            unlabeled_across_unmatched_edges_from(i, g, m ,t).each do |j|
-              if π(u, i, j) == 0
-                t << j
-                predecessors[j] = i
-
-                # If there are matched edges, follow each to a dog and
-                # label the dog with S.  Otherwise, backtrack to
-                # construct an augmenting path.
-                m_dogs = matched_adjacent(j, i, g, m)
-
-                m_dogs.each do |md|
-                  s << md
-                  predecessors[md] = j
-                end
-
-                if m_dogs.empty?
-                  aug_path = backtrack_from(j, predecessors)
-                  break
-                end
+            unlabeled_across_unmatched_edges_from(i, g, m, t).each do |j|
+              next unless slack(u, i, j) == 0
+              t << j
+              predecessors[j] = i
+
+              # If there are matched edges, follow each to a dog and
+              # label the dog with S.  Otherwise, backtrack to
+              # construct an augmenting path.
+              m_dogs = matched_adjacent(j, i, g, m)
+
+              m_dogs.each do |md|
+                s << md
+                predecessors[md] = j
+              end
+
+              if m_dogs.empty?
+                aug_path = backtrack_from(j, predecessors)
+                break
               end
             end
           end
@@ -116,7 +117,7 @@ module GraphMatching
         s.each do |s_dog|
           g.each_adjacent(s_dog) do |cat|
             unless t.include?(cat)
-              slacks.push π(u, s_dog, cat)
+              slacks.push slack(u, s_dog, cat)
             end
           end
         end
@@ -138,10 +139,9 @@ module GraphMatching
 
       # Returns the "slack" of an edge (Galil, 1986, p.30), the
       # difference between an edge's duals and its weight.
-      def π(u, i, j)
+      def slack(u, i, j)
         u[i] + u[j] - @weight[i - 1][j - 1]
       end
-
     end
   end
 end

data/lib/graph_matching/algorithm/mwm_general.rb

@@ -19,7 +19,7 @@ module GraphMatching
       LBL_S = 1
       LBL_T = 2
       LBL_CRUMB = 5
-      LBL_NAMES = %w(Free S T Crumb)
+      LBL_NAMES = %w(Free S T Crumb).freeze
 
       def initialize(graph)
         assert(graph).is_a(Graph::WeightedGraph)
@@ -42,13 +42,12 @@ module GraphMatching
 
         # Iterative *stages*.  Each stage augments the matching.
         # There can be at most n stages, where n is num. vertexes.
-        while true do
+        loop do
           init_stage
 
           # *sub-stages* either augment or scale the duals.
           augmented = false
-          while true do
-
+          loop do
             # > The search is conducted by scanning the S-vertices
             # > in turn. (Galil, 1986, p. 26)
             until augmented || @queue.empty?
@@ -60,9 +59,9 @@ module GraphMatching
             # > There is no augmenting path under these constraints;
             # > compute delta and reduce slack in the optimization problem.
             # > (Van Rantwijk, mwmatching.py, line 732)
-            delta, delta_type, delta_edge, delta_blossom = calc_delta(max_cardinality)
+            delta, d_type, d_edge, d_blossom = calc_delta(max_cardinality)
             update_duals(delta)
-            optimum = act_on_minimum_delta(delta_type, delta_edge, delta_blossom)
+            optimum = act_on_minimum_delta(d_type, d_edge, d_blossom)
             break if optimum
           end
 
@@ -91,21 +90,23 @@ module GraphMatching
           @tight_edge[delta_edge] = true
           i, j = @edges[delta_edge].to_a
           if @label[@in_blossom[i]] == LBL_FREE
-            i, j = j, i
+            # Think of this as swapping i and j, but the corresponding
+            # assignment `j = i` happens to be unnecessary.
+            i = j
           end
           assert_label(@in_blossom[i], LBL_S)
           @queue.push(i)
         when 3
           # > Use the least-slack edge to continue the search.
           @tight_edge[delta_edge] = true
-          i, j = @edges[delta_edge].to_a
+          i = @edges[delta_edge].to_a[0]
           assert_label(@in_blossom[i], LBL_S)
           @queue.push(i)
         when 4
           # > Expand the least-z blossom.
           expand_blossom(delta_blossom, false)
         else
-          fail "Invalid delta_type: #{delta_type}"
+          raise "Invalid delta_type: #{delta_type}"
         end
         optimum
       end
@@ -138,19 +139,19 @@ module GraphMatching
         #
         @blossom_children[b] = []
         @blossom_endps[b] = []
-        trace_to_base(bv, bb) do |bv|
-          @blossom_parent[bv] = b
-          @blossom_children[b] << bv
-          @blossom_endps[b] << @label_end[bv]
+        trace_to_base(bv, bb) do |bv2|
+          @blossom_parent[bv2] = b
+          @blossom_children[b] << bv2
+          @blossom_endps[b] << @label_end[bv2]
         end
         @blossom_children[b] << bb
         @blossom_children[b].reverse!
         @blossom_endps[b].reverse!
         @blossom_endps[b] << 2 * k
-        trace_to_base(bw, bb) do |bw|
-          @blossom_parent[bw] = b
-          @blossom_children[b] << bw
-          @blossom_endps[b] << (@label_end[bw] ^ 1)
+        trace_to_base(bw, bb) do |bw2|
+          @blossom_parent[bw2] = b
+          @blossom_children[b] << bw2
+          @blossom_endps[b] << (@label_end[bw2] ^ 1)
         end
 
         # > Set label to S
@@ -162,58 +163,58 @@ module GraphMatching
         @dual[b] = 0
 
         # > Relabel vertices.
-        blossom_leaves(b).each do |v|
-          if @label[@in_blossom[v]] == LBL_T
+        blossom_leaves(b).each do |leaf|
+          if @label[@in_blossom[leaf]] == LBL_T
             # > This T-vertex now turns into an S-vertex because it
             # > becomes part of an S-blossom; add it to the queue.
-            @queue << v
+            @queue << leaf
           end
-          @in_blossom[v] = b
+          @in_blossom[leaf] = b
         end
 
         # > Compute blossombestedges[b].
         best_edge_to = rantwijk_array(nil)
-        @blossom_children[b].each do |bv|
-          if @blossom_best_edges[bv].nil?
+        @blossom_children[b].each do |child|
+          if @blossom_best_edges[child].nil?
             # > This subblossom [bv] does not have a list of least-
             # > slack edges.  Get the information from the vertices.
-            nblists = blossom_leaves(bv).map { |v|
-              @neighb_end[v].map { |p|
-                p / 2 # floor division
+            nblists = blossom_leaves(child).map { |leaf|
+              @neighb_end[leaf].map { |p|
+                p / 2 # Intentional floor division
               }
             }
           else
             # > Walk this subblossom's least-slack edges.
-            nblists = [@blossom_best_edges[bv]]
+            nblists = [@blossom_best_edges[child]]
           end
 
           nblists.each do |nblist|
-            nblist.each do |k|
-              i, j = @edges[k].to_a
+            nblist.each do |x|
+              i, j = @edges[x].to_a
               if @in_blossom[j] == b
-                i, j = j, i
+                # Think of this as swapping i and j, but the corresponding
+                # assignment `i = j` happens to be unnecessary.
+                j = i
               end
               bj = @in_blossom[j]
-              if bj != b &&
-                  @label[bj] == LBL_S &&
-                  (best_edge_to[bj] == nil || slack(k) < slack(best_edge_to[bj]))
-                best_edge_to[bj] = k
+              if better_edge_to?(bj, x, b, best_edge_to)
+                best_edge_to[bj] = x
               end
             end
           end
 
           # > Forget about least-slack edges of the subblossom.
-          @blossom_best_edges[bv] = nil
-          @best_edge[bv] = nil
+          @blossom_best_edges[child] = nil
+          @best_edge[child] = nil
         end
 
         @blossom_best_edges[b] = best_edge_to.compact
 
         # > Select bestedge[b]
         @best_edge[b] = nil
-        @blossom_best_edges[b].each do |k|
-          if @best_edge[b].nil? || slack(k) < slack(@best_edge[b])
-            @best_edge[b] = k
+        @blossom_best_edges[b].each do |edge|
+          if @best_edge[b].nil? || slack(edge) < slack(@best_edge[b])
+            @best_edge[b] = edge
           end
         end
       end
@@ -223,7 +224,7 @@ module GraphMatching
         s = @label[b] == LBL_S
         m = @label_end[b] == @mate[@blossom_base[b]]
         unless t || s && m
-          fail <<-EOS
+          raise <<-EOS
               Assertion failed: Expected either:
               1. Current Bv to be a T-blossom, or
               2. Bv is an S-blossom and its base is matched to @label_end[bv]
@@ -233,7 +234,7 @@ module GraphMatching
 
       def assert_label(ix, lbl)
         unless @label[ix] == lbl
-          fail "Expected label at #{ix} to be #{LBL_NAMES[lbl]}"
+          raise "Expected label at #{ix} to be #{LBL_NAMES[lbl]}"
         end
       end
 
@@ -258,7 +259,7 @@ module GraphMatching
           # with an external mate.)
           base = @blossom_base[b]
           if @mate[base].nil?
-            fail "Expected blossom #{b}'s base (#{base}) to be matched"
+            raise "Expected blossom #{b}'s base (#{base}) to be matched"
           end
 
           # Assign label S to the mate of blossom b's base.
@@ -266,9 +267,13 @@ module GraphMatching
           # The bitwise XOR is very clever. `mate[x]` and `mate[x] ^ 1`
           # are connected "endpoints".
           base_edge_endpoints = [@mate[base], @mate[base] ^ 1]
-          assign_label(@endpoint[base_edge_endpoints[0]], LBL_S, base_edge_endpoints[1])
+          assign_label(
+            @endpoint[base_edge_endpoints[0]],
+            LBL_S,
+            base_edge_endpoints[1]
+          )
         else
-          fail ArgumentError, "Unexpected label: #{t}"
+          raise ArgumentError, "Unexpected label: #{t}"
         end
       end
 
@@ -329,7 +334,7 @@ module GraphMatching
           # > until we find a single vertex, swapping matched and unmatched
           # > edges as we go.
           # > (Van Rantwijk, mwmatching.py, line 504)
-          while true
+          loop do
             bs = @in_blossom[s]
             assert_label(bs, LBL_S)
             assert(@label_end[bs]).eq(@mate[@blossom_base[bs]])
@@ -361,6 +366,12 @@ module GraphMatching
         end
       end
 
+      def better_edge_to?(bj, k, b, best_edge_to)
+        bj != b &&
+          @label[bj] == LBL_S &&
+          (best_edge_to[bj] == nil || slack(k) < slack(best_edge_to[bj]))
+      end
+
       # TODO: Optimize by returning lazy iterator
       def blossom_leaves(b, ary = [])
         if b < @nvertex
@@ -391,7 +402,7 @@ module GraphMatching
           jstep = -1
           endptrick = 1
         end
-        return j, jstep, endptrick
+        [j, jstep, endptrick]
       end
 
       def calc_delta(max_cardinality)
@@ -410,41 +421,40 @@ module GraphMatching
         # > Compute delta2: the minimum slack on any edge between
         # > an S-vertex and a free vertex.
         # > (Van Rantwijk, mwmatching.py)
-        (0 ... @nvertex).each do |v|
-          if @label[@in_blossom[v]] == LBL_FREE && !@best_edge[v].nil?
-            d = slack(@best_edge[v])
-            if delta_type == nil || d < delta
-              delta = d
-              delta_type = 2
-              delta_edge = @best_edge[v]
-            end
-          end
+        (0...@nvertex).each do |v|
+          next unless @label[@in_blossom[v]] == LBL_FREE && !@best_edge[v].nil?
+          d = slack(@best_edge[v])
+          next unless delta_type == nil || d < delta
+          delta = d
+          delta_type = 2
+          delta_edge = @best_edge[v]
         end
 
         # > Compute delta3: half the minimum slack on any edge between
         # > a pair of S-blossoms.
         # > (Van Rantwijk, mwmatching.py)
-        (0 ... 2 * @nvertex).each do |b|
-          if @blossom_parent[b].nil? && @label[b] == LBL_S && !@best_edge[b].nil?
-            kslack = slack(@best_edge[b])
-            d = kslack / 2 # Van Rantwijk had some type checking here.  Why?
-            if delta_type.nil? || d < delta
-              delta = d
-              delta_type = 3
-              delta_edge = @best_edge[b]
-            end
+        (0...2 * @nvertex).each do |b|
+          unless @blossom_parent[b].nil? &&
+              @label[b] == LBL_S &&
+              !@best_edge[b].nil?
+            next
           end
+          kslack = slack(@best_edge[b])
+          d = kslack / 2 # Van Rantwijk had some type checking here.  Why?
+          next unless delta_type.nil? || d < delta
+          delta = d
+          delta_type = 3
+          delta_edge = @best_edge[b]
         end
 
         # > Compute delta4: minimum z variable of any T-blossom.
         # > (Van Rantwijk, mwmatching.py)
-        (@nvertex ... 2 * @nvertex).each do |b|
+        (@nvertex...2 * @nvertex).each do |b|
           top_t_blossom = top_level_blossom?(b) && @label[b] == LBL_T
-          if top_t_blossom && (delta_type.nil? || @dual[b] < delta)
-            delta = @dual[b]
-            delta_type = 4
-            delta_blossom = b
-          end
+          next unless top_t_blossom && (delta_type.nil? || @dual[b] < delta)
+          delta = @dual[b]
+          delta_type = 4
+          delta_blossom = b
         end
 
         if delta_type.nil?
@@ -457,7 +467,7 @@ module GraphMatching
           delta = [0, @dual[0, @nvertex].min].max
         end
 
-        return delta, delta_type, delta_edge, delta_blossom
+        [delta, delta_type, delta_edge, delta_blossom]
       end
 
       # Returns nil if `k` is known to be an endpoint of a tight
@@ -609,16 +619,20 @@ module GraphMatching
 
           # > Relabel the T-sub-blossom.
           @label[@endpoint[p ^ 1]] = LBL_FREE
-          @label[@endpoint[@blossom_endps[b][j - endptrick] ^ endptrick ^ 1]] = LBL_FREE
+          @label[
+            @endpoint[@blossom_endps[b][j - endptrick] ^ endptrick ^ 1]
+          ] = LBL_FREE
           assign_label(@endpoint[p ^ 1], LBL_T, p)
 
           # > Step to the next S-sub-blossom and note its forward endpoint.
-          @tight_edge[@blossom_endps[b][j - endptrick] / 2] = true # floor division
+          # Intentional floor division
+          @tight_edge[@blossom_endps[b][j - endptrick] / 2] = true
           j += jstep
           p = @blossom_endps[b][j - endptrick] ^ endptrick
 
           # > Step to the next T-sub-blossom.
-          @tight_edge[p / 2] = true # floor division
+          # Intentional floor division
+          @tight_edge[p / 2] = true
           j += jstep
         end
 
@@ -662,7 +676,7 @@ module GraphMatching
       # > End of a stage; expand all S-blossoms which have dualvar = 0.
       # > (Van Rantwijk, mwmatching.py)
       def expand_tight_s_blossoms
-        (@nvertex ... 2 * @nvertex).each do |b|
+        (@nvertex...2 * @nvertex).each do |b|
           if top_level_blossom?(b) && @label[b] == LBL_S && @dual[b] == 0
             expand_blossom(b, true)
           end
@@ -686,11 +700,10 @@ module GraphMatching
       # Data structures used throughout the algorithm.
       def init_algorithm_structures
         # > If v is a vertex,
-        # > mate[v] is the remote endpoint of its matched edge, or -1 if it is single
-        # > (i.e. endpoint[mate[v]] is v's partner vertex).
+        # > mate[v] is the remote endpoint of its matched edge, or -1 if it is
+        # > single (i.e. endpoint[mate[v]] is v's partner vertex).
         # > Initially all vertices are single; updated during augmentation.
         # > (Van Rantwijk, mwmatching.py)
-        #
         @mate = Array.new(@nvertex, nil)
 
         # > If b is a top-level blossom,
@@ -699,37 +712,29 @@ module GraphMatching
         # >             2 if b is a T-vertex/blossom.
         # > The label of a vertex is found by looking at the label of its
         # > top-level containing blossom.
-        # > If v is a vertex inside a T-blossom,
-        # > label[v] is 2 iff v is reachable from an S-vertex outside the blossom.
-        # > Labels are assigned during a stage and reset after each augmentation.
+        # > If v is a vertex inside a T-blossom, label[v] is 2 iff v is
+        # > reachable from an S-vertex outside the blossom. Labels are assigned
+        # > during a stage and reset after each augmentation.
         # > (Van Rantwijk, mwmatching.py)
-        #
         @label = rantwijk_array(LBL_FREE)
 
-        # > If b is a labeled top-level blossom,
-        # > labelend[b] is the remote endpoint of the edge through which b obtained
-        # > its label, or -1 if b's base vertex is single.
-        # > If v is a vertex inside a T-blossom and label[v] == 2,
-        # > labelend[v] is the remote endpoint of the edge through which v is
-        # > reachable from outside the blossom.
-        # > (Van Rantwijk, mwmatching.py)
-        #
+        # > If b is a labeled top-level blossom, labelend[b] is the remote
+        # > endpoint of the edge through which b obtained its label, or -1 if
+        # > b's base vertex is single. If v is a vertex inside a T-blossom and
+        # > label[v] == 2, labelend[v] is the remote endpoint of the edge
+        # > through which v is reachable from outside the blossom. (Van
+        # > Rantwijk, mwmatching.py)
         @label_end = rantwijk_array(nil)
 
-        # > If v is a vertex,
-        # > inblossom[v] is the top-level blossom to which v belongs.
-        # > If v is a top-level vertex, v is itself a blossom (a trivial blossom)
-        # > and inblossom[v] == v.
-        # > Initially all vertices are top-level trivial blossoms.
-        # > (Van Rantwijk, mwmatching.py)
-        #
-        @in_blossom = (0 ... @nvertex).to_a
+        # > If v is a vertex, inblossom[v] is the top-level blossom to which v
+        # > belongs. If v is a top-level vertex, v is itself a blossom (a
+        # > trivial blossom) and inblossom[v] == v. Initially all vertices are
+        # > top-level trivial blossoms. (Van Rantwijk, mwmatching.py)
+        @in_blossom = (0...@nvertex).to_a
 
-        # > If b is a sub-blossom,
-        # > blossomparent[b] is its immediate parent (sub-)blossom.
-        # > If b is a top-level blossom, blossomparent[b] is -1.
+        # > If b is a sub-blossom, blossomparent[b] is its immediate parent
+        # > (sub-)blossom. If b is a top-level blossom, blossomparent[b] is -1.
         # > (Van Rantwijk, mwmatching.py)
-        #
         @blossom_parent = rantwijk_array(nil)
 
         # A 2D array representing a tree of blossoms.
@@ -760,7 +765,7 @@ module GraphMatching
         # > blossombase[b] is its base VERTEX (i.e. recursive sub-blossom).
         # > (Van Rantwijk, mwmatching.py, line 153)
         #
-        @blossom_base = (0 ... @nvertex).to_a + Array.new(@nvertex, nil)
+        @blossom_base = (0...@nvertex).to_a + Array.new(@nvertex, nil)
 
         # > If b is a non-trivial (sub-)blossom,
         # > blossomendps[b] is a list of endpoints on its connecting edges,
@@ -792,7 +797,7 @@ module GraphMatching
 
         # > List of currently unused blossom numbers.
         # > (Van Rantwijk, mwmatching.py, line 174)
-        @unused_blossoms = (@nvertex ... 2 * @nvertex).to_a
+        @unused_blossoms = (@nvertex...2 * @nvertex).to_a
 
         # > If v is a vertex,
         # > dualvar[v] = 2 * u(v) where u(v) is the v's variable in the dual
@@ -884,7 +889,7 @@ module GraphMatching
       # > the queue. (Van Rantwijk, mwmatching.py, line 649)
       def init_stage_labels
         @label = rantwijk_array(LBL_FREE)
-        (0 ... @nvertex).each do |v|
+        (0...@nvertex).each do |v|
           if @mate[v].nil? && @label[@in_blossom[v]] == LBL_FREE
             assign_label(v, LBL_S)
           end
@@ -1006,7 +1011,7 @@ module GraphMatching
         augmented = false
 
         @neighb_end[v].each do |p|
-          k = p / 2 # floor division
+          k = p / 2 # Intentional floor division
           w = @endpoint[p]
 
           if @in_blossom[v] == @in_blossom[w]
@@ -1050,7 +1055,7 @@ module GraphMatching
       # > .. we make the following changes in the dual
       # > variables. (Galil, 1986, p. 32)
       def update_duals(delta)
-        (0 ... @nvertex).each do |v|
+        (0...@nvertex).each do |v|
           case @label[@in_blossom[v]]
           when LBL_S
             @dual[v] -= delta
@@ -1060,16 +1065,15 @@ module GraphMatching
             # No change to free vertexes
           end
         end
-        (@nvertex ... 2 * @nvertex).each do |b|
-          if top_level_blossom?(b)
-            case @label[b]
-            when LBL_S
-              @dual[b] += delta
-            when LBL_T
-              @dual[b] -= delta
-            else
-              # No change to free blossoms
-            end
+        (@nvertex...2 * @nvertex).each do |b|
+          next unless top_level_blossom?(b)
+          case @label[b]
+          when LBL_S
+            @dual[b] += delta
+          when LBL_T
+            @dual[b] -= delta
+          else
+            # No change to free blossoms
           end
         end
       end