MeasurementModel.h

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <concepts>
#include <cstddef>
#include <functional>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include <EmrysFilter/Core/Forwarding.h>
#include <EmrysFilter/Core/Macros.h>
#include <EmrysFilter/Distributions/Gaussian.h>
#include <EmrysFilter/Distributions/Roots.h>
#include <EmrysFilter/Models/Condition.h>
#include <EmrysFilter/Models/Methods.h>
#include <EmrysFilter/Models/Policies.h>
#include <EmrysFilter/Models/TransformArgs.h>
#include <EmrysFilter/Spaces/Composite.h>
#include <EmrysFilter/Spaces/Coordinates.h>
#include <EmrysFilter/Spaces/Space.h>
#include <EmrysFilter/Spaces/Subspace.h>
#include <EmrysFilter/Spaces/TagPath.h>
 
namespace Emrys
{
 
namespace internal
{

struct NoFunction
{};

struct NoOutputSpace
{};

template <typename S>
inline constexpr int maxCountOf =
    S::ValueDimensionStep == 0 ? 0
    : maxValueDimensionAtCompileTime<S> == Eigen::Dynamic
        ? Eigen::Dynamic
        : (maxValueDimensionAtCompileTime<S> - S::FixedValueDimension) / S::ValueDimensionStep;

template <typename In>
inline constexpr bool blocksAddValues = [] {
    if constexpr (IsComposite<In>)
    {
        return []<typename... Blocks>(std::tuple<Blocks...> *) {
            return ((!HasPlus<Blocks> && hasEqualSizes<Blocks>) && ...);
        }(static_cast<CompositeBlocks<In> *>(nullptr));
    }
    else
    {
        return !HasPlus<In> && hasEqualSizes<In>;
    }
}();
 
}  // namespace internal

template <typename Path, Space MeasurementSpace>
struct CountFrom
{
    static_assert(
        internal::resizableBlockCount<MeasurementSpace> == 1,
        "CountFrom's measurement space must have exactly one resizable block"
    );

    template <Space StateSpace>
    [[nodiscard]] MeasurementSpace
    operator()(StateSpace const & space) const
    {
        using Block = internal::PathSubspaceType<StateSpace, Path>;
        static_assert(
            internal::resizableBlockCount<Block> == 1,
            "CountFrom's block of the state must have exactly one resizable block"
        );
        static_assert(
            internal::maxCountOf<MeasurementSpace> == Eigen::Dynamic
                || (internal::maxCountOf<Block> != Eigen::Dynamic
                    && internal::maxCountOf<MeasurementSpace> >= internal::maxCountOf<Block>),
            "CountFrom's measurement space must hold a block per repetition of the state's block at its largest"
        );
        Eigen::Index const count = (valueDimension(internal::pathSubspace<Path>(space)) - Block::FixedValueDimension)
                                 / Block::ValueDimensionStep;
        auto result = MeasurementSpace{};
        result.resize(MeasurementSpace::FixedValueDimension + count * MeasurementSpace::ValueDimensionStep);
        return result;
    }
};

template <typename F, typename... Policies>
class MeasurementFunction
{
    using Set = internal::PolicySet<Policies...>;
 
public:
 
    using FunctionType = F;  
 
    static constexpr bool IsModel = true;  

    static constexpr bool HasFunction = !std::is_same_v<F, internal::NoFunction>;

    template <internal::PolicyKind K>
    static constexpr bool has = Set::template has<K>;

    template <internal::PolicyKind K>
    using Policy = typename Set::template Type<K>;

    explicit MeasurementFunction(F function, Policies... policies)
        : m_function{std::move(function)}
        , m_policies{std::move(policies)...}
    {}

    [[nodiscard]] F const &
    function() const
    {
        return m_function;
    }

    template <internal::PolicyKind K>
    [[nodiscard]] Policy<K> const &
    policy() const
    {
        return Set::template get<K>(m_policies);
    }

    [[nodiscard]] std::tuple<Policies...> const &
    policies() const
    {
        return m_policies;
    }
 
private:
 
    EMRYS_FILTER_NO_UNIQUE_ADDRESS F m_function;  
    std::tuple<Policies...> m_policies;           
};
 
namespace internal
{

template <typename T>
inline constexpr bool isMeasurementFunction = false;

template <typename F, typename... Policies>
inline constexpr bool isMeasurementFunction<MeasurementFunction<F, Policies...>>{true};
 
}  // namespace internal

template <typename M>
concept MeasurementModel = internal::isMeasurementFunction<std::remove_cvref_t<M>>;
 
namespace internal
{

template <typename Matrix>
class LinearFunction
{
public:

    using OutputSpaceType = Linear<Matrix::RowsAtCompileTime, Matrix::MaxRowsAtCompileTime>;

    explicit LinearFunction(Matrix matrix)
        : m_matrix{std::move(matrix)}
    {}

    [[nodiscard]] Matrix const &
    matrix() const
    {
        return m_matrix;
    }

    [[nodiscard]] Eigen::Index
    outputRows() const
    {
        return m_matrix.rows();
    }

    template <typename In, typename Out, typename X>
    [[nodiscard]] auto
    operator()([[maybe_unused]] In const & in, Out const &, X const & x) const
    {
        static_assert(
            blocksAddValues<In>,
            "a linear measurement model reads blocks with no plus() of their own; a block such as a unit quaternion "
            "has no linear measurement, so give measurementModel() a function"
        );
        static_assert(
            Matrix::ColsAtCompileTime == Eigen::Dynamic || valueDimensionAtCompileTime<In> == Eigen::Dynamic
                || Matrix::ColsAtCompileTime == valueDimensionAtCompileTime<In>,
            "a linear measurement model's matrix must have a column per coordinate of the blocks it reads"
        );
        EMRYS_FILTER_ASSERT(
            m_matrix.cols() == x.size()
            && "a linear measurement model's matrix must have a column per coordinate of the blocks it reads"
        );
        using T = typename X::Scalar;
        using Value = Eigen::Matrix<T, Matrix::RowsAtCompileTime, 1, Eigen::ColMajor, Matrix::MaxRowsAtCompileTime, 1>;
        Value value = m_matrix.template cast<T>() * x;
        return WithJacobian<Value, Matrix const &>{std::move(value), m_matrix};
    }
 
private:
 
    Matrix m_matrix;  
};

template <typename T>
struct ColumnsOf
{
    static constexpr bool IsPlaced = false;      
    static constexpr bool Each = false;          
    static constexpr int Rows = Eigen::Dynamic;  
    using Path = void;                           
};

template <MatrixExpression M, typename P>
struct ColumnsOf<OnPath<M, P>>
{
    static constexpr bool IsPlaced = true;             
    static constexpr bool Each = false;                
    static constexpr int Rows = M::RowsAtCompileTime;  
    using Path = P;                                    
};

template <MatrixExpression M, typename P>
    requires(!std::is_same_v<P, WholeSpace>)
struct ColumnsOf<OnEach<M, P>>
{
    static constexpr bool IsPlaced = true;             
    static constexpr bool Each = true;                 
    static constexpr int Rows = M::RowsAtCompileTime;  
    using Path = P;                                    
};

template <int... Rows>
inline constexpr int agreedRows = [] {
    int result = Eigen::Dynamic;
    for (int const rows : std::array<int, sizeof...(Rows)>{Rows...})
    {
        if (rows == Eigen::Dynamic)
        {
            continue;
        }
        if (result != Eigen::Dynamic && rows != result)
        {
            return 0;
        }
        result = rows;
    }
    return result;
}();

template <typename... Placed>
struct FirstEachPathOf
{
    using type = void;
};

template <typename First, typename... Rest>
struct FirstEachPathOf<First, Rest...>
{
    using type = std::
        conditional_t<ColumnsOf<First>::Each, typename ColumnsOf<First>::Path, typename FirstEachPathOf<Rest...>::type>;
};
 
}  // namespace internal

template <typename... Placed>
class Columns
{
    static_assert(sizeof...(Placed) > 0, "a model's matrix needs at least one block of columns");
    static_assert(
        (internal::ColumnsOf<Placed>::IsPlaced && ...),
        "each block of a model's columns is a matrix placed on a block of the state, with on<Path>() or "
        "onEach<Path>()"
    );
    static_assert(
        !(internal::ColumnsOf<Placed>::IsPlaced && ...)
            || internal::distinctTypes<internal::AsTagPath<typename internal::ColumnsOf<Placed>::Path>...>(),
        "a model's columns name each block of the state once"
    );
    static_assert(
        internal::agreedRows<internal::ColumnsOf<Placed>::Rows...> != 0,
        "every block of a model's columns has the rows of one repetition of the measurement"
    );
 
public:

    static constexpr bool Repeats = (internal::ColumnsOf<Placed>::Each || ...);

    static constexpr int Rows = internal::agreedRows<internal::ColumnsOf<Placed>::Rows...>;

    using Paths = TagPaths<typename internal::ColumnsOf<Placed>::Path...>;

    using FirstEachPath = typename internal::FirstEachPathOf<Placed...>::type;

    explicit Columns(Placed... placed)
        : m_placed{std::move(placed)...}
    {
        EMRYS_FILTER_ASSERT(
            std::apply(
                [&](auto const &... each) {
                    return ((each.value.rows() == rows()) && ...);
                },
                m_placed
            )
            && "every block of a model's columns has the rows of one repetition of the measurement"
        );
    }

    [[nodiscard]] std::tuple<Placed...> const &
    placed() const
    {
        return m_placed;
    }

    [[nodiscard]] Eigen::Index
    rows() const
    {
        return std::get<0>(m_placed).value.rows();
    }
 
private:
 
    std::tuple<Placed...> m_placed;  
};
 
namespace internal
{

template <typename T>
inline constexpr bool isColumns = false;

template <typename... Placed>
inline constexpr bool isColumns<Columns<Placed...>>{true};


template <typename Path, int Rows>
struct LinearPerRepetition
{
    template <typename StateSpace>
    [[nodiscard]] auto
    operator()(StateSpace const & space) const
    {
        using Block = PathSubspaceType<StateSpace, Path>;
        static_assert(
            Block::FixedValueDimension == 0 && Block::ValueDimensionStep > 0,
            "a model's onEach<Path>() repeats over a resizable block of the state, and the block named is fixed-size"
        );
        return CountFrom<Path, Repeated<Linear<Rows>, maxCountOf<Block>>>{}(space);
    }
};

template <typename... Placed>
class ColumnsFunction
{
    using Scalar = typename std::remove_cvref_t<
        decltype(std::get<0>(std::declval<std::tuple<Placed...> const &>()).value)>::Scalar;
 
public:

    using OutputSpaceType = Linear<Columns<Placed...>::Rows>;

    explicit ColumnsFunction(Columns<Placed...> columns)
        : m_columns{std::move(columns)}
    {}

    [[nodiscard]] Columns<Placed...> const &
    columns() const
    {
        return m_columns;
    }

    [[nodiscard]] Eigen::Index
    outputRows() const
        requires(!Columns<Placed...>::Repeats)
    {
        return m_columns.rows();
    }

    template <typename In, typename Out, typename X>
    [[nodiscard]] auto
    operator()(In const & in, Out const & out, X const & x) const
    {
        static_assert(
            blocksAddValues<In>,
            "a linear measurement model reads blocks with no plus() of their own; a block such as a unit quaternion "
            "has no linear measurement, so give measurementModel() a function"
        );
        using T = typename X::Scalar;
        constexpr int OutRows = Columns<Placed...>::Repeats ? Eigen::Dynamic : Columns<Placed...>::Rows;
        constexpr int OutMaxRows =
            Columns<Placed...>::Repeats ? maxValueDimensionAtCompileTime<Out> : Columns<Placed...>::Rows;
        using Value = Eigen::Matrix<T, OutRows, 1, Eigen::ColMajor, OutMaxRows, 1>;
        using Jacobian =
            MatrixOf<Scalar, OutRows, valueDimensionAtCompileTime<In>, OutMaxRows, maxValueDimensionAtCompileTime<In>>;
        Eigen::Index const rows = m_columns.rows();
        Eigen::Index const count = [&] {
            if constexpr (Columns<Placed...>::Repeats)
            {
                Eigen::Index const repetitions = valueDimension(out) / rows;
                EMRYS_FILTER_ASSERT(
                    repetitions * rows == valueDimension(out)
                    && "a linear model's matrices have a row per coordinate of one repetition of the measurement"
                );
                return repetitions;
            }
            else
            {
                return Eigen::Index{1};
            }
        }();
        Jacobian jacobian = Jacobian::Zero(count * rows, valueDimension(in));
        Eigen::Index column = 0;
        std::apply(
            [&](auto const &... placed) {
                (place(placed, in, count, column, jacobian), ...);
            },
            m_columns.placed()
        );
        EMRYS_FILTER_ASSERT(
            column == valueDimension(in)
            && "a linear model's matrices must have a column per coordinate of the blocks they read"
        );
        Value value = jacobian.template cast<T>() * x;
        return WithJacobian<Value, Jacobian>{std::move(value), std::move(jacobian)};
    }
 
private:

    template <typename P, typename In, typename Jacobian>
    static void
    place(P const & placed, In const & in, Eigen::Index count, Eigen::Index & column, Jacobian & jacobian)
    {
        using C = ColumnsOf<P>;
        using Name = PathTag<typename C::Path>;
        auto const & matrix = placed.value;
        Eigen::Index const rows = matrix.rows();
        Eigen::Index const width = valueDimension(pathSubspace<Name>(in));
        if constexpr (C::Each)
        {
            using Block = PathSubspaceType<In, Name>;
            static_assert(
                Block::FixedValueDimension == 0 && Block::ValueDimensionStep > 0,
                "a model's onEach<Path>() names a repeated block of the state"
            );
            constexpr int Cols = std::remove_cvref_t<decltype(matrix)>::ColsAtCompileTime;
            static_assert(
                Cols == Eigen::Dynamic || Cols == Block::ValueDimensionStep,
                "a model's onEach<Path>() matrix has a column per coordinate of one repetition of the block"
            );
            EMRYS_FILTER_ASSERT(
                matrix.cols() * count == width
                && "a model's onEach<Path>() blocks have the measurement's count of repetitions"
            );
            for (Eigen::Index i = 0; i < count; ++i)
            {
                jacobian.block(i * rows, column + i * matrix.cols(), rows, matrix.cols()) = matrix;
            }
        }
        else
        {
            EMRYS_FILTER_ASSERT(
                matrix.cols() == width
                && "a linear model's matrix must have a column per coordinate of the block it reads"
            );
            for (Eigen::Index i = 0; i < count; ++i)
            {
                jacobian.block(i * rows, column, rows, matrix.cols()) = matrix;
            }
        }
        column += width;
    }
 
    Columns<Placed...> m_columns;  
};

template <PolicyKind K, typename... Policies>
inline constexpr bool hasPolicy = ((policyKind<std::remove_cvref_t<Policies>> == K) || ...);

template <typename... Paths>
[[nodiscard]] auto
readsOf(TagPaths<Paths...> *)
{
    return reads(path<Paths>...);
}

template <typename Set>
[[nodiscard]] consteval bool
checkMeasurementPolicies()
{
    static_assert(
        !Set::template has<PolicyKind::continuousNoise>,
        "continuousNoise() is a process model's; a measurement model's noise is additiveNoise()"
    );
    static_assert(
        !Set::template has<PolicyKind::affineIn> || Set::template has<PolicyKind::reads>,
        "affineIn() names items of reads(), and a model without reads() reads the whole state under no names"
    );
    return true;
}

template <typename F>
struct CallArityOf
{
    static constexpr int value = -1;  
};

template <typename F>
    requires requires { &F::operator(); }
struct CallArityOf<F> : CallArityOf<decltype(&F::operator())>
{};
 
// Each signature is spelled with and without noexcept, since MSVC does not deduce a noexcept(B)
// in a partial specialization (C2764).
template <typename... A>
struct ArityOfParameters
{
    static constexpr int value = sizeof...(A);
};
 
template <typename R, typename... A>
struct CallArityOf<R (*)(A...)> : ArityOfParameters<A...>
{};
 
template <typename R, typename... A>
struct CallArityOf<R (*)(A...) noexcept> : ArityOfParameters<A...>
{};
 
template <typename R, typename C, typename... A>
struct CallArityOf<R (C::*)(A...)> : ArityOfParameters<A...>
{};
 
template <typename R, typename C, typename... A>
struct CallArityOf<R (C::*)(A...) noexcept> : ArityOfParameters<A...>
{};
 
template <typename R, typename C, typename... A>
struct CallArityOf<R (C::*)(A...) const> : ArityOfParameters<A...>
{};
 
template <typename R, typename C, typename... A>
struct CallArityOf<R (C::*)(A...) const noexcept> : ArityOfParameters<A...>
{};
 
template <typename R, typename C, typename... A>
struct CallArityOf<R (C::*)(A...) const &> : ArityOfParameters<A...>
{};
 
template <typename R, typename C, typename... A>
struct CallArityOf<R (C::*)(A...) const & noexcept> : ArityOfParameters<A...>
{};


template <typename F, typename Set>
[[nodiscard]] consteval auto
knownOutputType()
{
    if constexpr (Set::template has<PolicyKind::outputSpace>)
    {
        return std::type_identity<void>{};
    }
    else if constexpr (Set::template has<PolicyKind::writes>)
    {
        return std::type_identity<typename Set::template Type<PolicyKind::writes>::OutputSpace>{};
    }
    else if constexpr (requires { typename F::OutputSpaceType; })
    {
        return std::type_identity<typename F::OutputSpaceType>{};
    }
    else
    {
        return std::type_identity<void>{};
    }
}

template <typename S>
inline constexpr int differencesAtCompileTime = valueDimensionAtCompileTime<DifferenceSpace<S>>;

template <typename X>
[[nodiscard]] consteval int
noiseRowsAtCompileTime()
{
    if constexpr (MatrixExpression<X>)
    {
        return X::RowsAtCompileTime;
    }
    else if constexpr (requires { typename X::SpaceType; })
    {
        return differencesAtCompileTime<typename X::SpaceType>;
    }
    else
    {
        return Eigen::Dynamic;
    }
}

[[nodiscard]] consteval bool
noiseRowsFit(int rows, int coordinates)
{
    return rows == Eigen::Dynamic || coordinates == Eigen::Dynamic || rows == coordinates;
}

template <typename Out, typename X>
[[nodiscard]] consteval bool
noisePartFits(X const *)
{
    return noiseRowsFit(noiseRowsAtCompileTime<X>(), differencesAtCompileTime<Out>);
}

template <typename Out, typename X, typename Path>
[[nodiscard]] consteval bool
noisePartFits(OnPath<X, Path> const *)
{
    using Block = typename EachBlockOf<Out, Path>::type;
    return noiseRowsFit(noiseRowsAtCompileTime<std::remove_cvref_t<X>>(), differencesAtCompileTime<Block>);
}

template <typename Out, typename X, typename Path>
[[nodiscard]] consteval bool
noisePartFits(OnEach<X, Path> const *)
{
    using Block = typename EachBlockOf<Out, Path>::type;
    if constexpr (requires { typename Block::BlockType; })
    {
        return noiseRowsFit(
            noiseRowsAtCompileTime<std::remove_cvref_t<X>>(),
            differencesAtCompileTime<typename Block::BlockType>
        );
    }
    else
    {
        return true;
    }
}

template <typename Out, typename... Parts>
[[nodiscard]] consteval bool
noiseFits(AdditiveNoise<Parts...> const *)
{
    return (noisePartFits<Out>(static_cast<std::remove_cvref_t<Parts> const *>(nullptr)) && ...);
}

template <typename F, typename Set>
[[nodiscard]] consteval bool
checkMeasurementFunction()
{
    constexpr int Arity = CallArityOf<F>::value;
    static_assert(
        Arity < 0 || (Arity >= 1 && Arity <= 3),
        "a measurement model's function takes one to three arguments, h(x), h(in, x), or h(in, out, x), with in the "
        "input space, out the output space, and x a vector in the input space"
    );
    static_assert(
        !Set::template has<PolicyKind::sample>,
        "a measurement model with a function draws its observation through the function and its noise, so sample(g) "
        "is for a model known by its likelihood alone"
    );
    using Known = typename decltype(knownOutputType<F, Set>())::type;
    if constexpr (!std::is_void_v<Known> && Set::template has<PolicyKind::additiveNoise>)
    {
        static_assert(
            noiseFits<Known>(static_cast<typename Set::template Type<PolicyKind::additiveNoise> const *>(nullptr)),
            "a measurement model's additive noise has a row for each difference coordinate of the output space, from "
            "writes() or the matrix's rows, or of the block it is placed on"
        );
    }
    return true;
}
 
}  // namespace internal

template <typename F, typename... Policies>
    requires(!MatrixExpression<F> && !internal::ModelPolicy<F> && !internal::isColumns<std::remove_cvref_t<F>>)
[[nodiscard]] auto
measurementModel(F && function, Policies &&... policies)
{
    using Set = internal::PolicySet<std::remove_cvref_t<Policies>...>;
    static_assert(internal::checkMeasurementPolicies<Set>());
    static_assert(internal::checkMeasurementFunction<std::decay_t<F>, Set>());
    return MeasurementFunction<std::decay_t<F>, std::remove_cvref_t<Policies>...>{
        std::forward<F>(function),
        std::forward<Policies>(policies)...
    };
}

template <MatrixExpression Matrix, typename... Policies>
[[nodiscard]] auto
measurementModel(Matrix && matrix, Policies &&... policies)
{
    using Plain = internal::PlainResult<std::remove_cvref_t<Matrix>>;
    using Set = internal::PolicySet<std::remove_cvref_t<Policies>...>;
    static_assert(internal::checkMeasurementPolicies<Set>());
    static_assert(internal::checkMeasurementFunction<internal::LinearFunction<Plain>, Set>());
    return MeasurementFunction<internal::LinearFunction<Plain>, std::remove_cvref_t<Policies>...>{
        internal::LinearFunction<Plain>{Plain{std::forward<Matrix>(matrix)}},
        std::forward<Policies>(policies)...
    };
}

template <typename... Placed, typename... Policies>
[[nodiscard]] auto
measurementModel(Columns<Placed...> columns, Policies &&... policies)
{
    using ColumnsType = Columns<Placed...>;
    static_assert(
        !internal::hasPolicy<internal::PolicyKind::reads, Policies...>,
        "a model given Columns reads the blocks its columns are placed on, so it takes no reads()"
    );
    auto const read = internal::readsOf(static_cast<typename ColumnsType::Paths *>(nullptr));
    using Function = internal::ColumnsFunction<Placed...>;
    if constexpr (ColumnsType::Repeats && !internal::hasPolicy<internal::PolicyKind::outputSpace, Policies...>)
    {
        static_assert(
            ColumnsType::Rows != Eigen::Dynamic,
            "a model whose columns repeat infers its measurement space from its matrices' rows, so fix them at "
            "compile time, or give it outputSpace() with a function such as CountFrom"
        );
        auto const space =
            outputSpace(internal::LinearPerRepetition<typename ColumnsType::FirstEachPath, ColumnsType::Rows>{});
        using Set = internal::PolicySet<decltype(read), decltype(space), std::remove_cvref_t<Policies>...>;
        static_assert(internal::checkMeasurementFunction<Function, Set>());
        return MeasurementFunction<Function, decltype(read), decltype(space), std::remove_cvref_t<Policies>...>{
            Function{std::move(columns)},
            read,
            space,
            std::forward<Policies>(policies)...
        };
    }
    else
    {
        using Set = internal::PolicySet<decltype(read), std::remove_cvref_t<Policies>...>;
        static_assert(internal::checkMeasurementFunction<Function, Set>());
        return MeasurementFunction<Function, decltype(read), std::remove_cvref_t<Policies>...>{
            Function{std::move(columns)},
            read,
            std::forward<Policies>(policies)...
        };
    }
}

template <internal::ModelPolicy... Policies>
[[nodiscard]] auto
measurementModel(Policies &&... policies)
{
    using Set = internal::PolicySet<std::remove_cvref_t<Policies>...>;
    static_assert(internal::checkMeasurementPolicies<Set>());
    static_assert(
        Set::template has<internal::PolicyKind::logLikelihood>,
        "a measurement model without a function is known by its likelihood alone, so it takes logLikelihood(g)"
    );
    static_assert(
        !Set::template has<internal::PolicyKind::additiveNoise>,
        "a measurement model known by its likelihood alone has no function to add noise to"
    );
    return MeasurementFunction<internal::NoFunction, std::remove_cvref_t<Policies>...>{
        internal::NoFunction{},
        std::forward<Policies>(policies)...
    };
}
 
namespace internal
{

struct NoMethod
{};

struct NoObservation
{};

enum class ArgumentKind
{
    uncertain,  
    sure,       
    form,       
    repair,     
    consider,   
    reference,  
    other       
};

template <typename T>
[[nodiscard]] T const &
inputOf(T const & argument)
{
    return argument;
}

template <typename T>
inline constexpr ArgumentKind argumentKind = [] {
    using Plain = std::remove_cvref_t<T>;
    if constexpr (isSure<Plain>)
    {
        return ArgumentKind::sure;
    }
    else if constexpr (UncertainInput<Plain>)
    {
        return ArgumentKind::uncertain;
    }
    else if constexpr (isLinearizedAbout<Plain>)
    {
        return ArgumentKind::reference;
    }
    else if constexpr (CovarianceUpdate<Plain>)
    {
        return ArgumentKind::form;
    }
    else if constexpr (Repair<Plain>)
    {
        return ArgumentKind::repair;
    }
    else if constexpr (isConsider<Plain>)
    {
        return ArgumentKind::consider;
    }
    else
    {
        return ArgumentKind::other;
    }
}();

template <typename T>
struct InputTagOf
{
    using type = void;  
};

template <typename T>
    requires(argumentKind<T> == ArgumentKind::uncertain || argumentKind<T> == ArgumentKind::sure)
struct InputTagOf<T>
{
    using type =
        typename std::remove_cvref_t<decltype(inputOf(std::declval<std::remove_cvref_t<T> const &>()))>::SpaceType;
};


template <typename T>
using InputTag = typename InputTagOf<T>::type;

template <typename... Args>
[[nodiscard]] consteval bool
checkArguments()
{
    static_assert(
        ((argumentKind<Args> != ArgumentKind::other) && ...),
        "an argument after the observation is an uncertain input over a tagged space, sure<Tag>(value), a covariance "
        "update form such as updates::joseph(), a repair of the innovation covariance such as roots::ridge(), or the "
        "blocks to consider, consider(path<Bias>); after a prediction's step, an uncertain or a sure input, or a "
        "linearizedAbout() reference first"
    );
    static_assert(
        (std::size_t{argumentKind<Args> == ArgumentKind::reference} + ... + 0) <= 1,
        "give the linearizedAbout() reference once"
    );
    static_assert(
        ((argumentKind<Args> != ArgumentKind::uncertain || !IsUntagged<InputTag<Args>>) && ...),
        "an uncertain input is named by the tag of its space, so give it over a tag such as struct SpecificForce : "
        "Linear<3> {}"
    );
    static_assert(
        (std::size_t{argumentKind<Args> == ArgumentKind::form} + ... + 0) <= 1,
        "give the covariance update form once"
    );
    static_assert(
        (std::size_t{argumentKind<Args> == ArgumentKind::repair} + ... + 0) <= 1,
        "give the repair of the innovation covariance once"
    );
    static_assert(
        (std::size_t{argumentKind<Args> == ArgumentKind::consider} + ... + 0) <= 1,
        "give the blocks to consider in one consider()"
    );
    static_assert(
        distinctTypes<
            std::conditional_t<std::is_void_v<InputTag<Args>>, std::type_identity<Args>, InputTag<Args>>...>(),
        "two inputs of the call have one tag; an input's tag names it once"
    );
    return true;
}

template <ArgumentKind K, typename Default, typename... Args>
struct ArgumentOfKindOf
{
    using type = Default;  
};

template <ArgumentKind K, typename Default, typename First, typename... Rest>
struct ArgumentOfKindOf<K, Default, First, Rest...>
{
    using type = std::conditional_t<
        argumentKind<First> == K,
        std::remove_cvref_t<First>,
        typename ArgumentOfKindOf<K, Default, Rest...>::type>;
};


template <ArgumentKind K, typename Default, typename... Args>
using ArgumentOfKind = typename ArgumentOfKindOf<K, Default, Args...>::type;

template <ArgumentKind K, typename Default, typename... Args>
[[nodiscard]] auto const &
argumentOfKind(std::tuple<Args...> const & args, Default const & fallback)
{
    using Result = ArgumentOfKind<K, Default, Args...>;
    constexpr std::size_t position = [] {
        constexpr auto kinds = std::array<ArgumentKind, sizeof...(Args)>{argumentKind<Args>...};
        for (std::size_t i = 0; i < kinds.size(); ++i)
        {
            if (kinds[i] == K)
            {
                return i;
            }
        }
        return sizeof...(Args);
    }();
    if constexpr (position < sizeof...(Args))
    {
        return static_cast<Result const &>(std::get<position>(args));
    }
    else
    {
        return fallback;
    }
}
 
}  // namespace internal

template <typename Method, typename Model, typename Observation, typename... Args>
class Observed
{
public:
 
    using MethodType = Method;                                                      
    using ModelType = std::remove_cvref_t<Model>;                                   
    using ObservationType = Observation;                                            
    using ArgumentsType = std::tuple<Args...>;                                      
    static constexpr bool HasMethod = !std::is_same_v<Method, internal::NoMethod>;  

    static constexpr bool HasObservation = !std::is_same_v<Observation, internal::NoObservation>;

    using FormType = internal::ArgumentOfKind<internal::ArgumentKind::form, updates::Standard, Args...>;

    using InnovationRepair = internal::ArgumentOfKind<internal::ArgumentKind::repair, internal::NoRepair, Args...>;

    using ConsiderType = internal::ArgumentOfKind<internal::ArgumentKind::consider, Consider<>, Args...>;
 
    static_assert(internal::isModel<ModelType>, "an observation is of a model");
    static_assert(internal::checkArguments<Args...>());

    template <typename M, typename Z>
    Observed(Method method, M && model, Z && observation, Args... args)
        : m_method{std::move(method)}
        , m_model(std::forward<M>(model))
        , m_observation{std::forward<Z>(observation)}
        , m_arguments{std::move(args)...}
    {
        if constexpr (HasObservation)
        {
            EMRYS_FILTER_ASSERT(m_observation.cols() == 1 && "an observation is a column vector");
        }
    }

    [[nodiscard]] Method const &
    method() const
    {
        return m_method;
    }

    [[nodiscard]] ModelType const &
    model() const
    {
        return m_model;
    }

    [[nodiscard]] Observation const &
    observation() const
    {
        return m_observation;
    }

    [[nodiscard]] ArgumentsType const &
    arguments() const
    {
        return m_arguments;
    }

    [[nodiscard]] FormType const &
    covarianceUpdate() const
    {
        return internal::argumentOfKind<internal::ArgumentKind::form>(m_arguments, m_standard);
    }
 
private:
 
    EMRYS_FILTER_NO_UNIQUE_ADDRESS Method m_method;               
    Model m_model;                                                
    EMRYS_FILTER_NO_UNIQUE_ADDRESS Observation m_observation;     
    ArgumentsType m_arguments;                                    
    EMRYS_FILTER_NO_UNIQUE_ADDRESS updates::Standard m_standard;  
};
 
namespace internal
{

template <typename T>
inline constexpr bool isObserved = false;

template <typename Method, typename Model, typename Observation, typename... Args>
inline constexpr bool isObserved<Observed<Method, Model, Observation, Args...>>{true};
 
}  // namespace internal

template <typename M>
concept Measurement = internal::isObserved<std::remove_cvref_t<M>> && std::remove_cvref_t<M>::HasObservation;
 
namespace internal
{

template <typename M>
concept WeighsPoints = Measurement<M>;

template <typename M>
inline constexpr bool hasOwnLikelihood = std::remove_cvref_t<M>::ModelType::template has<PolicyKind::logLikelihood>;

template <typename M>
inline constexpr bool hasInnovationRepair =
    !std::is_same_v<typename std::remove_cvref_t<M>::InnovationRepair, NoRepair>;

template <typename M>
inline constexpr bool hasConsider = std::remove_cvref_t<M>::ConsiderType::Count > 0;

template <typename F>
inline constexpr bool isLinearFunction = false;

template <typename Matrix>
inline constexpr bool isLinearFunction<LinearFunction<Matrix>>{true};
 
template <typename... Placed>
inline constexpr bool isLinearFunction<ColumnsFunction<Placed...>>{true};

template <typename Model>
using MethodWithoutOne =
    std::conditional_t<isLinearFunction<typename Model::FunctionType>, methods::Linearized, NoMethod>;
 
}  // namespace internal

template <TransformMethod Method, typename M, MatrixExpression Z, typename... Args>
    requires MeasurementModel<std::unwrap_ref_decay_t<M>>
[[nodiscard]] auto
observe(Method method, M && model, Z && observation, Args &&... args)
{
    using Stored = std::unwrap_ref_decay_t<M>;
    using Observation = typename internal::CrtpDerived<Z>::PlainObject;
    return Observed<Method, Stored, Observation, std::unwrap_ref_decay_t<Args>...>{
        std::move(method),
        std::forward<M>(model),
        std::forward<Z>(observation),
        std::forward<Args>(args)...
    };
}

template <typename M, MatrixExpression Z, typename... Args>
    requires MeasurementModel<std::unwrap_ref_decay_t<M>>
[[nodiscard]] auto
observe(M && model, Z && observation, Args &&... args)
{
    using Stored = std::unwrap_ref_decay_t<M>;
    using Observation = typename internal::CrtpDerived<Z>::PlainObject;
    using Method = internal::MethodWithoutOne<Stored>;
    return Observed<Method, Stored, Observation, std::unwrap_ref_decay_t<Args>...>{
        Method{},
        std::forward<M>(model),
        std::forward<Z>(observation),
        std::forward<Args>(args)...
    };
}
 
namespace internal
{

template <typename M, typename... Args>
    requires isModel<std::remove_cvref_t<std::unwrap_ref_decay_t<M>>>
[[nodiscard]] auto
modelWith(M && model, Args &&... args)
{
    using Stored = std::unwrap_ref_decay_t<M>;
    return Observed<NoMethod, Stored, NoObservation, std::unwrap_ref_decay_t<Args>...>{
        NoMethod{},
        std::forward<M>(model),
        NoObservation{},
        std::forward<Args>(args)...
    };
}
 
}  // namespace internal
 
}  // namespace Emrys