bioroebe 0.10.80

data/lib/bioroebe/codons/codons.rb

@@ -0,0 +1,517 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# This file will store codon-related activities.
+#
+# An example for such a codon-related activity is a codon-to-aminoacid
+# mapping, e. g. "ATG" becoming "Methionin".
+#
+# Different (default) start codons in use will also be handled by this
+# file, which is usually ATG by default. Some genes in some organisms
+# use another starting codon, though; this will be synced in the file
+# called codon_table.rb.
+# =========================================================================== #
+# require 'bioroebe/codons/codons.rb'
+# Bioroebe.is_this_a_valid_codon?
+# Bioroebe.deduce_most_likely_aminoacid_sequence_as_string('KKKA') # => "AAGAAGAAGGCC"
+# Bioroebe.return_the_most_likely_codon_sequence_for_this_aminoacid_sequence(ARGV)
+# Bioroebe.n_stop_codons_in_this_sequence?
+# Bioroebe.decode_this_aminoacid
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/constants/codon_tables.rb'
+  require 'bioroebe/regexes/regexes.rb'
+  require 'bioroebe/codons/codon_table.rb'
+  require 'bioroebe/codons/convert_this_codon_to_that_aminoacid.rb'
+
+  # ========================================================================= #
+  # === @stop_codons
+  #
+  # Must always be an Array.
+  #
+  # Initially it is empty on startup of the Bioroebe project; keep this
+  # in mind, as otherwise you may assume that an error may exist.
+  # ========================================================================= #
+  @stop_codons = []
+
+  # ========================================================================= #
+  # === Bioroebe.determine_stop_codons_from_the_codon_table
+  #
+  # This method will determine the stop codons in use for the given
+  # species/organism, depending on the proper codon table.
+  # ========================================================================= #
+  def self.determine_stop_codons_from_the_codon_table(
+      this_codon_table_dataset = @codon_table_dataset
+    )
+    this_codon_table_dataset = this_codon_table_dataset.select {|key, value|
+      value == '*' # '*' refers to a stop codon.
+    }
+    use_these_stop_codons = this_codon_table_dataset.keys
+    set_stop_codons(
+      use_these_stop_codons
+    )
+  end; self.instance_eval { alias determine_the_stop_codons determine_stop_codons_from_the_codon_table } # === ::Bioroebe.determine_the_stop_codons
+       self.instance_eval { alias initialize_stop_codons    determine_stop_codons_from_the_codon_table } # === Bioroebe.initialize_stop_codons
+
+  # ========================================================================= #
+  # === Bioroebe.determine_start_codons_from_the_codon_table
+  # ========================================================================= #
+  def self.determine_start_codons_from_the_codon_table(
+      this_codon_table_dataset = @codon_table_dataset
+    )
+    this_codon_table_dataset = this_codon_table_dataset.select {|key, value|
+      key == 'START' # '*' refers to a stop codon.
+    }
+    use_these_start_codons = this_codon_table_dataset.values
+    if use_these_start_codons.is_a? Array
+      use_these_start_codons = use_these_start_codons.first
+    end
+    set_start_codon(
+      use_these_start_codons
+    )
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.initialize_codons
+  #
+  # This method will first initialize the stop-codons, and then
+  # determine the start codons in use.
+  # ========================================================================= #
+  def self.initialize_codons
+    initialize_stop_codons
+    determine_start_codons_from_the_codon_table
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.scan_this_input_for_startcodons
+  #
+  # The first argument to this method should be the DNA sequence that you
+  # wish to scan for.
+  #
+  # The second input is optional - it should be the regex to apply in
+  # order to find all matches.
+  #
+  # The method will then return an Array that may look like this:
+  #
+  #   [[1, ["ATG"]], [12, ["ATG"]], [18, ["ATG"]]]
+  #
+  # So it starts at 1, rather than 0, as there is no nucleotide 0.
+  # ========================================================================= #
+  def self.scan_this_input_for_startcodons(
+      input,
+      regex = ::Bioroebe.regex_with_startcodons
+    )
+    if input.is_a? Array
+      input = input.first
+    end
+    array = []
+    # ======================================================================= #
+    # We will search for both ATG and AUG though, respectively what
+    # the above regex will return.
+    # ======================================================================= #
+    input.to_enum(:scan, regex).map { |match|
+      array << [$`.size + 1, match] # +1 because we refer to the nucleotide positions.
+    }
+    return array
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.n_stop_codons_in_this_sequence?
+  #
+  # This method will return how many stop codons have been found in the
+  # passed sequence (the argument to this method), as an integer number,
+  # such as 4 or 6 or 0.
+  #
+  # Note that by default, this method will NOT honour specific frames - so
+  # if you need a frame-aware method, such as frame1, frame2 or frame3, then
+  # you may have to use another method or check afterwards whether the
+  # stop codons can be in the correct frame. Or, an alterative, is to
+  # input a subsequence that already has the proper frame aligned with,
+  # e. g. if you drop the leading, or the first two, nucleotides, before
+  # calling this method here.
+  #
+  # The optional second argument for this method allows us to check only
+  # for a given frame, such as frame1, frame2 or frame3. frame1 specifies
+  # the default, as-is; frame2 means a shift of +1; frame3 means a shift
+  # of +2 (frame4 for a shift of +3 would again restore the original
+  # reading frame, so we can ignore all of these events that come past
+  # that, since the reading frame will remain the same).
+  #
+  # By default this is turned off, though.
+  # ========================================================================= #
+  def self.n_stop_codons_in_this_sequence?(
+      i                    = :default,
+      check_for_this_frame = nil
+    )
+    if i.is_a? Array
+      i = i.join(' ').strip
+    end
+    case i
+    when :default, nil
+      # i = 'ATGTAGCTAACTCAGGTTACATGGGGATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGAATGATCCGAGTAG'
+      i = 'ATGCCCGGGTGA'
+    end
+    n_stop_codons = 0
+    if @stop_codons.empty?
+      Bioroebe.set_use_this_codon_table(:default)
+    end
+    array_stop_codons = @stop_codons
+    if check_for_this_frame
+      # ===================================================================== #
+      # Check for the corresponding frame.
+      # ===================================================================== #
+      case check_for_this_frame
+      when :frame1
+        i =        i.scan(/.../).select {|entry| array_stop_codons.include? entry }
+      when :frame2
+        i = i[1..-1].scan(/.../).select {|entry| array_stop_codons.include? entry }
+      when :frame3
+        i = i[2..-1].scan(/.../).select {|entry| array_stop_codons.include? entry }
+      end
+      n_stop_codons += i.size
+    else
+      # ===================================================================== #
+      # If we do not have to care about frames then we can just do a direct
+      # counting.
+      # ===================================================================== #
+      array_stop_codons.each {|this_stop_codon|
+        scanned = i.scan(/#{this_stop_codon}/)
+        n_stop_codons += scanned.size
+      }
+    end
+    n_stop_codons
+  end; self.instance_eval { alias return_n_stop_codons_in_this_sequence n_stop_codons_in_this_sequence? } # === Bioroebe.return_n_stop_codons_in_this_sequence
+       self.instance_eval { alias n_stop_codons_in_this_sequence        n_stop_codons_in_this_sequence? } # === Bioroebe.n_stop_codons_in_this_sequence
+       self.instance_eval { alias n_stop_codons                         n_stop_codons_in_this_sequence? } # === Bioroebe.n_stop_codons
+
+  # ========================================================================= #
+  # === Bioroebe.stop_codons?
+  #
+  # This method will return the three regular stop codons that can be
+  # "found" in DNA.
+  #
+  # Usually, the Stop Codons will be saved in DNA-form simply because
+  # the yaml files that keep the codon tables also use DNA.
+  #
+  # This method will return the Stop Codons that are valid for the
+  # respective organism at hand (if you selected the right codon
+  # table before).
+  #
+  # The default codon table in use will be for humans (mammals rather),
+  # which is valid for most eukaryotes as well.
+  # ========================================================================= #
+  def self.stop_codons?
+    @stop_codons
+  end; self.instance_eval { alias stop_codons     stop_codons? } # === Bioroebe.stop_codons
+       self.instance_eval { alias dna_stop_codons stop_codons? } # === Bioroebe.dna_stop_codons
+
+  # ========================================================================= #
+  # === Bioroebe.is_a_stop_codon?
+  #
+  # This method will return true if the given input to this method (== codon)
+  # is a stop codon in the currently selected codon table, otherwise it
+  # will return false.
+  #
+  # Returns:
+  #
+  #   - true if the given input is a stop codon
+  #   - false otherwise
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.is_a_stop_codon? 'TAG'
+  #   Bioroebe.stop_codon? 'TAG'
+  #
+  # ========================================================================= #
+  def self.is_a_stop_codon?(i)
+    @stop_codons.include?(i.upcase)
+  end; self.instance_eval { alias stop_codon? is_a_stop_codon? } # === Bioroebe.stop_codon?
+
+  # ========================================================================= #
+  # === Bioroebe.initialize_default_stop_codons
+  #
+  # This method will initialize the default stop codons. This defaults to
+  # e. g. the stop codons that can be found in the human genome.
+  #
+  # Note that this method will NOT work if @stop_codons already contains
+  # elements; this is a tiny "safeguard" to prevent erroneous use. If
+  # you wish to not be handicapped then clear it by yourself first,
+  # via:
+  #
+  #   Bioroebe.clear_stop_codons
+  #
+  # ========================================================================= #
+  def self.initialize_default_stop_codons
+    if @stop_codons.empty?
+      @stop_codons << %w( TAG TAA TGA ) # <- Add the default stop codons here.
+      @stop_codons.flatten! 
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.clear_stop_codons
+  # ========================================================================= #
+  def self.clear_stop_codons
+    @stop_codons = []
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.set_stop_codons
+  # ========================================================================= #
+  def self.set_stop_codons(*i)
+    i = [i].flatten.compact
+    @stop_codons = i
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.this_aminoacid_has_n_codons
+  #
+  # This method must return a Number at all times, either 0, or any other
+  # positive number. 0 will be returned if the aminoacid at hand does
+  # not exist as well, so it should be ensure that the aminoacid
+  # exists.
+  #
+  # Otherwise the number will be a positive integer, showing how many
+  # codons this aminoacid has.
+  #
+  # Since 22.03.2020 the method will also honour the specified codon-table.
+  # ========================================================================= #
+  def self.this_aminoacid_has_n_codons(i)
+    if i.is_a? Array
+      i.map {|entry| this_aminoacid_has_n_codons(entry) }.sum # Recursive call.
+    else
+      result = 0
+      array = codons_for_this_aminoacid?(i)
+      result += array.size if array
+      return result
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.codons_for_this_aminoacid?
+  #
+  # This method will return all possible DNA codons for a specific
+  # aminoacid, as an Array.
+  #
+  # So for example, for the aminoacid serine, this method would return
+  # an Array containing all 6 codons that code for this aminoacid (if
+  # the eukaryotic codon table is used, which also includes humans).
+  #
+  # This method supports to query only ONE aminoacid at a given time.
+  #
+  # Currently the method relies on the file called
+  # "codons_of_the_aminoacids.yml". In the future, the method here will
+  # probably be changed to add support for different codon tables.
+  #
+  # Specific invocation examples:
+  #
+  #   Bioroebe.codons_for?(:serine)
+  #   Bioroebe.codons_for?(:tyrosine)
+  #   Bioroebe.codons_for?(:threonine)
+  #   Bioroebe.codons_for?('T')
+  #
+  # To test this for another organism, try:
+  #
+  #   Bioroebe.use_this_codon_table(:yeast_mitochondria)
+  #   Bioroebe.codons_for?('T')
+  #   Bioroebe.decode_this_aminoacid 'K' # => ["AAA", "AAG"]
+  #
+  # ========================================================================= #
+  def self.codons_for_this_aminoacid?(
+      i = ARGV
+    )
+    # ======================================================================= #
+    # First, convert the input a bit and sanitize it.
+    # ======================================================================= #
+    i = i.first if i.is_a? Array
+    if i.is_a?(String) and i.start_with?(':')
+      i = i.delete(':').to_sym
+    end
+    case i # case tag
+    when :default,
+         nil
+      i = :lysine
+    end
+    if i.is_a? Symbol
+      # ===================================================================== #
+      # === Convert e. g. :serine into 'ser'
+      # ===================================================================== #
+      _ = i.to_s.downcase[0 .. 2]
+      i = AMINO_ACIDS_THREE_TO_ONE[_]
+    end
+    # ======================================================================= #
+    # Next we must use the one-letter abbreviation, and then find all
+    # entries that match to the given input at hand.
+    #
+    # @codon_table_dataset is a Hash and will have these key->value
+    # entries:
+    #
+    #   "TTC" => "F"
+    #
+    # ======================================================================= #
+    result = @codon_table_dataset.select {|key, value|
+      value == i
+    }
+    return result.keys
+  end; self.instance_eval { alias codons_for?                    codons_for_this_aminoacid? } # === Bioroebe.codons_for?
+       self.instance_eval { alias codon_for?                     codons_for_this_aminoacid? } # === Bioroebe.codon_for?
+       self.instance_eval { alias codons_for_this_aminoacid      codons_for_this_aminoacid? } # === Bioroebe.codons_for_this_aminoacid
+       self.instance_eval { alias decode_this_aminoacid          codons_for_this_aminoacid? } # === Bioroebe.decode_this_aminoacid
+       self.instance_eval { alias decode_this_aminoacid_sequence codons_for_this_aminoacid? } # === Bioroebe.decode_this_aminoacid_sequence
+       self.instance_eval { alias nucleotides_to_aminoacid       codons_for_this_aminoacid? } # === Bioroebe.nucleotides_to_aminoacid
+
+  require 'bioroebe/toplevel_methods/aminoacids_and_proteins.rb'
+  # ========================================================================= #
+  # === Bioroebe.decode_this_aminoacid_sequence
+  #
+  # This method can be used as means to decode an aminoacid sequence,
+  # such as a String like 'KKKA'.
+  #
+  # The input to this method may also be in the form of an Array, such as
+  # ['K','K','K','A']. Only valid one-letter aminoacids will be honoured
+  # by this method; invalid letters will be silently dropped.
+  #
+  # After that, this method will replace all valid letters, that is
+  # valid aminoacids (in single letter code), with the corresponding
+  # codon. It will return all possibilities.
+  #
+  # Invocation example:
+  #
+  #   Bioroebe.decode_this_aminoacid_sequence('KKKA') # => [["AAG", "AAA"], ["AAG", "AAA"], ["AAG", "AAA"], ["GCT", "GCC", "GCA", "GCG"]]
+  #
+  # ========================================================================= #
+  def self.decode_this_aminoacid_sequence(
+      i = 'KKKA'
+    )
+    if i.is_a? Array
+      i = i.join
+    end
+    if i.is_a? String
+      # ===================================================================== #
+      # We may have a 3-letter code too, so check for that first.
+      # ===================================================================== #
+      if i.include? '-'
+        i = i.split('-').map {|entry| ::Bioroebe.three_to_one(entry) }
+      else
+        i = i.split(//)
+      end
+    end
+    i = [i].flatten.map {|entry|
+      ::Bioroebe.decode_this_aminoacid(entry)
+    }
+    return i
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.return_random_codon_sequence_for_this_aminoacid_sequence
+  #
+  # This method will return a random linear codon sequence, as an Array,
+  # for the given input aminoacid sequence.
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.return_random_codon_sequence_for_this_aminoacid_sequence('KKKA') # => ["AAA", "AAA", "AAA", "GCG"]
+  #   Bioroebe.return_random_codon_sequence_for_this_aminoacid_sequence('KKKA') # => ["AAA", "AAA", "AAG", "GCC"]
+  #
+  # ========================================================================= #
+  def self.return_random_codon_sequence_for_this_aminoacid_sequence(i = 'KKKA')
+    _ = decode_this_aminoacid_sequence(i)
+    _.map {|array|
+      sample = array.sample
+      sample
+    }
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.is_this_a_valid_codon?
+  #
+  # Invocation examples:
+  #
+  #   Bioroebe.is_this_a_valid_codon?('UUU') # => true
+  #   Bioroebe.is_this_a_valid_codon?('UUS') # => false
+  #
+  # ========================================================================= #
+  def self.is_this_a_valid_codon?(i)
+    conversion_result = Bioroebe.codon_to_aminoacid(i)
+    !conversion_result.empty?
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.deduce_most_likely_aminoacid_sequence_as_string
+  #
+  # This method will attempt to deduce the most likely aminoacid
+  # sequence for a given protein, as a String.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.deduce_most_likely_aminoacid_sequence_as_string('KKKA') # => "AAGAAGAAGGCC"
+  #
+  # ========================================================================= #
+  def self.deduce_most_likely_aminoacid_sequence_as_string(
+      i, use_this_codon_tables_frequencies = :default
+    )
+    result = return_the_most_likely_codon_sequence_for_this_aminoacid_sequence(
+      i, 
+      use_this_codon_tables_frequencies
+    )
+    result = result.join if result.is_a? Array
+    return result
+  end; self.instance_eval { alias return_the_most_likely_codon_sequence_for_this_aminoacid_sequence_as_string deduce_most_likely_aminoacid_sequence_as_string } # === Bioroebe.return_the_most_likely_codon_sequence_for_this_aminoacid_sequence_as_string
+
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  require 'colours/autoinclude'
+  require 'bioroebe/nucleotides/show_nucleotide_sequence.rb'
+  puts Bioroebe.is_a_stop_codon? 'TAG'
+  Bioroebe.initialize_codons
+  puts Bioroebe.is_a_stop_codon? 'TAG'
+  Bioroebe.determine_stop_codons_from_the_codon_table
+  pp Bioroebe.stop_codons?
+  Bioroebe.set_use_this_codon_table(:bacteria)
+  Bioroebe.determine_stop_codons_from_the_codon_table
+  pp Bioroebe.stop_codons?
+  Bioroebe.set_use_this_codon_table(:blepharisma_macronuclear)
+  Bioroebe.determine_stop_codons_from_the_codon_table
+  pp Bioroebe.stop_codons?
+  # Next test codons_for_this_aminoacid?() functionality.
+  result = Bioroebe.codons_for_this_aminoacid?(ARGV)
+  if result
+    e
+    e 'This aminoacid has the following codons:'
+    e
+    print '  '
+    pp result
+    e
+  end
+  e "Let's see how many codons this amino acid has:\n\n"
+  e "  #{Bioroebe.this_aminoacid_has_n_codons(ARGV)}"
+  e
+  # e Bioroebe.this_aminoacid_has_n_codons 'M'
+  # e Bioroebe.this_aminoacid_has_n_codons 'R'
+  sequence = 'ATGCCCGGGTGA'
+  unless ARGV.empty?
+    sequence = ARGV.first
+  end
+  e 'Testing this sequence:'
+  e
+  e Bioroebe.colourize_this_sequence(sequence)
+  e
+  pp Bioroebe.n_stop_codons_in_this_sequence? sequence
+  e
+  e 'Next testing '+
+    Colours.orange('frame1')+
+    ', '+
+    Colours.orange('frame2')+
+    ', and '+
+    Colours.orange('frame3')+':'
+  e
+  pp Bioroebe.n_stop_codons_in_this_sequence? sequence, :frame1
+  pp Bioroebe.n_stop_codons_in_this_sequence? sequence, :frame2
+  pp Bioroebe.n_stop_codons_in_this_sequence? sequence, :frame3
+end # nstop
+    # nstop AGCCATGTAGCTAACTCAGGTTACATGGGGATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGAATGATCCGAGTAGCATCTCAG
+    # codonsforthisaminoacid :serine

data/lib/bioroebe/codons/convert_this_codon_to_that_aminoacid.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/codons/convert_this_codon_to_that_aminoacid.rb'
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/codons/codon_table.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.convert_this_codon_to_that_aminoacid
+  #
+  # This method can be used to convert a particular codon, such as 'ATG',
+  # into the corresponding aminoacid, in this case being 'M' for
+  # Methionin. A String will be returned by this method.
+  #
+  # The characters in that String will correspond to the one-letter
+  # format of aminoacids, such as the example shown above 'M' for
+  # Methionin.
+  #
+  # The method has to handle invalid input arguments as well, to some
+  # extent.
+  #
+  # The method supports both DNA and mRNA as "input".
+  #
+  # In order for the method to do its job properly, the method will
+  # make use of the codon table stored in:
+  #
+  #   Bioroebe.aa_to_rna_codon_table
+  #
+  # Also note that this method can easily be used to translate
+  # other frames - simply provide the proper input to it.
+  #
+  # Note that this method will return the result - it will NOT 
+  # output the result.
+  #
+  # Usage examples:
+  #
+  #   puts Bioroebe.codon_to_aminoacid('ATG') # => "M"
+  #   puts Bioroebe.codon_to_aminoacid('GUG') # => "V"
+  #   puts Bioroebe.decode_this_codon('CCG')  # => "P"
+  #   puts Bioroebe.codon_to_aminoacid('GUGGUG') # => "VV"
+  #   puts Bioroebe.codon_to_aminoacid('ATGA') # => "M"
+  #   puts Bioroebe.convert_dna_to_protein_sequence('ATGA') # => "M"
+  #   puts Bioroebe.convert_this_codon_to_that_aminoacid('ATGA') # => "M"
+  #
+  # ========================================================================= #
+  def self.convert_this_codon_to_that_aminoacid(
+      i                            = ARGV,
+      shall_we_replace_stop_codons = :default,
+      use_this_codon_table         = codon_table_dataset?.dup
+    )
+    case shall_we_replace_stop_codons
+    when :default
+      shall_we_replace_stop_codons = true
+    end
+    if i.is_a? Array
+      i = i.join
+    end
+    i = i.to_s.dup
+    i.upcase!
+    i.tr!('U','T') # We need DNA here, so U becomes T.
+    # ======================================================================= #
+    # Obtain the dataset from the correct codon_table next.
+    # ======================================================================= #
+    scanned = i.scan(/.../)
+    scanned.map! {|potential_codon|
+      if use_this_codon_table.has_key? potential_codon
+        potential_codon = use_this_codon_table[potential_codon]
+      end
+      # ===================================================================== #
+      # Get rid of stop codons. This works because 'O' is not
+      # a valid aminoacid.
+      # ===================================================================== #
+      if potential_codon.include? 'STOP'
+        potential_codon.gsub!(/STOP/, '*') if shall_we_replace_stop_codons
+      end
+      potential_codon
+    }
+    result = scanned
+    result = result.join if result.is_a? Array
+    return result
+  end; self.instance_eval { alias decode_this_codon               convert_this_codon_to_that_aminoacid } # === Bioroebe.decode_this_codon
+       self.instance_eval { alias convert_dna_to_protein_sequence convert_this_codon_to_that_aminoacid } # === Bioroebe.convert_dna_to_protein_sequence
+       self.instance_eval { alias translate_dna_into_aminoacid    convert_this_codon_to_that_aminoacid } # === Bioroebe.translate_dna_into_aminoacid
+       self.instance_eval { alias dna_to_aa                       convert_this_codon_to_that_aminoacid } # === Bioroebe.dna_to_aa
+       self.instance_eval { alias codon_to_aminoacid              convert_this_codon_to_that_aminoacid } # === Bioroebe.codon_to_aminoacid
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  alias e puts
+  # pp Bioroebe.convert_this_codon_to_that_aminoacid(ARGV)
+  # pp Bioroebe.convert_this_codon_to_that_aminoacid(ARGV)
+  e 'GUGGUG → '+Bioroebe.codon_to_aminoacid('GUGGUG') # => "VV"
+  e 'ATG → '+Bioroebe.codon_to_aminoacid('ATG') # => "M"
+  e 'GUG → '+Bioroebe.codon_to_aminoacid('GUG') # => "V"
+  e 'CCG → '+Bioroebe.decode_this_codon('CCG')  # => "P"
+  e 'ATGA → '+Bioroebe.codon_to_aminoacid('ATGA') # => "M"
+  e 'ATGA → '+Bioroebe.convert_dna_to_protein_sequence('ATGA') # => "M"
+end # $RUBY_SRC/bioroebe/lib/bioroebe/codons/convert_this_codon_to_that_aminoacid.rb