entry.hpp

#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <format>
#include <utility>
 
namespace centipede
{
    template <std::size_t NLocals, std::size_t NGlobals>
    struct EntryPoint
    {
        using data_type = float;                                               
        using LocalDerivs = std::array<float, NLocals>;                        
        using GlobalDerivs = std::array<std::pair<uint32_t, float>, NGlobals>; 
        static constexpr std::size_t n_locals = NLocals;                       
        static constexpr std::size_t n_globals = NGlobals;                     
 
        // NOLINTBEGIN (misc-non-private-member-variables-in-classes)
        LocalDerivs local_derivs{};   
        GlobalDerivs global_derivs{}; 
        float measurement{};          
        float sigma{};                
        // NOLINTEND (misc-non-private-member-variables-in-classes)

        constexpr void reset()
        {
            local_derivs = std::array<float, NLocals>{};
            global_derivs = std::array<std::pair<uint32_t, float>, NGlobals>{};
            measurement = float{};
            sigma = float{};
        }

        constexpr auto operator<=>(const EntryPoint<NLocals, NGlobals>& other) const = default;
    };

    template <std::size_t NLocals, std::size_t NGlobals>
    EntryPoint(std::array<float, NLocals>, std::array<std::pair<uint32_t, float>, NGlobals>, float, float)
        -> EntryPoint<NLocals, NGlobals>;
}; // namespace centipede

template <std::size_t NLocals, std::size_t NGlobals>
struct std::formatter<centipede::EntryPoint<NLocals, NGlobals>>
{
    static constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    static auto format(const centipede::EntryPoint<NLocals, NGlobals>& entry, std::format_context& ctx)
    {
        return std::format_to(ctx.out(),
                              "local derivatives: {}, global derivatives: {}, measurement: {}, sigma: {}",
                              entry.local_derivs,
                              entry.global_derivs,
                              entry.measurement,
                              entry.sigma);
    }
};