cuthbert 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

cuthbert/smc/marginal_particle_filter.py

@@ -0,0 +1,237 @@
+"""Implements the marginal particle filter.
+
+See [Klaas et. al. (2005)](https://www.cs.ubc.ca/~arnaud/klass_defreitas_doucet_marginalparticlefilterUAI2005.pdf)
+"""
+
+from functools import partial
+from typing import NamedTuple
+
+import jax
+import jax.numpy as jnp
+from jax import Array, random, tree
+
+from cuthbert.inference import Filter
+from cuthbert.smc.types import InitSample, LogPotential, PropagateSample
+from cuthbert.utils import dummy_tree_like
+from cuthbertlib.resampling import Resampling
+from cuthbertlib.smc.ess import log_ess
+from cuthbertlib.types import ArrayTree, ArrayTreeLike, KeyArray, ScalarArray
+
+
+class MarginalParticleFilterState(NamedTuple):
+    """Marginal particle filter state."""
+
+    # no ancestors, as it does not make sense for marginal particle filters
+    key: KeyArray
+    particles: ArrayTree
+    log_weights: Array
+    model_inputs: ArrayTree
+    log_normalizing_constant: ScalarArray
+
+
+def build_filter(
+    init_sample: InitSample,
+    propagate_sample: PropagateSample,
+    log_potential: LogPotential,
+    n_filter_particles: int,
+    resampling_fn: Resampling,
+    ess_threshold: float,
+) -> Filter:
+    r"""Builds a marginal particle filter object.
+
+    Args:
+        init_sample: Function to sample from the initial distribution $M_0(x_0)$.
+        propagate_sample: Function to sample from the Markov kernel $M_t(x_t \mid x_{t-1})$.
+        log_potential: Function to compute the log potential $\log G_t(x_{t-1}, x_t)$.
+        n_filter_particles: Number of particles for the filter.
+        resampling_fn: Resampling algorithm to use (e.g., systematic, multinomial).
+        ess_threshold: Fraction of particle count specifying when to resample.
+            Resampling is triggered when the
+            effective sample size (ESS) < ess_threshold * n_filter_particles.
+
+    Returns:
+        Filter object for the particle filter.
+    """
+    return Filter(
+        init_prepare=partial(
+            init_prepare,
+            init_sample=init_sample,
+            log_potential=log_potential,
+            n_filter_particles=n_filter_particles,
+        ),
+        filter_prepare=partial(
+            filter_prepare,
+            init_sample=init_sample,
+            n_filter_particles=n_filter_particles,
+        ),
+        filter_combine=partial(
+            filter_combine,
+            propagate_sample=propagate_sample,
+            log_potential=log_potential,
+            resampling_fn=resampling_fn,
+            ess_threshold=ess_threshold,
+        ),
+        associative=False,
+    )
+
+
+def init_prepare(
+    model_inputs: ArrayTreeLike,
+    init_sample: InitSample,
+    log_potential: LogPotential,
+    n_filter_particles: int,
+    key: KeyArray | None = None,
+) -> MarginalParticleFilterState:
+    """Prepare the initial state for the marginal particle filter.
+
+    Args:
+        model_inputs: Model inputs.
+        init_sample: Function to sample from the initial distribution M_0(x_0).
+        log_potential: Function to compute the log potential log G_t(x_{t-1}, x_t).
+            x_{t-1} is None since there is no previous state at t=0.
+        n_filter_particles: Number of particles to sample.
+        key: JAX random key.
+
+    Returns:
+        Initial state for the filter.
+
+    Raises:
+        ValueError: If `key` is None.
+    """
+    model_inputs = tree.map(lambda x: jnp.asarray(x), model_inputs)
+    if key is None:
+        raise ValueError("A JAX PRNG key must be provided.")
+
+    # Sample
+    keys = random.split(key, n_filter_particles)
+    particles = jax.vmap(init_sample, (0, None))(keys, model_inputs)
+
+    # Weight
+    log_weights = jax.vmap(log_potential, (None, 0, None))(
+        None, particles, model_inputs
+    )
+
+    # Compute the log normalizing constant
+    log_normalizing_constant = jax.nn.logsumexp(log_weights) - jnp.log(
+        n_filter_particles
+    )
+
+    return MarginalParticleFilterState(
+        key=key,
+        particles=particles,
+        log_weights=log_weights,
+        model_inputs=model_inputs,
+        log_normalizing_constant=log_normalizing_constant,
+    )
+
+
+def filter_prepare(
+    model_inputs: ArrayTreeLike,
+    init_sample: InitSample,
+    n_filter_particles: int,
+    key: KeyArray | None = None,
+) -> MarginalParticleFilterState:
+    """Prepare a state for a marginal particle filter step.
+
+    Args:
+        model_inputs: Model inputs.
+        init_sample: Function to sample from the initial distribution M_0(x_0).
+            Only used to infer particle shapes.
+        n_filter_particles: Number of particles for the filter.
+        key: JAX random key.
+
+    Returns:
+        Prepared state for the filter.
+
+    Raises:
+        ValueError: If `key` is None.
+    """
+    model_inputs = tree.map(lambda x: jnp.asarray(x), model_inputs)
+    if key is None:
+        raise ValueError("A JAX PRNG key must be provided.")
+    dummy_particle = jax.eval_shape(init_sample, key, model_inputs)
+    particles = tree.map(
+        lambda x: jnp.empty((n_filter_particles,) + x.shape), dummy_particle
+    )
+    particles = dummy_tree_like(particles)
+    return MarginalParticleFilterState(
+        key=key,
+        particles=particles,
+        log_weights=jnp.zeros(n_filter_particles),
+        model_inputs=model_inputs,
+        log_normalizing_constant=jnp.array(0.0),
+    )
+
+
+def filter_combine(
+    state_1: MarginalParticleFilterState,
+    state_2: MarginalParticleFilterState,
+    propagate_sample: PropagateSample,
+    log_potential: LogPotential,
+    resampling_fn: Resampling,
+    ess_threshold: float,
+) -> MarginalParticleFilterState:
+    """Combine previous filter state with the state prepared for the current step.
+
+    Implements the marginal particle filter update: conditional resampling,
+    propagation through state dynamics, and N^2 reweighting based on the
+    potential function.
+
+    Args:
+        state_1: Filter state from the previous time step.
+        state_2: Filter state prepared for the current step.
+        propagate_sample: Function to sample from the Markov kernel M_t(x_t | x_{t-1}).
+        log_potential: Function to compute the log potential log G_t(x_{t-1}, x_t).
+        resampling_fn: Resampling algorithm to use (e.g., systematic, multinomial).
+        ess_threshold: Fraction of particle count specifying when to resample.
+            Resampling is triggered when the effective sample size (ESS) < ess_threshold * N.
+
+    Returns:
+        The filtered state at the current time step.
+    """
+    N = state_1.log_weights.shape[0]
+    keys = random.split(state_1.key, N + 1)
+
+    # Resample
+    prev_log_weights = state_1.log_weights - jax.nn.logsumexp(
+        state_1.log_weights
+    )  # Ensure normalized
+    ancestor_indices, log_weights = jax.lax.cond(
+        log_ess(state_1.log_weights) < jnp.log(ess_threshold * N),
+        lambda: (resampling_fn(keys[0], state_1.log_weights, N), jnp.zeros(N)),
+        lambda: (jnp.arange(N), state_1.log_weights),
+    )
+    ancestors = tree.map(lambda x: x[ancestor_indices], state_1.particles)
+
+    # Propagate
+    next_particles = jax.vmap(propagate_sample, (0, 0, None))(
+        keys[1:], ancestors, state_2.model_inputs
+    )
+
+    # N^2 Reweight by comparing all ancestors with all next particles
+    log_potential_vmapped = jax.vmap(
+        jax.vmap(log_potential, (0, None, None), out_axes=0),
+        (None, 0, None),
+        out_axes=0,
+    )
+
+    log_potentials = log_potential_vmapped(
+        state_1.particles, next_particles, state_2.model_inputs
+    )
+    next_log_weights = log_potentials + prev_log_weights[None, :]
+    next_log_weights = jax.nn.logsumexp(next_log_weights, axis=1)
+
+    # Compute the log normalizing constant
+    logsum_weights = jax.nn.logsumexp(next_log_weights)
+    log_normalizing_constant_incr = logsum_weights - jax.nn.logsumexp(log_weights)
+    log_normalizing_constant = (
+        log_normalizing_constant_incr + state_1.log_normalizing_constant
+    )
+
+    return MarginalParticleFilterState(
+        key=state_2.key,
+        particles=next_particles,
+        log_weights=next_log_weights,
+        model_inputs=state_2.model_inputs,
+        log_normalizing_constant=log_normalizing_constant,
+    )

cuthbert/smc/particle_filter.py

@@ -0,0 +1,234 @@
+"""Implements the generic particle filter.
+
+See Algorithm 10.1, [Chopin and Papaspiliopoulos, 2020](https://doi.org/10.1007/978-3-030-47845-2).
+"""
+
+from functools import partial
+from typing import NamedTuple
+
+import jax
+import jax.numpy as jnp
+from jax import Array, random, tree
+
+from cuthbert.inference import Filter
+from cuthbert.smc.types import InitSample, LogPotential, PropagateSample
+from cuthbert.utils import dummy_tree_like
+from cuthbertlib.resampling import Resampling
+from cuthbertlib.smc.ess import log_ess
+from cuthbertlib.types import ArrayTree, ArrayTreeLike, KeyArray, ScalarArray
+
+
+class ParticleFilterState(NamedTuple):
+    """Particle filter state."""
+
+    key: KeyArray
+    particles: ArrayTree
+    log_weights: Array
+    ancestor_indices: Array
+    model_inputs: ArrayTree
+    log_normalizing_constant: ScalarArray
+
+    @property
+    def n_particles(self) -> int:
+        """Number of particles in the filter state."""
+        return self.log_weights.shape[-1]
+
+
+def build_filter(
+    init_sample: InitSample,
+    propagate_sample: PropagateSample,
+    log_potential: LogPotential,
+    n_filter_particles: int,
+    resampling_fn: Resampling,
+    ess_threshold: float,
+) -> Filter:
+    r"""Builds a particle filter object.
+
+    Args:
+        init_sample: Function to sample from the initial distribution $M_0(x_0)$.
+        propagate_sample: Function to sample from the Markov kernel $M_t(x_t \mid x_{t-1})$.
+        log_potential: Function to compute the log potential $\log G_t(x_{t-1}, x_t)$.
+        n_filter_particles: Number of particles for the filter.
+        resampling_fn: Resampling algorithm to use (e.g., systematic, multinomial).
+        ess_threshold: Fraction of particle count specifying when to resample.
+            Resampling is triggered when the
+            effective sample size (ESS) < ess_threshold * n_filter_particles.
+
+    Returns:
+        Filter object for the particle filter.
+    """
+    return Filter(
+        init_prepare=partial(
+            init_prepare,
+            init_sample=init_sample,
+            log_potential=log_potential,
+            n_filter_particles=n_filter_particles,
+        ),
+        filter_prepare=partial(
+            filter_prepare,
+            init_sample=init_sample,
+            n_filter_particles=n_filter_particles,
+        ),
+        filter_combine=partial(
+            filter_combine,
+            propagate_sample=propagate_sample,
+            log_potential=log_potential,
+            resampling_fn=resampling_fn,
+            ess_threshold=ess_threshold,
+        ),
+        associative=False,
+    )
+
+
+def init_prepare(
+    model_inputs: ArrayTreeLike,
+    init_sample: InitSample,
+    log_potential: LogPotential,
+    n_filter_particles: int,
+    key: KeyArray | None = None,
+) -> ParticleFilterState:
+    """Prepare the initial state for the particle filter.
+
+    Args:
+        model_inputs: Model inputs.
+        init_sample: Function to sample from the initial distribution M_0(x_0).
+        log_potential: Function to compute the log potential log G_t(x_{t-1}, x_t).
+            x_{t-1} is None since there is no previous state at t=0.
+        n_filter_particles: Number of particles to sample.
+        key: JAX random key.
+
+    Returns:
+        Initial state for the particle filter.
+
+    Raises:
+        ValueError: If `key` is None.
+    """
+    model_inputs = tree.map(lambda x: jnp.asarray(x), model_inputs)
+    if key is None:
+        raise ValueError("A JAX PRNG key must be provided.")
+
+    # Sample
+    keys = random.split(key, n_filter_particles)
+    particles = jax.vmap(init_sample, (0, None))(keys, model_inputs)
+
+    # Weight
+    log_weights = jax.vmap(log_potential, (None, 0, None))(
+        None, particles, model_inputs
+    )
+
+    # Compute the log normalizing constant
+    log_normalizing_constant = jax.nn.logsumexp(log_weights) - jnp.log(
+        n_filter_particles
+    )
+
+    return ParticleFilterState(
+        key=key,
+        particles=particles,
+        log_weights=log_weights,
+        ancestor_indices=jnp.arange(n_filter_particles),
+        model_inputs=model_inputs,
+        log_normalizing_constant=log_normalizing_constant,
+    )
+
+
+def filter_prepare(
+    model_inputs: ArrayTreeLike,
+    init_sample: InitSample,
+    n_filter_particles: int,
+    key: KeyArray | None = None,
+) -> ParticleFilterState:
+    """Prepare a state for a particle filter step.
+
+    Args:
+        model_inputs: Model inputs.
+        init_sample: Function to sample from the initial distribution M_0(x_0).
+            Only used to infer particle shapes.
+        n_filter_particles: Number of particles for the filter.
+        key: JAX random key.
+
+    Returns:
+        Prepared state for the filter.
+
+    Raises:
+        ValueError: If `key` is None.
+    """
+    model_inputs = tree.map(lambda x: jnp.asarray(x), model_inputs)
+    if key is None:
+        raise ValueError("A JAX PRNG key must be provided.")
+    dummy_particle = jax.eval_shape(init_sample, key, model_inputs)
+    particles = tree.map(
+        lambda x: jnp.empty((n_filter_particles,) + x.shape), dummy_particle
+    )
+    particles = dummy_tree_like(particles)
+    return ParticleFilterState(
+        key=key,
+        particles=particles,
+        log_weights=jnp.zeros(n_filter_particles),
+        ancestor_indices=jnp.arange(n_filter_particles),
+        model_inputs=model_inputs,
+        log_normalizing_constant=jnp.array(0.0),
+    )
+
+
+def filter_combine(
+    state_1: ParticleFilterState,
+    state_2: ParticleFilterState,
+    propagate_sample: PropagateSample,
+    log_potential: LogPotential,
+    resampling_fn: Resampling,
+    ess_threshold: float,
+) -> ParticleFilterState:
+    """Combine previous filter state with the state prepared for the current step.
+
+    Implements the particle filter update: conditional resampling,
+    propagation through state dynamics, and reweighting based on the potential function.
+
+    Args:
+        state_1: Filter state from the previous time step.
+        state_2: Filter state prepared for the current step.
+        propagate_sample: Function to sample from the Markov kernel M_t(x_t | x_{t-1}).
+        log_potential: Function to compute the log potential log G_t(x_{t-1}, x_t).
+        resampling_fn: Resampling algorithm to use (e.g., systematic, multinomial).
+        ess_threshold: Fraction of particle count specifying when to resample.
+            Resampling is triggered when the effective sample size (ESS) < ess_threshold * N.
+
+    Returns:
+        The filtered state at the current time step.
+    """
+    N = state_1.log_weights.shape[0]
+    keys = random.split(state_1.key, N + 1)
+
+    # Resample
+    ancestor_indices, log_weights = jax.lax.cond(
+        log_ess(state_1.log_weights) < jnp.log(ess_threshold * N),
+        lambda: (resampling_fn(keys[0], state_1.log_weights, N), jnp.zeros(N)),
+        lambda: (jnp.arange(N), state_1.log_weights),
+    )
+    ancestors = tree.map(lambda x: x[ancestor_indices], state_1.particles)
+
+    # Propagate
+    next_particles = jax.vmap(propagate_sample, (0, 0, None))(
+        keys[1:], ancestors, state_2.model_inputs
+    )
+
+    # Reweight
+    log_potentials = jax.vmap(log_potential, (0, 0, None))(
+        ancestors, next_particles, state_2.model_inputs
+    )
+    next_log_weights = log_potentials + log_weights
+
+    # Compute the log normalizing constant
+    logsum_weights = jax.nn.logsumexp(next_log_weights)
+    log_normalizing_constant_incr = logsum_weights - jax.nn.logsumexp(log_weights)
+    log_normalizing_constant = (
+        log_normalizing_constant_incr + state_1.log_normalizing_constant
+    )
+
+    return ParticleFilterState(
+        state_2.key,
+        next_particles,
+        next_log_weights,
+        ancestor_indices,
+        state_2.model_inputs,
+        log_normalizing_constant,
+    )

cuthbert/smc/types.py

@@ -0,0 +1,67 @@
+r"""Provides types for representing generic Feynman--Kac models.
+
+$$
+\mathbb{Q}_{t}(x_{0:t}) \propto \mathbb{M}_0(x_0) \, G_0(x_0) \prod_{s=1}^{t} M_s(x_s \mid x_{s-1}) \, G_s(x_{s-1}, x_s).
+$$
+"""
+
+from typing import Protocol
+
+from cuthbertlib.types import ArrayTree, ArrayTreeLike, KeyArray, ScalarArray
+
+
+class InitSample(Protocol):
+    """Protocol for  sampling from the initial distribution $M_0(x_0)$."""
+
+    def __call__(self, key: KeyArray, model_inputs: ArrayTreeLike) -> ArrayTree:
+        """Samples from the initial distribution $M_0(x_0)$.
+
+        Args:
+            key: JAX PRNG key.
+            model_inputs: Model inputs.
+
+        Returns:
+            A sample $x_0$.
+        """
+        ...
+
+
+class PropagateSample(Protocol):
+    r"""Protocol for sampling from the Markov kernel $M_t(x_t \mid x_{t-1})$."""
+
+    def __call__(
+        self, key: KeyArray, state: ArrayTreeLike, model_inputs: ArrayTreeLike
+    ) -> ArrayTree:
+        r"""Samples from the Markov kernel $M_t(x_t \mid x_{t-1})$.
+
+        Args:
+            key: JAX PRNG key.
+            state: State at the previous step $x_{t-1}$.
+            model_inputs: Model inputs.
+
+        Returns:
+            A sample $x_t$.
+        """
+        ...
+
+
+class LogPotential(Protocol):
+    r"""Protocol for computing the log potential function $\log G_t(x_{t-1}, x_t)$."""
+
+    def __call__(
+        self,
+        state_prev: ArrayTreeLike,
+        state: ArrayTreeLike,
+        model_inputs: ArrayTreeLike,
+    ) -> ScalarArray:
+        r"""Computes the log potential function $\log G_t(x_{t-1}, x_t)$.
+
+        Args:
+            state_prev: State at the previous step $x_{t-1}$.
+            state: State at the current step $x_{t}$.
+            model_inputs: Model inputs.
+
+        Returns:
+            A scalar value $\log G_t(x_{t-1}, x_t)$.
+        """
+        ...

{cuthbert-0.0.1.dist-info → cuthbert-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cuthbert
-Version: 0.0.1
+Version: 0.0.3
 Summary: State-space model inference with JAX
 Author-email: Sam Duffield <s@mduffield.com>, Sahel Iqbal <sahel13miqbal@proton.me>, Adrien Corenflos <adrien.corenflos.stats@gmail.com>
 License: Apache-2.0
@@ -33,7 +33,7 @@ Dynamic: license-file
 
 <!--intro-start-->
 <div align="center">
-<img src="docs/assets/cuthbert.png" alt="logo"></img>
+<img src="https://raw.githubusercontent.com/state-space-models/cuthbert/main/docs/assets/cuthbert.png" alt="cuthbert logo"></img>
 </div>
 
 A JAX library for state-space model inference

cuthbert-0.0.3.dist-info/RECORD

@@ -0,0 +1,76 @@
+cuthbert/__init__.py,sha256=60_FB1nfduZLPphbjEc7WRpebCnVYiwMyKuD-7yZBvw,281
+cuthbert/filtering.py,sha256=HaUPJWhBO8P5IWlRYhLwCeOEtlYenAvWjYsQaF_cPX0,2700
+cuthbert/inference.py,sha256=u02wVKGu7mIdqn2XhcSZ93xXyPIQkxzSvxJXMH7Zo5k,7600
+cuthbert/smoothing.py,sha256=qvNAWYTGGaEUEBp7HAtYLtF1UOQK9E7u3V_l4XgxeaI,4960
+cuthbert/utils.py,sha256=0JQgRiyVs4SXZ0ullh4OmAMtyoOtuCzvYuDmpu9jXOE,1023
+cuthbert/discrete/__init__.py,sha256=AI-GYq2QRyg2hwrEJm-LJRV9aMZ7MY-QkE0wG41Qg_I,104
+cuthbert/discrete/filter.py,sha256=wpefQ3Q6eN6PdXKon93E5tjJLxBxPjqE4ctrd-QBbHA,4674
+cuthbert/discrete/smoother.py,sha256=sMS2NKt-507LYnUSzqd3GMCArcSO2-eDiINX_hvLNzY,4291
+cuthbert/discrete/types.py,sha256=hdfxqBGRza45ni0_Lu2NNvqLga_3o0PQWQgJ08BcxhM,1412
+cuthbert/gaussian/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuthbert/gaussian/kalman.py,sha256=WldTKTCzlAWX1btAD6kD63Qoz1RpTufOiq2riT6ND44,11567
+cuthbert/gaussian/types.py,sha256=IjC8AWUpjLMgm1co2sc7knb3Otwz-pnUSJEw8p5ohGc,1725
+cuthbert/gaussian/utils.py,sha256=AnRdw_Ju7rWXpbCaOB0CUkoVctJ8gScchgURv5mQ0BU,1301
+cuthbert/gaussian/moments/__init__.py,sha256=cYUxe1Sksf0qqBYO-zwtKnuoZ_gOE_Hr7aGsrzeNkOQ,327
+cuthbert/gaussian/moments/associative_filter.py,sha256=abFEs2KVbXrnIMUJMVKD32hRP8Q3A4NkQP_VmfSGeaI,6188
+cuthbert/gaussian/moments/filter.py,sha256=8dG_Aqdvs_WC23JGpC3B5mTjG5uJMtd15LxJAjeyddY,3951
+cuthbert/gaussian/moments/non_associative_filter.py,sha256=wV_IBeaA-EnWLnX5Wkp6-Kx9WDnpeVWtdUiqlXeGS1U,5942
+cuthbert/gaussian/moments/smoother.py,sha256=L79R8WPwI30aHyCdZE1paYM9KNZtmQlRsvFhDyFsoxs,4262
+cuthbert/gaussian/moments/types.py,sha256=UXUaeakgyO-WLcY8ECmFcf16RwOQZ6pz0B5qI621xV8,1727
+cuthbert/gaussian/taylor/__init__.py,sha256=xOdFMzy59MfF1WuM7Oy4_H7Hn0TtekyoK-ECM5CVuEE,428
+cuthbert/gaussian/taylor/associative_filter.py,sha256=daIY693BefoeV15T4hnOiJ2_e-eH2bGDrmA4pEwNB0A,8318
+cuthbert/gaussian/taylor/filter.py,sha256=ljlHidVuFAlrVVSfmFM6sfdxQuYsmCVsSMucHCuFd3M,5303
+cuthbert/gaussian/taylor/non_associative_filter.py,sha256=qhT31jWyCct_C0Ae3wNLm3BD75eBYX16xNDaA8uw-wg,9446
+cuthbert/gaussian/taylor/smoother.py,sha256=hDAOTJc71oZZIH_ZRkVDXnbLj8riwNqncRy-N372wXA,5814
+cuthbert/gaussian/taylor/types.py,sha256=h45seSNRUSgT4tpQVjqW_AJny2HCz6kJi9yM7zLEWOc,2733
+cuthbert/smc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuthbert/smc/backward_sampler.py,sha256=rFsJvSvx3S2hRl2ojTwvwQqERtu_gaBEWzjQtO2GIXQ,6737
+cuthbert/smc/marginal_particle_filter.py,sha256=91WaqsSmoo3Q5pPanYaLSnCOyKLMWSDH1aV3h1SkO2g,8125
+cuthbert/smc/particle_filter.py,sha256=PebY0rt0C76lAZgoWkpIGzUkR_BxoRMCZtOFsRRVSok,7770
+cuthbert/smc/types.py,sha256=jen13y7RWylzIAmrpPGpp980V7uukG06kkoEkcCGZJA,1841
+cuthbert-0.0.3.dist-info/licenses/LICENSE,sha256=4bgVKT6ovc1ZpaqBTr3nDmQrN0rNe1Yx-WNW_q3Er7s,11390
+cuthbertlib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuthbertlib/types.py,sha256=sgHC0J7W_0wOzMm5dlLZXwJB3W1xvzq2J6cxl6U831w,1020
+cuthbertlib/discrete/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuthbertlib/discrete/filtering.py,sha256=_TMGwAeDXHivANpck3HUXFFm8SUalm72N7NHPzYTan8,1466
+cuthbertlib/discrete/smoothing.py,sha256=FZJkSpUhAo7-iM3FiudKvR5XNvNEFXhfzdkf_kIoNQM,1214
+cuthbertlib/kalman/__init__.py,sha256=Tf2dJBk9qavIe_0OL_TJ2zfCTC0hBJrPS0OMbnx_p_o,221
+cuthbertlib/kalman/filtering.py,sha256=YQvxzsF5XsYz8JEJIoHiETtcNHmcMCM4djanNn-pe4w,6757
+cuthbertlib/kalman/generate.py,sha256=AeF-NXIpxN-E6YmiKIaUg4EK5wzWLkTtdg3K9RCemg4,3148
+cuthbertlib/kalman/sampling.py,sha256=Cx4EPCXwMJlPt_48aLsCowk3t70dfA0Fp_lDUQih4ok,1914
+cuthbertlib/kalman/smoothing.py,sha256=iCd5hEVrwVZ3Q2aQtJeNe1IKbpcXD7E1fqHy1P6bX_U,3928
+cuthbertlib/linalg/__init__.py,sha256=ldnznmTBCJeyFfiz1nLQ1hN0X9PwcjnQOAXjpmL6Ag8,284
+cuthbertlib/linalg/collect_nans_chol.py,sha256=7pC7lh5Oux3IiNndIOSYLUdMTAjrVIwkeK52hGnbmJg,3137
+cuthbertlib/linalg/marginal_sqrt_cov.py,sha256=Hq0ofXdMzBANIhfwqKXUSU0IL6LwGZIvU3Uq7EfaZ7E,1188
+cuthbertlib/linalg/symmetric_inv_sqrt.py,sha256=8CWJzaS9VGl3tlJHdw7B7q-DiwbWA5aqAab4i5ZJKU8,5043
+cuthbertlib/linalg/tria.py,sha256=twzyyachwNGDlHA6i6mBl504vVqOYjeC_9a8fa_X_X4,571
+cuthbertlib/linearize/__init__.py,sha256=JzeMqWch_mXJ4a1WaAYuQqQg7Z4gCvTJpZas4RqXwSE,287
+cuthbertlib/linearize/log_density.py,sha256=VUwHFCWsvZwU22aPWD_YrUb3aGOQFP_NhyUqDDYmpJo,6073
+cuthbertlib/linearize/moments.py,sha256=DiU8osX4x9htR3G_cxqMN9EcfBJ0xxSoR0Rn-2bY5WA,3205
+cuthbertlib/linearize/taylor.py,sha256=9LUzoo0wuU5mReO4DUggwyFbSJpMuZ7UMqpmvnJyyrA,3238
+cuthbertlib/quadrature/__init__.py,sha256=79moFPswxvR9InZrL3RysITfjVnYDUpVa5E2CJcdvW4,275
+cuthbertlib/quadrature/common.py,sha256=HpNFVXgP_L4vzqpNtRE6XCmiFrBAsIj-9KThAENUSbM,2743
+cuthbertlib/quadrature/cubature.py,sha256=1yiGLaij6JDPtttFBbqgNuvG6ZUgdHSbWek8d8HGmyw,1877
+cuthbertlib/quadrature/gauss_hermite.py,sha256=LuapZIklRb7CpZI5StJ9BD7oBevD0JU4cEEkqqM10dE,1740
+cuthbertlib/quadrature/linearize.py,sha256=y_GcnER8Btd-mn2GN52Wowq893PMcSxcJtnDyxbKNoA,5403
+cuthbertlib/quadrature/unscented.py,sha256=SMI51HCESHLKEW4GGrYtVCmejkiP8WUxWM_BHWVCeJw,2399
+cuthbertlib/quadrature/utils.py,sha256=15s5na_MhRJOeaorvvetw1NnoYWD-9-xMdK4ZLIo9kg,3652
+cuthbertlib/resampling/__init__.py,sha256=Po73bCYwl-yAfYMRkrxeFmXMXdhwQ8btZqJ4fiH5qPc,200
+cuthbertlib/resampling/killing.py,sha256=sPw0r86wfR9ERjbGuXiIwYo9nIqX-Y83e7magv53J7I,2817
+cuthbertlib/resampling/multinomial.py,sha256=pGSKkfPuW3Hh815u_w0x47stg033H6XkeJbHzqcmJCE,2002
+cuthbertlib/resampling/protocols.py,sha256=i2EUyLOxxKonbx-9xU8ZjjpDimIu1O8zdreEUPftdzI,2457
+cuthbertlib/resampling/systematic.py,sha256=9eRRQjgShZUs98ATAUz4BYvudWEk0z1P73sLLlVZMR0,2338
+cuthbertlib/resampling/utils.py,sha256=hmf1PmcDi1kWOFBUS0GWoP8t2Q5T_PkFWgcNnjD6sXs,2689
+cuthbertlib/smc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuthbertlib/smc/ess.py,sha256=Lkafpy2QVt7EuxZYjLQHGzff_qfsVdouA4MUpRhMuS8,645
+cuthbertlib/smc/smoothing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuthbertlib/smc/smoothing/exact_sampling.py,sha256=lUqM64l4nGe34w7ex2l5AXg-Oa67Bkzm07ow4mf0ZyM,3590
+cuthbertlib/smc/smoothing/mcmc.py,sha256=fsLOzRTYRkgJgSxtCfp8hznG48tRXuA04VCxVuLN9Bo,2490
+cuthbertlib/smc/smoothing/protocols.py,sha256=461TVhQbYIqDWBl7QRjGA35YpbDk4f6-BwtgGfgT-tU,1302
+cuthbertlib/smc/smoothing/tracing.py,sha256=E8GFM0cOQiFspOFaAaK2xtyA5oMD6pbO9JqEk-O8RPk,1343
+cuthbertlib/stats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuthbertlib/stats/multivariate_normal.py,sha256=H5wGxtuHKJldJHs_PicsCX94hczeX9Xek625RdXrd18,4314
+cuthbert-0.0.3.dist-info/METADATA,sha256=9zXQmkEBc-fq8-2vymg9ThVhYKdOLswtnuS9e2TkN2s,7116
+cuthbert-0.0.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cuthbert-0.0.3.dist-info/top_level.txt,sha256=R7-G6fUQZSMNMcM4-IcpHKtY9CZOQeejEpVW9q-Sarw,21
+cuthbert-0.0.3.dist-info/RECORD,,

{cuthbert-0.0.1.dist-info → cuthbert-0.0.3.dist-info}/licenses/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2026 state-space-models org https://github.com/state-space-models
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.