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