The comparison operator.

Returns -1, 0 or 1 depending on whether self precedes rhs, equals to rhs or comes after rhs. The comparison is done based on chain id, residue number, and insertion code if present.

residues = Structure.read "peptide.pdb"
residues[0] # => <Residue A:TRP1>
residues[1] # => <Residue A:GLY1A>
residues[2] # => <Residue A:SER1B>
residues[3] # => <Residue A:ASN1C>
residues[4] # => <Residue A:VAL2>
residues[5] # => <Residue B:THR1>
residues[6] # => <Residue B:ASN2>

residues[0] <=> residues[1] # => -1
residues[1] <=> residues[1] # => 0
residues[2] <=> residues[1] # => 1
residues[0] <=> residues[5] # => -1
residues[5] <=> residues[6] # => -1

Returns true if this residue is the same as rhs, else false.

NOTE overrides the equality operator included by Comparable, which uses the <=> operator thus returning true for two different residues that have the same chain id, number and insertion code.

Returns the atom that matches atom_t.

Atom must match both atom template's name and element, otherwise it raises IndexError.

residue = Structure.read("peptide.pdb").residues[0]
residue[Templates::Atom("CA")]               # => <Atom A:TRP1:CA(2)
residue[Templates::Atom("CA", element: "N")] # raises IndexError
residue[Templates::Atom("CX")]               # raises IndexError

Returns the atom that matches atom_t.

Atom must match both atom template's name and element, otherwise it returns nil.

residue = Structure.read("peptide.pdb").residues[0]
residue[Templates::Atom("CA")]               # => <Atom A:TRP1:CA(2)
residue[Templates::Atom("CA", element: "N")] # => nil
residue[Templates::Atom("CX")]               # => nil

Returns true if self is bonded to other through bond_t, otherwise false.

# Covalent ligand (JG7) is bonded to CYS sidechain
residues = Structure.read("ala-cys-thr-jg7.pdb").residues
bond_t = Templates::Bond.new "C", "N"
residues[0].bonded?(residues[1], bond_t) # => true
residues[1].bonded?(residues[2], bond_t) # => true
residues[2].bonded?(residues[3], bond_t) # => false
residues[1].bonded?(residues[3], bond_t) # => false

Bond check follows the directionality of bond_t, that is, the left and right atoms are looked up in self and other, respectively:

residues[0].bonded?(residues[1], bond_t) # => true
residues[1].bonded?(residues[0], bond_t) # => false

Note that bond order is taken into account, e.g.:

bond_t = Templates::Bond.new "C", "N", order: 2
residues[0].bonded?(residues[1], bond_t) # => false

If strict is false, it uses elements only instead to look for bonded atoms, and bond order is ignored.

bond_t = Templates::Bond.new "C", "NX", order: 2
residues[0].bonded?(residues[1], bond_t)                # => false
residues[0].bonded?(residues[1], bond_t, strict: false) # => true

Returns true if self is bonded to other through a bond between lhs and rhs, otherwise false.

# Covalent ligand (JG7) is bonded to CYS sidechain
residues = Structure.read("ala-cys-thr-jg7.pdb").residues

One can use atom names, atom template, or elements:

a, b = Templates::Atom.new("C"), Templates::Atom.new("N")
residues[0].bonded? residues[1], "C", "N"            # => true
residues[0].bonded? residues[1], a, b                # => true
residues[0].bonded? residues[1], a, PeriodicTable::N # => true
residues[0].bonded? residues[1], PeriodicTable::C, b # => true
residues[1].bonded? residues[2], a, b                # => true
residues[1].bonded? residues[3], a, b                # => false
residues[2].bonded? residues[3], a, b                # => false

Note that lhs and rhs are looked up in self and other, respectively, i.e., the arguments are not interchangeable:

residues[0].bonded? residues[1], "C", "N" # => true
residues[0].bonded? residues[1], "N", "C" # => false

When atom names or atom template are specified, this method returns false if missing:

missing_atom_t = Templates::Atom.new("OZ5")
residues[0].bonded? residues[1], "CX1", "N"             # => false
residues[0].bonded? residues[1], missing_atom_t, "N"    # => false
residues[0].bonded? residues[1], "C", PeriodicTable::Mg # => false

When elements are specified, all atoms of that element are tested:

residues[1].bonded? residues[2], "C", PeriodicTable::N  # => true
residues[1].bonded? residues[2], "SG", PeriodicTable::C # => true

If order is specified, it also check for bond order, otherwise it is ignored:

residues[0].bonded? residues[1], "C", "N"    # => true
residues[0].bonded? residues[1], "C", "N", 1 # => true
residues[0].bonded? residues[1], "C", "N", 2 # => false

Returns true if self is bonded to other through a bond between lhs and rhs, otherwise false.

# Covalent ligand (JG7) is bonded to CYS sidechain
residues = Structure.read("ala-cys-thr-jg7.pdb").residues

One can use atom names, atom template, or elements:

a, b = Templates::Atom.new("C"), Templates::Atom.new("N")
residues[0].bonded? residues[1], "C", "N"            # => true
residues[0].bonded? residues[1], a, b                # => true
residues[0].bonded? residues[1], a, PeriodicTable::N # => true
residues[0].bonded? residues[1], PeriodicTable::C, b # => true
residues[1].bonded? residues[2], a, b                # => true
residues[1].bonded? residues[3], a, b                # => false
residues[2].bonded? residues[3], a, b                # => false

Note that lhs and rhs are looked up in self and other, respectively, i.e., the arguments are not interchangeable:

residues[0].bonded? residues[1], "C", "N" # => true
residues[0].bonded? residues[1], "N", "C" # => false

When atom names or atom template are specified, this method returns false if missing:

missing_atom_t = Templates::Atom.new("OZ5")
residues[0].bonded? residues[1], "CX1", "N"             # => false
residues[0].bonded? residues[1], missing_atom_t, "N"    # => false
residues[0].bonded? residues[1], "C", PeriodicTable::Mg # => false

When elements are specified, all atoms of that element are tested:

residues[1].bonded? residues[2], "C", PeriodicTable::N  # => true
residues[1].bonded? residues[2], "SG", PeriodicTable::C # => true

If order is specified, it also check for bond order, otherwise it is ignored:

residues[0].bonded? residues[1], "C", "N"    # => true
residues[0].bonded? residues[1], "C", "N", 1 # => true
residues[0].bonded? residues[1], "C", "N", 2 # => false

Returns true if self is bonded to other through a bond between lhs and rhs, otherwise false.

# Covalent ligand (JG7) is bonded to CYS sidechain
residues = Structure.read("ala-cys-thr-jg7.pdb").residues

One can use atom names, atom template, or elements:

a, b = Templates::Atom.new("C"), Templates::Atom.new("N")
residues[0].bonded? residues[1], "C", "N"            # => true
residues[0].bonded? residues[1], a, b                # => true
residues[0].bonded? residues[1], a, PeriodicTable::N # => true
residues[0].bonded? residues[1], PeriodicTable::C, b # => true
residues[1].bonded? residues[2], a, b                # => true
residues[1].bonded? residues[3], a, b                # => false
residues[2].bonded? residues[3], a, b                # => false

Note that lhs and rhs are looked up in self and other, respectively, i.e., the arguments are not interchangeable:

residues[0].bonded? residues[1], "C", "N" # => true
residues[0].bonded? residues[1], "N", "C" # => false

When atom names or atom template are specified, this method returns false if missing:

missing_atom_t = Templates::Atom.new("OZ5")
residues[0].bonded? residues[1], "CX1", "N"             # => false
residues[0].bonded? residues[1], missing_atom_t, "N"    # => false
residues[0].bonded? residues[1], "C", PeriodicTable::Mg # => false

When elements are specified, all atoms of that element are tested:

residues[1].bonded? residues[2], "C", PeriodicTable::N  # => true
residues[1].bonded? residues[2], "SG", PeriodicTable::C # => true

If order is specified, it also check for bond order, otherwise it is ignored:

residues[0].bonded? residues[1], "C", "N"    # => true
residues[0].bonded? residues[1], "C", "N", 1 # => true
residues[0].bonded? residues[1], "C", "N", 2 # => false

Returns true if self is bonded to other through a bond between lhs and rhs, otherwise false.

# Covalent ligand (JG7) is bonded to CYS sidechain
residues = Structure.read("ala-cys-thr-jg7.pdb").residues

One can use atom names, atom template, or elements:

a, b = Templates::Atom.new("C"), Templates::Atom.new("N")
residues[0].bonded? residues[1], "C", "N"            # => true
residues[0].bonded? residues[1], a, b                # => true
residues[0].bonded? residues[1], a, PeriodicTable::N # => true
residues[0].bonded? residues[1], PeriodicTable::C, b # => true
residues[1].bonded? residues[2], a, b                # => true
residues[1].bonded? residues[3], a, b                # => false
residues[2].bonded? residues[3], a, b                # => false

Note that lhs and rhs are looked up in self and other, respectively, i.e., the arguments are not interchangeable:

residues[0].bonded? residues[1], "C", "N" # => true
residues[0].bonded? residues[1], "N", "C" # => false

When atom names or atom template are specified, this method returns false if missing:

missing_atom_t = Templates::Atom.new("OZ5")
residues[0].bonded? residues[1], "CX1", "N"             # => false
residues[0].bonded? residues[1], missing_atom_t, "N"    # => false
residues[0].bonded? residues[1], "C", PeriodicTable::Mg # => false

When elements are specified, all atoms of that element are tested:

residues[1].bonded? residues[2], "C", PeriodicTable::N  # => true
residues[1].bonded? residues[2], "SG", PeriodicTable::C # => true

If order is specified, it also check for bond order, otherwise it is ignored:

residues[0].bonded? residues[1], "C", "N"    # => true
residues[0].bonded? residues[1], "C", "N", 1 # => true
residues[0].bonded? residues[1], "C", "N", 2 # => false

Returns true if self is bonded to other, otherwise false. Residues may be bonded by any two atoms.

# Covalent ligand (JG7) is bonded to CYS sidechain
residues = Structure.read("ala-cys-thr-jg7.pdb").residues
residues[0].bonded?(residues[1]) # => true
residues[1].bonded?(residues[2]) # => true
residues[2].bonded?(residues[3]) # => false
residues[1].bonded?(residues[3]) # => true

Returns residues bonded through bond_t. Residues are ordered by their chain id, residue number and insertion code if present (refer to #<=>).

# Covalent ligand (JG7) is bonded to CYS sidechain
residues = Structure.read("ala-cys-thr-jg7.pdb").residues
bond_t = Templates::Bond.new("C", "N")
residues[0].bonded_residues(bond_t).map(&.name) # => ["CYS"]
residues[1].bonded_residues(bond_t).map(&.name) # => ["THR"]
residues[2].bonded_residues(bond_t).map(&.name) # => []
residues[3].bonded_residues(bond_t).map(&.name) # => []

If forward_only is false, then bond directionality is ignored:

residues[0].bonded_residues(bond_t, forward_only: false).map(&.name) # => ["CYS"]
residues[1].bonded_residues(bond_t, forward_only: false).map(&.name) # => ["ALA", "THR"]
residues[2].bonded_residues(bond_t, forward_only: false).map(&.name) # => ["CYS"]
residues[3].bonded_residues(bond_t, forward_only: false).map(&.name) # => []

If strict is false, bond search checks elements only, and bond order is ignored (fuzzy search). In the following example, using strict: false makes that any C-N bond is accepted regardless of atom names or bond order:

bond_t = Templates::Bond.new "C", "NX", order: 2
residues[0].bonded_residues(bond_t, strict: false).map(&.name) # => ["CYS"]
residues[1].bonded_residues(bond_t, strict: false).map(&.name) # => ["THR"]
residues[2].bonded_residues(bond_t, strict: false).map(&.name) # => []
residues[3].bonded_residues(bond_t, strict: false).map(&.name) # => []

Returns bonded residues. Residues may be bonded through any atom. Residues are ordered by their chain id, residue number and insertion code if present (refer to #<=>).

# Covalent ligand (JG7) is bonded to CYS sidechain
residues = Structure.read("ala-cys-thr-jg7.pdb").residues
residues[0].bonded_residues.map(&.name) # => ["CYS"]
residues[1].bonded_residues.map(&.name) # => ["ALA", "THR", "JG7"]
residues[2].bonded_residues.map(&.name) # => ["CYS"]
residues[3].bonded_residues.map(&.name) # => ["CYS"]

Returns a single-letter code associated with the residue's template. If the residue has no associated template or it doesn't have a code, the method returns default.

Returns true is residue is dextrorotatory, otherwise false.

A residue is considered to be dextrorotatory if the improper angle C-CA-C-CB is negative.

Note that this method returns false if the residue doesn't have any of such atoms, therefore it's not always equal to the inverse of #levo?.

Returns true if the residue is a DNA residue, else false.

Yields each residue bonded through bond_t.

If forward_only is false, then bond directionality is ignored.

If strict is false, bond search checks elements only, and bond order is ignored (fuzzy search).

See #bonded_residues(bond_t, forward_only, strict) for examples.

Yields each bonded residue. Residues may be bonded through any atom.

See #bonded_residues for examples.

Returns true if the residue is a non-standard (HET) residue, else false.

Returns true if the residue contains atom, else false.

The check is done by name first, and then by atom equality.

Returns true if the residue is a ion residue, else false.

Returns true is residue is levorotatory, otherwise false.

A residue is considered to be levorotatory if the improper angle C-CA-C-CB is positive.

Note that this method returns false if the residue doesn't have any of such atoms, therefore it's not always equal to the inverse of #dextro?.

Returns true if the residue is a membrane residue, else false.

Returns true if the residue is an unknown residue, else false.

Returns the preceding residue if exists, else raises Error. Refer to #pred? for details.

Returns the preceding residue if exists, otherwise nil.

It uses the link bond type of the associated residue template, if present, to search for the previous residue. Thus, link bond determines the direction, e.g., C(i-1)-N(i). Be aware that atom types must match exactly to find a residue unless strict is false.

Otherwise, it returns a bonded residue whose number and insertion code come just before those of self. This fallback can be disabled by setting use_numbering to false.

Note that when multiple residues can be connected to the same residue (e.g., branched polymers), it returns the last residue among them.

Returns true if the residue is a protein residue, else false.

Returns true if the residue is a solvent residue, else false.

Writes the residue specification to the given IO.

Residue specification is a short string representation encoding residue information including chain, name, number, and insertion code.

Returns the residue specification.

Residue specification is a short string representation encoding residue information including chain, name, number, and insertion code.

Returns the following residue if exists, else raises Error. Refer to #succ? for details.

Returns the following residue if exists, otherwise nil.

It uses the link bond type of the associated residue template, if present, to search for the next residue. Thus, link bond determines the direction, e.g., C(i)-N(i+1). Be aware that atom types must match exactly to find a residue unless strict is false.

Otherwise, it returns a bonded residue whose number and insertion code come just after those of self. This fallback can be disabled by setting use_numbering to false.

Note that when multiple residues can be connected to the same residue (e.g., branched polymers), it returns the first residue among them.

Returns associated residue template if registered, otherwise nil.

The template is fetched by the residue name.

Appends a short String representation of this object which includes its class name and its object address.

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).to_s # => #<Person:0x10a199f20>

Returns true if the residue is a water residue, else false. This is done by checking if the associated residue template (if any) correspond to the water template.