inference

import "github.com/umbralcalc/stochadex/pkg/inference"

Package inference provides statistical inference and likelihood modeling capabilities for stochadex simulations. It includes probability distributions, likelihood functions, gradient computation, and Bayesian inference utilities for parameter estimation and model validation.

Key Features:

• Probability distribution implementations (Beta, Gamma, Normal, Poisson, etc.)
• Likelihood function evaluation and gradient computation
• Bayesian inference with posterior estimation
• Parameter estimation and optimization support
• Model comparison and validation utilities

Mathematical Background: The package implements various probability distributions and their associated likelihood functions for use in Bayesian inference. Key distributions include:

• Normal distributions for continuous variables
• Poisson distributions for count data
• Gamma distributions for positive continuous variables
• Beta distributions for bounded continuous variables

Usage Patterns:

• Fit models to observed data using maximum likelihood estimation
• Perform Bayesian parameter estimation with prior distributions
• Compare models using likelihood ratios or information criteria
• Validate model assumptions through posterior predictive checks

- Statistical hypothesis testing and model comparison

- Statistical hypothesis testing and model comparison

- Statistical hypothesis testing and model comparison

- Statistical hypothesis testing and model comparison

Index

• func CovarianceMatrixFromParams(params *simulator.Params) *mat.SymDense
• func CovarianceMatrixFromParamsOrPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.SymDense
• func CovarianceMatrixFromPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.SymDense
• func CovarianceMatrixVarianceFromParams(params *simulator.Params) *mat.SymDense
• func CovarianceMatrixVarianceFromPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.SymDense
• func MeanFromParams(params *simulator.Params) *mat.VecDense
• func MeanFromParamsOrPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.VecDense
• func MeanFromPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.VecDense
• func MeanGradientFunc(params *simulator.Params, likeMeanGrad []float64) []float64
• func MeanTransform(params *simulator.Params, values mat.Vector) mat.Vector
• func VarianceFromParams(params *simulator.Params) *mat.VecDense
• func VarianceFromParamsOrPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.VecDense
• func VarianceFromPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.VecDense
• func VarianceTransform(params *simulator.Params, values mat.Vector) mat.Vector
• type BetaLikelihoodDistribution
  • func (b *BetaLikelihoodDistribution) EvaluateLogLike(data []float64) float64
  • func (b *BetaLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64
  • func (b *BetaLikelihoodDistribution) GenerateNewSamples() []float64
  • func (b *BetaLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)
  • func (b *BetaLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)
• type DataComparisonGradientIteration
  • func (d *DataComparisonGradientIteration) Configure(partitionIndex int, settings *simulator.Settings)
  • func (d *DataComparisonGradientIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
  • func (d *DataComparisonGradientIteration) UpdateMemory(params *simulator.Params, update general.StateMemoryUpdate)
• type DataComparisonIteration
  • func (d *DataComparisonIteration) Configure(partitionIndex int, settings *simulator.Settings)
  • func (d *DataComparisonIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
• type DataGenerationIteration
  • func (d *DataGenerationIteration) Configure(partitionIndex int, settings *simulator.Settings)
  • func (d *DataGenerationIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
• type GammaLikelihoodDistribution
  • func (g *GammaLikelihoodDistribution) EvaluateLogLike(data []float64) float64
  • func (g *GammaLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64
  • func (g *GammaLikelihoodDistribution) GenerateNewSamples() []float64
  • func (g *GammaLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)
  • func (g *GammaLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)
• type LikelihoodDistribution
• type LikelihoodDistributionWithGradient
• type NegativeBinomialLikelihoodDistribution
  • func (n *NegativeBinomialLikelihoodDistribution) EvaluateLogLike(data []float64) float64
  • func (n *NegativeBinomialLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64
  • func (n *NegativeBinomialLikelihoodDistribution) GenerateNewSamples() []float64
  • func (n *NegativeBinomialLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)
  • func (n *NegativeBinomialLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)
• type NormalLikelihoodDistribution
  • func (n *NormalLikelihoodDistribution) EvaluateLogLike(data []float64) float64
  • func (n *NormalLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64
  • func (n *NormalLikelihoodDistribution) GenerateNewSamples() []float64
  • func (n *NormalLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)
  • func (n *NormalLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)
• type PoissonLikelihoodDistribution
  • func (p *PoissonLikelihoodDistribution) EvaluateLogLike(data []float64) float64
  • func (p *PoissonLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64
  • func (p *PoissonLikelihoodDistribution) GenerateNewSamples() []float64
  • func (p *PoissonLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)
  • func (p *PoissonLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)
• type PosteriorCovarianceIteration
  • func (p *PosteriorCovarianceIteration) Configure(partitionIndex int, settings *simulator.Settings)
  • func (p *PosteriorCovarianceIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
• type PosteriorLogNormalisationIteration
  • func (p *PosteriorLogNormalisationIteration) Configure(partitionIndex int, settings *simulator.Settings)
  • func (p *PosteriorLogNormalisationIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
• type PosteriorMeanIteration
  • func (p *PosteriorMeanIteration) Configure(partitionIndex int, settings *simulator.Settings)
  • func (p *PosteriorMeanIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
• type TLikelihoodDistribution
  • func (t *TLikelihoodDistribution) EvaluateLogLike(data []float64) float64
  • func (t *TLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64
  • func (t *TLikelihoodDistribution) GenerateNewSamples() []float64
  • func (t *TLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)
  • func (t *TLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)
• type WishartLikelihoodDistribution
  • func (w *WishartLikelihoodDistribution) EvaluateLogLike(data []float64) float64
  • func (w *WishartLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64
  • func (w *WishartLikelihoodDistribution) GenerateNewSamples() []float64
  • func (w *WishartLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)
  • func (w *WishartLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)

func CovarianceMatrixFromParams

func CovarianceMatrixFromParams(params *simulator.Params) *mat.SymDense

CovarianceMatrixFromParams retrieves the covariance matrix from params.

func CovarianceMatrixFromParamsOrPartition

func CovarianceMatrixFromParamsOrPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.SymDense

CovarianceMatrixFromParamsOrPartition retrieves the covariance matrix from params or indexed partition value, depending on which is set.

func CovarianceMatrixFromPartition

func CovarianceMatrixFromPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.SymDense

CovarianceMatrixFromPartition retrieves the covariance matrix from an indexed partition value.

func CovarianceMatrixVarianceFromParams

func CovarianceMatrixVarianceFromParams(params *simulator.Params) *mat.SymDense

CovarianceMatrixVarianceFromParams retrieves the covariance matrix from variance params.

func CovarianceMatrixVarianceFromPartition

func CovarianceMatrixVarianceFromPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.SymDense

CovarianceMatrixVarianceFromPartition retrieves the covariance matrix from an indexed partition value for the variance.

func MeanFromParams

func MeanFromParams(params *simulator.Params) *mat.VecDense

MeanFromParams retrieves the mean from params.

func MeanFromParamsOrPartition

func MeanFromParamsOrPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.VecDense

MeanFromParamsOrPartition retrieves the mean from params or indexed partition value, depending on which is set.

func MeanFromPartition

func MeanFromPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.VecDense

MeanFromPartition retrieves the mean from an indexed partition value.

func MeanGradientFunc

func MeanGradientFunc(params *simulator.Params, likeMeanGrad []float64) []float64

MeanGradientFunc computes the gradient with respect to the mean directly.

func MeanTransform

func MeanTransform(params *simulator.Params, values mat.Vector) mat.Vector

MeanTransform returns the values needed to compute the mean.

func VarianceFromParams

func VarianceFromParams(params *simulator.Params) *mat.VecDense

VarianceFromParams retrieves the variance from params.

func VarianceFromParamsOrPartition

func VarianceFromParamsOrPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.VecDense

VarianceFromParamsOrPartition retrieves the variance from params or indexed partition value, depending on which is set.

func VarianceFromPartition

func VarianceFromPartition(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory) *mat.VecDense

VarianceFromPartition retrieves the variance from from an indexed partition value.

func VarianceTransform

func VarianceTransform(params *simulator.Params, values mat.Vector) mat.Vector

VarianceTransform returns the values needed to compute the variance.

type BetaLikelihoodDistribution

BetaLikelihoodDistribution implements a Beta distribution likelihood model for bounded continuous data analysis and parameter estimation.

The Beta distribution is particularly useful for modeling data that is bounded between 0 and 1, such as proportions, probabilities, rates, and normalized measurements. It provides flexible shape modeling through its two shape parameters α (alpha) and β (beta).

Mathematical Background: The Beta distribution Beta(α, β) has probability density function:

f(x | α, β) = x^(α-1) * (1-x)^(β-1) / B(α, β)

where B(α, β) is the Beta function, and x ∈ [0, 1].

Key Properties:

• Support: x ∈ [0, 1] (bounded continuous)
• Shape parameters: α > 0, β > 0 (both must be positive)
• Mean: E[X] = α / (α + β)
• Variance: Var[X] = (α * β) / ((α + β)² * (α + β + 1))
• Special cases:
• α = β = 1: Uniform distribution on [0, 1]
• α = 1, β = 1: Uniform distribution
• α > 1, β > 1: Bell-shaped distribution
• α < 1, β < 1: U-shaped distribution

Applications:

• Proportion modeling: Success rates, conversion rates, market shares
• Probability estimation: Bayesian inference with Beta priors
• Quality control: Defect rates, pass/fail proportions
• Financial modeling: Recovery rates, default probabilities
• Machine learning: Classification confidence scores

Parameter Configuration: The distribution can be configured in two ways:

1. Direct parameters: Provide “alpha” and “beta” parameters directly
2. Mean-variance: Provide “mean” and “variance” parameters for automatic conversion

Example:

dist := &BetaLikelihoodDistribution{}
dist.SetSeed(0, settings)
// Configure with mean=0.3, variance=0.05
dist.SetParams(params, partitionIndex, stateHistories, timestepsHistory)

// Evaluate likelihood of observed proportions
logLike := dist.EvaluateLogLike([]float64{0.25, 0.35, 0.28})

Performance:

• O(d) time complexity where d is the data dimension
• Memory usage: O(d) for parameter storage
• Efficient for moderate dimensions (< 1000)

type BetaLikelihoodDistribution struct {
    Src rand.Source
    // contains filtered or unexported fields
}

func (*BetaLikelihoodDistribution) EvaluateLogLike

func (b *BetaLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (*BetaLikelihoodDistribution) EvaluateLogLikeMeanGrad

func (b *BetaLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64

func (*BetaLikelihoodDistribution) GenerateNewSamples

func (b *BetaLikelihoodDistribution) GenerateNewSamples() []float64

func (*BetaLikelihoodDistribution) SetParams

func (b *BetaLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)

func (*BetaLikelihoodDistribution) SetSeed

func (b *BetaLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)

type DataComparisonGradientIteration

DataComparisonGradientIteration allows for any log-likelihood gradient to be used in computing the overall comparison distribution gradient.

type DataComparisonGradientIteration struct {
    Likelihood   LikelihoodDistributionWithGradient
    GradientFunc func(
        params *simulator.Params,
        likeMeanGrad []float64,
    ) []float64
    Batch *simulator.StateHistory
}

func (*DataComparisonGradientIteration) Configure

func (d *DataComparisonGradientIteration) Configure(partitionIndex int, settings *simulator.Settings)

func (*DataComparisonGradientIteration) Iterate

func (d *DataComparisonGradientIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64

func (*DataComparisonGradientIteration) UpdateMemory

func (d *DataComparisonGradientIteration) UpdateMemory(params *simulator.Params, update general.StateMemoryUpdate)

type DataComparisonIteration

DataComparisonIteration allows for any log-likelihood to be used as a comparison distribution between data values, a mean vector and covariance matrix.

type DataComparisonIteration struct {
    Likelihood LikelihoodDistribution
    // contains filtered or unexported fields
}

func (*DataComparisonIteration) Configure

func (d *DataComparisonIteration) Configure(partitionIndex int, settings *simulator.Settings)

func (*DataComparisonIteration) Iterate

func (d *DataComparisonIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64

type DataGenerationIteration

DataGenerationIteration allows for any likelihood to be used as a data generation distribution based on a mean and covariance matrix.

type DataGenerationIteration struct {
    Likelihood LikelihoodDistribution
    // contains filtered or unexported fields
}

func (*DataGenerationIteration) Configure

func (d *DataGenerationIteration) Configure(partitionIndex int, settings *simulator.Settings)

func (*DataGenerationIteration) Iterate

func (d *DataGenerationIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64

type GammaLikelihoodDistribution

GammaLikelihoodDistribution assumes the real data are well described by a gamma distribution, given the input mean and variance.

type GammaLikelihoodDistribution struct {
    Src rand.Source
    // contains filtered or unexported fields
}

func (*GammaLikelihoodDistribution) EvaluateLogLike

func (g *GammaLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (*GammaLikelihoodDistribution) EvaluateLogLikeMeanGrad

func (g *GammaLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64

func (*GammaLikelihoodDistribution) GenerateNewSamples

func (g *GammaLikelihoodDistribution) GenerateNewSamples() []float64

func (*GammaLikelihoodDistribution) SetParams

func (g *GammaLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)

func (*GammaLikelihoodDistribution) SetSeed

func (g *GammaLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)

type LikelihoodDistribution

LikelihoodDistribution defines a likelihood model over observed data for statistical inference and parameter estimation.

This interface represents a probability distribution that can evaluate the likelihood of observed data given parameters and generate new samples from the distribution. It serves as the foundation for Bayesian inference, parameter estimation, and model validation in stochadex simulations.

Mathematical Concept: A likelihood distribution represents the probability model p(data | parameters), where the likelihood function measures how well the model explains observed data given specific parameter values. This is fundamental to:

• Maximum likelihood estimation: θ̂ = argmax_θ p(data | θ)
• Bayesian inference: p(θ | data) ∝ p(data | θ) × p(θ)
• Model comparison and selection
• Parameter uncertainty quantification

Interface Methods:

• SetSeed: Initialize random number generator state for reproducible sampling
• SetParams: Configure distribution parameters from simulation context
• EvaluateLogLike: Compute log-likelihood log p(data | params) for given data
• GenerateNewSamples: Draw new samples from the current parameter configuration

Implementation Requirements:

• SetSeed must be called before any other methods
• SetParams must be called before EvaluateLogLike or GenerateNewSamples
• EvaluateLogLike should return log-likelihood (not raw likelihood) for numerical stability
• GenerateNewSamples should return samples consistent with current parameters

Example Usage:

dist := &BetaLikelihoodDistribution{}
dist.SetSeed(0, settings)
dist.SetParams(params, partitionIndex, stateHistories, timestepsHistory)

// Evaluate likelihood of observed data
logLike := dist.EvaluateLogLike(observedData)

// Generate new samples for validation
newSamples := dist.GenerateNewSamples()

Related Types:

• See LikelihoodDistributionWithGradient for gradient-based optimization
• See BetaLikelihoodDistribution for beta distribution implementation
• See NormalLikelihoodDistribution for normal distribution implementation

type LikelihoodDistribution interface {
    SetSeed(partitionIndex int, settings *simulator.Settings)
    SetParams(
        params *simulator.Params,
        partitionIndex int,
        stateHistories []*simulator.StateHistory,
        timestepsHistory *simulator.CumulativeTimestepsHistory,
    )
    EvaluateLogLike(data []float64) float64
    GenerateNewSamples() []float64
}

type LikelihoodDistributionWithGradient

LikelihoodDistributionWithGradient extends LikelihoodDistribution with a mean gradient for optimisation.

type LikelihoodDistributionWithGradient interface {
    LikelihoodDistribution
    EvaluateLogLikeMeanGrad(data []float64) []float64
}

type NegativeBinomialLikelihoodDistribution

NegativeBinomialLikelihoodDistribution assumes the real data are well described by a negative binomial distribution, given the input mean and variance.

type NegativeBinomialLikelihoodDistribution struct {
    Src rand.Source
    // contains filtered or unexported fields
}

func (*NegativeBinomialLikelihoodDistribution) EvaluateLogLike

func (n *NegativeBinomialLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (*NegativeBinomialLikelihoodDistribution) EvaluateLogLikeMeanGrad

func (n *NegativeBinomialLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64

func (*NegativeBinomialLikelihoodDistribution) GenerateNewSamples

func (n *NegativeBinomialLikelihoodDistribution) GenerateNewSamples() []float64

func (*NegativeBinomialLikelihoodDistribution) SetParams

func (n *NegativeBinomialLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)

func (*NegativeBinomialLikelihoodDistribution) SetSeed

func (n *NegativeBinomialLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)

type NormalLikelihoodDistribution

NormalLikelihoodDistribution models data with a multivariate normal.

Usage hints:

• Provide mean/covariance via params or upstream partition outputs.
• Optional: “default_covariance” used if provided covariance is not PD.
• GenerateNewSamples draws from the current parameterised distribution.

type NormalLikelihoodDistribution struct {
    Src rand.Source
    // contains filtered or unexported fields
}

func (*NormalLikelihoodDistribution) EvaluateLogLike

func (n *NormalLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (*NormalLikelihoodDistribution) EvaluateLogLikeMeanGrad

func (n *NormalLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64

func (*NormalLikelihoodDistribution) GenerateNewSamples

func (n *NormalLikelihoodDistribution) GenerateNewSamples() []float64

func (*NormalLikelihoodDistribution) SetParams

func (n *NormalLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)

func (*NormalLikelihoodDistribution) SetSeed

func (n *NormalLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)

type PoissonLikelihoodDistribution

PoissonLikelihoodDistribution models count data with a Poisson distribution.

Usage hints:

• Provide mean via params or upstream partition outputs.
• GenerateNewSamples draws iid Poisson variates per dimension.

type PoissonLikelihoodDistribution struct {
    Src rand.Source
    // contains filtered or unexported fields
}

func (*PoissonLikelihoodDistribution) EvaluateLogLike

func (p *PoissonLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (*PoissonLikelihoodDistribution) EvaluateLogLikeMeanGrad

func (p *PoissonLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64

func (*PoissonLikelihoodDistribution) GenerateNewSamples

func (p *PoissonLikelihoodDistribution) GenerateNewSamples() []float64

func (*PoissonLikelihoodDistribution) SetParams

func (p *PoissonLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)

func (*PoissonLikelihoodDistribution) SetSeed

func (p *PoissonLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)

type PosteriorCovarianceIteration

PosteriorCovarianceIteration updates an estimate of the covariance matrix of the posterior distribution over params using log-likelihood and param values given in the state history of other partitions, and a mean vector.

type PosteriorCovarianceIteration struct {
}

func (*PosteriorCovarianceIteration) Configure

func (p *PosteriorCovarianceIteration) Configure(partitionIndex int, settings *simulator.Settings)

func (*PosteriorCovarianceIteration) Iterate

func (p *PosteriorCovarianceIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64

type PosteriorLogNormalisationIteration

PosteriorLogNormalisationIteration updates the cumulative normalisation of the posterior distribution over params using log-likelihood values given in the state history of other partitions as well as a specified past discounting factor.

type PosteriorLogNormalisationIteration struct {
}

func (*PosteriorLogNormalisationIteration) Configure

func (p *PosteriorLogNormalisationIteration) Configure(partitionIndex int, settings *simulator.Settings)

func (*PosteriorLogNormalisationIteration) Iterate

func (p *PosteriorLogNormalisationIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64

type PosteriorMeanIteration

PosteriorMeanIteration updates an estimate of the mean of the posterior distribution over params using log-likelihood and param values given in the state history of other partitions.

type PosteriorMeanIteration struct {
    Transform func(
        params *simulator.Params,
        values mat.Vector,
    ) mat.Vector
}

func (*PosteriorMeanIteration) Configure

func (p *PosteriorMeanIteration) Configure(partitionIndex int, settings *simulator.Settings)

func (*PosteriorMeanIteration) Iterate

func (p *PosteriorMeanIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64

type TLikelihoodDistribution

TLikelihoodDistribution assumes the real data are well described by a Student’s t-distribution, given the input degrees of freedom, mean and covariance matrix.

type TLikelihoodDistribution struct {
    Src rand.Source
    // contains filtered or unexported fields
}

func (*TLikelihoodDistribution) EvaluateLogLike

func (t *TLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (*TLikelihoodDistribution) EvaluateLogLikeMeanGrad

func (t *TLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64

func (*TLikelihoodDistribution) GenerateNewSamples

func (t *TLikelihoodDistribution) GenerateNewSamples() []float64

func (*TLikelihoodDistribution) SetParams

func (t *TLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)

func (*TLikelihoodDistribution) SetSeed

func (t *TLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)

type WishartLikelihoodDistribution

WishartLikelihoodDistribution assumes the real data are well described by a Wishart distribution, given the input degrees of freedom and scale matrix.

type WishartLikelihoodDistribution struct {
    Src rand.Source
    // contains filtered or unexported fields
}

func (*WishartLikelihoodDistribution) EvaluateLogLike

func (w *WishartLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (*WishartLikelihoodDistribution) EvaluateLogLikeMeanGrad

func (w *WishartLikelihoodDistribution) EvaluateLogLikeMeanGrad(data []float64) []float64

func (*WishartLikelihoodDistribution) GenerateNewSamples

func (w *WishartLikelihoodDistribution) GenerateNewSamples() []float64

func (*WishartLikelihoodDistribution) SetParams

func (w *WishartLikelihoodDistribution) SetParams(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory)

func (*WishartLikelihoodDistribution) SetSeed

func (w *WishartLikelihoodDistribution) SetSeed(partitionIndex int, settings *simulator.Settings)

Generated by gomarkdoc