bioroebe 0.10.80

data/lib/bioroebe/string_matching/simple_string_comparer.rb

@@ -0,0 +1,294 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Bioroebe::SimpleStringComparer
+#
+# This class will compare two input-sequences, via simple ASCII commands
+# on the commandline. This will NOT perform an optimal alignment! For
+# this, you will have to use another class, which will implement
+# something like the Smith-Waterman algorithm.
+#
+# Note that the class here is very similar to the Hamming class. The
+# only difference is that the class here does not report as much and
+# will also not keep track of how many differences there are,
+# via a number.
+#
+# Usage example:
+#
+#   ssc = Bioroebe::SimpleStringComparer.new(ARGV)
+#
+# =========================================================================== #
+# require 'bioroebe/string_matching/simple_string_comparer.rb'
+# =========================================================================== #
+require 'bioroebe/base/commandline_application/commandline_application.rb'
+
+module Bioroebe
+
+class SimpleStringComparer < ::Bioroebe::CommandlineApplication # === Bioroebe::SimpleStringComparer
+
+  # ========================================================================= #
+  # The two default strings, stored in the constants STRING1 and STRING2.
+  # ========================================================================= #
+
+  # ========================================================================= #
+  # === STRING1
+  # ========================================================================= #
+  STRING1 = 'gelfand'
+
+  # ========================================================================= #
+  # === STRING2
+  # ========================================================================= #
+  STRING2 = 'gandalf'
+
+  # ========================================================================= #
+  # === VERTICAL_BAR
+  # ========================================================================= #
+  VERTICAL_BAR = '|'
+
+  # ========================================================================= #
+  # === DEFAULT_MATCH_TOKEN
+  #
+  # This token is used to indicate a matching position. By default it
+  # will be the '|' character.
+  # ========================================================================= #
+  DEFAULT_MATCH_TOKEN = VERTICAL_BAR
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      i           = nil,
+      run_already = true,
+      &block
+    )
+    reset
+    case i
+    when nil # Pass through in this case.
+    when :dont_run_yet
+      i = nil
+      run_already = false
+    else
+      guess_from_this_input(i)
+    end
+    # ======================================================================= #
+    # === Handle blocks given to this method
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      case yielded
+      when :disable_colours
+        disable_colours
+      # ===================================================================== #
+      # === :use_vertical_bar
+      # ===================================================================== #
+      when :use_vertical_bar
+        set_match_token :vertical_bar
+      end
+    end
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  #
+  # Set default values for the two Strings.
+  # ========================================================================= #
+  def reset
+    super()
+    # ======================================================================= #
+    # Set up default strings first.
+    # ======================================================================= #
+    set_string1 STRING1
+    set_string2 STRING2
+    # ======================================================================= #
+    # === @n_matches
+    #
+    # This counter will keep track how many matches we found.
+    # ======================================================================= #
+    @n_matches = 0
+    set_match_token
+    @non_match_token = '.' # This is the token that will be displayed for non-matches.
+  end
+
+  # ========================================================================= #
+  # === guess_from_this_input
+  # ========================================================================= #
+  def guess_from_this_input(i)
+    # ======================================================================= #
+    # === Handle the case when the user did input two Arrays
+    # ======================================================================= #
+    i.flatten! if i.is_a? Array
+    if i.is_a? Array and i.empty?
+      # ===================================================================== #
+      # If our Array is empty, assign a default here.
+      # ===================================================================== #
+      splitted = [STRING1, STRING2]
+    else
+      splitted = i
+    end
+    splitted = splitted.split(N) unless splitted.is_a? Array
+    splitted.map!(&:strip) # Get rid of trailing and leading newspaces.
+    if splitted.is_a? Array
+      if splitted.size == 1
+        if splitted.first.include? '|'
+          splitted = splitted.first.split('|')
+        end
+      end
+    end
+    set_string_one(splitted.first)
+    set_string_last(splitted.last)
+  end
+
+  # ========================================================================= #
+  # === set_string1
+  # ========================================================================= #
+  def set_string1(i)
+    @string1 = i
+  end; alias string1=       set_string1 # === string1=
+       alias set_string_one set_string1 # === set_string_one
+
+  # ========================================================================= #
+  # === set_string2
+  # ========================================================================= #
+  def set_string2(i)
+    @string2 = i
+  end; alias string2=        set_string2 # === string2=
+       alias set_string_two  set_string2 # === set_string_two
+       alias set_string_last set_string2 # === set_string_last
+
+  # ========================================================================= #
+  # === string1?
+  # ========================================================================= #
+  def string1?
+    @string1
+  end; alias input? string1? # === input?
+
+  # ========================================================================= #
+  # === string2
+  # ========================================================================= #
+  def string2?
+    @string2
+  end; alias string2 string2? # === string2
+
+  # ========================================================================= #
+  # === return_non_match_token
+  # ========================================================================= #
+  def return_non_match_token
+    return swarn(@non_match_token)+rev if use_colours? # Colourize this in red if we use colours.
+    @non_match_token # Else just return it.
+  end
+
+  # ========================================================================= #
+  # === return_match_token
+  # ========================================================================= #
+  def return_match_token
+    @match_token
+  end
+
+  # ========================================================================= #
+  # === n_matches?
+  # ========================================================================= #
+  def n_matches?
+    @n_matches
+  end
+
+  # ========================================================================= #
+  # === match_or_no_match_for
+  # ========================================================================= #
+  def match_or_no_match_for(char1, char2)
+    if char1 == char2
+      @n_matches += 1
+      return_match_token
+    else
+      return_non_match_token
+    end
+  end
+
+  # ========================================================================= #
+  # === set_match_token
+  #
+  # You can define another match token here. The default is '+', another
+  # popular variant would be '|'.
+  # ========================================================================= #
+  def set_match_token(
+      i = DEFAULT_MATCH_TOKEN
+    )
+    case i
+    # ======================================================================= #
+    # === :vertical_bar
+    # ======================================================================= #
+    when :vertical_bar
+      i = VERTICAL_BAR
+    end
+    @match_token = i
+  end; alias set_main_alignment_token_to set_match_token # === set_main_alignment_token
+
+  # ========================================================================= #
+  # === match_token?
+  # ========================================================================= #
+  def match_token?
+    @match_token
+  end
+
+  # ========================================================================= #
+  # === do_compare
+  # ========================================================================= #
+  def do_compare
+    e rev # A newline for easier reading.
+    chars1 = string1?.chars
+    array1 = chars1.each_slice(80).to_a.map {|entry|
+      entry.join
+    }
+    chars2 = string2?.chars
+    array2 = chars2.each_slice(80).to_a.map {|entry|
+      entry.join
+    }
+    # ======================================================================= #
+    # Combine the two Arrays in order to find the "third" array.
+    # ======================================================================= #
+    array3 = chars1.zip(chars2).map {|entry|
+      match_or_no_match_for(entry[0], entry[1])
+    }.each_slice(80).to_a.map {|entry|
+      entry.join
+    }.map {|line|
+      line.gsub(/\|/, seagreen(match_token?)+rev) # Colourize the match-token in the colour seagreen.
+    }
+    0.upto(array1.size-1) {|index|
+      e array1[index]
+      e array3[index] # Middle position.
+      e array2[index]
+    }
+    consider_notifying_the_user_if_the_sequences_are_not_equal_in_length
+    e
+  end; alias compare do_compare # === compare
+
+  # ========================================================================= #
+  # === consider_notifying_the_user_if_the_sequences_are_not_equal_in_length
+  # ========================================================================= #
+  def consider_notifying_the_user_if_the_sequences_are_not_equal_in_length
+    if @string1.size == @string2.size
+      # In this case, all is fine.
+    else
+      # else notify the user
+      e
+      e '(Note that the two sequences are not equal in length. This class'
+      e 'will only try to align from the starting position of both'
+      e 'sequences as-is.)'
+    end
+  end
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    do_compare
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  Bioroebe::SimpleStringComparer.new(ARGV)
+end # sstringcompare
+    # sstringcompare   "AAAAAAAAAAAAAATTTTTTTTTTTAAAAAAAAAAAATATA|GAAAAAAAAAAAAAAAATATTTTTTTTTTTTTTTTTTTTTT"
+    # scompare         "acgagagaccagtaacgagagaccagta|gtcaggagccagtagtcaggagccagta"

data/lib/bioroebe/string_matching/smith_waterman.rb

@@ -0,0 +1,276 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Bioroebe::SmithWaterman
+#
+# This class is able to display a 2D matrix that shows the smith-waterman
+# algorithm applied in Dynamic Programming.
+# =========================================================================== #
+module Bioroebe
+
+class SmithWaterman # === Bioroebe::SmithWaterman
+
+  # ========================================================================= #
+  # === MATCH_COST
+  #
+  # First, define the match, mismatch and gap costs.
+  # ========================================================================= #
+  MATCH_COST    =  2
+
+  # ========================================================================= #
+  # === MISMATCH_COST
+  # ========================================================================= #
+  MISMATCH_COST = -1
+
+  # ========================================================================= #
+  # === GAP_COST
+  # ========================================================================= #
+  GAP_COST      = -4
+
+  # ========================================================================= #
+  # === SCORE_INSERT
+  # ========================================================================= #
+  SCORE_INSERT =  0
+
+  # ========================================================================= #
+  # === SCORE_DELETE
+  # ========================================================================= #
+  SCORE_DELETE = -1
+  SCORE_MISS   = -1
+  SCORE_MATCH  =  2
+
+  attr_reader :str_a
+  attr_reader :str_b
+  attr_reader :str_a_arr
+  attr_reader :str_b_arr
+  attr_reader :m
+  attr_reader :n
+  attr_reader :mat
+  attr_reader :config
+
+  # ========================================================================= #
+  # === initialize
+  #
+  # Provide the two strings as input.
+  # ========================================================================= #
+  def initialize(
+      stra, strb, opts = {}
+    )
+    @str_a  = stra
+    @str_b  = strb
+    @str_a_arr = stra.unpack('U*')
+    @str_b_arr = strb.unpack('U*')
+    @m      = str_a.length + 1
+    @n      = str_b.length + 1
+    @mat    = Matrix.new(m, n)
+    @config = opts
+  end
+
+  # ========================================================================= #
+  # === do_perform_the_alignment
+  # ========================================================================= #
+  def do_perform_the_alignment
+    do_iterate_over_the_cells
+    find_optimal_path
+    return alignment
+  end
+
+  # ========================================================================= #
+  # === alignment_inspect
+  # ========================================================================= #
+  def alignment_inspect
+    la = '... '.dup
+    lb = '... '.dup
+
+    alignment.each_with_index { |pos, i|
+      next if i == 0
+      case alignment[i-1][2]
+      when :down
+        la << [ str_a_arr[pos[0]-1] ].pack('U*')
+        lb << '-'
+      when :right
+        la << '-'
+        lb << [ str_b_arr[pos[1]-1] ].pack('U*')
+      else
+        la << [ str_a_arr[pos[0]-1] ].pack('U*')
+        lb << [ str_b_arr[pos[1]-1] ].pack('U*')
+      end
+    }
+    "#{la} ...\n#{lb} ..."    
+  end
+
+  private
+  # ========================================================================= #
+  # === find_optimal_path
+  # ========================================================================= #  
+  def find_optimal_path    
+    @alignment = []    
+    recurse_optimal_path(@i_max, @j_max)
+
+    @alignment.reverse!
+    @alignment.each_with_index { |pos, i|
+      next_pos = alignment[i+1]
+      next if next_pos.nil?
+
+      del_i = next_pos[0] - pos[0]
+      del_j = next_pos[1] - pos[1]
+      direction = case (del_i + del_j)
+      when 2
+        :diagonal
+      when 1
+        (del_i > del_j) ? :down : :right
+      end
+
+      pos << direction
+    }
+  end
+
+  # ========================================================================= #
+  # === recurse_optimal_path
+  # ========================================================================= #
+  def recurse_optimal_path(i_curr, j_curr)    
+    @alignment << [i_curr, j_curr]
+    array_values = [
+      mat[i_curr-1, j_curr-1],
+      mat[i_curr-1, j_curr],
+      mat[i_curr  , j_curr-1]
+    ]
+    
+    ii, jj = case array_values.index(array_values.max)
+    when 0
+      [i_curr-1, j_curr-1]
+    when 1
+      [i_curr-1, j_curr]
+    when 2
+      [i_curr  , j_curr-1]
+    end    
+    
+    if (mat[i_curr, j_curr] == 0)
+      return
+    else
+      return recurse_optimal_path(ii, jj)
+    end
+  end; private :recurse_optimal_path
+
+  # ========================================================================= #
+  # === do_iterate_over_the_cells
+  # ========================================================================= #
+  def do_iterate_over_the_cells
+    @score = -1
+    @i_max =  0
+    @j_max =  0
+
+    (2..m).each { |i|
+      (2..n).each { |j|
+        assign_cell(i-1, j-1)
+      }
+    }
+  end
+
+  # ========================================================================= #
+  # === assign_cell
+  # ========================================================================= #
+  def assign_cell(i, j)
+    score = (str_a_arr[i-1] == str_b_arr[j-1]) ? SCORE_MATCH : SCORE_MISS      
+    value = [
+      0,
+      mat[i-1, j-1] + score,
+      mat[i-1, j] + SCORE_DELETE,
+      mat[i, j-1] + SCORE_INSERT      
+    ].max
+
+    if (value >= @score)
+      @score = value
+      @i_max = i
+      @j_max = j
+    end
+    
+    mat[i,j] = value
+  end
+
+end
+
+class Matrix # === Matrix
+
+  # ========================================================================= #
+  # === IndexOverflow
+  # ========================================================================= #
+  IndexOverflow = Class.new(StandardError)
+  
+  attr_reader :dims
+  attr_reader :nrows
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(mm, nn)
+    @dims  = [mm, nn]
+    @nrows = mm
+    @ncols = nn
+    @m     = Array.new(mm)
+    (1..mm).each {|i| @m[i-1] = Array.new(nn, 0)}
+  end
+
+  # ========================================================================= #
+  # === ncols?
+  # ========================================================================= #
+  def ncols?
+    @ncols
+  end; alias ncols ncols? # === ncols
+
+  # ========================================================================= #
+  # === score?
+  # ========================================================================= #
+  def score?
+    @score
+  end; alias score score? # === score
+
+  # ========================================================================= #
+  # === inspect
+  # ========================================================================= #
+  def inspect
+    @m.inject('') { |str, row|
+      str += row.map {|entry| sprintf('%5d', entry) }.join(' ')+"\n"
+    }
+  end 
+
+  # ========================================================================= #
+  # === alignment?
+  # ========================================================================= # 
+  def alignment?
+    @alignment
+  end; alias alignment alignment? # === alignment
+
+  # ========================================================================= #
+  # === Bioroebe::SmithWaterman[]
+  # ========================================================================= #
+  def [](i, j)    
+    raise IndexOverflow if ((i >= nrows) || (j >= ncols))
+    @m[i][j]
+  end
+
+  # ========================================================================= #
+  # === Bioroebe::SmithWaterman[]=
+  # ========================================================================= #
+  def []=(i, j, k)
+    raise IndexOverflow if ((i >= nrows) || (j >= ncols))
+
+    @m[i][j] = k
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  # Determine our two main sequences next:
+  _ = Bioroebe::SmithWaterman.new(
+    'ACACACTA',
+    'AGCACACA'
+  )
+  _.do_perform_the_alignment
+  puts
+  puts _.mat.inspect
+  puts _.alignment_inspect
+  puts _.alignment.inspect
+  puts "Highest SCORE = #{_.score}"
+end # rb smith_waterman.rb

data/lib/bioroebe/svg/README.md

@@ -0,0 +1 @@
+SVG-related code may be stored in this directory here.