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:

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

Usage Patterns:

Index

Constants

Prior type codes for params-based configuration.

const (
    PriorTypeUniform         = 0
    PriorTypeTruncatedNormal = 1
    PriorTypeHalfNormal      = 2
    PriorTypeLogNormal       = 3
)

PriorParamsStride is the number of float64 values per prior in the prior_params encoding. Each prior type uses a subset:

Uniform (0):         [lo, hi, 0, 0]
TruncatedNormal (1): [mu, sigma, lo, hi]
HalfNormal (2):      [sigma, 0, 0, 0]
LogNormal (3):       [mu, sigma, 0, 0]
const PriorParamsStride = 4

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 EncodePriors

func EncodePriors(priors []Prior) (priorTypes, priorParams []float64)

EncodePriors converts a []Prior into params-compatible slices (prior_types and prior_params) for YAML configuration.

func LogSumExp

func LogSumExp(x []float64) float64

LogSumExp computes log(sum(exp(x))) with numerical stability.

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 PosteriorStateWidth

func PosteriorStateWidth(nParams int) int

PosteriorStateWidth returns the state width for SMCPosteriorIteration.

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.

func WeightedQuantiles

func WeightedQuantiles(values, weights, probs []float64) []float64

WeightedQuantiles computes weighted quantiles from particle values.

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:

Applications:

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:

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 HalfNormalPrior

HalfNormalPrior is a half-normal distribution (x >= 0) with scale sigma.

type HalfNormalPrior struct {
    Sigma float64
}

func (*HalfNormalPrior) InSupport

func (p *HalfNormalPrior) InSupport(x float64) bool

func (*HalfNormalPrior) LogPDF

func (p *HalfNormalPrior) LogPDF(x float64) float64

func (*HalfNormalPrior) Sample

func (p *HalfNormalPrior) Sample(rng *rand.Rand) float64

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:

Interface Methods:

Implementation Requirements:

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:

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 LogNormalPrior

LogNormalPrior is a log-normal distribution: log(x) ~ N(mu, sigma^2).

type LogNormalPrior struct {
    Mu, Sigma float64
}

func (*LogNormalPrior) InSupport

func (p *LogNormalPrior) InSupport(x float64) bool

func (*LogNormalPrior) LogPDF

func (p *LogNormalPrior) LogPDF(x float64) float64

func (*LogNormalPrior) Sample

func (p *LogNormalPrior) Sample(rng *rand.Rand) 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:

type NormalLikelihoodDistribution struct {
    Src rand.Source

    // AllowDefaultCovarianceFallback must be true to substitute
    // default_covariance when the primary matrix is not positive-definite.
    AllowDefaultCovarianceFallback bool
    // 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:

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.

Rolling history: each row i of the log-likelihood partition’s history is weighted by past_discounting_factor^i inside the inner LogSumExp. During an embedded likelihood burn-in, early outer steps often repeat the same inner score (e.g. 0); those rows remain in history until they roll off, so discounting applies to them as well—prefer aligning embedded burn-in with window depth or overriding EmbeddedBurnInSteps when building comparison partitions (see analysis.AppliedLikelihoodComparison).

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 Prior

Prior defines a 1D prior distribution for a model parameter.

type Prior interface {
    Sample(rng *rand.Rand) float64
    LogPDF(x float64) float64
    InSupport(x float64) bool
}

func DecodePriors

func DecodePriors(priorTypes, priorParams []float64) []Prior

DecodePriors builds a []Prior from params-encoded type codes and parameter values. prior_types has length d, prior_params has length 4*d (PriorParamsStride per prior).

type SMCPosteriorIteration

SMCPosteriorIteration computes importance-weighted posterior statistics from particle log-likelihoods and parameters received via params_from_upstream channels.

State layout: [posterior_mean(d) | posterior_cov(d²) | log_marginal_lik(1)] State width: d + d² + 1.

Params:

num_particles:     [N]
num_params:        [d]
particle_loglikes: [N values] (via params_from_upstream)
particle_params:   [N*d flat] (via params_from_upstream)
verbose:           [0 or 1]
type SMCPosteriorIteration struct {
    ParamNames []string
    // contains filtered or unexported fields
}

func (*SMCPosteriorIteration) Configure

func (s *SMCPosteriorIteration) Configure(partitionIndex int, settings *simulator.Settings)

func (*SMCPosteriorIteration) Iterate

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

type SMCProposalIteration

SMCProposalIteration generates N particle proposals at each step. On step 1 it draws from the prior. On subsequent steps it draws from a multivariate normal centred on the previous posterior, read from the posterior partition’s state history.

State layout: [particle_params(N*d)] flattened row-major. State width: N*d.

Params:

num_particles:      [N]
prior_types:        [type codes]
prior_params:       [4 values per prior]
posterior_partition: [partition_index] (via params_as_partitions)
verbose:            [0 or 1]
type SMCProposalIteration struct {
    Priors []Prior
    // contains filtered or unexported fields
}

func (*SMCProposalIteration) Configure

func (s *SMCProposalIteration) Configure(partitionIndex int, settings *simulator.Settings)

func (*SMCProposalIteration) Iterate

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

type SMCResult

SMCResult holds the posterior estimates from SMC inference.

type SMCResult struct {
    ParamNames     []string
    PosteriorMean  []float64
    PosteriorStd   []float64
    PosteriorCov   []float64 // d*d flattened row-major
    LogMarginalLik float64
    Predictions    [][]float64 // [T][N] predicted values per particle
    ParticleParams [][]float64 // [N][d] final round particle parameters
    ParticleLogLik []float64   // [N] final round cumulative log-likelihoods
    Weights        []float64   // [N] normalised importance weights
}

func ComputePosterior

func ComputePosterior(paramNames []string, particleParams [][]float64, logLiks []float64, predictions [][]float64) *SMCResult

ComputePosterior computes posterior statistics from weighted particles.

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 TruncatedNormalPrior

TruncatedNormalPrior is a normal distribution truncated to [Lo, Hi].

type TruncatedNormalPrior struct {
    Mu, Sigma float64
    Lo, Hi    float64
}

func (*TruncatedNormalPrior) InSupport

func (p *TruncatedNormalPrior) InSupport(x float64) bool

func (*TruncatedNormalPrior) LogPDF

func (p *TruncatedNormalPrior) LogPDF(x float64) float64

func (*TruncatedNormalPrior) Sample

func (p *TruncatedNormalPrior) Sample(rng *rand.Rand) float64

type UniformPrior

UniformPrior is a uniform distribution on [Lo, Hi].

type UniformPrior struct {
    Lo, Hi float64
}

func (*UniformPrior) InSupport

func (p *UniformPrior) InSupport(x float64) bool

func (*UniformPrior) LogPDF

func (p *UniformPrior) LogPDF(x float64) float64

func (*UniformPrior) Sample

func (p *UniformPrior) Sample(rng *rand.Rand) float64

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