Class | Bio::RestrictionEnzyme::DoubleStranded::AlignedStrands
In: | lib/bio/util/restriction_enzyme/double_stranded/aligned_strands.rb
Parent: | Object

Align two SingleStrand objects and return a Result object with `primary` and `complement` accessors.

### Methods

align align_with_cuts new validate_input

### Constants

Result | = | Struct.new(:primary, :complement) |  | The object returned for alignments

### Public Class methods

align(a, b)

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

[Source]

        # File lib/bio/util/restriction_enzyme/double_stranded/aligned_strands.rb, line 51
    51:   def self.align(a, b)
    52:     a = a.to_s
    53:     b = b.to_s
    54:     validate_input( strip_padding(a), strip_padding(b) )
    55:     left = [left_padding(a), left_padding(b)].sort.last
    56:     right = [right_padding(a), right_padding(b)].sort.last
    57:
    58:     p = left + strip_padding(a) + right
    59:     c = left + strip_padding(b) + right
    60:     Result.new(p,c)
    61:   end

align_with_cuts(a,b,a_cuts,b_cuts)

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

[Source]

         # File lib/bio/util/restriction_enzyme/double_stranded/aligned_strands.rb, line 87
     87:   def self.align_with_cuts(a,b,a_cuts,b_cuts)
     88:     a = a.to_s
     89:     b = b.to_s
     90:     validate_input( strip_padding(a), strip_padding(b) )
     91:
     92:     a_left, a_right = left_padding(a), right_padding(a)
     93:     b_left, b_right = left_padding(b), right_padding(b)
     94:
     95:     left_diff = a_left.length - b_left.length
     96:     right_diff = a_right.length - b_right.length
     97:
     98:     (right_diff > 0) ? (b_right += 'n' * right_diff) : (a_right += 'n' * right_diff.abs)
     99:
    100:     a_adjust = b_adjust = 0
    101:
    102:     if left_diff > 0
    103:       b_left += 'n' * left_diff
    104:       b_adjust = left_diff
    105:     else
    106:       a_left += 'n' * left_diff.abs
    107:       a_adjust = left_diff.abs
    108:     end
    109:
    110:     a = a_left + strip_padding(a) + a_right
    111:     b = b_left + strip_padding(b) + b_right
    112:
    113:     a_cuts.sort.reverse.each { |c| a.insert(c+1+a_adjust, cut_symbol) }
    114:     b_cuts.sort.reverse.each { |c| b.insert(c+1+b_adjust, cut_symbol) }
    115:
    116:     Result.new( add_spacing(a), add_spacing(b) )
    117:   end

new()

Creates a new object.

Returns: | Bio::RestrictionEnzyme::DoubleStranded::AlignedStrands object

[Source]

        # File lib/bio/util/restriction_enzyme/double_stranded/aligned_strands.rb, line 26
    26:   def initialize; super; end

### Protected Class methods

validate_input(a,b)

[Source]

         # File lib/bio/util/restriction_enzyme/double_stranded/aligned_strands.rb, line 123
    123:   def self.validate_input(a,b)
    124:     unless a.size == b.size
    125:       err = "Result sequences are not the same size.  Does not align sequences with differing lengths after strip_padding.\n"
    126:       err += "#{a.size}, #{a.inspect}\n"
    127:       err += "#{b.size}, #{b.inspect}"
    128:       raise ArgumentError, err
    129:     end
    130:   end

[Validate]