GibbsSampling

Type Members

case class State(p: Parameters, state: Array[(Time, DenseVector[Double])]) extends Product with Serializable
case class StudentTState(p: Parameters, variances: List[Double], state: Array[(Time, DenseVector[Double])]) extends Product with Serializable

The state of the Markov chain for the Student's t-distribution gibbs sampler

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

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

Definition Classes
AnyRef → Any
def args: Array[String]

Attributes
protected
Definition Classes
App
Annotations
@deprecatedOverriding( "args should not be overridden" , "2.11.0" )
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def diff[A](xs: Seq[A])(implicit A: Numeric[A]): Seq[A]

Calculate the lagged difference between items in a Seq
Calculate the lagged difference between items in a Seq
xs
a sequence of numeric values
returns
a sequence of numeric values containing the once lagged difference
def dinvGammaStep(mod: Model, priorV: InverseGamma, priorW: InverseGamma, observations: Array[Data])(gibbsState: State): Rand[State]

A single step of a Gibbs Sampler
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
val executionStart: Long

Definition Classes
App
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 gibbsMetropStep(proposal: (Parameters) ⇒ Rand[Parameters], mod: Model, priorV: InverseGamma, priorW: InverseGamma, observations: Array[Data])(gibbsState: State): Rand[State]
def hashCode(): Int

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

Definition Classes
Any
def main(args: Array[String]): Unit

Definition Classes
App
Annotations
@deprecatedOverriding( "main should not be overridden" , "2.11.0" )
def metropSamples(proposal: (Parameters) ⇒ Rand[Parameters], mod: Model, priorV: InverseGamma, priorW: InverseGamma, initParams: Parameters, observations: Array[Data]): Process[State]
def metropStep(mod: Model, observations: Array[Data], proposal: (Parameters) ⇒ Rand[Parameters]): (Parameters) ⇒ Rand[Parameters]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def observationSquaredDifference(f: (Time) ⇒ DenseMatrix[Double], state: Array[(Time, DenseVector[Double])], observations: Array[Data]): DenseVector[Double]

Calculate the sum of squared differences between the one step forecast and the actual observation for each time sum((y_t - f_t)^2)
Calculate the sum of squared differences between the one step forecast and the actual observation for each time sum((y_t - f_t)^2)
f
the observation matrix, a function from time => DenseMatrix[Double]
state
an array containing the state sampled from the backward sampling algorithm
observations
an array containing the actual observations of the data
returns
the sum of squared differences between the one step forecast and the actual observation for each time
def sample(mod: Model, priorV: InverseGamma, priorW: InverseGamma, initParams: Parameters, observations: Array[Data]): Process[State]

Return a Markov chain using Gibbs Sampling to determine the values of the system and observation noise covariance matrices, W and V
Return a Markov chain using Gibbs Sampling to determine the values of the system and observation noise covariance matrices, W and V
mod
the model containing the definition of the observation matrix F_t and system evolution matrix G_t
priorV
the prior distribution on the observation noise matrix, V
priorW
the prior distribution on the system noise matrix, W
initParams
the initial parameters of the Markov Chain
observations
an array of Data containing the observed time series
returns
a Process
def sampleObservationMatrix(prior: InverseGamma, f: (Time) ⇒ DenseMatrix[Double], state: Array[(Time, DenseVector[Double])], observations: Array[Data]): Rand[DenseMatrix[Double]]

Sample the (diagonal) observation noise covariance matrix from an Inverse Gamma distribution
Sample the (diagonal) observation noise covariance matrix from an Inverse Gamma distribution
prior
an Inverse Gamma prior distribution for each variance element of the observation matrix
state
a sample of the DLM state
observations
the observed values of the time series
returns
the posterior distribution over the diagonal observation matrix
def sampleScaleT(variances: List[Double], dof: Int): Rand[Double]

Sample the (square of the) scale of the Student's t distribution
def sampleStateT(variances: List[Double], params: Parameters, mod: Model, observations: Array[Data]): Rand[Array[(Time, DenseVector[Double])]]

Sample the state, incorporating the drawn variances for each observation
def sampleSystemMatrix(prior: InverseGamma, g: (TimeIncrement) ⇒ DenseMatrix[Double], state: Array[(Time, DenseVector[Double])]): Rand[DenseMatrix[Double]]

Sample the diagonal system matrix for an irregularly observed DLM
def sampleVariancesT(ys: Array[Data], f: ObservationMatrix, state: Array[(Time, DenseVector[Double])], dof: Int, scale: Double): Rand[List[Double]]

Sample the variances of the Normal distribution These are auxilliary variables required when calculating the one-step prediction in the Kalman Filter
Sample the variances of the Normal distribution These are auxilliary variables required when calculating the one-step prediction in the Kalman Filter
ys
an array of observations of length N
f
the observation matrix
state
a sample from the state, using sampleStateT
dof
the degrees of freedom of the Student's t-distribution
scale
the (square of the) scale of the Student's t-distribution
returns
a Rand distribution over the list of N variances
def studentT(dof: Int, data: Array[Data], priorW: InverseGamma, mod: Model, params: Parameters): Process[StudentTState]

Perform Gibbs Sampling for the Student t-distributed model
def studentTStep(dof: Int, data: Array[Data], priorW: InverseGamma, mod: Model)(state: StudentTState): Rand[StudentTState]

A single step of the Student t-distribution Gibbs Sampler
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
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( ... )

Deprecated Value Members

def delayedInit(body: ⇒ Unit): Unit

Definition Classes
App → DelayedInit
Annotations
@deprecated
Deprecated
(Since version 2.11.0) The delayedInit mechanism will disappear.

Related Doc: package model

object GibbsSampling extends App

Type Members

case class State(p: Parameters, state: Array[(Time, DenseVector[Double])]) extends Product with Serializable

case class StudentTState(p: Parameters, variances: List[Double], state: Array[(Time, DenseVector[Double])]) extends Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def args: Array[String]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def diff[A](xs: Seq[A])(implicit A: Numeric[A]): Seq[A]

def dinvGammaStep(mod: Model, priorV: InverseGamma, priorW: InverseGamma, observations: Array[Data])(gibbsState: State): Rand[State]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val executionStart: Long

def finalize(): Unit

final def getClass(): Class[_]

def gibbsMetropStep(proposal: (Parameters) ⇒ Rand[Parameters], mod: Model, priorV: InverseGamma, priorW: InverseGamma, observations: Array[Data])(gibbsState: State): Rand[State]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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

def metropSamples(proposal: (Parameters) ⇒ Rand[Parameters], mod: Model, priorV: InverseGamma, priorW: InverseGamma, initParams: Parameters, observations: Array[Data]): Process[State]

def metropStep(mod: Model, observations: Array[Data], proposal: (Parameters) ⇒ Rand[Parameters]): (Parameters) ⇒ Rand[Parameters]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def observationSquaredDifference(f: (Time) ⇒ DenseMatrix[Double], state: Array[(Time, DenseVector[Double])], observations: Array[Data]): DenseVector[Double]

def sample(mod: Model, priorV: InverseGamma, priorW: InverseGamma, initParams: Parameters, observations: Array[Data]): Process[State]

def sampleObservationMatrix(prior: InverseGamma, f: (Time) ⇒ DenseMatrix[Double], state: Array[(Time, DenseVector[Double])], observations: Array[Data]): Rand[DenseMatrix[Double]]

def sampleScaleT(variances: List[Double], dof: Int): Rand[Double]

def sampleStateT(variances: List[Double], params: Parameters, mod: Model, observations: Array[Data]): Rand[Array[(Time, DenseVector[Double])]]

def sampleSystemMatrix(prior: InverseGamma, g: (TimeIncrement) ⇒ DenseMatrix[Double], state: Array[(Time, DenseVector[Double])]): Rand[DenseMatrix[Double]]

def sampleVariancesT(ys: Array[Data], f: ObservationMatrix, state: Array[(Time, DenseVector[Double])], dof: Int, scale: Double): Rand[List[Double]]

def studentT(dof: Int, data: Array[Data], priorW: InverseGamma, mod: Model, params: Parameters): Process[StudentTState]

def studentTStep(dof: Int, data: Array[Data], priorW: InverseGamma, mod: Model)(state: StudentTState): Rand[StudentTState]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Deprecated Value Members

def delayedInit(body: ⇒ Unit): Unit

Inherited from App

Inherited from DelayedInit

Inherited from AnyRef

Inherited from Any

Ungrouped