Nucleotide (gatk 4.1.4.1 API)

java.lang.Object
- java.lang.Enum<Nucleotide>
- - org.broadinstitute.hellbender.utils.Nucleotide

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<Nucleotide>
```
public enum Nucleotide
extends java.lang.Enum<Nucleotide>
```
Represents the nucleotide alphabet with support for IUPAC ambiguity codes.
This enumeration not only contains standard (non-ambiguous) nucleotides, but also contains ambiguous nucleotides, as well as a code X (a.k.a. INVALID) for invalid nucleotide calls.

You can query whether a value refers to a non-ambiguous nucleotide with isStandard() or isAmbiguous() whichever is most convenient. Notice that the special value X is neither of those.

Querying the X value for its complement, transition or transversion or using it in other operations such as intersect(org.broadinstitute.hellbender.utils.Nucleotide) will return X; similar to Double.NaN in double arithmetic.

For naming consistency it is recommended to use decode(byte) and encodeAsByte(boolean) or encodeAsString() methods to translate byte/char and string encodings from and into values of this enum over the inherited Enum.toString(), Enum.name or valueOf(java.lang.String).

Although the canonical names for values use the single letter IUPAC encodings, this class provides convenient longer form names constant aliases (e.g. ADENINE for A, PURINE for R, etc.).

Uracil and Thymine are considered equivalent in this enum with T as the canonical name.

Finally, notice that there is no code of the "gap nucleotide" that may appear in aligned sequences as in fact that is not a nucleotide. A base encoding using the typical gap representation such as '.' or '-' would be interpreted as an INVALID (i.e. X) call which is probably not what you want. So code to support those will need to do so outside this enum.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Nucleotide.Counter
Helper class to count the number of occurrences of each nucleotide code in a sequence.

Nested Classes
Modifier and Type	Class and Description
`static class`	`Nucleotide.Counter` Helper class to count the number of occurrences of each nucleotide code in a sequence.

Enum Constant Summary

Enum Constants
Enum Constant and Description

A

B

C

D

G

H

K

M

N

R

S

T

V

W

X

Y

Enum Constants
Enum Constant and Description
`A`
`B`
`C`
`D`
`G`
`H`
`K`
`M`
`N`
`R`
`S`
`T`
`V`
`W`
`X`
`Y`

Field Summary

Fields
Modifier and Type	Field and Description
`static Nucleotide`	`ADENINE`
`static Nucleotide`	`AMINO`
`static Nucleotide`	`ANY`
`static Nucleotide`	`CYTOSINE`
`static Nucleotide`	`GUANINE`
`static Nucleotide`	`INVALID`
`static Nucleotide`	`KETO`
`static Nucleotide`	`PURINE`
`static Nucleotide`	`PYRIMIDINE`
`static java.util.List<Nucleotide>`	`STANDARD_BASES` List of the standard (non-redundant) nucleotide values in their preferred alphabetical order.
`static Nucleotide`	`STRONG`
`static Nucleotide`	`THYMINE`
`static Nucleotide`	`U`
`static Nucleotide`	`URACIL`
`static Nucleotide`	`WEAK`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Nucleotide`	`complement()` Returns the complement nucleotide code for this one.
`static byte`	`complement(byte b)` Returns the complement for a base code.
`static byte`	`complement(byte b, boolean upperCase)` Returns the complement for a base code.
`static Nucleotide`	`decode(byte base)` Returns the nucleotide that corresponds to a particular `byte` typed base code.
`static Nucleotide`	`decode(char ch)` Returns the nucleotide that corresponds to a particular `char` typed base code.
`static Nucleotide`	`decode(java.lang.CharSequence seq)` Transform a single-letter character string into the corresponding nucleotide.
`byte`	`encodeAsByte()` Returns this nucleotide's exclusive upper-case `byte` encoding.
`byte`	`encodeAsByte(boolean upperCase)` Returns the `byte` typed encoding that corresponds to this nucleotide.
`char`	`encodeAsChar()` Returns the nucleotide's exclusive upper-case `char` encoding.
`char`	`encodeAsChar(boolean upperCase)` Returns the `char` typed encoding that corresponds to this nucleotide.
`java.lang.String`	`encodeAsString()` Returns the nucleotide's exclusive upper-case `String` encoding.
`java.lang.String`	`encodeAsString(boolean upperCase)` Returns the nucleotide's exclusive `String` typed encoding.
`boolean`	`includes(byte b)` Checks whether this nucleotide code encloses all possible nucleotides for another code.
`boolean`	`includes(Nucleotide other)` Checks whether this nucleotide code encloses all possible nucleotides for another code.
`static boolean`	`intersect(byte a, byte b)` Checks whether two nucleotides intersect given their byte encodings.
`Nucleotide`	`intersect(Nucleotide other)` Returns the nucleotide code that include all and only the nucleotides that are included by this another code.
`boolean`	`isAmbiguous()` Checks whether the nucleotide refer to an ambiguous base.
`boolean`	`isStandard()` Checks whether the nucleotide refers to a concrete (rather than ambiguous) base.
`boolean`	`isValid()` Whether this nucleotide code is valid or not.
`static boolean`	`same(byte a, byte b)` Checks whether two base encodings make reference to the same `Nucleotide(org.broadinstitute.hellbender.utils.Nucleotide...)` instance regardless of their case.
`boolean`	`same(Nucleotide other)` Checks whether this and another `Nucleotide(org.broadinstitute.hellbender.utils.Nucleotide...)` make reference to the same nucleotide(s).
`Nucleotide`	`transition()` Returns the instance that would include all possible transition mutations from this one.
`Nucleotide`	`transversion()` Returns the instance that would include all possible tranversion mutations from nucleotides included in this one.
`Nucleotide`	`transversion(boolean strong)` Transversion mutation toward a strong or a weak base.
`static Nucleotide`	`valueOf(java.lang.String name)` Returns the enum constant of this type with the specified name.
`static Nucleotide[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Enum Constant Detail
  - A
```
public static final Nucleotide A
```
  - C
```
public static final Nucleotide C
```
  - G
```
public static final Nucleotide G
```
  - T
```
public static final Nucleotide T
```
  - R
```
public static final Nucleotide R
```
  - Y
```
public static final Nucleotide Y
```
  - S
```
public static final Nucleotide S
```
  - W
```
public static final Nucleotide W
```
  - K
```
public static final Nucleotide K
```
  - M
```
public static final Nucleotide M
```
  - B
```
public static final Nucleotide B
```
  - D
```
public static final Nucleotide D
```
  - H
```
public static final Nucleotide H
```
  - V
```
public static final Nucleotide V
```
  - N
```
public static final Nucleotide N
```
  - X
```
public static final Nucleotide X
```
- Field Detail
  - U
```
public static final Nucleotide U
```
  - ADENINE
```
public static final Nucleotide ADENINE
```
  - CYTOSINE
```
public static final Nucleotide CYTOSINE
```
  - GUANINE
```
public static final Nucleotide GUANINE
```
  - THYMINE
```
public static final Nucleotide THYMINE
```
  - URACIL
```
public static final Nucleotide URACIL
```
  - STRONG
```
public static final Nucleotide STRONG
```
  - WEAK
```
public static final Nucleotide WEAK
```
  - PURINE
```
public static final Nucleotide PURINE
```
  - PYRIMIDINE
```
public static final Nucleotide PYRIMIDINE
```
  - AMINO
```
public static final Nucleotide AMINO
```
  - KETO
```
public static final Nucleotide KETO
```
  - ANY
```
public static final Nucleotide ANY
```
  - INVALID
```
public static final Nucleotide INVALID
```
  - STANDARD_BASES
```
public static final java.util.List<Nucleotide> STANDARD_BASES
```
    List of the standard (non-redundant) nucleotide values in their preferred alphabetical order.
- Method Detail
  - values
```
public static Nucleotide[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (Nucleotide c : Nucleotide.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static Nucleotide valueOf(java.lang.String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    
    name - the name of the enum constant to be returned.
    
    Returns:
    
    the enum constant with the specified name
    
    Throws:
    
    java.lang.IllegalArgumentException - if this enum type has no constant with the specified name
    
    java.lang.NullPointerException - if the argument is null
  - encodeAsByte
```
public byte encodeAsByte(boolean upperCase)
```
    Returns the byte typed encoding that corresponds to this nucleotide.
    
    Parameters:
    
    upperCase - whether to return the upper- or lower-case byte representation.
    
    Returns:
    
    a valid and exclusive byte representation for a nucleotide.
  - encodeAsChar
```
public char encodeAsChar(boolean upperCase)
```
    Returns the char typed encoding that corresponds to this nucleotide.
    
    Parameters:
    
    upperCase - whether to return the upper- or lower-case char representation.
    
    Returns:
    
    a valid and exclusive char representation for a nucleotide.
  - encodeAsByte
```
public byte encodeAsByte()
```
    Returns this nucleotide's exclusive upper-case byte encoding.
    
    Returns:
    
    ditto.
  - encodeAsChar
```
public char encodeAsChar()
```
    Returns the nucleotide's exclusive upper-case char encoding.
    
    Returns:
    
    ditto.
  - encodeAsString
```
public java.lang.String encodeAsString()
```
    Returns the nucleotide's exclusive upper-case String encoding.
    
    Returns:
    
    ditto.
  - encodeAsString
```
public java.lang.String encodeAsString(boolean upperCase)
```
    Returns the nucleotide's exclusive String typed encoding.
    
    Parameters:
    
    upperCase - whether the upper or lower-case representation should be returned.
    
    Returns:
    
    a valid and exclusive String representation for this nucleotide.
  - decode
```
public static Nucleotide decode(byte base)
```
    Returns the nucleotide that corresponds to a particular byte typed base code.
    
    Parameters:
    
    base - the query base code.
    
    Returns:
    
    never null, but INVALID if the base code does not correspond to a valid nucleotide specification.
  - decode
```
public static Nucleotide decode(char ch)
```
    Returns the nucleotide that corresponds to a particular char typed base code.
    
    Parameters:
    
    ch - the query base code.
    
    Returns:
    
    never null, but INVALID if the base code does not correspond to a valid nucleotide specification.
  - decode
```
public static Nucleotide decode(java.lang.CharSequence seq)
```
    Transform a single-letter character string into the corresponding nucleotide.
    Null, empty or multi-letter input will result in an IllegalArgumentException. These are not simply invalid encodings as the fact that are not a single character is an indication of a probable bug.
    
    Parameters:
    
    seq - the input character sequence to transform into.
    
    Returns:
    
    never null, perhaps INVALID to indicate that the input is not a valid single letter encoding encoding.
  - isStandard
```
public boolean isStandard()
```
    Checks whether the nucleotide refers to a concrete (rather than ambiguous) base.
    
    Returns:
    
    true iff this is a concrete nucleotide.
  - isAmbiguous
```
public boolean isAmbiguous()
```
    Checks whether the nucleotide refer to an ambiguous base.
    
    Returns:
    
    true iff this is an ambiguous nucleotide.
  - isValid
```
public boolean isValid()
```
    Whether this nucleotide code is valid or not.
    
    Returns:
    
    true iff valid.
  - includes
```
public boolean includes(Nucleotide other)
```
    Checks whether this nucleotide code encloses all possible nucleotides for another code.
    
    Parameters:
    
    other - the other nucleotide to compare to.
    
    Returns:
    
    true iff every nucleotide in other is enclosed in this code.
  - includes
```
public boolean includes(byte b)
```
    Checks whether this nucleotide code encloses all possible nucleotides for another code.
    
    Parameters:
    
    b - the other nucleotide to compare to encoded as a byte.
    
    Returns:
    
    true iff every nucleotide in other is enclosed in this code.
  - intersect
```
public Nucleotide intersect(Nucleotide other)
```
    Returns the nucleotide code that include all and only the nucleotides that are included by this another code.
    
    Parameters:
    
    other - the other nucleotide code.
    
    Returns:
    
    never null. Returns INVALID if the intersection does not contain any nucleotide.
    
    Throws:
    
    java.lang.IllegalArgumentException - if other is null.
  - intersect
```
public static boolean intersect(byte a,
                                byte b)
```
    Checks whether two nucleotides intersect given their byte encodings.
    
    Parameters:
    
    a - first nucleotide.
    
    b - second nucleotide.
    
    Returns:
    
    true iff the input nucleotides intersect.
  - same
```
public static boolean same(byte a,
                           byte b)
```
    Checks whether two base encodings make reference to the same Nucleotide(org.broadinstitute.hellbender.utils.Nucleotide...) instance regardless of their case.
    This method is a shorthand for:
```
decode(byte)(a)same(decode(byte)(b)) 
```
    .
    
    The order of the inputs is not relevant, therefore same(a, b) == same(b, a) for any given a and b.
    
    Notice that if either or both input bases make reference to an invalid nucleotide (i.e.
```
 decode(byte)(x) == INVALID},
      this method will return  false even if  a == b.
  
```
    Parameters:
    
    a - the first base to compare (however order is not relevant).
    
    b - the second base to compare (however order is not relevant).
    
    Returns:
    
    true iff {@link #decode}.same(decode(byte)(b))}}
  - same
```
public boolean same(Nucleotide other)
```
    Checks whether this and another Nucleotide(org.broadinstitute.hellbender.utils.Nucleotide...) make reference to the same nucleotide(s).
    In contrast with Enum.equals(java.lang.Object), this method will return false if any of the two, this or the input nucleotide is the INVALID enum value. So even
```
INVALID.same(INVALID)
```
    will return false.
    Parameters:
    
    other - the other nucleotide.
    
    Returns:
    
    true iff this and the input nucleotide make reference to the same nucleotides.
  - complement
```
public Nucleotide complement()
```
    Returns the complement nucleotide code for this one.
    For ambiguous nucleotide codes, this will return the ambiguous code that encloses the complement of each possible nucleotide in this code.
    
    The complement of the INVALID nucleotide is itself.
    
    Returns:
    
    never null.
  - complement
```
public static byte complement(byte b,
                              boolean upperCase)
```
    Returns the complement for a base code.
    When an invalid base is provided this method will return the input byte (lower- or upper-cased depending on that flag value).
    
    Parameters:
    
    b - the input base
    
    upperCase - whether to return the uppercase (true) or the lower case (false) byte encoding.
    
    Returns:
    
    the complement of the input.
  - complement
```
public static byte complement(byte b)
```
    Returns the complement for a base code.
    The case of the output will match the case of the input.
    
    When an invalid base is provided this method will return the input base byte.
    
    Parameters:
    
    b - the input base
    
    Returns:
    
    the complement of the input.
  - transition
```
public Nucleotide transition()
```
    Returns the instance that would include all possible transition mutations from this one.
    
    Returns:
    
    never null.
  - transversion
```
public Nucleotide transversion()
```
    Returns the instance that would include all possible tranversion mutations from nucleotides included in this one.
    
    Returns:
    
    never null.
  - transversion
```
public Nucleotide transversion(boolean strong)
```
    Transversion mutation toward a strong or a weak base.
    This method provides a non-ambiguous alternative to transversion() for concrete nucleotides.
    
    Parameters:
    
    strong - whether the result should be a strong (S: G, C) or weak (W: A, T) nucleotide(s).
    
    Returns:
    
    nucleotides that may emerged from such a transversion.

Enum Nucleotide

Nested Class Summary

Enum Constant Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Enum Constant Detail

A

C

G

T

R

Y

S

W

K

M

B

D

H

V

N

X

Field Detail

U

ADENINE

CYTOSINE

GUANINE

THYMINE

URACIL

STRONG

WEAK

PURINE

PYRIMIDINE

AMINO

KETO

ANY

INVALID

STANDARD_BASES

Method Detail

values

valueOf

encodeAsByte

encodeAsChar

encodeAsByte

encodeAsChar

encodeAsString

encodeAsString

decode

decode

decode

isStandard

isAmbiguous

isValid

includes

includes

intersect

intersect

same

same

complement

complement

complement

transition

transversion

transversion