Line data Source code
1 1 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : /// \file
5 : /// Defines the tensor expression representing negation
6 :
7 : #pragma once
8 :
9 : #include <array>
10 : #include <cstddef>
11 : #include <limits>
12 : #include <utility>
13 :
14 : #include "DataStructures/Tensor/Expressions/NumberAsExpression.hpp"
15 : #include "DataStructures/Tensor/Expressions/TensorExpression.hpp"
16 : #include "Utilities/ForceInline.hpp"
17 : #include "Utilities/Gsl.hpp"
18 : #include "Utilities/TMPL.hpp"
19 :
20 : namespace tenex {
21 : /// \ingroup TensorExpressionsGroup
22 : /// \brief Defines the tensor expression representing the negation of a tensor
23 : /// expression
24 : ///
25 : /// \details
26 : /// For details on aliases and members defined in this class, as well as general
27 : /// `TensorExpression` terminology used in its members' documentation, see
28 : /// documentation for `TensorExpression`.
29 : ///
30 : /// \tparam T the type of tensor expression being negated
31 : template <typename T>
32 1 : struct Negate
33 : : public TensorExpression<Negate<T>, typename T::type, typename T::symmetry,
34 : typename T::index_list, typename T::args_list> {
35 : // === Index properties ===
36 : /// The type of the data being stored in the result of the expression
37 1 : using type = typename T::type;
38 : /// The ::Symmetry of the result of the expression
39 1 : using symmetry = typename T::symmetry;
40 : /// The list of \ref SpacetimeIndex "TensorIndexType"s of the result of the
41 : /// expression
42 1 : using index_list = typename T::index_list;
43 : /// The list of generic `TensorIndex`s of the result of the expression
44 1 : using args_list = typename T::args_list;
45 : /// The number of tensor indices in the result of the expression
46 1 : static constexpr auto num_tensor_indices = tmpl::size<index_list>::value;
47 :
48 : // === Expression subtree properties ===
49 : /// The number of arithmetic tensor operations done in the subtree for the
50 : /// left operand
51 1 : static constexpr size_t num_ops_left_child = T::num_ops_subtree;
52 : /// The number of arithmetic tensor operations done in the subtree for the
53 : /// right operand. This is 0 because this expression represents a unary
54 : /// operation.
55 1 : static constexpr size_t num_ops_right_child = 0;
56 : /// The total number of arithmetic tensor operations done in this expression's
57 : /// whole subtree
58 1 : static constexpr size_t num_ops_subtree = num_ops_left_child + 1;
59 : /// The height of this expression's node in the expression tree relative to
60 : /// the closest `TensorAsExpression` leaf in its subtree
61 1 : static constexpr size_t height_relative_to_closest_tensor_leaf_in_subtree =
62 : T::height_relative_to_closest_tensor_leaf_in_subtree !=
63 : std::numeric_limits<size_t>::max()
64 : ? T::height_relative_to_closest_tensor_leaf_in_subtree + 1
65 : : T::height_relative_to_closest_tensor_leaf_in_subtree;
66 :
67 : // === Properties for splitting up subexpressions along the primary path ===
68 : // These definitions only have meaning if this expression actually ends up
69 : // being along the primary path that is taken when evaluating the whole tree.
70 : // See documentation for `TensorExpression` for more details.
71 : /// If on the primary path, whether or not the expression is an ending point
72 : /// of a leg
73 1 : static constexpr bool is_primary_end = T::is_primary_start;
74 : /// If on the primary path, this is the remaining number of arithmetic tensor
75 : /// operations that need to be done in the subtree of the child along the
76 : /// primary path, given that we will have already computed the whole subtree
77 : /// at the next lowest leg's starting point.
78 1 : static constexpr size_t num_ops_to_evaluate_primary_left_child =
79 : is_primary_end ? 0 : T::num_ops_to_evaluate_primary_subtree;
80 : /// If on the primary path, this is the remaining number of arithmetic tensor
81 : /// operations that need to be done in the right operand's subtree. No
82 : /// splitting is currently done, so this is just `num_ops_right_child`.
83 1 : static constexpr size_t num_ops_to_evaluate_primary_right_child =
84 : num_ops_right_child;
85 : /// If on the primary path, this is the remaining number of arithmetic tensor
86 : /// operations that need to be done for this expression's subtree, given that
87 : /// we will have already computed the subtree at the next lowest leg's
88 : /// starting point
89 1 : static constexpr size_t num_ops_to_evaluate_primary_subtree =
90 : num_ops_to_evaluate_primary_left_child +
91 : num_ops_to_evaluate_primary_right_child + 1;
92 : /// If on the primary path, whether or not the expression is a starting point
93 : /// of a leg
94 1 : static constexpr bool is_primary_start =
95 : num_ops_to_evaluate_primary_subtree >=
96 : detail::max_num_ops_in_sub_expression<type>;
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
100 1 : static constexpr bool primary_child_subtree_contains_primary_start =
101 : T::primary_subtree_contains_primary_start;
102 : /// If on the primary path, whether or not this subtree contains a starting
103 : /// point of a leg along the primary path
104 1 : static constexpr bool primary_subtree_contains_primary_start =
105 : is_primary_start or primary_child_subtree_contains_primary_start;
106 :
107 0 : Negate(T t) : t_(std::move(t)) {}
108 0 : ~Negate() override = default;
109 :
110 : /// \brief Assert that the LHS tensor of the equation does not also appear in
111 : /// this expression's subtree
112 : template <typename LhsTensor>
113 1 : SPECTRE_ALWAYS_INLINE void assert_lhs_tensor_not_in_rhs_expression(
114 : const gsl::not_null<LhsTensor*> lhs_tensor) const {
115 : if constexpr (not std::is_base_of_v<MarkAsNumberAsExpression, T>) {
116 : t_.assert_lhs_tensor_not_in_rhs_expression(lhs_tensor);
117 : }
118 : }
119 :
120 : /// \brief Assert that each instance of the LHS tensor in the RHS tensor
121 : /// expression uses the same generic index order that the LHS uses
122 : ///
123 : /// \tparam LhsTensorIndices the list of generic `TensorIndex`s of the LHS
124 : /// result `Tensor` being computed
125 : /// \param lhs_tensor the LHS result `Tensor` being computed
126 : template <typename LhsTensorIndices, typename LhsTensor>
127 1 : SPECTRE_ALWAYS_INLINE void assert_lhs_tensorindices_same_in_rhs(
128 : const gsl::not_null<LhsTensor*> lhs_tensor) const {
129 : if constexpr (not std::is_base_of_v<MarkAsNumberAsExpression, T>) {
130 : t_.template assert_lhs_tensorindices_same_in_rhs<LhsTensorIndices>(
131 : lhs_tensor);
132 : }
133 : }
134 :
135 : /// \brief Get the size of a component from a `Tensor` in this expression's
136 : /// subtree of the RHS `TensorExpression`
137 : ///
138 : /// \return the size of a component from a `Tensor` in this expression's
139 : /// subtree of the RHS `TensorExpression`
140 1 : SPECTRE_ALWAYS_INLINE size_t get_rhs_tensor_component_size() const {
141 : return t_.get_rhs_tensor_component_size();
142 : }
143 :
144 : /// \brief Return the value of the component of the negated tensor expression
145 : /// at a given multi-index
146 : ///
147 : /// \param multi_index the multi-index of the component to retrieve from the
148 : /// negated tensor expression
149 : /// \return the value of the component at `multi_index` in the negated tensor
150 : /// expression
151 1 : SPECTRE_ALWAYS_INLINE decltype(auto) get(
152 : const std::array<size_t, num_tensor_indices>& multi_index) const {
153 : return -t_.get(multi_index);
154 : }
155 :
156 : /// \brief Return the value of the component of the negated tensor expression
157 : /// at a given multi-index
158 : ///
159 : /// \details
160 : /// This function differs from `get` in that it takes into account whether we
161 : /// have already computed part of the result component at a lower subtree.
162 : /// In recursively computing this negation, the current result component will
163 : /// be substituted in for the most recent (highest) subtree below it that has
164 : /// already been evaluated.
165 : ///
166 : /// \param result_component the LHS tensor component to evaluate
167 : /// \param multi_index the multi-index of the component to retrieve from the
168 : /// negated tensor expression
169 : /// \return the value of the component at `multi_index` in the negated tensor
170 : /// expression
171 : template <typename ResultType>
172 1 : SPECTRE_ALWAYS_INLINE decltype(auto) get_primary(
173 : const ResultType& result_component,
174 : const std::array<size_t, num_tensor_indices>& multi_index) const {
175 : if constexpr (is_primary_end) {
176 : (void)multi_index;
177 : // We've already computed the whole child subtree on the primary path, so
178 : // just return the negation of the current result component
179 : return -result_component;
180 : } else {
181 : // We haven't yet evaluated the whole subtree for this expression, so
182 : // return the negation of this expression's subtree
183 : return -t_.get_primary(result_component, multi_index);
184 : }
185 : }
186 :
187 : /// \brief Successively evaluate the LHS Tensor's result component at each
188 : /// leg in this expression's subtree
189 : ///
190 : /// \details
191 : /// This function takes into account whether we have already computed part of
192 : /// the result component at a lower subtree. In recursively computing this
193 : /// negation, the current result component will be substituted in for the most
194 : /// recent (highest) subtree below it that has already been evaluated.
195 : ///
196 : /// \param result_component the LHS tensor component to evaluate
197 : /// \param multi_index the multi-index of the component of the result tensor
198 : /// to evaluate
199 : template <typename ResultType>
200 1 : SPECTRE_ALWAYS_INLINE void evaluate_primary_subtree(
201 : ResultType& result_component,
202 : const std::array<size_t, num_tensor_indices>& multi_index) const {
203 : if constexpr (primary_child_subtree_contains_primary_start) {
204 : // The primary child's subtree contains at least one leg, so recurse down
205 : // and evaluate that first
206 : t_.evaluate_primary_subtree(result_component, multi_index);
207 : }
208 : if constexpr (is_primary_start) {
209 : // We want to evaluate the subtree for this expression
210 : result_component = get_primary(result_component, multi_index);
211 : }
212 : }
213 :
214 : private:
215 : /// Operand expression
216 1 : T t_;
217 : };
218 : } // namespace tenex
219 :
220 : /// \ingroup TensorExpressionsGroup
221 : /// \brief Returns the tensor expression representing the negation of a tensor
222 : /// expression
223 : ///
224 : /// \param t the tensor expression
225 : /// \return the tensor expression representing the negation of `t`
226 : template <typename T>
227 1 : SPECTRE_ALWAYS_INLINE auto operator-(
228 : const TensorExpression<T, typename T::type, typename T::symmetry,
229 : typename T::index_list, typename T::args_list>& t) {
230 : return tenex::Negate<T>(~t);
231 : }
|
