CovarianceBase1.hpp

/* This file is part of OpenKalman, a header-only C++ library for
 * Kalman filters and other recursive filters.
 *
 * Copyright (c) 2020-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_COVARIANCEBASE1_HPP
#define OPENKALMAN_COVARIANCEBASE1_HPP

namespace OpenKalman::internal
{

#ifdef __cpp_concepts
  template<typename Derived, typename NestedMatrix>
#else
  template<typename Derived, typename NestedMatrix, typename = void>
#endif
  struct CovarianceBase;


  template<typename Cov, typename Nested = nested_object_of_t<Cov>>
#ifdef __cpp_concepts
  concept case1or2 = (self_adjoint_covariance<Cov> and hermitian_matrix<Nested>) or
    (triangular_covariance<Cov> and triangular_matrix<Nested>);
#else
  static constexpr bool case1or2 = (self_adjoint_covariance<Cov> and hermitian_matrix<Nested>) or
    (triangular_covariance<Cov> and triangular_matrix<Nested>);
#endif


  // =====================================CASE 1=======================================
#ifdef __cpp_concepts
  template<typename Derived, typename NestedMatrix> requires
    case1or2<Derived, NestedMatrix> and self_contained<NestedMatrix>
  struct CovarianceBase<Derived, NestedMatrix>
#else
  template<typename Derived, typename NestedMatrix>
  struct CovarianceBase<Derived, NestedMatrix, std::enable_if_t<
    case1or2<Derived, NestedMatrix> and self_contained<NestedMatrix>>>
#endif
    : AdapterBase<Derived, NestedMatrix>
  {
  private:

    using Base = AdapterBase<Derived, NestedMatrix>;

    using Scalar = scalar_type_of_t<NestedMatrix>;


#ifdef __cpp_concepts
    template<typename, typename>
#else
    template<typename, typename, typename>
#endif
    friend struct CovarianceBase;

  protected:

    using CholeskyNestedMatrix = std::conditional_t<diagonal_matrix<NestedMatrix>,
      typename MatrixTraits<std::decay_t<NestedMatrix>>::template DiagonalMatrixFrom<>,
      std::conditional_t<triangular_matrix<NestedMatrix>,
        typename MatrixTraits<std::decay_t<NestedMatrix>>::template SelfAdjointMatrixFrom<>,
        typename MatrixTraits<std::decay_t<NestedMatrix>>::template TriangularAdapterFrom<>>>;


    decltype(auto) cholesky_nested_matrix() &
    {
      if constexpr (triangular_covariance<Derived>) return cholesky_square(this->nested_object());
      else return cholesky_factor(this->nested_object());
    }


    decltype(auto) cholesky_nested_matrix() const &
    {
      if constexpr (triangular_covariance<Derived>) return cholesky_square(this->nested_object());
      else return cholesky_factor(this->nested_object());
    }


    decltype(auto) cholesky_nested_matrix() &&
    {
      if constexpr (triangular_covariance<Derived>) return cholesky_square(std::move(*this).nested_object());
      else return cholesky_factor(std::move(*this).nested_object());
    }


    decltype(auto) cholesky_nested_matrix() const &&
    {
      if constexpr (triangular_covariance<Derived>) return cholesky_square(std::move(*this).nested_object());
      else return cholesky_factor(std::move(*this).nested_object());
    }


    constexpr static int synchronization_direction() { return 0; }


    constexpr static void synchronize_forward() {};


    constexpr static void synchronize_reverse() {};


    constexpr static void mark_nested_matrix_changed() {};


    constexpr static void mark_cholesky_nested_matrix_changed() {};


    constexpr static void mark_synchronized() {};


  public:
#ifdef __cpp_concepts
    CovarianceBase() requires std::default_initializable<NestedMatrix>
#else
    template<typename T = NestedMatrix, std::enable_if_t<std::is_default_constructible_v<T>, int> = 0>
    CovarianceBase()
#endif
      : Base {} {}


#ifdef __cpp_concepts
    template<covariance Arg> requires (not std::derived_from<std::decay_t<Arg>, CovarianceBase>)
#else
    template<typename Arg, std::enable_if_t<covariance<Arg> and
      (not std::is_base_of_v<CovarianceBase, std::decay_t<Arg>>), int> = 0>
#endif
    CovarianceBase(Arg&& arg) : Base {to_covariance_nestable<NestedMatrix>(std::forward<Arg>(arg))} {}


#ifdef __cpp_concepts
    template<covariance_nestable Arg>
#else
    template<typename Arg, std::enable_if_t<covariance_nestable<Arg>, int> = 0>
#endif
    explicit CovarianceBase(Arg&& arg) : Base {to_covariance_nestable<NestedMatrix>(std::forward<Arg>(arg))} {}


#ifdef __cpp_concepts
    template<typename Arg> requires (covariance<Arg> or covariance_nestable<Arg>) and
      (not std::derived_from<std::decay_t<Arg>, CovarianceBase>)
#else
    template<typename Arg, std::enable_if_t<(covariance<Arg> or covariance_nestable<Arg>) and
      (not std::is_base_of_v<CovarianceBase, std::decay_t<Arg>>), int> = 0>
#endif
    auto& operator=(Arg&& arg)
    {
      Base::operator=(to_covariance_nestable<NestedMatrix>(std::forward<Arg>(arg)));
      return *this;
    }


    auto operator() (std::size_t i, std::size_t j)
    {
      return ElementAccessor(Base::nested_object(), i, j);
    }


    auto operator() (std::size_t i, std::size_t j) const
    {
      return ElementAccessor(Base::nested_object(), i, j);
    }


    auto operator[] (std::size_t i)
    {
      return ElementAccessor(Base::nested_object(), i);
    }


    auto operator[] (std::size_t i) const
    {
      return ElementAccessor(Base::nested_object(), i);
    }


    void set_component(const Scalar s, const std::size_t i, const std::size_t j)
    {
      OpenKalman::set_component(Base::nested_object(), s, i, j);
    }


    void set_component(const Scalar s, const std::size_t i)
    {
      OpenKalman::set_component(Base::nested_object(), s, i);
    }

  };


}

#endif //OPENKALMAN_COVARIANCEBASE1_HPP