SimiLie
Loading...
Searching...
No Matches
tensor_prod.hpp
1// SPDX-FileCopyrightText: 2024 Baptiste Legouix
2// SPDX-License-Identifier: AGPL-3.0-or-later
3// AI-GENERATED
4
5#pragma once
6
7#include <array>
8#include <utility>
9
10#include <ddc/ddc.hpp>
11
12#include <similie/misc/specialization.hpp>
13#include <similie/misc/type_seq_ext.hpp>
14#include <similie/tensor/tensor_indices/character.hpp>
15#if defined BUILD_YOUNG_TABLEAU
16#include <similie/tensor/tensor_indices/young_tableau_tensor.hpp>
17#endif
18
19namespace sil {
20
21namespace tensor {
22
23namespace detail {
24
25template <class Index>
26struct SubindicesDomain;
27
28template <template <class...> class T, class... SubIndex>
29struct SubindicesDomain<T<SubIndex...>>
30{
31 using type = ddc::DiscreteDomain<SubIndex...>;
32
33 KOKKOS_FUNCTION static constexpr type operator()()
34 {
35 return ddc::DiscreteDomain<SubIndex...>(
36 ddc::DiscreteElement<SubIndex...>(ddc::DiscreteElement<SubIndex>(0)...),
37 ddc::DiscreteVector<SubIndex...>(
38 ddc::DiscreteVector<SubIndex>(SubIndex::size())...));
39 }
40};
41
42} // namespace detail
43
44template <class T>
45using subindices_domain_t = detail::SubindicesDomain<T>::type;
46
47template <class T>
48KOKKOS_FUNCTION static constexpr subindices_domain_t<T> subindices_domain()
49{
50 return detail::SubindicesDomain<T>::operator()();
51};
52
53// Check tensor compatibility
54namespace detail {
55
56template <class ProdDDims, class Indices1, class Indices2>
57struct CheckTensorsCompatibility;
58
59template <class... ProdDDim, class... Index1, class... Index2>
60struct CheckTensorsCompatibility<
61 ddc::TypeSeq<ProdDDim...>,
62 ddc::TypeSeq<Index1...>,
63 ddc::TypeSeq<Index2...>>
64{
65 static constexpr void operator()()
66 {
67 static_assert(std::is_same_v<
68 ddc::type_seq_remove_t<
69 uncharacterize_t<ddc::to_type_seq_t<
71 uncharacterize_t<ddc::to_type_seq_t<
73 ddc::type_seq_remove_t<
74 uncharacterize_t<ddc::to_type_seq_t<
78 static_assert(are_different_characters_v<
79 ddc::type_seq_remove_t<
80 ddc::to_type_seq_t<
82 ddc::to_type_seq_t<
84 ddc::type_seq_remove_t<
85 ddc::to_type_seq_t<
87 ddc::to_type_seq_t<sil::misc::cartesian_prod_t<
89 }
90};
91
92} // namespace detail
93
94template <class ProdDDims, class Indices1, class Indices2>
96{
97 return detail::CheckTensorsCompatibility<ProdDDims, Indices1, Indices2>::operator()();
98}
99
100namespace detail {
101
102// Evaluate the index's existing access transformation with a unit coefficient.
103// This resolves structural zeros, ones and signs without reading tensor storage.
104// In particular, access ID zero need not mean a structural zero for every index.
105struct TensorProductUnitAccess
106{
107 using element_type = double;
108
109 template <class Tensor, class Element>
110 KOKKOS_FUNCTION constexpr double operator()(Tensor const&, Element const&) const
111 {
112 return 1.;
113 }
114};
115
116template <class Index, class Element>
117KOKKOS_FUNCTION constexpr double tensor_product_access_coefficient(Element const& element)
118{
119 return Index::template process_access<
120 TensorProductUnitAccess,
121 Element,
122 Index>(TensorProductUnitAccess(), TensorProductUnitAccess(), element);
123}
124
125// A structural zero is a property of the access transformation, independent of
126// the index family and of the values stored in a tensor.
127template <class Index>
128KOKKOS_FUNCTION constexpr bool tensor_product_has_structural_zeros()
129{
130 for (std::size_t id = 0; id < Index::access_size(); ++id) {
131 if (tensor_product_access_coefficient<Index>(ddc::DiscreteElement<Index>(id)) == 0.)
132 return true;
133 }
134 return false;
135}
136
137template <class... Free, class... Contracted>
138KOKKOS_FUNCTION constexpr ddc::DiscreteElement<Free..., Contracted...> tensor_product_known_element(
139 ddc::DiscreteElement<Free...> free,
140 ddc::DiscreteElement<Contracted...> contracted)
141{
142 return ddc::DiscreteElement<Free..., Contracted...>(free, contracted);
143}
144
145template <class ProductIndices, class LeftIndices, class RightIndices, class ContractedIndices>
146class TensorProdUnrolled;
147
148// Unfold the canonical output components and contractions for any index types.
149// Accessor conversions see constant indices and resolve storage offsets and signs
150// at compile time. The index access transformations identify structural zeros.
151template <class... Product, class... Left, class... Right, class... Contracted>
152class TensorProdUnrolled<
153 ddc::TypeSeq<Product...>,
154 ddc::TypeSeq<Left...>,
155 ddc::TypeSeq<Right...>,
156 ddc::TypeSeq<Contracted...>>
157{
158 template <std::size_t Output>
159 KOKKOS_FUNCTION static constexpr ddc::DiscreteElement<Product...> output_element()
160 {
161 std::array<std::size_t, sizeof...(Product)> const sizes {Product::mem_size()...};
162 std::array<std::size_t, sizeof...(Product)> ids {};
163 std::size_t remaining = Output;
164 for (std::size_t i = sizes.size(); i > 0; --i) {
165 ids[i - 1] = remaining % sizes[i - 1];
166 remaining /= sizes[i - 1];
167 }
168 ddc::DiscreteElement<Product...> element;
169 ddc::detail::array(element) = ids;
170 return element;
171 }
172
173 template <std::size_t... Values, std::size_t... Positions>
174 KOKKOS_FUNCTION static constexpr ddc::DiscreteElement<
175 ddc::type_seq_element_t<Positions, ddc::TypeSeq<Contracted...>>...>
176 contracted_element(std::index_sequence<Values...>, std::index_sequence<Positions...>)
177 {
178 return ddc::DiscreteElement<
179 ddc::type_seq_element_t<Positions, ddc::TypeSeq<Contracted...>>...>(Values...);
180 }
181
182 template <
183 std::size_t Output,
184 class Tensor1,
185 class Tensor2,
186 std::size_t... Values,
187 std::size_t... Next>
188 KOKKOS_FORCEINLINE_FUNCTION static void extend(
189 Tensor1 const& left,
190 Tensor2 const& right,
191 std::remove_const_t<typename Tensor1::element_type>& sum,
192 bool& initialized,
193 std::index_sequence<Values...>,
194 std::index_sequence<Next...>)
195 {
196 (contract<Output>(left, right, sum, initialized, std::index_sequence<Values..., Next>()),
197 ...);
198 }
199
200 template <std::size_t Output, class Tensor1, class Tensor2, std::size_t... Values>
201 KOKKOS_FORCEINLINE_FUNCTION static void contract(
202 Tensor1 const& left,
203 Tensor2 const& right,
204 std::remove_const_t<typename Tensor1::element_type>& sum,
205 bool& initialized,
206 std::index_sequence<Values...> assigned)
207 {
208 constexpr auto known = tensor_product_known_element(
210 contracted_element(
211 std::index_sequence<Values...>(),
212 std::make_index_sequence<sizeof...(Values)>()));
213 if constexpr (sizeof...(Values) == sizeof...(Contracted)) {
214 constexpr auto left_element = TensorAccessor<Left...>::access_element(known);
215 constexpr auto right_element = TensorAccessor<Right...>::access_element(known);
216 if constexpr (
217 ((tensor_product_access_coefficient<Left>(left_element) != 0.) && ...)
218 && ((tensor_product_access_coefficient<Right>(right_element) != 0.) && ...)) {
219 if (initialized)
220 sum += left.get(left_element) * right.get(right_element);
221 else {
222 sum = left.get(left_element) * right.get(right_element);
223 initialized = true;
224 }
225 }
226 } else {
227 extend<Output>(
228 left,
229 right,
230 sum,
231 initialized,
232 assigned,
233 std::make_index_sequence<ddc::type_seq_element_t<
234 sizeof...(Values),
235 ddc::TypeSeq<Contracted...>>::size()>());
236 }
237 }
238
239 template <std::size_t Output, class ProductTensor, class Tensor1, class Tensor2>
240 KOKKOS_FORCEINLINE_FUNCTION static void write(
241 ProductTensor const& product,
242 Tensor1 const& left,
243 Tensor2 const& right)
244 {
245 constexpr ddc::DiscreteElement<Product...> element = output_element<Output>();
246 // Tensor views may select only a subset of the stored output components.
247 if (product.domain().contains(element)) {
248 typename ProductTensor::element_type sum = 0.;
249 // The general reduction starts from zero. Preserve that addition
250 // (including signed zeros). Products with structural zeros start from
251 // their first retained term, preserving copies and signed zeros.
252 bool initialized = sizeof...(Contracted) > 0
253 && !((tensor_product_has_structural_zeros<Left>() || ...)
254 || (tensor_product_has_structural_zeros<Right>() || ...));
255 contract<Output>(left, right, sum, initialized, std::index_sequence<>());
256 product.mem(element) = sum;
257 }
258 }
259
260 template <class ProductTensor, class Tensor1, class Tensor2, std::size_t... Outputs>
261 KOKKOS_FORCEINLINE_FUNCTION static void write(
262 ProductTensor const& product,
263 Tensor1 const& left,
264 Tensor2 const& right,
265 std::index_sequence<Outputs...>)
266 {
267 (write<Outputs>(product, left, right), ...);
268 }
269
270public:
271 template <class ProductTensor, class Tensor1, class Tensor2>
272 KOKKOS_FUNCTION static void operator()(
273 ProductTensor const& product,
274 Tensor1 const& left,
275 Tensor2 const& right)
276 {
277 write(product,
278 left,
279 right,
280 std::make_index_sequence<(Product::mem_size() * ... * std::size_t(1))>());
281 }
282};
283
284} // namespace detail
285
286// Any-any product into Any; unfold small contractions at compile time.
287namespace detail {
288
289template <
290 class ProdDDims,
291 class Indices1,
292 class Indices2,
293 class HeadDDim1TypeSeq,
294 class ContractDDimTypeSeq,
295 class TailDDim2TypeSeq>
296struct TensorProdAnyAnyAny;
297
298template <
299 class... ProdDDim,
300 class... Index1,
301 class... Index2,
302 class... HeadDDim1,
303 class... ContractDDim,
304 class... TailDDim2>
305struct TensorProdAnyAnyAny<
306 ddc::TypeSeq<ProdDDim...>,
307 ddc::TypeSeq<Index1...>,
308 ddc::TypeSeq<Index2...>,
309 ddc::TypeSeq<HeadDDim1...>,
310 ddc::TypeSeq<ContractDDim...>,
311 ddc::TypeSeq<TailDDim2...>>
312{
313 template <
314 class ElementType,
315 class LeftElement,
316 class RightElement,
317 class LayoutStridedPolicy,
318 class MemorySpace>
319 KOKKOS_FUNCTION static Tensor<
320 ElementType,
321 ddc::DiscreteDomain<ProdDDim...>,
322 LayoutStridedPolicy,
323 MemorySpace>
324 operator()(
325 Tensor<ElementType,
326 ddc::DiscreteDomain<ProdDDim...>,
327 LayoutStridedPolicy,
328 MemorySpace> const& prod_tensor,
329 Tensor<LeftElement,
330 ddc::DiscreteDomain<Index1...>,
331 LayoutStridedPolicy,
332 MemorySpace> const& tensor1,
333 Tensor<RightElement,
334 ddc::DiscreteDomain<Index2...>,
335 LayoutStridedPolicy,
336 MemorySpace> const& tensor2)
337 {
338 // Bound expansion of the general case by the number of scalar products.
339 // Larger products retain the loop implementation to limit generated code.
340 if constexpr (
341 (tensor_product_has_structural_zeros<Index1>() || ...)
342 || (tensor_product_has_structural_zeros<Index2>() || ...)
343 || ((ProdDDim::mem_size() * ... * 1) <= 128
344 && (ContractDDim::size() * ... * 1) <= 128
345 && (ProdDDim::mem_size() * ... * 1) * (ContractDDim::size() * ... * 1)
346 <= 128)) {
347 TensorProdUnrolled<
348 ddc::TypeSeq<ProdDDim...>,
349 ddc::TypeSeq<Index1...>,
350 ddc::TypeSeq<Index2...>,
351 ddc::TypeSeq<ContractDDim...>>::operator()(prod_tensor, tensor1, tensor2);
352 } else {
353 tensor::TensorAccessor<ContractDDim...> const contract_accessor;
354 ddc::DiscreteDomain<ContractDDim...> const contract_dom
355 = contract_accessor.natural_domain();
356
357 ddc::device_for_each(
358 prod_tensor.domain(),
359 [&](ddc::DiscreteElement<ProdDDim...> mem_elem) {
360 auto const elem = prod_tensor.canonical_natural_element(mem_elem);
361 prod_tensor.mem(mem_elem) = ddc::device_transform_reduce(
362 contract_dom,
363 0.,
364 ddc::reducer::sum<ElementType>(),
365 [&](ddc::DiscreteElement<ContractDDim...> contract_elem) {
366 return tensor1.get(tensor1.access_element(
367 ddc::DiscreteElement<
368 HeadDDim1...,
369 ContractDDim...>(
370 ddc::select<HeadDDim1...>(elem),
371 contract_accessor.access_element(
372 contract_elem))))
373 * tensor2.get(tensor2.access_element(
374 ddc::DiscreteElement<
375 ContractDDim...,
376 TailDDim2...>(
377 contract_accessor.access_element(
378 contract_elem),
379 ddc::select<TailDDim2...>(elem))));
380 });
381 });
382 }
383 return prod_tensor;
384 }
385};
386
387} // namespace detail
388
389template <
390 class... ProdDDim,
391 class... Index1,
392 class... Index2,
393 class ElementType,
394 class LeftElement,
395 class RightElement,
396 class LayoutStridedPolicy,
397 class MemorySpace>
398 requires(
399 std::is_same_v<ElementType, std::remove_const_t<LeftElement>>
400 && std::is_same_v<ElementType, std::remove_const_t<RightElement>>
401 && ((!TensorNatIndex<ProdDDim> || ...) || (!TensorNatIndex<Index2> || ...)
402 || (!TensorNatIndex<Index1> || ...))
403#if defined BUILD_YOUNG_TABLEAU
404 && (!misc::Specialization<ProdDDim, TensorYoungTableauIndex> && ...)
405 && (!misc::Specialization<Index1, TensorYoungTableauIndex> && ...)
406 && (!misc::Specialization<Index2, TensorYoungTableauIndex> && ...)
407#endif
408 )
409Tensor<ElementType, ddc::DiscreteDomain<ProdDDim...>, LayoutStridedPolicy, MemorySpace>
410 KOKKOS_FUNCTION tensor_prod(
411 Tensor<ElementType,
412 ddc::DiscreteDomain<ProdDDim...>,
413 LayoutStridedPolicy,
414 MemorySpace> const& prod_tensor,
415 Tensor<LeftElement,
416 ddc::DiscreteDomain<Index1...>,
417 LayoutStridedPolicy,
418 MemorySpace> const& tensor1,
419 Tensor<RightElement,
420 ddc::DiscreteDomain<Index2...>,
421 LayoutStridedPolicy,
422 MemorySpace> const& tensor2)
423{
425 ddc::TypeSeq<ProdDDim...>,
426 ddc::TypeSeq<Index1...>,
427 ddc::TypeSeq<Index2...>>();
428
429 detail::TensorProdAnyAnyAny<
430 uncharacterize_t<ddc::TypeSeq<ProdDDim...>>,
431 uncharacterize_t<ddc::TypeSeq<Index1...>>,
432 uncharacterize_t<ddc::TypeSeq<Index2...>>,
433 ddc::type_seq_remove_t<
434 uncharacterize_t<ddc::to_type_seq_t<
436 uncharacterize_t<ddc::to_type_seq_t<
438 ddc::type_seq_remove_t<
439 uncharacterize_t<ddc::to_type_seq_t<
441 uncharacterize_t<ddc::to_type_seq_t<
443 ddc::type_seq_remove_t<
444 uncharacterize_t<ddc::to_type_seq_t<
446 uncharacterize_t<ddc::to_type_seq_t<
448 operator()(
449 uncharacterize_tensor(prod_tensor),
450 uncharacterize_tensor(tensor1),
451 uncharacterize_tensor(tensor2));
452 return prod_tensor;
453}
454
455#if defined BUILD_YOUNG_TABLEAU
456// Young-dense product
457namespace detail {
458
459template <class Index1, class HeadDDim1TypeSeq, class ContractDDimTypeSeq, class TailDDim2TypeSeq>
460struct TensorProdNatYoungNat;
461
462template <class Index1, class... HeadDDim1, class... ContractDDim, class... TailDDim2>
463struct TensorProdNatYoungNat<
464 Index1,
465 ddc::TypeSeq<HeadDDim1...>,
466 ddc::TypeSeq<ContractDDim...>,
467 ddc::TypeSeq<TailDDim2...>>
468{
469 template <class ElementType, class LayoutStridedPolicy, class MemorySpace>
470 static Tensor<
471 ElementType,
472 ddc::DiscreteDomain<HeadDDim1..., TailDDim2...>,
473 LayoutStridedPolicy,
474 MemorySpace>
475 operator()(
476 Tensor<ElementType,
477 ddc::DiscreteDomain<HeadDDim1..., TailDDim2...>,
478 Kokkos::layout_right,
479 Kokkos::DefaultHostExecutionSpace::memory_space> const& prod_tensor,
480 Tensor<ElementType,
481 ddc::DiscreteDomain<Index1>,
482 LayoutStridedPolicy,
483 MemorySpace> const& tensor1,
484 Tensor<ElementType,
485 ddc::DiscreteDomain<ContractDDim..., TailDDim2...>,
486 LayoutStridedPolicy,
487 MemorySpace> const& tensor2)
488 {
489 std::array<ElementType, Index1::subindices_domain().size()> uncompressed_tensor1_alloc;
490 tensor::Tensor uncompressed_tensor1(
491 uncompressed_tensor1_alloc.data(),
492 Index1::subindices_domain());
493
494 tensor::uncompress(uncompressed_tensor1, tensor1);
495
496 return tensor_prod(prod_tensor, uncompressed_tensor1, tensor2);
497 }
498};
499
500} // namespace detail
501
502template <
503 TensorNatIndex... ProdDDim,
504 misc::Specialization<TensorYoungTableauIndex> Index1,
505 TensorNatIndex... DDim2,
506 class ElementType,
507 class LayoutStridedPolicy,
508 class MemorySpace>
509Tensor<ElementType,
510 ddc::DiscreteDomain<ProdDDim...>,
511 Kokkos::layout_right,
512 Kokkos::DefaultHostExecutionSpace::memory_space>
514 Tensor<ElementType,
515 ddc::DiscreteDomain<ProdDDim...>,
516 Kokkos::layout_right,
517 Kokkos::DefaultHostExecutionSpace::memory_space> const& prod_tensor,
518 Tensor<ElementType, ddc::DiscreteDomain<Index1>, LayoutStridedPolicy, MemorySpace> const&
519 tensor1,
520 Tensor<ElementType, ddc::DiscreteDomain<DDim2...>, LayoutStridedPolicy, MemorySpace> const&
521 tensor2)
522{
523 // TODO DDim2 -> Index2, characterize
524 return detail::TensorProdNatYoungNat<
525 Index1,
526 ddc::type_seq_remove_t<ddc::TypeSeq<ProdDDim...>, ddc::TypeSeq<DDim2...>>,
527 ddc::type_seq_remove_t<
528 ddc::to_type_seq_t<typename Index1::subindices_domain_t>,
529 ddc::TypeSeq<ProdDDim...>>,
530 ddc::type_seq_remove_t<
531 ddc::TypeSeq<ProdDDim...>,
532 ddc::to_type_seq_t<typename Index1::subindices_domain_t>>>::
533 operator()(prod_tensor, tensor1, tensor2);
534}
535
536// Young-young product
537namespace detail {
538
539template <
540 class Index1,
541 class Index2,
542 class HeadDDim1TypeSeq,
543 class ContractDDimTypeSeq,
544 class TailDDim2TypeSeq>
545struct TensorProdNatYoungYoung;
546
547template <class Index1, class Index2, class... HeadDDim1, class... ContractDDim, class... TailDDim2>
548struct TensorProdNatYoungYoung<
549 Index1,
550 Index2,
551 ddc::TypeSeq<HeadDDim1...>,
552 ddc::TypeSeq<ContractDDim...>,
553 ddc::TypeSeq<TailDDim2...>>
554{
555 template <class ElementType, class LayoutStridedPolicy, class MemorySpace>
556 static Tensor<
557 ElementType,
558 ddc::DiscreteDomain<HeadDDim1..., TailDDim2...>,
559 LayoutStridedPolicy,
560 MemorySpace>
561 operator()(
562 Tensor<ElementType,
563 ddc::DiscreteDomain<HeadDDim1..., TailDDim2...>,
564 Kokkos::layout_right,
565 Kokkos::DefaultHostExecutionSpace::memory_space> const& prod_tensor,
566 Tensor<ElementType,
567 ddc::DiscreteDomain<Index1>,
568 LayoutStridedPolicy,
569 MemorySpace> const& tensor1,
570 Tensor<ElementType,
571 ddc::DiscreteDomain<Index2>,
572 LayoutStridedPolicy,
573 MemorySpace> const& tensor2)
574 {
575 std::array<ElementType, Index1::subindices_domain().size()> uncompressed_tensor1_alloc;
576 tensor::Tensor uncompressed_tensor1(
577 uncompressed_tensor1_alloc.data(),
578 Index1::subindices_domain());
579
580 std::array<ElementType, Index2::subindices_domain().size()> uncompressed_tensor2_alloc;
581 tensor::Tensor uncompressed_tensor2(
582 uncompressed_tensor2_alloc.data(),
583 Index2::subindices_domain());
584
585 tensor::uncompress(uncompressed_tensor1, tensor1);
586 tensor::uncompress(uncompressed_tensor2, tensor2);
587
588 return tensor_prod(prod_tensor, uncompressed_tensor1, uncompressed_tensor2);
589 }
590};
591
592} // namespace detail
593
594template <
595 TensorNatIndex... ProdDDim,
596 misc::Specialization<TensorYoungTableauIndex> Index1,
597 misc::Specialization<TensorYoungTableauIndex> Index2,
598 class ElementType,
599 class LayoutStridedPolicy,
600 class MemorySpace>
601Tensor<ElementType,
602 ddc::DiscreteDomain<ProdDDim...>,
603 Kokkos::layout_right,
604 Kokkos::DefaultHostExecutionSpace::memory_space>
606 Tensor<ElementType,
607 ddc::DiscreteDomain<ProdDDim...>,
608 Kokkos::layout_right,
609 Kokkos::DefaultHostExecutionSpace::memory_space> const& prod_tensor,
610 Tensor<ElementType, ddc::DiscreteDomain<Index1>, LayoutStridedPolicy, MemorySpace> const&
611 tensor1,
612 Tensor<ElementType, ddc::DiscreteDomain<Index2>, LayoutStridedPolicy, MemorySpace> const&
613 tensor2)
614{
616 ddc::TypeSeq<ProdDDim...>,
617 ddc::TypeSeq<Index1>,
618 ddc::TypeSeq<Index2>>();
619
620 detail::TensorProdNatYoungYoung<
621 uncharacterize_t<Index1>,
622 uncharacterize_t<Index2>,
623 ddc::type_seq_remove_t<
624 uncharacterize_t<ddc::to_type_seq_t<
626 uncharacterize_t<ddc::to_type_seq_t<
628 ddc::type_seq_remove_t<
629 uncharacterize_t<ddc::to_type_seq_t<
631 uncharacterize_t<ddc::to_type_seq_t<
633 ddc::type_seq_remove_t<
634 uncharacterize_t<ddc::to_type_seq_t<
636 uncharacterize_t<ddc::to_type_seq_t<
638 operator()(
639 uncharacterize_tensor(prod_tensor),
640 uncharacterize_tensor(tensor1),
641 uncharacterize_tensor(tensor2));
642
643 return prod_tensor;
644}
645
646// Any-any product into Young
647namespace detail {
648
649template <
650 class ProdDDims,
651 class Indices1,
652 class Indices2,
653 class HeadDDim1TypeSeq,
654 class ContractDDimTypeSeq,
655 class TailDDim2TypeSeq>
656struct TensorProdYoungAnyAny;
657
658template <
659 class... ProdDDim,
660 class... Index1,
661 class... Index2,
662 class... HeadDDim1,
663 class... ContractDDim,
664 class... TailDDim2>
665struct TensorProdYoungAnyAny<
666 ddc::TypeSeq<ProdDDim...>,
667 ddc::TypeSeq<Index1...>,
668 ddc::TypeSeq<Index2...>,
669 ddc::TypeSeq<HeadDDim1...>,
670 ddc::TypeSeq<ContractDDim...>,
671 ddc::TypeSeq<TailDDim2...>>
672{
673 template <class ElementType, class LayoutStridedPolicy, class MemorySpace>
674 static Tensor<ElementType, ddc::DiscreteDomain<ProdDDim...>, LayoutStridedPolicy, MemorySpace>
675 operator()(
676 Tensor<ElementType,
677 ddc::DiscreteDomain<ProdDDim...>,
678 Kokkos::layout_right,
679 Kokkos::DefaultHostExecutionSpace::memory_space> const& prod_tensor,
680 Tensor<ElementType,
681 ddc::DiscreteDomain<Index1...>,
682 LayoutStridedPolicy,
683 MemorySpace> const& tensor1,
684 Tensor<ElementType,
685 ddc::DiscreteDomain<Index2...>,
686 LayoutStridedPolicy,
687 MemorySpace> const& tensor2)
688 {
689 std::array<ElementType, ddc::DiscreteDomain(ProdDDim::subindices_domain()...).size()>
690 uncompressed_prod_alloc;
691 tensor::Tensor uncompressed_prod(
692 uncompressed_prod_alloc.data(),
693 ddc::DiscreteDomain(ProdDDim::subindices_domain()...));
694
695 tensor::TensorAccessor<ContractDDim...> const contract_accessor;
696 ddc::DiscreteDomain<ContractDDim...> const contract_dom
697 = contract_accessor.natural_domain();
698
699 ddc::host_for_each(
700 uncompressed_prod.domain(),
702 typename ProdDDim::subindices_domain_t...>::discrete_element_type elem) {
703 uncompressed_prod(elem) = ddc::host_transform_reduce(
704 contract_dom,
705 0.,
706 ddc::reducer::sum<ElementType>(),
707 [&](ddc::DiscreteElement<ContractDDim...> contract_elem) {
708 return tensor1.get(tensor1.access_element(
709 ddc::DiscreteElement<HeadDDim1..., ContractDDim...>(
710 ddc::select<HeadDDim1...>(elem),
711 contract_accessor.access_element(
712 contract_elem))))
713 * tensor2.get(tensor2.access_element(
714 ddc::DiscreteElement<ContractDDim..., TailDDim2...>(
715 contract_accessor.access_element(
716 contract_elem),
717 ddc::select<TailDDim2...>(elem))));
718 });
719 });
720 tensor::compress(prod_tensor, uncompressed_prod);
721 return prod_tensor;
722 }
723};
724
725} // namespace detail
726
727template <
728 misc::Specialization<TensorYoungTableauIndex> ProdDDim,
729 class... Index1,
730 class... Index2,
731 class ElementType,
732 class LayoutStridedPolicy,
733 class MemorySpace>
734Tensor<ElementType,
735 ddc::DiscreteDomain<ProdDDim>,
736 Kokkos::layout_right,
737 Kokkos::DefaultHostExecutionSpace::memory_space>
739 Tensor<ElementType,
740 ddc::DiscreteDomain<ProdDDim>,
741 Kokkos::layout_right,
742 Kokkos::DefaultHostExecutionSpace::memory_space> const& prod_tensor,
743 Tensor<ElementType, ddc::DiscreteDomain<Index1...>, LayoutStridedPolicy, MemorySpace> const&
744 tensor1,
745 Tensor<ElementType, ddc::DiscreteDomain<Index2...>, LayoutStridedPolicy, MemorySpace> const&
746 tensor2)
747{
749 ddc::TypeSeq<ProdDDim>,
750 ddc::TypeSeq<Index1...>,
751 ddc::TypeSeq<Index2...>>();
752
753 detail::TensorProdYoungAnyAny<
754 uncharacterize_t<ddc::TypeSeq<ProdDDim>>,
755 uncharacterize_t<ddc::TypeSeq<Index1...>>,
756 uncharacterize_t<ddc::TypeSeq<Index2...>>,
757 ddc::type_seq_remove_t<
758 uncharacterize_t<ddc::to_type_seq_t<
760 uncharacterize_t<ddc::to_type_seq_t<
762 ddc::type_seq_remove_t<
763 uncharacterize_t<ddc::to_type_seq_t<
765 uncharacterize_t<ddc::to_type_seq_t<
767 ddc::type_seq_remove_t<
768 uncharacterize_t<ddc::to_type_seq_t<
770 uncharacterize_t<ddc::to_type_seq_t<
772 operator()(
773 uncharacterize_tensor(prod_tensor),
774 uncharacterize_tensor(tensor1),
775 uncharacterize_tensor(tensor2));
776 return prod_tensor;
777}
778#endif
779
780} // namespace tensor
781
782} // namespace sil
static KOKKOS_FUNCTION constexpr discrete_element_type access_element()
static KOKKOS_FUNCTION constexpr natural_domain_t::discrete_element_type canonical_natural_element(ddc::DiscreteElement< MemIndex... > mem_elem)
sil::tensor::Tensor< double, ddc::DiscreteDomain< TailTensorIndex... >, Kokkos::layout_right, Kokkos::DefaultHostExecutionSpace::memory_space > tensor_prod(sil::tensor::Tensor< double, ddc::DiscreteDomain< TailTensorIndex... >, Kokkos::layout_right, Kokkos::DefaultHostExecutionSpace::memory_space > const &prod, sil::tensor::Tensor< double, ddc::DiscreteDomain< HeadTensorIndex >, Kokkos::layout_right, Kokkos::DefaultHostExecutionSpace::memory_space > const &dense, Csr< N, HeadTensorIndex, TailTensorIndex... > const &csr)
Definition csr.hpp:112
convert_type_seq_to_t< ddc::DiscreteDomain, typename detail::CartesianProd< Domains... >::type > cartesian_prod_t
constexpr void check_tensors_compatibility()
Tensor(ddc::Chunk< ElementType, SupportType, Allocator >) -> Tensor< ElementType, SupportType, Kokkos::layout_right, typename Allocator::memory_space >
constexpr bool are_different_characters_v
detail::SubindicesDomain< T >::type subindices_domain_t
KOKKOS_FUNCTION constexpr uncharacterize_tensor_t< TensorType > uncharacterize_tensor(TensorType const &tensor)
detail::Uncharacterize< Index >::type uncharacterize_t
typename detail::NaturalDomainType< Index >::type natural_domain_t
The top-level namespace of SimiLie.
Definition csr.hpp:15