Time.h

Go to the documentation of this file.

#pragma once

 
#include <chrono>
#include <concepts>
#include <type_traits>
 
#include <Eigen/Core>
 
#include <EmrysFilter/Core/Macros.h>
 
namespace Emrys
{


template <typename Time>
struct TimeTraits
{};

template <std::floating_point Time>
struct TimeTraits<Time>
{
    template <typename Scalar>
    [[nodiscard]] static Scalar
    toScalar(Time t)
    {
        return Scalar(t);
    }
};

template <typename Rep, typename Period>
struct TimeTraits<std::chrono::duration<Rep, Period>>
{
    template <typename Scalar>
    [[nodiscard]] static Scalar
    toScalar(std::chrono::duration<Rep, Period> const & t)
    {
        // Through the scalar's literal type, the plain number an autodiff scalar is built from, so
        // that the integer's conversion is explicit there too.
        using Real = typename Eigen::NumTraits<Scalar>::Literal;
        Scalar const count = Scalar(Real(t.count()));
        Scalar const numerator = Scalar(Real(Period::num));
        Scalar const denominator = Scalar(Real(Period::den));
        if constexpr (Period::num == 1 && Period::den == 1)
        {
            return count;
        }
        else if constexpr (Period::num == 1)
        {
            return Scalar(count / denominator);
        }
        else if constexpr (Period::den == 1)
        {
            return Scalar(count * numerator);
        }
        else
        {
            return Scalar(Scalar(count * numerator) / denominator);
        }
    }
};

template <typename Time, typename Scalar>
concept TimeStep = std::same_as<std::remove_cvref_t<Time>, Scalar> || requires(std::remove_cvref_t<Time> const & t) {
    { TimeTraits<std::remove_cvref_t<Time>>::template toScalar<Scalar>(t) } -> std::same_as<Scalar>;
};

struct Steps
{
    Eigen::Index count;  
};
 
namespace internal
{

template <typename Scalar, typename Time>
    requires TimeStep<Time, Scalar>
[[nodiscard]] Scalar
toScalarTime(Time const & t)
{
    Scalar const step = [&] {
        if constexpr (std::same_as<Time, Scalar>)
        {
            return t;
        }
        else
        {
            return TimeTraits<Time>::template toScalar<Scalar>(t);
        }
    }();
    EMRYS_FILTER_ASSERT(step >= Scalar(0) && "a time step must be nonnegative");
    return step;
}

template <typename... Args>
inline constexpr bool leadsWithSteps = false;

template <typename First, typename... Rest>
inline constexpr bool leadsWithSteps<First, Rest...> = std::same_as<std::remove_cvref_t<First>, Steps>;

template <typename... Args>
inline constexpr bool leadsWithTimeStep = false;

template <typename First, typename... Rest>
inline constexpr bool leadsWithTimeStep<First, Rest...> =
    std::is_arithmetic_v<std::remove_cvref_t<First>> || TimeStep<First, double> || TimeStep<First, float>;

template <typename... Inputs>
consteval void
rejectTimeStep()
{
    static_assert(
        !leadsWithTimeStep<Inputs...>,
        "a fixed-step filter takes its own step: call predict() for one step or predict(Steps{n}) for n, "
        "and give an input by its tag, as sure<Tag>(value) or a distribution over the tag's space"
    );
}
 
}  // namespace internal
 
}  // namespace Emrys