Print.h

Go to the documentation of this file.

#pragma once

 
#include <EmrysFilter/Core/Macros.h>
 
#ifndef EMRYS_FILTER_NO_IO
 
#    include <expected>
#    include <format>
#    include <ostream>
#    include <sstream>
#    include <string>
#    include <string_view>
 
#    include <EmrysFilter/Core/Weights.h>
 
namespace Emrys
{
 
namespace internal
{

struct Indent
{
    int depth = 0;  

    [[nodiscard]] Indent
    deeper() const
    {
        return {depth + 1};
    }
};

inline std::ostream &
operator<<(std::ostream & stream, Indent indent)
{
    for (int i = 0; i < indent.depth; ++i)
    {
        stream << "  ";
    }
    return stream;
}

template <typename T>
concept Printable = requires(std::ostream & stream, T const & value) { describe(stream, value, Indent{}); };

template <typename Derived>
void
printRow(std::ostream & stream, Indent indent, std::string_view label, Eigen::DenseBase<Derived> const & vector)
{
    static auto const row = Eigen::IOFormat{Eigen::StreamPrecision, Eigen::DontAlignCols, " ", " "};
    stream << indent << label << ':';
    if (vector.size() > 0)
    {
        stream << ' ' << vector.reshaped().transpose().format(row);
    }
}

template <typename Derived>
void
printMatrix(std::ostream & stream, Indent indent, std::string_view label, Eigen::DenseBase<Derived> const & matrix)
{
    stream << indent << label << ':';
    if (matrix.size() > 0)
    {
        auto prefix = std::ostringstream{};
        prefix << indent.deeper();
        auto const rows = Eigen::IOFormat{Eigen::StreamPrecision, 0, " ", "\n", prefix.str()};
        stream << '\n' << matrix.format(rows);
    }
}

inline void
printDimension(std::ostream & stream, Eigen::Index valueDimension, Eigen::Index differenceDimension)
{
    stream << " of dimension " << valueDimension;
    if (differenceDimension != valueDimension)
    {
        stream << " (" << differenceDimension << " in differences)";
    }
}

inline void
printCount(std::ostream & stream, Eigen::Index count, std::string_view noun)
{
    stream << count << ' ' << noun << (count == 1 ? "" : "s");
}

template <typename M>
void
printMoments(std::ostream & stream, Indent indent, M const & moments)
{
    stream << '\n';
    printRow(stream, indent, "mean", moments.mean());
    stream << '\n';
    printMatrix(stream, indent, "covariance", moments.covarianceLower());
}

template <typename M, typename E>
void
printMoments(std::ostream & stream, Indent indent, std::expected<M, E> const & moments)
{
    if (moments)
    {
        printMoments(stream, indent, *moments);
    }
    else
    {
        stream << '\n' << indent << "no moments: ";
        describe(stream, moments.error(), Indent{});
    }
}

template <typename State>
void
describeFilter(std::ostream & stream, std::string_view name, State const & state, Indent indent)
{
    stream << indent << name << '\n';
    describe(stream, state, indent.deeper());
}

inline void
describe(std::ostream & stream, NumericError error, Indent indent)
{
    stream << indent;
    switch (error)
    {
        case NumericError::NotPositiveDefinite:
            stream << "the covariance is not positive definite";
            break;
        case NumericError::Singular:
            stream << "the precision is singular";
            break;
        case NumericError::NonFinite:
            stream << "a value is not finite";
            break;
        case NumericError::Empty:
            stream << "no weights";
            break;
        case NumericError::ZeroSum:
            stream << "every weight is zero";
            break;
    }
}
 
}  // namespace internal

template <internal::Printable T>
std::ostream &
operator<<(std::ostream & stream, T const & value)
{
    describe(stream, value, internal::Indent{});
    return stream;
}
 
}  // namespace Emrys

template <Emrys::internal::Printable T>
struct std::formatter<T, char> : std::formatter<std::string_view, char>
{
    template <typename ParseContext>
    constexpr typename ParseContext::iterator
    parse(ParseContext & context)
    {
        auto const begin = context.begin();
        auto end = begin;
        while (end != context.end() && *end != '}')
        {
            ++end;
        }
        auto const spec = std::string_view{begin, end};
        // The spec without a trailing type s, which is a string's default.
        auto const body = spec.ends_with('s') ? spec.substr(0, spec.size() - 1) : spec;
        // A precision is a '.' and the digits after it, at the end. A '.' as the fill is followed
        // by an alignment, so a '.' just before the last digits is always the precision.
        auto digits = body.size();
        while (digits > 0 && body[digits - 1] >= '0' && body[digits - 1] <= '9')
        {
            --digits;
        }
        if (digits == body.size() || digits == 0 || body[digits - 1] != '.')
        {
            return std::formatter<std::string_view, char>::parse(context);
        }
        int precision = 0;
        for (char const digit : body.substr(digits))
        {
            precision = precision * 10 + (digit - '0');
        }
        m_precision = precision;
        // The string's part, the spec before the precision, parsed on its own.
        auto rest = std::format_parse_context{body.substr(0, digits - 1)};
        std::formatter<std::string_view, char>::parse(rest);
        return end;
    }

    template <typename Context>
    [[nodiscard]] typename Context::iterator
    format(T const & value, Context & context) const
    {
        auto stream = std::ostringstream{};
        if (m_precision >= 0)
        {
            stream.precision(m_precision);
        }
        stream << value;
        return std::formatter<std::string_view, char>::format(stream.str(), context);
    }
 
private:
 
    int m_precision = -1;  
};
 
#endif  // EMRYS_FILTER_NO_IO