gfa 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7a646a57c98f25bda2120b3e04783099433d7aa7c8f0658a1bfdcd07e0dea35
-  data.tar.gz: c8aec87b21fd9b1d7972228fa7118cf71b40f58a5dd20e385e6e80ef86b2ef92
+  metadata.gz: 19dfd08ccdacfb94b432f3f5f131eac2015af842e2743d65189a3e0b0f43ec38
+  data.tar.gz: 6db8c334210acac287f5fde451d5d35b143872982a3e9ea680e149c4c5c49205
 SHA512:
-  metadata.gz: 3f4c54a483e4cd6baaf66fbddda2e7eb41a13cd14bd492c5132a2d2610bdd2f283d7a92c261dca10f54fb9e03611ca7f7c05036fa783c361d4b8e752e9fd6b53
-  data.tar.gz: 2b17c35013f3c9dbdb99a20e060c2dde13732c139f0551f3ce5b65e317ad5d1918b84447570542b11b67f5d65387729606de914b18994c420e5fe8b41b9bf5af
+  metadata.gz: f54d487e8af5817a1630c01f4cc315ada464127804e4086b82826e0555d5f41be7458dbb11dd038f3f0f49f607a0aa1d4eb5c68c65d316e3d9a6e3d5e3abe151
+  data.tar.gz: 3fb919b9ce1171d82bc51d3afefcb2c82e7cf15bb72482f9a03e066d66dcec65dd990aef07734bbc3874fa8bcebf0d54561f73b93314265f64047322ccdc05b5

data/lib/gfa/common.rb

@@ -1,4 +1,5 @@
 require 'gfa/version'
+require 'gfa/matrix'
 require 'gfa/record_set'
 require 'gfa/field'
 
@@ -10,6 +11,41 @@ class GFA
     end
   end
 
+  def self.advance_bar(n)
+    @advance_bar_n = n
+    @advance_bar_i = 0
+    @advance_bar_p = 0
+    @advance_bar_s = Time.now
+    $stderr.print '  [' + (' ' * 50) + ']' + " #{n}\r"
+    $stderr.print '  [>'
+  end
+
+  def self.advance
+    @advance_bar_i += 1
+    # $stderr.print "#{@advance_bar_i}"[-1] + "\b"
+    while 50 * @advance_bar_i / @advance_bar_n > @advance_bar_p
+      $stderr.print "\b=>"
+      @advance_bar_p += 1
+    end
+    return unless @advance_bar_i == @advance_bar_n
+
+    $stderr.print "\b]\r"
+    t_t = Time.now - @advance_bar_s
+    t_u = 'sec'
+
+    if t_t > 60
+      t_t /= 60
+      t_u = 'min'
+    end
+
+    if t_t > 60
+      t_t /= 60
+      t_u = 'h'
+    end
+
+    $stderr.puts '  [ %-48s ]' % "Time elapsed: #{'%.1f' % t_t} #{t_u}"
+  end
+
   # Instance-level
   attr :gfa_version, :records, :opts
 

data/lib/gfa/graph.rb

@@ -22,10 +22,36 @@ class GFA
     implicit_graph(opts).to_adjacency
   end
 
+  ##
+  # Calculate and store internally a matrix representing all edges.
+  def calculate_edge_matrix!
+    $stderr.puts '- Building edge matrix'
+    @edge_matrix = GFA::Matrix.new(segments.size, segments.size)
+    self.class.advance_bar(all_edges.size)
+    all_edges.each do |edge|
+      self.class.advance
+      idx = edge.segments(self).map { |i| segments.position(i) }
+      idx.each do |i|
+        idx.each do |j|
+          @edge_matrix[i, j] = true unless i == j
+        end
+      end
+    end
+    @edge_matrix
+  end
+
+  ##
+  # Returns the matrix representing all edges
+  def edge_matrix
+    @edge_matrix or calculate_edge_matrix!
+  end
+
   ##
   # Extracts the subset of records associated to +segments+, which is an Array
-  # with values of any class in: Integer (segment index),
-  # String or GFA::Field::String (segment names), or GFA::Record::Segment.
+  # with values of any class in:
+  # - Integer: segment index,
+  # - String or GFA::Field::String: segment names, or
+  # - GFA::Record::Segment: the actual segments themselves
   #
   # +degree+ indicates the maximum degree of separation between the original
   # segment set and any additional segments. Use 0 to include only the segments
@@ -63,8 +89,7 @@ class GFA
     segments.each { |segment| gfa << segment }
 
     # Expand graph
-    linking, edges = linking_records(gfa.segments, degree: degree)
-    linking += internally_linking_records(segments, edges)
+    linking = linking_records(gfa.segments, degree: degree)
     linking.each { |record| gfa << record }
 
     # Return
@@ -84,70 +109,54 @@ class GFA
   # of the +segments+ set (assumes they have already been evaluated). This is
   # only used for internal heuristics
   #
-  # Returns an Array of with two elements:
-  # 0. An array of GFA::Record objects with all the identified linking records
-  # 1. An array of GFA::Record objects with all edges that were not identified
+  # Returns an array of GFA::Record objects with all the identified linking
+  # records (edges)
   #
   # IMPORTANT NOTE 1: The object +segments+ will be modified to include all
   # linked segments. If you don't want this behaviour, please make sure to pass
   # a duplicate of the object instead.
-  #
-  # IMPORTANT NOTE 2: The list of linking records may not comprehensively
-  # include all records linking the identified expanded segment set. To ensure
-  # a consistent set is identified, use:
-  # linking, edges = gfa.linking_records(segments)
-  # linking += gfa.internally_linking_records(segments, edges)
-  # 
-  def linking_records(segments, degree: 1, edges: nil, _ignore: 0)
+  def linking_records(segments, degree: 1)
     unless segments.is_a? GFA::RecordSet::SegmentSet
       raise "Unrecognised class: #{segments.class}"
     end
 
-    # Gather edges to evaluate
-    edges ||= all_edges
-    return [[], edges] if degree <= 0
-
-    # Links, Containments, Jumps (from, to) and Paths (segment_names)
-    linking = []
-    eval_set = _ignore == 0 ? segments.set : segments.set[_ignore..]
-    edges.delete_if do |edge|
-      if eval_set.any? { |segment| edge.include? segment }
-        linking << edge
-        true  # Remove from the edge set to speed up future recursions
-      else
-        false # Keep it, possibly linking future recursions 
-      end
-    end
-
-    # Recurse and return
-    if degree >= 1
-      pre = segments.size
-
-      # Add additional linked segments
-      linking.each do |record|
-        record.segments(self).each do |other_seg|
-          segments << other_seg unless segments[other_seg.name]
+    return [] if degree <= 0
+
+    edge_matrix # Just to trigger matrix calculation
+    degree.times do |round|
+      $stderr.puts "- Expansion round #{round + 1}"
+      self.class.advance_bar(segments.size)
+      pre_expansion = segments.size
+      new_segments = []
+      segments.set.each do |segment|
+        self.class.advance
+        idx = self.segments.position(segment)
+        edge_matrix[nil, idx].each_with_index do |edge, target_k|
+          new_segments << target_k if edge
         end
       end
-
-      # Recurse only if new segments were discovered
-      if segments.size > pre
-        $stderr.puts "- Recursion [#{degree}]: " \
-                     "#{pre} -> #{segments.size}\t(#{edges.size})"
-        linking +=
-          linking_records(
-            segments,
-            degree: degree - 1, edges: edges, _ignore: pre
-          )[0]
-      end
+      new_segments = new_segments.uniq.map { |i| self.segments[i] }
+      new_segments.each { |i| segments << i unless segments[i.name] }
+      new = segments.size - pre_expansion
+      $stderr.puts "  #{new} segments found, total: #{segments.size}"
+      break if new == 0
     end
-    [linking, edges]
+
+    internally_linking_records(segments, all_edges)
   end
 
   def internally_linking_records(segments, edges)
+    unless segments.is_a? GFA::RecordSet::SegmentSet
+      raise "Unrecognised class: #{segments.class}"
+    end
+
     $stderr.puts '- Gathering internally linking records'
-    segments = Hash[segments.map { |i| [i.name.value, true]}]
-    edges.select { |record| record.segment_names_a.all? { |s| segments[s] } }
+    s_names = Hash[segments.set.map { |i| [i.name.value, true]}]
+    self.class.advance_bar(edges.size)
+    edges.select do |record|
+      self.class.advance
+      record.segment_names_a.all? { |s| s_names[s] }
+    end
   end
 
   ##
@@ -155,7 +164,7 @@ class GFA
   # from the GFA. I.e., all links, jumps, containments, and paths.
   def all_edges
     edge_t = %i[Link Jump Containment Path]
-    edges = edge_t.flat_map { |t| records[t].set } if edges.nil?
+    @edges ||= edge_t.flat_map { |t| records[t].set }
   end
 
   private

data/lib/gfa/matrix.rb

@@ -0,0 +1,96 @@
+
+##
+# A class to represent sparse matrices internally used for graph operations
+class GFA::Matrix
+
+  attr_accessor :rows, :columns, :values
+
+  ##
+  # Initialize a Matrix with +rows+ and +columns+ (both should be Integer),
+  # and a default +value+ (+nil+ if missing)
+  def initialize(rows, columns, value = nil)
+    raise 'Matrix rows must be an integer' unless rows.is_a? Integer
+    raise 'Matrix columns must be an integer' unless columns.is_a? Integer
+    raise 'Matrix rows must be positive' if rows < 0
+    raise 'Matrix columns must be positive' if columns < 0
+
+    @rows    = rows
+    @columns = columns
+    @values  = Hash.new(value)
+  end
+
+  def [](row = nil, col = nil)
+    index(row, col).map { |i| values[i] }
+  end
+
+  def []=(row, col, value)
+    values = (row.nil? || col.nil?) ? value : [value]
+    unless values.is_a? Array
+      raise 'Value must be an array if setting a range of cells'
+    end
+
+    idx = index(row, col)
+    if idx.size != values.size
+      raise "Expected #{idx.size} values, but only got #{values.size}"
+    end
+    idx.each_with_index.map { |i, k| @values[i] = values[k] }
+  end
+
+  ##
+  # Determines the index of +row+ and +col+ (both must be defined Integer),
+  # sets its value to an empty Array if not yet defined, and appends +value+.
+  # Returns an error if the value already exists but it's not an array
+  def append(row, col, value)
+    raise 'wow must be a defined integer' unless row.is_a?(Integer)
+    raise 'col must be a defined integer' unless col.is_a?(Integer)
+
+    idx = index(row, col).first
+    @values[idx] ||= []
+    unless @values[idx].is_a? Array
+      raise 'The values exists and it is not an array'
+    end
+
+    @values[idx] << value
+  end
+
+  ##
+  # Returns the list of indexes determined by +row+ and +col+ as an Array:
+  # - If +row+ and +col+ are Integer, it returns the value at the given cell
+  # - If both +row+ and +col+ are +nil+, it returns the indexes for all values
+  # - If +row+ xor +col+ are +nil+, it returns the indexes of the entire column
+  #   or row, respectively.
+  def index(row = nil, col = nil)
+    if row.nil? && col.nil?
+      # All values
+      (0 .. values.size - 1).to_a
+    elsif row.nil?
+      # Entire column
+      (col_offset(col) .. col_offset(col) + rows - 1).to_a
+    elsif col.nil?
+      # Entire row
+      ric = row_in_column(row)
+      (0 .. columns - 1).map { |i| col_offset(i) + ric }
+    else
+      # Single value
+      [col_offset(col) + row_in_column(row)]
+    end
+  end
+
+  ##
+  # Index of the first cell of the +col+. The column is a 0-based
+  # index, with negative integers representing columns counted from
+  # the bottom (-1 being the last column)
+  def col_offset(col)
+    col = cols + col if col < 0
+    col * rows
+  end
+
+  ##
+  # Index of the +row+ as if it was in the first column. The row
+  # is a 0-based index, with negative integers representing rows
+  # counted from the end (-1 being the last row)
+  def row_in_column(row)
+    row = rows + row if row < 0
+    row
+  end
+end

data/lib/gfa/parser.rb

@@ -48,6 +48,7 @@ class GFA
     blk = (lno.to_f / thr).ceil
 
     # Launch children processes
+    advance_bar(blk)
     io  = []
     pid = []
     thr.times do |i|
@@ -56,7 +57,10 @@ class GFA
         io[i][0].close
         o = opts.merge(line_range: [i * blk, (i + 1) * blk - 1])
         records = []
-        read_records(file, o) { |record| records << record }
+        read_records(file, o) do |record|
+          advance if i == 0
+          records << record
+        end
         Marshal.dump(records, io[i][1])
         exit!(0)
       end

data/lib/gfa/record/has_from_to.rb

@@ -10,7 +10,8 @@ module GFA::Record::HasFromTo
   ##
   # Extracts all linked segments from +gfa+ (which *must* be indexed)
   def segments(gfa)
-    raise "Unindexed GFA" unless gfa.indexed?
+    raise 'Unindexed GFA' unless gfa.indexed?
+
     [gfa.segments[from.value], gfa.segments[to.value]]
   end
 

data/lib/gfa/record/path.rb

@@ -27,10 +27,9 @@ class GFA::Record::Path < GFA::Record
   ##
   # Extracts all linked segments from +gfa+ (which *must* be indexed)
   def segments(gfa)
-    raise "Unindexed GFA" unless gfa.indexed?
-    segment_names_a.map do |name|
-      gfa.segments[name]
-    end
+    raise 'Unindexed GFA' unless gfa.indexed?
+
+    segment_names_a.map { |name| gfa.segments[name] }
   end
 
   ##

data/lib/gfa/record_set.rb

@@ -23,12 +23,13 @@ class GFA::RecordSet
 
   # Instance-level
 
-  attr_reader :set, :index, :gfa
+  attr_reader :set, :index, :position, :gfa
 
   def initialize(gfa = nil)
-    @set   = []
-    @index = {}
-    @gfa   = gfa || GFA.new
+    @set      = []
+    @index    = {}
+    @position = {}
+    @gfa      = gfa || GFA.new
   end
 
   def [](k)
@@ -69,6 +70,7 @@ class GFA::RecordSet
     raise "Wrong type of record: #{v.type}" if v.type != type
 
     @set << v
+    @position[index_id(v)] = set.size - 1
     index!(v)
   end
 
@@ -109,6 +111,12 @@ class GFA::RecordSet
     @index[k]
   end
 
+  def position(v)
+    v = index_id(v) if v.is_a? GFA::Record
+    v = v.value if v.is_a? GFA::Field
+    @position[v]
+  end
+
   def merge!(record_set)
     raise "Not a record set" unless record_set.is_a?(GFA::RecordSet)
     if record_set.type != type

data/lib/gfa/version.rb

@@ -1,5 +1,5 @@
 class GFA
-  VERSION       = '0.7.0'
+  VERSION       = '0.8.1'
   VERSION_ARRAY = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR = VERSION_ARRAY[1] # :nodoc:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gfa
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-10 00:00:00.000000000 Z
+date: 2023-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgl
@@ -81,6 +81,7 @@ files:
 - lib/gfa/field/string.rb
 - lib/gfa/generator.rb
 - lib/gfa/graph.rb
+- lib/gfa/matrix.rb
 - lib/gfa/modules.rb
 - lib/gfa/parser.rb
 - lib/gfa/record.rb