VariablesSettingsSampler

Instance Constructors

new VariablesSettingsSampler(model: model.Model, objective: model.Model = null)(implicit random: Random)

Type Members

type ContextType = Seq[V]

Definition Classes
Sampler

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
var changeCount: Int

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

Definition Classes
Sampler
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
var iterationCount: Int

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

Definition Classes
Sampler
var makeNewDiffList: Boolean

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

Definition Classes
Sampler
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newDiffList: variable.DiffList

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

Definition Classes
Sampler
def noDiffList: VariablesSettingsSampler.this.type

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

Definition Classes
Sampler
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def pickProposal(proposals: Seq[Proposal[Seq[V]]]): Proposal[Seq[V]]

Definition Classes
ProposalSampler
def postIterationHook: Boolean

Called after each iteration of sampling the full list of variables.
Called after each iteration of sampling the full list of variables. Return false if you want sampling to stop early.

Definition Classes
Sampler
val postIterationHooks: Hooks0

Definition Classes
Sampler
def postProcessHook(context: Seq[V], difflist: DiffList): Unit

Call just after each step of sampling.
Call just after each step of sampling.

Definition Classes
Sampler
def preProcessHook(context: Seq[V]): Seq[V]

Called just before each step of sampling.
Called just before each step of sampling. Return an alternative variable if you want that one sampled instead. Return null if you want to abort sampling of this context.

Definition Classes
Sampler
final def process(count: Int): Unit

Definition Classes
Sampler
final def process(context: Seq[V], repeat: Int): Unit

Definition Classes
Sampler
final def process(context: Seq[V]): DiffList

Do one step of sampling.
Do one step of sampling. This is a method intended to be called by users. It manages hooks and processCount.

Definition Classes
Sampler
def process1(context: Seq[V]): DiffList

The underlying protected method that actually does the work.
The underlying protected method that actually does the work. Use this.newDiffList to optionally create returned DiffList. Needs to be defined in subclasses.

Definition Classes
ProposalSampler → Sampler
final def processAll(contexts: Iterable[Seq[V]], numIterations: Int): Unit

Definition Classes
Sampler
final def processAll(contexts: Iterable[Seq[V]], returnDiffs: Boolean = false): DiffList

Definition Classes
Sampler
var processCount: Int

The number of calls to process(context:C)
The number of calls to process(context:C)

Definition Classes
Sampler
def processProposals(props: Seq[Proposal[Seq[V]]]): DiffList

Definition Classes
ProposalSampler
def proposalHook(proposal: Proposal[Seq[V]]): Unit

Definition Classes
ProposalSampler
val proposalHooks: Hooks1[Proposal[Seq[V]]]

Definition Classes
ProposalSampler
def proposals(context: Seq[V]): Seq[Proposal[Seq[V]]]

Definition Classes
SettingsSampler → ProposalSampler
def proposalsHook(proposals: Seq[Proposal[Seq[V]]]): Unit

Definition Classes
ProposalSampler
val proposalsHooks: Hooks1[Seq[Proposal[Seq[V]]]]

Definition Classes
ProposalSampler
def settings(variables: Seq[V]): SettingIterator

Abstract method must be implemented in sub-classes.
Abstract method must be implemented in sub-classes. Provides access to all different possible worlds we will evaluate for each call to 'process'

Definition Classes
VariablesSettingsSampler → SettingsSampler
def skipEmptyProposals: Boolean

Definition Classes
ProposalSampler
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
var temperature: Double

Definition Classes
ProposalSampler
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

class VariablesSettingsSampler[V <: Var with IterableSettings] extends SettingsSampler[Seq[V]]

Instance Constructors

new VariablesSettingsSampler(model: model.Model, objective: model.Model = null)(implicit random: Random)

Type Members

type ContextType = Seq[V]

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

var changeCount: 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

final def isInstanceOf[T0]: Boolean

var iterationCount: Int

var makeNewDiffList: Boolean

final def ne(arg0: AnyRef): Boolean

def newDiffList: variable.DiffList

def noDiffList: VariablesSettingsSampler.this.type

final def notify(): Unit

final def notifyAll(): Unit

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

def postIterationHook: Boolean

val postIterationHooks: Hooks0

def postProcessHook(context: Seq[V], difflist: DiffList): Unit

def preProcessHook(context: Seq[V]): Seq[V]

final def process(count: Int): Unit

final def process(context: Seq[V], repeat: Int): Unit

final def process(context: Seq[V]): DiffList

def process1(context: Seq[V]): DiffList

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

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

var processCount: Int

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

def proposalHook(proposal: Proposal[Seq[V]]): Unit

val proposalHooks: Hooks1[Proposal[Seq[V]]]

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

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

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

def settings(variables: Seq[V]): SettingIterator

def skipEmptyProposals: Boolean

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

var temperature: Double

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from SettingsSampler[Seq[V]]

Inherited from ProposalSampler[Seq[V]]

Inherited from Sampler[Seq[V]]

Inherited from AnyRef

Inherited from Any

Ungrouped