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 <cstddef>
       8             : #include <limits>
       9             : 
      10             : #include "DataStructures/Tensor/Expressions/DataTypeSupport.hpp"
      11             : #include "DataStructures/Tensor/Expressions/TensorExpression.hpp"
      12             : #include "Utilities/ForceInline.hpp"
      13             : #include "Utilities/TMPL.hpp"
      14             : 
      15             : namespace tenex {
      16             : /// \ingroup TensorExpressionsGroup
      17             : /// \brief Marks a class as being a `NumberAsExpression<DataType>`
      18             : ///
      19             : /// \details
      20             : /// The empty base class provides a simple means for checking if a type is a
      21             : /// `NumberAsExpression<DataType>`.
      22           1 : struct MarkAsNumberAsExpression {};
      23             : 
      24             : /// \ingroup TensorExpressionsGroup
      25             : /// \brief Defines an expression representing a number
      26             : ///
      27             : /// \details
      28             : /// For details on aliases and members defined in this class, as well as general
      29             : /// `TensorExpression` terminology used in its members' documentation, see
      30             : /// documentation for `TensorExpression`.
      31             : template <typename DataType>
      32           1 : struct NumberAsExpression
      33             :     : public TensorExpression<NumberAsExpression<DataType>, DataType,
      34             :                               tmpl::list<>, tmpl::list<>, tmpl::list<>>,
      35             :       MarkAsNumberAsExpression {
      36             :   static_assert(detail::is_supported_number_datatype_v<DataType>,
      37             :                 "TensorExpressions currently only support numeric terms whose "
      38             :                 "type is double or std::complex<double>. It is possible to add "
      39             :                 "support for more numeric types.");
      40             : 
      41             :   // === Index properties ===
      42             :   /// The type of the data being stored in the result of the expression
      43           1 :   using type = DataType;
      44             :   /// The list of \ref SpacetimeIndex "TensorIndexType"s of the result of the
      45             :   /// expression
      46           1 :   using symmetry = tmpl::list<>;
      47             :   /// The list of \ref SpacetimeIndex "TensorIndexType"s of the result of the
      48             :   /// expression
      49           1 :   using index_list = tmpl::list<>;
      50             :   /// The list of generic `TensorIndex`s of the result of the expression
      51           1 :   using args_list = tmpl::list<>;
      52             :   /// The number of tensor indices in the result of the expression
      53           1 :   static constexpr auto num_tensor_indices = 0;
      54             : 
      55             :   // === Expression subtree properties ===
      56             :   /// The number of arithmetic tensor operations done in the subtree for the
      57             :   /// left operand, which is 0 because this is a leaf expression
      58           1 :   static constexpr size_t num_ops_left_child = 0;
      59             :   /// The number of arithmetic tensor operations done in the subtree for the
      60             :   /// right operand, which is 0 because this is a leaf expression
      61           1 :   static constexpr size_t num_ops_right_child = 0;
      62             :   /// The total number of arithmetic tensor operations done in this expression's
      63             :   /// whole subtree, which is 0 because this is a leaf expression
      64           1 :   static constexpr size_t num_ops_subtree = 0;
      65             :   /// The height of this expression's node in the expression tree relative to
      66             :   /// the closest `TensorAsExpression` leaf in its subtree. Because this
      67             :   /// expression type is leaf, the height for this type is set to the maximum
      68             :   /// `size_t` value to encode a sense of maximal height.
      69           1 :   static constexpr size_t height_relative_to_closest_tensor_leaf_in_subtree =
      70             :       std::numeric_limits<size_t>::max();
      71             : 
      72             :   // === Properties for splitting up subexpressions along the primary path ===
      73             :   // These definitions only have meaning if this expression actually ends up
      74             :   // being along the primary path that is taken when evaluating the whole tree.
      75             :   // See documentation for `TensorExpression` for more details.
      76             :   /// If on the primary path, whether or not the expression is an ending point
      77             :   /// of a leg
      78           1 :   static constexpr bool is_primary_end = true;
      79             :   /// If on the primary path, this is the remaining number of arithmetic tensor
      80             :   /// operations that need to be done in the subtree of the child along the
      81             :   /// primary path, given that we will have already computed the whole subtree
      82             :   /// at the next lowest leg's starting point. This is just 0 because this
      83             :   /// expression is a leaf.
      84           1 :   static constexpr size_t num_ops_to_evaluate_primary_left_child = 0;
      85             :   /// If on the primary path, this is the remaining number of arithmetic tensor
      86             :   /// operations that need to be done in the right operand's subtree. This is
      87             :   /// just 0 because this expression is a leaf.
      88           1 :   static constexpr size_t num_ops_to_evaluate_primary_right_child = 0;
      89             :   /// If on the primary path, this is the remaining number of arithmetic tensor
      90             :   /// operations that need to be done for this expression's subtree, given that
      91             :   /// we will have already computed the subtree at the next lowest leg's
      92             :   /// starting point. This is just 0 because this expression is a leaf.
      93           1 :   static constexpr size_t num_ops_to_evaluate_primary_subtree = 0;
      94             :   /// If on the primary path, whether or not the expression is a starting point
      95             :   /// of a leg
      96           1 :   static constexpr bool is_primary_start = false;
      97             :   /// If on the primary path, whether or not the expression's child along the
      98             :   /// primary path is a subtree that contains a starting point of a leg along
      99             :   /// the primary path. This is always falls because this expression is a leaf.
     100           1 :   static constexpr bool primary_child_subtree_contains_primary_start = false;
     101             :   /// If on the primary path, whether or not this subtree contains a starting
     102             :   /// point of a leg along the primary path
     103           1 :   static constexpr bool primary_subtree_contains_primary_start =
     104             :       is_primary_start;
     105             : 
     106           0 :   NumberAsExpression(const type& number) : number_(number) {}
     107           0 :   ~NumberAsExpression() override = default;
     108             : 
     109             :   // This expression does not represent a tensor, nor does it have any children,
     110             :   // so we should never need to assert that the LHS `Tensor` is not equal to the
     111             :   // number stored by this expression
     112             :   template <typename LhsTensor>
     113           0 :   void assert_lhs_tensor_not_in_rhs_expression(
     114             :       const gsl::not_null<LhsTensor*>) const = delete;
     115             :   // This expression does not represent a tensor, nor does it have any children,
     116             :   // so we should never need to assert that instances of the LHS Tensor in this
     117             :   // expression's subtree have the same generic index order
     118             :   template <typename LhsTensorIndices, typename LhsTensor>
     119           0 :   void assert_lhs_tensorindices_same_in_rhs(
     120             :       const gsl::not_null<LhsTensor*> lhs_tensor) const = delete;
     121             :   // This expression is a non-`Tensor` leaf, so we should never try to get the
     122             :   // size of a `Tensor` component from this expression.
     123           0 :   size_t get_rhs_tensor_component_size() const = delete;
     124             : 
     125             :   /// \brief Returns the number represented by the expression
     126             :   ///
     127             :   /// \return the number represented by this expression
     128             :   SPECTRE_ALWAYS_INLINE type
     129           1 :   get(const std::array<size_t, num_tensor_indices>& /*multi_index*/) const {
     130             :     return number_;
     131             :   }
     132             : 
     133             :   /// \brief Returns the number represented by the expression
     134             :   ///
     135             :   /// \return the number represented by this expression
     136             :   template <typename ResultType>
     137           1 :   SPECTRE_ALWAYS_INLINE type get_primary(
     138             :       const ResultType& /*result_component*/,
     139             :       const std::array<size_t, num_tensor_indices>& /*multi_index*/) const {
     140             :     return number_;
     141             :   }
     142             : 
     143             :   // This expression is a leaf and therefore will never be the start of a leg
     144             :   // to evaluate in a split tree, which is enforced by
     145             :   // `is_primary_start == false`. Therefore, this function should never be
     146             :   // called on this expression type.
     147             :   template <typename ResultType>
     148           0 :   void evaluate_primary_subtree(
     149             :       ResultType&,
     150             :       const std::array<size_t, num_tensor_indices>&) const = delete;
     151             : 
     152             :  private:
     153             :   /// Number represented by this expression
     154           1 :   type number_;
     155             : };
     156             : }  // namespace tenex