Provided by: libbio-perl-perl_1.7.2-2_all bug


       Bio::Tools::CodonTable - Codon table object


         # This is a read-only class for all known codon tables.  The IDs are
         # the ones used by nucleotide sequence databases.  All common IUPAC
         # ambiguity codes for DNA, RNA and amino acids are recognized.

         use Bio::Tools::CodonTable;

         # defaults to ID 1 "Standard"
         $myCodonTable   = Bio::Tools::CodonTable->new();
         $myCodonTable2  = Bio::Tools::CodonTable->new( -id => 3 );

         # change codon table

         # examine codon table
         print  join (' ', "The name of the codon table no.", $myCodonTable->id(4),
                  "is:", $myCodonTable->name(), "\n");

         # print possible codon tables
         $tables = Bio::Tools::CodonTable->tables;
         while ( ($id,$name) = each %{$tables} ) {
           print "$id = $name\n";

         # translate a codon
         $aa = $myCodonTable->translate('ACU');
         $aa = $myCodonTable->translate('act');
         $aa = $myCodonTable->translate('ytr');

         # reverse translate an amino acid
         @codons = $myCodonTable->revtranslate('A');
         @codons = $myCodonTable->revtranslate('Ser');
         @codons = $myCodonTable->revtranslate('Glx');
         @codons = $myCodonTable->revtranslate('cYS', 'rna');

         # reverse translate an entire amino acid sequence into a IUPAC
         # nucleotide string

         my $seqobj    = Bio::PrimarySeq->new(-seq => 'FHGERHEL');
         my $iupac_str = $myCodonTable->reverse_translate_all($seqobj);

         # boolean tests
         print "Is a start\n"       if $myCodonTable->is_start_codon('ATG');
         print "Is a terminator\n" if $myCodonTable->is_ter_codon('tar');
         print "Is a unknown\n"     if $myCodonTable->is_unknown_codon('JTG');


       Codon tables are also called translation tables or genetic codes since that is what they
       represent. A bit more complete picture of the full complexity of codon usage in various
       taxonomic groups is presented at the NCBI Genetic Codes Home page.

       CodonTable is a BioPerl class that knows all current translation tables that are used by
       primary nucleotide sequence databases (GenBank, EMBL and DDBJ). It provides methods to
       output information about tables and relationships between codons and amino acids.

       This class and its methods recognized all common IUPAC ambiguity codes for DNA, RNA and
       animo acids. The translation method follows the conventions in EMBL and TREMBL databases.

       It is a nuisance to separate RNA and cDNA representations of nucleic acid transcripts. The
       CodonTable object accepts codons of both type as input and allows the user to set the mode
       for output when reverse translating. Its default for output is DNA.


       This class deals primarily with individual codons and amino acids. However in the interest
       of speed you can translate longer sequence, too. The full complexity of protein
       translation is tackled by Bio::PrimarySeqI::translate.

       The amino acid codes are IUPAC recommendations for common amino acids:

                 A           Ala            Alanine
                 R           Arg            Arginine
                 N           Asn            Asparagine
                 D           Asp            Aspartic acid
                 C           Cys            Cysteine
                 Q           Gln            Glutamine
                 E           Glu            Glutamic acid
                 G           Gly            Glycine
                 H           His            Histidine
                 I           Ile            Isoleucine
                 L           Leu            Leucine
                 K           Lys            Lysine
                 M           Met            Methionine
                 F           Phe            Phenylalanine
                 P           Pro            Proline
                 O           Pyl            Pyrrolysine (22nd amino acid)
                 U           Sec            Selenocysteine (21st amino acid)
                 S           Ser            Serine
                 T           Thr            Threonine
                 W           Trp            Tryptophan
                 Y           Tyr            Tyrosine
                 V           Val            Valine
                 B           Asx            Aspartic acid or Asparagine
                 Z           Glx            Glutamine or Glutamic acid
                 J           Xle            Isoleucine or Valine (mass spec ambiguity)
                 X           Xaa            Any or unknown amino acid

       It is worth noting that, "Bacterial" codon table no. 11 produces an polypeptide that is,
       confusingly, identical to the standard one. The only differences are in available
       initiator codons.

       NCBI Genetic Codes home page:
            (Last update of the Genetic Codes: April 30, 2013)

       ASN.1 version with ids 1 to 25 is at:

       Thanks to Matteo diTomasso for the original Perl implementation of these tables.


   Mailing Lists
       User feedback is an integral part of the evolution of this and other Bioperl modules. Send
       your comments and suggestions preferably to the Bioperl mailing lists  Your participation
       is much appreciated.
                  - General discussion  - About the mailing lists

       Please direct usage questions or support issues to the mailing list:

       rather than to the module maintainer directly. Many experienced and reponsive experts will
       be able look at the problem and quickly address it. Please include a thorough description
       of the problem with code and data examples if at all possible.

   Reporting Bugs
       Report bugs to the Bioperl bug tracking system to help us keep track the bugs and their
       resolution.  Bug reports can be submitted via the web:

AUTHOR - Heikki Lehvaslaiho

       Email:  heikki-at-bioperl-dot-org


       The rest of the documentation details each of the object methods. Internal methods are
       usually preceded with a _

        Title   : id
        Usage   : $obj->id(3); $id_integer = $obj->id();
        Function: Sets or returns the id of the translation table.  IDs are
                  integers from 0 (special ATG-only start) to 25, excluding
                  7-8 and 17-20 which have been removed. If an invalid ID is
                  given the method returns 1, the standard table.
        Example :
        Returns : value of id, a scalar, warn and fall back to 1 (standard table)
                  if specified id is not valid
        Args    : newvalue (optional)

        Title   : name
        Usage   : $obj->name()
        Function: returns the descriptive name of the translation table
        Example :
        Returns : A string
        Args    : None

        Title   : tables
        Usage   : $obj->tables()  or  Bio::Tools::CodonTable->tables()
        Function: returns a hash reference where each key is a valid codon
                  table id() number, and each value is the corresponding
                  codon table name() string
        Example :
        Returns : A hashref
        Args    : None

        Title   : translate
        Usage   : $obj->translate('YTR')
        Function: Returns a string of one letter amino acid codes from
                  nucleotide sequence input. The imput can be of any length.

                  Returns 'X' for unknown codons and codons that code for
                  more than one amino acid. Returns an empty string if input
                  is not three characters long. Exceptions for these are:

                    - IUPAC amino acid code B for Aspartic Acid and
                      Asparagine, is used.
                    - IUPAC amino acid code Z for Glutamic Acid, Glutamine is
                    - if the codon is two nucleotides long and if by adding
                      an a third character 'N', it codes for a single amino
                      acid (with exceptions above), return that, otherwise
                      return empty string.

                  Returns empty string for other input strings that are not
                  three characters long.

        Example :
        Returns : a string of one letter ambiguous IUPAC amino acid codes
        Args    : ambiguous IUPAC nucleotide string

        Title   : translate_strict
        Usage   : $obj->translate_strict('ACT')
        Function: returns one letter amino acid code for a codon input

                  Fast and simple translation. User is responsible to resolve
                  ambiguous nucleotide codes before calling this
                  method. Returns 'X' for unknown codons and an empty string
                  for input strings that are not three characters long.

                  It is not recommended to use this method in a production
                  environment. Use method translate, instead.

        Example :
        Returns : A string
        Args    : a codon = a three nucleotide character string

        Title   : revtranslate
        Usage   : $obj->revtranslate('G')
        Function: returns codons for an amino acid

                  Returns an empty string for unknown amino acid
                  codes. Ambiguous IUPAC codes Asx,B, (Asp,D; Asn,N) and
                  Glx,Z (Glu,E; Gln,Q) are resolved. Both single and three
                  letter amino acid codes are accepted. '*' and 'Ter' are
                  used for terminator.

                  By default, the output codons are shown in DNA.  If the
                  output is needed in RNA (tr/t/u/), add a second argument

        Example : $obj->revtranslate('Gly', 'RNA')
        Returns : An array of three lower case letter strings i.e. codons
        Args    : amino acid, 'RNA'

        Title   : reverse_translate_all
        Usage   : my $iup_str = $cttable->reverse_translate_all($seq_object)
                  my $iup_str = $cttable->reverse_translate_all($seq_object,
        Function: reverse translates a protein sequence into IUPAC nucleotide
                  sequence. An 'X' in the protein sequence is converted to 'NNN'
                  in the nucleotide sequence.
        Returns : a string
        Args    : a Bio::PrimarySeqI compatible object (mandatory)
                  a Bio::CodonUsage::Table object and a threshold if only
                    codons with a relative frequency above the threshold are
                    to be considered.

        Title   : reverse_translate_best
        Usage   : my $str = $cttable->reverse_translate_best($seq_object,$cutable);
        Function: Reverse translates a protein sequence into plain nucleotide
                  sequence (GATC), uses the most common codon for each amino acid
        Returns : A string
        Args    : A Bio::PrimarySeqI compatible object and a Bio::CodonUsage::Table object

        Title   : is_start_codon
        Usage   : $obj->is_start_codon('ATG')
        Function: returns true (1) for all codons that can be used as a
                  translation start, false (0) for others.
        Example : $myCodonTable->is_start_codon('ATG')
        Returns : boolean
        Args    : codon

        Title   : is_ter_codon
        Usage   : $obj->is_ter_codon('GAA')
        Function: returns true (1) for all codons that can be used as a
                  translation tarminator, false (0) for others.
        Example : $myCodonTable->is_ter_codon('ATG')
        Returns : boolean
        Args    : codon

        Title   : is_unknown_codon
        Usage   : $obj->is_unknown_codon('GAJ')
        Function: returns false (0) for all codons that are valid,
               true (1) for others.
        Example : $myCodonTable->is_unknown_codon('NTG')
        Returns : boolean
        Args    : codon

        Title   : unambiguous_codons
        Usage   : @codons = $self->unambiguous_codons('ACN')
        Returns : array of strings (one-letter unambiguous amino acid codes)
        Args    : a codon = a three IUPAC nucleotide character string

       deprecated, now an alias for unambiguous_codons

        Title   : add_table
        Usage   : $newid = $ct->add_table($name, $table, $starts)
        Function: Add a custom Codon Table into the object.
                  Know what you are doing, only the length of
                  the argument strings is checked!
        Returns : the id of the new codon table
        Args    : name, a string, optional (can be empty)
                  table, a string of 64 characters
                  startcodons, a string of 64 characters, defaults to standard