is_uniform_pattern_component_of.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) 2020-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_IS_UNIFORM_COMPONENT_OF_HPP
#define OPENKALMAN_IS_UNIFORM_COMPONENT_OF_HPP

#include "collections/collections.hpp"
#include "coordinates/concepts/pattern.hpp"
#include "coordinates/concepts/uniform_pattern.hpp"
#include "coordinates/concepts/compares_with.hpp"
#include "coordinates/traits/uniform_pattern_type.hpp"
#include "coordinates/concepts/uniform_pattern.hpp"
#include "coordinates/functions/compare.hpp"

namespace OpenKalman::coordinates
{
#ifdef __cpp_concepts
  template<pattern A, pattern B>
  constexpr OpenKalman::internal::boolean_testable auto
#else
  template<typename A, typename B, std::enable_if_t<pattern<A> and pattern<B>, int> = 0>
  constexpr auto
#endif
  is_uniform_pattern_component_of(const A& a, const B& b)
  {
    if constexpr (not uniform_pattern<B, applicability::permitted>)
    {
      return std::false_type {};
    }
    else if constexpr (euclidean_pattern<B>)
    {
      return compare(a, Dimensions<1>{});;
    }
    else
    {
      using C = common_descriptor_type_t<B>;
      if constexpr (compares_with<A, C, &stdex::is_eq, applicability::guaranteed>)
      {
        return values::operation(std::equal_to{}, get_dimension(a), std::integral_constant<std::size_t, 1>{});
      }
      else if constexpr (compares_with<A, C, &stdex::is_neq, applicability::guaranteed> or
        (dimension_of_v<C> != stdex::dynamic_extent and dimension_of_v<C> != 1))
      {
        return std::false_type {};
      }
      else if (get_dimension(a) != 1)
      {
        return false;
      }
      else if (get_is_euclidean(b))
      {
        return get_is_euclidean(a);
      }
      else
      {
        if constexpr (descriptor<B>)
        {
          return compare(a, b);
        }
        else
        {
          for (const auto& x : collections::views::all(b))
          {
            if (get_dimension(x) == 0) continue;
            if (get_is_euclidean(x) and get_is_euclidean(a)) continue;
            if (not compare(a, x)) return false;
          }
          return true;
        }
      }
    }
  }

}

#endif