1 // 2 // BAGEL - Brilliantly Advanced General Electronic Structure Library 3 // Filename: CASPT2_tasks1.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_CASPT2_TASKS1_H 29 #define __SRC_SMITH_CASPT2_TASKS1_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 CASPT2{ 40 41 class Task0 : public Task { // associated with gamma 42 protected: 43 std::shared_ptr<Tensor> out_; 44 std::array<std::shared_ptr<const Tensor>,5> in_; 45 class Task_local : public SubTask<6,5> { 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,6> & block,const std::array<std::shared_ptr<const Tensor>,5> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)52 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,5>& in, std::shared_ptr<Tensor>& out, 53 std::array<std::shared_ptr<const IndexRange>,3>& ran) 54 : SubTask<6,5>(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 : subtasks_) i->compute(); 62 } 63 public: 64 Task0(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task0()65 ~Task0() {} 66 }; 67 68 class Task1 : public Task { // associated with gamma 69 protected: 70 std::shared_ptr<Tensor> out_; 71 std::array<std::shared_ptr<const Tensor>,3> in_; 72 class Task_local : public SubTask<4,3> { 73 protected: 74 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)75 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)76 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()77 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 78 public: Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)79 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 80 std::array<std::shared_ptr<const IndexRange>,3>& ran) 81 : SubTask<4,3>(block, in, out), range_(ran) { } 82 void compute() override; 83 }; 84 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()85 void compute_() override { 86 if (!out_->allocated()) 87 out_->allocate(); 88 for (auto& i : subtasks_) i->compute(); 89 } 90 public: 91 Task1(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task1()92 ~Task1() {} 93 }; 94 95 class Task2 : public Task { // associated with gamma 96 protected: 97 std::shared_ptr<Tensor> out_; 98 std::array<std::shared_ptr<const Tensor>,3> in_; 99 class Task_local : public SubTask<6,3> { 100 protected: 101 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)102 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)103 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()104 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 105 public: Task_local(const std::array<const Index,6> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)106 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 107 std::array<std::shared_ptr<const IndexRange>,3>& ran) 108 : SubTask<6,3>(block, in, out), range_(ran) { } 109 void compute() override; 110 }; 111 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()112 void compute_() override { 113 if (!out_->allocated()) 114 out_->allocate(); 115 for (auto& i : subtasks_) i->compute(); 116 } 117 public: 118 Task2(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task2()119 ~Task2() {} 120 }; 121 122 class Task3 : public Task { // associated with gamma 123 protected: 124 std::shared_ptr<Tensor> out_; 125 std::array<std::shared_ptr<const Tensor>,3> in_; 126 class Task_local : public SubTask<4,3> { 127 protected: 128 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)129 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)130 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()131 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 132 public: Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)133 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 134 std::array<std::shared_ptr<const IndexRange>,3>& ran) 135 : SubTask<4,3>(block, in, out), range_(ran) { } 136 void compute() override; 137 }; 138 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()139 void compute_() override { 140 if (!out_->allocated()) 141 out_->allocate(); 142 for (auto& i : subtasks_) i->compute(); 143 } 144 public: 145 Task3(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task3()146 ~Task3() {} 147 }; 148 149 class Task4 : public Task { // associated with gamma 150 protected: 151 std::shared_ptr<Tensor> out_; 152 std::array<std::shared_ptr<const Tensor>,3> in_; 153 class Task_local : public SubTask<6,3> { 154 protected: 155 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)156 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)157 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()158 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 159 public: Task_local(const std::array<const Index,6> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)160 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 161 std::array<std::shared_ptr<const IndexRange>,3>& ran) 162 : SubTask<6,3>(block, in, out), range_(ran) { } 163 void compute() override; 164 }; 165 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()166 void compute_() override { 167 if (!out_->allocated()) 168 out_->allocate(); 169 for (auto& i : subtasks_) i->compute(); 170 } 171 public: 172 Task4(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task4()173 ~Task4() {} 174 }; 175 176 class Task5 : public Task { // associated with gamma 177 protected: 178 std::shared_ptr<Tensor> out_; 179 std::array<std::shared_ptr<const Tensor>,5> in_; 180 class Task_local : public SubTask<8,5> { 181 protected: 182 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)183 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)184 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()185 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 186 public: Task_local(const std::array<const Index,8> & block,const std::array<std::shared_ptr<const Tensor>,5> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)187 Task_local(const std::array<const Index,8>& block, const std::array<std::shared_ptr<const Tensor>,5>& in, std::shared_ptr<Tensor>& out, 188 std::array<std::shared_ptr<const IndexRange>,3>& ran) 189 : SubTask<8,5>(block, in, out), range_(ran) { } 190 void compute() override; 191 }; 192 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()193 void compute_() override { 194 if (!out_->allocated()) 195 out_->allocate(); 196 for (auto& i : subtasks_) i->compute(); 197 } 198 public: 199 Task5(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task5()200 ~Task5() {} 201 }; 202 203 class Task6 : public Task { // associated with gamma 204 protected: 205 std::shared_ptr<Tensor> out_; 206 std::array<std::shared_ptr<const Tensor>,3> in_; 207 class Task_local : public SubTask<6,3> { 208 protected: 209 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)210 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)211 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()212 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 213 public: Task_local(const std::array<const Index,6> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)214 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 215 std::array<std::shared_ptr<const IndexRange>,3>& ran) 216 : SubTask<6,3>(block, in, out), range_(ran) { } 217 void compute() override; 218 }; 219 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()220 void compute_() override { 221 if (!out_->allocated()) 222 out_->allocate(); 223 for (auto& i : subtasks_) i->compute(); 224 } 225 public: 226 Task6(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task6()227 ~Task6() {} 228 }; 229 230 class Task7 : public Task { // associated with gamma 231 protected: 232 std::shared_ptr<Tensor> out_; 233 std::array<std::shared_ptr<const Tensor>,2> in_; 234 class Task_local : public SubTask<4,2> { 235 protected: 236 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)237 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)238 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()239 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 240 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)241 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 242 std::array<std::shared_ptr<const IndexRange>,3>& ran) 243 : SubTask<4,2>(block, in, out), range_(ran) { } 244 void compute() override; 245 }; 246 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()247 void compute_() override { 248 if (!out_->allocated()) 249 out_->allocate(); 250 for (auto& i : subtasks_) i->compute(); 251 } 252 public: 253 Task7(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task7()254 ~Task7() {} 255 }; 256 257 class Task8 : public Task { // associated with gamma 258 protected: 259 std::shared_ptr<Tensor> out_; 260 std::array<std::shared_ptr<const Tensor>,3> in_; 261 class Task_local : public SubTask<6,3> { 262 protected: 263 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)264 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)265 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()266 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 267 public: Task_local(const std::array<const Index,6> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)268 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 269 std::array<std::shared_ptr<const IndexRange>,3>& ran) 270 : SubTask<6,3>(block, in, out), range_(ran) { } 271 void compute() override; 272 }; 273 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()274 void compute_() override { 275 if (!out_->allocated()) 276 out_->allocate(); 277 for (auto& i : subtasks_) i->compute(); 278 } 279 public: 280 Task8(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task8()281 ~Task8() {} 282 }; 283 284 class Task9 : public Task { // associated with gamma 285 protected: 286 std::shared_ptr<Tensor> out_; 287 std::array<std::shared_ptr<const Tensor>,2> in_; 288 class Task_local : public SubTask<4,2> { 289 protected: 290 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)291 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)292 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()293 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 294 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)295 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 296 std::array<std::shared_ptr<const IndexRange>,3>& ran) 297 : SubTask<4,2>(block, in, out), range_(ran) { } 298 void compute() override; 299 }; 300 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()301 void compute_() override { 302 if (!out_->allocated()) 303 out_->allocate(); 304 for (auto& i : subtasks_) i->compute(); 305 } 306 public: 307 Task9(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task9()308 ~Task9() {} 309 }; 310 311 class Task10 : public Task { // associated with gamma 312 protected: 313 std::shared_ptr<Tensor> out_; 314 std::array<std::shared_ptr<const Tensor>,4> in_; 315 class Task_local : public SubTask<4,4> { 316 protected: 317 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)318 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)319 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()320 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 321 public: Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,4> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)322 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,4>& in, std::shared_ptr<Tensor>& out, 323 std::array<std::shared_ptr<const IndexRange>,3>& ran) 324 : SubTask<4,4>(block, in, out), range_(ran) { } 325 void compute() override; 326 }; 327 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()328 void compute_() override { 329 if (!out_->allocated()) 330 out_->allocate(); 331 for (auto& i : subtasks_) i->compute(); 332 } 333 public: 334 Task10(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task10()335 ~Task10() {} 336 }; 337 338 class Task11 : public Task { // associated with gamma 339 protected: 340 std::shared_ptr<Tensor> out_; 341 std::array<std::shared_ptr<const Tensor>,2> in_; 342 class Task_local : public SubTask<2,2> { 343 protected: 344 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)345 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)346 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()347 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 348 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)349 Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 350 std::array<std::shared_ptr<const IndexRange>,3>& ran) 351 : SubTask<2,2>(block, in, out), range_(ran) { } 352 void compute() override; 353 }; 354 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()355 void compute_() override { 356 if (!out_->allocated()) 357 out_->allocate(); 358 for (auto& i : subtasks_) i->compute(); 359 } 360 public: 361 Task11(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task11()362 ~Task11() {} 363 }; 364 365 class Task12 : public Task { // associated with gamma 366 protected: 367 std::shared_ptr<Tensor> out_; 368 std::array<std::shared_ptr<const Tensor>,2> in_; 369 class Task_local : public SubTask<4,2> { 370 protected: 371 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)372 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)373 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()374 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 375 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)376 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 377 std::array<std::shared_ptr<const IndexRange>,3>& ran) 378 : SubTask<4,2>(block, in, out), range_(ran) { } 379 void compute() override; 380 }; 381 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()382 void compute_() override { 383 if (!out_->allocated()) 384 out_->allocate(); 385 for (auto& i : subtasks_) i->compute(); 386 } 387 public: 388 Task12(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task12()389 ~Task12() {} 390 }; 391 392 class Task13 : public Task { // associated with gamma 393 protected: 394 std::shared_ptr<Tensor> out_; 395 std::array<std::shared_ptr<const Tensor>,3> in_; 396 class Task_local : public SubTask<6,3> { 397 protected: 398 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)399 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)400 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()401 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 402 public: Task_local(const std::array<const Index,6> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)403 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 404 std::array<std::shared_ptr<const IndexRange>,3>& ran) 405 : SubTask<6,3>(block, in, out), range_(ran) { } 406 void compute() override; 407 }; 408 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()409 void compute_() override { 410 if (!out_->allocated()) 411 out_->allocate(); 412 for (auto& i : subtasks_) i->compute(); 413 } 414 public: 415 Task13(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task13()416 ~Task13() {} 417 }; 418 419 class Task14 : public Task { // associated with gamma 420 protected: 421 std::shared_ptr<Tensor> out_; 422 std::array<std::shared_ptr<const Tensor>,2> in_; 423 class Task_local : public SubTask<4,2> { 424 protected: 425 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)426 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)427 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()428 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 429 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)430 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 431 std::array<std::shared_ptr<const IndexRange>,3>& ran) 432 : SubTask<4,2>(block, in, out), range_(ran) { } 433 void compute() override; 434 }; 435 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()436 void compute_() override { 437 if (!out_->allocated()) 438 out_->allocate(); 439 for (auto& i : subtasks_) i->compute(); 440 } 441 public: 442 Task14(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task14()443 ~Task14() {} 444 }; 445 446 class Task15 : public Task { // associated with gamma 447 protected: 448 std::shared_ptr<Tensor> out_; 449 std::array<std::shared_ptr<const Tensor>,4> in_; 450 class Task_local : public SubTask<6,4> { 451 protected: 452 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)453 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)454 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()455 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 456 public: Task_local(const std::array<const Index,6> & block,const std::array<std::shared_ptr<const Tensor>,4> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)457 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,4>& in, std::shared_ptr<Tensor>& out, 458 std::array<std::shared_ptr<const IndexRange>,3>& ran) 459 : SubTask<6,4>(block, in, out), range_(ran) { } 460 void compute() override; 461 }; 462 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()463 void compute_() override { 464 if (!out_->allocated()) 465 out_->allocate(); 466 for (auto& i : subtasks_) i->compute(); 467 } 468 public: 469 Task15(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task15()470 ~Task15() {} 471 }; 472 473 class Task16 : public Task { // associated with gamma 474 protected: 475 std::shared_ptr<Tensor> out_; 476 std::array<std::shared_ptr<const Tensor>,2> in_; 477 class Task_local : public SubTask<4,2> { 478 protected: 479 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)480 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)481 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()482 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 483 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)484 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 485 std::array<std::shared_ptr<const IndexRange>,3>& ran) 486 : SubTask<4,2>(block, in, out), range_(ran) { } 487 void compute() override; 488 }; 489 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()490 void compute_() override { 491 if (!out_->allocated()) 492 out_->allocate(); 493 for (auto& i : subtasks_) i->compute(); 494 } 495 public: 496 Task16(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task16()497 ~Task16() {} 498 }; 499 500 class Task17 : public Task { // associated with gamma 501 protected: 502 std::shared_ptr<Tensor> out_; 503 std::array<std::shared_ptr<const Tensor>,2> in_; 504 class Task_local : public SubTask<4,2> { 505 protected: 506 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)507 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)508 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()509 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 510 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)511 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 512 std::array<std::shared_ptr<const IndexRange>,3>& ran) 513 : SubTask<4,2>(block, in, out), range_(ran) { } 514 void compute() override; 515 }; 516 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()517 void compute_() override { 518 if (!out_->allocated()) 519 out_->allocate(); 520 for (auto& i : subtasks_) i->compute(); 521 } 522 public: 523 Task17(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task17()524 ~Task17() {} 525 }; 526 527 class Task18 : public Task { // associated with gamma 528 protected: 529 std::shared_ptr<Tensor> out_; 530 std::array<std::shared_ptr<const Tensor>,4> in_; 531 class Task_local : public SubTask<6,4> { 532 protected: 533 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)534 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)535 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()536 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 537 public: Task_local(const std::array<const Index,6> & block,const std::array<std::shared_ptr<const Tensor>,4> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)538 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,4>& in, std::shared_ptr<Tensor>& out, 539 std::array<std::shared_ptr<const IndexRange>,3>& ran) 540 : SubTask<6,4>(block, in, out), range_(ran) { } 541 void compute() override; 542 }; 543 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()544 void compute_() override { 545 if (!out_->allocated()) 546 out_->allocate(); 547 for (auto& i : subtasks_) i->compute(); 548 } 549 public: 550 Task18(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task18()551 ~Task18() {} 552 }; 553 554 class Task19 : public Task { // associated with gamma 555 protected: 556 std::shared_ptr<Tensor> out_; 557 std::array<std::shared_ptr<const Tensor>,2> in_; 558 class Task_local : public SubTask<6,2> { 559 protected: 560 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)561 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)562 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()563 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 564 public: Task_local(const std::array<const Index,6> & 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)565 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 566 std::array<std::shared_ptr<const IndexRange>,3>& ran) 567 : SubTask<6,2>(block, in, out), range_(ran) { } 568 void compute() override; 569 }; 570 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()571 void compute_() override { 572 if (!out_->allocated()) 573 out_->allocate(); 574 for (auto& i : subtasks_) i->compute(); 575 } 576 public: 577 Task19(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task19()578 ~Task19() {} 579 }; 580 581 class Task20 : public Task { // associated with gamma 582 protected: 583 std::shared_ptr<Tensor> out_; 584 std::array<std::shared_ptr<const Tensor>,1> in_; 585 class Task_local : public SubTask<2,1> { 586 protected: 587 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)588 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)589 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()590 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 591 public: Task_local(const std::array<const Index,2> & 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)592 Task_local(const std::array<const Index,2>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out, 593 std::array<std::shared_ptr<const IndexRange>,3>& ran) 594 : SubTask<2,1>(block, in, out), range_(ran) { } 595 void compute() override; 596 }; 597 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()598 void compute_() override { 599 if (!out_->allocated()) 600 out_->allocate(); 601 for (auto& i : subtasks_) i->compute(); 602 } 603 public: 604 Task20(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task20()605 ~Task20() {} 606 }; 607 608 class Task21 : public Task { // associated with gamma 609 protected: 610 std::shared_ptr<Tensor> out_; 611 std::array<std::shared_ptr<const Tensor>,2> in_; 612 class Task_local : public SubTask<6,2> { 613 protected: 614 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)615 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)616 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()617 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 618 public: Task_local(const std::array<const Index,6> & 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)619 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 620 std::array<std::shared_ptr<const IndexRange>,3>& ran) 621 : SubTask<6,2>(block, in, out), range_(ran) { } 622 void compute() override; 623 }; 624 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()625 void compute_() override { 626 if (!out_->allocated()) 627 out_->allocate(); 628 for (auto& i : subtasks_) i->compute(); 629 } 630 public: 631 Task21(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task21()632 ~Task21() {} 633 }; 634 635 class Task22 : public Task { // associated with gamma 636 protected: 637 std::shared_ptr<Tensor> out_; 638 std::array<std::shared_ptr<const Tensor>,2> in_; 639 class Task_local : public SubTask<6,2> { 640 protected: 641 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)642 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)643 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()644 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 645 public: Task_local(const std::array<const Index,6> & 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)646 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 647 std::array<std::shared_ptr<const IndexRange>,3>& ran) 648 : SubTask<6,2>(block, in, out), range_(ran) { } 649 void compute() override; 650 }; 651 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()652 void compute_() override { 653 if (!out_->allocated()) 654 out_->allocate(); 655 for (auto& i : subtasks_) i->compute(); 656 } 657 public: 658 Task22(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task22()659 ~Task22() {} 660 }; 661 662 class Task23 : public Task { // associated with gamma 663 protected: 664 std::shared_ptr<Tensor> out_; 665 std::array<std::shared_ptr<const Tensor>,2> in_; 666 class Task_local : public SubTask<6,2> { 667 protected: 668 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)669 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)670 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()671 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 672 public: Task_local(const std::array<const Index,6> & 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)673 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 674 std::array<std::shared_ptr<const IndexRange>,3>& ran) 675 : SubTask<6,2>(block, in, out), range_(ran) { } 676 void compute() override; 677 }; 678 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()679 void compute_() override { 680 if (!out_->allocated()) 681 out_->allocate(); 682 for (auto& i : subtasks_) i->compute(); 683 } 684 public: 685 Task23(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task23()686 ~Task23() {} 687 }; 688 689 class Task24 : public Task { // associated with gamma 690 protected: 691 std::shared_ptr<Tensor> out_; 692 std::array<std::shared_ptr<const Tensor>,4> in_; 693 class Task_local : public SubTask<8,4> { 694 protected: 695 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)696 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)697 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()698 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 699 public: Task_local(const std::array<const Index,8> & block,const std::array<std::shared_ptr<const Tensor>,4> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)700 Task_local(const std::array<const Index,8>& block, const std::array<std::shared_ptr<const Tensor>,4>& in, std::shared_ptr<Tensor>& out, 701 std::array<std::shared_ptr<const IndexRange>,3>& ran) 702 : SubTask<8,4>(block, in, out), range_(ran) { } 703 void compute() override; 704 }; 705 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()706 void compute_() override { 707 if (!out_->allocated()) 708 out_->allocate(); 709 for (auto& i : subtasks_) i->compute(); 710 } 711 public: 712 Task24(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task24()713 ~Task24() {} 714 }; 715 716 class Task25 : public Task { // associated with gamma 717 protected: 718 std::shared_ptr<Tensor> out_; 719 std::array<std::shared_ptr<const Tensor>,2> in_; 720 class Task_local : public SubTask<6,2> { 721 protected: 722 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)723 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)724 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()725 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 726 public: Task_local(const std::array<const Index,6> & 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)727 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 728 std::array<std::shared_ptr<const IndexRange>,3>& ran) 729 : SubTask<6,2>(block, in, out), range_(ran) { } 730 void compute() override; 731 }; 732 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()733 void compute_() override { 734 if (!out_->allocated()) 735 out_->allocate(); 736 for (auto& i : subtasks_) i->compute(); 737 } 738 public: 739 Task25(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task25()740 ~Task25() {} 741 }; 742 743 class Task26 : public Task { // associated with gamma 744 protected: 745 std::shared_ptr<Tensor> out_; 746 std::array<std::shared_ptr<const Tensor>,1> in_; 747 class Task_local : public SubTask<4,1> { 748 protected: 749 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)750 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)751 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()752 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 753 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)754 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out, 755 std::array<std::shared_ptr<const IndexRange>,3>& ran) 756 : SubTask<4,1>(block, in, out), range_(ran) { } 757 void compute() override; 758 }; 759 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()760 void compute_() override { 761 if (!out_->allocated()) 762 out_->allocate(); 763 for (auto& i : subtasks_) i->compute(); 764 } 765 public: 766 Task26(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task26()767 ~Task26() {} 768 }; 769 770 class Task27 : public Task { // associated with gamma 771 protected: 772 std::shared_ptr<Tensor> out_; 773 std::array<std::shared_ptr<const Tensor>,2> in_; 774 class Task_local : public SubTask<4,2> { 775 protected: 776 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)777 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)778 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()779 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 780 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)781 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 782 std::array<std::shared_ptr<const IndexRange>,3>& ran) 783 : SubTask<4,2>(block, in, out), range_(ran) { } 784 void compute() override; 785 }; 786 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()787 void compute_() override { 788 if (!out_->allocated()) 789 out_->allocate(); 790 for (auto& i : subtasks_) i->compute(); 791 } 792 public: 793 Task27(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task27()794 ~Task27() {} 795 }; 796 797 class Task28 : public Task { // associated with gamma 798 protected: 799 std::shared_ptr<Tensor> out_; 800 std::array<std::shared_ptr<const Tensor>,2> in_; 801 class Task_local : public SubTask<6,2> { 802 protected: 803 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)804 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)805 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()806 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 807 public: Task_local(const std::array<const Index,6> & 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)808 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 809 std::array<std::shared_ptr<const IndexRange>,3>& ran) 810 : SubTask<6,2>(block, in, out), range_(ran) { } 811 void compute() override; 812 }; 813 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()814 void compute_() override { 815 if (!out_->allocated()) 816 out_->allocate(); 817 for (auto& i : subtasks_) i->compute(); 818 } 819 public: 820 Task28(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task28()821 ~Task28() {} 822 }; 823 824 class Task29 : public Task { // associated with gamma 825 protected: 826 std::shared_ptr<Tensor> out_; 827 std::array<std::shared_ptr<const Tensor>,3> in_; 828 class Task_local : public SubTask<6,3> { 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,6> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)835 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 836 std::array<std::shared_ptr<const IndexRange>,3>& ran) 837 : SubTask<6,3>(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 : subtasks_) i->compute(); 845 } 846 public: 847 Task29(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task29()848 ~Task29() {} 849 }; 850 851 class Task30 : public Task { // associated with gamma 852 protected: 853 std::shared_ptr<Tensor> out_; 854 std::array<std::shared_ptr<const Tensor>,4> in_; 855 class Task_local : public SubTask<6,4> { 856 protected: 857 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)858 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)859 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()860 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 861 public: Task_local(const std::array<const Index,6> & block,const std::array<std::shared_ptr<const Tensor>,4> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)862 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,4>& in, std::shared_ptr<Tensor>& out, 863 std::array<std::shared_ptr<const IndexRange>,3>& ran) 864 : SubTask<6,4>(block, in, out), range_(ran) { } 865 void compute() override; 866 }; 867 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()868 void compute_() override { 869 if (!out_->allocated()) 870 out_->allocate(); 871 for (auto& i : subtasks_) i->compute(); 872 } 873 public: 874 Task30(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task30()875 ~Task30() {} 876 }; 877 878 class Task31 : public Task { // associated with gamma 879 protected: 880 std::shared_ptr<Tensor> out_; 881 std::array<std::shared_ptr<const Tensor>,3> in_; 882 class Task_local : public SubTask<6,3> { 883 protected: 884 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)885 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)886 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()887 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 888 public: Task_local(const std::array<const Index,6> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)889 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 890 std::array<std::shared_ptr<const IndexRange>,3>& ran) 891 : SubTask<6,3>(block, in, out), range_(ran) { } 892 void compute() override; 893 }; 894 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()895 void compute_() override { 896 if (!out_->allocated()) 897 out_->allocate(); 898 for (auto& i : subtasks_) i->compute(); 899 } 900 public: 901 Task31(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task31()902 ~Task31() {} 903 }; 904 905 class Task32 : public Task { // associated with gamma 906 protected: 907 std::shared_ptr<Tensor> out_; 908 std::array<std::shared_ptr<const Tensor>,3> in_; 909 class Task_local : public SubTask<6,3> { 910 protected: 911 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)912 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)913 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()914 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 915 public: Task_local(const std::array<const Index,6> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)916 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 917 std::array<std::shared_ptr<const IndexRange>,3>& ran) 918 : SubTask<6,3>(block, in, out), range_(ran) { } 919 void compute() override; 920 }; 921 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()922 void compute_() override { 923 if (!out_->allocated()) 924 out_->allocate(); 925 for (auto& i : subtasks_) i->compute(); 926 } 927 public: 928 Task32(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task32()929 ~Task32() {} 930 }; 931 932 class Task33 : public Task { // associated with gamma 933 protected: 934 std::shared_ptr<Tensor> out_; 935 std::array<std::shared_ptr<const Tensor>,1> in_; 936 class Task_local : public SubTask<6,1> { 937 protected: 938 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)939 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)940 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()941 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 942 public: Task_local(const std::array<const Index,6> & 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)943 Task_local(const std::array<const Index,6>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out, 944 std::array<std::shared_ptr<const IndexRange>,3>& ran) 945 : SubTask<6,1>(block, in, out), range_(ran) { } 946 void compute() override; 947 }; 948 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()949 void compute_() override { 950 if (!out_->allocated()) 951 out_->allocate(); 952 for (auto& i : subtasks_) i->compute(); 953 } 954 public: 955 Task33(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task33()956 ~Task33() {} 957 }; 958 959 class Task34 : public Task { // associated with gamma 960 protected: 961 std::shared_ptr<Tensor> out_; 962 std::array<std::shared_ptr<const Tensor>,4> in_; 963 class Task_local : public SubTask<8,4> { 964 protected: 965 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)966 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)967 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()968 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 969 public: Task_local(const std::array<const Index,8> & block,const std::array<std::shared_ptr<const Tensor>,4> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)970 Task_local(const std::array<const Index,8>& block, const std::array<std::shared_ptr<const Tensor>,4>& in, std::shared_ptr<Tensor>& out, 971 std::array<std::shared_ptr<const IndexRange>,3>& ran) 972 : SubTask<8,4>(block, in, out), range_(ran) { } 973 void compute() override; 974 }; 975 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()976 void compute_() override { 977 if (!out_->allocated()) 978 out_->allocate(); 979 for (auto& i : subtasks_) i->compute(); 980 } 981 public: 982 Task34(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task34()983 ~Task34() {} 984 }; 985 986 class Task35 : public Task { // associated with gamma 987 protected: 988 std::shared_ptr<Tensor> out_; 989 std::array<std::shared_ptr<const Tensor>,3> in_; 990 class Task_local : public SubTask<8,3> { 991 protected: 992 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)993 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)994 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()995 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 996 public: Task_local(const std::array<const Index,8> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)997 Task_local(const std::array<const Index,8>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 998 std::array<std::shared_ptr<const IndexRange>,3>& ran) 999 : SubTask<8,3>(block, in, out), range_(ran) { } 1000 void compute() override; 1001 }; 1002 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()1003 void compute_() override { 1004 if (!out_->allocated()) 1005 out_->allocate(); 1006 for (auto& i : subtasks_) i->compute(); 1007 } 1008 public: 1009 Task35(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task35()1010 ~Task35() {} 1011 }; 1012 1013 class Task36 : public Task { // associated with gamma 1014 protected: 1015 std::shared_ptr<Tensor> out_; 1016 std::array<std::shared_ptr<const Tensor>,3> in_; 1017 class Task_local : public SubTask<4,3> { 1018 protected: 1019 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)1020 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)1021 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()1022 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 1023 public: Task_local(const std::array<const Index,4> & block,const std::array<std::shared_ptr<const Tensor>,3> & in,std::shared_ptr<Tensor> & out,std::array<std::shared_ptr<const IndexRange>,3> & ran)1024 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,3>& in, std::shared_ptr<Tensor>& out, 1025 std::array<std::shared_ptr<const IndexRange>,3>& ran) 1026 : SubTask<4,3>(block, in, out), range_(ran) { } 1027 void compute() override; 1028 }; 1029 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()1030 void compute_() override { 1031 if (!out_->allocated()) 1032 out_->allocate(); 1033 for (auto& i : subtasks_) i->compute(); 1034 } 1035 public: 1036 Task36(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task36()1037 ~Task36() {} 1038 }; 1039 1040 class Task37 : public Task { 1041 protected: 1042 std::shared_ptr<Tensor> r_; 1043 IndexRange closed_; 1044 IndexRange active_; 1045 IndexRange virt_; 1046 const bool reset_; compute_()1047 void compute_() { 1048 if (reset_) r_->zero(); 1049 } 1050 public: 1051 Task37(std::vector<std::shared_ptr<Tensor>> t, const bool reset); ~Task37()1052 ~Task37() {} 1053 }; 1054 1055 class Task38 : public Task { 1056 protected: 1057 std::shared_ptr<Tensor> out_; 1058 std::array<std::shared_ptr<const Tensor>,1> in_; 1059 class Task_local : public SubTask<4,1> { 1060 protected: 1061 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)1062 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)1063 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()1064 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 1065 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)1066 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out, 1067 std::array<std::shared_ptr<const IndexRange>,3>& ran) 1068 : SubTask<4,1>(block, in, out), range_(ran) { } 1069 void compute() override; 1070 }; 1071 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()1072 void compute_() override { 1073 if (!out_->allocated()) 1074 out_->allocate(); 1075 for (auto& i : in_) 1076 i->init(); 1077 for (auto& i : subtasks_) i->compute(); 1078 } 1079 public: 1080 Task38(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task38()1081 ~Task38() {} 1082 }; 1083 1084 class Task39 : public Task { 1085 protected: 1086 std::shared_ptr<Tensor> out_; 1087 std::array<std::shared_ptr<const Tensor>,2> in_; 1088 class Task_local : public SubTask<4,2> { 1089 protected: 1090 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)1091 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)1092 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()1093 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 1094 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)1095 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,2>& in, std::shared_ptr<Tensor>& out, 1096 std::array<std::shared_ptr<const IndexRange>,3>& ran) 1097 : SubTask<4,2>(block, in, out), range_(ran) { } 1098 void compute() override; 1099 }; 1100 std::vector<std::shared_ptr<Task_local>> subtasks_; compute_()1101 void compute_() override { 1102 if (!out_->allocated()) 1103 out_->allocate(); 1104 for (auto& i : in_) 1105 i->init(); 1106 for (auto& i : subtasks_) i->compute(); 1107 } 1108 public: 1109 Task39(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task39()1110 ~Task39() {} 1111 }; 1112 1113 class Task40 : public Task { 1114 protected: 1115 std::shared_ptr<Tensor> out_; 1116 std::array<std::shared_ptr<const Tensor>,2> in_; 1117 class Task_local : public SubTask<4,2> { 1118 protected: 1119 const std::array<std::shared_ptr<const IndexRange>,3> range_; b(const size_t & i)1120 const Index& b(const size_t& i) const { return this->block(i); } in(const size_t & i)1121 std::shared_ptr<const Tensor> in(const size_t& i) const { return this->in_tensor(i); } out()1122 std::shared_ptr<Tensor> out() { return this->out_tensor(); } 1123 const double e0_; 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,const double e)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, const double e) 1127 : SubTask<4,2>(block, in, out), range_(ran), e0_(e) { } 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 Task40(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range, const double e); ~Task40()1140 ~Task40() {} 1141 }; 1142 1143 class Task41 : public Task { 1144 protected: 1145 std::shared_ptr<Tensor> out_; 1146 std::array<std::shared_ptr<const Tensor>,1> in_; 1147 class Task_local : public SubTask<4,1> { 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>,1> & 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>,1>& in, std::shared_ptr<Tensor>& out, 1155 std::array<std::shared_ptr<const IndexRange>,3>& ran) 1156 : SubTask<4,1>(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 Task41(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task41()1169 ~Task41() {} 1170 }; 1171 1172 class Task42 : 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 Task42(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task42()1198 ~Task42() {} 1199 }; 1200 1201 class Task43 : 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 Task43(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task43()1227 ~Task43() {} 1228 }; 1229 1230 class Task44 : 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<4,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,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)1241 Task_local(const std::array<const Index,4>& 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<4,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 Task44(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task44()1256 ~Task44() {} 1257 }; 1258 1259 class Task45 : 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 Task45(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task45()1285 ~Task45() {} 1286 }; 1287 1288 class Task46 : 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<4,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,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)1299 Task_local(const std::array<const Index,4>& 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<4,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 Task46(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task46()1314 ~Task46() {} 1315 }; 1316 1317 class Task47 : 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 Task47(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task47()1343 ~Task47() {} 1344 }; 1345 1346 class Task48 : public Task { 1347 protected: 1348 std::shared_ptr<Tensor> out_; 1349 std::array<std::shared_ptr<const Tensor>,1> in_; 1350 class Task_local : public SubTask<4,1> { 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,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)1357 Task_local(const std::array<const Index,4>& block, const std::array<std::shared_ptr<const Tensor>,1>& in, std::shared_ptr<Tensor>& out, 1358 std::array<std::shared_ptr<const IndexRange>,3>& ran) 1359 : SubTask<4,1>(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 Task48(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task48()1372 ~Task48() {} 1373 }; 1374 1375 class Task49 : 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<4,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,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)1386 Task_local(const std::array<const Index,4>& 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<4,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 Task49(std::vector<std::shared_ptr<Tensor>> t, std::array<std::shared_ptr<const IndexRange>,3> range); ~Task49()1401 ~Task49() {} 1402 }; 1403 1404 1405 } 1406 } 1407 } 1408 #endif 1409 #endif 1410 1411