library_interface.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) 2022-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_LIBRARY_INTERFACE_HPP
#define OPENKALMAN_LIBRARY_INTERFACE_HPP

#include <type_traits>
#include <tuple>

namespace OpenKalman::interface
{
#ifdef __cpp_concepts
  template<typename LibraryObject>
#else
  template<typename LibraryObject, typename>
#endif
  struct library_interface
  {
#ifdef DOXYGEN_SHOULD_SKIP_THIS

    template<typename Derived>
    using LibraryBase = std::monostate;


#ifdef __cpp_lib_ranges
    template<indexible Arg, std::ranges::input_range Indices> requires values::index<std::ranges::range_value_t<Indices>>
    static constexpr values::scalar decltype(auto)
#else
    template<typename Arg, typename Indices>
    static constexpr decltype(auto)
#endif
    get_component(Arg&& arg, const Indices& indices) = delete;


#ifdef __cpp_lib_ranges
    template<indexible Arg, std::ranges::input_range Indices> requires values::index<std::ranges::range_value_t<Indices>>
#else
    template<typename Arg, typename Indices>
#endif
    static void
    set_component(Arg& arg, const scalar_type_of_t<Arg>& s, const Indices& indices) = delete;


#ifdef __cpp_concepts
    static decltype(auto)
    to_native_matrix(auto&& arg) = delete;
#else
    template<typename Arg>
    static decltype(auto)
    to_native_matrix(Arg&& arg) = delete;
#endif


#ifdef __cpp_concepts
    template<writable To, indexible From>
#else
    template<typename To, typename From, std::enable_if_t<indexible<To> and indexible<From>, int> = 0>
#endif
    static void
    assign(M& a, From&& b) = delete;


#ifdef __cpp_concepts
    template<Layout layout, values::number Scalar> requires (layout != Layout::stride)
    static auto
    make_default(coordinates::euclidean_pattern_collection auto&& descriptors) = delete;
#else
    template<Layout layout, typename Scalar, typename Descriptors>
    static auto
    make_default(Descriptors&& descriptors) = delete;
#endif


#ifdef __cpp_concepts
    template<Layout layout, writable Arg> requires (layout == Layout::right) or (layout == Layout::left)
    static void
    fill_components(Arg& arg, const std::convertible_to<scalar_type_of_t<Arg>> auto ... scalars) = delete;
#else
    template<Layout layout, typename Arg, typename...Scalars, std::enable_if_t<
      writable<Arg> and (layout == Layout::right) or (layout == Layout::left), int> = 0>
    static void
    fill_components(Arg& arg, const Scalars...scalars) = delete;
#endif


#ifdef __cpp_concepts
    static constexpr constant_matrix auto
    make_constant(const values::scalar auto& c, coordinates::euclidean_pattern_collection auto&& d) = delete;
#else
    template<typename C, typename D>
    static constexpr auto
    make_constant(const C& c, D&& d) = delete;
#endif


#ifdef __cpp_concepts
    template<values::number Scalar>
    static constexpr identity_matrix auto
    make_identity_matrix(coordinates::euclidean_pattern_collection auto&& d) = delete;
#else
    template<typename Scalar, typename D>
    static constexpr auto
    make_identity_matrix(D&& d) = delete;
#endif


#ifdef __cpp_concepts
    template<TriangleType t>
    static constexpr auto
    make_triangular_matrix(indexible auto&& arg) = delete;
#else
    template<TriangleType t, typename Arg>
    static constexpr auto
    make_triangular_matrix(Arg&& arg) = delete;
#endif


#ifdef __cpp_concepts
     template<HermitianAdapterType t>
     static constexpr auto
     make_hermitian_adapter(indexible auto&& arg) = delete;
#else
     template<HermitianAdapterType t, typename Arg>
     static constexpr auto
     make_hermitian_adapter(Arg&& arg) = delete;
#endif


 #ifdef __cpp_concepts
     template<indexible Arg>
     static constexpr indexible auto
 #else
     template<typename Arg>
     static constexpr auto
 #endif
     to_euclidean(Arg&& arg) = delete;


 #ifdef __cpp_concepts
     template<indexible Arg, coordinates::pattern V>
     static constexpr indexible auto
 #else
     template<typename Arg, typename V>
     static constexpr auto
 #endif
     from_euclidean(Arg&& arg, const V& v) = delete;


 #ifdef __cpp_concepts
     template<indexible Arg>
     static constexpr indexible auto
 #else
     template<typename Arg>
     static constexpr auto
 #endif
     wrap_angles(Arg&& arg) = delete;


#ifdef __cpp_concepts
    template<indexible Arg, values::index...Begin, values::index...Size> requires
      (index_count_v<Arg> == sizeof...(Begin)) and (index_count_v<Arg> == sizeof...(Size))
    static indexible decltype(auto)
#else
    template<typename Arg, typename...Begin, typename...Size>
    static decltype(auto)
#endif
    get_slice(Arg&& arg, const std::tuple<Begin...>& begin, const std::tuple<Size...>& size) = delete;


#ifdef __cpp_concepts
    template<writable Arg, indexible Block, values::index...Begin> requires
      (index_count_v<Block> == sizeof...(Begin)) and (index_count_v<Arg> == sizeof...(Begin))
#else
    template<typename Arg, typename Block, typename...Begin>
#endif
    static void
    set_slice(Arg& arg, Block&& block, const Begin&...begin) = delete;


#ifdef __cpp_concepts
    template<TriangleType t>
    static void
    set_triangle(writable auto& a, indexible auto&& b) = delete;
#else
    template<TriangleType t, typename A, typename B, std::enable_if_t<writable<A> and indexible<B>, int> = 0>
    static void
    set_triangle(A& a, B&& b) = delete;
#endif


#ifdef __cpp_concepts
    static constexpr diagonal_matrix auto
    to_diagonal(indexible auto&& arg) = delete;
#else
    template<typename Arg>
    static constexpr auto
    to_diagonal(Arg&& arg) = delete;
#endif


#ifdef __cpp_concepts
    static constexpr indexible auto
    diagonal_of(square_shaped<Applicability::permitted> auto&& arg) = delete;
#else
    template<typename Arg>
    static constexpr auto
    diagonal_of(Arg&& arg) = delete;
#endif


#ifdef __cpp_concepts
    static indexible auto
    broadcast(indexible auto&& arg, const values::index auto&...factors) = delete;
#else
    template<typename Arg, typename...Factors>
    static auto
    broadcast(Arg&& arg, const Factors&...factors) = delete;
#endif


#ifdef __cpp_concepts
    template<coordinates::pattern...Ds, typename Operation, indexible...Args> requires
      std::invocable<Operation&&, scalar_type_of_t<Args>...> or
      std::invocable<Operation&&, scalar_type_of_t<Args>..., std::conditional_t<true, std::size_t, Ds>...>
    static compatible_with_vector_space_descriptor_collection<std::tuple<Ds...>> auto
#else
    template<typename...Ds, typename Operation, typename...Args>
    static auto
#endif
    n_ary_operation(const std::tuple<Ds...>& d_tup, Operation&& op, Args&&...args) = delete;


#ifdef __cpp_concepts
    template<std::size_t...indices, typename BinaryFunction, indexible Arg>
#else
    template<std::size_t...indices, typename BinaryFunction, typename Arg>
#endif
    static constexpr auto
    reduce(BinaryFunction&& op, Arg&& arg) = delete;


#ifdef __cpp_concepts
    template<indexible Arg>
    static constexpr vector_space_descriptors_may_match_with<Arg> auto
#else
    template<typename Arg>
    static constexpr auto
#endif
    conjugate(Arg&& arg) = delete;


#ifdef __cpp_concepts
    template<indexible Arg>
    static constexpr compatible_with_vector_space_descriptor_collection<std::tuple<vector_space_descriptor_of_t<Arg, 1>, vector_space_descriptor_of_t<Arg, 0>>> auto
#else
    template<typename Arg>
    static constexpr auto
#endif
    transpose(Arg&& arg) = delete;


#ifdef __cpp_concepts
    template<indexible Arg>
    static constexpr compatible_with_vector_space_descriptor_collection<std::tuple<vector_space_descriptor_of_t<Arg, 1>, vector_space_descriptor_of_t<Arg, 0>>> auto
#else
    template<typename Arg>
    static constexpr auto
#endif
    adjoint(Arg&& arg) = delete;


#ifdef __cpp_concepts
    template<square_shaped<Applicability::permitted> Arg>
    static constexpr std::convertible_to<scalar_type_of_t<Arg>> auto
#else
    template<typename Arg>
    static constexpr auto
#endif
    determinant(Arg&& arg) = delete;


#ifdef __cpp_concepts
    template<indexible Arg, vector_space_descriptors_may_match_with<Arg>...Args>
    static constexpr vector_space_descriptors_may_match_with<Arg> auto
#else
    template<typename Arg, typename...Args>
    static constexpr auto
#endif
    sum(Arg&& arg, Args&&...args) = delete;


#ifdef __cpp_concepts
    template<indexible Arg, values::scalar S> requires
      requires(S s) { {values::to_number(s)} -> std::convertible_to<scalar_type_of_t<Arg>>; }
    static constexpr vector_space_descriptors_may_match_with<Arg> auto
#else
    template<typename Arg, typename S>
    static constexpr auto
#endif
    scalar_product(Arg&& arg, S&& s) = delete;


#ifdef __cpp_concepts
    template<indexible Arg, values::scalar S> requires
      requires(S s) { {values::to_number(s)} -> std::convertible_to<scalar_type_of_t<Arg>>; }
    static constexpr vector_space_descriptors_may_match_with<Arg> auto
#else
    template<typename Arg, typename S>
    static constexpr auto
#endif
    scalar_quotient(Arg&& arg, S&& s) = delete;


#ifdef __cpp_concepts
    template<indexible A, vector_space_descriptors_may_match_with<A> B>
    static constexpr compatible_with_vector_space_descriptor_collection<std::tuple(vector_space_descriptor_of_t<A, 1>, vector_space_descriptor_of_t<B, 1>>> auto
#else
    template<typename A, typename B>
    static constexpr auto
#endif
    contract(A&& a, B&& b) = delete;


#ifdef __cpp_concepts
    template<bool on_the_right, writable A, vector_space_descriptors_may_match_with<A> B>
#else
    template<bool on_the_right, typename A, typename B>
#endif
    static constexpr A&
    contract_in_place(A& a, B&& b) = delete;


#ifdef __cpp_concepts
    template<TriangleType triangle_type>
    static constexpr triangular_matrix<triangle_type> auto
    cholesky_factor(indexible auto&& a) = delete;
#else
    template<TriangleType triangle_type, typename Arg>
    static constexpr auto
    cholesky_factor(Arg&& a) = delete;
#endif


#ifdef __cpp_concepts
    template<HermitianAdapterType significant_triangle, indexible A, indexible U>
    static hermitian_matrix decltype(auto)
#else
    template<HermitianAdapterType significant_triangle, typename A, typename U>
    static decltype(auto)
#endif
    rank_update_hermitian(A&& a, U&& u, const scalar_type_of_t<A>& alpha) = delete;


#ifdef __cpp_concepts
    template<TriangleType triangle, indexible A, indexible U> requires
      (triangle == TriangleType::lower) or (triangle == TriangleType::upper)
    static triangular_matrix<triangle> decltype(auto)
#else
    template<TriangleType triangle, typename A, typename U>
    static decltype(auto)
#endif
    rank_update_triangular(A&& a, U&& u, const scalar_type_of_t<A>& alpha) = delete;


#ifdef __cpp_concepts
    template<bool must_be_unique = false, bool must_be_exact = false, indexible A, indexible B>
    static compatible_with_vector_space_descriptor_collection<std::tuple<vector_space_descriptor_of_t<A, 1>, vector_space_descriptor_of_t<B, 1>>> auto
    solve(indexible auto&& a, indexible auto&& b) = delete;
#else
    template<bool must_be_unique = false, bool must_be_exact = false, typename A, typename B>
    static auto
    solve(A&& a, B&& b) = delete;
#endif


#ifdef __cpp_concepts
    static constexpr triangular_matrix<TriangleType::lower> auto
    LQ_decomposition(indexible auto&& arg) = delete;
#else
    template<typename Arg>
    static constexpr auto
    LQ_decomposition(Arg&& arg) = delete;
#endif


#ifdef __cpp_concepts
    static constexpr triangular_matrix<TriangleType::upper> auto
    QR_decomposition(indexible auto&& arg) = delete;
#else
    template<typename Arg>
    static constexpr auto
    QR_decomposition(Arg&& arg) = delete;
#endif

#endif // DOXYGEN_SHOULD_SKIP_THIS
  };


} // namespace OpenKalman::interface


#endif //OPENKALMAN_LIBRARY_INTERFACE_HPP