Dimensions.hpp

Go to the documentation of this file.

/* This file is part of OpenKalman, a header-only C++ library for
 * Kalman filters and other recursive filters.
 *
 * Copyright (c) 2022-2025 Christopher Lee Ogden <ogden@gatech.edu>
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

#ifndef OPENKALMAN_DIMENSIONS_HPP
#define OPENKALMAN_DIMENSIONS_HPP

#include <cstddef>
#include "collections/collections.hpp"
#include "coordinates/interfaces/coordinate_descriptor_traits.hpp"
#include "coordinates/concepts/fixed_pattern.hpp"
#include "coordinates/concepts/dynamic_pattern.hpp"
#include "coordinates/concepts/euclidean_pattern.hpp"
#include "coordinates/traits/dimension_of.hpp"
#include "coordinates/functions/get_dimension.hpp"
#include "Any.hpp"

namespace OpenKalman::coordinates
{
  // ------------ //
  //  fixed case  //
  // ------------ //

  template<std::size_t N = stdex::dynamic_extent>
  struct Dimensions
  {
    constexpr Dimensions() = default;


#ifdef __cpp_concepts
    template<euclidean_pattern D> requires
      (dimension_of<D>::value == N) and
      (not std::same_as<D, Dimensions>)
#else
    template<typename D, std::enable_if_t<
      euclidean_pattern<D> and
      values::fixed_value_compares_with<dimension_of<D>, N> and
      not std::is_same_v<D, Dimensions>, int> = 0>
#endif
    constexpr Dimensions(const D&) {}


    template<typename Int>
    explicit constexpr operator std::integral_constant<Int, N>()
    {
      return std::integral_constant<Int, N>{};
    }


#ifdef __cpp_concepts
    template<std::integral Int>
#else
    template<typename Int, std::enable_if_t<std::is_integral_v<Int>, int> = 0>
#endif
    explicit constexpr operator Int()
    {
      return N;
    }

  }; // struct Dimensions, static case


  // -------------- //
  //  dynamic case  //
  // -------------- //

  template<>
  struct Dimensions<stdex::dynamic_extent>
  {
#ifdef __cpp_concepts
    template<euclidean_pattern D> requires (not std::same_as<D, Dimensions>)
#else
    template<typename D, std::enable_if_t<euclidean_pattern<D> and (not std::is_same_v<Dimensions, D>), int> = 0>
#endif
    constexpr Dimensions(const D& d) : runtime_size {get_dimension(d)}
    {}


    constexpr Dimensions(const std::size_t& d = 0) : runtime_size {static_cast<std::size_t>(d)}
    {}


#ifdef __cpp_concepts
    template<euclidean_pattern D> requires (not std::same_as<D, Dimensions>)
#else
    template<typename D, std::enable_if_t<euclidean_pattern<D> and (not std::is_same_v<D, Dimensions>), int> = 0>
#endif
    constexpr Dimensions& operator=(const D& d)
    {
      runtime_size = get_dimension(d);
      return *this;
    }


#ifdef __cpp_concepts
    template<std::integral Int>
#else
    template<typename Int, std::enable_if_t<std::is_integral_v<Int>, int> = 0>
#endif
    explicit constexpr operator Int()
    {
      return runtime_size;
    }

  protected:

    std::size_t runtime_size;

    friend struct interface::coordinate_descriptor_traits<Dimensions>;
  };


  // ------------------ //
  //  deduction guides  //
  // ------------------ //

#ifdef __cpp_concepts
  template<fixed_pattern D> requires euclidean_pattern<D>
#else
  template<typename D, std::enable_if_t<fixed_pattern<D> and euclidean_pattern<D>, int> = 0>
#endif
  explicit Dimensions(D&&) -> Dimensions<dimension_of<D>::value>;


#ifdef __cpp_concepts
  template<dynamic_pattern D> requires euclidean_pattern<D>
#else
  template<typename D, std::enable_if_t<dynamic_pattern<D> and euclidean_pattern<D>, int> = 0>
#endif
  explicit Dimensions(D&&) -> Dimensions<stdex::dynamic_extent>;


  explicit Dimensions(const std::size_t&) -> Dimensions<stdex::dynamic_extent>;


  // ------ //
  //  Axis  //
  // ------ //

  using Axis = Dimensions<1>;

}


namespace OpenKalman::interface
{
  template<std::size_t N>
  struct coordinate_descriptor_traits<coordinates::Dimensions<N>>
  {
  private:

    using T = coordinates::Dimensions<N>;

  public:

    static constexpr bool is_specialized = true;


    static constexpr auto
    dimension = [](const T& t)
    {
      if constexpr (N == stdex::dynamic_extent) return t.runtime_size;
      else return std::integral_constant<std::size_t, N>{};
    };


    static constexpr auto
    stat_dimension = [](const T& t) { return dimension(t); };


    static constexpr auto
    is_euclidean = [](const T&) { return std::true_type{}; };


    static constexpr auto
    hash_code = [](const T& t)
    {
      if constexpr (N == stdex::dynamic_extent)
        return static_cast<std::size_t>(t.runtime_size);
      else
        return std::integral_constant<std::size_t, N>{};
    };

  };

}


namespace std
{
  template<std::size_t M, std::size_t N>
  struct common_type<OpenKalman::coordinates::Dimensions<M>, OpenKalman::coordinates::Dimensions<N>>
  {
    using type = OpenKalman::coordinates::Dimensions<M == N ? N : OpenKalman::stdex::dynamic_extent>;
  };


  template<std::size_t N, typename T>
  struct common_type<OpenKalman::coordinates::Dimensions<N>, T>
    : std::conditional_t<
      OpenKalman::coordinates::descriptor<T>,
      std::conditional<OpenKalman::coordinates::euclidean_pattern<T>,
        OpenKalman::coordinates::Dimensions<N == OpenKalman::coordinates::dimension_of_v<T> ? N : OpenKalman::stdex::dynamic_extent>,
        OpenKalman::coordinates::Any<>>,
      std::monostate> {};


  template<std::size_t N, typename Scalar>
  struct common_type<OpenKalman::coordinates::Dimensions<N>, OpenKalman::coordinates::Any<Scalar>>
  {
    using type = OpenKalman::coordinates::Any<Scalar>;
  };


  template<std::size_t N, typename Scalar>
  struct common_type<OpenKalman::coordinates::Any<Scalar>, OpenKalman::coordinates::Dimensions<N>>
  {
    using type = OpenKalman::coordinates::Any<Scalar>;
  };


#ifdef __cpp_concepts
  template<OpenKalman::coordinates::euclidean_pattern T, std::size_t N>
  struct common_type<T, OpenKalman::coordinates::Dimensions<N>> : common_type<OpenKalman::coordinates::Dimensions<N>, T> {};
#endif
}

#ifndef __cpp_concepts
#define OPENKALMAN_INDEX_STD_COMMON_TYPE_SPECIALIZATION(I)          \
namespace std                                                       \
{                                                                   \
  template<std::size_t N>                                           \
  struct common_type<I, OpenKalman::coordinates::Dimensions<N>>     \
    : common_type<OpenKalman::coordinates::Dimensions<N>, I> {};    \
}

OPENKALMAN_INDEX_STD_COMMON_TYPE_SPECIALIZATION(unsigned char)
OPENKALMAN_INDEX_STD_COMMON_TYPE_SPECIALIZATION(unsigned short)
OPENKALMAN_INDEX_STD_COMMON_TYPE_SPECIALIZATION(unsigned int)
OPENKALMAN_INDEX_STD_COMMON_TYPE_SPECIALIZATION(unsigned long)
OPENKALMAN_INDEX_STD_COMMON_TYPE_SPECIALIZATION(unsigned long long)

namespace std
{
  template<typename T, auto M, std::size_t N>
  struct common_type<std::integral_constant<T, M>, OpenKalman::coordinates::Dimensions<N>>
    : common_type<OpenKalman::coordinates::Dimensions<N>, std::integral_constant<T, M>> {};


  template<typename T, auto...M, std::size_t N>
  struct common_type<OpenKalman::values::fixed_value<T, M...>, OpenKalman::coordinates::Dimensions<N>>
    : common_type<OpenKalman::coordinates::Dimensions<N>, OpenKalman::values::fixed_value<T, M...>> {};


  template<typename...Args, std::size_t N>
  struct common_type<OpenKalman::values::consteval_operation<Args...>, OpenKalman::coordinates::Dimensions<N>>
    : common_type<OpenKalman::coordinates::Dimensions<N>, OpenKalman::values::consteval_operation<Args...>> {};
}
#endif


#endif