bioroebe 0.12.24 → 0.13.31

data/lib/bioroebe/toplevel_methods/nucleotides.rb

@@ -1,787 +0,0 @@
-#!/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.can_base_pair_with?
-  #
-  # Usage example:
-  #
-  #   Bioroebe.can_base_pair_with?('A','T') # => true
-  #   Bioroebe.can_base_pair_with?('A','G') # => false
-  #
-  # ========================================================================= #
-  def self.can_base_pair_with?(a, b)
-    ::Bioroebe.partner_nucleotide(a) == b
-  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.contains_an_inverted_repeat?
-  #
-  # We assume an inverted repeat to exist if at the least 2 nucleotides
-  # match to one another in the reverse, so a total of 4 matching
-  # nucleotides. This assumption may not necessarily be correct and
-  # we may have to fine-tune this at a later time.
-  #
-  # For testing purpose, the sequence 'TTACGAAAAAACGTAA' can be used. 
-  # ========================================================================= #
-  def self.contains_an_inverted_repeat?(
-      #i = 'AGCCCCGCAAAAAAGGCGGGCU'
-      i = 'TTACGAAAAAACGTAA' # This is in the 5'→3' direction.
-    )
-    contains_an_inverted_repeat = false
-    longest_stretch = 0
-    current_stretch = 0
-    halfed_position = i.size / 2
-    both_sides = [
-      i[0 .. (halfed_position-1)],
-      i[halfed_position .. -1]
-    ]
-    # ======================================================================= #
-    # Now that we have both sides, we will try to match them. First reverse
-    # the second, though.
-    # ======================================================================= #
-    first  = both_sides[0]
-    second = both_sides[1].reverse # Work via the reverse sequence.
-    first.chars.each_with_index {|this_nucleotide, index|
-      if can_base_pair_with?(second[index], this_nucleotide)
-        current_stretch += 1
-        longest_stretch = current_stretch if current_stretch > longest_stretch 
-      else
-        current_stretch = 0
-      end
-    }
-    if longest_stretch >= 2
-      contains_an_inverted_repeat = true
-    end
-    return contains_an_inverted_repeat
-  end
-
-  # ========================================================================= #
-  # === 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.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"
-  #   Bioroebe.random_dna(20, 'ATGGGGGGGG') # => "TGAGGGGGGGGGTGGGAGGG"
-  #   Bioroebe.random_dna(20, 'ATGGGGGGGG') # => "GGTAGGGGGGGGTAGGGGGG"
-  #
-  # ========================================================================= #
-  def self.generate_random_dna_sequence(
-      i                                  = ARGV,
-      optional_hash_with_the_frequencies = {} # ← This may be a String too, mind you.
-    )
-    # ======================================================================= #
-    # First define our result-String. This one will be returned by this
-    # method.
-    # ======================================================================= #
-    result = ''.dup
-    _ = 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 # This is "n times".
-    # ======================================================================= #
-    # First handle the case where the user passed a String:
-    # ======================================================================= #
-    if optional_hash_with_the_frequencies.is_a? String
-      pool = optional_hash_with_the_frequencies.dup.chars.shuffle
-      i.times {
-        if pool.size == 0
-          pool = optional_hash_with_the_frequencies.dup.chars.shuffle
-        end
-        result << pool.pop
-      }
-    elsif 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