Bridge++  Ver.2.1.3
vsimd_Wilson_SU3_float-inc.h
Go to the documentation of this file.
1 
9 #ifndef QXS_VSIMD_WILSON_SU3_INCLUDED
10 #define QXS_VSIMD_WILSON_SU3_INCLUDED
11 
12 #define ID1 0
13 #define ID2 2
14 #define ID3 4
15 #define ID4 6
16 
17 namespace {
18  /*
19 void check_Nc()
20  {
21  vout.general(CommonParameters::Vlevel(),
22  "Fopr_Wilson_impl: implementation for SU(3).\n");
23  }
24  */
25  inline void load_u(svbool_t pg,
26  svreal_t& u0, svreal_t& u1,
27  svreal_t& u2, svreal_t& u3,
28  svreal_t& u4, svreal_t& u5,
29  real_t *u)
30  {
31  load_vec(pg, u0, &u[VLEN * 0]);
32  load_vec(pg, u1, &u[VLEN * 1]);
33  load_vec(pg, u2, &u[VLEN * (0 + NVC)]);
34  load_vec(pg, u3, &u[VLEN * (1 + NVC)]);
35  load_vec(pg, u4, &u[VLEN * (0 + 2 * NVC)]);
36  load_vec(pg, u5, &u[VLEN * (1 + 2 * NVC)]);
37  }
38 
39 
40  inline void load_udag(svbool_t pg,
41  svreal_t& u0, svreal_t& u1,
42  svreal_t& u2, svreal_t& u3,
43  svreal_t& u4, svreal_t& u5,
44  real_t *u)
45  {
46  load_vec(pg, u0, &u[VLEN * 0]);
47  load_vec(pg, u1, &u[VLEN * 1]);
48  load_vec(pg, u2, &u[VLEN * 2]);
49  load_vec(pg, u3, &u[VLEN * 3]);
50  load_vec(pg, u4, &u[VLEN * 4]);
51  load_vec(pg, u5, &u[VLEN * 5]);
52  }
53 
54 
55  inline void load_udag(svbool_t pg,
56  svreal_t& u0, svreal_t& u1,
57  svreal_t& u2, svreal_t& u3,
58  svreal_t& u4, svreal_t& u5,
59  real_t *u, svint_t index)
60  {
61  load_vec_gather(pg, u0, &u[VLEN * 0], index);
62  load_vec_gather(pg, u1, &u[VLEN * 1], index);
63  load_vec_gather(pg, u2, &u[VLEN * 2], index);
64  load_vec_gather(pg, u3, &u[VLEN * 3], index);
65  load_vec_gather(pg, u4, &u[VLEN * 4], index);
66  load_vec_gather(pg, u5, &u[VLEN * 5], index);
67  }
68 
69 
70  // to be discarded
71  inline void mult_uv(Vsimd_t *x, Vsimd_t *u, Vsimd_t *w, int Nc)
72  {
73  for (int k = 0; k < VLEN; ++k) {
74  x[0].v[k] =
75  u[0].v[k] * w[0].v[k] - u[1].v[k] * w[1].v[k]
76  + u[6].v[k] * w[2].v[k] - u[7].v[k] * w[3].v[k]
77  + u[12].v[k] * w[4].v[k] - u[13].v[k] * w[5].v[k];
78  x[1].v[k] =
79  u[0].v[k] * w[1].v[k] + u[1].v[k] * w[0].v[k]
80  + u[6].v[k] * w[3].v[k] + u[7].v[k] * w[2].v[k]
81  + u[12].v[k] * w[5].v[k] + u[13].v[k] * w[4].v[k];
82  }
83  }
84 
85 
86  inline void mult_uv(svbool_t pg,
87  svreal_t& yr, svreal_t& yi,
88  svreal_t u0, svreal_t u1,
89  svreal_t u2, svreal_t u3,
90  svreal_t u4, svreal_t u5,
91  svreal_t v0, svreal_t v1,
92  svreal_t v2, svreal_t v3,
93  svreal_t v4, svreal_t v5)
94  {
95  for (int k = 0; k < VLEN; ++k) {
96  yr.v[k] =
97  u0.v[k] * v0.v[k] - u1.v[k] * v1.v[k]
98  + u2.v[k] * v2.v[k] - u3.v[k] * v3.v[k]
99  + u4.v[k] * v4.v[k] - u5.v[k] * v5.v[k];
100  yi.v[k] =
101  u0.v[k] * v1.v[k] + u1.v[k] * v0.v[k]
102  + u2.v[k] * v3.v[k] + u3.v[k] * v2.v[k]
103  + u4.v[k] * v5.v[k] + u5.v[k] * v4.v[k];
104  }
105  }
106 
107 
108  // to be discarded
109  inline void mult_udagv(Vsimd_t *x, Vsimd_t *u, Vsimd_t *w, int Nc)
110  {
111  for (int k = 0; k < VLEN; ++k) {
112  x[0].v[k] =
113  u[0].v[k] * w[0].v[k] + u[1].v[k] * w[1].v[k]
114  + u[2].v[k] * w[2].v[k] + u[3].v[k] * w[3].v[k]
115  + u[4].v[k] * w[4].v[k] + u[5].v[k] * w[5].v[k];
116  x[1].v[k] =
117  u[0].v[k] * w[1].v[k] - u[1].v[k] * w[0].v[k]
118  + u[2].v[k] * w[3].v[k] - u[3].v[k] * w[2].v[k]
119  + u[4].v[k] * w[5].v[k] - u[5].v[k] * w[4].v[k];
120  }
121  }
122 
123 
124  inline void mult_udv(svbool_t pg,
125  svreal_t& yr, svreal_t& yi,
126  svreal_t u0, svreal_t u1,
127  svreal_t u2, svreal_t u3,
128  svreal_t u4, svreal_t u5,
129  svreal_t v0, svreal_t v1,
130  svreal_t v2, svreal_t v3,
131  svreal_t v4, svreal_t v5)
132  {
133  for (int k = 0; k < VLEN; ++k) {
134  yr.v[k] =
135  u0.v[k] * v0.v[k] + u1.v[k] * v1.v[k]
136  + u2.v[k] * v2.v[k] + u3.v[k] * v3.v[k]
137  + u4.v[k] * v4.v[k] + u5.v[k] * v5.v[k];
138  yi.v[k] =
139  u0.v[k] * v1.v[k] - u1.v[k] * v0.v[k]
140  + u2.v[k] * v3.v[k] - u3.v[k] * v2.v[k]
141  + u4.v[k] * v5.v[k] - u5.v[k] * v4.v[k];
142  }
143  }
144 
145 
146  inline void mult_ctv(Vsimd_t *x, Vsimd_t *u, Vsimd_t *w, int Nc)
147  {
148  for (int k = 0; k < VLEN; ++k) {
149  x[0].v[k] =
150  u[0].v[k] * w[0].v[k] - u[1].v[k] * w[1].v[k]
151  + u[6].v[k] * w[2 * ND].v[k] - u[7].v[k] * w[2 * ND + 1].v[k]
152  + u[12].v[k] * w[4 * ND].v[k] - u[13].v[k] * w[4 * ND + 1].v[k];
153  x[1].v[k] =
154  u[0].v[k] * w[1].v[k] + u[1].v[k] * w[0].v[k]
155  + u[6].v[k] * w[2 * ND + 1].v[k] + u[7].v[k] * w[2 * ND].v[k]
156  + u[12].v[k] * w[4 * ND + 1].v[k] + u[13].v[k] * w[4 * ND].v[k];
157  }
158  }
159 
160 
161  template<typename REALTYPE>
162  inline void set_sp2_xp(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
163  {
164  for (int ic = 0; ic < NC; ++ic) {
165  int icr = ND * 2 * ic;
166  int ici = ND * 2 * ic + 1;
167  for (int k = 0; k < VLEN; ++k) {
168  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] + w[k + VLEN * (ici + ID4)];
169  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] - w[k + VLEN * (icr + ID4)];
170  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] + w[k + VLEN * (ici + ID3)];
171  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] - w[k + VLEN * (icr + ID3)];
172  }
173  }
174  }
175 
176 
177  template<typename REALTYPE>
178  inline void set_sp2_xp(svbool_t pg,
179  svreal_t& vt1r, svreal_t& vt1i,
180  svreal_t& vt2r, svreal_t& vt2i,
181  REALTYPE *w, int ic)
182  {
183  int icr = ND * 2 * ic;
184  int ici = ND * 2 * ic + 1;
185  for (int k = 0; k < VLEN; ++k) {
186  vt1r.v[k] = w[k + VLEN * (icr + ID1)] + w[k + VLEN * (ici + ID4)];
187  vt1i.v[k] = w[k + VLEN * (ici + ID1)] - w[k + VLEN * (icr + ID4)];
188  vt2r.v[k] = w[k + VLEN * (icr + ID2)] + w[k + VLEN * (ici + ID3)];
189  vt2i.v[k] = w[k + VLEN * (ici + ID2)] - w[k + VLEN * (icr + ID3)];
190  }
191  }
192 
193 
194  template<typename REALTYPE>
195  inline void set_sp2_xp1(REALTYPE *vt, REALTYPE *w)
196  {
197  for (int ic = 0; ic < NC; ++ic) {
198  int icr = ND * 2 * ic;
199  int ici = ND * 2 * ic + 1;
200  for (int ky = 0; ky < VLENY; ++ky) {
201  vt[ky + VLENY * (2 * ic)] = w[ky + VLENY * (icr + ID1)]
202  + w[ky + VLENY * (ici + ID4)];
203  vt[ky + VLENY * (2 * ic + 1)] = w[ky + VLENY * (ici + ID1)]
204  - w[ky + VLENY * (icr + ID4)];
205  vt[ky + VLENY * (2 * ic + NVC)] = w[ky + VLENY * (icr + ID2)]
206  + w[ky + VLENY * (ici + ID3)];
207  vt[ky + VLENY * (2 * ic + 1 + NVC)] = w[ky + VLENY * (ici + ID2)]
208  - w[ky + VLENY * (icr + ID3)];
209  }
210  }
211  }
212 
213 
214  template<typename REALTYPE>
215  inline void set_sp2_xm(svbool_t pg,
216  svreal_t& vt1r, svreal_t& vt1i,
217  svreal_t& vt2r, svreal_t& vt2i,
218  REALTYPE *w, int ic)
219  {
220  int icr = ND * 2 * ic;
221  int ici = ND * 2 * ic + 1;
222  for (int k = 0; k < VLEN; ++k) {
223  vt1r.v[k] = w[k + VLEN * (icr + ID1)] - w[k + VLEN * (ici + ID4)];
224  vt1i.v[k] = w[k + VLEN * (ici + ID1)] + w[k + VLEN * (icr + ID4)];
225  vt2r.v[k] = w[k + VLEN * (icr + ID2)] - w[k + VLEN * (ici + ID3)];
226  vt2i.v[k] = w[k + VLEN * (ici + ID2)] + w[k + VLEN * (icr + ID3)];
227  }
228  }
229 
230 
231  template<typename REALTYPE>
232  inline void set_sp2_xm(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
233  {
234  for (int ic = 0; ic < NC; ++ic) {
235  int icr = ND * 2 * ic;
236  int ici = ND * 2 * ic + 1;
237  for (int k = 0; k < VLEN; ++k) {
238  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] - w[k + VLEN * (ici + ID4)];
239  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] + w[k + VLEN * (icr + ID4)];
240  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] - w[k + VLEN * (ici + ID3)];
241  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] + w[k + VLEN * (icr + ID3)];
242  }
243  }
244  }
245 
246 
247  template<typename REALTYPE>
248  inline void set_sp2_yp(svbool_t pg,
249  svreal_t& vt1r, svreal_t& vt1i,
250  svreal_t& vt2r, svreal_t& vt2i,
251  REALTYPE *w, int ic)
252  {
253  int icr = ND * 2 * ic;
254  int ici = ND * 2 * ic + 1;
255  for (int k = 0; k < VLEN; ++k) {
256  vt1r.v[k] = w[k + VLEN * (icr + ID1)] - w[k + VLEN * (icr + ID4)];
257  vt1i.v[k] = w[k + VLEN * (ici + ID1)] - w[k + VLEN * (ici + ID4)];
258  vt2r.v[k] = w[k + VLEN * (icr + ID2)] + w[k + VLEN * (icr + ID3)];
259  vt2i.v[k] = w[k + VLEN * (ici + ID2)] + w[k + VLEN * (ici + ID3)];
260  }
261  }
262 
263 
264  template<typename REALTYPE>
265  inline void set_sp2_yp(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
266  {
267  for (int ic = 0; ic < NC; ++ic) {
268  int icr = ND * 2 * ic;
269  int ici = ND * 2 * ic + 1;
270  for (int k = 0; k < VLEN; ++k) {
271  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] - w[k + VLEN * (icr + ID4)];
272  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] - w[k + VLEN * (ici + ID4)];
273  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] + w[k + VLEN * (icr + ID3)];
274  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] + w[k + VLEN * (ici + ID3)];
275  }
276  }
277  }
278 
279 
280  template<typename REALTYPE>
281  inline void set_sp2_yp1(REALTYPE *vt, REALTYPE *w)
282  {
283  for (int ic = 0; ic < NC; ++ic) {
284  int icr = ND * 2 * ic;
285  int ici = ND * 2 * ic + 1;
286  for (int kx = 0; kx < VLENX; ++kx) {
287  vt[kx + VLENX * (2 * ic)] = w[kx + VLENX * (icr + ID1)]
288  - w[kx + VLENX * (icr + ID4)];
289  vt[kx + VLENX * (2 * ic + 1)] = w[kx + VLENX * (ici + ID1)]
290  - w[kx + VLENX * (ici + ID4)];
291  vt[kx + VLENX * (2 * ic + NVC)] = w[kx + VLENX * (icr + ID2)]
292  + w[kx + VLENX * (icr + ID3)];
293  vt[kx + VLENX * (2 * ic + 1 + NVC)] = w[kx + VLENX * (ici + ID2)]
294  + w[kx + VLENX * (ici + ID3)];
295  }
296  }
297  }
298 
299 
300  template<typename REALTYPE>
301  inline void set_sp2_ym(svbool_t pg,
302  svreal_t& vt1r, svreal_t& vt1i,
303  svreal_t& vt2r, svreal_t& vt2i,
304  REALTYPE *w, int ic)
305  {
306  int icr = ND * 2 * ic;
307  int ici = ND * 2 * ic + 1;
308  for (int k = 0; k < VLEN; ++k) {
309  vt1r.v[k] = w[k + VLEN * (icr + ID1)] + w[k + VLEN * (icr + ID4)];
310  vt1i.v[k] = w[k + VLEN * (ici + ID1)] + w[k + VLEN * (ici + ID4)];
311  vt2r.v[k] = w[k + VLEN * (icr + ID2)] - w[k + VLEN * (icr + ID3)];
312  vt2i.v[k] = w[k + VLEN * (ici + ID2)] - w[k + VLEN * (ici + ID3)];
313  }
314  }
315 
316 
317  template<typename REALTYPE>
318  inline void set_sp2_ym(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
319  {
320  for (int ic = 0; ic < NC; ++ic) {
321  int icr = ND * 2 * ic;
322  int ici = ND * 2 * ic + 1;
323  for (int k = 0; k < VLEN; ++k) {
324  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] + w[k + VLEN * (icr + ID4)];
325  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] + w[k + VLEN * (ici + ID4)];
326  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] - w[k + VLEN * (icr + ID3)];
327  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] - w[k + VLEN * (ici + ID3)];
328  }
329  }
330  }
331 
332 
333  template<typename REALTYPE>
334  inline void set_sp2_zp(svbool_t pg,
335  svreal_t& vt1r, svreal_t& vt1i,
336  svreal_t& vt2r, svreal_t& vt2i,
337  REALTYPE *w, int ic)
338  {
339  int icr = ND * 2 * ic;
340  int ici = ND * 2 * ic + 1;
341  for (int k = 0; k < VLEN; ++k) {
342  vt1r.v[k] = w[k + VLEN * (icr + ID1)] + w[k + VLEN * (ici + ID3)];
343  vt1i.v[k] = w[k + VLEN * (ici + ID1)] - w[k + VLEN * (icr + ID3)];
344  vt2r.v[k] = w[k + VLEN * (icr + ID2)] - w[k + VLEN * (ici + ID4)];
345  vt2i.v[k] = w[k + VLEN * (ici + ID2)] + w[k + VLEN * (icr + ID4)];
346  }
347  }
348 
349 
350  template<typename REALTYPE>
351  inline void set_sp2_zp(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
352  {
353  for (int ic = 0; ic < NC; ++ic) {
354  int icr = ND * 2 * ic;
355  int ici = ND * 2 * ic + 1;
356  for (int k = 0; k < VLEN; ++k) {
357  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] + w[k + VLEN * (ici + ID3)];
358  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] - w[k + VLEN * (icr + ID3)];
359  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] - w[k + VLEN * (ici + ID4)];
360  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] + w[k + VLEN * (icr + ID4)];
361  }
362  }
363  }
364 
365 
366  template<typename REALTYPE>
367  inline void set_sp2_zm(svbool_t pg,
368  svreal_t& vt1r, svreal_t& vt1i,
369  svreal_t& vt2r, svreal_t& vt2i,
370  REALTYPE *w, int ic)
371  {
372  int icr = ND * 2 * ic;
373  int ici = ND * 2 * ic + 1;
374  for (int k = 0; k < VLEN; ++k) {
375  vt1r.v[k] = w[k + VLEN * (icr + ID1)] - w[k + VLEN * (ici + ID3)];
376  vt1i.v[k] = w[k + VLEN * (ici + ID1)] + w[k + VLEN * (icr + ID3)];
377  vt2r.v[k] = w[k + VLEN * (icr + ID2)] + w[k + VLEN * (ici + ID4)];
378  vt2i.v[k] = w[k + VLEN * (ici + ID2)] - w[k + VLEN * (icr + ID4)];
379  }
380  }
381 
382 
383  template<typename REALTYPE>
384  inline void set_sp2_zm(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
385  {
386  for (int ic = 0; ic < NC; ++ic) {
387  int icr = ND * 2 * ic;
388  int ici = ND * 2 * ic + 1;
389  for (int k = 0; k < VLEN; ++k) {
390  vt1[2 * ic].v[k] = w[k + VLEN * (icr + ID1)] - w[k + VLEN * (ici + ID3)];
391  vt1[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID1)] + w[k + VLEN * (icr + ID3)];
392  vt2[2 * ic].v[k] = w[k + VLEN * (icr + ID2)] + w[k + VLEN * (ici + ID4)];
393  vt2[2 * ic + 1].v[k] = w[k + VLEN * (ici + ID2)] - w[k + VLEN * (icr + ID4)];
394  }
395  }
396  }
397 
398 
399  template<typename REALTYPE>
400  inline void set_sp2_tp_dirac(svbool_t pg,
401  svreal_t& vt1r, svreal_t& vt1i,
402  svreal_t& vt2r, svreal_t& vt2i,
403  REALTYPE *w, int ic)
404  {
405  int icr = ND * 2 * ic;
406  int ici = ND * 2 * ic + 1;
407  for (int k = 0; k < VLEN; ++k) {
408  vt1r.v[k] = 2.0 * w[k + VLEN * (icr + ID3)];
409  vt1i.v[k] = 2.0 * w[k + VLEN * (ici + ID3)];
410  vt2r.v[k] = 2.0 * w[k + VLEN * (icr + ID4)];
411  vt2i.v[k] = 2.0 * w[k + VLEN * (ici + ID4)];
412  }
413  }
414 
415 
416  template<typename REALTYPE>
417  inline void set_sp2_tp_dirac(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
418  {
419  for (int ic = 0; ic < NC; ++ic) {
420  int icr = ND * 2 * ic;
421  int ici = ND * 2 * ic + 1;
422  for (int k = 0; k < VLEN; ++k) {
423  vt1[2 * ic].v[k] = 2.0 * w[k + VLEN * (icr + ID3)];
424  vt1[2 * ic + 1].v[k] = 2.0 * w[k + VLEN * (ici + ID3)];
425  vt2[2 * ic].v[k] = 2.0 * w[k + VLEN * (icr + ID4)];
426  vt2[2 * ic + 1].v[k] = 2.0 * w[k + VLEN * (ici + ID4)];
427  }
428  }
429  }
430 
431 
432  template<typename REALTYPE>
433  inline void set_sp2_tm_dirac(svbool_t pg,
434  svreal_t& vt1r, svreal_t& vt1i,
435  svreal_t& vt2r, svreal_t& vt2i,
436  REALTYPE *w, int ic)
437  {
438  int icr = ND * 2 * ic;
439  int ici = ND * 2 * ic + 1;
440  for (int k = 0; k < VLEN; ++k) {
441  vt1r.v[k] = 2.0 * w[k + VLEN * (icr + ID1)];
442  vt1i.v[k] = 2.0 * w[k + VLEN * (ici + ID1)];
443  vt2r.v[k] = 2.0 * w[k + VLEN * (icr + ID2)];
444  vt2i.v[k] = 2.0 * w[k + VLEN * (ici + ID2)];
445  }
446  }
447 
448 
449  template<typename REALTYPE>
450  inline void set_sp2_tm_dirac(Vsimd_t *vt1, Vsimd_t *vt2, REALTYPE *w)
451  {
452  for (int ic = 0; ic < NC; ++ic) {
453  int icr = ND * 2 * ic;
454  int ici = ND * 2 * ic + 1;
455  for (int k = 0; k < VLEN; ++k) {
456  vt1[2 * ic].v[k] = 2.0 * w[k + VLEN * (icr + ID1)];
457  vt1[2 * ic + 1].v[k] = 2.0 * w[k + VLEN * (ici + ID1)];
458  vt2[2 * ic].v[k] = 2.0 * w[k + VLEN * (icr + ID2)];
459  vt2[2 * ic + 1].v[k] = 2.0 * w[k + VLEN * (ici + ID2)];
460  }
461  }
462  }
463 
464 
465  inline void set_sp4_xp(svbool_t pg, Vsimd_t *x,
466  svreal_t wt1r, svreal_t wt1i,
467  svreal_t wt2r, svreal_t wt2i, int ic)
468  {
469  int ic2 = ND * 2 * ic;
470  for (int k = 0; k < VLEN; ++k) {
471  x[ic2 + ID1].v[k] += wt1r.v[k];
472  x[ic2 + 1 + ID1].v[k] += wt1i.v[k];
473  x[ic2 + ID2].v[k] += wt2r.v[k];
474  x[ic2 + 1 + ID2].v[k] += wt2i.v[k];
475  x[ic2 + ID3].v[k] += -wt2i.v[k];
476  x[ic2 + 1 + ID3].v[k] += wt2r.v[k];
477  x[ic2 + ID4].v[k] += -wt1i.v[k];
478  x[ic2 + 1 + ID4].v[k] += wt1r.v[k];
479  }
480  }
481 
482 
483  template<typename REALTYPE>
484  inline void set_sp4_xp(svbool_t pg, REALTYPE *x,
485  svreal_t wt1r, svreal_t wt1i,
486  svreal_t wt2r, svreal_t wt2i, int ic)
487  {
488  int ic2 = ND * 2 * ic;
489  for (int k = 0; k < VLEN; ++k) {
490  x[k + VLEN * (ic2 + ID1)] += wt1r.v[k];
491  x[k + VLEN * (ic2 + 1 + ID1)] += wt1i.v[k];
492  x[k + VLEN * (ic2 + ID2)] += wt2r.v[k];
493  x[k + VLEN * (ic2 + 1 + ID2)] += wt2i.v[k];
494  x[k + VLEN * (ic2 + ID3)] += -wt2i.v[k];
495  x[k + VLEN * (ic2 + 1 + ID3)] += wt2r.v[k];
496  x[k + VLEN * (ic2 + ID4)] += -wt1i.v[k];
497  x[k + VLEN * (ic2 + 1 + ID4)] += wt1r.v[k];
498  }
499  }
500 
501 
502  inline void set_sp4_xp(Vsimd_t *x, Vsimd_t *wt1, Vsimd_t *wt2)
503  {
504  for (int k = 0; k < VLEN; ++k) {
505  x[ID1].v[k] += wt1[0].v[k];
506  x[1 + ID1].v[k] += wt1[1].v[k];
507  x[ID2].v[k] += wt2[0].v[k];
508  x[1 + ID2].v[k] += wt2[1].v[k];
509  x[ID3].v[k] += -wt2[1].v[k];
510  x[1 + ID3].v[k] += wt2[0].v[k];
511  x[ID4].v[k] += -wt1[1].v[k];
512  x[1 + ID4].v[k] += wt1[0].v[k];
513  }
514  }
515 
516 
517  inline void set_sp4_xm(Vsimd_t *x, Vsimd_t *wt1, Vsimd_t *wt2)
518  {
519  for (int k = 0; k < VLEN; ++k) {
520  x[ID1].v[k] += wt1[0].v[k];
521  x[1 + ID1].v[k] += wt1[1].v[k];
522  x[ID2].v[k] += wt2[0].v[k];
523  x[1 + ID2].v[k] += wt2[1].v[k];
524  x[ID3].v[k] += wt2[1].v[k];
525  x[1 + ID3].v[k] += -wt2[0].v[k];
526  x[ID4].v[k] += wt1[1].v[k];
527  x[1 + ID4].v[k] += -wt1[0].v[k];
528  }
529  }
530 
531 
532  inline void set_sp4_xm(svbool_t pg, Vsimd_t *x,
533  svreal_t wt1r, svreal_t wt1i,
534  svreal_t wt2r, svreal_t wt2i, int ic)
535  {
536  int ic2 = ND * 2 * ic;
537  for (int k = 0; k < VLEN; ++k) {
538  x[ic2 + ID1].v[k] += wt1r.v[k];
539  x[ic2 + 1 + ID1].v[k] += wt1i.v[k];
540  x[ic2 + ID2].v[k] += wt2r.v[k];
541  x[ic2 + 1 + ID2].v[k] += wt2i.v[k];
542  x[ic2 + ID3].v[k] += wt2i.v[k];
543  x[ic2 + 1 + ID3].v[k] += -wt2r.v[k];
544  x[ic2 + ID4].v[k] += wt1i.v[k];
545  x[ic2 + 1 + ID4].v[k] += -wt1r.v[k];
546  }
547  }
548 
549 
550  template<typename REALTYPE>
551  inline void set_sp4_xm(svbool_t pg, REALTYPE *x,
552  svreal_t wt1r, svreal_t wt1i,
553  svreal_t wt2r, svreal_t wt2i, int ic)
554  {
555  int ic2 = ND * 2 * ic;
556  for (int k = 0; k < VLEN; ++k) {
557  x[k + VLEN * (ic2 + ID1)] += wt1r.v[k];
558  x[k + VLEN * (ic2 + 1 + ID1)] += wt1i.v[k];
559  x[k + VLEN * (ic2 + ID2)] += wt2r.v[k];
560  x[k + VLEN * (ic2 + 1 + ID2)] += wt2i.v[k];
561  x[k + VLEN * (ic2 + ID3)] += wt2i.v[k];
562  x[k + VLEN * (ic2 + 1 + ID3)] += -wt2r.v[k];
563  x[k + VLEN * (ic2 + ID4)] += wt1i.v[k];
564  x[k + VLEN * (ic2 + 1 + ID4)] += -wt1r.v[k];
565  }
566  }
567 
568 
569  inline void set_sp4_yp(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
570  {
571  for (int k = 0; k < VLEN; ++k) {
572  v[ID1].v[k] += wt1[0].v[k];
573  v[1 + ID1].v[k] += wt1[1].v[k];
574  v[ID2].v[k] += wt2[0].v[k];
575  v[1 + ID2].v[k] += wt2[1].v[k];
576  v[ID3].v[k] += wt2[0].v[k];
577  v[1 + ID3].v[k] += wt2[1].v[k];
578  v[ID4].v[k] += -wt1[0].v[k];
579  v[1 + ID4].v[k] += -wt1[1].v[k];
580  }
581  }
582 
583 
584  inline void set_sp4_ym(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
585  {
586  for (int k = 0; k < VLEN; ++k) {
587  v[ID1].v[k] += wt1[0].v[k];
588  v[1 + ID1].v[k] += wt1[1].v[k];
589  v[ID2].v[k] += wt2[0].v[k];
590  v[1 + ID2].v[k] += wt2[1].v[k];
591  v[ID3].v[k] += -wt2[0].v[k];
592  v[1 + ID3].v[k] += -wt2[1].v[k];
593  v[ID4].v[k] += wt1[0].v[k];
594  v[1 + ID4].v[k] += wt1[1].v[k];
595  }
596  }
597 
598 
599  inline void set_sp4_yp(svbool_t pg, Vsimd_t *v,
600  svreal_t wt1r, svreal_t wt1i,
601  svreal_t wt2r, svreal_t wt2i, int ic)
602  {
603  int ic2 = ND * 2 * ic;
604  for (int k = 0; k < VLEN; ++k) {
605  v[ic2 + ID1].v[k] += wt1r.v[k];
606  v[ic2 + 1 + ID1].v[k] += wt1i.v[k];
607  v[ic2 + ID2].v[k] += wt2r.v[k];
608  v[ic2 + 1 + ID2].v[k] += wt2i.v[k];
609  v[ic2 + ID3].v[k] += wt2r.v[k];
610  v[ic2 + 1 + ID3].v[k] += wt2i.v[k];
611  v[ic2 + ID4].v[k] += -wt1r.v[k];
612  v[ic2 + 1 + ID4].v[k] += -wt1i.v[k];
613  }
614  }
615 
616 
617  inline void set_sp4_ym(svbool_t pg, Vsimd_t *v,
618  svreal_t wt1r, svreal_t wt1i,
619  svreal_t wt2r, svreal_t wt2i, int ic)
620  {
621  int ic2 = ND * 2 * ic;
622  for (int k = 0; k < VLEN; ++k) {
623  v[ic2 + ID1].v[k] += wt1r.v[k];
624  v[ic2 + 1 + ID1].v[k] += wt1i.v[k];
625  v[ic2 + ID2].v[k] += wt2r.v[k];
626  v[ic2 + 1 + ID2].v[k] += wt2i.v[k];
627  v[ic2 + ID3].v[k] += -wt2r.v[k];
628  v[ic2 + 1 + ID3].v[k] += -wt2i.v[k];
629  v[ic2 + ID4].v[k] += wt1r.v[k];
630  v[ic2 + 1 + ID4].v[k] += wt1i.v[k];
631  }
632  }
633 
634 
635  template<typename REALTYPE>
636  inline void set_sp4_yp(svbool_t pg, REALTYPE *v,
637  svreal_t wt1r, svreal_t wt1i,
638  svreal_t wt2r, svreal_t wt2i, int ic)
639  {
640  int ic2 = ND * 2 * ic;
641  for (int k = 0; k < VLEN; ++k) {
642  v[k + VLEN * (ic2 + ID1)] += wt1r.v[k];
643  v[k + VLEN * (ic2 + 1 + ID1)] += wt1i.v[k];
644  v[k + VLEN * (ic2 + ID2)] += wt2r.v[k];
645  v[k + VLEN * (ic2 + 1 + ID2)] += wt2i.v[k];
646  v[k + VLEN * (ic2 + ID3)] += wt2r.v[k];
647  v[k + VLEN * (ic2 + 1 + ID3)] += wt2i.v[k];
648  v[k + VLEN * (ic2 + ID4)] += -wt1r.v[k];
649  v[k + VLEN * (ic2 + 1 + ID4)] += -wt1i.v[k];
650  }
651  }
652 
653 
654  template<typename REALTYPE>
655  inline void set_sp4_ym(svbool_t pg, REALTYPE *v,
656  svreal_t wt1r, svreal_t wt1i,
657  svreal_t wt2r, svreal_t wt2i, int ic)
658  {
659  int ic2 = ND * 2 * ic;
660  for (int k = 0; k < VLEN; ++k) {
661  v[k + VLEN * (ic2 + ID1)] += wt1r.v[k];
662  v[k + VLEN * (ic2 + 1 + ID1)] += wt1i.v[k];
663  v[k + VLEN * (ic2 + ID2)] += wt2r.v[k];
664  v[k + VLEN * (ic2 + 1 + ID2)] += wt2i.v[k];
665  v[k + VLEN * (ic2 + ID3)] += -wt2r.v[k];
666  v[k + VLEN * (ic2 + 1 + ID3)] += -wt2i.v[k];
667  v[k + VLEN * (ic2 + ID4)] += wt1r.v[k];
668  v[k + VLEN * (ic2 + 1 + ID4)] += wt1i.v[k];
669  }
670  }
671 
672 
673  inline void set_sp4_zp(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
674  {
675  for (int k = 0; k < VLEN; ++k) {
676  v[ID1].v[k] += wt1[0].v[k];
677  v[1 + ID1].v[k] += wt1[1].v[k];
678  v[ID2].v[k] += wt2[0].v[k];
679  v[1 + ID2].v[k] += wt2[1].v[k];
680  v[ID3].v[k] += -wt1[1].v[k];
681  v[1 + ID3].v[k] += wt1[0].v[k];
682  v[ID4].v[k] += wt2[1].v[k];
683  v[1 + ID4].v[k] += -wt2[0].v[k];
684  }
685  }
686 
687 
688  inline void set_sp4_zm(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
689  {
690  for (int k = 0; k < VLEN; ++k) {
691  v[ID1].v[k] += wt1[0].v[k];
692  v[1 + ID1].v[k] += wt1[1].v[k];
693  v[ID2].v[k] += wt2[0].v[k];
694  v[1 + ID2].v[k] += wt2[1].v[k];
695  v[ID3].v[k] += wt1[1].v[k];
696  v[1 + ID3].v[k] += -wt1[0].v[k];
697  v[ID4].v[k] += -wt2[1].v[k];
698  v[1 + ID4].v[k] += wt2[0].v[k];
699  }
700  }
701 
702 
703  inline void set_sp4_zp(svbool_t pg, Vsimd_t *v,
704  svreal_t wt1r, svreal_t wt1i,
705  svreal_t wt2r, svreal_t wt2i, int ic)
706  {
707  int ic2 = ND * 2 * ic;
708  for (int k = 0; k < VLEN; ++k) {
709  v[ic2 + ID1].v[k] += wt1r.v[k];
710  v[ic2 + 1 + ID1].v[k] += wt1i.v[k];
711  v[ic2 + ID2].v[k] += wt2r.v[k];
712  v[ic2 + 1 + ID2].v[k] += wt2i.v[k];
713  v[ic2 + ID3].v[k] += -wt1i.v[k];
714  v[ic2 + 1 + ID3].v[k] += wt1r.v[k];
715  v[ic2 + ID4].v[k] += wt2i.v[k];
716  v[ic2 + 1 + ID4].v[k] += -wt2r.v[k];
717  }
718  }
719 
720 
721  inline void set_sp4_zm(svbool_t pg, Vsimd_t *v,
722  svreal_t wt1r, svreal_t wt1i,
723  svreal_t wt2r, svreal_t wt2i, int ic)
724  {
725  int ic2 = ND * 2 * ic;
726  for (int k = 0; k < VLEN; ++k) {
727  v[ic2 + ID1].v[k] += wt1r.v[k];
728  v[ic2 + 1 + ID1].v[k] += wt1i.v[k];
729  v[ic2 + ID2].v[k] += wt2r.v[k];
730  v[ic2 + 1 + ID2].v[k] += wt2i.v[k];
731  v[ic2 + ID3].v[k] += wt1i.v[k];
732  v[ic2 + 1 + ID3].v[k] += -wt1r.v[k];
733  v[ic2 + ID4].v[k] += -wt2i.v[k];
734  v[ic2 + 1 + ID4].v[k] += wt2r.v[k];
735  }
736  }
737 
738 
739  template<typename REALTYPE>
740  inline void set_sp4_zp(svbool_t pg, REALTYPE *v,
741  svreal_t wt1r, svreal_t wt1i,
742  svreal_t wt2r, svreal_t wt2i, int ic)
743  {
744  int ic2 = ND * 2 * ic;
745  for (int k = 0; k < VLEN; ++k) {
746  v[k + VLEN * (ic2 + ID1)] += wt1r.v[k];
747  v[k + VLEN * (ic2 + 1 + ID1)] += wt1i.v[k];
748  v[k + VLEN * (ic2 + ID2)] += wt2r.v[k];
749  v[k + VLEN * (ic2 + 1 + ID2)] += wt2i.v[k];
750  v[k + VLEN * (ic2 + ID3)] += -wt1i.v[k];
751  v[k + VLEN * (ic2 + 1 + ID3)] += wt1r.v[k];
752  v[k + VLEN * (ic2 + ID4)] += wt2i.v[k];
753  v[k + VLEN * (ic2 + 1 + ID4)] += -wt2r.v[k];
754  }
755  }
756 
757 
758  template<typename REALTYPE>
759  inline void set_sp4_zm(svbool_t pg, REALTYPE *v,
760  svreal_t wt1r, svreal_t wt1i,
761  svreal_t wt2r, svreal_t wt2i, int ic)
762  {
763  int ic2 = ND * 2 * ic;
764  for (int k = 0; k < VLEN; ++k) {
765  v[k + VLEN * (ic2 + ID1)] += wt1r.v[k];
766  v[k + VLEN * (ic2 + 1 + ID1)] += wt1i.v[k];
767  v[k + VLEN * (ic2 + ID2)] += wt2r.v[k];
768  v[k + VLEN * (ic2 + 1 + ID2)] += wt2i.v[k];
769  v[k + VLEN * (ic2 + ID3)] += wt1i.v[k];
770  v[k + VLEN * (ic2 + 1 + ID3)] += -wt1r.v[k];
771  v[k + VLEN * (ic2 + ID4)] += -wt2i.v[k];
772  v[k + VLEN * (ic2 + 1 + ID4)] += wt2r.v[k];
773  }
774  }
775 
776 
777  inline void set_sp4_tp_dirac(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
778  {
779  for (int k = 0; k < VLEN; ++k) {
780  v[ID3].v[k] += wt1[0].v[k];
781  v[1 + ID3].v[k] += wt1[1].v[k];
782  v[ID4].v[k] += wt2[0].v[k];
783  v[1 + ID4].v[k] += wt2[1].v[k];
784  }
785  }
786 
787 
788  inline void set_sp4_tm_dirac(Vsimd_t *v, Vsimd_t *wt1, Vsimd_t *wt2)
789  {
790  for (int k = 0; k < VLEN; ++k) {
791  v[ID1].v[k] += wt1[0].v[k];
792  v[1 + ID1].v[k] += wt1[1].v[k];
793  v[ID2].v[k] += wt2[0].v[k];
794  v[1 + ID2].v[k] += wt2[1].v[k];
795  }
796  }
797 
798 
799  inline void set_sp4_tp_dirac(svbool_t pg, Vsimd_t *v,
800  svreal_t wt1r, svreal_t wt1i,
801  svreal_t wt2r, svreal_t wt2i, int ic)
802  {
803  int ic2 = ND * 2 * ic;
804  for (int k = 0; k < VLEN; ++k) {
805  v[ic2 + ID3].v[k] += wt1r.v[k];
806  v[ic2 + 1 + ID3].v[k] += wt1i.v[k];
807  v[ic2 + ID4].v[k] += wt2r.v[k];
808  v[ic2 + 1 + ID4].v[k] += wt2i.v[k];
809  }
810  }
811 
812 
813  inline void set_sp4_tm_dirac(svbool_t pg, Vsimd_t *v,
814  svreal_t wt1r, svreal_t wt1i,
815  svreal_t wt2r, svreal_t wt2i, int ic)
816  {
817  int ic2 = ND * 2 * ic;
818  for (int k = 0; k < VLEN; ++k) {
819  v[ic2 + ID1].v[k] += wt1r.v[k];
820  v[ic2 + 1 + ID1].v[k] += wt1i.v[k];
821  v[ic2 + ID2].v[k] += wt2r.v[k];
822  v[ic2 + 1 + ID2].v[k] += wt2i.v[k];
823  }
824  }
825 
826 
827  template<typename REALTYPE>
828  inline void set_sp4_tp_dirac(svbool_t pg, REALTYPE *v,
829  svreal_t wt1r, svreal_t wt1i,
830  svreal_t wt2r, svreal_t wt2i, int ic)
831  {
832  int ic2 = ND * 2 * ic;
833  for (int k = 0; k < VLEN; ++k) {
834  v[k + VLEN * (ic2 + ID3)] += wt1r.v[k];
835  v[k + VLEN * (ic2 + 1 + ID3)] += wt1i.v[k];
836  v[k + VLEN * (ic2 + ID4)] += wt2r.v[k];
837  v[k + VLEN * (ic2 + 1 + ID4)] += wt2i.v[k];
838  }
839  }
840 
841 
842  template<typename REALTYPE>
843  inline void set_sp4_tm_dirac(svbool_t pg, REALTYPE *v,
844  svreal_t wt1r, svreal_t wt1i,
845  svreal_t wt2r, svreal_t wt2i, int ic)
846  {
847  int ic2 = ND * 2 * ic;
848  for (int k = 0; k < VLEN; ++k) {
849  v[k + VLEN * (ic2 + ID1)] += wt1r.v[k];
850  v[k + VLEN * (ic2 + 1 + ID1)] += wt1i.v[k];
851  v[k + VLEN * (ic2 + ID2)] += wt2r.v[k];
852  v[k + VLEN * (ic2 + 1 + ID2)] += wt2i.v[k];
853  }
854  }
855 
856 
857  template<typename REALTYPE>
858  inline void mult_gm5_dirac_vec(svbool_t pg,
859  REALTYPE *v, REALTYPE *w)
860  {
861  for (int k = 0; k < VLEN; ++k) {
862  v[k + VLEN * (ID3)] = -w[k + VLEN * (ID1)];
863  v[k + VLEN * (ID3 + 1)] = -w[k + VLEN * (ID1 + 1)];
864  v[k + VLEN * (ID4)] = -w[k + VLEN * (ID2)];
865  v[k + VLEN * (ID4 + 1)] = -w[k + VLEN * (ID2 + 1)];
866  v[k + VLEN * (ID1)] = -w[k + VLEN * (ID3)];
867  v[k + VLEN * (ID1 + 1)] = -w[k + VLEN * (ID3 + 1)];
868  v[k + VLEN * (ID2)] = -w[k + VLEN * (ID4)];
869  v[k + VLEN * (ID2 + 1)] = -w[k + VLEN * (ID4 + 1)];
870  }
871  }
872 } // end of nameless namespace
873 
874 #endif
875 //============================================================END=====
VLEN
#define VLEN
Definition: bridgeQXS_Clover_coarse_double.cpp:12
ID1
#define ID1
Definition: vsimd_Wilson_SU3_float-inc.h:12
Vsimd_t
Definition: vsimd_double-inc.h:13
wt1i
wt1i
Definition: mult_Domainwall_eo_t_dirac_openacc-inc.h:55
Isimd_t
Definition: vsimd_double-inc.h:20
wt2r
wt2r
Definition: mult_Domainwall_eo_t_dirac_openacc-inc.h:57
ID3
#define ID3
Definition: vsimd_Wilson_SU3_float-inc.h:14
Vsimd_t::v
double v[VLEND]
Definition: vsimd_double-inc.h:15
NC
#define NC
Definition: field_F_imp_SU2-inc.h:15
vt1
real_t vt1
Definition: mult_Staggered_uvdn1_openacc-inc.h:8
wt1r
wt1r
Definition: mult_Domainwall_eo_t_dirac_openacc-inc.h:53
wt2i
wt2i
Definition: mult_Domainwall_eo_t_dirac_openacc-inc.h:59
ND
#define ND
Definition: field_F_imp_SU2-inc.h:18
real_t
double real_t
Definition: bridgeACC_AField_double.cpp:14
ID2
#define ID2
Definition: vsimd_Wilson_SU3_float-inc.h:13
VLENY
#define VLENY
Definition: bridgeQXS_Clover_coarse_double.cpp:14
NVC
#define NVC
Definition: fopr_Wilson_impl_SU2-inc.h:15
load_u
void load_u(real_t *ut, real_t *up, int site)
Definition: mult_Wilson_inline_openacc-inc.h:26
svbool_t
Definition: vsimd_double-inc.h:30
VLENX
#define VLENX
Definition: bridgeQXS_Clover_coarse_double.cpp:13
vt2
real_t vt2
Definition: mult_Staggered_uvdn1_openacc-inc.h:8
ID4
#define ID4
Definition: vsimd_Wilson_SU3_float-inc.h:15