bioroebe 0.10.80

data/lib/bioroebe/toplevel_methods/nucleotides.rb

@@ -0,0 +1,715 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# This file will gather "dna-related" code that can reside on the
+# toplevel. For example, Bioroebe.generate_random_dna_sequence()
+# will reside in this file here.
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/nucleotides.rb'
+# Bioroebe.to_rna
+# Bioroebe.generate_random_dna_sequence(ARGV)
+# Bioroebe.complementary_dna_strand('ATCATCATC') # => "TAGTAGTAG"
+# Bioroebe.filter_away_invalid_nucleotides(ARGV)
+# Bioroebe.return_all_positions_of_this_nucleotide(ARGV)
+# Bioroebe.partner_nucleotide(ARGV)
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/constants/nucleotides.rb'
+  require 'bioroebe/toplevel_methods/e.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.complementary_rna_strand
+  #
+  # This method will simply return the corresponding (complementary)
+  # RNA strand.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.complementary_rna_strand('ATCATCATC') # => "UAGUAGUAG"
+  #
+  # ========================================================================= #
+  def self.complementary_rna_strand(i)
+    if i.is_a? Array
+      i = i.first
+    end
+    hash = partner_nucleotide_hash
+    i.chars.map {|entry| hash[entry] }.join.tr('T','U')
+  end; self.instance_eval { alias complementary_rna complementary_rna_strand } # === Bioroebe.complementary_rna
+
+  # ========================================================================= #
+  # === Bioroebe.is_a_purine?
+  #
+  # This method will simply return true if we have a purine (as the
+  # given input to this method), and false otherwise.
+  #
+  # The argument given to this method should be a single letter, such
+  # as 'A' or 'G' (a String).
+  #
+  # In nucleic acids, two types of nucleobases are purine derivatives
+  # and would, thus, return true via this method:
+  #
+  #   - adenine (A)
+  #   - guanine (G)
+  #
+  # ========================================================================= #
+  def self.is_a_purine?(
+      i = 'A'
+    )
+    i = i.first if i.is_a? Array
+    case i
+    when 'A','G'
+      true
+    else # This is for T, C and U, at the least.
+      false
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.is_a_pyrimidine?
+  #
+  # This method will return true if we have a pyrimidine (as input), and
+  # false otherwise.
+  #
+  # In DNA and RNA we may find these pyrimidine derivatives:
+  #
+  #   cytosine (C), thymine (T), and uracil (U) 
+  #
+  # URL for explanations is at:
+  #
+  #   https://en.wikipedia.org/wiki/Pyrimidine
+  #
+  # ========================================================================= #
+  def self.is_a_pyrimidine?(
+      i = 'C'
+    )
+    i = i.first if i.is_a? Array
+    case i
+    when 'C','T','U'
+      true
+    else # This is for A and G, at the least.
+      false
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.partner_nucleotide_hash
+  #
+  # This method will return a Hash, which should be faster for lookup.
+  # ========================================================================= #
+  def self.partner_nucleotide_hash
+    HASH_DNA_NUCLEOTIDES
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.nucleotide_permutations
+  #
+  # This method will try to permutate the given nucleotides, so that
+  # we get an Array that has e. g. "AA", "AT", "AG", "AC". So really
+  # all permutations possible.
+  #
+  # The first argument to this method tells us how long we will run
+  # the algorithm at hand. A level of 2 means to show only permutations
+  # for two nucleotides and so forth. Unfortunately, this does not
+  # yet work with anything more than 2 for the time being.
+  #
+  # Since as of August 2019, this method can also read from a local
+  # file - this was added to specifically solve a problem of the
+  # ROSALIND challenges. The task can be seen here:
+  # https://rosalind.info/problems/lexf/
+  #
+  # Usage example:
+  #
+  #   Bioroebe.nucleotide_permutations
+  #
+  # ========================================================================= #
+  def self.nucleotide_permutations(
+      level       = 2,
+      nucleotides = DNA_NUCLEOTIDES # => ["A", "T", "G", "C"]
+    )
+    # ======================================================================= #
+    # Grab a reference to the possible nucleotides next.
+    # ======================================================================= #
+    _ = []
+    if level and File.file?(level.to_s)
+      dataset = File.read(level).strip
+      splitted = dataset.split("\n")
+      nucleotides = splitted.first.strip.split(' ')
+      level = splitted.last
+    end
+    level = level.to_i # We need an Integer past this point.
+    (level - 1).times {
+      nucleotides.each {|entry|
+        _ << nucleotides.map {|inner_entry| entry+inner_entry }
+      }
+    }
+    return _.flatten.uniq.sort
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.partner_nucleotide
+  #
+  # This small "table" will simply return the corresponding Nucleotide
+  # matching the given input at hand - in other words, the corresponding
+  # DNA nucleotide that can base-pair with the input nucleotide.
+  #
+  # Since this is a method call this may be a bit slow if you have to
+  # invoke the method repeatedly. In this case, you should consider
+  # using the method befined below, through the method
+  # Bioroebe.partner_nucleotide_hash(), and then use that Hash instead.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.partner_nucleotide('A') # => "T"
+  #   Bioroebe.should_match_to?('T') # => "A"
+  #
+  # ========================================================================= #
+  def self.partner_nucleotide(i)
+    i = i.first if i.is_a? Array # We only handle the first entry in an Array.
+    if i
+      i = i.dup if i.frozen?
+      i.upcase! # just in caase.
+      case i # case tag.
+      when 'A'
+        return 'T'
+      when 'T','U'
+        return 'A'
+      when 'G'
+        return 'C'
+      when 'C'
+        return 'G'
+      else
+        return nil # means illegal value.
+      end
+    end
+    return i # Return just in case.
+  end; self.instance_eval { alias complementary_nucleotide partner_nucleotide } # === Bioroebe.complementary_nucleotide
+       self.instance_eval { alias return_dna_match         partner_nucleotide } # === Bioroebe.return_dna_match
+       self.instance_eval { alias should_match_to?         partner_nucleotide } # === Bioroebe.should_match_to?
+
+  # ========================================================================= #
+  # === Bioroebe.return_all_positions_of_this_nucleotide
+  #
+  # This method will return all positions of a given nucleotide in a
+  # larger subsequence, as an Array. Thus, the returned value will
+  # be an Array.
+  #
+  # For example: if the input String is 'AUGCUUCAGAAAGGUCUUACG' and we
+  # search for 'U' then this method must return an Array that holds
+  # [2, 5, 6, 15, 17, 18].
+  # ========================================================================= #
+  def self.return_all_positions_of_this_nucleotide(
+      input_string    = 'AUGCUUCAGAAAGGUCUUACG',
+      this_nucleotide = 'U'
+    )
+    # ======================================================================= #
+    # Setting the default for this_nucleotide next:
+    # ======================================================================= #
+    this_nucleotide = 'U' if this_nucleotide.nil?
+    if input_string
+      array = (0 ... input_string.length).find_all {|position|
+        input_string[position, 1] == this_nucleotide
+      }.map {|line| line += 1 } # This line is for dealing with nucleotides.
+      return array
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.only_nucleotides?
+  #
+  # This filter-method will return true or false depending on whether
+  # we have only valid nucleotides as part of the given input to this
+  # method.
+  #
+  # In order for this to work, we will tap into the constant
+  # called HASH_DNA_NUCLEOTIDES. Note that, despite the name,
+  # we also include RNA there.
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.only_nucleotides? 'ATGCG'  # => true
+  #   Bioroebe.only_nucleotides? 'ATGCGi' # => false
+  #
+  # ========================================================================= #
+  def self.only_nucleotides?(i)
+    i = i.join.strip if i.is_a? Array
+    allowed_keys = HASH_DNA_NUCLEOTIDES.keys
+    chars = i.chars
+    chars.all? {|entry| allowed_keys.include? entry }
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.is_reverse_complement?
+  #
+  # This method was specifically added to solve a problem at Rosalind.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.is_reverse_complement?('GCATGC')  # => true
+  #   Bioroebe.is_reverse_complement?('GCATGCA') # => false
+  #
+  # ========================================================================= #
+  def self.is_reverse_complement?(i)
+    ::Bioroebe.complement(i) == i.reverse
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.generate_random_dna_sequence
+  #
+  # This method will "generate" a random DNA sequence (as a String).
+  #
+  # A String will be returned by this method.
+  #
+  # The second argument to this method can be a Hash, specifying the
+  # percentage likelihood for each of the nucleotides. See the
+  # following usage examples to find out how to use this.
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.random_dna 15 # => "TTGGTAAGCTCTTTA"
+  #   Bioroebe.random_dna 25 # => "TTAGCACAAGCATGGACGGACCAGA"
+  #   Bioroebe.random_dna(50, { A: 10, T: 10, C: 10, G: 70}) # => "GGGGTGGGGAGGGTATGCGGAGGAAGGGCGGGAAGGGCGGGGGCTGGGCG"
+  #
+  # ========================================================================= #
+  def self.generate_random_dna_sequence(
+      i = ARGV,
+      optional_hash_with_the_frequencies = {}
+    )
+    _ = Bioroebe::DNA_NUCLEOTIDES # Get a handle to the four DNA nucleotides.
+    if i.is_a? Array
+      i = i.join.strip
+    end
+    case i
+    when :default
+      i = 250
+    end
+    i = i.to_i
+    result = ''.dup
+    if optional_hash_with_the_frequencies.empty?
+      # ===================================================================== #
+      # This is the default clause.
+      # ===================================================================== #
+      i.times {
+        result << _.sample
+      }
+    else
+      # ===================================================================== #
+      # Else, the user wants to use a frequency hash:
+      # ===================================================================== #
+      hash = optional_hash_with_the_frequencies
+      frequency_for_A = hash[:A]
+      frequency_for_T = hash[:T]
+      frequency_for_C = hash[:C]
+      frequency_for_G = hash[:G]
+      i.times {
+        percentage = rand(100)+1
+        if percentage <= frequency_for_A
+          match = 'A'
+        elsif (percentage > frequency_for_A) and
+              (percentage <= frequency_for_A+frequency_for_T)
+          match = 'T'
+        elsif (percentage > frequency_for_A+frequency_for_T) and
+              (percentage <= frequency_for_A+frequency_for_T+frequency_for_C)
+          match = 'C'
+        elsif (percentage > frequency_for_A+frequency_for_T+frequency_for_C) and
+              (percentage <= frequency_for_A+frequency_for_T+frequency_for_C+frequency_for_G)
+          match = 'G'
+        else
+          e 'Not found a match for '+percentage.to_s
+        end
+        result << match
+      }
+    end
+    result
+  end; self.instance_eval { alias random_dna                 generate_random_dna_sequence } # === Bioroebe.random_dna
+       self.instance_eval { alias generate_dna               generate_random_dna_sequence } # === Bioroebe.generate_dna
+       self.instance_eval { alias create_random_dna_sequence generate_random_dna_sequence } # === Bioroebe.create_random_dna_sequence
+       self.instance_eval { alias create_random_dna          generate_random_dna_sequence } # === Bioroebe.create_random_dna
+
+  # ========================================================================= #
+  # === Bioroebe.filter_away_invalid_nucleotides
+  #
+  # This method can be used to filter away invalid nucleotides. An "invalid"
+  # nucleotide is, for example, if you work with DNA sequences, any character
+  # that is not allowed to be part of DNA. For example, Uracil, which can
+  # be found (almost exclusively) only in RNA.
+  #
+  # As for now, the behaviour is to downcase the given input before
+  # applying the .tr() method on the given String.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.filter_away_invalid_nucleotides 'ATGCCGGAGGAGANNN' # => "ATGCCGGAGGAGA"
+  #
+  # ========================================================================= #
+  def self.filter_away_invalid_nucleotides(
+      i,
+      preserve_uracil = false
+    )
+    if i.is_a? Array
+      i = i.join(' ').strip
+    end
+    case preserve_uracil
+    when :preserve_uracil
+      preserve_uracil = true
+    when :preserve_nothing
+      preserve_uracil = false
+    end
+    i = i.to_s.upcase
+    if preserve_uracil
+      i.tr!('B,D-F,H-S,V-Z','') # A T C G U
+    else
+      i.tr!('B,D-F,H-S,U-Z','') # A T C G
+    end
+    return i
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.input_as_dna
+  #
+  # This method will only accept input that is DNA, that is, the short
+  # letter variant (thus, A, T, C or G). Any other input will be
+  # stripped away, aka discarded, so this methods acts as a filter -
+  # a forward-filter for DNA.
+  #
+  # The method will return a "String" that is assumed to be a
+  # "DNA string". You can expect only DNA nucleotides to be
+  # part of that string.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.input_as_dna 'UUTGAGGACCA' # => "TGAGGACCA"
+  #
+  # ========================================================================= #
+  def self.input_as_dna(i)
+    i = i.first if i.is_a? Array
+    i = i.dup if i.frozen?
+    i.upcase!
+    # ======================================================================= #
+    # The next method is defined in this file here.
+    # ======================================================================= #
+    i = filter_away_invalid_nucleotides(i, :preserve_nothing)
+    return i
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.to_rna
+  #
+  # This method will convert DNA into RNA. See the usage example below for
+  # a bit more details.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.to_rna 'ATGACCG' # => "AUGACCG"
+  #
+  # ========================================================================= #
+  def self.to_rna(
+      i         = nil,
+      upcase_me = true
+    )
+    i = i.first if i.is_a? Array
+    i = i.to_s
+    i = i.dup if i.frozen?
+    if i and File.exist?(i) and i.include?('.') # Assume input such as 'foobar.md'.
+      i = File.read(i)
+    end
+    i.gsub!(/T/,'U')
+    return i
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.to_dna
+  #
+  # This method will essentially replace all "U" with "T", from the given
+  # input argument (which can be a String or an Array).
+  #
+  # To test this method, do:
+  #
+  #   Bioroebe.to_dna 'ACCACACCAUUUCCCAUGGGUGUGUGG' # => "ACCACACCATTTCCCATGGGTGTGTGG"
+  #
+  # ========================================================================= #
+  def self.to_dna(
+      i         = nil,
+      upcase_me = true
+    )
+    i = i.first if i.is_a? Array
+    i = i.to_s
+    i = filter_away_invalid_nucleotides(i, :preserve_uracil) # A module-method.
+    i = i.upcase if upcase_me
+    if upcase_me # Sanitize all U into T.
+      i.tr!('U','T')
+    else
+      i.tr!('u','t')
+    end
+    return i
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.generate_nucleotide_sequence_based_on_these_frequencies
+  #
+  # The second argument to this method should be a Hash.
+  #
+  # The default output may be a String such as this one here:
+  #
+  #   AACTGAACATTTTAGGAGATATCAAGACCCTCTGATTCTCAAGGAATAATTAGCTAATTT
+  #
+  # Usage example:
+  #
+  #   Bioroebe.generate_nucleotide_sequence_based_on_these_frequencies(:default, { A: 0.25, C: 0.25, G: 0.25, T: 0.25 })
+  #
+  # ========================================================================= #
+  def self.generate_nucleotide_sequence_based_on_these_frequencies(
+      n_nucleotides = 1061, # Denote how many nucleotides to use.
+      hash_frequencies = {
+        A: 0.3191430,
+        C: 0.2086633,
+        G: 0.2580345,
+        T: 0.2141593
+      }
+    )
+    case n_nucleotides
+    # ======================================================================= #
+    # === :default
+    # ======================================================================= #
+    when :default
+      n_nucleotides = 500
+    end
+    result = ''.dup
+    frequency_for_A = hash_frequencies[:A]
+    frequency_for_C = hash_frequencies[:C]
+    frequency_for_G = hash_frequencies[:G]
+    frequency_for_T = hash_frequencies[:T]
+    n_nucleotides.times {|run_number_n|
+      use_this_number = rand(0)
+      if use_this_number <= frequency_for_A
+        result << 'A'
+      elsif use_this_number <= (frequency_for_A+frequency_for_C)
+        result << 'C'
+      elsif use_this_number <= (frequency_for_A+frequency_for_C+frequency_for_G)
+        result << 'G'
+      elsif use_this_number <= (frequency_for_A+frequency_for_C+frequency_for_G+frequency_for_T)
+        result << 'T'
+      end
+    }
+    return result
+  end; self.instance_eval { alias generate_nucleotide_sequence_based_on_frequencies generate_nucleotide_sequence_based_on_these_frequencies } # === Bioroebe.generate_nucleotide_sequence_based_on_frequencies
+
+  # ========================================================================= #
+  # === Bioroebe.n_transversions
+  # ========================================================================= #
+  def self.n_transversions(
+      string1 = 'ATGAAA',
+      string2 = 'ATGCTG'
+    )
+    n_transversions = 0
+    chars1 = string1.chars
+    chars2 = string2.chars
+    chars1.each_with_index {|char1, index|
+      char2 = chars2[index]
+      if char1 == char2
+        # Equal, so it can not be a transition or transversion.
+      elsif is_a_pyrimidine?(char1)
+        # In this case it can be either a transition or a transversion.
+        if is_a_purine?(char2)
+          n_transversions += 1
+        end
+      elsif is_a_purine?(char1)
+        if is_a_pyrimidine?(char2)
+          n_transversions += 1
+        end
+      end
+    }
+    n_transversions
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.n_transitions
+  #
+  # In genetics, a transition is a point mutation that changes a purine
+  # nucleotide to another purine (A ←→ G) or a pyrimidine nucleotide
+  # to another pyrimidine (C ←→ T).
+  #
+  # The method Bioroebe.n_transitions will return an Integer value.
+  #
+  # It expects two Strings as arguments.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.n_transitions('ATGAAAAACA', 'ATGCTGATGG') # => 2
+  #
+  # ========================================================================= #
+  def self.n_transitions(
+      string1 = 'ATGAAA',
+      string2 = 'ATGCTG'
+    )
+    n_transitions = 0
+    chars1 = string1.chars
+    chars2 = string2.chars
+    chars1.each_with_index {|char1, index|
+      char2 = chars2[index]
+      if char1 == char2
+        # Equal, so it can not be a transition or transversion.
+      elsif is_a_pyrimidine?(char1)
+        # In this case it can be either a transition or a transversion.
+        if is_a_pyrimidine?(char2)
+          n_transitions += 1
+        end
+      elsif is_a_purine?(char1)
+        if is_a_purine?(char2)
+          n_transitions += 1
+        end
+      end
+    }
+    n_transitions
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.transitions_to_transversions_ratio
+  #
+  # This method will calculate the transition-to-transversion ratio
+  # between two Strings of equal length.
+  #
+  # The second argument, called `string2`, can be nil, in which case
+  # we may re-set it to a value if the input to string1 is a file. The
+  # reason for this is that we may want to read both string1 and
+  # string2 from a file, if available. If it is a file then it is
+  # typically assumed to be a FASTA (.fasta or .fa) file. See the
+  # following usage examples for this.
+  #
+  # Usage examples:
+  #
+  #   dataset = Bioroebe.transitions_to_transversions_ratio('/XXX.txt')
+  #   dataset = Bioroebe.transitions_to_transversions_ratio('/TRANSITIONS.txt')
+  #
+  # ========================================================================= #
+  def self.transitions_to_transversions_ratio(
+      string1, string2 = nil, round_to_n_positions = 11
+    )
+    if File.file? string1
+      # ===================================================================== #
+      # We can read in fasta-data here.
+      # ===================================================================== #
+      require 'bioroebe/fasta_and_fastq/parse_fasta/parse_fasta.rb'
+      dataset = ::Bioroebe::ParseFasta.new(string1) { :be_quiet }.values
+      if dataset.size > 1
+        string1 = dataset[0]
+        string2 = dataset[1]
+      end
+    end
+    n_transitions = n_transitions(string1, string2).to_f
+    ratio = ( n_transitions / n_transversions(string1, string2).to_f )
+    return ratio.to_f.round(round_to_n_positions)
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.generate_random_rna_sequence
+  #
+  # The input-argument should be a number, an Integer, such as 10.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.generate_random_rna_sequence(10)
+  #
+  # ========================================================================= # 
+  def self.generate_random_rna_sequence(i = ARGV)
+    if i.is_a? Array
+      i = i.join(' ').strip
+    end
+    _ = Bioroebe::RNA_NUCLEOTIDES # Point to the allowed RNA-nucleotides here.
+    result = ''.dup
+    i.to_s.to_i.times {
+      result << _.sample
+    }
+    return result
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  require 'colours/autoinclude'
+  e
+  e 'Next testing whether the following is a purine or a pyrimidine:'
+  e
+  e 'A T C G U'
+  e
+  p Bioroebe.is_a_purine?('A')
+  p Bioroebe.is_a_purine?('T')
+  p Bioroebe.is_a_purine?('C')
+  p Bioroebe.is_a_purine?('G')
+  p Bioroebe.is_a_purine?('U')
+  p Bioroebe.is_a_pyrimidine?('A')
+  p Bioroebe.is_a_pyrimidine?('T')
+  p Bioroebe.is_a_pyrimidine?('C')
+  p Bioroebe.is_a_pyrimidine?('G')
+  p Bioroebe.is_a_pyrimidine?('U')
+
+  pp Bioroebe.return_all_positions_of_this_nucleotide(ARGV.first, ARGV[1])
+  if ARGV.empty?
+    puts Bioroebe.partner_nucleotide('A')
+  else
+    puts Bioroebe.partner_nucleotide(ARGV)
+  end
+
+  _ = 'ATGCG';  print 'Does '+_+' contain only nucleotides? '; p Bioroebe.only_nucleotides? _ # => true
+  _ = 'ATGCGi'; print 'Does '+_+' contain only nucleotides? '; p Bioroebe.only_nucleotides? _ # => false
+
+  e
+  e 'Next handling Bioroebe.nucleotide_permutations()'
+  e
+  if ARGV.empty?
+    pp Bioroebe.nucleotide_permutations
+    pp Bioroebe.nucleotide_permutations(3)
+  else
+    result = Bioroebe.nucleotide_permutations(ARGV.first)
+    result.each {|entry|
+      puts entry
+    }
+  end
+
+  Bioroebe.generate_random_dna_sequence(ARGV)
+
+  input_sequence = 'BBBATGCCGGAGGAGANNN'
+
+  e
+  e Colours.rev+'The input sequence used was:'
+  e
+  e '  '+Colours.steelblue(input_sequence)
+  e
+  e 'The output sequence is:'
+  e
+  e '  '+Colours.steelblue(Bioroebe.filter_away_invalid_nucleotides(input_sequence))
+  e # filter_away_invalid_nucleotides
+  e
+  e Bioroebe.complementary_dna_strand(ARGV)
+  e
+  e Bioroebe.generate_nucleotide_sequence_based_on_these_frequencies
+  e
+
+  # ========================================================================= #
+  # The code here can be used as test the transitions-and-transversions
+  # functionality.
+  # ========================================================================= #
+  alias e puts
+  e 'The two strings that are to be compared, are:'
+  e
+  e '  ATGAAA'
+  e '  ATGCTG'
+  e
+  e 'n transition events?:   '+Bioroebe.n_transitions.to_s
+  e 'n transversion events?: '+Bioroebe.n_transversions.to_s
+  e
+  string1 = 'GCAACGCACAACGAAAACCCTTAGGGACTGGATTATTTCGTGATCGTTGTAGTTATTGGAAGTACGGGCATCAACCCAGTT'
+  string2 = 'TTATCTGACAAAGAAAGCCGTCAACGGCTGGATAATTTCGCGATCGTGCTGGTTACTGGCGGTACGAGTGTTCCTTTGGGT'
+  e string1
+  e string2
+  e
+  e 'The ratio is:'
+  e
+  e "  #{Bioroebe.transitions_to_transversions_ratio(string1, string2).to_s}"
+  e
+end # returnallpositionsofthisnucleotide AUGCUUCAGAAAGGUCUUACG   # => [2, 5, 6, 15, 17, 18]
+    # returnallpositionsofthisnucleotide AUGCUUCAGAGGGGUCUUACG G # => [3, 9, 11, 12, 13, 14, 21]
+    # nucleotide_permutations
+    # nucleotide_permutations 2
+    # nucleotide_permutations /PERMUTATIONS.md