rgfa 1.2.1

data/lib/rgfa/multiplication.rb

@@ -0,0 +1,156 @@
+require_relative "error.rb"
+
+#
+# Method for the RGFA class, which allow to split a segment into
+# multiple copies.
+#
+module RGFA::Multiplication
+
+  # Create multiple copies of a segment.
+  #
+  # == Automatic computation of the copy names
+  #
+  # - Can be overridden, by providing an array of copy names.
+  # - First, it is checked if the name of the original segment ends with a
+  #   relevant
+  #   string, i.e. a lower case letter (for +:lowcase+), an upper case letter
+  #   (for +:upcase+), a digit (for +:number+), or the string +"_copy"+
+  #   plus one or more optional digits (for +:copy+).
+  # - If so, it is assumed, it was already a copy, and it is not
+  #   altered.
+  # - If not, then +a+ (for +:lowcase+), +A+ (for +:upcase+), +1+ (for
+  #   +:number+), +_copy+ (for +:copy+) is appended to the string.
+  # - Then, in all
+  #   cases, next (*) is called on the string, until a valid, non-existant name
+  #   is found for each of the segment copies
+  # - (*) = except for +:copy+, where
+  #   for the first copy no digit is present, but for the following is,
+  #   i.e. the segment names will be +:copy+, +:copy2+, +:copy3+, etc.
+  #
+  # @param [Integer] factor multiplication factor; if 0, delete the segment;
+  #   if 1; do nothing; if > 1; number of copies to create
+  # @param segment [String, RGFA::Line::Segment] segment name or instance
+  # @param [:lowcase, :upcase, :number, :copy, Array<String>] copy_names
+  #   <i>(Defaults to: +:lowcase+)</i>
+  #   Array of names for the copies of the segment,
+  #   or a symbol, which defines a system to compute the names from the name of
+  #   the original segment. See "automatic computation of the copy names".
+  # @param [Boolean] conserve_components <i>(Defaults to: +true+)</i>
+  #   If factor == 0 (i.e. deletion), delete segment only if
+  #   {#cut_segment?}(segment) is +false+.
+  #
+  # @return [RGFA] self
+  def multiply(segment, factor, copy_names: :lowcase,
+               conserve_components: true)
+    segment_name = segment.kind_of?(RGFA::Line) ? segment.name : segment
+    if factor < 2
+      return self if factor == 1
+      return self if cut_segment?(segment_name) and conserve_components
+      return delete_segment(segment_name)
+    end
+    s = segment!(segment_name)
+    divide_segment_and_connection_counts(s, factor)
+    copy_names = compute_copy_names(copy_names, segment_name, factor)
+    copy_names.each {|cn| clone_segment_and_connections(s, cn)}
+    return self
+  end
+
+  private
+
+  def compute_copy_names(copy_names, segment_name, factor)
+    return nil if factor < 2
+    accepted = [:lowcase, :upcase, :number, :copy]
+    if copy_names.kind_of?(Array)
+      return copy_names
+    elsif !accepted.include?(copy_names)
+      raise ArgumentError,
+        "copy_names shall be an array of names or one of: "+
+        accepted.inspect
+    end
+    retval = []
+    next_name = segment_name.to_s
+    case copy_names
+    when :lowcase
+      if next_name =~ /^.*[a-z]$/
+        next_name = next_name.next
+      else
+        next_name += "b"
+      end
+    when :upcase
+      if next_name =~ /^.*[A-Z]$/
+        next_name = next_name.next
+      else
+        next_name += "B"
+      end
+    when :number
+      if next_name =~ /^.*[0-9]$/
+        next_name = next_name.next
+      else
+        next_name += "2"
+      end
+    when :copy
+      if next_name =~ /^.*_copy(\d*)$/
+        next_name += "1" if $1 == ""
+        next_name = next_name.next
+        copy_names = :number
+      else
+        next_name += "_copy"
+      end
+    end
+    while retval.size < (factor-1)
+      while retval.include?(next_name) or
+            @segments.has_key?(next_name.to_sym) or
+            @paths.has_key?(next_name.to_sym)
+        if copy_names == :copy
+          next_name += "1"
+          copy_names = :number
+        end
+        next_name = next_name.next
+      end
+      retval << next_name
+    end
+    return retval
+  end
+
+  def divide_counts(gfa_line, factor)
+    [:KC, :RC, :FC].each do |count_tag|
+      if gfa_line.optional_fieldnames.include?(count_tag)
+        value = (gfa_line.get(count_tag).to_f / factor)
+        gfa_line.set(count_tag, value.to_i)
+      end
+    end
+  end
+
+  def divide_segment_and_connection_counts(segment, factor)
+    divide_counts(segment, factor)
+    [:links,:containments].each do |rt|
+      [:from,:to].each do |dir|
+        [:+, :-].each do |o|
+          segment.send(rt)[dir][o].each do |l|
+            # circular link counts shall be divided only ones
+            next if dir == :to and l.from == l.to
+            divide_counts(l, factor)
+          end
+        end
+      end
+    end
+  end
+
+  def clone_segment_and_connections(segment, clone_name)
+    cpy = segment.clone
+    cpy.name = clone_name
+    self << cpy
+    [:links,:containments].each do |rt|
+      [:from,:to].each do |dir|
+        [:+, :-].each do |o|
+          segment.send(rt)[dir][o].each do |l|
+            lc = l.clone
+            lc.set(dir, clone_name)
+            self << lc
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/rgfa/numeric_array.rb

@@ -0,0 +1,196 @@
+require_relative "error"
+
+#
+# A numeric array representable using the data type B of the GFA specification
+#
+class RGFA::NumericArray < Array
+
+  # Subtypes for signed integers, from the smallest to the largest
+  SIGNED_INT_SUBTYPE = %W[c s i]
+
+  # Subtypes for unsigned integers, from the smallest to the largest
+  UNSIGNED_INT_SUBTYPE = SIGNED_INT_SUBTYPE.map{|st|st.upcase}
+
+  # Subtypes for integers
+  INT_SUBTYPE = UNSIGNED_INT_SUBTYPE + SIGNED_INT_SUBTYPE
+
+  # Subtypes for floats
+  FLOAT_SUBTYPE = ["f"]
+
+  # Subtypes
+  SUBTYPE = INT_SUBTYPE + FLOAT_SUBTYPE
+
+  # Number of bits of unsigned integer subtypes
+  SUBTYPE_BITS = {"c" => 8, "s" => 16, "i" => 32}
+
+  # Range for integer subtypes
+  SUBTYPE_RANGE = Hash[
+      INT_SUBTYPE.map do |subtype|
+        [
+         subtype,
+         if subtype == subtype.upcase
+           0..((2**SUBTYPE_BITS[subtype.downcase])-1)
+         else
+           (-(2**(SUBTYPE_BITS[subtype]-1)))..((2**(SUBTYPE_BITS[subtype]-1))-1)
+         end
+        ]
+      end
+    ]
+
+  # Validate the numeric array
+  #
+  # @raise [RGFA::NumericArray::ValueError] if the array is not valid
+  def validate!
+    compute_subtype
+  end
+
+  # Computes the subtype of the array from its content.
+  #
+  # If all elements are float, then the computed subtype is "f".
+  # If all elements are integer, the smallest possible numeric subtype
+  # is computed; thereby,
+  # if all elements are non-negative, an unsigned subtype is selected,
+  # otherwise a signed subtype.
+  # In all other cases an exception is raised.
+  #
+  # @raise [RGFA::NumericArray::ValueError] if the array is not a valid numeric
+  #   array
+  # @return [RGFA::NumericArray::SUBTYPE]
+  def compute_subtype
+    if all? {|f|f.kind_of?(Float)}
+      return "f"
+    else
+      e_max = nil
+      e_min = nil
+      each do |e|
+        if !e.kind_of?(Integer)
+          raise RGFA::NumericArray::ValueError,
+            "NumericArray does not contain homogenous numeric values\n"+
+            "Content: #{inspect}"
+        end
+        e_max = e if e_max.nil? or e > e_max
+        e_min = e if e_min.nil? or e < e_min
+      end
+      return RGFA::NumericArray.integer_type(e_min..e_max)
+    end
+  end
+
+  # Computes the subtype for integers in a given range.
+  #
+  # If all elements are non-negative, an unsigned subtype is selected,
+  # otherwise a signed subtype.
+  #
+  # @param range [Range] the integer range
+  #
+  # @raise [RGFA::NumericArray::ValueError] if the integer range is outside
+  #   all subtype ranges
+  #
+  # @return [RGFA::NumericArray::INT_SUBTYPE] subtype code
+  def self.integer_type(range)
+    if range.min < 0
+      SIGNED_INT_SUBTYPE.each do |st|
+        st_range = RGFA::NumericArray::SUBTYPE_RANGE[st]
+        if st_range.include?(range.min) and st_range.include?(range.max)
+          return st
+        end
+      end
+    else
+      UNSIGNED_INT_SUBTYPE.each do |st|
+        return st if range.max < RGFA::NumericArray::SUBTYPE_RANGE[st].max
+      end
+    end
+    raise RGFA::NumericArray::ValueError,
+      "NumericArray: values are outside of all integer subtype ranges\n"+
+      "Content: #{inspect}"
+  end
+
+  # Return self
+  # @param validate [Boolean] <i>(default: +false+)</i>
+  #   if +true+, validate the range of the numeric values, according
+  #   to the array subtype
+  # @raise [RGFA::NumericArray::ValueError] if validate is set and
+  #   any value is not compatible with the subtype
+  # @return [RGFA::NumericArray]
+  def to_numeric_array(validate: false)
+    validate! if validate
+    self
+  end
+
+  # GFA datatype B representation of the numeric array
+  # @raise [RGFA::NumericArray::ValueError] if the array
+  #   if not a valid numeric array
+  # @return [String]
+  def to_s
+    subtype = compute_subtype
+    "#{subtype},#{join(",")}"
+  end
+
+end
+
+# Exception raised if a value in a numeric array is not compatible
+# with the selected subtype
+class RGFA::NumericArray::ValueError < RGFA::Error; end
+
+# Exception raised if an invalid subtype code is found
+class RGFA::NumericArray::TypeError < RGFA::Error; end
+
+#
+# Method to create a numeric array from an array
+#
+class Array
+  # Create a numeric array from an Array instance
+  # @param validate [Boolean] <i>(default: +true+)</i>
+  #   if +true+, validate the range of the numeric values, according
+  #   to the array subtype
+  # @raise [RGFA::NumericArray::ValueError] if validate is set and
+  #   any value is not compatible with the subtype
+  # @return [RGFA::NumericArray] the numeric array
+  def to_numeric_array(validate: true)
+    na = RGFA::NumericArray.new(self)
+    na.validate! if validate
+    na
+  end
+end
+
+#
+# Method to create a numeric array from a string
+#
+class String
+  # Create a numeric array from a string
+  # @param validate [Boolean] <i>(default: +true+)</i>
+  #   if +true+, validate the range of the numeric values, according
+  #   to the array subtype
+  # @raise [RGFA::NumericArray::ValueError] if validate is set and
+  #   any value is not compatible with the subtype
+  # @raise [RGFA::NumericArray::TypeError] if the subtype code is invalid
+  # @return [RGFA::NumericArray] the numeric array
+  def to_numeric_array(validate: true)
+    elems = split(",")
+    subtype = elems.shift
+    integer = (subtype != "f")
+    if integer
+      range = RGFA::NumericArray::SUBTYPE_RANGE[subtype]
+    elsif !RGFA::NumericArray::SUBTYPE.include?(subtype)
+      raise RGFA::NumericArray::TypeError, "Subtype #{subtype} unknown"
+    end
+    elems.map do |e|
+      begin
+        if integer
+          e = Integer(e)
+          if validate and not range.include?(e)
+            raise "NumericArray: "+
+                  "value is outside of subtype #{subtype} range\n"+
+                  "Value: #{e}\n"+
+                  "Range: #{range.inspect}\n"+
+                  "Content: #{inspect}"
+          end
+          e
+        else
+          Float(e)
+        end
+      rescue => msg
+        raise RGFA::NumericArray::ValueError, msg
+      end
+    end
+  end
+end

data/lib/rgfa/paths.rb

@@ -0,0 +1,98 @@
+require_relative "error"
+
+#
+# Methods for the RGFA class, which allow to handle paths in the graph.
+#
+module RGFA::Paths
+
+  def add_path(gfa_line)
+    gfa_line = gfa_line.to_rgfa_line(validate: @validate)
+    if @segments.has_key?(gfa_line.path_name)
+      raise RGFA::DuplicatedLabelError,
+        "Error when adding line: #{gfa_line}\n"+
+        "a segment already exists with the name: #{gfa_line.path_name}\n"+
+        "Segment: #{@segments[gfa_line.path_name]}"
+    elsif @paths.has_key?(gfa_line.path_name)
+      raise RGFA::DuplicatedLabelError,
+        "Error when adding line: #{gfa_line}\n"+
+        "a path already exists with the name: #{gfa_line.path_name}\n"+
+        "Path: #{@paths[gfa_line.path_name]}"
+    else
+      @paths[gfa_line.path_name] = gfa_line
+      gfa_line.required_links.each do |from,to,cigar|
+        l = nil
+        if segment(from.segment) and segment(to.segment)
+          l = link_from_to(from, to, cigar)
+        end
+        if l.nil?
+          v = RGFA::Line::Link.new({:from => from.segment,
+                                    :from_orient => from.orient,
+                                    :to => to.segment,
+                                    :to_orient => to.orient,
+                                    :overlap => cigar},
+                                   virtual: true)
+          if @segments_first_order
+            raise RGFA::LineMissingError, "Path: #{gfa_line}\n"+
+              "requires a non-existing link:\n"+
+              "#{v}"
+          end
+          add_link(v)
+          l = v
+        end
+        direct = l.compatible_direct?(from, to, cigar)
+        gfa_line.links << [l, direct]
+        l.paths << [gfa_line, direct]
+      end
+      gfa_line.segment_names.each do |sn_with_o|
+        sn_with_o[0] = segment(sn_with_o[0])
+        sn_with_o[0].paths[sn_with_o[1]] << gfa_line
+      end
+    end
+  end
+  protected :add_path
+
+  # Delete a path from the RGFA graph
+  # @return [RGFA] self
+  # @param pt [String, RGFA::Line::Path] path name or instance
+  def delete_path(pt)
+    pt = path!(pt)
+    pt.segment_names.each {|sn, o| segment!(sn).paths[o].delete(pt)}
+    pt.links.each {|l, dir| l.paths.delete([pt, dir])}
+    @paths.delete(pt.path_name)
+    return self
+  end
+
+  # All path lines of the graph
+  # @return [Array<RGFA::Line::Path>]
+  def paths
+    @paths.values
+  end
+
+  # @!macro [new] path
+  #   Searches the path with name equal to +pt+.
+  #   @param pt [String, RGFA::Line::Path] a path or path name
+  #   @return [RGFA::Line::Path] if a path is found
+  # @return [nil] if no such path exists in the RGFA instance
+  #
+  def path(pt)
+    return pt if pt.kind_of?(RGFA::Line)
+    @paths[pt.to_sym]
+  end
+
+  # @!macro path
+  # @raise [RGFA::LineMissingError] if no such path exists in the RGFA instance
+  def path!(pt)
+    pt = path(pt)
+    raise RGFA::LineMissingError, "No path has name #{pt}" if pt.nil?
+    pt
+  end
+
+  # @return [Array<RGFA::Line::Path>] paths whose +segment_names+ include the
+  #   specified segment.
+  # @!macro [new] segment_or_name
+  #   @param s [RGFA::Line::Segment, Symbol] a segment instance or name
+  def paths_with(s)
+    segment!(s).all_paths
+  end
+
+end