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 "coordinates/coordinates.hpp"

namespace OpenKalman
{
  // ------------------------------------------ //
  //  diagonal_adapter, internal::diagonal_expr  //
  // ------------------------------------------ //

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


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

      template<typename NestedMatrix>
      struct is_diagonal_expr<diagonal_adapter<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
  }


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

#ifdef __cpp_concepts
  template<square_shaped<applicability::permitted> NestedMatrix, HermitianAdapterType storage_triangle =
      triangular_matrix<NestedMatrix, triangle_type::diagonal> ? HermitianAdapterType::lower :
      triangular_matrix<NestedMatrix, triangle_type::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_value<NestedMatrix>>) and
    (not constant_diagonal_matrix<NestedMatrix> or values::not_complex<constant_diagonal_value<NestedMatrix>>) and
    (not triangular_matrix<NestedMatrix, triangle_type::any> or triangular_matrix<NestedMatrix, static_cast<triangle_type>(storage_triangle)>)
#else
  template<typename NestedMatrix, HermitianAdapterType storage_triangle =
    triangular_matrix<NestedMatrix, triangle_type::diagonal> ? HermitianAdapterType::lower :
    triangular_matrix<NestedMatrix, triangle_type::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
  }


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

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


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

      template<typename NestedMatrix, triangle_type tri>
      struct is_triangular_expr<TriangularAdapter<NestedMatrix, tri>> : 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
  }


  // -------------------------------------------------------- //
  //  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 {};
    }


    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_collection 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 {};

  }


#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