bioroebe 0.10.80

data/lib/bioroebe/toplevel_methods/aminoacids_and_proteins.rb

@@ -0,0 +1,715 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/aminoacids_and_proteins.rb'
+# puts Bioroebe.colourize_this_aminoacid_sequence_for_the_commandline('NLKRSPTHY')
+# Bioroebe.upcase_this_aminoacid_sequence_and_remove_numbers
+# Bioroebe.parse_this_prosite_pattern
+# Bioroebe.weight_of_this_aminoacid?
+# Bioroebe.strict_filter_away_invalid_aminoacids(ARGV)
+# Bioroebe.three_to_one(ARGV)
+# Bioroebe.return_short_aminoacid_letter_from_long_aminoacid_name('lysine') # => "K"
+# Bioroebe.return_the_most_likely_codon_sequence_for_this_aminoacid_sequence
+# Bioroebe.sort_aminoacid_based_on_its_hydrophobicity(ARGV)
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/toplevel_methods/e.rb'
+  require 'bioroebe/constants/files_and_directories.rb'
+  require 'bioroebe/colours/colours.rb'
+  require 'bioroebe/requires/require_yaml.rb'
+
+  # ========================================================================= #
+  # === @array_colourize_this_aminoacid
+  #
+  # These aminoacids must be colourized in red.
+  # ========================================================================= #
+  @array_colourize_this_aminoacid = []
+
+  # ========================================================================= #
+  # === Bioroebe.clear_array_colourize_this_aminoacid
+  # ========================================================================= #
+  def self.clear_array_colourize_this_aminoacid
+    @array_colourize_this_aminoacid = []
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.array_colourize_this_aminoacid
+  #
+  # Query as to which aminoacid we will colourize, if any at all.
+  # ========================================================================= #
+  def self.array_colourize_this_aminoacid
+    @array_colourize_this_aminoacid
+  end; self.instance_eval { alias array_colourize_this_aminoacid? array_colourize_this_aminoacid } # === Bioroebe.array_colourize_this_aminoacid?
+
+  # ========================================================================= #
+  # === Bioroebe.three_to_one
+  #
+  # This method will convert from e. g. "THR" to "T" - aka the one-letter
+  # abbreviation for the aminoacid threonine.
+  #
+  # That way this method acts as the sister method to the other method
+  # that gives us three letters from ONE letter, sort of. Taken together,
+  # these two methods form a corresponding dual-pair there, yin/yang,
+  # from 3-to-1 and from 1-to-3.
+  #
+  # Behaviour of this method:
+  #
+  #   This method will translate "Lys" into "L", and the other
+  #   corresponding aminoacids into their one-letter abbreviation.
+  #
+  # The input to this method should be a String.
+  #
+  # The output will not contain any '-' character by default, even if
+  # the input came with '-' characters. The reason why this is the
+  # default is because the most common use cases may wish to continue
+  # to work with the one-letter abbreviation instead, which is much
+  # more common than the three-letter abbreviation.
+  # ========================================================================= #
+  def self.three_to_one(i)
+    _ = ''.dup
+    if i
+      if i.is_a? Array
+        i = i.join
+      end
+      if i =~ /gui/i
+        require 'bioroebe/gui/gtk3/three_to_one/three_to_one.rb'
+        Bioroebe::GUI::Gtk::ThreeToOne.run # three_to_one --gui
+        return
+      end
+      if i.include? '-'
+        i = i.dup if i.frozen?
+        i.delete!('-')
+      end
+      dataset = AMINO_ACIDS_THREE_TO_ONE
+      # ===================================================================== #
+      # The table keeps the members in a downcase variant, hence why we
+      # also apply .downcase next. The above dataset will keep the hash
+      # keys in a downcased variant as-is.
+      # ===================================================================== #
+      scanned = i.scan(/.../).map(&:downcase)
+      scanned.each {|key|
+        if dataset.has_key? key
+          match = dataset[key]
+          _ << match
+        end
+      }
+    end
+    return _
+  end; self.instance_eval { alias three_letters_to_one_letter three_to_one } # === Bioroebe.three_letters_to_one_letter
+
+  # ========================================================================= #
+  # === Bioroebe.colourize_this_aminoacid_sequence_for_the_commandline
+  #
+  # This method uses some hardcoded colour assignments to the 20
+  # different aminoacids.
+  #
+  # Usage example:
+  #
+  #   puts Bioroebe.colourize_this_aminoacid_sequence_for_the_commandline('NLKRSPTHY')
+  #
+  # ========================================================================= #
+  def self.colourize_this_aminoacid_sequence_for_the_commandline(i)
+    if i.is_a? Array
+      i = i.join
+    end
+    dataset = YAML.load_file(FILE_DEFAULT_COLOURS_FOR_THE_AMINOACIDS)
+    array_of_allowed_aminoacids = %w( A R N D B C E Q Z G H I L K M F P S T W Y V )
+    _ = ''.dup
+    splitted = i.chars
+    splitted.each {|this_aminoacid|
+      case this_aminoacid
+      when *array_of_allowed_aminoacids
+        this_aminoacid = send(dataset[this_aminoacid.to_s], this_aminoacid)
+      # else # else it will not be colourized.
+      end
+      _ << this_aminoacid
+    }
+    return _
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.remove_invalid_aminoacids
+  #
+  # This method will filter away invalid aminoacids such as "U".
+  # "U" is not a valid aminoacid.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.remove_invalid_aminoacids('LKLSUSURZZZ')
+  #
+  # ========================================================================= #
+  def self.remove_invalid_aminoacids(from_this_string)
+    if from_this_string.is_a? Array
+      from_this_string = from_this_string.first
+    end
+    all_valid_aminoacids = YAML.load_file(Bioroebe.file_amino_acids).keys
+    new_result = ''.dup
+    from_this_string.chars.each {|entry|
+      new_result << entry if all_valid_aminoacids.include?(entry)
+    }
+    return new_result
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.colourize_aa
+  #
+  # Use this method if you wish to colourize an aminoacid, in a red colour.
+  #
+  # The input should be the specific aminoacid sequence in question
+  # that you wish to see being colourized here.
+  #
+  # This currently only works for aminoacids, and only in red. Perhaps
+  # at a later time it will become more flexible, but for now, it will
+  # be exclusive for aminoacids alone.
+  #
+  # Usage example:
+  #
+  #   puts Bioroebe.colourize_aa 'STGYGGCTR', 'S T Y'
+  #
+  # ========================================================================= #
+  def self.colourize_aa(
+      i,
+      array_colourize_these_aminoacids = array_colourize_this_aminoacid?
+    )
+    if array_colourize_these_aminoacids.is_a? String
+      array_colourize_these_aminoacids = array_colourize_these_aminoacids.split(' ') # Split it into an Array.
+    end
+    unless array_colourize_these_aminoacids.empty?
+      if i.nil?
+        puts 'You first have to assign a sequence.'
+      else
+        if i.chars.any? {|entry| array_colourize_these_aminoacids.include? entry }
+          # =================================================================== #
+          # Ok, we have established a need to colourize the result.
+          # =================================================================== #
+          array_colourize_these_aminoacids.each {|colour|
+            i.gsub!(/(#{colour})/, swarn('\\1')+rev)
+          }
+        end
+      end
+    end if use_colours? # But only if we use colours.
+    return i
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.upcase_this_aminoacid_sequence_and_remove_numbers
+  #
+  # This method can be used to remove numbers, upcase all entries
+  # and delete all ' ' characters and newlines. It is mostly a
+  # "sanitize" method.
+  #
+  # Invocation example:
+  #
+  #   Bioroebe.upcase_this_aminoacid_sequence_and_remove_numbers # => "MSASASA" (etc..)
+  #
+  # ========================================================================= #
+  def self.upcase_this_aminoacid_sequence_and_remove_numbers(
+      i = '1 msasasacdc lvgvptgptl astcggsafm lfmgllevfi rsqcdledpc grassrfrse
+          61 pdyeydfivi gggsagsvva srlsevpqwk vllieaggde pvgaqipsmf lnfigsdidy'
+    )
+    if i.is_a? Array
+      i = i.join(' ').strip
+    end
+    i = i.dup if i.frozen?
+    i = i.delete(' ').delete("\n").gsub(/\d+/,'').strip.upcase
+    e i
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.convert_one_letter_to_full
+  #
+  # Convert one aminoacid to the real name.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.convert_one_letter_to_full('T') # => "threonine"
+  #
+  # ========================================================================= #
+  def self.convert_one_letter_to_full(i)
+    if i.is_a? Array
+      i.each {|entry| convert_one_letter_to_full(entry) }
+    else
+      i = i.to_s.downcase # need it to be downcased.
+      three_letters = convert_one_letter_to_three(i)
+      i = AMINO_ACIDS_ABBREVIATIONS[three_letters]
+      return i
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.amino_acid_average_mass
+  #
+  # The input to this method should be in the form of the one-letter
+  # code for aminoacids. Several aminoacids can be input, of course,
+  # such as 'AGL'.
+  #
+  # Do note that since as of March 2020 a float will be returned by
+  # this method, if the input was found to be a valid aminoacid.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.amino_acid_average_mass('F') # => "147.17660"
+  #
+  # ========================================================================= #
+  def self.amino_acid_average_mass(i)
+    use_this_table = AMINO_ACIDS_AVERAGE_MASS_TABLE
+    i = i.split(//) if i.is_a? String
+    i = [i] unless i.is_a? Array
+    result = i.map {|entry|
+      entry = use_this_table[entry].to_f
+    }
+    return ('%.5f' % result.sum).to_f # ← This is our properly formatted result.
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.amino_acid_monoisotopic_mass
+  #
+  # We require the monoisotopic table for this method, and return the
+  # corresponding match to the given aminoacid.
+  #
+  # The input format should be in the one-letter aminoacid abbreviation.
+  #
+  # Invocation example:
+  #
+  #   Bioroebe.amino_acid_monoisotopic_mass 'L' # => 113.08406
+  #   Bioroebe.amino_acid_monoisotopic_mass 'K' # => 128.09496
+  #
+  # ========================================================================= #
+  def self.amino_acid_monoisotopic_mass(this_aminoacid)
+    use_this_table = AMINO_ACIDS_AVERAGE_MONOISOTOPIC_TABLE
+    # '%.5f' % use_this_table[this_aminoacid].to_f
+    use_this_table[this_aminoacid].to_f
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.return_long_aminoacid_name
+  #
+  # Use this method to translate a one-letter aminoacid to the long name
+  # of the given aminoacid.
+  #
+  # We also have to consider Stop-Codons as input.
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.return_long_aminoacid_name 'M' # => "Methionin"
+  #   Bioroebe.return_long_aminoacid_name 'T' # => "Threonine"
+  #
+  # ========================================================================= #
+  def self.return_long_aminoacid_name(
+      short_name_of_the_aminoacid
+    )
+    aminoacid = AMINO_ACIDS_ENGLISH[short_name_of_the_aminoacid].dup
+    if aminoacid
+      aminoacid = aminoacid.select {|key,value|
+        key.size == 3
+      }.flatten[1]
+    else
+      aminoacid = short_name_of_the_aminoacid
+      aminoacid = 'Translation Stop' if aminoacid == '*'
+    end unless aminoacid.is_a? String
+    return aminoacid
+  end; self.instance_eval {
+    alias return_long_name_of_this_aminoacid return_long_aminoacid_name
+  } # === Bioroebe.return_long_name_of_this_aminoacid
+
+  # ========================================================================= #
+  # === Bioroebe.sort_aminoacid_based_on_its_hydrophobicity
+  #
+  # This method can sort aminoacids based on their hydrophobicity.
+  #
+  # The input to this method MUST happen in the form of the one-aminoacid
+  # letter code, as the input will be upcased, as-is.
+  #
+  # The preferred input "type" should be a String.
+  #
+  # The output of this method will be a String, such as 'D < F < P'
+  # or something similar. This output is then already sorted by
+  # hydrophobicity, e. g. D being not as hydrophobic as F, and
+  # so forth.
+  #
+  # This method was created primarily because of a Rosalind challenge,
+  # but the functionality seems sufficiently useful to retain in
+  # general, as it may be useful for other code elements.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.sort_aminoacid_based_on_its_hydrophobicity('TAMS')
+  #   Bioroebe.sort_aminoacid_based_on_its_hydrophobicity('TAMS') # => T < G < A
+  #
+  # ========================================================================= #
+  def self.sort_aminoacid_based_on_its_hydrophobicity(
+      i = 'FDMS'
+    )
+    dataset_from_the_hydropathy_table_file = YAML.load_file(
+      FILE_HYDROPATHY_TABLE
+    )
+    i = i.first if i.is_a? Array
+    i = 'FDMS' if i.nil?
+    i = i.chars.uniq # Obtain the characters.
+    hash = {}
+    i.each {|entry|
+      # ===================================================================== #
+      # Find the entry in our main dataset next.
+      # ===================================================================== #
+      hash[entry] = dataset_from_the_hydropathy_table_file[entry]
+    }
+    sorted_hash = hash.sort_by {|key, hydrophobicity_value|
+      hydrophobicity_value
+    }
+    # ======================================================================= #
+    # We will return a String as a result.
+    # ======================================================================= #
+    result = ''.dup
+    sorted_hash.each {|a,b|
+      result << "#{a} < "
+    }
+    result.strip!
+    result.chop! if result.end_with? '<'
+    result.strip!
+    return result
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.is_an_aminoacid?
+  #
+  # This method will return either true or false, depending on whether the
+  # given input is an Aminoacid or whether it is not.
+  #
+  # Currently this requires the long letter, but it should be no problem
+  # to also check or one-letter key codes.
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.is_aminoacid? 'Tryptophane' # => true
+  #   Bioroebe.is_aminoacid? 'Glycine'
+  #   Bioroebe.is_aminoacid? 'lysine'      # => true
+  #   Bioroebe.is_aminoacid? 'GB'
+  #
+  # ========================================================================= #
+  def self.is_an_aminoacid?(i)
+    i = i.first if i.is_a? Array
+    i = i.dup if i.frozen?
+    if i
+      i.downcase!
+      return_value = false
+      keys = AMINO_ACIDS_RESTE.keys
+      return_value = true if keys.include? i
+      return return_value
+    else
+      e 'Something went wrong in the method Bioroebe.is_an_aminoacid?() - '\
+        'nil was passed.'
+      e 'caller() was:'
+      e
+      pp caller
+      e
+    end
+  end; self.instance_eval { alias is_aminoacid? is_an_aminoacid? } # === Bioroebe.is_aminoacid?
+
+  # ========================================================================= #
+  # === Bioroebe.parse_this_prosite_pattern
+  #
+  # Usage example:
+  #
+  #   Bioroebe.parse_this_prosite_pattern('[GSTNE]-[GSTQCR]-[FYW]-{ANW}-x(2)-P') # => "EGFIWQP"
+  #
+  # ========================================================================= #
+  def self.parse_this_prosite_pattern(
+      i = '[GSTNE]-[GSTQCR]-[FYW]-{ANW}-x(2)-P'
+    )
+    i = i.first if i.is_a? Array
+    if i.include? '-'
+      splitted = i.split('-')
+      return splitted.map {|entry|
+        return_random_aminoacid_from_this_prosite_pattern(entry)
+      }.join
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.return_random_aminoacid_from_this_prosite_pattern
+  #
+  # If no match was found, the original input will be returned.
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.return_random_aminoacid_from_this_prosite_pattern()
+  #   Bioroebe.return_random_aminoacid_from_this_prosite_pattern('[GSTNE]')
+  #   Bioroebe.return_random_aminoacid_from_this_prosite_pattern('{ANW}')
+  #   Bioroebe.return_random_aminoacid_from_this_prosite_pattern('x(2)')
+  #
+  # ========================================================================= #
+  def self.return_random_aminoacid_from_this_prosite_pattern(i)
+    if i.include?('(') and i.include?(')') and i.include?('x')
+      n_aminoacids = i.scan(REGEX_PROSITE_FOR_ANY_AMINOACID).flatten.first.to_i
+      result = n_aminoacids.times.map { return_random_aminoacid }.join
+      return result
+    end
+    if i.include?('[') and i.include?(']')
+      splitted = i.delete('[]').split(//)
+      return splitted.sample
+    end
+    if i.include?('{') and i.include?('}')
+      # ===================================================================== #
+      # In this case we will return a random aminoacid
+      # without any of the specified aminoacids.
+      # ===================================================================== #
+      forbidden_aminoacids = i.delete('{}').split(//)
+      all_aminoacids = Bioroebe.aminoacids?.keys
+      filtered_aminoacids = all_aminoacids.reject {|this_aminoacid|
+        forbidden_aminoacids.include? this_aminoacid
+      }
+      return filtered_aminoacids.sample
+    end
+    return i # Return the original input in this case.
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.strict_filter_away_invalid_aminoacids
+  #
+  # This method, named `Bioroebe.strict_filter_away_invalid_aminoacids()`,
+  # is a strict filter for aminoacids. That is, if an invalid aminoacid
+  # is passed to this method, that aminoacid will simply be discarded.
+  #
+  # Only 20 aminoacids are valid, in regards to this filter here - the
+  # canonical aminoacids.
+  #
+  # The following behaviour is valid for this method:
+  #
+  # - Any String passed into this method will be converted to an Array.
+  #
+  # - Any Array passed into this method will be turned into an Array"
+  #   of Strings" if it contains at the least one String.
+  #
+  # Note that this method will return an Array as a result. This
+  # Array will retain only valid aminoacids (e. g. from the 20
+  # that are possible).
+  #
+  # Usage example:
+  #
+  #   Bioroebe.strict_filter_away_invalid_aminoacids('ABCDEFGHIJKLMNOPQRSTUVWXYZ') # => 'ACDEFGHIKLMNOPQRSTUVWY'
+  #
+  # ========================================================================= #
+  def self.strict_filter_away_invalid_aminoacids(
+      i = :default
+    )
+    case i
+    when :default
+      # Assign a default in this case.
+      i = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    # In the past, the above entry also handled nil, '',
+    # but I realized that this makes no sense, so it was
+    # disabled as of 06.12.2020.
+    end
+    if i.is_a? String
+      i = i.chars
+    elsif i.is_a?(Array) and i.first.is_a?(String)
+      i = i.first.chars
+    end
+    # ======================================================================= #
+    # We should now have an Array, hopefully. Next we can apply a filter on
+    # that Array.
+    # ======================================================================= #
+    valid_aminoacids = AMINO_ACIDS.keys
+    i.select! {|this_aminoacid|
+      valid_aminoacids.include? this_aminoacid
+    }
+    if i.is_a? Array
+      i = i.join
+    end
+    i
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.convert_one_letter_to_three
+  #
+  # Convert a one-letter-code for an aminoacid into the slightly longer
+  # three-letter-code variant for that particular aminoacid.
+  #
+  # Note that this method will return the result in a downcased variant,
+  # such as "gly" for "glycine".
+  #
+  # Returns:
+  #
+  #   A string of three characters, if it is a valid one-letter aminoacid.
+  #
+  # Usage example for an aminoacid such as Glycine:
+  #
+  #   Bioroebe.convert_one_letter_to_three('G') # => "gly"
+  #
+  # ========================================================================= #
+  def self.convert_one_letter_to_three(i)
+    AMINO_ACIDS_THREE_TO_ONE.invert[i.upcase]
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.return_short_aminoacid_letter_from_long_aminoacid_name
+  #
+  # This will turn input such as "lysine" into "K".
+  #
+  # Invocation example:
+  #
+  #   Bioroebe.return_short_aminoacid_letter_from_long_aminoacid_name('lysine') # => "K"
+  #
+  # Commandline invocation example:
+  #
+  #   short_aminoacid_letter_from_long_aminoacid_name lysine
+  #
+  # ========================================================================= #
+  def self.return_short_aminoacid_letter_from_long_aminoacid_name(
+      i
+    )
+    if i.nil?
+      e "Please provide some input to the method #{__method__.to_s}."
+      return nil
+    end
+    aminoacids = AMINO_ACIDS_ENGLISH
+    inverted_table = aminoacids.invert
+    i = [i].flatten.compact.map(&:capitalize)
+    if i.first.include? '-'
+      i = i.join.strip.split('-').map {|entry|
+        entry.capitalize!
+        if inverted_table.has_key? entry
+          entry = inverted_table[entry]
+        else
+          e "The given input `#{entry}` does not appear to be "\
+            "a valid long-letter aminoacid."
+        end
+        entry
+      }
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.is_in_the_three_letter_code?
+  #
+  # This method can be used to check whether the given input is in the
+  # three letter code.
+  #
+  # Usage examples:
+  #
+  #    Bioroebe.is_in_the_three_letter_code? 'Lys-Asp-Glu-Leu'     # => true
+  #    Bioroebe.is_in_the_three_letter_code? 'Lys-Asp-Glu-Leu-Lun' # => false
+  #
+  # ========================================================================= #
+  def self.is_in_the_three_letter_code?(
+      i = 'Lys-Asp-Glu-Leu'
+    )
+    result = true
+    dataset = AMINO_ACIDS_THREE_TO_ONE
+    if i.is_a? Array
+      i = i.join('-').strip
+    end
+    i = i.to_s.dup
+    i.strip!
+    i.delete!(' ') if i.include? ' '
+    i.delete!('-') if i.include? '-'
+    scanned = i.scan(/.../).map(&:downcase)
+    scanned.each {|key|
+      if dataset.has_key? key
+      else
+        result = false
+      end
+    }
+    return result
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.one_to_three
+  #
+  # This method will convert from the one-aminoacid letter to the
+  # three-letter code.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.one_to_three('HIM') # => "His-Ile-Met"
+  #
+  # ========================================================================= #
+  def self.one_to_three(i)
+    if i.is_a? Array
+      i = i.join
+    end
+    inverted_hash = AMINO_ACIDS_THREE_TO_ONE.invert
+    chars = i.chars
+    result = chars.map {|one_aminoacid_letter|
+      inverted_hash[one_aminoacid_letter].capitalize+'-'
+    }.join
+    return result.chop
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.weight_of_this_aminoacid?
+  #
+  # This method will return the weight of an aminoacid (that is bound
+  # in a protein, thus having a H2O group less than normally in total).
+  # ========================================================================= #
+  def self.weight_of_this_aminoacid?(
+      i, use_this_dataset = nil
+    )
+    if use_this_dataset.nil?
+      use_this_dataset = YAML.load_file(FILE_AMINO_ACIDS_MASS_TABLE)
+    end
+    if i.is_a? Array
+      i.map {|entry|
+        result = weight_of_this_aminoacid?(entry, use_this_dataset)
+        if result.nil?
+          erev 'A nil value happened for '+steelblue(entry)+rev+
+            '. Check file '+sfile(FILE_AMINO_ACIDS_MASS_TABLE)
+        end
+        result
+      }.compact.sum
+    else
+      use_this_dataset[i]
+    end
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+
+  alias e puts
+
+  Bioroebe.upcase_this_aminoacid_sequence_and_remove_numbers(
+    '1 msasasacdc lvgvptgptl astcggsafm lfmgllevfi rsqcdledpc grassrfrse
+    61 pdyeydfivi gggsagsvva srlsevpqwk vllieaggde pvgaqipsmf lnfigsdidy')
+
+  e Bioroebe.three_to_one('THR')
+
+  if ARGV.empty?
+    input = 'thr-Arg-His'
+  else
+    input = ARGV.join(' ').strip
+  end
+
+  puts 'From '+input+' to: '+Bioroebe.three_to_one(input) # => "TRH"
+  # And more tests:
+  #   p Bioroebe.is_aminoacid? 'Tryptophan' # => true
+  #   p Bioroebe.is_aminoacid? 'Glycine'    # => true
+  #   p Bioroebe.is_aminoacid? 'lysine'     # => true
+  #   p Bioroebe.is_aminoacid? 'GB'         # => false
+  #   p Bioroebe.is_aminoacid? 'G'          # => false
+  #
+  # puts Bioroebe.return_long_aminoacid_name 'M' # => "Methionine"
+  # puts Bioroebe.return_long_aminoacid_name ARGV.first
+  #
+  # puts Bioroebe.sort_aminoacid_based_on_its_hydrophobicity(ARGV)
+  #
+  # if ARGV.empty?
+  #   puts Bioroebe.return_short_aminoacid_letter_from_long_aminoacid_name 'M' # => "Methionine"
+  # else
+  #   puts Bioroebe.return_short_aminoacid_letter_from_long_aminoacid_name ARGV.first
+  # end
+  #
+  # if ARGV.empty?
+  #   puts 'This test-code will show 1,2,3 aminoacids in build-up (Alanin, Glycine, Leucine):'
+  #   puts
+  #   puts '  '+Bioroebe.amino_acid_average_mass('A').to_s   # Alanin
+  #   puts '  '+Bioroebe.amino_acid_average_mass('AG').to_s  # Alanin, Glycine
+  #   puts '  '+Bioroebe.amino_acid_average_mass('AGL').to_s # Alanin, Glycine, Leucine.
+  #   puts
+  # else
+  #   puts '  '+Bioroebe.amino_acid_average_mass(ARGV).to_s # Alanin, Glycine, Leucine.
+  # end
+  #
+end # three_to_one His