UnrefinedGrammarAnchoring

abstract def addConstraints(cs: ChartConstraints[L]): UnrefinedGrammarAnchoring[L, W]

abstract def lexicon: Lexicon[L, W]

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

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

abstract def scoreSpan(begin: Int, end: Int, tag: Int): Double

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

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

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

abstract def sparsityPattern: ChartConstraints[L]

abstract def topology: RuleTopology[L]

abstract def words: IndexedSeq[W]

final def !=(arg0: Any): Boolean

final def ##(): Int

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

Computes the point-wise product of this grammar with some other grammar.

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

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

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

Computes the point-wise division of this grammar with some other grammar.

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 annotationTag: Int

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

final def asInstanceOf[T0]: T0

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

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

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

Is this CoreAnchoring nearly the same as that core anchoring?

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

final def isInstanceOf[T0]: Boolean

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

def length: Int

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

final def numValidRefinements(label: Int): Int

final def numValidRuleRefinements(rule: Int): Int

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

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

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

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

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

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

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)

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

def tagConstraints: TagConstraints[L]

def toString(): String

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

final 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, childRef: Int): Array[Int]

final 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, childRef: Int): Array[Int]

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit