wwood-bioruby 1.2.11

data/lib/bio/util/restriction_enzyme/double_stranded/aligned_strands.rb

@@ -0,0 +1,130 @@
+#
+# bio/util/restriction_enzyme/double_stranded/aligned_strands.rb - Align two SingleStrand objects
+#
+# Author::    Trevor Wennblom  <mailto:trevor@corevx.com>
+# Copyright:: Copyright (c) 2005-2007 Midwinter Laboratories, LLC (http://midwinterlabs.com)
+# License::   The Ruby License
+#
+#  $Id: aligned_strands.rb,v 1.6 2007/07/16 19:28:48 k Exp $
+#
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class DoubleStranded
+
+# Align two SingleStrand objects and return a Result
+# object with +primary+ and +complement+ accessors.
+#
+class AlignedStrands
+  extend CutSymbol
+  extend StringFormatting
+
+  # The object returned for alignments
+  Result = Struct.new(:primary, :complement)
+
+  # Pad and align two String objects without cut symbols.
+  #
+  # This will look for the sub-sequence without left and right 'n' padding
+  # and re-apply 'n' padding to both strings on both sides equal to the 
+  # maximum previous padding on that side.
+  #
+  # The sub-sequences stripped of left and right 'n' padding must be of equal
+  # length.
+  #
+  # Example:
+  #   AlignedStrands.align('nngattacannnnn', 'nnnnnctaatgtnn') # => 
+  #    <struct Bio::RestrictionEnzyme::DoubleStranded::AlignedStrands::Result
+  #      primary="nnnnngattacannnnn",
+  #      complement="nnnnnctaatgtnnnnn">
+  #
+  # ---
+  # *Arguments*
+  # * +a+: Primary strand
+  # * +b+: Complementary strand
+  # *Returns*:: +Result+ object with equal padding on both strings
+  def self.align(a, b)
+    a = a.to_s
+    b = b.to_s
+    validate_input( strip_padding(a), strip_padding(b) )
+    left = [left_padding(a), left_padding(b)].sort.last
+    right = [right_padding(a), right_padding(b)].sort.last
+
+    p = left + strip_padding(a) + right
+    c = left + strip_padding(b) + right
+    Result.new(p,c)
+  end
+
+  # Pad and align two String objects with cut symbols.
+  #
+  # Example:
+  #   AlignedStrands.with_cuts('nngattacannnnn', 'nnnnnctaatgtnn', [0, 10, 12], [0, 2, 12]) # => 
+  #     <struct Bio::RestrictionEnzyme::DoubleStranded::AlignedStrands::Result
+  #       primary="n n n n^n g a t t a c a n n^n n^n",
+  #       complement="n^n n^n n c t a a t g t n^n n n n">
+  #
+  # Notes:
+  # * To make room for the cut symbols each nucleotide is spaced out.
+  # * This is meant to be able to handle multiple cuts and completely
+  #   unrelated cutsites on the two strands, therefore no biological
+  #   algorithm assumptions (shortcuts) are made.
+  #
+  # The sequences stripped of left and right 'n' padding must be of equal
+  # length.
+  #
+  # ---
+  # *Arguments*
+  # * +a+: Primary sequence
+  # * +b+: Complementary sequence
+  # * +a_cuts+: Primary strand cut locations in 0-based index notation
+  # * +b_cuts+: Complementary strand cut locations in 0-based index notation
+  # *Returns*:: +Result+ object with equal padding on both strings and spacing between bases
+  def self.align_with_cuts(a,b,a_cuts,b_cuts)
+    a = a.to_s
+    b = b.to_s
+    validate_input( strip_padding(a), strip_padding(b) )
+
+    a_left, a_right = left_padding(a), right_padding(a)
+    b_left, b_right = left_padding(b), right_padding(b)
+
+    left_diff = a_left.length - b_left.length
+    right_diff = a_right.length - b_right.length
+
+    (right_diff > 0) ? (b_right += 'n' * right_diff) : (a_right += 'n' * right_diff.abs)
+
+    a_adjust = b_adjust = 0
+
+    if left_diff > 0
+      b_left += 'n' * left_diff
+      b_adjust = left_diff
+    else
+      a_left += 'n' * left_diff.abs
+      a_adjust = left_diff.abs
+    end
+
+    a = a_left + strip_padding(a) + a_right
+    b = b_left + strip_padding(b) + b_right
+
+    a_cuts.sort.reverse.each { |c| a.insert(c+1+a_adjust, cut_symbol) }
+    b_cuts.sort.reverse.each { |c| b.insert(c+1+b_adjust, cut_symbol) }
+
+    Result.new( add_spacing(a), add_spacing(b) )
+  end
+
+  #########
+  protected
+  #########
+
+  def self.validate_input(a,b)
+    unless a.size == b.size
+      err = "Result sequences are not the same size.  Does not align sequences with differing lengths after strip_padding.\n"
+      err += "#{a.size}, #{a.inspect}\n"
+      err += "#{b.size}, #{b.inspect}"
+      raise ArgumentError, err
+    end
+  end
+end # AlignedStrands
+end # DoubleStranded
+end # RestrictionEnzyme
+end # Bio

data/lib/bio/util/restriction_enzyme/double_stranded/cut_location_pair.rb

@@ -0,0 +1,103 @@
+#
+# bio/util/restriction_enzyme/double_stranded/cut_location_pair.rb - Stores a cut location pair in 0-based index notation
+#
+# Author::    Trevor Wennblom  <mailto:trevor@corevx.com>
+# Copyright:: Copyright (c) 2005-2007 Midwinter Laboratories, LLC (http://midwinterlabs.com)
+# License::   The Ruby License
+#
+#  $Id: cut_location_pair.rb,v 1.9 2007/07/16 19:28:48 k Exp $
+#
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class DoubleStranded
+  
+# Stores a single cut location pair in 0-based index notation for use with
+# DoubleStranded enzyme sequences.
+#
+class CutLocationPair < Array
+  # Location of the cut on the primary strand.
+  # Corresponds - or 'pairs' - to the complement cut.
+  # A value of +nil+ is an explicit representation of 'no cut'.
+  attr_reader :primary
+  
+  # Location of the cut on the complementary strand.
+  # Corresponds - or 'pairs' - to the primary cut.
+  # A value of +nil+ is an explicit representation of 'no cut'.
+  attr_reader :complement
+
+  # CutLocationPair constructor.
+  #
+  # Stores a single cut location pair in 0-based index notation for use with
+  # DoubleStranded enzyme sequences.
+  # 
+  # Example:
+  #   clp = CutLocationPair.new(3,2)
+  #   clp.primary                    # 3
+  #   clp.complement                 # 2
+  #
+  # ---
+  # *Arguments*
+  # * +pair+: May be two values represented as an Array, a Range, or a
+  #   combination of Integer and nil values.  The first value
+  #   represents a cut on the primary strand, the second represents
+  #   a cut on the complement strand.
+  # *Returns*:: nothing
+  def initialize( *pair )
+    a = b = nil
+
+    if pair[0].kind_of? Array
+      a,b = init_with_array( pair[0] )
+
+    # no idea why this barfs without the second half during test/runner.rb
+    # are there two Range objects running around?
+    elsif pair[0].kind_of? Range or (pair[0].class.to_s == 'Range')
+    #elsif pair[0].kind_of? Range
+      a,b = init_with_array( [pair[0].first, pair[0].last] )
+
+    elsif pair[0].kind_of? Integer or pair[0].kind_of? NilClass
+      a,b = init_with_array( [pair[0], pair[1]] )
+
+    else
+      raise ArgumentError, "#{pair[0].class} is an invalid class type to initalize CutLocationPair."
+    end
+
+    super( [a,b] )
+    @primary = a
+    @complement = b
+    return
+  end
+
+  #########
+  protected
+  #########
+
+  def init_with_array( ary )
+    validate_1(ary)
+    a = ary.shift
+    ary.empty? ? b = nil : b = ary.shift
+    validate_2(a,b)
+    [a,b]
+  end
+
+  def validate_1( ary )
+    unless ary.size == 1 or ary.size == 2
+      raise ArgumentError, "Must be one or two elements."
+    end
+  end
+
+  def validate_2( a, b )
+    if (a != nil and a < 0) or (b != nil and b < 0)
+      raise ArgumentError, "0-based index notation only.  Negative values are illegal."
+    end
+
+    if a == nil and b == nil
+      raise ArgumentError, "Neither strand has a cut.  Ambiguous."
+    end
+  end
+end # CutLocationPair
+end # DoubleStranded
+end # RestrictionEnzyme
+end # Bio

data/lib/bio/util/restriction_enzyme/double_stranded/cut_location_pair_in_enzyme_notation.rb

@@ -0,0 +1,38 @@
+#
+# bio/util/restriction_enzyme/double_stranded/cut_location_pair_in_enzyme_notation.rb - Inherits from DoubleStranded::CutLocationPair
+#
+# Author::    Trevor Wennblom  <mailto:trevor@corevx.com>
+# Copyright:: Copyright (c) 2005-2007 Midwinter Laboratories, LLC (http://midwinterlabs.com)
+# License::   The Ruby License
+#
+#  $Id: cut_location_pair_in_enzyme_notation.rb,v 1.7 2007/07/16 19:28:48 k Exp $
+#
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class DoubleStranded
+
+# Inherits from DoubleStranded::CutLocationPair , stores the cut location pair in
+# enzyme notation instead of 0-based.
+#
+class CutLocationPairInEnzymeNotation < CutLocationPair
+
+  #########
+  protected
+  #########
+
+  def validate_2( a, b )
+    if (a == 0) or (b == 0)
+      raise ArgumentError, "Enzyme index notation only.  0 values are illegal."
+    end
+
+    if a == nil and b == nil
+      raise ArgumentError, "Neither strand has a cut.  Ambiguous."
+    end
+  end
+end # CutLocationPair
+end # DoubleStranded
+end # RestrictionEnzyme
+end # Bio

data/lib/bio/util/restriction_enzyme/double_stranded/cut_locations.rb

@@ -0,0 +1,76 @@
+#
+# bio/util/restriction_enzyme/double_stranded/cut_locations.rb - Contains an Array of CutLocationPair objects
+#
+# Author::    Trevor Wennblom  <mailto:trevor@corevx.com>
+# Copyright:: Copyright (c) 2005-2007 Midwinter Laboratories, LLC (http://midwinterlabs.com)
+# License::   The Ruby License
+#
+#  $Id: cut_locations.rb,v 1.6 2007/07/16 19:28:48 k Exp $
+#
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class DoubleStranded
+
+# Contains an +Array+ of CutLocationPair objects.
+#
+class CutLocations < Array
+
+  # CutLocations constructor.
+  #
+  # Contains an +Array+ of CutLocationPair objects.
+  #
+  # Example:
+  #   clp1 = CutLocationPair.new(3,2)
+  #   clp2 = CutLocationPair.new(7,9)
+  #   pairs = CutLocations.new(clp1, clp2)
+  #
+  # ---
+  # *Arguments*
+  # * +args+: Any number of +CutLocationPair+ objects
+  # *Returns*:: nothing
+  def initialize(*args)
+    validate_args(args)
+    super(args)
+  end
+
+  # Returns an +Array+ of locations of cuts on the primary strand
+  #
+  # ---
+  # *Arguments*
+  # * _none_
+  # *Returns*:: +Array+ of locations of cuts on the primary strand
+  def primary
+    self.collect {|a| a[0]}
+  end
+
+  # Returns an +Array+ of locations of cuts on the complementary strand
+  #
+  # ---
+  # *Arguments*
+  # * _none_
+  # *Returns*:: +Array+ of locations of cuts on the complementary strand
+  def complement
+    self.collect {|a| a[1]}
+  end
+
+  #########
+  protected
+  #########
+
+  def validate_args(args)
+    args.each do |a|
+      unless a.class == Bio::RestrictionEnzyme::DoubleStranded::CutLocationPair
+        err = "Not a CutLocationPair\n"
+        err += "class: #{a.class}\n"
+        err += "inspect: #{a.inspect}"
+        raise ArgumentError, err
+      end
+    end
+  end
+end # CutLocations
+end # DoubleStranded
+end # RestrictionEnzyme
+end # Bio

data/lib/bio/util/restriction_enzyme/double_stranded/cut_locations_in_enzyme_notation.rb

@@ -0,0 +1,107 @@
+#
+# bio/util/restriction_enzyme/double_stranded/cut_locations_in_enzyme_notation.rb - Inherits from DoubleStrand::CutLocations
+#
+# Author::    Trevor Wennblom  <mailto:trevor@corevx.com>
+# Copyright:: Copyright (c) 2005-2007 Midwinter Laboratories, LLC (http://midwinterlabs.com)
+# License::   The Ruby License
+#
+#  $Id: cut_locations_in_enzyme_notation.rb,v 1.7 2007/07/16 19:28:48 k Exp $
+#
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class DoubleStranded
+
+# Inherits from DoubleStranded::CutLocations.  Contains CutLocationPairInEnzymeNotation objects.
+# Adds helper methods to convert from enzyme index notation to 0-based array index notation.
+#
+class CutLocationsInEnzymeNotation < CutLocations
+
+  # Returns +Array+ of locations of cuts on the primary 
+  # strand in 0-based array index notation.
+  #
+  # ---
+  # *Arguments*
+  # * _none_
+  # *Returns*:: +Array+ of locations of cuts on the primary strand in 0-based array index notation.
+  def primary_to_array_index
+    helper_for_to_array_index(self.primary)
+  end
+
+  # Returns +Array+ of locations of cuts on the complementary 
+  # strand in 0-based array index notation.
+  #
+  # ---
+  # *Arguments*
+  # * _none_
+  # *Returns*:: +Array+ of locations of cuts on the complementary strand in 0-based array index notation.
+  def complement_to_array_index
+    helper_for_to_array_index(self.complement)
+  end
+
+  # Returns the contents of the present CutLocationsInEnzymeNotation object as
+  # a CutLocations object with the contents converted from enzyme notation 
+  # to 0-based array index notation.
+  #
+  # ---
+  # *Arguments*
+  # * _none_
+  # *Returns*:: +CutLocations+
+  def to_array_index
+    unless self.primary_to_array_index.size == self.complement_to_array_index.size
+      err = "Primary and complement strand cut locations are not available in equal numbers.\n"
+      err += "primary: #{self.primary_to_array_index.inspect}\n"
+      err += "primary.size: #{self.primary_to_array_index.size}\n"
+      err += "complement: #{self.complement_to_array_index.inspect}\n"
+      err += "complement.size: #{self.complement_to_array_index.size}"
+      raise IndexError, err
+    end
+    a = self.primary_to_array_index.zip(self.complement_to_array_index)
+    CutLocations.new( *a.collect {|cl| CutLocationPair.new(cl)} )
+  end
+
+  #########
+  protected
+  #########
+
+  def helper_for_to_array_index(a)
+    minimum = (self.primary + self.complement).flatten
+    minimum.delete(nil)
+    minimum = minimum.sort.first
+
+    return [] if minimum == nil  # no elements
+
+    if minimum < 0
+      calc = lambda do |n|
+        unless n == nil
+          n -= 1 unless n < 0
+          n += minimum.abs
+        end
+        n
+      end
+    else
+      calc = lambda do |n| 
+        n -= 1 unless n == nil
+        n
+      end
+    end
+
+    a.collect(&calc)
+  end
+
+  def validate_args(args)
+    args.each do |a|
+      unless a.class == Bio::RestrictionEnzyme::DoubleStranded::CutLocationPairInEnzymeNotation
+        err = "Not a CutLocationPairInEnzymeNotation\n"
+        err += "class: #{a.class}\n"
+        err += "inspect: #{a.inspect}"
+        raise TypeError, err
+      end
+    end
+  end
+end # CutLocationsInEnzymeNotation
+end # DoubleStranded
+end # RestrictionEnzyme
+end # Bio