1 //
2 // BAGEL - Brilliantly Advanced General Electronic Structure Library
3 // Filename: RelMRCI_tasks11.h
4 // Copyright (C) 2014 Toru Shiozaki
5 //
6 // Author: Toru Shiozaki <shiozaki@northwestern.edu>
7 // Maintainer: Shiozaki group
8 //
9 // This file is part of the BAGEL package.
10 //
11 // This program is free software: you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation, either version 3 of the License, or
14 // (at your option) any later version.
15 //
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU General Public License
22 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
23 //
24 
25 #include <bagel_config.h>
26 #ifdef COMPILE_SMITH
27 
28 #ifndef __SRC_SMITH_RelMRCI_TASKS11_H
29 #define __SRC_SMITH_RelMRCI_TASKS11_H
30 
31 #include <src/smith/indexrange.h>
32 #include <src/smith/tensor.h>
33 #include <src/smith/task.h>
34 #include <src/smith/subtask.h>
35 #include <src/smith/storage.h>
36 
37 namespace bagel {
38 namespace SMITH {
39 namespace RelMRCI{
40 
41 class Task500 : public Task {
42   protected:
43     std::shared_ptr<Tensor> out_;
44     std::array<std::shared_ptr<const Tensor>,2> in_;
45     class Task_local : public SubTask<2,2> {
46       protected:
47         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)48         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)49         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()50         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
51       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)52         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
53                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
54           : SubTask<2,2>(block, in, out), range_(ran) { }
55         void compute() override;
56     };
57     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()58     void compute_() override {
59       if (!out_->allocated())
60         out_->allocate();
61       for (auto& i : in_)
62         i->init();
63       for (auto& i : subtasks_) i->compute();
64     }
65   public:
66     Task500(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task500()67     ~Task500() {}
68 };
69 
70 class Task501 : public Task {
71   protected:
72     std::shared_ptr<Tensor> out_;
73     std::array<std::shared_ptr<const Tensor>,2> in_;
74     class Task_local : public SubTask<4,2> {
75       protected:
76         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)77         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)78         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()79         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
80       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)81         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
82                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
83           : SubTask<4,2>(block, in, out), range_(ran) { }
84         void compute() override;
85     };
86     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()87     void compute_() override {
88       if (!out_->allocated())
89         out_->allocate();
90       for (auto& i : in_)
91         i->init();
92       for (auto& i : subtasks_) i->compute();
93     }
94   public:
95     Task501(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task501()96     ~Task501() {}
97 };
98 
99 class Task502 : public Task {
100   protected:
101     std::shared_ptr<Tensor> out_;
102     std::array<std::shared_ptr<const Tensor>,2> in_;
103     class Task_local : public SubTask<2,2> {
104       protected:
105         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)106         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)107         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()108         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
109       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)110         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
111                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
112           : SubTask<2,2>(block, in, out), range_(ran) { }
113         void compute() override;
114     };
115     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()116     void compute_() override {
117       if (!out_->allocated())
118         out_->allocate();
119       for (auto& i : in_)
120         i->init();
121       for (auto& i : subtasks_) i->compute();
122     }
123   public:
124     Task502(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task502()125     ~Task502() {}
126 };
127 
128 class Task503 : public Task {
129   protected:
130     std::shared_ptr<Tensor> out_;
131     std::array<std::shared_ptr<const Tensor>,1> in_;
132     class Task_local : public SubTask<4,1> {
133       protected:
134         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)135         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)136         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()137         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
138       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,1> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)139         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out,
140                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
141           : SubTask<4,1>(block, in, out), range_(ran) { }
142         void compute() override;
143     };
144     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()145     void compute_() override {
146       if (!out_->allocated())
147         out_->allocate();
148       for (auto& i : in_)
149         i->init();
150       for (auto& i : subtasks_) i->compute();
151     }
152   public:
153     Task503(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task503()154     ~Task503() {}
155 };
156 
157 class Task504 : public Task {
158   protected:
159     std::shared_ptr<Tensor> out_;
160     std::array<std::shared_ptr<const Tensor>,2> in_;
161     class Task_local : public SubTask<2,2> {
162       protected:
163         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)164         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)165         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()166         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
167       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)168         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
169                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
170           : SubTask<2,2>(block, in, out), range_(ran) { }
171         void compute() override;
172     };
173     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()174     void compute_() override {
175       if (!out_->allocated())
176         out_->allocate();
177       for (auto& i : in_)
178         i->init();
179       for (auto& i : subtasks_) i->compute();
180     }
181   public:
182     Task504(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task504()183     ~Task504() {}
184 };
185 
186 class Task505 : public Task {
187   protected:
188     std::shared_ptr<Tensor> out_;
189     std::array<std::shared_ptr<const Tensor>,2> in_;
190     class Task_local : public SubTask<4,2> {
191       protected:
192         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)193         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)194         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()195         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
196       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)197         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
198                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
199           : SubTask<4,2>(block, in, out), range_(ran) { }
200         void compute() override;
201     };
202     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()203     void compute_() override {
204       if (!out_->allocated())
205         out_->allocate();
206       for (auto& i : in_)
207         i->init();
208       for (auto& i : subtasks_) i->compute();
209     }
210   public:
211     Task505(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task505()212     ~Task505() {}
213 };
214 
215 class Task506 : public Task {
216   protected:
217     std::shared_ptr<Tensor> out_;
218     std::array<std::shared_ptr<const Tensor>,2> in_;
219     class Task_local : public SubTask<4,2> {
220       protected:
221         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)222         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)223         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()224         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
225       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)226         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
227                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
228           : SubTask<4,2>(block, in, out), range_(ran) { }
229         void compute() override;
230     };
231     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()232     void compute_() override {
233       if (!out_->allocated())
234         out_->allocate();
235       for (auto& i : in_)
236         i->init();
237       for (auto& i : subtasks_) i->compute();
238     }
239   public:
240     Task506(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task506()241     ~Task506() {}
242 };
243 
244 class Task507 : public Task {
245   protected:
246     std::shared_ptr<Tensor> out_;
247     std::array<std::shared_ptr<const Tensor>,2> in_;
248     class Task_local : public SubTask<4,2> {
249       protected:
250         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)251         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)252         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()253         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
254       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)255         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
256                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
257           : SubTask<4,2>(block, in, out), range_(ran) { }
258         void compute() override;
259     };
260     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()261     void compute_() override {
262       if (!out_->allocated())
263         out_->allocate();
264       for (auto& i : in_)
265         i->init();
266       for (auto& i : subtasks_) i->compute();
267     }
268   public:
269     Task507(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task507()270     ~Task507() {}
271 };
272 
273 class Task508 : public Task {
274   protected:
275     std::shared_ptr<Tensor> out_;
276     std::array<std::shared_ptr<const Tensor>,2> in_;
277     class Task_local : public SubTask<4,2> {
278       protected:
279         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)280         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)281         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()282         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
283       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)284         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
285                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
286           : SubTask<4,2>(block, in, out), range_(ran) { }
287         void compute() override;
288     };
289     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()290     void compute_() override {
291       if (!out_->allocated())
292         out_->allocate();
293       for (auto& i : in_)
294         i->init();
295       for (auto& i : subtasks_) i->compute();
296     }
297   public:
298     Task508(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task508()299     ~Task508() {}
300 };
301 
302 class Task509 : public Task {
303   protected:
304     std::shared_ptr<Tensor> out_;
305     std::array<std::shared_ptr<const Tensor>,2> in_;
306     class Task_local : public SubTask<4,2> {
307       protected:
308         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)309         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)310         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()311         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
312       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)313         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
314                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
315           : SubTask<4,2>(block, in, out), range_(ran) { }
316         void compute() override;
317     };
318     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()319     void compute_() override {
320       if (!out_->allocated())
321         out_->allocate();
322       for (auto& i : in_)
323         i->init();
324       for (auto& i : subtasks_) i->compute();
325     }
326   public:
327     Task509(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task509()328     ~Task509() {}
329 };
330 
331 class Task510 : public Task {
332   protected:
333     std::shared_ptr<Tensor> out_;
334     std::array<std::shared_ptr<const Tensor>,2> in_;
335     class Task_local : public SubTask<4,2> {
336       protected:
337         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)338         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)339         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()340         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
341       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)342         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
343                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
344           : SubTask<4,2>(block, in, out), range_(ran) { }
345         void compute() override;
346     };
347     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()348     void compute_() override {
349       if (!out_->allocated())
350         out_->allocate();
351       for (auto& i : in_)
352         i->init();
353       for (auto& i : subtasks_) i->compute();
354     }
355   public:
356     Task510(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task510()357     ~Task510() {}
358 };
359 
360 class Task511 : public Task {
361   protected:
362     std::shared_ptr<Tensor> out_;
363     std::array<std::shared_ptr<const Tensor>,2> in_;
364     class Task_local : public SubTask<4,2> {
365       protected:
366         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)367         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)368         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()369         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
370       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)371         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
372                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
373           : SubTask<4,2>(block, in, out), range_(ran) { }
374         void compute() override;
375     };
376     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()377     void compute_() override {
378       if (!out_->allocated())
379         out_->allocate();
380       for (auto& i : in_)
381         i->init();
382       for (auto& i : subtasks_) i->compute();
383     }
384   public:
385     Task511(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task511()386     ~Task511() {}
387 };
388 
389 class Task512 : public Task {
390   protected:
391     std::shared_ptr<Tensor> out_;
392     std::array<std::shared_ptr<const Tensor>,2> in_;
393     class Task_local : public SubTask<4,2> {
394       protected:
395         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)396         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)397         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()398         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
399       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)400         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
401                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
402           : SubTask<4,2>(block, in, out), range_(ran) { }
403         void compute() override;
404     };
405     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()406     void compute_() override {
407       if (!out_->allocated())
408         out_->allocate();
409       for (auto& i : in_)
410         i->init();
411       for (auto& i : subtasks_) i->compute();
412     }
413   public:
414     Task512(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task512()415     ~Task512() {}
416 };
417 
418 class Task513 : public Task {
419   protected:
420     std::shared_ptr<Tensor> out_;
421     std::array<std::shared_ptr<const Tensor>,2> in_;
422     class Task_local : public SubTask<4,2> {
423       protected:
424         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)425         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)426         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()427         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
428       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)429         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
430                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
431           : SubTask<4,2>(block, in, out), range_(ran) { }
432         void compute() override;
433     };
434     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()435     void compute_() override {
436       if (!out_->allocated())
437         out_->allocate();
438       for (auto& i : in_)
439         i->init();
440       for (auto& i : subtasks_) i->compute();
441     }
442   public:
443     Task513(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task513()444     ~Task513() {}
445 };
446 
447 class Task514 : public Task {
448   protected:
449     std::shared_ptr<Tensor> out_;
450     std::array<std::shared_ptr<const Tensor>,2> in_;
451     class Task_local : public SubTask<2,2> {
452       protected:
453         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)454         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)455         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()456         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
457       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)458         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
459                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
460           : SubTask<2,2>(block, in, out), range_(ran) { }
461         void compute() override;
462     };
463     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()464     void compute_() override {
465       if (!out_->allocated())
466         out_->allocate();
467       for (auto& i : in_)
468         i->init();
469       for (auto& i : subtasks_) i->compute();
470     }
471   public:
472     Task514(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task514()473     ~Task514() {}
474 };
475 
476 class Task515 : public Task {
477   protected:
478     std::shared_ptr<Tensor> out_;
479     std::array<std::shared_ptr<const Tensor>,2> in_;
480     class Task_local : public SubTask<2,2> {
481       protected:
482         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)483         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)484         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()485         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
486       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)487         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
488                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
489           : SubTask<2,2>(block, in, out), range_(ran) { }
490         void compute() override;
491     };
492     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()493     void compute_() override {
494       if (!out_->allocated())
495         out_->allocate();
496       for (auto& i : in_)
497         i->init();
498       for (auto& i : subtasks_) i->compute();
499     }
500   public:
501     Task515(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task515()502     ~Task515() {}
503 };
504 
505 class Task516 : public Task {
506   protected:
507     std::shared_ptr<Tensor> out_;
508     std::array<std::shared_ptr<const Tensor>,2> in_;
509     class Task_local : public SubTask<4,2> {
510       protected:
511         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)512         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)513         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()514         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
515       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)516         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
517                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
518           : SubTask<4,2>(block, in, out), range_(ran) { }
519         void compute() override;
520     };
521     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()522     void compute_() override {
523       if (!out_->allocated())
524         out_->allocate();
525       for (auto& i : in_)
526         i->init();
527       for (auto& i : subtasks_) i->compute();
528     }
529   public:
530     Task516(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task516()531     ~Task516() {}
532 };
533 
534 class Task517 : public Task {
535   protected:
536     std::shared_ptr<Tensor> out_;
537     std::array<std::shared_ptr<const Tensor>,2> in_;
538     class Task_local : public SubTask<2,2> {
539       protected:
540         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)541         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)542         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()543         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
544       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)545         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
546                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
547           : SubTask<2,2>(block, in, out), range_(ran) { }
548         void compute() override;
549     };
550     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()551     void compute_() override {
552       if (!out_->allocated())
553         out_->allocate();
554       for (auto& i : in_)
555         i->init();
556       for (auto& i : subtasks_) i->compute();
557     }
558   public:
559     Task517(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task517()560     ~Task517() {}
561 };
562 
563 class Task518 : public Task {
564   protected:
565     std::shared_ptr<Tensor> out_;
566     std::array<std::shared_ptr<const Tensor>,2> in_;
567     class Task_local : public SubTask<2,2> {
568       protected:
569         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)570         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)571         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()572         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
573       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)574         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
575                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
576           : SubTask<2,2>(block, in, out), range_(ran) { }
577         void compute() override;
578     };
579     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()580     void compute_() override {
581       if (!out_->allocated())
582         out_->allocate();
583       for (auto& i : in_)
584         i->init();
585       for (auto& i : subtasks_) i->compute();
586     }
587   public:
588     Task518(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task518()589     ~Task518() {}
590 };
591 
592 class Task519 : public Task {
593   protected:
594     std::shared_ptr<Tensor> out_;
595     std::array<std::shared_ptr<const Tensor>,2> in_;
596     class Task_local : public SubTask<4,2> {
597       protected:
598         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)599         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)600         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()601         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
602       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)603         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
604                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
605           : SubTask<4,2>(block, in, out), range_(ran) { }
606         void compute() override;
607     };
608     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()609     void compute_() override {
610       if (!out_->allocated())
611         out_->allocate();
612       for (auto& i : in_)
613         i->init();
614       for (auto& i : subtasks_) i->compute();
615     }
616   public:
617     Task519(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task519()618     ~Task519() {}
619 };
620 
621 class Task520 : public Task {
622   protected:
623     std::shared_ptr<Tensor> out_;
624     std::array<std::shared_ptr<const Tensor>,2> in_;
625     class Task_local : public SubTask<4,2> {
626       protected:
627         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)628         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)629         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()630         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
631       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)632         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
633                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
634           : SubTask<4,2>(block, in, out), range_(ran) { }
635         void compute() override;
636     };
637     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()638     void compute_() override {
639       if (!out_->allocated())
640         out_->allocate();
641       for (auto& i : in_)
642         i->init();
643       for (auto& i : subtasks_) i->compute();
644     }
645   public:
646     Task520(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task520()647     ~Task520() {}
648 };
649 
650 class Task521 : public Task {
651   protected:
652     std::shared_ptr<Tensor> out_;
653     std::array<std::shared_ptr<const Tensor>,2> in_;
654     class Task_local : public SubTask<4,2> {
655       protected:
656         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)657         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)658         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()659         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
660       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)661         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
662                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
663           : SubTask<4,2>(block, in, out), range_(ran) { }
664         void compute() override;
665     };
666     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()667     void compute_() override {
668       if (!out_->allocated())
669         out_->allocate();
670       for (auto& i : in_)
671         i->init();
672       for (auto& i : subtasks_) i->compute();
673     }
674   public:
675     Task521(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task521()676     ~Task521() {}
677 };
678 
679 class Task522 : public Task {
680   protected:
681     std::shared_ptr<Tensor> out_;
682     std::array<std::shared_ptr<const Tensor>,2> in_;
683     class Task_local : public SubTask<4,2> {
684       protected:
685         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)686         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)687         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()688         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
689       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)690         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
691                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
692           : SubTask<4,2>(block, in, out), range_(ran) { }
693         void compute() override;
694     };
695     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()696     void compute_() override {
697       if (!out_->allocated())
698         out_->allocate();
699       for (auto& i : in_)
700         i->init();
701       for (auto& i : subtasks_) i->compute();
702     }
703   public:
704     Task522(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task522()705     ~Task522() {}
706 };
707 
708 class Task523 : public Task {
709   protected:
710     std::shared_ptr<Tensor> out_;
711     std::array<std::shared_ptr<const Tensor>,2> in_;
712     class Task_local : public SubTask<4,2> {
713       protected:
714         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)715         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)716         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()717         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
718       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)719         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
720                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
721           : SubTask<4,2>(block, in, out), range_(ran) { }
722         void compute() override;
723     };
724     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()725     void compute_() override {
726       if (!out_->allocated())
727         out_->allocate();
728       for (auto& i : in_)
729         i->init();
730       for (auto& i : subtasks_) i->compute();
731     }
732   public:
733     Task523(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task523()734     ~Task523() {}
735 };
736 
737 class Task524 : public Task {
738   protected:
739     std::shared_ptr<Tensor> out_;
740     std::array<std::shared_ptr<const Tensor>,2> in_;
741     class Task_local : public SubTask<4,2> {
742       protected:
743         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)744         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)745         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()746         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
747       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)748         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
749                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
750           : SubTask<4,2>(block, in, out), range_(ran) { }
751         void compute() override;
752     };
753     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()754     void compute_() override {
755       if (!out_->allocated())
756         out_->allocate();
757       for (auto& i : in_)
758         i->init();
759       for (auto& i : subtasks_) i->compute();
760     }
761   public:
762     Task524(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task524()763     ~Task524() {}
764 };
765 
766 class Task525 : public Task {
767   protected:
768     std::shared_ptr<Tensor> out_;
769     std::array<std::shared_ptr<const Tensor>,1> in_;
770     class Task_local : public SubTask<4,1> {
771       protected:
772         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)773         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)774         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()775         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
776       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,1> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)777         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out,
778                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
779           : SubTask<4,1>(block, in, out), range_(ran) { }
780         void compute() override;
781     };
782     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()783     void compute_() override {
784       if (!out_->allocated())
785         out_->allocate();
786       for (auto& i : in_)
787         i->init();
788       for (auto& i : subtasks_) i->compute();
789     }
790   public:
791     Task525(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task525()792     ~Task525() {}
793 };
794 
795 class Task526 : public Task {
796   protected:
797     std::shared_ptr<Tensor> out_;
798     std::array<std::shared_ptr<const Tensor>,2> in_;
799     class Task_local : public SubTask<4,2> {
800       protected:
801         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)802         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)803         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()804         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
805       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)806         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
807                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
808           : SubTask<4,2>(block, in, out), range_(ran) { }
809         void compute() override;
810     };
811     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()812     void compute_() override {
813       if (!out_->allocated())
814         out_->allocate();
815       for (auto& i : in_)
816         i->init();
817       for (auto& i : subtasks_) i->compute();
818     }
819   public:
820     Task526(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task526()821     ~Task526() {}
822 };
823 
824 class Task527 : public Task {
825   protected:
826     std::shared_ptr<Tensor> out_;
827     std::array<std::shared_ptr<const Tensor>,2> in_;
828     class Task_local : public SubTask<4,2> {
829       protected:
830         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)831         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)832         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()833         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
834       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)835         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
836                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
837           : SubTask<4,2>(block, in, out), range_(ran) { }
838         void compute() override;
839     };
840     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()841     void compute_() override {
842       if (!out_->allocated())
843         out_->allocate();
844       for (auto& i : in_)
845         i->init();
846       for (auto& i : subtasks_) i->compute();
847     }
848   public:
849     Task527(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task527()850     ~Task527() {}
851 };
852 
853 class Task528 : public Task {
854   protected:
855     std::shared_ptr<Tensor> out_;
856     std::array<std::shared_ptr<const Tensor>,1> in_;
857     class Task_local : public SubTask<4,1> {
858       protected:
859         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)860         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)861         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()862         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
863       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,1> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)864         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out,
865                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
866           : SubTask<4,1>(block, in, out), range_(ran) { }
867         void compute() override;
868     };
869     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()870     void compute_() override {
871       if (!out_->allocated())
872         out_->allocate();
873       for (auto& i : in_)
874         i->init();
875       for (auto& i : subtasks_) i->compute();
876     }
877   public:
878     Task528(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task528()879     ~Task528() {}
880 };
881 
882 class Task529 : public Task {
883   protected:
884     std::shared_ptr<Tensor> out_;
885     std::array<std::shared_ptr<const Tensor>,2> in_;
886     class Task_local : public SubTask<4,2> {
887       protected:
888         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)889         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)890         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()891         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
892       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)893         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
894                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
895           : SubTask<4,2>(block, in, out), range_(ran) { }
896         void compute() override;
897     };
898     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()899     void compute_() override {
900       if (!out_->allocated())
901         out_->allocate();
902       for (auto& i : in_)
903         i->init();
904       for (auto& i : subtasks_) i->compute();
905     }
906   public:
907     Task529(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task529()908     ~Task529() {}
909 };
910 
911 class Task530 : public Task {
912   protected:
913     std::shared_ptr<Tensor> out_;
914     std::array<std::shared_ptr<const Tensor>,2> in_;
915     class Task_local : public SubTask<4,2> {
916       protected:
917         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)918         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)919         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()920         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
921       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)922         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
923                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
924           : SubTask<4,2>(block, in, out), range_(ran) { }
925         void compute() override;
926     };
927     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()928     void compute_() override {
929       if (!out_->allocated())
930         out_->allocate();
931       for (auto& i : in_)
932         i->init();
933       for (auto& i : subtasks_) i->compute();
934     }
935   public:
936     Task530(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task530()937     ~Task530() {}
938 };
939 
940 class Task531 : public Task {
941   protected:
942     std::shared_ptr<Tensor> out_;
943     std::array<std::shared_ptr<const Tensor>,1> in_;
944     class Task_local : public SubTask<4,1> {
945       protected:
946         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)947         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)948         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()949         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
950       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,1> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)951         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out,
952                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
953           : SubTask<4,1>(block, in, out), range_(ran) { }
954         void compute() override;
955     };
956     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()957     void compute_() override {
958       if (!out_->allocated())
959         out_->allocate();
960       for (auto& i : in_)
961         i->init();
962       for (auto& i : subtasks_) i->compute();
963     }
964   public:
965     Task531(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task531()966     ~Task531() {}
967 };
968 
969 class Task532 : public Task {
970   protected:
971     std::shared_ptr<Tensor> out_;
972     std::array<std::shared_ptr<const Tensor>,2> in_;
973     class Task_local : public SubTask<4,2> {
974       protected:
975         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)976         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)977         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()978         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
979       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)980         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
981                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
982           : SubTask<4,2>(block, in, out), range_(ran) { }
983         void compute() override;
984     };
985     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()986     void compute_() override {
987       if (!out_->allocated())
988         out_->allocate();
989       for (auto& i : in_)
990         i->init();
991       for (auto& i : subtasks_) i->compute();
992     }
993   public:
994     Task532(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task532()995     ~Task532() {}
996 };
997 
998 class Task533 : public Task {
999   protected:
1000     std::shared_ptr<Tensor> out_;
1001     std::array<std::shared_ptr<const Tensor>,2> in_;
1002     class Task_local : public SubTask<4,2> {
1003       protected:
1004         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1005         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1006         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1007         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1008       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1009         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1010                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1011           : SubTask<4,2>(block, in, out), range_(ran) { }
1012         void compute() override;
1013     };
1014     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1015     void compute_() override {
1016       if (!out_->allocated())
1017         out_->allocate();
1018       for (auto& i : in_)
1019         i->init();
1020       for (auto& i : subtasks_) i->compute();
1021     }
1022   public:
1023     Task533(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task533()1024     ~Task533() {}
1025 };
1026 
1027 class Task534 : public Task {
1028   protected:
1029     std::shared_ptr<Tensor> out_;
1030     std::array<std::shared_ptr<const Tensor>,1> in_;
1031     class Task_local : public SubTask<4,1> {
1032       protected:
1033         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1034         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1035         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1036         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1037       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,1> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1038         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out,
1039                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1040           : SubTask<4,1>(block, in, out), range_(ran) { }
1041         void compute() override;
1042     };
1043     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1044     void compute_() override {
1045       if (!out_->allocated())
1046         out_->allocate();
1047       for (auto& i : in_)
1048         i->init();
1049       for (auto& i : subtasks_) i->compute();
1050     }
1051   public:
1052     Task534(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task534()1053     ~Task534() {}
1054 };
1055 
1056 class Task535 : public Task {
1057   protected:
1058     std::shared_ptr<Tensor> out_;
1059     std::array<std::shared_ptr<const Tensor>,1> in_;
1060     class Task_local : public SubTask<4,1> {
1061       protected:
1062         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1063         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1064         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1065         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1066       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,1> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1067         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out,
1068                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1069           : SubTask<4,1>(block, in, out), range_(ran) { }
1070         void compute() override;
1071     };
1072     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1073     void compute_() override {
1074       if (!out_->allocated())
1075         out_->allocate();
1076       for (auto& i : in_)
1077         i->init();
1078       for (auto& i : subtasks_) i->compute();
1079     }
1080   public:
1081     Task535(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task535()1082     ~Task535() {}
1083 };
1084 
1085 class Task536 : public Task {
1086   protected:
1087     std::shared_ptr<Tensor> out_;
1088     std::array<std::shared_ptr<const Tensor>,2> in_;
1089     class Task_local : public SubTask<4,2> {
1090       protected:
1091         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1092         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1093         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1094         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1095       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1096         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1097                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1098           : SubTask<4,2>(block, in, out), range_(ran) { }
1099         void compute() override;
1100     };
1101     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1102     void compute_() override {
1103       if (!out_->allocated())
1104         out_->allocate();
1105       for (auto& i : in_)
1106         i->init();
1107       for (auto& i : subtasks_) i->compute();
1108     }
1109   public:
1110     Task536(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task536()1111     ~Task536() {}
1112 };
1113 
1114 class Task537 : public Task {
1115   protected:
1116     std::shared_ptr<Tensor> out_;
1117     std::array<std::shared_ptr<const Tensor>,2> in_;
1118     class Task_local : public SubTask<4,2> {
1119       protected:
1120         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1121         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1122         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1123         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1124       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1125         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1126                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1127           : SubTask<4,2>(block, in, out), range_(ran) { }
1128         void compute() override;
1129     };
1130     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1131     void compute_() override {
1132       if (!out_->allocated())
1133         out_->allocate();
1134       for (auto& i : in_)
1135         i->init();
1136       for (auto& i : subtasks_) i->compute();
1137     }
1138   public:
1139     Task537(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task537()1140     ~Task537() {}
1141 };
1142 
1143 class Task538 : public Task {
1144   protected:
1145     std::shared_ptr<Tensor> out_;
1146     std::array<std::shared_ptr<const Tensor>,2> in_;
1147     class Task_local : public SubTask<4,2> {
1148       protected:
1149         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1150         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1151         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1152         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1153       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1154         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1155                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1156           : SubTask<4,2>(block, in, out), range_(ran) { }
1157         void compute() override;
1158     };
1159     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1160     void compute_() override {
1161       if (!out_->allocated())
1162         out_->allocate();
1163       for (auto& i : in_)
1164         i->init();
1165       for (auto& i : subtasks_) i->compute();
1166     }
1167   public:
1168     Task538(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task538()1169     ~Task538() {}
1170 };
1171 
1172 class Task539 : public Task {
1173   protected:
1174     std::shared_ptr<Tensor> out_;
1175     std::array<std::shared_ptr<const Tensor>,2> in_;
1176     class Task_local : public SubTask<4,2> {
1177       protected:
1178         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1179         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1180         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1181         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1182       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1183         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1184                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1185           : SubTask<4,2>(block, in, out), range_(ran) { }
1186         void compute() override;
1187     };
1188     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1189     void compute_() override {
1190       if (!out_->allocated())
1191         out_->allocate();
1192       for (auto& i : in_)
1193         i->init();
1194       for (auto& i : subtasks_) i->compute();
1195     }
1196   public:
1197     Task539(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task539()1198     ~Task539() {}
1199 };
1200 
1201 class Task540 : public Task {
1202   protected:
1203     std::shared_ptr<Tensor> out_;
1204     std::array<std::shared_ptr<const Tensor>,2> in_;
1205     class Task_local : public SubTask<4,2> {
1206       protected:
1207         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1208         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1209         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1210         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1211       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1212         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1213                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1214           : SubTask<4,2>(block, in, out), range_(ran) { }
1215         void compute() override;
1216     };
1217     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1218     void compute_() override {
1219       if (!out_->allocated())
1220         out_->allocate();
1221       for (auto& i : in_)
1222         i->init();
1223       for (auto& i : subtasks_) i->compute();
1224     }
1225   public:
1226     Task540(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task540()1227     ~Task540() {}
1228 };
1229 
1230 class Task541 : public Task {
1231   protected:
1232     std::shared_ptr<Tensor> out_;
1233     std::array<std::shared_ptr<const Tensor>,2> in_;
1234     class Task_local : public SubTask<2,2> {
1235       protected:
1236         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1237         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1238         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1239         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1240       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1241         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1242                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1243           : SubTask<2,2>(block, in, out), range_(ran) { }
1244         void compute() override;
1245     };
1246     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1247     void compute_() override {
1248       if (!out_->allocated())
1249         out_->allocate();
1250       for (auto& i : in_)
1251         i->init();
1252       for (auto& i : subtasks_) i->compute();
1253     }
1254   public:
1255     Task541(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task541()1256     ~Task541() {}
1257 };
1258 
1259 class Task542 : public Task {
1260   protected:
1261     std::shared_ptr<Tensor> out_;
1262     std::array<std::shared_ptr<const Tensor>,2> in_;
1263     class Task_local : public SubTask<4,2> {
1264       protected:
1265         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1266         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1267         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1268         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1269       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1270         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1271                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1272           : SubTask<4,2>(block, in, out), range_(ran) { }
1273         void compute() override;
1274     };
1275     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1276     void compute_() override {
1277       if (!out_->allocated())
1278         out_->allocate();
1279       for (auto& i : in_)
1280         i->init();
1281       for (auto& i : subtasks_) i->compute();
1282     }
1283   public:
1284     Task542(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task542()1285     ~Task542() {}
1286 };
1287 
1288 class Task543 : public Task {
1289   protected:
1290     std::shared_ptr<Tensor> out_;
1291     std::array<std::shared_ptr<const Tensor>,2> in_;
1292     class Task_local : public SubTask<2,2> {
1293       protected:
1294         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1295         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1296         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1297         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1298       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1299         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1300                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1301           : SubTask<2,2>(block, in, out), range_(ran) { }
1302         void compute() override;
1303     };
1304     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1305     void compute_() override {
1306       if (!out_->allocated())
1307         out_->allocate();
1308       for (auto& i : in_)
1309         i->init();
1310       for (auto& i : subtasks_) i->compute();
1311     }
1312   public:
1313     Task543(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task543()1314     ~Task543() {}
1315 };
1316 
1317 class Task544 : public Task {
1318   protected:
1319     std::shared_ptr<Tensor> out_;
1320     std::array<std::shared_ptr<const Tensor>,2> in_;
1321     class Task_local : public SubTask<4,2> {
1322       protected:
1323         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1324         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1325         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1326         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1327       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1328         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1329                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1330           : SubTask<4,2>(block, in, out), range_(ran) { }
1331         void compute() override;
1332     };
1333     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1334     void compute_() override {
1335       if (!out_->allocated())
1336         out_->allocate();
1337       for (auto& i : in_)
1338         i->init();
1339       for (auto& i : subtasks_) i->compute();
1340     }
1341   public:
1342     Task544(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task544()1343     ~Task544() {}
1344 };
1345 
1346 class Task545 : public Task {
1347   protected:
1348     std::shared_ptr<Tensor> out_;
1349     std::array<std::shared_ptr<const Tensor>,2> in_;
1350     class Task_local : public SubTask<2,2> {
1351       protected:
1352         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1353         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1354         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1355         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1356       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1357         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1358                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1359           : SubTask<2,2>(block, in, out), range_(ran) { }
1360         void compute() override;
1361     };
1362     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1363     void compute_() override {
1364       if (!out_->allocated())
1365         out_->allocate();
1366       for (auto& i : in_)
1367         i->init();
1368       for (auto& i : subtasks_) i->compute();
1369     }
1370   public:
1371     Task545(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task545()1372     ~Task545() {}
1373 };
1374 
1375 class Task546 : public Task {
1376   protected:
1377     std::shared_ptr<Tensor> out_;
1378     std::array<std::shared_ptr<const Tensor>,2> in_;
1379     class Task_local : public SubTask<2,2> {
1380       protected:
1381         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1382         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1383         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1384         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1385       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1386         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1387                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1388           : SubTask<2,2>(block, in, out), range_(ran) { }
1389         void compute() override;
1390     };
1391     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1392     void compute_() override {
1393       if (!out_->allocated())
1394         out_->allocate();
1395       for (auto& i : in_)
1396         i->init();
1397       for (auto& i : subtasks_) i->compute();
1398     }
1399   public:
1400     Task546(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task546()1401     ~Task546() {}
1402 };
1403 
1404 class Task547 : public Task {
1405   protected:
1406     std::shared_ptr<Tensor> out_;
1407     std::array<std::shared_ptr<const Tensor>,2> in_;
1408     class Task_local : public SubTask<2,2> {
1409       protected:
1410         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1411         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1412         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1413         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1414       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1415         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1416                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1417           : SubTask<2,2>(block, in, out), range_(ran) { }
1418         void compute() override;
1419     };
1420     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1421     void compute_() override {
1422       if (!out_->allocated())
1423         out_->allocate();
1424       for (auto& i : in_)
1425         i->init();
1426       for (auto& i : subtasks_) i->compute();
1427     }
1428   public:
1429     Task547(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task547()1430     ~Task547() {}
1431 };
1432 
1433 class Task548 : public Task {
1434   protected:
1435     std::shared_ptr<Tensor> out_;
1436     std::array<std::shared_ptr<const Tensor>,2> in_;
1437     class Task_local : public SubTask<4,2> {
1438       protected:
1439         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1440         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1441         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1442         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1443       public:
Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1444         Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1445                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1446           : SubTask<4,2>(block, in, out), range_(ran) { }
1447         void compute() override;
1448     };
1449     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1450     void compute_() override {
1451       if (!out_->allocated())
1452         out_->allocate();
1453       for (auto& i : in_)
1454         i->init();
1455       for (auto& i : subtasks_) i->compute();
1456     }
1457   public:
1458     Task548(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task548()1459     ~Task548() {}
1460 };
1461 
1462 class Task549 : public Task {
1463   protected:
1464     std::shared_ptr<Tensor> out_;
1465     std::array<std::shared_ptr<const Tensor>,2> in_;
1466     class Task_local : public SubTask<2,2> {
1467       protected:
1468         const std::array<std::shared_ptr<const IndexRange>,3> range_;
b(const size_t & i)1469         const Index& b(const size_t& i) const { return this->block(i); }
in(const size_t & i)1470         std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); }
out()1471         std::shared_ptr<Tensor> out() { return this->out_tensor(); }
1472       public:
Task_local(const std::array<const Index,2> & block,const std::array<std::shared_ptr<const Tensor>,2> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1473         Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out,
1474                    std::array<std::shared_ptr<const IndexRange>,3>& ran)
1475           : SubTask<2,2>(block, in, out), range_(ran) { }
1476         void compute() override;
1477     };
1478     std::vector<std::shared_ptr<Task_local>> subtasks_;
compute_()1479     void compute_() override {
1480       if (!out_->allocated())
1481         out_->allocate();
1482       for (auto& i : in_)
1483         i->init();
1484       for (auto& i : subtasks_) i->compute();
1485     }
1486   public:
1487     Task549(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range);
~Task549()1488     ~Task549() {}
1489 };
1490 
1491 
1492 }
1493 }
1494 }
1495 #endif
1496 #endif
1497 
1498