Bridge++  Ver. 2.0.2
afield_dd-inc.h
Go to the documentation of this file.
1 
10 #ifndef QXS_AFIELD_DD_INC_INCLUDED
11 #define QXS_AFIELD_DD_INC_INCLUDED
12 
13 #include <cstdlib>
14 
15 #include "complexTraits.h"
16 #include "lib/ResourceManager/threadManager.h"
17 
18 #include "lib_alt_QXS/inline/afield_th-inc.h"
19 
20 
21 
22 //====================================================================
23 template<typename INDEX, typename AFIELD>
24 void block_dotc(typename AFIELD::complex_t *out, const AFIELD& v,
25  const AFIELD& w, const INDEX& block_index)
26 {
27  block_dotc_eo(out, v, w, -1, block_index);
28 }
29 
30 
31 //====================================================================
32 template<typename INDEX, typename AFIELD>
33 void block_dotc_eo(typename AFIELD::complex_t *out,
34  const AFIELD& v, const AFIELD& w,
35  const int ieo, const INDEX& block_index)
36 {
37  typedef typename AFIELD::real_t real_t;
38  typedef typename AFIELD::complex_t complex_t;
39 
40  real_t *vp = const_cast<AFIELD *>(&v)->ptr(0);
41  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
42 
43  int Nin = v.nin();
44  int Nex = v.nex();
45  int Nstv = v.nvol() / VLEN;
46 
47  int Nxv = block_index.fine_lattice_size(0) / VLENX;
48  int Nyv = block_index.fine_lattice_size(1) / VLENY;
49  int Nz = block_index.fine_lattice_size(2);
50 
51  int Nblock = block_index.coarse_nvol();
52  int NBx = block_index.coarse_lattice_size(0);
53  int NBy = block_index.coarse_lattice_size(1);
54  int NBz = block_index.coarse_lattice_size(2);
55  int NBt = block_index.coarse_lattice_size(3);
56 
57  int Bsize = block_index.block_nvol() / VLEN;
58  int Bxv = block_index.block_size(0) / VLENX;
59  int Byv = block_index.block_size(1) / VLENY;
60  int Bz = block_index.block_size(2);
61  int Bt = block_index.block_size(3);
62 
63  int ith, nth, is, ns;
64  set_threadtask(ith, nth, is, ns, Nblock);
65 
66  int ieo_skip = 1 - ieo;
67  for (int block = is; block < ns; ++block) {
68  if (block_index.block_eo(block) == ieo_skip) {
69  out[block] = cmplx(real_t(0.0), real_t(0.0));
70  continue;
71  }
72 
73  int ibx = block % NBx;
74  int iby = (block / NBx) % NBy;
75  int ibz = (block / (NBx * NBy)) % NBz;
76  int ibt = block / (NBx * NBy * NBz);
77 
78  svbool_t pg = set_predicate();
79  svreal_t ytr, yti;
80  set_vec(pg, ytr, 0.0);
81  set_vec(pg, yti, 0.0);
82 
83  for (int bsite = 0; bsite < Bsize; ++bsite) {
84  int kx = bsite % Bxv;
85  int ix = kx + Bxv * ibx;
86  int kyzt = bsite / Bxv;
87  int ky = kyzt % Byv;
88  int iy = ky + Byv * iby;
89  int kzt = kyzt / Byv;
90  int kz = kzt % Bz;
91  int iz = kz + Bz * ibz;
92  int kt = kzt / Bz;
93  int it = kt + Bt * ibt;
94  int site = ix + Nxv * (iy + Nyv * (iz + Nz * it));
95 
96  svbool_t pg = set_predicate();
97  svreal_t xtr, xti;
98  set_vec(pg, xtr, 0.0);
99  set_vec(pg, xti, 0.0);
100 
101  for (int ex = 0; ex < Nex; ++ex) {
102  for (int in2 = 0; in2 < Nin / 2; ++in2) {
103  int inr = 2 * in2;
104  int ini = 2 * in2 + 1;
105 
106  svreal_t vtr, vti, wtr, wti;
107  load_vec(pg, vtr, &vp[VLEN * (inr + Nin * (site + Nstv * ex))]);
108  load_vec(pg, vti, &vp[VLEN * (ini + Nin * (site + Nstv * ex))]);
109  load_vec(pg, wtr, &wp[VLEN * (inr + Nin * (site + Nstv * ex))]);
110  load_vec(pg, wti, &wp[VLEN * (ini + Nin * (site + Nstv * ex))]);
111  add_dot_vec(pg, xtr, vtr, wtr);
112  add_dot_vec(pg, xtr, vti, wti);
113  add_dot_vec(pg, xti, vtr, wti);
114  sub_dot_vec(pg, xti, vti, wtr);
115  }
116  }
117 
118  add_vec(pg, ytr, xtr);
119  add_vec(pg, yti, xti);
120  }
121 
122  real_t atr, ati;
123  reduce_vec(pg, atr, ytr);
124  reduce_vec(pg, ati, yti);
125  out[block] = cmplx(atr, ati);
126  }
127 }
128 
129 
130 //====================================================================
131 template<typename INDEX, typename AFIELD>
132 void block_norm2(typename AFIELD::real_t *out, const AFIELD& v,
133  const INDEX& block_index)
134 {
135  block_norm2_eo(out, v, -1, block_index);
136 }
137 
138 
139 //====================================================================
140 template<typename INDEX, typename AFIELD>
141 void block_norm2_eo(typename AFIELD::real_t *out,
142  const AFIELD& v, const int ieo,
143  const INDEX& block_index)
144 {
145  typedef typename AFIELD::real_t real_t;
146 
147  real_t *vp = const_cast<AFIELD *>(&v)->ptr(0);
148 
149  int Nin = v.nin();
150  int Nex = v.nex();
151  int Nstv = v.nvol() / VLEN;
152 
153  int Nxv = block_index.fine_lattice_size(0) / VLENX;
154  int Nyv = block_index.fine_lattice_size(1) / VLENY;
155  int Nz = block_index.fine_lattice_size(2);
156 
157  int Nblock = block_index.coarse_nvol();
158  int NBx = block_index.coarse_lattice_size(0);
159  int NBy = block_index.coarse_lattice_size(1);
160  int NBz = block_index.coarse_lattice_size(2);
161  int NBt = block_index.coarse_lattice_size(3);
162 
163  int Bsize = block_index.block_nvol() / VLEN;
164  int Bxv = block_index.block_size(0) / VLENX;
165  int Byv = block_index.block_size(1) / VLENY;
166  int Bz = block_index.block_size(2);
167  int Bt = block_index.block_size(3);
168 
169  int ith, nth, is, ns;
170  set_threadtask(ith, nth, is, ns, Nblock);
171  int ieo_skip = 1 - ieo;
172 
173  for (int block = is; block < ns; ++block) {
174  if (block_index.block_eo(block) == ieo_skip) {
175  // out[block] = real_t(0.0);
176  continue;
177  }
178 
179  int ibx = block % NBx;
180  int iby = (block / NBx) % NBy;
181  int ibz = (block / (NBx * NBy)) % NBz;
182  int ibt = block / (NBx * NBy * NBz);
183 
184  svbool_t pg = set_predicate();
185  svreal_t yt;
186  set_vec(pg, yt, 0.0);
187 
188  for (int bsite = 0; bsite < Bsize; ++bsite) {
189  int kx = bsite % Bxv;
190  int ix = kx + Bxv * ibx;
191  int kyzt = bsite / Bxv;
192  int ky = kyzt % Byv;
193  int iy = ky + Byv * iby;
194  int kzt = kyzt / Byv;
195  int kz = kzt % Bz;
196  int iz = kz + Bz * ibz;
197  int kt = kzt / Bz;
198  int it = kt + Bt * ibt;
199  int site = ix + Nxv * (iy + Nyv * (iz + Nz * it));
200 
201  svreal_t xt, vt;
202  set_vec(pg, xt, 0.0);
203 
204  for (int ex = 0; ex < Nex; ++ex) {
205  for (int in = 0; in < Nin; ++in) {
206  load_vec(pg, vt, &vp[VLEN * (in + Nin * (site + Nstv * ex))]);
207  add_dot_vec(pg, xt, vt, vt);
208  }
209  }
210  add_vec(pg, yt, xt);
211  }
212  real_t a;
213  reduce_vec(pg, a, yt);
214  out[block] = a;
215  }
216 }
217 
218 
219 //====================================================================
220 template<typename INDEX, typename AFIELD>
221 void block_scal(AFIELD& v, const typename AFIELD::real_t *a,
222  const INDEX& block_index)
223 {
224  block_scal_eo(v, a, -1, block_index);
225 }
226 
227 
228 //====================================================================
229 template<typename INDEX, typename AFIELD>
230 void block_scal_eo(AFIELD& v, const typename AFIELD::real_t *a,
231  const int ieo, const INDEX& block_index)
232 {
233  typedef typename AFIELD::real_t real_t;
234 
235  real_t *vp = v.ptr(0);
236 
237  int Nin = v.nin();
238  int Nex = v.nex();
239  int Nstv = v.nvol() / VLEN;
240 
241  int Nxv = block_index.fine_lattice_size(0) / VLENX;
242  int Nyv = block_index.fine_lattice_size(1) / VLENY;
243  int Nz = block_index.fine_lattice_size(2);
244 
245  int Nblock = block_index.coarse_nvol();
246  int NBx = block_index.coarse_lattice_size(0);
247  int NBy = block_index.coarse_lattice_size(1);
248  int NBz = block_index.coarse_lattice_size(2);
249  int NBt = block_index.coarse_lattice_size(3);
250 
251  int Bsize = block_index.block_nvol() / VLEN;
252  int Bxv = block_index.block_size(0) / VLENX;
253  int Byv = block_index.block_size(1) / VLENY;
254  int Bz = block_index.block_size(2);
255  int Bt = block_index.block_size(3);
256 
257  int ith, nth, is, ns;
258  set_threadtask(ith, nth, is, ns, Nblock);
259  int ieo_skip = 1 - ieo;
260 
261  svbool_t pg = set_predicate();
262 
263  for (int block = is; block < ns; ++block) {
264  if (block_index.block_eo(block) == ieo_skip) continue;
265  int ibx = block % NBx;
266  int iby = (block / NBx) % NBy;
267  int ibz = (block / (NBx * NBy)) % NBz;
268  int ibt = block / (NBx * NBy * NBz);
269 
270  real_t at = a[block];
271  for (int bsite = 0; bsite < Bsize; ++bsite) {
272  int kx = bsite % Bxv;
273  int ix = kx + Bxv * ibx;
274  int kyzt = bsite / Bxv;
275  int ky = kyzt % Byv;
276  int iy = ky + Byv * iby;
277  int kzt = kyzt / Byv;
278  int kz = kzt % Bz;
279  int iz = kz + Bz * ibz;
280  int kt = kzt / Bz;
281  int it = kt + Bt * ibt;
282  int site = ix + Nxv * (iy + Nyv * (iz + Nz * it));
283 
284  for (int ex = 0; ex < Nex; ++ex) {
285  for (int in = 0; in < Nin; ++in) {
286  svreal_t vt;
287  load_vec(pg, vt, &vp[VLEN * (in + Nin * (site + Nstv * ex))]);
288  scal_vec(pg, vt, at);
289  save_vec(pg, &vp[VLEN * (in + Nin * (site + Nstv * ex))], vt);
290  }
291  }
292  }
293  }
294 }
295 
296 
297 //====================================================================
298 template<typename INDEX, typename AFIELD>
299 void block_scal(AFIELD& v, const typename AFIELD::complex_t *a,
300  const INDEX& block_index)
301 {
302  block_scal_eo(v, a, -1, block_index);
303 }
304 
305 
306 //====================================================================
307 template<typename INDEX, typename AFIELD>
308 void block_scal_eo(AFIELD& v, const typename AFIELD::complex_t *a,
309  const int ieo, const INDEX& block_index)
310 {
311  typedef typename AFIELD::real_t real_t;
312  typedef typename AFIELD::complex_t complex_t;
313 
314  real_t *vp = v.ptr(0);
315 
316  int Nin = v.nin();
317  int Nex = v.nex();
318  int Nstv = v.nvol() / VLEN;
319 
320  int Nxv = block_index.fine_lattice_size(0) / VLENX;
321  int Nyv = block_index.fine_lattice_size(1) / VLENY;
322  int Nz = block_index.fine_lattice_size(2);
323 
324  int Nblock = block_index.coarse_nvol();
325  int NBx = block_index.coarse_lattice_size(0);
326  int NBy = block_index.coarse_lattice_size(1);
327  int NBz = block_index.coarse_lattice_size(2);
328  int NBt = block_index.coarse_lattice_size(3);
329 
330  int Bsize = block_index.block_nvol() / VLEN;
331  int Bxv = block_index.block_size(0) / VLENX;
332  int Byv = block_index.block_size(1) / VLENY;
333  int Bz = block_index.block_size(2);
334  int Bt = block_index.block_size(3);
335 
336  int ith, nth, is, ns;
337  set_threadtask(ith, nth, is, ns, Nblock);
338  int ieo_skip = 1 - ieo;
339 
340  svbool_t pg = set_predicate();
341 
342  for (int block = is; block < ns; ++block) {
343  if (block_index.block_eo(block) == ieo_skip) continue;
344  int ibx = block % NBx;
345  int iby = (block / NBx) % NBy;
346  int ibz = (block / (NBx * NBy)) % NBz;
347  int ibt = block / (NBx * NBy * NBz);
348 
349  for (int bsite = 0; bsite < Bsize; ++bsite) {
350  int kx = bsite % Bxv;
351  int ix = kx + Bxv * ibx;
352  int kyzt = bsite / Bxv;
353  int ky = kyzt % Byv;
354  int iy = ky + Byv * iby;
355  int kzt = kyzt / Byv;
356  int kz = kzt % Bz;
357  int iz = kz + Bz * ibz;
358  int kt = kzt / Bz;
359  int it = kt + Bt * ibt;
360  int site = ix + Nxv * (iy + Nyv * (iz + Nz * it));
361 
362  complex_t at = a[block];
363  real_t atr = real(at);
364  real_t ati = imag(at);
365 
366  for (int ex = 0; ex < Nex; ++ex) {
367  for (int in2 = 0; in2 < Nin / 2; ++in2) {
368  int inr = 2 * in2;
369  int ini = 2 * in2 + 1;
370  svreal_t vtr, vti, wtr, wti;
371  load_vec(pg, wtr, &vp[VLEN * (inr + Nin * (site + Nstv * ex))]);
372  load_vec(pg, wti, &vp[VLEN * (ini + Nin * (site + Nstv * ex))]);
373  set_vec(pg, vtr, atr, wtr);
374  axpy_vec(pg, vtr, -ati, wti);
375  set_vec(pg, vti, atr, wti);
376  axpy_vec(pg, vti, ati, wtr);
377  save_vec(pg, &vp[VLEN * (inr + Nin * (site + Nstv * ex))], vtr);
378  save_vec(pg, &vp[VLEN * (ini + Nin * (site + Nstv * ex))], vti);
379  }
380  }
381  }
382  }
383 }
384 
385 
386 //====================================================================
387 template<typename INDEX, typename AFIELD>
388 void block_axpy(AFIELD& v, const typename AFIELD::real_t *a,
389  const AFIELD& w, const typename AFIELD::real_t fac,
390  const INDEX& block_index)
391 {
392  block_axpy_eo(v, a, w, -1, fac, block_index);
393 }
394 
395 
396 //====================================================================
397 template<typename INDEX, typename AFIELD>
398 void block_axpy_eo(AFIELD& v, const typename AFIELD::real_t *a,
399  const AFIELD& w, const int ieo,
400  const typename AFIELD::real_t fac,
401  const INDEX& block_index)
402 {
403  typedef typename AFIELD::real_t real_t;
404 
405  real_t *vp = v.ptr(0);
406  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
407 
408  int Nin = v.nin();
409  int Nex = v.nex();
410  int Nstv = v.nvol() / VLEN;
411 
412  int Nxv = block_index.fine_lattice_size(0) / VLENX;
413  int Nyv = block_index.fine_lattice_size(1) / VLENY;
414  int Nz = block_index.fine_lattice_size(2);
415 
416  int Nblock = block_index.coarse_nvol();
417  int NBx = block_index.coarse_lattice_size(0);
418  int NBy = block_index.coarse_lattice_size(1);
419  int NBz = block_index.coarse_lattice_size(2);
420  int NBt = block_index.coarse_lattice_size(3);
421 
422  int Bsize = block_index.block_nvol() / VLEN;
423  int Bxv = block_index.block_size(0) / VLENX;
424  int Byv = block_index.block_size(1) / VLENY;
425  int Bz = block_index.block_size(2);
426  int Bt = block_index.block_size(3);
427 
428  svbool_t pg = set_predicate();
429 
430  int ith, nth, is, ns;
431  set_threadtask(ith, nth, is, ns, Nblock);
432  int ieo_skip = 1 - ieo;
433 
434  for (int block = is; block < ns; ++block) {
435  if (block_index.block_eo(block) == ieo_skip) continue;
436  int ibx = block % NBx;
437  int iby = (block / NBx) % NBy;
438  int ibz = (block / (NBx * NBy)) % NBz;
439  int ibt = block / (NBx * NBy * NBz);
440 
441  for (int bsite = 0; bsite < Bsize; ++bsite) {
442  int kx = bsite % Bxv;
443  int ix = kx + Bxv * ibx;
444  int kyzt = bsite / Bxv;
445  int ky = kyzt % Byv;
446  int iy = ky + Byv * iby;
447  int kzt = kyzt / Byv;
448  int kz = kzt % Bz;
449  int iz = kz + Bz * ibz;
450  int kt = kzt / Bz;
451  int it = kt + Bt * ibt;
452  int site = ix + Nxv * (iy + Nyv * (iz + Nz * it));
453 
454  real_t at = fac * a[block];
455 
456  for (int ex = 0; ex < Nex; ++ex) {
457  for (int in = 0; in < Nin; ++in) {
458  svreal_t wt, vt;
459  load_vec(pg, wt, &wp[VLEN * (in + Nin * (site + Nstv * ex))]);
460  load_vec(pg, vt, &vp[VLEN * (in + Nin * (site + Nstv * ex))]);
461  axpy_vec(pg, vt, at, wt);
462  save_vec(pg, &vp[VLEN * (in + Nin * (site + Nstv * ex))], vt);
463  }
464  }
465  }
466  }
467 }
468 
469 
470 //====================================================================
471 template<typename INDEX, typename AFIELD>
472 void block_axpy(AFIELD& v, const typename AFIELD::complex_t *a,
473  const AFIELD& w, const typename AFIELD::real_t fac,
474  const INDEX& block_index)
475 {
476  block_axpy_eo(v, a, w, -1, fac, block_index);
477 }
478 
479 
480 //====================================================================
481 template<typename INDEX, typename AFIELD>
482 void block_axpy_eo(AFIELD& v, const typename AFIELD::complex_t *a,
483  const AFIELD& w, const int ieo,
484  const typename AFIELD::real_t fac,
485  const INDEX& block_index)
486 {
487  typedef typename AFIELD::real_t real_t;
488  typedef typename AFIELD::complex_t complex_t;
489 
490  real_t *vp = v.ptr(0);
491  real_t *wp = const_cast<AFIELD *>(&w)->ptr(0);
492 
493  int Nin = v.nin();
494  int Nex = v.nex();
495  int Nstv = v.nvol() / VLEN;
496 
497  int Nxv = block_index.fine_lattice_size(0) / VLENX;
498  int Nyv = block_index.fine_lattice_size(1) / VLENY;
499  int Nz = block_index.fine_lattice_size(2);
500 
501  int Nblock = block_index.coarse_nvol();
502  int NBx = block_index.coarse_lattice_size(0);
503  int NBy = block_index.coarse_lattice_size(1);
504  int NBz = block_index.coarse_lattice_size(2);
505  int NBt = block_index.coarse_lattice_size(3);
506 
507  int Bsize = block_index.block_nvol() / VLEN;
508  int Bxv = block_index.block_size(0) / VLENX;
509  int Byv = block_index.block_size(1) / VLENY;
510  int Bz = block_index.block_size(2);
511  int Bt = block_index.block_size(3);
512 
513  svbool_t pg = set_predicate();
514 
515  int ith, nth, is, ns;
516  set_threadtask(ith, nth, is, ns, Nblock);
517  int ieo_skip = 1 - ieo;
518 
519  for (int block = is; block < ns; ++block) {
520  if (block_index.block_eo(block) == ieo_skip) continue;
521  int ibx = block % NBx;
522  int iby = (block / NBx) % NBy;
523  int ibz = (block / (NBx * NBy)) % NBz;
524  int ibt = block / (NBx * NBy * NBz);
525 
526  for (int bsite = 0; bsite < Bsize; ++bsite) {
527  int kx = bsite % Bxv;
528  int ix = kx + Bxv * ibx;
529  int kyzt = bsite / Bxv;
530  int ky = kyzt % Byv;
531  int iy = ky + Byv * iby;
532  int kzt = kyzt / Byv;
533  int kz = kzt % Bz;
534  int iz = kz + Bz * ibz;
535  int kt = kzt / Bz;
536  int it = kt + Bt * ibt;
537  int site = ix + Nxv * (iy + Nyv * (iz + Nz * it));
538 
539  complex_t at = a[block];
540  real_t atr = fac * real(at);
541  real_t ati = fac * imag(at);
542 
543  for (int ex = 0; ex < Nex; ++ex) {
544  for (int in2 = 0; in2 < Nin / 2; ++in2) {
545  int inr = 2 * in2;
546  int ini = 2 * in2 + 1;
547  svreal_t wtr, wti, vtr, vti;
548  load_vec(pg, wtr, &wp[VLEN * (inr + Nin * (site + Nstv * ex))]);
549  load_vec(pg, wti, &wp[VLEN * (ini + Nin * (site + Nstv * ex))]);
550  load_vec(pg, vtr, &vp[VLEN * (inr + Nin * (site + Nstv * ex))]);
551  load_vec(pg, vti, &vp[VLEN * (ini + Nin * (site + Nstv * ex))]);
552  axpy_vec(pg, vtr, atr, wtr);
553  axpy_vec(pg, vtr, -ati, wti);
554  axpy_vec(pg, vti, atr, wti);
555  axpy_vec(pg, vti, ati, wtr);
556  save_vec(pg, &vp[VLEN * (inr + Nin * (site + Nstv * ex))], vtr);
557  save_vec(pg, &vp[VLEN * (ini + Nin * (site + Nstv * ex))], vti);
558  }
559  }
560  }
561  }
562 }
563 
564 
565 //============================================================END=====
566 #endif
VLEN
#define VLEN
Definition: bridgeQXS_Clover_coarse_double.cpp:12
Field::nex
int nex() const
Definition: field.h:128
Vsimd_t
Definition: vsimd_double-inc.h:13
real_t
double real_t
Definition: bridgeQXS_Clover_coarse_double.cpp:16
Field::nin
int nin() const
Definition: field.h:126
block_scal_eo
void block_scal_eo(AFIELD &v, const typename AFIELD::real_t *a, const int ieo, const INDEX &block_index)
Definition: afield_dd-inc.h:230
Field::real_t
double real_t
Definition: field.h:51
block_dotc
void block_dotc(typename AFIELD::complex_t *out, const AFIELD &v, const AFIELD &w, const INDEX &block_index)
Definition: afield_dd-inc.h:24
block_axpy_eo
void block_axpy_eo(AFIELD &v, const typename AFIELD::real_t *a, const AFIELD &w, const int ieo, const typename AFIELD::real_t fac, const INDEX &block_index)
Definition: afield_dd-inc.h:398
block_dotc_eo
void block_dotc_eo(typename AFIELD::complex_t *out, const AFIELD &v, const AFIELD &w, const int ieo, const INDEX &block_index)
Definition: afield_dd-inc.h:33
threadManager.h
Field::nvol
int nvol() const
Definition: field.h:127
block_scal
void block_scal(AFIELD &v, const typename AFIELD::real_t *a, const INDEX &block_index)
Definition: afield_dd-inc.h:221
VLENY
#define VLENY
Definition: bridgeQXS_Clover_coarse_double.cpp:14
Field::ptr
const double * ptr(const int jin, const int site, const int jex) const
Definition: field.h:153
svbool_t
Definition: vsimd_double-inc.h:30
VLENX
#define VLENX
Definition: bridgeQXS_Clover_coarse_double.cpp:13
complex_t
ComplexTraits< double >::complex_t complex_t
Definition: afopr_Clover_coarse_double.cpp:23
block_norm2
void block_norm2(typename AFIELD::real_t *out, const AFIELD &v, const INDEX &block_index)
Definition: afield_dd-inc.h:132
complexTraits.h
block_norm2_eo
void block_norm2_eo(typename AFIELD::real_t *out, const AFIELD &v, const int ieo, const INDEX &block_index)
Definition: afield_dd-inc.h:141
Field
Container of Field-type object.
Definition: field.h:46
block_axpy
void block_axpy(AFIELD &v, const typename AFIELD::real_t *a, const AFIELD &w, const typename AFIELD::real_t fac, const INDEX &block_index)
Definition: afield_dd-inc.h:388