Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <blaze/math/traits/MultTrait.h>
       7              : 
       8              : #include "Utilities/Gsl.hpp"
       9              : 
      10              : /// @{
      11              : /// \ingroup UtilitiesGroup
      12              : /// \brief Computes the outer product between two vectors.
      13              : /// \details For vectors \f$A\f$ and \f$B\f$, the resulting outer product is
      14              : /// \f$\{A_1 B_1,\, A_2 B_1\, \dots\, A_N B_1,\, A_1 B_2\, \dots\, A_N B_M\}\f$.
      15              : /// This is useful for generating separable volume data from its constituent
      16              : /// inputs.
      17              : template <typename LhsVectorType, typename RhsVectorType,
      18              :           typename ResultVectorType =
      19              :               typename blaze::MultTrait<LhsVectorType, RhsVectorType>::Type>
      20            1 : void outer_product(const gsl::not_null<ResultVectorType*> result,
      21              :                    const LhsVectorType& lhs, const RhsVectorType& rhs) {
      22              :   result->destructive_resize(lhs.size() * rhs.size());
      23              :   for (size_t i = 0; i < rhs.size(); ++i) {
      24              :     ResultVectorType view{result->data() + i * lhs.size(), lhs.size()};
      25              :     view = rhs[i] * lhs;
      26              :   }
      27              : }
      28              : 
      29              : template <typename LhsVectorType, typename RhsVectorType,
      30              :           typename ResultVectorType =
      31              :               typename blaze::MultTrait<LhsVectorType, RhsVectorType>::Type>
      32            1 : ResultVectorType outer_product(const LhsVectorType& lhs,
      33              :                                const RhsVectorType& rhs) {
      34              :   auto result = ResultVectorType{lhs.size() * rhs.size()};
      35              :   outer_product(make_not_null(&result), lhs, rhs);
      36              :   return result;
      37              : }
      38              : /// @}
      39              : 
      40              : /// @{
      41              : /// \ingroup UtilitiesGroup
      42              : /// \brief Creates or fills a vector with data from `to_repeat` copied
      43              : /// `times_to_repeat`  times in sequence.
      44              : ///
      45              : /// \details This can be useful for generating data that consists of the same
      46              : /// block of values duplicated a number of times. For instance, this can be used
      47              : /// to create a vector representing three-dimensional volume data from a
      48              : /// corresponding two-dimensional vector data, if the two-dimensional data
      49              : /// corresponds to the two fastest-varying directions of the desired
      50              : /// three-dimensional representation. The result would then be uniform in the
      51              : /// slowest-varying direction of the three dimensional grid.
      52              : template <typename VectorType>
      53            1 : void fill_with_n_copies(
      54              :     // NOLINTNEXTLINE(readability-avoid-const-params-in-decls)
      55              :     const gsl::not_null<VectorType*> result, const VectorType& to_copy,
      56              :     // NOLINTNEXTLINE(readability-avoid-const-params-in-decls)
      57              :     const size_t times_to_copy) {
      58              :   result->destructive_resize(to_copy.size() * times_to_copy);
      59              :   for (size_t i = 0; i < times_to_copy; ++i) {
      60              :     VectorType view{result->data() + i * to_copy.size(), to_copy.size()};
      61              :     view = to_copy;
      62              :   }
      63              : }
      64              : 
      65              : // clang-tidy incorrectly believes this to be a forward-declaration
      66              : template <typename VectorType>
      67            1 : VectorType create_vector_of_n_copies(const VectorType& to_copy,
      68              :                                      const size_t times_to_copy) {  // NOLINT
      69              :   auto result = VectorType{to_copy.size() * times_to_copy};
      70              :   fill_with_n_copies(make_not_null(&result), to_copy, times_to_copy);
      71              :   return result;
      72              : }
      73              : /// @}