Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include "DataStructures/ComplexModalVector.hpp"
       7             : #include "DataStructures/DataVector.hpp"  // IWYU pragma: keep
       8             : #include "DataStructures/DiagonalModalOperator.hpp"
       9             : #include "DataStructures/VectorImpl.hpp"
      10             : #include "Utilities/TMPL.hpp"
      11             : 
      12             : /// \cond
      13             : class DiagonalModalOperator;
      14             : class ModalVector;
      15             : class ComplexDiagonalModalOperator;
      16             : /// \endcond
      17             : 
      18             : namespace blaze {
      19           0 : DECLARE_GENERAL_VECTOR_BLAZE_TRAITS(ComplexDiagonalModalOperator);
      20             : }  // namespace blaze
      21             : 
      22             : /*!
      23             :  * \ingroup DataStructuresGroup
      24             :  * \brief A class for an element-wise complex multiplier of modal coefficients.
      25             :  *
      26             :  * \details A `ComplexDiagonalModalOperator` holds an array of factors to
      27             :  * multiply by spectral coefficients, and can be either owning (the array is
      28             :  * deleted when the `ComplexDiagonalModalOperator` goes out of scope) or
      29             :  * non-owning, meaning it just has a pointer to an array.
      30             :  *
      31             :  * `ComplexDiagonalModalOperator`s are intended to represent a diagonal matrix
      32             :  * that can operate (via the `*` operator) on spectral coefficients represented
      33             :  * by `ComplexModalVector`s easily. Only basic mathematical operations are
      34             :  * supported with `ComplexDiagonalModalOperator`s.
      35             :  * `ComplexDiagonalModalOperator`s may be added, subtracted, multiplied, or
      36             :  * divided, and all arithmetic operations are similarly supported between
      37             :  * `ComplexDiagonalModalOperator`s and `DiagonalModalOperator`s. In addition,
      38             :  * the following operations with modal data structures are supported:
      39             :  * - multiplication of a `ComplexDiagonalModalOperator` and a
      40             :  *   `ComplexModalVector` resulting in a `ComplexModalVector`
      41             :  * - multiplication of a `ComplexDiagonalModalOperator` and a `ModalVector`
      42             :  *   resulting in a `ComplexModalVector`
      43             :  * - multiplication of a `DiagonalModalOperator` and a `ComplexModalVector`
      44             :  *   resulting in a `ComplexModalVector`
      45             :  * All of these multiplication operations are commutative, supporting the
      46             :  * interpretation of the modal data structure as either a 'row' or a 'column'
      47             :  * vector.
      48             :  *
      49             :  * The following unary operations are supported with
      50             :  * `ComplexDiagonalModalOperator`s:
      51             :  * - conj
      52             :  * - imag (results in a `DiagonalModalOperator`)
      53             :  * - real (results in a `DiagonalModalOperator`)
      54             :  *
      55             :  * Also, addition, subtraction, multiplication and division of
      56             :  * `DiagonalModalOperator`s with `std::complex<double>`s or `double`s is
      57             :  * supported.
      58             :  */
      59           1 : class ComplexDiagonalModalOperator
      60             :     : public VectorImpl<std::complex<double>, ComplexDiagonalModalOperator> {
      61             :  public:
      62           0 :   ComplexDiagonalModalOperator() = default;
      63           0 :   ComplexDiagonalModalOperator(const ComplexDiagonalModalOperator&) = default;
      64           0 :   ComplexDiagonalModalOperator(ComplexDiagonalModalOperator&&) = default;
      65           0 :   ComplexDiagonalModalOperator& operator=(const ComplexDiagonalModalOperator&) =
      66             :       default;
      67           0 :   ComplexDiagonalModalOperator& operator=(ComplexDiagonalModalOperator&&) =
      68             :       default;
      69           0 :   ~ComplexDiagonalModalOperator() = default;
      70             : 
      71           0 :   using BaseType =
      72             :       VectorImpl<std::complex<double>, ComplexDiagonalModalOperator>;
      73             : 
      74             :   using BaseType::operator=;
      75             :   using BaseType::VectorImpl;
      76             : };
      77             : 
      78             : namespace blaze {
      79           0 : VECTOR_BLAZE_TRAIT_SPECIALIZE_ARITHMETIC_TRAITS(ComplexDiagonalModalOperator);
      80             : 
      81           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(ComplexDiagonalModalOperator,
      82             :                                                DiagonalModalOperator, AddTrait,
      83             :                                                ComplexDiagonalModalOperator);
      84           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(ComplexDiagonalModalOperator,
      85             :                                                DiagonalModalOperator, DivTrait,
      86             :                                                ComplexDiagonalModalOperator);
      87           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(ComplexDiagonalModalOperator,
      88             :                                                DiagonalModalOperator, MultTrait,
      89             :                                                ComplexDiagonalModalOperator);
      90           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(ComplexDiagonalModalOperator,
      91             :                                                DiagonalModalOperator, SubTrait,
      92             :                                                ComplexDiagonalModalOperator);
      93             : 
      94           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(ComplexDiagonalModalOperator,
      95             :                                                double, AddTrait,
      96             :                                                ComplexDiagonalModalOperator);
      97           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(ComplexDiagonalModalOperator,
      98             :                                                double, DivTrait,
      99             :                                                ComplexDiagonalModalOperator);
     100           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(ComplexDiagonalModalOperator,
     101             :                                                double, MultTrait,
     102             :                                                ComplexDiagonalModalOperator);
     103           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(ComplexDiagonalModalOperator,
     104             :                                                double, SubTrait,
     105             :                                                ComplexDiagonalModalOperator);
     106             : 
     107           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(DiagonalModalOperator,
     108             :                                                std::complex<double>, AddTrait,
     109             :                                                ComplexDiagonalModalOperator);
     110           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(DiagonalModalOperator,
     111             :                                                std::complex<double>, DivTrait,
     112             :                                                ComplexDiagonalModalOperator);
     113           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(DiagonalModalOperator,
     114             :                                                std::complex<double>, MultTrait,
     115             :                                                ComplexDiagonalModalOperator);
     116           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(DiagonalModalOperator,
     117             :                                                std::complex<double>, SubTrait,
     118             :                                                ComplexDiagonalModalOperator);
     119             : 
     120           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(ComplexModalVector,
     121             :                                                DiagonalModalOperator,
     122             :                                                MultTrait, ComplexModalVector);
     123           0 : BLAZE_TRAIT_SPECIALIZE_COMPATIBLE_BINARY_TRAIT(ComplexModalVector,
     124             :                                                ComplexDiagonalModalOperator,
     125             :                                                MultTrait, ComplexModalVector);
     126             : template <>
     127           0 : struct MultTrait<ModalVector, ComplexDiagonalModalOperator> {
     128           0 :   using Type = ComplexModalVector;
     129             : };
     130             : template <>
     131           0 : struct MultTrait<ComplexDiagonalModalOperator, ModalVector> {
     132           0 :   using Type = ComplexModalVector;
     133             : };
     134             : 
     135             : template <typename Operator>
     136           0 : struct MapTrait<ComplexDiagonalModalOperator, Operator> {
     137             :   // Selectively allow unary operations for spectral coefficient operators
     138             :   static_assert(tmpl::list_contains_v<
     139             :                     tmpl::list<blaze::Conj, blaze::Sqrt,
     140             :                                blaze::Bind1st<blaze::Add, std::complex<double>>,
     141             :                                blaze::Bind2nd<blaze::Add, std::complex<double>>,
     142             :                                blaze::Bind1st<blaze::Div, std::complex<double>>,
     143             :                                blaze::Bind2nd<blaze::Div, std::complex<double>>,
     144             :                                blaze::Bind1st<blaze::Sub, std::complex<double>>,
     145             :                                blaze::Bind2nd<blaze::Sub, std::complex<double>>,
     146             :                                blaze::Bind1st<blaze::Add, double>,
     147             :                                blaze::Bind2nd<blaze::Add, double>,
     148             :                                blaze::Bind1st<blaze::Div, double>,
     149             :                                blaze::Bind2nd<blaze::Div, double>,
     150             :                                blaze::Bind1st<blaze::Sub, double>,
     151             :                                blaze::Bind2nd<blaze::Sub, double>>,
     152             :                     Operator>,
     153             :                 "This unary operation is not permitted on a "
     154             :                 "ComplexDiagonalModalOperator");
     155           0 :   using Type = ComplexDiagonalModalOperator;
     156             : };
     157             : template <>
     158           0 : struct MapTrait<ComplexDiagonalModalOperator, blaze::Imag> {
     159           0 :   using Type = DiagonalModalOperator;
     160             : };
     161             : template <>
     162           0 : struct MapTrait<ComplexDiagonalModalOperator, blaze::Real> {
     163           0 :   using Type = DiagonalModalOperator;
     164             : };
     165             : template <>
     166           0 : struct MapTrait<DiagonalModalOperator, blaze::Imag> {
     167           0 :   using Type = DiagonalModalOperator;
     168             : };
     169             : template <>
     170           0 : struct MapTrait<DiagonalModalOperator, blaze::Real> {
     171           0 :   using Type = DiagonalModalOperator;
     172             : };
     173             : 
     174             : template <typename Operator>
     175           0 : struct MapTrait<ComplexDiagonalModalOperator, ComplexDiagonalModalOperator,
     176             :                 Operator> {
     177             :   // Forbid math operations in this specialization of BinaryMap traits for
     178             :   // ComplexDiagonalModalOperator that are unlikely to be used on spectral
     179             :   // coefficients. Currently no non-arithmetic binary operations are supported.
     180             :   static_assert(tmpl::list_contains_v<tmpl::list<>, Operator>,
     181             :                 "This binary operation is not permitted on a "
     182             :                 "ComplexDiagonalModalOperator.");
     183           0 :   using Type = ComplexDiagonalModalOperator;
     184             : };
     185             : }  // namespace blaze
     186             : 
     187             : MAKE_STD_ARRAY_VECTOR_BINOPS(ComplexDiagonalModalOperator)
     188             : 
     189             : MAKE_WITH_VALUE_IMPL_DEFINITION_FOR(ComplexDiagonalModalOperator)