forward-class-declarations.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) 2019-2024 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_FORWARD_CLASS_DECLARATIONS_HPP
#define OPENKALMAN_FORWARD_CLASS_DECLARATIONS_HPP

#include <type_traits>
#include <random>
#include "basics/traits/traits.hpp"

namespace OpenKalman
{
  // ----------------- //
  //  ConstantAdapter  //
  // ----------------- //

#ifdef __cpp_concepts
  template<indexible PatternMatrix, values::scalar Scalar = scalar_type_of_t<PatternMatrix>, auto...constant>
    requires (sizeof...(constant) == 0) or requires { Scalar {constant...}; }
#else
  template<typename PatternMatrix, typename Scalar = scalar_type_of_t<PatternMatrix>, auto...constant>
#endif
  struct ConstantAdapter;


  // ------------------ //
  //  constant_adapter  //
  // ------------------ //

  namespace detail
  {
    template<typename T>
    struct is_constant_adapter : std::false_type {};

    template<typename PatternMatrix, typename Scalar, auto...constant>
    struct is_constant_adapter<ConstantAdapter<PatternMatrix, Scalar, constant...>> : std::true_type {};
  }


  template<typename T>
#ifdef __cpp_concepts
  concept constant_adapter = detail::is_constant_adapter<std::decay_t<T>>::value;
#else
  constexpr bool constant_adapter = detail::is_constant_adapter<std::decay_t<T>>::value;
#endif


  // ------------- //
  //  ZeroAdapter  //
  // ------------- //

#ifdef __cpp_concepts
  template<indexible PatternObject, values::number Scalar = scalar_type_of_t<PatternObject>>
#else
  template<typename PatternObject, typename Scalar = scalar_type_of_t<PatternObject>>
#endif
  using ZeroAdapter = ConstantAdapter<PatternObject, Scalar, 0>;


  // ---------------------------------------- //
  //  pattern_matrix_of, pattern_matrix_of_t  //
  // ---------------------------------------- //

#ifdef __cpp_concepts
  template<typename T>
#else
  template<typename T, typename = void>
#endif
  struct pattern_matrix_of;

  template<typename PatternMatrix, typename Scalar, auto...constant>
  struct pattern_matrix_of<ConstantAdapter<PatternMatrix, Scalar, constant...>> { using type = PatternMatrix; };


#ifdef __cpp_concepts
  template<has_nested_object T>
  struct pattern_matrix_of<T> { using type = nested_object_of_t<T>; };
#else
  template<typename T>
  struct pattern_matrix_of<T, std::enable_if_t<has_nested_object<T>>> { using type = nested_object_of_t<T>; };
#endif


  template<typename T>
  using pattern_matrix_of_t = typename pattern_matrix_of<std::decay_t<T>>::type;


  // ------------------------------------------ //
  //  DiagonalAdapter, internal::diagonal_expr  //
  // ------------------------------------------ //

#ifdef __cpp_concepts
  template<vector<0, Applicability::permitted> NestedMatrix>
#else
  template<typename NestedMatrix>
#endif
  struct DiagonalAdapter;


  namespace internal
  {
    namespace detail
    {
      template<typename T>
      struct is_diagonal_expr : std::false_type {};

      template<typename NestedMatrix>
      struct is_diagonal_expr<DiagonalAdapter<NestedMatrix>> : std::true_type {};
    }


    template<typename T>
#ifdef __cpp_concepts
    concept diagonal_expr = detail::is_diagonal_expr<std::decay_t<T>>::value;
#else
    constexpr bool diagonal_expr = detail::is_diagonal_expr<std::decay_t<T>>::value;
#endif
  } // namespace internal


  // -------------------------------------------- //
  //  HermitianAdapter, internal::hermitian_expr  //
  // -------------------------------------------- //

#ifdef __cpp_concepts
  template<square_shaped<Applicability::permitted> NestedMatrix, HermitianAdapterType storage_triangle =
      triangular_matrix<NestedMatrix, TriangleType::diagonal> ? HermitianAdapterType::lower :
      triangular_matrix<NestedMatrix, TriangleType::upper> ? HermitianAdapterType::upper : HermitianAdapterType::lower> requires
    (index_count_v<NestedMatrix> <= 2) and
    (storage_triangle == HermitianAdapterType::lower or storage_triangle == HermitianAdapterType::upper) and
    (not constant_matrix<NestedMatrix> or values::not_complex<constant_coefficient<NestedMatrix>>) and
    (not constant_diagonal_matrix<NestedMatrix> or values::not_complex<constant_diagonal_coefficient<NestedMatrix>>) and
    (not triangular_matrix<NestedMatrix, TriangleType::any> or triangular_matrix<NestedMatrix, static_cast<TriangleType>(storage_triangle)>)
#else
  template<typename NestedMatrix, HermitianAdapterType storage_triangle =
    triangular_matrix<NestedMatrix, TriangleType::diagonal> ? HermitianAdapterType::lower :
    triangular_matrix<NestedMatrix, TriangleType::upper> ? HermitianAdapterType::upper : HermitianAdapterType::lower>
#endif
  struct HermitianAdapter;


  namespace internal
  {
    namespace detail
    {
      template<typename T>
      struct is_hermitian_expr : std::false_type {};

      template<typename NestedMatrix, HermitianAdapterType storage_triangle>
      struct is_hermitian_expr<HermitianAdapter<NestedMatrix, storage_triangle>> : std::true_type {};
    }


    template<typename T>
#ifdef __cpp_concepts
    concept hermitian_expr = detail::is_hermitian_expr<std::decay_t<T>>::value;
#else
    constexpr bool hermitian_expr = detail::is_hermitian_expr<std::decay_t<T>>::value;
#endif
  } // namespace internal


  // ---------------------------------------------- //
  //  TriangularAdapter, internal::triangular_expr  //
  // ---------------------------------------------- //

#ifdef __cpp_concepts
  template<
    square_shaped<Applicability::permitted> NestedMatrix,
    TriangleType triangle_type = (diagonal_matrix<NestedMatrix> ? TriangleType::diagonal :
      (triangular_matrix<NestedMatrix, TriangleType::upper> ? TriangleType::upper : TriangleType::lower))>
    requires (index_count_v<NestedMatrix> <= 2)
#else
  template<typename NestedMatrix, TriangleType triangle_type = (diagonal_matrix<NestedMatrix> ? TriangleType::diagonal :
    (triangular_matrix<NestedMatrix, TriangleType::upper> ? TriangleType::upper : TriangleType::lower))>
#endif
  struct TriangularAdapter;


  namespace internal
  {
    namespace detail
    {
      template<typename T>
      struct is_triangular_expr : std::false_type {};

      template<typename NestedMatrix, TriangleType triangle_type>
      struct is_triangular_expr<TriangularAdapter<NestedMatrix, triangle_type>> : std::true_type {};
    }


    template<typename T>
#ifdef __cpp_concepts
    concept triangular_expr = detail::is_triangular_expr<std::decay_t<T>>::value;
#else
    constexpr bool triangular_expr = detail::is_triangular_expr<std::decay_t<T>>::value;
#endif
  }


  // ------------------------------------------ //
  //  VectorSpaceAdapter; vector_space_adapter  //
  // ------------------------------------------ //

#ifdef __cpp_concepts
  template<indexible NestedObject, pattern_collection Descriptors>
  requires internal::not_more_fixed_than<NestedObject, Descriptors> and (not internal::less_fixed_than<NestedObject, Descriptors>) and
    internal::maybe_same_shape_as_vector_space_descriptors<NestedObject, Descriptors>
#else
  template<typename NestedObject, typename Descriptors>
#endif
  struct VectorSpaceAdapter;

  namespace internal
  {
    namespace detail
    {
      template<typename T>
      struct is_vector_space_adapter : std::false_type {};

      template<typename NestedObject, typename Descriptors>
      struct is_vector_space_adapter<VectorSpaceAdapter<NestedObject, Descriptors>> : std::true_type {};
    } // namespace detail


    template<typename T>
#ifdef __cpp_concepts
    concept vector_space_adapter =
#else
    constexpr bool vector_space_adapter =
#endif
      detail::is_vector_space_adapter<std::decay_t<T>>::value;

  } // namespace internal


  // -------------------------------------------------------- //
  //  FromEuclideanExpr, from_euclidean_expr, euclidean_expr  //
  // -------------------------------------------------------- //

#ifdef __cpp_concepts
  template<indexible NestedObject, coordinates::pattern RowDescriptor> requires
    compares_with<vector_space_descriptor_of<NestedObject, 0>, coordinates::Dimensions<coordinates::stat_dimension_of_v<RowDescriptor>>, equal_to<>, Applicability::permitted>
#else
  template<typename NestedMatrix, typename RowDescriptor>
#endif
  struct FromEuclideanExpr;


  namespace detail
  {
    template<typename T>
    struct is_from_euclidean_expr : std::false_type {};

    template<typename NestedMatrix, typename D>
    struct is_from_euclidean_expr<FromEuclideanExpr<NestedMatrix, D>> : std::true_type {};
  }


  template<typename T>
#ifdef __cpp_concepts
  concept from_euclidean_expr = detail::is_from_euclidean_expr<std::decay_t<T>>::value;
#else
  constexpr bool from_euclidean_expr = detail::is_from_euclidean_expr<std::decay_t<T>>::value;
#endif


  // ------------------------------------ //
  //  ToEuclideanExpr, to_euclidean_expr  //
  // ------------------------------------ //

#ifdef __cpp_concepts
  template<indexible NestedObject> requires (not from_euclidean_expr<NestedObject>)
#else
  template<typename NestedObject>
#endif
  struct ToEuclideanExpr;


  namespace detail
  {
    template<typename T>
    struct is_to_euclidean_expr : std::false_type {};

    template<typename NestedObject>
    struct is_to_euclidean_expr<ToEuclideanExpr<NestedObject>> : std::true_type {};
  }


  template<typename T>
#ifdef __cpp_concepts
  concept to_euclidean_expr = detail::is_to_euclidean_expr<std::decay_t<T>>::value;
#else
  constexpr bool to_euclidean_expr = detail::is_to_euclidean_expr<std::decay_t<T>>::value;
#endif


  template<typename T>
#ifdef __cpp_concepts
  concept euclidean_expr = to_euclidean_expr<T> or from_euclidean_expr<T>;
#else
  constexpr bool euclidean_expr = from_euclidean_expr<T> or to_euclidean_expr<T>;
#endif


  // --------------------- //
  //  Deprecated adapters  //
  // --------------------- //

#ifdef __cpp_concepts
  template<fixed_pattern RowCoefficients, fixed_pattern ColumnCoefficients, typed_matrix_nestable NestedMatrix>
  requires (coordinates::dimension_of_v<RowCoefficients> == index_dimension_of_v<NestedMatrix, 0>) and
    (coordinates::dimension_of_v<ColumnCoefficients> == index_dimension_of_v<NestedMatrix, 1>) and
    (not std::is_rvalue_reference_v<NestedMatrix>) and
    (dynamic_pattern<RowCoefficients> == dynamic_dimension<NestedMatrix, 0>) and
    (dynamic_pattern<ColumnCoefficients> == dynamic_dimension<NestedMatrix, 1>)
#else
  template<typename RowCoefficients, typename ColumnCoefficients, typename NestedMatrix>
#endif
  struct Matrix;


  namespace internal
  {
    template<typename RowCoefficients, typename ColumnCoefficients, typename NestedMatrix>
    struct is_matrix<Matrix<RowCoefficients, ColumnCoefficients, NestedMatrix>> : std::true_type {};
  }


#ifdef __cpp_concepts
  template<fixed_pattern Descriptor, typed_matrix_nestable NestedMatrix> requires
  (coordinates::dimension_of_v<Descriptor> == index_dimension_of_v<NestedMatrix, 0>) and
  (not std::is_rvalue_reference_v<NestedMatrix>)
#else
  template<typename Descriptor, typename NestedMatrix>
#endif
  struct Mean;


  namespace internal
  {
    template<typename Descriptor, typename NestedMatrix>
    struct is_mean<Mean<Descriptor, NestedMatrix>> : std::true_type {};
  }


#ifdef __cpp_concepts
  template<fixed_pattern Descriptor, typed_matrix_nestable NestedMatrix> requires
  (coordinates::stat_dimension_of_v<Descriptor> == index_dimension_of_v<NestedMatrix, 0>) and (not std::is_rvalue_reference_v<NestedMatrix>)
#else
  template<typename Descriptor, typename NestedMatrix>
#endif
  struct EuclideanMean;


  namespace internal
  {
    template<typename Descriptor, typename NestedMatrix>
    struct is_euclidean_mean<EuclideanMean<Descriptor, NestedMatrix>> : std::true_type {};
  }


#ifdef __cpp_concepts
  template<fixed_pattern Descriptor, covariance_nestable NestedMatrix> requires
    (coordinates::dimension_of_v<Descriptor> == index_dimension_of_v<NestedMatrix, 0>) and
    (not std::is_rvalue_reference_v<NestedMatrix>) and values::number<scalar_type_of_t<NestedMatrix>>
#else
  template<typename Descriptor, typename NestedMatrix>
#endif
  struct Covariance;


  namespace internal
  {
    template<typename Descriptor, typename NestedMatrix>
    struct is_self_adjoint_covariance<Covariance<Descriptor, NestedMatrix>> : std::true_type {};
  }


#ifdef __cpp_concepts
  template<fixed_pattern Descriptor, covariance_nestable NestedMatrix> requires
    (coordinates::dimension_of_v<Descriptor> == index_dimension_of_v<NestedMatrix, 0>) and
    (not std::is_rvalue_reference_v<NestedMatrix>) and values::number<scalar_type_of_t<NestedMatrix>>
#else
  template<typename Descriptor, typename NestedMatrix>
#endif
  struct SquareRootCovariance;


  // ------------------- //
  //  Internal adapters  //
  // ------------------- //

  namespace internal
  {
  #ifdef __cpp_concepts
    template<indexible NestedObject, indexible LibraryObject>
  #else
    template<typename NestedObject, typename LibraryObject>
  #endif
    struct LibraryWrapper;


    namespace detail
    {
      template<typename T>
      struct is_library_wrapper : std::false_type {};

      template<typename N, typename L>
      struct is_library_wrapper<internal::LibraryWrapper<N, L>> : std::true_type {};
    } // namespace detail


    template<typename T>
#ifdef __cpp_concepts
    concept library_wrapper =
#else
    constexpr bool library_wrapper =
#endif
      detail::is_library_wrapper<std::decay_t<T>>::value;


  #ifdef __cpp_concepts
    template<indexible NestedObject, pattern_tuple Descriptors> requires
      compatible_with_vector_space_descriptor_collection<NestedObject, Descriptors> and
      internal::not_more_fixed_than<NestedObject, Descriptors> and internal::less_fixed_than<NestedObject, Descriptors>
  #else
    template<typename NestedObject, typename Descriptors>
  #endif
    struct FixedSizeAdapter;


  namespace detail
  {
    template<typename T>
    struct is_fixed_size_adapter : std::false_type {};

    template<typename NestedMatrix, typename Descriptors>
    struct is_fixed_size_adapter<FixedSizeAdapter<NestedMatrix, Descriptors>> : std::true_type {};
  }


  template<typename T>
#ifdef __cpp_concepts
  concept fixed_size_adapter =
#else
  constexpr bool fixed_size_adapter =
#endif
    detail::is_fixed_size_adapter<std::decay_t<T>>::value;


    template<typename Descriptor, typename NestedMatrix>
    struct is_triangular_covariance<SquareRootCovariance<Descriptor, NestedMatrix>> : std::true_type {};

  } // namespace internal


#ifdef __cpp_concepts
  template<
    fixed_pattern Descriptor,
    typed_matrix_nestable MeanNestedMatrix,
    covariance_nestable CovarianceNestedMatrix,
    std::uniform_random_bit_generator random_number_engine = std::mt19937> requires
      (index_dimension_of_v<MeanNestedMatrix, 0> == index_dimension_of_v<CovarianceNestedMatrix, 0>) and
      (index_dimension_of_v<MeanNestedMatrix, 1> == 1) and
      (std::is_same_v<scalar_type_of_t<MeanNestedMatrix>,
        scalar_type_of_t<CovarianceNestedMatrix>>)
#else
  template<
    typename Descriptor,
    typename MeanNestedMatrix,
    typename CovarianceNestedMatrix,
    typename random_number_engine = std::mt19937>
#endif
  struct GaussianDistribution;


  namespace internal
  {
    template<typename Descriptor, typename MeanNestedMatrix, typename CovarianceNestedMatrix, typename re>
    struct is_gaussian_distribution<GaussianDistribution<Descriptor, MeanNestedMatrix, CovarianceNestedMatrix, re>>
      : std::true_type {};
  }

} // OpenKalman

#endif //OPENKALMAN_FORWARD_CLASS_DECLARATIONS_HPP