RuleTopology

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def chain(r: Int): IndexedSeq[String]

def child(r: Int): Int

Returns the child label index from the (unary) rule index

def clone(): AnyRef

def decode[V](array: SparseArray[V]): Map[Rule[L], V]

def decode[V](array: Array[V]): Map[Rule[L], V]

def decode(v: Vector[Double], keepZeros: Boolean): Counter[Rule[L], Double]

def encode(c: Tensor[(Rule[L], Rule[L]), Double]): DenseMatrix[Double]

def encode(c: Tensor[Rule[L], Double], ignoreOutOfIndex: Boolean): Vector[Double]

def encodeDense(c: Tensor[Rule[L], Double], ignoreOutOfIndex: Boolean): DenseVector[Double]

def encodeSparse(c: Tensor[Rule[L], Double], ignoreOutOfIndex: Boolean): SparseVector[Double]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fillArray[V](default: ⇒ V)(implicit arg0: ClassTag[V]): Array[V]

def fillSparseArrayMap[V](default: ⇒ V)(implicit arg0: ClassTag[V], arg1: Zero[V]): SparseArrayMap[V]

final def getClass(): Class[_]

def hashCode(): Int

val index: Index[Rule[L]]

def indexedBinaryRulesWithLeftChild(b: Int): Array[Int]

Gives all binary rule indices with this left child

def indexedBinaryRulesWithParent(l: Int): Array[Int]

Gives all binary rule indices with this parent

def indexedBinaryRulesWithRightChild(c: Int): Array[Int]

Gives all binary rule indices with this right child

def indexedRule(r: Int): Rule[Int]

val indexedRules: Array[Rule[Int]]

def indexedUnaryRulesWithChild(l: Int): Array[Int]

Gives all unary rule indices with this child

def indexedUnaryRulesWithParent(l: Int): Array[Int]

Gives all unary rule indices with this parent

def isBinary(r: Int): Boolean

final def isInstanceOf[T0]: Boolean

def labelEncoder: Encoder[L]

val labelIndex: Index[L]

def leftChild(r: Int): Int

Returns the left child label index from the rule index

def mkArray[V](implicit arg0: ClassTag[V]): Array[V]

final def mkDenseVector(default: Double): DenseVector[Double]

final def mkMatrix(): DenseMatrix[Double]

def mkSparseArray[V](implicit arg0: ClassTag[V], arg1: Zero[V]): SparseArray[V]

def mkSparseVector(): SparseVector[Double]

final def mkVector(): Vector[Double]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parent(r: Int): Int

Returns the parent label index from the rule index

def prettyString: String

def rightChild(r: Int): Int

Returns the right child label index from the rule index

val root: L

val rootIndex: Int

final def synchronized[T0](arg0: ⇒ T0): T0

def tabulateArray[V](f: (Rule[L]) ⇒ V)(implicit arg0: ClassTag[V]): Array[V]

def tabulateDenseVector(f: (Rule[L]) ⇒ Double): DenseVector[Double]

def toString(): String

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit