RbPointMassFilter.h

Go to the documentation of this file.

#pragma once

 
#include <expected>
#include <span>
#include <type_traits>
#include <utility>
 
#include <EmrysFilter/Core/Allocation.h>
#include <EmrysFilter/Core/Execution.h>
#include <EmrysFilter/Distributions/Gaussian.h>
#include <EmrysFilter/Distributions/GridGaussian.h>
#include <EmrysFilter/Distributions/Hybrid.h>
#include <EmrysFilter/Core/Macros.h>
#include <EmrysFilter/Filters/FilterUpkeep.h>
#include <EmrysFilter/Filters/ImmFilter.h>
#include <EmrysFilter/Models/Measurement.h>
#include <EmrysFilter/Models/ProcessModel.h>
#include <EmrysFilter/Filters/RbUpdate.h>
#include <EmrysFilter/Models/Reduction.h>
#include <EmrysFilter/Models/Transform.h>
#include <EmrysFilter/Core/Print.h>
 
namespace Emrys
{
 
namespace internal
{

template <typename Grid, typename Model, bool = isSwitchingPointModel<Model>>
struct CellComponentOf
{
    using type = Gaussian<typename Grid::RestSpace, typename Grid::Scalar>;  
};

template <typename Grid, typename Model>
struct CellComponentOf<Grid, Model, true>
{
    using type = Hybrid<
        Gaussian<typename Grid::RestSpace, typename Grid::Scalar>,
        typename Model::ModeSpaceType,
        typename Grid::allocator_type>;
};
 
}  // namespace internal

template <typename Scalar = double, typename Allocator = DefaultAllocator>
class RbPointMassFilterUpdate
{
public:
 
    using ArrayType = Eigen::Map<Eigen::Array<Scalar, Eigen::Dynamic, 1> const>;  
    using allocator_type = Allocator;  

    explicit RbPointMassFilterUpdate(Allocator const & allocator = {})
        : m_cells(internal::ReBound<Allocator, Eigen::Index>(allocator))
        , m_points{allocator}
    {}

    [[nodiscard]] std::span<Eigen::Index const>
    cells() const
    {
        return {m_cells.data(), m_cells.size()};
    }

    [[nodiscard]] ArrayType
    logLikelihoods() const
    {
        return m_points.logLikelihoods();
    }

    [[nodiscard]] ArrayType
    nis() const
    {
        return m_points.nis();
    }

    [[nodiscard]] Eigen::Index
    innovationSize() const
    {
        return m_points.innovationSize;
    }

    [[nodiscard]] allocator_type
    get_allocator() const
    {
        return allocator_type(m_cells.get_allocator());
    }

    [[nodiscard]] Scalar
    logLikelihood() const
    {
        return m_logLikelihood;
    }
 
    bool accepted = false;  
 
private:
 
    friend struct internal::PointLikelihoodsAccess;
    friend struct internal::UpdateAccess;
 
    Scalar m_logLikelihood = 0;  
 
    internal::Buffer<Eigen::Index, Allocator> m_cells;       
    internal::PointLikelihoods<Scalar, Allocator> m_points;  
};

template <
    typename Grid_,
    typename Model_,
    typename Covariance_ = internal::PointCovarianceFor<Model_>,
    typename Method_ = DefaultMethodFor<Model_>,
    typename Upkeep_ = upkeep::None>
class RbPointMassFilter
    : public internal::HeldUpkeep<RbPointMassFilter<Grid_, Model_, Covariance_, Method_, Upkeep_>, Upkeep_>
{
    using UpkeepBase = internal::HeldUpkeep<RbPointMassFilter, Upkeep_>;  
 
    static constexpr bool Shared = std::is_same_v<Covariance_, SharedCovariance>;  

    static constexpr bool Switching = internal::isSwitchingPointModel<Model_>;

    template <typename P>
    static constexpr void
    assertCellsRunUnder()
    {
        static_assert(
            !Switching || internal::isSequential<P>,
            "a cell's IMM step writes the recursion's scratch, so the cells of a hybrid grid run in order: pass "
            "Sequential"
        );
    }
 
    static_assert(
        internal::predictsBy<Model_, Method_>,
        "a filter with a fixed-step model predicts by the model's method"
    );
    static_assert(internal::checkPredictionMethod<Method_>());
 
public:
 
    using GridType = Grid_;                       
    using Scalar = typename Grid_::Scalar;        
    using SpaceType = typename Grid_::SpaceType;  
    using ModelType = Model_;                     
    using MethodType = Method_;                   
    using StateType = GridGaussianParams<Grid_, Covariance_, typename internal::CellComponentOf<Grid_, Model_>::type>;
    using ConditionalType = typename StateType::ConditionalType;  
    using allocator_type = typename StateType::allocator_type;    

    RbPointMassFilter(
        std::type_identity_t<Model_> model,
        Grid_ grid,
        ConditionalType const & conditional,
        Covariance_ = {},
        MethodFor<Model_, Method_> method = {}
    )
        : RbPointMassFilter{std::move(model), std::move(grid), conditional, Covariance_{}, std::move(method), Upkeep_{}}
    {}

    RbPointMassFilter(
        std::type_identity_t<Model_> model,
        Grid_ grid,
        ConditionalType const & conditional,
        Covariance_,
        MethodFor<Model_, Method_> method,
        std::type_identity_t<Upkeep_> upkeep
    )
        : UpkeepBase{std::move(upkeep)}
        , m_steps{std::move(model), std::move(method), grid.get_allocator()}
        , m_state{std::move(grid), conditional}
        , m_posterior{m_state.m_conditionals, m_state.get_allocator()}
    {
        assertModelPartitions(m_state);
        reserve();
    }

    RbPointMassFilter(
        std::type_identity_t<Model_> model,
        Grid_ grid,
        ConditionalType const & conditional,
        std::type_identity_t<Upkeep_> upkeep
    )
        requires(!std::same_as<Upkeep_, Emrys::upkeep::None>)
        : RbPointMassFilter{
              std::move(model),
              std::move(grid),
              conditional,
              Covariance_{},
              MethodFor<Model_, Method_>{},
              std::move(upkeep)
          }
    {}

    RbPointMassFilter(
        std::type_identity_t<Model_> model,
        Grid_ grid,
        ConditionalType const & conditional,
        Covariance_ covariance,
        std::type_identity_t<Upkeep_> upkeep
    )
        requires(!std::same_as<Upkeep_, Emrys::upkeep::None>)
        : RbPointMassFilter{
              std::move(model),
              std::move(grid),
              conditional,
              covariance,
              MethodFor<Model_, Method_>{},
              std::move(upkeep)
          }
    {}

    explicit RbPointMassFilter(Grid_ grid, Covariance_ = {})
        requires(std::is_same_v<typename Grid_::RestSpace, Linear<0>> && std::is_same_v<Model_, NoProcessModel>)
        : UpkeepBase{Upkeep_{}}
        , m_state{std::move(grid), ConditionalType{}}
        , m_posterior{m_state.m_conditionals, m_state.get_allocator()}
    {
        reserve();
    }

    RbPointMassFilter(Grid_ grid, Covariance_, std::type_identity_t<Upkeep_> upkeep)
        requires(!std::same_as<Upkeep_, Emrys::upkeep::None> && std::is_same_v<Model_, NoProcessModel>
                 && std::is_same_v<typename Grid_::RestSpace, Linear<0>>)
        : UpkeepBase{std::move(upkeep)}
        , m_state{std::move(grid), ConditionalType{}}
        , m_posterior{m_state.m_conditionals, m_state.get_allocator()}
    {
        reserve();
    }

    RbPointMassFilter(Grid_ grid, std::type_identity_t<Upkeep_> upkeep)
        requires(
            !std::same_as<Upkeep_, Emrys::upkeep::None> && std::is_same_v<Model_, NoProcessModel>
            && std::is_same_v<typename Grid_::RestSpace, Linear<0>>
        )
        : RbPointMassFilter{std::move(grid), Covariance_{}, std::move(upkeep)}
    {}

    [[nodiscard]] allocator_type
    get_allocator() const
    {
        return m_state.get_allocator();
    }

    [[nodiscard]] StateType const &
    state() const
    {
        return m_state;
    }

    [[nodiscard]] StateType &
    state()
    {
        return m_state;
    }

    void
    setState(StateType state)
    {
        if constexpr (!std::is_same_v<Model_, NoProcessModel>)
        {
            assertModelPartitions(state);
        }
        auto const before = m_state.get_allocator();
        m_state = std::move(state);
        if (m_state.get_allocator() != before)
        {
            // The assignment carried the new state's allocator in, so the scratch follows it.
            m_posterior = decltype(m_posterior){m_state.m_conditionals, m_state.get_allocator()};
            if constexpr (Switching)
            {
                m_steps.resetScratch(m_state.get_allocator());
            }
        }
        reserve();
    }

    [[nodiscard]] Model_ const &
    model() const
    {
        return m_steps.model();
    }

    [[nodiscard]] Model_ &
    model()
    {
        return m_steps.model();
    }

    [[nodiscard]] Method_ const &
    method() const
    {
        return m_steps.method();
    }

    template <typename... Inputs>
        requires(!isFixedStep<Model_>)
    void
    predict(TimeStep<Scalar> auto const & dt, Inputs const &... inputs)
    {
        predict(execution::sequential, dt, inputs...);
    }

    template <ExecutionPolicy P, typename... Inputs>
        requires(!isFixedStep<Model_>)
    void
    predict([[maybe_unused]] P && policy, TimeStep<Scalar> auto const & dt, [[maybe_unused]] Inputs const &... inputs)
    {
        [[maybe_unused]] Scalar const step = internal::toScalarTime<Scalar>(dt);
        if constexpr (Switching)
        {
            assertCellsRunUnder<P>();
            m_state.m_stamp.touchValues();
            for (Eigen::Index i = 0; i < m_state.size(); ++i)
            {
                m_steps.predict(m_state.m_conditionals.conditional(i), step, inputs...);
            }
        }
        else if constexpr (!std::is_same_v<Model_, NoProcessModel>)
        {
            moveCells(
                std::forward<P>(policy),
                [&](auto const & cell) {
                    return Emrys::predict(m_steps.method(), cell, m_steps.model(), step, inputs...);
                },
                [&](auto const & mean) {
                    return Emrys::propagate(m_state.grid().restSpace(), mean, m_steps.model(), step, inputs...);
                }
            );
        }
        else
        {
            static_assert(sizeof...(Inputs) == 0, "a point-mass filter over the whole state takes no input");
        }
    }

    template <typename... Inputs>
        requires(isFixedStep<Model_> && !internal::leadsWithPolicy<Inputs...> && !internal::leadsWithSteps<Inputs...>)
    void
    predict(Inputs const &... inputs)
    {
        internal::rejectTimeStep<Inputs...>();
        predict(execution::sequential, inputs...);
    }

    template <ExecutionPolicy P, typename... Inputs>
        requires(isFixedStep<Model_> && !internal::leadsWithSteps<Inputs...>)
    void
    predict(P && policy, Inputs const &... inputs)
    {
        internal::rejectTimeStep<Inputs...>();
        if constexpr (Switching)
        {
            assertCellsRunUnder<P>();
            m_state.m_stamp.touchValues();
            for (Eigen::Index i = 0; i < m_state.size(); ++i)
            {
                m_steps.predict(m_state.m_conditionals.conditional(i), inputs...);
            }
        }
        else
        {
            moveCells(
                std::forward<P>(policy),
                [&](auto const & cell) {
                    return Emrys::predict(cell, m_steps.model(), inputs...);
                },
                [&](auto const & mean) {
                    return Emrys::propagate(
                        m_state.grid().restSpace(),
                        mean,
                        m_steps.model().model(),
                        m_steps.model().timeStep(),
                        inputs...
                    );
                }
            );
        }
    }

    template <typename... Inputs>
        requires isFixedStep<Model_>
    void
    predict(Steps steps, Inputs const &... inputs)
    {
        predict(execution::sequential, steps, inputs...);
    }

    template <ExecutionPolicy P, typename... Inputs>
        requires isFixedStep<Model_>
    void
    predict(P && policy, Steps steps, Inputs const &... inputs)
    {
        EMRYS_FILTER_ASSERT(steps.count >= 0 && "the number of steps must be nonnegative");
        for (Eigen::Index i = 0; i < steps.count; ++i)
        {
            predict(policy, inputs...);
        }
    }

    using UpdateType = RbPointMassFilterUpdate<Scalar, allocator_type>;

    template <internal::WeighsPoints M>
    [[nodiscard]] std::expected<UpdateType, NumericError>
    update(M const & measurement)
    {
        return update(execution::sequential, measurement);
    }

    template <ExecutionPolicy P, internal::WeighsPoints M>
    [[nodiscard]] std::expected<UpdateType, NumericError>
    update(P && executionPolicy, M const & measurement)
    {
        auto result = UpdateType{get_allocator()};
        auto const updated = update(std::forward<P>(executionPolicy), measurement, result);
        if (!updated)
        {
            return std::unexpected{updated.error()};
        }
        return result;
    }

    template <internal::WeighsPoints M, typename ResultAllocator>
    [[nodiscard]] std::expected<void, NumericError>
    update(M const & measurement, RbPointMassFilterUpdate<Scalar, ResultAllocator> & result)
    {
        return update(execution::sequential, measurement, result);
    }

    template <ExecutionPolicy P, internal::WeighsPoints M, typename ResultAllocator>
    [[nodiscard]] std::expected<void, NumericError>
    update(P && executionPolicy, M const & measurement, RbPointMassFilterUpdate<Scalar, ResultAllocator> & result)
    {
        if constexpr (!internal::hasOwnLikelihood<M> && !Shared)
        {
            return update(std::forward<P>(executionPolicy), measurement, reductions::collapse(), result);
        }
        else
        {
            auto & points = internal::PointLikelihoodsAccess::points(result);
            if constexpr (internal::hasOwnLikelihood<M>)
            {
                internal::updateGivenLikelihood(
                    executionPolicy,
                    m_state.points(),
                    m_state.m_conditionals,
                    measurement,
                    points
                );
                finish<false>(std::forward<P>(executionPolicy), result);
            }
            else
            {
                auto const updated = internal::updateGivenShared(
                    executionPolicy,
                    m_state.points(),
                    m_state.m_conditionals,
                    m_state.mostProbable(),
                    measurement,
                    points,
                    m_posterior
                );
                if (!updated)
                {
                    return std::unexpected{updated.error()};
                }
                finish(std::forward<P>(executionPolicy), result);
            }
            return {};
        }
    }

    template <internal::WeighsPoints M, typename Policy>
    [[nodiscard]] std::expected<UpdateType, NumericError>
    update(M const & measurement, Policy const & policy)
        requires(!Shared)
    {
        return update(execution::sequential, measurement, policy);
    }

    template <ExecutionPolicy P, internal::WeighsPoints M, typename Policy>
    [[nodiscard]] std::expected<UpdateType, NumericError>
    update(P && executionPolicy, M const & measurement, Policy const & policy)
        requires(!Shared)
    {
        auto result = UpdateType{get_allocator()};
        auto const updated = update(std::forward<P>(executionPolicy), measurement, policy, result);
        if (!updated)
        {
            return std::unexpected{updated.error()};
        }
        return result;
    }

    template <internal::WeighsPoints M, typename Policy, typename ResultAllocator>
    [[nodiscard]] std::expected<void, NumericError>
    update(M const & measurement, Policy const & policy, RbPointMassFilterUpdate<Scalar, ResultAllocator> & result)
        requires(!Shared)
    {
        return update(execution::sequential, measurement, policy, result);
    }

    template <ExecutionPolicy P, internal::WeighsPoints M, typename Policy, typename ResultAllocator>
    [[nodiscard]] std::expected<void, NumericError>
    update(
        P && executionPolicy,
        M const & measurement,
        Policy const & policy,
        RbPointMassFilterUpdate<Scalar, ResultAllocator> & result
    )
        requires(!Shared)
    {
        static_assert(
            !internal::hasOwnLikelihood<M>,
            "a measurement weighted by its own logLikelihood() has no branches to reduce, so it takes no policy"
        );
        if constexpr (Switching && internal::isByMode<M>)
        {
            // Each mode's measurement holds its own noise component, so the recursion resolves it.
            using PathType = typename Grid_::PathType;
            return updateCells(
                std::forward<P>(executionPolicy),
                m_steps.template emptyGivenUpdate<M, SpaceType, PathType>(get_allocator(), modeCount()),
                [&](auto & cell, auto const & pinned, auto & cellResult) {
                    using Value = std::remove_cvref_t<decltype(pinned)>;
                    return m_steps.update(
                        cell,
                        measurement,
                        GivenBlock<SpaceType, PathType, Value>{m_state.grid().space(), pinned},
                        policy,
                        cellResult
                    );
                },
                result
            );
        }
        else if constexpr (Switching)
        {
            auto const f = internal::PinnedMeasurement<SpaceType, typename Grid_::PathType, M>{
                m_state.grid().space(),
                measurement
            };
            return updateCells(
                std::forward<P>(executionPolicy),
                m_steps.template emptyGivenUpdate<M, SpaceType, typename Grid_::PathType>(get_allocator(), modeCount()),
                [&](auto & cell, auto const & pinned, auto & cellResult) {
                    return m_steps.updateGiven(cell, f, pinned, policy, cellResult);
                },
                result
            );
        }
        else
        {
            auto const updated = internal::updateGivenEach(
                executionPolicy,
                m_state.points(),
                m_state.m_conditionals,
                measurement,
                policy,
                internal::PointLikelihoodsAccess::points(result),
                m_posterior
            );
            if (!updated)
            {
                return std::unexpected{updated.error()};
            }
            finish(std::forward<P>(executionPolicy), result);
            return {};
        }
    }
 
private:

    void
    assertModelPartitions([[maybe_unused]] StateType const & state) const
    {
        if constexpr (Switching)
        {
            EMRYS_FILTER_ASSERT(
                m_steps.partitions(state.grid().restSpace())
                && "every mode's process model must write every coordinate of the rest of the state once"
            );
        }
        else
        {
            internal::assertPartitions(
                m_steps.model(),
                state.grid().restSpace(),
                "the process model must write every coordinate of the rest of the state once"
            );
        }
    }

    [[nodiscard]] Eigen::Index
    modeCount() const
        requires Switching
    {
        return m_steps.modeSpace().cardinality();
    }

    template <typename P, typename CellResult, typename UpdateCell, typename ResultAllocator>
    [[nodiscard]] std::expected<void, NumericError>
    updateCells(
        P && policy,
        CellResult cellResult,
        UpdateCell const & updateCell,
        RbPointMassFilterUpdate<Scalar, ResultAllocator> & result
    )
    {
        assertCellsRunUnder<P>();
        // Each cell's hybrid is updated in place below, so a density of the state is stale.
        m_state.m_stamp.touchValues();
        auto const updated = internal::updateHybridsGiven(
            m_state.points(),
            m_state.m_conditionals,
            internal::PointLikelihoodsAccess::points(result),
            cellResult,
            updateCell
        );
        if (!updated)
        {
            return updated;
        }
        finish<false>(std::forward<P>(policy), result);
        return {};
    }

    template <typename P, typename PredictCell, typename Propagate>
    void
    moveCells(P && policy, PredictCell const & predictCell, Propagate const & propagate)
    {
        m_state.m_stamp.touchValues();
        auto & conditionals = m_state.m_conditionals;
        static_assert(!Switching);
        if constexpr (Shared)
        {
            ConditionalType const predicted = predictCell(conditionals.conditional(m_state.mostProbable()));
            auto means = conditionals.means();
            internal::forEachIndex(std::forward<P>(policy), means.cols(), [&](Eigen::Index i) {
                means.col(i) = propagate(means.col(i));
            });
            normalizeValues(m_state.grid().restSpace(), means);
            conditionals.sharedCovariance() = predicted.covarianceLower();
        }
        else
        {
            internal::forEachIndex(std::forward<P>(policy), conditionals.size(), [&](Eigen::Index i) {
                auto & cell = conditionals.conditional(i);
                cell = predictCell(cell);
            });
        }
    }

    void
    reserve()
    {
        m_posterior.reserve(m_state.size());
    }

    template <bool Posterior = true, typename P, typename ResultAllocator>
    void
    finish(P && policy, RbPointMassFilterUpdate<Scalar, ResultAllocator> & result)
    {
        auto const cells = m_state.cells();
        internal::PointLikelihoodsAccess::cells(result).assign(cells.begin(), cells.end());
        auto & points = internal::PointLikelihoodsAccess::points(result);
        auto const [logLikelihood, accepted] = [&] {
            if constexpr (Posterior)
            {
                return m_state.reweight(std::forward<P>(policy), points.logLikelihoods(), m_posterior);
            }
            else
            {
                return m_state.reweight(std::forward<P>(policy), points.logLikelihoods());
            }
        }();
        internal::UpdateAccess::logLikelihood(result) = logLikelihood;
        result.accepted = accepted;
    }

    using StepsType = std::conditional_t<
        Switching,
        ImmRecursion<Gaussian<typename Grid_::RestSpace, Scalar>, Model_, Method_, allocator_type>,
        internal::PointSteps<Model_, Method_>>;
 
    StepsType m_steps;  
    StateType m_state;  
 
    // Scratch, reused across steps.
    typename StateType::ConditionalsType m_posterior;  
};
 
namespace internal
{

template <typename U>
concept GridUpkeepArgument =
    UpkeepArgument<U> && !std::same_as<U, SharedCovariance> && !std::same_as<U, PerPointCovariance>;
 
}  // namespace internal

// The method argument's type depends on the model, so it is deduced here; the parameters are in
// the class's order so MSVC also deduces through the PointMassFilter alias. An upkeep, given last,
// is told from a covariance form or a method by its type.
template <
    typename Grid_,
    typename Model_,
    typename Covariance_ = internal::PointCovarianceFor<Model_>,
    typename Method_ = DefaultMethodFor<Model_>,
    typename Conditional>
    requires(!internal::GridUpkeepArgument<Covariance_> && !internal::UpkeepArgument<Method_>)
RbPointMassFilter(Model_, Grid_, Conditional, Covariance_ = {}, Method_ = {}) -> RbPointMassFilter<
    Grid_,
    internal::BoundStep<Model_, typename Grid_::RestSpace, typename Grid_::Scalar>,
    Covariance_,
    Method_>;
 
template <
    typename Grid_,
    typename Model_,
    typename Covariance_ = internal::PointCovarianceFor<Model_>,
    typename Method_ = DefaultMethodFor<Model_>,
    typename Upkeep_,
    typename Conditional>
    requires internal::GridUpkeepArgument<Upkeep_>
RbPointMassFilter(Model_, Grid_, Conditional, Upkeep_) -> RbPointMassFilter<
    Grid_,
    internal::BoundStep<Model_, typename Grid_::RestSpace, typename Grid_::Scalar>,
    Covariance_,
    Method_,
    Upkeep_>;
 
template <
    typename Grid_,
    typename Model_,
    typename Covariance_,
    typename Method_ = DefaultMethodFor<Model_>,
    typename Upkeep_,
    typename Conditional>
    requires(!internal::GridUpkeepArgument<Covariance_> && internal::GridUpkeepArgument<Upkeep_>)
RbPointMassFilter(Model_, Grid_, Conditional, Covariance_, Upkeep_) -> RbPointMassFilter<
    Grid_,
    internal::BoundStep<Model_, typename Grid_::RestSpace, typename Grid_::Scalar>,
    Covariance_,
    Method_,
    Upkeep_>;
 
template <
    typename Grid_,
    typename Model_,
    typename Covariance_,
    typename Method_,
    typename Upkeep_,
    typename Conditional>
RbPointMassFilter(Model_, Grid_, Conditional, Covariance_, Method_, Upkeep_) -> RbPointMassFilter<
    Grid_,
    internal::BoundStep<Model_, typename Grid_::RestSpace, typename Grid_::Scalar>,
    Covariance_,
    Method_,
    Upkeep_>;
 
template <
    typename Grid_,
    typename Model_ = NoProcessModel,
    typename Covariance_ = SharedCovariance,
    typename Method_ = methods::Linearized,
    typename Upkeep_ = upkeep::None>
    requires(!internal::GridUpkeepArgument<Covariance_>)
RbPointMassFilter(Grid_, Covariance_ = {}) -> RbPointMassFilter<Grid_, Model_, Covariance_, Method_, Upkeep_>;
 
template <
    typename Grid_,
    typename Model_ = NoProcessModel,
    typename Covariance_ = SharedCovariance,
    typename Method_ = methods::Linearized,
    typename Upkeep_>
    requires internal::GridUpkeepArgument<Upkeep_>
RbPointMassFilter(Grid_, Upkeep_) -> RbPointMassFilter<Grid_, Model_, Covariance_, Method_, Upkeep_>;
 
template <
    typename Grid_,
    typename Model_ = NoProcessModel,
    typename Covariance_,
    typename Method_ = methods::Linearized,
    typename Upkeep_>
    requires(!internal::GridUpkeepArgument<Covariance_> && internal::GridUpkeepArgument<Upkeep_>)
RbPointMassFilter(Grid_, Covariance_, Upkeep_) -> RbPointMassFilter<Grid_, Model_, Covariance_, Method_, Upkeep_>;

template <typename Grid_, typename Covariance_ = SharedCovariance, typename Upkeep_ = upkeep::None>
using PointMassFilter = RbPointMassFilter<Grid_, NoProcessModel, Covariance_, methods::Linearized, Upkeep_>;
 
}  // namespace Emrys
 
#ifndef EMRYS_FILTER_NO_IO
 
namespace Emrys
{
 
namespace internal
{

template <typename Grid_, typename Model_, typename Covariance_, typename Method_, typename Upkeep_>
void
describe(
    std::ostream & stream,
    RbPointMassFilter<Grid_, Model_, Covariance_, Method_, Upkeep_> const & filter,
    Indent indent
)
{
    describeFilter(stream, "Rao-Blackwellized point-mass filter", filter.state(), indent);
}
 
}  // namespace internal
 
}  // namespace Emrys
 
#endif  // EMRYS_FILTER_NO_IO