Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

CEmrys::AdditiveNoise< Parts >	Noise added to a model's output, \( z = h(x) \boxplus v \), as additiveNoise() declares it (decisions.md [additive-noise], [model-policies]): the function is transformed once, and the noise only widens and shifts the result
CEmrys::AdditiveNoise< Part >
CEmrys::ModeNoise< Axis, Part >	Additive mixture noise whose components are the values of a mode axis, as additiveNoise(mixture).byMode<Axis>() declares it (decisions.md [imm]): the Markov outlier model, in which a sensor's outlier state is a mode of the target that persists as the mode chain says
CEmrys::AffineIn< Names >	The input names a model's function is affine in, given the rest, as affineIn() declares them (decisions.md [model-policies], [affine-coordinates]): a sigma-point method factors those coordinates out and spreads its points over the others alone
CEmrys::internal::AllocatorTypeOf< ComponentType >
CEmrys::MixtureParams< Component_, Allocator_ >::Entry	One weighted component
CEmrys::roots::Along< Vector >	Axes along a direction: a root whose first column is parallel to \( d \), so that a sigma-point rule puts its first pair of points on the line through the mean along \( d \), as a split or a probe of the nonlinearity along \( d \) needs (decisions.md [splitting-hooks])
CEmrys::AxisIndex< Path, N >	An index in each leaf axis of the axis named by the path Path (a tag or a TagPath), as at() makes it, for valueOf()
CEmrys::Batched< F, Mark >	A function that takes every point at once, as batched() marks it (decisions.md [batched-functions]): it receives the points as the columns of a matrix X and writes into one output Y, a BatchedOutput the library provides, last
CEmrys::BatchedOutput< In, Out, Scalar_, Mark >	The output of a batched function (decisions.md [batched-functions]): its values, a column per point, and the Jacobians the library uses, by block of the function's input, in storage the library provides and sizes once before the call
CEmrys::BlockRows	Rows of a contiguous block of a space
CEmrys::Capacity	The most elements a container will hold, reserved once: a mixture's components or a particle set's particles
CEmrys::Categorical< Space_, Scalar_ >	The probabilities of a CategoricalParams whose weights define a distribution: a read-only view
CEmrys::CategoricalHistory< Space_, Scalar_, Allocator_ >	The record of a HiddenMarkovFilter's forward pass that a smoother runs backward over: one CategoricalPredictedJoint per prediction, each with room for its smoothed distribution
CEmrys::CategoricalParams< Space_, Scalar_ >	The parameters of a probability distribution over a discrete space: one weight per value
CEmrys::CategoricalPredictedJoint< Space, Scalar >	One prediction of a HiddenMarkovFilter as a smoother needs it: the distribution the step started from, the prediction, and the matrix that moved one to the other
CEmrys::CategoricalUpdate< Space, Scalar >	The result of updating a CategoricalParams by an emission model: the posterior, whose weights sum to one, and the log-evidence of the measurement
Cinternal::ChiSquaredWindowFor
CEmrys::NeesMonitor< Window, MaxWindow, Scalar, Allocator >	A chi-squared consistency check of a filter's estimates against the true states, over a window of them
CEmrys::NisMonitor< Window, MaxWindow, Scalar, Allocator >	A chi-squared consistency check over a window of updates
CEmrys::roots::Cholesky	Cholesky axes: the lower Cholesky factor \( L \), \( L L^T = P \), by Eigen's LLT, which fails on a covariance that is not positive definite
CEmrys::roots::ClampReport	The report of Pivoted, Principal, and Symmetric: how many pivots or eigenvalues were below zero and taken as zero, which only rounding should give a covariance
CEmrys::reductions::Collapse	Reduction policy that moment-matches an update's branches into one Gaussian: soft outlier rejection, as in the probabilistic data association of Bar-Shalom and Tse (1975)
CEmrys::CollapseBounds< Scalar >	The bracket \( \max(B - H(\hat w), 0) \le \mathrm{KL}(p \parallel q) \le B \) on the divergence of a distribution from its collapse, which kullbackLeiblerCollapseBounds() returns
CEmrys::Columns< Placed >	The matrix \( H \) of a linear measurement model by its columns: a matrix per block of the state read, each placed by tag path with on() or onEach() (decisions.md [linear-sensors])
CEmrys::ComponentError	A mixture component that could not be factorized
CEmrys::ComponentTraits< C >	What a container does with a component beyond the component's own members (decisions.md [component-first]): logDensity(component, x), the log-density read from the component's factorization without a check of its own, for a container's density view that already holds one [execution-policies]; collapse(count, componentAt, logWeightAt), the collapse of several components into one by moment matching; moments(component), its mean and covariance, read without a check, for a container's density view that has checked it, as a hybrid's needs no member for them; and MarginalType, the view of a subset of one component's coordinates that a marginal of the container gives per component [element-marginals]
CEmrys::ComponentTraits< GaussianParams< Space_, Scalar_ > >	ComponentTraits of a Gaussian in covariance form
CEmrys::ComponentTraits< HybridParams< Component_, ModeSpace_, Allocator_ > >	ComponentTraits of a hybrid state, which make it a component (decisions.md [component-first])
CEmrys::ComponentTraits< SqrtGaussianParams< Space_, Scalar_ > >	ComponentTraits of a Gaussian in square-root form (decisions.md [component-first], [gaussian-forms])
CEmrys::Composition< Models >	Process models side by side, as compose() puts them (decisions.md [model-policies], [model-placement]): one model whose reads are the union of the parts', gathered once, whose writes are the parts' together, which must write every block of the state once, whose noise is block-diagonal, and whose affine set is the names every part reading them declares affine
CEmrys::Conditioned< Space, OutputSpace, Scalar >	The result of condition(): the posterior, and the innovation, from which the log-likelihood of the observation follows when asked for
CEmrys::Consider< Paths >	The blocks of the state that a Kalman update considers rather than estimates, as consider() names them (decisions.md [consider-states]): the Schmidt-Kalman update of Schmidt (1966)
CEmrys::ContinuousNoise< Parts >	A process model's white-noise spectral density, as continuousNoise() declares it, placed by tag path on blocks of the output and discretized over the step by the model (decisions.md [continuous-time-noise], [model-policies]): \( Q_c \, \Delta t \) on each block's differences
CEmrys::ContinuousTimeMarkovChain< Space_, Scalar_ >	A continuous-time Markov chain on a discrete space: the rate of moving from each value to each other value
CEmrys::CountFrom< Path, MeasurementSpace >	The measurement space function of a model whose measurement has a block of MeasurementSpace per repetition of the state's block Path, given to outputSpace() (decisions.md [measurement-space-functions])
CEmrys::CrossMarked< Input >	An uncertain input marked by withCross()
CEmrys::methods::Cubature	Cubature method: the \( 2L \) points \( \mu \boxplus \pm \sqrt{L} \, S_j \) over the joint input space of dimension \( L \), for each column \( S_j \) of a root of the joint covariance, equally weighted by \( 1 / (2L) \), with no center point and no parameter
CEmrys::DensityEmission< Observation, DistributionOf >	The emission model of an observation drawn from a distribution chosen by the value: the log-density of the observation under the value's distribution
CEmrys::DensityOf< P >	The density of the parameters P, as its member DensityType: what its toDensity() returns
CEmrys::EachRepetition< F, BlockSpace >	One factor on every repetition of a repeated block: the product of independent copies of a density, one per repetition, as a density over the whole block (decisions.md [product-factors])
CEmrys::MixtureMarginal< Source, Selection, SubSpace >::Element	One component's log-weight, as in the source, and its marginal
CEmrys::ParticleSetMarginal< Source, Selection, SubSpace >::Element	One particle's log-weight, as in the source, and the selected entries of its state
CEmrys::UniformGrid< Space_, Scalar_ >::Element	One component: its log-weight and its mean and covariance
CEmrys::EmissionTable< Space_, ObservationSpace_, Scalar_ >	An emission table: the probability of each observed value given each value of the state
CEmrys::Factors< Placed >	The factors of a product, each placed by tag path with on() or onEach(), in no space yet: a Product once placed in one (decisions.md [product-factors])
CEmrys::FilterBranch< MeasurementSpace, Scalar >	One branch of a filter's update (see FilterUpdate): its weight, its innovation, and its labels, without the posterior, which the filter reduced into its state (decisions.md [innovation-statistics])
CEmrys::FilterUpdate< MeasurementSpace, Count, Scalar_, Allocator >	What a filter's update did: the branches of the update before reduction, with their weights and innovations but not their posteriors (decisions.md [innovation-statistics]), and whether the reduction policy accepted the measurement
CEmrys::FilterUpdate< MeasurementSpace, std::dynamic_extent, double, DefaultAllocator >
CEmrys::ReusableFilterUpdate< Space, MeasurementSpace, Scalar, Allocator >	A FilterUpdate of a run-time number of branches that keeps the MeasurementUpdate it was last filled from, posteriors included, as the scratch of its next fill
CEmrys::internal::FiniteExtent< Cardinality_, Cardinality_ >
CEmrys::Finite< Eigen::Dynamic >
CEmrys::GridAxis< Block, I >	The axis of a regular grid of points (see regularGrid()) along coordinate I of the block Block: a run-time number of cells
CEmrys::PointCells< Path >	The cells of a grid of given points (see pointGrid()) for the block named by the path Path: one value per point, under a tag of its own
CEmrys::Finite< Cardinality_, MaxCardinality_ >	Cardinality_ unnamed values, 0 to Cardinality_ - 1, such as the cells of a grid; or a number set at run time, at most MaxCardinality_, if Cardinality_ is Eigen::Dynamic
CEmrys::FitOptions< Scalar >	Options for fitMixture()
CEmrys::FixedStepModel< Space_, Model_, Method_, Scalar_ >	A process model over one fixed time step, with the work that depends only on the step done once
CEmrys::upkeep::FloorModes< Scalar_ >	Action that raises every mode less probable than probability to it, scaling the others down to keep the sum one, so that no mode is ruled out for good
Cstd::formatter
Cstd::formatter< T, char >	Formats any type the library describes (Emrys::internal::Printable) as its operator<< prints it
CEmrys::FormGaussian< Params_ >	The density of a Gaussian in a square-root or information form: a read-only view
CEmrys::methods::FourthMomentUnscented	Unscented method with \( \alpha = 1 \), \( \beta = 0 \), and \( \kappa = 3 - L \) over \( L \) coordinates, so that \( L + \lambda = 3 \): the points sit at \( \sqrt 3 \) standard deviations along each column of the root whatever \( L \) is, and their fourth moment along each column is a Gaussian's, 3
CEmrys::Gamma< Space_, Scalar_ >	Independent Gamma distributions on the coordinates, for positive quantities such as ranges, speeds, and rates
CEmrys::reductions::Gate< Inner, Scalar_ >	Reduction policy that rejects branches by a chi-squared test on their normalized innovation squared, then reduces the rest with Inner
CEmrys::methods::GaussHermite< Order >	Gauss-Hermite method: the product rule of Order points per coordinate over the joint input space of dimension \( L \), \( \mathrm{Order}^L \) points in the coordinates of a root of the joint covariance
CEmrys::Gaussian< Space_, Scalar_ >	The density of a Gaussian whose covariance has been factorized: a read-only view
CEmrys::GaussianConditional< Space_, Scalar_ >	The result of GaussianParams::conditionalWithEvidence(): the conditional distribution and the log-evidence of the given values
CEmrys::GaussianHistory< Space_, Scalar_, Allocator_ >	The record of a Kalman filter's forward pass that a smoother runs backward over: one PredictedJoint per prediction, each with room for its smoothed Gaussian
CEmrys::GaussianMarginal< Source, Selection, SubSpace >	Read-only view of a subset of the entries of a GaussianParams or Gaussian
CEmrys::GaussianMixtureHistory< Space_, Scalar_, Allocator_ >	The record of a Gaussian mixture filter's forward pass that its smoother runs backward over: one GaussianMixturePredictedJoint per prediction, each with room for its smoothed mixture
CEmrys::GaussianMixturePredictedJoint< Space_, Scalar_, Allocator_ >	One prediction of a mixture of Gaussians as its smoother needs it: the weights the step started from, each component's prediction as a PredictedJoint, and how the components descend from those of the record before
CEmrys::GaussianParams< Space_, Scalar_ >	A Gaussian distribution: a mean and covariance in a space
CEmrys::GivenBlock< Space, P, Value >	A block of a state given from outside the Gaussian being updated, as given() makes it, for update(prior, measurement, given): the block named by the path P of a state in Space, given as Value
CEmrys::GridCells< Path >	The cells of a regular grid over the block named by the path Path: the DiscreteProduct of its GridAxis axes, the last varying fastest, under a tag of its own
CEmrys::GridGaussian< Grid_, Covariance_, Component_ >	The density of a Rao-Blackwellized point-mass filter's state, a checked view of its GridGaussianParams (decisions.md [params-and-density], [view-stamp]): \( p(x) = \sum_c P(c) \, \delta(x_p - p_c) \, \mathcal{N}(x_r; \mu_c, \Sigma_c) \) over the live cells, or the hybrid of Gaussians in each cell
CEmrys::GridGaussianParams< Grid_, Covariance_, Component_ >	The parameters of a Rao-Blackwellized point-mass filter's state: the cells of a grid still alive, their probabilities, and for each a Gaussian, or a hybrid of Gaussians, over the rest of the state
CEmrys::GroundMetric< Space_, Scalar_ >	A weighting of a space's differences, built by tag path: the ground metric of wasserstein()
CEmrys::internal::HeldUpkeep< Derived, Upkeep_ >	The upkeep a filter holds, and the members that give it out and run it on the filter's state (decisions.md [upkeep])
CEmrys::ImmFilter< Component_, Model_, Method_, Allocator_, Upkeep_ >
CEmrys::KalmanFilter< InfoGaussian< Space_, Scalar_ >, Model_, Method_, KalmanRecursion< InfoGaussian< Space_, Scalar_ >, Model_, Method_ >, Upkeep_ >
CEmrys::KalmanFilter< SqrtInfoGaussian< Space_, Scalar_ >, Model_, Method_, KalmanRecursion< SqrtInfoGaussian< Space_, Scalar_ >, Model_, Method_ >, Upkeep_ >
CEmrys::KalmanFilter< SqrtGaussian< Space_, Scalar_ >, Model_, Method_, KalmanRecursion< SqrtGaussian< Space_, Scalar_ >, Model_, Method_ >, Upkeep_ >
CEmrys::RbPointMassFilter< Grid_, NoProcessModel, Covariance_, methods::Linearized, Upkeep_ >
CEmrys::HiddenMarkovFilter< Space_, Chain_, Scalar_, Upkeep_ >	A hidden Markov model filter: a CategoricalParams state, the chain that moves it, and the log-evidence of the measurements so far
CEmrys::ImmFilter< Component_, Model_, Method_, Allocator_, Upkeep_ >	An interacting multiple model (IMM) filter: a hybrid state with one component per mode, and the ImmRecursion that mixes it through a switching process model and updates it per mode
CEmrys::AmmFilter< Component_, Model_, Method_, Allocator_, Upkeep_ >	The autonomous multiple model (AMM) estimator: a bank of filters, one per mode, each running on its own, and the probability that each mode is the one in force, by Bayes' rule over their measurement likelihoods
CEmrys::MixtureFilter< Component_, Model_, Method_, Allocator_, Recursion_, Upkeep_ >	A mixture filter: a Mixture state, a process model, and the method that predicts through it, each component run by the recursion its type names, or by the one given
CEmrys::GaussianMixtureFilter< Space_, Model_, Method_, Scalar_, Allocator_, Upkeep_ >	The MixtureFilter over a GaussianMixtureParams, the spelling for the common case (decisions.md [filters-and-recursions]): each component a KalmanFilter's step, reweighted by its likelihood
CEmrys::RbParticleFilter< Space_, Path_, Model_, Covariance_, Method_, Scalar_, Allocator_, Upkeep_ >	A Rao-Blackwellized particle filter: particles for one block of the state, each carrying a Kalman filter over the rest
CEmrys::RbPointMassFilter< Grid_, Model_, Covariance_, Method_, Upkeep_ >	A Rao-Blackwellized point-mass filter: fixed points for one block of the state, such as a coarse position, each carrying a Kalman filter over the rest
CEmrys::internal::HeldUpkeep< ImmFilter< Component_, Model_, DefaultMethodFor< Model_ >, DefaultAllocator, upkeep::None >, upkeep::None >
CEmrys::ImmFilter< Component_, Model_, DefaultMethodFor< Model_ >, DefaultAllocator, upkeep::None >
Cinternal::HeldUpkeep< KalmanFilter< Component_, Model_, DefaultMethodFor< Model_ >, KalmanRecursion< Component_, Model_, DefaultMethodFor< Model_ > >, upkeep::None >, upkeep::None >
CEmrys::KalmanFilter< Component_, Model_, Method_, Recursion_, Upkeep_ >	A Kalman filter: a Gaussian state and the KalmanRecursion that predicts it through a process model and conditions it on measurements
CEmrys::InfoFilter< Space_, Model_, Method_, Scalar_, Upkeep_ >	The information filter: a KalmanFilter whose state is an InfoGaussianParams, the precision and information vector about a reference (decisions.md [gaussian-forms])
CEmrys::SqrtInfoFilter< Space_, Model_, Method_, Scalar_, Upkeep_ >	The square-root information filter: a KalmanFilter whose state is a SqrtInfoGaussianParams, the data array \( [\,R \;\; r\,] \) about a reference (decisions.md [gaussian-forms])
CEmrys::SqrtKalmanFilter< Space_, Model_, Method_, Scalar_, Upkeep_ >	The square-root Kalman filter: a KalmanFilter whose state is a SqrtGaussianParams, a mean and a lower-triangular factor of the covariance (decisions.md [gaussian-forms])
CEmrys::internal::HeldUpkeep< KalmanFilter< Component_, Model_, DefaultMethodFor< Model_ >, Recursion_, upkeep::None >, upkeep::None >
CEmrys::KalmanFilter< InfoGaussian< Space_, double >, Model_, DefaultMethodFor< Model_ >, KalmanRecursion< InfoGaussian< Space_, double >, Model_, DefaultMethodFor< Model_ > >, upkeep::None >
CEmrys::KalmanFilter< SqrtInfoGaussian< Space_, double >, Model_, DefaultMethodFor< Model_ >, KalmanRecursion< SqrtInfoGaussian< Space_, double >, Model_, DefaultMethodFor< Model_ > >, upkeep::None >
CEmrys::KalmanFilter< SqrtGaussian< Space_, double >, Model_, DefaultMethodFor< Model_ >, KalmanRecursion< SqrtGaussian< Space_, double >, Model_, DefaultMethodFor< Model_ > >, upkeep::None >
CEmrys::internal::HeldUpkeep< ParticleFilter< Space_, Model_, double, DefaultAllocator, upkeep::None >, upkeep::None >
CEmrys::ParticleFilter< Space_, Model_, Scalar_, Allocator_, Upkeep_ >	A particle filter: a weighted set of state points, moved by sampling the process model and weighted by the measurement likelihood
CEmrys::HiddenMarkovFilterUpdate< Scalar >	What a hidden Markov filter's update did: the measurement's log-evidence under the prior, and whether it was accepted
CEmrys::Hybrid< Component_, ModeSpace_, Allocator_ >	The density of a hybrid state, a checked view of its HybridParams (decisions.md [params-and-density], [view-stamp]): \( p(x, m) = P(m) \, p_m(x) \), with \( P(m) = w_m / \sum_n w_n \)
CEmrys::HybridGaussianHistory< Space_, ModeSpace_, Scalar_, Allocator_ >	The record of an IMM filter's forward pass that its smoother runs backward over: one HybridPredictedJoint per prediction, each with room for its smoothed HybridGaussian
CEmrys::HybridParams< Component_, ModeSpace_, Allocator_ >	The parameters of a hybrid state: a discrete mode, and a component conditioned on each mode
CEmrys::HybridPredictedJoint< Space_, ModeSpace_, Scalar_, Allocator_ >	One IMM prediction as its smoother needs it: the mode probabilities the step started from, each mode's Gaussian predicted through its own model as a PredictedJoint, and the chain's transition matrix
CEmrys::ImmFilterUpdate< ModeUpdate, Scalar_, Allocator >	What an IMM filter's update did: each mode's update before reduction, the observation's log-likelihood over every mode, and whether any mode accepted the measurement
CEmrys::ImmRecursion< Component_, Model_, Method_, Allocator_ >	The interacting multiple model (IMM) filter's steps over a hybrid state, without the state: a switching process model, the method that predicts the modes whose models carry none of their own, and the scratch the modes are mixed and updated into, acting on a Hybrid passed in (decisions.md [filters-and-recursions])
CEmrys::InfoGaussianParams< Space_, Scalar_ >	A Gaussian kept as its precision and information vector, about a reference value
CEmrys::Innovation< Space, Scalar >	The innovation of an update: the residual \( r \) of the observation from the predicted output, normalized in the output space, and its covariance \( S \), from which the update's statistics follow (decisions.md [innovation-statistics])
CEmrys::methods::Iterated< Method, Scalar >	Iterated method, for a measurement update: the update of Method relinearized with respect to its own posterior, with the prior held fixed, until the mean stops moving
CEmrys::IteratedOptions< Scalar >	The run-time settings of an Iterated method, given to methods::iterated() as iterated(method, {.tolerance = 1e-6}): what stops the iteration, in the scalar the method holds (decisions.md [policy-factories])
CEmrys::JacobianForm	The Jacobian form of a linearization (decisions.md [linearization-forms]), which methods::linearized() and a Jacobian returned with the value compute (decisions.md [returned-jacobians]): the Jacobian \( H \) of the output in the marked input at its mean, and the cross-covariance \( \Sigma_{xy} = P H^T \)
CEmrys::updates::Joseph	The Joseph covariance update: \( (I - K H) P (I - K H)^T + K R K^T \), with \( H \) and \( R \) from the statistical linearization of the output in the input (see statisticalLinearization())
CEmrys::KalmanRecursion< Component_, Model_, Method_ >	The Kalman filter's steps over one component, without the state: a process model and a prediction method, acting on a component passed in (decisions.md [filters-and-recursions])
CEmrys::reductions::Keep	Reduction policy that keeps every branch, each added to the filter's output with its own posterior probability (see ReductionPolicy)
CEmrys::KernelDensity< Space_, Scalar_, Allocator_ >	Gaussian kernel density estimate over a ParticleSet
CEmrys::Lag	The number of steps a fixed-lag history keeps
CEmrys::internal::LeafExtent< Dimension, MaxDimension >	The value dimension of a coordinate type: a compile-time constant when fixed, which takes no storage
CEmrys::Linear< Matrix::RowsAtCompileTime, Matrix::MaxRowsAtCompileTime >
CEmrys::Linear< Columns< Placed... >::Rows >
CEmrys::Periodic< PeriodicInterval{.lower=-std::numbers::pi,.upper=std::numbers::pi}, Dimension, MaxDimension >
CEmrys::Periodic< PeriodicInterval{.lower=0.0,.upper=2 *std::numbers::pi}, Dimension, MaxDimension >
CEmrys::Periodic< PeriodicInterval{.lower=-180.0,.upper=180.0}, Dimension, MaxDimension >
CEmrys::Periodic< PeriodicInterval{.lower=0.0,.upper=360.0}, Dimension, MaxDimension >
CEmrys::internal::LeafExtent< 1, 1 >
CEmrys::Linear< Dimension_, MaxDimension_ >	Dimension_ plain coordinates, or a resizable run of at most MaxDimension_ of them if Dimension_ is Eigen::Dynamic
CEmrys::Periodic< Interval, Dimension_, MaxDimension_ >	Dimension_ coordinates that wrap with a common period, such as angles or DFT bins
CEmrys::methods::Linearized	Linearized method: \( \bar y = f(\mu) \) and \( \Sigma_{yy} = \sum_i J_i \Sigma_i J_i^T \), with the Jacobians \( J_i \) of f at the input means
CEmrys::LinearizedAbout< Reference >	Where a step linearizes its input: a point, or a distribution, in place of the input's own mean and spread (decisions.md [linearization-reference])
CEmrys::LogLikelihood< G >	A measurement model's own \( \log p(z \mid x) \) at a state point, as logLikelihood() declares it, for the filters that weight points (decisions.md [likelihood-measurements], [model-policies]): a function g(in, x, z) of the model's input space instance, its input vector, and the observation
CEmrys::LogSumExp< Scalar >	Streaming log-sum-exp: accumulates \( \log \sum_i e^{x_i} \) without overflow
CEmrys::MarkovChain< Space_, Scalar_ >	A Markov chain on a discrete space: the probability of moving from each value to each value in one step
CEmrys::MeasurementFunction< F, Policies >	A measurement model: a function \( h \) of its input, with the policies that say what it reads, what it writes, and what it is affine in, and its noise (decisions.md [model-policies])
CEmrys::MeasurementUpdate< Space, MeasurementSpace, Count, Scalar_, Allocator >	The result of update(): weighted branches, one per noise component, and the observation's log-likelihood
CEmrys::Mixture< Component_, Allocator_ >	The density of a Mixture whose components have been factorized: a read-only view
CEmrys::MixtureFilterUpdate< ComponentUpdate, Scalar, Allocator >	What a mixture filter's update did: each prior component's update before reduction, the observation's log-likelihood under the whole mixture, and whether any component accepted the measurement
CEmrys::MixtureFit< Space, Scalar, Allocator >	Result of fitMixture(), in Space, with the source's allocator
CEmrys::MixtureLineage< Scalar_, Allocator_ >	How each component of a Mixture descends from the components it had at its last startLineage(): each component's share from each of those parents
CEmrys::MixtureMarginal< Source, Selection, SubSpace >	Read-only view of a subset of the coordinates of every component of a mixture or a hybrid, which iterates the components and gives each one's marginal in turn (decisions.md [element-marginals])
CEmrys::MixtureParams< Component_, Allocator_ >	A weighted sum of components of one type, all in one space
CEmrys::ModelsMethod	What a filter with a fixed-step model takes in place of a prediction method: nothing, since the model carries its own
CEmrys::ModelWithMethod< Model_, Method_ >	A process model and the prediction method that one mode of a SwitchingModel predicts it by, in place of the filter's [switching-models]
CEmrys::Moments< Space_, Scalar_ >	First and second moments (mean and covariance) of a distribution
CEmrys::MonteCarlo	Method that estimates a divergence from count draws
CEmrys::MonteCarloEstimate< Scalar >	An estimate from MonteCarlo draws, with its standard error
CEmrys::resamplers::Multinomial	Draws each ancestor independently
CEmrys::MixtureParams< Component_, Allocator_ >::MutableEntry	Writable access to one entry during forEach()
CEmrys::ParticleSet< Space_, Scalar_, Allocator_ >::MutableParticle	Writable access to one particle during forEach()
CEmrys::Named< Values >	Values named by the tag types Values, in order: struct Maneuver : Named<Cruise, Turn> {};
CEmrys::NisThreshold< Scalar >	A Gate's threshold given directly as a normalized innovation squared, rather than as a probability, in the scalar it is written in (NisThreshold{9.21f} is a float)
CEmrys::upkeep::None	The upkeep a filter holds when it is given none: it takes any state, changes nothing, and returns false, so that maintain() can be called on every filter (decisions.md [upkeep])
CEmrys::NoProcessModel	The process model of a state with nothing to move: what a PointMassFilter, whose grid covers the whole state, holds in place of one
CEmrys::roots::NoReport	The report of axes or a repair with nothing to say, as Cholesky's: it either took the root or failed
CEmrys::EmissionTable< Space_, ObservationSpace_, Scalar_ >::Observation	The emission model of one observed value: the column of the table it selects
CEmrys::Observed< Method, Model, Observation, Args >	An observation of a measurement model: the observed value, the model, the method that pushes the state through it, and the inputs of the call, as observe() makes it (decisions.md [templated-measurements], [method-per-measurement], [model-policies])
CEmrys::OutputSpace< X >	A model's output space given by its instance, or computed from the state's space, as outputSpace() declares it (decisions.md [measurement-space-functions], [model-policies]): for an output with a resizable block, whose size the type does not fix
CEmrys::OutputWithCross< InputSpace, OutputSpace, Form, Scalar >	The result of transform() with an input marked by withCross(): the output's Gaussian and its linearization in that input, in the Form the method computes it, JacobianForm or RootForm (decisions.md [linearization-forms])
CEmrys::ParamsOf< D >	The parameters of the density D, as its member ParamsType: the type it borrows from, or what a marginal's copy() returns
CEmrys::ParticleFilterUpdate< Scalar >	What a particle filter's update did: the observation's log-likelihood under the particles, and whether it was accepted
CEmrys::ParticleGaussian< Space_, Path_, Covariance_, Scalar_, Allocator_, Component_ >	The density of a Rao-Blackwellized particle filter's state, a checked view of its ParticleGaussianParams (decisions.md [params-and-density], [view-stamp]): \( p(x) = \sum_i w_i \, \delta(x_p - p_i) \, \mathcal{N}(x_r; \mu_i, \Sigma_i) \), or with a hybrid per particle, a mixture over its modes in place of each Gaussian
CEmrys::ParticleGaussianParams< Space_, Path_, Covariance_, Scalar_, Allocator_, Component_ >	The parameters of a Rao-Blackwellized particle filter's state: weighted particles for one block of the state, each carrying a Gaussian, or a hybrid of Gaussians, over the rest
CEmrys::ParticleHistory< Space_, Scalar_, Allocator_ >	The record of a particle filter's forward pass that ancestor tracing runs backward over: the particles at each step, how each descends from the step before, and room for the step's smoothed particles
CEmrys::ParticleSet< Space_, Scalar_, Allocator_ >	A set of weighted samples: the empirical distribution
CEmrys::ParticleSetMarginal< Source, Selection, SubSpace >	Read-only view of a subset of the state entries of a ParticleSet
CEmrys::jacobians::PerColumn	The mark that a batched function writes one Jacobian per column, by block of its input: Y.jacobian<Name>(j), made by perColumn()
CEmrys::PeriodicInterval	Where a Periodic coordinate's values lie: the half-open interval [lower, upper), whose width is the period
CEmrys::PerPointCovariance	A covariance per point
CEmrys::roots::Pivoted	Pivoted axes: \( \Pi^T L D^{1/2} \) from Eigen's pivoted LDL decomposition \( P = \Pi^T L D L^T \Pi \), with a negative pivot, which rounding can give a singular matrix, taken as zero
CEmrys::PointGrid< Space_, Path_, Cells_, CellCovariance_, Scalar_, Allocator_ >	Fixed points for the block named by the path Path_ of a state in Space_, one per value of the discrete space Cells_, such as the cells of a grid of positions
CEmrys::PosteriorCramerRaoBound< Space_, Scalar_ >	The posterior Cramér-Rao bound along true trajectories: the Fisher information \( J_k \) of the state, whose inverse bounds the mean squared error of any estimator of \( x_k \)
CEmrys::PredictedJoint< Space_, Scalar_ >	One prediction step as a joint: the Gaussian the step started from, the Gaussian it predicted, and the cross-covariance between them
CEmrys::roots::Principal	Principal axes: \( U \Lambda^{1/2} \), the eigenvectors of \( P = U \Lambda U^T \) scaled by the roots of their eigenvalues, largest first, with a negative eigenvalue taken as zero, so that it never fails
CEmrys::ProcessFunction< F, Policies >	A process model: a function \( f \) of its input and the step, with the policies that say what it reads, what it writes, and what it is affine in, and its noise (decisions.md [model-policies], [continuous-time-noise])
CEmrys::ProcessFunction< internal::IdentityStep, internal::ReadsOne< Path >, internal::WritesOf< Path >, AffineIn< internal::PathTag< Path > > >
CEmrys::Constant< Path >	The block named by Path does not change, and has no process noise, such as a fixed calibration parameter
CEmrys::ProcessFunction< internal::IdentityStep, internal::ReadsOne< Path >, internal::WritesOf< Path >, AffineIn< internal::PathTag< Path > >, internal::DiscreteNoise< internal::RandomWalkNoise< internal::DifferenceSpaceOf< internal::PathTag< Path > >::type::FixedValueDimension, double > > >
CEmrys::RandomWalk< Path, Scalar_ >	A model driven by white noise alone: \( x' = x \), with noise \( Q_c \, \Delta t \) on its differences
CEmrys::ProcessFunction< internal::KinematicStep< internal::PathTag< std::tuple_element_t< 0, std::tuple< Paths... > > >::FixedValueDimension, internal::PathTag< Paths >... >, internal::ReadsOf< Paths... >, internal::WritesOf< Paths... >, AffineIn< internal::PathTag< Paths >... >, internal::DiscreteNoise< internal::KinematicNoise< internal::PathTag< std::tuple_element_t< 0, std::tuple< Paths... > > >::FixedValueDimension, Scalar_, internal::PathTag< Paths >... > > >
CEmrys::Kinematic< Scalar, Position, Velocity >
CEmrys::Kinematic< Scalar, Position, Velocity, Acceleration >
CEmrys::Kinematic< Scalar_, Paths >	A chain of two or more derivatives whose last one is driven by white noise: constant velocity and constant acceleration
CEmrys::ProcessFunction< internal::OrnsteinUhlenbeckStep< double >, internal::ReadsOne< Path >, internal::WritesOf< Path >, AffineIn< internal::PathTag< Path > >, internal::DiscreteNoise< internal::OrnsteinUhlenbeckNoise< double > > >
CEmrys::OrnsteinUhlenbeck< Path, Scalar_ >	A zero-mean Ornstein-Uhlenbeck (first-order Gauss-Markov) process on each coordinate of the block named by Path, such as a slowly varying sensor bias
CEmrys::Product< Space_, Scalar_, Factors_ >	The product of independent densities, each on its own coordinates of a space
CEmrys::upkeep::PruneBelow< Scalar_ >	Action that removes every point whose normalized probability is below probability, renormalizing the rest; the most probable point is always kept
CEmrys::upkeep::PruneTail< Scalar_ >	Action that removes the least probable points, as many as can be while their combined probability stays below fraction, renormalizing the rest
CEmrys::upkeep::PruneToSize	Action that removes the least probable points until at most maxSize remain, renormalizing the rest
CEmrys::RbParticleFilterUpdate< Scalar, Allocator >	What a Rao-Blackwellized particle filter's update did, per particle and in total
CEmrys::RbPointMassFilterUpdate< Scalar, Allocator >	What a Rao-Blackwellized point-mass filter's update did, per live cell and in total
CEmrys::Reads< Items >	What a model reads, as reads() declares it: the items, each a path into the state or the tag of an input of the call, under a name (decisions.md [model-policies])
CEmrys::upkeep::RepairCovariance< Repair_ >	Action that repairs every covariance of the state that is not positive definite, by the Repair Repair_ (roots::Ridge by default), so that its density can be read
CEmrys::Repeated< Block, MaxCount_ >	A fixed-size Block repeated count() times, up to MaxCount_, such as one block per vehicle
CEmrys::upkeep::Resample< G, Resampler_, Policy_ >	Action that resamples a set in proportion to its weights, drawing from the generator G with the resampler Resampler_ (systematic by default) under the execution policy Policy_ (sequential by default), to a given size if one is given and to the set's size otherwise
CEmrys::resamplers::Residual< Inner >	Chooses index i floor( \( M w_i / \sum w \)) times deterministically, then draws the remainder with Inner from the fractional parts
CEmrys::roots::Ridge< Relative, Absolute >	The ridge repair: the Gershgorin ridge of decisions.md [covariance-repair], added to the diagonal of a covariance whose root failed so that the root can be retried
CEmrys::roots::RidgeReport< Scalar >	The report of a Ridge: the ridge \( \delta \) it added to the diagonal
CEmrys::roots::RootFailure< Report >	Why squareRootWithReport() failed, and what each entry tried did
CEmrys::RootForm	The root form of a linearization (decisions.md [linearization-forms]), which every sigma-point method computes: the root \( S \) of the marked input's covariance that spread the points, \( S S^T = P \), and the whitened cross-covariance \( \Psi = S^{-1} \Sigma_{xy} = (H S)^T \), the weighted sum \( \sum_i w_i \xi_i \Delta y_i^T \) over the unit points \( \xi_i \) and the output deviations \( \Delta y_i \)
CEmrys::roots::RootWithReport< Matrix, Report >	A root and the report of the axes that took it, from squareRootWithReport()
CEmrys::upkeep::Roughen< G, Scalar_, Policy_ >	Action that moves each particle by an independent draw from a Gaussian kernel, to restore the diversity resampling removes: the regularized particle filter
CEmrys::Sample< G >	A draw of the observation that a measurement model known by its likelihood alone makes of a state, as sample() declares it, for simulate() (decisions.md [likelihood-measurements], [model-policies]): a function g(in, x, rng) of the model's input space instance, its input vector, and the caller's generator, returning the observation
CEmrys::SamplesWithLogDensity< Space, Scalar >	Samples in Space together with the log of the density they were drawn from, evaluated at each
CEmrys::SampleWithLogDensity< Space, Scalar >	One sample in Space, in a vector sized by the space, together with the log of the density it was drawn from, evaluated at it: what drawSampleWithLogDensity() returns, so that a bounded space allocates nothing [allocation]
CEmrys::reductions::Select	Reduction policy that keeps the most probable branch: hard rejection by comparing the noise components with each other
CEmrys::execution::Sequential	The type of execution::sequential, the default execution policy: plain loops on the calling thread, in index order
CEmrys::jacobians::Shared	The mark that a batched function writes one Jacobian for every column, by block of its input: Y.jacobian<Name>(), for a function linear in its input, made by shared()
CEmrys::SharedCovariance	One covariance for every point
CEmrys::methods::SphericalSimplex< CenterWeight >	Spherical simplex method: \( L + 2 \) points over the joint input space of dimension \( L \), the mean with weight centerWeight \( W_0 \) and \( L + 1 \) points of weight \( (1 - W_0) / (L + 1) \) on a sphere of radius \( \sqrt{L / (1 - W_0)} \) about it, in the coordinates of a root of the joint covariance
CEmrys::methods::Spread< Rule, A >	A sigma-point rule spread by axes of its own (decisions.md [sigma-point-axes]): Rule's unit points and weights, an UnscentedRule or a PointSet, carried into the input by the root A takes (Axes), in place of the default, roots::cholesky(roots::pivoted())
CEmrys::SqrtGaussianParams< Space_, Scalar_ >	A Gaussian kept as a mean and a lower-triangular root of its covariance
CEmrys::SqrtGaussianParams< SubSpace, Source::Scalar >
CEmrys::SqrtInfoGaussianParams< Space_, Scalar_ >	A Gaussian kept as an upper-triangular root of its precision and a whitened offset, about a reference value
CEmrys::updates::Standard	The standard covariance update of condition(): \( P - K \Sigma_{xy}^T \), which is \( (I - K H) P \) written without \( H \)
CEmrys::StationaryVariance< Scalar >	The stationary variance \( \sigma^2 \) of an OrnsteinUhlenbeck model, named so that it cannot be given in the place of its time constant
CEmrys::StatisticalLinearization< InputSpace, OutputSpace, Scalar >	The statistical linearization of an output in an input, from statisticalLinearization(): the affine function of the input that best predicts the output in mean square, \( y \approx \bar y \boxplus H (x \boxminus \mu) \), and the covariance \( \Omega \) of what it leaves unexplained
CEmrys::CategoricalHistory< Space_, Scalar_, Allocator_ >::Step	One recorded prediction and its smoothed distribution
CEmrys::GaussianHistory< Space_, Scalar_, Allocator_ >::Step	One recorded prediction and its smoothed Gaussian
CEmrys::GaussianMixtureHistory< Space_, Scalar_, Allocator_ >::Step	One recorded prediction and its smoothed mixture, built from the history's allocator
CEmrys::HybridGaussianHistory< Space_, ModeSpace_, Scalar_, Allocator_ >::Step	One recorded prediction and its smoothed hybrid state, built from the history's allocator
CEmrys::ParticleHistory< Space_, Scalar_, Allocator_ >::Step	One recorded set of particles, its descent from the step before, and its smoothed set, built from the history's allocator
CEmrys::Steps	A count of a fixed-step model's steps, for predict(Steps{n})
CEmrys::internal::StoredParts< decltype(std::tuple_cat(std::declval< StoredPart< Parts > >()...))>
CEmrys::internal::PartStorage< Blocks... >
CEmrys::Composite< typename Items::NameType... >
CEmrys::Composite< Blocks >	The concatenation of Blocks, any number of them resizable
CEmrys::internal::PartStorage< Axes... >
CEmrys::DiscreteProduct< Axes >	The product of the discrete spaces Axes: a value has one value in each axis
CEmrys::resamplers::Stratified	Draws one uniform in each of M equal strata of [0, 1)
CEmrys::StudentT< Space_, Scalar_ >	The multivariate Student-t distribution: a Gaussian with heavier tails
CEmrys::upkeep::Subdivide	Action that splits every point into factor points along each axis, sharing its probability equally
CEmrys::Sure< S, Vector >	A sure input of predict() or observe(): a known value in the tagged space S, as sure() marks it (decisions.md [prediction-inputs], [tag-addressing])
CEmrys::SwitchingMeasurement< Path_, Measurements >	A measurement that switches between modes: one Measurement per value of a mode axis, so that a filter over a Hybrid updates each mode by the measurement that its value in that axis names [imm]
CEmrys::SwitchingModel< ModeSpace_, Scalar_, Path_, Models >	A process model that switches between modes: a Markov chain on a discrete mode space, and the process model each mode follows [switching-models]
CEmrys::roots::Symmetric	Symmetric axes: the principal square root \( P^{1/2} = U \Lambda^{1/2} U^T \), the one symmetric positive semidefinite root, with a negative eigenvalue taken as zero, so that it never fails
CEmrys::updates::Symmetric	The symmetric covariance update: \( P - K \Sigma_{yy} K^T \), equal to the standard form when \( K \) is the optimal gain, and made exactly symmetric
CEmrys::resamplers::Systematic	Uses one uniform offset for M evenly spaced positions in [0, 1)
CEmrys::TagPath< Tags >	A path of tags, each naming a block inside the one before: TagPath<Ownship, Position> is the Position block of Ownship
CEmrys::TagPaths< Paths >	A list of tag paths, each a tag or a TagPath, such as the blocks a measurement reads (TagPaths<Position, TagPath<Sensor, Bias>>)
CEmrys::TimeConstant< Scalar >	The time constant \( \tau \) of an OrnsteinUhlenbeck model, named so that it cannot be given in the place of its variance
CEmrys::TimeTraits< Time >	How a time type converts to a scalar, as a static member template toScalar<Scalar>(t) returning Scalar, in the unit of the parameters of the models it steps
CEmrys::TimeTraits< std::chrono::duration< Rep, Period > >	A std::chrono::duration, converted to seconds in the scalar by its period
CEmrys::TimeTraits< Time >	A floating-point number, taken as it is and converted to the scalar
CEmrys::UnboundFixedStep< Model_, Method_, Time_ >	A process model taken over one fixed time step, not yet bound to a state space: what fixedStep() returns
CEmrys::Uniform< Space_, Scalar_ >	The uniform distribution over a box in a space
CEmrys::UniformGrid< Space_, Scalar_ >	The equal-weight components of a grid over some coordinates of a space, made one at a time when read: what uniformComponents() returns
CEmrys::UnitQuaternion	An attitude: a unit quaternion of four coordinates whose differences are three-coordinate rotation vectors in the body frame
CEmrys::methods::Unscented< Alpha, Beta, Kappa >	Unscented method: \( 2L + 1 \) sigma points over the joint input space of dimension \( L \), spread by \( \lambda = \alpha^2 (L + \kappa) - L \)
CEmrys::UnscentedParams< Scalar >	The parameters of the scaled unscented transform over a number of coordinates, in Scalar, as an UnscentedRule gives them: \( \lambda = \alpha^2 (L + \kappa) - L \)
CEmrys::UpdateBranch< Space, MeasurementSpace, Scalar >	One outcome of an update: a posterior, how probable it is, and its innovation, from which the observation's likelihood under it and its NIS follow (decisions.md [innovation-statistics])
CEmrys::ImmRecursion< Component_, Model_, Method_, Allocator_ >::UpdateTypeOf< M >	UpdateType<M>, named without being formed (see internal::UnlessGivenBlock)
CEmrys::internal::ValueRates< Space, double >
CEmrys::ArrivalInterval< Space, Scalar_ >	The observation of a Markov-modulated Poisson process over an interval: no event inside it, and an event at its end unless it closes the record
CEmrys::ExponentialEmission< Space, Scalar_ >	The emission model of the time from one event to the next, from a Poisson process whose rate is a function of the value
CEmrys::PoissonEmission< Space, Scalar_ >	The emission model of a count of events over an interval, from a Poisson process whose rate is a function of the value
CEmrys::ValueSequence< Space, Scalar, Allocator >	The most probable sequence of values over a CategoricalHistory, and its posterior probability, from mostProbableSequence()
CEmrys::upkeep::When< Predicate, Actions >	Trigger that runs its actions when its predicate holds for the state: the general trigger, of which WhenEss and WhenSize are two
CEmrys::roots::WithFallbacks< Head, Fallbacks >	Axes that can fail, followed by their fallbacks, tried in order (decisions.md [sigma-point-axes]): a repair, which retries Head on the covariance it repairs, or other axes, which take the root themselves
CEmrys::WithJacobian< Value, Jacobian >	What a function returns when it knows its Jacobian: its value, and the Jacobian of its output differences in its uncertain inputs' differences, at the same point (decisions.md [returned-jacobians])
CEmrys::Writes< Paths >	What a model writes, as writes() declares it: the blocks its function's result fills (decisions.md [model-policies])
CRecursion_