bioroebe 0.10.80

data/lib/bioroebe/toplevel_methods/number_of_clones.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/number_of_clones.rb'
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.number_of_clones
+  #
+  # This method will "calculate" the number of clones required for
+  # an experiment that attempts to create a genomic library.
+  #
+  # The general formula is:
+  #
+  #   N = ln (1 - P ) / ln (1 - a/b)
+  #
+  # Where:
+  #
+  #   N is the number of clones required.
+  #   P is the desired probability.
+  #   a is the average size of the DNA fragments that are cloned.
+  #   b is the size of the genome at hand (in n bp).
+  #
+  # ========================================================================= #
+  def self.number_of_clones(
+      average_size_of_the_dna_fragments = 10_000,
+      size_of_the_genome                = 4_693_221, # ← E. coli K12.
+      desired_probability               = 0.99       # ← Or 0.95 (this is P)
+    )
+    n_clones = Math.log(1 - desired_probability) /
+              (Math.log(1 - (average_size_of_the_dna_fragments.to_f / size_of_the_genome.to_f)))
+    n_clones.round(0)
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  require 'colours/autoinclude'
+  genome_size = 4.0 * (10 ** 3)
+  probability = 0.95
+  insert_size = 20 # 20kb, lambda vector
+  e 'For a probability of '+probability.to_s+', we will obtain these results:'
+  e
+  e '  For E. coli (insert size '+insert_size.to_s+' kb): '+
+    Bioroebe.number_of_clones(insert_size, genome_size, probability).to_s+
+    ' clones are required' # 598
+  insert_size = 45 # 45kb, cosmid vector
+  e '  For E. coli (insert size '+insert_size.to_s+' kb): '+
+    Bioroebe.number_of_clones(insert_size, genome_size, probability).to_s+
+    ' clones are required' # 598
+  genome_size = 1.4 * (10 ** 4)
+  insert_size = 20 # 20kb, lambda vector
+  e '  For S. cerevisiae (insert size '+insert_size.to_s+' kb): '+
+    Bioroebe.number_of_clones(insert_size, genome_size, probability).to_s+
+    ' clones are required' # 598
+  insert_size = 45 # 45kb, cosmid vector
+  e '  For S. cerevisiae (insert size '+insert_size.to_s+' kb): '+
+    Bioroebe.number_of_clones(insert_size, genome_size, probability).to_s+
+    ' clones are required' # 598
+  e
+end # numberofclones

data/lib/bioroebe/toplevel_methods/open_in_browser.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/open_in_browser.rb'
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/project/project.rb'
+  require 'bioroebe/toplevel_methods/esystem.rb'
+  require 'bioroebe/toplevel_methods/url.rb'
+  require 'bioroebe/requires/require_yaml.rb'
+  require 'bioroebe/constants/files_and_directories.rb'
+
+  # ========================================================================= #
+  # === USE_THIS_BROWSER
+  #
+  # This constant specifies the default browser to use for the
+  # bioroebe-project.
+  # ========================================================================= #
+  if File.exist? "#{project_yaml_directory?}browser.yml"
+    USE_THIS_BROWSER = YAML.load_file(FILE_BROWSER)
+  elsif ENV['BROWSER']
+    USE_THIS_BROWSER = ENV['BROWSER'].to_s.dup
+  else
+    USE_THIS_BROWSER = 'firefox' # opera # Hardcoded value in this case..
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.open_in_browser
+  #
+  # This method will try to open a remote URL in the specified browser -
+  # the one that has been noted down in 'browser.yml'. It is accessed
+  # via the Symbol :use_the_default_browser (as second argument to
+  # this method).
+  #
+  # If you wish to make use of another browser then you can also
+  # pass in the location to the browser as the second argument tp
+  # this method.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.open_in_browser('derstandard.at')
+  #
+  # ========================================================================= #
+  def self.open_in_browser(
+      this_url,
+      use_this_browser = :use_the_default_browser
+    )
+    if this_url.is_a? Array
+      this_url.each {|entry|
+        open_in_browser(entry, use_this_browser)
+      }
+    else
+      case use_this_browser # case tag
+      # ===================================================================== #
+      # === :default
+      # ===================================================================== #
+      when :default,
+           :use_the_default_browser
+        # =================================================================== #
+        # Sanitize the default setting here, by loading up the content of
+        # the proper yaml file.
+        # =================================================================== #
+        use_this_browser =
+          YAML.load_file(FILE_BROWSER)
+      end
+      this_url = ::Bioroebe.try_to_pass_through_beautiful_url(this_url)
+      esystem "#{use_this_browser.strip} -new-tab #{this_url}"
+    end
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  Bioroebe.open_in_browser 'https://www.youtube.com/'
+end # rb open_in_browser.rb

data/lib/bioroebe/toplevel_methods/open_reading_frames.rb

@@ -0,0 +1,236 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/open_reading_frames.rb'
+# Bioroebe.return_longest_ORF_from_this_sequence(ARGV)
+# Bioroebe.return_all_open_reading_frames_from_this_sequence
+# Bioroebe.return_n_ORFs_in_this_sequence
+# Bioroebe.open_reading_frames_to_aminoacid_sequence
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/toplevel_methods/e.rb'
+  require 'bioroebe/codons/codons.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.return_longest_ORF_from_this_sequence
+  #
+  # This method will return the longest ORF from the given input
+  # sequence. By default it will assume that the input sequence
+  # is meant to have derived from a dsDNA sequence, so the
+  # reverse complement is evaluated as well. If you do not need
+  # or want that behaviour then simply pass "false" as the
+  # second argument to this method.
+  #
+  # Usage example:
+  #
+  #   x = Bioroebe.return_longest_ORF_from_this_sequence; puts x
+  #
+  # ========================================================================= #
+  def self.return_longest_ORF_from_this_sequence(
+      i                                =
+        'AGCCATGTAGCTAACTCAGGTTACATGGGGATGACCCCGC'\
+        'GACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGAATGATC'\
+        'CGAGTAGCATCTCAG',
+      check_reverse_complement_as_well = true,
+      start_codon                      = ::Bioroebe.start_codon?,
+      stop_codons                      = ::Bioroebe.stop_codons? # ← This method will yield an Array.
+    )
+    results = Bioroebe.return_all_open_reading_frames_from_this_sequence(
+      i, check_reverse_complement_as_well, start_codon, stop_codons
+    ).sort_by {|entry| entry.size }.reverse
+    longest_result = results.first
+    return longest_result
+  end; self.instance_eval { alias return_longest_open_reading_frame_from_this_sequence return_longest_ORF_from_this_sequence } # === Bioroebe.return_longest_open_reading_frame_from_this_sequence
+       self.instance_eval { alias longest_ORF?                                         return_longest_ORF_from_this_sequence } # === Bioroebe.longest_ORF?
+
+  # ========================================================================= #
+  # === Bioroebe.return_all_open_reading_frames_from_this_sequence
+  #
+  # This method will return an Array of all open reading frames from the
+  # given input-sequence.
+  #
+  # The second argument to this method, called `check_reverse_complement_as_well`,
+  # can be used to find the reverse complement.
+  #
+  # Usage examples:
+  #
+  #
+  #   x = Bioroebe.return_all_open_reading_frames_from_this_sequence('AGCCATGTAGCTAACTCAGGTTACATGGGGATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGAATGATCCGAGTAGCATCTCAG', true)
+  #
+  #   Bioroebe.return_all_open_reading_frames_from_this_sequence # => 
+  #
+  #     ["ATGTAGCTAACTCAGGTTACATGGGGATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGAATGATCCGAGTAG", "ATGTAGCTAACTCAGGTTACATGGGGATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGAATGA", "ATGGGGATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGA", "ATGTAGCTAACTCAGGTTACATGGGGATGACCCCGCGACTTGGATTAG", "ATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGA", "ATGGGGATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAA", "ATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAA", "ATGTAGCTAACTCAGGTTACATGGGGATGA", "ATGTAG"]
+  #
+  # ========================================================================= #
+  def self.return_all_open_reading_frames_from_this_sequence(
+      i                                =
+        'AGCCATGTAGCTAACTCAGGTTACATGGGGATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGAATGATCCGAGTAGCATCTCAG',
+      check_reverse_complement_as_well = true,
+      start_codon                      = ::Bioroebe.start_codon?,
+      stop_codons                      = ::Bioroebe.stop_codons? # ← This method will yield an Array.
+    )
+    if i.is_a? Array
+      # ===================================================================== #
+      # Only handle the first entry in the event that an Array was given.
+      # ===================================================================== #
+      i = i.first
+    end
+    array = [] # ← We will return this Array.
+    if stop_codons.empty?
+      # ===================================================================== #
+      # In this case we will use a hardcoded approach and define all
+      # valid stop codons, referring to the eukaryotic genome.
+      # ===================================================================== #
+      stop_codons = %w(
+        TAG TGA TAA
+      )
+    end
+    # ======================================================================= #
+    # Find all positions for start codons next; it will be stored in
+    # an Array that contains all indices thereof.
+    # ======================================================================= #
+    all_start_codons = (0 ... i.length).find_all { |entry|
+      i[entry, 3] == start_codon # First three must equal the start_codon.
+    }
+    array_all_subsequences = []
+    all_start_codons.each {|start_index|
+      subsequence = i[start_index .. -1]
+      array_all_subsequences << subsequence
+    }
+    # ======================================================================= #
+    # Now that we have all subsequences (stored in array_all_subsequences)
+    # we can now match all subsequences that end with a stop codon.
+    # ======================================================================= #
+    array_all_subsequences.each {|sequence|
+      # ===================================================================== #
+      # We know that these sequences must begin with 'ATG'. Now we must
+      # determine all remaining sequences with a stop-sequence here,
+      # but only if they are in-frame (aka can be divided by 3).
+      #
+      # In order to simplify this, we will group these sequences
+      # in pairs of three.
+      # ===================================================================== #
+      scanned = sequence.scan(/.../)
+      scanned.each_with_index {|codon, index| index += 1
+        if stop_codons.include? codon # In this case it is a valid stop-codon.
+          array << sequence[0 .. ((index * 3)-1)]
+        end
+      }
+    }
+    # ======================================================================= #
+    # The next check will also include the reverse complement as well.
+    # ======================================================================= #
+    if check_reverse_complement_as_well
+      array << return_all_open_reading_frames_from_this_sequence(i.reverse, false)
+    end
+    array.flatten!
+    # ======================================================================= #
+    # Sort by size next - longest substring is returned first.
+    # ======================================================================= #
+    array = array.sort_by {|entry| entry.size }.reverse
+    return array
+  end; self.instance_eval { alias open_reading_frames return_all_open_reading_frames_from_this_sequence } # === Bioroebe.open_reading_frames
+
+  # ========================================================================= #
+  # === Bioroebe.return_n_ORFs_in_this_sequence
+  #
+  # Return how many ORFs are in a given sequence.
+  # ========================================================================= #
+  def self.return_n_ORFs_in_this_sequence(
+        i           =
+          'AGCCATGTAGCTAACTCAGGTTACATGGGGATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGAATGATCCGAGTAGCATCTCAG',
+        start_codon = Bioroebe.to_aa(::Bioroebe.start_codon?)
+      )
+    if i.is_a? Array
+      i = i.join
+    end
+    if i.is_a? String
+      i = i.chars
+    end
+    n_ORFs_in_this_sequence = 0
+    all_start_codons = (0 ... i.length).find_all {|index|
+      i[index] == start_codon
+    }
+    stop_codons_are_at_that_position = (0 ... i.length).find_all {|index|
+      i[index] == '*'
+    }
+    all_start_codons.each {|this_start_codon_position|
+      stop_codons_are_at_that_position.each {|this_stop_codon_position|
+        if this_start_codon_position < this_stop_codon_position
+          n_ORFs_in_this_sequence += 1
+          break
+        end 
+      }
+    }
+    return n_ORFs_in_this_sequence
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.display_all_open_reading_frames_from_this_sequence
+  # ========================================================================= #
+  def self.display_all_open_reading_frames_from_this_sequence(i = ARGV)
+    require 'bioroebe/colours/colours.rb'
+    if i.empty?
+      array = Bioroebe.return_all_open_reading_frames_from_this_sequence
+      pp array
+      pp Bioroebe.to_aa(array)
+    else
+      this_sequence = i
+      array = return_all_open_reading_frames_from_this_sequence(this_sequence)
+      this_sequence = this_sequence.join
+      if array.empty?
+        e "No open reading from has been found from "\
+          "this sequence: #{this_sequence}"
+      else
+        e rev+
+          'The following ORFs have been found in this sequence: '
+        e
+        e "  #{Colours.lightgreen(this_sequence)}"
+        e
+        array.each_with_index {|sequence, index| index += 1
+          name_for_the_ORF = "ORF number #{index}"
+          e "  #{Colours.steelblue(sequence.ljust(50))} "\
+            "#{Colours.lightslategrey('#')} "\
+            "#{Colours.mediumseagreen(name_for_the_ORF)}"
+        }
+        e
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.open_reading_frames_to_aminoacid_sequence
+  #
+  # This method is similar to Bioroebe.open_reading_frames(), but it
+  # will additionally convert to the corresponding aminoacids at once.
+  #
+  # This method will return a String as a result.
+  #
+  # Usage example:
+  #
+  #   x = Bioroebe.open_reading_frames_to_aminoacid_sequence('AAAATGGGCCCATGA') # => ["MGP"]
+  #
+  # ========================================================================= #
+  def self.open_reading_frames_to_aminoacid_sequence(
+      i = 'AGCCATGTAGCTAACTCAGGTTACATGGGGATGACCCCGCGACTTGGA'\
+          'TTAGAGTCTCTTTTGGAATAAGCCTGAATGATCCGAGTAGCATCTCAG'
+    )
+    all_aminoacids = ::Bioroebe.open_reading_frames(i).map {|nucleotide_sequence|
+      ::Bioroebe.to_aa(nucleotide_sequence)
+    }
+    if all_aminoacids
+      all_aminoacids = all_aminoacids.first
+    end
+    return all_aminoacids
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  require 'colours/autoinclude.rb'
+  Bioroebe.display_all_open_reading_frames_from_this_sequence(ARGV)
+end # openreadingframes AGCCATGTAGCTAACTCAGGTTACATGGGGATGACCCCGCGACTTGGATTAGAGTCTCTTTTGGAATAAGCCTGAATGATCCGAGTAGCATCTCAG
+    # openreadingframes AGTATGGGGATGTAGGTA
+    # openreadingframes ATGATGTGA

data/lib/bioroebe/toplevel_methods/opn.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/opn.rb'
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.permanently_disable_opn
+  #
+  # The purpose of this method is to permanently disable opn for the
+  # whole Bioroebe-project.
+  # ========================================================================= #
+  def self.permanently_disable_opn
+    require 'bioroebe/project/project.rb'
+    require 'bioroebe/colours/colours.rb'
+    require 'bioroebe/toplevel_methods/e.rb'
+    require 'bioroebe/toplevel_methods/file_and_directory_related_actions.rb'
+    erev 'Permanently disabling the use of opn for the Bioroebe project next.'
+    target_dir = CONFIGURATION_DIRECTORY
+    target_file = "#{target_dir}use_opn.yml"
+    if File.exist? target_file
+      erev 'Modifying the file `'+
+           sfile(target_file)+rev+'` next.'
+      write_what_into('false', target_file)
+    end
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  Bioroebe.permanently_disable_opn
+end # bioroebepermanentlydisableopn

data/lib/bioroebe/toplevel_methods/palindromes.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/palindromes.rb'
+# puts Bioroebe.is_palindrome? ARGV
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/toplevel_methods/e.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.return_every_substring_from_this_sequence
+  # ========================================================================= #
+  def self.return_every_substring_from_this_sequence(i)
+    result = []
+    i.chars.each_with_index {|entry, index|
+      result << i[0, (index+1)] 
+    }
+    return result
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.every_reverse_palindrome_in_this_string
+  #
+  # This method can return every reverse palindrome in the given input
+  # String.
+  #
+  # The output will be an Array such as this:
+  #
+  #   [[4, 6], [5, 4], [6, 6], [7, 4], [17, 4], [18, 4], [4, 6], [5, 4]]
+  #
+  # ========================================================================= #
+  def self.every_reverse_palindrome_in_this_string(
+      i          = 'TCAATGCATGCGGGTCTATATGCAT',
+      min_length =  4,
+      max_length = 12
+    )
+    require 'bioroebe/sequence/reverse_complement.rb'
+    if i.is_a? Array # Arrays will become Strings - or rather, whatever is the first argument.
+      i = i.first
+    end
+    if i and File.exist?(i)
+      i = File.readlines(i).reject {|entry|
+        entry.start_with?('>')
+      }.map {|inner_entry| inner_entry.strip }.join
+    end
+    # ======================================================================= #
+    # How do we find all subsequences that are relevant? Well - we
+    # need to find all the sequences between min_length and
+    # max_length, e. g. 4 and 12.
+    # ======================================================================= #
+    string = i.dup
+    array_containing_starting_index_and_length_of_reverse_palindromes = []
+    i.size.times {
+      substrings = return_every_substring_from_this_sequence(string)
+      substrings.each {|entry|
+        next if entry.size > max_length
+        if (entry.size >= min_length) and
+           (Bioroebe.reverse_complement(entry) == entry)
+          array_containing_starting_index_and_length_of_reverse_palindromes << 
+            [i.index(entry)+1, entry.size]
+        end
+      }
+      string[0,1] = ''
+    }
+    return array_containing_starting_index_and_length_of_reverse_palindromes
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.is_palindrome?
+  #
+  # This method will return true if the target sequence is a palindrome,
+  # and false otherwise.
+  #
+  # When will a sequence be considered to be a "palindrome"?
+  #
+  # Firstly, it must have an even number of components. If it has an odd
+  # number then it can never be a Palindrome, by definition alone.
+  #
+  # So, "GATC" is a palindrome, but "GATCC" can never be. (GATC is a 
+  # palindrome because the reverse of GATC will bind to itself again.)
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.is_palindrome? 'GAATTC'   # => true
+  #   Bioroebe.is_palindrome? 'GAATTCCC' # => false
+  #
+  # ========================================================================= #
+  def self.is_palindrome?(i)
+    require 'bioroebe/toplevel_methods/nucleotides.rb'
+    if i.is_a? Array
+      i = i.first
+    end
+    hash = ::Bioroebe.partner_nucleotide_hash
+    return_value = false
+    if i
+      if i.to_s.size.odd? # Then it can never be a Palindrome.
+      else # Ok, it may be a palindrome here.
+        first_half = i[0 .. (i.size / 2)-1]
+        _ = ''.dup
+        first_half.chars.reverse.each {|char|
+          _ << hash[char] if hash.has_key? char
+        }
+        if (first_half + _) == i # Compare it to the original input.
+          return_value = true
+        end
+      end
+      return return_value
+    else
+      :invalid_input
+    end
+  end; self.instance_eval { alias is_this_sequence_a_palindrome? is_palindrome? } # === Bioroebe.is_this_sequence_a_palindrome?
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+pp Bioroebe.every_reverse_palindrome_in_this_string(ARGV)
+exit
+  if ARGV.empty?
+    p 'GAATTC: '+Bioroebe.is_palindrome?('GAATTC').to_s   # => true
+    p 'GAATTCCC: '+Bioroebe.is_palindrome?('GAATTCCC').to_s # => false
+  else
+    p Bioroebe.is_palindrome? ARGV
+  end
+end # ispalindrome GATC # true
+    # ispalindrome GAAG # false

data/lib/bioroebe/toplevel_methods/parse.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/parse.rb'
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.parse
+  #
+  # This is a general parse-related method.
+  #
+  # The main ideafor this method is to parse files in particular, in a
+  # simplified manner. That means, for example, if the input to this
+  # method is a genbank file, then this method will simply return the 
+  # sequence. If it is a .pdb file, same thing. A .fasta file, same
+  # result - the content will be returned. Thus, this method attempts
+  # to make it simpler to parse a wide array of different file
+  # formats - simply feed it what you want and you get the
+  # "most logical" output.
+  # ========================================================================= #
+  def self.parse(
+      i = ARGV
+    )
+    if i.is_a? Array
+      i = i.first
+    end
+    if i
+      case i
+      # ===================================================================== #
+      # === .genbank
+      # ===================================================================== #
+      when /\.genbank$/i
+        require 'bioroebe/fasta_and_fastq/parse_fasta/parse_fasta.rb' 
+        i = Bioroebe.genbank_to_fasta(i, :be_quiet)
+      # ===================================================================== #
+      # === .pdb
+      # ===================================================================== #
+      when /\.pdb$/i
+        require 'bioroebe/pdb/parse_pdb_file.rb'
+        i = Bioroebe.return_aminoacid_sequence_from_this_pdb_file(i)
+      # ===================================================================== #
+      # === .fasta
+      # ===================================================================== #
+      when /\.fasta$/i,
+           /\.fa$/i
+        require 'bioroebe/fasta_and_fastq/parse_fasta/parse_fasta.rb'
+        i = Bioroebe::ParseFasta.new(i) { :be_quiet }.sequence?
+      end
+      return i
+    end
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  puts Bioroebe.parse(ARGV)
+end # bioroebeparse

data/lib/bioroebe/toplevel_methods/phred_error_probability.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/phred_error_probability.rb'
+# Bioroebe.phred_error_probability(ARGV)
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.phred_error_probability
+  #
+  # Datasets obtained from next-generation reads specify a Phred score
+  # for each base. This is also known as the "Q score" (Quality score).
+  #
+  # The Q score is an integer value, and is typically within the range 2
+  # to 40. Q indicates the probability that the base call is incorrect (P_e).
+  #
+  # For example, Q=2 means that the error probability is 63%, so the machine
+  # is reporting that the base is more likely to be wrong than right, while
+  # Q=20 corresponds to an error probability of only 1%.
+  #
+  # The second argument to this method can be used to format to a specific
+  # number. So if we pass in 6 as the second argument then the result will
+  # be rounded to 6 slots after the first '.'. See the usage examples
+  # below.
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.phred_error_probability '48'
+  #   Bioroebe.phred_error_probability '48',6 # => "0.000016"
+  #
+  # ========================================================================= #
+  def self.phred_error_probability(
+      quality_score                = 50,
+      optional_use_this_formatting = nil
+    )
+    if quality_score.is_a? Array
+      quality_score = quality_score.first
+    end
+    quality_score = quality_score.to_f # Need a Float past this point.
+    result = 10 ** (- quality_score / 10.0)
+    # ======================================================================= #
+    # Next, do some rounding if the user requested this through the
+    # second argument to this method.
+    # ======================================================================= #
+    if optional_use_this_formatting
+      if optional_use_this_formatting.is_a? Numeric
+        use_this_formatting_rule = "%.#{optional_use_this_formatting}f"
+        result = use_this_formatting_rule % result
+      else
+        result = optional_use_this_formatting.to_s % result
+      end
+    end
+    return result
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  if ARGV.empty?
+  (1 .. 40).each {|entry|
+    puts "#{entry.to_s.ljust(3)} #{Bioroebe.phred_error_probability(entry)}"
+  }
+  else
+    puts Bioroebe.phred_error_probability(ARGV)
+  end
+end # phrederrorprobability 48