largest_pattern.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) 2024-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_LARGEST_PATTERN_HPP
#define OPENKALMAN_LARGEST_PATTERN_HPP

#include <algorithm>
#include "collections/collections.hpp"
#include "coordinates/concepts/pattern.hpp"
#include "coordinates/concepts/pattern_collection.hpp"

namespace OpenKalman::coordinates::internal
{
  namespace detail
  {
    template<std::size_t i = 0, typename P,
      typename MI = std::integral_constant<std::size_t, 0>,
      typename Max = std::integral_constant<std::size_t, 0>>
    constexpr auto
    largest_pattern_fixed(const P& p, MI mi = {}, Max max = {})
    {
      if constexpr (i < collections::size_of_v<P>)
      {
        auto ix = std::integral_constant<std::size_t, i>{};
        auto p_i = get_dimension(collections::get<i>(p));
        auto is_new_max = values::operation(std::greater{}, p_i, max);
        auto select = [](bool q, std::size_t curr, std::size_t old){ return q ? curr : old; };
        return largest_pattern_fixed<i + 1>(
          p,
          values::operation(select, is_new_max, ix, mi),
          values::operation(select, is_new_max, p_i, max));
      }
      else
      {
        return mi;
      }
    }
  }


#ifdef __cpp_concepts
  template<pattern_collection P> requires collections::sized<P> and
    (collections::size_of_v<P> == stdex::dynamic_extent or collections::size_of_v<P> > 0_uz)
  constexpr values::index auto
#else
  template<typename P, std::enable_if_t<pattern_collection<P> and collections::sized<P> and
    (collections::size_of<P>::value == stdex::dynamic_extent or collections::size_of<P>::value > 0_uz), int> = 0>
  constexpr auto
#endif
  largest_pattern(const P& p)
  {
    if constexpr (collections::size_of_v<P> == stdex::dynamic_extent)
    {
      auto fn = [](auto a, auto b){ return get_dimension(a) < get_dimension(b); };
      decltype(auto) pr = collections::views::all(p);
#ifdef __cpp_lib_ranges
      auto it = std::ranges::max_element(pr, fn);
#else
      auto it = std::max_element(pr.begin(), pr.end(), fn);
#endif
      return static_cast<std::size_t>(std::distance(pr.begin(), it));
    }
    else
    {
      return detail::largest_pattern_fixed(p);
    }
  }

}

#endif