ProductGrammarAnchoring

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(other: UnrefinedGrammarAnchoring[L, W]): GrammarAnchoring[L, W]

def *(other: GrammarAnchoring[L, W]): GrammarAnchoring[L, W]

Computes the pointwise product of two grammars, augmenting their refinement space to reflect this.

def /(other: GrammarAnchoring[L, W]): GrammarAnchoring[L, W]

Computes the pointwise division of two grammars, augmenting their refinement space to reflect this.

final def ==(arg0: Any): Boolean

def addConstraints(constraints: ChartConstraints[L]): GrammarAnchoring[L, W]

val alpha: Double

def annotationTag: Int

The annotationTag controls if two grammars are over the same refinements.

final def asInstanceOf[T0]: T0

def childRefinement(rule: Int, ruleRef: Int): Int

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

final def getClass(): Class[_]

def isConvergedTo(f: GrammarAnchoring[L, W], diff: Double): Boolean

final def isInstanceOf[T0]: Boolean

final def label1Ref(label: Int, ref: Int): Int

final def label2Ref(label: Int, ref: Int): Int

def leftChildRefinement(rule: Int, ruleRef: Int): Int

def length: Int

def lexicon: Lexicon[L, W]

def logPartition: Double

def marginal: RefinedChartMarginal[L, W]

def maxLabelRefinements: Int

def maxMarginal: RefinedChartMarginal[L, W]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def numValidRefinements(label: Int): Int

def numValidRuleRefinements(rule: Int): Int

def parentRefinement(rule: Int, ruleRef: Int): Int

final val refinementController: GrammarAnchoring[L, W]

def rightChildRefinement(rule: Int, ruleRef: Int): Int

final def rule1Ref(rule: Int, ref: Int): Int

final def rule2Ref(rule: Int, ref: Int): Int

def ruleRefinementFromRefinements(r: Int, refA: Int, refB: Int, refC: Int): Int

Returns the refined rule given parent and child refinements for a unary rule.

def ruleRefinementFromRefinements(r: Int, refA: Int, refB: Int): Int

Returns the refined rule given parent and child refinements for a unary rule.

val s1: GrammarAnchoring[L, W]

val s2: GrammarAnchoring[L, W]

def scoreBinaryRule(begin: Int, split: Int, end: Int, rule: Int, ref: Int): Double

Scores the indexed epic.trees.BinaryRule rule when it occurs at (begin, split, end)

def scoreSpan(begin: Int, end: Int, label: Int, ref: Int): Double

Scores the indexed label rule with refinenemnt ref, when it occurs at (begin, end).

def scoreUnaryRule(begin: Int, end: Int, rule: Int, ref: Int): Double

Scores the indexed epic.trees.UnaryRule rule when it occurs at (begin, end)

val sparsityPattern: ChartConstraints[L]

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

def tagConstraints: TagConstraints[L]

val topology: RuleTopology[L]

def validCoarseRulesGivenParentRefinement(a: Int, refA: Int): Array[Int]

def validLabelRefinements(begin: Int, end: Int, label: Int): Array[Int]

For a given span, what refinements to the label are allowed? Refinements in general are in the range (0, numValidRefinements).

def validLeftChildRefinementsGivenRule(begin: Int, end: Int, completionBegin: Int, completionEnd: Int, rule: Int): Array[Int]

def validParentRefinementsGivenRule(begin: Int, splitBegin: Int, splitEnd: Int, end: Int, rule: Int): Array[Int]

def validRightChildRefinementsGivenRule(completionBegin: Int, completionEnd: Int, begin: Int, end: Int, rule: Int): Array[Int]

def validRuleRefinementsGivenLeftChild(begin: Int, split: Int, completionBegin: Int, completionEnd: Int, rule: Int, leftChildRef: Int): Array[Int]

def validRuleRefinementsGivenParent(begin: Int, end: Int, rule: Int, parentRef: Int): Array[Int]

For a given span and the parent's refinement, what refinements to the rule are allowed?

def validRuleRefinementsGivenParent(begin: Int, splitBegin: Int, splitEnd: Int, end: Int, rule: Int, parentRef: Int): Array[Int]

def validRuleRefinementsGivenRightChild(completionBegin: Int, completionEnd: Int, split: Int, end: Int, rule: Int, rightChildRef: Int): Array[Int]

def validUnaryRuleRefinementsGivenChild(begin: Int, end: Int, rule: Int, childRef: Int): Array[Int]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def words: IndexedSeq[W]

def finalize(): Unit