bioroebe 0.12.24 → 0.13.31

data/lib/bioroebe/toplevel_methods/aminoacids_and_proteins.rb

@@ -1,722 +0,0 @@
-#!/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.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
-
-  # ========================================================================= #
-  # === Bioroebe.remove_invalid_aminoacids
-  #
-  # This method will filter away invalid aminoacids such as "U".
-  # "U" is not a valid aminoacid. It requires the data stored
-  # in the yaml file at:
-  # 
-  #    "/home/Programs/Ruby/3.1.2/lib/ruby/site_ruby/3.1.0/bioroebe/yaml/aminoacids/amino_acids.yml"
-  #
-  # Note that U is a valid aminoacid - it is selenocysteine.
-  #
-  # 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
-
-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
-
-  e '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