bio 1.0.0 → 1.1.0

data/lib/bio/util/restriction_enzyme/range/cut_range.rb

@@ -0,0 +1,24 @@
+#
+# bio/util/restriction_enzyme/range/cut_range.rb - Abstract base class for HorizontalCutRange and VerticalCutRange
+#
+# Author::    Trevor Wennblom  <mailto:trevor@corevx.com>
+# Copyright:: Copyright (c) 2005-2007 Midwinter Laboratories, LLC (http://midwinterlabs.com)
+# License::   The Ruby License
+#
+#  $Id: cut_range.rb,v 1.4 2007/07/16 19:28:48 k Exp $
+#
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class Range
+
+# Abstract base class for HorizontalCutRange and VerticalCutRange
+#
+class CutRange
+end # CutRange
+
+end # Range
+end # RestrictionEnzyme
+end # Bio

data/lib/bio/util/restriction_enzyme/range/cut_ranges.rb

@@ -0,0 +1,47 @@
+#
+# bio/util/restriction_enzyme/range/cut_ranges.rb - Container for many CutRange objects or CutRange child 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_ranges.rb,v 1.5 2007/07/16 19:28:48 k Exp $
+#
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class Range
+  
+# Container for many CutRange objects or CutRange child objects.  Inherits from array.
+#
+class CutRanges < Array
+  def min; self.collect{|a| a.min}.flatten.sort.first; end
+  def max; self.collect{|a| a.max}.flatten.sort.last; end
+  def include?(i); self.collect{|a| a.include?(i)}.include?(true); end
+  
+  def min_vertical
+    vertical_min_max_helper( :min )
+  end
+  
+  def max_vertical
+    vertical_min_max_helper( :max )
+  end
+  
+  protected
+  
+  def vertical_min_max_helper( sym_which )
+    tmp = []
+    self.each do |a|
+      next unless a.class == Bio::RestrictionEnzyme::Range::VerticalCutRange
+      tmp << a.send( sym_which )
+    end
+    z = (sym_which == :max) ? :last : :first
+    tmp.flatten.sort.send(z)
+  end
+    
+end # CutRanges
+end # Range
+end # RestrictionEnzyme
+end # Bio

data/lib/bio/util/restriction_enzyme/range/horizontal_cut_range.rb

@@ -0,0 +1,67 @@
+#
+# bio/util/restriction_enzyme/range/horizontal_cut_range.rb - 
+#
+# Author::    Trevor Wennblom  <mailto:trevor@corevx.com>
+# Copyright:: Copyright (c) 2005-2007 Midwinter Laboratories, LLC (http://midwinterlabs.com)
+# License::   The Ruby License
+#
+#  $Id: horizontal_cut_range.rb,v 1.5 2007/07/16 19:28:48 k Exp $
+#
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class Range
+
+class HorizontalCutRange < CutRange
+  attr_reader :p_cut_left, :p_cut_right
+  attr_reader :c_cut_left, :c_cut_right
+  attr_reader :min, :max
+  attr_reader :hcuts
+
+  def initialize( left, right=left )
+    raise "left > right" if left > right
+
+    # The 'range' here is actually off by one on the left
+    # side in relation to a normal CutRange, so using the normal
+    # variables from CutRange would result in bad behavior.
+    #
+    # See below - the first horizontal cut is the primary cut plus one.
+    #
+    #    1 2 3 4 5 6 7
+    #    G A|T T A C A
+    #       +-----+
+    #    C T A A T|G T
+    #    1 2 3 4 5 6 7
+    # 
+    # Primary cut = 2
+    # Complement cut = 5
+    # Horizontal cuts = 3, 4, 5
+
+    @p_cut_left = nil
+    @p_cut_right = nil
+    @c_cut_left = nil
+    @c_cut_right = nil
+    @min = left  # NOTE this used to be 'nil', make sure all tests work
+    @max = right # NOTE this used to be 'nil', make sure all tests work
+    @range = (@min..@max) unless @min == nil or @max == nil # NOTE this used to be 'nil', make sure all tests work
+    
+
+    @hcuts = (left..right)
+  end
+
+  # Check if a location falls within the minimum or maximum values of this
+  # range.
+  #
+  # ---
+  # *Arguments*
+  # * +i+: Location to check if it is included in the range
+  # *Returns*:: +true+ _or_ +false+
+  def include?(i)
+    @range.include?(i)
+  end
+end # HorizontalCutRange
+end # Range
+end # RestrictionEnzyme
+end # Bio

data/lib/bio/util/restriction_enzyme/range/sequence_range.rb

@@ -0,0 +1,257 @@
+#
+# bio/util/restriction_enzyme/range/sequence_range.rb - A defined range over a nucleotide sequence
+#
+# Author::    Trevor Wennblom  <mailto:trevor@corevx.com>
+# Copyright:: Copyright (c) 2005-2007 Midwinter Laboratories, LLC (http://midwinterlabs.com)
+# License::   The Ruby License
+#
+#  $Id: sequence_range.rb,v 1.9 2007/07/16 19:28:48 k Exp $
+#
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class Range
+
+  autoload :CutRange,                'bio/util/restriction_enzyme/range/cut_range'
+  autoload :CutRanges,               'bio/util/restriction_enzyme/range/cut_ranges'
+  autoload :HorizontalCutRange,      'bio/util/restriction_enzyme/range/horizontal_cut_range'
+  autoload :VerticalCutRange,        'bio/util/restriction_enzyme/range/vertical_cut_range'
+
+# A defined range over a nucleotide sequence.
+#
+# This class accomadates having cuts defined on a sequence and returning the
+# fragments made by those cuts.
+class SequenceRange
+
+  autoload :Fragment,                'bio/util/restriction_enzyme/range/sequence_range/fragment'
+  autoload :Fragments,               'bio/util/restriction_enzyme/range/sequence_range/fragments'
+  autoload :CalculatedCuts,          'bio/util/restriction_enzyme/range/sequence_range/calculated_cuts'
+
+  # Left-most index of primary strand
+  attr_reader :p_left
+  
+  # Right-most index of primary strand
+  attr_reader :p_right
+  
+  # Left-most index of complementary strand
+  attr_reader :c_left
+  
+  # Right-most index of complementary strand
+  attr_reader :c_right
+
+  # Left-most index of DNA sequence
+  attr_reader :left
+  
+  # Right-most index of DNA sequence
+  attr_reader :right
+  
+  # Size of DNA sequence
+  attr_reader :size
+  
+  # CutRanges in this SequenceRange
+  attr_reader :cut_ranges
+
+  def initialize( p_left = nil, p_right = nil, c_left = nil, c_right = nil )
+    raise ArgumentError if p_left == nil and c_left == nil
+    raise ArgumentError if p_right == nil and c_right == nil
+    (raise ArgumentError unless p_left <= p_right) unless p_left == nil or p_right == nil
+    (raise ArgumentError unless c_left <= c_right) unless c_left == nil or c_right == nil
+
+    @p_left, @p_right, @c_left, @c_right = p_left, p_right, c_left, c_right
+    @left = [p_left, c_left].compact.sort.first
+    @right = [p_right, c_right].compact.sort.last
+    @size = (@right - @left) + 1 unless @left == nil or @right == nil
+    @cut_ranges = CutRanges.new
+    @__fragments_current = false
+  end
+
+
+  # If the first object is HorizontalCutRange or VerticalCutRange, that is
+  # added to the SequenceRange.  Otherwise this method
+  # builds a VerticalCutRange object and adds it to the SequenceRange.
+  # 
+  # Note:
+  # Cut occurs immediately after the index supplied.
+  # For example, a cut at '0' would mean a cut occurs between bases 0 and 1.
+  #
+  # ---
+  # *Arguments*
+  # * +p_cut_left+: (_optional_) Left-most cut on the primary strand *or* a CutRange object.  +nil+ to skip
+  # * +p_cut_right+: (_optional_) Right-most cut on the primary strand.  +nil+ to skip
+  # * +c_cut_left+: (_optional_) Left-most cut on the complementary strand.  +nil+ to skip
+  # * +c_cut_right+: (_optional_) Right-most cut on the complementary strand.  +nil+ to skip
+  # *Returns*:: nothing
+  def add_cut_range( p_cut_left=nil, p_cut_right=nil, c_cut_left=nil, c_cut_right=nil )
+    @__fragments_current = false
+    if p_cut_left.kind_of? CutRange # shortcut
+      @cut_ranges << p_cut_left
+    else
+      [p_cut_left, p_cut_right, c_cut_left, c_cut_right].each { |n| (raise IndexError unless n >= @left and n <= @right) unless n == nil }
+      @cut_ranges << VerticalCutRange.new( p_cut_left, p_cut_right, c_cut_left, c_cut_right )
+    end
+  end
+
+  # Add a series of CutRange objects (HorizontalCutRange or VerticalCutRange).
+  #
+  # ---
+  # *Arguments*
+  # * +cut_ranges+: A series of CutRange objects
+  # *Returns*:: nothing
+  def add_cut_ranges(*cut_ranges)
+    cut_ranges.flatten.each do |cut_range|
+      raise TypeError, "Not of type CutRange" unless cut_range.kind_of? CutRange
+      self.add_cut_range( cut_range )
+    end
+  end
+
+  # Builds a HorizontalCutRange object and adds it to the SequenceRange.
+  #
+  # ---
+  # *Arguments*
+  # * +left+: Left-most cut
+  # * +right+: (_optional_) Right side - by default this equals the left side, default is recommended.
+  # *Returns*:: nothing
+  def add_horizontal_cut_range( left, right=left )
+    @__fragments_current = false
+    @cut_ranges << HorizontalCutRange.new( left, right )
+  end
+  
+  # A Bio::RestrictionEnzyme::Range::SequenceRange::Bin holds an +Array+ of 
+  # indexes for the primary and complement strands (+p+ and +c+ accessors).
+  # 
+  # Example hash with Bin values:
+  #   {0=>#<struct Bio::RestrictionEnzyme::Range::SequenceRange::Bin c=[0, 1], p=[0]>,
+  #    2=>#<struct Bio::RestrictionEnzyme::Range::SequenceRange::Bin c=[], p=[1, 2]>,
+  #    3=>#<struct Bio::RestrictionEnzyme::Range::SequenceRange::Bin c=[2, 3], p=[]>,
+  #    4=>#<struct Bio::RestrictionEnzyme::Range::SequenceRange::Bin c=[4, 5], p=[3, 4, 5]>}
+  #
+  # Note that the bin cannot be easily stored as a range since there may be
+  # nucleotides excised in the middle of a range.
+  #
+  # TODO: Perhaps store the bins as one-or-many ranges since missing
+  # nucleotides due to enzyme cutting is a special case.
+  Bin = Struct.new(:c, :p)
+
+  # Calculates the fragments over this sequence range as defined after using
+  # the methods add_cut_range, add_cut_ranges, and/or add_horizontal_cut_range
+  #
+  # Example return value:
+  #   [#<Bio::RestrictionEnzyme::Range::SequenceRange::Fragment:0x277bdc
+  #     @complement_bin=[0, 1],
+  #     @primary_bin=[0]>,
+  #    #<Bio::RestrictionEnzyme::Range::SequenceRange::Fragment:0x277bc8
+  #     @complement_bin=[],
+  #     @primary_bin=[1, 2]>,
+  #    #<Bio::RestrictionEnzyme::Range::SequenceRange::Fragment:0x277bb4
+  #     @complement_bin=[2, 3],
+  #     @primary_bin=[]>,
+  #    #<Bio::RestrictionEnzyme::Range::SequenceRange::Fragment:0x277ba0
+  #     @complement_bin=[4, 5],
+  #     @primary_bin=[3, 4, 5]>]
+  #
+  # ---
+  # *Arguments*
+  # * _none_
+  # *Returns*:: Bio::RestrictionEnzyme::Range::SequenceRange::Fragments
+  def fragments
+    return @__fragments if @__fragments_current == true
+    @__fragments_current = true
+    
+    num_txt = '0123456789'
+    num_txt_repeat = (num_txt * ( @size / num_txt.size.to_f ).ceil)[0..@size-1]
+    fragments = Fragments.new(num_txt_repeat, num_txt_repeat)
+
+    cc = Bio::RestrictionEnzyme::Range::SequenceRange::CalculatedCuts.new(@size)
+    cc.add_cuts_from_cut_ranges(@cut_ranges)
+    cc.remove_incomplete_cuts
+    
+    create_bins(cc).sort.each { |k, bin| fragments << Fragment.new( bin.p, bin.c ) }
+    @__fragments = fragments
+    return fragments
+  end
+  
+  #########
+  protected
+  #########
+  
+  # Example:
+  #   cc = Bio::RestrictionEnzyme::Range::SequenceRange::CalculatedCuts.new(@size)
+  #   cc.add_cuts_from_cut_ranges(@cut_ranges)
+  #   cc.remove_incomplete_cuts
+  #   bins = create_bins(cc)
+  # 
+  # Example return value:
+  #   {0=>#<struct Bio::RestrictionEnzyme::Range::SequenceRange::Bin c=[0, 1], p=[0]>,
+  #    2=>#<struct Bio::RestrictionEnzyme::Range::SequenceRange::Bin c=[], p=[1, 2]>,
+  #    3=>#<struct Bio::RestrictionEnzyme::Range::SequenceRange::Bin c=[2, 3], p=[]>,
+  #    4=>#<struct Bio::RestrictionEnzyme::Range::SequenceRange::Bin c=[4, 5], p=[3, 4, 5]>}
+  #
+  # ---
+  # *Arguments*
+  # * +cc+: Bio::RestrictionEnzyme::Range::SequenceRange::CalculatedCuts
+  # *Returns*:: +Hash+ Keys are unique, values are Bio::RestrictionEnzyme::Range::SequenceRange::Bin objects filled with indexes of the sequence locations they represent.
+  def create_bins(cc)
+    p_cut = cc.vc_primary
+    c_cut = cc.vc_complement
+    h_cut = cc.hc_between_strands
+    
+    if @circular
+      # NOTE
+      # if it's circular we should start at the beginning of a cut for orientation
+      # scan for it, hack off the first set of hcuts and move them to the back
+  
+      unique_id = 0
+    else
+      p_cut.unshift(-1) unless p_cut.include?(-1)
+      c_cut.unshift(-1) unless c_cut.include?(-1)
+      unique_id = -1
+    end
+
+    p_bin_id = c_bin_id = unique_id
+    bins = {}
+    setup_new_bin(bins, unique_id)
+
+    -1.upto(@size-1) do |idx| # NOTE - circular, for the future - should '-1' be replace with 'unique_id'?
+      
+      # if bin_ids are out of sync but the strands are attached
+      if (p_bin_id != c_bin_id) and !h_cut.include?(idx)
+        min_id, max_id = [p_bin_id, c_bin_id].sort
+        bins.delete(max_id)
+        p_bin_id = c_bin_id = min_id
+      end
+
+      bins[ p_bin_id ].p << idx
+      bins[ c_bin_id ].c << idx
+      
+      if p_cut.include? idx
+        p_bin_id = (unique_id += 1)
+        setup_new_bin(bins, p_bin_id)
+      end
+
+      if c_cut.include? idx             # repetition
+        c_bin_id = (unique_id += 1)     # repetition
+        setup_new_bin(bins, c_bin_id)   # repetition
+      end                               # repetition
+       
+    end
+  
+    # Bin "-1" is an easy way to indicate the start of a strand just in case
+    # there is a horizontal cut at position 0
+    bins.delete(-1) unless @circular
+    bins
+  end
+  
+  # Modifies bins in place by creating a new element with key bin_id and
+  # initializing the bin.
+  def setup_new_bin(bins, bin_id)
+    bins[ bin_id ] = Bin.new
+    bins[ bin_id ].p = []
+    bins[ bin_id ].c = []
+  end
+  
+end # SequenceRange
+end # Range
+end # RestrictionEnzyme
+end # Bio

data/lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb

@@ -0,0 +1,242 @@
+#
+# bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb - 
+#
+# Author::    Trevor Wennblom  <mailto:trevor@corevx.com>
+# Copyright:: Copyright (c) 2005-2007 Midwinter Laboratories, LLC (http://midwinterlabs.com)
+# License::   The Ruby License
+#
+#  $Id: calculated_cuts.rb,v 1.7 2007/07/16 19:28:48 k Exp $
+#
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class Range
+class SequenceRange
+
+# cc = CalculatedCuts.new(@size)
+# cc.add_cuts_from_cut_ranges(@cut_ranges)
+# cc.remove_incomplete_cuts
+#
+#    1 2 3 4 5 6 7
+#    G A|T T A C A
+#       +-----+
+#    C T A A T|G T
+#    1 2 3 4 5 6 7
+# 
+# Primary cut = 2
+# Complement cut = 5
+# Horizontal cuts = 3, 4, 5
+#
+class CalculatedCuts
+  include CutSymbol
+  include StringFormatting
+
+  # +Array+ of vertical cuts on the primary strand in 0-based index notation
+  attr_reader :vc_primary
+  
+  # +Array+ of vertical cuts on the complementary strand in 0-based index notation
+  attr_reader :vc_complement
+
+  # +Array+ of horizontal cuts between strands in 0-based index notation
+  attr_reader :hc_between_strands
+
+  # Set to +true+ if the fragment CalculatedCuts is working on is circular
+  attr_accessor :circular
+  
+  # An +Array+ with the primary strand with vertical cuts, the horizontal cuts, and the complementary strand with vertical cuts.
+  attr_reader :strands_for_display
+  
+  # If +false+ the strands_for_display method needs to be called to update the contents
+  # of @strands_for_display.  Becomes out of date whenever add_cuts_from_cut_ranges is called.
+  attr_reader :strands_for_display_current
+
+  # Size of the sequence being digested.
+  attr_reader :size
+
+  def initialize(size=nil, circular=false)
+    @size = size
+    @circular = circular
+    @vc_primary = []
+    @vc_complement = []
+    @hc_between_strands = []
+  end
+
+  # Accepts an +Array+ of CutRange type objects and applies them to 
+  # @vc_complement, @vc_primary, and @hc_between_strands.
+  #
+  # ---
+  # *Arguments*
+  # * +cut_ranges+: An +Array+ of HorizontalCutRange or VerticalCutRange objects
+  # *Returns*:: nothing
+  def add_cuts_from_cut_ranges(cut_ranges)
+    @strands_for_display_current = false
+
+    cut_ranges.each do |cut_range|
+      @vc_primary += [cut_range.p_cut_left, cut_range.p_cut_right]
+      @vc_complement += [cut_range.c_cut_left, cut_range.c_cut_right]
+
+      # Add horizontal cut ranges.  This may happen from cuts made inbetween a
+      # VerticalCutRange or may be specifically defined by a HorizontalCutRange.
+      if cut_range.class == VerticalCutRange
+        ( cut_range.min + 1 ).upto( cut_range.max ){|i| @hc_between_strands << i} if cut_range.min < cut_range.max
+      elsif cut_range.class == HorizontalCutRange
+        ( cut_range.hcuts.first ).upto( cut_range.hcuts.last ){|i| @hc_between_strands << i}
+      end
+    end
+    clean_all
+    #return
+  end
+
+  # There may be incomplete cuts made, this method removes the cuts that don't
+  # create sub-sequences for easier processing.
+  #
+  # For example, stray horizontal cuts that do not end with a left 
+  # and right separation:
+  #
+  #   G A T T A C A
+  #      +--  ---
+  #   C T|A A T G T
+  #
+  # Or stray vertical cuts:
+  #
+  #   G A T T A C A
+  #      +--   +
+  #   C T|A A T|G T
+  #
+  # However note that for non-circular sequences this would be a successful 
+  # cut which would result in a floating 'GT' sub-sequence:
+  #
+  #   G A T T A C A
+  #            +---
+  #   C T A A T|G T
+  #
+  # Blunt cuts are also complete cuts.
+  # ---
+  # *Arguments*
+  # * +size+: (_optional_) Size of the sequence being digested.  Defined here or during initalization of CalculatedCuts.
+  # *Returns*:: nothing
+  def remove_incomplete_cuts(size=nil)
+    @strands_for_display_current = false
+    @size = size if size
+    raise IndexError, "Size of the strand must be provided here or during initalization." if !@size.kind_of?(Fixnum) and not @circular
+
+    vcuts = (@vc_primary + @vc_complement).uniq.sort
+    hcuts = @hc_between_strands
+    last_index = @size - 1
+    good_hcuts = []
+    potential_hcuts = []
+
+    if @circular
+    # NOTE
+    # if it's circular we should start at the beginning of a cut for orientation,
+    # scan for it, hack off the first set of hcuts and move them to the back
+    else
+      vcuts.unshift(-1) unless vcuts.include?(-1)
+      vcuts.push(last_index) unless vcuts.include?(last_index)
+    end
+
+    hcuts.each do |hcut|
+      raise IndexError if hcut < -1 or hcut > last_index
+      # skipped a nucleotide
+      potential_hcuts.clear if !potential_hcuts.empty? and (hcut - potential_hcuts.last).abs > 1
+
+      if potential_hcuts.empty?
+        if vcuts.include?( hcut ) and vcuts.include?( hcut - 1 )
+          good_hcuts += [hcut]
+        elsif vcuts.include?( hcut - 1 )
+          potential_hcuts << hcut
+        end
+      else
+        if vcuts.include?( hcut )
+          good_hcuts += potential_hcuts + [hcut]
+          potential_hcuts.clear
+        else
+          potential_hcuts << hcut
+        end
+      end
+    end
+
+    check_vc = lambda do |vertical_cuts, opposing_vcuts|
+      # opposing_vcuts is here only to check for blunt cuts, so there shouldn't
+      # be any out-of-order problems with this
+      good_vc = []
+      vertical_cuts.each { |vc| good_vc << vc if good_hcuts.include?( vc ) or good_hcuts.include?( vc + 1 ) or opposing_vcuts.include?( vc ) }
+      good_vc
+    end
+
+    @vc_primary = check_vc.call(@vc_primary, @vc_complement)
+    @vc_complement = check_vc.call(@vc_complement, @vc_primary)
+    @hc_between_strands = good_hcuts
+
+    clean_all
+  end
+
+  # Sets @strands_for_display_current to +true+ and populates @strands_for_display.
+  #
+  # ---
+  # *Arguments*
+  # * +str1+: (_optional_) For displaying a primary strand.  If +nil+ a numbered sequence will be used in place.
+  # * +str2+: (_optional_) For displaying a complementary strand.  If +nil+ a numbered sequence will be used in place.
+  # * +vcp+: (_optional_) An array of vertical cut locations on the primary strand.  If +nil+ the contents of @vc_primary is used.
+  # * +vcc+: (_optional_) An array of vertical cut locations on the complementary strand.  If +nil+ the contents of @vc_complementary is used.
+  # * +hc+: (_optional_) An array of horizontal cut locations between strands.  If +nil+ the contents of @hc_between_strands is used.
+  # *Returns*:: +Array+ An array with the primary strand with vertical cuts, the horizontal cuts, and the complementary strand with vertical cuts.
+  #
+  def strands_for_display(str1 = nil, str2 = nil, vcp=nil, vcc=nil, hc=nil)
+    return @strands_for_display if @strands_for_display_current
+    vcs = '|'   # Vertical cut symbol
+    hcs = '-'   # Horizontal cut symbol
+    vhcs = '+'  # Intersection of vertical and horizontal cut symbol
+      
+    num_txt_repeat = lambda { num_txt = '0123456789'; (num_txt * ( @size / num_txt.size.to_f ).ceil)[0..@size-1] }
+    (str1 == nil) ? a = num_txt_repeat.call : a = str1.dup
+    (str2 == nil) ? b = num_txt_repeat.call : b = str2.dup
+
+    vcp = @vc_primary if vcp==nil
+    vcc = @vc_complement if vcc==nil
+    hc = @hc_between_strands if hc==nil
+
+    vcuts = (vcp + vcc).uniq.sort
+
+    vcp.reverse.each { |c| a.insert(c+1, vcs) }
+    vcc.reverse.each { |c| b.insert(c+1, vcs) }
+
+    between = ' ' * @size
+    hc.each {|hcut| between[hcut,1] = hcs }
+
+    s_a = add_spacing(a, vcs)
+    s_b = add_spacing(b, vcs)
+    s_bet = add_spacing(between)
+
+    # NOTE watch this for circular
+    i = 0
+    0.upto( s_a.size-1 ) do
+      if (s_a[i,1] == vcs) or (s_b[i,1] == vcs)
+        s_bet[i] = vhcs 
+      elsif i != 0 and s_bet[i-1,1] == hcs and s_bet[i+1,1] == hcs
+        s_bet[i] = hcs 
+      end
+      i+=1
+    end
+
+    @strands_for_display_current = true
+    @strands_for_display = [s_a, s_bet, s_b]
+  end
+
+  #########
+  protected
+  #########
+
+  # remove nil values, remove duplicate values, and 
+  # sort @vc_primary, @vc_complement, and @hc_between_strands
+  def clean_all
+    [@vc_primary, @vc_complement, @hc_between_strands].collect { |a| a.delete(nil); a.uniq!; a.sort! }
+  end
+
+end # CalculatedCuts
+end # SequenceRange
+end # Range
+end # RestrictionEnzyme
+end # Bio