Moments.h

Go to the documentation of this file.

#pragma once

 
#include <type_traits>
 
#include <EmrysFilter/Core/Forwarding.h>
#include <EmrysFilter/Core/Macros.h>
#include <EmrysFilter/Core/Math.h>
#include <EmrysFilter/Core/Print.h>
#include <EmrysFilter/Spaces/Space.h>
#include <EmrysFilter/Spaces/TagPath.h>
 
namespace Emrys
{

template <typename X>
using ScalarOf = typename std::remove_cvref_t<X>::Scalar;

enum class MomentsError
{
    Infinite,  
};

template <Space Space_, RealScalar Scalar_ = double>
class Moments
{
public:
 
    using Scalar = Scalar_;      
    using Index = Eigen::Index;  
    using SpaceType = Space_;    

    static constexpr int ValueDimensionAtCompileTime = valueDimensionAtCompileTime<Space_>;

    static constexpr int MaxValueDimensionAtCompileTime = maxValueDimensionAtCompileTime<Space_>;

    static constexpr int DifferenceDimensionAtCompileTime = valueDimensionAtCompileTime<DifferenceSpace<Space_>>;

    static constexpr int MaxDifferenceDimensionAtCompileTime = maxValueDimensionAtCompileTime<DifferenceSpace<Space_>>;
 
    using VectorType = ValueVector<Space_, Scalar>;                 
    using DifferenceVectorType = DifferenceVector<Space_, Scalar>;  
    using MatrixType = DifferenceMatrix<Space_, Space_, Scalar>;  
 
    Moments() = default;

    Moments(Index valueDimension, Index differenceDimension)
    {
        resize(valueDimension, differenceDimension);
    }

    explicit Moments(Space_ const & space)
        : Moments{Emrys::valueDimension(space), Emrys::differenceDimension(space)}
    {}

    template <MatrixExpression Mean, CovarianceExpression Cov>
    Moments(Mean && mean, Cov && cov)
        : m_mean{std::forward<Mean>(mean)}
        , m_cov{std::forward<Cov>(cov)}
    {
        EMRYS_FILTER_ASSERT(m_cov.rows() == m_cov.cols() && "the covariance must be square");
        EMRYS_FILTER_ASSERT(
            (!internal::hasEqualSizes<Space_> || m_cov.rows() == m_mean.size())
            && "the covariance must have a row per coordinate of the mean"
        );
    }

    [[nodiscard]] Index
    valueDimension() const
    {
        return m_mean.size();
    }

    [[nodiscard]] Index
    differenceDimension() const
    {
        return m_cov.rows();
    }

    void
    resize(Index valueDimension, Index differenceDimension)
    {
        m_mean.resize(valueDimension);
        m_cov.resize(differenceDimension, differenceDimension);
    }

    void
    resize(Space_ const & space)
    {
        resize(Emrys::valueDimension(space), Emrys::differenceDimension(space));
    }

    [[nodiscard]] VectorType const &
    mean() const
    {
        return m_mean;
    }

    [[nodiscard]] MatrixType const &
    covarianceLower() const
    {
        return m_cov;
    }

    [[nodiscard]] VectorType &
    mean()
    {
        return m_mean;
    }

    [[nodiscard]] MatrixType &
    covarianceLower()
    {
        return m_cov;
    }

    template <typename Path>
    [[nodiscard]] auto
    mean() const
    {
        return m_mean(idx<Space_, Path>());
    }

    template <typename Path>
    [[nodiscard]] auto
    covarianceLower() const
    {
        return m_cov(diffIdx<Space_, Path>(), diffIdx<Space_, Path>());
    }

    template <typename RowPath, typename ColPath>
    [[nodiscard]] auto
    covarianceLower() const
    {
        return m_cov(diffIdx<Space_, RowPath>(), diffIdx<Space_, ColPath>());
    }

    template <typename Path>
    [[nodiscard]] decltype(auto)
    mean()
    {
        return m_mean(idx<Space_, Path>());
    }

    template <typename Path>
    [[nodiscard]] decltype(auto)
    covarianceLower()
    {
        return m_cov(diffIdx<Space_, Path>(), diffIdx<Space_, Path>());
    }
 
private:
 
    VectorType m_mean;  
    MatrixType m_cov;   
};
 
}  // namespace Emrys
 
#ifndef EMRYS_FILTER_NO_IO
 
namespace Emrys
{
 
namespace internal
{

inline void
describe(std::ostream & stream, MomentsError error, Indent indent)
{
    stream << indent;
    switch (error)
    {
        case MomentsError::Infinite:
            stream << "the moments are infinite";
            break;
    }
}

template <typename Space_, typename Scalar_>
void
describe(std::ostream & stream, Moments<Space_, Scalar_> const & moments, Indent indent)
{
    stream << indent << "moments";
    printDimension(stream, moments.valueDimension(), moments.differenceDimension());
    printMoments(stream, indent.deeper(), moments);
}
 
}  // namespace internal
 
}  // namespace Emrys
 
#endif  // EMRYS_FILTER_NO_IO