HierCorefSampler

abstract def initializeAttributesOfNewRoot(e1: T, e2: T, parent: T)(implicit d: variable.DiffList): Unit

abstract def newEntity: T

abstract def sampleAttributes(e: T)(implicit d: variable.DiffList): Unit

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addEntity(e: T): Unit

final def asInstanceOf[T0]: T0

var changeCount: Int

The number of calls to process that resulted in a change (a non-empty DiffList)

def clone(): AnyRef

def collapse(entity: T)(implicit d: variable.DiffList): Unit

Removes an intermediate node in the tree, merging that nodes children to their grandparent.

var deletedEntities: ArrayBuffer[T]

var entities: ArrayBuffer[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def getDeletedEntities: Seq[T]

def getEntities: Seq[T]

def hashCode(): Int

def infer(numSamples: Int): Unit

final def isInstanceOf[T0]: Boolean

def isMention(e: Entity): Boolean

var iterationCount: Int

The number of calls to process(numIterations:Int) or process(contexts:C,numIterations:Int).

var makeNewDiffList: Boolean

If true, calls to "newDiffList" will create a new DiffList to describe the changes they made, otherwise "newDiffList" will return null.

def mergeLeft(left: T, right: T)(implicit d: variable.DiffList): Unit

Jump function that proposes merge: entity1<----entity2

def mergeUp(e1: T, e2: T)(implicit d: variable.DiffList): T

Jump function that proposes merge: entity1--->NEW-PARENT-ENTITY<---entity2

final def ne(arg0: AnyRef): Boolean

def newDiffList: variable.DiffList

In your implementation of "process1" use this method to optionally create a new DiffList, obeying "makeNewDiffList".

def nextEntity(context: T): T

def nextEntity: T

Returns a random entity that 'exists'

def nextEntityPair: (T, T)

def noDiffList: HierCorefSampler.this.type

Convenient method for setting makeNewDiffList to false, and returning this.

final def notify(): Unit

final def notifyAll(): Unit

def objective: model.Model

def performMaintenance(es: ArrayBuffer[T]): Unit

Garbage collects all the deleted entities from the master list of entities

def pickProposal(proposals: Seq[Proposal[Null]]): Proposal[Null]

def postIterationHook: Boolean

Called after each iteration of sampling the full list of variables.

val postIterationHooks: Hooks0

def postProcessHook(context: Null, difflist: DiffList): Unit

Call just after each step of sampling.

def preProcessHook(context: Null): Null

Called just before each step of sampling.

final def process(count: Int): Unit

final def process(context: Null, repeat: Int): Unit

final def process(context: Null): DiffList

Do one step of sampling.

def process1(context: Null): DiffList

The underlying protected method that actually does the work.

final def processAll(contexts: Iterable[Null], numIterations: Int): Unit

final def processAll(contexts: Iterable[Null], returnDiffs: Boolean = false): DiffList

var processCount: Int

The number of calls to process(context:C)

def processProposals(props: Seq[Proposal[Null]]): DiffList

def propagateBagUp(entity: Entity)(implicit d: variable.DiffList): Unit

def propagateRemoveBag(parting: Entity, formerParent: Entity)(implicit d: variable.DiffList): Unit

def proposalHook(proposal: Proposal[Null]): Unit

Identify entities that are created by accepted jumps so we can add them to our master entity list.

val proposalHooks: Hooks1[Proposal[Null]]

def proposals(context: Null): Seq[Proposal[Null]]

def proposalsHook(proposals: Seq[Proposal[Null]]): Unit

val proposalsHooks: Hooks1[Seq[Proposal[Null]]]

def proposeMergeIfValid(entity1: T, entity2: T, changes: ArrayBuffer[(variable.DiffList) ⇒ Unit]): Unit

implicit val random: Random

def sampleEntity(samplePool: ArrayBuffer[T]): T

def setEntities(ents: Iterable[T]): Unit

def settings(c: Null): SettingIterator

Abstract method must be implemented in sub-classes.

def skipEmptyProposals: Boolean

def splitRight(left: T, right: T)(implicit d: variable.DiffList): Unit

Peels off the entity "right", second argument not necessary except for error checking/debuggin.

def structurePreservationForEntityThatLostChild(e: Entity)(implicit d: variable.DiffList): Unit

Ensure that chains are not created in our tree.

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

var temperature: Double

def timeAndProcess(n: Int): Unit

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit