File List

Here is a list of all documented files with brief descriptions:

EmrysFilter
Core
Allocation.h	The allocator conventions of decisions.md [allocation]: DefaultAllocator, Capacity, and the internal rebinding alias and buffer type every type with a run-time number of elements uses
ChiSquared.h	The chi-squared distribution's CDF and quantile, with no dependency outside Eigen, for the gates and consistency checks of Consistency.h and the confidence regions of Gaussian.h
Execution.h	Execution policies (decisions.md [execution-policies]): execution::sequential, the ExecutionPolicy concept, and the internal primitives that every loop over a run-time count of elements runs through, a for-each over indices or over chunks, a reduction, a scan, a gather, a compaction, and a fill, with the iterators they run over, one over indices and one over elements a view makes when read
Forwarding.h	How a function that stores a matrix argument takes it (decisions.md [forwarded-matrices]): the concept MatrixExpression, which constrains its forwarding reference so that an rvalue is moved, and internal::castScalar(), which forwards a matrix that already has the scalar rather than copying it; and internal::forwardLike(), std::forward_like for every standard library
Macros.h	The macros every header includes first
Math.h	Mathematical constants and scalar functions that work in every scalar type the library accepts, where the standard library and Eigen serve only some of them
Multiply.h	Products of fixed-size matrices by Eigen's fixed-size product at every size: multiply() is \( A B \) by Eigen's coefficient-based product wherever both operands have a fixed size, which Eigen itself chooses only while no dimension reaches eight, and asTriangular() is a triangular factor as a dense matrix to multiply by, which a triangular view never is
NumericError.h	NumericError, the reasons a factorization or a normalization can fail, and its two names, GaussianError and WeightError (decisions.md [update-outcomes])
Print.h	Printing: operator<< and std::formatter for every distribution, every filter (which prints its name and nests its state under it), and the library's error codes, so that std::cout << filter and std::println("{}", filter.state()) work
Resampling.h	The resamplers: function objects that draw ancestors in proportion to weights, which ParticleSet::resample() and the Resample upkeep action call
Solve.h	Solving by a factorization of a small matrix: transposedSolve() gives \( (A^{-1} B)^T \), the shape of a Kalman gain and of a statistical linearization, from an Eigen factorization of \( A \), and solveInPlace() overwrites \( B \) with \( A^{-1} B \), and inverseFrom() gives \( A^{-1} \), all one column of \( B \) at a time where \( A \) has a small fixed size, which Eigen's solve with a matrix right-hand side does not do
Stamp.h	What parameters and their views share (decisions.md [view-stamp], [params-and-density]): Stamp, the modification stamp that parameters keep; ValuesCheck and ShapeCheck, by which a view checks that its parameters have not changed under it; ViewHolder, by which a marginal of a view keeps that view; and CallbackGuard, which checks that a callback leaves its parameters alone
Time.h	Time steps (decisions.md [time-steps]): TimeTraits, which converts a time type to a scalar, the TimeStep concept that a filter's predict() takes its step through, and Steps, a count of a fixed-step model's steps
Triangularization.h	Triangularization: the triangular factor of a stacked matrix by Householder reflections, in place and without forming the orthogonal factor
Version.h	The library's version, the same numbers as the CMake project's, and the Eigen version it requires
Weights.h	Log-weights: the WeightError a normalization can fail with (NumericError.h), and the streaming log-sum-exp that totals them without overflow, sequentially or in chunks under an execution policy: LogSumExp and logSumExp(), which are public, so that a user's code normalizes weights or sums likelihoods as the library does
Distributions
Categorical.h	The distribution over a discrete space (decisions.md [discrete-spaces], [params-and-density]): CategoricalParams, one weight per value, written freely and updated by Bayes' rule, with marginals and conditionals by axis; and Categorical, the view its toDensity() returns once the weights define a distribution, with probabilities by value and by named event
Component.h	What a container of several Gaussians needs of each one (decisions.md [component-first]): the Component concept, ComponentTraits with the log-density read without a check, the weighted collapse of several components into one, and the type of one component's marginal, and their specializations for Gaussian and for the square-root form, SqrtGaussian
Conditionals.h	What the Rao-Blackwellized states share (decisions.md [rao-blackwellized-core], [rb-particle-filter]): the SharedCovariance and PerPointCovariance forms, BlockSplit, which divides a state into the block fixed at points and the Gaussian rest, Conditionals, the Gaussians over the rest stored in either form, the collapse of points and conditionals into one Gaussian, and the conditioning of the rest on a drawn block
ContinuousTimeMarkovChain.h	The continuous-time chain on a discrete space: ContinuousTimeMarkovChain, built from a generator of rates, from independent chains on the axes of a product, as persistent, or from mean dwell times and exit weights; its transition over an interval as a MarkovChain, through the matrix exponential; predict() over an interval; and stationary(), its stationary distribution (decisions.md [emissions])
Divergence.h	Divergences between distributions (decisions.md [divergences]): Kullback-Leibler, Bhattacharyya, Hellinger, Jensen-Shannon, and 2-Wasserstein, in closed form between two Gaussians or two Categoricals and by MonteCarlo estimate otherwise; kullbackLeiblerCollapseBounds(), how far a Gaussian mixture or a hybrid state is from its moment-matched Gaussian; GroundMetric for the Wasserstein distance's units; and expectedSquaredError() about a known truth
Fitting.h	Fitting a Gaussian mixture by expectation-maximization: fitMixture() over particles, over a mixture's components (hierarchical EM, a mixture reduction), or over particles seeded from a mixture, with FitOptions and the MixtureFit result
Gamma.h	Gamma: independent Gamma distributions on the coordinates, with the exponential and chi-squared as special cases and a parameterization by mean and standard deviation, and its draws; and GammaError, why parameters fail to define one
Gaussian.h	The Gaussian: its parameters GaussianParams, the Gaussian that evaluates the density, read from them by toDensity() (decisions.md [params-and-density]), and the GaussianMarginal view from marginal<Path>() (decisions.md [density-names]), with conditional<Path>(), insert() and erase() on a resizable block, the repair of a covariance that fails to factorize by a Repair such as roots::ridge(), and the exact confidence regions
GaussianForm.h	What the four forms of the Gaussian share (decisions.md [gaussian-forms], [form-densities]): the GaussianForm concept and the isInfoForm<> and isSqrtForm<> traits; FormGaussian, the read-only density view that the square-root and information forms' parameters return from toDensity(), with its moments(), marginals, drawSamples(), and drawSamplesWithLogDensity(); and toGaussian(), which converts any form to the covariance form
GridGaussian.h	Grids of points and the state over them (decisions.md [rb-point-mass], [rao-blackwellized-core]): GridAxis and GridCells for a regular grid, PointCells for given points, PointGrid with regularGrid() and pointGrid() for fixed points of one block with optional cell covariances, and GridGaussianParams, the live cells with their probabilities and a Gaussian or a hybrid of Gaussians over the rest each, which prunes and subdivides, the point-mass filters' state, with its density GridGaussian, which gives the collapse
Hybrid.h	The hybrid state of a discrete mode and a component per mode (decisions.md [imm], [component-first]): Hybrid, with its collapse into one component, whole or grouped by a mode axis, its view as a mixture, its marginal, a MixtureMarginal over the modes [element-marginals], and its ComponentTraits and internal::ElementsOf, which make a hybrid state a component in its own right, so a Mixture of hybrids is the state of a mixture of interacting multiple model filters [filters-and-recursions]; and the HybridGaussian alias for the hybrid of Gaussians, the interacting multiple model filter's state
InfoGaussian.h	The information form of the Gaussian (decisions.md [gaussian-forms]): its parameters InfoGaussianParams, which holds the precision and the information vector about a reference value; its factor operations, addInfo(), multiply(), marginal<Path>(), and conditional<Path>(); and toInfo(), which converts any form to it
KernelDensity.h	KernelDensity: the Gaussian kernel density estimate over a ParticleSet, the read-only view that ParticleSet::toDensity() returns, with its draws
Mixture.h	The mixture: the parameters MixtureParams of weighted components of one type (decisions.md [component-first], [params-and-density]), with its components added, removed, merged, split, truncated, and reweighted, and the MixtureLineage it keeps through those for the mixture smoother [smoothing]; the Mixture that evaluates the density, read from them by toDensity(); the MixtureMarginal view from marginal<Path>(), a range over the components' marginals [element-marginals], which a Hybrid's marginal is too; the draws from a mixture of Gaussians; and the GaussianMixtureParams and GaussianMixture aliases for the mixture of Gaussians, the spelling for the common case
Moments.h	Moments: the mean and covariance that a Gaussian carries and that a mixture or a sample set is moment-matched to, with MomentsError and the ScalarOf alias
Params.h	Params and Density: the traits that pair a distribution's parameters with its density, the type that evaluates it (decisions.md [params-and-density])
ParticleGaussian.h	The state of a Rao-Blackwellized particle filter (decisions.md [rb-particle-filter]): ParticleGaussianParams, weighted particles for one block with a Gaussian or a hybrid of Gaussians over the rest each, built by particleGaussian() or drawn from a joint Gaussian by drawParticleGaussian(), and its density ParticleGaussian, which gives the collapse
ParticleSet.h	The particle set: ParticleSet, the weighted samples, with resampling, upkeep of weights and particles, insert() and erase() on a resizable block, and a kernel bandwidth; its marginal view ParticleSetMarginal; and Silverman's bandwidth
Product.h	Product: the product of independent densities, each on its own block of a space, built with on<Path>() or onEach<Path>() or from Factors (decisions.md [product-factors]), with marginals and conditionals that work factor by factor, and its draws; EachRepetition; the HasLogDensity and ProductFactor concepts
Roots.h	Square roots of a covariance (decisions.md [sigma-point-axes]): the Axes and Repair concepts that a root of the user's own meets [user-extension-points], the library's axes roots::cholesky(), roots::pivoted(), roots::principal(), roots::symmetric(), and roots::along(), the repair roots::ridge(), the flat list of fallbacks that axes which can fail take, and roots::squareRoot() and roots::squareRootWithReport(), which take a root by them
SampleSet.h	SampleSet: a matrix whose columns are samples in a space, which the samplers return and the unscented transform uses for its sigma points, and SampleSetMap and ConstSampleSetMap, the same layout over memory the matrix does not own, which ParticleSet and the other containers return over their allocators' buffers [allocation]
Sampling.h	Drawing samples: SamplesWithLogDensity and SampleWithLogDensity, the Gaussian draws drawSamples(), drawSamplesWithLogDensity(), and drawSample() and drawSampleWithLogDensity(), the one-at-a-time draws that allocate nothing for a bounded space [allocation], and the internal standard normal and uniform draws
SqrtGaussian.h	The square-root form of the Gaussian (decisions.md [gaussian-forms]): its parameters SqrtGaussianParams, which holds a mean and a lower-triangular root of the covariance, its marginal<Path>() by triangularization, and toSqrt(), which converts any form to it
SqrtInfoGaussian.h	The square-root information form of the Gaussian (decisions.md [gaussian-forms]): its parameters SqrtInfoGaussianParams, which holds an upper-triangular root of the precision and the whitened offset of the mean from a reference value; multiply(), marginal<Path>(), and conditional<Path>(), each a triangularization of a stacked data array; and toSqrtInfo(), which converts any form to it
Statistics.h	Weighted statistics over points, all in internal, which the containers of weighted elements (GaussianMixtureParams, ParticleSet, the Rao-Blackwellized states) call: the weighted covariance, weighted moments with a tangent-space mean in a nonlinear space, taken one point at a time so that they allocate nothing sized by the count [allocation], the moment-matched mixture of Gaussians, and the effective sample size, the moments and the effective sample size also under an execution policy
StudentT.h	StudentT: the multivariate Student-t, a Gaussian with heavier tails, built by create() from a location, scale matrix, and degrees of freedom, with its marginals, conditionals, and draws; and StudentTError, why those fail to define one
Uniform.h	Uniform: the uniform distribution over a box, with the box taken from a space of Periodic coordinates or given to create(), which checks it, and its draws; and UniformError, why bounds fail to define one
UniformMixture.h	UniformComponents(): equal-weight Gaussian components on a regular grid that approximate a Uniform, alone or as factors of a Product whose other factors are Gaussian [uniform-mixtures], given one at a time as a UniformGrid, which GaussianMixtureParams::assign() takes
Upkeep.h	Upkeep (decisions.md [upkeep], [rao-blackwellized-core]): the actions Resample, Roughen, PruneBelow, PruneTail, PruneToSize, Subdivide, FloorModes, and RepairCovariance, the triggers When, WhenEss, and WhenSize that run them, the Sequence that runs them all, and None, which a caller applies to a filter's state between steps or gives the filter to run by maintain()
Filters
AmmFilter.h	AmmFilter (decisions.md [autonomous-multiple-model]): the ImmFilter on the identity chain, whose constructor builds that chain from the state's modes, and the AmmFilter alias
FilterUpkeep.h	The upkeep a filter holds (decisions.md [upkeep]): internal::HeldUpkeep, the base that gives every filter its upkeep() and maintain()
HiddenMarkovFilter.h	HiddenMarkovFilter (decisions.md [filters-and-recursions], [emissions], [update-outcomes]): a CategoricalParams state moved by a MarkovChain or a ContinuousTimeMarkovChain and updated by emission models, with the log-evidence of the measurements so far, and HiddenMarkovFilterUpdate
ImmFilter.h	ImmRecursion and ImmFilter (decisions.md [switching-models], [imm], [filters-and-recursions]): a Hybrid state mixed through a Markov chain, predicted through each mode's model, and updated per mode, with Markov outlier states when a measurement's noise is by mode axis (ModeNoise) and a measurement per mode through a SwitchingMeasurement; the recursion that does this to a hybrid passed in, keeping the scratch it mixes and updates into, the filter that owns a hybrid and runs the recursion on it
InfoFilter.h	InfoFilter (decisions.md [filters-and-recursions], [gaussian-forms]): the KalmanFilter over an InfoGaussianParams, spelled space first, whose update adds information and whose prediction goes through the moments
KalmanFilter.h	KalmanRecursion and KalmanFilter (decisions.md [templated-measurements] and [filters-and-recursions]): the Kalman steps over one component as a recursion, a process model and a prediction method acting on a state passed in, and the filter that owns a component and runs that recursion on it, with updates by any measurement reduced to one component by a policy
MixtureFilter.h	MixtureFilter (decisions.md [mixture-filter], [filters-and-recursions]): a Mixture state whose components are each predicted and updated by the recursion their type names, a KalmanRecursion for Gaussians and an ImmRecursion for hybrid states, or by one of the user's own (Recursion.h), and reweighted by their likelihoods, with MixtureFilterUpdate; GaussianMixturePredictedJoint, what predictJoint() records for the mixture smoother [smoothing] in GaussianMixtureHistory.h; and GaussianMixtureFilter, the spelling for the mixture of Gaussians
ParticleFilter.h	ParticleFilter (decisions.md [upkeep]): a ParticleSet moved by sampling the process model and its noise, weighted by the measurement likelihood, with upkeep left to the caller, and ParticleFilterUpdate; its steps also run under an execution policy [execution-policies]
RbParticleFilter.h	RbParticleFilter (decisions.md [rb-particle-filter]): particles for one block of the state, each carrying a Kalman filter over the rest, or an IMM filter under a switching model, with a coupled prediction that draws the block from the predicted joint and conditions the rest on it
RbPointMassFilter.h	RbPointMassFilter (decisions.md [rb-point-mass] and [rao-blackwellized-core]): fixed points for one block of the state, each carrying a Kalman filter over the rest, or an IMM filter under a switching model, with the PointMassFilter alias for a grid that covers the whole state
RbUpdate.h	The update that the Rao-Blackwellized filters share (decisions.md [rb-point-mass], [rao-blackwellized-core], [rb-particle-filter]): every point's Gaussian conditioned on a measurement given the point, with one transform for all points under a shared covariance or one Kalman update each, into the reused PointLikelihoods
Recursion.h	The Recursion concept (decisions.md [filters-and-recursions], [user-extension-points]): what a KalmanFilter or a MixtureFilter asks of the object that runs its steps, spelled so that a recursion of the user's own, a method the library doesn't ship, runs inside either filter; and internal::UpdateAccess, through which the filters write the log-likelihood their results hold [update-outcomes]
SqrtInfoFilter.h	SqrtInfoFilter (decisions.md [filters-and-recursions], [gaussian-forms]): the KalmanFilter over a SqrtInfoGaussianParams, spelled space first, Bierman's filter on the data array
SqrtKalmanFilter.h	SqrtKalmanFilter (decisions.md [filters-and-recursions], [gaussian-forms]): the KalmanFilter over a SqrtGaussianParams, spelled space first, whose steps triangularize stacked factors and never form a covariance
Models
Batched.h	Batched functions (decisions.md [batched-functions]): batched(), the mark that a function takes every point at once, as the columns of a matrix, and writes one output; the marks of the Jacobians it writes, jacobians::perColumn() and jacobians::shared(); and BatchedOutput, the output the library provides, sized once for the batch and for the blocks whose Jacobians it uses
Condition.h	The Kalman conditioning of a marked input on an observation of a transform's output (decisions.md [covariance-update-forms], [innovation-cholesky], [linearization-forms]): condition() with the updates::Standard, updates::Symmetric, and updates::Joseph covariance forms and the CovarianceUpdate concept, its result Conditioned, and statisticalLinearization() of a result in its marked input
Consistency.h	Consistency checks (decisions.md [composed-features]): NisMonitor, a windowed chi-squared test on the normalized innovation squared of a filter's updates, and nees() with NeesMonitor, the same test on the normalized estimation error squared against a true state, which a simulation knows (see simulate())
CramerRao.h	PosteriorCramerRaoBound: the Fisher information of the state along true trajectories, whose inverse bounds the mean squared error of any filter run on them (decisions.md [cramer-rao-bound])
Emission.h	The measurement of a discrete state: the EmissionModel concept, which fills one log-likelihood per value; update() of a CategoricalParams by one, returning its CategoricalUpdate; the emission models EmissionTable, DensityEmission, PoissonEmission, and ExponentialEmission; and ArrivalInterval, the exact observation of a Markov-modulated Poisson process over a ContinuousTimeMarkovChain's interval, with its predict() (decisions.md [emissions])
FormSteps.h	The prediction and update steps of the square-root and information forms of the Gaussian (decisions.md [gaussian-forms]): internal::predictInPlace() and internal::updateInPlace() overloaded on SqrtGaussianParams, InfoGaussianParams, and SqrtInfoGaussianParams, which KalmanRecursion calls as it calls the covariance form's
IteratedUpdate.h	The iterated measurement update, all internal (decisions.md [iterated-update], [sigma-point-sets]): the read blocks moved to an iterate and respread as the prior spreads them, the iteration's scale and its test, the step to the prior's chart, and iteratedUpdate(), which Measurement.h's update() calls for an Iterated method
Likelihood.h	The likelihoods that sample-based filters weight by (decisions.md [likelihood-measurements], [execution-policies]): logLikelihoods() of a measurement at the columns of a matrix of states, under an execution policy, and logLikelihood() at one
Linearization.h	What a transform returns and what a measurement update reads from it (decisions.md [linearization-forms], [innovation-statistics], [innovation-cholesky]): the UncertainInput concept of a transform's uncertain arguments, the linearization forms JacobianForm and RootForm, OutputWithCross, the output's Gaussian with its linearization in the input marked by withCross(), and Innovation, an observation's residual and its covariance, from which the NIS and the log-likelihood follow
Measurement.h	The update of a Gaussian by a measurement (decisions.md [templated-measurements], [weighted-branches], [covariance-update-forms], [innovation-statistics], [linearization-reference], [rb-point-mass]): update() of a state by a measurement that reads part of it, with one UpdateBranch per noise component, and update() given a block from outside the Gaussian
MeasurementModel.h	Measurement models and their observations (decisions.md [model-policies], [sensors], [linear-sensors], [measurement-space-functions], [templated-measurements], [method-per-measurement]): the MeasurementFunction that measurementModel() builds from a function, a matrix, or Columns and its policies, or from a likelihood alone; CountFrom, a measurement space that repeats with a block of the state; the MeasurementModel concept; Observed, what observe() makes of a model, a method, an observation, and the call's inputs, and the Measurement concept a filter's update() takes
MeasurementReads.h	How an update reads a measurement, all internal (decisions.md [model-policies], [measurement-space-functions], [additive-noise], [method-per-measurement]): ResolvedMeasurement, an observation resolved against a state space, which builds on ResolvedReads.h's resolution of the model's reads() against the state and the call's arguments, builds the output space, places the additive noise, calls the function with its input gathered once per evaluation, and splits a returned Jacobian by input; the predicted measurement's moments; and the covariance the uncertain inputs carry through the function
MeasurementUpdate.h	What an update returns (decisions.md [weighted-branches], [innovation-statistics]): an UpdateBranch per noise component in a MeasurementUpdate, and FilterUpdate and ReusableFilterUpdate, what a filter's update returns without the posteriors, with the internal rebinding of an update to an allocator
Methods.h	The transform methods, as policies made by their factories (decisions.md [policy-factories], [method-per-measurement], [affine-coordinates], [returned-jacobians], [iterated-update], [sigma-point-sets], [user-extension-points]): methods::linearized(), unscented(), fourthMomentUnscented(), cubature(), sphericalSimplex(), gaussHermite(), spread(), and iterated(); the UnscentedRule and PointSet concepts a rule or a point set of the user's own meets; the TransformMethod concept observe() requires of its method; and withJacobian() for a function that knows its Jacobian
Placement.h	Models placed in a larger state and measurement models side by side (decisions.md [model-placement], [model-policies]): on<Path>(model), which places a process or a measurement model on the block that a path names, prefixing every path into the state it reads and writes; onEach<Path>(model), which places one copy of a process model on every repetition of a repeated block; and compose() of measurement models, whose output is their outputs side by side
Policies.h	The policies a model is built from, and the marks on a step's arguments (decisions.md [model-policies], [tag-addressing]): reads(), writes(), affineIn(), additiveNoise(), continuousNoise(), logLikelihood(), and outputSpace(), each a call returning an object of its own type, which processModel() and measurementModel() take after the function in any order; the internal PolicySet, which finds each in an argument pack; the placing of additive noise in an output space; and sure(), which marks a known input of predict() or observe() by the tag of its space
ProcessModel.h	Process models as functions with reads and writes (decisions.md [model-policies], [continuous-time-noise], [prediction-inputs], [time-steps]): the ProcessFunction that processModel() builds from a function and its policies; the built-in models RandomWalk, the Kinematic chains ConstantVelocity and ConstantAcceleration, OrnsteinUhlenbeck, and Constant, each the same object; compose(), which puts process models side by side; the ProcessModel concept; predict(), which moves a Gaussian through one by any transform method with the discretized process noise added, and predictJoint(), which also keeps the Gaussian it started from and its cross-covariance with the prediction, a PredictedJoint, which is what a smoother records [smoothing]; propagate(), the noise-free step; and FixedStepModel, a model over one step with the work that depends only on the step done once
Reduction.h	Reducing an update's branches (decisions.md [weighted-branches], [reduction-policies], [composed-features]): the Collapse, Select, and Keep policies, the Gate that rejects branches by a chi-squared test before another policy, the ReductionPolicy and MixtureReductionPolicy concepts a filter's update() requires of its policy, which a policy of the user's own meets [user-extension-points], and filterUpdate(), which turns an update into the FilterUpdate a filter returns
ResolvedReads.h	How a model's reads() meet a state and a call, all internal (decisions.md [model-policies], [tag-addressing]): ReadBlocks, the blocks of the state a model reads; and ResolvedReads, a model's reads() resolved against a state space and the call's arguments, which sorts the items into blocks of the state and inputs of the call, builds the model's input space from both, and gathers the function's input vector once per evaluation
Simulation.h	Simulate(): a draw of a process model's next true state, the ground truth that a simulation runs a filter against and that nees() and NeesMonitor test its estimates by, and a draw of a measurement model's observation of a true state, which observe() turns into the measurement the filter takes, and a draw of a Markov chain's next value, the true mode of a switching or hidden Markov model (decisions.md [printing-and-simulation])
SwitchingModel.h	SwitchingModel (decisions.md [switching-models], [imm]): a Markov chain on a discrete mode space and the process model each mode follows, one per mode, one per value of a mode axis through switchingModel(), or one shared, and over a fixed step when every model is a FixedStepModel [fixed-step-models]
Transform.h	Propagating a distribution through a function (decisions.md [method-per-measurement], [prediction-inputs], [affine-coordinates], [returned-jacobians], [iterated-update], [sigma-point-sets], [linearization-reference], [transform-policies]): transform(), which takes a measurement model's policies or a measurement model itself, the withCross() mark on its arguments, and linearizedAbout() for a step linearized about a point or a distribution the caller gives
TransformArgs.h	The arguments of transform() and the joint input they form (decisions.md [prediction-inputs], [affine-coordinates], [linearization-reference]): the types of the withCross() and linearizedAbout() marks, CrossMarked and LinearizedAbout, and, in the internal namespace, how each argument reaches the function, as uncertain or known, and the Transform that concatenates the uncertain ones into one input, with its covariance and root
Smoothers
CategoricalHistory.h	Smoothing a HiddenMarkovFilter [emissions]: CategoricalHistory, the record of its forward pass, whose smooth() runs the backward pass over it, fixed-interval or fixed-lag; its smoothStep() and transitionPosterior(); and mostProbableSequence(), the Viterbi path over the same record, with the ValueSequence it returns (decisions.md [smoothing])
GaussianHistory.h	Smoothing the Kalman family (decisions.md [smoothing]): smoothStep(), the Rauch-Tung-Striebel backward step in the tangent space; and GaussianHistory, the record of a Kalman filter's forward pass that a caller keeps, whose smooth() runs the backward pass over it, fixed-interval or fixed-lag
GaussianMixtureHistory.h	GaussianMixtureHistory, the record of a Gaussian mixture filter's forward pass, whose backward pass follows each component's lineage through merges, with smoothStep() for each component and each parent it descends from (decisions.md [smoothing])
HybridGaussianHistory.h	HybridGaussianHistory, the record of an IMM filter's forward pass, whose backward pass interacts its modes as the IMM does going forward, with smoothStep() for each mode (decisions.md [smoothing])
Lag.h	Lag, the number of steps a fixed-lag history keeps, which every history of the Smoothers layer takes (decisions.md [smoothing])
ParticleHistory.h	ParticleHistory, the record of a particle filter's particles and their genealogy, smoothed by ancestor tracing (decisions.md [smoothing])
Spaces
Composite.h	Spaces built from other spaces (decisions.md [sizes-and-dimensions], [several-resizable-blocks]): Composite, which concatenates blocks, and Repeated, which repeats a fixed-size block a run-time number of times
Coordinates.h	The coordinate types (decisions.md [no-bounded-coordinates]): Linear, plain coordinates, and Periodic, coordinates that wrap at the ends of an interval, with the named angles RadiansPi, Radians2Pi, Degrees180, and Degrees360
Discrete.h	Discrete spaces (decisions.md [discrete-spaces]): the DiscreteSpace concept; Finite, Named, and DiscreteProduct; and valueOf(), the flat index of a value named by tags
Indexing.h	What marginals and conditionals are built from: resolving Eigen index sets against a space; the shared implementations of marginal<Path>() and conditional<Path>(); inserting and erasing rows of vectors and symmetric matrices for insert() and erase(); reading a symmetric matrix from its lower triangle; and conditionMoments() and conditionMomentsWithEvidence(), the Gaussian conditioning every Gaussian form calls
Reset.h	The covariance reset (decisions.md [covariance-reset]): hasIdentityReset<>, resetJacobian(), and resetCovariance(), which carry a covariance from the tangent space at a value to the one at that value moved by a step, block by block, and compile to nothing on a space whose every block moves its differences unchanged
Space.h	The Space concept and what every continuous space shares (decisions.md [sizes-and-dimensions]): the traits a space exposes, DifferenceSpace, valueDimension(), differenceDimension(), and allowsValueDimension(); ValueVector, DifferenceVector, and DifferenceMatrix, the Eigen types a space sizes; isLinear<> and its parts; writable(); and the free functions plus(), minus(), less(), normalizeValues(), and normalizeDifferences(), which add and subtract where a space has no plus() or minus() of its own [difference-spaces]
Subspace.h	Subspaces, and growing and shrinking blocks (decisions.md [several-resizable-blocks])
TagPath.h	Tag paths and the index utilities (decisions.md [tag-addressing], [index-names]): TagPath and TagPaths, and path, a path as a value; on() and onEach(), which place a factor or a matrix by path in a space not yet known [product-factors], or name a path differently; idx() and diffIdx(), which turn a path into Eigen indices from a space's run-time sizes or as compile-time constants; block() and diffBlock(), the block an Eigen vector or matrix has for a path; and zeros(), the vector a function fills block by block
UnitQuaternion.h	The unit quaternion space (decisions.md [unit-quaternion]): UnitQuaternion, an attitude stored in Eigen::Quaternion's own coefficient order with body-frame rotation vectors as its differences, its exponential and logarithm, the closed-form reset Jacobian of [covariance-reset], and map(), which views an attitude block, such as block<Attitude>(space, x) of a state (TagPath.h), as an Eigen::Quaternion without copying it
Core.h	Everything in the Core layer, which depends on Eigen alone: the version, the configuration macros, the mathematical constants and scalar concept, how matrix arguments are forwarded, the allocator conventions, execution policies, log-weight arithmetic, resamplers, the chi-squared distribution, triangularization, products of fixed-size matrices, solving by a small factorization, the modification stamp that views check, and printing
Distributions.h	Everything in the Distributions layer: the distributions, their parameters and densities, the read-only views over them, their moments, samples, statistics, sampling, fitting, upkeep, and the divergences between them
EmrysFilter.h	The whole library: the six layers, in order
Filters.h	Everything in the Filters layer: the Kalman, Gaussian mixture, interacting multiple model, particle, Rao-Blackwellized, and hidden Markov model filters
Models.h	Everything in the Models layer: transforms of a distribution through a function, process and measurement models, mode-switching models, the branch reduction policies, the consistency statistics, and simulation
Smoothers.h	Everything in the Smoothers layer: the histories of the Kalman, interacting multiple model, Gaussian mixture, particle, and hidden Markov model filters' forward passes, and the backward passes over them
Spaces.h	Everything in the Spaces layer: continuous spaces and their tag paths, the index utilities, the unit quaternion, and discrete spaces