ParallelSampling

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

abstract def newEntity: E

abstract def newSampler: BibSampler[E]

abstract def numThreads: Int

abstract def sampleAttributes(e: E)(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

var _amountOfDirt: Double

var _forPSIATimeCount: Long

var _forPSIAcceptanceCount: Long

var _instantPctAccepted: Double

var _numSampleAttempts: Double

def acceptanceRateSinceLastTimeCheck: Double

def addEntities(ents: Iterable[E]): Unit

def addEntity(e: E): Unit

var allDiffVarsInWindow: Int

final def asInstanceOf[T0]: T0

def calculateInstantaneousAcceptanceRate(): Unit

var canopies: HashMap[String, ArrayBuffer[E]]

var canopyStats: CanopyStatistics[E]

var changeCount: Int

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

def clone(): AnyRef

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

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

var deletedEntities: ArrayBuffer[E]

var entities: ArrayBuffer[E]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def getDeletedEntities: Seq[E]

def getEntities: Seq[E]

def hashCode(): Int

def infer(numSamples: Int): Unit

var intervalTime: Long

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).

def loadBalancing(): Unit

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: E, right: E)(implicit d: variable.DiffList): Unit

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

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

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

def model: model.Model

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: E = null.asInstanceOf[E]): E

def nextEntity: E

Returns a random entity that 'exists'

def nextEntityPair: (E, E)

def noDiffList: ParallelSampling.this.type

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

def nonAssignedEntities: ArrayBuffer[E]

final def notify(): Unit

final def notifyAll(): Unit

var numAccepted: Long

var numAcceptedInTimeWindow: Int

def numCanopies: Int

var numDiffVars: Long

var numDiffVarsInWindow: Int

var numNonTrivialDiffs: Int

def objective: model.Model

var optionalId: Int

def performMaintenance(es: ArrayBuffer[E]): 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.

var printDotInterval: Long

var printInfo: Boolean

def printSamplingInfo(count: Long = proposalCount): Unit

var printUpdateInterval: Long

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

var proposalCount: Long

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: E, entity2: E, changes: ArrayBuffer[(variable.DiffList) ⇒ Unit]): Unit

implicit val random: Random

def resetSamplingStatistics(): Unit

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

var samplers: Array[BibSampler[E]]

def samplesPerEntityCount(numEntities: Int): Int

val sampsPerMicroBatch: Int

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

def settings(c: Null): SettingIterator

Abstract method must be implemented in sub-classes.

val shortDecimal: DecimalFormat

var singletonCanopies: ArrayBuffer[E]

def skipEmptyProposals: Boolean

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

Peels off the entity "right", does not really need both arguments unless we want to error check.

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

var totalTime: Long

final def wait(): Unit

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

final def wait(arg0: Long): Unit