bioroebe 0.10.80

data/lib/bioroebe/toplevel_methods/matches.rb

@@ -0,0 +1,259 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# Match-related actions on the toplevel "namespace" are collected in this
+# file here.
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/matches.rb'
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/constants/regex.rb'
+  require 'bioroebe/toplevel_methods/e.rb'
+  require 'bioroebe/toplevel_methods/download_and_fetch_data.rb'
+  require 'bioroebe/toplevel_methods/file_and_directory_related_actions.rb'
+  require 'bioroebe/fasta_and_fastq/parse_fasta/parse_fasta.rb'
+  require 'bioroebe/codons/start_codons.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.determine_n_glycosylation_matches
+  #
+  # This method can be used to determine N-Glycosylation patterns in a
+  # protein.
+  #
+  # The input to this method should be an aminoacid chain - aka a protein
+  # sequence.
+  #
+  # This method will return an Array. This Array holds the indices where
+  # a N-glycosylation pattern begins.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.determine_n_glycosylation_matches # => [85, 118, 142, 306, 395]
+  #
+  # ========================================================================= #
+  def self.determine_n_glycosylation_matches(
+      of_this_protein_sequence =
+        'MKNKFKTQEELVNHLKTVGFVFANSEIYNGLANAWDYGPLGVLLKNNLKNLWWKEFVTKQKDV'\
+        'VGLDSAIILNPLVWKASGHLDNFSDPLIDCKNCKARYRADKLIESFDENIHIAENSSNEEFAK'\
+        'VLNDYEISCPTCKQFNWTEIRHFNLMFKTYQGVIEDAKNVVYLRPETAQGIFVNFKNVQRSMR'\
+        'LHLPFGIAQIGKSFRNEITPGNFIFRTREFEQMEIEFFLKEESAYDIFDKYLNQIENWLVSAC'\
+        'GLSLNNLRKHEHPKEELSHYSKKTIDFEYNFLHGFSELYGIAYRTNYDLSVHMNLSKKDLTYF'\
+        'DEQTKEKYVPHVIEPSVGVERLLYAILTEATFIEKLENDDERILMDLKYDLAPYKIAVMPLVN'\
+        'KLKDKAEEIYGKILDLNISATFDNSGSIGKRYRRQDAIGTIYCLTIDFDSLDDQQDPSFTIRE'\
+        'RNSMAQKRIKLSELPLYLNQKAHEDFQRQCQK'
+    )
+    if of_this_protein_sequence.is_a? Array
+      of_this_protein_sequence.each {|this_sequence|
+        determine_n_glycosylation_matches(this_sequence)
+      }
+    else
+      scanned = of_this_protein_sequence.scan(
+        REGEX_FOR_N_GLYCOSYLATION_PATTERN
+      )
+      scanned.flatten.uniq.map {|substring|
+        of_this_protein_sequence.index(substring)+1 # +1 because ruby starts at 0.
+      }
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.return_longest_substring_via_LCS_algorithm
+  #
+  # This method will return the longest substring between two different
+  # sequences. It will ignore gaps and will thus not be as sophisticated
+  # as other algorithms.
+  #
+  # This method will return a String.
+  #
+  # Usage example in plain ruby:
+  #
+  #   Bioroebe.return_longest_substring_via_LCS_algorithm 'ATGAAA','ATGCAT' # => 'ATGA'
+  #
+  # ========================================================================= #
+  def self.return_longest_substring_via_LCS_algorithm(
+      sequence1 = ARGV,
+      sequence2 = nil
+    )
+    begin
+      require 'diff/lcs'
+    rescue LoadError; end
+    if sequence1.is_a? Array
+      if sequence1.size > 1
+        sequence2 = sequence1[1]
+        sequence1 = sequence1[0]
+      end
+    end 
+    lcs_object = Diff::LCS.LCS(sequence1, sequence2)
+    return lcs_object.join # Must return a String.
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.return_array_of_sequence_matches
+  #
+  # This method can be used to return an Array of subsequence matches.
+  #
+  # This method will always return an Array - an empty Array if no
+  # subsequence match has been found; and an Array with integer numbers
+  # as indices, to denote which indices contain the subsequence. These
+  # numbers store the start position of the subsequence.
+  #
+  # Keep in mind that for nucleotides we will start at +1, not 0, so
+  # if you see an Array such as [3, 7] as result then this refers to
+  # the nucleotide at position 3 and the nucleotide at position 7.
+  #
+  # Arguments to this method:
+  #
+  # The first argument to this method should be the main sequence.
+  #
+  # The second argument to this method should be the subsequence
+  # that we assume to be part of the main sequence (that is, to
+  # occur within that main sequence at the least once).
+  #
+  # Specific invocation examples, with the last example showing
+  # how an empty Array will be returned:
+  #
+  #   Bioroebe.return_array_of_sequence_matches('ACGTACGTAACG','GTA')   # => [3, 7]
+  #   Bioroebe.return_array_of_sequence_matches('ACGTACGTAACG','GTAAA') # => []
+  #   Bioroebe.return_array_of_sequence_matches('ATGGTGGTGGTGATGATGTGCACTCGGTTCCAGGGGGGTCGTAGGAATTGAGCTAGGACCTCCACTAGGCATCTGGGTTCGAAATTATAAAGGTCAAACGCTACTACCCTGTGTGCTAGCTTTGAAGGGCTGACGCTAGAATTGACGTCGCCGGTGACATTTGCGTCGAGGTGGTAGTAATGTTCCAAGGATGCCGGACGAACGGTACTTACCCTCGTTAGTCAGATCGCCAACCCGAGTCGTCCATGAGGAAAGCGTAATGGAAGAGACCGGGACAGCCCTCCTCAAATGTGCCTGGATACGAGTGATTTACCA','ATG')
+  #
+  # ========================================================================= #
+  def self.return_array_of_sequence_matches(
+      main_sequence,
+      subsequence # ← The subsequence that you wish to match onto the main sequence.
+    )
+    if main_sequence
+      array = []
+      chars = main_sequence.chars
+      if main_sequence.is_a? ::Bioroebe::Sequence
+        main_sequence = main_sequence.sequence?
+      end
+      chars.each_with_index.select {|char, index|
+        if main_sequence[index, subsequence.length] == subsequence
+          array << index+1
+        end
+      }
+      return array
+    else
+      []
+    end
+  end; self.instance_eval { alias return_indices_of_matches return_array_of_sequence_matches } # === Bioroebe.return_indices_of_matches
+       self.instance_eval { alias indices_of_matches        return_array_of_sequence_matches } # === Bioroebe.indices_of_matches
+
+  # ========================================================================= #
+  # === Bioroebe.return_all_substring_matches
+  #
+  # This method will give us back an Array that contains all matching
+  # substrings.
+  #
+  # By default, the method will search for start codons such as ATG
+  # or GTG.
+  # ========================================================================= #
+  def self.return_all_substring_matches(
+      this_string,
+      use_this_as_substring = ::Bioroebe.start_codon?
+    )
+    # ======================================================================= #
+    # We will search for both ATG and AUG though, respectively the
+    # input variants given to us. If the following regex appears to
+    # be complicated to you, here is the old variant for the regex:
+    #
+    #   use_this_regex = /(ATG|AUG)/i
+    #
+    # =================================================================== #
+    if use_this_as_substring.include? 'T'
+      use_this_regex = /(#{use_this_as_substring}|#{use_this_as_substring.tr('T','U')})/i
+    else
+      use_this_regex = /#{use_this_as_substring}/i
+    end
+    result = this_string.to_enum(:scan, use_this_regex).map { |match|
+      [$`.size + 1, match] # +1 because we refer to the nucleotide positions.
+    }
+    return result
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.show_n_glycosylation_motifs
+  #
+  # The argument to this method should be a local file, which
+  # stores the IDs of the proteins. Only use one ID per given
+  # line, though.
+  #
+  # This method has been inspired by this Rosalind task:
+  #
+  #   http://rosalind.info/problems/mprt/
+  #
+  # ========================================================================= #
+  def self.show_n_glycosylation_motifs(
+      from_this_file = 'foobar.fasta'
+    )
+    if from_this_file.is_a? Array
+      from_this_file = from_this_file.first
+    end
+    from_this_file = from_this_file.to_s
+    if File.exist? from_this_file
+      result = ''.dup
+      dataset = File.readlines(from_this_file).reject {|entry| entry.strip.empty? }
+      index = 0
+      dataset.each {|this_id_for_the_protein| index += 1
+        this_id_for_the_protein.strip!
+        # =================================================================== #
+        # Fetch the remote dataset from uniprot.
+        # =================================================================== #
+        e
+        e royalblue(
+            index.to_s.rjust(2)+') '
+          )
+        file_location         = ::Bioroebe.fetch_data_from_uniprot(this_id_for_the_protein)
+        parsed_fasta_sequence = ::Bioroebe::ParseFasta.new(file_location) { :be_quiet }.first_value
+        array_of_indices      = ::Bioroebe.determine_n_glycosylation_matches(parsed_fasta_sequence)
+        # =================================================================== #
+        # Next, this is the output that Rosalind wants to have.
+        # =================================================================== #
+        unless array_of_indices.empty?
+          result << this_id_for_the_protein+"\n"
+          result << array_of_indices.join(' ')+"\n"
+        end
+      }
+      e result # And display that result finally.
+    else
+      no_file_exists_at(from_this_file)
+    end
+  end; self.instance_eval { alias glycosylation show_n_glycosylation_motifs } # === Bioroebe.glycosylation
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  pp Bioroebe.determine_n_glycosylation_matches
+  Bioroebe.show_n_glycosylation_motifs(ARGV)
+    # ========================================================================= #
+  # Some test-code.
+  # ========================================================================= #
+  require 'colours/autoinclude'
+  input_sequence = 'TGCAGAAAAAAAAAAAGCCCCCCCCGTTTTTTTTATGCCCCCCGCGGGGGGGGATGTGGGGGC'
+  e rev+'The input sequence is:'
+  e
+  e "  #{sfancy(input_sequence)}"
+  e
+  array_matches = Bioroebe.return_all_substring_matches(input_sequence)
+  e 'The first match (for the sequence '+::Bioroebe.start_codon?+') would yield:'
+  e
+  e "  #{sfancy(input_sequence[(array_matches.first.first-1) .. -1])}"
+  e
+  e 'All matches found with a start codon are contained in the following Array:'
+  e
+  print '  '; pp array_matches
+  e
+  e 'Next, testing Bioroebe.return_array_of_sequence_matches(ARGV[0], ARGV[1])'
+  e
+  pp Bioroebe.return_array_of_sequence_matches(ARGV[0], ARGV[1])
+end # determinenglycosylationmatches
+    # determinenglycosylationmatches /UNIPROT.md
+    # determinenglycosylationmatches /HERE.md
+    # determinenglycosylationmatches /ABC.md
+    # determinenglycosylationmatches /rosalind_mprt.txt
+    #
+    # return_array_of_sequence_matches AUGACGTACGTAACG AUG # => [1]
+    # return_array_of_sequence_matches ACGTACGTAACG GTA    # => [3, 7]
+    # rb matches.rb ACGTACGTAACG GTA

data/lib/bioroebe/toplevel_methods/misc.rb

@@ -0,0 +1,432 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/misc.rb'
+# Bioroebe.reverse_sequence(ARGV)
+# Bioroebe.bisulfite_treatment(ARGV)
+# Bioroebe.return_DNA_composition_hash
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/encoding/encoding.rb'
+  require 'bioroebe/toplevel_methods/aminoacids_and_proteins.rb'
+  require 'bioroebe/toplevel_methods/e.rb'
+  require 'bioroebe/toplevel_methods/esystem.rb'
+  require 'bioroebe/toplevel_methods/extract.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.thousand_percentage
+  #
+  # This method is solely a helper-method for Bioroebe.frequency_per_thousand().
+  # ========================================================================= #
+  def self.thousand_percentage(
+      this_codon_n_times =   1,
+      total_n_elements  = 1000
+    )
+    result = (
+      (this_codon_n_times * 1000.0) / total_n_elements.to_f
+    ).round(1)
+    padded_result = result.to_s.rjust(5, ' ')
+    return padded_result
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.frequency_per_thousand
+  #
+  # The input to this method should be a String ideally. If an Array is
+  # input then it will simply be .join()-ed.
+  #
+  # This method will return a String, if all goes well.
+  # ========================================================================= # 
+  def self.frequency_per_thousand(i)
+    result = "fields: [triplet] [frequency: per thousand] ([number])\n".dup # This String will be returned.
+    if i.is_a? Array
+      i = i.join
+    end
+    i.delete!("\n")
+    hash = ::Bioroebe.codon_frequency_of_this_string(i)
+    hash.default = 0
+    total_n_elements = hash.values.sum
+    append_this = <<-EOF 
+
+UUU#{thousand_percentage(hash['UUU'], total_n_elements)}(     #{hash['UUU']})  UCU#{thousand_percentage(hash['UCU'], total_n_elements)}(     #{hash['UCU']})  UAU#{thousand_percentage(hash['UAU'], total_n_elements)}(     #{hash['UAU']})  UGU#{thousand_percentage(hash['UGU'], total_n_elements)}(     #{hash['UGU']})
+UUC#{thousand_percentage(hash['UUC'], total_n_elements)}(     #{hash['UUC']})  UCC#{thousand_percentage(hash['UCC'], total_n_elements)}(     #{hash['UCC']})  UAC#{thousand_percentage(hash['UAC'], total_n_elements)}(     #{hash['UAC']})  UGC#{thousand_percentage(hash['UGC'], total_n_elements)}(     #{hash['UGC']})
+UUA#{thousand_percentage(hash['UUA'], total_n_elements)}(     #{hash['UUA']})  UCA#{thousand_percentage(hash['UCA'], total_n_elements)}(     #{hash['UCA']})  UAA#{thousand_percentage(hash['UAA'], total_n_elements)}(     #{hash['UAA']})  UGA#{thousand_percentage(hash['UGA'], total_n_elements)}(     #{hash['UGA']})
+UUG#{thousand_percentage(hash['UUG'], total_n_elements)}(     #{hash['UUG']})  UCG#{thousand_percentage(hash['UCG'], total_n_elements)}(     #{hash['UCG']})  UAG#{thousand_percentage(hash['UAG'], total_n_elements)}(     #{hash['UAG']})  UGG#{thousand_percentage(hash['UGG'], total_n_elements)}(     #{hash['UGG']})
+
+CUU#{thousand_percentage(hash['CUU'], total_n_elements)}(     #{hash['CUU']})  CCU#{thousand_percentage(hash['CCU'], total_n_elements)}(     #{hash['CCU']})  CAU#{thousand_percentage(hash['CAU'], total_n_elements)}(     #{hash['CAU']})  CGU#{thousand_percentage(hash['CGU'], total_n_elements)}(     #{hash['CGU']})
+CUC#{thousand_percentage(hash['CUC'], total_n_elements)}(     #{hash['CUC']})  CCC#{thousand_percentage(hash['CCC'], total_n_elements)}(     #{hash['CCC']})  CAC#{thousand_percentage(hash['CAC'], total_n_elements)}(     #{hash['CAC']})  CGC#{thousand_percentage(hash['CGC'], total_n_elements)}(     #{hash['CGC']})
+CUA#{thousand_percentage(hash['CUA'], total_n_elements)}(     #{hash['CUA']})  CCA#{thousand_percentage(hash['CCA'], total_n_elements)}(     #{hash['CCA']})  CAA#{thousand_percentage(hash['CAA'], total_n_elements)}(     #{hash['CAA']})  CGA#{thousand_percentage(hash['CGA'], total_n_elements)}(     #{hash['CGA']})
+CUG#{thousand_percentage(hash['CUG'], total_n_elements)}(     #{hash['CUG']})  CCG#{thousand_percentage(hash['CCG'], total_n_elements)}(     #{hash['CCG']})  CAG#{thousand_percentage(hash['CAG'], total_n_elements)}(     #{hash['CAG']})  CGG#{thousand_percentage(hash['CGG'], total_n_elements)}(     #{hash['CGG']})
+
+AUU#{thousand_percentage(hash['AUU'], total_n_elements)}(     #{hash['AUU']})  ACU#{thousand_percentage(hash['ACU'], total_n_elements)}(     #{hash['ACU']})  AAU#{thousand_percentage(hash['AAU'], total_n_elements)}(     #{hash['AAU']})  AGU#{thousand_percentage(hash['AGU'], total_n_elements)}(     #{hash['AGU']})
+AUC#{thousand_percentage(hash['AUC'], total_n_elements)}(     #{hash['AUC']})  ACC#{thousand_percentage(hash['ACC'], total_n_elements)}(     #{hash['ACC']})  AAC#{thousand_percentage(hash['AAC'], total_n_elements)}(     #{hash['AAC']})  AGC#{thousand_percentage(hash['AGC'], total_n_elements)}(     #{hash['AGC']})
+AUA#{thousand_percentage(hash['AUA'], total_n_elements)}(     #{hash['AUA']})  ACA#{thousand_percentage(hash['ACA'], total_n_elements)}(     #{hash['ACA']})  AAA#{thousand_percentage(hash['AAA'], total_n_elements)}(     #{hash['AAA']})  AGA#{thousand_percentage(hash['AGA'], total_n_elements)}(     #{hash['AGA']})
+AUG#{thousand_percentage(hash['AUG'], total_n_elements)}(     #{hash['AUG']})  ACG#{thousand_percentage(hash['ACG'], total_n_elements)}(     #{hash['ACG']})  AAG#{thousand_percentage(hash['AAG'], total_n_elements)}(     #{hash['AAG']})  AGG#{thousand_percentage(hash['AGG'], total_n_elements)}(     #{hash['AGG']})
+
+GUU#{thousand_percentage(hash['GUU'], total_n_elements)}(     #{hash['GUU']})  GCU#{thousand_percentage(hash['GCU'], total_n_elements)}(     #{hash['GCU']})  GAU#{thousand_percentage(hash['GAU'], total_n_elements)}(     #{hash['GAU']})  GGU#{thousand_percentage(hash['GGU'], total_n_elements)}(     #{hash['GGU']})
+GUC#{thousand_percentage(hash['GUC'], total_n_elements)}(     #{hash['GUC']})  GCC#{thousand_percentage(hash['GCC'], total_n_elements)}(     #{hash['GCC']})  GAC#{thousand_percentage(hash['GAC'], total_n_elements)}(     #{hash['GAC']})  GGC#{thousand_percentage(hash['GGC'], total_n_elements)}(     #{hash['GGC']})
+GUA#{thousand_percentage(hash['GUA'], total_n_elements)}(     #{hash['GUA']})  GCA#{thousand_percentage(hash['GCA'], total_n_elements)}(     #{hash['GCA']})  GAA#{thousand_percentage(hash['GAA'], total_n_elements)}(     #{hash['GAA']})  GGA#{thousand_percentage(hash['GGA'], total_n_elements)}(     #{hash['GGA']})
+GUG#{thousand_percentage(hash['GUG'], total_n_elements)}(     #{hash['GUG']})  GCG#{thousand_percentage(hash['GCG'], total_n_elements)}(     #{hash['GCG']})  GAG#{thousand_percentage(hash['GAG'], total_n_elements)}(     #{hash['GAG']})  GGG#{thousand_percentage(hash['GGG'], total_n_elements)}(     #{hash['GGG']})
+EOF
+    result << append_this
+    return result
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.codon_frequency_of_this_string
+  #
+  # The input to this method should ideally be a String. It will be assumed
+  # to be a RNA string, e. g. mRNA. Thus, all T are replaced with U by
+  # default. This can be toggled via the second argument of this method.
+  #
+  # This method will return a Hash.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.codon_frequency_of_this_string
+  #
+  # ========================================================================= #
+  def self.codon_frequency_of_this_string(
+      i = 'ATTCGTACGATCGACTGACTGACAGTCATTCGTAGTACGATCGACTGACTGACAGTCATTCGTAC'\
+          'GATCGACTGACTGACAAGTCATTCGTACGATCGACTGACTTGACAGTCATAA',
+      automatically_convert_into_a_RNA_sequence = true
+    )
+    i = i.join if i.is_a? Array
+    if automatically_convert_into_a_RNA_sequence
+      i = i.dup if i.frozen?
+      i.tr!('T','U')
+    end
+    scanned = i.scan(/.../)
+    tally = scanned.tally
+    # ======================================================================= #
+    # We still have to sort it.
+    # ======================================================================= #
+    sorted_hash = Hash[tally.sort_by {|key, value| value }.reverse]
+    return sorted_hash
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.align_this_string_via_multiple_sequence_alignment
+  #
+  # This method will simply return an Array.
+  # ========================================================================= #
+  def self.align_this_string_via_multiple_sequence_alignment(
+      this_string =
+        "PSRARRDAVG--DH--PAVEALP----PQSGPHKKEISFFTVRKEEAADADLWFPS
+         PGGASK--VGQTDNDPQAIKDLP----PQGED------------------------
+        "
+    )
+    if this_string.is_a? Array
+      this_string = this_string.join("\n")
+    end
+    this_string = this_string.dup if this_string.frozen?
+    this_string.strip!
+    this_string.delete!(' ')
+    splitted = this_string.split("\n")
+    return splitted
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.quaternary_encoding_translate_from_alphabet_string_into_the_corresponding_DNA_sequence
+  #
+  # Usage example:
+  #
+  #   Bioroebe.quaternary_encoding_translate_from_alphabet_string_into_the_corresponding_DNA_sequence('OTTO')
+  #
+  # ========================================================================= #
+  def self.quaternary_encoding_translate_from_alphabet_string_into_the_corresponding_DNA_sequence(
+      this_string = 'Hello world'
+    )
+    _ = ''.dup
+    chars = this_string.chars
+    chars.each {|this_char|
+      case chars
+      when ' ','!','?'
+        # pass through in this case.
+      else
+        this_char = this_char.upcase
+        _ << Bioroebe.quaternary_encoding_letter_to_number(this_char)
+      end
+    }
+    return _
+  end
+  
+  # ========================================================================= #
+  # === Bioroebe.quaternary_encoding_DNA_to_numbers
+  #
+  # You can pass in another hash as the second argument to this method,
+  # if you'd like to.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.quaternary_encoding_DNA_to_numbers('TACATCTTTCGATCGATCGG') # => "10201211123012301233"
+  #
+  # ========================================================================= #
+  def self.quaternary_encoding_DNA_to_numbers(
+      i    = 'TACATCTTTCGATCGATCGG',
+      hash = { A: 0, T: 1, C: 2, G: 3 }
+    )
+    i = i.chars unless i.is_a? Array
+    return i.map {|entry|
+      hash[entry.to_sym]
+    }.join
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.quaternary_encoding_letter_to_number
+  # ========================================================================= #
+  def self.quaternary_encoding_letter_to_number(
+    letter,
+    use_this_hash = {
+      '0000': :A,
+      '1000': :B,
+      '2000': :C,
+      '3000': :D,
+      '0100': :E,
+      '0200': :F,
+      '0300': :G,
+      '0010': :H,
+      '0020': :I,
+      '0030': :J,
+      '0001': :K,
+      '0002': :L,
+      '0003': :M,
+      '1100': :N,
+      '1200': :O,
+      '1300': :P,
+      '1110': :Q,
+      '1120': :R,
+      '1130': :S,
+      '1210': :T,
+      '1220': :U,
+      '1230': :V,
+      '1231': :W
+    })
+    use_this_hash = use_this_hash.invert
+    return use_this_hash[letter.to_sym].to_s
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.quaternary_encoding_number_to_letter
+  # ========================================================================= #
+  def self.quaternary_encoding_number_to_letter(
+    number,
+    use_this_hash = {
+      '0000': :A,
+      '1000': :B,
+      '2000': :C,
+      '3000': :D,
+      '0100': :E,
+      '0200': :F,
+      '0300': :G,
+      '0010': :H,
+      '0020': :I,
+      '0030': :J,
+      '0001': :K,
+      '0002': :L,
+      '0003': :M,
+      '1100': :N,
+      '1200': :O,
+      '1300': :P,
+      '1110': :Q,
+      '1120': :R,
+      '1130': :S,
+      '1210': :T,
+      '1220': :U,
+      '1230': :V,
+      '1231': :W
+    })
+    return use_this_hash[number.to_s].to_s
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.quaternary_encoding_numbers_to_DNA
+  # ========================================================================= #
+  def self.quaternary_encoding_numbers_to_DNA(
+      i    = '10201211123012301233',
+      hash = { A: 0, T: 1, C: 2, G: 3 }
+    )
+    i = i.chars unless i.is_a? Array
+    inverted_hash = hash.invert
+    return i.map {|number|
+      inverted_hash[number.to_i]
+    }.join
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.download_human_genome
+  # ========================================================================= #
+  def self.download_human_genome(
+      from_this_URL = 'https://bioconductor.org/packages/release/data/annotation/src/contrib/BSgenome.Hsapiens.UCSC.hg38_1.4.4.tar.gz'
+    )
+    esystem "wget #{from_this_URL}"
+    extract(
+      File.basename(from_this_URL)
+    )
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.guess_format
+  # ========================================================================= #
+  def self.guess_format(i)
+    case i
+    # ======================================================================= #
+    # === fasta
+    # ======================================================================= #
+    when /.fa$/,
+         /.fna$/,
+         /.faa$/,
+         /.fasta$/
+      'fasta'
+    # ======================================================================= #
+    # === fastq
+    # ======================================================================= #
+    when /.fq$/,
+         /.fastq$/
+      'fastq'
+    when /.fx/
+      ''
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.return_ubiquitin_sequence
+  #
+  # This method will simply return the Ubiquitin sequence. We may also
+  # colourize some aminoacids, if we have enabled this.
+  # ========================================================================= #
+  def self.return_ubiquitin_sequence(
+      i = 'MQIFVKTLTGKTITLEVEPSDTIENVKAKIQDKEGIPPDQQRLIFAGKQLEDGRTLSDYNIQKESTLHLVLRLRGG'
+    )
+    colourize_aa(i) # Consider colourizing it.
+  end; self.instance_eval { alias ubiquitin return_ubiquitin_sequence } # === Bioroebe.ubiquitin
+
+  # ========================================================================= #
+  # === Bioroebe.reverse_sequence
+  # ========================================================================= #
+  def self.reverse_sequence(i)
+    i = i.first if i.is_a? Array
+    i.reverse
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.bisulfite_treatment
+  #
+  # Simply convert all C into U.
+  # ========================================================================= #
+  def self.bisulfite_treatment(i)
+    if i.is_a? Array
+      i = i.join('').strip
+    end
+    i.tr('C','U')
+  end; self.instance_eval { alias bisulfie bisulfite_treatment } # === Bioroebe.bisulfite
+
+  # ========================================================================= #
+  # === Bioroebe.batch_create_windows_executables
+  #
+  # This method is only useful for windows. We will use "ocra" to create
+  # various .exe files that have the desired widgt-functionality.
+  #
+  # Note that the functionality depends on the roebe-gem.
+  # ========================================================================= #
+  def self.batch_create_windows_executables
+    begin
+      require 'roebe/custom_methods/custom_methods.rb'
+    rescue LoadError; end
+    array_these_files =  %w(
+      /home/x/programming/ruby/src/bioroebe/lib/bioroebe/gui/libui/hamming_distance/hamming_distance.rb
+    )
+    array_these_files.each {|this_file|
+      Roebe.ocra_build(
+        this_file,
+        File.basename(this_file).delete_suffix('.rb')
+      )
+    }
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.create_the_pdf_tutorial
+  #
+  # This method can be used to quickly turn the README.md file into
+  # a .pdf file, for whatever the reason the user may want this.
+  # ========================================================================= #
+  def self.create_the_pdf_tutorial(
+      read_from_this_file = '/home/x/programming/ruby/src/bioroebe/README.md',
+      store_where         = '/Depot/j/example.pdf'
+    )
+
+    require 'prawn'
+
+    Prawn::Fonts::AFM.hide_m17n_warning = true # Hide a useless warning.
+
+    pdf = Prawn::Document.new(
+            page_size: 'A4',
+            page_layout: :landscape
+          )
+    pdf.text "The Bioroebe Project", size: 80
+    pdf.start_new_page
+    pdf.bounding_box [50, 600], width: 200 do
+      pdf.fill_color '000000'
+      pdf.text "making bioinformatics great again:", size: 15
+    end
+    pdf.start_new_page
+    dataset = File.read(read_from_this_file, encoding: UTF_ENCODING)
+    dataset = dataset.encode("Windows-1252", invalid: :replace, undef: :replace)
+
+    pdf.text(dataset)
+    e 'Storing at this location: '+store_where
+    pdf.render_file store_where
+  end; self.instance_eval { alias pdf create_the_pdf_tutorial } # === Bioroebe.pdf
+
+  # ========================================================================= #
+  # === Bioroebe.return_DNA_composition_hash
+  # ========================================================================= #
+  def self.return_DNA_composition_hash(
+      of_this_sequence
+    )
+    of_this_sequence = of_this_sequence.first if of_this_sequence.is_a? Array
+    hash = {}
+    array1 = %w( A T C G )
+    array2 = Array.new(array1.size, 0)
+    array = array1.zip(array2) # Zip it up with 0-values here.
+    hash = Hash[array]
+    of_this_sequence.chars.each {|this_char|
+      hash[this_char] += 1
+    }
+    sorted_hash = Hash[*hash.sort_by {|key, value|
+      key
+    }.flatten]
+    # ======================================================================= #
+    # The hash may then look like this:
+    #
+    #   {"A"=>7, "T"=>6, "C"=>7, "G"=>6}
+    #
+    # ======================================================================= #
+    return sorted_hash
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.windows_platform?
+  # ========================================================================= #
+  def self.windows_platform?
+    case RUBY_PLATFORM
+    when /(?:mswin|bccwin|mingw|windows)(?:32|64)/i
+      true
+    else
+      false
+    end
+  end; self.instance_eval { alias on_windows?    windows_platform? } # === Bioroebe.on_windows?
+       self.instance_eval { alias is_on_windows? windows_platform? } # === Bioroebe.is_on_windows?
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  puts Bioroebe.reverse_sequence(ARGV)
+  puts Bioroebe.bisulfite_treatment('CCCGCAATGCATACCTCGCCG')
+  puts Bioroebe.return_ubiquitin_sequence
+  pp Bioroebe.return_DNA_composition_hash(ARGV)
+end # rb misc ATGC # => CGTA
+    # rb misc.rb GATCTGCAGTACGTACGTACTGACAC
+    # returnubiquitinsequence