ogdenc/OpenKalman/contract__in__place_8hpp_source.html

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


 namespace OpenKalman
 {
 #ifdef __cpp_concepts
   template<bool on_the_right = true, square_shaped<Applicability::permitted> A, square_shaped<Applicability::permitted> B> requires
     vector_space_descriptors_may_match_with<A, B> and (not triangular_matrix<A> or triangle_type_of_v<A> == triangle_type_of_v<A, B>) and
     (index_count_v<A> == dynamic_size or index_count_v<A> <= 2) and (index_count_v<B> == dynamic_size or index_count_v<B> <= 2)
 #else
   template<bool on_the_right = true, typename A, typename B, std::enable_if_t<
     square_shaped<A, Applicability::permitted> and square_shaped<B, Applicability::permitted> and
     vector_space_descriptors_may_match_with<A, B> and (not triangular_matrix<A> or triangle_type_of<A>::value == triangle_type_of<A, B>::value) and
     (index_count<A>::value == dynamic_size or index_count<A>::value <= 2) and (index_count<B>::value == dynamic_size or index_count<B>::value <= 2), int> = 0>
 #endif
   constexpr A&&
   contract_in_place(A&& a, B&& b)
   {
     if constexpr (not square_shaped<A> or not square_shaped<B> or not vector_space_descriptors_match_with<A, B>) if (not vector_space_descriptors_match(a, b))
       throw std::invalid_argument {"Arguments to contract_in_place must match in size and be square matrices"};

     if constexpr (zero<A> or identity_matrix<B>)
     {
       ;
     }
     else if constexpr (zero<B> and writable<A>)
     {
       assign(a, std::forward<B>(b));
     }
     else if constexpr (interface::contract_in_place_defined_for<A, on_the_right, A&, B&&>)
     {
       return interface::library_interface<std::decay_t<A>>::template contract_in_place<on_the_right>(a, std::forward<B>(b));
     }
     else
     {
       assign(a, to_dense_object(contract(a, std::forward<B>(b))));
     }
     return std::forward<A>(a);
   }


 } // namespace OpenKalman


 #endif //OPENKALMAN_CONTRACT_IN_PLACE_HPP
OpenKalman::contract
decltype(auto) constexpr contract(A &&a, B &&b)
Matrix multiplication of A * B.
Definition: contract.hpp:54

OpenKalman::values::value
constexpr bool value
T is numerical value or is reducible to a numerical value.
Definition: value.hpp:31

OpenKalman::to_dense_object
decltype(auto) constexpr to_dense_object(Arg &&arg)
Convert the argument to a dense, writable matrix of a particular scalar type.
Definition: to_dense_object.hpp:37

OpenKalman
The root namespace for OpenKalman.
Definition: basics.hpp:34

OpenKalman::interface::library_interface
An interface to various routines from the linear algebra library associated with indexible object T...
Definition: library_interface.hpp:37

OpenKalman::vector_space_descriptors_match
constexpr bool vector_space_descriptors_match(const Ts &...ts)
Return true if every set of coordinates::pattern of a set of objects match.
Definition: vector_space_descriptors_match.hpp:62

OpenKalman::contract_in_place
constexpr A && contract_in_place(A &&a, B &&b)
In-place matrix multiplication of A * B, storing the result in A.
Definition: contract_in_place.hpp:38

OpenKalman::assign
constexpr To && assign(To &&a, From &&b)
Assign a writable object from an indexible object.
Definition: assign.hpp:51

OpenKalman::dynamic_size
constexpr std::size_t dynamic_size
A constant indicating that a size or index is dynamic.
Definition: global-definitions.hpp:33