Struct ParticleFilter 

pub struct ParticleFilter {
    pub num_particles: usize,
    pub particles: Vec<Particle>,
    pub state_variables: Vec<String>,
    pub ess_threshold: f64,
    pub track_history: bool,
}

Particle filter (Sequential Monte Carlo) for temporal inference.

Particle filtering is used for inference in dynamic systems where the state evolves over time.

Example

use tensorlogic_quantrs_hooks::{ParticleFilter, HiddenMarkovModel, Assignment};
use std::collections::HashMap;

// Create HMM with 2 states, 3 observations, 10 time steps
let hmm = HiddenMarkovModel::new(2, 3, 10);

// Create particle filter
let mut pf = ParticleFilter::new(100, vec!["state".to_string()]);

// Initialize particles
let cardinalities: HashMap<String, usize> = [("state".to_string(), 2)].into_iter().collect();
pf.initialize(&cardinalities);

Fields

num_particles: usize

Number of particles

particles: Vec<Particle>

Current particles

state_variables: Vec<String>

State variable names

ess_threshold: f64

Effective sample size threshold for resampling

track_history: bool

Whether to track history

Implementations

impl ParticleFilter

pub fn new(num_particles: usize, state_variables: Vec<String>) -> Self

Create a new particle filter.

pub fn with_ess_threshold(self, threshold: f64) -> Self

Set the ESS threshold for resampling (as fraction of num_particles).

pub fn with_history(self, track: bool) -> Self

Enable history tracking.

pub fn initialize(&mut self, cardinalities: &HashMap<String, usize>)

Initialize particles uniformly.

pub fn initialize_from_prior( &mut self, prior: &[f64], cardinalities: &HashMap<String, usize>, )

Initialize particles from a prior distribution.

pub fn predict( &mut self, transition: &dyn Fn(&Assignment, u64) -> Assignment, cardinalities: &HashMap<String, usize>, )

Predict step: propagate particles through transition model.

The transition function takes a state and a random seed, returning the next state.

pub fn update<F>(&mut self, observation: &Assignment, likelihood: F)

where F: Fn(&Assignment, &Assignment) -> f64,

Update step: weight particles based on observation likelihood.

pub fn effective_sample_size(&self) -> f64

Compute effective sample size.

pub fn resample(&mut self)

Resample particles using systematic resampling.

pub fn estimate_marginal(&self, var_name: &str, cardinality: usize) -> Vec<f64>

Estimate marginal distribution from particles.

pub fn estimate_expectation<F>(&self, func: F) -> f64

where F: Fn(&Assignment) -> f64,

Estimate expected value of a function over the particle distribution.

pub fn map_estimate(&self) -> Option<&Assignment>

Get the MAP (most likely) state.

pub fn entropy(&self) -> f64

Get entropy of the particle distribution.

pub fn run_sequence( &mut self, observations: &[Assignment], transition: &dyn Fn(&Assignment, u64) -> Assignment, likelihood: &dyn Fn(&Assignment, &Assignment) -> f64, cardinalities: &HashMap<String, usize>, ) -> Vec<Vec<f64>>

Run particle filter on a sequence of observations.

The transition function takes a state and a random seed. The likelihood function computes P(observation | state).