eigen-forward-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-2021 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_EIGEN_FORWARD_DECLARATIONS_HPP
#define OPENKALMAN_EIGEN_FORWARD_DECLARATIONS_HPP

#include <type_traits>


namespace OpenKalman::Eigen3
{

  template<typename NullaryOp, typename PlainObjectType>
  struct NullaryFunctorTraits;


  template<typename Operation>
  struct UnaryFunctorTraits;


  enum struct BinaryFunctorType: int {
    normal, 
    sum, 
    product, 
  };


  template<typename Operation>
  struct BinaryFunctorTraits;


  template<typename Operation, typename Arg1, typename Arg2, typename Arg3>
  struct TernaryFunctorTraits;


  struct EigenCustomBase {};


  template<typename Derived, typename Base>
  struct EigenAdapterBase;


  // -------------------------------------- //
  //   concepts for specific Eigen classes  //
  // -------------------------------------- //

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

    template<typename XprType>
    struct is_ArrayWrapper<Eigen::ArrayWrapper<XprType>> : std::true_type {};
  }


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


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

    template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
    struct is_Block<Eigen::Block<XprType, BlockRows, BlockCols, InnerPanel>> : std::true_type {};
  }


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


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

    template<typename UnaryOp, typename XprType>
    struct is_CwiseUnaryOp<Eigen::CwiseUnaryOp<UnaryOp, XprType>> : std::true_type {};
  }


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


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

    template<typename ViewOp, typename XprType>
    struct is_CwiseUnaryView<Eigen::CwiseUnaryView<ViewOp, XprType>> : std::true_type {};
  }


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


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

    template<typename Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
    struct is_DiagonalMatrix<Eigen::DiagonalMatrix<Scalar, SizeAtCompileTime, MaxSizeAtCompileTime>>
      : std::true_type {};
  }


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


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

    template<typename DiagonalVectorType>
    struct is_DiagonalWrapper<Eigen::DiagonalWrapper<DiagonalVectorType>> : std::true_type {};
  }


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


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

    template<typename Scalar, typename Arg>
    struct is_eigen_Identity<Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>, Arg>>
      : std::true_type {};
  }


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


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

    template<typename XprType>
    struct is_eigen_MatrixWrapper<Eigen::MatrixWrapper<XprType>> : std::true_type {};
  }


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


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

    template<typename MatrixType, int RowFactor, int ColFactor>
    struct is_eigen_Replicate<Eigen::Replicate<MatrixType, RowFactor, ColFactor>> : std::true_type
    {
    private:

      template<std::size_t direction>
      static constexpr std::size_t efactor = direction == 1 ? ColFactor : RowFactor;

    public:

      template<std::size_t direction>
      static constexpr std::size_t factor = efactor<direction> == Eigen::Dynamic ? dynamic_size : efactor<direction>;
    };
  }


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


  template<typename T, std::size_t direction>
  struct eigen_Replicate_factor
    : std::integral_constant<std::size_t, detail::is_eigen_Replicate<std::decay_t<T>>::template factor<direction>> {};


  template<typename T, std::size_t direction>
  constexpr auto eigen_Replicate_factor_v = eigen_Replicate_factor<T, direction>::value;


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

    template<typename MatrixType, unsigned int UpLo>
    struct is_eigen_SelfAdjointView<Eigen::SelfAdjointView<MatrixType, UpLo>> : std::true_type {};
  }


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


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

    template<typename MatrixType, unsigned int UpLo>
    struct is_eigen_TriangularView<Eigen::TriangularView<MatrixType, UpLo>> : std::true_type {};
  }


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


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

    template<typename T, int Size>
    struct is_eigen_VectorBlock<Eigen::VectorBlock<T, Size>> : std::true_type {};
  }


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


  template<typename T, bool must_be_native = false>
#ifdef __cpp_concepts
  concept eigen_general =
#else
  constexpr bool eigen_general =
#endif
    (std::is_base_of_v<Eigen::EigenBase<std::decay_t<T>>, std::decay_t<T>> or eigen_VectorBlock<T>) and
      (not must_be_native or not std::is_base_of_v<EigenCustomBase, std::decay_t<T>>);


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

    template<typename T, int Size>
    struct is_derived_eigen_matrix<Eigen::VectorBlock<T, Size>>
      : std::is_base_of<Eigen::MatrixBase<std::decay_t<T>>, std::decay_t<T>> {};
  }


  template<typename T, bool must_be_native = false>
#ifdef __cpp_concepts
  concept eigen_matrix_general =
#else
  constexpr bool eigen_matrix_general =
#endif
    (eigen_general<T, must_be_native> and std::is_base_of_v<Eigen::MatrixBase<std::decay_t<T>>, std::decay_t<T>>) or
      detail::is_derived_eigen_matrix<std::decay_t<T>>::value;


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

    template<typename T, int Size>
    struct is_derived_eigen_array<Eigen::VectorBlock<T, Size>>
      : std::is_base_of<Eigen::ArrayBase<std::decay_t<T>>, std::decay_t<T>> {};
  }


  template<typename T, bool must_be_native = false>
#ifdef __cpp_concepts
  concept eigen_array_general =
#else
  constexpr bool eigen_array_general =
#endif
    (eigen_general<T, must_be_native> and std::is_base_of_v<Eigen::ArrayBase<std::decay_t<T>>, std::decay_t<T>>) or
      detail::is_derived_eigen_array<std::decay_t<T>>::value;


  template<typename T, bool must_be_native = false>
#ifdef __cpp_concepts
  concept eigen_dense_general =
#else
  constexpr bool eigen_dense_general =
#endif
    eigen_matrix_general<T, must_be_native> or eigen_array_general<T, must_be_native>;


  template<typename NestedMatrix>
  using IdentityMatrix = Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<
    typename Eigen::internal::traits<std::decay_t<NestedMatrix>>::Scalar>, NestedMatrix>;


  // ---------------- //
  //  eigen_matrix_t  //
  // ---------------- //

  namespace detail
  {
    template<std::size_t size>
    constexpr auto eigen_index_convert = size == dynamic_size ? Eigen::Dynamic : static_cast<Eigen::Index>(size);
  }

  template<typename Scalar, std::size_t...dims>
  using eigen_matrix_t = std::conditional_t<sizeof...(dims) == 1,
    Eigen::Matrix<Scalar, detail::eigen_index_convert<dims>..., detail::eigen_index_convert<1>>,
    Eigen::Matrix<Scalar, detail::eigen_index_convert<dims>...>>;


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


  template<typename Op> static decltype(auto) native_operation(Op&& op) { return std::forward<Op>(op); };
  template<typename S> static auto native_operation(const std::plus<S>& op) { return Eigen::internal::scalar_sum_op<S, S> {}; };
  template<typename S> static auto native_operation(const std::minus<S>& op) { return Eigen::internal::scalar_difference_op<S, S> {}; };
  template<typename S> static auto native_operation(const std::multiplies<S>& op) {return Eigen::internal::scalar_product_op<S, S> {}; };
  template<typename S> static auto native_operation(const std::divides<S>& op) { return Eigen::internal::scalar_quotient_op<S, S> {}; };
  template<typename S> static auto native_operation(const std::negate<S>& op) { return Eigen::internal::scalar_opposite_op<S> {}; };

  using EIC = Eigen::internal::ComparisonName;
  template<typename S> static auto native_operation(const std::equal_to<S>& op) { return Eigen::internal::scalar_cmp_op<S, S, EIC::cmp_EQ> {}; };
  template<typename S> static auto native_operation(const std::not_equal_to<S>& op) { return Eigen::internal::scalar_cmp_op<S, S, EIC::cmp_NEQ> {}; };
  template<typename S> static auto native_operation(const std::greater<S>& op) { return Eigen::internal::scalar_cmp_op<S, S, EIC::cmp_GT> {}; };
  template<typename S> static auto native_operation(const std::less<S>& op) { return Eigen::internal::scalar_cmp_op<S, S, EIC::cmp_LT> {}; };
  template<typename S> static auto native_operation(const std::greater_equal<S>& op) { return Eigen::internal::scalar_cmp_op<S, S, EIC::cmp_GE> {}; };
  template<typename S> static auto native_operation(const std::less_equal<S>& op) { return Eigen::internal::scalar_cmp_op<S, S, EIC::cmp_LE> {}; };

  template<typename S> static auto native_operation(const std::logical_and<S>& op) { return Eigen::internal::scalar_boolean_and_op {}; };
  template<typename S> static auto native_operation(const std::logical_or<S>& op) { return Eigen::internal::scalar_boolean_or_op {}; };
  template<typename S> static auto native_operation(const std::logical_not<S>& op) { return Eigen::internal::scalar_boolean_not_op<S> {}; };


} // namespace OpenKalman::Eigen3


#endif //OPENKALMAN_EIGEN_FORWARD_DECLARATIONS_HPP