Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <array>
       7             : #include <complex>
       8             : #include <cstddef>
       9             : #include <type_traits>
      10             : #include <utility>
      11             : 
      12             : #include "DataStructures/ComplexDataVector.hpp"
      13             : #include "DataStructures/DataVector.hpp"
      14             : #include "Utilities/Gsl.hpp"
      15             : #include "Utilities/TMPL.hpp"
      16             : 
      17             : /// \ingroup DataStructuresGroup
      18             : /// A comma-separated list of valid template arguments to MathWrapper.
      19             : /// Useful for explicit instantiations.
      20             : ///
      21             : /// \snippet Helpers/DataStructures/MathWrapperDetail.cpp MATH_WRAPPER_TYPES_instantiate
      22           1 : #define MATH_WRAPPER_TYPES \
      23             :   double, std::complex<double>, DataVector, ComplexDataVector
      24             : 
      25             : /// \ingroup DataStructuresGroup
      26             : /// Type-erased data for performing math on.
      27             : ///
      28             : /// This class can only be instantiated with possibly const-qualified
      29             : /// types from \ref MATH_WRAPPER_TYPES, which can be assumed to
      30             : /// support the mathematical operations of a linear-algebra vector.
      31             : /// Instances of this class with those template arguments can be
      32             : /// created using overloads of `make_math_wrapper` (passing a `const
      33             : /// T&` for const versions and a `gsl::not_null<T*>` for mutable
      34             : /// versions).  Other data structures (such as `Variables`) can add
      35             : /// additional overloads implemented on top of these basic ones.
      36             : ///
      37             : /// \snippet Test_MathWrapper.cpp MathWrapper
      38             : template <typename T>
      39           1 : class MathWrapper {
      40             :  private:
      41           0 :   using MutableT = std::remove_const_t<T>;
      42             : 
      43             :   static_assert(
      44             :       tmpl::list_contains_v<tmpl::list<MATH_WRAPPER_TYPES>, MutableT>);
      45             : 
      46             :   template <typename U = T,
      47             :             bool IsVector =
      48             :                 not(std::is_same_v<std::decay_t<T>, double> or
      49             :                     std::is_same_v<std::decay_t<T>, std::complex<double>>),
      50             :             bool IsConst = std::is_const_v<T>>
      51           0 :   struct Impl {
      52           0 :     using scalar_type = std::remove_const_t<U>;
      53           0 :     T& data;
      54           0 :     Impl(const gsl::not_null<T*> data_in) : data(*data_in) {}
      55             :   };
      56             : 
      57             :   template <typename U>
      58           0 :   struct Impl<U, true, false> {
      59           0 :     using scalar_type = typename U::value_type;
      60             :     // NOLINTNEXTLINE(spectre-mutable)
      61           0 :     mutable T data;
      62           0 :     Impl(const gsl::not_null<T*> data_in) : data(std::move(*data_in)) {}
      63             :   };
      64             : 
      65             :   template <typename U>
      66           0 :   struct Impl<U, true, true> {
      67           0 :     using scalar_type = typename U::value_type;
      68           0 :     const T data;
      69             :     // Need to invoke the move-from-mutable constructor on DataVector, etc.
      70           0 :     Impl(const gsl::not_null<MutableT*> data_in) : data(std::move(*data_in)) {}
      71             :   };
      72             : 
      73           0 :   explicit MathWrapper(const gsl::not_null<MutableT*> data) : data_(data) {}
      74             : 
      75           0 :   friend MathWrapper<T> make_math_wrapper(
      76             :       tmpl::conditional_t<std::is_const_v<T>, T&, gsl::not_null<T*>>);
      77             : 
      78             :  public:
      79             :   /// The class's template parameter.
      80           1 :   using value_type = T;
      81             :   /// Scalar type for linear-algebra operations.  Either double or
      82             :   /// std::complex<double>.
      83           1 :   using scalar_type = typename Impl<>::scalar_type;
      84             : 
      85           0 :   T& operator*() const { return data_.data; }
      86           0 :   T* operator->() const { return &data_.data; }
      87             : 
      88           0 :   MathWrapper(MathWrapper&&) = default;
      89             : 
      90           0 :   MathWrapper() = delete;
      91           0 :   MathWrapper(const MathWrapper&) = delete;
      92           0 :   MathWrapper& operator=(const MathWrapper&) = delete;
      93           0 :   MathWrapper& operator=(MathWrapper&&) = delete;
      94             : 
      95             :   /// Convert MathWrapper wrapping a mutable value to one wrapping a
      96             :   /// const one.
      97             :   ///
      98             :   /// These methods will fail to compile if called on a MathWrapper
      99             :   /// wrapping a const value.  The `to_const` method is useful because
     100             :   /// C++ fails to resolve the implicit conversion in many cases.
     101             :   /// @{
     102           1 :   operator MathWrapper<const T>() const;
     103             : 
     104           1 :   MathWrapper<const T> to_const() const {
     105             :     return static_cast<MathWrapper<const T>>(*this);
     106             :   }
     107             :   /// @}
     108             : 
     109             :  private:
     110           0 :   Impl<> data_;
     111             : };
     112             : 
     113             : /// \ingroup DataStructuresGroup
     114             : /// A fundamental overload of the MathWrapper construction functions.
     115             : ///
     116             : /// Additional overloads can be implemented in terms of the
     117             : /// fundamental overloads.
     118             : /// @{
     119           1 : inline MathWrapper<double> make_math_wrapper(
     120             :     const gsl::not_null<double*> data) {
     121             :   return MathWrapper<double>(data);
     122             : }
     123             : 
     124           1 : inline MathWrapper<const double> make_math_wrapper(const double& data) {
     125             :   return MathWrapper<const double>(const_cast<double*>(&data));
     126             : }
     127             : 
     128           1 : inline MathWrapper<std::complex<double>> make_math_wrapper(
     129             :     const gsl::not_null<std::complex<double>*> data) {
     130             :   return MathWrapper<std::complex<double>>(data);
     131             : }
     132             : 
     133           1 : inline MathWrapper<const std::complex<double>> make_math_wrapper(
     134             :     const std::complex<double>& data) {
     135             :   return MathWrapper<const std::complex<double>>(
     136             :       const_cast<std::complex<double>*>(&data));
     137             : }
     138             : 
     139           1 : inline MathWrapper<DataVector> make_math_wrapper(
     140             :     const gsl::not_null<DataVector*> data) {
     141             :   if (UNLIKELY(data->size() == 0)) {
     142             :     DataVector empty{};
     143             :     return MathWrapper<DataVector>(&empty);
     144             :   }
     145             :   DataVector referencing(data->data(), data->size());
     146             :   return MathWrapper<DataVector>(&referencing);
     147             : }
     148             : 
     149           1 : inline MathWrapper<const DataVector> make_math_wrapper(const DataVector& data) {
     150             :   if (UNLIKELY(data.size() == 0)) {
     151             :     DataVector empty{};
     152             :     return MathWrapper<const DataVector>(&empty);
     153             :   }
     154             :   DataVector referencing(const_cast<double*>(data.data()), data.size());
     155             :   return MathWrapper<const DataVector>(&referencing);
     156             : }
     157             : 
     158           1 : inline MathWrapper<ComplexDataVector> make_math_wrapper(
     159             :     const gsl::not_null<ComplexDataVector*> data) {
     160             :   if (UNLIKELY(data->size() == 0)) {
     161             :     ComplexDataVector empty{};
     162             :     return MathWrapper<ComplexDataVector>(&empty);
     163             :   }
     164             :   ComplexDataVector referencing(data->data(), data->size());
     165             :   return MathWrapper<ComplexDataVector>(&referencing);
     166             : }
     167             : 
     168           1 : inline MathWrapper<const ComplexDataVector> make_math_wrapper(
     169             :     const ComplexDataVector& data) {
     170             :   if (UNLIKELY(data.size() == 0)) {
     171             :     ComplexDataVector empty{};
     172             :     return MathWrapper<const ComplexDataVector>(&empty);
     173             :   }
     174             :   ComplexDataVector referencing(const_cast<std::complex<double>*>(data.data()),
     175             :                                 data.size());
     176             :   return MathWrapper<const ComplexDataVector>(&referencing);
     177             : }
     178             : /// @}
     179             : 
     180             : template <typename T>
     181             : MathWrapper<T>::operator MathWrapper<const T>() const {
     182             :   return make_math_wrapper(data_.data);
     183             : }
     184             : 
     185             : template <typename T, size_t N>
     186           0 : auto make_math_wrapper(const gsl::not_null<std::array<T, N>*> array) {
     187             :   DataVector referencing(array->data(), array->size());
     188             :   return make_math_wrapper(&referencing);
     189             : }
     190             : 
     191             : template <typename T, size_t N>
     192           0 : auto make_math_wrapper(const std::array<T, N>& array) {
     193             :   const DataVector referencing(const_cast<double*>(array.data()), array.size());
     194             :   return make_math_wrapper(referencing);
     195             : }
     196             : 
     197             : /// \ingroup DataStructuresGroup
     198             : /// The `value_type` for a MathWrapper wrapping `T`.
     199             : template <typename T>
     200           1 : using math_wrapper_type = typename decltype(make_math_wrapper(
     201             :     std::declval<tmpl::conditional_t<std::is_const_v<T>, const T&,
     202             :                                      gsl::not_null<T*>>>()))::value_type;
     203             : 
     204             : /// \ingroup DataStructuresGroup
     205             : /// A fundamental overload for owning type-erasure.  Returns its argument
     206             : /// unchanged.
     207             : ///
     208             : /// Additional overloads should always return the `math_wrapper_type`
     209             : /// of their argument, and should be implemented to avoid allocations
     210             : /// and copying whenever possible.
     211             : /// @{
     212           1 : inline double into_math_wrapper_type(double&& data) { return data; }
     213             : 
     214           1 : inline std::complex<double> into_math_wrapper_type(
     215             :     std::complex<double>&& data) {
     216             :   return data;
     217             : }
     218             : 
     219           1 : inline DataVector into_math_wrapper_type(DataVector&& data) {
     220             :   return std::move(data);
     221             : }
     222             : 
     223           1 : inline ComplexDataVector into_math_wrapper_type(ComplexDataVector&& data) {
     224             :   return std::move(data);
     225             : }
     226             : /// @}