pass_through_interface.hpp

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

#include "patterns/patterns.hpp"
#include "linear-algebra/interfaces/interfaces-defined.hpp"
#include "linear-algebra/concepts/indexible.hpp"
#include "linear-algebra/adapters/internal/AdapterBase.hpp"
#include "linear-algebra/concepts/hermitian_matrix.hpp"
#include "linear-algebra/concepts/pattern_collection_for.hpp"
#include "linear-algebra/concepts/square_shaped.hpp"
#include "linear-algebra/functions/copy_from.hpp"
#include "linear-algebra/traits/hermitian_adapter_type_of.hpp"
#include "linear-algebra/adapters/internal/AdapterBase.hpp"

namespace OpenKalman::interface
{
  template<typename Object, typename Nested>
  struct pass_through_object_traits
  {
  private:

    using NestedTraits = object_traits<Nested>;

    template<typename T>
    static constexpr void
    assert_valid_arg_type(T) { static_assert(stdex::same_as<stdex::remove_cvref_t<T>, Object>); }

  public:

    static constexpr auto
    get_mdspan = [](auto&& t) -> decltype(auto)
    {
      assert_valid_arg_type(t);
      return OpenKalman::get_mdspan(std::forward<decltype(t)>(t).nested_object());
    };


    static constexpr auto
    get_pattern_collection = [](auto&& t) -> decltype(auto)
    {
      assert_valid_arg_type(t);
      return OpenKalman::get_pattern_collection(std::forward<decltype(t)>(t).nested_object());
    };


    static constexpr triangle_type
    triangle_type_value = triangle_type_of_v<Nested>;


#ifdef __cpp_concepts
    template<typename T> requires get_constant_defined_for<Nested>
#else
    template<typename T, bool Enable = true, std::enable_if_t<Enable and get_constant_defined_for<Nested>, int> = 0>
#endif
    static constexpr auto
    get_constant(T&& t)
    {
      assert_valid_arg_type(t);
      return NestedTraits::get_constant(std::forward<T>(t).nested_object());
    };


    static constexpr auto
    nested_object = [](auto&& t) -> decltype(auto)
    {
      assert_valid_arg_type(t);
      return std::forward<decltype(t)>(t).nested_object();
    };


    template<applicability b>
    static constexpr bool
    is_square = square_shaped<Nested, 2, b>;


    static constexpr bool
    is_triangular_adapter = false;


    static constexpr bool
    is_hermitian = hermitian_matrix<Nested>;


    static constexpr HermitianAdapterType
    hermitian_adapter_type = hermitian_adapter_type_of_v<Nested>;

  };


  template<typename Object, typename Nested>
  struct pass_through_library_interface
  {
  private:

    using NestedInterface = library_interface<stdex::remove_cvref_t<Nested>>;

    template<typename T>
    static constexpr void
    assert_valid_arg_type(T) { static_assert(stdex::same_as<stdex::remove_cvref_t<T>, Object>); }

    template<typename T, typename Arg>
    static constexpr auto
    make_adapter(T&& t, Arg&& arg)
    {
      return std::apply([](auto&& a, auto&&...vs){
        return attach_patterns(std::forward<decltype(a)>(a), std::forward<decltype(vs)>(vs)...);
        }, std::tuple_cat(std::forward_as_tuple(std::forward<Arg>(arg)), std::forward<T>(t).my_descriptors));
    }

  public:

    template<typename Derived>
    using library_base = internal::library_base_t<Derived, Nested>;


#ifdef __cpp_concepts
    template<typename T, typename Other> requires copy_from_defined_for<Nested&, Other&&>
#else
    template<typename T, typename Other, std::enable_if_t<copy_from_defined_for<Nested&, Other&&>, int> = 0>
#endif
    static constexpr void
    copy_from(T& t, Other&& other)
    {
      assert_valid_arg_type(t);
      OpenKalman::copy_from(t.nested_object(), std::forward<decltype(other)>(other));
    };


/*#ifdef __cpp_lib_ranges
    template<indexible Arg, std::ranges::input_range Indices> requires values::index<std::ranges::range_value_t<Indices>> and
      interface::get_component_defined_for<Nested, nested_object_of_t<Arg&&>, const Indices&>
    static constexpr values::scalar decltype(auto)
#else
    template<typename Arg, typename Indices, std::enable_if_t<
      interface::get_component_defined_for<Nested, typename nested_object_of<Arg&&>::type, const Indices&>, int> = 0>
    static constexpr decltype(auto)
#endif
    get_component(Arg&& arg, const Indices& indices)
    {
      return NestedInterface::get_component(nested_object(std::forward<Arg>(arg)), indices);
    }


#ifdef __cpp_lib_ranges
    template<indexible Arg, std::ranges::input_range Indices> requires values::index<std::ranges::range_value_t<Indices>> and
      interface::set_component_defined_for<Nested, nested_object_of_t<Arg&&>, const scalar_type_of_t<Arg>&, const Indices&>
#else
    template<typename Arg, typename Indices, std::enable_if_t<
      interface::set_component_defined_for<Nested, typename nested_object_of<Arg&&>::type, const typename scalar_type_of<Arg>::type&, const Indices&>, int> = 0>
#endif
    static constexpr void
    set_component(Arg& arg, const scalar_type_of_t<Arg>& s, const Indices& indices)
    {
      NestedInterface::set_component(nested_object(arg), s, indices);
    }


#ifdef __cpp_concepts
    template<typename Arg> requires interface::to_native_matrix_defined_for<Nested, nested_object_of_t<Arg&&>>
#else
    template<typename Arg, std::enable_if_t<interface::to_native_matrix_defined_for<Nested, nested_object_of_t<Arg&&>>, int> = 0>
#endif
    static decltype(auto)
    to_native_matrix(Arg&& arg)
    {
      return make_adapter(std::forward<Arg>(arg), NestedInterface::to_native_matrix(nested_object(std::forward<Arg>(arg))));
    }


#ifdef __cpp_concepts
    template<data_layout layout, typename Scalar, typename D> requires
      interface::make_default_defined_for<Nested, layout, Scalar, D&&>
#else
    template<data_layout layout, typename Scalar, typename D, std::enable_if_t<
      interface::make_default_defined_for<Nested, layout, Scalar, D&&>, int> = 0>
#endif
    static auto
    make_default(D&& d)
    {
      return NestedInterface::template make_default<layout, Scalar>(std::forward<D>(d));
    }


#ifdef __cpp_concepts
    template<data_layout layout, typename Arg, typename...Scalars> requires
      interface::fill_components_defined_for<Nested, layout, nested_object_of_t<Arg&>, Scalars...>
#else
    template<data_layout layout, typename Arg, typename...Scalars, std::enable_if_t<
      interface::fill_components_defined_for<Nested, layout, typename nested_object_of<Arg&>::type, Scalars...>, int> = 0>
#endif
    static void
    fill_components(Arg& arg, const Scalars...scalars)
    {
      NestedInterface::template fill_components<layout>(nested_object(arg), scalars...);
    }


#ifdef __cpp_concepts
    template<typename C, typename D> requires interface::make_constant_defined_for<Nested, C&&, D&&>
#else
    template<typename C, typename D, std::enable_if_t<interface::make_constant_defined_for<Nested, C&&, D&&>, int> = 0>
#endif
    static constexpr auto
    make_constant(C&& c, D&& d)
    {
      return NestedInterface::make_constant(std::forward<C>(c), std::forward<D>(d));
    }


#ifdef __cpp_concepts
    template<typename Scalar, typename D> requires interface::make_identity_matrix_defined_for<Nested, Scalar, D&&>
#else
    template<typename Scalar, typename D, std::enable_if_t<interface::make_identity_matrix_defined_for<Nested, Scalar, D&&>, int> = 0>
#endif
    static constexpr auto
    make_identity_matrix(D&& d)
    {
      return NestedInterface::make_identity_matrix(std::forward<D>(d));
    }


#ifdef __cpp_concepts
    template<triangle_type t, indexible Arg> requires
      interface::make_triangular_matrix_defined_for<Nested, t, nested_object_of_t<Arg&&>>
    static constexpr triangular_matrix<t> auto
#else
    template<triangle_type t, typename Arg, std::enable_if_t<
      interface::make_triangular_matrix_defined_for<Nested, t, typename nested_object_of<Arg&&>::type>, int> = 0>
    static constexpr auto
#endif
    make_triangular_matrix(Arg&& arg)
    {
      return make_adapter(std::forward<Arg>(arg), (NestedInterface::template make_triangular_matrix<t>(nested_object(std::forward<Arg>(arg)))));
    }


#ifdef __cpp_concepts
    template<HermitianAdapterType t, indexible Arg> requires
      interface::make_hermitian_adapter_defined_for<Nested, t, nested_object_of_t<Arg&&>>
    static constexpr hermitian_matrix auto
#else
    template<HermitianAdapterType t, typename Arg, std::enable_if_t<
      make_hermitian_adapter_defined_for<Nested, t, typename nested_object_of<Arg&>::type>, int> = 0>
    static constexpr auto
#endif
    make_hermitian_adapter(Arg&& arg)
    {
      return make_adapter(std::forward<Arg>(arg), NestedInterface::template make_hermitian_adapter<t>(nested_object(std::forward<Arg>(arg))));
    }

  private:

    template<typename Arg, typename BeginTup, typename SizeTup, std::size_t...Ix>
    static decltype(auto)
    get_slice_impl(Arg&& arg, const BeginTup& begin_tup, const SizeTup& size_tup, std::index_sequence<Ix...>)
    {
      return attach_patterns(NestedInterface::get_slice(nested_object(std::forward<Arg>(arg)), begin_tup, size_tup),
        std::tuple {patterns::get_slice<scalar_type_of_t<Arg>>(OpenKalman::get_pattern_collection(arg, Ix), std::get<Ix>(begin_tup), std::get<Ix>(size_tup))...});
    }

  public:

#ifdef __cpp_concepts
    template<typename Arg, typename...Begin, typename...Size> requires
      interface::get_slice_defined_for<Nested, nested_object_of_t<Arg&&>, const std::tuple<Begin...>&, const std::tuple<Size...>&>
#else
    template<typename Arg, typename...Begin, typename...Size, std::enable_if_t<
      interface::get_slice_defined_for<Nested, typename nested_object_of<Arg&&>::type, const std::tuple<Begin...>&, const std::tuple<Size...>&>, int> = 0>
#endif
    static decltype(auto)
    get_slice(Arg&& arg, const std::tuple<Begin...>& begin_tup, const std::tuple<Size...>& size_tup)
    {
      return get_slice_impl(std::forward<Arg>(arg), begin_tup, size_tup, std::index_sequence_for<Begin...>{});
    };


#ifdef __cpp_concepts
    template<typename Arg, typename Block, typename...Begin> requires
      interface::set_slice_defined_for<Arg, nested_object_of_t<Arg&>, Block&&, const Begin&...>
#else
    template<typename Arg, typename Block, typename...Begin, std::enable_if_t<
      interface::set_slice_defined_for<Arg, typename nested_object_of<Arg&>::type, Block&&, const Begin&...>, int> = 0>
#endif
    static void
    set_slice(Arg& arg, Block&& block, const Begin&...begin)
    {
      NestedInterface::set_slice(nested_object(arg), std::forward<Block>(block), begin...);
    };


#ifdef __cpp_concepts
    template<triangle_type t, typename A, typename B> requires
      interface::set_triangle_defined_for<Nested, t, nested_object_of_t<A&&>, B&&>
#else
    template<triangle_type t, typename A, typename B, std::enable_if_t<
      interface::set_triangle_defined_for<Nested, t, typename nested_object_of<A&&>::type, B&&>, int> = 0>
#endif
    static void
    set_triangle(A&& a, B&& b)
    {
      NestedInterface::template set_triangle<t>(nested_object(std::forward<A>(a)), std::forward<B>(b));
    }


#ifdef __cpp_concepts
    template<typename Arg> requires
      interface::to_diagonal_defined_for<Nested, nested_object_of_t<Arg&&>>
    static constexpr diagonal_matrix auto
#else
    template<typename Arg, std::enable_if_t<
      interface::to_diagonal_defined_for<Nested, typename nested_object_of<Arg&&>::type>, int> = 0>
    static constexpr auto
#endif
    to_diagonal(Arg&& arg)
    {
      return std::apply([](auto&& a, auto&& v, auto&&...vs){
        return attach_patterns(
          std::forward<decltype(a)>(a),
          std::forward<decltype(v)>(v),
          std::forward<decltype(v)>(v),
          std::forward<decltype(vs)>(vs)...);
        }, std::tuple_cat(
          std::forward_as_tuple(NestedInterface::to_diagonal(nested_object(std::forward<Arg>(arg)))),
          std::forward<Arg>(arg).my_descriptors),
          std::tuple{patterns::Axis{}});
    }

  private:

    template<typename Arg, typename V0, typename V1, typename...Vs>
    static constexpr decltype(auto)
    diagonal_of_impl(Arg&& arg, V0&& v0, V1&& v1, const Vs&...vs)
    {
      auto d0 = internal::smallest_pattern<scalar_type_of_t<Arg>>(std::forward<V0>(v0), std::forward<V1>(v1));
      return attach_patterns(std::forward<Arg>(arg), d0, vs...);
    }

  public:

#ifdef __cpp_concepts
    template<indexible Arg> requires (diagonal_matrix<Nested> and internal::has_nested_vector<Nested>) or
      (diagonal_matrix<Nested> and internal::has_nested_vector<Nested, 1> and
        interface::transpose_defined_for<Nested, decltype(nested_object(nested_object(std::declval<Arg>())))>) or
      interface::diagonal_of_defined_for<Nested, nested_object_of_t<Arg&&>>
    static constexpr vector auto
#else
    template<typename Arg, std::enable_if_t<(diagonal_matrix<Nested> and internal::has_nested_vector<Nested>) or
      (diagonal_matrix<Nested> and internal::has_nested_vector<Nested, 1> and
        interface::transpose_defined_for<Nested, decltype(nested_object(nested_object(std::declval<Arg>())))>) or
      interface::diagonal_of_defined_for<Nested, typename nested_object_of<Arg&&>::type>, int> = 0>
    static constexpr auto
#endif
    diagonal_of(Arg&& arg)
    {
      if constexpr (diagonal_matrix<Nested> and internal::has_nested_vector<Nested>)
        return diagonal_of_impl(nested_object(nested_object(std::forward<Arg>(arg))));
      else if constexpr (diagonal_matrix<Nested> and internal::has_nested_vector<Nested, 1> and
          interface::transpose_defined_for<Nested, decltype(nested_object(nested_object(std::declval<Arg>())))>)
        return diagonal_of_impl(NestedInterface::transpose(nested_object(nested_object(std::forward<Arg>(arg)))));
      else
        return diagonal_of_impl(NestedInterface::diagonal_of(nested_object(std::forward<Arg>(arg))),
          std::tuple_cat(all_vector_space_descriptors(std::forward<Arg>(arg)), std::tuple{patterns::Axis{}, patterns::Axis{}}));
    }

  private:

    template<std::size_t Ix, typename Arg, typename Factors_tup>
    static constexpr auto broadcast_for_index(const Arg& arg, const Factors_tup& factors_tup)
    {
      constexpr auto N = collections::size_of_v<Factors_tup>;
      if constexpr (Ix < N)
        return get_pattern_collection<Ix>(arg) * std::get<Ix>(factors_tup);
      else
        return patterns::Axis{};
    }


    template<typename Arg, std::size_t...Is, typename Factors_tup>
    static constexpr auto broadcast_impl(Arg&& arg, std::index_sequence<Is...>, const Factors_tup& factors_tup)
    {
      constexpr auto N = collections::size_of_v<Factors_tup>;
      return attach_patterns(std::forward<Arg>(arg), broadcast_for_index<Is>(arg, factors_tup)...);
    }

  public:

#ifdef __cpp_concepts
    template<indexible Arg, values::index...Factors> requires
      interface::broadcast_defined_for<Nested, nested_object_of_t<Arg&&>, const Factors&...>
    static indexible auto
#else
    template<typename Arg, typename...Factors, std::enable_if_t<
      interface::broadcast_defined_for<Nested, typename nested_object_of<Arg&&>::type, const Factors&...>, int> = 0>
    static auto
#endif
    broadcast(Arg&& arg, const Factors&...factors)
    {
      auto&& ret = NestedInterface::broadcast(nested_object(std::forward<Arg>(arg)), factors...);
      using Ret = decltype(ret);
      auto seq = std::make_index_sequence<std::max(index_count_v<Arg>, sizeof...(factors))>{};
      return broadcast_impl(std::forward<Ret>(ret), seq, std::forward_as_tuple(factors...));
    }


#ifdef __cpp_concepts
    template<patterns::pattern...Vs, typename Operation> requires
      interface::n_ary_operation_defined_for<NestedInterface, const std::tuple<Vs...>&, Operation&&>
    static indexible auto
#else
    template<typename...Vs, typename Operation, std::enable_if_t<
      interface::n_ary_operation_defined_for<NestedInterface, const std::tuple<Vs...>&, Operation&&>, int> = 0>
    static auto
#endif
    n_ary_operation(const std::tuple<Vs...>& d_tup, Operation&& op)
    {
      return NestedInterface::n_ary_operation(d_tup, std::forward<Operation>(op));
    }


#ifdef __cpp_concepts
    template<patterns::pattern...Vs, typename Operation, indexible Arg, indexible...Args> requires
      interface::n_ary_operation_defined_for<Nested, const std::tuple<Vs...>&, Operation&&, nested_object_of_t<Arg&&>, Args...>
    static indexible auto
#else
    template<typename...Vs, typename Operation, typename Arg, typename...Args, std::enable_if_t<
      interface::n_ary_operation_defined_for<Nested, const std::tuple<Vs...>&, Operation&&, typename nested_object_of<Arg&&>::type, Args...>, int> = 0>
    static auto
#endif
    n_ary_operation(const std::tuple<Vs...>& d_tup, Operation&& op, Arg&& arg, Args&&...args)
    {
      return NestedInterface::n_ary_operation(d_tup, std::forward<Operation>(op), nested_object(std::forward<Arg>(arg)), std::forward<Args>(args)...);
    }

  private:

    template<std::size_t...indices, typename Arg, typename...Vs, std::size_t...Ix>
    static constexpr decltype(auto)
    reduce_impl(Arg&& arg, const std::tuple<Vs...>& tup_vs, std::index_sequence<Ix...> seq)
    {
      return attach_patterns(std::forward<Arg>(arg),
        ([]{ constexpr auto I = Ix; return ((I == indices) or ...); } ?
          uniform_pattern_component_of_t<vector_space_descriptor_of_t<Vs, Ix>>{} :
          std::get<Ix>(tup_vs))...);
    }

  public:

#ifdef __cpp_concepts
    template<std::size_t...indices, typename BinaryFunction, indexible Arg> requires
      interface::reduce_defined_for<Nested, BinaryFunction&&, nested_object_of_t<Arg&&>, indices...>
#else
    template<std::size_t...indices, typename BinaryFunction, typename Arg, std::enable_if_t<
      interface::reduce_defined_for<Nested, BinaryFunction&&, typename nested_object_of<Arg&&>::type, indices...>, int> = 0>
#endif
    static constexpr auto
    reduce(BinaryFunction&& op, Arg&& arg)
    {
      return reduce_impl<indices...>(
        NestedInterface::template reduce<indices...>(std::forward<BinaryFunction>(op), nested_object(std::forward<Arg>(arg))),
        std::forward<Arg>(arg).my_descriptors,
        std::index_sequence_for<Ds...>{});
    }


#ifdef __cpp_concepts
    template<indexible Arg> requires
      interface::to_euclidean_defined_for<Nested, Arg&&> or
      interface::to_euclidean_defined_for<Nested, nested_object_of_t<Arg&&>>
    static constexpr indexible auto
#else
    template<typename Arg, std::enable_if_t<
      interface::to_euclidean_defined_for<Nested, Arg&&> or
      interface::to_euclidean_defined_for<Nested, typename nested_object_of<Arg&&>::type>, int> = 0>
    static constexpr auto
#endif
    to_euclidean(Arg&& arg)
    {
      if constexpr (interface::to_euclidean_defined_for<Nested, Arg&&>)
        return NestedInterface::to_euclidean(std::forward<Arg>(arg));
      else
        return NestedInterface::to_euclidean(nested_object(std::forward<Arg>(arg)));
    }


#ifdef __cpp_concepts
    template<indexible Arg, patterns::pattern V> requires
      interface::from_euclidean_defined_for<Nested, Arg&&, const V&> or
      interface::from_euclidean_defined_for<Nested, nested_object_of_t<Arg&&>, const V&>
    static constexpr indexible auto
#else
    template<typename Arg, typename V, std::enable_if_t<
      interface::from_euclidean_defined_for<Nested, Arg&&, const V&> or
      interface::from_euclidean_defined_for<Nested, typename nested_object_of<Arg&&>::type, const V&>, int> = 0>
    static constexpr auto
#endif
    from_euclidean(Arg&& arg, const V& v)
    {
      if constexpr (interface::from_euclidean_defined_for<Nested, Arg&&, const V&>)
        return NestedInterface::from_euclidean(std::forward<Arg>(arg), v);
      else
        return NestedInterface::from_euclidean(nested_object(std::forward<Arg>(arg)), v);
    }


#ifdef __cpp_concepts
    template<indexible Arg> requires
      interface::wrap_angles_defined_for<Nested, Arg&&> or
      interface::wrap_angles_defined_for<Nested, nested_object_of_t<Arg&&>>
    static constexpr indexible auto
#else
    template<typename Arg, std::enable_if_t<
      interface::wrap_angles_defined_for<Nested, Arg&&> or
      interface::wrap_angles_defined_for<Nested, typename nested_object_of<Arg&&>::type>, int> = 0>
    static constexpr auto
#endif
    wrap_angles(Arg&& arg)
    {
      if constexpr (interface::wrap_angles_defined_for<Nested, Arg&&>)
        return NestedInterface::wrap_angles(std::forward<Arg>(arg));
      else
        return NestedInterface::wrap_angles(nested_object(std::forward<Arg>(arg)));
    }


#ifdef __cpp_concepts
    template<indexible Arg> requires
      interface::conjugate_defined_for<Nested, Arg&&> or
      interface::conjugate_defined_for<Nested, nested_object_of_t<Arg&&>>
    static constexpr indexible auto
#else
    template<typename Arg, std::enable_if_t<
      interface::conjugate_defined_for<Nested, Arg&&> or
      interface::conjugate_defined_for<Nested, typename nested_object_of<Arg&&>::type>, int> = 0>
    static constexpr auto
#endif
    conjugate(Arg&& arg)
    {
      if constexpr (interface::conjugate_defined_for<Nested, Arg&&>)
      {
        return NestedInterface::conjugate(std::forward<Arg>(arg));
      }
      else
      {
        auto&& conj = NestedInterface::conjugate(nested_object(std::forward<Arg>(arg)));
        return internal::make_fixed_size_adapter_like<Arg>(std::forward<decltype(conj)>(conj));
      }
    }


#ifdef __cpp_concepts
    template<indexible Arg> requires
      interface::transpose_defined_for<Nested, Arg&&> or
      interface::transpose_defined_for<Nested, nested_object_of_t<Arg&&>>
    static constexpr indexible auto
#else
    template<typename Arg, std::enable_if_t<
      interface::transpose_defined_for<Nested, Arg&&> or
      interface::transpose_defined_for<Nested, typename nested_object_of<Arg&&>::type>, int> = 0>
    static constexpr auto
#endif
    transpose(Arg&& arg)
    {
      if constexpr (interface::transpose_defined_for<Nested, Arg&&>)
      {
        return NestedInterface::transpose(std::forward<Arg>(arg));
      }
      else
      {
        return internal::make_fixed_size_adapter<vector_space_descriptor_of_t<Arg, 1>, vector_space_descriptor_of_t<Arg, 0>>(
          NestedInterface::transpose(nested_object(std::forward<Arg>(arg))));
      }
    }


#ifdef __cpp_concepts
    template<indexible Arg> requires
      interface::adjoint_defined_for<Nested, Arg&&> or
      interface::adjoint_defined_for<Nested, nested_object_of_t<Arg&&>>
    static constexpr indexible auto
#else
    template<typename Arg, std::enable_if_t<
      interface::adjoint_defined_for<Nested, Arg&&> or
      interface::adjoint_defined_for<Nested, typename nested_object_of<Arg&&>::type>, int> = 0>
    static constexpr auto
#endif
    conjugate_transpose(Arg&& arg)
    {
      if constexpr (interface::adjoint_defined_for<Nested, Arg&&>)
      {
        return NestedInterface::conjugate_transpose(std::forward<Arg>(arg));
      }
      else
      {
        return internal::make_fixed_size_adapter<vector_space_descriptor_of_t<Arg, 1>, vector_space_descriptor_of_t<Arg, 0>>(
          NestedInterface::conjugate_transpose(nested_object(std::forward<Arg>(arg))));
      }
    }


#ifdef __cpp_concepts
    template<indexible Arg> requires
      interface::determinant_defined_for<Nested, Arg&&> or
      interface::determinant_defined_for<Nested, nested_object_of_t<Arg&&>>
    static constexpr std::convertible_to<scalar_type_of_t<Arg>> auto
#else
    template<typename Arg, std::enable_if_t<
      interface::determinant_defined_for<Nested, Arg&&> or
      interface::determinant_defined_for<Nested, typename nested_object_of<Arg&&>::type>, int> = 0>
    static constexpr auto
#endif
    determinant(Arg&& arg)
    {
      if constexpr (interface::determinant_defined_for<Nested, Arg&&>)
      {
        return NestedInterface::determinant(std::forward<Arg>(arg));
      }
      else
      {
        return NestedInterface::determinant(nested_object(std::forward<Arg>(arg)));
      }
    }


#ifdef __cpp_concepts
    template<typename Arg, typename...Args> requires
      interface::sum_defined_for<Nested, Arg&&, Args&&...> or
      interface::sum_defined_for<Nested, nested_object_of_t<Arg&&>, Args&&...>
#else
    template<typename Arg, typename...Args, std::enable_if_t<
      interface::sum_defined_for<Nested, Arg&&, Args&&...> or
      interface::sum_defined_for<Nested, typename nested_object_of<Arg&&>::type, Args&&...>, int> = 0>
#endif
    static auto
    sum(Arg&& arg, Args&&...args)
    {
      if constexpr (interface::sum_defined_for<Nested, Arg&&, Args&&...>)
      {
        return NestedInterface::sum(std::forward<Arg>(arg), std::forward<Args>(args)...);
      }
      else
      {
        return NestedInterface::sum(nested_object(std::forward<Arg>(arg)), std::forward<Args>(args)...);
      }
    }


#ifdef __cpp_concepts
    template<typename A, typename B> requires
      interface::contract_defined_for<Nested, A&&, B&&> or
      interface::contract_defined_for<Nested, nested_object_of_t<A&&>, B&&>
#else
    template<typename A, typename B, std::enable_if_t<
      interface::contract_defined_for<Nested, A&&, B&&> or
      interface::contract_defined_for<Nested, typename nested_object_of<A&&>::type, B&&>, int> = 0>
#endif
    static auto
    contract(A&& a, B&& b)
    {
      if constexpr (interface::contract_defined_for<Nested, A&&, B&&>)
      {
        return NestedInterface::contract(std::forward<A>(a), std::forward<B>(b));
      }
      else
      {
        return internal::make_fixed_size_adapter<vector_space_descriptor_of_t<A, 0>, vector_space_descriptor_of_t<B, 1>>(
          NestedInterface::contract(nested_object(std::forward<A>(a)), std::forward<B>(b)));
      }
    }


#ifdef __cpp_concepts
    template<bool on_the_right, typename A, typename B> requires
      interface::contract_in_place_defined_for<Nested, on_the_right, A&&, B&&> or
      interface::contract_in_place_defined_for<Nested, on_the_right, nested_object_of_t<A&&>, B&&>
#else
    template<bool on_the_right, typename A, typename B, std::enable_if_t<
      interface::contract_in_place_defined_for<Nested, on_the_right, A&&, B&&> or
      interface::contract_in_place_defined_for<Nested, on_the_right, typename nested_object_of<A&&>::type, B&&>, int> = 0>
#endif
    static decltype(auto)
    contract_in_place(A&& a, B&& b)
    {
      if constexpr (interface::contract_in_place_defined_for<Nested, on_the_right, A&&, B&&>)
      {
        return NestedInterface::template contract_in_place<on_the_right>(std::forward<A>(a), std::forward<B>(b));
      }
      else
      {
        auto&& ret = NestedInterface::template contract_in_place<on_the_right>(nested_object(std::forward<A>(a)), std::forward<B>(b));
        using Ret = decltype(ret);
        if constexpr (std::is_lvalue_reference_v<Ret> and std::is_same_v<Ret, nested_object_of_t<A&&>>)
        {
          return std::forward<A>(a);
        }
        else if constexpr (on_the_right)
        {
          return internal::make_fixed_size_adapter<vector_space_descriptor_of_t<A, 0>, vector_space_descriptor_of_t<B, 1>>(std::forward<Ret>(ret));
        }
        else
        {
          return internal::make_fixed_size_adapter<vector_space_descriptor_of_t<B, 0>, vector_space_descriptor_of_t<A, 1>>(std::forward<Ret>(ret));
        }
      }
    }


#ifdef __cpp_concepts
    template<triangle_type tri, indexible Arg> requires
      interface::cholesky_factor_defined_for<Nested, tri, Arg&&> or
      interface::cholesky_factor_defined_for<Nested, tri, nested_object_of_t<Arg&&>>
    static constexpr triangular_matrix<tri> auto
#else
    template<triangle_type tri, typename Arg, std::enable_if_t<
      interface::cholesky_factor_defined_for<Nested, tri, Arg&&> or
      interface::cholesky_factor_defined_for<Nested, tri, typename nested_object_of<Arg&&>::type>, int> = 0>
    static constexpr auto
#endif
    cholesky_factor(Arg&& arg)
    {
      if constexpr (interface::cholesky_factor_defined_for<Nested, tri, Arg&&>)
      {
        return NestedInterface::template cholesky_factor<tri>(std::forward<Arg>(arg));
      }
      else
      {
        auto tri = NestedInterface::template cholesky_factor<tri>(nested_object(std::forward<Arg>(arg)));
        return internal::make_fixed_square_adapter_like(std::move(tri));
      }
    }


#ifdef __cpp_concepts
    template<HermitianAdapterType significant_triangle, indexible A, indexible U> requires
      interface::rank_update_self_adjoint_defined_for<Nested, significant_triangle, A&&, U&&, const scalar_type_of_t<A>&> or
      interface::rank_update_self_adjoint_defined_for<Nested, significant_triangle, nested_object_of_t<A&&>, U&&, const scalar_type_of_t<A>&>
    static constexpr hermitian_matrix auto
#else
    template<HermitianAdapterType significant_triangle, typename A, typename U, std::enable_if_t<
      interface::rank_update_self_adjoint_defined_for<Nested, significant_triangle, A&&, U&&, const typename scalar_type_of<A>::type&> or
      interface::rank_update_self_adjoint_defined_for<Nested, significant_triangle, typename nested_object_of<A&&>::type, U&&, const typename scalar_type_of<A>::type&>, int> = 0>
    static constexpr auto
#endif
    rank_update_hermitian(A&& a, U&& u, const scalar_type_of_t<A>& alpha)
    {
      if constexpr (interface::rank_update_self_adjoint_defined_for<Nested, significant_triangle, A&&, U&&, const scalar_type_of_t<A>&>)
      {
        return NestedInterface::template rank_update_hermitian<significant_triangle>(std::forward<A>(a), std::forward<U>(u), alpha);
      }
      else
      {
        auto tri = NestedInterface::template rank_update_hermitian<significant_triangle>(nested_object(std::forward<A>(a), std::forward<U>(u), alpha));
        return internal::make_fixed_square_adapter_like(std::move(tri));
      }
    }


#ifdef __cpp_concepts
    template<triangle_type tri, indexible A, indexible U> requires
      interface::rank_update_triangular_defined_for<Nested, tri, A&&, U&&, const scalar_type_of_t<A>&> or
      interface::rank_update_triangular_defined_for<Nested, tri, nested_object_of_t<A&&>, U&&, const scalar_type_of_t<A>&>
    static constexpr triangular_matrix<tri> auto
#else
    template<triangle_type tri, typename A, typename U, std::enable_if_t<
      interface::rank_update_triangular_defined_for<Nested, tri, A&&, U&&, const typename scalar_type_of<A>::type&> or
      interface::rank_update_triangular_defined_for<Nested, tri, typename nested_object_of<A&&>::type, U&&, const typename scalar_type_of<A>::type&>, int> = 0>
    static constexpr auto
#endif
    rank_update_triangular(A&& a, U&& u, const scalar_type_of_t<A>& alpha)
    {
      if constexpr (interface::rank_update_triangular_defined_for<Nested, tri, A&&, U&&, const scalar_type_of_t<A>&>)
      {
        return NestedInterface::template rank_update_triangular<tri>(std::forward<A>(a), std::forward<U>(u), alpha);
      }
      else
      {
        auto tri = NestedInterface::template rank_update_triangular<tri>(nested_object(std::forward<A>(a), std::forward<U>(u), alpha));
        return internal::make_fixed_square_adapter_like(std::move(tri));
      }
    }


#ifdef __cpp_concepts
    template<bool must_be_unique, bool must_be_exact, typename A, typename B> requires
      interface::solve_defined_for<Nested, must_be_unique, must_be_exact, A&&, B&&> or
      interface::solve_defined_for<Nested, must_be_unique, must_be_exact, nested_object_of_t<A&&>, 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
#else
    template<bool must_be_unique, bool must_be_exact, typename A, typename B, std::enable_if_t<
      interface::solve_defined_for<Nested, must_be_unique, must_be_exact, A&&, B&&> or
      interface::solve_defined_for<Nested, must_be_unique, must_be_exact, typename nested_object_of<A&&>::type, B&&>, int> = 0>
    static auto
#endif
    solve(A&& a, B&& b)
    {
      if constexpr (interface::solve_defined_for<Nested, must_be_unique, must_be_exact, A&&, B&&>)
      {
        return NestedInterface::template solve<must_be_unique, must_be_exact>(std::forward<A>(a), std::forward<B>(b));
      }
      else
      {
        return internal::make_fixed_size_adapter<vector_space_descriptor_of_t<A, 1>, vector_space_descriptor_of_t<B, 1>>(
          NestedInterface::template solve<must_be_unique, must_be_exact>(nested_object(std::forward<A>(a)), std::forward<B>(b)));
      }
    }


#ifdef __cpp_concepts
    template<typename A> requires
      interface::LQ_decomposition_defined_for<Nested, A&&> or
      interface::LQ_decomposition_defined_for<Nested, nested_object_of_t<A&&>>
#else
    template<typename A, std::enable_if_t<
      interface::LQ_decomposition_defined_for<Nested, A&&> or
      interface::LQ_decomposition_defined_for<Nested, typename nested_object_of<A&&>::type>, int> = 0>
#endif
    static auto
    LQ_decomposition(A&& a)
    {
      if constexpr (interface::LQ_decomposition_defined_for<Nested, A&&>)
      {
        return NestedInterface::LQ_decomposition(std::forward<A>(a));
      }
      else
      {
        auto&& ret = NestedInterface::LQ_decomposition(nested_object(std::forward<A>(a)));
        using D0 = vector_space_descriptor_of<A, 0>;
        return internal::make_fixed_square_adapter_like<D0>(std::forward<decltype(ret)>(ret));
      }
    }


#ifdef __cpp_concepts
    template<typename A> requires
      interface::QR_decomposition_defined_for<Nested, A&&> or
      interface::QR_decomposition_defined_for<Nested, nested_object_of_t<A&&>>
#else
    template<typename A, std::enable_if_t<
      interface::QR_decomposition_defined_for<Nested, A&&> or
      interface::QR_decomposition_defined_for<Nested, typename nested_object_of<A&&>::type>, int> = 0>
#endif
    static auto
    QR_decomposition(A&& a)
    {
      if constexpr (interface::QR_decomposition_defined_for<Nested, A&&>)
      {
        return NestedInterface::QR_decomposition(std::forward<A>(a));
      }
      else
      {
        auto&& ret = NestedInterface::QR_decomposition(nested_object(std::forward<A>(a)));
        using D1 = vector_space_descriptor_of<A, 1>;
        return internal::make_fixed_square_adapter_like<D1>(std::forward<decltype(ret)>(ret));
      }
    }
    */

  };

}


#endif