ParticleGibbsAncestor

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ancestorResampling(mod: Model, time: Time, states: Vector[LatentState], weights: Vector[Double], condState: DenseVector[Double], p: Parameters): (List[LatentState], LatentState)

Perform Ancestor Resampling on Particle Paths

def args: Array[String]

final def asInstanceOf[T0]: T0

def calcWeight(mod: Model, time: Time, xt: DenseVector[Double], xt1: DenseVector[Double], y: Observation, p: Parameters): Double

The weights are proportional to the conditional likelihood of the observations given the state multiplied by the transition probability of the resampled particles at time t-1 to the conditioned state at time t

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val executionStart: Long

def filter(n: Int, p: Parameters, mod: Model, obs: List[Data])(state: LatentState): Rand[(Double, LatentState)]

Run Particle Gibbs with Ancestor Sampling

def filterAll(n: Int, mod: Model, p: Parameters, obs: List[Data])(state: LatentState): State

Run Particle Gibbs with Ancestor Sampling

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def importanceWeight(sampledStates: Vector[DenseVector[Double]], weights: Vector[Double], conditionedState: DenseVector[Double], time: Time, mod: Model, p: Parameters): Vector[Double]

Calculate the importance weights for ancestor resampling the Nth path

final def isInstanceOf[T0]: Boolean

def logSumExp(w: Vector[Double]): Vector[Double]

Recalculate the weights such that the smallest weight is 1

def main(args: Array[String]): Unit

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def sample[A](n: Int, xs: Vector[A], ws: Vector[Double]): Vector[A]

Sample n items with replacement from xs with probability ws

def step(mod: Model, p: Parameters): (State, (Data, DenseVector[Double])) ⇒ State

A single step in the Particle Gibbs with Ancestor Sampling algorithm

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

def toString(): String

def transitionProbability(sampledState: DenseVector[Double], time: Time, mod: Model, p: Parameters)(conditionedState: DenseVector[Double]): Double

Calculate the transition probability from a given particle at time t-1 to the conditioned upon particle at time t

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def delayedInit(body: ⇒ Unit): Unit