# doc-cache created by Octave 9.2.0
# name: cache
# type: cell
# rows: 3
# columns: 10
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
aa2int


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 245
 -- Function File: SEQUENCEINT = aa2int (SEQUENCECHAR)
     Convert amino acid characters into integers.  See ‘aminolookup’ for
     the listing of numbers and their corresponding characters.

     See also: aminolookup,int2aa,int2nt,nt2int.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Convert amino acid characters into integers.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
aminolookup


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 803
 -- Function File: aminolookup ()
 -- Function File: AMINODESC = aminolookup (SEQ)
 -- Function File: AMINODESC = aminolookup (SEARCHTYPE, SEQ)
     Convert between amino acid representations.  The types of input are

        • Name

          The amino acid name
        • Code

          The amino acid single letter code
        • Abbreviation

          The three letter abbreviation for the amino acid
        • Integer

          The number representation of the amino acid

     To see the full list of each of the above, run this function
     without any arguments or outputs.

     If called without zero inputs, this will display the mapping
     between the above types.  If called with one input, it will convert
     to code by default.

     See also: aa2int,int2aa,int2nt,nt2int.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Convert between amino acid representations.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
cleave


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1233
 -- Function File: FRAGMENTS = cleave (SEQUENCE, PATTERN, POSITION)
 -- Function File: [FRAGMENTS, CUTTINGSITES] = cleave (...)
 -- Function File: [FRAGMENTS, CUTTINGSITES, LENGTHS] = cleave (...)
 -- Function File: [...] = cleave (..., 'PartialDigest', PROB)
     Cleave a peptide SEQUENCE using the PATTERN at the POSITION
     relative to the pattern.  The SEQUENCE is a sequence of amino
     acids; the PATTERN is a regular expression to find the location of
     the cleavage; and the POSITION is the position relative to that
     regular expression (0 is immediately to the left of the first
     character, 1 is immediately to the right of the first character,
     ...).

     Example regular expressions for some commone proteases are given
     below.

     Protease                             Peptide Pattern        Position
     Trypsin                              [KR](?!P)              1
     Chymotrypsin                         [WYF](?!P)             1
     Glutamine C                          [ED](?!P)              1
     Lysine C                             [K](?!P)               1
     Aspartic acid N                      D                      1

     See also: rebasecuts, restrict, seqshowwords, regexp.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Cleave a peptide SEQUENCE using the PATTERN at the POSITION relative to
the p...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
fastaread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 753
 FASTAREAD reads fasta data

 Usage:
	FASTADATA = fastaread(filename)
	... = fastaread(..., 'TrimHeaders', TrimHeadersValue, ...)
	... = fastaread(..., 'IgnoreGaps', IgnoreGapsValue, ...)
	... = fastaread(..., 'Blockread', BlockreadValue, ...)
	[headers, seqs] = fastaread(...)

    TrimHeadersValue: default 0 (false), if it is non-zero,
	header strings are truncated at 1st white space character (<tab> or <space>)
    HeaderOnly: default 0 (false),
       if it is non-zero, seqs and quality are not reported
    BlockreadValue: default [], reads all blocks
       in case of a scalar N, only N-th block is returned
       in case of [N1,N2], all blocks from N1:N2 are returned.
       N2 can be infinite, than all blocks from N1 to the end are read



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 FASTAREAD reads fasta data



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
fastqread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 762
 FASTQREAD reads fastq data

 Usage:
	FASTQDATA = fastqread(filename)
	... = fastqread(..., 'TrimHeaders', TrimHeadersValue, ...)
	... = fastqread(..., 'HeaderOnly', HeaderOnlyValue, ...)
	... = fastqread(..., 'Blockread', BlockreadValue, ...)
	[headers, seqs, quality] = fastqread(...)

    TrimHeadersValue: default 0 (false), if it is non-zero,
	header strings are truncated at 1st white space character (<tab> or <space>)
    HeaderOnly: default 0 (false),
       if it is non-zero, seqs and quality are not reported
    BlockreadValue: default [], reads all blocks
       in case of a scalar N, only N-th block is returned
       in case of [N1,N2], all blocks from N1:N2 are returned.
       N2 can be infinite, than all blocks from N1 to the end are read



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 FASTQREAD reads fastq data



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
getpdb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 360
 GETPDB retrieves protein structure from the protein data base PDB

 PDBStruct = getpdb(PDBid)
 PDBStruct = getpdb(PDBid, ...'ToFile', ToFileValue, ...)
 PDBStruct = getpdb(PDBid, ...'SequenceOnly', SequenceOnlyValue, ...)
 
 https://files.rcsb.org/download/6EUV.pdb.gz

  R=getpdb('6EUV');

 Reference(s):
  [1] http://www.wwpdb.org/documentation/file-format



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
 GETPDB retrieves protein structure from the protein data base PDB



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
graphtraverse


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1224
 GRAPHTRAVERSE traverses a graph by following adjacent nodes
   by implementing the ideas according to the methods as described
   in [1-3].

 Usage:
	[disc, pred, closed] = graphtraverse(G, S)
	[...] = graphtraverse(..., 'Depth', DepthValue, ...)
	[...] = graphtraverse(..., 'Directed', DirectedValue, ...)
	[...] = graphtraverse(..., 'Method', MethodValue, ...)

 Input:
	G	NxN sparse matrix, edges are indicated by non-zero entries
	S	starting node number
       MethodValue:
		'DFS' Depth-first-search (default) 
               'BFS' Breadth-first-search
	DepthValue:	depth of search, (default is Inf)	
	DirectedValue:
		True: (default) G is a directed graph
		False: G undirected graph, (upper triangle is ignored) 

 Output:
	disc 	vector containing node indices in the order of their discovery
	pred	predecessor node indices
       closed	vector of node indices in closing order
   NOTE: For the DFS method, the result of "closed"
        can differ from the Matlab version - most likely because
        a non-recursive algorithm is used [1].

 References:
 [1] https://en.wikipedia.org/wiki/Depth-first_search
 [2] https://en.wikipedia.org/wiki/Breadth-first_search
 [3] https://en.wikipedia.org/wiki/Tree_traversal



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 GRAPHTRAVERSE traverses a graph by following adjacent nodes
   by implementi...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
int2aa


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 245
 -- Function File: SEQUENCECHAR = int2aa (SEQUENCEINT)
     Convert amino acid integers into characters.  See ‘aminolookup’ for
     the listing of numbers and their corresponding characters.

     See also: aminolookup,aa2int,int2nt,nt2int.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Convert amino acid integers into characters.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
pdbread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 248
 PDBREAD retrieves protein structure from the protein data base PDB

 PDBStruct = pdbread(file)
 PDBStruct = pdbread(file, 'ModelNum', ModelNumValue)

  R=pdbread('6euv.pdb.gz');

 Reference(s):
  [1] http://www.wwpdb.org/documentation/file-format



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
 PDBREAD retrieves protein structure from the protein data base PDB



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
seqreverse


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 282
 -- Function File: SEQR = seqreverse (SEQF)
     Reverse a nucleotide sequence.  SEQF can be either a numeric or
     code DNA or RNA sequence or a struct with the field sequence, and
     it will reverse the direction of the sequence.

     See also: seqcomplement, seqrcomplement.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Reverse a nucleotide sequence.





