GeneralizedSuffixTreeBuilder

Type Members

sealed abstract class WrappedSequence extends AnyRef

Represents a sequence that may contain a terminal symbol

Abstract Value Members

implicit abstract val cbf: CanBuildFrom[Repr, Alphabet, Repr]
abstract def generateUniqueTerminalSymbol(): TerminalSymbol

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++=(xs: TraversableOnce[Repr]): GeneralizedSuffixTreeBuilder.this.type

Definition Classes
Growable
def +=(elem: Repr): GeneralizedSuffixTreeBuilder.this.type

Definition Classes
GeneralizedSuffixTreeBuilder → Builder → Growable
def +=(elem1: Repr, elem2: Repr, elems: Repr*): GeneralizedSuffixTreeBuilder.this.type

Definition Classes
Growable
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object A
def C(n: Node): Int

The number of distinct leaf string identifiers in the subtree of v
The number of distinct leaf string identifiers in the subtree of v

Attributes
protected
object C
object I
object L
def N: Int

Number of nodes by their depth-first number in the tree
Number of nodes by their depth-first number in the tree

Attributes
protected
object WrappedSequence
var _C: Array[Int]

The number of distinct leaf string identifiers in the subtree of v
def addSequence(realseq: Repr): (SequenceID, WrappedSequence)
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bulkMultipleCommonSubsequence(): Iterator[(Int, Repr)]

Efficiently computes an iterator over the multiple common subsequences from this generalized suffix tree.
Efficiently computes an iterator over the multiple common subsequences from this generalized suffix tree.
Pre-processing of this algorithm has a linear-time complexity. It is fully described in section 9.7 "A linear-time solution to the multiple common substring problem" of Dan Gusfield's book "Algorithms on Strings, Trees, and Sequences" (1997).
returns
An iterator over the sequences along with their frequencies

Definition Classes
GeneralizedSuffixTreeBuilder → GeneralizedSuffixTree
def clear(): Unit

Definition Classes
GeneralizedSuffixTreeBuilder → Builder → Growable → Clearable
def clearLCAPreProcessing(): Unit

Clear variable pre-computed for the constant-time LCA retrieval process
Clear variable pre-computed for the constant-time LCA retrieval process

Attributes
protected
def clearMCSAPreProcessing(): Unit

Part of the MCSA pre-processing.
Part of the MCSA pre-processing.
Clear variable used in this processing ("clean slate")

Attributes
protected
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def computeA(): Unit

Part of the LCA pre-processing
Part of the LCA pre-processing

Attributes
protected
def computeIvAndLeaders(): Unit

Part of the LCA pre-processing
Part of the LCA pre-processing

Attributes
protected
def computeSvAndUv(hLCAcount: Array[Int]): Unit

Part of the MCSA pre-processing
Part of the MCSA pre-processing

Attributes
protected
def contains(pattern: Repr): Boolean

Determines if a pattern is contained in the suffix tree
Determines if a pattern is contained in the suffix tree

Definition Classes
GeneralizedSuffixTreeBuilder → GeneralizedSuffixTree
def countNewNode(): Unit

Attributes
protected
def currentSequenceID(): SequenceID
def depthFirstNumberingAndHv(): Unit

Part of the LCA pre-processing
Part of the LCA pre-processing

Attributes
protected
def dfsInternalNodes(): Iterable[Int]

Computes the set of internal nodes by their depth-first number (i.e., internal nodes and leaf nodes but not the root)
Computes the set of internal nodes by their depth-first number (i.e., internal nodes and leaf nodes but not the root)

Attributes
protected
def dfsNodes(): Iterable[Int]

Computes the set of nodes by their depth-first number (including root, internal nodes and leaf nodes)
Computes the set of nodes by their depth-first number (including root, internal nodes and leaf nodes)

Attributes
protected
def dfsToNode(dfs: Int): Node

Attributes
protected
object dfsToNode
def dropSequenceBy(id: SequenceID, n: Int): Repr
def edgeLabel(node: NonRootNode): Repr

Computes an edge-label on a built generalized suffix tree
Computes an edge-label on a built generalized suffix tree

Attributes
protected
def edgeLabelPartial(currentID: SequenceID, currentEnd: Int)(node: NonRootNode): Repr

Computes the edge label of a node taking into account the context of the Ukkonen's algorithm.
Computes the edge label of a node taking into account the context of the Ukkonen's algorithm.

Attributes
protected
Note
This method is not efficient and should NOT be used because it makes copies of subsequences
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(pattern: Repr): List[(SequenceID, Int)]

Determines the occurrences of a pattern in this suffix tree
Determines the occurrences of a pattern in this suffix tree
returns
A list of pairs containing the sequence ID and the position of the given sequence as a starting index (starting from 0, else an empty list

Definition Classes
GeneralizedSuffixTreeBuilder → GeneralizedSuffixTree
def findLongestCommonSubsequences(pattern: Repr): Seq[(Int, Int, Set[(SequenceID, Int)])]

Determines the longest common subsequences between a given pattern and the generalized suffix tree.
Determines the longest common subsequences between a given pattern and the generalized suffix tree.
For instance, given a suffix tree containing sequences:
- Scala|is|awesome|! (sequence 0)
- Programming|is|awesome|. (sequence 1)
- Scala|is|cool|! (sequence 2) And given a pattern: |Well|,|Scala|is|...|cool|!
It will return:
- (2, 4, Set((0, 0), (2, 0))) i.e. the position of subpattern Scala|is in sequences 0 and 2
- (5, 7, Set((2, 2))) i.e. the position of subpattern cool|! in sequence 2
returns
an empty list if the longest common subsequence does not exist, else a list of triple containing the starting index (inclusive, starting from 0), the end index (exclusive) and the set of sequence IDs containing this subsequence along with the starting position of the (sub)pattern in the sequence (starting from 0).

Definition Classes
GeneralizedSuffixTreeBuilder → GeneralizedSuffixTree
def fullSequences(): Iterator[Repr]

Computes an iterator over the full sequences of this generalized suffix tree
Computes an iterator over the full sequences of this generalized suffix tree

Definition Classes
GeneralizedSuffixTreeBuilder → GeneralizedSuffixTree
def generateSequenceID(): SequenceID

Attributes
protected
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getItemI(id: SequenceID, index: Int): Either[Alphabet, TerminalSymbol]
def getItemLabel(node: NonRootNode, i: Int): Either[Alphabet, TerminalSymbol]

Retrieves the ith item on the edge label to the given node
Retrieves the ith item on the edge label to the given node

Attributes
protected
Note
this method does not check for out-of-bounds error
def getSequenceBy(id: SequenceID): Repr

Retrieves a sequence by a given ID
Retrieves a sequence by a given ID

Definition Classes
GeneralizedSuffixTreeBuilder → GeneralizedSuffixTree
def getSequenceIDS(): Iterable[SequenceID]
def getSequenceLengthBy(id: SequenceID): Int
def getSubsequenceBy(id: SequenceID, from: Int, until: Int): Repr
def hashCode(): Int

Definition Classes
AnyRef → Any
def insert(preseq: Repr): Unit
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def label(node: NonRootNode): Repr

Computes the full label from the root to the given node on a built generalized suffix tree
Computes the full label from the root to the given node on a built generalized suffix tree

Attributes
protected
def labelLength(node: NonRootNode): Int

Computes the length of an edge-label on a built generalized suffix tree
Computes the length of an edge-label on a built generalized suffix tree

Attributes
protected
def labelLengthPartial(currentID: SequenceID, currentEnd: Int)(node: NonRootNode): Int

Attributes
protected
def labelPartial(currentID: SequenceID, currentEnd: Int)(node: NonRootNode): Repr

Computes the path from the root to a given node.
Computes the path from the root to a given node.

Attributes
protected
Note
This method is costly in computational time (in other words, inefficient).
def labels(currentID: SequenceID, currentEnd: Int)(node: NonRootNode): String

Attributes
protected
def labels(node: NonRootNode): String

Computes an informative label containing the edge-label, the path from the root and the count C(node) if it exists on a built generalized suffix tree
Computes an informative label containing the edge-label, the path from the root and the count C(node) if it exists on a built generalized suffix tree

Attributes
protected
def lca(x: Int, y: Int): Int

Computes the lowest common ancestor to two given nodes identified by their depth-first number (constant-time LCA retrieval)
Computes the lowest common ancestor to two given nodes identified by their depth-first number (constant-time LCA retrieval)

Attributes
protected
def lca(node1: Node, node2: Node): Node

Computes the lowest common ancestor of two given nodes (constant-time LCA retrieval)
Computes the lowest common ancestor of two given nodes (constant-time LCA retrieval)

Attributes
protected
def mapResult[NewTo](f: (GeneralizedSuffixTree[Alphabet, Repr]) ⇒ NewTo): Builder[Repr, NewTo]

Definition Classes
Builder
def mkString: String
def multipleCommonSubsequence(): CommonSubsequences[Repr]

Computes the multiple common subsequence from this generalized suffix tree.
Computes the multiple common subsequence from this generalized suffix tree.
This method is NOT efficient for large tree, see bulkMultipleCommonSubsequence instead.
Pre-processing of this algorithm has a linear-time complexity. It is fully described in section 9.7 "A linear-time solution to the multiple common substring problem" of Dan Gusfield's book "Algorithms on Strings, Trees, and Sequences" (1997).

Definition Classes
GeneralizedSuffixTreeBuilder → GeneralizedSuffixTree
def nSuffixes(): Int

Number of suffixes in this generalized suffix tree
Number of suffixes in this generalized suffix tree

Definition Classes
GeneralizedSuffixTreeBuilder → GeneralizedSuffixTree
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
var nodeCount: Int

Attributes
protected
object nodeToDFS

Mapping: node to depth-first search numbers
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def numberOfNodes(): Int

Attributes
protected
def preProcessingLCA(): Unit

Linear time pre-processing for LCA constant-time retrieval.
Linear time pre-processing for LCA constant-time retrieval.
This pre-processing is fully described in chapter 8 "Constant-Time Lowest Common Ancestor Retrieval" of Dan Gusfield's book "Algorithms on Strings, Trees, and Sequences" (1997).

Attributes
protected
def preprocessingMultipleCommonSubsequence(): Unit

Pre-processing of the Multiple Common Subsequence Algorithm (MCSA)
Pre-processing of the Multiple Common Subsequence Algorithm (MCSA)
This pre-processing is fully described in section 9.7 "A linear-time solution to the multiple common substring problem" of Dan Gusfield's book "Algorithms on Strings, Trees, and Sequences" (1997).

Attributes
protected
def result(): GeneralizedSuffixTree[Alphabet, Repr]

Definition Classes
GeneralizedSuffixTreeBuilder → Builder
var root: Root

Attributes
protected
def size(): Int

Number of sequences in this suffix tree
Number of sequences in this suffix tree

Definition Classes
GeneralizedSuffixTreeBuilder → GeneralizedSuffixTree
def sizeHint(coll: TraversableLike[_, _], delta: Int): Unit

Definition Classes
Builder
def sizeHint(coll: TraversableLike[_, _]): Unit

Definition Classes
Builder
def sizeHint(size: Int): Unit

Definition Classes
Builder
def sizeHintBounded(size: Int, boundingColl: TraversableLike[_, _]): Unit

Definition Classes
Builder
def start(node: NonRootNode): Either[Alphabet, TerminalSymbol]

Attributes
protected
object stringDepth
def suffixes(): Iterator[Repr]

Computes an iterator over the suffixes of this generalized suffix tree
Computes an iterator over the suffixes of this generalized suffix tree

Definition Classes
GeneralizedSuffixTreeBuilder → GeneralizedSuffixTree
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def toggleRequirePreprocessing(): Unit

Attributes
protected
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object GeneralizedSuffixTreeBuilder | package gstlib

sealed abstract class GeneralizedSuffixTreeBuilder[Alphabet, Repr] extends GeneralizedSuffixTree[Alphabet, Repr] with Builder[Repr, GeneralizedSuffixTree[Alphabet, Repr]]

Type Members

sealed abstract class WrappedSequence extends AnyRef

Abstract Value Members

implicit abstract val cbf: CanBuildFrom[Repr, Alphabet, Repr]

abstract def generateUniqueTerminalSymbol(): TerminalSymbol

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++=(xs: TraversableOnce[Repr]): GeneralizedSuffixTreeBuilder.this.type

def +=(elem: Repr): GeneralizedSuffixTreeBuilder.this.type

def +=(elem1: Repr, elem2: Repr, elems: Repr*): GeneralizedSuffixTreeBuilder.this.type

final def ==(arg0: Any): Boolean

object A

def C(n: Node): Int

object C

object I

object L

def N: Int

object WrappedSequence

var _C: Array[Int]

def addSequence(realseq: Repr): (SequenceID, WrappedSequence)

final def asInstanceOf[T0]: T0

def bulkMultipleCommonSubsequence(): Iterator[(Int, Repr)]

def clear(): Unit

def clearLCAPreProcessing(): Unit

def clearMCSAPreProcessing(): Unit

def clone(): AnyRef

def computeA(): Unit

def computeIvAndLeaders(): Unit

def computeSvAndUv(hLCAcount: Array[Int]): Unit

def contains(pattern: Repr): Boolean

def countNewNode(): Unit

def currentSequenceID(): SequenceID

def depthFirstNumberingAndHv(): Unit

def dfsInternalNodes(): Iterable[Int]

def dfsNodes(): Iterable[Int]

def dfsToNode(dfs: Int): Node

object dfsToNode

def dropSequenceBy(id: SequenceID, n: Int): Repr

def edgeLabel(node: NonRootNode): Repr

def edgeLabelPartial(currentID: SequenceID, currentEnd: Int)(node: NonRootNode): Repr

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def find(pattern: Repr): List[(SequenceID, Int)]

def findLongestCommonSubsequences(pattern: Repr): Seq[(Int, Int, Set[(SequenceID, Int)])]

def fullSequences(): Iterator[Repr]

def generateSequenceID(): SequenceID

final def getClass(): Class[_]

def getItemI(id: SequenceID, index: Int): Either[Alphabet, TerminalSymbol]

def getItemLabel(node: NonRootNode, i: Int): Either[Alphabet, TerminalSymbol]

def getSequenceBy(id: SequenceID): Repr

def getSequenceIDS(): Iterable[SequenceID]

def getSequenceLengthBy(id: SequenceID): Int

def getSubsequenceBy(id: SequenceID, from: Int, until: Int): Repr

def hashCode(): Int

def insert(preseq: Repr): Unit

final def isInstanceOf[T0]: Boolean

def label(node: NonRootNode): Repr

def labelLength(node: NonRootNode): Int

def labelLengthPartial(currentID: SequenceID, currentEnd: Int)(node: NonRootNode): Int

def labelPartial(currentID: SequenceID, currentEnd: Int)(node: NonRootNode): Repr

def labels(currentID: SequenceID, currentEnd: Int)(node: NonRootNode): String

def labels(node: NonRootNode): String

def lca(x: Int, y: Int): Int

def lca(node1: Node, node2: Node): Node

def mapResult[NewTo](f: (GeneralizedSuffixTree[Alphabet, Repr]) ⇒ NewTo): Builder[Repr, NewTo]

def mkString: String

def multipleCommonSubsequence(): CommonSubsequences[Repr]

def nSuffixes(): Int

final def ne(arg0: AnyRef): Boolean

var nodeCount: Int

object nodeToDFS

final def notify(): Unit

final def notifyAll(): Unit

def numberOfNodes(): Int

def preProcessingLCA(): Unit